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. |
danielk1977 | 9a9b156 | 2008-04-24 08:31:51 +0000 | [diff] [blame] | 16 | ** |
drh | 6a1e071 | 2008-12-05 15:24:15 +0000 | [diff] [blame] | 17 | ** $Id: vdbeaux.c,v 1.423 2008/12/05 15:24:17 drh Exp $ |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 18 | */ |
| 19 | #include "sqliteInt.h" |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 20 | #include <ctype.h> |
| 21 | #include "vdbeInt.h" |
| 22 | |
| 23 | |
drh | 46c99e0 | 2007-08-27 23:26:59 +0000 | [diff] [blame] | 24 | |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 25 | /* |
| 26 | ** When debugging the code generator in a symbolic debugger, one can |
mlcreech | 3a00f90 | 2008-03-04 17:45:01 +0000 | [diff] [blame] | 27 | ** set the sqlite3VdbeAddopTrace to 1 and all opcodes will be printed |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 28 | ** as they are added to the instruction stream. |
| 29 | */ |
drh | 8d904f0 | 2005-06-14 17:47:58 +0000 | [diff] [blame] | 30 | #ifdef SQLITE_DEBUG |
mlcreech | 3a00f90 | 2008-03-04 17:45:01 +0000 | [diff] [blame] | 31 | int sqlite3VdbeAddopTrace = 0; |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 32 | #endif |
| 33 | |
| 34 | |
| 35 | /* |
| 36 | ** Create a new virtual database engine. |
| 37 | */ |
drh | 9bb575f | 2004-09-06 17:24:11 +0000 | [diff] [blame] | 38 | Vdbe *sqlite3VdbeCreate(sqlite3 *db){ |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 39 | Vdbe *p; |
drh | 1743575 | 2007-08-16 04:30:38 +0000 | [diff] [blame] | 40 | p = sqlite3DbMallocZero(db, sizeof(Vdbe) ); |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 41 | if( p==0 ) return 0; |
| 42 | p->db = db; |
| 43 | if( db->pVdbe ){ |
| 44 | db->pVdbe->pPrev = p; |
| 45 | } |
| 46 | p->pNext = db->pVdbe; |
| 47 | p->pPrev = 0; |
| 48 | db->pVdbe = p; |
| 49 | p->magic = VDBE_MAGIC_INIT; |
| 50 | return p; |
| 51 | } |
| 52 | |
| 53 | /* |
drh | b900aaf | 2006-11-09 00:24:53 +0000 | [diff] [blame] | 54 | ** Remember the SQL string for a prepared statement. |
| 55 | */ |
| 56 | void sqlite3VdbeSetSql(Vdbe *p, const char *z, int n){ |
| 57 | if( p==0 ) return; |
| 58 | assert( p->zSql==0 ); |
drh | 1743575 | 2007-08-16 04:30:38 +0000 | [diff] [blame] | 59 | p->zSql = sqlite3DbStrNDup(p->db, z, n); |
drh | b900aaf | 2006-11-09 00:24:53 +0000 | [diff] [blame] | 60 | } |
| 61 | |
| 62 | /* |
| 63 | ** Return the SQL associated with a prepared statement |
| 64 | */ |
danielk1977 | d0e2a85 | 2007-11-14 06:48:48 +0000 | [diff] [blame] | 65 | const char *sqlite3_sql(sqlite3_stmt *pStmt){ |
| 66 | return ((Vdbe *)pStmt)->zSql; |
drh | b900aaf | 2006-11-09 00:24:53 +0000 | [diff] [blame] | 67 | } |
| 68 | |
| 69 | /* |
drh | c515525 | 2007-01-08 21:07:17 +0000 | [diff] [blame] | 70 | ** Swap all content between two VDBE structures. |
drh | b900aaf | 2006-11-09 00:24:53 +0000 | [diff] [blame] | 71 | */ |
drh | c515525 | 2007-01-08 21:07:17 +0000 | [diff] [blame] | 72 | void sqlite3VdbeSwap(Vdbe *pA, Vdbe *pB){ |
| 73 | Vdbe tmp, *pTmp; |
| 74 | char *zTmp; |
| 75 | int nTmp; |
| 76 | tmp = *pA; |
| 77 | *pA = *pB; |
| 78 | *pB = tmp; |
| 79 | pTmp = pA->pNext; |
| 80 | pA->pNext = pB->pNext; |
| 81 | pB->pNext = pTmp; |
| 82 | pTmp = pA->pPrev; |
| 83 | pA->pPrev = pB->pPrev; |
| 84 | pB->pPrev = pTmp; |
| 85 | zTmp = pA->zSql; |
| 86 | pA->zSql = pB->zSql; |
| 87 | pB->zSql = zTmp; |
| 88 | nTmp = pA->nSql; |
| 89 | pA->nSql = pB->nSql; |
| 90 | pB->nSql = nTmp; |
drh | b900aaf | 2006-11-09 00:24:53 +0000 | [diff] [blame] | 91 | } |
| 92 | |
drh | cf1023c | 2007-05-08 20:59:49 +0000 | [diff] [blame] | 93 | #ifdef SQLITE_DEBUG |
drh | b900aaf | 2006-11-09 00:24:53 +0000 | [diff] [blame] | 94 | /* |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 95 | ** Turn tracing on or off |
| 96 | */ |
danielk1977 | 4adee20 | 2004-05-08 08:23:19 +0000 | [diff] [blame] | 97 | void sqlite3VdbeTrace(Vdbe *p, FILE *trace){ |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 98 | p->trace = trace; |
| 99 | } |
drh | cf1023c | 2007-05-08 20:59:49 +0000 | [diff] [blame] | 100 | #endif |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 101 | |
| 102 | /* |
danielk1977 | 00e1361 | 2008-11-17 19:18:54 +0000 | [diff] [blame] | 103 | ** Resize the Vdbe.aOp array so that it is at least one op larger than |
| 104 | ** it was. |
danielk1977 | ace3eb2 | 2006-01-26 10:35:04 +0000 | [diff] [blame] | 105 | ** |
danielk1977 | 00e1361 | 2008-11-17 19:18:54 +0000 | [diff] [blame] | 106 | ** If an out-of-memory error occurs while resizing the array, return |
| 107 | ** SQLITE_NOMEM. In this case Vdbe.aOp and Vdbe.nOpAlloc remain |
| 108 | ** unchanged (this is so that any opcodes already allocated can be |
| 109 | ** correctly deallocated along with the rest of the Vdbe). |
drh | 76ff3a0 | 2004-09-24 22:32:30 +0000 | [diff] [blame] | 110 | */ |
danielk1977 | 00e1361 | 2008-11-17 19:18:54 +0000 | [diff] [blame] | 111 | static int growOpArray(Vdbe *p){ |
drh | a4e5d58 | 2007-10-20 15:41:57 +0000 | [diff] [blame] | 112 | VdbeOp *pNew; |
danielk1977 | 00e1361 | 2008-11-17 19:18:54 +0000 | [diff] [blame] | 113 | int nNew = (p->nOpAlloc ? p->nOpAlloc*2 : (int)(1024/sizeof(Op))); |
| 114 | pNew = sqlite3DbRealloc(p->db, p->aOp, nNew*sizeof(Op)); |
drh | a4e5d58 | 2007-10-20 15:41:57 +0000 | [diff] [blame] | 115 | if( pNew ){ |
danielk1977 | 00e1361 | 2008-11-17 19:18:54 +0000 | [diff] [blame] | 116 | p->nOpAlloc = nNew; |
drh | a4e5d58 | 2007-10-20 15:41:57 +0000 | [diff] [blame] | 117 | p->aOp = pNew; |
drh | 76ff3a0 | 2004-09-24 22:32:30 +0000 | [diff] [blame] | 118 | } |
danielk1977 | 00e1361 | 2008-11-17 19:18:54 +0000 | [diff] [blame] | 119 | return (pNew ? SQLITE_OK : SQLITE_NOMEM); |
drh | 76ff3a0 | 2004-09-24 22:32:30 +0000 | [diff] [blame] | 120 | } |
| 121 | |
| 122 | /* |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 123 | ** Add a new instruction to the list of instructions current in the |
| 124 | ** VDBE. Return the address of the new instruction. |
| 125 | ** |
| 126 | ** Parameters: |
| 127 | ** |
| 128 | ** p Pointer to the VDBE |
| 129 | ** |
| 130 | ** op The opcode for this instruction |
| 131 | ** |
drh | 66a5167 | 2008-01-03 00:01:23 +0000 | [diff] [blame] | 132 | ** p1, p2, p3 Operands |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 133 | ** |
danielk1977 | 4adee20 | 2004-05-08 08:23:19 +0000 | [diff] [blame] | 134 | ** Use the sqlite3VdbeResolveLabel() function to fix an address and |
drh | 66a5167 | 2008-01-03 00:01:23 +0000 | [diff] [blame] | 135 | ** the sqlite3VdbeChangeP4() function to change the value of the P4 |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 136 | ** operand. |
| 137 | */ |
drh | 66a5167 | 2008-01-03 00:01:23 +0000 | [diff] [blame] | 138 | int sqlite3VdbeAddOp3(Vdbe *p, int op, int p1, int p2, int p3){ |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 139 | int i; |
drh | 701a0ae | 2004-02-22 20:05:00 +0000 | [diff] [blame] | 140 | VdbeOp *pOp; |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 141 | |
| 142 | i = p->nOp; |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 143 | assert( p->magic==VDBE_MAGIC_INIT ); |
drh | fd2d26b | 2006-03-15 22:44:36 +0000 | [diff] [blame] | 144 | if( p->nOpAlloc<=i ){ |
danielk1977 | 00e1361 | 2008-11-17 19:18:54 +0000 | [diff] [blame] | 145 | if( growOpArray(p) ){ |
drh | fd2d26b | 2006-03-15 22:44:36 +0000 | [diff] [blame] | 146 | return 0; |
| 147 | } |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 148 | } |
danielk1977 | 0125683 | 2007-04-18 14:24:32 +0000 | [diff] [blame] | 149 | p->nOp++; |
drh | 701a0ae | 2004-02-22 20:05:00 +0000 | [diff] [blame] | 150 | pOp = &p->aOp[i]; |
| 151 | pOp->opcode = op; |
drh | 26c9b5e | 2008-04-11 14:56:53 +0000 | [diff] [blame] | 152 | pOp->p5 = 0; |
drh | 701a0ae | 2004-02-22 20:05:00 +0000 | [diff] [blame] | 153 | pOp->p1 = p1; |
drh | 701a0ae | 2004-02-22 20:05:00 +0000 | [diff] [blame] | 154 | pOp->p2 = p2; |
drh | 66a5167 | 2008-01-03 00:01:23 +0000 | [diff] [blame] | 155 | pOp->p3 = p3; |
| 156 | pOp->p4.p = 0; |
| 157 | pOp->p4type = P4_NOTUSED; |
drh | 55ef4d9 | 2005-08-14 01:20:37 +0000 | [diff] [blame] | 158 | p->expired = 0; |
danielk1977 | 8b60e0f | 2005-01-12 09:10:39 +0000 | [diff] [blame] | 159 | #ifdef SQLITE_DEBUG |
drh | 26c9b5e | 2008-04-11 14:56:53 +0000 | [diff] [blame] | 160 | pOp->zComment = 0; |
mlcreech | 3a00f90 | 2008-03-04 17:45:01 +0000 | [diff] [blame] | 161 | if( sqlite3VdbeAddopTrace ) sqlite3VdbePrintOp(0, i, &p->aOp[i]); |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 162 | #endif |
drh | 26c9b5e | 2008-04-11 14:56:53 +0000 | [diff] [blame] | 163 | #ifdef VDBE_PROFILE |
| 164 | pOp->cycles = 0; |
| 165 | pOp->cnt = 0; |
| 166 | #endif |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 167 | return i; |
| 168 | } |
drh | 66a5167 | 2008-01-03 00:01:23 +0000 | [diff] [blame] | 169 | int sqlite3VdbeAddOp0(Vdbe *p, int op){ |
| 170 | return sqlite3VdbeAddOp3(p, op, 0, 0, 0); |
| 171 | } |
| 172 | int sqlite3VdbeAddOp1(Vdbe *p, int op, int p1){ |
| 173 | return sqlite3VdbeAddOp3(p, op, p1, 0, 0); |
| 174 | } |
| 175 | int sqlite3VdbeAddOp2(Vdbe *p, int op, int p1, int p2){ |
| 176 | return sqlite3VdbeAddOp3(p, op, p1, p2, 0); |
drh | 701a0ae | 2004-02-22 20:05:00 +0000 | [diff] [blame] | 177 | } |
| 178 | |
drh | 66a5167 | 2008-01-03 00:01:23 +0000 | [diff] [blame] | 179 | |
drh | 701a0ae | 2004-02-22 20:05:00 +0000 | [diff] [blame] | 180 | /* |
drh | 66a5167 | 2008-01-03 00:01:23 +0000 | [diff] [blame] | 181 | ** Add an opcode that includes the p4 value as a pointer. |
drh | d4e70eb | 2008-01-02 00:34:36 +0000 | [diff] [blame] | 182 | */ |
drh | 66a5167 | 2008-01-03 00:01:23 +0000 | [diff] [blame] | 183 | int sqlite3VdbeAddOp4( |
drh | d4e70eb | 2008-01-02 00:34:36 +0000 | [diff] [blame] | 184 | Vdbe *p, /* Add the opcode to this VM */ |
| 185 | int op, /* The new opcode */ |
drh | 66a5167 | 2008-01-03 00:01:23 +0000 | [diff] [blame] | 186 | int p1, /* The P1 operand */ |
| 187 | int p2, /* The P2 operand */ |
| 188 | int p3, /* The P3 operand */ |
| 189 | const char *zP4, /* The P4 operand */ |
| 190 | int p4type /* P4 operand type */ |
drh | d4e70eb | 2008-01-02 00:34:36 +0000 | [diff] [blame] | 191 | ){ |
drh | 66a5167 | 2008-01-03 00:01:23 +0000 | [diff] [blame] | 192 | int addr = sqlite3VdbeAddOp3(p, op, p1, p2, p3); |
| 193 | sqlite3VdbeChangeP4(p, addr, zP4, p4type); |
drh | d4e70eb | 2008-01-02 00:34:36 +0000 | [diff] [blame] | 194 | return addr; |
| 195 | } |
| 196 | |
| 197 | /* |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 198 | ** Create a new symbolic label for an instruction that has yet to be |
| 199 | ** coded. The symbolic label is really just a negative number. The |
| 200 | ** label can be used as the P2 value of an operation. Later, when |
| 201 | ** the label is resolved to a specific address, the VDBE will scan |
| 202 | ** through its operation list and change all values of P2 which match |
| 203 | ** the label into the resolved address. |
| 204 | ** |
| 205 | ** The VDBE knows that a P2 value is a label because labels are |
| 206 | ** always negative and P2 values are suppose to be non-negative. |
| 207 | ** 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] | 208 | ** |
| 209 | ** Zero is returned if a malloc() fails. |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 210 | */ |
danielk1977 | 4adee20 | 2004-05-08 08:23:19 +0000 | [diff] [blame] | 211 | int sqlite3VdbeMakeLabel(Vdbe *p){ |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 212 | int i; |
| 213 | i = p->nLabel++; |
| 214 | assert( p->magic==VDBE_MAGIC_INIT ); |
| 215 | if( i>=p->nLabelAlloc ){ |
drh | 6a1e071 | 2008-12-05 15:24:15 +0000 | [diff] [blame] | 216 | int n = p->nLabelAlloc*2 + 5; |
danielk1977 | 1e53695 | 2007-08-16 10:09:01 +0000 | [diff] [blame] | 217 | p->aLabel = sqlite3DbReallocOrFree(p->db, p->aLabel, |
drh | 6a1e071 | 2008-12-05 15:24:15 +0000 | [diff] [blame] | 218 | n*sizeof(p->aLabel[0])); |
| 219 | p->nLabelAlloc = sqlite3DbMallocSize(p->db, p->aLabel)/sizeof(p->aLabel[0]); |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 220 | } |
drh | 76ff3a0 | 2004-09-24 22:32:30 +0000 | [diff] [blame] | 221 | if( p->aLabel ){ |
| 222 | p->aLabel[i] = -1; |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 223 | } |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 224 | return -1-i; |
| 225 | } |
| 226 | |
| 227 | /* |
| 228 | ** Resolve label "x" to be the address of the next instruction to |
| 229 | ** be inserted. The parameter "x" must have been obtained from |
danielk1977 | 4adee20 | 2004-05-08 08:23:19 +0000 | [diff] [blame] | 230 | ** a prior call to sqlite3VdbeMakeLabel(). |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 231 | */ |
danielk1977 | 4adee20 | 2004-05-08 08:23:19 +0000 | [diff] [blame] | 232 | void sqlite3VdbeResolveLabel(Vdbe *p, int x){ |
drh | 76ff3a0 | 2004-09-24 22:32:30 +0000 | [diff] [blame] | 233 | int j = -1-x; |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 234 | assert( p->magic==VDBE_MAGIC_INIT ); |
drh | 76ff3a0 | 2004-09-24 22:32:30 +0000 | [diff] [blame] | 235 | assert( j>=0 && j<p->nLabel ); |
| 236 | if( p->aLabel ){ |
| 237 | p->aLabel[j] = p->nOp; |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 238 | } |
| 239 | } |
| 240 | |
| 241 | /* |
drh | 9cbf342 | 2008-01-17 16:22:13 +0000 | [diff] [blame] | 242 | ** Loop through the program looking for P2 values that are negative |
| 243 | ** on jump instructions. Each such value is a label. Resolve the |
| 244 | ** label by setting the P2 value to its correct non-zero value. |
drh | 76ff3a0 | 2004-09-24 22:32:30 +0000 | [diff] [blame] | 245 | ** |
| 246 | ** This routine is called once after all opcodes have been inserted. |
danielk1977 | 634f298 | 2005-03-28 08:44:07 +0000 | [diff] [blame] | 247 | ** |
drh | 1344989 | 2005-09-07 21:22:45 +0000 | [diff] [blame] | 248 | ** Variable *pMaxFuncArgs is set to the maximum value of any P2 argument |
danielk1977 | 399918f | 2006-06-14 13:03:23 +0000 | [diff] [blame] | 249 | ** to an OP_Function, OP_AggStep or OP_VFilter opcode. This is used by |
danielk1977 | 634f298 | 2005-03-28 08:44:07 +0000 | [diff] [blame] | 250 | ** sqlite3VdbeMakeReady() to size the Vdbe.apArg[] array. |
danielk1977 | bc04f85 | 2005-03-29 08:26:13 +0000 | [diff] [blame] | 251 | ** |
drh | 3844990 | 2005-06-07 01:43:41 +0000 | [diff] [blame] | 252 | ** This routine also does the following optimization: It scans for |
drh | 77658e2 | 2007-12-04 16:54:52 +0000 | [diff] [blame] | 253 | ** instructions that might cause a statement rollback. Such instructions |
| 254 | ** are: |
| 255 | ** |
| 256 | ** * OP_Halt with P1=SQLITE_CONSTRAINT and P2=OE_Abort. |
| 257 | ** * OP_Destroy |
| 258 | ** * OP_VUpdate |
| 259 | ** * OP_VRename |
| 260 | ** |
| 261 | ** If no such instruction is found, then every Statement instruction |
| 262 | ** is changed to a Noop. In this way, we avoid creating the statement |
| 263 | ** journal file unnecessarily. |
drh | 76ff3a0 | 2004-09-24 22:32:30 +0000 | [diff] [blame] | 264 | */ |
drh | 9cbf342 | 2008-01-17 16:22:13 +0000 | [diff] [blame] | 265 | static void resolveP2Values(Vdbe *p, int *pMaxFuncArgs){ |
drh | 76ff3a0 | 2004-09-24 22:32:30 +0000 | [diff] [blame] | 266 | int i; |
danielk1977 | bc04f85 | 2005-03-29 08:26:13 +0000 | [diff] [blame] | 267 | int nMaxArgs = 0; |
drh | 76ff3a0 | 2004-09-24 22:32:30 +0000 | [diff] [blame] | 268 | Op *pOp; |
| 269 | int *aLabel = p->aLabel; |
drh | 3844990 | 2005-06-07 01:43:41 +0000 | [diff] [blame] | 270 | int doesStatementRollback = 0; |
| 271 | int hasStatementBegin = 0; |
drh | ad4a4b8 | 2008-11-05 16:37:34 +0000 | [diff] [blame] | 272 | p->readOnly = 1; |
| 273 | p->usesStmtJournal = 0; |
drh | 76ff3a0 | 2004-09-24 22:32:30 +0000 | [diff] [blame] | 274 | for(pOp=p->aOp, i=p->nOp-1; i>=0; i--, pOp++){ |
danielk1977 | 634f298 | 2005-03-28 08:44:07 +0000 | [diff] [blame] | 275 | u8 opcode = pOp->opcode; |
| 276 | |
drh | a2baf3a | 2008-06-18 15:34:09 +0000 | [diff] [blame] | 277 | if( opcode==OP_Function || opcode==OP_AggStep ){ |
drh | 9875715 | 2008-01-09 23:04:12 +0000 | [diff] [blame] | 278 | if( pOp->p5>nMaxArgs ) nMaxArgs = pOp->p5; |
danielk1977 | 399918f | 2006-06-14 13:03:23 +0000 | [diff] [blame] | 279 | #ifndef SQLITE_OMIT_VIRTUALTABLE |
drh | a2baf3a | 2008-06-18 15:34:09 +0000 | [diff] [blame] | 280 | }else if( opcode==OP_VUpdate ){ |
danielk1977 | bc04f85 | 2005-03-29 08:26:13 +0000 | [diff] [blame] | 281 | if( pOp->p2>nMaxArgs ) nMaxArgs = pOp->p2; |
drh | a2baf3a | 2008-06-18 15:34:09 +0000 | [diff] [blame] | 282 | #endif |
danielk1977 | 5dfecba | 2008-06-23 13:57:21 +0000 | [diff] [blame] | 283 | } |
danielk1977 | 182c4ba | 2007-06-27 15:53:34 +0000 | [diff] [blame] | 284 | if( opcode==OP_Halt ){ |
drh | 3844990 | 2005-06-07 01:43:41 +0000 | [diff] [blame] | 285 | if( pOp->p1==SQLITE_CONSTRAINT && pOp->p2==OE_Abort ){ |
| 286 | doesStatementRollback = 1; |
| 287 | } |
drh | 3844990 | 2005-06-07 01:43:41 +0000 | [diff] [blame] | 288 | }else if( opcode==OP_Statement ){ |
| 289 | hasStatementBegin = 1; |
drh | ad4a4b8 | 2008-11-05 16:37:34 +0000 | [diff] [blame] | 290 | p->usesStmtJournal = 1; |
drh | 77658e2 | 2007-12-04 16:54:52 +0000 | [diff] [blame] | 291 | }else if( opcode==OP_Destroy ){ |
| 292 | doesStatementRollback = 1; |
drh | ad4a4b8 | 2008-11-05 16:37:34 +0000 | [diff] [blame] | 293 | }else if( opcode==OP_Transaction && pOp->p2!=0 ){ |
| 294 | p->readOnly = 0; |
danielk1977 | 182c4ba | 2007-06-27 15:53:34 +0000 | [diff] [blame] | 295 | #ifndef SQLITE_OMIT_VIRTUALTABLE |
| 296 | }else if( opcode==OP_VUpdate || opcode==OP_VRename ){ |
| 297 | doesStatementRollback = 1; |
drh | 4be8b51 | 2006-06-13 23:51:34 +0000 | [diff] [blame] | 298 | }else if( opcode==OP_VFilter ){ |
| 299 | int n; |
| 300 | assert( p->nOp - i >= 3 ); |
drh | 4c58312 | 2008-01-04 22:01:03 +0000 | [diff] [blame] | 301 | assert( pOp[-1].opcode==OP_Integer ); |
danielk1977 | 6dbee81 | 2008-01-03 18:39:41 +0000 | [diff] [blame] | 302 | n = pOp[-1].p1; |
drh | 4be8b51 | 2006-06-13 23:51:34 +0000 | [diff] [blame] | 303 | if( n>nMaxArgs ) nMaxArgs = n; |
danielk1977 | 182c4ba | 2007-06-27 15:53:34 +0000 | [diff] [blame] | 304 | #endif |
danielk1977 | bc04f85 | 2005-03-29 08:26:13 +0000 | [diff] [blame] | 305 | } |
danielk1977 | 634f298 | 2005-03-28 08:44:07 +0000 | [diff] [blame] | 306 | |
drh | d298151 | 2008-01-04 19:33:49 +0000 | [diff] [blame] | 307 | if( sqlite3VdbeOpcodeHasProperty(opcode, OPFLG_JUMP) && pOp->p2<0 ){ |
| 308 | assert( -1-pOp->p2<p->nLabel ); |
| 309 | pOp->p2 = aLabel[-1-pOp->p2]; |
| 310 | } |
drh | 76ff3a0 | 2004-09-24 22:32:30 +0000 | [diff] [blame] | 311 | } |
drh | 633e6d5 | 2008-07-28 19:34:53 +0000 | [diff] [blame] | 312 | sqlite3DbFree(p->db, p->aLabel); |
drh | 76ff3a0 | 2004-09-24 22:32:30 +0000 | [diff] [blame] | 313 | p->aLabel = 0; |
danielk1977 | bc04f85 | 2005-03-29 08:26:13 +0000 | [diff] [blame] | 314 | |
| 315 | *pMaxFuncArgs = nMaxArgs; |
drh | 3844990 | 2005-06-07 01:43:41 +0000 | [diff] [blame] | 316 | |
| 317 | /* If we never rollback a statement transaction, then statement |
| 318 | ** transactions are not needed. So change every OP_Statement |
drh | 66560ad | 2006-01-06 14:32:19 +0000 | [diff] [blame] | 319 | ** opcode into an OP_Noop. This avoid a call to sqlite3OsOpenExclusive() |
drh | 3844990 | 2005-06-07 01:43:41 +0000 | [diff] [blame] | 320 | ** which can be expensive on some platforms. |
| 321 | */ |
| 322 | if( hasStatementBegin && !doesStatementRollback ){ |
drh | ad4a4b8 | 2008-11-05 16:37:34 +0000 | [diff] [blame] | 323 | p->usesStmtJournal = 0; |
drh | 3844990 | 2005-06-07 01:43:41 +0000 | [diff] [blame] | 324 | for(pOp=p->aOp, i=p->nOp-1; i>=0; i--, pOp++){ |
| 325 | if( pOp->opcode==OP_Statement ){ |
| 326 | pOp->opcode = OP_Noop; |
| 327 | } |
| 328 | } |
| 329 | } |
drh | 76ff3a0 | 2004-09-24 22:32:30 +0000 | [diff] [blame] | 330 | } |
| 331 | |
| 332 | /* |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 333 | ** Return the address of the next instruction to be inserted. |
| 334 | */ |
danielk1977 | 4adee20 | 2004-05-08 08:23:19 +0000 | [diff] [blame] | 335 | int sqlite3VdbeCurrentAddr(Vdbe *p){ |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 336 | assert( p->magic==VDBE_MAGIC_INIT ); |
| 337 | return p->nOp; |
| 338 | } |
| 339 | |
| 340 | /* |
| 341 | ** Add a whole list of operations to the operation stack. Return the |
| 342 | ** address of the first operation added. |
| 343 | */ |
danielk1977 | 4adee20 | 2004-05-08 08:23:19 +0000 | [diff] [blame] | 344 | int sqlite3VdbeAddOpList(Vdbe *p, int nOp, VdbeOpList const *aOp){ |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 345 | int addr; |
| 346 | assert( p->magic==VDBE_MAGIC_INIT ); |
danielk1977 | 00e1361 | 2008-11-17 19:18:54 +0000 | [diff] [blame] | 347 | if( p->nOp + nOp > p->nOpAlloc && growOpArray(p) ){ |
drh | 76ff3a0 | 2004-09-24 22:32:30 +0000 | [diff] [blame] | 348 | return 0; |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 349 | } |
| 350 | addr = p->nOp; |
| 351 | if( nOp>0 ){ |
| 352 | int i; |
drh | 905793e | 2004-02-21 13:31:09 +0000 | [diff] [blame] | 353 | VdbeOpList const *pIn = aOp; |
| 354 | for(i=0; i<nOp; i++, pIn++){ |
| 355 | int p2 = pIn->p2; |
| 356 | VdbeOp *pOut = &p->aOp[i+addr]; |
| 357 | pOut->opcode = pIn->opcode; |
| 358 | pOut->p1 = pIn->p1; |
drh | 8558cde | 2008-01-05 05:20:10 +0000 | [diff] [blame] | 359 | if( p2<0 && sqlite3VdbeOpcodeHasProperty(pOut->opcode, OPFLG_JUMP) ){ |
| 360 | pOut->p2 = addr + ADDR(p2); |
| 361 | }else{ |
| 362 | pOut->p2 = p2; |
| 363 | } |
drh | 2400345 | 2008-01-03 01:28:59 +0000 | [diff] [blame] | 364 | pOut->p3 = pIn->p3; |
| 365 | pOut->p4type = P4_NOTUSED; |
| 366 | pOut->p4.p = 0; |
| 367 | pOut->p5 = 0; |
danielk1977 | 8b60e0f | 2005-01-12 09:10:39 +0000 | [diff] [blame] | 368 | #ifdef SQLITE_DEBUG |
drh | 26c9b5e | 2008-04-11 14:56:53 +0000 | [diff] [blame] | 369 | pOut->zComment = 0; |
mlcreech | 3a00f90 | 2008-03-04 17:45:01 +0000 | [diff] [blame] | 370 | if( sqlite3VdbeAddopTrace ){ |
danielk1977 | 4adee20 | 2004-05-08 08:23:19 +0000 | [diff] [blame] | 371 | sqlite3VdbePrintOp(0, i+addr, &p->aOp[i+addr]); |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 372 | } |
| 373 | #endif |
| 374 | } |
| 375 | p->nOp += nOp; |
| 376 | } |
| 377 | return addr; |
| 378 | } |
| 379 | |
| 380 | /* |
| 381 | ** Change the value of the P1 operand for a specific instruction. |
| 382 | ** This routine is useful when a large program is loaded from a |
danielk1977 | 4adee20 | 2004-05-08 08:23:19 +0000 | [diff] [blame] | 383 | ** static array using sqlite3VdbeAddOpList but we want to make a |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 384 | ** few minor changes to the program. |
| 385 | */ |
danielk1977 | 4adee20 | 2004-05-08 08:23:19 +0000 | [diff] [blame] | 386 | void sqlite3VdbeChangeP1(Vdbe *p, int addr, int val){ |
drh | 8aa34ae | 2006-03-13 12:54:09 +0000 | [diff] [blame] | 387 | assert( p==0 || p->magic==VDBE_MAGIC_INIT ); |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 388 | if( p && addr>=0 && p->nOp>addr && p->aOp ){ |
| 389 | p->aOp[addr].p1 = val; |
| 390 | } |
| 391 | } |
| 392 | |
| 393 | /* |
| 394 | ** Change the value of the P2 operand for a specific instruction. |
| 395 | ** This routine is useful for setting a jump destination. |
| 396 | */ |
danielk1977 | 4adee20 | 2004-05-08 08:23:19 +0000 | [diff] [blame] | 397 | void sqlite3VdbeChangeP2(Vdbe *p, int addr, int val){ |
drh | 8aa34ae | 2006-03-13 12:54:09 +0000 | [diff] [blame] | 398 | assert( p==0 || p->magic==VDBE_MAGIC_INIT ); |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 399 | if( p && addr>=0 && p->nOp>addr && p->aOp ){ |
| 400 | p->aOp[addr].p2 = val; |
| 401 | } |
| 402 | } |
| 403 | |
drh | d654be8 | 2005-09-20 17:42:23 +0000 | [diff] [blame] | 404 | /* |
danielk1977 | 1f4aa33 | 2008-01-03 09:51:55 +0000 | [diff] [blame] | 405 | ** Change the value of the P3 operand for a specific instruction. |
danielk1977 | 207872a | 2008-01-03 07:54:23 +0000 | [diff] [blame] | 406 | */ |
| 407 | void sqlite3VdbeChangeP3(Vdbe *p, int addr, int val){ |
| 408 | assert( p==0 || p->magic==VDBE_MAGIC_INIT ); |
| 409 | if( p && addr>=0 && p->nOp>addr && p->aOp ){ |
| 410 | p->aOp[addr].p3 = val; |
| 411 | } |
| 412 | } |
| 413 | |
| 414 | /* |
drh | 3557335 | 2008-01-08 23:54:25 +0000 | [diff] [blame] | 415 | ** Change the value of the P5 operand for the most recently |
| 416 | ** added operation. |
danielk1977 | 1f4aa33 | 2008-01-03 09:51:55 +0000 | [diff] [blame] | 417 | */ |
drh | 3557335 | 2008-01-08 23:54:25 +0000 | [diff] [blame] | 418 | void sqlite3VdbeChangeP5(Vdbe *p, u8 val){ |
danielk1977 | 1f4aa33 | 2008-01-03 09:51:55 +0000 | [diff] [blame] | 419 | assert( p==0 || p->magic==VDBE_MAGIC_INIT ); |
drh | 3557335 | 2008-01-08 23:54:25 +0000 | [diff] [blame] | 420 | if( p && p->aOp ){ |
| 421 | assert( p->nOp>0 ); |
| 422 | p->aOp[p->nOp-1].p5 = val; |
danielk1977 | 1f4aa33 | 2008-01-03 09:51:55 +0000 | [diff] [blame] | 423 | } |
| 424 | } |
| 425 | |
| 426 | /* |
drh | f887540 | 2006-03-17 13:56:34 +0000 | [diff] [blame] | 427 | ** Change the P2 operand of instruction addr so that it points to |
drh | d654be8 | 2005-09-20 17:42:23 +0000 | [diff] [blame] | 428 | ** the address of the next instruction to be coded. |
| 429 | */ |
| 430 | void sqlite3VdbeJumpHere(Vdbe *p, int addr){ |
| 431 | sqlite3VdbeChangeP2(p, addr, p->nOp); |
| 432 | } |
drh | b38ad99 | 2005-09-16 00:27:01 +0000 | [diff] [blame] | 433 | |
drh | b7f6f68 | 2006-07-08 17:06:43 +0000 | [diff] [blame] | 434 | |
| 435 | /* |
| 436 | ** If the input FuncDef structure is ephemeral, then free it. If |
| 437 | ** the FuncDef is not ephermal, then do nothing. |
| 438 | */ |
drh | 633e6d5 | 2008-07-28 19:34:53 +0000 | [diff] [blame] | 439 | static void freeEphemeralFunction(sqlite3 *db, FuncDef *pDef){ |
drh | b7f6f68 | 2006-07-08 17:06:43 +0000 | [diff] [blame] | 440 | if( pDef && (pDef->flags & SQLITE_FUNC_EPHEM)!=0 ){ |
drh | 633e6d5 | 2008-07-28 19:34:53 +0000 | [diff] [blame] | 441 | sqlite3DbFree(db, pDef); |
drh | b7f6f68 | 2006-07-08 17:06:43 +0000 | [diff] [blame] | 442 | } |
| 443 | } |
| 444 | |
drh | b38ad99 | 2005-09-16 00:27:01 +0000 | [diff] [blame] | 445 | /* |
drh | 66a5167 | 2008-01-03 00:01:23 +0000 | [diff] [blame] | 446 | ** Delete a P4 value if necessary. |
drh | b38ad99 | 2005-09-16 00:27:01 +0000 | [diff] [blame] | 447 | */ |
drh | 633e6d5 | 2008-07-28 19:34:53 +0000 | [diff] [blame] | 448 | static void freeP4(sqlite3 *db, int p4type, void *p4){ |
drh | 0acb7e4 | 2008-06-25 00:12:41 +0000 | [diff] [blame] | 449 | if( p4 ){ |
drh | 66a5167 | 2008-01-03 00:01:23 +0000 | [diff] [blame] | 450 | switch( p4type ){ |
| 451 | case P4_REAL: |
| 452 | case P4_INT64: |
| 453 | case P4_MPRINTF: |
| 454 | case P4_DYNAMIC: |
| 455 | case P4_KEYINFO: |
drh | 0acb7e4 | 2008-06-25 00:12:41 +0000 | [diff] [blame] | 456 | case P4_INTARRAY: |
drh | 66a5167 | 2008-01-03 00:01:23 +0000 | [diff] [blame] | 457 | case P4_KEYINFO_HANDOFF: { |
drh | 633e6d5 | 2008-07-28 19:34:53 +0000 | [diff] [blame] | 458 | sqlite3DbFree(db, p4); |
drh | ac1733d | 2005-09-17 17:58:22 +0000 | [diff] [blame] | 459 | break; |
| 460 | } |
drh | 66a5167 | 2008-01-03 00:01:23 +0000 | [diff] [blame] | 461 | case P4_VDBEFUNC: { |
drh | 0acb7e4 | 2008-06-25 00:12:41 +0000 | [diff] [blame] | 462 | VdbeFunc *pVdbeFunc = (VdbeFunc *)p4; |
drh | 633e6d5 | 2008-07-28 19:34:53 +0000 | [diff] [blame] | 463 | freeEphemeralFunction(db, pVdbeFunc->pFunc); |
drh | ac1733d | 2005-09-17 17:58:22 +0000 | [diff] [blame] | 464 | sqlite3VdbeDeleteAuxData(pVdbeFunc, 0); |
drh | 633e6d5 | 2008-07-28 19:34:53 +0000 | [diff] [blame] | 465 | sqlite3DbFree(db, pVdbeFunc); |
drh | ac1733d | 2005-09-17 17:58:22 +0000 | [diff] [blame] | 466 | break; |
| 467 | } |
drh | 66a5167 | 2008-01-03 00:01:23 +0000 | [diff] [blame] | 468 | case P4_FUNCDEF: { |
drh | 633e6d5 | 2008-07-28 19:34:53 +0000 | [diff] [blame] | 469 | freeEphemeralFunction(db, (FuncDef*)p4); |
drh | b7f6f68 | 2006-07-08 17:06:43 +0000 | [diff] [blame] | 470 | break; |
| 471 | } |
drh | 66a5167 | 2008-01-03 00:01:23 +0000 | [diff] [blame] | 472 | case P4_MEM: { |
drh | 0acb7e4 | 2008-06-25 00:12:41 +0000 | [diff] [blame] | 473 | sqlite3ValueFree((sqlite3_value*)p4); |
drh | ac1733d | 2005-09-17 17:58:22 +0000 | [diff] [blame] | 474 | break; |
| 475 | } |
drh | b38ad99 | 2005-09-16 00:27:01 +0000 | [diff] [blame] | 476 | } |
| 477 | } |
| 478 | } |
| 479 | |
| 480 | |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 481 | /* |
drh | f887540 | 2006-03-17 13:56:34 +0000 | [diff] [blame] | 482 | ** Change N opcodes starting at addr to No-ops. |
| 483 | */ |
| 484 | void sqlite3VdbeChangeToNoop(Vdbe *p, int addr, int N){ |
danielk1977 | 92d4d7a | 2007-05-04 12:05:56 +0000 | [diff] [blame] | 485 | if( p && p->aOp ){ |
| 486 | VdbeOp *pOp = &p->aOp[addr]; |
drh | 633e6d5 | 2008-07-28 19:34:53 +0000 | [diff] [blame] | 487 | sqlite3 *db = p->db; |
danielk1977 | 92d4d7a | 2007-05-04 12:05:56 +0000 | [diff] [blame] | 488 | while( N-- ){ |
drh | 633e6d5 | 2008-07-28 19:34:53 +0000 | [diff] [blame] | 489 | freeP4(db, pOp->p4type, pOp->p4.p); |
danielk1977 | 92d4d7a | 2007-05-04 12:05:56 +0000 | [diff] [blame] | 490 | memset(pOp, 0, sizeof(pOp[0])); |
| 491 | pOp->opcode = OP_Noop; |
| 492 | pOp++; |
| 493 | } |
drh | f887540 | 2006-03-17 13:56:34 +0000 | [diff] [blame] | 494 | } |
| 495 | } |
| 496 | |
| 497 | /* |
drh | 66a5167 | 2008-01-03 00:01:23 +0000 | [diff] [blame] | 498 | ** Change the value of the P4 operand for a specific instruction. |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 499 | ** This routine is useful when a large program is loaded from a |
danielk1977 | 4adee20 | 2004-05-08 08:23:19 +0000 | [diff] [blame] | 500 | ** static array using sqlite3VdbeAddOpList but we want to make a |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 501 | ** few minor changes to the program. |
| 502 | ** |
drh | 66a5167 | 2008-01-03 00:01:23 +0000 | [diff] [blame] | 503 | ** If n>=0 then the P4 operand is dynamic, meaning that a copy of |
drh | 1743575 | 2007-08-16 04:30:38 +0000 | [diff] [blame] | 504 | ** the string is made into memory obtained from sqlite3_malloc(). |
drh | 66a5167 | 2008-01-03 00:01:23 +0000 | [diff] [blame] | 505 | ** A value of n==0 means copy bytes of zP4 up to and including the |
| 506 | ** first null byte. If n>0 then copy n+1 bytes of zP4. |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 507 | ** |
drh | 66a5167 | 2008-01-03 00:01:23 +0000 | [diff] [blame] | 508 | ** If n==P4_KEYINFO it means that zP4 is a pointer to a KeyInfo structure. |
danielk1977 | 1f55c05 | 2005-05-19 08:42:59 +0000 | [diff] [blame] | 509 | ** A copy is made of the KeyInfo structure into memory obtained from |
drh | 1743575 | 2007-08-16 04:30:38 +0000 | [diff] [blame] | 510 | ** sqlite3_malloc, to be freed when the Vdbe is finalized. |
drh | 66a5167 | 2008-01-03 00:01:23 +0000 | [diff] [blame] | 511 | ** n==P4_KEYINFO_HANDOFF indicates that zP4 points to a KeyInfo structure |
drh | 1743575 | 2007-08-16 04:30:38 +0000 | [diff] [blame] | 512 | ** stored in memory that the caller has obtained from sqlite3_malloc. The |
danielk1977 | 1f55c05 | 2005-05-19 08:42:59 +0000 | [diff] [blame] | 513 | ** caller should not free the allocation, it will be freed when the Vdbe is |
| 514 | ** finalized. |
| 515 | ** |
drh | 66a5167 | 2008-01-03 00:01:23 +0000 | [diff] [blame] | 516 | ** Other values of n (P4_STATIC, P4_COLLSEQ etc.) indicate that zP4 points |
danielk1977 | 1f55c05 | 2005-05-19 08:42:59 +0000 | [diff] [blame] | 517 | ** to a string or structure that is guaranteed to exist for the lifetime of |
| 518 | ** the Vdbe. In these cases we can just copy the pointer. |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 519 | ** |
drh | 66a5167 | 2008-01-03 00:01:23 +0000 | [diff] [blame] | 520 | ** If addr<0 then change P4 on the most recently inserted instruction. |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 521 | */ |
drh | 66a5167 | 2008-01-03 00:01:23 +0000 | [diff] [blame] | 522 | void sqlite3VdbeChangeP4(Vdbe *p, int addr, const char *zP4, int n){ |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 523 | Op *pOp; |
drh | 633e6d5 | 2008-07-28 19:34:53 +0000 | [diff] [blame] | 524 | sqlite3 *db; |
drh | 91fd4d4 | 2008-01-19 20:11:25 +0000 | [diff] [blame] | 525 | assert( p!=0 ); |
drh | 633e6d5 | 2008-07-28 19:34:53 +0000 | [diff] [blame] | 526 | db = p->db; |
drh | 91fd4d4 | 2008-01-19 20:11:25 +0000 | [diff] [blame] | 527 | assert( p->magic==VDBE_MAGIC_INIT ); |
drh | 633e6d5 | 2008-07-28 19:34:53 +0000 | [diff] [blame] | 528 | if( p->aOp==0 || db->mallocFailed ){ |
drh | 66a5167 | 2008-01-03 00:01:23 +0000 | [diff] [blame] | 529 | if (n != P4_KEYINFO) { |
drh | 633e6d5 | 2008-07-28 19:34:53 +0000 | [diff] [blame] | 530 | freeP4(db, n, (void*)*(char**)&zP4); |
danielk1977 | 261919c | 2005-12-06 12:52:59 +0000 | [diff] [blame] | 531 | } |
danielk1977 | d5d5652 | 2005-03-16 12:15:20 +0000 | [diff] [blame] | 532 | return; |
| 533 | } |
drh | 91fd4d4 | 2008-01-19 20:11:25 +0000 | [diff] [blame] | 534 | assert( addr<p->nOp ); |
| 535 | if( addr<0 ){ |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 536 | addr = p->nOp - 1; |
| 537 | if( addr<0 ) return; |
| 538 | } |
| 539 | pOp = &p->aOp[addr]; |
drh | 633e6d5 | 2008-07-28 19:34:53 +0000 | [diff] [blame] | 540 | freeP4(db, pOp->p4type, pOp->p4.p); |
drh | 66a5167 | 2008-01-03 00:01:23 +0000 | [diff] [blame] | 541 | pOp->p4.p = 0; |
drh | 9875715 | 2008-01-09 23:04:12 +0000 | [diff] [blame] | 542 | if( n==P4_INT32 ){ |
mlcreech | 12d4082 | 2008-03-06 07:35:21 +0000 | [diff] [blame] | 543 | /* Note: this cast is safe, because the origin data point was an int |
| 544 | ** that was cast to a (const char *). */ |
shane | 1fc4129 | 2008-07-08 22:28:48 +0000 | [diff] [blame] | 545 | pOp->p4.i = SQLITE_PTR_TO_INT(zP4); |
drh | 9875715 | 2008-01-09 23:04:12 +0000 | [diff] [blame] | 546 | pOp->p4type = n; |
| 547 | }else if( zP4==0 ){ |
drh | 66a5167 | 2008-01-03 00:01:23 +0000 | [diff] [blame] | 548 | pOp->p4.p = 0; |
| 549 | pOp->p4type = P4_NOTUSED; |
| 550 | }else if( n==P4_KEYINFO ){ |
drh | d3d39e9 | 2004-05-20 22:16:29 +0000 | [diff] [blame] | 551 | KeyInfo *pKeyInfo; |
| 552 | int nField, nByte; |
drh | 4db38a7 | 2005-09-01 12:16:28 +0000 | [diff] [blame] | 553 | |
drh | 66a5167 | 2008-01-03 00:01:23 +0000 | [diff] [blame] | 554 | nField = ((KeyInfo*)zP4)->nField; |
drh | fdd6e85 | 2005-12-16 01:06:16 +0000 | [diff] [blame] | 555 | nByte = sizeof(*pKeyInfo) + (nField-1)*sizeof(pKeyInfo->aColl[0]) + nField; |
drh | e5ae573 | 2008-06-15 02:51:47 +0000 | [diff] [blame] | 556 | pKeyInfo = sqlite3Malloc( nByte ); |
danielk1977 | 2dca4ac | 2008-01-03 11:50:29 +0000 | [diff] [blame] | 557 | pOp->p4.pKeyInfo = pKeyInfo; |
drh | d3d39e9 | 2004-05-20 22:16:29 +0000 | [diff] [blame] | 558 | if( pKeyInfo ){ |
drh | b21e7c7 | 2008-06-22 12:37:57 +0000 | [diff] [blame] | 559 | u8 *aSortOrder; |
drh | 66a5167 | 2008-01-03 00:01:23 +0000 | [diff] [blame] | 560 | memcpy(pKeyInfo, zP4, nByte); |
drh | fdd6e85 | 2005-12-16 01:06:16 +0000 | [diff] [blame] | 561 | aSortOrder = pKeyInfo->aSortOrder; |
| 562 | if( aSortOrder ){ |
danielk1977 | bab45c6 | 2006-01-16 15:14:27 +0000 | [diff] [blame] | 563 | pKeyInfo->aSortOrder = (unsigned char*)&pKeyInfo->aColl[nField]; |
drh | fdd6e85 | 2005-12-16 01:06:16 +0000 | [diff] [blame] | 564 | memcpy(pKeyInfo->aSortOrder, aSortOrder, nField); |
| 565 | } |
drh | 66a5167 | 2008-01-03 00:01:23 +0000 | [diff] [blame] | 566 | pOp->p4type = P4_KEYINFO; |
drh | d3d39e9 | 2004-05-20 22:16:29 +0000 | [diff] [blame] | 567 | }else{ |
drh | 1743575 | 2007-08-16 04:30:38 +0000 | [diff] [blame] | 568 | p->db->mallocFailed = 1; |
drh | 66a5167 | 2008-01-03 00:01:23 +0000 | [diff] [blame] | 569 | pOp->p4type = P4_NOTUSED; |
drh | d3d39e9 | 2004-05-20 22:16:29 +0000 | [diff] [blame] | 570 | } |
drh | 66a5167 | 2008-01-03 00:01:23 +0000 | [diff] [blame] | 571 | }else if( n==P4_KEYINFO_HANDOFF ){ |
danielk1977 | 2dca4ac | 2008-01-03 11:50:29 +0000 | [diff] [blame] | 572 | pOp->p4.p = (void*)zP4; |
drh | 66a5167 | 2008-01-03 00:01:23 +0000 | [diff] [blame] | 573 | pOp->p4type = P4_KEYINFO; |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 574 | }else if( n<0 ){ |
danielk1977 | 2dca4ac | 2008-01-03 11:50:29 +0000 | [diff] [blame] | 575 | pOp->p4.p = (void*)zP4; |
drh | 66a5167 | 2008-01-03 00:01:23 +0000 | [diff] [blame] | 576 | pOp->p4type = n; |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 577 | }else{ |
drh | 66a5167 | 2008-01-03 00:01:23 +0000 | [diff] [blame] | 578 | if( n==0 ) n = strlen(zP4); |
danielk1977 | 2dca4ac | 2008-01-03 11:50:29 +0000 | [diff] [blame] | 579 | pOp->p4.z = sqlite3DbStrNDup(p->db, zP4, n); |
drh | 66a5167 | 2008-01-03 00:01:23 +0000 | [diff] [blame] | 580 | pOp->p4type = P4_DYNAMIC; |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 581 | } |
| 582 | } |
| 583 | |
drh | ad6d946 | 2004-09-19 02:15:24 +0000 | [diff] [blame] | 584 | #ifndef NDEBUG |
| 585 | /* |
drh | 16ee60f | 2008-06-20 18:13:25 +0000 | [diff] [blame] | 586 | ** Change the comment on the the most recently coded instruction. Or |
| 587 | ** insert a No-op and add the comment to that new instruction. This |
| 588 | ** makes the code easier to read during debugging. None of this happens |
| 589 | ** in a production build. |
drh | ad6d946 | 2004-09-19 02:15:24 +0000 | [diff] [blame] | 590 | */ |
| 591 | void sqlite3VdbeComment(Vdbe *p, const char *zFormat, ...){ |
| 592 | va_list ap; |
danielk1977 | 0125683 | 2007-04-18 14:24:32 +0000 | [diff] [blame] | 593 | assert( p->nOp>0 || p->aOp==0 ); |
drh | d4e70eb | 2008-01-02 00:34:36 +0000 | [diff] [blame] | 594 | assert( p->aOp==0 || p->aOp[p->nOp-1].zComment==0 || p->db->mallocFailed ); |
danielk1977 | dba0137 | 2008-01-05 18:44:29 +0000 | [diff] [blame] | 595 | if( p->nOp ){ |
drh | 8cc7432 | 2008-01-15 02:22:24 +0000 | [diff] [blame] | 596 | char **pz = &p->aOp[p->nOp-1].zComment; |
danielk1977 | dba0137 | 2008-01-05 18:44:29 +0000 | [diff] [blame] | 597 | va_start(ap, zFormat); |
drh | 633e6d5 | 2008-07-28 19:34:53 +0000 | [diff] [blame] | 598 | sqlite3DbFree(p->db, *pz); |
drh | 8cc7432 | 2008-01-15 02:22:24 +0000 | [diff] [blame] | 599 | *pz = sqlite3VMPrintf(p->db, zFormat, ap); |
danielk1977 | dba0137 | 2008-01-05 18:44:29 +0000 | [diff] [blame] | 600 | va_end(ap); |
| 601 | } |
drh | ad6d946 | 2004-09-19 02:15:24 +0000 | [diff] [blame] | 602 | } |
drh | 16ee60f | 2008-06-20 18:13:25 +0000 | [diff] [blame] | 603 | void sqlite3VdbeNoopComment(Vdbe *p, const char *zFormat, ...){ |
| 604 | va_list ap; |
| 605 | sqlite3VdbeAddOp0(p, OP_Noop); |
| 606 | assert( p->nOp>0 || p->aOp==0 ); |
| 607 | assert( p->aOp==0 || p->aOp[p->nOp-1].zComment==0 || p->db->mallocFailed ); |
| 608 | if( p->nOp ){ |
| 609 | char **pz = &p->aOp[p->nOp-1].zComment; |
| 610 | va_start(ap, zFormat); |
drh | 633e6d5 | 2008-07-28 19:34:53 +0000 | [diff] [blame] | 611 | sqlite3DbFree(p->db, *pz); |
drh | 16ee60f | 2008-06-20 18:13:25 +0000 | [diff] [blame] | 612 | *pz = sqlite3VMPrintf(p->db, zFormat, ap); |
| 613 | va_end(ap); |
| 614 | } |
| 615 | } |
| 616 | #endif /* NDEBUG */ |
drh | ad6d946 | 2004-09-19 02:15:24 +0000 | [diff] [blame] | 617 | |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 618 | /* |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 619 | ** Return the opcode for a given address. |
| 620 | */ |
danielk1977 | 4adee20 | 2004-05-08 08:23:19 +0000 | [diff] [blame] | 621 | VdbeOp *sqlite3VdbeGetOp(Vdbe *p, int addr){ |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 622 | assert( p->magic==VDBE_MAGIC_INIT ); |
drh | 1743575 | 2007-08-16 04:30:38 +0000 | [diff] [blame] | 623 | assert( (addr>=0 && addr<p->nOp) || p->db->mallocFailed ); |
danielk1977 | 0125683 | 2007-04-18 14:24:32 +0000 | [diff] [blame] | 624 | return ((addr>=0 && addr<p->nOp)?(&p->aOp[addr]):0); |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 625 | } |
| 626 | |
drh | b7f9164 | 2004-10-31 02:22:47 +0000 | [diff] [blame] | 627 | #if !defined(SQLITE_OMIT_EXPLAIN) || !defined(NDEBUG) \ |
| 628 | || defined(VDBE_PROFILE) || defined(SQLITE_DEBUG) |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 629 | /* |
drh | 66a5167 | 2008-01-03 00:01:23 +0000 | [diff] [blame] | 630 | ** Compute a string that describes the P4 parameter for an opcode. |
drh | d3d39e9 | 2004-05-20 22:16:29 +0000 | [diff] [blame] | 631 | ** Use zTemp for any required temporary buffer space. |
| 632 | */ |
drh | 66a5167 | 2008-01-03 00:01:23 +0000 | [diff] [blame] | 633 | static char *displayP4(Op *pOp, char *zTemp, int nTemp){ |
| 634 | char *zP4 = zTemp; |
drh | d3d39e9 | 2004-05-20 22:16:29 +0000 | [diff] [blame] | 635 | assert( nTemp>=20 ); |
drh | 66a5167 | 2008-01-03 00:01:23 +0000 | [diff] [blame] | 636 | switch( pOp->p4type ){ |
drh | 16ee60f | 2008-06-20 18:13:25 +0000 | [diff] [blame] | 637 | case P4_KEYINFO_STATIC: |
drh | 66a5167 | 2008-01-03 00:01:23 +0000 | [diff] [blame] | 638 | case P4_KEYINFO: { |
drh | d3d39e9 | 2004-05-20 22:16:29 +0000 | [diff] [blame] | 639 | int i, j; |
danielk1977 | 2dca4ac | 2008-01-03 11:50:29 +0000 | [diff] [blame] | 640 | KeyInfo *pKeyInfo = pOp->p4.pKeyInfo; |
drh | 5bb3eb9 | 2007-05-04 13:15:55 +0000 | [diff] [blame] | 641 | sqlite3_snprintf(nTemp, zTemp, "keyinfo(%d", pKeyInfo->nField); |
drh | d3d39e9 | 2004-05-20 22:16:29 +0000 | [diff] [blame] | 642 | i = strlen(zTemp); |
| 643 | for(j=0; j<pKeyInfo->nField; j++){ |
| 644 | CollSeq *pColl = pKeyInfo->aColl[j]; |
| 645 | if( pColl ){ |
| 646 | int n = strlen(pColl->zName); |
| 647 | if( i+n>nTemp-6 ){ |
drh | 5bb3eb9 | 2007-05-04 13:15:55 +0000 | [diff] [blame] | 648 | memcpy(&zTemp[i],",...",4); |
drh | d3d39e9 | 2004-05-20 22:16:29 +0000 | [diff] [blame] | 649 | break; |
| 650 | } |
| 651 | zTemp[i++] = ','; |
drh | ffbc308 | 2004-05-21 01:29:06 +0000 | [diff] [blame] | 652 | if( pKeyInfo->aSortOrder && pKeyInfo->aSortOrder[j] ){ |
drh | d3d39e9 | 2004-05-20 22:16:29 +0000 | [diff] [blame] | 653 | zTemp[i++] = '-'; |
| 654 | } |
drh | 5bb3eb9 | 2007-05-04 13:15:55 +0000 | [diff] [blame] | 655 | memcpy(&zTemp[i], pColl->zName,n+1); |
drh | d3d39e9 | 2004-05-20 22:16:29 +0000 | [diff] [blame] | 656 | i += n; |
| 657 | }else if( i+4<nTemp-6 ){ |
drh | 5bb3eb9 | 2007-05-04 13:15:55 +0000 | [diff] [blame] | 658 | memcpy(&zTemp[i],",nil",4); |
drh | d3d39e9 | 2004-05-20 22:16:29 +0000 | [diff] [blame] | 659 | i += 4; |
| 660 | } |
| 661 | } |
| 662 | zTemp[i++] = ')'; |
| 663 | zTemp[i] = 0; |
| 664 | assert( i<nTemp ); |
drh | d3d39e9 | 2004-05-20 22:16:29 +0000 | [diff] [blame] | 665 | break; |
| 666 | } |
drh | 66a5167 | 2008-01-03 00:01:23 +0000 | [diff] [blame] | 667 | case P4_COLLSEQ: { |
danielk1977 | 2dca4ac | 2008-01-03 11:50:29 +0000 | [diff] [blame] | 668 | CollSeq *pColl = pOp->p4.pColl; |
drh | 5bb3eb9 | 2007-05-04 13:15:55 +0000 | [diff] [blame] | 669 | sqlite3_snprintf(nTemp, zTemp, "collseq(%.20s)", pColl->zName); |
drh | d3d39e9 | 2004-05-20 22:16:29 +0000 | [diff] [blame] | 670 | break; |
| 671 | } |
drh | 66a5167 | 2008-01-03 00:01:23 +0000 | [diff] [blame] | 672 | case P4_FUNCDEF: { |
danielk1977 | 2dca4ac | 2008-01-03 11:50:29 +0000 | [diff] [blame] | 673 | FuncDef *pDef = pOp->p4.pFunc; |
drh | a967e88 | 2006-06-13 01:04:52 +0000 | [diff] [blame] | 674 | sqlite3_snprintf(nTemp, zTemp, "%s(%d)", pDef->zName, pDef->nArg); |
drh | f9b596e | 2004-05-26 16:54:42 +0000 | [diff] [blame] | 675 | break; |
| 676 | } |
drh | 66a5167 | 2008-01-03 00:01:23 +0000 | [diff] [blame] | 677 | case P4_INT64: { |
danielk1977 | 2dca4ac | 2008-01-03 11:50:29 +0000 | [diff] [blame] | 678 | sqlite3_snprintf(nTemp, zTemp, "%lld", *pOp->p4.pI64); |
drh | d4e70eb | 2008-01-02 00:34:36 +0000 | [diff] [blame] | 679 | break; |
| 680 | } |
drh | 66a5167 | 2008-01-03 00:01:23 +0000 | [diff] [blame] | 681 | case P4_INT32: { |
| 682 | sqlite3_snprintf(nTemp, zTemp, "%d", pOp->p4.i); |
drh | 598f134 | 2007-10-23 15:39:45 +0000 | [diff] [blame] | 683 | break; |
| 684 | } |
drh | 66a5167 | 2008-01-03 00:01:23 +0000 | [diff] [blame] | 685 | case P4_REAL: { |
danielk1977 | 2dca4ac | 2008-01-03 11:50:29 +0000 | [diff] [blame] | 686 | sqlite3_snprintf(nTemp, zTemp, "%.16g", *pOp->p4.pReal); |
drh | d4e70eb | 2008-01-02 00:34:36 +0000 | [diff] [blame] | 687 | break; |
| 688 | } |
drh | 66a5167 | 2008-01-03 00:01:23 +0000 | [diff] [blame] | 689 | case P4_MEM: { |
danielk1977 | 2dca4ac | 2008-01-03 11:50:29 +0000 | [diff] [blame] | 690 | Mem *pMem = pOp->p4.pMem; |
drh | c4dd3fd | 2008-01-22 01:48:05 +0000 | [diff] [blame] | 691 | assert( (pMem->flags & MEM_Null)==0 ); |
drh | d4e70eb | 2008-01-02 00:34:36 +0000 | [diff] [blame] | 692 | if( pMem->flags & MEM_Str ){ |
drh | 66a5167 | 2008-01-03 00:01:23 +0000 | [diff] [blame] | 693 | zP4 = pMem->z; |
drh | d4e70eb | 2008-01-02 00:34:36 +0000 | [diff] [blame] | 694 | }else if( pMem->flags & MEM_Int ){ |
| 695 | sqlite3_snprintf(nTemp, zTemp, "%lld", pMem->u.i); |
| 696 | }else if( pMem->flags & MEM_Real ){ |
| 697 | sqlite3_snprintf(nTemp, zTemp, "%.16g", pMem->r); |
drh | d4e70eb | 2008-01-02 00:34:36 +0000 | [diff] [blame] | 698 | } |
drh | 598f134 | 2007-10-23 15:39:45 +0000 | [diff] [blame] | 699 | break; |
| 700 | } |
drh | a967e88 | 2006-06-13 01:04:52 +0000 | [diff] [blame] | 701 | #ifndef SQLITE_OMIT_VIRTUALTABLE |
drh | 66a5167 | 2008-01-03 00:01:23 +0000 | [diff] [blame] | 702 | case P4_VTAB: { |
danielk1977 | 2dca4ac | 2008-01-03 11:50:29 +0000 | [diff] [blame] | 703 | sqlite3_vtab *pVtab = pOp->p4.pVtab; |
drh | 1914619 | 2006-06-26 19:10:32 +0000 | [diff] [blame] | 704 | sqlite3_snprintf(nTemp, zTemp, "vtab:%p:%p", pVtab, pVtab->pModule); |
drh | a967e88 | 2006-06-13 01:04:52 +0000 | [diff] [blame] | 705 | break; |
| 706 | } |
| 707 | #endif |
drh | 0acb7e4 | 2008-06-25 00:12:41 +0000 | [diff] [blame] | 708 | case P4_INTARRAY: { |
| 709 | sqlite3_snprintf(nTemp, zTemp, "intarray"); |
| 710 | break; |
| 711 | } |
drh | d3d39e9 | 2004-05-20 22:16:29 +0000 | [diff] [blame] | 712 | default: { |
danielk1977 | 2dca4ac | 2008-01-03 11:50:29 +0000 | [diff] [blame] | 713 | zP4 = pOp->p4.z; |
drh | 949f9cd | 2008-01-12 21:35:57 +0000 | [diff] [blame] | 714 | if( zP4==0 ){ |
drh | 66a5167 | 2008-01-03 00:01:23 +0000 | [diff] [blame] | 715 | zP4 = zTemp; |
drh | d4e70eb | 2008-01-02 00:34:36 +0000 | [diff] [blame] | 716 | zTemp[0] = 0; |
drh | d3d39e9 | 2004-05-20 22:16:29 +0000 | [diff] [blame] | 717 | } |
| 718 | } |
| 719 | } |
drh | 66a5167 | 2008-01-03 00:01:23 +0000 | [diff] [blame] | 720 | assert( zP4!=0 ); |
drh | 66a5167 | 2008-01-03 00:01:23 +0000 | [diff] [blame] | 721 | return zP4; |
drh | d3d39e9 | 2004-05-20 22:16:29 +0000 | [diff] [blame] | 722 | } |
drh | b7f9164 | 2004-10-31 02:22:47 +0000 | [diff] [blame] | 723 | #endif |
drh | d3d39e9 | 2004-05-20 22:16:29 +0000 | [diff] [blame] | 724 | |
drh | 900b31e | 2007-08-28 02:27:51 +0000 | [diff] [blame] | 725 | /* |
drh | d0679ed | 2007-08-28 22:24:34 +0000 | [diff] [blame] | 726 | ** Declare to the Vdbe that the BTree object at db->aDb[i] is used. |
| 727 | ** |
drh | 900b31e | 2007-08-28 02:27:51 +0000 | [diff] [blame] | 728 | */ |
drh | fb98264 | 2007-08-30 01:19:59 +0000 | [diff] [blame] | 729 | void sqlite3VdbeUsesBtree(Vdbe *p, int i){ |
| 730 | int mask; |
drh | d0679ed | 2007-08-28 22:24:34 +0000 | [diff] [blame] | 731 | assert( i>=0 && i<p->db->nDb ); |
danielk1977 | 00e1361 | 2008-11-17 19:18:54 +0000 | [diff] [blame] | 732 | assert( i<(int)sizeof(p->btreeMask)*8 ); |
drh | fb98264 | 2007-08-30 01:19:59 +0000 | [diff] [blame] | 733 | mask = 1<<i; |
| 734 | if( (p->btreeMask & mask)==0 ){ |
| 735 | p->btreeMask |= mask; |
| 736 | sqlite3BtreeMutexArrayInsert(&p->aMutex, p->db->aDb[i].pBt); |
| 737 | } |
drh | 900b31e | 2007-08-28 02:27:51 +0000 | [diff] [blame] | 738 | } |
| 739 | |
drh | d3d39e9 | 2004-05-20 22:16:29 +0000 | [diff] [blame] | 740 | |
danielk1977 | 8b60e0f | 2005-01-12 09:10:39 +0000 | [diff] [blame] | 741 | #if defined(VDBE_PROFILE) || defined(SQLITE_DEBUG) |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 742 | /* |
| 743 | ** Print a single opcode. This routine is used for debugging only. |
| 744 | */ |
danielk1977 | 4adee20 | 2004-05-08 08:23:19 +0000 | [diff] [blame] | 745 | void sqlite3VdbePrintOp(FILE *pOut, int pc, Op *pOp){ |
drh | 66a5167 | 2008-01-03 00:01:23 +0000 | [diff] [blame] | 746 | char *zP4; |
drh | d3d39e9 | 2004-05-20 22:16:29 +0000 | [diff] [blame] | 747 | char zPtr[50]; |
drh | 1db639c | 2008-01-17 02:36:28 +0000 | [diff] [blame] | 748 | static const char *zFormat1 = "%4d %-13s %4d %4d %4d %-4s %.2X %s\n"; |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 749 | if( pOut==0 ) pOut = stdout; |
drh | 66a5167 | 2008-01-03 00:01:23 +0000 | [diff] [blame] | 750 | zP4 = displayP4(pOp, zPtr, sizeof(zPtr)); |
danielk1977 | 11641c1 | 2008-01-03 08:18:30 +0000 | [diff] [blame] | 751 | fprintf(pOut, zFormat1, pc, |
drh | 1db639c | 2008-01-17 02:36:28 +0000 | [diff] [blame] | 752 | sqlite3OpcodeName(pOp->opcode), pOp->p1, pOp->p2, pOp->p3, zP4, pOp->p5, |
| 753 | #ifdef SQLITE_DEBUG |
| 754 | pOp->zComment ? pOp->zComment : "" |
| 755 | #else |
| 756 | "" |
| 757 | #endif |
| 758 | ); |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 759 | fflush(pOut); |
| 760 | } |
| 761 | #endif |
| 762 | |
| 763 | /* |
drh | 76ff3a0 | 2004-09-24 22:32:30 +0000 | [diff] [blame] | 764 | ** Release an array of N Mem elements |
| 765 | */ |
drh | c890fec | 2008-08-01 20:10:08 +0000 | [diff] [blame] | 766 | static void releaseMemArray(Mem *p, int N){ |
danielk1977 | a7a8e14 | 2008-02-13 18:25:27 +0000 | [diff] [blame] | 767 | if( p && N ){ |
danielk1977 | e972e03 | 2008-09-19 18:32:26 +0000 | [diff] [blame] | 768 | Mem *pEnd; |
danielk1977 | a7a8e14 | 2008-02-13 18:25:27 +0000 | [diff] [blame] | 769 | sqlite3 *db = p->db; |
| 770 | int malloc_failed = db->mallocFailed; |
danielk1977 | e972e03 | 2008-09-19 18:32:26 +0000 | [diff] [blame] | 771 | for(pEnd=&p[N]; p<pEnd; p++){ |
| 772 | assert( (&p[1])==pEnd || p[0].db==p[1].db ); |
| 773 | |
| 774 | /* This block is really an inlined version of sqlite3VdbeMemRelease() |
| 775 | ** that takes advantage of the fact that the memory cell value is |
| 776 | ** being set to NULL after releasing any dynamic resources. |
| 777 | ** |
| 778 | ** The justification for duplicating code is that according to |
| 779 | ** callgrind, this causes a certain test case to hit the CPU 4.7 |
| 780 | ** percent less (x86 linux, gcc version 4.1.2, -O6) than if |
| 781 | ** sqlite3MemRelease() were called from here. With -O2, this jumps |
| 782 | ** to 6.6 percent. The test case is inserting 1000 rows into a table |
| 783 | ** with no indexes using a single prepared INSERT statement, bind() |
| 784 | ** and reset(). Inserts are grouped into a transaction. |
| 785 | */ |
| 786 | if( p->flags&(MEM_Agg|MEM_Dyn) ){ |
| 787 | sqlite3VdbeMemRelease(p); |
| 788 | }else if( p->zMalloc ){ |
| 789 | sqlite3DbFree(db, p->zMalloc); |
| 790 | p->zMalloc = 0; |
| 791 | } |
| 792 | |
danielk1977 | 5f09613 | 2008-03-28 15:44:09 +0000 | [diff] [blame] | 793 | p->flags = MEM_Null; |
drh | 76ff3a0 | 2004-09-24 22:32:30 +0000 | [diff] [blame] | 794 | } |
danielk1977 | a7a8e14 | 2008-02-13 18:25:27 +0000 | [diff] [blame] | 795 | db->mallocFailed = malloc_failed; |
drh | 76ff3a0 | 2004-09-24 22:32:30 +0000 | [diff] [blame] | 796 | } |
| 797 | } |
| 798 | |
danielk1977 | dfb316d | 2008-03-26 18:34:43 +0000 | [diff] [blame] | 799 | #ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT |
| 800 | int sqlite3VdbeReleaseBuffers(Vdbe *p){ |
| 801 | int ii; |
| 802 | int nFree = 0; |
| 803 | assert( sqlite3_mutex_held(p->db->mutex) ); |
| 804 | for(ii=1; ii<=p->nMem; ii++){ |
| 805 | Mem *pMem = &p->aMem[ii]; |
drh | 3d4501e | 2008-12-04 20:40:10 +0000 | [diff] [blame] | 806 | if( pMem->flags & MEM_RowSet ){ |
| 807 | sqlite3RowSetClear(pMem->u.pRowSet); |
| 808 | } |
danielk1977 | dfb316d | 2008-03-26 18:34:43 +0000 | [diff] [blame] | 809 | if( pMem->z && pMem->flags&MEM_Dyn ){ |
| 810 | assert( !pMem->xDel ); |
drh | 633e6d5 | 2008-07-28 19:34:53 +0000 | [diff] [blame] | 811 | nFree += sqlite3DbMallocSize(pMem->db, pMem->z); |
danielk1977 | dfb316d | 2008-03-26 18:34:43 +0000 | [diff] [blame] | 812 | sqlite3VdbeMemRelease(pMem); |
| 813 | } |
| 814 | } |
| 815 | return nFree; |
| 816 | } |
| 817 | #endif |
| 818 | |
drh | b7f9164 | 2004-10-31 02:22:47 +0000 | [diff] [blame] | 819 | #ifndef SQLITE_OMIT_EXPLAIN |
drh | 76ff3a0 | 2004-09-24 22:32:30 +0000 | [diff] [blame] | 820 | /* |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 821 | ** Give a listing of the program in the virtual machine. |
| 822 | ** |
danielk1977 | 4adee20 | 2004-05-08 08:23:19 +0000 | [diff] [blame] | 823 | ** The interface is the same as sqlite3VdbeExec(). But instead of |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 824 | ** running the code, it invokes the callback once for each instruction. |
| 825 | ** This feature is used to implement "EXPLAIN". |
drh | 9cbf342 | 2008-01-17 16:22:13 +0000 | [diff] [blame] | 826 | ** |
| 827 | ** When p->explain==1, each instruction is listed. When |
| 828 | ** p->explain==2, only OP_Explain instructions are listed and these |
| 829 | ** are shown in a different format. p->explain==2 is used to implement |
| 830 | ** EXPLAIN QUERY PLAN. |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 831 | */ |
danielk1977 | 4adee20 | 2004-05-08 08:23:19 +0000 | [diff] [blame] | 832 | int sqlite3VdbeList( |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 833 | Vdbe *p /* The VDBE */ |
| 834 | ){ |
drh | 9bb575f | 2004-09-06 17:24:11 +0000 | [diff] [blame] | 835 | sqlite3 *db = p->db; |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 836 | int i; |
drh | 826fb5a | 2004-02-14 23:59:57 +0000 | [diff] [blame] | 837 | int rc = SQLITE_OK; |
drh | 9cbf342 | 2008-01-17 16:22:13 +0000 | [diff] [blame] | 838 | Mem *pMem = p->pResultSet = &p->aMem[1]; |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 839 | |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 840 | assert( p->explain ); |
drh | c5cdca6 | 2005-01-11 16:54:14 +0000 | [diff] [blame] | 841 | if( p->magic!=VDBE_MAGIC_RUN ) return SQLITE_MISUSE; |
| 842 | assert( db->magic==SQLITE_MAGIC_BUSY ); |
danielk1977 | 6c359f0 | 2008-11-21 16:58:03 +0000 | [diff] [blame] | 843 | assert( p->rc==SQLITE_OK || p->rc==SQLITE_BUSY || p->rc==SQLITE_NOMEM ); |
danielk1977 | 18f4189 | 2004-05-22 07:27:46 +0000 | [diff] [blame] | 844 | |
drh | 9cbf342 | 2008-01-17 16:22:13 +0000 | [diff] [blame] | 845 | /* Even though this opcode does not use dynamic strings for |
| 846 | ** the result, result columns may become dynamic if the user calls |
drh | 4f26d6c | 2004-05-26 23:25:30 +0000 | [diff] [blame] | 847 | ** sqlite3_column_text16(), causing a translation to UTF-16 encoding. |
danielk1977 | 18f4189 | 2004-05-22 07:27:46 +0000 | [diff] [blame] | 848 | */ |
drh | c890fec | 2008-08-01 20:10:08 +0000 | [diff] [blame] | 849 | releaseMemArray(pMem, p->nMem); |
danielk1977 | 18f4189 | 2004-05-22 07:27:46 +0000 | [diff] [blame] | 850 | |
danielk1977 | 6c359f0 | 2008-11-21 16:58:03 +0000 | [diff] [blame] | 851 | if( p->rc==SQLITE_NOMEM ){ |
| 852 | /* This happens if a malloc() inside a call to sqlite3_column_text() or |
| 853 | ** sqlite3_column_text16() failed. */ |
| 854 | db->mallocFailed = 1; |
| 855 | return SQLITE_ERROR; |
| 856 | } |
| 857 | |
drh | ecc9242 | 2005-09-10 16:46:12 +0000 | [diff] [blame] | 858 | do{ |
| 859 | i = p->pc++; |
| 860 | }while( i<p->nOp && p->explain==2 && p->aOp[i].opcode!=OP_Explain ); |
drh | 826fb5a | 2004-02-14 23:59:57 +0000 | [diff] [blame] | 861 | if( i>=p->nOp ){ |
| 862 | p->rc = SQLITE_OK; |
| 863 | rc = SQLITE_DONE; |
drh | 881feaa | 2006-07-26 01:39:30 +0000 | [diff] [blame] | 864 | }else if( db->u1.isInterrupted ){ |
drh | c5cdca6 | 2005-01-11 16:54:14 +0000 | [diff] [blame] | 865 | p->rc = SQLITE_INTERRUPT; |
drh | 826fb5a | 2004-02-14 23:59:57 +0000 | [diff] [blame] | 866 | rc = SQLITE_ERROR; |
drh | f089aa4 | 2008-07-08 19:34:06 +0000 | [diff] [blame] | 867 | sqlite3SetString(&p->zErrMsg, db, "%s", sqlite3ErrStr(p->rc)); |
drh | 826fb5a | 2004-02-14 23:59:57 +0000 | [diff] [blame] | 868 | }else{ |
danielk1977 | a7a8e14 | 2008-02-13 18:25:27 +0000 | [diff] [blame] | 869 | char *z; |
drh | d3d39e9 | 2004-05-20 22:16:29 +0000 | [diff] [blame] | 870 | Op *pOp = &p->aOp[i]; |
danielk1977 | 0d78bae | 2008-01-03 07:09:48 +0000 | [diff] [blame] | 871 | if( p->explain==1 ){ |
| 872 | pMem->flags = MEM_Int; |
| 873 | pMem->type = SQLITE_INTEGER; |
| 874 | pMem->u.i = i; /* Program counter */ |
| 875 | pMem++; |
| 876 | |
| 877 | pMem->flags = MEM_Static|MEM_Str|MEM_Term; |
| 878 | pMem->z = (char*)sqlite3OpcodeName(pOp->opcode); /* Opcode */ |
| 879 | assert( pMem->z!=0 ); |
| 880 | pMem->n = strlen(pMem->z); |
| 881 | pMem->type = SQLITE_TEXT; |
| 882 | pMem->enc = SQLITE_UTF8; |
| 883 | pMem++; |
| 884 | } |
drh | eb2e176 | 2004-05-27 01:53:56 +0000 | [diff] [blame] | 885 | |
| 886 | pMem->flags = MEM_Int; |
drh | 3c024d6 | 2007-03-30 11:23:45 +0000 | [diff] [blame] | 887 | pMem->u.i = pOp->p1; /* P1 */ |
drh | 9c05483 | 2004-05-31 18:51:57 +0000 | [diff] [blame] | 888 | pMem->type = SQLITE_INTEGER; |
drh | eb2e176 | 2004-05-27 01:53:56 +0000 | [diff] [blame] | 889 | pMem++; |
| 890 | |
| 891 | pMem->flags = MEM_Int; |
drh | 3c024d6 | 2007-03-30 11:23:45 +0000 | [diff] [blame] | 892 | pMem->u.i = pOp->p2; /* P2 */ |
drh | 9c05483 | 2004-05-31 18:51:57 +0000 | [diff] [blame] | 893 | pMem->type = SQLITE_INTEGER; |
drh | eb2e176 | 2004-05-27 01:53:56 +0000 | [diff] [blame] | 894 | pMem++; |
| 895 | |
danielk1977 | 0d78bae | 2008-01-03 07:09:48 +0000 | [diff] [blame] | 896 | if( p->explain==1 ){ |
| 897 | pMem->flags = MEM_Int; |
| 898 | pMem->u.i = pOp->p3; /* P3 */ |
| 899 | pMem->type = SQLITE_INTEGER; |
| 900 | pMem++; |
| 901 | } |
| 902 | |
danielk1977 | a7a8e14 | 2008-02-13 18:25:27 +0000 | [diff] [blame] | 903 | if( sqlite3VdbeMemGrow(pMem, 32, 0) ){ /* P4 */ |
| 904 | p->db->mallocFailed = 1; |
| 905 | return SQLITE_NOMEM; |
| 906 | } |
| 907 | pMem->flags = MEM_Dyn|MEM_Str|MEM_Term; |
| 908 | z = displayP4(pOp, pMem->z, 32); |
| 909 | if( z!=pMem->z ){ |
| 910 | sqlite3VdbeMemSetStr(pMem, z, -1, SQLITE_UTF8, 0); |
| 911 | }else{ |
| 912 | assert( pMem->z!=0 ); |
| 913 | pMem->n = strlen(pMem->z); |
| 914 | pMem->enc = SQLITE_UTF8; |
| 915 | } |
drh | 9c05483 | 2004-05-31 18:51:57 +0000 | [diff] [blame] | 916 | pMem->type = SQLITE_TEXT; |
danielk1977 | 0d78bae | 2008-01-03 07:09:48 +0000 | [diff] [blame] | 917 | pMem++; |
drh | eb2e176 | 2004-05-27 01:53:56 +0000 | [diff] [blame] | 918 | |
danielk1977 | 0d78bae | 2008-01-03 07:09:48 +0000 | [diff] [blame] | 919 | if( p->explain==1 ){ |
drh | 85e5f0d | 2008-02-19 18:28:13 +0000 | [diff] [blame] | 920 | if( sqlite3VdbeMemGrow(pMem, 4, 0) ){ |
danielk1977 | a7a8e14 | 2008-02-13 18:25:27 +0000 | [diff] [blame] | 921 | p->db->mallocFailed = 1; |
| 922 | return SQLITE_NOMEM; |
| 923 | } |
| 924 | pMem->flags = MEM_Dyn|MEM_Str|MEM_Term; |
drh | 85e5f0d | 2008-02-19 18:28:13 +0000 | [diff] [blame] | 925 | pMem->n = 2; |
| 926 | sqlite3_snprintf(3, pMem->z, "%.2x", pOp->p5); /* P5 */ |
danielk1977 | 0d78bae | 2008-01-03 07:09:48 +0000 | [diff] [blame] | 927 | pMem->type = SQLITE_TEXT; |
| 928 | pMem->enc = SQLITE_UTF8; |
| 929 | pMem++; |
| 930 | |
drh | aa9b896 | 2008-01-08 02:57:55 +0000 | [diff] [blame] | 931 | #ifdef SQLITE_DEBUG |
danielk1977 | 0d78bae | 2008-01-03 07:09:48 +0000 | [diff] [blame] | 932 | if( pOp->zComment ){ |
| 933 | pMem->flags = MEM_Str|MEM_Term; |
| 934 | pMem->z = pOp->zComment; |
| 935 | pMem->n = strlen(pMem->z); |
| 936 | pMem->enc = SQLITE_UTF8; |
danielk1977 | 1e522b4 | 2008-09-16 09:09:19 +0000 | [diff] [blame] | 937 | pMem->type = SQLITE_TEXT; |
drh | 52391cb | 2008-02-14 23:44:13 +0000 | [diff] [blame] | 938 | }else |
drh | aa9b896 | 2008-01-08 02:57:55 +0000 | [diff] [blame] | 939 | #endif |
drh | 52391cb | 2008-02-14 23:44:13 +0000 | [diff] [blame] | 940 | { |
| 941 | pMem->flags = MEM_Null; /* Comment */ |
| 942 | pMem->type = SQLITE_NULL; |
| 943 | } |
danielk1977 | 0d78bae | 2008-01-03 07:09:48 +0000 | [diff] [blame] | 944 | } |
| 945 | |
| 946 | p->nResColumn = 8 - 5*(p->explain-1); |
drh | 826fb5a | 2004-02-14 23:59:57 +0000 | [diff] [blame] | 947 | p->rc = SQLITE_OK; |
| 948 | rc = SQLITE_ROW; |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 949 | } |
drh | 826fb5a | 2004-02-14 23:59:57 +0000 | [diff] [blame] | 950 | return rc; |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 951 | } |
drh | b7f9164 | 2004-10-31 02:22:47 +0000 | [diff] [blame] | 952 | #endif /* SQLITE_OMIT_EXPLAIN */ |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 953 | |
drh | 7c4ac0c | 2007-04-05 11:25:58 +0000 | [diff] [blame] | 954 | #ifdef SQLITE_DEBUG |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 955 | /* |
drh | 3f7d4e4 | 2004-07-24 14:35:58 +0000 | [diff] [blame] | 956 | ** Print the SQL that was used to generate a VDBE program. |
| 957 | */ |
| 958 | void sqlite3VdbePrintSql(Vdbe *p){ |
drh | 3f7d4e4 | 2004-07-24 14:35:58 +0000 | [diff] [blame] | 959 | int nOp = p->nOp; |
| 960 | VdbeOp *pOp; |
drh | c16a03b | 2004-09-15 13:38:10 +0000 | [diff] [blame] | 961 | if( nOp<1 ) return; |
drh | 949f9cd | 2008-01-12 21:35:57 +0000 | [diff] [blame] | 962 | pOp = &p->aOp[0]; |
| 963 | if( pOp->opcode==OP_Trace && pOp->p4.z!=0 ){ |
danielk1977 | 2dca4ac | 2008-01-03 11:50:29 +0000 | [diff] [blame] | 964 | const char *z = pOp->p4.z; |
drh | 4c755c0 | 2004-08-08 20:22:17 +0000 | [diff] [blame] | 965 | while( isspace(*(u8*)z) ) z++; |
drh | 3f7d4e4 | 2004-07-24 14:35:58 +0000 | [diff] [blame] | 966 | printf("SQL: [%s]\n", z); |
| 967 | } |
drh | 3f7d4e4 | 2004-07-24 14:35:58 +0000 | [diff] [blame] | 968 | } |
drh | 7c4ac0c | 2007-04-05 11:25:58 +0000 | [diff] [blame] | 969 | #endif |
drh | 3f7d4e4 | 2004-07-24 14:35:58 +0000 | [diff] [blame] | 970 | |
drh | 602c237 | 2007-03-01 00:29:13 +0000 | [diff] [blame] | 971 | #if !defined(SQLITE_OMIT_TRACE) && defined(SQLITE_ENABLE_IOTRACE) |
| 972 | /* |
| 973 | ** Print an IOTRACE message showing SQL content. |
| 974 | */ |
| 975 | void sqlite3VdbeIOTraceSql(Vdbe *p){ |
| 976 | int nOp = p->nOp; |
| 977 | VdbeOp *pOp; |
mlcreech | 3a00f90 | 2008-03-04 17:45:01 +0000 | [diff] [blame] | 978 | if( sqlite3IoTrace==0 ) return; |
drh | 602c237 | 2007-03-01 00:29:13 +0000 | [diff] [blame] | 979 | if( nOp<1 ) return; |
drh | 949f9cd | 2008-01-12 21:35:57 +0000 | [diff] [blame] | 980 | pOp = &p->aOp[0]; |
| 981 | if( pOp->opcode==OP_Trace && pOp->p4.z!=0 ){ |
drh | 602c237 | 2007-03-01 00:29:13 +0000 | [diff] [blame] | 982 | int i, j; |
drh | 00a18e4 | 2007-08-13 11:10:34 +0000 | [diff] [blame] | 983 | char z[1000]; |
drh | 949f9cd | 2008-01-12 21:35:57 +0000 | [diff] [blame] | 984 | sqlite3_snprintf(sizeof(z), z, "%s", pOp->p4.z); |
danielk1977 | 2be2be9 | 2007-05-16 17:50:45 +0000 | [diff] [blame] | 985 | for(i=0; isspace((unsigned char)z[i]); i++){} |
drh | 602c237 | 2007-03-01 00:29:13 +0000 | [diff] [blame] | 986 | for(j=0; z[i]; i++){ |
danielk1977 | 2be2be9 | 2007-05-16 17:50:45 +0000 | [diff] [blame] | 987 | if( isspace((unsigned char)z[i]) ){ |
drh | 602c237 | 2007-03-01 00:29:13 +0000 | [diff] [blame] | 988 | if( z[i-1]!=' ' ){ |
| 989 | z[j++] = ' '; |
| 990 | } |
| 991 | }else{ |
| 992 | z[j++] = z[i]; |
| 993 | } |
| 994 | } |
| 995 | z[j] = 0; |
mlcreech | 3a00f90 | 2008-03-04 17:45:01 +0000 | [diff] [blame] | 996 | sqlite3IoTrace("SQL %s\n", z); |
drh | 602c237 | 2007-03-01 00:29:13 +0000 | [diff] [blame] | 997 | } |
| 998 | } |
| 999 | #endif /* !SQLITE_OMIT_TRACE && SQLITE_ENABLE_IOTRACE */ |
| 1000 | |
| 1001 | |
drh | 3f7d4e4 | 2004-07-24 14:35:58 +0000 | [diff] [blame] | 1002 | /* |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 1003 | ** Prepare a virtual machine for execution. This involves things such |
| 1004 | ** as allocating stack space and initializing the program counter. |
| 1005 | ** 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] | 1006 | ** calls to sqlite3VdbeExec(). |
drh | 92f02c3 | 2004-09-02 14:57:08 +0000 | [diff] [blame] | 1007 | ** |
| 1008 | ** This is the only way to move a VDBE from VDBE_MAGIC_INIT to |
| 1009 | ** VDBE_MAGIC_RUN. |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 1010 | */ |
danielk1977 | 4adee20 | 2004-05-08 08:23:19 +0000 | [diff] [blame] | 1011 | void sqlite3VdbeMakeReady( |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 1012 | Vdbe *p, /* The VDBE */ |
drh | 7c972de | 2003-09-06 22:18:07 +0000 | [diff] [blame] | 1013 | int nVar, /* Number of '?' see in the SQL statement */ |
drh | 290c194 | 2004-08-21 17:54:45 +0000 | [diff] [blame] | 1014 | int nMem, /* Number of memory cells to allocate */ |
| 1015 | int nCursor, /* Number of cursors to allocate */ |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 1016 | int isExplain /* True if the EXPLAIN keywords is present */ |
| 1017 | ){ |
| 1018 | int n; |
danielk1977 | 1e53695 | 2007-08-16 10:09:01 +0000 | [diff] [blame] | 1019 | sqlite3 *db = p->db; |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 1020 | |
| 1021 | assert( p!=0 ); |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 1022 | assert( p->magic==VDBE_MAGIC_INIT ); |
| 1023 | |
drh | c16a03b | 2004-09-15 13:38:10 +0000 | [diff] [blame] | 1024 | /* There should be at least one opcode. |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 1025 | */ |
drh | c16a03b | 2004-09-15 13:38:10 +0000 | [diff] [blame] | 1026 | assert( p->nOp>0 ); |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 1027 | |
danielk1977 | 00e1361 | 2008-11-17 19:18:54 +0000 | [diff] [blame] | 1028 | /* Set the magic to VDBE_MAGIC_RUN sooner rather than later. */ |
danielk1977 | 634f298 | 2005-03-28 08:44:07 +0000 | [diff] [blame] | 1029 | p->magic = VDBE_MAGIC_RUN; |
| 1030 | |
danielk1977 | cd3e8f7 | 2008-03-25 09:47:35 +0000 | [diff] [blame] | 1031 | /* For each cursor required, also allocate a memory cell. Memory |
| 1032 | ** cells (nMem+1-nCursor)..nMem, inclusive, will never be used by |
| 1033 | ** the vdbe program. Instead they are used to allocate space for |
drh | dfe88ec | 2008-11-03 20:55:06 +0000 | [diff] [blame] | 1034 | ** VdbeCursor/BtCursor structures. The blob of memory associated with |
danielk1977 | cd3e8f7 | 2008-03-25 09:47:35 +0000 | [diff] [blame] | 1035 | ** cursor 0 is stored in memory cell nMem. Memory cell (nMem-1) |
| 1036 | ** stores the blob of memory associated with cursor 1, etc. |
| 1037 | ** |
| 1038 | ** See also: allocateCursor(). |
| 1039 | */ |
| 1040 | nMem += nCursor; |
| 1041 | |
drh | 9cbf342 | 2008-01-17 16:22:13 +0000 | [diff] [blame] | 1042 | /* |
| 1043 | ** Allocation space for registers. |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 1044 | */ |
drh | 9cbf342 | 2008-01-17 16:22:13 +0000 | [diff] [blame] | 1045 | if( p->aMem==0 ){ |
danielk1977 | 634f298 | 2005-03-28 08:44:07 +0000 | [diff] [blame] | 1046 | int nArg; /* Maximum number of args passed to a user function. */ |
drh | 9cbf342 | 2008-01-17 16:22:13 +0000 | [diff] [blame] | 1047 | resolveP2Values(p, &nArg); |
drh | 82a4851 | 2003-09-06 22:45:20 +0000 | [diff] [blame] | 1048 | assert( nVar>=0 ); |
drh | 9cbf342 | 2008-01-17 16:22:13 +0000 | [diff] [blame] | 1049 | if( isExplain && nMem<10 ){ |
drh | c46f520 | 2008-11-04 14:25:06 +0000 | [diff] [blame] | 1050 | nMem = 10; |
drh | 0f7eb61 | 2006-08-08 13:51:43 +0000 | [diff] [blame] | 1051 | } |
drh | 9cbf342 | 2008-01-17 16:22:13 +0000 | [diff] [blame] | 1052 | p->aMem = sqlite3DbMallocZero(db, |
| 1053 | nMem*sizeof(Mem) /* aMem */ |
drh | 86f4330 | 2004-10-05 17:37:36 +0000 | [diff] [blame] | 1054 | + nVar*sizeof(Mem) /* aVar */ |
drh | 9cbf342 | 2008-01-17 16:22:13 +0000 | [diff] [blame] | 1055 | + nArg*sizeof(Mem*) /* apArg */ |
drh | 86f4330 | 2004-10-05 17:37:36 +0000 | [diff] [blame] | 1056 | + nVar*sizeof(char*) /* azVar */ |
drh | dfe88ec | 2008-11-03 20:55:06 +0000 | [diff] [blame] | 1057 | + nCursor*sizeof(VdbeCursor*)+1 /* apCsr */ |
drh | 82a4851 | 2003-09-06 22:45:20 +0000 | [diff] [blame] | 1058 | ); |
drh | 1743575 | 2007-08-16 04:30:38 +0000 | [diff] [blame] | 1059 | if( !db->mallocFailed ){ |
drh | 9cbf342 | 2008-01-17 16:22:13 +0000 | [diff] [blame] | 1060 | p->aMem--; /* aMem[] goes from 1..nMem */ |
| 1061 | p->nMem = nMem; /* not from 0..nMem-1 */ |
drh | 0a07c10 | 2008-01-03 18:03:08 +0000 | [diff] [blame] | 1062 | p->aVar = &p->aMem[nMem+1]; |
drh | 86f4330 | 2004-10-05 17:37:36 +0000 | [diff] [blame] | 1063 | p->nVar = nVar; |
| 1064 | p->okVar = 0; |
| 1065 | p->apArg = (Mem**)&p->aVar[nVar]; |
danielk1977 | 634f298 | 2005-03-28 08:44:07 +0000 | [diff] [blame] | 1066 | p->azVar = (char**)&p->apArg[nArg]; |
drh | dfe88ec | 2008-11-03 20:55:06 +0000 | [diff] [blame] | 1067 | p->apCsr = (VdbeCursor**)&p->azVar[nVar]; |
drh | 290c194 | 2004-08-21 17:54:45 +0000 | [diff] [blame] | 1068 | p->nCursor = nCursor; |
| 1069 | for(n=0; n<nVar; n++){ |
| 1070 | p->aVar[n].flags = MEM_Null; |
drh | b21c8cd | 2007-08-21 19:33:56 +0000 | [diff] [blame] | 1071 | p->aVar[n].db = db; |
| 1072 | } |
drh | 9cbf342 | 2008-01-17 16:22:13 +0000 | [diff] [blame] | 1073 | for(n=1; n<=nMem; n++){ |
| 1074 | p->aMem[n].flags = MEM_Null; |
| 1075 | p->aMem[n].db = db; |
drh | 290c194 | 2004-08-21 17:54:45 +0000 | [diff] [blame] | 1076 | } |
danielk1977 | 54db47e | 2004-05-19 10:36:43 +0000 | [diff] [blame] | 1077 | } |
drh | 82a4851 | 2003-09-06 22:45:20 +0000 | [diff] [blame] | 1078 | } |
drh | 9cbf342 | 2008-01-17 16:22:13 +0000 | [diff] [blame] | 1079 | #ifdef SQLITE_DEBUG |
| 1080 | for(n=1; n<p->nMem; n++){ |
| 1081 | assert( p->aMem[n].db==db ); |
danielk1977 | b3bce66 | 2005-01-29 08:32:43 +0000 | [diff] [blame] | 1082 | } |
drh | 9cbf342 | 2008-01-17 16:22:13 +0000 | [diff] [blame] | 1083 | #endif |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 1084 | |
danielk1977 | 1d850a7 | 2004-05-31 08:26:49 +0000 | [diff] [blame] | 1085 | p->pc = -1; |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 1086 | p->rc = SQLITE_OK; |
| 1087 | p->uniqueCnt = 0; |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 1088 | p->errorAction = OE_Abort; |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 1089 | p->explain |= isExplain; |
| 1090 | p->magic = VDBE_MAGIC_RUN; |
danielk1977 | b28af71 | 2004-06-21 06:50:26 +0000 | [diff] [blame] | 1091 | p->nChange = 0; |
drh | 76873ab | 2006-01-07 18:48:26 +0000 | [diff] [blame] | 1092 | p->cacheCtr = 1; |
drh | d946db0 | 2005-12-29 19:23:06 +0000 | [diff] [blame] | 1093 | p->minWriteFileFormat = 255; |
danielk1977 | 182c4ba | 2007-06-27 15:53:34 +0000 | [diff] [blame] | 1094 | p->openedStatement = 0; |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 1095 | #ifdef VDBE_PROFILE |
drh | cf64d8b | 2003-12-31 17:57:10 +0000 | [diff] [blame] | 1096 | { |
| 1097 | int i; |
| 1098 | for(i=0; i<p->nOp; i++){ |
| 1099 | p->aOp[i].cnt = 0; |
| 1100 | p->aOp[i].cycles = 0; |
| 1101 | } |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 1102 | } |
| 1103 | #endif |
| 1104 | } |
| 1105 | |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 1106 | /* |
danielk1977 | cd3e8f7 | 2008-03-25 09:47:35 +0000 | [diff] [blame] | 1107 | ** Close a VDBE cursor and release all the resources that cursor |
| 1108 | ** happens to hold. |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 1109 | */ |
drh | dfe88ec | 2008-11-03 20:55:06 +0000 | [diff] [blame] | 1110 | void sqlite3VdbeFreeCursor(Vdbe *p, VdbeCursor *pCx){ |
drh | 4774b13 | 2004-06-12 20:12:51 +0000 | [diff] [blame] | 1111 | if( pCx==0 ){ |
| 1112 | return; |
| 1113 | } |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 1114 | if( pCx->pBt ){ |
danielk1977 | 4adee20 | 2004-05-08 08:23:19 +0000 | [diff] [blame] | 1115 | sqlite3BtreeClose(pCx->pBt); |
drh | 34004ce | 2008-07-11 16:15:17 +0000 | [diff] [blame] | 1116 | /* The pCx->pCursor will be close automatically, if it exists, by |
| 1117 | ** the call above. */ |
| 1118 | }else if( pCx->pCursor ){ |
| 1119 | sqlite3BtreeCloseCursor(pCx->pCursor); |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 1120 | } |
drh | 9eff616 | 2006-06-12 21:59:13 +0000 | [diff] [blame] | 1121 | #ifndef SQLITE_OMIT_VIRTUALTABLE |
| 1122 | if( pCx->pVtabCursor ){ |
| 1123 | sqlite3_vtab_cursor *pVtabCursor = pCx->pVtabCursor; |
danielk1977 | be71889 | 2006-06-23 08:05:19 +0000 | [diff] [blame] | 1124 | const sqlite3_module *pModule = pCx->pModule; |
| 1125 | p->inVtabMethod = 1; |
drh | 7e8b848 | 2008-01-23 03:03:05 +0000 | [diff] [blame] | 1126 | (void)sqlite3SafetyOff(p->db); |
drh | 9eff616 | 2006-06-12 21:59:13 +0000 | [diff] [blame] | 1127 | pModule->xClose(pVtabCursor); |
drh | 7e8b848 | 2008-01-23 03:03:05 +0000 | [diff] [blame] | 1128 | (void)sqlite3SafetyOn(p->db); |
danielk1977 | be71889 | 2006-06-23 08:05:19 +0000 | [diff] [blame] | 1129 | p->inVtabMethod = 0; |
drh | 9eff616 | 2006-06-12 21:59:13 +0000 | [diff] [blame] | 1130 | } |
| 1131 | #endif |
danielk1977 | 9882d99 | 2008-03-27 17:59:01 +0000 | [diff] [blame] | 1132 | if( !pCx->ephemPseudoTable ){ |
drh | 633e6d5 | 2008-07-28 19:34:53 +0000 | [diff] [blame] | 1133 | sqlite3DbFree(p->db, pCx->pData); |
danielk1977 | 9882d99 | 2008-03-27 17:59:01 +0000 | [diff] [blame] | 1134 | } |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 1135 | } |
| 1136 | |
| 1137 | /* |
drh | ff0587c | 2007-08-29 17:43:19 +0000 | [diff] [blame] | 1138 | ** Close all cursors except for VTab cursors that are currently |
| 1139 | ** in use. |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 1140 | */ |
drh | ff0587c | 2007-08-29 17:43:19 +0000 | [diff] [blame] | 1141 | static void closeAllCursorsExceptActiveVtabs(Vdbe *p){ |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 1142 | int i; |
drh | 290c194 | 2004-08-21 17:54:45 +0000 | [diff] [blame] | 1143 | if( p->apCsr==0 ) return; |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 1144 | for(i=0; i<p->nCursor; i++){ |
drh | dfe88ec | 2008-11-03 20:55:06 +0000 | [diff] [blame] | 1145 | VdbeCursor *pC = p->apCsr[i]; |
drh | ff0587c | 2007-08-29 17:43:19 +0000 | [diff] [blame] | 1146 | if( pC && (!p->inVtabMethod || !pC->pVtabCursor) ){ |
| 1147 | sqlite3VdbeFreeCursor(p, pC); |
danielk1977 | b7a2f2e | 2006-06-23 11:34:54 +0000 | [diff] [blame] | 1148 | p->apCsr[i] = 0; |
danielk1977 | be71889 | 2006-06-23 08:05:19 +0000 | [diff] [blame] | 1149 | } |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 1150 | } |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 1151 | } |
| 1152 | |
| 1153 | /* |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 1154 | ** Clean up the VM after execution. |
| 1155 | ** |
| 1156 | ** This routine will automatically close any cursors, lists, and/or |
| 1157 | ** sorters that were left open. It also deletes the values of |
drh | 5a12e68 | 2004-05-19 11:24:25 +0000 | [diff] [blame] | 1158 | ** variables in the aVar[] array. |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 1159 | */ |
drh | c890fec | 2008-08-01 20:10:08 +0000 | [diff] [blame] | 1160 | static void Cleanup(Vdbe *p){ |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 1161 | int i; |
drh | 633e6d5 | 2008-07-28 19:34:53 +0000 | [diff] [blame] | 1162 | sqlite3 *db = p->db; |
drh | 3d4501e | 2008-12-04 20:40:10 +0000 | [diff] [blame] | 1163 | Mem *pMem; |
drh | ff0587c | 2007-08-29 17:43:19 +0000 | [diff] [blame] | 1164 | closeAllCursorsExceptActiveVtabs(p); |
drh | 3d4501e | 2008-12-04 20:40:10 +0000 | [diff] [blame] | 1165 | for(pMem=&p->aMem[1], i=1; i<=p->nMem; i++, pMem++){ |
| 1166 | if( pMem->flags & MEM_RowSet ){ |
| 1167 | sqlite3RowSetClear(pMem->u.pRowSet); |
| 1168 | } |
| 1169 | MemSetTypeFlag(pMem, MEM_Null); |
danielk1977 | a7a8e14 | 2008-02-13 18:25:27 +0000 | [diff] [blame] | 1170 | } |
drh | c890fec | 2008-08-01 20:10:08 +0000 | [diff] [blame] | 1171 | releaseMemArray(&p->aMem[1], p->nMem); |
drh | 76ff3a0 | 2004-09-24 22:32:30 +0000 | [diff] [blame] | 1172 | if( p->contextStack ){ |
drh | 633e6d5 | 2008-07-28 19:34:53 +0000 | [diff] [blame] | 1173 | sqlite3DbFree(db, p->contextStack); |
drh | 344737f | 2004-09-19 00:50:20 +0000 | [diff] [blame] | 1174 | } |
drh | 5f96843 | 2004-02-21 19:02:30 +0000 | [diff] [blame] | 1175 | p->contextStack = 0; |
drh | 344737f | 2004-09-19 00:50:20 +0000 | [diff] [blame] | 1176 | p->contextStackDepth = 0; |
| 1177 | p->contextStackTop = 0; |
drh | 633e6d5 | 2008-07-28 19:34:53 +0000 | [diff] [blame] | 1178 | sqlite3DbFree(db, p->zErrMsg); |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 1179 | p->zErrMsg = 0; |
drh | d4e70eb | 2008-01-02 00:34:36 +0000 | [diff] [blame] | 1180 | p->pResultSet = 0; |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 1181 | } |
| 1182 | |
| 1183 | /* |
danielk1977 | 22322fd | 2004-05-25 23:35:17 +0000 | [diff] [blame] | 1184 | ** Set the number of result columns that will be returned by this SQL |
| 1185 | ** statement. This is now set at compile time, rather than during |
| 1186 | ** execution of the vdbe program so that sqlite3_column_count() can |
| 1187 | ** be called on an SQL statement before sqlite3_step(). |
| 1188 | */ |
| 1189 | void sqlite3VdbeSetNumCols(Vdbe *p, int nResColumn){ |
drh | 76ff3a0 | 2004-09-24 22:32:30 +0000 | [diff] [blame] | 1190 | Mem *pColName; |
| 1191 | int n; |
drh | 633e6d5 | 2008-07-28 19:34:53 +0000 | [diff] [blame] | 1192 | sqlite3 *db = p->db; |
drh | 4a50aac | 2007-08-23 02:47:53 +0000 | [diff] [blame] | 1193 | |
drh | c890fec | 2008-08-01 20:10:08 +0000 | [diff] [blame] | 1194 | releaseMemArray(p->aColName, p->nResColumn*COLNAME_N); |
drh | 633e6d5 | 2008-07-28 19:34:53 +0000 | [diff] [blame] | 1195 | sqlite3DbFree(db, p->aColName); |
danielk1977 | 955de52 | 2006-02-10 02:27:42 +0000 | [diff] [blame] | 1196 | n = nResColumn*COLNAME_N; |
drh | cc43cab | 2005-10-05 11:35:09 +0000 | [diff] [blame] | 1197 | p->nResColumn = nResColumn; |
drh | 633e6d5 | 2008-07-28 19:34:53 +0000 | [diff] [blame] | 1198 | p->aColName = pColName = (Mem*)sqlite3DbMallocZero(db, sizeof(Mem)*n ); |
drh | 76ff3a0 | 2004-09-24 22:32:30 +0000 | [diff] [blame] | 1199 | if( p->aColName==0 ) return; |
| 1200 | while( n-- > 0 ){ |
drh | 4a50aac | 2007-08-23 02:47:53 +0000 | [diff] [blame] | 1201 | pColName->flags = MEM_Null; |
drh | 153c62c | 2007-08-24 03:51:33 +0000 | [diff] [blame] | 1202 | pColName->db = p->db; |
drh | 4a50aac | 2007-08-23 02:47:53 +0000 | [diff] [blame] | 1203 | pColName++; |
drh | 76ff3a0 | 2004-09-24 22:32:30 +0000 | [diff] [blame] | 1204 | } |
danielk1977 | 22322fd | 2004-05-25 23:35:17 +0000 | [diff] [blame] | 1205 | } |
| 1206 | |
| 1207 | /* |
danielk1977 | 3cf8606 | 2004-05-26 10:11:05 +0000 | [diff] [blame] | 1208 | ** Set the name of the idx'th column to be returned by the SQL statement. |
| 1209 | ** zName must be a pointer to a nul terminated string. |
| 1210 | ** |
| 1211 | ** This call must be made after a call to sqlite3VdbeSetNumCols(). |
| 1212 | ** |
danielk1977 | 10fb749 | 2008-10-31 10:53:22 +0000 | [diff] [blame] | 1213 | ** The final parameter, xDel, must be one of SQLITE_DYNAMIC, SQLITE_STATIC |
| 1214 | ** or SQLITE_TRANSIENT. If it is SQLITE_DYNAMIC, then the buffer pointed |
| 1215 | ** to by zName will be freed by sqlite3DbFree() when the vdbe is destroyed. |
danielk1977 | 3cf8606 | 2004-05-26 10:11:05 +0000 | [diff] [blame] | 1216 | */ |
danielk1977 | 10fb749 | 2008-10-31 10:53:22 +0000 | [diff] [blame] | 1217 | int sqlite3VdbeSetColName( |
| 1218 | Vdbe *p, /* Vdbe being configured */ |
| 1219 | int idx, /* Index of column zName applies to */ |
| 1220 | int var, /* One of the COLNAME_* constants */ |
| 1221 | const char *zName, /* Pointer to buffer containing name */ |
| 1222 | void (*xDel)(void*) /* Memory management strategy for zName */ |
| 1223 | ){ |
danielk1977 | 3cf8606 | 2004-05-26 10:11:05 +0000 | [diff] [blame] | 1224 | int rc; |
| 1225 | Mem *pColName; |
danielk1977 | 955de52 | 2006-02-10 02:27:42 +0000 | [diff] [blame] | 1226 | assert( idx<p->nResColumn ); |
| 1227 | assert( var<COLNAME_N ); |
danielk1977 | 10fb749 | 2008-10-31 10:53:22 +0000 | [diff] [blame] | 1228 | if( p->db->mallocFailed ){ |
| 1229 | assert( !zName || xDel!=SQLITE_DYNAMIC ); |
| 1230 | return SQLITE_NOMEM; |
| 1231 | } |
drh | 76ff3a0 | 2004-09-24 22:32:30 +0000 | [diff] [blame] | 1232 | assert( p->aColName!=0 ); |
danielk1977 | 955de52 | 2006-02-10 02:27:42 +0000 | [diff] [blame] | 1233 | pColName = &(p->aColName[idx+var*p->nResColumn]); |
danielk1977 | 10fb749 | 2008-10-31 10:53:22 +0000 | [diff] [blame] | 1234 | rc = sqlite3VdbeMemSetStr(pColName, zName, -1, SQLITE_UTF8, xDel); |
drh | 0793f1b | 2008-11-05 17:41:19 +0000 | [diff] [blame] | 1235 | assert( rc!=0 || !zName || (pColName->flags&MEM_Term)!=0 ); |
danielk1977 | 3cf8606 | 2004-05-26 10:11:05 +0000 | [diff] [blame] | 1236 | return rc; |
| 1237 | } |
| 1238 | |
danielk1977 | 13adf8a | 2004-06-03 16:08:41 +0000 | [diff] [blame] | 1239 | /* |
| 1240 | ** A read or write transaction may or may not be active on database handle |
| 1241 | ** db. If a transaction is active, commit it. If there is a |
| 1242 | ** write-transaction spanning more than one database file, this routine |
| 1243 | ** takes care of the master journal trickery. |
| 1244 | */ |
danielk1977 | 3e3a84d | 2008-08-01 17:37:40 +0000 | [diff] [blame] | 1245 | static int vdbeCommit(sqlite3 *db, Vdbe *p){ |
danielk1977 | 13adf8a | 2004-06-03 16:08:41 +0000 | [diff] [blame] | 1246 | int i; |
| 1247 | int nTrans = 0; /* Number of databases with an active write-transaction */ |
| 1248 | int rc = SQLITE_OK; |
| 1249 | int needXcommit = 0; |
| 1250 | |
danielk1977 | 5bd270b | 2006-07-25 15:14:52 +0000 | [diff] [blame] | 1251 | /* Before doing anything else, call the xSync() callback for any |
| 1252 | ** virtual module tables written in this transaction. This has to |
| 1253 | ** be done before determining whether a master journal file is |
| 1254 | ** required, as an xSync() callback may add an attached database |
| 1255 | ** to the transaction. |
| 1256 | */ |
danielk1977 | 3e3a84d | 2008-08-01 17:37:40 +0000 | [diff] [blame] | 1257 | rc = sqlite3VtabSync(db, &p->zErrMsg); |
danielk1977 | 5bd270b | 2006-07-25 15:14:52 +0000 | [diff] [blame] | 1258 | if( rc!=SQLITE_OK ){ |
| 1259 | return rc; |
| 1260 | } |
| 1261 | |
| 1262 | /* This loop determines (a) if the commit hook should be invoked and |
| 1263 | ** (b) how many database files have open write transactions, not |
| 1264 | ** including the temp database. (b) is important because if more than |
| 1265 | ** one database file has an open write transaction, a master journal |
| 1266 | ** file is required for an atomic commit. |
| 1267 | */ |
danielk1977 | 13adf8a | 2004-06-03 16:08:41 +0000 | [diff] [blame] | 1268 | for(i=0; i<db->nDb; i++){ |
| 1269 | Btree *pBt = db->aDb[i].pBt; |
drh | d0679ed | 2007-08-28 22:24:34 +0000 | [diff] [blame] | 1270 | if( sqlite3BtreeIsInTrans(pBt) ){ |
danielk1977 | 13adf8a | 2004-06-03 16:08:41 +0000 | [diff] [blame] | 1271 | needXcommit = 1; |
| 1272 | if( i!=1 ) nTrans++; |
| 1273 | } |
| 1274 | } |
| 1275 | |
| 1276 | /* If there are any write-transactions at all, invoke the commit hook */ |
| 1277 | if( needXcommit && db->xCommitCallback ){ |
drh | 7e8b848 | 2008-01-23 03:03:05 +0000 | [diff] [blame] | 1278 | (void)sqlite3SafetyOff(db); |
drh | 92f02c3 | 2004-09-02 14:57:08 +0000 | [diff] [blame] | 1279 | rc = db->xCommitCallback(db->pCommitArg); |
drh | 7e8b848 | 2008-01-23 03:03:05 +0000 | [diff] [blame] | 1280 | (void)sqlite3SafetyOn(db); |
drh | 92f02c3 | 2004-09-02 14:57:08 +0000 | [diff] [blame] | 1281 | if( rc ){ |
danielk1977 | 13adf8a | 2004-06-03 16:08:41 +0000 | [diff] [blame] | 1282 | return SQLITE_CONSTRAINT; |
| 1283 | } |
| 1284 | } |
| 1285 | |
danielk1977 | 40b38dc | 2004-06-26 08:38:24 +0000 | [diff] [blame] | 1286 | /* The simple case - no more than one database file (not counting the |
| 1287 | ** TEMP database) has a transaction active. There is no need for the |
drh | 2ac3ee9 | 2004-06-07 16:27:46 +0000 | [diff] [blame] | 1288 | ** master-journal. |
drh | c9e0686 | 2004-06-09 20:03:08 +0000 | [diff] [blame] | 1289 | ** |
danielk1977 | 40b38dc | 2004-06-26 08:38:24 +0000 | [diff] [blame] | 1290 | ** If the return value of sqlite3BtreeGetFilename() is a zero length |
danielk1977 | 17b90b5 | 2008-06-06 11:11:25 +0000 | [diff] [blame] | 1291 | ** string, it means the main database is :memory: or a temp file. In |
| 1292 | ** that case we do not support atomic multi-file commits, so use the |
| 1293 | ** simple case then too. |
danielk1977 | 13adf8a | 2004-06-03 16:08:41 +0000 | [diff] [blame] | 1294 | */ |
danielk1977 | 40b38dc | 2004-06-26 08:38:24 +0000 | [diff] [blame] | 1295 | if( 0==strlen(sqlite3BtreeGetFilename(db->aDb[0].pBt)) || nTrans<=1 ){ |
drh | 2ac3ee9 | 2004-06-07 16:27:46 +0000 | [diff] [blame] | 1296 | for(i=0; rc==SQLITE_OK && i<db->nDb; i++){ |
danielk1977 | 13adf8a | 2004-06-03 16:08:41 +0000 | [diff] [blame] | 1297 | Btree *pBt = db->aDb[i].pBt; |
| 1298 | if( pBt ){ |
drh | 80e35f4 | 2007-03-30 14:06:34 +0000 | [diff] [blame] | 1299 | rc = sqlite3BtreeCommitPhaseOne(pBt, 0); |
drh | 2ac3ee9 | 2004-06-07 16:27:46 +0000 | [diff] [blame] | 1300 | } |
| 1301 | } |
| 1302 | |
drh | 80e35f4 | 2007-03-30 14:06:34 +0000 | [diff] [blame] | 1303 | /* Do the commit only if all databases successfully complete phase 1. |
| 1304 | ** If one of the BtreeCommitPhaseOne() calls fails, this indicates an |
| 1305 | ** IO error while deleting or truncating a journal file. It is unlikely, |
| 1306 | ** but could happen. In this case abandon processing and return the error. |
danielk1977 | 979f38e | 2007-03-27 16:19:51 +0000 | [diff] [blame] | 1307 | */ |
| 1308 | for(i=0; rc==SQLITE_OK && i<db->nDb; i++){ |
| 1309 | Btree *pBt = db->aDb[i].pBt; |
| 1310 | if( pBt ){ |
drh | 80e35f4 | 2007-03-30 14:06:34 +0000 | [diff] [blame] | 1311 | rc = sqlite3BtreeCommitPhaseTwo(pBt); |
danielk1977 | 13adf8a | 2004-06-03 16:08:41 +0000 | [diff] [blame] | 1312 | } |
danielk1977 | 979f38e | 2007-03-27 16:19:51 +0000 | [diff] [blame] | 1313 | } |
| 1314 | if( rc==SQLITE_OK ){ |
danielk1977 | f9e7dda | 2006-06-16 16:08:53 +0000 | [diff] [blame] | 1315 | sqlite3VtabCommit(db); |
danielk1977 | 13adf8a | 2004-06-03 16:08:41 +0000 | [diff] [blame] | 1316 | } |
| 1317 | } |
| 1318 | |
| 1319 | /* The complex case - There is a multi-file write-transaction active. |
| 1320 | ** This requires a master journal file to ensure the transaction is |
| 1321 | ** committed atomicly. |
| 1322 | */ |
danielk1977 | 44ee5bf | 2005-05-27 09:41:12 +0000 | [diff] [blame] | 1323 | #ifndef SQLITE_OMIT_DISKIO |
danielk1977 | 13adf8a | 2004-06-03 16:08:41 +0000 | [diff] [blame] | 1324 | else{ |
danielk1977 | b4b4741 | 2007-08-17 15:53:36 +0000 | [diff] [blame] | 1325 | sqlite3_vfs *pVfs = db->pVfs; |
drh | 2c8997b | 2005-08-27 16:36:48 +0000 | [diff] [blame] | 1326 | int needSync = 0; |
danielk1977 | 13adf8a | 2004-06-03 16:08:41 +0000 | [diff] [blame] | 1327 | char *zMaster = 0; /* File-name for the master journal */ |
| 1328 | char const *zMainFile = sqlite3BtreeGetFilename(db->aDb[0].pBt); |
danielk1977 | b4b4741 | 2007-08-17 15:53:36 +0000 | [diff] [blame] | 1329 | sqlite3_file *pMaster = 0; |
danielk1977 | 6207906 | 2007-08-15 17:08:46 +0000 | [diff] [blame] | 1330 | i64 offset = 0; |
danielk1977 | 861f745 | 2008-06-05 11:39:11 +0000 | [diff] [blame] | 1331 | int res; |
danielk1977 | 13adf8a | 2004-06-03 16:08:41 +0000 | [diff] [blame] | 1332 | |
| 1333 | /* Select a master journal file name */ |
| 1334 | do { |
drh | a6abd04 | 2004-06-09 17:37:22 +0000 | [diff] [blame] | 1335 | u32 random; |
drh | 633e6d5 | 2008-07-28 19:34:53 +0000 | [diff] [blame] | 1336 | sqlite3DbFree(db, zMaster); |
drh | 2fa1868 | 2008-03-19 14:15:34 +0000 | [diff] [blame] | 1337 | sqlite3_randomness(sizeof(random), &random); |
danielk1977 | 1e53695 | 2007-08-16 10:09:01 +0000 | [diff] [blame] | 1338 | zMaster = sqlite3MPrintf(db, "%s-mj%08X", zMainFile, random&0x7fffffff); |
danielk1977 | 13adf8a | 2004-06-03 16:08:41 +0000 | [diff] [blame] | 1339 | if( !zMaster ){ |
| 1340 | return SQLITE_NOMEM; |
| 1341 | } |
danielk1977 | 861f745 | 2008-06-05 11:39:11 +0000 | [diff] [blame] | 1342 | rc = sqlite3OsAccess(pVfs, zMaster, SQLITE_ACCESS_EXISTS, &res); |
| 1343 | }while( rc==SQLITE_OK && res ); |
| 1344 | if( rc==SQLITE_OK ){ |
drh | 19db935 | 2008-03-27 22:42:51 +0000 | [diff] [blame] | 1345 | /* Open the master journal. */ |
| 1346 | rc = sqlite3OsOpenMalloc(pVfs, zMaster, &pMaster, |
| 1347 | SQLITE_OPEN_READWRITE|SQLITE_OPEN_CREATE| |
| 1348 | SQLITE_OPEN_EXCLUSIVE|SQLITE_OPEN_MASTER_JOURNAL, 0 |
| 1349 | ); |
| 1350 | } |
danielk1977 | 13adf8a | 2004-06-03 16:08:41 +0000 | [diff] [blame] | 1351 | if( rc!=SQLITE_OK ){ |
drh | 633e6d5 | 2008-07-28 19:34:53 +0000 | [diff] [blame] | 1352 | sqlite3DbFree(db, zMaster); |
danielk1977 | 13adf8a | 2004-06-03 16:08:41 +0000 | [diff] [blame] | 1353 | return rc; |
| 1354 | } |
| 1355 | |
| 1356 | /* Write the name of each database file in the transaction into the new |
| 1357 | ** master journal file. If an error occurs at this point close |
| 1358 | ** and delete the master journal file. All the individual journal files |
| 1359 | ** still have 'null' as the master journal pointer, so they will roll |
danielk1977 | aca790a | 2005-01-13 11:07:52 +0000 | [diff] [blame] | 1360 | ** back independently if a failure occurs. |
danielk1977 | 13adf8a | 2004-06-03 16:08:41 +0000 | [diff] [blame] | 1361 | */ |
danielk1977 | 1e53695 | 2007-08-16 10:09:01 +0000 | [diff] [blame] | 1362 | for(i=0; i<db->nDb; i++){ |
danielk1977 | 13adf8a | 2004-06-03 16:08:41 +0000 | [diff] [blame] | 1363 | Btree *pBt = db->aDb[i].pBt; |
drh | c9e0686 | 2004-06-09 20:03:08 +0000 | [diff] [blame] | 1364 | if( i==1 ) continue; /* Ignore the TEMP database */ |
drh | d0679ed | 2007-08-28 22:24:34 +0000 | [diff] [blame] | 1365 | if( sqlite3BtreeIsInTrans(pBt) ){ |
danielk1977 | 5865e3d | 2004-06-14 06:03:57 +0000 | [diff] [blame] | 1366 | char const *zFile = sqlite3BtreeGetJournalname(pBt); |
drh | c9e0686 | 2004-06-09 20:03:08 +0000 | [diff] [blame] | 1367 | if( zFile[0]==0 ) continue; /* Ignore :memory: databases */ |
drh | 2c8997b | 2005-08-27 16:36:48 +0000 | [diff] [blame] | 1368 | if( !needSync && !sqlite3BtreeSyncDisabled(pBt) ){ |
| 1369 | needSync = 1; |
| 1370 | } |
danielk1977 | b4b4741 | 2007-08-17 15:53:36 +0000 | [diff] [blame] | 1371 | rc = sqlite3OsWrite(pMaster, zFile, strlen(zFile)+1, offset); |
danielk1977 | 6207906 | 2007-08-15 17:08:46 +0000 | [diff] [blame] | 1372 | offset += strlen(zFile)+1; |
danielk1977 | 13adf8a | 2004-06-03 16:08:41 +0000 | [diff] [blame] | 1373 | if( rc!=SQLITE_OK ){ |
danielk1977 | fee2d25 | 2007-08-18 10:59:19 +0000 | [diff] [blame] | 1374 | sqlite3OsCloseFree(pMaster); |
| 1375 | sqlite3OsDelete(pVfs, zMaster, 0); |
drh | 633e6d5 | 2008-07-28 19:34:53 +0000 | [diff] [blame] | 1376 | sqlite3DbFree(db, zMaster); |
danielk1977 | 13adf8a | 2004-06-03 16:08:41 +0000 | [diff] [blame] | 1377 | return rc; |
| 1378 | } |
| 1379 | } |
| 1380 | } |
| 1381 | |
danielk1977 | 9663b8f | 2007-08-24 11:52:28 +0000 | [diff] [blame] | 1382 | /* Sync the master journal file. If the IOCAP_SEQUENTIAL device |
| 1383 | ** flag is set this is not required. |
| 1384 | */ |
danielk1977 | 5865e3d | 2004-06-14 06:03:57 +0000 | [diff] [blame] | 1385 | zMainFile = sqlite3BtreeGetDirname(db->aDb[0].pBt); |
danielk1977 | f036aef | 2007-08-20 05:36:51 +0000 | [diff] [blame] | 1386 | if( (needSync |
danielk1977 | 9663b8f | 2007-08-24 11:52:28 +0000 | [diff] [blame] | 1387 | && (0==(sqlite3OsDeviceCharacteristics(pMaster)&SQLITE_IOCAP_SEQUENTIAL)) |
danielk1977 | f036aef | 2007-08-20 05:36:51 +0000 | [diff] [blame] | 1388 | && (rc=sqlite3OsSync(pMaster, SQLITE_SYNC_NORMAL))!=SQLITE_OK) ){ |
danielk1977 | fee2d25 | 2007-08-18 10:59:19 +0000 | [diff] [blame] | 1389 | sqlite3OsCloseFree(pMaster); |
| 1390 | sqlite3OsDelete(pVfs, zMaster, 0); |
drh | 633e6d5 | 2008-07-28 19:34:53 +0000 | [diff] [blame] | 1391 | sqlite3DbFree(db, zMaster); |
danielk1977 | 5865e3d | 2004-06-14 06:03:57 +0000 | [diff] [blame] | 1392 | return rc; |
| 1393 | } |
drh | c9e0686 | 2004-06-09 20:03:08 +0000 | [diff] [blame] | 1394 | |
danielk1977 | 13adf8a | 2004-06-03 16:08:41 +0000 | [diff] [blame] | 1395 | /* Sync all the db files involved in the transaction. The same call |
| 1396 | ** sets the master journal pointer in each individual journal. If |
| 1397 | ** an error occurs here, do not delete the master journal file. |
| 1398 | ** |
drh | 80e35f4 | 2007-03-30 14:06:34 +0000 | [diff] [blame] | 1399 | ** If the error occurs during the first call to |
| 1400 | ** sqlite3BtreeCommitPhaseOne(), then there is a chance that the |
| 1401 | ** master journal file will be orphaned. But we cannot delete it, |
| 1402 | ** in case the master journal file name was written into the journal |
| 1403 | ** file before the failure occured. |
danielk1977 | 13adf8a | 2004-06-03 16:08:41 +0000 | [diff] [blame] | 1404 | */ |
danielk1977 | 5bd270b | 2006-07-25 15:14:52 +0000 | [diff] [blame] | 1405 | for(i=0; rc==SQLITE_OK && i<db->nDb; i++){ |
danielk1977 | 13adf8a | 2004-06-03 16:08:41 +0000 | [diff] [blame] | 1406 | Btree *pBt = db->aDb[i].pBt; |
drh | d0679ed | 2007-08-28 22:24:34 +0000 | [diff] [blame] | 1407 | if( pBt ){ |
drh | 80e35f4 | 2007-03-30 14:06:34 +0000 | [diff] [blame] | 1408 | rc = sqlite3BtreeCommitPhaseOne(pBt, zMaster); |
danielk1977 | 13adf8a | 2004-06-03 16:08:41 +0000 | [diff] [blame] | 1409 | } |
| 1410 | } |
danielk1977 | fee2d25 | 2007-08-18 10:59:19 +0000 | [diff] [blame] | 1411 | sqlite3OsCloseFree(pMaster); |
danielk1977 | 5bd270b | 2006-07-25 15:14:52 +0000 | [diff] [blame] | 1412 | if( rc!=SQLITE_OK ){ |
drh | 633e6d5 | 2008-07-28 19:34:53 +0000 | [diff] [blame] | 1413 | sqlite3DbFree(db, zMaster); |
danielk1977 | 5bd270b | 2006-07-25 15:14:52 +0000 | [diff] [blame] | 1414 | return rc; |
| 1415 | } |
danielk1977 | 13adf8a | 2004-06-03 16:08:41 +0000 | [diff] [blame] | 1416 | |
danielk1977 | 962398d | 2004-06-14 09:35:16 +0000 | [diff] [blame] | 1417 | /* Delete the master journal file. This commits the transaction. After |
| 1418 | ** doing this the directory is synced again before any individual |
| 1419 | ** transaction files are deleted. |
| 1420 | */ |
danielk1977 | fee2d25 | 2007-08-18 10:59:19 +0000 | [diff] [blame] | 1421 | rc = sqlite3OsDelete(pVfs, zMaster, 1); |
drh | 633e6d5 | 2008-07-28 19:34:53 +0000 | [diff] [blame] | 1422 | sqlite3DbFree(db, zMaster); |
drh | c416ba9 | 2007-03-30 18:42:55 +0000 | [diff] [blame] | 1423 | zMaster = 0; |
drh | 29a0138 | 2006-08-13 19:04:18 +0000 | [diff] [blame] | 1424 | if( rc ){ |
| 1425 | return rc; |
| 1426 | } |
danielk1977 | 13adf8a | 2004-06-03 16:08:41 +0000 | [diff] [blame] | 1427 | |
| 1428 | /* All files and directories have already been synced, so the following |
drh | 80e35f4 | 2007-03-30 14:06:34 +0000 | [diff] [blame] | 1429 | ** calls to sqlite3BtreeCommitPhaseTwo() are only closing files and |
| 1430 | ** deleting or truncating journals. If something goes wrong while |
| 1431 | ** this is happening we don't really care. The integrity of the |
| 1432 | ** transaction is already guaranteed, but some stray 'cold' journals |
| 1433 | ** may be lying around. Returning an error code won't help matters. |
danielk1977 | 13adf8a | 2004-06-03 16:08:41 +0000 | [diff] [blame] | 1434 | */ |
danielk1977 | 979f38e | 2007-03-27 16:19:51 +0000 | [diff] [blame] | 1435 | disable_simulated_io_errors(); |
danielk1977 | 2d1d86f | 2008-06-20 14:59:51 +0000 | [diff] [blame] | 1436 | sqlite3BeginBenignMalloc(); |
danielk1977 | 13adf8a | 2004-06-03 16:08:41 +0000 | [diff] [blame] | 1437 | for(i=0; i<db->nDb; i++){ |
| 1438 | Btree *pBt = db->aDb[i].pBt; |
| 1439 | if( pBt ){ |
drh | 80e35f4 | 2007-03-30 14:06:34 +0000 | [diff] [blame] | 1440 | sqlite3BtreeCommitPhaseTwo(pBt); |
danielk1977 | 13adf8a | 2004-06-03 16:08:41 +0000 | [diff] [blame] | 1441 | } |
| 1442 | } |
danielk1977 | 2d1d86f | 2008-06-20 14:59:51 +0000 | [diff] [blame] | 1443 | sqlite3EndBenignMalloc(); |
danielk1977 | 979f38e | 2007-03-27 16:19:51 +0000 | [diff] [blame] | 1444 | enable_simulated_io_errors(); |
| 1445 | |
danielk1977 | f9e7dda | 2006-06-16 16:08:53 +0000 | [diff] [blame] | 1446 | sqlite3VtabCommit(db); |
danielk1977 | 13adf8a | 2004-06-03 16:08:41 +0000 | [diff] [blame] | 1447 | } |
danielk1977 | 44ee5bf | 2005-05-27 09:41:12 +0000 | [diff] [blame] | 1448 | #endif |
danielk1977 | 026d270 | 2004-06-14 13:14:59 +0000 | [diff] [blame] | 1449 | |
drh | 2ac3ee9 | 2004-06-07 16:27:46 +0000 | [diff] [blame] | 1450 | return rc; |
danielk1977 | 13adf8a | 2004-06-03 16:08:41 +0000 | [diff] [blame] | 1451 | } |
| 1452 | |
danielk1977 | 1d850a7 | 2004-05-31 08:26:49 +0000 | [diff] [blame] | 1453 | /* |
| 1454 | ** This routine checks that the sqlite3.activeVdbeCnt count variable |
| 1455 | ** matches the number of vdbe's in the list sqlite3.pVdbe that are |
| 1456 | ** currently active. An assertion fails if the two counts do not match. |
drh | 92f02c3 | 2004-09-02 14:57:08 +0000 | [diff] [blame] | 1457 | ** This is an internal self-check only - it is not an essential processing |
| 1458 | ** step. |
danielk1977 | 1d850a7 | 2004-05-31 08:26:49 +0000 | [diff] [blame] | 1459 | ** |
| 1460 | ** This is a no-op if NDEBUG is defined. |
| 1461 | */ |
| 1462 | #ifndef NDEBUG |
drh | 9bb575f | 2004-09-06 17:24:11 +0000 | [diff] [blame] | 1463 | static void checkActiveVdbeCnt(sqlite3 *db){ |
danielk1977 | 1d850a7 | 2004-05-31 08:26:49 +0000 | [diff] [blame] | 1464 | Vdbe *p; |
| 1465 | int cnt = 0; |
drh | ad4a4b8 | 2008-11-05 16:37:34 +0000 | [diff] [blame] | 1466 | int nWrite = 0; |
danielk1977 | 1d850a7 | 2004-05-31 08:26:49 +0000 | [diff] [blame] | 1467 | p = db->pVdbe; |
| 1468 | while( p ){ |
drh | 92f02c3 | 2004-09-02 14:57:08 +0000 | [diff] [blame] | 1469 | if( p->magic==VDBE_MAGIC_RUN && p->pc>=0 ){ |
danielk1977 | 1d850a7 | 2004-05-31 08:26:49 +0000 | [diff] [blame] | 1470 | cnt++; |
drh | ad4a4b8 | 2008-11-05 16:37:34 +0000 | [diff] [blame] | 1471 | if( p->readOnly==0 ) nWrite++; |
danielk1977 | 1d850a7 | 2004-05-31 08:26:49 +0000 | [diff] [blame] | 1472 | } |
| 1473 | p = p->pNext; |
| 1474 | } |
danielk1977 | 1d850a7 | 2004-05-31 08:26:49 +0000 | [diff] [blame] | 1475 | assert( cnt==db->activeVdbeCnt ); |
drh | ad4a4b8 | 2008-11-05 16:37:34 +0000 | [diff] [blame] | 1476 | assert( nWrite==db->writeVdbeCnt ); |
danielk1977 | 1d850a7 | 2004-05-31 08:26:49 +0000 | [diff] [blame] | 1477 | } |
| 1478 | #else |
| 1479 | #define checkActiveVdbeCnt(x) |
| 1480 | #endif |
| 1481 | |
danielk1977 | 3cf8606 | 2004-05-26 10:11:05 +0000 | [diff] [blame] | 1482 | /* |
drh | fb98264 | 2007-08-30 01:19:59 +0000 | [diff] [blame] | 1483 | ** For every Btree that in database connection db which |
| 1484 | ** has been modified, "trip" or invalidate each cursor in |
| 1485 | ** that Btree might have been modified so that the cursor |
| 1486 | ** can never be used again. This happens when a rollback |
| 1487 | *** occurs. We have to trip all the other cursors, even |
| 1488 | ** cursor from other VMs in different database connections, |
| 1489 | ** so that none of them try to use the data at which they |
| 1490 | ** were pointing and which now may have been changed due |
| 1491 | ** to the rollback. |
| 1492 | ** |
| 1493 | ** Remember that a rollback can delete tables complete and |
| 1494 | ** reorder rootpages. So it is not sufficient just to save |
| 1495 | ** the state of the cursor. We have to invalidate the cursor |
| 1496 | ** so that it is never used again. |
danielk1977 | be71889 | 2006-06-23 08:05:19 +0000 | [diff] [blame] | 1497 | */ |
drh | ade6c9c | 2007-11-24 10:23:44 +0000 | [diff] [blame] | 1498 | static void invalidateCursorsOnModifiedBtrees(sqlite3 *db){ |
drh | fb98264 | 2007-08-30 01:19:59 +0000 | [diff] [blame] | 1499 | int i; |
| 1500 | for(i=0; i<db->nDb; i++){ |
| 1501 | Btree *p = db->aDb[i].pBt; |
| 1502 | if( p && sqlite3BtreeIsInTrans(p) ){ |
| 1503 | sqlite3BtreeTripAllCursors(p, SQLITE_ABORT); |
| 1504 | } |
danielk1977 | be71889 | 2006-06-23 08:05:19 +0000 | [diff] [blame] | 1505 | } |
| 1506 | } |
| 1507 | |
| 1508 | /* |
drh | 92f02c3 | 2004-09-02 14:57:08 +0000 | [diff] [blame] | 1509 | ** This routine is called the when a VDBE tries to halt. If the VDBE |
| 1510 | ** has made changes and is in autocommit mode, then commit those |
| 1511 | ** changes. If a rollback is needed, then do the rollback. |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 1512 | ** |
drh | 92f02c3 | 2004-09-02 14:57:08 +0000 | [diff] [blame] | 1513 | ** This routine is the only way to move the state of a VM from |
drh | ff0587c | 2007-08-29 17:43:19 +0000 | [diff] [blame] | 1514 | ** SQLITE_MAGIC_RUN to SQLITE_MAGIC_HALT. It is harmless to |
| 1515 | ** call this on a VM that is in the SQLITE_MAGIC_HALT state. |
drh | 92f02c3 | 2004-09-02 14:57:08 +0000 | [diff] [blame] | 1516 | ** |
| 1517 | ** Return an error code. If the commit could not complete because of |
| 1518 | ** lock contention, return SQLITE_BUSY. If SQLITE_BUSY is returned, it |
| 1519 | ** means the close did not happen and needs to be repeated. |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 1520 | */ |
drh | ff0587c | 2007-08-29 17:43:19 +0000 | [diff] [blame] | 1521 | int sqlite3VdbeHalt(Vdbe *p){ |
drh | 9bb575f | 2004-09-06 17:24:11 +0000 | [diff] [blame] | 1522 | sqlite3 *db = p->db; |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 1523 | int i; |
danielk1977 | 1d850a7 | 2004-05-31 08:26:49 +0000 | [diff] [blame] | 1524 | int (*xFunc)(Btree *pBt) = 0; /* Function to call on each btree backend */ |
danielk1977 | 07cb560 | 2006-01-20 10:55:05 +0000 | [diff] [blame] | 1525 | int isSpecialError; /* Set to true if SQLITE_NOMEM or IOERR */ |
| 1526 | |
| 1527 | /* This function contains the logic that determines if a statement or |
| 1528 | ** transaction will be committed or rolled back as a result of the |
| 1529 | ** execution of this virtual machine. |
| 1530 | ** |
drh | 71b890a | 2007-10-03 15:30:52 +0000 | [diff] [blame] | 1531 | ** If any of the following errors occur: |
danielk1977 | 07cb560 | 2006-01-20 10:55:05 +0000 | [diff] [blame] | 1532 | ** |
drh | 71b890a | 2007-10-03 15:30:52 +0000 | [diff] [blame] | 1533 | ** SQLITE_NOMEM |
| 1534 | ** SQLITE_IOERR |
| 1535 | ** SQLITE_FULL |
| 1536 | ** SQLITE_INTERRUPT |
danielk1977 | 07cb560 | 2006-01-20 10:55:05 +0000 | [diff] [blame] | 1537 | ** |
drh | 71b890a | 2007-10-03 15:30:52 +0000 | [diff] [blame] | 1538 | ** Then the internal cache might have been left in an inconsistent |
| 1539 | ** state. We need to rollback the statement transaction, if there is |
| 1540 | ** one, or the complete transaction if there is no statement transaction. |
danielk1977 | 07cb560 | 2006-01-20 10:55:05 +0000 | [diff] [blame] | 1541 | */ |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 1542 | |
drh | 1743575 | 2007-08-16 04:30:38 +0000 | [diff] [blame] | 1543 | if( p->db->mallocFailed ){ |
danielk1977 | 261919c | 2005-12-06 12:52:59 +0000 | [diff] [blame] | 1544 | p->rc = SQLITE_NOMEM; |
| 1545 | } |
drh | ff0587c | 2007-08-29 17:43:19 +0000 | [diff] [blame] | 1546 | closeAllCursorsExceptActiveVtabs(p); |
drh | 92f02c3 | 2004-09-02 14:57:08 +0000 | [diff] [blame] | 1547 | if( p->magic!=VDBE_MAGIC_RUN ){ |
drh | 92f02c3 | 2004-09-02 14:57:08 +0000 | [diff] [blame] | 1548 | return SQLITE_OK; |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 1549 | } |
danielk1977 | 1d850a7 | 2004-05-31 08:26:49 +0000 | [diff] [blame] | 1550 | checkActiveVdbeCnt(db); |
danielk1977 | 261919c | 2005-12-06 12:52:59 +0000 | [diff] [blame] | 1551 | |
danielk1977 | 07cb560 | 2006-01-20 10:55:05 +0000 | [diff] [blame] | 1552 | /* No commit or rollback needed if the program never started */ |
| 1553 | if( p->pc>=0 ){ |
drh | aac2f55 | 2006-09-23 21:44:23 +0000 | [diff] [blame] | 1554 | int mrc; /* Primary error code from p->rc */ |
drh | ff0587c | 2007-08-29 17:43:19 +0000 | [diff] [blame] | 1555 | |
| 1556 | /* Lock all btrees used by the statement */ |
| 1557 | sqlite3BtreeMutexArrayEnter(&p->aMutex); |
| 1558 | |
drh | 71b890a | 2007-10-03 15:30:52 +0000 | [diff] [blame] | 1559 | /* Check for one of the special errors */ |
drh | aac2f55 | 2006-09-23 21:44:23 +0000 | [diff] [blame] | 1560 | mrc = p->rc & 0xff; |
drh | 71b890a | 2007-10-03 15:30:52 +0000 | [diff] [blame] | 1561 | isSpecialError = mrc==SQLITE_NOMEM || mrc==SQLITE_IOERR |
drh | 77658e2 | 2007-12-04 16:54:52 +0000 | [diff] [blame] | 1562 | || mrc==SQLITE_INTERRUPT || mrc==SQLITE_FULL; |
danielk1977 | 07cb560 | 2006-01-20 10:55:05 +0000 | [diff] [blame] | 1563 | if( isSpecialError ){ |
danielk1977 | 07cb560 | 2006-01-20 10:55:05 +0000 | [diff] [blame] | 1564 | /* If the query was read-only, we need do no rollback at all. Otherwise, |
| 1565 | ** proceed with the special handling. |
| 1566 | */ |
drh | ad4a4b8 | 2008-11-05 16:37:34 +0000 | [diff] [blame] | 1567 | if( !p->readOnly || mrc!=SQLITE_INTERRUPT ){ |
| 1568 | if( p->rc==SQLITE_IOERR_BLOCKED && p->usesStmtJournal ){ |
danielk1977 | e965ac7 | 2007-06-13 15:22:28 +0000 | [diff] [blame] | 1569 | xFunc = sqlite3BtreeRollbackStmt; |
| 1570 | p->rc = SQLITE_BUSY; |
drh | ad4a4b8 | 2008-11-05 16:37:34 +0000 | [diff] [blame] | 1571 | }else if( (mrc==SQLITE_NOMEM || mrc==SQLITE_FULL) |
| 1572 | && p->usesStmtJournal ){ |
danielk1977 | 07cb560 | 2006-01-20 10:55:05 +0000 | [diff] [blame] | 1573 | xFunc = sqlite3BtreeRollbackStmt; |
| 1574 | }else{ |
| 1575 | /* We are forced to roll back the active transaction. Before doing |
| 1576 | ** so, abort any other statements this handle currently has active. |
| 1577 | */ |
drh | fb98264 | 2007-08-30 01:19:59 +0000 | [diff] [blame] | 1578 | invalidateCursorsOnModifiedBtrees(db); |
danielk1977 | 97a227c | 2006-01-20 16:32:04 +0000 | [diff] [blame] | 1579 | sqlite3RollbackAll(db); |
danielk1977 | 07cb560 | 2006-01-20 10:55:05 +0000 | [diff] [blame] | 1580 | db->autoCommit = 1; |
| 1581 | } |
danielk1977 | 261919c | 2005-12-06 12:52:59 +0000 | [diff] [blame] | 1582 | } |
| 1583 | } |
danielk1977 | 07cb560 | 2006-01-20 10:55:05 +0000 | [diff] [blame] | 1584 | |
| 1585 | /* If the auto-commit flag is set and this is the only active vdbe, then |
| 1586 | ** we do either a commit or rollback of the current transaction. |
| 1587 | ** |
| 1588 | ** Note: This block also runs if one of the special errors handled |
drh | ad4a4b8 | 2008-11-05 16:37:34 +0000 | [diff] [blame] | 1589 | ** above has occurred. |
danielk1977 | 07cb560 | 2006-01-20 10:55:05 +0000 | [diff] [blame] | 1590 | */ |
danielk1977 | 093e0f6 | 2008-11-13 18:00:14 +0000 | [diff] [blame] | 1591 | if( !sqlite3VtabInSync(db) |
| 1592 | && db->autoCommit |
| 1593 | && db->writeVdbeCnt==(p->readOnly==0) |
| 1594 | ){ |
danielk1977 | 07cb560 | 2006-01-20 10:55:05 +0000 | [diff] [blame] | 1595 | if( p->rc==SQLITE_OK || (p->errorAction==OE_Fail && !isSpecialError) ){ |
drh | fd131da | 2007-08-07 17:13:03 +0000 | [diff] [blame] | 1596 | /* The auto-commit flag is true, and the vdbe program was |
danielk1977 | 07cb560 | 2006-01-20 10:55:05 +0000 | [diff] [blame] | 1597 | ** successful or hit an 'OR FAIL' constraint. This means a commit |
| 1598 | ** is required. |
| 1599 | */ |
danielk1977 | 3e3a84d | 2008-08-01 17:37:40 +0000 | [diff] [blame] | 1600 | int rc = vdbeCommit(db, p); |
danielk1977 | 07cb560 | 2006-01-20 10:55:05 +0000 | [diff] [blame] | 1601 | if( rc==SQLITE_BUSY ){ |
drh | ff0587c | 2007-08-29 17:43:19 +0000 | [diff] [blame] | 1602 | sqlite3BtreeMutexArrayLeave(&p->aMutex); |
danielk1977 | 07cb560 | 2006-01-20 10:55:05 +0000 | [diff] [blame] | 1603 | return SQLITE_BUSY; |
| 1604 | }else if( rc!=SQLITE_OK ){ |
| 1605 | p->rc = rc; |
danielk1977 | 97a227c | 2006-01-20 16:32:04 +0000 | [diff] [blame] | 1606 | sqlite3RollbackAll(db); |
danielk1977 | 07cb560 | 2006-01-20 10:55:05 +0000 | [diff] [blame] | 1607 | }else{ |
| 1608 | sqlite3CommitInternalChanges(db); |
| 1609 | } |
| 1610 | }else{ |
danielk1977 | 97a227c | 2006-01-20 16:32:04 +0000 | [diff] [blame] | 1611 | sqlite3RollbackAll(db); |
danielk1977 | 07cb560 | 2006-01-20 10:55:05 +0000 | [diff] [blame] | 1612 | } |
| 1613 | }else if( !xFunc ){ |
| 1614 | if( p->rc==SQLITE_OK || p->errorAction==OE_Fail ){ |
danielk1977 | 182c4ba | 2007-06-27 15:53:34 +0000 | [diff] [blame] | 1615 | if( p->openedStatement ){ |
| 1616 | xFunc = sqlite3BtreeCommitStmt; |
| 1617 | } |
danielk1977 | 07cb560 | 2006-01-20 10:55:05 +0000 | [diff] [blame] | 1618 | }else if( p->errorAction==OE_Abort ){ |
| 1619 | xFunc = sqlite3BtreeRollbackStmt; |
| 1620 | }else{ |
drh | fb98264 | 2007-08-30 01:19:59 +0000 | [diff] [blame] | 1621 | invalidateCursorsOnModifiedBtrees(db); |
danielk1977 | 97a227c | 2006-01-20 16:32:04 +0000 | [diff] [blame] | 1622 | sqlite3RollbackAll(db); |
danielk1977 | 07cb560 | 2006-01-20 10:55:05 +0000 | [diff] [blame] | 1623 | db->autoCommit = 1; |
| 1624 | } |
danielk1977 | 1d850a7 | 2004-05-31 08:26:49 +0000 | [diff] [blame] | 1625 | } |
danielk1977 | 07cb560 | 2006-01-20 10:55:05 +0000 | [diff] [blame] | 1626 | |
| 1627 | /* If xFunc is not NULL, then it is one of sqlite3BtreeRollbackStmt or |
| 1628 | ** sqlite3BtreeCommitStmt. Call it once on each backend. If an error occurs |
| 1629 | ** and the return code is still SQLITE_OK, set the return code to the new |
| 1630 | ** error value. |
| 1631 | */ |
| 1632 | assert(!xFunc || |
| 1633 | xFunc==sqlite3BtreeCommitStmt || |
| 1634 | xFunc==sqlite3BtreeRollbackStmt |
| 1635 | ); |
| 1636 | for(i=0; xFunc && i<db->nDb; i++){ |
| 1637 | int rc; |
| 1638 | Btree *pBt = db->aDb[i].pBt; |
| 1639 | if( pBt ){ |
| 1640 | rc = xFunc(pBt); |
danielk1977 | 8a7aea3 | 2006-01-23 15:25:48 +0000 | [diff] [blame] | 1641 | if( rc && (p->rc==SQLITE_OK || p->rc==SQLITE_CONSTRAINT) ){ |
| 1642 | p->rc = rc; |
drh | 633e6d5 | 2008-07-28 19:34:53 +0000 | [diff] [blame] | 1643 | sqlite3DbFree(db, p->zErrMsg); |
drh | f089aa4 | 2008-07-08 19:34:06 +0000 | [diff] [blame] | 1644 | p->zErrMsg = 0; |
danielk1977 | 8a7aea3 | 2006-01-23 15:25:48 +0000 | [diff] [blame] | 1645 | } |
danielk1977 | 07cb560 | 2006-01-20 10:55:05 +0000 | [diff] [blame] | 1646 | } |
danielk1977 | 77d83ba | 2004-05-31 10:08:14 +0000 | [diff] [blame] | 1647 | } |
danielk1977 | 07cb560 | 2006-01-20 10:55:05 +0000 | [diff] [blame] | 1648 | |
| 1649 | /* If this was an INSERT, UPDATE or DELETE and the statement was committed, |
| 1650 | ** set the change counter. |
| 1651 | */ |
| 1652 | if( p->changeCntOn && p->pc>=0 ){ |
| 1653 | if( !xFunc || xFunc==sqlite3BtreeCommitStmt ){ |
| 1654 | sqlite3VdbeSetChanges(db, p->nChange); |
| 1655 | }else{ |
| 1656 | sqlite3VdbeSetChanges(db, 0); |
| 1657 | } |
| 1658 | p->nChange = 0; |
danielk1977 | b28af71 | 2004-06-21 06:50:26 +0000 | [diff] [blame] | 1659 | } |
danielk1977 | 07cb560 | 2006-01-20 10:55:05 +0000 | [diff] [blame] | 1660 | |
| 1661 | /* Rollback or commit any schema changes that occurred. */ |
| 1662 | if( p->rc!=SQLITE_OK && db->flags&SQLITE_InternChanges ){ |
| 1663 | sqlite3ResetInternalSchema(db, 0); |
| 1664 | db->flags = (db->flags | SQLITE_InternChanges); |
| 1665 | } |
drh | ff0587c | 2007-08-29 17:43:19 +0000 | [diff] [blame] | 1666 | |
| 1667 | /* Release the locks */ |
| 1668 | sqlite3BtreeMutexArrayLeave(&p->aMutex); |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 1669 | } |
danielk1977 | 1d850a7 | 2004-05-31 08:26:49 +0000 | [diff] [blame] | 1670 | |
danielk1977 | 65fd59f | 2006-06-24 11:51:33 +0000 | [diff] [blame] | 1671 | /* We have successfully halted and closed the VM. Record this fact. */ |
| 1672 | if( p->pc>=0 ){ |
danielk1977 | 1d850a7 | 2004-05-31 08:26:49 +0000 | [diff] [blame] | 1673 | db->activeVdbeCnt--; |
drh | ad4a4b8 | 2008-11-05 16:37:34 +0000 | [diff] [blame] | 1674 | if( !p->readOnly ){ |
| 1675 | db->writeVdbeCnt--; |
| 1676 | } |
| 1677 | assert( db->activeVdbeCnt>=db->writeVdbeCnt ); |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 1678 | } |
drh | 92f02c3 | 2004-09-02 14:57:08 +0000 | [diff] [blame] | 1679 | p->magic = VDBE_MAGIC_HALT; |
| 1680 | checkActiveVdbeCnt(db); |
drh | ff0587c | 2007-08-29 17:43:19 +0000 | [diff] [blame] | 1681 | if( p->db->mallocFailed ){ |
| 1682 | p->rc = SQLITE_NOMEM; |
| 1683 | } |
danielk1977 | 1d850a7 | 2004-05-31 08:26:49 +0000 | [diff] [blame] | 1684 | |
drh | 92f02c3 | 2004-09-02 14:57:08 +0000 | [diff] [blame] | 1685 | return SQLITE_OK; |
| 1686 | } |
drh | 4cf7c7f | 2007-08-28 23:28:07 +0000 | [diff] [blame] | 1687 | |
drh | 92f02c3 | 2004-09-02 14:57:08 +0000 | [diff] [blame] | 1688 | |
| 1689 | /* |
drh | 3c23a88 | 2007-01-09 14:01:13 +0000 | [diff] [blame] | 1690 | ** Each VDBE holds the result of the most recent sqlite3_step() call |
| 1691 | ** in p->rc. This routine sets that result back to SQLITE_OK. |
| 1692 | */ |
| 1693 | void sqlite3VdbeResetStepResult(Vdbe *p){ |
| 1694 | p->rc = SQLITE_OK; |
| 1695 | } |
| 1696 | |
| 1697 | /* |
drh | 92f02c3 | 2004-09-02 14:57:08 +0000 | [diff] [blame] | 1698 | ** Clean up a VDBE after execution but do not delete the VDBE just yet. |
| 1699 | ** Write any error messages into *pzErrMsg. Return the result code. |
| 1700 | ** |
| 1701 | ** After this routine is run, the VDBE should be ready to be executed |
| 1702 | ** again. |
| 1703 | ** |
| 1704 | ** To look at it another way, this routine resets the state of the |
| 1705 | ** virtual machine from VDBE_MAGIC_RUN or VDBE_MAGIC_HALT back to |
| 1706 | ** VDBE_MAGIC_INIT. |
| 1707 | */ |
drh | c890fec | 2008-08-01 20:10:08 +0000 | [diff] [blame] | 1708 | int sqlite3VdbeReset(Vdbe *p){ |
drh | 4ac285a | 2006-09-15 07:28:50 +0000 | [diff] [blame] | 1709 | sqlite3 *db; |
drh | 4ac285a | 2006-09-15 07:28:50 +0000 | [diff] [blame] | 1710 | db = p->db; |
drh | 92f02c3 | 2004-09-02 14:57:08 +0000 | [diff] [blame] | 1711 | |
| 1712 | /* If the VM did not run to completion or if it encountered an |
| 1713 | ** error, then it might not have been halted properly. So halt |
| 1714 | ** it now. |
| 1715 | */ |
drh | 7e8b848 | 2008-01-23 03:03:05 +0000 | [diff] [blame] | 1716 | (void)sqlite3SafetyOn(db); |
drh | 92f02c3 | 2004-09-02 14:57:08 +0000 | [diff] [blame] | 1717 | sqlite3VdbeHalt(p); |
drh | 7e8b848 | 2008-01-23 03:03:05 +0000 | [diff] [blame] | 1718 | (void)sqlite3SafetyOff(db); |
drh | 92f02c3 | 2004-09-02 14:57:08 +0000 | [diff] [blame] | 1719 | |
drh | fb7e765 | 2005-01-24 00:28:42 +0000 | [diff] [blame] | 1720 | /* If the VDBE has be run even partially, then transfer the error code |
| 1721 | ** and error message from the VDBE into the main database structure. But |
| 1722 | ** if the VDBE has just been set to run but has not actually executed any |
| 1723 | ** instructions yet, leave the main database error information unchanged. |
drh | 92f02c3 | 2004-09-02 14:57:08 +0000 | [diff] [blame] | 1724 | */ |
drh | fb7e765 | 2005-01-24 00:28:42 +0000 | [diff] [blame] | 1725 | if( p->pc>=0 ){ |
| 1726 | if( p->zErrMsg ){ |
danielk1977 | 9ff3f3f | 2008-10-11 17:51:38 +0000 | [diff] [blame] | 1727 | sqlite3BeginBenignMalloc(); |
drh | 633e6d5 | 2008-07-28 19:34:53 +0000 | [diff] [blame] | 1728 | sqlite3ValueSetStr(db->pErr,-1,p->zErrMsg,SQLITE_UTF8,SQLITE_TRANSIENT); |
danielk1977 | 9ff3f3f | 2008-10-11 17:51:38 +0000 | [diff] [blame] | 1729 | sqlite3EndBenignMalloc(); |
danielk1977 | 97a227c | 2006-01-20 16:32:04 +0000 | [diff] [blame] | 1730 | db->errCode = p->rc; |
drh | 633e6d5 | 2008-07-28 19:34:53 +0000 | [diff] [blame] | 1731 | sqlite3DbFree(db, p->zErrMsg); |
drh | fb7e765 | 2005-01-24 00:28:42 +0000 | [diff] [blame] | 1732 | p->zErrMsg = 0; |
| 1733 | }else if( p->rc ){ |
drh | 4ac285a | 2006-09-15 07:28:50 +0000 | [diff] [blame] | 1734 | sqlite3Error(db, p->rc, 0); |
drh | fb7e765 | 2005-01-24 00:28:42 +0000 | [diff] [blame] | 1735 | }else{ |
drh | 4ac285a | 2006-09-15 07:28:50 +0000 | [diff] [blame] | 1736 | sqlite3Error(db, SQLITE_OK, 0); |
drh | fb7e765 | 2005-01-24 00:28:42 +0000 | [diff] [blame] | 1737 | } |
danielk1977 | a21c6b6 | 2005-01-24 10:25:59 +0000 | [diff] [blame] | 1738 | }else if( p->rc && p->expired ){ |
| 1739 | /* The expired flag was set on the VDBE before the first call |
| 1740 | ** to sqlite3_step(). For consistency (since sqlite3_step() was |
| 1741 | ** called), set the database error in this case as well. |
| 1742 | */ |
drh | 4ac285a | 2006-09-15 07:28:50 +0000 | [diff] [blame] | 1743 | sqlite3Error(db, p->rc, 0); |
drh | 633e6d5 | 2008-07-28 19:34:53 +0000 | [diff] [blame] | 1744 | sqlite3ValueSetStr(db->pErr, -1, p->zErrMsg, SQLITE_UTF8, SQLITE_TRANSIENT); |
| 1745 | sqlite3DbFree(db, p->zErrMsg); |
danielk1977 | 8e55652 | 2007-11-13 10:30:24 +0000 | [diff] [blame] | 1746 | p->zErrMsg = 0; |
drh | 92f02c3 | 2004-09-02 14:57:08 +0000 | [diff] [blame] | 1747 | } |
| 1748 | |
| 1749 | /* Reclaim all memory used by the VDBE |
| 1750 | */ |
drh | c890fec | 2008-08-01 20:10:08 +0000 | [diff] [blame] | 1751 | Cleanup(p); |
drh | 92f02c3 | 2004-09-02 14:57:08 +0000 | [diff] [blame] | 1752 | |
| 1753 | /* Save profiling information from this VDBE run. |
| 1754 | */ |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 1755 | #ifdef VDBE_PROFILE |
| 1756 | { |
| 1757 | FILE *out = fopen("vdbe_profile.out", "a"); |
| 1758 | if( out ){ |
| 1759 | int i; |
| 1760 | fprintf(out, "---- "); |
| 1761 | for(i=0; i<p->nOp; i++){ |
| 1762 | fprintf(out, "%02x", p->aOp[i].opcode); |
| 1763 | } |
| 1764 | fprintf(out, "\n"); |
| 1765 | for(i=0; i<p->nOp; i++){ |
| 1766 | fprintf(out, "%6d %10lld %8lld ", |
| 1767 | p->aOp[i].cnt, |
| 1768 | p->aOp[i].cycles, |
| 1769 | p->aOp[i].cnt>0 ? p->aOp[i].cycles/p->aOp[i].cnt : 0 |
| 1770 | ); |
danielk1977 | 4adee20 | 2004-05-08 08:23:19 +0000 | [diff] [blame] | 1771 | sqlite3VdbePrintOp(out, i, &p->aOp[i]); |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 1772 | } |
| 1773 | fclose(out); |
| 1774 | } |
| 1775 | } |
| 1776 | #endif |
| 1777 | p->magic = VDBE_MAGIC_INIT; |
drh | 4ac285a | 2006-09-15 07:28:50 +0000 | [diff] [blame] | 1778 | return p->rc & db->errMask; |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 1779 | } |
drh | 92f02c3 | 2004-09-02 14:57:08 +0000 | [diff] [blame] | 1780 | |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 1781 | /* |
| 1782 | ** Clean up and delete a VDBE after execution. Return an integer which is |
| 1783 | ** the result code. Write any error message text into *pzErrMsg. |
| 1784 | */ |
danielk1977 | 9e6db7d | 2004-06-21 08:18:51 +0000 | [diff] [blame] | 1785 | int sqlite3VdbeFinalize(Vdbe *p){ |
danielk1977 | b5548a8 | 2004-06-26 13:51:33 +0000 | [diff] [blame] | 1786 | int rc = SQLITE_OK; |
danielk1977 | b5548a8 | 2004-06-26 13:51:33 +0000 | [diff] [blame] | 1787 | if( p->magic==VDBE_MAGIC_RUN || p->magic==VDBE_MAGIC_HALT ){ |
drh | c890fec | 2008-08-01 20:10:08 +0000 | [diff] [blame] | 1788 | rc = sqlite3VdbeReset(p); |
drh | 4ac285a | 2006-09-15 07:28:50 +0000 | [diff] [blame] | 1789 | assert( (rc & p->db->errMask)==rc ); |
danielk1977 | b5548a8 | 2004-06-26 13:51:33 +0000 | [diff] [blame] | 1790 | }else if( p->magic!=VDBE_MAGIC_INIT ){ |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 1791 | return SQLITE_MISUSE; |
| 1792 | } |
danielk1977 | 4adee20 | 2004-05-08 08:23:19 +0000 | [diff] [blame] | 1793 | sqlite3VdbeDelete(p); |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 1794 | return rc; |
| 1795 | } |
| 1796 | |
| 1797 | /* |
drh | f92c7ff | 2004-06-19 15:40:23 +0000 | [diff] [blame] | 1798 | ** Call the destructor for each auxdata entry in pVdbeFunc for which |
danielk1977 | e159fdf | 2004-06-21 10:45:06 +0000 | [diff] [blame] | 1799 | ** the corresponding bit in mask is clear. Auxdata entries beyond 31 |
drh | f92c7ff | 2004-06-19 15:40:23 +0000 | [diff] [blame] | 1800 | ** are always destroyed. To destroy all auxdata entries, call this |
danielk1977 | e159fdf | 2004-06-21 10:45:06 +0000 | [diff] [blame] | 1801 | ** routine with mask==0. |
drh | f92c7ff | 2004-06-19 15:40:23 +0000 | [diff] [blame] | 1802 | */ |
| 1803 | void sqlite3VdbeDeleteAuxData(VdbeFunc *pVdbeFunc, int mask){ |
| 1804 | int i; |
| 1805 | for(i=0; i<pVdbeFunc->nAux; i++){ |
| 1806 | struct AuxData *pAux = &pVdbeFunc->apAux[i]; |
| 1807 | if( (i>31 || !(mask&(1<<i))) && pAux->pAux ){ |
| 1808 | if( pAux->xDelete ){ |
| 1809 | pAux->xDelete(pAux->pAux); |
| 1810 | } |
| 1811 | pAux->pAux = 0; |
| 1812 | } |
| 1813 | } |
| 1814 | } |
| 1815 | |
| 1816 | /* |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 1817 | ** Delete an entire VDBE. |
| 1818 | */ |
danielk1977 | 4adee20 | 2004-05-08 08:23:19 +0000 | [diff] [blame] | 1819 | void sqlite3VdbeDelete(Vdbe *p){ |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 1820 | int i; |
drh | 633e6d5 | 2008-07-28 19:34:53 +0000 | [diff] [blame] | 1821 | sqlite3 *db; |
| 1822 | |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 1823 | if( p==0 ) return; |
drh | 633e6d5 | 2008-07-28 19:34:53 +0000 | [diff] [blame] | 1824 | db = p->db; |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 1825 | if( p->pPrev ){ |
| 1826 | p->pPrev->pNext = p->pNext; |
| 1827 | }else{ |
drh | 633e6d5 | 2008-07-28 19:34:53 +0000 | [diff] [blame] | 1828 | assert( db->pVdbe==p ); |
| 1829 | db->pVdbe = p->pNext; |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 1830 | } |
| 1831 | if( p->pNext ){ |
| 1832 | p->pNext->pPrev = p->pPrev; |
| 1833 | } |
drh | 76ff3a0 | 2004-09-24 22:32:30 +0000 | [diff] [blame] | 1834 | if( p->aOp ){ |
drh | d4e70eb | 2008-01-02 00:34:36 +0000 | [diff] [blame] | 1835 | Op *pOp = p->aOp; |
| 1836 | for(i=0; i<p->nOp; i++, pOp++){ |
drh | 633e6d5 | 2008-07-28 19:34:53 +0000 | [diff] [blame] | 1837 | freeP4(db, pOp->p4type, pOp->p4.p); |
drh | d4e70eb | 2008-01-02 00:34:36 +0000 | [diff] [blame] | 1838 | #ifdef SQLITE_DEBUG |
drh | 633e6d5 | 2008-07-28 19:34:53 +0000 | [diff] [blame] | 1839 | sqlite3DbFree(db, pOp->zComment); |
drh | d4e70eb | 2008-01-02 00:34:36 +0000 | [diff] [blame] | 1840 | #endif |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 1841 | } |
drh | 633e6d5 | 2008-07-28 19:34:53 +0000 | [diff] [blame] | 1842 | sqlite3DbFree(db, p->aOp); |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 1843 | } |
drh | c890fec | 2008-08-01 20:10:08 +0000 | [diff] [blame] | 1844 | releaseMemArray(p->aVar, p->nVar); |
drh | 633e6d5 | 2008-07-28 19:34:53 +0000 | [diff] [blame] | 1845 | sqlite3DbFree(db, p->aLabel); |
drh | 9cbf342 | 2008-01-17 16:22:13 +0000 | [diff] [blame] | 1846 | if( p->aMem ){ |
drh | 633e6d5 | 2008-07-28 19:34:53 +0000 | [diff] [blame] | 1847 | sqlite3DbFree(db, &p->aMem[1]); |
drh | 9cbf342 | 2008-01-17 16:22:13 +0000 | [diff] [blame] | 1848 | } |
drh | c890fec | 2008-08-01 20:10:08 +0000 | [diff] [blame] | 1849 | releaseMemArray(p->aColName, p->nResColumn*COLNAME_N); |
drh | 633e6d5 | 2008-07-28 19:34:53 +0000 | [diff] [blame] | 1850 | sqlite3DbFree(db, p->aColName); |
| 1851 | sqlite3DbFree(db, p->zSql); |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 1852 | p->magic = VDBE_MAGIC_DEAD; |
drh | 633e6d5 | 2008-07-28 19:34:53 +0000 | [diff] [blame] | 1853 | sqlite3DbFree(db, p); |
drh | 9a32464 | 2003-09-06 20:12:01 +0000 | [diff] [blame] | 1854 | } |
drh | a11846b | 2004-01-07 18:52:56 +0000 | [diff] [blame] | 1855 | |
| 1856 | /* |
drh | a11846b | 2004-01-07 18:52:56 +0000 | [diff] [blame] | 1857 | ** If a MoveTo operation is pending on the given cursor, then do that |
| 1858 | ** MoveTo now. Return an error code. If no MoveTo is pending, this |
| 1859 | ** routine does nothing and returns SQLITE_OK. |
| 1860 | */ |
drh | dfe88ec | 2008-11-03 20:55:06 +0000 | [diff] [blame] | 1861 | int sqlite3VdbeCursorMoveto(VdbeCursor *p){ |
drh | a11846b | 2004-01-07 18:52:56 +0000 | [diff] [blame] | 1862 | if( p->deferredMoveto ){ |
drh | 536065a | 2005-01-26 21:55:31 +0000 | [diff] [blame] | 1863 | int res, rc; |
adamd | 4fc9308 | 2006-09-14 16:57:19 +0000 | [diff] [blame] | 1864 | #ifdef SQLITE_TEST |
danielk1977 | 132872b | 2004-05-10 10:37:18 +0000 | [diff] [blame] | 1865 | extern int sqlite3_search_count; |
adamd | 4fc9308 | 2006-09-14 16:57:19 +0000 | [diff] [blame] | 1866 | #endif |
drh | f0863fe | 2005-06-12 21:35:51 +0000 | [diff] [blame] | 1867 | assert( p->isTable ); |
drh | e63d999 | 2008-08-13 19:11:48 +0000 | [diff] [blame] | 1868 | rc = sqlite3BtreeMovetoUnpacked(p->pCursor, 0, p->movetoTarget, 0, &res); |
drh | 536065a | 2005-01-26 21:55:31 +0000 | [diff] [blame] | 1869 | if( rc ) return rc; |
drh | f0863fe | 2005-06-12 21:35:51 +0000 | [diff] [blame] | 1870 | p->lastRowid = keyToInt(p->movetoTarget); |
| 1871 | p->rowidIsValid = res==0; |
drh | a11846b | 2004-01-07 18:52:56 +0000 | [diff] [blame] | 1872 | if( res<0 ){ |
drh | 536065a | 2005-01-26 21:55:31 +0000 | [diff] [blame] | 1873 | rc = sqlite3BtreeNext(p->pCursor, &res); |
| 1874 | if( rc ) return rc; |
drh | a11846b | 2004-01-07 18:52:56 +0000 | [diff] [blame] | 1875 | } |
drh | 10cfdd5 | 2006-08-08 15:42:59 +0000 | [diff] [blame] | 1876 | #ifdef SQLITE_TEST |
danielk1977 | 132872b | 2004-05-10 10:37:18 +0000 | [diff] [blame] | 1877 | sqlite3_search_count++; |
drh | 10cfdd5 | 2006-08-08 15:42:59 +0000 | [diff] [blame] | 1878 | #endif |
drh | a11846b | 2004-01-07 18:52:56 +0000 | [diff] [blame] | 1879 | p->deferredMoveto = 0; |
drh | 76873ab | 2006-01-07 18:48:26 +0000 | [diff] [blame] | 1880 | p->cacheStatus = CACHE_STALE; |
drh | a346058 | 2008-07-11 21:02:53 +0000 | [diff] [blame] | 1881 | }else if( p->pCursor ){ |
| 1882 | int hasMoved; |
| 1883 | int rc = sqlite3BtreeCursorHasMoved(p->pCursor, &hasMoved); |
| 1884 | if( rc ) return rc; |
| 1885 | if( hasMoved ){ |
| 1886 | p->cacheStatus = CACHE_STALE; |
| 1887 | p->nullRow = 1; |
| 1888 | } |
drh | a11846b | 2004-01-07 18:52:56 +0000 | [diff] [blame] | 1889 | } |
| 1890 | return SQLITE_OK; |
| 1891 | } |
danielk1977 | 4adee20 | 2004-05-08 08:23:19 +0000 | [diff] [blame] | 1892 | |
drh | ab9f7f1 | 2004-05-08 10:56:11 +0000 | [diff] [blame] | 1893 | /* |
danielk1977 | cfcdaef | 2004-05-12 07:33:33 +0000 | [diff] [blame] | 1894 | ** The following functions: |
danielk1977 | 90e4d95 | 2004-05-10 10:05:53 +0000 | [diff] [blame] | 1895 | ** |
danielk1977 | cfcdaef | 2004-05-12 07:33:33 +0000 | [diff] [blame] | 1896 | ** sqlite3VdbeSerialType() |
| 1897 | ** sqlite3VdbeSerialTypeLen() |
danielk1977 | 90e4d95 | 2004-05-10 10:05:53 +0000 | [diff] [blame] | 1898 | ** sqlite3VdbeSerialLen() |
shane | 9200309 | 2008-07-31 01:43:13 +0000 | [diff] [blame] | 1899 | ** sqlite3VdbeSerialPut() |
| 1900 | ** sqlite3VdbeSerialGet() |
danielk1977 | 90e4d95 | 2004-05-10 10:05:53 +0000 | [diff] [blame] | 1901 | ** |
| 1902 | ** encapsulate the code that serializes values for storage in SQLite |
danielk1977 | cfcdaef | 2004-05-12 07:33:33 +0000 | [diff] [blame] | 1903 | ** data and index records. Each serialized value consists of a |
| 1904 | ** 'serial-type' and a blob of data. The serial type is an 8-byte unsigned |
| 1905 | ** integer, stored as a varint. |
danielk1977 | 90e4d95 | 2004-05-10 10:05:53 +0000 | [diff] [blame] | 1906 | ** |
danielk1977 | cfcdaef | 2004-05-12 07:33:33 +0000 | [diff] [blame] | 1907 | ** In an SQLite index record, the serial type is stored directly before |
| 1908 | ** the blob of data that it corresponds to. In a table record, all serial |
| 1909 | ** types are stored at the start of the record, and the blobs of data at |
| 1910 | ** the end. Hence these functions allow the caller to handle the |
| 1911 | ** serial-type and data blob seperately. |
| 1912 | ** |
| 1913 | ** The following table describes the various storage classes for data: |
| 1914 | ** |
| 1915 | ** serial type bytes of data type |
danielk1977 | 90e4d95 | 2004-05-10 10:05:53 +0000 | [diff] [blame] | 1916 | ** -------------- --------------- --------------- |
drh | a19b775 | 2004-05-30 21:14:58 +0000 | [diff] [blame] | 1917 | ** 0 0 NULL |
danielk1977 | 90e4d95 | 2004-05-10 10:05:53 +0000 | [diff] [blame] | 1918 | ** 1 1 signed integer |
| 1919 | ** 2 2 signed integer |
drh | a19b775 | 2004-05-30 21:14:58 +0000 | [diff] [blame] | 1920 | ** 3 3 signed integer |
| 1921 | ** 4 4 signed integer |
| 1922 | ** 5 6 signed integer |
| 1923 | ** 6 8 signed integer |
| 1924 | ** 7 8 IEEE float |
drh | d946db0 | 2005-12-29 19:23:06 +0000 | [diff] [blame] | 1925 | ** 8 0 Integer constant 0 |
| 1926 | ** 9 0 Integer constant 1 |
| 1927 | ** 10,11 reserved for expansion |
danielk1977 | 90e4d95 | 2004-05-10 10:05:53 +0000 | [diff] [blame] | 1928 | ** N>=12 and even (N-12)/2 BLOB |
| 1929 | ** N>=13 and odd (N-13)/2 text |
| 1930 | ** |
drh | 35a5965 | 2006-01-02 18:24:40 +0000 | [diff] [blame] | 1931 | ** The 8 and 9 types were added in 3.3.0, file format 4. Prior versions |
| 1932 | ** of SQLite will not understand those serial types. |
danielk1977 | 90e4d95 | 2004-05-10 10:05:53 +0000 | [diff] [blame] | 1933 | */ |
| 1934 | |
| 1935 | /* |
danielk1977 | cfcdaef | 2004-05-12 07:33:33 +0000 | [diff] [blame] | 1936 | ** Return the serial-type for the value stored in pMem. |
danielk1977 | 192ac1d | 2004-05-10 07:17:30 +0000 | [diff] [blame] | 1937 | */ |
drh | d946db0 | 2005-12-29 19:23:06 +0000 | [diff] [blame] | 1938 | u32 sqlite3VdbeSerialType(Mem *pMem, int file_format){ |
danielk1977 | cfcdaef | 2004-05-12 07:33:33 +0000 | [diff] [blame] | 1939 | int flags = pMem->flags; |
drh | fdf972a | 2007-05-02 13:30:27 +0000 | [diff] [blame] | 1940 | int n; |
danielk1977 | cfcdaef | 2004-05-12 07:33:33 +0000 | [diff] [blame] | 1941 | |
| 1942 | if( flags&MEM_Null ){ |
drh | a19b775 | 2004-05-30 21:14:58 +0000 | [diff] [blame] | 1943 | return 0; |
danielk1977 | 90e4d95 | 2004-05-10 10:05:53 +0000 | [diff] [blame] | 1944 | } |
danielk1977 | cfcdaef | 2004-05-12 07:33:33 +0000 | [diff] [blame] | 1945 | if( flags&MEM_Int ){ |
drh | fe2093d | 2005-01-20 22:48:47 +0000 | [diff] [blame] | 1946 | /* Figure out whether to use 1, 2, 4, 6 or 8 bytes. */ |
drh | 5284a05 | 2008-05-08 15:18:10 +0000 | [diff] [blame] | 1947 | # define MAX_6BYTE ((((i64)0x00008000)<<32)-1) |
drh | 3c024d6 | 2007-03-30 11:23:45 +0000 | [diff] [blame] | 1948 | i64 i = pMem->u.i; |
drh | d946db0 | 2005-12-29 19:23:06 +0000 | [diff] [blame] | 1949 | u64 u; |
| 1950 | if( file_format>=4 && (i&1)==i ){ |
| 1951 | return 8+i; |
| 1952 | } |
| 1953 | u = i<0 ? -i : i; |
drh | 5742b63 | 2005-01-26 17:47:02 +0000 | [diff] [blame] | 1954 | if( u<=127 ) return 1; |
| 1955 | if( u<=32767 ) return 2; |
| 1956 | if( u<=8388607 ) return 3; |
| 1957 | if( u<=2147483647 ) return 4; |
| 1958 | if( u<=MAX_6BYTE ) return 5; |
drh | a19b775 | 2004-05-30 21:14:58 +0000 | [diff] [blame] | 1959 | return 6; |
danielk1977 | 90e4d95 | 2004-05-10 10:05:53 +0000 | [diff] [blame] | 1960 | } |
danielk1977 | cfcdaef | 2004-05-12 07:33:33 +0000 | [diff] [blame] | 1961 | if( flags&MEM_Real ){ |
drh | a19b775 | 2004-05-30 21:14:58 +0000 | [diff] [blame] | 1962 | return 7; |
danielk1977 | 90e4d95 | 2004-05-10 10:05:53 +0000 | [diff] [blame] | 1963 | } |
danielk1977 | e435975 | 2008-11-03 09:39:45 +0000 | [diff] [blame] | 1964 | assert( pMem->db->mallocFailed || flags&(MEM_Str|MEM_Blob) ); |
drh | fdf972a | 2007-05-02 13:30:27 +0000 | [diff] [blame] | 1965 | n = pMem->n; |
| 1966 | if( flags & MEM_Zero ){ |
| 1967 | n += pMem->u.i; |
danielk1977 | 90e4d95 | 2004-05-10 10:05:53 +0000 | [diff] [blame] | 1968 | } |
drh | fdf972a | 2007-05-02 13:30:27 +0000 | [diff] [blame] | 1969 | assert( n>=0 ); |
| 1970 | return ((n*2) + 12 + ((flags&MEM_Str)!=0)); |
danielk1977 | 192ac1d | 2004-05-10 07:17:30 +0000 | [diff] [blame] | 1971 | } |
| 1972 | |
| 1973 | /* |
danielk1977 | cfcdaef | 2004-05-12 07:33:33 +0000 | [diff] [blame] | 1974 | ** Return the length of the data corresponding to the supplied serial-type. |
danielk1977 | 192ac1d | 2004-05-10 07:17:30 +0000 | [diff] [blame] | 1975 | */ |
drh | 25aa1b4 | 2004-05-28 01:39:01 +0000 | [diff] [blame] | 1976 | int sqlite3VdbeSerialTypeLen(u32 serial_type){ |
drh | a19b775 | 2004-05-30 21:14:58 +0000 | [diff] [blame] | 1977 | if( serial_type>=12 ){ |
drh | 51846b5 | 2004-05-28 16:00:21 +0000 | [diff] [blame] | 1978 | return (serial_type-12)/2; |
| 1979 | }else{ |
drh | 5719628 | 2004-10-06 15:41:16 +0000 | [diff] [blame] | 1980 | 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] | 1981 | return aSize[serial_type]; |
| 1982 | } |
danielk1977 | 192ac1d | 2004-05-10 07:17:30 +0000 | [diff] [blame] | 1983 | } |
| 1984 | |
| 1985 | /* |
drh | 110daac | 2007-05-04 11:59:31 +0000 | [diff] [blame] | 1986 | ** If we are on an architecture with mixed-endian floating |
drh | 7a4f502 | 2007-05-23 07:20:08 +0000 | [diff] [blame] | 1987 | ** points (ex: ARM7) then swap the lower 4 bytes with the |
drh | 110daac | 2007-05-04 11:59:31 +0000 | [diff] [blame] | 1988 | ** upper 4 bytes. Return the result. |
| 1989 | ** |
drh | 7a4f502 | 2007-05-23 07:20:08 +0000 | [diff] [blame] | 1990 | ** For most architectures, this is a no-op. |
| 1991 | ** |
| 1992 | ** (later): It is reported to me that the mixed-endian problem |
| 1993 | ** on ARM7 is an issue with GCC, not with the ARM7 chip. It seems |
| 1994 | ** that early versions of GCC stored the two words of a 64-bit |
| 1995 | ** float in the wrong order. And that error has been propagated |
| 1996 | ** ever since. The blame is not necessarily with GCC, though. |
| 1997 | ** GCC might have just copying the problem from a prior compiler. |
| 1998 | ** I am also told that newer versions of GCC that follow a different |
| 1999 | ** ABI get the byte order right. |
| 2000 | ** |
| 2001 | ** Developers using SQLite on an ARM7 should compile and run their |
| 2002 | ** application using -DSQLITE_DEBUG=1 at least once. With DEBUG |
| 2003 | ** enabled, some asserts below will ensure that the byte order of |
| 2004 | ** floating point values is correct. |
drh | 60d09a7 | 2007-08-30 15:05:08 +0000 | [diff] [blame] | 2005 | ** |
| 2006 | ** (2007-08-30) Frank van Vugt has studied this problem closely |
| 2007 | ** and has send his findings to the SQLite developers. Frank |
| 2008 | ** writes that some Linux kernels offer floating point hardware |
| 2009 | ** emulation that uses only 32-bit mantissas instead of a full |
| 2010 | ** 48-bits as required by the IEEE standard. (This is the |
| 2011 | ** CONFIG_FPE_FASTFPE option.) On such systems, floating point |
| 2012 | ** byte swapping becomes very complicated. To avoid problems, |
| 2013 | ** the necessary byte swapping is carried out using a 64-bit integer |
| 2014 | ** rather than a 64-bit float. Frank assures us that the code here |
| 2015 | ** works for him. We, the developers, have no way to independently |
| 2016 | ** verify this, but Frank seems to know what he is talking about |
| 2017 | ** so we trust him. |
drh | 110daac | 2007-05-04 11:59:31 +0000 | [diff] [blame] | 2018 | */ |
| 2019 | #ifdef SQLITE_MIXED_ENDIAN_64BIT_FLOAT |
drh | 60d09a7 | 2007-08-30 15:05:08 +0000 | [diff] [blame] | 2020 | static u64 floatSwap(u64 in){ |
drh | 110daac | 2007-05-04 11:59:31 +0000 | [diff] [blame] | 2021 | union { |
drh | 60d09a7 | 2007-08-30 15:05:08 +0000 | [diff] [blame] | 2022 | u64 r; |
drh | 110daac | 2007-05-04 11:59:31 +0000 | [diff] [blame] | 2023 | u32 i[2]; |
| 2024 | } u; |
| 2025 | u32 t; |
| 2026 | |
| 2027 | u.r = in; |
| 2028 | t = u.i[0]; |
| 2029 | u.i[0] = u.i[1]; |
| 2030 | u.i[1] = t; |
| 2031 | return u.r; |
| 2032 | } |
| 2033 | # define swapMixedEndianFloat(X) X = floatSwap(X) |
| 2034 | #else |
| 2035 | # define swapMixedEndianFloat(X) |
| 2036 | #endif |
| 2037 | |
| 2038 | /* |
danielk1977 | cfcdaef | 2004-05-12 07:33:33 +0000 | [diff] [blame] | 2039 | ** Write the serialized data blob for the value stored in pMem into |
| 2040 | ** buf. It is assumed that the caller has allocated sufficient space. |
| 2041 | ** Return the number of bytes written. |
drh | fdf972a | 2007-05-02 13:30:27 +0000 | [diff] [blame] | 2042 | ** |
| 2043 | ** nBuf is the amount of space left in buf[]. nBuf must always be |
| 2044 | ** large enough to hold the entire field. Except, if the field is |
| 2045 | ** a blob with a zero-filled tail, then buf[] might be just the right |
| 2046 | ** size to hold everything except for the zero-filled tail. If buf[] |
| 2047 | ** is only big enough to hold the non-zero prefix, then only write that |
| 2048 | ** prefix into buf[]. But if buf[] is large enough to hold both the |
| 2049 | ** prefix and the tail then write the prefix and set the tail to all |
| 2050 | ** zeros. |
| 2051 | ** |
| 2052 | ** Return the number of bytes actually written into buf[]. The number |
| 2053 | ** of bytes in the zero-filled tail is included in the return value only |
| 2054 | ** if those bytes were zeroed in buf[]. |
danielk1977 | cfcdaef | 2004-05-12 07:33:33 +0000 | [diff] [blame] | 2055 | */ |
drh | fdf972a | 2007-05-02 13:30:27 +0000 | [diff] [blame] | 2056 | int sqlite3VdbeSerialPut(u8 *buf, int nBuf, Mem *pMem, int file_format){ |
drh | d946db0 | 2005-12-29 19:23:06 +0000 | [diff] [blame] | 2057 | u32 serial_type = sqlite3VdbeSerialType(pMem, file_format); |
danielk1977 | cfcdaef | 2004-05-12 07:33:33 +0000 | [diff] [blame] | 2058 | int len; |
danielk1977 | 183f9f7 | 2004-05-13 05:20:26 +0000 | [diff] [blame] | 2059 | |
drh | 1483e14 | 2004-05-21 21:12:42 +0000 | [diff] [blame] | 2060 | /* Integer and Real */ |
drh | d946db0 | 2005-12-29 19:23:06 +0000 | [diff] [blame] | 2061 | if( serial_type<=7 && serial_type>0 ){ |
drh | 1483e14 | 2004-05-21 21:12:42 +0000 | [diff] [blame] | 2062 | u64 v; |
| 2063 | int i; |
drh | a19b775 | 2004-05-30 21:14:58 +0000 | [diff] [blame] | 2064 | if( serial_type==7 ){ |
drh | 4f0c587 | 2007-03-26 22:05:01 +0000 | [diff] [blame] | 2065 | assert( sizeof(v)==sizeof(pMem->r) ); |
| 2066 | memcpy(&v, &pMem->r, sizeof(v)); |
drh | 60d09a7 | 2007-08-30 15:05:08 +0000 | [diff] [blame] | 2067 | swapMixedEndianFloat(v); |
drh | 1483e14 | 2004-05-21 21:12:42 +0000 | [diff] [blame] | 2068 | }else{ |
drh | 3c024d6 | 2007-03-30 11:23:45 +0000 | [diff] [blame] | 2069 | v = pMem->u.i; |
danielk1977 | cfcdaef | 2004-05-12 07:33:33 +0000 | [diff] [blame] | 2070 | } |
drh | 1483e14 | 2004-05-21 21:12:42 +0000 | [diff] [blame] | 2071 | len = i = sqlite3VdbeSerialTypeLen(serial_type); |
drh | fdf972a | 2007-05-02 13:30:27 +0000 | [diff] [blame] | 2072 | assert( len<=nBuf ); |
drh | 1483e14 | 2004-05-21 21:12:42 +0000 | [diff] [blame] | 2073 | while( i-- ){ |
| 2074 | buf[i] = (v&0xFF); |
| 2075 | v >>= 8; |
| 2076 | } |
| 2077 | return len; |
danielk1977 | cfcdaef | 2004-05-12 07:33:33 +0000 | [diff] [blame] | 2078 | } |
drh | d946db0 | 2005-12-29 19:23:06 +0000 | [diff] [blame] | 2079 | |
danielk1977 | cfcdaef | 2004-05-12 07:33:33 +0000 | [diff] [blame] | 2080 | /* String or blob */ |
drh | d946db0 | 2005-12-29 19:23:06 +0000 | [diff] [blame] | 2081 | if( serial_type>=12 ){ |
drh | fdf972a | 2007-05-02 13:30:27 +0000 | [diff] [blame] | 2082 | assert( pMem->n + ((pMem->flags & MEM_Zero)?pMem->u.i:0) |
| 2083 | == sqlite3VdbeSerialTypeLen(serial_type) ); |
| 2084 | assert( pMem->n<=nBuf ); |
| 2085 | len = pMem->n; |
drh | d946db0 | 2005-12-29 19:23:06 +0000 | [diff] [blame] | 2086 | memcpy(buf, pMem->z, len); |
drh | fdf972a | 2007-05-02 13:30:27 +0000 | [diff] [blame] | 2087 | if( pMem->flags & MEM_Zero ){ |
| 2088 | len += pMem->u.i; |
| 2089 | if( len>nBuf ){ |
| 2090 | len = nBuf; |
| 2091 | } |
| 2092 | memset(&buf[pMem->n], 0, len-pMem->n); |
| 2093 | } |
drh | d946db0 | 2005-12-29 19:23:06 +0000 | [diff] [blame] | 2094 | return len; |
| 2095 | } |
| 2096 | |
| 2097 | /* NULL or constants 0 or 1 */ |
| 2098 | return 0; |
danielk1977 | cfcdaef | 2004-05-12 07:33:33 +0000 | [diff] [blame] | 2099 | } |
| 2100 | |
| 2101 | /* |
| 2102 | ** Deserialize the data blob pointed to by buf as serial type serial_type |
| 2103 | ** and store the result in pMem. Return the number of bytes read. |
| 2104 | */ |
danielk1977 | b1bc953 | 2004-05-22 03:05:33 +0000 | [diff] [blame] | 2105 | int sqlite3VdbeSerialGet( |
danielk1977 | 93d4675 | 2004-05-23 13:30:58 +0000 | [diff] [blame] | 2106 | const unsigned char *buf, /* Buffer to deserialize from */ |
drh | 25aa1b4 | 2004-05-28 01:39:01 +0000 | [diff] [blame] | 2107 | u32 serial_type, /* Serial type to deserialize */ |
| 2108 | Mem *pMem /* Memory cell to write value into */ |
danielk1977 | b1bc953 | 2004-05-22 03:05:33 +0000 | [diff] [blame] | 2109 | ){ |
drh | 3c68582 | 2005-05-21 18:32:18 +0000 | [diff] [blame] | 2110 | switch( serial_type ){ |
drh | 3c68582 | 2005-05-21 18:32:18 +0000 | [diff] [blame] | 2111 | case 10: /* Reserved for future use */ |
| 2112 | case 11: /* Reserved for future use */ |
| 2113 | case 0: { /* NULL */ |
| 2114 | pMem->flags = MEM_Null; |
| 2115 | break; |
| 2116 | } |
| 2117 | case 1: { /* 1-byte signed integer */ |
drh | 3c024d6 | 2007-03-30 11:23:45 +0000 | [diff] [blame] | 2118 | pMem->u.i = (signed char)buf[0]; |
drh | 1483e14 | 2004-05-21 21:12:42 +0000 | [diff] [blame] | 2119 | pMem->flags = MEM_Int; |
drh | 3c68582 | 2005-05-21 18:32:18 +0000 | [diff] [blame] | 2120 | return 1; |
drh | 1483e14 | 2004-05-21 21:12:42 +0000 | [diff] [blame] | 2121 | } |
drh | 3c68582 | 2005-05-21 18:32:18 +0000 | [diff] [blame] | 2122 | case 2: { /* 2-byte signed integer */ |
drh | 3c024d6 | 2007-03-30 11:23:45 +0000 | [diff] [blame] | 2123 | pMem->u.i = (((signed char)buf[0])<<8) | buf[1]; |
drh | 3c68582 | 2005-05-21 18:32:18 +0000 | [diff] [blame] | 2124 | pMem->flags = MEM_Int; |
| 2125 | return 2; |
| 2126 | } |
| 2127 | case 3: { /* 3-byte signed integer */ |
drh | 3c024d6 | 2007-03-30 11:23:45 +0000 | [diff] [blame] | 2128 | pMem->u.i = (((signed char)buf[0])<<16) | (buf[1]<<8) | buf[2]; |
drh | 3c68582 | 2005-05-21 18:32:18 +0000 | [diff] [blame] | 2129 | pMem->flags = MEM_Int; |
| 2130 | return 3; |
| 2131 | } |
| 2132 | case 4: { /* 4-byte signed integer */ |
drh | 3c024d6 | 2007-03-30 11:23:45 +0000 | [diff] [blame] | 2133 | pMem->u.i = (buf[0]<<24) | (buf[1]<<16) | (buf[2]<<8) | buf[3]; |
drh | 3c68582 | 2005-05-21 18:32:18 +0000 | [diff] [blame] | 2134 | pMem->flags = MEM_Int; |
| 2135 | return 4; |
| 2136 | } |
| 2137 | case 5: { /* 6-byte signed integer */ |
| 2138 | u64 x = (((signed char)buf[0])<<8) | buf[1]; |
| 2139 | u32 y = (buf[2]<<24) | (buf[3]<<16) | (buf[4]<<8) | buf[5]; |
| 2140 | x = (x<<32) | y; |
drh | 3c024d6 | 2007-03-30 11:23:45 +0000 | [diff] [blame] | 2141 | pMem->u.i = *(i64*)&x; |
drh | 3c68582 | 2005-05-21 18:32:18 +0000 | [diff] [blame] | 2142 | pMem->flags = MEM_Int; |
| 2143 | return 6; |
| 2144 | } |
drh | 91124b3 | 2005-08-18 18:15:05 +0000 | [diff] [blame] | 2145 | case 6: /* 8-byte signed integer */ |
drh | 3c68582 | 2005-05-21 18:32:18 +0000 | [diff] [blame] | 2146 | case 7: { /* IEEE floating point */ |
drh | d81bd4e | 2005-09-05 20:06:49 +0000 | [diff] [blame] | 2147 | u64 x; |
| 2148 | u32 y; |
drh | 2a3e4a7 | 2006-01-23 21:44:53 +0000 | [diff] [blame] | 2149 | #if !defined(NDEBUG) && !defined(SQLITE_OMIT_FLOATING_POINT) |
drh | de941c6 | 2005-08-28 01:34:21 +0000 | [diff] [blame] | 2150 | /* Verify that integers and floating point values use the same |
drh | 110daac | 2007-05-04 11:59:31 +0000 | [diff] [blame] | 2151 | ** byte order. Or, that if SQLITE_MIXED_ENDIAN_64BIT_FLOAT is |
| 2152 | ** defined that 64-bit floating point values really are mixed |
| 2153 | ** endian. |
drh | bfd6b03 | 2005-08-28 01:38:44 +0000 | [diff] [blame] | 2154 | */ |
drh | de941c6 | 2005-08-28 01:34:21 +0000 | [diff] [blame] | 2155 | static const u64 t1 = ((u64)0x3ff00000)<<32; |
drh | 4f0c587 | 2007-03-26 22:05:01 +0000 | [diff] [blame] | 2156 | static const double r1 = 1.0; |
drh | 60d09a7 | 2007-08-30 15:05:08 +0000 | [diff] [blame] | 2157 | u64 t2 = t1; |
| 2158 | swapMixedEndianFloat(t2); |
| 2159 | assert( sizeof(r1)==sizeof(t2) && memcmp(&r1, &t2, sizeof(r1))==0 ); |
drh | de941c6 | 2005-08-28 01:34:21 +0000 | [diff] [blame] | 2160 | #endif |
drh | bfd6b03 | 2005-08-28 01:38:44 +0000 | [diff] [blame] | 2161 | |
drh | d81bd4e | 2005-09-05 20:06:49 +0000 | [diff] [blame] | 2162 | x = (buf[0]<<24) | (buf[1]<<16) | (buf[2]<<8) | buf[3]; |
| 2163 | y = (buf[4]<<24) | (buf[5]<<16) | (buf[6]<<8) | buf[7]; |
drh | 3c68582 | 2005-05-21 18:32:18 +0000 | [diff] [blame] | 2164 | x = (x<<32) | y; |
| 2165 | if( serial_type==6 ){ |
drh | 3c024d6 | 2007-03-30 11:23:45 +0000 | [diff] [blame] | 2166 | pMem->u.i = *(i64*)&x; |
drh | 3c68582 | 2005-05-21 18:32:18 +0000 | [diff] [blame] | 2167 | pMem->flags = MEM_Int; |
| 2168 | }else{ |
drh | 4f0c587 | 2007-03-26 22:05:01 +0000 | [diff] [blame] | 2169 | assert( sizeof(x)==8 && sizeof(pMem->r)==8 ); |
drh | 60d09a7 | 2007-08-30 15:05:08 +0000 | [diff] [blame] | 2170 | swapMixedEndianFloat(x); |
drh | 4f0c587 | 2007-03-26 22:05:01 +0000 | [diff] [blame] | 2171 | memcpy(&pMem->r, &x, sizeof(x)); |
drh | 2eaf93d | 2008-04-29 00:15:20 +0000 | [diff] [blame] | 2172 | pMem->flags = sqlite3IsNaN(pMem->r) ? MEM_Null : MEM_Real; |
drh | 3c68582 | 2005-05-21 18:32:18 +0000 | [diff] [blame] | 2173 | } |
| 2174 | return 8; |
| 2175 | } |
drh | d946db0 | 2005-12-29 19:23:06 +0000 | [diff] [blame] | 2176 | case 8: /* Integer 0 */ |
| 2177 | case 9: { /* Integer 1 */ |
drh | 3c024d6 | 2007-03-30 11:23:45 +0000 | [diff] [blame] | 2178 | pMem->u.i = serial_type-8; |
drh | d946db0 | 2005-12-29 19:23:06 +0000 | [diff] [blame] | 2179 | pMem->flags = MEM_Int; |
| 2180 | return 0; |
| 2181 | } |
drh | 3c68582 | 2005-05-21 18:32:18 +0000 | [diff] [blame] | 2182 | default: { |
| 2183 | int len = (serial_type-12)/2; |
| 2184 | pMem->z = (char *)buf; |
| 2185 | pMem->n = len; |
| 2186 | pMem->xDel = 0; |
| 2187 | if( serial_type&0x01 ){ |
| 2188 | pMem->flags = MEM_Str | MEM_Ephem; |
| 2189 | }else{ |
| 2190 | pMem->flags = MEM_Blob | MEM_Ephem; |
| 2191 | } |
| 2192 | return len; |
drh | 696b32f | 2004-05-30 01:51:52 +0000 | [diff] [blame] | 2193 | } |
danielk1977 | cfcdaef | 2004-05-12 07:33:33 +0000 | [diff] [blame] | 2194 | } |
drh | 3c68582 | 2005-05-21 18:32:18 +0000 | [diff] [blame] | 2195 | return 0; |
danielk1977 | 192ac1d | 2004-05-10 07:17:30 +0000 | [diff] [blame] | 2196 | } |
| 2197 | |
drh | 0e6082e | 2006-01-12 20:28:35 +0000 | [diff] [blame] | 2198 | |
drh | 1e968a0 | 2008-03-25 00:22:21 +0000 | [diff] [blame] | 2199 | /* |
| 2200 | ** Given the nKey-byte encoding of a record in pKey[], parse the |
drh | e14006d | 2008-03-25 17:23:32 +0000 | [diff] [blame] | 2201 | ** record into a UnpackedRecord structure. Return a pointer to |
drh | 1e968a0 | 2008-03-25 00:22:21 +0000 | [diff] [blame] | 2202 | ** that structure. |
| 2203 | ** |
| 2204 | ** The calling function might provide szSpace bytes of memory |
| 2205 | ** space at pSpace. This space can be used to hold the returned |
| 2206 | ** VDbeParsedRecord structure if it is large enough. If it is |
| 2207 | ** not big enough, space is obtained from sqlite3_malloc(). |
| 2208 | ** |
| 2209 | ** The returned structure should be closed by a call to |
drh | e14006d | 2008-03-25 17:23:32 +0000 | [diff] [blame] | 2210 | ** sqlite3VdbeDeleteUnpackedRecord(). |
drh | 1e968a0 | 2008-03-25 00:22:21 +0000 | [diff] [blame] | 2211 | */ |
drh | e14006d | 2008-03-25 17:23:32 +0000 | [diff] [blame] | 2212 | UnpackedRecord *sqlite3VdbeRecordUnpack( |
drh | 1e968a0 | 2008-03-25 00:22:21 +0000 | [diff] [blame] | 2213 | KeyInfo *pKeyInfo, /* Information about the record format */ |
| 2214 | int nKey, /* Size of the binary record */ |
| 2215 | const void *pKey, /* The binary record */ |
drh | 23f79d0 | 2008-08-20 22:06:47 +0000 | [diff] [blame] | 2216 | UnpackedRecord *pSpace,/* Space available to hold resulting object */ |
drh | 1e968a0 | 2008-03-25 00:22:21 +0000 | [diff] [blame] | 2217 | int szSpace /* Size of pSpace[] in bytes */ |
| 2218 | ){ |
| 2219 | const unsigned char *aKey = (const unsigned char *)pKey; |
drh | e14006d | 2008-03-25 17:23:32 +0000 | [diff] [blame] | 2220 | UnpackedRecord *p; |
danielk1977 | 00e1361 | 2008-11-17 19:18:54 +0000 | [diff] [blame] | 2221 | int nByte, d; |
| 2222 | u32 idx; |
shane | 0b8d276 | 2008-07-22 05:18:00 +0000 | [diff] [blame] | 2223 | u16 u; /* Unsigned loop counter */ |
drh | 1e968a0 | 2008-03-25 00:22:21 +0000 | [diff] [blame] | 2224 | u32 szHdr; |
| 2225 | Mem *pMem; |
| 2226 | |
drh | fab6959 | 2008-04-10 14:57:24 +0000 | [diff] [blame] | 2227 | assert( sizeof(Mem)>sizeof(*p) ); |
| 2228 | nByte = sizeof(Mem)*(pKeyInfo->nField+2); |
drh | 1e968a0 | 2008-03-25 00:22:21 +0000 | [diff] [blame] | 2229 | if( nByte>szSpace ){ |
| 2230 | p = sqlite3DbMallocRaw(pKeyInfo->db, nByte); |
| 2231 | if( p==0 ) return 0; |
drh | e63d999 | 2008-08-13 19:11:48 +0000 | [diff] [blame] | 2232 | p->flags = UNPACKED_NEED_FREE | UNPACKED_NEED_DESTROY; |
drh | 1e968a0 | 2008-03-25 00:22:21 +0000 | [diff] [blame] | 2233 | }else{ |
| 2234 | p = pSpace; |
drh | e63d999 | 2008-08-13 19:11:48 +0000 | [diff] [blame] | 2235 | p->flags = UNPACKED_NEED_DESTROY; |
drh | 1e968a0 | 2008-03-25 00:22:21 +0000 | [diff] [blame] | 2236 | } |
| 2237 | p->pKeyInfo = pKeyInfo; |
| 2238 | p->nField = pKeyInfo->nField + 1; |
drh | fab6959 | 2008-04-10 14:57:24 +0000 | [diff] [blame] | 2239 | p->aMem = pMem = &((Mem*)p)[1]; |
shane | 3f8d5cf | 2008-04-24 19:15:09 +0000 | [diff] [blame] | 2240 | idx = getVarint32(aKey, szHdr); |
drh | 1e968a0 | 2008-03-25 00:22:21 +0000 | [diff] [blame] | 2241 | d = szHdr; |
shane | 0b8d276 | 2008-07-22 05:18:00 +0000 | [diff] [blame] | 2242 | u = 0; |
| 2243 | while( idx<szHdr && u<p->nField ){ |
drh | 1e968a0 | 2008-03-25 00:22:21 +0000 | [diff] [blame] | 2244 | u32 serial_type; |
| 2245 | |
danielk1977 | 00e1361 | 2008-11-17 19:18:54 +0000 | [diff] [blame] | 2246 | idx += getVarint32(&aKey[idx], serial_type); |
drh | 1e968a0 | 2008-03-25 00:22:21 +0000 | [diff] [blame] | 2247 | if( d>=nKey && sqlite3VdbeSerialTypeLen(serial_type)>0 ) break; |
| 2248 | pMem->enc = pKeyInfo->enc; |
| 2249 | pMem->db = pKeyInfo->db; |
| 2250 | pMem->flags = 0; |
danielk1977 | 5f09613 | 2008-03-28 15:44:09 +0000 | [diff] [blame] | 2251 | pMem->zMalloc = 0; |
drh | 1e968a0 | 2008-03-25 00:22:21 +0000 | [diff] [blame] | 2252 | d += sqlite3VdbeSerialGet(&aKey[d], serial_type, pMem); |
drh | e14006d | 2008-03-25 17:23:32 +0000 | [diff] [blame] | 2253 | pMem++; |
shane | 0b8d276 | 2008-07-22 05:18:00 +0000 | [diff] [blame] | 2254 | u++; |
drh | 1e968a0 | 2008-03-25 00:22:21 +0000 | [diff] [blame] | 2255 | } |
drh | 7d10d5a | 2008-08-20 16:35:10 +0000 | [diff] [blame] | 2256 | assert( u<=pKeyInfo->nField + 1 ); |
shane | 0b8d276 | 2008-07-22 05:18:00 +0000 | [diff] [blame] | 2257 | p->nField = u; |
drh | 1e968a0 | 2008-03-25 00:22:21 +0000 | [diff] [blame] | 2258 | return (void*)p; |
| 2259 | } |
| 2260 | |
| 2261 | /* |
drh | e14006d | 2008-03-25 17:23:32 +0000 | [diff] [blame] | 2262 | ** This routine destroys a UnpackedRecord object |
drh | 1e968a0 | 2008-03-25 00:22:21 +0000 | [diff] [blame] | 2263 | */ |
drh | e14006d | 2008-03-25 17:23:32 +0000 | [diff] [blame] | 2264 | void sqlite3VdbeDeleteUnpackedRecord(UnpackedRecord *p){ |
drh | 1e968a0 | 2008-03-25 00:22:21 +0000 | [diff] [blame] | 2265 | if( p ){ |
drh | e63d999 | 2008-08-13 19:11:48 +0000 | [diff] [blame] | 2266 | if( p->flags & UNPACKED_NEED_DESTROY ){ |
drh | 1e968a0 | 2008-03-25 00:22:21 +0000 | [diff] [blame] | 2267 | int i; |
drh | e14006d | 2008-03-25 17:23:32 +0000 | [diff] [blame] | 2268 | Mem *pMem; |
| 2269 | for(i=0, pMem=p->aMem; i<p->nField; i++, pMem++){ |
danielk1977 | 5f09613 | 2008-03-28 15:44:09 +0000 | [diff] [blame] | 2270 | if( pMem->zMalloc ){ |
drh | e14006d | 2008-03-25 17:23:32 +0000 | [diff] [blame] | 2271 | sqlite3VdbeMemRelease(pMem); |
drh | 1e968a0 | 2008-03-25 00:22:21 +0000 | [diff] [blame] | 2272 | } |
| 2273 | } |
| 2274 | } |
drh | e63d999 | 2008-08-13 19:11:48 +0000 | [diff] [blame] | 2275 | if( p->flags & UNPACKED_NEED_FREE ){ |
drh | 633e6d5 | 2008-07-28 19:34:53 +0000 | [diff] [blame] | 2276 | sqlite3DbFree(p->pKeyInfo->db, p); |
drh | 1e968a0 | 2008-03-25 00:22:21 +0000 | [diff] [blame] | 2277 | } |
| 2278 | } |
| 2279 | } |
| 2280 | |
| 2281 | /* |
| 2282 | ** This function compares the two table rows or index records |
| 2283 | ** specified by {nKey1, pKey1} and pPKey2. It returns a negative, zero |
drh | e63d999 | 2008-08-13 19:11:48 +0000 | [diff] [blame] | 2284 | ** or positive integer if key1 is less than, equal to or |
| 2285 | ** greater than key2. The {nKey1, pKey1} key must be a blob |
drh | 1e968a0 | 2008-03-25 00:22:21 +0000 | [diff] [blame] | 2286 | ** created by th OP_MakeRecord opcode of the VDBE. The pPKey2 |
| 2287 | ** key must be a parsed key such as obtained from |
| 2288 | ** sqlite3VdbeParseRecord. |
| 2289 | ** |
| 2290 | ** Key1 and Key2 do not have to contain the same number of fields. |
drh | e63d999 | 2008-08-13 19:11:48 +0000 | [diff] [blame] | 2291 | ** The key with fewer fields is usually compares less than the |
| 2292 | ** longer key. However if the UNPACKED_INCRKEY flags in pPKey2 is set |
| 2293 | ** and the common prefixes are equal, then key1 is less than key2. |
| 2294 | ** Or if the UNPACKED_MATCH_PREFIX flag is set and the prefixes are |
| 2295 | ** equal, then the keys are considered to be equal and |
drh | ec1fc80 | 2008-08-13 14:07:40 +0000 | [diff] [blame] | 2296 | ** the parts beyond the common prefix are ignored. |
| 2297 | ** |
drh | e63d999 | 2008-08-13 19:11:48 +0000 | [diff] [blame] | 2298 | ** If the UNPACKED_IGNORE_ROWID flag is set, then the last byte of |
| 2299 | ** the header of pKey1 is ignored. It is assumed that pKey1 is |
| 2300 | ** an index key, and thus ends with a rowid value. The last byte |
| 2301 | ** of the header will therefore be the serial type of the rowid: |
| 2302 | ** one of 1, 2, 3, 4, 5, 6, 8, or 9 - the integer serial types. |
| 2303 | ** The serial type of the final rowid will always be a single byte. |
| 2304 | ** By ignoring this last byte of the header, we force the comparison |
| 2305 | ** to ignore the rowid at the end of key1. |
drh | 1e968a0 | 2008-03-25 00:22:21 +0000 | [diff] [blame] | 2306 | */ |
drh | e14006d | 2008-03-25 17:23:32 +0000 | [diff] [blame] | 2307 | int sqlite3VdbeRecordCompare( |
drh | ec1fc80 | 2008-08-13 14:07:40 +0000 | [diff] [blame] | 2308 | int nKey1, const void *pKey1, /* Left key */ |
drh | ec1fc80 | 2008-08-13 14:07:40 +0000 | [diff] [blame] | 2309 | UnpackedRecord *pPKey2 /* Right key */ |
drh | 1e968a0 | 2008-03-25 00:22:21 +0000 | [diff] [blame] | 2310 | ){ |
danielk1977 | 00e1361 | 2008-11-17 19:18:54 +0000 | [diff] [blame] | 2311 | int d1; /* Offset into aKey[] of next data element */ |
drh | 1e968a0 | 2008-03-25 00:22:21 +0000 | [diff] [blame] | 2312 | u32 idx1; /* Offset into aKey[] of next header element */ |
| 2313 | u32 szHdr1; /* Number of bytes in header */ |
| 2314 | int i = 0; |
| 2315 | int nField; |
| 2316 | int rc = 0; |
| 2317 | const unsigned char *aKey1 = (const unsigned char *)pKey1; |
| 2318 | KeyInfo *pKeyInfo; |
| 2319 | Mem mem1; |
| 2320 | |
| 2321 | pKeyInfo = pPKey2->pKeyInfo; |
| 2322 | mem1.enc = pKeyInfo->enc; |
| 2323 | mem1.db = pKeyInfo->db; |
| 2324 | mem1.flags = 0; |
danielk1977 | 5f09613 | 2008-03-28 15:44:09 +0000 | [diff] [blame] | 2325 | mem1.zMalloc = 0; |
drh | 1e968a0 | 2008-03-25 00:22:21 +0000 | [diff] [blame] | 2326 | |
shane | 3f8d5cf | 2008-04-24 19:15:09 +0000 | [diff] [blame] | 2327 | idx1 = getVarint32(aKey1, szHdr1); |
drh | 1e968a0 | 2008-03-25 00:22:21 +0000 | [diff] [blame] | 2328 | d1 = szHdr1; |
drh | e63d999 | 2008-08-13 19:11:48 +0000 | [diff] [blame] | 2329 | if( pPKey2->flags & UNPACKED_IGNORE_ROWID ){ |
| 2330 | szHdr1--; |
| 2331 | } |
drh | 1e968a0 | 2008-03-25 00:22:21 +0000 | [diff] [blame] | 2332 | nField = pKeyInfo->nField; |
| 2333 | while( idx1<szHdr1 && i<pPKey2->nField ){ |
| 2334 | u32 serial_type1; |
| 2335 | |
| 2336 | /* Read the serial types for the next element in each key. */ |
shane | 3f8d5cf | 2008-04-24 19:15:09 +0000 | [diff] [blame] | 2337 | idx1 += getVarint32( aKey1+idx1, serial_type1 ); |
drh | 1e968a0 | 2008-03-25 00:22:21 +0000 | [diff] [blame] | 2338 | if( d1>=nKey1 && sqlite3VdbeSerialTypeLen(serial_type1)>0 ) break; |
| 2339 | |
| 2340 | /* Extract the values to be compared. |
| 2341 | */ |
| 2342 | d1 += sqlite3VdbeSerialGet(&aKey1[d1], serial_type1, &mem1); |
| 2343 | |
| 2344 | /* Do the comparison |
| 2345 | */ |
drh | e14006d | 2008-03-25 17:23:32 +0000 | [diff] [blame] | 2346 | rc = sqlite3MemCompare(&mem1, &pPKey2->aMem[i], |
drh | 1e968a0 | 2008-03-25 00:22:21 +0000 | [diff] [blame] | 2347 | i<nField ? pKeyInfo->aColl[i] : 0); |
drh | 1e968a0 | 2008-03-25 00:22:21 +0000 | [diff] [blame] | 2348 | if( rc!=0 ){ |
| 2349 | break; |
| 2350 | } |
| 2351 | i++; |
| 2352 | } |
danielk1977 | 5f09613 | 2008-03-28 15:44:09 +0000 | [diff] [blame] | 2353 | if( mem1.zMalloc ) sqlite3VdbeMemRelease(&mem1); |
drh | 1e968a0 | 2008-03-25 00:22:21 +0000 | [diff] [blame] | 2354 | |
drh | 1e968a0 | 2008-03-25 00:22:21 +0000 | [diff] [blame] | 2355 | if( rc==0 ){ |
drh | ec1fc80 | 2008-08-13 14:07:40 +0000 | [diff] [blame] | 2356 | /* rc==0 here means that one of the keys ran out of fields and |
drh | e63d999 | 2008-08-13 19:11:48 +0000 | [diff] [blame] | 2357 | ** all the fields up to that point were equal. If the UNPACKED_INCRKEY |
| 2358 | ** flag is set, then break the tie by treating key2 as larger. |
| 2359 | ** If the UPACKED_PREFIX_MATCH flag is set, then keys with common prefixes |
drh | ec1fc80 | 2008-08-13 14:07:40 +0000 | [diff] [blame] | 2360 | ** are considered to be equal. Otherwise, the longer key is the |
| 2361 | ** larger. As it happens, the pPKey2 will always be the longer |
| 2362 | ** if there is a difference. |
| 2363 | */ |
drh | e63d999 | 2008-08-13 19:11:48 +0000 | [diff] [blame] | 2364 | if( pPKey2->flags & UNPACKED_INCRKEY ){ |
drh | 1e968a0 | 2008-03-25 00:22:21 +0000 | [diff] [blame] | 2365 | rc = -1; |
drh | e63d999 | 2008-08-13 19:11:48 +0000 | [diff] [blame] | 2366 | }else if( pPKey2->flags & UNPACKED_PREFIX_MATCH ){ |
drh | ec1fc80 | 2008-08-13 14:07:40 +0000 | [diff] [blame] | 2367 | /* Leave rc==0 */ |
| 2368 | }else if( idx1<szHdr1 ){ |
| 2369 | rc = 1; |
drh | 1e968a0 | 2008-03-25 00:22:21 +0000 | [diff] [blame] | 2370 | } |
| 2371 | }else if( pKeyInfo->aSortOrder && i<pKeyInfo->nField |
| 2372 | && pKeyInfo->aSortOrder[i] ){ |
| 2373 | rc = -rc; |
| 2374 | } |
| 2375 | |
| 2376 | return rc; |
| 2377 | } |
drh | ec1fc80 | 2008-08-13 14:07:40 +0000 | [diff] [blame] | 2378 | |
danielk1977 | eb015e0 | 2004-05-18 01:31:14 +0000 | [diff] [blame] | 2379 | |
| 2380 | /* |
drh | 7a224de | 2004-06-02 01:22:02 +0000 | [diff] [blame] | 2381 | ** pCur points at an index entry created using the OP_MakeRecord opcode. |
| 2382 | ** Read the rowid (the last field in the record) and store it in *rowid. |
| 2383 | ** Return SQLITE_OK if everything works, or an error code otherwise. |
danielk1977 | 183f9f7 | 2004-05-13 05:20:26 +0000 | [diff] [blame] | 2384 | */ |
drh | b21c8cd | 2007-08-21 19:33:56 +0000 | [diff] [blame] | 2385 | int sqlite3VdbeIdxRowid(BtCursor *pCur, i64 *rowid){ |
drh | 61fc595 | 2007-04-01 23:49:51 +0000 | [diff] [blame] | 2386 | i64 nCellKey = 0; |
danielk1977 | 183f9f7 | 2004-05-13 05:20:26 +0000 | [diff] [blame] | 2387 | int rc; |
drh | d578820 | 2004-05-28 08:21:05 +0000 | [diff] [blame] | 2388 | u32 szHdr; /* Size of the header */ |
| 2389 | u32 typeRowid; /* Serial type of the rowid */ |
| 2390 | u32 lenRowid; /* Size of the rowid */ |
| 2391 | Mem m, v; |
danielk1977 | 183f9f7 | 2004-05-13 05:20:26 +0000 | [diff] [blame] | 2392 | |
drh | d578820 | 2004-05-28 08:21:05 +0000 | [diff] [blame] | 2393 | sqlite3BtreeKeySize(pCur, &nCellKey); |
| 2394 | if( nCellKey<=0 ){ |
drh | 4928570 | 2005-09-17 15:20:26 +0000 | [diff] [blame] | 2395 | return SQLITE_CORRUPT_BKPT; |
drh | d578820 | 2004-05-28 08:21:05 +0000 | [diff] [blame] | 2396 | } |
danielk1977 | a7a8e14 | 2008-02-13 18:25:27 +0000 | [diff] [blame] | 2397 | m.flags = 0; |
| 2398 | m.db = 0; |
danielk1977 | 5f09613 | 2008-03-28 15:44:09 +0000 | [diff] [blame] | 2399 | m.zMalloc = 0; |
drh | b21c8cd | 2007-08-21 19:33:56 +0000 | [diff] [blame] | 2400 | rc = sqlite3VdbeMemFromBtree(pCur, 0, nCellKey, 1, &m); |
drh | d578820 | 2004-05-28 08:21:05 +0000 | [diff] [blame] | 2401 | if( rc ){ |
danielk1977 | 183f9f7 | 2004-05-13 05:20:26 +0000 | [diff] [blame] | 2402 | return rc; |
| 2403 | } |
shane | 3f8d5cf | 2008-04-24 19:15:09 +0000 | [diff] [blame] | 2404 | (void)getVarint32((u8*)m.z, szHdr); |
| 2405 | (void)getVarint32((u8*)&m.z[szHdr-1], typeRowid); |
drh | d578820 | 2004-05-28 08:21:05 +0000 | [diff] [blame] | 2406 | lenRowid = sqlite3VdbeSerialTypeLen(typeRowid); |
drh | 2646da7 | 2005-12-09 20:02:05 +0000 | [diff] [blame] | 2407 | sqlite3VdbeSerialGet((u8*)&m.z[m.n-lenRowid], typeRowid, &v); |
drh | 3c024d6 | 2007-03-30 11:23:45 +0000 | [diff] [blame] | 2408 | *rowid = v.u.i; |
danielk1977 | d812336 | 2004-06-12 09:25:12 +0000 | [diff] [blame] | 2409 | sqlite3VdbeMemRelease(&m); |
danielk1977 | 183f9f7 | 2004-05-13 05:20:26 +0000 | [diff] [blame] | 2410 | return SQLITE_OK; |
| 2411 | } |
| 2412 | |
drh | 7cf6e4d | 2004-05-19 14:56:55 +0000 | [diff] [blame] | 2413 | /* |
drh | d3d39e9 | 2004-05-20 22:16:29 +0000 | [diff] [blame] | 2414 | ** 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] | 2415 | ** the key string in pKey (of length nKey). Write into *pRes a number |
| 2416 | ** that is negative, zero, or positive if pC is less than, equal to, |
| 2417 | ** or greater than pKey. Return SQLITE_OK on success. |
drh | d3d39e9 | 2004-05-20 22:16:29 +0000 | [diff] [blame] | 2418 | ** |
drh | d578820 | 2004-05-28 08:21:05 +0000 | [diff] [blame] | 2419 | ** pKey is either created without a rowid or is truncated so that it |
| 2420 | ** omits the rowid at the end. The rowid at the end of the index entry |
drh | ec1fc80 | 2008-08-13 14:07:40 +0000 | [diff] [blame] | 2421 | ** is ignored as well. Hence, this routine only compares the prefixes |
| 2422 | ** of the keys prior to the final rowid, not the entire key. |
| 2423 | ** |
| 2424 | ** pUnpacked may be an unpacked version of pKey,nKey. If pUnpacked is |
| 2425 | ** supplied it is used in place of pKey,nKey. |
drh | 7cf6e4d | 2004-05-19 14:56:55 +0000 | [diff] [blame] | 2426 | */ |
danielk1977 | 183f9f7 | 2004-05-13 05:20:26 +0000 | [diff] [blame] | 2427 | int sqlite3VdbeIdxKeyCompare( |
drh | dfe88ec | 2008-11-03 20:55:06 +0000 | [diff] [blame] | 2428 | VdbeCursor *pC, /* The cursor to compare against */ |
drh | ec1fc80 | 2008-08-13 14:07:40 +0000 | [diff] [blame] | 2429 | UnpackedRecord *pUnpacked, /* Unpacked version of pKey and nKey */ |
drh | 7cf6e4d | 2004-05-19 14:56:55 +0000 | [diff] [blame] | 2430 | int *res /* Write the comparison result here */ |
danielk1977 | 183f9f7 | 2004-05-13 05:20:26 +0000 | [diff] [blame] | 2431 | ){ |
drh | 61fc595 | 2007-04-01 23:49:51 +0000 | [diff] [blame] | 2432 | i64 nCellKey = 0; |
danielk1977 | 183f9f7 | 2004-05-13 05:20:26 +0000 | [diff] [blame] | 2433 | int rc; |
danielk1977 | 3d1bfea | 2004-05-14 11:00:53 +0000 | [diff] [blame] | 2434 | BtCursor *pCur = pC->pCursor; |
drh | d578820 | 2004-05-28 08:21:05 +0000 | [diff] [blame] | 2435 | Mem m; |
danielk1977 | 183f9f7 | 2004-05-13 05:20:26 +0000 | [diff] [blame] | 2436 | |
| 2437 | sqlite3BtreeKeySize(pCur, &nCellKey); |
| 2438 | if( nCellKey<=0 ){ |
| 2439 | *res = 0; |
| 2440 | return SQLITE_OK; |
| 2441 | } |
danielk1977 | a7a8e14 | 2008-02-13 18:25:27 +0000 | [diff] [blame] | 2442 | m.db = 0; |
| 2443 | m.flags = 0; |
danielk1977 | 5f09613 | 2008-03-28 15:44:09 +0000 | [diff] [blame] | 2444 | m.zMalloc = 0; |
drh | ec1fc80 | 2008-08-13 14:07:40 +0000 | [diff] [blame] | 2445 | rc = sqlite3VdbeMemFromBtree(pC->pCursor, 0, nCellKey, 1, &m); |
| 2446 | if( rc ){ |
drh | d578820 | 2004-05-28 08:21:05 +0000 | [diff] [blame] | 2447 | return rc; |
danielk1977 | 183f9f7 | 2004-05-13 05:20:26 +0000 | [diff] [blame] | 2448 | } |
drh | e63d999 | 2008-08-13 19:11:48 +0000 | [diff] [blame] | 2449 | assert( pUnpacked->flags & UNPACKED_IGNORE_ROWID ); |
| 2450 | *res = sqlite3VdbeRecordCompare(m.n, m.z, pUnpacked); |
danielk1977 | d812336 | 2004-06-12 09:25:12 +0000 | [diff] [blame] | 2451 | sqlite3VdbeMemRelease(&m); |
danielk1977 | 183f9f7 | 2004-05-13 05:20:26 +0000 | [diff] [blame] | 2452 | return SQLITE_OK; |
| 2453 | } |
danielk1977 | b28af71 | 2004-06-21 06:50:26 +0000 | [diff] [blame] | 2454 | |
| 2455 | /* |
| 2456 | ** This routine sets the value to be returned by subsequent calls to |
| 2457 | ** sqlite3_changes() on the database handle 'db'. |
| 2458 | */ |
| 2459 | void sqlite3VdbeSetChanges(sqlite3 *db, int nChange){ |
drh | b21c8cd | 2007-08-21 19:33:56 +0000 | [diff] [blame] | 2460 | assert( sqlite3_mutex_held(db->mutex) ); |
danielk1977 | b28af71 | 2004-06-21 06:50:26 +0000 | [diff] [blame] | 2461 | db->nChange = nChange; |
| 2462 | db->nTotalChange += nChange; |
| 2463 | } |
| 2464 | |
| 2465 | /* |
| 2466 | ** Set a flag in the vdbe to update the change counter when it is finalised |
| 2467 | ** or reset. |
| 2468 | */ |
drh | 4794f73 | 2004-11-05 17:17:50 +0000 | [diff] [blame] | 2469 | void sqlite3VdbeCountChanges(Vdbe *v){ |
| 2470 | v->changeCntOn = 1; |
danielk1977 | b28af71 | 2004-06-21 06:50:26 +0000 | [diff] [blame] | 2471 | } |
drh | d89bd00 | 2005-01-22 03:03:54 +0000 | [diff] [blame] | 2472 | |
| 2473 | /* |
| 2474 | ** Mark every prepared statement associated with a database connection |
| 2475 | ** as expired. |
| 2476 | ** |
| 2477 | ** An expired statement means that recompilation of the statement is |
| 2478 | ** recommend. Statements expire when things happen that make their |
| 2479 | ** programs obsolete. Removing user-defined functions or collating |
| 2480 | ** sequences, or changing an authorization function are the types of |
| 2481 | ** things that make prepared statements obsolete. |
| 2482 | */ |
| 2483 | void sqlite3ExpirePreparedStatements(sqlite3 *db){ |
| 2484 | Vdbe *p; |
| 2485 | for(p = db->pVdbe; p; p=p->pNext){ |
| 2486 | p->expired = 1; |
| 2487 | } |
| 2488 | } |
danielk1977 | aee18ef | 2005-03-09 12:26:50 +0000 | [diff] [blame] | 2489 | |
| 2490 | /* |
| 2491 | ** Return the database associated with the Vdbe. |
| 2492 | */ |
| 2493 | sqlite3 *sqlite3VdbeDb(Vdbe *v){ |
| 2494 | return v->db; |
| 2495 | } |