Annotation of embedaddon/sqlite3/src/update.c, revision 1.1.1.1
1.1 misho 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: #include "sqliteInt.h"
16:
17: #ifndef SQLITE_OMIT_VIRTUALTABLE
18: /* Forward declaration */
19: static void updateVirtualTable(
20: Parse *pParse, /* The parsing context */
21: SrcList *pSrc, /* The virtual table to be modified */
22: Table *pTab, /* The virtual table */
23: ExprList *pChanges, /* The columns to change in the UPDATE statement */
24: Expr *pRowidExpr, /* Expression used to recompute the rowid */
25: int *aXRef, /* Mapping from columns of pTab to entries in pChanges */
26: Expr *pWhere, /* WHERE clause of the UPDATE statement */
27: int onError /* ON CONFLICT strategy */
28: );
29: #endif /* SQLITE_OMIT_VIRTUALTABLE */
30:
31: /*
32: ** The most recently coded instruction was an OP_Column to retrieve the
33: ** i-th column of table pTab. This routine sets the P4 parameter of the
34: ** OP_Column to the default value, if any.
35: **
36: ** The default value of a column is specified by a DEFAULT clause in the
37: ** column definition. This was either supplied by the user when the table
38: ** was created, or added later to the table definition by an ALTER TABLE
39: ** command. If the latter, then the row-records in the table btree on disk
40: ** may not contain a value for the column and the default value, taken
41: ** from the P4 parameter of the OP_Column instruction, is returned instead.
42: ** If the former, then all row-records are guaranteed to include a value
43: ** for the column and the P4 value is not required.
44: **
45: ** Column definitions created by an ALTER TABLE command may only have
46: ** literal default values specified: a number, null or a string. (If a more
47: ** complicated default expression value was provided, it is evaluated
48: ** when the ALTER TABLE is executed and one of the literal values written
49: ** into the sqlite_master table.)
50: **
51: ** Therefore, the P4 parameter is only required if the default value for
52: ** the column is a literal number, string or null. The sqlite3ValueFromExpr()
53: ** function is capable of transforming these types of expressions into
54: ** sqlite3_value objects.
55: **
56: ** If parameter iReg is not negative, code an OP_RealAffinity instruction
57: ** on register iReg. This is used when an equivalent integer value is
58: ** stored in place of an 8-byte floating point value in order to save
59: ** space.
60: */
61: void sqlite3ColumnDefault(Vdbe *v, Table *pTab, int i, int iReg){
62: assert( pTab!=0 );
63: if( !pTab->pSelect ){
64: sqlite3_value *pValue;
65: u8 enc = ENC(sqlite3VdbeDb(v));
66: Column *pCol = &pTab->aCol[i];
67: VdbeComment((v, "%s.%s", pTab->zName, pCol->zName));
68: assert( i<pTab->nCol );
69: sqlite3ValueFromExpr(sqlite3VdbeDb(v), pCol->pDflt, enc,
70: pCol->affinity, &pValue);
71: if( pValue ){
72: sqlite3VdbeChangeP4(v, -1, (const char *)pValue, P4_MEM);
73: }
74: #ifndef SQLITE_OMIT_FLOATING_POINT
75: if( iReg>=0 && pTab->aCol[i].affinity==SQLITE_AFF_REAL ){
76: sqlite3VdbeAddOp1(v, OP_RealAffinity, iReg);
77: }
78: #endif
79: }
80: }
81:
82: /*
83: ** Process an UPDATE statement.
84: **
85: ** UPDATE OR IGNORE table_wxyz SET a=b, c=d WHERE e<5 AND f NOT NULL;
86: ** \_______/ \________/ \______/ \________________/
87: * onError pTabList pChanges pWhere
88: */
89: void sqlite3Update(
90: Parse *pParse, /* The parser context */
91: SrcList *pTabList, /* The table in which we should change things */
92: ExprList *pChanges, /* Things to be changed */
93: Expr *pWhere, /* The WHERE clause. May be null */
94: int onError /* How to handle constraint errors */
95: ){
96: int i, j; /* Loop counters */
97: Table *pTab; /* The table to be updated */
98: int addr = 0; /* VDBE instruction address of the start of the loop */
99: WhereInfo *pWInfo; /* Information about the WHERE clause */
100: Vdbe *v; /* The virtual database engine */
101: Index *pIdx; /* For looping over indices */
102: int nIdx; /* Number of indices that need updating */
103: int iCur; /* VDBE Cursor number of pTab */
104: sqlite3 *db; /* The database structure */
105: int *aRegIdx = 0; /* One register assigned to each index to be updated */
106: int *aXRef = 0; /* aXRef[i] is the index in pChanges->a[] of the
107: ** an expression for the i-th column of the table.
108: ** aXRef[i]==-1 if the i-th column is not changed. */
109: int chngRowid; /* True if the record number is being changed */
110: Expr *pRowidExpr = 0; /* Expression defining the new record number */
111: int openAll = 0; /* True if all indices need to be opened */
112: AuthContext sContext; /* The authorization context */
113: NameContext sNC; /* The name-context to resolve expressions in */
114: int iDb; /* Database containing the table being updated */
115: int okOnePass; /* True for one-pass algorithm without the FIFO */
116: int hasFK; /* True if foreign key processing is required */
117:
118: #ifndef SQLITE_OMIT_TRIGGER
119: int isView; /* True when updating a view (INSTEAD OF trigger) */
120: Trigger *pTrigger; /* List of triggers on pTab, if required */
121: int tmask; /* Mask of TRIGGER_BEFORE|TRIGGER_AFTER */
122: #endif
123: int newmask; /* Mask of NEW.* columns accessed by BEFORE triggers */
124:
125: /* Register Allocations */
126: int regRowCount = 0; /* A count of rows changed */
127: int regOldRowid; /* The old rowid */
128: int regNewRowid; /* The new rowid */
129: int regNew; /* Content of the NEW.* table in triggers */
130: int regOld = 0; /* Content of OLD.* table in triggers */
131: int regRowSet = 0; /* Rowset of rows to be updated */
132:
133: memset(&sContext, 0, sizeof(sContext));
134: db = pParse->db;
135: if( pParse->nErr || db->mallocFailed ){
136: goto update_cleanup;
137: }
138: assert( pTabList->nSrc==1 );
139:
140: /* Locate the table which we want to update.
141: */
142: pTab = sqlite3SrcListLookup(pParse, pTabList);
143: if( pTab==0 ) goto update_cleanup;
144: iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
145:
146: /* Figure out if we have any triggers and if the table being
147: ** updated is a view.
148: */
149: #ifndef SQLITE_OMIT_TRIGGER
150: pTrigger = sqlite3TriggersExist(pParse, pTab, TK_UPDATE, pChanges, &tmask);
151: isView = pTab->pSelect!=0;
152: assert( pTrigger || tmask==0 );
153: #else
154: # define pTrigger 0
155: # define isView 0
156: # define tmask 0
157: #endif
158: #ifdef SQLITE_OMIT_VIEW
159: # undef isView
160: # define isView 0
161: #endif
162:
163: if( sqlite3ViewGetColumnNames(pParse, pTab) ){
164: goto update_cleanup;
165: }
166: if( sqlite3IsReadOnly(pParse, pTab, tmask) ){
167: goto update_cleanup;
168: }
169: aXRef = sqlite3DbMallocRaw(db, sizeof(int) * pTab->nCol );
170: if( aXRef==0 ) goto update_cleanup;
171: for(i=0; i<pTab->nCol; i++) aXRef[i] = -1;
172:
173: /* Allocate a cursors for the main database table and for all indices.
174: ** The index cursors might not be used, but if they are used they
175: ** need to occur right after the database cursor. So go ahead and
176: ** allocate enough space, just in case.
177: */
178: pTabList->a[0].iCursor = iCur = pParse->nTab++;
179: for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
180: pParse->nTab++;
181: }
182:
183: /* Initialize the name-context */
184: memset(&sNC, 0, sizeof(sNC));
185: sNC.pParse = pParse;
186: sNC.pSrcList = pTabList;
187:
188: /* Resolve the column names in all the expressions of the
189: ** of the UPDATE statement. Also find the column index
190: ** for each column to be updated in the pChanges array. For each
191: ** column to be updated, make sure we have authorization to change
192: ** that column.
193: */
194: chngRowid = 0;
195: for(i=0; i<pChanges->nExpr; i++){
196: if( sqlite3ResolveExprNames(&sNC, pChanges->a[i].pExpr) ){
197: goto update_cleanup;
198: }
199: for(j=0; j<pTab->nCol; j++){
200: if( sqlite3StrICmp(pTab->aCol[j].zName, pChanges->a[i].zName)==0 ){
201: if( j==pTab->iPKey ){
202: chngRowid = 1;
203: pRowidExpr = pChanges->a[i].pExpr;
204: }
205: aXRef[j] = i;
206: break;
207: }
208: }
209: if( j>=pTab->nCol ){
210: if( sqlite3IsRowid(pChanges->a[i].zName) ){
211: chngRowid = 1;
212: pRowidExpr = pChanges->a[i].pExpr;
213: }else{
214: sqlite3ErrorMsg(pParse, "no such column: %s", pChanges->a[i].zName);
215: pParse->checkSchema = 1;
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: hasFK = sqlite3FkRequired(pParse, pTab, aXRef, chngRowid);
234:
235: /* Allocate memory for the array aRegIdx[]. There is one entry in the
236: ** array for each index associated with table being updated. Fill in
237: ** the value with a register number for indices that are to be used
238: ** and with zero for unused indices.
239: */
240: for(nIdx=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, nIdx++){}
241: if( nIdx>0 ){
242: aRegIdx = sqlite3DbMallocRaw(db, sizeof(Index*) * nIdx );
243: if( aRegIdx==0 ) goto update_cleanup;
244: }
245: for(j=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, j++){
246: int reg;
247: if( hasFK || chngRowid ){
248: reg = ++pParse->nMem;
249: }else{
250: reg = 0;
251: for(i=0; i<pIdx->nColumn; i++){
252: if( aXRef[pIdx->aiColumn[i]]>=0 ){
253: reg = ++pParse->nMem;
254: break;
255: }
256: }
257: }
258: aRegIdx[j] = reg;
259: }
260:
261: /* Begin generating code. */
262: v = sqlite3GetVdbe(pParse);
263: if( v==0 ) goto update_cleanup;
264: if( pParse->nested==0 ) sqlite3VdbeCountChanges(v);
265: sqlite3BeginWriteOperation(pParse, 1, iDb);
266:
267: #ifndef SQLITE_OMIT_VIRTUALTABLE
268: /* Virtual tables must be handled separately */
269: if( IsVirtual(pTab) ){
270: updateVirtualTable(pParse, pTabList, pTab, pChanges, pRowidExpr, aXRef,
271: pWhere, onError);
272: pWhere = 0;
273: pTabList = 0;
274: goto update_cleanup;
275: }
276: #endif
277:
278: /* Allocate required registers. */
279: regRowSet = ++pParse->nMem;
280: regOldRowid = regNewRowid = ++pParse->nMem;
281: if( pTrigger || hasFK ){
282: regOld = pParse->nMem + 1;
283: pParse->nMem += pTab->nCol;
284: }
285: if( chngRowid || pTrigger || hasFK ){
286: regNewRowid = ++pParse->nMem;
287: }
288: regNew = pParse->nMem + 1;
289: pParse->nMem += pTab->nCol;
290:
291: /* Start the view context. */
292: if( isView ){
293: sqlite3AuthContextPush(pParse, &sContext, pTab->zName);
294: }
295:
296: /* If we are trying to update a view, realize that view into
297: ** a ephemeral table.
298: */
299: #if !defined(SQLITE_OMIT_VIEW) && !defined(SQLITE_OMIT_TRIGGER)
300: if( isView ){
301: sqlite3MaterializeView(pParse, pTab, pWhere, iCur);
302: }
303: #endif
304:
305: /* Resolve the column names in all the expressions in the
306: ** WHERE clause.
307: */
308: if( sqlite3ResolveExprNames(&sNC, pWhere) ){
309: goto update_cleanup;
310: }
311:
312: /* Begin the database scan
313: */
314: sqlite3VdbeAddOp3(v, OP_Null, 0, regRowSet, regOldRowid);
315: pWInfo = sqlite3WhereBegin(
316: pParse, pTabList, pWhere, 0, 0, WHERE_ONEPASS_DESIRED
317: );
318: if( pWInfo==0 ) goto update_cleanup;
319: okOnePass = pWInfo->okOnePass;
320:
321: /* Remember the rowid of every item to be updated.
322: */
323: sqlite3VdbeAddOp2(v, OP_Rowid, iCur, regOldRowid);
324: if( !okOnePass ){
325: sqlite3VdbeAddOp2(v, OP_RowSetAdd, regRowSet, regOldRowid);
326: }
327:
328: /* End the database scan loop.
329: */
330: sqlite3WhereEnd(pWInfo);
331:
332: /* Initialize the count of updated rows
333: */
334: if( (db->flags & SQLITE_CountRows) && !pParse->pTriggerTab ){
335: regRowCount = ++pParse->nMem;
336: sqlite3VdbeAddOp2(v, OP_Integer, 0, regRowCount);
337: }
338:
339: if( !isView ){
340: /*
341: ** Open every index that needs updating. Note that if any
342: ** index could potentially invoke a REPLACE conflict resolution
343: ** action, then we need to open all indices because we might need
344: ** to be deleting some records.
345: */
346: if( !okOnePass ) sqlite3OpenTable(pParse, iCur, iDb, pTab, OP_OpenWrite);
347: if( onError==OE_Replace ){
348: openAll = 1;
349: }else{
350: openAll = 0;
351: for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
352: if( pIdx->onError==OE_Replace ){
353: openAll = 1;
354: break;
355: }
356: }
357: }
358: for(i=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, i++){
359: assert( aRegIdx );
360: if( openAll || aRegIdx[i]>0 ){
361: KeyInfo *pKey = sqlite3IndexKeyinfo(pParse, pIdx);
362: sqlite3VdbeAddOp4(v, OP_OpenWrite, iCur+i+1, pIdx->tnum, iDb,
363: (char*)pKey, P4_KEYINFO_HANDOFF);
364: assert( pParse->nTab>iCur+i+1 );
365: }
366: }
367: }
368:
369: /* Top of the update loop */
370: if( okOnePass ){
371: int a1 = sqlite3VdbeAddOp1(v, OP_NotNull, regOldRowid);
372: addr = sqlite3VdbeAddOp0(v, OP_Goto);
373: sqlite3VdbeJumpHere(v, a1);
374: }else{
375: addr = sqlite3VdbeAddOp3(v, OP_RowSetRead, regRowSet, 0, regOldRowid);
376: }
377:
378: /* Make cursor iCur point to the record that is being updated. If
379: ** this record does not exist for some reason (deleted by a trigger,
380: ** for example, then jump to the next iteration of the RowSet loop. */
381: sqlite3VdbeAddOp3(v, OP_NotExists, iCur, addr, regOldRowid);
382:
383: /* If the record number will change, set register regNewRowid to
384: ** contain the new value. If the record number is not being modified,
385: ** then regNewRowid is the same register as regOldRowid, which is
386: ** already populated. */
387: assert( chngRowid || pTrigger || hasFK || regOldRowid==regNewRowid );
388: if( chngRowid ){
389: sqlite3ExprCode(pParse, pRowidExpr, regNewRowid);
390: sqlite3VdbeAddOp1(v, OP_MustBeInt, regNewRowid);
391: }
392:
393: /* If there are triggers on this table, populate an array of registers
394: ** with the required old.* column data. */
395: if( hasFK || pTrigger ){
396: u32 oldmask = (hasFK ? sqlite3FkOldmask(pParse, pTab) : 0);
397: oldmask |= sqlite3TriggerColmask(pParse,
398: pTrigger, pChanges, 0, TRIGGER_BEFORE|TRIGGER_AFTER, pTab, onError
399: );
400: for(i=0; i<pTab->nCol; i++){
401: if( aXRef[i]<0 || oldmask==0xffffffff || (i<32 && (oldmask & (1<<i))) ){
402: sqlite3ExprCodeGetColumnOfTable(v, pTab, iCur, i, regOld+i);
403: }else{
404: sqlite3VdbeAddOp2(v, OP_Null, 0, regOld+i);
405: }
406: }
407: if( chngRowid==0 ){
408: sqlite3VdbeAddOp2(v, OP_Copy, regOldRowid, regNewRowid);
409: }
410: }
411:
412: /* Populate the array of registers beginning at regNew with the new
413: ** row data. This array is used to check constaints, create the new
414: ** table and index records, and as the values for any new.* references
415: ** made by triggers.
416: **
417: ** If there are one or more BEFORE triggers, then do not populate the
418: ** registers associated with columns that are (a) not modified by
419: ** this UPDATE statement and (b) not accessed by new.* references. The
420: ** values for registers not modified by the UPDATE must be reloaded from
421: ** the database after the BEFORE triggers are fired anyway (as the trigger
422: ** may have modified them). So not loading those that are not going to
423: ** be used eliminates some redundant opcodes.
424: */
425: newmask = sqlite3TriggerColmask(
426: pParse, pTrigger, pChanges, 1, TRIGGER_BEFORE, pTab, onError
427: );
428: sqlite3VdbeAddOp3(v, OP_Null, 0, regNew, regNew+pTab->nCol-1);
429: for(i=0; i<pTab->nCol; i++){
430: if( i==pTab->iPKey ){
431: /*sqlite3VdbeAddOp2(v, OP_Null, 0, regNew+i);*/
432: }else{
433: j = aXRef[i];
434: if( j>=0 ){
435: sqlite3ExprCode(pParse, pChanges->a[j].pExpr, regNew+i);
436: }else if( 0==(tmask&TRIGGER_BEFORE) || i>31 || (newmask&(1<<i)) ){
437: /* This branch loads the value of a column that will not be changed
438: ** into a register. This is done if there are no BEFORE triggers, or
439: ** if there are one or more BEFORE triggers that use this value via
440: ** a new.* reference in a trigger program.
441: */
442: testcase( i==31 );
443: testcase( i==32 );
444: sqlite3VdbeAddOp3(v, OP_Column, iCur, i, regNew+i);
445: sqlite3ColumnDefault(v, pTab, i, regNew+i);
446: }
447: }
448: }
449:
450: /* Fire any BEFORE UPDATE triggers. This happens before constraints are
451: ** verified. One could argue that this is wrong.
452: */
453: if( tmask&TRIGGER_BEFORE ){
454: sqlite3VdbeAddOp2(v, OP_Affinity, regNew, pTab->nCol);
455: sqlite3TableAffinityStr(v, pTab);
456: sqlite3CodeRowTrigger(pParse, pTrigger, TK_UPDATE, pChanges,
457: TRIGGER_BEFORE, pTab, regOldRowid, onError, addr);
458:
459: /* The row-trigger may have deleted the row being updated. In this
460: ** case, jump to the next row. No updates or AFTER triggers are
461: ** required. This behaviour - what happens when the row being updated
462: ** is deleted or renamed by a BEFORE trigger - is left undefined in the
463: ** documentation.
464: */
465: sqlite3VdbeAddOp3(v, OP_NotExists, iCur, addr, regOldRowid);
466:
467: /* If it did not delete it, the row-trigger may still have modified
468: ** some of the columns of the row being updated. Load the values for
469: ** all columns not modified by the update statement into their
470: ** registers in case this has happened.
471: */
472: for(i=0; i<pTab->nCol; i++){
473: if( aXRef[i]<0 && i!=pTab->iPKey ){
474: sqlite3VdbeAddOp3(v, OP_Column, iCur, i, regNew+i);
475: sqlite3ColumnDefault(v, pTab, i, regNew+i);
476: }
477: }
478: }
479:
480: if( !isView ){
481: int j1; /* Address of jump instruction */
482:
483: /* Do constraint checks. */
484: sqlite3GenerateConstraintChecks(pParse, pTab, iCur, regNewRowid,
485: aRegIdx, (chngRowid?regOldRowid:0), 1, onError, addr, 0);
486:
487: /* Do FK constraint checks. */
488: if( hasFK ){
489: sqlite3FkCheck(pParse, pTab, regOldRowid, 0);
490: }
491:
492: /* Delete the index entries associated with the current record. */
493: j1 = sqlite3VdbeAddOp3(v, OP_NotExists, iCur, 0, regOldRowid);
494: sqlite3GenerateRowIndexDelete(pParse, pTab, iCur, aRegIdx);
495:
496: /* If changing the record number, delete the old record. */
497: if( hasFK || chngRowid ){
498: sqlite3VdbeAddOp2(v, OP_Delete, iCur, 0);
499: }
500: sqlite3VdbeJumpHere(v, j1);
501:
502: if( hasFK ){
503: sqlite3FkCheck(pParse, pTab, 0, regNewRowid);
504: }
505:
506: /* Insert the new index entries and the new record. */
507: sqlite3CompleteInsertion(pParse, pTab, iCur, regNewRowid, aRegIdx, 1, 0, 0);
508:
509: /* Do any ON CASCADE, SET NULL or SET DEFAULT operations required to
510: ** handle rows (possibly in other tables) that refer via a foreign key
511: ** to the row just updated. */
512: if( hasFK ){
513: sqlite3FkActions(pParse, pTab, pChanges, regOldRowid);
514: }
515: }
516:
517: /* Increment the row counter
518: */
519: if( (db->flags & SQLITE_CountRows) && !pParse->pTriggerTab){
520: sqlite3VdbeAddOp2(v, OP_AddImm, regRowCount, 1);
521: }
522:
523: sqlite3CodeRowTrigger(pParse, pTrigger, TK_UPDATE, pChanges,
524: TRIGGER_AFTER, pTab, regOldRowid, onError, addr);
525:
526: /* Repeat the above with the next record to be updated, until
527: ** all record selected by the WHERE clause have been updated.
528: */
529: sqlite3VdbeAddOp2(v, OP_Goto, 0, addr);
530: sqlite3VdbeJumpHere(v, addr);
531:
532: /* Close all tables */
533: for(i=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, i++){
534: assert( aRegIdx );
535: if( openAll || aRegIdx[i]>0 ){
536: sqlite3VdbeAddOp2(v, OP_Close, iCur+i+1, 0);
537: }
538: }
539: sqlite3VdbeAddOp2(v, OP_Close, iCur, 0);
540:
541: /* Update the sqlite_sequence table by storing the content of the
542: ** maximum rowid counter values recorded while inserting into
543: ** autoincrement tables.
544: */
545: if( pParse->nested==0 && pParse->pTriggerTab==0 ){
546: sqlite3AutoincrementEnd(pParse);
547: }
548:
549: /*
550: ** Return the number of rows that were changed. If this routine is
551: ** generating code because of a call to sqlite3NestedParse(), do not
552: ** invoke the callback function.
553: */
554: if( (db->flags&SQLITE_CountRows) && !pParse->pTriggerTab && !pParse->nested ){
555: sqlite3VdbeAddOp2(v, OP_ResultRow, regRowCount, 1);
556: sqlite3VdbeSetNumCols(v, 1);
557: sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "rows updated", SQLITE_STATIC);
558: }
559:
560: update_cleanup:
561: sqlite3AuthContextPop(&sContext);
562: sqlite3DbFree(db, aRegIdx);
563: sqlite3DbFree(db, aXRef);
564: sqlite3SrcListDelete(db, pTabList);
565: sqlite3ExprListDelete(db, pChanges);
566: sqlite3ExprDelete(db, pWhere);
567: return;
568: }
569: /* Make sure "isView" and other macros defined above are undefined. Otherwise
570: ** thely may interfere with compilation of other functions in this file
571: ** (or in another file, if this file becomes part of the amalgamation). */
572: #ifdef isView
573: #undef isView
574: #endif
575: #ifdef pTrigger
576: #undef pTrigger
577: #endif
578:
579: #ifndef SQLITE_OMIT_VIRTUALTABLE
580: /*
581: ** Generate code for an UPDATE of a virtual table.
582: **
583: ** The strategy is that we create an ephemerial table that contains
584: ** for each row to be changed:
585: **
586: ** (A) The original rowid of that row.
587: ** (B) The revised rowid for the row. (note1)
588: ** (C) The content of every column in the row.
589: **
590: ** Then we loop over this ephemeral table and for each row in
591: ** the ephermeral table call VUpdate.
592: **
593: ** When finished, drop the ephemeral table.
594: **
595: ** (note1) Actually, if we know in advance that (A) is always the same
596: ** as (B) we only store (A), then duplicate (A) when pulling
597: ** it out of the ephemeral table before calling VUpdate.
598: */
599: static void updateVirtualTable(
600: Parse *pParse, /* The parsing context */
601: SrcList *pSrc, /* The virtual table to be modified */
602: Table *pTab, /* The virtual table */
603: ExprList *pChanges, /* The columns to change in the UPDATE statement */
604: Expr *pRowid, /* Expression used to recompute the rowid */
605: int *aXRef, /* Mapping from columns of pTab to entries in pChanges */
606: Expr *pWhere, /* WHERE clause of the UPDATE statement */
607: int onError /* ON CONFLICT strategy */
608: ){
609: Vdbe *v = pParse->pVdbe; /* Virtual machine under construction */
610: ExprList *pEList = 0; /* The result set of the SELECT statement */
611: Select *pSelect = 0; /* The SELECT statement */
612: Expr *pExpr; /* Temporary expression */
613: int ephemTab; /* Table holding the result of the SELECT */
614: int i; /* Loop counter */
615: int addr; /* Address of top of loop */
616: int iReg; /* First register in set passed to OP_VUpdate */
617: sqlite3 *db = pParse->db; /* Database connection */
618: const char *pVTab = (const char*)sqlite3GetVTable(db, pTab);
619: SelectDest dest;
620:
621: /* Construct the SELECT statement that will find the new values for
622: ** all updated rows.
623: */
624: pEList = sqlite3ExprListAppend(pParse, 0, sqlite3Expr(db, TK_ID, "_rowid_"));
625: if( pRowid ){
626: pEList = sqlite3ExprListAppend(pParse, pEList,
627: sqlite3ExprDup(db, pRowid, 0));
628: }
629: assert( pTab->iPKey<0 );
630: for(i=0; i<pTab->nCol; i++){
631: if( aXRef[i]>=0 ){
632: pExpr = sqlite3ExprDup(db, pChanges->a[aXRef[i]].pExpr, 0);
633: }else{
634: pExpr = sqlite3Expr(db, TK_ID, pTab->aCol[i].zName);
635: }
636: pEList = sqlite3ExprListAppend(pParse, pEList, pExpr);
637: }
638: pSelect = sqlite3SelectNew(pParse, pEList, pSrc, pWhere, 0, 0, 0, 0, 0, 0);
639:
640: /* Create the ephemeral table into which the update results will
641: ** be stored.
642: */
643: assert( v );
644: ephemTab = pParse->nTab++;
645: sqlite3VdbeAddOp2(v, OP_OpenEphemeral, ephemTab, pTab->nCol+1+(pRowid!=0));
646: sqlite3VdbeChangeP5(v, BTREE_UNORDERED);
647:
648: /* fill the ephemeral table
649: */
650: sqlite3SelectDestInit(&dest, SRT_Table, ephemTab);
651: sqlite3Select(pParse, pSelect, &dest);
652:
653: /* Generate code to scan the ephemeral table and call VUpdate. */
654: iReg = ++pParse->nMem;
655: pParse->nMem += pTab->nCol+1;
656: addr = sqlite3VdbeAddOp2(v, OP_Rewind, ephemTab, 0);
657: sqlite3VdbeAddOp3(v, OP_Column, ephemTab, 0, iReg);
658: sqlite3VdbeAddOp3(v, OP_Column, ephemTab, (pRowid?1:0), iReg+1);
659: for(i=0; i<pTab->nCol; i++){
660: sqlite3VdbeAddOp3(v, OP_Column, ephemTab, i+1+(pRowid!=0), iReg+2+i);
661: }
662: sqlite3VtabMakeWritable(pParse, pTab);
663: sqlite3VdbeAddOp4(v, OP_VUpdate, 0, pTab->nCol+2, iReg, pVTab, P4_VTAB);
664: sqlite3VdbeChangeP5(v, onError==OE_Default ? OE_Abort : onError);
665: sqlite3MayAbort(pParse);
666: sqlite3VdbeAddOp2(v, OP_Next, ephemTab, addr+1);
667: sqlite3VdbeJumpHere(v, addr);
668: sqlite3VdbeAddOp2(v, OP_Close, ephemTab, 0);
669:
670: /* Cleanup */
671: sqlite3SelectDelete(db, pSelect);
672: }
673: #endif /* SQLITE_OMIT_VIRTUALTABLE */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to update.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / sqlite3 / src