4 ** The author disclaims copyright to this source code. In place of
5 ** a legal notice, here is a blessing:
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.
11 *************************************************************************
12 ** This file contains C code routines that are called by the parser
13 ** to handle UPDATE statements.
15 #include "sqliteInt.h"
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 */
29 #endif /* SQLITE_OMIT_VIRTUALTABLE */
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.
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.
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.)
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.
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
61 void sqlite3ColumnDefault(Vdbe
*v
, Table
*pTab
, int i
, int iReg
){
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
);
72 sqlite3VdbeChangeP4(v
, -1, (const char *)pValue
, P4_MEM
);
74 #ifndef SQLITE_OMIT_FLOATING_POINT
75 if( iReg
>=0 && pTab
->aCol
[i
].affinity
==SQLITE_AFF_REAL
){
76 sqlite3VdbeAddOp1(v
, OP_RealAffinity
, iReg
);
83 ** Process an UPDATE statement.
85 ** UPDATE OR IGNORE table_wxyz SET a=b, c=d WHERE e<5 AND f NOT NULL;
86 ** \_______/ \________/ \______/ \________________/
87 * onError pTabList pChanges pWhere
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 */
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 */
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 */
123 int newmask
; /* Mask of NEW.* columns accessed by BEFORE triggers */
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 */
133 memset(&sContext
, 0, sizeof(sContext
));
135 if( pParse
->nErr
|| db
->mallocFailed
){
138 assert( pTabList
->nSrc
==1 );
140 /* Locate the table which we want to update.
142 pTab
= sqlite3SrcListLookup(pParse
, pTabList
);
143 if( pTab
==0 ) goto update_cleanup
;
144 iDb
= sqlite3SchemaToIndex(pParse
->db
, pTab
->pSchema
);
146 /* Figure out if we have any triggers and if the table being
147 ** updated is a view.
149 #ifndef SQLITE_OMIT_TRIGGER
150 pTrigger
= sqlite3TriggersExist(pParse
, pTab
, TK_UPDATE
, pChanges
, &tmask
);
151 isView
= pTab
->pSelect
!=0;
152 assert( pTrigger
|| tmask
==0 );
158 #ifdef SQLITE_OMIT_VIEW
163 if( sqlite3ViewGetColumnNames(pParse
, pTab
) ){
166 if( sqlite3IsReadOnly(pParse
, pTab
, tmask
) ){
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;
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.
178 pTabList
->a
[0].iCursor
= iCur
= pParse
->nTab
++;
179 for(pIdx
=pTab
->pIndex
; pIdx
; pIdx
=pIdx
->pNext
){
183 /* Initialize the name-context */
184 memset(&sNC
, 0, sizeof(sNC
));
186 sNC
.pSrcList
= pTabList
;
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
195 for(i
=0; i
<pChanges
->nExpr
; i
++){
196 if( sqlite3ResolveExprNames(&sNC
, pChanges
->a
[i
].pExpr
) ){
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
){
203 pRowidExpr
= pChanges
->a
[i
].pExpr
;
210 if( sqlite3IsRowid(pChanges
->a
[i
].zName
) ){
212 pRowidExpr
= pChanges
->a
[i
].pExpr
;
214 sqlite3ErrorMsg(pParse
, "no such column: %s", pChanges
->a
[i
].zName
);
215 pParse
->checkSchema
= 1;
219 #ifndef SQLITE_OMIT_AUTHORIZATION
222 rc
= sqlite3AuthCheck(pParse
, SQLITE_UPDATE
, pTab
->zName
,
223 pTab
->aCol
[j
].zName
, db
->aDb
[iDb
].zName
);
224 if( rc
==SQLITE_DENY
){
226 }else if( rc
==SQLITE_IGNORE
){
233 hasFK
= sqlite3FkRequired(pParse
, pTab
, aXRef
, chngRowid
);
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.
240 for(nIdx
=0, pIdx
=pTab
->pIndex
; pIdx
; pIdx
=pIdx
->pNext
, nIdx
++){}
242 aRegIdx
= sqlite3DbMallocRaw(db
, sizeof(Index
*) * nIdx
);
243 if( aRegIdx
==0 ) goto update_cleanup
;
245 for(j
=0, pIdx
=pTab
->pIndex
; pIdx
; pIdx
=pIdx
->pNext
, j
++){
247 if( hasFK
|| chngRowid
){
248 reg
= ++pParse
->nMem
;
251 for(i
=0; i
<pIdx
->nColumn
; i
++){
252 if( aXRef
[pIdx
->aiColumn
[i
]]>=0 ){
253 reg
= ++pParse
->nMem
;
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
);
267 #ifndef SQLITE_OMIT_VIRTUALTABLE
268 /* Virtual tables must be handled separately */
269 if( IsVirtual(pTab
) ){
270 updateVirtualTable(pParse
, pTabList
, pTab
, pChanges
, pRowidExpr
, aXRef
,
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
;
285 if( chngRowid
|| pTrigger
|| hasFK
){
286 regNewRowid
= ++pParse
->nMem
;
288 regNew
= pParse
->nMem
+ 1;
289 pParse
->nMem
+= pTab
->nCol
;
291 /* Start the view context. */
293 sqlite3AuthContextPush(pParse
, &sContext
, pTab
->zName
);
296 /* If we are trying to update a view, realize that view into
297 ** a ephemeral table.
299 #if !defined(SQLITE_OMIT_VIEW) && !defined(SQLITE_OMIT_TRIGGER)
301 sqlite3MaterializeView(pParse
, pTab
, pWhere
, iCur
);
305 /* Resolve the column names in all the expressions in the
308 if( sqlite3ResolveExprNames(&sNC
, pWhere
) ){
312 /* Begin the database scan
314 sqlite3VdbeAddOp3(v
, OP_Null
, 0, regRowSet
, regOldRowid
);
315 pWInfo
= sqlite3WhereBegin(
316 pParse
, pTabList
, pWhere
, 0, 0, WHERE_ONEPASS_DESIRED
318 if( pWInfo
==0 ) goto update_cleanup
;
319 okOnePass
= pWInfo
->okOnePass
;
321 /* Remember the rowid of every item to be updated.
323 sqlite3VdbeAddOp2(v
, OP_Rowid
, iCur
, regOldRowid
);
325 sqlite3VdbeAddOp2(v
, OP_RowSetAdd
, regRowSet
, regOldRowid
);
328 /* End the database scan loop.
330 sqlite3WhereEnd(pWInfo
);
332 /* Initialize the count of updated rows
334 if( (db
->flags
& SQLITE_CountRows
) && !pParse
->pTriggerTab
){
335 regRowCount
= ++pParse
->nMem
;
336 sqlite3VdbeAddOp2(v
, OP_Integer
, 0, regRowCount
);
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.
346 if( !okOnePass
) sqlite3OpenTable(pParse
, iCur
, iDb
, pTab
, OP_OpenWrite
);
347 if( onError
==OE_Replace
){
351 for(pIdx
=pTab
->pIndex
; pIdx
; pIdx
=pIdx
->pNext
){
352 if( pIdx
->onError
==OE_Replace
){
358 for(i
=0, pIdx
=pTab
->pIndex
; pIdx
; pIdx
=pIdx
->pNext
, i
++){
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 );
369 /* Top of the update loop */
371 int a1
= sqlite3VdbeAddOp1(v
, OP_NotNull
, regOldRowid
);
372 addr
= sqlite3VdbeAddOp0(v
, OP_Goto
);
373 sqlite3VdbeJumpHere(v
, a1
);
375 addr
= sqlite3VdbeAddOp3(v
, OP_RowSetRead
, regRowSet
, 0, regOldRowid
);
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
);
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
);
389 sqlite3ExprCode(pParse
, pRowidExpr
, regNewRowid
);
390 sqlite3VdbeAddOp1(v
, OP_MustBeInt
, regNewRowid
);
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
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
);
404 sqlite3VdbeAddOp2(v
, OP_Null
, 0, regOld
+i
);
408 sqlite3VdbeAddOp2(v
, OP_Copy
, regOldRowid
, regNewRowid
);
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
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.
425 newmask
= sqlite3TriggerColmask(
426 pParse
, pTrigger
, pChanges
, 1, TRIGGER_BEFORE
, pTab
, onError
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);*/
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.
444 sqlite3VdbeAddOp3(v
, OP_Column
, iCur
, i
, regNew
+i
);
445 sqlite3ColumnDefault(v
, pTab
, i
, regNew
+i
);
450 /* Fire any BEFORE UPDATE triggers. This happens before constraints are
451 ** verified. One could argue that this is wrong.
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
);
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
465 sqlite3VdbeAddOp3(v
, OP_NotExists
, iCur
, addr
, regOldRowid
);
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.
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
);
481 int j1
; /* Address of jump instruction */
483 /* Do constraint checks. */
484 sqlite3GenerateConstraintChecks(pParse
, pTab
, iCur
, regNewRowid
,
485 aRegIdx
, (chngRowid
?regOldRowid
:0), 1, onError
, addr
, 0);
487 /* Do FK constraint checks. */
489 sqlite3FkCheck(pParse
, pTab
, regOldRowid
, 0);
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
);
496 /* If changing the record number, delete the old record. */
497 if( hasFK
|| chngRowid
){
498 sqlite3VdbeAddOp2(v
, OP_Delete
, iCur
, 0);
500 sqlite3VdbeJumpHere(v
, j1
);
503 sqlite3FkCheck(pParse
, pTab
, 0, regNewRowid
);
506 /* Insert the new index entries and the new record. */
507 sqlite3CompleteInsertion(pParse
, pTab
, iCur
, regNewRowid
, aRegIdx
, 1, 0, 0);
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. */
513 sqlite3FkActions(pParse
, pTab
, pChanges
, regOldRowid
);
517 /* Increment the row counter
519 if( (db
->flags
& SQLITE_CountRows
) && !pParse
->pTriggerTab
){
520 sqlite3VdbeAddOp2(v
, OP_AddImm
, regRowCount
, 1);
523 sqlite3CodeRowTrigger(pParse
, pTrigger
, TK_UPDATE
, pChanges
,
524 TRIGGER_AFTER
, pTab
, regOldRowid
, onError
, addr
);
526 /* Repeat the above with the next record to be updated, until
527 ** all record selected by the WHERE clause have been updated.
529 sqlite3VdbeAddOp2(v
, OP_Goto
, 0, addr
);
530 sqlite3VdbeJumpHere(v
, addr
);
532 /* Close all tables */
533 for(i
=0, pIdx
=pTab
->pIndex
; pIdx
; pIdx
=pIdx
->pNext
, i
++){
535 if( openAll
|| aRegIdx
[i
]>0 ){
536 sqlite3VdbeAddOp2(v
, OP_Close
, iCur
+i
+1, 0);
539 sqlite3VdbeAddOp2(v
, OP_Close
, iCur
, 0);
541 /* Update the sqlite_sequence table by storing the content of the
542 ** maximum rowid counter values recorded while inserting into
543 ** autoincrement tables.
545 if( pParse
->nested
==0 && pParse
->pTriggerTab
==0 ){
546 sqlite3AutoincrementEnd(pParse
);
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.
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
);
561 sqlite3AuthContextPop(&sContext
);
562 sqlite3DbFree(db
, aRegIdx
);
563 sqlite3DbFree(db
, aXRef
);
564 sqlite3SrcListDelete(db
, pTabList
);
565 sqlite3ExprListDelete(db
, pChanges
);
566 sqlite3ExprDelete(db
, pWhere
);
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). */
579 #ifndef SQLITE_OMIT_VIRTUALTABLE
581 ** Generate code for an UPDATE of a virtual table.
583 ** The strategy is that we create an ephemerial table that contains
584 ** for each row to be changed:
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.
590 ** Then we loop over this ephemeral table and for each row in
591 ** the ephermeral table call VUpdate.
593 ** When finished, drop the ephemeral table.
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.
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 */
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
);
621 /* Construct the SELECT statement that will find the new values for
624 pEList
= sqlite3ExprListAppend(pParse
, 0, sqlite3Expr(db
, TK_ID
, "_rowid_"));
626 pEList
= sqlite3ExprListAppend(pParse
, pEList
,
627 sqlite3ExprDup(db
, pRowid
, 0));
629 assert( pTab
->iPKey
<0 );
630 for(i
=0; i
<pTab
->nCol
; i
++){
632 pExpr
= sqlite3ExprDup(db
, pChanges
->a
[aXRef
[i
]].pExpr
, 0);
634 pExpr
= sqlite3Expr(db
, TK_ID
, pTab
->aCol
[i
].zName
);
636 pEList
= sqlite3ExprListAppend(pParse
, pEList
, pExpr
);
638 pSelect
= sqlite3SelectNew(pParse
, pEList
, pSrc
, pWhere
, 0, 0, 0, 0, 0, 0);
640 /* Create the ephemeral table into which the update results will
644 ephemTab
= pParse
->nTab
++;
645 sqlite3VdbeAddOp2(v
, OP_OpenEphemeral
, ephemTab
, pTab
->nCol
+1+(pRowid
!=0));
646 sqlite3VdbeChangeP5(v
, BTREE_UNORDERED
);
648 /* fill the ephemeral table
650 sqlite3SelectDestInit(&dest
, SRT_Table
, ephemTab
);
651 sqlite3Select(pParse
, pSelect
, &dest
);
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
);
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);
671 sqlite3SelectDelete(db
, pSelect
);
673 #endif /* SQLITE_OMIT_VIRTUALTABLE */