|
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.133 2006/06/27 13:20:21 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 P3 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 P3 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 P3 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 P3 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 sqlite3ValueFromExpr(pCol->pDflt, enc, pCol->affinity, &pValue); |
|
63 if( pValue ){ |
|
64 sqlite3VdbeChangeP3(v, -1, (const char *)pValue, P3_MEM); |
|
65 }else{ |
|
66 VdbeComment((v, "# %s.%s", pTab->zName, pCol->zName)); |
|
67 } |
|
68 } |
|
69 } |
|
70 |
|
71 /* |
|
72 ** Process an UPDATE statement. |
|
73 ** |
|
74 ** UPDATE OR IGNORE table_wxyz SET a=b, c=d WHERE e<5 AND f NOT NULL; |
|
75 ** \_______/ \________/ \______/ \________________/ |
|
76 * onError pTabList pChanges pWhere |
|
77 */ |
|
78 void sqlite3Update( |
|
79 Parse *pParse, /* The parser context */ |
|
80 SrcList *pTabList, /* The table in which we should change things */ |
|
81 ExprList *pChanges, /* Things to be changed */ |
|
82 Expr *pWhere, /* The WHERE clause. May be null */ |
|
83 int onError /* How to handle constraint errors */ |
|
84 ){ |
|
85 int i, j; /* Loop counters */ |
|
86 Table *pTab; /* The table to be updated */ |
|
87 int addr = 0; /* VDBE instruction address of the start of the loop */ |
|
88 WhereInfo *pWInfo; /* Information about the WHERE clause */ |
|
89 Vdbe *v; /* The virtual database engine */ |
|
90 Index *pIdx; /* For looping over indices */ |
|
91 int nIdx; /* Number of indices that need updating */ |
|
92 int nIdxTotal; /* Total number of indices */ |
|
93 int iCur; /* VDBE Cursor number of pTab */ |
|
94 sqlite3 *db; /* The database structure */ |
|
95 Index **apIdx = 0; /* An array of indices that need updating too */ |
|
96 char *aIdxUsed = 0; /* aIdxUsed[i]==1 if the i-th index is used */ |
|
97 int *aXRef = 0; /* aXRef[i] is the index in pChanges->a[] of the |
|
98 ** an expression for the i-th column of the table. |
|
99 ** aXRef[i]==-1 if the i-th column is not changed. */ |
|
100 int chngRowid; /* True if the record number is being changed */ |
|
101 Expr *pRowidExpr = 0; /* Expression defining the new record number */ |
|
102 int openAll = 0; /* True if all indices need to be opened */ |
|
103 AuthContext sContext; /* The authorization context */ |
|
104 NameContext sNC; /* The name-context to resolve expressions in */ |
|
105 int iDb; /* Database containing the table being updated */ |
|
106 |
|
107 #ifndef SQLITE_OMIT_TRIGGER |
|
108 int isView; /* Trying to update a view */ |
|
109 int triggers_exist = 0; /* True if any row triggers exist */ |
|
110 #endif |
|
111 |
|
112 int newIdx = -1; /* index of trigger "new" temp table */ |
|
113 int oldIdx = -1; /* index of trigger "old" temp table */ |
|
114 |
|
115 sContext.pParse = 0; |
|
116 if( pParse->nErr || sqlite3MallocFailed() ){ |
|
117 goto update_cleanup; |
|
118 } |
|
119 db = pParse->db; |
|
120 assert( pTabList->nSrc==1 ); |
|
121 |
|
122 /* Locate the table which we want to update. |
|
123 */ |
|
124 pTab = sqlite3SrcListLookup(pParse, pTabList); |
|
125 if( pTab==0 ) goto update_cleanup; |
|
126 iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema); |
|
127 |
|
128 /* Figure out if we have any triggers and if the table being |
|
129 ** updated is a view |
|
130 */ |
|
131 #ifndef SQLITE_OMIT_TRIGGER |
|
132 triggers_exist = sqlite3TriggersExist(pParse, pTab, TK_UPDATE, pChanges); |
|
133 isView = pTab->pSelect!=0; |
|
134 #else |
|
135 # define triggers_exist 0 |
|
136 # define isView 0 |
|
137 #endif |
|
138 #ifdef SQLITE_OMIT_VIEW |
|
139 # undef isView |
|
140 # define isView 0 |
|
141 #endif |
|
142 |
|
143 if( sqlite3IsReadOnly(pParse, pTab, triggers_exist) ){ |
|
144 goto update_cleanup; |
|
145 } |
|
146 if( sqlite3ViewGetColumnNames(pParse, pTab) ){ |
|
147 goto update_cleanup; |
|
148 } |
|
149 aXRef = sqliteMallocRaw( sizeof(int) * pTab->nCol ); |
|
150 if( aXRef==0 ) goto update_cleanup; |
|
151 for(i=0; i<pTab->nCol; i++) aXRef[i] = -1; |
|
152 |
|
153 /* If there are FOR EACH ROW triggers, allocate cursors for the |
|
154 ** special OLD and NEW tables |
|
155 */ |
|
156 if( triggers_exist ){ |
|
157 newIdx = pParse->nTab++; |
|
158 oldIdx = pParse->nTab++; |
|
159 } |
|
160 |
|
161 /* Allocate a cursors for the main database table and for all indices. |
|
162 ** The index cursors might not be used, but if they are used they |
|
163 ** need to occur right after the database cursor. So go ahead and |
|
164 ** allocate enough space, just in case. |
|
165 */ |
|
166 pTabList->a[0].iCursor = iCur = pParse->nTab++; |
|
167 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){ |
|
168 pParse->nTab++; |
|
169 } |
|
170 |
|
171 /* Initialize the name-context */ |
|
172 memset(&sNC, 0, sizeof(sNC)); |
|
173 sNC.pParse = pParse; |
|
174 sNC.pSrcList = pTabList; |
|
175 |
|
176 /* Resolve the column names in all the expressions of the |
|
177 ** of the UPDATE statement. Also find the column index |
|
178 ** for each column to be updated in the pChanges array. For each |
|
179 ** column to be updated, make sure we have authorization to change |
|
180 ** that column. |
|
181 */ |
|
182 chngRowid = 0; |
|
183 for(i=0; i<pChanges->nExpr; i++){ |
|
184 if( sqlite3ExprResolveNames(&sNC, pChanges->a[i].pExpr) ){ |
|
185 goto update_cleanup; |
|
186 } |
|
187 for(j=0; j<pTab->nCol; j++){ |
|
188 if( sqlite3StrICmp(pTab->aCol[j].zName, pChanges->a[i].zName)==0 ){ |
|
189 if( j==pTab->iPKey ){ |
|
190 chngRowid = 1; |
|
191 pRowidExpr = pChanges->a[i].pExpr; |
|
192 } |
|
193 aXRef[j] = i; |
|
194 break; |
|
195 } |
|
196 } |
|
197 if( j>=pTab->nCol ){ |
|
198 if( sqlite3IsRowid(pChanges->a[i].zName) ){ |
|
199 chngRowid = 1; |
|
200 pRowidExpr = pChanges->a[i].pExpr; |
|
201 }else{ |
|
202 sqlite3ErrorMsg(pParse, "no such column: %s", pChanges->a[i].zName); |
|
203 goto update_cleanup; |
|
204 } |
|
205 } |
|
206 #ifndef SQLITE_OMIT_AUTHORIZATION |
|
207 { |
|
208 int rc; |
|
209 rc = sqlite3AuthCheck(pParse, SQLITE_UPDATE, pTab->zName, |
|
210 pTab->aCol[j].zName, db->aDb[iDb].zName); |
|
211 if( rc==SQLITE_DENY ){ |
|
212 goto update_cleanup; |
|
213 }else if( rc==SQLITE_IGNORE ){ |
|
214 aXRef[j] = -1; |
|
215 } |
|
216 } |
|
217 #endif |
|
218 } |
|
219 |
|
220 /* Allocate memory for the array apIdx[] and fill it with pointers to every |
|
221 ** index that needs to be updated. Indices only need updating if their |
|
222 ** key includes one of the columns named in pChanges or if the record |
|
223 ** number of the original table entry is changing. |
|
224 */ |
|
225 for(nIdx=nIdxTotal=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, nIdxTotal++){ |
|
226 if( chngRowid ){ |
|
227 i = 0; |
|
228 }else { |
|
229 for(i=0; i<pIdx->nColumn; i++){ |
|
230 if( aXRef[pIdx->aiColumn[i]]>=0 ) break; |
|
231 } |
|
232 } |
|
233 if( i<pIdx->nColumn ) nIdx++; |
|
234 } |
|
235 if( nIdxTotal>0 ){ |
|
236 apIdx = sqliteMallocRaw( sizeof(Index*) * nIdx + nIdxTotal ); |
|
237 if( apIdx==0 ) goto update_cleanup; |
|
238 aIdxUsed = (char*)&apIdx[nIdx]; |
|
239 } |
|
240 for(nIdx=j=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, j++){ |
|
241 if( chngRowid ){ |
|
242 i = 0; |
|
243 }else{ |
|
244 for(i=0; i<pIdx->nColumn; i++){ |
|
245 if( aXRef[pIdx->aiColumn[i]]>=0 ) break; |
|
246 } |
|
247 } |
|
248 if( i<pIdx->nColumn ){ |
|
249 apIdx[nIdx++] = pIdx; |
|
250 aIdxUsed[j] = 1; |
|
251 }else{ |
|
252 aIdxUsed[j] = 0; |
|
253 } |
|
254 } |
|
255 |
|
256 /* Begin generating code. |
|
257 */ |
|
258 v = sqlite3GetVdbe(pParse); |
|
259 if( v==0 ) goto update_cleanup; |
|
260 if( pParse->nested==0 ) sqlite3VdbeCountChanges(v); |
|
261 sqlite3BeginWriteOperation(pParse, 1, iDb); |
|
262 |
|
263 #ifndef SQLITE_OMIT_VIRTUALTABLE |
|
264 /* Virtual tables must be handled separately */ |
|
265 if( IsVirtual(pTab) ){ |
|
266 updateVirtualTable(pParse, pTabList, pTab, pChanges, pRowidExpr, aXRef, |
|
267 pWhere); |
|
268 pWhere = 0; |
|
269 pTabList = 0; |
|
270 goto update_cleanup; |
|
271 } |
|
272 #endif |
|
273 |
|
274 /* Resolve the column names in all the expressions in the |
|
275 ** WHERE clause. |
|
276 */ |
|
277 if( sqlite3ExprResolveNames(&sNC, pWhere) ){ |
|
278 goto update_cleanup; |
|
279 } |
|
280 |
|
281 /* Start the view context |
|
282 */ |
|
283 if( isView ){ |
|
284 sqlite3AuthContextPush(pParse, &sContext, pTab->zName); |
|
285 } |
|
286 |
|
287 /* If we are trying to update a view, realize that view into |
|
288 ** a ephemeral table. |
|
289 */ |
|
290 if( isView ){ |
|
291 Select *pView; |
|
292 pView = sqlite3SelectDup(pTab->pSelect); |
|
293 sqlite3Select(pParse, pView, SRT_EphemTab, iCur, 0, 0, 0, 0); |
|
294 sqlite3SelectDelete(pView); |
|
295 } |
|
296 |
|
297 /* Begin the database scan |
|
298 */ |
|
299 pWInfo = sqlite3WhereBegin(pParse, pTabList, pWhere, 0); |
|
300 if( pWInfo==0 ) goto update_cleanup; |
|
301 |
|
302 /* Remember the rowid of every item to be updated. |
|
303 */ |
|
304 sqlite3VdbeAddOp(v, IsVirtual(pTab) ? OP_VRowid : OP_Rowid, iCur, 0); |
|
305 sqlite3VdbeAddOp(v, OP_FifoWrite, 0, 0); |
|
306 |
|
307 /* End the database scan loop. |
|
308 */ |
|
309 sqlite3WhereEnd(pWInfo); |
|
310 |
|
311 /* Initialize the count of updated rows |
|
312 */ |
|
313 if( db->flags & SQLITE_CountRows && !pParse->trigStack ){ |
|
314 sqlite3VdbeAddOp(v, OP_Integer, 0, 0); |
|
315 } |
|
316 |
|
317 if( triggers_exist ){ |
|
318 /* Create pseudo-tables for NEW and OLD |
|
319 */ |
|
320 sqlite3VdbeAddOp(v, OP_OpenPseudo, oldIdx, 0); |
|
321 sqlite3VdbeAddOp(v, OP_SetNumColumns, oldIdx, pTab->nCol); |
|
322 sqlite3VdbeAddOp(v, OP_OpenPseudo, newIdx, 0); |
|
323 sqlite3VdbeAddOp(v, OP_SetNumColumns, newIdx, pTab->nCol); |
|
324 |
|
325 /* The top of the update loop for when there are triggers. |
|
326 */ |
|
327 addr = sqlite3VdbeAddOp(v, OP_FifoRead, 0, 0); |
|
328 |
|
329 if( !isView ){ |
|
330 sqlite3VdbeAddOp(v, OP_Dup, 0, 0); |
|
331 sqlite3VdbeAddOp(v, OP_Dup, 0, 0); |
|
332 /* Open a cursor and make it point to the record that is |
|
333 ** being updated. |
|
334 */ |
|
335 sqlite3OpenTable(pParse, iCur, iDb, pTab, OP_OpenRead); |
|
336 } |
|
337 sqlite3VdbeAddOp(v, OP_MoveGe, iCur, 0); |
|
338 |
|
339 /* Generate the OLD table |
|
340 */ |
|
341 sqlite3VdbeAddOp(v, OP_Rowid, iCur, 0); |
|
342 sqlite3VdbeAddOp(v, OP_RowData, iCur, 0); |
|
343 sqlite3VdbeAddOp(v, OP_Insert, oldIdx, 0); |
|
344 |
|
345 /* Generate the NEW table |
|
346 */ |
|
347 if( chngRowid ){ |
|
348 sqlite3ExprCodeAndCache(pParse, pRowidExpr); |
|
349 }else{ |
|
350 sqlite3VdbeAddOp(v, OP_Rowid, iCur, 0); |
|
351 } |
|
352 for(i=0; i<pTab->nCol; i++){ |
|
353 if( i==pTab->iPKey ){ |
|
354 sqlite3VdbeAddOp(v, OP_Null, 0, 0); |
|
355 continue; |
|
356 } |
|
357 j = aXRef[i]; |
|
358 if( j<0 ){ |
|
359 sqlite3VdbeAddOp(v, OP_Column, iCur, i); |
|
360 sqlite3ColumnDefault(v, pTab, i); |
|
361 }else{ |
|
362 sqlite3ExprCodeAndCache(pParse, pChanges->a[j].pExpr); |
|
363 } |
|
364 } |
|
365 sqlite3VdbeAddOp(v, OP_MakeRecord, pTab->nCol, 0); |
|
366 if( !isView ){ |
|
367 sqlite3TableAffinityStr(v, pTab); |
|
368 } |
|
369 if( pParse->nErr ) goto update_cleanup; |
|
370 sqlite3VdbeAddOp(v, OP_Insert, newIdx, 0); |
|
371 if( !isView ){ |
|
372 sqlite3VdbeAddOp(v, OP_Close, iCur, 0); |
|
373 } |
|
374 |
|
375 /* Fire the BEFORE and INSTEAD OF triggers |
|
376 */ |
|
377 if( sqlite3CodeRowTrigger(pParse, TK_UPDATE, pChanges, TRIGGER_BEFORE, pTab, |
|
378 newIdx, oldIdx, onError, addr) ){ |
|
379 goto update_cleanup; |
|
380 } |
|
381 } |
|
382 |
|
383 if( !isView && !IsVirtual(pTab) ){ |
|
384 /* |
|
385 ** Open every index that needs updating. Note that if any |
|
386 ** index could potentially invoke a REPLACE conflict resolution |
|
387 ** action, then we need to open all indices because we might need |
|
388 ** to be deleting some records. |
|
389 */ |
|
390 sqlite3OpenTable(pParse, iCur, iDb, pTab, OP_OpenWrite); |
|
391 if( onError==OE_Replace ){ |
|
392 openAll = 1; |
|
393 }else{ |
|
394 openAll = 0; |
|
395 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){ |
|
396 if( pIdx->onError==OE_Replace ){ |
|
397 openAll = 1; |
|
398 break; |
|
399 } |
|
400 } |
|
401 } |
|
402 for(i=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, i++){ |
|
403 if( openAll || aIdxUsed[i] ){ |
|
404 KeyInfo *pKey = sqlite3IndexKeyinfo(pParse, pIdx); |
|
405 sqlite3VdbeAddOp(v, OP_Integer, iDb, 0); |
|
406 sqlite3VdbeOp3(v, OP_OpenWrite, iCur+i+1, pIdx->tnum, |
|
407 (char*)pKey, P3_KEYINFO_HANDOFF); |
|
408 assert( pParse->nTab>iCur+i+1 ); |
|
409 } |
|
410 } |
|
411 |
|
412 /* Loop over every record that needs updating. We have to load |
|
413 ** the old data for each record to be updated because some columns |
|
414 ** might not change and we will need to copy the old value. |
|
415 ** Also, the old data is needed to delete the old index entries. |
|
416 ** So make the cursor point at the old record. |
|
417 */ |
|
418 if( !triggers_exist ){ |
|
419 addr = sqlite3VdbeAddOp(v, OP_FifoRead, 0, 0); |
|
420 sqlite3VdbeAddOp(v, OP_Dup, 0, 0); |
|
421 } |
|
422 sqlite3VdbeAddOp(v, OP_NotExists, iCur, addr); |
|
423 |
|
424 /* If the record number will change, push the record number as it |
|
425 ** will be after the update. (The old record number is currently |
|
426 ** on top of the stack.) |
|
427 */ |
|
428 if( chngRowid ){ |
|
429 sqlite3ExprCode(pParse, pRowidExpr); |
|
430 sqlite3VdbeAddOp(v, OP_MustBeInt, 0, 0); |
|
431 } |
|
432 |
|
433 /* Compute new data for this record. |
|
434 */ |
|
435 for(i=0; i<pTab->nCol; i++){ |
|
436 if( i==pTab->iPKey ){ |
|
437 sqlite3VdbeAddOp(v, OP_Null, 0, 0); |
|
438 continue; |
|
439 } |
|
440 j = aXRef[i]; |
|
441 if( j<0 ){ |
|
442 sqlite3VdbeAddOp(v, OP_Column, iCur, i); |
|
443 sqlite3ColumnDefault(v, pTab, i); |
|
444 }else{ |
|
445 sqlite3ExprCode(pParse, pChanges->a[j].pExpr); |
|
446 } |
|
447 } |
|
448 |
|
449 /* Do constraint checks |
|
450 */ |
|
451 sqlite3GenerateConstraintChecks(pParse, pTab, iCur, aIdxUsed, chngRowid, 1, |
|
452 onError, addr); |
|
453 |
|
454 /* Delete the old indices for the current record. |
|
455 */ |
|
456 sqlite3GenerateRowIndexDelete(v, pTab, iCur, aIdxUsed); |
|
457 |
|
458 /* If changing the record number, delete the old record. |
|
459 */ |
|
460 if( chngRowid ){ |
|
461 sqlite3VdbeAddOp(v, OP_Delete, iCur, 0); |
|
462 } |
|
463 |
|
464 /* Create the new index entries and the new record. |
|
465 */ |
|
466 sqlite3CompleteInsertion(pParse, pTab, iCur, aIdxUsed, chngRowid, 1, -1); |
|
467 } |
|
468 |
|
469 /* Increment the row counter |
|
470 */ |
|
471 if( db->flags & SQLITE_CountRows && !pParse->trigStack){ |
|
472 sqlite3VdbeAddOp(v, OP_AddImm, 1, 0); |
|
473 } |
|
474 |
|
475 /* If there are triggers, close all the cursors after each iteration |
|
476 ** through the loop. The fire the after triggers. |
|
477 */ |
|
478 if( triggers_exist ){ |
|
479 if( !isView ){ |
|
480 for(i=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, i++){ |
|
481 if( openAll || aIdxUsed[i] ) |
|
482 sqlite3VdbeAddOp(v, OP_Close, iCur+i+1, 0); |
|
483 } |
|
484 sqlite3VdbeAddOp(v, OP_Close, iCur, 0); |
|
485 } |
|
486 if( sqlite3CodeRowTrigger(pParse, TK_UPDATE, pChanges, TRIGGER_AFTER, pTab, |
|
487 newIdx, oldIdx, onError, addr) ){ |
|
488 goto update_cleanup; |
|
489 } |
|
490 } |
|
491 |
|
492 /* Repeat the above with the next record to be updated, until |
|
493 ** all record selected by the WHERE clause have been updated. |
|
494 */ |
|
495 sqlite3VdbeAddOp(v, OP_Goto, 0, addr); |
|
496 sqlite3VdbeJumpHere(v, addr); |
|
497 |
|
498 /* Close all tables if there were no FOR EACH ROW triggers */ |
|
499 if( !triggers_exist ){ |
|
500 for(i=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, i++){ |
|
501 if( openAll || aIdxUsed[i] ){ |
|
502 sqlite3VdbeAddOp(v, OP_Close, iCur+i+1, 0); |
|
503 } |
|
504 } |
|
505 sqlite3VdbeAddOp(v, OP_Close, iCur, 0); |
|
506 }else{ |
|
507 sqlite3VdbeAddOp(v, OP_Close, newIdx, 0); |
|
508 sqlite3VdbeAddOp(v, OP_Close, oldIdx, 0); |
|
509 } |
|
510 |
|
511 /* |
|
512 ** Return the number of rows that were changed. If this routine is |
|
513 ** generating code because of a call to sqlite3NestedParse(), do not |
|
514 ** invoke the callback function. |
|
515 */ |
|
516 if( db->flags & SQLITE_CountRows && !pParse->trigStack && pParse->nested==0 ){ |
|
517 sqlite3VdbeAddOp(v, OP_Callback, 1, 0); |
|
518 sqlite3VdbeSetNumCols(v, 1); |
|
519 sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "rows updated", P3_STATIC); |
|
520 } |
|
521 |
|
522 update_cleanup: |
|
523 sqlite3AuthContextPop(&sContext); |
|
524 sqliteFree(apIdx); |
|
525 sqliteFree(aXRef); |
|
526 sqlite3SrcListDelete(pTabList); |
|
527 sqlite3ExprListDelete(pChanges); |
|
528 sqlite3ExprDelete(pWhere); |
|
529 return; |
|
530 } |
|
531 |
|
532 #ifndef SQLITE_OMIT_VIRTUALTABLE |
|
533 /* |
|
534 ** Generate code for an UPDATE of a virtual table. |
|
535 ** |
|
536 ** The strategy is that we create an ephemerial table that contains |
|
537 ** for each row to be changed: |
|
538 ** |
|
539 ** (A) The original rowid of that row. |
|
540 ** (B) The revised rowid for the row. (note1) |
|
541 ** (C) The content of every column in the row. |
|
542 ** |
|
543 ** Then we loop over this ephemeral table and for each row in |
|
544 ** the ephermeral table call VUpdate. |
|
545 ** |
|
546 ** When finished, drop the ephemeral table. |
|
547 ** |
|
548 ** (note1) Actually, if we know in advance that (A) is always the same |
|
549 ** as (B) we only store (A), then duplicate (A) when pulling |
|
550 ** it out of the ephemeral table before calling VUpdate. |
|
551 */ |
|
552 static void updateVirtualTable( |
|
553 Parse *pParse, /* The parsing context */ |
|
554 SrcList *pSrc, /* The virtual table to be modified */ |
|
555 Table *pTab, /* The virtual table */ |
|
556 ExprList *pChanges, /* The columns to change in the UPDATE statement */ |
|
557 Expr *pRowid, /* Expression used to recompute the rowid */ |
|
558 int *aXRef, /* Mapping from columns of pTab to entries in pChanges */ |
|
559 Expr *pWhere /* WHERE clause of the UPDATE statement */ |
|
560 ){ |
|
561 Vdbe *v = pParse->pVdbe; /* Virtual machine under construction */ |
|
562 ExprList *pEList = 0; /* The result set of the SELECT statement */ |
|
563 Select *pSelect = 0; /* The SELECT statement */ |
|
564 Expr *pExpr; /* Temporary expression */ |
|
565 int ephemTab; /* Table holding the result of the SELECT */ |
|
566 int i; /* Loop counter */ |
|
567 int addr; /* Address of top of loop */ |
|
568 |
|
569 /* Construct the SELECT statement that will find the new values for |
|
570 ** all updated rows. |
|
571 */ |
|
572 pEList = sqlite3ExprListAppend(0, sqlite3CreateIdExpr("_rowid_"), 0); |
|
573 if( pRowid ){ |
|
574 pEList = sqlite3ExprListAppend(pEList, sqlite3ExprDup(pRowid), 0); |
|
575 } |
|
576 assert( pTab->iPKey<0 ); |
|
577 for(i=0; i<pTab->nCol; i++){ |
|
578 if( aXRef[i]>=0 ){ |
|
579 pExpr = sqlite3ExprDup(pChanges->a[aXRef[i]].pExpr); |
|
580 }else{ |
|
581 pExpr = sqlite3CreateIdExpr(pTab->aCol[i].zName); |
|
582 } |
|
583 pEList = sqlite3ExprListAppend(pEList, pExpr, 0); |
|
584 } |
|
585 pSelect = sqlite3SelectNew(pEList, pSrc, pWhere, 0, 0, 0, 0, 0, 0); |
|
586 |
|
587 /* Create the ephemeral table into which the update results will |
|
588 ** be stored. |
|
589 */ |
|
590 assert( v ); |
|
591 ephemTab = pParse->nTab++; |
|
592 sqlite3VdbeAddOp(v, OP_OpenEphemeral, ephemTab, pTab->nCol+1+(pRowid!=0)); |
|
593 |
|
594 /* fill the ephemeral table |
|
595 */ |
|
596 sqlite3Select(pParse, pSelect, SRT_Table, ephemTab, 0, 0, 0, 0); |
|
597 |
|
598 /* |
|
599 ** Generate code to scan the ephemeral table and call VDelete and |
|
600 ** VInsert |
|
601 */ |
|
602 sqlite3VdbeAddOp(v, OP_Rewind, ephemTab, 0); |
|
603 addr = sqlite3VdbeCurrentAddr(v); |
|
604 sqlite3VdbeAddOp(v, OP_Column, ephemTab, 0); |
|
605 if( pRowid ){ |
|
606 sqlite3VdbeAddOp(v, OP_Column, ephemTab, 1); |
|
607 }else{ |
|
608 sqlite3VdbeAddOp(v, OP_Dup, 0, 0); |
|
609 } |
|
610 for(i=0; i<pTab->nCol; i++){ |
|
611 sqlite3VdbeAddOp(v, OP_Column, ephemTab, i+1+(pRowid!=0)); |
|
612 } |
|
613 pParse->pVirtualLock = pTab; |
|
614 sqlite3VdbeOp3(v, OP_VUpdate, 0, pTab->nCol+2, |
|
615 (const char*)pTab->pVtab, P3_VTAB); |
|
616 sqlite3VdbeAddOp(v, OP_Next, ephemTab, addr); |
|
617 sqlite3VdbeAddOp(v, OP_Close, ephemTab, 0); |
|
618 |
|
619 /* Cleanup */ |
|
620 sqlite3SelectDelete(pSelect); |
|
621 } |
|
622 #endif /* SQLITE_OMIT_VIRTUALTABLE */ |