|
1 /* |
|
2 ** 2001 September 15 |
|
3 ** |
|
4 ** The author disclaims copyright to this source code. In place of |
|
5 ** a legal notice, here is a blessing: |
|
6 ** |
|
7 ** May you do good and not evil. |
|
8 ** May you find forgiveness for yourself and forgive others. |
|
9 ** May you share freely, never taking more than you give. |
|
10 ** |
|
11 ************************************************************************* |
|
12 ** This file contains C code routines that are called by the parser |
|
13 ** to handle UPDATE statements. |
|
14 ** |
|
15 ** $Id: update.c,v 1.181 2008/07/28 19:34:54 drh Exp $ |
|
16 */ |
|
17 #include "sqliteInt.h" |
|
18 |
|
19 #ifndef SQLITE_OMIT_VIRTUALTABLE |
|
20 /* Forward declaration */ |
|
21 static void updateVirtualTable( |
|
22 Parse *pParse, /* The parsing context */ |
|
23 SrcList *pSrc, /* The virtual table to be modified */ |
|
24 Table *pTab, /* The virtual table */ |
|
25 ExprList *pChanges, /* The columns to change in the UPDATE statement */ |
|
26 Expr *pRowidExpr, /* Expression used to recompute the rowid */ |
|
27 int *aXRef, /* Mapping from columns of pTab to entries in pChanges */ |
|
28 Expr *pWhere /* WHERE clause of the UPDATE statement */ |
|
29 ); |
|
30 #endif /* SQLITE_OMIT_VIRTUALTABLE */ |
|
31 |
|
32 /* |
|
33 ** The most recently coded instruction was an OP_Column to retrieve the |
|
34 ** i-th column of table pTab. This routine sets the P4 parameter of the |
|
35 ** OP_Column to the default value, if any. |
|
36 ** |
|
37 ** The default value of a column is specified by a DEFAULT clause in the |
|
38 ** column definition. This was either supplied by the user when the table |
|
39 ** was created, or added later to the table definition by an ALTER TABLE |
|
40 ** command. If the latter, then the row-records in the table btree on disk |
|
41 ** may not contain a value for the column and the default value, taken |
|
42 ** from the P4 parameter of the OP_Column instruction, is returned instead. |
|
43 ** If the former, then all row-records are guaranteed to include a value |
|
44 ** for the column and the P4 value is not required. |
|
45 ** |
|
46 ** Column definitions created by an ALTER TABLE command may only have |
|
47 ** literal default values specified: a number, null or a string. (If a more |
|
48 ** complicated default expression value was provided, it is evaluated |
|
49 ** when the ALTER TABLE is executed and one of the literal values written |
|
50 ** into the sqlite_master table.) |
|
51 ** |
|
52 ** Therefore, the P4 parameter is only required if the default value for |
|
53 ** the column is a literal number, string or null. The sqlite3ValueFromExpr() |
|
54 ** function is capable of transforming these types of expressions into |
|
55 ** sqlite3_value objects. |
|
56 */ |
|
57 void sqlite3ColumnDefault(Vdbe *v, Table *pTab, int i){ |
|
58 if( pTab && !pTab->pSelect ){ |
|
59 sqlite3_value *pValue; |
|
60 u8 enc = ENC(sqlite3VdbeDb(v)); |
|
61 Column *pCol = &pTab->aCol[i]; |
|
62 VdbeComment((v, "%s.%s", pTab->zName, pCol->zName)); |
|
63 assert( i<pTab->nCol ); |
|
64 sqlite3ValueFromExpr(sqlite3VdbeDb(v), pCol->pDflt, enc, |
|
65 pCol->affinity, &pValue); |
|
66 if( pValue ){ |
|
67 sqlite3VdbeChangeP4(v, -1, (const char *)pValue, P4_MEM); |
|
68 } |
|
69 } |
|
70 } |
|
71 |
|
72 /* |
|
73 ** Process an UPDATE statement. |
|
74 ** |
|
75 ** UPDATE OR IGNORE table_wxyz SET a=b, c=d WHERE e<5 AND f NOT NULL; |
|
76 ** \_______/ \________/ \______/ \________________/ |
|
77 * onError pTabList pChanges pWhere |
|
78 */ |
|
79 void sqlite3Update( |
|
80 Parse *pParse, /* The parser context */ |
|
81 SrcList *pTabList, /* The table in which we should change things */ |
|
82 ExprList *pChanges, /* Things to be changed */ |
|
83 Expr *pWhere, /* The WHERE clause. May be null */ |
|
84 int onError /* How to handle constraint errors */ |
|
85 ){ |
|
86 int i, j; /* Loop counters */ |
|
87 Table *pTab; /* The table to be updated */ |
|
88 int addr = 0; /* VDBE instruction address of the start of the loop */ |
|
89 WhereInfo *pWInfo; /* Information about the WHERE clause */ |
|
90 Vdbe *v; /* The virtual database engine */ |
|
91 Index *pIdx; /* For looping over indices */ |
|
92 int nIdx; /* Number of indices that need updating */ |
|
93 int iCur; /* VDBE Cursor number of pTab */ |
|
94 sqlite3 *db; /* The database structure */ |
|
95 int *aRegIdx = 0; /* One register assigned to each index to be updated */ |
|
96 int *aXRef = 0; /* aXRef[i] is the index in pChanges->a[] of the |
|
97 ** an expression for the i-th column of the table. |
|
98 ** aXRef[i]==-1 if the i-th column is not changed. */ |
|
99 int chngRowid; /* True if the record number is being changed */ |
|
100 Expr *pRowidExpr = 0; /* Expression defining the new record number */ |
|
101 int openAll = 0; /* True if all indices need to be opened */ |
|
102 AuthContext sContext; /* The authorization context */ |
|
103 NameContext sNC; /* The name-context to resolve expressions in */ |
|
104 int iDb; /* Database containing the table being updated */ |
|
105 int j1; /* Addresses of jump instructions */ |
|
106 int okOnePass; /* True for one-pass algorithm without the FIFO */ |
|
107 |
|
108 #ifndef SQLITE_OMIT_TRIGGER |
|
109 int isView; /* Trying to update a view */ |
|
110 int triggers_exist = 0; /* True if any row triggers exist */ |
|
111 #endif |
|
112 int iBeginAfterTrigger; /* Address of after trigger program */ |
|
113 int iEndAfterTrigger; /* Exit of after trigger program */ |
|
114 int iBeginBeforeTrigger; /* Address of before trigger program */ |
|
115 int iEndBeforeTrigger; /* Exit of before trigger program */ |
|
116 u32 old_col_mask = 0; /* Mask of OLD.* columns in use */ |
|
117 u32 new_col_mask = 0; /* Mask of NEW.* columns in use */ |
|
118 |
|
119 int newIdx = -1; /* index of trigger "new" temp table */ |
|
120 int oldIdx = -1; /* index of trigger "old" temp table */ |
|
121 |
|
122 /* Register Allocations */ |
|
123 int regRowCount = 0; /* A count of rows changed */ |
|
124 int regOldRowid; /* The old rowid */ |
|
125 int regNewRowid; /* The new rowid */ |
|
126 int regData; /* New data for the row */ |
|
127 |
|
128 sContext.pParse = 0; |
|
129 db = pParse->db; |
|
130 if( pParse->nErr || db->mallocFailed ){ |
|
131 goto update_cleanup; |
|
132 } |
|
133 assert( pTabList->nSrc==1 ); |
|
134 |
|
135 /* Locate the table which we want to update. |
|
136 */ |
|
137 pTab = sqlite3SrcListLookup(pParse, pTabList); |
|
138 if( pTab==0 ) goto update_cleanup; |
|
139 iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema); |
|
140 |
|
141 /* Figure out if we have any triggers and if the table being |
|
142 ** updated is a view |
|
143 */ |
|
144 #ifndef SQLITE_OMIT_TRIGGER |
|
145 triggers_exist = sqlite3TriggersExist(pParse, pTab, TK_UPDATE, pChanges); |
|
146 isView = pTab->pSelect!=0; |
|
147 #else |
|
148 # define triggers_exist 0 |
|
149 # define isView 0 |
|
150 #endif |
|
151 #ifdef SQLITE_OMIT_VIEW |
|
152 # undef isView |
|
153 # define isView 0 |
|
154 #endif |
|
155 |
|
156 if( sqlite3IsReadOnly(pParse, pTab, triggers_exist) ){ |
|
157 goto update_cleanup; |
|
158 } |
|
159 if( sqlite3ViewGetColumnNames(pParse, pTab) ){ |
|
160 goto update_cleanup; |
|
161 } |
|
162 aXRef = sqlite3DbMallocRaw(db, sizeof(int) * pTab->nCol ); |
|
163 if( aXRef==0 ) goto update_cleanup; |
|
164 for(i=0; i<pTab->nCol; i++) aXRef[i] = -1; |
|
165 |
|
166 /* If there are FOR EACH ROW triggers, allocate cursors for the |
|
167 ** special OLD and NEW tables |
|
168 */ |
|
169 if( triggers_exist ){ |
|
170 newIdx = pParse->nTab++; |
|
171 oldIdx = pParse->nTab++; |
|
172 } |
|
173 |
|
174 /* Allocate a cursors for the main database table and for all indices. |
|
175 ** The index cursors might not be used, but if they are used they |
|
176 ** need to occur right after the database cursor. So go ahead and |
|
177 ** allocate enough space, just in case. |
|
178 */ |
|
179 pTabList->a[0].iCursor = iCur = pParse->nTab++; |
|
180 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){ |
|
181 pParse->nTab++; |
|
182 } |
|
183 |
|
184 /* Initialize the name-context */ |
|
185 memset(&sNC, 0, sizeof(sNC)); |
|
186 sNC.pParse = pParse; |
|
187 sNC.pSrcList = pTabList; |
|
188 |
|
189 /* Resolve the column names in all the expressions of the |
|
190 ** of the UPDATE statement. Also find the column index |
|
191 ** for each column to be updated in the pChanges array. For each |
|
192 ** column to be updated, make sure we have authorization to change |
|
193 ** that column. |
|
194 */ |
|
195 chngRowid = 0; |
|
196 for(i=0; i<pChanges->nExpr; i++){ |
|
197 if( sqlite3ExprResolveNames(&sNC, pChanges->a[i].pExpr) ){ |
|
198 goto update_cleanup; |
|
199 } |
|
200 for(j=0; j<pTab->nCol; j++){ |
|
201 if( sqlite3StrICmp(pTab->aCol[j].zName, pChanges->a[i].zName)==0 ){ |
|
202 if( j==pTab->iPKey ){ |
|
203 chngRowid = 1; |
|
204 pRowidExpr = pChanges->a[i].pExpr; |
|
205 } |
|
206 aXRef[j] = i; |
|
207 break; |
|
208 } |
|
209 } |
|
210 if( j>=pTab->nCol ){ |
|
211 if( sqlite3IsRowid(pChanges->a[i].zName) ){ |
|
212 chngRowid = 1; |
|
213 pRowidExpr = pChanges->a[i].pExpr; |
|
214 }else{ |
|
215 sqlite3ErrorMsg(pParse, "no such column: %s", pChanges->a[i].zName); |
|
216 goto update_cleanup; |
|
217 } |
|
218 } |
|
219 #ifndef SQLITE_OMIT_AUTHORIZATION |
|
220 { |
|
221 int rc; |
|
222 rc = sqlite3AuthCheck(pParse, SQLITE_UPDATE, pTab->zName, |
|
223 pTab->aCol[j].zName, db->aDb[iDb].zName); |
|
224 if( rc==SQLITE_DENY ){ |
|
225 goto update_cleanup; |
|
226 }else if( rc==SQLITE_IGNORE ){ |
|
227 aXRef[j] = -1; |
|
228 } |
|
229 } |
|
230 #endif |
|
231 } |
|
232 |
|
233 /* Allocate memory for the array aRegIdx[]. There is one entry in the |
|
234 ** array for each index associated with table being updated. Fill in |
|
235 ** the value with a register number for indices that are to be used |
|
236 ** and with zero for unused indices. |
|
237 */ |
|
238 for(nIdx=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, nIdx++){} |
|
239 if( nIdx>0 ){ |
|
240 aRegIdx = sqlite3DbMallocRaw(db, sizeof(Index*) * nIdx ); |
|
241 if( aRegIdx==0 ) goto update_cleanup; |
|
242 } |
|
243 for(j=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, j++){ |
|
244 int reg; |
|
245 if( chngRowid ){ |
|
246 reg = ++pParse->nMem; |
|
247 }else{ |
|
248 reg = 0; |
|
249 for(i=0; i<pIdx->nColumn; i++){ |
|
250 if( aXRef[pIdx->aiColumn[i]]>=0 ){ |
|
251 reg = ++pParse->nMem; |
|
252 break; |
|
253 } |
|
254 } |
|
255 } |
|
256 aRegIdx[j] = reg; |
|
257 } |
|
258 |
|
259 /* Allocate a block of register used to store the change record |
|
260 ** sent to sqlite3GenerateConstraintChecks(). There are either |
|
261 ** one or two registers for holding the rowid. One rowid register |
|
262 ** is used if chngRowid is false and two are used if chngRowid is |
|
263 ** true. Following these are pTab->nCol register holding column |
|
264 ** data. |
|
265 */ |
|
266 regOldRowid = regNewRowid = pParse->nMem + 1; |
|
267 pParse->nMem += pTab->nCol + 1; |
|
268 if( chngRowid ){ |
|
269 regNewRowid++; |
|
270 pParse->nMem++; |
|
271 } |
|
272 regData = regNewRowid+1; |
|
273 |
|
274 |
|
275 /* Begin generating code. |
|
276 */ |
|
277 v = sqlite3GetVdbe(pParse); |
|
278 if( v==0 ) goto update_cleanup; |
|
279 if( pParse->nested==0 ) sqlite3VdbeCountChanges(v); |
|
280 sqlite3BeginWriteOperation(pParse, 1, iDb); |
|
281 |
|
282 #ifndef SQLITE_OMIT_VIRTUALTABLE |
|
283 /* Virtual tables must be handled separately */ |
|
284 if( IsVirtual(pTab) ){ |
|
285 updateVirtualTable(pParse, pTabList, pTab, pChanges, pRowidExpr, aXRef, |
|
286 pWhere); |
|
287 pWhere = 0; |
|
288 pTabList = 0; |
|
289 goto update_cleanup; |
|
290 } |
|
291 #endif |
|
292 |
|
293 /* Start the view context |
|
294 */ |
|
295 if( isView ){ |
|
296 sqlite3AuthContextPush(pParse, &sContext, pTab->zName); |
|
297 } |
|
298 |
|
299 /* Generate the code for triggers. |
|
300 */ |
|
301 if( triggers_exist ){ |
|
302 int iGoto; |
|
303 |
|
304 /* Create pseudo-tables for NEW and OLD |
|
305 */ |
|
306 sqlite3VdbeAddOp2(v, OP_SetNumColumns, 0, pTab->nCol); |
|
307 sqlite3VdbeAddOp2(v, OP_OpenPseudo, oldIdx, 0); |
|
308 sqlite3VdbeAddOp2(v, OP_SetNumColumns, 0, pTab->nCol); |
|
309 sqlite3VdbeAddOp2(v, OP_OpenPseudo, newIdx, 0); |
|
310 |
|
311 iGoto = sqlite3VdbeAddOp2(v, OP_Goto, 0, 0); |
|
312 addr = sqlite3VdbeMakeLabel(v); |
|
313 iBeginBeforeTrigger = sqlite3VdbeCurrentAddr(v); |
|
314 if( sqlite3CodeRowTrigger(pParse, TK_UPDATE, pChanges, TRIGGER_BEFORE, pTab, |
|
315 newIdx, oldIdx, onError, addr, &old_col_mask, &new_col_mask) ){ |
|
316 goto update_cleanup; |
|
317 } |
|
318 iEndBeforeTrigger = sqlite3VdbeAddOp2(v, OP_Goto, 0, 0); |
|
319 iBeginAfterTrigger = sqlite3VdbeCurrentAddr(v); |
|
320 if( sqlite3CodeRowTrigger(pParse, TK_UPDATE, pChanges, TRIGGER_AFTER, pTab, |
|
321 newIdx, oldIdx, onError, addr, &old_col_mask, &new_col_mask) ){ |
|
322 goto update_cleanup; |
|
323 } |
|
324 iEndAfterTrigger = sqlite3VdbeAddOp2(v, OP_Goto, 0, 0); |
|
325 sqlite3VdbeJumpHere(v, iGoto); |
|
326 } |
|
327 |
|
328 /* If we are trying to update a view, realize that view into |
|
329 ** a ephemeral table. |
|
330 */ |
|
331 if( isView ){ |
|
332 sqlite3MaterializeView(pParse, pTab->pSelect, pWhere, iCur); |
|
333 } |
|
334 |
|
335 /* Resolve the column names in all the expressions in the |
|
336 ** WHERE clause. |
|
337 */ |
|
338 if( sqlite3ExprResolveNames(&sNC, pWhere) ){ |
|
339 goto update_cleanup; |
|
340 } |
|
341 |
|
342 /* Begin the database scan |
|
343 */ |
|
344 sqlite3VdbeAddOp2(v, OP_Null, 0, regOldRowid); |
|
345 pWInfo = sqlite3WhereBegin(pParse, pTabList, pWhere, 0, |
|
346 WHERE_ONEPASS_DESIRED); |
|
347 if( pWInfo==0 ) goto update_cleanup; |
|
348 okOnePass = pWInfo->okOnePass; |
|
349 |
|
350 /* Remember the rowid of every item to be updated. |
|
351 */ |
|
352 sqlite3VdbeAddOp2(v, IsVirtual(pTab)?OP_VRowid:OP_Rowid, iCur, regOldRowid); |
|
353 if( !okOnePass ) sqlite3VdbeAddOp2(v, OP_FifoWrite, regOldRowid, 0); |
|
354 |
|
355 /* End the database scan loop. |
|
356 */ |
|
357 sqlite3WhereEnd(pWInfo); |
|
358 |
|
359 /* Initialize the count of updated rows |
|
360 */ |
|
361 if( db->flags & SQLITE_CountRows && !pParse->trigStack ){ |
|
362 regRowCount = ++pParse->nMem; |
|
363 sqlite3VdbeAddOp2(v, OP_Integer, 0, regRowCount); |
|
364 } |
|
365 |
|
366 if( !isView && !IsVirtual(pTab) ){ |
|
367 /* |
|
368 ** Open every index that needs updating. Note that if any |
|
369 ** index could potentially invoke a REPLACE conflict resolution |
|
370 ** action, then we need to open all indices because we might need |
|
371 ** to be deleting some records. |
|
372 */ |
|
373 if( !okOnePass ) sqlite3OpenTable(pParse, iCur, iDb, pTab, OP_OpenWrite); |
|
374 if( onError==OE_Replace ){ |
|
375 openAll = 1; |
|
376 }else{ |
|
377 openAll = 0; |
|
378 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){ |
|
379 if( pIdx->onError==OE_Replace ){ |
|
380 openAll = 1; |
|
381 break; |
|
382 } |
|
383 } |
|
384 } |
|
385 for(i=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, i++){ |
|
386 if( openAll || aRegIdx[i]>0 ){ |
|
387 KeyInfo *pKey = sqlite3IndexKeyinfo(pParse, pIdx); |
|
388 sqlite3VdbeAddOp4(v, OP_OpenWrite, iCur+i+1, pIdx->tnum, iDb, |
|
389 (char*)pKey, P4_KEYINFO_HANDOFF); |
|
390 assert( pParse->nTab>iCur+i+1 ); |
|
391 } |
|
392 } |
|
393 } |
|
394 |
|
395 /* Jump back to this point if a trigger encounters an IGNORE constraint. */ |
|
396 if( triggers_exist ){ |
|
397 sqlite3VdbeResolveLabel(v, addr); |
|
398 } |
|
399 |
|
400 /* Top of the update loop */ |
|
401 if( okOnePass ){ |
|
402 int a1 = sqlite3VdbeAddOp1(v, OP_NotNull, regOldRowid); |
|
403 addr = sqlite3VdbeAddOp0(v, OP_Goto); |
|
404 sqlite3VdbeJumpHere(v, a1); |
|
405 }else{ |
|
406 addr = sqlite3VdbeAddOp2(v, OP_FifoRead, regOldRowid, 0); |
|
407 } |
|
408 |
|
409 if( triggers_exist ){ |
|
410 int regRowid; |
|
411 int regRow; |
|
412 int regCols; |
|
413 |
|
414 /* Make cursor iCur point to the record that is being updated. |
|
415 */ |
|
416 sqlite3VdbeAddOp3(v, OP_NotExists, iCur, addr, regOldRowid); |
|
417 |
|
418 /* Generate the OLD table |
|
419 */ |
|
420 regRowid = sqlite3GetTempReg(pParse); |
|
421 regRow = sqlite3GetTempReg(pParse); |
|
422 sqlite3VdbeAddOp2(v, OP_Rowid, iCur, regRowid); |
|
423 if( !old_col_mask ){ |
|
424 sqlite3VdbeAddOp2(v, OP_Null, 0, regRow); |
|
425 }else{ |
|
426 sqlite3VdbeAddOp2(v, OP_RowData, iCur, regRow); |
|
427 } |
|
428 sqlite3VdbeAddOp3(v, OP_Insert, oldIdx, regRow, regRowid); |
|
429 |
|
430 /* Generate the NEW table |
|
431 */ |
|
432 if( chngRowid ){ |
|
433 sqlite3ExprCodeAndCache(pParse, pRowidExpr, regRowid); |
|
434 }else{ |
|
435 sqlite3VdbeAddOp2(v, OP_Rowid, iCur, regRowid); |
|
436 } |
|
437 regCols = sqlite3GetTempRange(pParse, pTab->nCol); |
|
438 for(i=0; i<pTab->nCol; i++){ |
|
439 if( i==pTab->iPKey ){ |
|
440 sqlite3VdbeAddOp2(v, OP_Null, 0, regCols+i); |
|
441 continue; |
|
442 } |
|
443 j = aXRef[i]; |
|
444 if( new_col_mask&((u32)1<<i) || new_col_mask==0xffffffff ){ |
|
445 if( j<0 ){ |
|
446 sqlite3VdbeAddOp3(v, OP_Column, iCur, i, regCols+i); |
|
447 sqlite3ColumnDefault(v, pTab, i); |
|
448 }else{ |
|
449 sqlite3ExprCodeAndCache(pParse, pChanges->a[j].pExpr, regCols+i); |
|
450 } |
|
451 }else{ |
|
452 sqlite3VdbeAddOp2(v, OP_Null, 0, regCols+i); |
|
453 } |
|
454 } |
|
455 sqlite3VdbeAddOp3(v, OP_MakeRecord, regCols, pTab->nCol, regRow); |
|
456 if( !isView ){ |
|
457 sqlite3TableAffinityStr(v, pTab); |
|
458 sqlite3ExprCacheAffinityChange(pParse, regCols, pTab->nCol); |
|
459 } |
|
460 sqlite3ReleaseTempRange(pParse, regCols, pTab->nCol); |
|
461 /* if( pParse->nErr ) goto update_cleanup; */ |
|
462 sqlite3VdbeAddOp3(v, OP_Insert, newIdx, regRow, regRowid); |
|
463 sqlite3ReleaseTempReg(pParse, regRowid); |
|
464 sqlite3ReleaseTempReg(pParse, regRow); |
|
465 |
|
466 sqlite3VdbeAddOp2(v, OP_Goto, 0, iBeginBeforeTrigger); |
|
467 sqlite3VdbeJumpHere(v, iEndBeforeTrigger); |
|
468 } |
|
469 |
|
470 if( !isView && !IsVirtual(pTab) ){ |
|
471 /* Loop over every record that needs updating. We have to load |
|
472 ** the old data for each record to be updated because some columns |
|
473 ** might not change and we will need to copy the old value. |
|
474 ** Also, the old data is needed to delete the old index entries. |
|
475 ** So make the cursor point at the old record. |
|
476 */ |
|
477 sqlite3VdbeAddOp3(v, OP_NotExists, iCur, addr, regOldRowid); |
|
478 |
|
479 /* If the record number will change, push the record number as it |
|
480 ** will be after the update. (The old record number is currently |
|
481 ** on top of the stack.) |
|
482 */ |
|
483 if( chngRowid ){ |
|
484 sqlite3ExprCode(pParse, pRowidExpr, regNewRowid); |
|
485 sqlite3VdbeAddOp1(v, OP_MustBeInt, regNewRowid); |
|
486 } |
|
487 |
|
488 /* Compute new data for this record. |
|
489 */ |
|
490 for(i=0; i<pTab->nCol; i++){ |
|
491 if( i==pTab->iPKey ){ |
|
492 sqlite3VdbeAddOp2(v, OP_Null, 0, regData+i); |
|
493 continue; |
|
494 } |
|
495 j = aXRef[i]; |
|
496 if( j<0 ){ |
|
497 sqlite3VdbeAddOp3(v, OP_Column, iCur, i, regData+i); |
|
498 sqlite3ColumnDefault(v, pTab, i); |
|
499 }else{ |
|
500 sqlite3ExprCode(pParse, pChanges->a[j].pExpr, regData+i); |
|
501 } |
|
502 } |
|
503 |
|
504 /* Do constraint checks |
|
505 */ |
|
506 sqlite3GenerateConstraintChecks(pParse, pTab, iCur, regNewRowid, |
|
507 aRegIdx, chngRowid, 1, |
|
508 onError, addr); |
|
509 |
|
510 /* Delete the old indices for the current record. |
|
511 */ |
|
512 j1 = sqlite3VdbeAddOp3(v, OP_NotExists, iCur, 0, regOldRowid); |
|
513 sqlite3GenerateRowIndexDelete(pParse, pTab, iCur, aRegIdx); |
|
514 |
|
515 /* If changing the record number, delete the old record. |
|
516 */ |
|
517 if( chngRowid ){ |
|
518 sqlite3VdbeAddOp2(v, OP_Delete, iCur, 0); |
|
519 } |
|
520 sqlite3VdbeJumpHere(v, j1); |
|
521 |
|
522 /* Create the new index entries and the new record. |
|
523 */ |
|
524 sqlite3CompleteInsertion(pParse, pTab, iCur, regNewRowid, |
|
525 aRegIdx, chngRowid, 1, -1, 0); |
|
526 } |
|
527 |
|
528 /* Increment the row counter |
|
529 */ |
|
530 if( db->flags & SQLITE_CountRows && !pParse->trigStack){ |
|
531 sqlite3VdbeAddOp2(v, OP_AddImm, regRowCount, 1); |
|
532 } |
|
533 |
|
534 /* If there are triggers, close all the cursors after each iteration |
|
535 ** through the loop. The fire the after triggers. |
|
536 */ |
|
537 if( triggers_exist ){ |
|
538 sqlite3VdbeAddOp2(v, OP_Goto, 0, iBeginAfterTrigger); |
|
539 sqlite3VdbeJumpHere(v, iEndAfterTrigger); |
|
540 } |
|
541 |
|
542 /* Repeat the above with the next record to be updated, until |
|
543 ** all record selected by the WHERE clause have been updated. |
|
544 */ |
|
545 sqlite3VdbeAddOp2(v, OP_Goto, 0, addr); |
|
546 sqlite3VdbeJumpHere(v, addr); |
|
547 |
|
548 /* Close all tables */ |
|
549 for(i=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, i++){ |
|
550 if( openAll || aRegIdx[i]>0 ){ |
|
551 sqlite3VdbeAddOp2(v, OP_Close, iCur+i+1, 0); |
|
552 } |
|
553 } |
|
554 sqlite3VdbeAddOp2(v, OP_Close, iCur, 0); |
|
555 if( triggers_exist ){ |
|
556 sqlite3VdbeAddOp2(v, OP_Close, newIdx, 0); |
|
557 sqlite3VdbeAddOp2(v, OP_Close, oldIdx, 0); |
|
558 } |
|
559 |
|
560 /* |
|
561 ** Return the number of rows that were changed. If this routine is |
|
562 ** generating code because of a call to sqlite3NestedParse(), do not |
|
563 ** invoke the callback function. |
|
564 */ |
|
565 if( db->flags & SQLITE_CountRows && !pParse->trigStack && pParse->nested==0 ){ |
|
566 sqlite3VdbeAddOp2(v, OP_ResultRow, regRowCount, 1); |
|
567 sqlite3VdbeSetNumCols(v, 1); |
|
568 sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "rows updated", P4_STATIC); |
|
569 } |
|
570 |
|
571 update_cleanup: |
|
572 sqlite3AuthContextPop(&sContext); |
|
573 sqlite3DbFree(db, aRegIdx); |
|
574 sqlite3DbFree(db, aXRef); |
|
575 sqlite3SrcListDelete(db, pTabList); |
|
576 sqlite3ExprListDelete(db, pChanges); |
|
577 sqlite3ExprDelete(db, pWhere); |
|
578 return; |
|
579 } |
|
580 |
|
581 #ifndef SQLITE_OMIT_VIRTUALTABLE |
|
582 /* |
|
583 ** Generate code for an UPDATE of a virtual table. |
|
584 ** |
|
585 ** The strategy is that we create an ephemerial table that contains |
|
586 ** for each row to be changed: |
|
587 ** |
|
588 ** (A) The original rowid of that row. |
|
589 ** (B) The revised rowid for the row. (note1) |
|
590 ** (C) The content of every column in the row. |
|
591 ** |
|
592 ** Then we loop over this ephemeral table and for each row in |
|
593 ** the ephermeral table call VUpdate. |
|
594 ** |
|
595 ** When finished, drop the ephemeral table. |
|
596 ** |
|
597 ** (note1) Actually, if we know in advance that (A) is always the same |
|
598 ** as (B) we only store (A), then duplicate (A) when pulling |
|
599 ** it out of the ephemeral table before calling VUpdate. |
|
600 */ |
|
601 static void updateVirtualTable( |
|
602 Parse *pParse, /* The parsing context */ |
|
603 SrcList *pSrc, /* The virtual table to be modified */ |
|
604 Table *pTab, /* The virtual table */ |
|
605 ExprList *pChanges, /* The columns to change in the UPDATE statement */ |
|
606 Expr *pRowid, /* Expression used to recompute the rowid */ |
|
607 int *aXRef, /* Mapping from columns of pTab to entries in pChanges */ |
|
608 Expr *pWhere /* WHERE clause of the UPDATE statement */ |
|
609 ){ |
|
610 Vdbe *v = pParse->pVdbe; /* Virtual machine under construction */ |
|
611 ExprList *pEList = 0; /* The result set of the SELECT statement */ |
|
612 Select *pSelect = 0; /* The SELECT statement */ |
|
613 Expr *pExpr; /* Temporary expression */ |
|
614 int ephemTab; /* Table holding the result of the SELECT */ |
|
615 int i; /* Loop counter */ |
|
616 int addr; /* Address of top of loop */ |
|
617 int iReg; /* First register in set passed to OP_VUpdate */ |
|
618 sqlite3 *db = pParse->db; /* Database connection */ |
|
619 const char *pVtab = (const char*)pTab->pVtab; |
|
620 SelectDest dest; |
|
621 |
|
622 /* Construct the SELECT statement that will find the new values for |
|
623 ** all updated rows. |
|
624 */ |
|
625 pEList = sqlite3ExprListAppend(pParse, 0, |
|
626 sqlite3CreateIdExpr(pParse, "_rowid_"), 0); |
|
627 if( pRowid ){ |
|
628 pEList = sqlite3ExprListAppend(pParse, pEList, |
|
629 sqlite3ExprDup(db, pRowid), 0); |
|
630 } |
|
631 assert( pTab->iPKey<0 ); |
|
632 for(i=0; i<pTab->nCol; i++){ |
|
633 if( aXRef[i]>=0 ){ |
|
634 pExpr = sqlite3ExprDup(db, pChanges->a[aXRef[i]].pExpr); |
|
635 }else{ |
|
636 pExpr = sqlite3CreateIdExpr(pParse, pTab->aCol[i].zName); |
|
637 } |
|
638 pEList = sqlite3ExprListAppend(pParse, pEList, pExpr, 0); |
|
639 } |
|
640 pSelect = sqlite3SelectNew(pParse, pEList, pSrc, pWhere, 0, 0, 0, 0, 0, 0); |
|
641 |
|
642 /* Create the ephemeral table into which the update results will |
|
643 ** be stored. |
|
644 */ |
|
645 assert( v ); |
|
646 ephemTab = pParse->nTab++; |
|
647 sqlite3VdbeAddOp2(v, OP_OpenEphemeral, ephemTab, pTab->nCol+1+(pRowid!=0)); |
|
648 |
|
649 /* fill the ephemeral table |
|
650 */ |
|
651 sqlite3SelectDestInit(&dest, SRT_Table, ephemTab); |
|
652 sqlite3Select(pParse, pSelect, &dest, 0, 0, 0); |
|
653 |
|
654 /* Generate code to scan the ephemeral table and call VUpdate. */ |
|
655 iReg = ++pParse->nMem; |
|
656 pParse->nMem += pTab->nCol+1; |
|
657 sqlite3VdbeAddOp2(v, OP_Rewind, ephemTab, 0); |
|
658 addr = sqlite3VdbeCurrentAddr(v); |
|
659 sqlite3VdbeAddOp3(v, OP_Column, ephemTab, 0, iReg); |
|
660 sqlite3VdbeAddOp3(v, OP_Column, ephemTab, (pRowid?1:0), iReg+1); |
|
661 for(i=0; i<pTab->nCol; i++){ |
|
662 sqlite3VdbeAddOp3(v, OP_Column, ephemTab, i+1+(pRowid!=0), iReg+2+i); |
|
663 } |
|
664 sqlite3VtabMakeWritable(pParse, pTab); |
|
665 sqlite3VdbeAddOp4(v, OP_VUpdate, 0, pTab->nCol+2, iReg, pVtab, P4_VTAB); |
|
666 sqlite3VdbeAddOp2(v, OP_Next, ephemTab, addr); |
|
667 sqlite3VdbeJumpHere(v, addr-1); |
|
668 sqlite3VdbeAddOp2(v, OP_Close, ephemTab, 0); |
|
669 |
|
670 /* Cleanup */ |
|
671 sqlite3SelectDelete(db, pSelect); |
|
672 } |
|
673 #endif /* SQLITE_OMIT_VIRTUALTABLE */ |
|
674 |
|
675 /* Make sure "isView" gets undefined in case this file becomes part of |
|
676 ** the amalgamation - so that subsequent files do not see isView as a |
|
677 ** macro. */ |
|
678 #undef isView |