drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 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 |
danielk1977 | fc57d7b | 2004-05-26 02:04:57 +0000 | [diff] [blame] | 13 | ** a VDBE (or an "sqlite3_stmt" as it is known to the outside world.) Prior |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 14 | ** to version 2.8.7, all this code was combined into the vdbe.c source file. |
| 15 | ** But that file was getting too big so this subroutines were split out. |
| 16 | */ |
| 17 | #include "sqliteInt.h" |
| 18 | #include "os.h" |
| 19 | #include <ctype.h> |
| 20 | #include "vdbeInt.h" |
| 21 | |
| 22 | |
| 23 | /* |
| 24 | ** When debugging the code generator in a symbolic debugger, one can |
danielk1977 | 132872b | 2004-05-10 10:37:18 +0000 | [diff] [blame] | 25 | ** set the sqlite3_vdbe_addop_trace to 1 and all opcodes will be printed |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 26 | ** as they are added to the instruction stream. |
| 27 | */ |
drh | 8d904f0 | 2005-06-14 17:47:58 +0000 | [diff] [blame] | 28 | #ifdef SQLITE_DEBUG |
danielk1977 | 132872b | 2004-05-10 10:37:18 +0000 | [diff] [blame] | 29 | int sqlite3_vdbe_addop_trace = 0; |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 30 | #endif |
| 31 | |
| 32 | |
| 33 | /* |
| 34 | ** Create a new virtual database engine. |
| 35 | */ |
drh | 9bb575f | 2004-09-06 17:24:11 +0000 | [diff] [blame] | 36 | Vdbe *sqlite3VdbeCreate(sqlite3 *db){ |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 37 | Vdbe *p; |
| 38 | p = sqliteMalloc( sizeof(Vdbe) ); |
| 39 | if( p==0 ) return 0; |
| 40 | p->db = db; |
| 41 | if( db->pVdbe ){ |
| 42 | db->pVdbe->pPrev = p; |
| 43 | } |
| 44 | p->pNext = db->pVdbe; |
| 45 | p->pPrev = 0; |
| 46 | db->pVdbe = p; |
| 47 | p->magic = VDBE_MAGIC_INIT; |
| 48 | return p; |
| 49 | } |
| 50 | |
| 51 | /* |
| 52 | ** Turn tracing on or off |
| 53 | */ |
danielk1977 | 4adee20 | 2004-05-08 08:23:19 +0000 | [diff] [blame] | 54 | void sqlite3VdbeTrace(Vdbe *p, FILE *trace){ |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 55 | p->trace = trace; |
| 56 | } |
| 57 | |
| 58 | /* |
drh | 76ff3a0 | 2004-09-24 22:32:30 +0000 | [diff] [blame] | 59 | ** Resize the Vdbe.aOp array so that it contains at least N |
danielk1977 | 634f298 | 2005-03-28 08:44:07 +0000 | [diff] [blame] | 60 | ** elements. If the Vdbe is in VDBE_MAGIC_RUN state, then |
danielk1977 | ace3eb2 | 2006-01-26 10:35:04 +0000 | [diff] [blame] | 61 | ** the Vdbe.aOp array will be sized to contain exactly N |
| 62 | ** elements. Vdbe.nOpAlloc is set to reflect the new size of |
| 63 | ** the array. |
| 64 | ** |
| 65 | ** If an out-of-memory error occurs while resizing the array, |
| 66 | ** Vdbe.aOp and Vdbe.nOpAlloc remain unchanged (this is so that |
| 67 | ** any opcodes already allocated can be correctly deallocated |
| 68 | ** along with the rest of the Vdbe). |
drh | 76ff3a0 | 2004-09-24 22:32:30 +0000 | [diff] [blame] | 69 | */ |
| 70 | static void resizeOpArray(Vdbe *p, int N){ |
drh | 53f733c | 2005-09-16 02:38:09 +0000 | [diff] [blame] | 71 | int runMode = p->magic==VDBE_MAGIC_RUN; |
| 72 | if( runMode || p->nOpAlloc<N ){ |
drh | b38ad99 | 2005-09-16 00:27:01 +0000 | [diff] [blame] | 73 | VdbeOp *pNew; |
drh | 53f733c | 2005-09-16 02:38:09 +0000 | [diff] [blame] | 74 | int nNew = N + 100*(!runMode); |
| 75 | int oldSize = p->nOpAlloc; |
| 76 | pNew = sqliteRealloc(p->aOp, nNew*sizeof(Op)); |
drh | b38ad99 | 2005-09-16 00:27:01 +0000 | [diff] [blame] | 77 | if( pNew ){ |
drh | 53f733c | 2005-09-16 02:38:09 +0000 | [diff] [blame] | 78 | p->nOpAlloc = nNew; |
drh | b38ad99 | 2005-09-16 00:27:01 +0000 | [diff] [blame] | 79 | p->aOp = pNew; |
drh | 53f733c | 2005-09-16 02:38:09 +0000 | [diff] [blame] | 80 | if( nNew>oldSize ){ |
| 81 | memset(&p->aOp[oldSize], 0, (nNew-oldSize)*sizeof(Op)); |
| 82 | } |
drh | 76ff3a0 | 2004-09-24 22:32:30 +0000 | [diff] [blame] | 83 | } |
| 84 | } |
| 85 | } |
| 86 | |
| 87 | /* |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 88 | ** Add a new instruction to the list of instructions current in the |
| 89 | ** VDBE. Return the address of the new instruction. |
| 90 | ** |
| 91 | ** Parameters: |
| 92 | ** |
| 93 | ** p Pointer to the VDBE |
| 94 | ** |
| 95 | ** op The opcode for this instruction |
| 96 | ** |
| 97 | ** p1, p2 First two of the three possible operands. |
| 98 | ** |
danielk1977 | 4adee20 | 2004-05-08 08:23:19 +0000 | [diff] [blame] | 99 | ** Use the sqlite3VdbeResolveLabel() function to fix an address and |
| 100 | ** the sqlite3VdbeChangeP3() function to change the value of the P3 |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 101 | ** operand. |
| 102 | */ |
danielk1977 | 4adee20 | 2004-05-08 08:23:19 +0000 | [diff] [blame] | 103 | int sqlite3VdbeAddOp(Vdbe *p, int op, int p1, int p2){ |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 104 | int i; |
drh | 701a0ae | 2004-02-22 20:05:00 +0000 | [diff] [blame] | 105 | VdbeOp *pOp; |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 106 | |
| 107 | i = p->nOp; |
| 108 | p->nOp++; |
| 109 | assert( p->magic==VDBE_MAGIC_INIT ); |
drh | fd2d26b | 2006-03-15 22:44:36 +0000 | [diff] [blame] | 110 | if( p->nOpAlloc<=i ){ |
| 111 | resizeOpArray(p, i+1); |
| 112 | if( sqlite3MallocFailed() ){ |
| 113 | return 0; |
| 114 | } |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 115 | } |
drh | 701a0ae | 2004-02-22 20:05:00 +0000 | [diff] [blame] | 116 | pOp = &p->aOp[i]; |
| 117 | pOp->opcode = op; |
| 118 | pOp->p1 = p1; |
drh | 701a0ae | 2004-02-22 20:05:00 +0000 | [diff] [blame] | 119 | pOp->p2 = p2; |
| 120 | pOp->p3 = 0; |
| 121 | pOp->p3type = P3_NOTUSED; |
drh | 55ef4d9 | 2005-08-14 01:20:37 +0000 | [diff] [blame] | 122 | p->expired = 0; |
danielk1977 | 8b60e0f | 2005-01-12 09:10:39 +0000 | [diff] [blame] | 123 | #ifdef SQLITE_DEBUG |
danielk1977 | 132872b | 2004-05-10 10:37:18 +0000 | [diff] [blame] | 124 | if( sqlite3_vdbe_addop_trace ) sqlite3VdbePrintOp(0, i, &p->aOp[i]); |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 125 | #endif |
| 126 | return i; |
| 127 | } |
| 128 | |
| 129 | /* |
drh | 701a0ae | 2004-02-22 20:05:00 +0000 | [diff] [blame] | 130 | ** Add an opcode that includes the p3 value. |
| 131 | */ |
drh | eb2e176 | 2004-05-27 01:53:56 +0000 | [diff] [blame] | 132 | int sqlite3VdbeOp3(Vdbe *p, int op, int p1, int p2, const char *zP3,int p3type){ |
danielk1977 | 4adee20 | 2004-05-08 08:23:19 +0000 | [diff] [blame] | 133 | int addr = sqlite3VdbeAddOp(p, op, p1, p2); |
| 134 | sqlite3VdbeChangeP3(p, addr, zP3, p3type); |
drh | 701a0ae | 2004-02-22 20:05:00 +0000 | [diff] [blame] | 135 | return addr; |
| 136 | } |
| 137 | |
| 138 | /* |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 139 | ** Create a new symbolic label for an instruction that has yet to be |
| 140 | ** coded. The symbolic label is really just a negative number. The |
| 141 | ** label can be used as the P2 value of an operation. Later, when |
| 142 | ** the label is resolved to a specific address, the VDBE will scan |
| 143 | ** through its operation list and change all values of P2 which match |
| 144 | ** the label into the resolved address. |
| 145 | ** |
| 146 | ** The VDBE knows that a P2 value is a label because labels are |
| 147 | ** always negative and P2 values are suppose to be non-negative. |
| 148 | ** Hence, a negative P2 value is a label that has yet to be resolved. |
danielk1977 | b5548a8 | 2004-06-26 13:51:33 +0000 | [diff] [blame] | 149 | ** |
| 150 | ** Zero is returned if a malloc() fails. |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 151 | */ |
danielk1977 | 4adee20 | 2004-05-08 08:23:19 +0000 | [diff] [blame] | 152 | int sqlite3VdbeMakeLabel(Vdbe *p){ |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 153 | int i; |
| 154 | i = p->nLabel++; |
| 155 | assert( p->magic==VDBE_MAGIC_INIT ); |
| 156 | if( i>=p->nLabelAlloc ){ |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 157 | p->nLabelAlloc = p->nLabelAlloc*2 + 10; |
danielk1977 | e725929 | 2006-01-13 06:33:23 +0000 | [diff] [blame] | 158 | sqliteReallocOrFree((void**)&p->aLabel, |
drh | 53f733c | 2005-09-16 02:38:09 +0000 | [diff] [blame] | 159 | p->nLabelAlloc*sizeof(p->aLabel[0])); |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 160 | } |
drh | 76ff3a0 | 2004-09-24 22:32:30 +0000 | [diff] [blame] | 161 | if( p->aLabel ){ |
| 162 | p->aLabel[i] = -1; |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 163 | } |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 164 | return -1-i; |
| 165 | } |
| 166 | |
| 167 | /* |
| 168 | ** Resolve label "x" to be the address of the next instruction to |
| 169 | ** be inserted. The parameter "x" must have been obtained from |
danielk1977 | 4adee20 | 2004-05-08 08:23:19 +0000 | [diff] [blame] | 170 | ** a prior call to sqlite3VdbeMakeLabel(). |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 171 | */ |
danielk1977 | 4adee20 | 2004-05-08 08:23:19 +0000 | [diff] [blame] | 172 | void sqlite3VdbeResolveLabel(Vdbe *p, int x){ |
drh | 76ff3a0 | 2004-09-24 22:32:30 +0000 | [diff] [blame] | 173 | int j = -1-x; |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 174 | assert( p->magic==VDBE_MAGIC_INIT ); |
drh | 76ff3a0 | 2004-09-24 22:32:30 +0000 | [diff] [blame] | 175 | assert( j>=0 && j<p->nLabel ); |
| 176 | if( p->aLabel ){ |
| 177 | p->aLabel[j] = p->nOp; |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 178 | } |
| 179 | } |
| 180 | |
| 181 | /* |
danielk1977 | bc04f85 | 2005-03-29 08:26:13 +0000 | [diff] [blame] | 182 | ** Return non-zero if opcode 'op' is guarenteed not to push more values |
| 183 | ** onto the VDBE stack than it pops off. |
| 184 | */ |
danielk1977 | 7a5147c | 2005-03-29 13:07:00 +0000 | [diff] [blame] | 185 | static int opcodeNoPush(u8 op){ |
| 186 | /* The 10 NOPUSH_MASK_n constants are defined in the automatically |
danielk1977 | bc04f85 | 2005-03-29 08:26:13 +0000 | [diff] [blame] | 187 | ** generated header file opcodes.h. Each is a 16-bit bitmask, one |
| 188 | ** bit corresponding to each opcode implemented by the virtual |
danielk1977 | 7a5147c | 2005-03-29 13:07:00 +0000 | [diff] [blame] | 189 | ** machine in vdbe.c. The bit is true if the word "no-push" appears |
danielk1977 | bc04f85 | 2005-03-29 08:26:13 +0000 | [diff] [blame] | 190 | ** in a comment on the same line as the "case OP_XXX:" in |
| 191 | ** sqlite3VdbeExec() in vdbe.c. |
| 192 | ** |
| 193 | ** If the bit is true, then the corresponding opcode is guarenteed not |
| 194 | ** to grow the stack when it is executed. Otherwise, it may grow the |
| 195 | ** stack by at most one entry. |
| 196 | ** |
danielk1977 | 7a5147c | 2005-03-29 13:07:00 +0000 | [diff] [blame] | 197 | ** NOPUSH_MASK_0 corresponds to opcodes 0 to 15. NOPUSH_MASK_1 contains |
danielk1977 | bc04f85 | 2005-03-29 08:26:13 +0000 | [diff] [blame] | 198 | ** one bit for opcodes 16 to 31, and so on. |
| 199 | ** |
| 200 | ** 16-bit bitmasks (rather than 32-bit) are specified in opcodes.h |
| 201 | ** because the file is generated by an awk program. Awk manipulates |
| 202 | ** all numbers as floating-point and we don't want to risk a rounding |
| 203 | ** error if someone builds with an awk that uses (for example) 32-bit |
| 204 | ** IEEE floats. |
| 205 | */ |
drh | 9a7e608 | 2005-03-31 22:26:19 +0000 | [diff] [blame] | 206 | static const u32 masks[5] = { |
drh | 580eeaf | 2006-02-24 03:09:37 +0000 | [diff] [blame] | 207 | NOPUSH_MASK_0 + (((unsigned)NOPUSH_MASK_1)<<16), |
| 208 | NOPUSH_MASK_2 + (((unsigned)NOPUSH_MASK_3)<<16), |
| 209 | NOPUSH_MASK_4 + (((unsigned)NOPUSH_MASK_5)<<16), |
| 210 | NOPUSH_MASK_6 + (((unsigned)NOPUSH_MASK_7)<<16), |
| 211 | NOPUSH_MASK_8 + (((unsigned)NOPUSH_MASK_9)<<16) |
danielk1977 | bc04f85 | 2005-03-29 08:26:13 +0000 | [diff] [blame] | 212 | }; |
drh | 9cbe635 | 2005-11-29 03:13:21 +0000 | [diff] [blame] | 213 | assert( op<32*5 ); |
danielk1977 | bc04f85 | 2005-03-29 08:26:13 +0000 | [diff] [blame] | 214 | return (masks[op>>5] & (1<<(op&0x1F))); |
| 215 | } |
| 216 | |
| 217 | #ifndef NDEBUG |
danielk1977 | 7a5147c | 2005-03-29 13:07:00 +0000 | [diff] [blame] | 218 | int sqlite3VdbeOpcodeNoPush(u8 op){ |
| 219 | return opcodeNoPush(op); |
danielk1977 | bc04f85 | 2005-03-29 08:26:13 +0000 | [diff] [blame] | 220 | } |
| 221 | #endif |
| 222 | |
| 223 | /* |
drh | 76ff3a0 | 2004-09-24 22:32:30 +0000 | [diff] [blame] | 224 | ** Loop through the program looking for P2 values that are negative. |
| 225 | ** Each such value is a label. Resolve the label by setting the P2 |
| 226 | ** value to its correct non-zero value. |
| 227 | ** |
| 228 | ** This routine is called once after all opcodes have been inserted. |
danielk1977 | 634f298 | 2005-03-28 08:44:07 +0000 | [diff] [blame] | 229 | ** |
drh | 1344989 | 2005-09-07 21:22:45 +0000 | [diff] [blame] | 230 | ** Variable *pMaxFuncArgs is set to the maximum value of any P2 argument |
| 231 | ** to an OP_Function or OP_AggStep opcode. This is used by |
danielk1977 | 634f298 | 2005-03-28 08:44:07 +0000 | [diff] [blame] | 232 | ** sqlite3VdbeMakeReady() to size the Vdbe.apArg[] array. |
danielk1977 | bc04f85 | 2005-03-29 08:26:13 +0000 | [diff] [blame] | 233 | ** |
| 234 | ** The integer *pMaxStack is set to the maximum number of vdbe stack |
| 235 | ** entries that static analysis reveals this program might need. |
drh | 3844990 | 2005-06-07 01:43:41 +0000 | [diff] [blame] | 236 | ** |
| 237 | ** This routine also does the following optimization: It scans for |
| 238 | ** Halt instructions where P1==SQLITE_CONSTRAINT or P2==OE_Abort or for |
drh | f0863fe | 2005-06-12 21:35:51 +0000 | [diff] [blame] | 239 | ** IdxInsert instructions where P2!=0. If no such instruction is |
drh | 3844990 | 2005-06-07 01:43:41 +0000 | [diff] [blame] | 240 | ** found, then every Statement instruction is changed to a Noop. In |
| 241 | ** this way, we avoid creating the statement journal file unnecessarily. |
drh | 76ff3a0 | 2004-09-24 22:32:30 +0000 | [diff] [blame] | 242 | */ |
danielk1977 | bc04f85 | 2005-03-29 08:26:13 +0000 | [diff] [blame] | 243 | static void resolveP2Values(Vdbe *p, int *pMaxFuncArgs, int *pMaxStack){ |
drh | 76ff3a0 | 2004-09-24 22:32:30 +0000 | [diff] [blame] | 244 | int i; |
danielk1977 | bc04f85 | 2005-03-29 08:26:13 +0000 | [diff] [blame] | 245 | int nMaxArgs = 0; |
| 246 | int nMaxStack = p->nOp; |
drh | 76ff3a0 | 2004-09-24 22:32:30 +0000 | [diff] [blame] | 247 | Op *pOp; |
| 248 | int *aLabel = p->aLabel; |
drh | 3844990 | 2005-06-07 01:43:41 +0000 | [diff] [blame] | 249 | int doesStatementRollback = 0; |
| 250 | int hasStatementBegin = 0; |
drh | 76ff3a0 | 2004-09-24 22:32:30 +0000 | [diff] [blame] | 251 | for(pOp=p->aOp, i=p->nOp-1; i>=0; i--, pOp++){ |
danielk1977 | 634f298 | 2005-03-28 08:44:07 +0000 | [diff] [blame] | 252 | u8 opcode = pOp->opcode; |
| 253 | |
drh | 1344989 | 2005-09-07 21:22:45 +0000 | [diff] [blame] | 254 | if( opcode==OP_Function || opcode==OP_AggStep ){ |
danielk1977 | bc04f85 | 2005-03-29 08:26:13 +0000 | [diff] [blame] | 255 | if( pOp->p2>nMaxArgs ) nMaxArgs = pOp->p2; |
drh | 3844990 | 2005-06-07 01:43:41 +0000 | [diff] [blame] | 256 | }else if( opcode==OP_Halt ){ |
| 257 | if( pOp->p1==SQLITE_CONSTRAINT && pOp->p2==OE_Abort ){ |
| 258 | doesStatementRollback = 1; |
| 259 | } |
drh | f0863fe | 2005-06-12 21:35:51 +0000 | [diff] [blame] | 260 | }else if( opcode==OP_IdxInsert ){ |
drh | 3844990 | 2005-06-07 01:43:41 +0000 | [diff] [blame] | 261 | if( pOp->p2 ){ |
| 262 | doesStatementRollback = 1; |
| 263 | } |
| 264 | }else if( opcode==OP_Statement ){ |
| 265 | hasStatementBegin = 1; |
drh | 4be8b51 | 2006-06-13 23:51:34 +0000 | [diff] [blame^] | 266 | }else if( opcode==OP_VFilter ){ |
| 267 | int n; |
| 268 | assert( p->nOp - i >= 3 ); |
| 269 | assert( pOp[-2].opcode==OP_Integer ); |
| 270 | n = pOp[-2].p1; |
| 271 | if( n>nMaxArgs ) nMaxArgs = n; |
danielk1977 | bc04f85 | 2005-03-29 08:26:13 +0000 | [diff] [blame] | 272 | } |
danielk1977 | 7a5147c | 2005-03-29 13:07:00 +0000 | [diff] [blame] | 273 | if( opcodeNoPush(opcode) ){ |
danielk1977 | bc04f85 | 2005-03-29 08:26:13 +0000 | [diff] [blame] | 274 | nMaxStack--; |
danielk1977 | 634f298 | 2005-03-28 08:44:07 +0000 | [diff] [blame] | 275 | } |
| 276 | |
drh | 76ff3a0 | 2004-09-24 22:32:30 +0000 | [diff] [blame] | 277 | if( pOp->p2>=0 ) continue; |
| 278 | assert( -1-pOp->p2<p->nLabel ); |
| 279 | pOp->p2 = aLabel[-1-pOp->p2]; |
| 280 | } |
| 281 | sqliteFree(p->aLabel); |
| 282 | p->aLabel = 0; |
danielk1977 | bc04f85 | 2005-03-29 08:26:13 +0000 | [diff] [blame] | 283 | |
| 284 | *pMaxFuncArgs = nMaxArgs; |
| 285 | *pMaxStack = nMaxStack; |
drh | 3844990 | 2005-06-07 01:43:41 +0000 | [diff] [blame] | 286 | |
| 287 | /* If we never rollback a statement transaction, then statement |
| 288 | ** transactions are not needed. So change every OP_Statement |
drh | 66560ad | 2006-01-06 14:32:19 +0000 | [diff] [blame] | 289 | ** opcode into an OP_Noop. This avoid a call to sqlite3OsOpenExclusive() |
drh | 3844990 | 2005-06-07 01:43:41 +0000 | [diff] [blame] | 290 | ** which can be expensive on some platforms. |
| 291 | */ |
| 292 | if( hasStatementBegin && !doesStatementRollback ){ |
| 293 | for(pOp=p->aOp, i=p->nOp-1; i>=0; i--, pOp++){ |
| 294 | if( pOp->opcode==OP_Statement ){ |
| 295 | pOp->opcode = OP_Noop; |
| 296 | } |
| 297 | } |
| 298 | } |
drh | 76ff3a0 | 2004-09-24 22:32:30 +0000 | [diff] [blame] | 299 | } |
| 300 | |
| 301 | /* |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 302 | ** Return the address of the next instruction to be inserted. |
| 303 | */ |
danielk1977 | 4adee20 | 2004-05-08 08:23:19 +0000 | [diff] [blame] | 304 | int sqlite3VdbeCurrentAddr(Vdbe *p){ |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 305 | assert( p->magic==VDBE_MAGIC_INIT ); |
| 306 | return p->nOp; |
| 307 | } |
| 308 | |
| 309 | /* |
| 310 | ** Add a whole list of operations to the operation stack. Return the |
| 311 | ** address of the first operation added. |
| 312 | */ |
danielk1977 | 4adee20 | 2004-05-08 08:23:19 +0000 | [diff] [blame] | 313 | int sqlite3VdbeAddOpList(Vdbe *p, int nOp, VdbeOpList const *aOp){ |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 314 | int addr; |
| 315 | assert( p->magic==VDBE_MAGIC_INIT ); |
drh | 76ff3a0 | 2004-09-24 22:32:30 +0000 | [diff] [blame] | 316 | resizeOpArray(p, p->nOp + nOp); |
danielk1977 | 9e12800 | 2006-01-18 16:51:35 +0000 | [diff] [blame] | 317 | if( sqlite3MallocFailed() ){ |
drh | 76ff3a0 | 2004-09-24 22:32:30 +0000 | [diff] [blame] | 318 | return 0; |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 319 | } |
| 320 | addr = p->nOp; |
| 321 | if( nOp>0 ){ |
| 322 | int i; |
drh | 905793e | 2004-02-21 13:31:09 +0000 | [diff] [blame] | 323 | VdbeOpList const *pIn = aOp; |
| 324 | for(i=0; i<nOp; i++, pIn++){ |
| 325 | int p2 = pIn->p2; |
| 326 | VdbeOp *pOut = &p->aOp[i+addr]; |
| 327 | pOut->opcode = pIn->opcode; |
| 328 | pOut->p1 = pIn->p1; |
| 329 | pOut->p2 = p2<0 ? addr + ADDR(p2) : p2; |
| 330 | pOut->p3 = pIn->p3; |
| 331 | pOut->p3type = pIn->p3 ? P3_STATIC : P3_NOTUSED; |
danielk1977 | 8b60e0f | 2005-01-12 09:10:39 +0000 | [diff] [blame] | 332 | #ifdef SQLITE_DEBUG |
danielk1977 | 132872b | 2004-05-10 10:37:18 +0000 | [diff] [blame] | 333 | if( sqlite3_vdbe_addop_trace ){ |
danielk1977 | 4adee20 | 2004-05-08 08:23:19 +0000 | [diff] [blame] | 334 | sqlite3VdbePrintOp(0, i+addr, &p->aOp[i+addr]); |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 335 | } |
| 336 | #endif |
| 337 | } |
| 338 | p->nOp += nOp; |
| 339 | } |
| 340 | return addr; |
| 341 | } |
| 342 | |
| 343 | /* |
| 344 | ** Change the value of the P1 operand for a specific instruction. |
| 345 | ** This routine is useful when a large program is loaded from a |
danielk1977 | 4adee20 | 2004-05-08 08:23:19 +0000 | [diff] [blame] | 346 | ** static array using sqlite3VdbeAddOpList but we want to make a |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 347 | ** few minor changes to the program. |
| 348 | */ |
danielk1977 | 4adee20 | 2004-05-08 08:23:19 +0000 | [diff] [blame] | 349 | void sqlite3VdbeChangeP1(Vdbe *p, int addr, int val){ |
drh | 8aa34ae | 2006-03-13 12:54:09 +0000 | [diff] [blame] | 350 | assert( p==0 || p->magic==VDBE_MAGIC_INIT ); |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 351 | if( p && addr>=0 && p->nOp>addr && p->aOp ){ |
| 352 | p->aOp[addr].p1 = val; |
| 353 | } |
| 354 | } |
| 355 | |
| 356 | /* |
| 357 | ** Change the value of the P2 operand for a specific instruction. |
| 358 | ** This routine is useful for setting a jump destination. |
| 359 | */ |
danielk1977 | 4adee20 | 2004-05-08 08:23:19 +0000 | [diff] [blame] | 360 | void sqlite3VdbeChangeP2(Vdbe *p, int addr, int val){ |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 361 | assert( val>=0 ); |
drh | 8aa34ae | 2006-03-13 12:54:09 +0000 | [diff] [blame] | 362 | assert( p==0 || p->magic==VDBE_MAGIC_INIT ); |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 363 | if( p && addr>=0 && p->nOp>addr && p->aOp ){ |
| 364 | p->aOp[addr].p2 = val; |
| 365 | } |
| 366 | } |
| 367 | |
drh | d654be8 | 2005-09-20 17:42:23 +0000 | [diff] [blame] | 368 | /* |
drh | f887540 | 2006-03-17 13:56:34 +0000 | [diff] [blame] | 369 | ** Change the P2 operand of instruction addr so that it points to |
drh | d654be8 | 2005-09-20 17:42:23 +0000 | [diff] [blame] | 370 | ** the address of the next instruction to be coded. |
| 371 | */ |
| 372 | void sqlite3VdbeJumpHere(Vdbe *p, int addr){ |
| 373 | sqlite3VdbeChangeP2(p, addr, p->nOp); |
| 374 | } |
drh | b38ad99 | 2005-09-16 00:27:01 +0000 | [diff] [blame] | 375 | |
| 376 | /* |
| 377 | ** Delete a P3 value if necessary. |
| 378 | */ |
| 379 | static void freeP3(int p3type, void *p3){ |
| 380 | if( p3 ){ |
drh | ac1733d | 2005-09-17 17:58:22 +0000 | [diff] [blame] | 381 | switch( p3type ){ |
| 382 | case P3_DYNAMIC: |
| 383 | case P3_KEYINFO: |
| 384 | case P3_KEYINFO_HANDOFF: { |
| 385 | sqliteFree(p3); |
| 386 | break; |
| 387 | } |
drh | 4be8b51 | 2006-06-13 23:51:34 +0000 | [diff] [blame^] | 388 | case P3_MPRINTF: { |
| 389 | sqlite3_free(p3); |
| 390 | break; |
| 391 | } |
drh | ac1733d | 2005-09-17 17:58:22 +0000 | [diff] [blame] | 392 | case P3_VDBEFUNC: { |
| 393 | VdbeFunc *pVdbeFunc = (VdbeFunc *)p3; |
| 394 | sqlite3VdbeDeleteAuxData(pVdbeFunc, 0); |
| 395 | sqliteFree(pVdbeFunc); |
| 396 | break; |
| 397 | } |
| 398 | case P3_MEM: { |
| 399 | sqlite3ValueFree((sqlite3_value*)p3); |
| 400 | break; |
| 401 | } |
drh | b38ad99 | 2005-09-16 00:27:01 +0000 | [diff] [blame] | 402 | } |
| 403 | } |
| 404 | } |
| 405 | |
| 406 | |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 407 | /* |
drh | f887540 | 2006-03-17 13:56:34 +0000 | [diff] [blame] | 408 | ** Change N opcodes starting at addr to No-ops. |
| 409 | */ |
| 410 | void sqlite3VdbeChangeToNoop(Vdbe *p, int addr, int N){ |
| 411 | VdbeOp *pOp = &p->aOp[addr]; |
| 412 | while( N-- ){ |
| 413 | freeP3(pOp->p3type, pOp->p3); |
| 414 | memset(pOp, 0, sizeof(pOp[0])); |
| 415 | pOp->opcode = OP_Noop; |
| 416 | pOp++; |
| 417 | } |
| 418 | } |
| 419 | |
| 420 | /* |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 421 | ** Change the value of the P3 operand for a specific instruction. |
| 422 | ** This routine is useful when a large program is loaded from a |
danielk1977 | 4adee20 | 2004-05-08 08:23:19 +0000 | [diff] [blame] | 423 | ** static array using sqlite3VdbeAddOpList but we want to make a |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 424 | ** few minor changes to the program. |
| 425 | ** |
| 426 | ** If n>=0 then the P3 operand is dynamic, meaning that a copy of |
| 427 | ** the string is made into memory obtained from sqliteMalloc(). |
| 428 | ** A value of n==0 means copy bytes of zP3 up to and including the |
| 429 | ** first null byte. If n>0 then copy n+1 bytes of zP3. |
| 430 | ** |
danielk1977 | 1f55c05 | 2005-05-19 08:42:59 +0000 | [diff] [blame] | 431 | ** If n==P3_KEYINFO it means that zP3 is a pointer to a KeyInfo structure. |
| 432 | ** A copy is made of the KeyInfo structure into memory obtained from |
| 433 | ** sqliteMalloc, to be freed when the Vdbe is finalized. |
| 434 | ** n==P3_KEYINFO_HANDOFF indicates that zP3 points to a KeyInfo structure |
| 435 | ** stored in memory that the caller has obtained from sqliteMalloc. The |
| 436 | ** caller should not free the allocation, it will be freed when the Vdbe is |
| 437 | ** finalized. |
| 438 | ** |
| 439 | ** Other values of n (P3_STATIC, P3_COLLSEQ etc.) indicate that zP3 points |
| 440 | ** to a string or structure that is guaranteed to exist for the lifetime of |
| 441 | ** the Vdbe. In these cases we can just copy the pointer. |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 442 | ** |
| 443 | ** If addr<0 then change P3 on the most recently inserted instruction. |
| 444 | */ |
danielk1977 | 4adee20 | 2004-05-08 08:23:19 +0000 | [diff] [blame] | 445 | void sqlite3VdbeChangeP3(Vdbe *p, int addr, const char *zP3, int n){ |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 446 | Op *pOp; |
drh | 8aa34ae | 2006-03-13 12:54:09 +0000 | [diff] [blame] | 447 | assert( p==0 || p->magic==VDBE_MAGIC_INIT ); |
danielk1977 | 9e12800 | 2006-01-18 16:51:35 +0000 | [diff] [blame] | 448 | if( p==0 || p->aOp==0 || sqlite3MallocFailed() ){ |
danielk1977 | 261919c | 2005-12-06 12:52:59 +0000 | [diff] [blame] | 449 | if (n != P3_KEYINFO) { |
| 450 | freeP3(n, (void*)*(char**)&zP3); |
| 451 | } |
danielk1977 | d5d5652 | 2005-03-16 12:15:20 +0000 | [diff] [blame] | 452 | return; |
| 453 | } |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 454 | if( addr<0 || addr>=p->nOp ){ |
| 455 | addr = p->nOp - 1; |
| 456 | if( addr<0 ) return; |
| 457 | } |
| 458 | pOp = &p->aOp[addr]; |
drh | b38ad99 | 2005-09-16 00:27:01 +0000 | [diff] [blame] | 459 | freeP3(pOp->p3type, pOp->p3); |
| 460 | pOp->p3 = 0; |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 461 | if( zP3==0 ){ |
| 462 | pOp->p3 = 0; |
| 463 | pOp->p3type = P3_NOTUSED; |
drh | d3d39e9 | 2004-05-20 22:16:29 +0000 | [diff] [blame] | 464 | }else if( n==P3_KEYINFO ){ |
| 465 | KeyInfo *pKeyInfo; |
| 466 | int nField, nByte; |
drh | 4db38a7 | 2005-09-01 12:16:28 +0000 | [diff] [blame] | 467 | |
drh | d3d39e9 | 2004-05-20 22:16:29 +0000 | [diff] [blame] | 468 | nField = ((KeyInfo*)zP3)->nField; |
drh | fdd6e85 | 2005-12-16 01:06:16 +0000 | [diff] [blame] | 469 | nByte = sizeof(*pKeyInfo) + (nField-1)*sizeof(pKeyInfo->aColl[0]) + nField; |
drh | eafe05b | 2004-06-13 00:54:01 +0000 | [diff] [blame] | 470 | pKeyInfo = sqliteMallocRaw( nByte ); |
drh | d3d39e9 | 2004-05-20 22:16:29 +0000 | [diff] [blame] | 471 | pOp->p3 = (char*)pKeyInfo; |
| 472 | if( pKeyInfo ){ |
danielk1977 | bab45c6 | 2006-01-16 15:14:27 +0000 | [diff] [blame] | 473 | unsigned char *aSortOrder; |
drh | d3d39e9 | 2004-05-20 22:16:29 +0000 | [diff] [blame] | 474 | memcpy(pKeyInfo, zP3, nByte); |
drh | fdd6e85 | 2005-12-16 01:06:16 +0000 | [diff] [blame] | 475 | aSortOrder = pKeyInfo->aSortOrder; |
| 476 | if( aSortOrder ){ |
danielk1977 | bab45c6 | 2006-01-16 15:14:27 +0000 | [diff] [blame] | 477 | pKeyInfo->aSortOrder = (unsigned char*)&pKeyInfo->aColl[nField]; |
drh | fdd6e85 | 2005-12-16 01:06:16 +0000 | [diff] [blame] | 478 | memcpy(pKeyInfo->aSortOrder, aSortOrder, nField); |
| 479 | } |
drh | d3d39e9 | 2004-05-20 22:16:29 +0000 | [diff] [blame] | 480 | pOp->p3type = P3_KEYINFO; |
| 481 | }else{ |
| 482 | pOp->p3type = P3_NOTUSED; |
| 483 | } |
drh | ffbc308 | 2004-05-21 01:29:06 +0000 | [diff] [blame] | 484 | }else if( n==P3_KEYINFO_HANDOFF ){ |
| 485 | pOp->p3 = (char*)zP3; |
| 486 | pOp->p3type = P3_KEYINFO; |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 487 | }else if( n<0 ){ |
| 488 | pOp->p3 = (char*)zP3; |
| 489 | pOp->p3type = n; |
| 490 | }else{ |
drh | ae29ffb | 2004-09-25 14:39:18 +0000 | [diff] [blame] | 491 | if( n==0 ) n = strlen(zP3); |
| 492 | pOp->p3 = sqliteStrNDup(zP3, n); |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 493 | pOp->p3type = P3_DYNAMIC; |
| 494 | } |
| 495 | } |
| 496 | |
drh | ad6d946 | 2004-09-19 02:15:24 +0000 | [diff] [blame] | 497 | #ifndef NDEBUG |
| 498 | /* |
| 499 | ** Replace the P3 field of the most recently coded instruction with |
| 500 | ** comment text. |
| 501 | */ |
| 502 | void sqlite3VdbeComment(Vdbe *p, const char *zFormat, ...){ |
| 503 | va_list ap; |
| 504 | assert( p->nOp>0 ); |
drh | 6f7adc8 | 2006-01-11 21:41:20 +0000 | [diff] [blame] | 505 | assert( p->aOp==0 || p->aOp[p->nOp-1].p3==0 |
danielk1977 | 9e12800 | 2006-01-18 16:51:35 +0000 | [diff] [blame] | 506 | || sqlite3MallocFailed() ); |
drh | ad6d946 | 2004-09-19 02:15:24 +0000 | [diff] [blame] | 507 | va_start(ap, zFormat); |
| 508 | sqlite3VdbeChangeP3(p, -1, sqlite3VMPrintf(zFormat, ap), P3_DYNAMIC); |
| 509 | va_end(ap); |
| 510 | } |
| 511 | #endif |
| 512 | |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 513 | /* |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 514 | ** Return the opcode for a given address. |
| 515 | */ |
danielk1977 | 4adee20 | 2004-05-08 08:23:19 +0000 | [diff] [blame] | 516 | VdbeOp *sqlite3VdbeGetOp(Vdbe *p, int addr){ |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 517 | assert( p->magic==VDBE_MAGIC_INIT ); |
| 518 | assert( addr>=0 && addr<p->nOp ); |
| 519 | return &p->aOp[addr]; |
| 520 | } |
| 521 | |
drh | b7f9164 | 2004-10-31 02:22:47 +0000 | [diff] [blame] | 522 | #if !defined(SQLITE_OMIT_EXPLAIN) || !defined(NDEBUG) \ |
| 523 | || defined(VDBE_PROFILE) || defined(SQLITE_DEBUG) |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 524 | /* |
drh | d3d39e9 | 2004-05-20 22:16:29 +0000 | [diff] [blame] | 525 | ** Compute a string that describes the P3 parameter for an opcode. |
| 526 | ** Use zTemp for any required temporary buffer space. |
| 527 | */ |
| 528 | static char *displayP3(Op *pOp, char *zTemp, int nTemp){ |
| 529 | char *zP3; |
| 530 | assert( nTemp>=20 ); |
| 531 | switch( pOp->p3type ){ |
drh | d3d39e9 | 2004-05-20 22:16:29 +0000 | [diff] [blame] | 532 | case P3_KEYINFO: { |
| 533 | int i, j; |
| 534 | KeyInfo *pKeyInfo = (KeyInfo*)pOp->p3; |
| 535 | sprintf(zTemp, "keyinfo(%d", pKeyInfo->nField); |
| 536 | i = strlen(zTemp); |
| 537 | for(j=0; j<pKeyInfo->nField; j++){ |
| 538 | CollSeq *pColl = pKeyInfo->aColl[j]; |
| 539 | if( pColl ){ |
| 540 | int n = strlen(pColl->zName); |
| 541 | if( i+n>nTemp-6 ){ |
| 542 | strcpy(&zTemp[i],",..."); |
| 543 | break; |
| 544 | } |
| 545 | zTemp[i++] = ','; |
drh | ffbc308 | 2004-05-21 01:29:06 +0000 | [diff] [blame] | 546 | if( pKeyInfo->aSortOrder && pKeyInfo->aSortOrder[j] ){ |
drh | d3d39e9 | 2004-05-20 22:16:29 +0000 | [diff] [blame] | 547 | zTemp[i++] = '-'; |
| 548 | } |
| 549 | strcpy(&zTemp[i], pColl->zName); |
| 550 | i += n; |
| 551 | }else if( i+4<nTemp-6 ){ |
| 552 | strcpy(&zTemp[i],",nil"); |
| 553 | i += 4; |
| 554 | } |
| 555 | } |
| 556 | zTemp[i++] = ')'; |
| 557 | zTemp[i] = 0; |
| 558 | assert( i<nTemp ); |
| 559 | zP3 = zTemp; |
| 560 | break; |
| 561 | } |
| 562 | case P3_COLLSEQ: { |
| 563 | CollSeq *pColl = (CollSeq*)pOp->p3; |
drh | ffbc308 | 2004-05-21 01:29:06 +0000 | [diff] [blame] | 564 | sprintf(zTemp, "collseq(%.20s)", pColl->zName); |
drh | d3d39e9 | 2004-05-20 22:16:29 +0000 | [diff] [blame] | 565 | zP3 = zTemp; |
| 566 | break; |
| 567 | } |
drh | f9b596e | 2004-05-26 16:54:42 +0000 | [diff] [blame] | 568 | case P3_FUNCDEF: { |
| 569 | FuncDef *pDef = (FuncDef*)pOp->p3; |
drh | a967e88 | 2006-06-13 01:04:52 +0000 | [diff] [blame] | 570 | sqlite3_snprintf(nTemp, zTemp, "%s(%d)", pDef->zName, pDef->nArg); |
drh | f9b596e | 2004-05-26 16:54:42 +0000 | [diff] [blame] | 571 | zP3 = zTemp; |
| 572 | break; |
| 573 | } |
drh | a967e88 | 2006-06-13 01:04:52 +0000 | [diff] [blame] | 574 | #ifndef SQLITE_OMIT_VIRTUALTABLE |
| 575 | case P3_VTAB: { |
| 576 | sqlite3_vtab *pVtab = (sqlite3_vtab*)pOp->p3; |
| 577 | sqlite3_snprintf(nTemp, zTemp, "%p:%s", pVtab, pVtab->pModule->zName); |
| 578 | zP3 = zTemp; |
| 579 | break; |
| 580 | } |
| 581 | #endif |
drh | d3d39e9 | 2004-05-20 22:16:29 +0000 | [diff] [blame] | 582 | default: { |
| 583 | zP3 = pOp->p3; |
drh | 3f7d4e4 | 2004-07-24 14:35:58 +0000 | [diff] [blame] | 584 | if( zP3==0 || pOp->opcode==OP_Noop ){ |
drh | d3d39e9 | 2004-05-20 22:16:29 +0000 | [diff] [blame] | 585 | zP3 = ""; |
| 586 | } |
| 587 | } |
| 588 | } |
| 589 | return zP3; |
| 590 | } |
drh | b7f9164 | 2004-10-31 02:22:47 +0000 | [diff] [blame] | 591 | #endif |
drh | d3d39e9 | 2004-05-20 22:16:29 +0000 | [diff] [blame] | 592 | |
| 593 | |
danielk1977 | 8b60e0f | 2005-01-12 09:10:39 +0000 | [diff] [blame] | 594 | #if defined(VDBE_PROFILE) || defined(SQLITE_DEBUG) |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 595 | /* |
| 596 | ** Print a single opcode. This routine is used for debugging only. |
| 597 | */ |
danielk1977 | 4adee20 | 2004-05-08 08:23:19 +0000 | [diff] [blame] | 598 | void sqlite3VdbePrintOp(FILE *pOut, int pc, Op *pOp){ |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 599 | char *zP3; |
drh | d3d39e9 | 2004-05-20 22:16:29 +0000 | [diff] [blame] | 600 | char zPtr[50]; |
| 601 | static const char *zFormat1 = "%4d %-13s %4d %4d %s\n"; |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 602 | if( pOut==0 ) pOut = stdout; |
drh | d3d39e9 | 2004-05-20 22:16:29 +0000 | [diff] [blame] | 603 | zP3 = displayP3(pOp, zPtr, sizeof(zPtr)); |
drh | d3d39e9 | 2004-05-20 22:16:29 +0000 | [diff] [blame] | 604 | fprintf(pOut, zFormat1, |
| 605 | pc, sqlite3OpcodeNames[pOp->opcode], pOp->p1, pOp->p2, zP3); |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 606 | fflush(pOut); |
| 607 | } |
| 608 | #endif |
| 609 | |
| 610 | /* |
drh | 76ff3a0 | 2004-09-24 22:32:30 +0000 | [diff] [blame] | 611 | ** Release an array of N Mem elements |
| 612 | */ |
| 613 | static void releaseMemArray(Mem *p, int N){ |
| 614 | if( p ){ |
| 615 | while( N-->0 ){ |
| 616 | sqlite3VdbeMemRelease(p++); |
| 617 | } |
| 618 | } |
| 619 | } |
| 620 | |
drh | b7f9164 | 2004-10-31 02:22:47 +0000 | [diff] [blame] | 621 | #ifndef SQLITE_OMIT_EXPLAIN |
drh | 76ff3a0 | 2004-09-24 22:32:30 +0000 | [diff] [blame] | 622 | /* |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 623 | ** Give a listing of the program in the virtual machine. |
| 624 | ** |
danielk1977 | 4adee20 | 2004-05-08 08:23:19 +0000 | [diff] [blame] | 625 | ** The interface is the same as sqlite3VdbeExec(). But instead of |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 626 | ** running the code, it invokes the callback once for each instruction. |
| 627 | ** This feature is used to implement "EXPLAIN". |
| 628 | */ |
danielk1977 | 4adee20 | 2004-05-08 08:23:19 +0000 | [diff] [blame] | 629 | int sqlite3VdbeList( |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 630 | Vdbe *p /* The VDBE */ |
| 631 | ){ |
drh | 9bb575f | 2004-09-06 17:24:11 +0000 | [diff] [blame] | 632 | sqlite3 *db = p->db; |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 633 | int i; |
drh | 826fb5a | 2004-02-14 23:59:57 +0000 | [diff] [blame] | 634 | int rc = SQLITE_OK; |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 635 | |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 636 | assert( p->explain ); |
drh | c5cdca6 | 2005-01-11 16:54:14 +0000 | [diff] [blame] | 637 | if( p->magic!=VDBE_MAGIC_RUN ) return SQLITE_MISUSE; |
| 638 | assert( db->magic==SQLITE_MAGIC_BUSY ); |
| 639 | assert( p->rc==SQLITE_OK || p->rc==SQLITE_BUSY ); |
danielk1977 | 18f4189 | 2004-05-22 07:27:46 +0000 | [diff] [blame] | 640 | |
| 641 | /* Even though this opcode does not put dynamic strings onto the |
| 642 | ** the stack, they may become dynamic if the user calls |
drh | 4f26d6c | 2004-05-26 23:25:30 +0000 | [diff] [blame] | 643 | ** sqlite3_column_text16(), causing a translation to UTF-16 encoding. |
danielk1977 | 18f4189 | 2004-05-22 07:27:46 +0000 | [diff] [blame] | 644 | */ |
| 645 | if( p->pTos==&p->aStack[4] ){ |
drh | 76ff3a0 | 2004-09-24 22:32:30 +0000 | [diff] [blame] | 646 | releaseMemArray(p->aStack, 5); |
danielk1977 | 18f4189 | 2004-05-22 07:27:46 +0000 | [diff] [blame] | 647 | } |
danielk1977 | 18f4189 | 2004-05-22 07:27:46 +0000 | [diff] [blame] | 648 | p->resOnStack = 0; |
| 649 | |
drh | ecc9242 | 2005-09-10 16:46:12 +0000 | [diff] [blame] | 650 | do{ |
| 651 | i = p->pc++; |
| 652 | }while( i<p->nOp && p->explain==2 && p->aOp[i].opcode!=OP_Explain ); |
drh | 826fb5a | 2004-02-14 23:59:57 +0000 | [diff] [blame] | 653 | if( i>=p->nOp ){ |
| 654 | p->rc = SQLITE_OK; |
| 655 | rc = SQLITE_DONE; |
| 656 | }else if( db->flags & SQLITE_Interrupt ){ |
| 657 | db->flags &= ~SQLITE_Interrupt; |
drh | c5cdca6 | 2005-01-11 16:54:14 +0000 | [diff] [blame] | 658 | p->rc = SQLITE_INTERRUPT; |
drh | 826fb5a | 2004-02-14 23:59:57 +0000 | [diff] [blame] | 659 | rc = SQLITE_ERROR; |
danielk1977 | f20b21c | 2004-05-31 23:56:42 +0000 | [diff] [blame] | 660 | sqlite3SetString(&p->zErrMsg, sqlite3ErrStr(p->rc), (char*)0); |
drh | 826fb5a | 2004-02-14 23:59:57 +0000 | [diff] [blame] | 661 | }else{ |
drh | d3d39e9 | 2004-05-20 22:16:29 +0000 | [diff] [blame] | 662 | Op *pOp = &p->aOp[i]; |
drh | eb2e176 | 2004-05-27 01:53:56 +0000 | [diff] [blame] | 663 | Mem *pMem = p->aStack; |
| 664 | pMem->flags = MEM_Int; |
drh | 9c05483 | 2004-05-31 18:51:57 +0000 | [diff] [blame] | 665 | pMem->type = SQLITE_INTEGER; |
drh | eb2e176 | 2004-05-27 01:53:56 +0000 | [diff] [blame] | 666 | pMem->i = i; /* Program counter */ |
| 667 | pMem++; |
| 668 | |
| 669 | pMem->flags = MEM_Static|MEM_Str|MEM_Term; |
| 670 | pMem->z = sqlite3OpcodeNames[pOp->opcode]; /* Opcode */ |
| 671 | pMem->n = strlen(pMem->z); |
drh | 9c05483 | 2004-05-31 18:51:57 +0000 | [diff] [blame] | 672 | pMem->type = SQLITE_TEXT; |
danielk1977 | dc8453f | 2004-06-12 00:42:34 +0000 | [diff] [blame] | 673 | pMem->enc = SQLITE_UTF8; |
drh | eb2e176 | 2004-05-27 01:53:56 +0000 | [diff] [blame] | 674 | pMem++; |
| 675 | |
| 676 | pMem->flags = MEM_Int; |
| 677 | pMem->i = pOp->p1; /* P1 */ |
drh | 9c05483 | 2004-05-31 18:51:57 +0000 | [diff] [blame] | 678 | pMem->type = SQLITE_INTEGER; |
drh | eb2e176 | 2004-05-27 01:53:56 +0000 | [diff] [blame] | 679 | pMem++; |
| 680 | |
| 681 | pMem->flags = MEM_Int; |
| 682 | pMem->i = pOp->p2; /* P2 */ |
drh | 9c05483 | 2004-05-31 18:51:57 +0000 | [diff] [blame] | 683 | pMem->type = SQLITE_INTEGER; |
drh | eb2e176 | 2004-05-27 01:53:56 +0000 | [diff] [blame] | 684 | pMem++; |
| 685 | |
drh | b806798 | 2006-03-03 21:38:03 +0000 | [diff] [blame] | 686 | pMem->flags = MEM_Ephem|MEM_Str|MEM_Term; /* P3 */ |
drh | eb2e176 | 2004-05-27 01:53:56 +0000 | [diff] [blame] | 687 | pMem->z = displayP3(pOp, pMem->zShort, sizeof(pMem->zShort)); |
drh | b806798 | 2006-03-03 21:38:03 +0000 | [diff] [blame] | 688 | pMem->n = strlen(pMem->z); |
drh | 9c05483 | 2004-05-31 18:51:57 +0000 | [diff] [blame] | 689 | pMem->type = SQLITE_TEXT; |
danielk1977 | dc8453f | 2004-06-12 00:42:34 +0000 | [diff] [blame] | 690 | pMem->enc = SQLITE_UTF8; |
drh | eb2e176 | 2004-05-27 01:53:56 +0000 | [diff] [blame] | 691 | |
drh | ecc9242 | 2005-09-10 16:46:12 +0000 | [diff] [blame] | 692 | p->nResColumn = 5 - 2*(p->explain-1); |
drh | eb2e176 | 2004-05-27 01:53:56 +0000 | [diff] [blame] | 693 | p->pTos = pMem; |
drh | 826fb5a | 2004-02-14 23:59:57 +0000 | [diff] [blame] | 694 | p->rc = SQLITE_OK; |
danielk1977 | 18f4189 | 2004-05-22 07:27:46 +0000 | [diff] [blame] | 695 | p->resOnStack = 1; |
drh | 826fb5a | 2004-02-14 23:59:57 +0000 | [diff] [blame] | 696 | rc = SQLITE_ROW; |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 697 | } |
drh | 826fb5a | 2004-02-14 23:59:57 +0000 | [diff] [blame] | 698 | return rc; |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 699 | } |
drh | b7f9164 | 2004-10-31 02:22:47 +0000 | [diff] [blame] | 700 | #endif /* SQLITE_OMIT_EXPLAIN */ |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 701 | |
| 702 | /* |
drh | 3f7d4e4 | 2004-07-24 14:35:58 +0000 | [diff] [blame] | 703 | ** Print the SQL that was used to generate a VDBE program. |
| 704 | */ |
| 705 | void sqlite3VdbePrintSql(Vdbe *p){ |
| 706 | #ifdef SQLITE_DEBUG |
| 707 | int nOp = p->nOp; |
| 708 | VdbeOp *pOp; |
drh | c16a03b | 2004-09-15 13:38:10 +0000 | [diff] [blame] | 709 | if( nOp<1 ) return; |
| 710 | pOp = &p->aOp[nOp-1]; |
drh | 3f7d4e4 | 2004-07-24 14:35:58 +0000 | [diff] [blame] | 711 | if( pOp->opcode==OP_Noop && pOp->p3!=0 ){ |
| 712 | const char *z = pOp->p3; |
drh | 4c755c0 | 2004-08-08 20:22:17 +0000 | [diff] [blame] | 713 | while( isspace(*(u8*)z) ) z++; |
drh | 3f7d4e4 | 2004-07-24 14:35:58 +0000 | [diff] [blame] | 714 | printf("SQL: [%s]\n", z); |
| 715 | } |
| 716 | #endif |
| 717 | } |
| 718 | |
| 719 | /* |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 720 | ** Prepare a virtual machine for execution. This involves things such |
| 721 | ** as allocating stack space and initializing the program counter. |
| 722 | ** After the VDBE has be prepped, it can be executed by one or more |
danielk1977 | 4adee20 | 2004-05-08 08:23:19 +0000 | [diff] [blame] | 723 | ** calls to sqlite3VdbeExec(). |
drh | 92f02c3 | 2004-09-02 14:57:08 +0000 | [diff] [blame] | 724 | ** |
| 725 | ** This is the only way to move a VDBE from VDBE_MAGIC_INIT to |
| 726 | ** VDBE_MAGIC_RUN. |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 727 | */ |
danielk1977 | 4adee20 | 2004-05-08 08:23:19 +0000 | [diff] [blame] | 728 | void sqlite3VdbeMakeReady( |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 729 | Vdbe *p, /* The VDBE */ |
drh | 7c972de | 2003-09-06 22:18:07 +0000 | [diff] [blame] | 730 | int nVar, /* Number of '?' see in the SQL statement */ |
drh | 290c194 | 2004-08-21 17:54:45 +0000 | [diff] [blame] | 731 | int nMem, /* Number of memory cells to allocate */ |
| 732 | int nCursor, /* Number of cursors to allocate */ |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 733 | int isExplain /* True if the EXPLAIN keywords is present */ |
| 734 | ){ |
| 735 | int n; |
| 736 | |
| 737 | assert( p!=0 ); |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 738 | assert( p->magic==VDBE_MAGIC_INIT ); |
| 739 | |
drh | c16a03b | 2004-09-15 13:38:10 +0000 | [diff] [blame] | 740 | /* There should be at least one opcode. |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 741 | */ |
drh | c16a03b | 2004-09-15 13:38:10 +0000 | [diff] [blame] | 742 | assert( p->nOp>0 ); |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 743 | |
danielk1977 | 634f298 | 2005-03-28 08:44:07 +0000 | [diff] [blame] | 744 | /* Set the magic to VDBE_MAGIC_RUN sooner rather than later. This |
| 745 | * is because the call to resizeOpArray() below may shrink the |
| 746 | * p->aOp[] array to save memory if called when in VDBE_MAGIC_RUN |
| 747 | * state. |
| 748 | */ |
| 749 | p->magic = VDBE_MAGIC_RUN; |
| 750 | |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 751 | /* No instruction ever pushes more than a single element onto the |
| 752 | ** stack. And the stack never grows on successive executions of the |
| 753 | ** same loop. So the total number of instructions is an upper bound |
drh | 3844990 | 2005-06-07 01:43:41 +0000 | [diff] [blame] | 754 | ** on the maximum stack depth required. (Added later:) The |
| 755 | ** resolveP2Values() call computes a tighter upper bound on the |
| 756 | ** stack size. |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 757 | ** |
| 758 | ** Allocation all the stack space we will ever need. |
| 759 | */ |
drh | 82a4851 | 2003-09-06 22:45:20 +0000 | [diff] [blame] | 760 | if( p->aStack==0 ){ |
danielk1977 | 634f298 | 2005-03-28 08:44:07 +0000 | [diff] [blame] | 761 | int nArg; /* Maximum number of args passed to a user function. */ |
danielk1977 | bc04f85 | 2005-03-29 08:26:13 +0000 | [diff] [blame] | 762 | int nStack; /* Maximum number of stack entries required */ |
| 763 | resolveP2Values(p, &nArg, &nStack); |
danielk1977 | 634f298 | 2005-03-28 08:44:07 +0000 | [diff] [blame] | 764 | resizeOpArray(p, p->nOp); |
drh | 82a4851 | 2003-09-06 22:45:20 +0000 | [diff] [blame] | 765 | assert( nVar>=0 ); |
danielk1977 | bc04f85 | 2005-03-29 08:26:13 +0000 | [diff] [blame] | 766 | assert( nStack<p->nOp ); |
| 767 | nStack = isExplain ? 10 : nStack; |
drh | 82a4851 | 2003-09-06 22:45:20 +0000 | [diff] [blame] | 768 | p->aStack = sqliteMalloc( |
danielk1977 | bc04f85 | 2005-03-29 08:26:13 +0000 | [diff] [blame] | 769 | nStack*sizeof(p->aStack[0]) /* aStack */ |
danielk1977 | 634f298 | 2005-03-28 08:44:07 +0000 | [diff] [blame] | 770 | + nArg*sizeof(Mem*) /* apArg */ |
drh | 86f4330 | 2004-10-05 17:37:36 +0000 | [diff] [blame] | 771 | + nVar*sizeof(Mem) /* aVar */ |
| 772 | + nVar*sizeof(char*) /* azVar */ |
| 773 | + nMem*sizeof(Mem) /* aMem */ |
| 774 | + nCursor*sizeof(Cursor*) /* apCsr */ |
drh | 82a4851 | 2003-09-06 22:45:20 +0000 | [diff] [blame] | 775 | ); |
danielk1977 | 9e12800 | 2006-01-18 16:51:35 +0000 | [diff] [blame] | 776 | if( !sqlite3MallocFailed() ){ |
danielk1977 | bc04f85 | 2005-03-29 08:26:13 +0000 | [diff] [blame] | 777 | p->aMem = &p->aStack[nStack]; |
drh | 290c194 | 2004-08-21 17:54:45 +0000 | [diff] [blame] | 778 | p->nMem = nMem; |
drh | 86f4330 | 2004-10-05 17:37:36 +0000 | [diff] [blame] | 779 | p->aVar = &p->aMem[nMem]; |
| 780 | p->nVar = nVar; |
| 781 | p->okVar = 0; |
| 782 | p->apArg = (Mem**)&p->aVar[nVar]; |
danielk1977 | 634f298 | 2005-03-28 08:44:07 +0000 | [diff] [blame] | 783 | p->azVar = (char**)&p->apArg[nArg]; |
drh | 86f4330 | 2004-10-05 17:37:36 +0000 | [diff] [blame] | 784 | p->apCsr = (Cursor**)&p->azVar[nVar]; |
drh | 290c194 | 2004-08-21 17:54:45 +0000 | [diff] [blame] | 785 | p->nCursor = nCursor; |
| 786 | for(n=0; n<nVar; n++){ |
| 787 | p->aVar[n].flags = MEM_Null; |
| 788 | } |
danielk1977 | 54db47e | 2004-05-19 10:36:43 +0000 | [diff] [blame] | 789 | } |
drh | 82a4851 | 2003-09-06 22:45:20 +0000 | [diff] [blame] | 790 | } |
danielk1977 | b3bce66 | 2005-01-29 08:32:43 +0000 | [diff] [blame] | 791 | for(n=0; n<p->nMem; n++){ |
| 792 | p->aMem[n].flags = MEM_Null; |
| 793 | } |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 794 | |
drh | faa57ac | 2004-06-09 14:01:51 +0000 | [diff] [blame] | 795 | #ifdef SQLITE_DEBUG |
drh | 35d4c2f | 2004-06-10 01:30:59 +0000 | [diff] [blame] | 796 | if( (p->db->flags & SQLITE_VdbeListing)!=0 |
drh | 66560ad | 2006-01-06 14:32:19 +0000 | [diff] [blame] | 797 | || sqlite3OsFileExists("vdbe_explain") |
drh | 35d4c2f | 2004-06-10 01:30:59 +0000 | [diff] [blame] | 798 | ){ |
drh | 8024205 | 2004-06-09 00:48:12 +0000 | [diff] [blame] | 799 | int i; |
| 800 | printf("VDBE Program Listing:\n"); |
drh | 3f7d4e4 | 2004-07-24 14:35:58 +0000 | [diff] [blame] | 801 | sqlite3VdbePrintSql(p); |
drh | 8024205 | 2004-06-09 00:48:12 +0000 | [diff] [blame] | 802 | for(i=0; i<p->nOp; i++){ |
| 803 | sqlite3VdbePrintOp(stdout, i, &p->aOp[i]); |
| 804 | } |
| 805 | } |
drh | 66560ad | 2006-01-06 14:32:19 +0000 | [diff] [blame] | 806 | if( sqlite3OsFileExists("vdbe_trace") ){ |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 807 | p->trace = stdout; |
| 808 | } |
| 809 | #endif |
drh | 6810ce6 | 2004-01-31 19:22:56 +0000 | [diff] [blame] | 810 | p->pTos = &p->aStack[-1]; |
danielk1977 | 1d850a7 | 2004-05-31 08:26:49 +0000 | [diff] [blame] | 811 | p->pc = -1; |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 812 | p->rc = SQLITE_OK; |
| 813 | p->uniqueCnt = 0; |
| 814 | p->returnDepth = 0; |
| 815 | p->errorAction = OE_Abort; |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 816 | p->popStack = 0; |
| 817 | p->explain |= isExplain; |
| 818 | p->magic = VDBE_MAGIC_RUN; |
danielk1977 | b28af71 | 2004-06-21 06:50:26 +0000 | [diff] [blame] | 819 | p->nChange = 0; |
drh | 76873ab | 2006-01-07 18:48:26 +0000 | [diff] [blame] | 820 | p->cacheCtr = 1; |
drh | d946db0 | 2005-12-29 19:23:06 +0000 | [diff] [blame] | 821 | p->minWriteFileFormat = 255; |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 822 | #ifdef VDBE_PROFILE |
drh | cf64d8b | 2003-12-31 17:57:10 +0000 | [diff] [blame] | 823 | { |
| 824 | int i; |
| 825 | for(i=0; i<p->nOp; i++){ |
| 826 | p->aOp[i].cnt = 0; |
| 827 | p->aOp[i].cycles = 0; |
| 828 | } |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 829 | } |
| 830 | #endif |
| 831 | } |
| 832 | |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 833 | /* |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 834 | ** Close a cursor and release all the resources that cursor happens |
| 835 | ** to hold. |
| 836 | */ |
drh | 4774b13 | 2004-06-12 20:12:51 +0000 | [diff] [blame] | 837 | void sqlite3VdbeFreeCursor(Cursor *pCx){ |
| 838 | if( pCx==0 ){ |
| 839 | return; |
| 840 | } |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 841 | if( pCx->pCursor ){ |
danielk1977 | 4adee20 | 2004-05-08 08:23:19 +0000 | [diff] [blame] | 842 | sqlite3BtreeCloseCursor(pCx->pCursor); |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 843 | } |
| 844 | if( pCx->pBt ){ |
danielk1977 | 4adee20 | 2004-05-08 08:23:19 +0000 | [diff] [blame] | 845 | sqlite3BtreeClose(pCx->pBt); |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 846 | } |
drh | 9eff616 | 2006-06-12 21:59:13 +0000 | [diff] [blame] | 847 | #ifndef SQLITE_OMIT_VIRTUALTABLE |
| 848 | if( pCx->pVtabCursor ){ |
| 849 | sqlite3_vtab_cursor *pVtabCursor = pCx->pVtabCursor; |
| 850 | sqlite3_vtab *pVtab = pVtabCursor->pVtab; |
danielk1977 | b7a7b9a | 2006-06-13 10:24:42 +0000 | [diff] [blame] | 851 | const sqlite3_module *pModule = pVtab->pModule; |
drh | 9eff616 | 2006-06-12 21:59:13 +0000 | [diff] [blame] | 852 | pModule->xClose(pVtabCursor); |
| 853 | } |
| 854 | #endif |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 855 | sqliteFree(pCx->pData); |
drh | 9188b38 | 2004-05-14 21:12:22 +0000 | [diff] [blame] | 856 | sqliteFree(pCx->aType); |
drh | 4774b13 | 2004-06-12 20:12:51 +0000 | [diff] [blame] | 857 | sqliteFree(pCx); |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 858 | } |
| 859 | |
| 860 | /* |
| 861 | ** Close all cursors |
| 862 | */ |
| 863 | static void closeAllCursors(Vdbe *p){ |
| 864 | int i; |
drh | 290c194 | 2004-08-21 17:54:45 +0000 | [diff] [blame] | 865 | if( p->apCsr==0 ) return; |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 866 | for(i=0; i<p->nCursor; i++){ |
drh | 4774b13 | 2004-06-12 20:12:51 +0000 | [diff] [blame] | 867 | sqlite3VdbeFreeCursor(p->apCsr[i]); |
drh | 290c194 | 2004-08-21 17:54:45 +0000 | [diff] [blame] | 868 | p->apCsr[i] = 0; |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 869 | } |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 870 | } |
| 871 | |
| 872 | /* |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 873 | ** Clean up the VM after execution. |
| 874 | ** |
| 875 | ** This routine will automatically close any cursors, lists, and/or |
| 876 | ** sorters that were left open. It also deletes the values of |
drh | 5a12e68 | 2004-05-19 11:24:25 +0000 | [diff] [blame] | 877 | ** variables in the aVar[] array. |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 878 | */ |
| 879 | static void Cleanup(Vdbe *p){ |
| 880 | int i; |
drh | 6810ce6 | 2004-01-31 19:22:56 +0000 | [diff] [blame] | 881 | if( p->aStack ){ |
drh | 76ff3a0 | 2004-09-24 22:32:30 +0000 | [diff] [blame] | 882 | releaseMemArray(p->aStack, 1 + (p->pTos - p->aStack)); |
| 883 | p->pTos = &p->aStack[-1]; |
drh | 6810ce6 | 2004-01-31 19:22:56 +0000 | [diff] [blame] | 884 | } |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 885 | closeAllCursors(p); |
drh | 76ff3a0 | 2004-09-24 22:32:30 +0000 | [diff] [blame] | 886 | releaseMemArray(p->aMem, p->nMem); |
drh | a01f79d | 2005-07-08 13:07:59 +0000 | [diff] [blame] | 887 | sqlite3VdbeFifoClear(&p->sFifo); |
drh | 76ff3a0 | 2004-09-24 22:32:30 +0000 | [diff] [blame] | 888 | if( p->contextStack ){ |
| 889 | for(i=0; i<p->contextStackTop; i++){ |
drh | a01f79d | 2005-07-08 13:07:59 +0000 | [diff] [blame] | 890 | sqlite3VdbeFifoClear(&p->contextStack[i].sFifo); |
drh | 76ff3a0 | 2004-09-24 22:32:30 +0000 | [diff] [blame] | 891 | } |
| 892 | sqliteFree(p->contextStack); |
drh | 344737f | 2004-09-19 00:50:20 +0000 | [diff] [blame] | 893 | } |
drh | 5f96843 | 2004-02-21 19:02:30 +0000 | [diff] [blame] | 894 | p->contextStack = 0; |
drh | 344737f | 2004-09-19 00:50:20 +0000 | [diff] [blame] | 895 | p->contextStackDepth = 0; |
| 896 | p->contextStackTop = 0; |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 897 | sqliteFree(p->zErrMsg); |
| 898 | p->zErrMsg = 0; |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 899 | } |
| 900 | |
| 901 | /* |
danielk1977 | 22322fd | 2004-05-25 23:35:17 +0000 | [diff] [blame] | 902 | ** Set the number of result columns that will be returned by this SQL |
| 903 | ** statement. This is now set at compile time, rather than during |
| 904 | ** execution of the vdbe program so that sqlite3_column_count() can |
| 905 | ** be called on an SQL statement before sqlite3_step(). |
| 906 | */ |
| 907 | void sqlite3VdbeSetNumCols(Vdbe *p, int nResColumn){ |
drh | 76ff3a0 | 2004-09-24 22:32:30 +0000 | [diff] [blame] | 908 | Mem *pColName; |
| 909 | int n; |
danielk1977 | 955de52 | 2006-02-10 02:27:42 +0000 | [diff] [blame] | 910 | releaseMemArray(p->aColName, p->nResColumn*COLNAME_N); |
drh | cc43cab | 2005-10-05 11:35:09 +0000 | [diff] [blame] | 911 | sqliteFree(p->aColName); |
danielk1977 | 955de52 | 2006-02-10 02:27:42 +0000 | [diff] [blame] | 912 | n = nResColumn*COLNAME_N; |
drh | cc43cab | 2005-10-05 11:35:09 +0000 | [diff] [blame] | 913 | p->nResColumn = nResColumn; |
drh | 76ff3a0 | 2004-09-24 22:32:30 +0000 | [diff] [blame] | 914 | p->aColName = pColName = (Mem*)sqliteMalloc( sizeof(Mem)*n ); |
| 915 | if( p->aColName==0 ) return; |
| 916 | while( n-- > 0 ){ |
| 917 | (pColName++)->flags = MEM_Null; |
| 918 | } |
danielk1977 | 22322fd | 2004-05-25 23:35:17 +0000 | [diff] [blame] | 919 | } |
| 920 | |
| 921 | /* |
danielk1977 | 3cf8606 | 2004-05-26 10:11:05 +0000 | [diff] [blame] | 922 | ** Set the name of the idx'th column to be returned by the SQL statement. |
| 923 | ** zName must be a pointer to a nul terminated string. |
| 924 | ** |
| 925 | ** This call must be made after a call to sqlite3VdbeSetNumCols(). |
| 926 | ** |
danielk1977 | d812336 | 2004-06-12 09:25:12 +0000 | [diff] [blame] | 927 | ** If N==P3_STATIC it means that zName is a pointer to a constant static |
| 928 | ** string and we can just copy the pointer. If it is P3_DYNAMIC, then |
| 929 | ** the string is freed using sqliteFree() when the vdbe is finished with |
| 930 | ** it. Otherwise, N bytes of zName are copied. |
danielk1977 | 3cf8606 | 2004-05-26 10:11:05 +0000 | [diff] [blame] | 931 | */ |
danielk1977 | 955de52 | 2006-02-10 02:27:42 +0000 | [diff] [blame] | 932 | int sqlite3VdbeSetColName(Vdbe *p, int idx, int var, const char *zName, int N){ |
danielk1977 | 3cf8606 | 2004-05-26 10:11:05 +0000 | [diff] [blame] | 933 | int rc; |
| 934 | Mem *pColName; |
danielk1977 | 955de52 | 2006-02-10 02:27:42 +0000 | [diff] [blame] | 935 | assert( idx<p->nResColumn ); |
| 936 | assert( var<COLNAME_N ); |
danielk1977 | 9e12800 | 2006-01-18 16:51:35 +0000 | [diff] [blame] | 937 | if( sqlite3MallocFailed() ) return SQLITE_NOMEM; |
drh | 76ff3a0 | 2004-09-24 22:32:30 +0000 | [diff] [blame] | 938 | assert( p->aColName!=0 ); |
danielk1977 | 955de52 | 2006-02-10 02:27:42 +0000 | [diff] [blame] | 939 | pColName = &(p->aColName[idx+var*p->nResColumn]); |
danielk1977 | d812336 | 2004-06-12 09:25:12 +0000 | [diff] [blame] | 940 | if( N==P3_DYNAMIC || N==P3_STATIC ){ |
| 941 | rc = sqlite3VdbeMemSetStr(pColName, zName, -1, SQLITE_UTF8, SQLITE_STATIC); |
danielk1977 | 3cf8606 | 2004-05-26 10:11:05 +0000 | [diff] [blame] | 942 | }else{ |
danielk1977 | d812336 | 2004-06-12 09:25:12 +0000 | [diff] [blame] | 943 | rc = sqlite3VdbeMemSetStr(pColName, zName, N, SQLITE_UTF8,SQLITE_TRANSIENT); |
danielk1977 | 3cf8606 | 2004-05-26 10:11:05 +0000 | [diff] [blame] | 944 | } |
| 945 | if( rc==SQLITE_OK && N==P3_DYNAMIC ){ |
| 946 | pColName->flags = (pColName->flags&(~MEM_Static))|MEM_Dyn; |
danielk1977 | d812336 | 2004-06-12 09:25:12 +0000 | [diff] [blame] | 947 | pColName->xDel = 0; |
danielk1977 | 3cf8606 | 2004-05-26 10:11:05 +0000 | [diff] [blame] | 948 | } |
| 949 | return rc; |
| 950 | } |
| 951 | |
danielk1977 | 13adf8a | 2004-06-03 16:08:41 +0000 | [diff] [blame] | 952 | /* |
| 953 | ** A read or write transaction may or may not be active on database handle |
| 954 | ** db. If a transaction is active, commit it. If there is a |
| 955 | ** write-transaction spanning more than one database file, this routine |
| 956 | ** takes care of the master journal trickery. |
| 957 | */ |
drh | 9bb575f | 2004-09-06 17:24:11 +0000 | [diff] [blame] | 958 | static int vdbeCommit(sqlite3 *db){ |
danielk1977 | 13adf8a | 2004-06-03 16:08:41 +0000 | [diff] [blame] | 959 | int i; |
| 960 | int nTrans = 0; /* Number of databases with an active write-transaction */ |
| 961 | int rc = SQLITE_OK; |
| 962 | int needXcommit = 0; |
| 963 | |
| 964 | for(i=0; i<db->nDb; i++){ |
| 965 | Btree *pBt = db->aDb[i].pBt; |
| 966 | if( pBt && sqlite3BtreeIsInTrans(pBt) ){ |
| 967 | needXcommit = 1; |
| 968 | if( i!=1 ) nTrans++; |
| 969 | } |
| 970 | } |
| 971 | |
| 972 | /* If there are any write-transactions at all, invoke the commit hook */ |
| 973 | if( needXcommit && db->xCommitCallback ){ |
drh | 92f02c3 | 2004-09-02 14:57:08 +0000 | [diff] [blame] | 974 | sqlite3SafetyOff(db); |
| 975 | rc = db->xCommitCallback(db->pCommitArg); |
| 976 | sqlite3SafetyOn(db); |
| 977 | if( rc ){ |
danielk1977 | 13adf8a | 2004-06-03 16:08:41 +0000 | [diff] [blame] | 978 | return SQLITE_CONSTRAINT; |
| 979 | } |
| 980 | } |
| 981 | |
danielk1977 | 40b38dc | 2004-06-26 08:38:24 +0000 | [diff] [blame] | 982 | /* The simple case - no more than one database file (not counting the |
| 983 | ** TEMP database) has a transaction active. There is no need for the |
drh | 2ac3ee9 | 2004-06-07 16:27:46 +0000 | [diff] [blame] | 984 | ** master-journal. |
drh | c9e0686 | 2004-06-09 20:03:08 +0000 | [diff] [blame] | 985 | ** |
danielk1977 | 40b38dc | 2004-06-26 08:38:24 +0000 | [diff] [blame] | 986 | ** If the return value of sqlite3BtreeGetFilename() is a zero length |
| 987 | ** string, it means the main database is :memory:. In that case we do |
| 988 | ** not support atomic multi-file commits, so use the simple case then |
drh | c9e0686 | 2004-06-09 20:03:08 +0000 | [diff] [blame] | 989 | ** too. |
danielk1977 | 13adf8a | 2004-06-03 16:08:41 +0000 | [diff] [blame] | 990 | */ |
danielk1977 | 40b38dc | 2004-06-26 08:38:24 +0000 | [diff] [blame] | 991 | if( 0==strlen(sqlite3BtreeGetFilename(db->aDb[0].pBt)) || nTrans<=1 ){ |
drh | 2ac3ee9 | 2004-06-07 16:27:46 +0000 | [diff] [blame] | 992 | for(i=0; rc==SQLITE_OK && i<db->nDb; i++){ |
danielk1977 | 13adf8a | 2004-06-03 16:08:41 +0000 | [diff] [blame] | 993 | Btree *pBt = db->aDb[i].pBt; |
| 994 | if( pBt ){ |
drh | 2ac3ee9 | 2004-06-07 16:27:46 +0000 | [diff] [blame] | 995 | rc = sqlite3BtreeSync(pBt, 0); |
| 996 | } |
| 997 | } |
| 998 | |
| 999 | /* Do the commit only if all databases successfully synced */ |
| 1000 | if( rc==SQLITE_OK ){ |
| 1001 | for(i=0; i<db->nDb; i++){ |
| 1002 | Btree *pBt = db->aDb[i].pBt; |
| 1003 | if( pBt ){ |
| 1004 | sqlite3BtreeCommit(pBt); |
| 1005 | } |
danielk1977 | 13adf8a | 2004-06-03 16:08:41 +0000 | [diff] [blame] | 1006 | } |
| 1007 | } |
| 1008 | } |
| 1009 | |
| 1010 | /* The complex case - There is a multi-file write-transaction active. |
| 1011 | ** This requires a master journal file to ensure the transaction is |
| 1012 | ** committed atomicly. |
| 1013 | */ |
danielk1977 | 44ee5bf | 2005-05-27 09:41:12 +0000 | [diff] [blame] | 1014 | #ifndef SQLITE_OMIT_DISKIO |
danielk1977 | 13adf8a | 2004-06-03 16:08:41 +0000 | [diff] [blame] | 1015 | else{ |
drh | 2c8997b | 2005-08-27 16:36:48 +0000 | [diff] [blame] | 1016 | int needSync = 0; |
danielk1977 | 13adf8a | 2004-06-03 16:08:41 +0000 | [diff] [blame] | 1017 | char *zMaster = 0; /* File-name for the master journal */ |
| 1018 | char const *zMainFile = sqlite3BtreeGetFilename(db->aDb[0].pBt); |
drh | 9cbe635 | 2005-11-29 03:13:21 +0000 | [diff] [blame] | 1019 | OsFile *master = 0; |
danielk1977 | 13adf8a | 2004-06-03 16:08:41 +0000 | [diff] [blame] | 1020 | |
| 1021 | /* Select a master journal file name */ |
| 1022 | do { |
drh | a6abd04 | 2004-06-09 17:37:22 +0000 | [diff] [blame] | 1023 | u32 random; |
| 1024 | sqliteFree(zMaster); |
danielk1977 | 13adf8a | 2004-06-03 16:08:41 +0000 | [diff] [blame] | 1025 | sqlite3Randomness(sizeof(random), &random); |
drh | ff13c7d | 2004-06-09 21:01:11 +0000 | [diff] [blame] | 1026 | zMaster = sqlite3MPrintf("%s-mj%08X", zMainFile, random&0x7fffffff); |
danielk1977 | 13adf8a | 2004-06-03 16:08:41 +0000 | [diff] [blame] | 1027 | if( !zMaster ){ |
| 1028 | return SQLITE_NOMEM; |
| 1029 | } |
drh | 66560ad | 2006-01-06 14:32:19 +0000 | [diff] [blame] | 1030 | }while( sqlite3OsFileExists(zMaster) ); |
danielk1977 | 13adf8a | 2004-06-03 16:08:41 +0000 | [diff] [blame] | 1031 | |
| 1032 | /* Open the master journal. */ |
drh | 66560ad | 2006-01-06 14:32:19 +0000 | [diff] [blame] | 1033 | rc = sqlite3OsOpenExclusive(zMaster, &master, 0); |
danielk1977 | 13adf8a | 2004-06-03 16:08:41 +0000 | [diff] [blame] | 1034 | if( rc!=SQLITE_OK ){ |
| 1035 | sqliteFree(zMaster); |
| 1036 | return rc; |
| 1037 | } |
| 1038 | |
| 1039 | /* Write the name of each database file in the transaction into the new |
| 1040 | ** master journal file. If an error occurs at this point close |
| 1041 | ** and delete the master journal file. All the individual journal files |
| 1042 | ** still have 'null' as the master journal pointer, so they will roll |
danielk1977 | aca790a | 2005-01-13 11:07:52 +0000 | [diff] [blame] | 1043 | ** back independently if a failure occurs. |
danielk1977 | 13adf8a | 2004-06-03 16:08:41 +0000 | [diff] [blame] | 1044 | */ |
| 1045 | for(i=0; i<db->nDb; i++){ |
| 1046 | Btree *pBt = db->aDb[i].pBt; |
drh | c9e0686 | 2004-06-09 20:03:08 +0000 | [diff] [blame] | 1047 | if( i==1 ) continue; /* Ignore the TEMP database */ |
danielk1977 | 13adf8a | 2004-06-03 16:08:41 +0000 | [diff] [blame] | 1048 | if( pBt && sqlite3BtreeIsInTrans(pBt) ){ |
danielk1977 | 5865e3d | 2004-06-14 06:03:57 +0000 | [diff] [blame] | 1049 | char const *zFile = sqlite3BtreeGetJournalname(pBt); |
drh | c9e0686 | 2004-06-09 20:03:08 +0000 | [diff] [blame] | 1050 | if( zFile[0]==0 ) continue; /* Ignore :memory: databases */ |
drh | 2c8997b | 2005-08-27 16:36:48 +0000 | [diff] [blame] | 1051 | if( !needSync && !sqlite3BtreeSyncDisabled(pBt) ){ |
| 1052 | needSync = 1; |
| 1053 | } |
drh | 054889e | 2005-11-30 03:20:31 +0000 | [diff] [blame] | 1054 | rc = sqlite3OsWrite(master, zFile, strlen(zFile)+1); |
danielk1977 | 13adf8a | 2004-06-03 16:08:41 +0000 | [diff] [blame] | 1055 | if( rc!=SQLITE_OK ){ |
drh | 054889e | 2005-11-30 03:20:31 +0000 | [diff] [blame] | 1056 | sqlite3OsClose(&master); |
drh | 66560ad | 2006-01-06 14:32:19 +0000 | [diff] [blame] | 1057 | sqlite3OsDelete(zMaster); |
danielk1977 | 13adf8a | 2004-06-03 16:08:41 +0000 | [diff] [blame] | 1058 | sqliteFree(zMaster); |
| 1059 | return rc; |
| 1060 | } |
| 1061 | } |
| 1062 | } |
| 1063 | |
danielk1977 | 13adf8a | 2004-06-03 16:08:41 +0000 | [diff] [blame] | 1064 | |
danielk1977 | 5865e3d | 2004-06-14 06:03:57 +0000 | [diff] [blame] | 1065 | /* Sync the master journal file. Before doing this, open the directory |
| 1066 | ** the master journal file is store in so that it gets synced too. |
| 1067 | */ |
| 1068 | zMainFile = sqlite3BtreeGetDirname(db->aDb[0].pBt); |
drh | 054889e | 2005-11-30 03:20:31 +0000 | [diff] [blame] | 1069 | rc = sqlite3OsOpenDirectory(master, zMainFile); |
drh | eb796a7 | 2005-09-08 12:38:41 +0000 | [diff] [blame] | 1070 | if( rc!=SQLITE_OK || |
drh | 054889e | 2005-11-30 03:20:31 +0000 | [diff] [blame] | 1071 | (needSync && (rc=sqlite3OsSync(master,0))!=SQLITE_OK) ){ |
| 1072 | sqlite3OsClose(&master); |
drh | 66560ad | 2006-01-06 14:32:19 +0000 | [diff] [blame] | 1073 | sqlite3OsDelete(zMaster); |
danielk1977 | 5865e3d | 2004-06-14 06:03:57 +0000 | [diff] [blame] | 1074 | sqliteFree(zMaster); |
| 1075 | return rc; |
| 1076 | } |
drh | c9e0686 | 2004-06-09 20:03:08 +0000 | [diff] [blame] | 1077 | |
danielk1977 | 13adf8a | 2004-06-03 16:08:41 +0000 | [diff] [blame] | 1078 | /* Sync all the db files involved in the transaction. The same call |
| 1079 | ** sets the master journal pointer in each individual journal. If |
| 1080 | ** an error occurs here, do not delete the master journal file. |
| 1081 | ** |
| 1082 | ** If the error occurs during the first call to sqlite3BtreeSync(), |
| 1083 | ** then there is a chance that the master journal file will be |
| 1084 | ** orphaned. But we cannot delete it, in case the master journal |
| 1085 | ** file name was written into the journal file before the failure |
| 1086 | ** occured. |
| 1087 | */ |
| 1088 | for(i=0; i<db->nDb; i++){ |
| 1089 | Btree *pBt = db->aDb[i].pBt; |
| 1090 | if( pBt && sqlite3BtreeIsInTrans(pBt) ){ |
| 1091 | rc = sqlite3BtreeSync(pBt, zMaster); |
| 1092 | if( rc!=SQLITE_OK ){ |
drh | 054889e | 2005-11-30 03:20:31 +0000 | [diff] [blame] | 1093 | sqlite3OsClose(&master); |
danielk1977 | 13adf8a | 2004-06-03 16:08:41 +0000 | [diff] [blame] | 1094 | sqliteFree(zMaster); |
| 1095 | return rc; |
| 1096 | } |
| 1097 | } |
| 1098 | } |
drh | 054889e | 2005-11-30 03:20:31 +0000 | [diff] [blame] | 1099 | sqlite3OsClose(&master); |
danielk1977 | 13adf8a | 2004-06-03 16:08:41 +0000 | [diff] [blame] | 1100 | |
danielk1977 | 962398d | 2004-06-14 09:35:16 +0000 | [diff] [blame] | 1101 | /* Delete the master journal file. This commits the transaction. After |
| 1102 | ** doing this the directory is synced again before any individual |
| 1103 | ** transaction files are deleted. |
| 1104 | */ |
drh | 66560ad | 2006-01-06 14:32:19 +0000 | [diff] [blame] | 1105 | rc = sqlite3OsDelete(zMaster); |
danielk1977 | 13adf8a | 2004-06-03 16:08:41 +0000 | [diff] [blame] | 1106 | assert( rc==SQLITE_OK ); |
danielk1977 | 3fe83ac | 2004-06-14 09:41:17 +0000 | [diff] [blame] | 1107 | sqliteFree(zMaster); |
| 1108 | zMaster = 0; |
drh | 66560ad | 2006-01-06 14:32:19 +0000 | [diff] [blame] | 1109 | rc = sqlite3OsSyncDirectory(zMainFile); |
danielk1977 | 962398d | 2004-06-14 09:35:16 +0000 | [diff] [blame] | 1110 | if( rc!=SQLITE_OK ){ |
| 1111 | /* This is not good. The master journal file has been deleted, but |
| 1112 | ** the directory sync failed. There is no completely safe course of |
| 1113 | ** action from here. The individual journals contain the name of the |
| 1114 | ** master journal file, but there is no way of knowing if that |
| 1115 | ** master journal exists now or if it will exist after the operating |
| 1116 | ** system crash that may follow the fsync() failure. |
| 1117 | */ |
danielk1977 | 962398d | 2004-06-14 09:35:16 +0000 | [diff] [blame] | 1118 | return rc; |
| 1119 | } |
danielk1977 | 13adf8a | 2004-06-03 16:08:41 +0000 | [diff] [blame] | 1120 | |
| 1121 | /* All files and directories have already been synced, so the following |
| 1122 | ** calls to sqlite3BtreeCommit() are only closing files and deleting |
| 1123 | ** journals. If something goes wrong while this is happening we don't |
danielk1977 | 962398d | 2004-06-14 09:35:16 +0000 | [diff] [blame] | 1124 | ** really care. The integrity of the transaction is already guaranteed, |
danielk1977 | 13adf8a | 2004-06-03 16:08:41 +0000 | [diff] [blame] | 1125 | ** but some stray 'cold' journals may be lying around. Returning an |
| 1126 | ** error code won't help matters. |
| 1127 | */ |
| 1128 | for(i=0; i<db->nDb; i++){ |
| 1129 | Btree *pBt = db->aDb[i].pBt; |
| 1130 | if( pBt ){ |
| 1131 | sqlite3BtreeCommit(pBt); |
| 1132 | } |
| 1133 | } |
| 1134 | } |
danielk1977 | 44ee5bf | 2005-05-27 09:41:12 +0000 | [diff] [blame] | 1135 | #endif |
danielk1977 | 026d270 | 2004-06-14 13:14:59 +0000 | [diff] [blame] | 1136 | |
drh | 2ac3ee9 | 2004-06-07 16:27:46 +0000 | [diff] [blame] | 1137 | return rc; |
danielk1977 | 13adf8a | 2004-06-03 16:08:41 +0000 | [diff] [blame] | 1138 | } |
| 1139 | |
drh | 91b48aa | 2004-06-30 11:14:18 +0000 | [diff] [blame] | 1140 | /* |
| 1141 | ** Find every active VM other than pVdbe and change its status to |
drh | 376deb1 | 2004-06-30 11:41:55 +0000 | [diff] [blame] | 1142 | ** aborted. This happens when one VM causes a rollback due to an |
| 1143 | ** ON CONFLICT ROLLBACK clause (for example). The other VMs must be |
| 1144 | ** aborted so that they do not have data rolled out from underneath |
| 1145 | ** them leading to a segfault. |
drh | 91b48aa | 2004-06-30 11:14:18 +0000 | [diff] [blame] | 1146 | */ |
danielk1977 | 8d34dfd | 2006-01-24 16:37:57 +0000 | [diff] [blame] | 1147 | void sqlite3AbortOtherActiveVdbes(sqlite3 *db, Vdbe *pExcept){ |
drh | 91b48aa | 2004-06-30 11:14:18 +0000 | [diff] [blame] | 1148 | Vdbe *pOther; |
danielk1977 | 8d34dfd | 2006-01-24 16:37:57 +0000 | [diff] [blame] | 1149 | for(pOther=db->pVdbe; pOther; pOther=pOther->pNext){ |
| 1150 | if( pOther==pExcept ) continue; |
drh | 91b48aa | 2004-06-30 11:14:18 +0000 | [diff] [blame] | 1151 | if( pOther->magic!=VDBE_MAGIC_RUN || pOther->pc<0 ) continue; |
| 1152 | closeAllCursors(pOther); |
| 1153 | pOther->aborted = 1; |
| 1154 | } |
| 1155 | } |
| 1156 | |
danielk1977 | 1d850a7 | 2004-05-31 08:26:49 +0000 | [diff] [blame] | 1157 | /* |
| 1158 | ** This routine checks that the sqlite3.activeVdbeCnt count variable |
| 1159 | ** matches the number of vdbe's in the list sqlite3.pVdbe that are |
| 1160 | ** currently active. An assertion fails if the two counts do not match. |
drh | 92f02c3 | 2004-09-02 14:57:08 +0000 | [diff] [blame] | 1161 | ** This is an internal self-check only - it is not an essential processing |
| 1162 | ** step. |
danielk1977 | 1d850a7 | 2004-05-31 08:26:49 +0000 | [diff] [blame] | 1163 | ** |
| 1164 | ** This is a no-op if NDEBUG is defined. |
| 1165 | */ |
| 1166 | #ifndef NDEBUG |
drh | 9bb575f | 2004-09-06 17:24:11 +0000 | [diff] [blame] | 1167 | static void checkActiveVdbeCnt(sqlite3 *db){ |
danielk1977 | 1d850a7 | 2004-05-31 08:26:49 +0000 | [diff] [blame] | 1168 | Vdbe *p; |
| 1169 | int cnt = 0; |
danielk1977 | 1d850a7 | 2004-05-31 08:26:49 +0000 | [diff] [blame] | 1170 | p = db->pVdbe; |
| 1171 | while( p ){ |
drh | 92f02c3 | 2004-09-02 14:57:08 +0000 | [diff] [blame] | 1172 | if( p->magic==VDBE_MAGIC_RUN && p->pc>=0 ){ |
danielk1977 | 1d850a7 | 2004-05-31 08:26:49 +0000 | [diff] [blame] | 1173 | cnt++; |
| 1174 | } |
| 1175 | p = p->pNext; |
| 1176 | } |
danielk1977 | 1d850a7 | 2004-05-31 08:26:49 +0000 | [diff] [blame] | 1177 | assert( cnt==db->activeVdbeCnt ); |
| 1178 | } |
| 1179 | #else |
| 1180 | #define checkActiveVdbeCnt(x) |
| 1181 | #endif |
| 1182 | |
danielk1977 | 3cf8606 | 2004-05-26 10:11:05 +0000 | [diff] [blame] | 1183 | /* |
drh | 92f02c3 | 2004-09-02 14:57:08 +0000 | [diff] [blame] | 1184 | ** This routine is called the when a VDBE tries to halt. If the VDBE |
| 1185 | ** has made changes and is in autocommit mode, then commit those |
| 1186 | ** changes. If a rollback is needed, then do the rollback. |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 1187 | ** |
drh | 92f02c3 | 2004-09-02 14:57:08 +0000 | [diff] [blame] | 1188 | ** This routine is the only way to move the state of a VM from |
| 1189 | ** SQLITE_MAGIC_RUN to SQLITE_MAGIC_HALT. |
| 1190 | ** |
| 1191 | ** Return an error code. If the commit could not complete because of |
| 1192 | ** lock contention, return SQLITE_BUSY. If SQLITE_BUSY is returned, it |
| 1193 | ** means the close did not happen and needs to be repeated. |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 1194 | */ |
drh | 92f02c3 | 2004-09-02 14:57:08 +0000 | [diff] [blame] | 1195 | int sqlite3VdbeHalt(Vdbe *p){ |
drh | 9bb575f | 2004-09-06 17:24:11 +0000 | [diff] [blame] | 1196 | sqlite3 *db = p->db; |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 1197 | int i; |
danielk1977 | 1d850a7 | 2004-05-31 08:26:49 +0000 | [diff] [blame] | 1198 | int (*xFunc)(Btree *pBt) = 0; /* Function to call on each btree backend */ |
danielk1977 | 07cb560 | 2006-01-20 10:55:05 +0000 | [diff] [blame] | 1199 | int isSpecialError; /* Set to true if SQLITE_NOMEM or IOERR */ |
| 1200 | |
| 1201 | /* This function contains the logic that determines if a statement or |
| 1202 | ** transaction will be committed or rolled back as a result of the |
| 1203 | ** execution of this virtual machine. |
| 1204 | ** |
| 1205 | ** Special errors: |
| 1206 | ** |
| 1207 | ** If an SQLITE_NOMEM error has occured in a statement that writes to |
| 1208 | ** the database, then either a statement or transaction must be rolled |
| 1209 | ** back to ensure the tree-structures are in a consistent state. A |
| 1210 | ** statement transaction is rolled back if one is open, otherwise the |
| 1211 | ** entire transaction must be rolled back. |
| 1212 | ** |
| 1213 | ** If an SQLITE_IOERR error has occured in a statement that writes to |
| 1214 | ** the database, then the entire transaction must be rolled back. The |
| 1215 | ** I/O error may have caused garbage to be written to the journal |
| 1216 | ** file. Were the transaction to continue and eventually be rolled |
| 1217 | ** back that garbage might end up in the database file. |
| 1218 | ** |
| 1219 | ** In both of the above cases, the Vdbe.errorAction variable is |
| 1220 | ** ignored. If the sqlite3.autoCommit flag is false and a transaction |
| 1221 | ** is rolled back, it will be set to true. |
| 1222 | ** |
| 1223 | ** Other errors: |
| 1224 | ** |
| 1225 | ** No error: |
| 1226 | ** |
| 1227 | */ |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 1228 | |
danielk1977 | 9e12800 | 2006-01-18 16:51:35 +0000 | [diff] [blame] | 1229 | if( sqlite3MallocFailed() ){ |
danielk1977 | 261919c | 2005-12-06 12:52:59 +0000 | [diff] [blame] | 1230 | p->rc = SQLITE_NOMEM; |
| 1231 | } |
drh | 92f02c3 | 2004-09-02 14:57:08 +0000 | [diff] [blame] | 1232 | if( p->magic!=VDBE_MAGIC_RUN ){ |
| 1233 | /* Already halted. Nothing to do. */ |
| 1234 | assert( p->magic==VDBE_MAGIC_HALT ); |
| 1235 | return SQLITE_OK; |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 1236 | } |
drh | 92f02c3 | 2004-09-02 14:57:08 +0000 | [diff] [blame] | 1237 | closeAllCursors(p); |
danielk1977 | 1d850a7 | 2004-05-31 08:26:49 +0000 | [diff] [blame] | 1238 | checkActiveVdbeCnt(db); |
danielk1977 | 261919c | 2005-12-06 12:52:59 +0000 | [diff] [blame] | 1239 | |
danielk1977 | 07cb560 | 2006-01-20 10:55:05 +0000 | [diff] [blame] | 1240 | /* No commit or rollback needed if the program never started */ |
| 1241 | if( p->pc>=0 ){ |
danielk1977 | 261919c | 2005-12-06 12:52:59 +0000 | [diff] [blame] | 1242 | |
danielk1977 | 07cb560 | 2006-01-20 10:55:05 +0000 | [diff] [blame] | 1243 | /* Check for one of the special errors - SQLITE_NOMEM or SQLITE_IOERR */ |
| 1244 | isSpecialError = ((p->rc==SQLITE_NOMEM || p->rc==SQLITE_IOERR)?1:0); |
| 1245 | if( isSpecialError ){ |
danielk1977 | 261919c | 2005-12-06 12:52:59 +0000 | [diff] [blame] | 1246 | /* This loop does static analysis of the query to see which of the |
| 1247 | ** following three categories it falls into: |
| 1248 | ** |
| 1249 | ** Read-only |
danielk1977 | 07cb560 | 2006-01-20 10:55:05 +0000 | [diff] [blame] | 1250 | ** Query with statement journal |
| 1251 | ** Query without statement journal |
danielk1977 | 261919c | 2005-12-06 12:52:59 +0000 | [diff] [blame] | 1252 | ** |
| 1253 | ** We could do something more elegant than this static analysis (i.e. |
| 1254 | ** store the type of query as part of the compliation phase), but |
danielk1977 | 07cb560 | 2006-01-20 10:55:05 +0000 | [diff] [blame] | 1255 | ** handling malloc() or IO failure is a fairly obscure edge case so |
| 1256 | ** this is probably easier. Todo: Might be an opportunity to reduce |
| 1257 | ** code size a very small amount though... |
danielk1977 | 261919c | 2005-12-06 12:52:59 +0000 | [diff] [blame] | 1258 | */ |
| 1259 | int isReadOnly = 1; |
| 1260 | int isStatement = 0; |
| 1261 | assert(p->aOp || p->nOp==0); |
| 1262 | for(i=0; i<p->nOp; i++){ |
| 1263 | switch( p->aOp[i].opcode ){ |
| 1264 | case OP_Transaction: |
| 1265 | isReadOnly = 0; |
| 1266 | break; |
| 1267 | case OP_Statement: |
| 1268 | isStatement = 1; |
| 1269 | break; |
| 1270 | } |
| 1271 | } |
danielk1977 | 07cb560 | 2006-01-20 10:55:05 +0000 | [diff] [blame] | 1272 | |
| 1273 | /* If the query was read-only, we need do no rollback at all. Otherwise, |
| 1274 | ** proceed with the special handling. |
| 1275 | */ |
| 1276 | if( !isReadOnly ){ |
| 1277 | if( p->rc==SQLITE_NOMEM && isStatement ){ |
| 1278 | xFunc = sqlite3BtreeRollbackStmt; |
| 1279 | }else{ |
| 1280 | /* We are forced to roll back the active transaction. Before doing |
| 1281 | ** so, abort any other statements this handle currently has active. |
| 1282 | */ |
danielk1977 | 8d34dfd | 2006-01-24 16:37:57 +0000 | [diff] [blame] | 1283 | sqlite3AbortOtherActiveVdbes(db, p); |
danielk1977 | 97a227c | 2006-01-20 16:32:04 +0000 | [diff] [blame] | 1284 | sqlite3RollbackAll(db); |
danielk1977 | 07cb560 | 2006-01-20 10:55:05 +0000 | [diff] [blame] | 1285 | db->autoCommit = 1; |
| 1286 | } |
danielk1977 | 261919c | 2005-12-06 12:52:59 +0000 | [diff] [blame] | 1287 | } |
| 1288 | } |
danielk1977 | 07cb560 | 2006-01-20 10:55:05 +0000 | [diff] [blame] | 1289 | |
| 1290 | /* If the auto-commit flag is set and this is the only active vdbe, then |
| 1291 | ** we do either a commit or rollback of the current transaction. |
| 1292 | ** |
| 1293 | ** Note: This block also runs if one of the special errors handled |
| 1294 | ** above has occured. |
| 1295 | */ |
| 1296 | if( db->autoCommit && db->activeVdbeCnt==1 ){ |
| 1297 | if( p->rc==SQLITE_OK || (p->errorAction==OE_Fail && !isSpecialError) ){ |
| 1298 | /* The auto-commit flag is true, and the vdbe program was |
| 1299 | ** successful or hit an 'OR FAIL' constraint. This means a commit |
| 1300 | ** is required. |
| 1301 | */ |
| 1302 | int rc = vdbeCommit(db); |
| 1303 | if( rc==SQLITE_BUSY ){ |
| 1304 | return SQLITE_BUSY; |
| 1305 | }else if( rc!=SQLITE_OK ){ |
| 1306 | p->rc = rc; |
danielk1977 | 97a227c | 2006-01-20 16:32:04 +0000 | [diff] [blame] | 1307 | sqlite3RollbackAll(db); |
danielk1977 | 07cb560 | 2006-01-20 10:55:05 +0000 | [diff] [blame] | 1308 | }else{ |
| 1309 | sqlite3CommitInternalChanges(db); |
| 1310 | } |
| 1311 | }else{ |
danielk1977 | 97a227c | 2006-01-20 16:32:04 +0000 | [diff] [blame] | 1312 | sqlite3RollbackAll(db); |
danielk1977 | 07cb560 | 2006-01-20 10:55:05 +0000 | [diff] [blame] | 1313 | } |
| 1314 | }else if( !xFunc ){ |
| 1315 | if( p->rc==SQLITE_OK || p->errorAction==OE_Fail ){ |
| 1316 | xFunc = sqlite3BtreeCommitStmt; |
| 1317 | }else if( p->errorAction==OE_Abort ){ |
| 1318 | xFunc = sqlite3BtreeRollbackStmt; |
| 1319 | }else{ |
danielk1977 | 8d34dfd | 2006-01-24 16:37:57 +0000 | [diff] [blame] | 1320 | sqlite3AbortOtherActiveVdbes(db, p); |
danielk1977 | 97a227c | 2006-01-20 16:32:04 +0000 | [diff] [blame] | 1321 | sqlite3RollbackAll(db); |
danielk1977 | 07cb560 | 2006-01-20 10:55:05 +0000 | [diff] [blame] | 1322 | db->autoCommit = 1; |
| 1323 | } |
danielk1977 | 1d850a7 | 2004-05-31 08:26:49 +0000 | [diff] [blame] | 1324 | } |
danielk1977 | 07cb560 | 2006-01-20 10:55:05 +0000 | [diff] [blame] | 1325 | |
| 1326 | /* If xFunc is not NULL, then it is one of sqlite3BtreeRollbackStmt or |
| 1327 | ** sqlite3BtreeCommitStmt. Call it once on each backend. If an error occurs |
| 1328 | ** and the return code is still SQLITE_OK, set the return code to the new |
| 1329 | ** error value. |
| 1330 | */ |
| 1331 | assert(!xFunc || |
| 1332 | xFunc==sqlite3BtreeCommitStmt || |
| 1333 | xFunc==sqlite3BtreeRollbackStmt |
| 1334 | ); |
| 1335 | for(i=0; xFunc && i<db->nDb; i++){ |
| 1336 | int rc; |
| 1337 | Btree *pBt = db->aDb[i].pBt; |
| 1338 | if( pBt ){ |
| 1339 | rc = xFunc(pBt); |
danielk1977 | 8a7aea3 | 2006-01-23 15:25:48 +0000 | [diff] [blame] | 1340 | if( rc && (p->rc==SQLITE_OK || p->rc==SQLITE_CONSTRAINT) ){ |
| 1341 | p->rc = rc; |
| 1342 | sqlite3SetString(&p->zErrMsg, 0); |
| 1343 | } |
danielk1977 | 07cb560 | 2006-01-20 10:55:05 +0000 | [diff] [blame] | 1344 | } |
danielk1977 | 77d83ba | 2004-05-31 10:08:14 +0000 | [diff] [blame] | 1345 | } |
danielk1977 | 07cb560 | 2006-01-20 10:55:05 +0000 | [diff] [blame] | 1346 | |
| 1347 | /* If this was an INSERT, UPDATE or DELETE and the statement was committed, |
| 1348 | ** set the change counter. |
| 1349 | */ |
| 1350 | if( p->changeCntOn && p->pc>=0 ){ |
| 1351 | if( !xFunc || xFunc==sqlite3BtreeCommitStmt ){ |
| 1352 | sqlite3VdbeSetChanges(db, p->nChange); |
| 1353 | }else{ |
| 1354 | sqlite3VdbeSetChanges(db, 0); |
| 1355 | } |
| 1356 | p->nChange = 0; |
danielk1977 | b28af71 | 2004-06-21 06:50:26 +0000 | [diff] [blame] | 1357 | } |
danielk1977 | 07cb560 | 2006-01-20 10:55:05 +0000 | [diff] [blame] | 1358 | |
| 1359 | /* Rollback or commit any schema changes that occurred. */ |
| 1360 | if( p->rc!=SQLITE_OK && db->flags&SQLITE_InternChanges ){ |
| 1361 | sqlite3ResetInternalSchema(db, 0); |
| 1362 | db->flags = (db->flags | SQLITE_InternChanges); |
| 1363 | } |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 1364 | } |
danielk1977 | 1d850a7 | 2004-05-31 08:26:49 +0000 | [diff] [blame] | 1365 | |
drh | 92f02c3 | 2004-09-02 14:57:08 +0000 | [diff] [blame] | 1366 | /* We have successfully halted and closed the VM. Record this fact. */ |
| 1367 | if( p->pc>=0 ){ |
danielk1977 | 1d850a7 | 2004-05-31 08:26:49 +0000 | [diff] [blame] | 1368 | db->activeVdbeCnt--; |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 1369 | } |
drh | 92f02c3 | 2004-09-02 14:57:08 +0000 | [diff] [blame] | 1370 | p->magic = VDBE_MAGIC_HALT; |
| 1371 | checkActiveVdbeCnt(db); |
danielk1977 | 1d850a7 | 2004-05-31 08:26:49 +0000 | [diff] [blame] | 1372 | |
drh | 92f02c3 | 2004-09-02 14:57:08 +0000 | [diff] [blame] | 1373 | return SQLITE_OK; |
| 1374 | } |
| 1375 | |
| 1376 | /* |
| 1377 | ** Clean up a VDBE after execution but do not delete the VDBE just yet. |
| 1378 | ** Write any error messages into *pzErrMsg. Return the result code. |
| 1379 | ** |
| 1380 | ** After this routine is run, the VDBE should be ready to be executed |
| 1381 | ** again. |
| 1382 | ** |
| 1383 | ** To look at it another way, this routine resets the state of the |
| 1384 | ** virtual machine from VDBE_MAGIC_RUN or VDBE_MAGIC_HALT back to |
| 1385 | ** VDBE_MAGIC_INIT. |
| 1386 | */ |
| 1387 | int sqlite3VdbeReset(Vdbe *p){ |
| 1388 | if( p->magic!=VDBE_MAGIC_RUN && p->magic!=VDBE_MAGIC_HALT ){ |
drh | c60d044 | 2004-09-30 13:43:13 +0000 | [diff] [blame] | 1389 | sqlite3Error(p->db, SQLITE_MISUSE, 0); |
drh | 92f02c3 | 2004-09-02 14:57:08 +0000 | [diff] [blame] | 1390 | return SQLITE_MISUSE; |
| 1391 | } |
| 1392 | |
| 1393 | /* If the VM did not run to completion or if it encountered an |
| 1394 | ** error, then it might not have been halted properly. So halt |
| 1395 | ** it now. |
| 1396 | */ |
| 1397 | sqlite3VdbeHalt(p); |
| 1398 | |
drh | fb7e765 | 2005-01-24 00:28:42 +0000 | [diff] [blame] | 1399 | /* If the VDBE has be run even partially, then transfer the error code |
| 1400 | ** and error message from the VDBE into the main database structure. But |
| 1401 | ** if the VDBE has just been set to run but has not actually executed any |
| 1402 | ** instructions yet, leave the main database error information unchanged. |
drh | 92f02c3 | 2004-09-02 14:57:08 +0000 | [diff] [blame] | 1403 | */ |
drh | fb7e765 | 2005-01-24 00:28:42 +0000 | [diff] [blame] | 1404 | if( p->pc>=0 ){ |
| 1405 | if( p->zErrMsg ){ |
danielk1977 | 97a227c | 2006-01-20 16:32:04 +0000 | [diff] [blame] | 1406 | sqlite3* db = p->db; |
| 1407 | sqlite3ValueSetStr(db->pErr, -1, p->zErrMsg, SQLITE_UTF8, sqlite3FreeX); |
| 1408 | db->errCode = p->rc; |
drh | fb7e765 | 2005-01-24 00:28:42 +0000 | [diff] [blame] | 1409 | p->zErrMsg = 0; |
| 1410 | }else if( p->rc ){ |
| 1411 | sqlite3Error(p->db, p->rc, 0); |
| 1412 | }else{ |
| 1413 | sqlite3Error(p->db, SQLITE_OK, 0); |
| 1414 | } |
danielk1977 | a21c6b6 | 2005-01-24 10:25:59 +0000 | [diff] [blame] | 1415 | }else if( p->rc && p->expired ){ |
| 1416 | /* The expired flag was set on the VDBE before the first call |
| 1417 | ** to sqlite3_step(). For consistency (since sqlite3_step() was |
| 1418 | ** called), set the database error in this case as well. |
| 1419 | */ |
| 1420 | sqlite3Error(p->db, p->rc, 0); |
drh | 92f02c3 | 2004-09-02 14:57:08 +0000 | [diff] [blame] | 1421 | } |
| 1422 | |
| 1423 | /* Reclaim all memory used by the VDBE |
| 1424 | */ |
| 1425 | Cleanup(p); |
| 1426 | |
| 1427 | /* Save profiling information from this VDBE run. |
| 1428 | */ |
danielk1977 | 261919c | 2005-12-06 12:52:59 +0000 | [diff] [blame] | 1429 | assert( p->pTos<&p->aStack[p->pc<0?0:p->pc] || !p->aStack ); |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 1430 | #ifdef VDBE_PROFILE |
| 1431 | { |
| 1432 | FILE *out = fopen("vdbe_profile.out", "a"); |
| 1433 | if( out ){ |
| 1434 | int i; |
| 1435 | fprintf(out, "---- "); |
| 1436 | for(i=0; i<p->nOp; i++){ |
| 1437 | fprintf(out, "%02x", p->aOp[i].opcode); |
| 1438 | } |
| 1439 | fprintf(out, "\n"); |
| 1440 | for(i=0; i<p->nOp; i++){ |
| 1441 | fprintf(out, "%6d %10lld %8lld ", |
| 1442 | p->aOp[i].cnt, |
| 1443 | p->aOp[i].cycles, |
| 1444 | p->aOp[i].cnt>0 ? p->aOp[i].cycles/p->aOp[i].cnt : 0 |
| 1445 | ); |
danielk1977 | 4adee20 | 2004-05-08 08:23:19 +0000 | [diff] [blame] | 1446 | sqlite3VdbePrintOp(out, i, &p->aOp[i]); |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 1447 | } |
| 1448 | fclose(out); |
| 1449 | } |
| 1450 | } |
| 1451 | #endif |
| 1452 | p->magic = VDBE_MAGIC_INIT; |
drh | 91b48aa | 2004-06-30 11:14:18 +0000 | [diff] [blame] | 1453 | p->aborted = 0; |
drh | 178286b | 2005-01-23 13:14:55 +0000 | [diff] [blame] | 1454 | if( p->rc==SQLITE_SCHEMA ){ |
| 1455 | sqlite3ResetInternalSchema(p->db, 0); |
| 1456 | } |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 1457 | return p->rc; |
| 1458 | } |
drh | 92f02c3 | 2004-09-02 14:57:08 +0000 | [diff] [blame] | 1459 | |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 1460 | /* |
| 1461 | ** Clean up and delete a VDBE after execution. Return an integer which is |
| 1462 | ** the result code. Write any error message text into *pzErrMsg. |
| 1463 | */ |
danielk1977 | 9e6db7d | 2004-06-21 08:18:51 +0000 | [diff] [blame] | 1464 | int sqlite3VdbeFinalize(Vdbe *p){ |
danielk1977 | b5548a8 | 2004-06-26 13:51:33 +0000 | [diff] [blame] | 1465 | int rc = SQLITE_OK; |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 1466 | |
danielk1977 | b5548a8 | 2004-06-26 13:51:33 +0000 | [diff] [blame] | 1467 | if( p->magic==VDBE_MAGIC_RUN || p->magic==VDBE_MAGIC_HALT ){ |
| 1468 | rc = sqlite3VdbeReset(p); |
| 1469 | }else if( p->magic!=VDBE_MAGIC_INIT ){ |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 1470 | return SQLITE_MISUSE; |
| 1471 | } |
danielk1977 | 4adee20 | 2004-05-08 08:23:19 +0000 | [diff] [blame] | 1472 | sqlite3VdbeDelete(p); |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 1473 | return rc; |
| 1474 | } |
| 1475 | |
| 1476 | /* |
drh | f92c7ff | 2004-06-19 15:40:23 +0000 | [diff] [blame] | 1477 | ** Call the destructor for each auxdata entry in pVdbeFunc for which |
danielk1977 | e159fdf | 2004-06-21 10:45:06 +0000 | [diff] [blame] | 1478 | ** the corresponding bit in mask is clear. Auxdata entries beyond 31 |
drh | f92c7ff | 2004-06-19 15:40:23 +0000 | [diff] [blame] | 1479 | ** are always destroyed. To destroy all auxdata entries, call this |
danielk1977 | e159fdf | 2004-06-21 10:45:06 +0000 | [diff] [blame] | 1480 | ** routine with mask==0. |
drh | f92c7ff | 2004-06-19 15:40:23 +0000 | [diff] [blame] | 1481 | */ |
| 1482 | void sqlite3VdbeDeleteAuxData(VdbeFunc *pVdbeFunc, int mask){ |
| 1483 | int i; |
| 1484 | for(i=0; i<pVdbeFunc->nAux; i++){ |
| 1485 | struct AuxData *pAux = &pVdbeFunc->apAux[i]; |
| 1486 | if( (i>31 || !(mask&(1<<i))) && pAux->pAux ){ |
| 1487 | if( pAux->xDelete ){ |
| 1488 | pAux->xDelete(pAux->pAux); |
| 1489 | } |
| 1490 | pAux->pAux = 0; |
| 1491 | } |
| 1492 | } |
| 1493 | } |
| 1494 | |
| 1495 | /* |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 1496 | ** Delete an entire VDBE. |
| 1497 | */ |
danielk1977 | 4adee20 | 2004-05-08 08:23:19 +0000 | [diff] [blame] | 1498 | void sqlite3VdbeDelete(Vdbe *p){ |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 1499 | int i; |
| 1500 | if( p==0 ) return; |
| 1501 | Cleanup(p); |
| 1502 | if( p->pPrev ){ |
| 1503 | p->pPrev->pNext = p->pNext; |
| 1504 | }else{ |
| 1505 | assert( p->db->pVdbe==p ); |
| 1506 | p->db->pVdbe = p->pNext; |
| 1507 | } |
| 1508 | if( p->pNext ){ |
| 1509 | p->pNext->pPrev = p->pPrev; |
| 1510 | } |
drh | 76ff3a0 | 2004-09-24 22:32:30 +0000 | [diff] [blame] | 1511 | if( p->aOp ){ |
| 1512 | for(i=0; i<p->nOp; i++){ |
| 1513 | Op *pOp = &p->aOp[i]; |
drh | b38ad99 | 2005-09-16 00:27:01 +0000 | [diff] [blame] | 1514 | freeP3(pOp->p3type, pOp->p3); |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 1515 | } |
drh | 76ff3a0 | 2004-09-24 22:32:30 +0000 | [diff] [blame] | 1516 | sqliteFree(p->aOp); |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 1517 | } |
drh | 76ff3a0 | 2004-09-24 22:32:30 +0000 | [diff] [blame] | 1518 | releaseMemArray(p->aVar, p->nVar); |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 1519 | sqliteFree(p->aLabel); |
| 1520 | sqliteFree(p->aStack); |
danielk1977 | 955de52 | 2006-02-10 02:27:42 +0000 | [diff] [blame] | 1521 | releaseMemArray(p->aColName, p->nResColumn*COLNAME_N); |
drh | 76ff3a0 | 2004-09-24 22:32:30 +0000 | [diff] [blame] | 1522 | sqliteFree(p->aColName); |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 1523 | p->magic = VDBE_MAGIC_DEAD; |
| 1524 | sqliteFree(p); |
| 1525 | } |
drh | a11846b | 2004-01-07 18:52:56 +0000 | [diff] [blame] | 1526 | |
| 1527 | /* |
drh | a11846b | 2004-01-07 18:52:56 +0000 | [diff] [blame] | 1528 | ** If a MoveTo operation is pending on the given cursor, then do that |
| 1529 | ** MoveTo now. Return an error code. If no MoveTo is pending, this |
| 1530 | ** routine does nothing and returns SQLITE_OK. |
| 1531 | */ |
danielk1977 | 4adee20 | 2004-05-08 08:23:19 +0000 | [diff] [blame] | 1532 | int sqlite3VdbeCursorMoveto(Cursor *p){ |
drh | a11846b | 2004-01-07 18:52:56 +0000 | [diff] [blame] | 1533 | if( p->deferredMoveto ){ |
drh | 536065a | 2005-01-26 21:55:31 +0000 | [diff] [blame] | 1534 | int res, rc; |
danielk1977 | 132872b | 2004-05-10 10:37:18 +0000 | [diff] [blame] | 1535 | extern int sqlite3_search_count; |
drh | f0863fe | 2005-06-12 21:35:51 +0000 | [diff] [blame] | 1536 | assert( p->isTable ); |
| 1537 | if( p->isTable ){ |
drh | 536065a | 2005-01-26 21:55:31 +0000 | [diff] [blame] | 1538 | rc = sqlite3BtreeMoveto(p->pCursor, 0, p->movetoTarget, &res); |
danielk1977 | 6490beb | 2004-05-11 06:17:21 +0000 | [diff] [blame] | 1539 | }else{ |
drh | 536065a | 2005-01-26 21:55:31 +0000 | [diff] [blame] | 1540 | rc = sqlite3BtreeMoveto(p->pCursor,(char*)&p->movetoTarget, |
| 1541 | sizeof(i64),&res); |
danielk1977 | 6490beb | 2004-05-11 06:17:21 +0000 | [diff] [blame] | 1542 | } |
drh | 536065a | 2005-01-26 21:55:31 +0000 | [diff] [blame] | 1543 | if( rc ) return rc; |
drh | d3d39e9 | 2004-05-20 22:16:29 +0000 | [diff] [blame] | 1544 | *p->pIncrKey = 0; |
drh | f0863fe | 2005-06-12 21:35:51 +0000 | [diff] [blame] | 1545 | p->lastRowid = keyToInt(p->movetoTarget); |
| 1546 | p->rowidIsValid = res==0; |
drh | a11846b | 2004-01-07 18:52:56 +0000 | [diff] [blame] | 1547 | if( res<0 ){ |
drh | 536065a | 2005-01-26 21:55:31 +0000 | [diff] [blame] | 1548 | rc = sqlite3BtreeNext(p->pCursor, &res); |
| 1549 | if( rc ) return rc; |
drh | a11846b | 2004-01-07 18:52:56 +0000 | [diff] [blame] | 1550 | } |
danielk1977 | 132872b | 2004-05-10 10:37:18 +0000 | [diff] [blame] | 1551 | sqlite3_search_count++; |
drh | a11846b | 2004-01-07 18:52:56 +0000 | [diff] [blame] | 1552 | p->deferredMoveto = 0; |
drh | 76873ab | 2006-01-07 18:48:26 +0000 | [diff] [blame] | 1553 | p->cacheStatus = CACHE_STALE; |
drh | a11846b | 2004-01-07 18:52:56 +0000 | [diff] [blame] | 1554 | } |
| 1555 | return SQLITE_OK; |
| 1556 | } |
danielk1977 | 4adee20 | 2004-05-08 08:23:19 +0000 | [diff] [blame] | 1557 | |
drh | ab9f7f1 | 2004-05-08 10:56:11 +0000 | [diff] [blame] | 1558 | /* |
danielk1977 | cfcdaef | 2004-05-12 07:33:33 +0000 | [diff] [blame] | 1559 | ** The following functions: |
danielk1977 | 90e4d95 | 2004-05-10 10:05:53 +0000 | [diff] [blame] | 1560 | ** |
danielk1977 | cfcdaef | 2004-05-12 07:33:33 +0000 | [diff] [blame] | 1561 | ** sqlite3VdbeSerialType() |
| 1562 | ** sqlite3VdbeSerialTypeLen() |
| 1563 | ** sqlite3VdbeSerialRead() |
danielk1977 | 90e4d95 | 2004-05-10 10:05:53 +0000 | [diff] [blame] | 1564 | ** sqlite3VdbeSerialLen() |
danielk1977 | cfcdaef | 2004-05-12 07:33:33 +0000 | [diff] [blame] | 1565 | ** sqlite3VdbeSerialWrite() |
danielk1977 | 90e4d95 | 2004-05-10 10:05:53 +0000 | [diff] [blame] | 1566 | ** |
| 1567 | ** encapsulate the code that serializes values for storage in SQLite |
danielk1977 | cfcdaef | 2004-05-12 07:33:33 +0000 | [diff] [blame] | 1568 | ** data and index records. Each serialized value consists of a |
| 1569 | ** 'serial-type' and a blob of data. The serial type is an 8-byte unsigned |
| 1570 | ** integer, stored as a varint. |
danielk1977 | 90e4d95 | 2004-05-10 10:05:53 +0000 | [diff] [blame] | 1571 | ** |
danielk1977 | cfcdaef | 2004-05-12 07:33:33 +0000 | [diff] [blame] | 1572 | ** In an SQLite index record, the serial type is stored directly before |
| 1573 | ** the blob of data that it corresponds to. In a table record, all serial |
| 1574 | ** types are stored at the start of the record, and the blobs of data at |
| 1575 | ** the end. Hence these functions allow the caller to handle the |
| 1576 | ** serial-type and data blob seperately. |
| 1577 | ** |
| 1578 | ** The following table describes the various storage classes for data: |
| 1579 | ** |
| 1580 | ** serial type bytes of data type |
danielk1977 | 90e4d95 | 2004-05-10 10:05:53 +0000 | [diff] [blame] | 1581 | ** -------------- --------------- --------------- |
drh | a19b775 | 2004-05-30 21:14:58 +0000 | [diff] [blame] | 1582 | ** 0 0 NULL |
danielk1977 | 90e4d95 | 2004-05-10 10:05:53 +0000 | [diff] [blame] | 1583 | ** 1 1 signed integer |
| 1584 | ** 2 2 signed integer |
drh | a19b775 | 2004-05-30 21:14:58 +0000 | [diff] [blame] | 1585 | ** 3 3 signed integer |
| 1586 | ** 4 4 signed integer |
| 1587 | ** 5 6 signed integer |
| 1588 | ** 6 8 signed integer |
| 1589 | ** 7 8 IEEE float |
drh | d946db0 | 2005-12-29 19:23:06 +0000 | [diff] [blame] | 1590 | ** 8 0 Integer constant 0 |
| 1591 | ** 9 0 Integer constant 1 |
| 1592 | ** 10,11 reserved for expansion |
danielk1977 | 90e4d95 | 2004-05-10 10:05:53 +0000 | [diff] [blame] | 1593 | ** N>=12 and even (N-12)/2 BLOB |
| 1594 | ** N>=13 and odd (N-13)/2 text |
| 1595 | ** |
drh | 35a5965 | 2006-01-02 18:24:40 +0000 | [diff] [blame] | 1596 | ** The 8 and 9 types were added in 3.3.0, file format 4. Prior versions |
| 1597 | ** of SQLite will not understand those serial types. |
danielk1977 | 90e4d95 | 2004-05-10 10:05:53 +0000 | [diff] [blame] | 1598 | */ |
| 1599 | |
| 1600 | /* |
danielk1977 | cfcdaef | 2004-05-12 07:33:33 +0000 | [diff] [blame] | 1601 | ** Return the serial-type for the value stored in pMem. |
danielk1977 | 192ac1d | 2004-05-10 07:17:30 +0000 | [diff] [blame] | 1602 | */ |
drh | d946db0 | 2005-12-29 19:23:06 +0000 | [diff] [blame] | 1603 | u32 sqlite3VdbeSerialType(Mem *pMem, int file_format){ |
danielk1977 | cfcdaef | 2004-05-12 07:33:33 +0000 | [diff] [blame] | 1604 | int flags = pMem->flags; |
| 1605 | |
| 1606 | if( flags&MEM_Null ){ |
drh | a19b775 | 2004-05-30 21:14:58 +0000 | [diff] [blame] | 1607 | return 0; |
danielk1977 | 90e4d95 | 2004-05-10 10:05:53 +0000 | [diff] [blame] | 1608 | } |
danielk1977 | cfcdaef | 2004-05-12 07:33:33 +0000 | [diff] [blame] | 1609 | if( flags&MEM_Int ){ |
drh | fe2093d | 2005-01-20 22:48:47 +0000 | [diff] [blame] | 1610 | /* Figure out whether to use 1, 2, 4, 6 or 8 bytes. */ |
drh | b47d45c | 2005-04-15 12:04:34 +0000 | [diff] [blame] | 1611 | # define MAX_6BYTE ((((i64)0x00001000)<<32)-1) |
danielk1977 | cfcdaef | 2004-05-12 07:33:33 +0000 | [diff] [blame] | 1612 | i64 i = pMem->i; |
drh | d946db0 | 2005-12-29 19:23:06 +0000 | [diff] [blame] | 1613 | u64 u; |
| 1614 | if( file_format>=4 && (i&1)==i ){ |
| 1615 | return 8+i; |
| 1616 | } |
| 1617 | u = i<0 ? -i : i; |
drh | 5742b63 | 2005-01-26 17:47:02 +0000 | [diff] [blame] | 1618 | if( u<=127 ) return 1; |
| 1619 | if( u<=32767 ) return 2; |
| 1620 | if( u<=8388607 ) return 3; |
| 1621 | if( u<=2147483647 ) return 4; |
| 1622 | if( u<=MAX_6BYTE ) return 5; |
drh | a19b775 | 2004-05-30 21:14:58 +0000 | [diff] [blame] | 1623 | return 6; |
danielk1977 | 90e4d95 | 2004-05-10 10:05:53 +0000 | [diff] [blame] | 1624 | } |
danielk1977 | cfcdaef | 2004-05-12 07:33:33 +0000 | [diff] [blame] | 1625 | if( flags&MEM_Real ){ |
drh | a19b775 | 2004-05-30 21:14:58 +0000 | [diff] [blame] | 1626 | return 7; |
danielk1977 | 90e4d95 | 2004-05-10 10:05:53 +0000 | [diff] [blame] | 1627 | } |
danielk1977 | cfcdaef | 2004-05-12 07:33:33 +0000 | [diff] [blame] | 1628 | if( flags&MEM_Str ){ |
danielk1977 | 93d4675 | 2004-05-23 13:30:58 +0000 | [diff] [blame] | 1629 | int n = pMem->n; |
| 1630 | assert( n>=0 ); |
danielk1977 | 93d4675 | 2004-05-23 13:30:58 +0000 | [diff] [blame] | 1631 | return ((n*2) + 13); |
danielk1977 | 90e4d95 | 2004-05-10 10:05:53 +0000 | [diff] [blame] | 1632 | } |
danielk1977 | cfcdaef | 2004-05-12 07:33:33 +0000 | [diff] [blame] | 1633 | if( flags&MEM_Blob ){ |
| 1634 | return (pMem->n*2 + 12); |
| 1635 | } |
| 1636 | return 0; |
danielk1977 | 192ac1d | 2004-05-10 07:17:30 +0000 | [diff] [blame] | 1637 | } |
| 1638 | |
| 1639 | /* |
danielk1977 | cfcdaef | 2004-05-12 07:33:33 +0000 | [diff] [blame] | 1640 | ** Return the length of the data corresponding to the supplied serial-type. |
danielk1977 | 192ac1d | 2004-05-10 07:17:30 +0000 | [diff] [blame] | 1641 | */ |
drh | 25aa1b4 | 2004-05-28 01:39:01 +0000 | [diff] [blame] | 1642 | int sqlite3VdbeSerialTypeLen(u32 serial_type){ |
drh | a19b775 | 2004-05-30 21:14:58 +0000 | [diff] [blame] | 1643 | if( serial_type>=12 ){ |
drh | 51846b5 | 2004-05-28 16:00:21 +0000 | [diff] [blame] | 1644 | return (serial_type-12)/2; |
| 1645 | }else{ |
drh | 5719628 | 2004-10-06 15:41:16 +0000 | [diff] [blame] | 1646 | static const u8 aSize[] = { 0, 1, 2, 3, 4, 6, 8, 8, 0, 0, 0, 0 }; |
drh | 51846b5 | 2004-05-28 16:00:21 +0000 | [diff] [blame] | 1647 | return aSize[serial_type]; |
| 1648 | } |
danielk1977 | 192ac1d | 2004-05-10 07:17:30 +0000 | [diff] [blame] | 1649 | } |
| 1650 | |
| 1651 | /* |
danielk1977 | cfcdaef | 2004-05-12 07:33:33 +0000 | [diff] [blame] | 1652 | ** Write the serialized data blob for the value stored in pMem into |
| 1653 | ** buf. It is assumed that the caller has allocated sufficient space. |
| 1654 | ** Return the number of bytes written. |
| 1655 | */ |
drh | d946db0 | 2005-12-29 19:23:06 +0000 | [diff] [blame] | 1656 | int sqlite3VdbeSerialPut(unsigned char *buf, Mem *pMem, int file_format){ |
| 1657 | u32 serial_type = sqlite3VdbeSerialType(pMem, file_format); |
danielk1977 | cfcdaef | 2004-05-12 07:33:33 +0000 | [diff] [blame] | 1658 | int len; |
danielk1977 | 183f9f7 | 2004-05-13 05:20:26 +0000 | [diff] [blame] | 1659 | |
drh | 1483e14 | 2004-05-21 21:12:42 +0000 | [diff] [blame] | 1660 | /* Integer and Real */ |
drh | d946db0 | 2005-12-29 19:23:06 +0000 | [diff] [blame] | 1661 | if( serial_type<=7 && serial_type>0 ){ |
drh | 1483e14 | 2004-05-21 21:12:42 +0000 | [diff] [blame] | 1662 | u64 v; |
| 1663 | int i; |
drh | a19b775 | 2004-05-30 21:14:58 +0000 | [diff] [blame] | 1664 | if( serial_type==7 ){ |
drh | 1483e14 | 2004-05-21 21:12:42 +0000 | [diff] [blame] | 1665 | v = *(u64*)&pMem->r; |
| 1666 | }else{ |
| 1667 | v = *(u64*)&pMem->i; |
danielk1977 | cfcdaef | 2004-05-12 07:33:33 +0000 | [diff] [blame] | 1668 | } |
drh | 1483e14 | 2004-05-21 21:12:42 +0000 | [diff] [blame] | 1669 | len = i = sqlite3VdbeSerialTypeLen(serial_type); |
| 1670 | while( i-- ){ |
| 1671 | buf[i] = (v&0xFF); |
| 1672 | v >>= 8; |
| 1673 | } |
| 1674 | return len; |
danielk1977 | cfcdaef | 2004-05-12 07:33:33 +0000 | [diff] [blame] | 1675 | } |
drh | d946db0 | 2005-12-29 19:23:06 +0000 | [diff] [blame] | 1676 | |
danielk1977 | cfcdaef | 2004-05-12 07:33:33 +0000 | [diff] [blame] | 1677 | /* String or blob */ |
drh | d946db0 | 2005-12-29 19:23:06 +0000 | [diff] [blame] | 1678 | if( serial_type>=12 ){ |
| 1679 | len = sqlite3VdbeSerialTypeLen(serial_type); |
| 1680 | memcpy(buf, pMem->z, len); |
| 1681 | return len; |
| 1682 | } |
| 1683 | |
| 1684 | /* NULL or constants 0 or 1 */ |
| 1685 | return 0; |
danielk1977 | cfcdaef | 2004-05-12 07:33:33 +0000 | [diff] [blame] | 1686 | } |
| 1687 | |
| 1688 | /* |
| 1689 | ** Deserialize the data blob pointed to by buf as serial type serial_type |
| 1690 | ** and store the result in pMem. Return the number of bytes read. |
| 1691 | */ |
danielk1977 | b1bc953 | 2004-05-22 03:05:33 +0000 | [diff] [blame] | 1692 | int sqlite3VdbeSerialGet( |
danielk1977 | 93d4675 | 2004-05-23 13:30:58 +0000 | [diff] [blame] | 1693 | const unsigned char *buf, /* Buffer to deserialize from */ |
drh | 25aa1b4 | 2004-05-28 01:39:01 +0000 | [diff] [blame] | 1694 | u32 serial_type, /* Serial type to deserialize */ |
| 1695 | Mem *pMem /* Memory cell to write value into */ |
danielk1977 | b1bc953 | 2004-05-22 03:05:33 +0000 | [diff] [blame] | 1696 | ){ |
drh | 3c68582 | 2005-05-21 18:32:18 +0000 | [diff] [blame] | 1697 | switch( serial_type ){ |
drh | 3c68582 | 2005-05-21 18:32:18 +0000 | [diff] [blame] | 1698 | case 10: /* Reserved for future use */ |
| 1699 | case 11: /* Reserved for future use */ |
| 1700 | case 0: { /* NULL */ |
| 1701 | pMem->flags = MEM_Null; |
| 1702 | break; |
| 1703 | } |
| 1704 | case 1: { /* 1-byte signed integer */ |
| 1705 | pMem->i = (signed char)buf[0]; |
drh | 1483e14 | 2004-05-21 21:12:42 +0000 | [diff] [blame] | 1706 | pMem->flags = MEM_Int; |
drh | 3c68582 | 2005-05-21 18:32:18 +0000 | [diff] [blame] | 1707 | return 1; |
drh | 1483e14 | 2004-05-21 21:12:42 +0000 | [diff] [blame] | 1708 | } |
drh | 3c68582 | 2005-05-21 18:32:18 +0000 | [diff] [blame] | 1709 | case 2: { /* 2-byte signed integer */ |
| 1710 | pMem->i = (((signed char)buf[0])<<8) | buf[1]; |
| 1711 | pMem->flags = MEM_Int; |
| 1712 | return 2; |
| 1713 | } |
| 1714 | case 3: { /* 3-byte signed integer */ |
| 1715 | pMem->i = (((signed char)buf[0])<<16) | (buf[1]<<8) | buf[2]; |
| 1716 | pMem->flags = MEM_Int; |
| 1717 | return 3; |
| 1718 | } |
| 1719 | case 4: { /* 4-byte signed integer */ |
| 1720 | pMem->i = (buf[0]<<24) | (buf[1]<<16) | (buf[2]<<8) | buf[3]; |
| 1721 | pMem->flags = MEM_Int; |
| 1722 | return 4; |
| 1723 | } |
| 1724 | case 5: { /* 6-byte signed integer */ |
| 1725 | u64 x = (((signed char)buf[0])<<8) | buf[1]; |
| 1726 | u32 y = (buf[2]<<24) | (buf[3]<<16) | (buf[4]<<8) | buf[5]; |
| 1727 | x = (x<<32) | y; |
| 1728 | pMem->i = *(i64*)&x; |
| 1729 | pMem->flags = MEM_Int; |
| 1730 | return 6; |
| 1731 | } |
drh | 91124b3 | 2005-08-18 18:15:05 +0000 | [diff] [blame] | 1732 | case 6: /* 8-byte signed integer */ |
drh | 3c68582 | 2005-05-21 18:32:18 +0000 | [diff] [blame] | 1733 | case 7: { /* IEEE floating point */ |
drh | d81bd4e | 2005-09-05 20:06:49 +0000 | [diff] [blame] | 1734 | u64 x; |
| 1735 | u32 y; |
drh | 2a3e4a7 | 2006-01-23 21:44:53 +0000 | [diff] [blame] | 1736 | #if !defined(NDEBUG) && !defined(SQLITE_OMIT_FLOATING_POINT) |
drh | de941c6 | 2005-08-28 01:34:21 +0000 | [diff] [blame] | 1737 | /* Verify that integers and floating point values use the same |
drh | bfd6b03 | 2005-08-28 01:38:44 +0000 | [diff] [blame] | 1738 | ** byte order. The byte order differs on some (broken) architectures. |
| 1739 | */ |
drh | de941c6 | 2005-08-28 01:34:21 +0000 | [diff] [blame] | 1740 | static const u64 t1 = ((u64)0x3ff00000)<<32; |
| 1741 | assert( 1.0==*(double*)&t1 ); |
| 1742 | #endif |
drh | bfd6b03 | 2005-08-28 01:38:44 +0000 | [diff] [blame] | 1743 | |
drh | d81bd4e | 2005-09-05 20:06:49 +0000 | [diff] [blame] | 1744 | x = (buf[0]<<24) | (buf[1]<<16) | (buf[2]<<8) | buf[3]; |
| 1745 | y = (buf[4]<<24) | (buf[5]<<16) | (buf[6]<<8) | buf[7]; |
drh | 3c68582 | 2005-05-21 18:32:18 +0000 | [diff] [blame] | 1746 | x = (x<<32) | y; |
| 1747 | if( serial_type==6 ){ |
| 1748 | pMem->i = *(i64*)&x; |
| 1749 | pMem->flags = MEM_Int; |
| 1750 | }else{ |
| 1751 | pMem->r = *(double*)&x; |
| 1752 | pMem->flags = MEM_Real; |
| 1753 | } |
| 1754 | return 8; |
| 1755 | } |
drh | d946db0 | 2005-12-29 19:23:06 +0000 | [diff] [blame] | 1756 | case 8: /* Integer 0 */ |
| 1757 | case 9: { /* Integer 1 */ |
| 1758 | pMem->i = serial_type-8; |
| 1759 | pMem->flags = MEM_Int; |
| 1760 | return 0; |
| 1761 | } |
drh | 3c68582 | 2005-05-21 18:32:18 +0000 | [diff] [blame] | 1762 | default: { |
| 1763 | int len = (serial_type-12)/2; |
| 1764 | pMem->z = (char *)buf; |
| 1765 | pMem->n = len; |
| 1766 | pMem->xDel = 0; |
| 1767 | if( serial_type&0x01 ){ |
| 1768 | pMem->flags = MEM_Str | MEM_Ephem; |
| 1769 | }else{ |
| 1770 | pMem->flags = MEM_Blob | MEM_Ephem; |
| 1771 | } |
| 1772 | return len; |
drh | 696b32f | 2004-05-30 01:51:52 +0000 | [diff] [blame] | 1773 | } |
danielk1977 | cfcdaef | 2004-05-12 07:33:33 +0000 | [diff] [blame] | 1774 | } |
drh | 3c68582 | 2005-05-21 18:32:18 +0000 | [diff] [blame] | 1775 | return 0; |
danielk1977 | 192ac1d | 2004-05-10 07:17:30 +0000 | [diff] [blame] | 1776 | } |
| 1777 | |
| 1778 | /* |
drh | 0e6082e | 2006-01-12 20:28:35 +0000 | [diff] [blame] | 1779 | ** The header of a record consists of a sequence variable-length integers. |
| 1780 | ** These integers are almost always small and are encoded as a single byte. |
| 1781 | ** The following macro takes advantage this fact to provide a fast decode |
| 1782 | ** of the integers in a record header. It is faster for the common case |
| 1783 | ** where the integer is a single byte. It is a little slower when the |
| 1784 | ** integer is two or more bytes. But overall it is faster. |
| 1785 | ** |
| 1786 | ** The following expressions are equivalent: |
| 1787 | ** |
| 1788 | ** x = sqlite3GetVarint32( A, &B ); |
| 1789 | ** |
| 1790 | ** x = GetVarint( A, B ); |
| 1791 | ** |
| 1792 | */ |
| 1793 | #define GetVarint(A,B) ((B = *(A))<=0x7f ? 1 : sqlite3GetVarint32(A, &B)) |
| 1794 | |
| 1795 | /* |
drh | 7a224de | 2004-06-02 01:22:02 +0000 | [diff] [blame] | 1796 | ** This function compares the two table rows or index records specified by |
danielk1977 | eb015e0 | 2004-05-18 01:31:14 +0000 | [diff] [blame] | 1797 | ** {nKey1, pKey1} and {nKey2, pKey2}, returning a negative, zero |
| 1798 | ** or positive integer if {nKey1, pKey1} is less than, equal to or |
drh | 7a224de | 2004-06-02 01:22:02 +0000 | [diff] [blame] | 1799 | ** greater than {nKey2, pKey2}. Both Key1 and Key2 must be byte strings |
| 1800 | ** composed by the OP_MakeRecord opcode of the VDBE. |
danielk1977 | eb015e0 | 2004-05-18 01:31:14 +0000 | [diff] [blame] | 1801 | */ |
drh | 7a224de | 2004-06-02 01:22:02 +0000 | [diff] [blame] | 1802 | int sqlite3VdbeRecordCompare( |
danielk1977 | eb015e0 | 2004-05-18 01:31:14 +0000 | [diff] [blame] | 1803 | void *userData, |
| 1804 | int nKey1, const void *pKey1, |
| 1805 | int nKey2, const void *pKey2 |
| 1806 | ){ |
drh | d3d39e9 | 2004-05-20 22:16:29 +0000 | [diff] [blame] | 1807 | KeyInfo *pKeyInfo = (KeyInfo*)userData; |
drh | d3194f5 | 2004-05-27 19:59:32 +0000 | [diff] [blame] | 1808 | u32 d1, d2; /* Offset into aKey[] of next data element */ |
| 1809 | u32 idx1, idx2; /* Offset into aKey[] of next header element */ |
| 1810 | u32 szHdr1, szHdr2; /* Number of bytes in header */ |
| 1811 | int i = 0; |
| 1812 | int nField; |
| 1813 | int rc = 0; |
danielk1977 | eb015e0 | 2004-05-18 01:31:14 +0000 | [diff] [blame] | 1814 | const unsigned char *aKey1 = (const unsigned char *)pKey1; |
| 1815 | const unsigned char *aKey2 = (const unsigned char *)pKey2; |
danielk1977 | 0202b29 | 2004-06-09 09:55:16 +0000 | [diff] [blame] | 1816 | |
| 1817 | Mem mem1; |
| 1818 | Mem mem2; |
| 1819 | mem1.enc = pKeyInfo->enc; |
| 1820 | mem2.enc = pKeyInfo->enc; |
drh | d3194f5 | 2004-05-27 19:59:32 +0000 | [diff] [blame] | 1821 | |
drh | 0e6082e | 2006-01-12 20:28:35 +0000 | [diff] [blame] | 1822 | idx1 = GetVarint(aKey1, szHdr1); |
drh | d3194f5 | 2004-05-27 19:59:32 +0000 | [diff] [blame] | 1823 | d1 = szHdr1; |
drh | 0e6082e | 2006-01-12 20:28:35 +0000 | [diff] [blame] | 1824 | idx2 = GetVarint(aKey2, szHdr2); |
drh | d3194f5 | 2004-05-27 19:59:32 +0000 | [diff] [blame] | 1825 | d2 = szHdr2; |
| 1826 | nField = pKeyInfo->nField; |
drh | d578820 | 2004-05-28 08:21:05 +0000 | [diff] [blame] | 1827 | while( idx1<szHdr1 && idx2<szHdr2 ){ |
drh | d3194f5 | 2004-05-27 19:59:32 +0000 | [diff] [blame] | 1828 | u32 serial_type1; |
| 1829 | u32 serial_type2; |
danielk1977 | 84ac9d0 | 2004-05-18 09:58:06 +0000 | [diff] [blame] | 1830 | |
| 1831 | /* Read the serial types for the next element in each key. */ |
drh | 0e6082e | 2006-01-12 20:28:35 +0000 | [diff] [blame] | 1832 | idx1 += GetVarint( aKey1+idx1, serial_type1 ); |
drh | d578820 | 2004-05-28 08:21:05 +0000 | [diff] [blame] | 1833 | if( d1>=nKey1 && sqlite3VdbeSerialTypeLen(serial_type1)>0 ) break; |
drh | 0e6082e | 2006-01-12 20:28:35 +0000 | [diff] [blame] | 1834 | idx2 += GetVarint( aKey2+idx2, serial_type2 ); |
drh | d578820 | 2004-05-28 08:21:05 +0000 | [diff] [blame] | 1835 | if( d2>=nKey2 && sqlite3VdbeSerialTypeLen(serial_type2)>0 ) break; |
danielk1977 | 84ac9d0 | 2004-05-18 09:58:06 +0000 | [diff] [blame] | 1836 | |
| 1837 | /* Assert that there is enough space left in each key for the blob of |
| 1838 | ** data to go with the serial type just read. This assert may fail if |
| 1839 | ** the file is corrupted. Then read the value from each key into mem1 |
| 1840 | ** and mem2 respectively. |
| 1841 | */ |
drh | 25aa1b4 | 2004-05-28 01:39:01 +0000 | [diff] [blame] | 1842 | d1 += sqlite3VdbeSerialGet(&aKey1[d1], serial_type1, &mem1); |
| 1843 | d2 += sqlite3VdbeSerialGet(&aKey2[d2], serial_type2, &mem2); |
danielk1977 | 84ac9d0 | 2004-05-18 09:58:06 +0000 | [diff] [blame] | 1844 | |
drh | d578820 | 2004-05-28 08:21:05 +0000 | [diff] [blame] | 1845 | rc = sqlite3MemCompare(&mem1, &mem2, i<nField ? pKeyInfo->aColl[i] : 0); |
drh | 3c68582 | 2005-05-21 18:32:18 +0000 | [diff] [blame] | 1846 | if( mem1.flags & MEM_Dyn ) sqlite3VdbeMemRelease(&mem1); |
| 1847 | if( mem2.flags & MEM_Dyn ) sqlite3VdbeMemRelease(&mem2); |
danielk1977 | 84ac9d0 | 2004-05-18 09:58:06 +0000 | [diff] [blame] | 1848 | if( rc!=0 ){ |
drh | d3194f5 | 2004-05-27 19:59:32 +0000 | [diff] [blame] | 1849 | break; |
| 1850 | } |
| 1851 | i++; |
| 1852 | } |
| 1853 | |
| 1854 | /* One of the keys ran out of fields, but all the fields up to that point |
| 1855 | ** were equal. If the incrKey flag is true, then the second key is |
| 1856 | ** treated as larger. |
| 1857 | */ |
| 1858 | if( rc==0 ){ |
| 1859 | if( pKeyInfo->incrKey ){ |
drh | d3194f5 | 2004-05-27 19:59:32 +0000 | [diff] [blame] | 1860 | rc = -1; |
| 1861 | }else if( d1<nKey1 ){ |
| 1862 | rc = 1; |
| 1863 | }else if( d2<nKey2 ){ |
| 1864 | rc = -1; |
danielk1977 | 84ac9d0 | 2004-05-18 09:58:06 +0000 | [diff] [blame] | 1865 | } |
drh | 0b2f316 | 2005-12-21 18:36:45 +0000 | [diff] [blame] | 1866 | }else if( pKeyInfo->aSortOrder && i<pKeyInfo->nField |
| 1867 | && pKeyInfo->aSortOrder[i] ){ |
drh | d3194f5 | 2004-05-27 19:59:32 +0000 | [diff] [blame] | 1868 | rc = -rc; |
| 1869 | } |
| 1870 | |
| 1871 | return rc; |
danielk1977 | eb015e0 | 2004-05-18 01:31:14 +0000 | [diff] [blame] | 1872 | } |
drh | d578820 | 2004-05-28 08:21:05 +0000 | [diff] [blame] | 1873 | |
| 1874 | /* |
drh | 7a224de | 2004-06-02 01:22:02 +0000 | [diff] [blame] | 1875 | ** The argument is an index entry composed using the OP_MakeRecord opcode. |
| 1876 | ** The last entry in this record should be an integer (specifically |
| 1877 | ** an integer rowid). This routine returns the number of bytes in |
| 1878 | ** that integer. |
drh | d578820 | 2004-05-28 08:21:05 +0000 | [diff] [blame] | 1879 | */ |
drh | 7416170 | 2006-02-24 02:53:49 +0000 | [diff] [blame] | 1880 | int sqlite3VdbeIdxRowidLen(const u8 *aKey){ |
drh | d578820 | 2004-05-28 08:21:05 +0000 | [diff] [blame] | 1881 | u32 szHdr; /* Size of the header */ |
| 1882 | u32 typeRowid; /* Serial type of the rowid */ |
| 1883 | |
| 1884 | sqlite3GetVarint32(aKey, &szHdr); |
| 1885 | sqlite3GetVarint32(&aKey[szHdr-1], &typeRowid); |
| 1886 | return sqlite3VdbeSerialTypeLen(typeRowid); |
| 1887 | } |
danielk1977 | eb015e0 | 2004-05-18 01:31:14 +0000 | [diff] [blame] | 1888 | |
| 1889 | |
| 1890 | /* |
drh | 7a224de | 2004-06-02 01:22:02 +0000 | [diff] [blame] | 1891 | ** pCur points at an index entry created using the OP_MakeRecord opcode. |
| 1892 | ** Read the rowid (the last field in the record) and store it in *rowid. |
| 1893 | ** Return SQLITE_OK if everything works, or an error code otherwise. |
danielk1977 | 183f9f7 | 2004-05-13 05:20:26 +0000 | [diff] [blame] | 1894 | */ |
| 1895 | int sqlite3VdbeIdxRowid(BtCursor *pCur, i64 *rowid){ |
danielk1977 | e0d4b06 | 2004-06-28 01:11:46 +0000 | [diff] [blame] | 1896 | i64 nCellKey; |
danielk1977 | 183f9f7 | 2004-05-13 05:20:26 +0000 | [diff] [blame] | 1897 | int rc; |
drh | d578820 | 2004-05-28 08:21:05 +0000 | [diff] [blame] | 1898 | u32 szHdr; /* Size of the header */ |
| 1899 | u32 typeRowid; /* Serial type of the rowid */ |
| 1900 | u32 lenRowid; /* Size of the rowid */ |
| 1901 | Mem m, v; |
danielk1977 | 183f9f7 | 2004-05-13 05:20:26 +0000 | [diff] [blame] | 1902 | |
drh | d578820 | 2004-05-28 08:21:05 +0000 | [diff] [blame] | 1903 | sqlite3BtreeKeySize(pCur, &nCellKey); |
| 1904 | if( nCellKey<=0 ){ |
drh | 4928570 | 2005-09-17 15:20:26 +0000 | [diff] [blame] | 1905 | return SQLITE_CORRUPT_BKPT; |
drh | d578820 | 2004-05-28 08:21:05 +0000 | [diff] [blame] | 1906 | } |
| 1907 | rc = sqlite3VdbeMemFromBtree(pCur, 0, nCellKey, 1, &m); |
| 1908 | if( rc ){ |
danielk1977 | 183f9f7 | 2004-05-13 05:20:26 +0000 | [diff] [blame] | 1909 | return rc; |
| 1910 | } |
drh | 2646da7 | 2005-12-09 20:02:05 +0000 | [diff] [blame] | 1911 | sqlite3GetVarint32((u8*)m.z, &szHdr); |
| 1912 | sqlite3GetVarint32((u8*)&m.z[szHdr-1], &typeRowid); |
drh | d578820 | 2004-05-28 08:21:05 +0000 | [diff] [blame] | 1913 | lenRowid = sqlite3VdbeSerialTypeLen(typeRowid); |
drh | 2646da7 | 2005-12-09 20:02:05 +0000 | [diff] [blame] | 1914 | sqlite3VdbeSerialGet((u8*)&m.z[m.n-lenRowid], typeRowid, &v); |
drh | d578820 | 2004-05-28 08:21:05 +0000 | [diff] [blame] | 1915 | *rowid = v.i; |
danielk1977 | d812336 | 2004-06-12 09:25:12 +0000 | [diff] [blame] | 1916 | sqlite3VdbeMemRelease(&m); |
danielk1977 | 183f9f7 | 2004-05-13 05:20:26 +0000 | [diff] [blame] | 1917 | return SQLITE_OK; |
| 1918 | } |
| 1919 | |
drh | 7cf6e4d | 2004-05-19 14:56:55 +0000 | [diff] [blame] | 1920 | /* |
drh | d3d39e9 | 2004-05-20 22:16:29 +0000 | [diff] [blame] | 1921 | ** Compare the key of the index entry that cursor pC is point to against |
drh | 7cf6e4d | 2004-05-19 14:56:55 +0000 | [diff] [blame] | 1922 | ** the key string in pKey (of length nKey). Write into *pRes a number |
| 1923 | ** that is negative, zero, or positive if pC is less than, equal to, |
| 1924 | ** or greater than pKey. Return SQLITE_OK on success. |
drh | d3d39e9 | 2004-05-20 22:16:29 +0000 | [diff] [blame] | 1925 | ** |
drh | d578820 | 2004-05-28 08:21:05 +0000 | [diff] [blame] | 1926 | ** pKey is either created without a rowid or is truncated so that it |
| 1927 | ** omits the rowid at the end. The rowid at the end of the index entry |
| 1928 | ** is ignored as well. |
drh | 7cf6e4d | 2004-05-19 14:56:55 +0000 | [diff] [blame] | 1929 | */ |
danielk1977 | 183f9f7 | 2004-05-13 05:20:26 +0000 | [diff] [blame] | 1930 | int sqlite3VdbeIdxKeyCompare( |
drh | 7cf6e4d | 2004-05-19 14:56:55 +0000 | [diff] [blame] | 1931 | Cursor *pC, /* The cursor to compare against */ |
| 1932 | int nKey, const u8 *pKey, /* The key to compare */ |
| 1933 | int *res /* Write the comparison result here */ |
danielk1977 | 183f9f7 | 2004-05-13 05:20:26 +0000 | [diff] [blame] | 1934 | ){ |
danielk1977 | e0d4b06 | 2004-06-28 01:11:46 +0000 | [diff] [blame] | 1935 | i64 nCellKey; |
danielk1977 | 183f9f7 | 2004-05-13 05:20:26 +0000 | [diff] [blame] | 1936 | int rc; |
danielk1977 | 3d1bfea | 2004-05-14 11:00:53 +0000 | [diff] [blame] | 1937 | BtCursor *pCur = pC->pCursor; |
drh | d578820 | 2004-05-28 08:21:05 +0000 | [diff] [blame] | 1938 | int lenRowid; |
| 1939 | Mem m; |
danielk1977 | 183f9f7 | 2004-05-13 05:20:26 +0000 | [diff] [blame] | 1940 | |
| 1941 | sqlite3BtreeKeySize(pCur, &nCellKey); |
| 1942 | if( nCellKey<=0 ){ |
| 1943 | *res = 0; |
| 1944 | return SQLITE_OK; |
| 1945 | } |
drh | d578820 | 2004-05-28 08:21:05 +0000 | [diff] [blame] | 1946 | rc = sqlite3VdbeMemFromBtree(pC->pCursor, 0, nCellKey, 1, &m); |
| 1947 | if( rc ){ |
| 1948 | return rc; |
danielk1977 | 183f9f7 | 2004-05-13 05:20:26 +0000 | [diff] [blame] | 1949 | } |
drh | 7416170 | 2006-02-24 02:53:49 +0000 | [diff] [blame] | 1950 | lenRowid = sqlite3VdbeIdxRowidLen((u8*)m.z); |
drh | 7a224de | 2004-06-02 01:22:02 +0000 | [diff] [blame] | 1951 | *res = sqlite3VdbeRecordCompare(pC->pKeyInfo, m.n-lenRowid, m.z, nKey, pKey); |
danielk1977 | d812336 | 2004-06-12 09:25:12 +0000 | [diff] [blame] | 1952 | sqlite3VdbeMemRelease(&m); |
danielk1977 | 183f9f7 | 2004-05-13 05:20:26 +0000 | [diff] [blame] | 1953 | return SQLITE_OK; |
| 1954 | } |
danielk1977 | b28af71 | 2004-06-21 06:50:26 +0000 | [diff] [blame] | 1955 | |
| 1956 | /* |
| 1957 | ** This routine sets the value to be returned by subsequent calls to |
| 1958 | ** sqlite3_changes() on the database handle 'db'. |
| 1959 | */ |
| 1960 | void sqlite3VdbeSetChanges(sqlite3 *db, int nChange){ |
| 1961 | db->nChange = nChange; |
| 1962 | db->nTotalChange += nChange; |
| 1963 | } |
| 1964 | |
| 1965 | /* |
| 1966 | ** Set a flag in the vdbe to update the change counter when it is finalised |
| 1967 | ** or reset. |
| 1968 | */ |
drh | 4794f73 | 2004-11-05 17:17:50 +0000 | [diff] [blame] | 1969 | void sqlite3VdbeCountChanges(Vdbe *v){ |
| 1970 | v->changeCntOn = 1; |
danielk1977 | b28af71 | 2004-06-21 06:50:26 +0000 | [diff] [blame] | 1971 | } |
drh | d89bd00 | 2005-01-22 03:03:54 +0000 | [diff] [blame] | 1972 | |
| 1973 | /* |
| 1974 | ** Mark every prepared statement associated with a database connection |
| 1975 | ** as expired. |
| 1976 | ** |
| 1977 | ** An expired statement means that recompilation of the statement is |
| 1978 | ** recommend. Statements expire when things happen that make their |
| 1979 | ** programs obsolete. Removing user-defined functions or collating |
| 1980 | ** sequences, or changing an authorization function are the types of |
| 1981 | ** things that make prepared statements obsolete. |
| 1982 | */ |
| 1983 | void sqlite3ExpirePreparedStatements(sqlite3 *db){ |
| 1984 | Vdbe *p; |
| 1985 | for(p = db->pVdbe; p; p=p->pNext){ |
| 1986 | p->expired = 1; |
| 1987 | } |
| 1988 | } |
danielk1977 | aee18ef | 2005-03-09 12:26:50 +0000 | [diff] [blame] | 1989 | |
| 1990 | /* |
| 1991 | ** Return the database associated with the Vdbe. |
| 1992 | */ |
| 1993 | sqlite3 *sqlite3VdbeDb(Vdbe *v){ |
| 1994 | return v->db; |
| 1995 | } |