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
= 0;
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( 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 addrTop
= 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 Index
*pPk
; /* The PRIMARY KEY index for WITHOUT ROWID tables */
103 int nIdx
; /* Number of indices that need updating */
104 int iBaseCur
; /* Base cursor number */
105 int iDataCur
; /* Cursor for the canonical data btree */
106 int iIdxCur
; /* Cursor for the first index */
107 sqlite3
*db
; /* The database structure */
108 int *aRegIdx
= 0; /* One register assigned to each index to be updated */
109 int *aXRef
= 0; /* aXRef[i] is the index in pChanges->a[] of the
110 ** an expression for the i-th column of the table.
111 ** aXRef[i]==-1 if the i-th column is not changed. */
112 u8
*aToOpen
; /* 1 for tables and indices to be opened */
113 u8 chngPk
; /* PRIMARY KEY changed in a WITHOUT ROWID table */
114 u8 chngRowid
; /* Rowid changed in a normal table */
115 u8 chngKey
; /* Either chngPk or chngRowid */
116 Expr
*pRowidExpr
= 0; /* Expression defining the new record number */
117 AuthContext sContext
; /* The authorization context */
118 NameContext sNC
; /* The name-context to resolve expressions in */
119 int iDb
; /* Database containing the table being updated */
120 int okOnePass
; /* True for one-pass algorithm without the FIFO */
121 int hasFK
; /* True if foreign key processing is required */
122 int labelBreak
; /* Jump here to break out of UPDATE loop */
123 int labelContinue
; /* Jump here to continue next step of UPDATE loop */
125 #ifndef SQLITE_OMIT_TRIGGER
126 int isView
; /* True when updating a view (INSTEAD OF trigger) */
127 Trigger
*pTrigger
; /* List of triggers on pTab, if required */
128 int tmask
; /* Mask of TRIGGER_BEFORE|TRIGGER_AFTER */
130 int newmask
; /* Mask of NEW.* columns accessed by BEFORE triggers */
131 int iEph
= 0; /* Ephemeral table holding all primary key values */
132 int nKey
= 0; /* Number of elements in regKey for WITHOUT ROWID */
133 int aiCurOnePass
[2]; /* The write cursors opened by WHERE_ONEPASS */
135 /* Register Allocations */
136 int regRowCount
= 0; /* A count of rows changed */
137 int regOldRowid
= 0; /* The old rowid */
138 int regNewRowid
= 0; /* The new rowid */
139 int regNew
= 0; /* Content of the NEW.* table in triggers */
140 int regOld
= 0; /* Content of OLD.* table in triggers */
141 int regRowSet
= 0; /* Rowset of rows to be updated */
142 int regKey
= 0; /* composite PRIMARY KEY value */
144 memset(&sContext
, 0, sizeof(sContext
));
146 if( pParse
->nErr
|| db
->mallocFailed
){
149 assert( pTabList
->nSrc
==1 );
151 /* Locate the table which we want to update.
153 pTab
= sqlite3SrcListLookup(pParse
, pTabList
);
154 if( pTab
==0 ) goto update_cleanup
;
155 iDb
= sqlite3SchemaToIndex(pParse
->db
, pTab
->pSchema
);
157 /* Figure out if we have any triggers and if the table being
158 ** updated is a view.
160 #ifndef SQLITE_OMIT_TRIGGER
161 pTrigger
= sqlite3TriggersExist(pParse
, pTab
, TK_UPDATE
, pChanges
, &tmask
);
162 isView
= pTab
->pSelect
!=0;
163 assert( pTrigger
|| tmask
==0 );
169 #ifdef SQLITE_OMIT_VIEW
174 if( sqlite3ViewGetColumnNames(pParse
, pTab
) ){
177 if( sqlite3IsReadOnly(pParse
, pTab
, tmask
) ){
181 /* Allocate a cursors for the main database table and for all indices.
182 ** The index cursors might not be used, but if they are used they
183 ** need to occur right after the database cursor. So go ahead and
184 ** allocate enough space, just in case.
186 pTabList
->a
[0].iCursor
= iBaseCur
= iDataCur
= pParse
->nTab
++;
187 iIdxCur
= iDataCur
+1;
188 pPk
= HasRowid(pTab
) ? 0 : sqlite3PrimaryKeyIndex(pTab
);
189 for(nIdx
=0, pIdx
=pTab
->pIndex
; pIdx
; pIdx
=pIdx
->pNext
, nIdx
++){
190 if( IsPrimaryKeyIndex(pIdx
) && pPk
!=0 ){
191 iDataCur
= pParse
->nTab
;
192 pTabList
->a
[0].iCursor
= iDataCur
;
197 /* Allocate space for aXRef[], aRegIdx[], and aToOpen[].
198 ** Initialize aXRef[] and aToOpen[] to their default values.
200 aXRef
= sqlite3DbMallocRawNN(db
, sizeof(int) * (pTab
->nCol
+nIdx
) + nIdx
+2 );
201 if( aXRef
==0 ) goto update_cleanup
;
202 aRegIdx
= aXRef
+pTab
->nCol
;
203 aToOpen
= (u8
*)(aRegIdx
+nIdx
);
204 memset(aToOpen
, 1, nIdx
+1);
206 for(i
=0; i
<pTab
->nCol
; i
++) aXRef
[i
] = -1;
208 /* Initialize the name-context */
209 memset(&sNC
, 0, sizeof(sNC
));
211 sNC
.pSrcList
= pTabList
;
213 /* Resolve the column names in all the expressions of the
214 ** of the UPDATE statement. Also find the column index
215 ** for each column to be updated in the pChanges array. For each
216 ** column to be updated, make sure we have authorization to change
219 chngRowid
= chngPk
= 0;
220 for(i
=0; i
<pChanges
->nExpr
; i
++){
221 if( sqlite3ResolveExprNames(&sNC
, pChanges
->a
[i
].pExpr
) ){
224 for(j
=0; j
<pTab
->nCol
; j
++){
225 if( sqlite3StrICmp(pTab
->aCol
[j
].zName
, pChanges
->a
[i
].zName
)==0 ){
226 if( j
==pTab
->iPKey
){
228 pRowidExpr
= pChanges
->a
[i
].pExpr
;
229 }else if( pPk
&& (pTab
->aCol
[j
].colFlags
& COLFLAG_PRIMKEY
)!=0 ){
237 if( pPk
==0 && sqlite3IsRowid(pChanges
->a
[i
].zName
) ){
240 pRowidExpr
= pChanges
->a
[i
].pExpr
;
242 sqlite3ErrorMsg(pParse
, "no such column: %s", pChanges
->a
[i
].zName
);
243 pParse
->checkSchema
= 1;
247 #ifndef SQLITE_OMIT_AUTHORIZATION
250 rc
= sqlite3AuthCheck(pParse
, SQLITE_UPDATE
, pTab
->zName
,
251 j
<0 ? "ROWID" : pTab
->aCol
[j
].zName
,
252 db
->aDb
[iDb
].zDbSName
);
253 if( rc
==SQLITE_DENY
){
255 }else if( rc
==SQLITE_IGNORE
){
261 assert( (chngRowid
& chngPk
)==0 );
262 assert( chngRowid
==0 || chngRowid
==1 );
263 assert( chngPk
==0 || chngPk
==1 );
264 chngKey
= chngRowid
+ chngPk
;
266 /* The SET expressions are not actually used inside the WHERE loop.
267 ** So reset the colUsed mask. Unless this is a virtual table. In that
268 ** case, set all bits of the colUsed mask (to ensure that the virtual
269 ** table implementation makes all columns available).
271 pTabList
->a
[0].colUsed
= IsVirtual(pTab
) ? ALLBITS
: 0;
273 hasFK
= sqlite3FkRequired(pParse
, pTab
, aXRef
, chngKey
);
275 /* There is one entry in the aRegIdx[] array for each index on the table
276 ** being updated. Fill in aRegIdx[] with a register number that will hold
277 ** the key for accessing each index.
279 ** FIXME: Be smarter about omitting indexes that use expressions.
281 for(j
=0, pIdx
=pTab
->pIndex
; pIdx
; pIdx
=pIdx
->pNext
, j
++){
283 if( chngKey
|| hasFK
|| pIdx
->pPartIdxWhere
|| pIdx
==pPk
){
284 reg
= ++pParse
->nMem
;
287 for(i
=0; i
<pIdx
->nKeyCol
; i
++){
288 i16 iIdxCol
= pIdx
->aiColumn
[i
];
289 if( iIdxCol
<0 || aXRef
[iIdxCol
]>=0 ){
290 reg
= ++pParse
->nMem
;
295 if( reg
==0 ) aToOpen
[j
+1] = 0;
299 /* Begin generating code. */
300 v
= sqlite3GetVdbe(pParse
);
301 if( v
==0 ) goto update_cleanup
;
302 if( pParse
->nested
==0 ) sqlite3VdbeCountChanges(v
);
303 sqlite3BeginWriteOperation(pParse
, 1, iDb
);
305 /* Allocate required registers. */
306 if( !IsVirtual(pTab
) ){
307 regRowSet
= ++pParse
->nMem
;
308 regOldRowid
= regNewRowid
= ++pParse
->nMem
;
309 if( chngPk
|| pTrigger
|| hasFK
){
310 regOld
= pParse
->nMem
+ 1;
311 pParse
->nMem
+= pTab
->nCol
;
313 if( chngKey
|| pTrigger
|| hasFK
){
314 regNewRowid
= ++pParse
->nMem
;
316 regNew
= pParse
->nMem
+ 1;
317 pParse
->nMem
+= pTab
->nCol
;
320 /* Start the view context. */
322 sqlite3AuthContextPush(pParse
, &sContext
, pTab
->zName
);
325 /* If we are trying to update a view, realize that view into
326 ** an ephemeral table.
328 #if !defined(SQLITE_OMIT_VIEW) && !defined(SQLITE_OMIT_TRIGGER)
330 sqlite3MaterializeView(pParse
, pTab
, pWhere
, iDataCur
);
334 /* Resolve the column names in all the expressions in the
337 if( sqlite3ResolveExprNames(&sNC
, pWhere
) ){
341 #ifndef SQLITE_OMIT_VIRTUALTABLE
342 /* Virtual tables must be handled separately */
343 if( IsVirtual(pTab
) ){
344 updateVirtualTable(pParse
, pTabList
, pTab
, pChanges
, pRowidExpr
, aXRef
,
350 /* Begin the database scan
352 if( HasRowid(pTab
) ){
353 sqlite3VdbeAddOp3(v
, OP_Null
, 0, regRowSet
, regOldRowid
);
354 pWInfo
= sqlite3WhereBegin(
355 pParse
, pTabList
, pWhere
, 0, 0,
356 WHERE_ONEPASS_DESIRED
| WHERE_SEEK_TABLE
, iIdxCur
358 if( pWInfo
==0 ) goto update_cleanup
;
359 okOnePass
= sqlite3WhereOkOnePass(pWInfo
, aiCurOnePass
);
361 /* Remember the rowid of every item to be updated.
363 sqlite3VdbeAddOp2(v
, OP_Rowid
, iDataCur
, regOldRowid
);
365 sqlite3VdbeAddOp2(v
, OP_RowSetAdd
, regRowSet
, regOldRowid
);
368 /* End the database scan loop.
370 sqlite3WhereEnd(pWInfo
);
372 int iPk
; /* First of nPk memory cells holding PRIMARY KEY value */
373 i16 nPk
; /* Number of components of the PRIMARY KEY */
374 int addrOpen
; /* Address of the OpenEphemeral instruction */
378 iPk
= pParse
->nMem
+1;
380 regKey
= ++pParse
->nMem
;
381 iEph
= pParse
->nTab
++;
382 sqlite3VdbeAddOp2(v
, OP_Null
, 0, iPk
);
383 addrOpen
= sqlite3VdbeAddOp2(v
, OP_OpenEphemeral
, iEph
, nPk
);
384 sqlite3VdbeSetP4KeyInfo(pParse
, pPk
);
385 pWInfo
= sqlite3WhereBegin(pParse
, pTabList
, pWhere
, 0, 0,
386 WHERE_ONEPASS_DESIRED
, iIdxCur
);
387 if( pWInfo
==0 ) goto update_cleanup
;
388 okOnePass
= sqlite3WhereOkOnePass(pWInfo
, aiCurOnePass
);
389 for(i
=0; i
<nPk
; i
++){
390 assert( pPk
->aiColumn
[i
]>=0 );
391 sqlite3ExprCodeGetColumnOfTable(v
, pTab
, iDataCur
, pPk
->aiColumn
[i
],
395 sqlite3VdbeChangeToNoop(v
, addrOpen
);
399 sqlite3VdbeAddOp4(v
, OP_MakeRecord
, iPk
, nPk
, regKey
,
400 sqlite3IndexAffinityStr(db
, pPk
), nPk
);
401 sqlite3VdbeAddOp2(v
, OP_IdxInsert
, iEph
, regKey
);
403 sqlite3WhereEnd(pWInfo
);
406 /* Initialize the count of updated rows
408 if( (db
->flags
& SQLITE_CountRows
) && !pParse
->pTriggerTab
){
409 regRowCount
= ++pParse
->nMem
;
410 sqlite3VdbeAddOp2(v
, OP_Integer
, 0, regRowCount
);
413 labelBreak
= sqlite3VdbeMakeLabel(v
);
416 ** Open every index that needs updating. Note that if any
417 ** index could potentially invoke a REPLACE conflict resolution
418 ** action, then we need to open all indices because we might need
419 ** to be deleting some records.
421 if( onError
==OE_Replace
){
422 memset(aToOpen
, 1, nIdx
+1);
424 for(pIdx
=pTab
->pIndex
; pIdx
; pIdx
=pIdx
->pNext
){
425 if( pIdx
->onError
==OE_Replace
){
426 memset(aToOpen
, 1, nIdx
+1);
432 if( aiCurOnePass
[0]>=0 ) aToOpen
[aiCurOnePass
[0]-iBaseCur
] = 0;
433 if( aiCurOnePass
[1]>=0 ) aToOpen
[aiCurOnePass
[1]-iBaseCur
] = 0;
435 sqlite3OpenTableAndIndices(pParse
, pTab
, OP_OpenWrite
, 0, iBaseCur
, aToOpen
,
439 /* Top of the update loop */
441 if( aToOpen
[iDataCur
-iBaseCur
] && !isView
){
443 sqlite3VdbeAddOp4Int(v
, OP_NotFound
, iDataCur
, labelBreak
, regKey
, nKey
);
444 VdbeCoverageNeverTaken(v
);
446 labelContinue
= labelBreak
;
447 sqlite3VdbeAddOp2(v
, OP_IsNull
, pPk
? regKey
: regOldRowid
, labelBreak
);
448 VdbeCoverageIf(v
, pPk
==0);
449 VdbeCoverageIf(v
, pPk
!=0);
451 labelContinue
= sqlite3VdbeMakeLabel(v
);
452 sqlite3VdbeAddOp2(v
, OP_Rewind
, iEph
, labelBreak
); VdbeCoverage(v
);
453 addrTop
= sqlite3VdbeAddOp2(v
, OP_RowKey
, iEph
, regKey
);
454 sqlite3VdbeAddOp4Int(v
, OP_NotFound
, iDataCur
, labelContinue
, regKey
, 0);
457 labelContinue
= sqlite3VdbeAddOp3(v
, OP_RowSetRead
, regRowSet
, labelBreak
,
460 sqlite3VdbeAddOp3(v
, OP_NotExists
, iDataCur
, labelContinue
, regOldRowid
);
464 /* If the record number will change, set register regNewRowid to
465 ** contain the new value. If the record number is not being modified,
466 ** then regNewRowid is the same register as regOldRowid, which is
467 ** already populated. */
468 assert( chngKey
|| pTrigger
|| hasFK
|| regOldRowid
==regNewRowid
);
470 sqlite3ExprCode(pParse
, pRowidExpr
, regNewRowid
);
471 sqlite3VdbeAddOp1(v
, OP_MustBeInt
, regNewRowid
); VdbeCoverage(v
);
474 /* Compute the old pre-UPDATE content of the row being changed, if that
475 ** information is needed */
476 if( chngPk
|| hasFK
|| pTrigger
){
477 u32 oldmask
= (hasFK
? sqlite3FkOldmask(pParse
, pTab
) : 0);
478 oldmask
|= sqlite3TriggerColmask(pParse
,
479 pTrigger
, pChanges
, 0, TRIGGER_BEFORE
|TRIGGER_AFTER
, pTab
, onError
481 for(i
=0; i
<pTab
->nCol
; i
++){
482 if( oldmask
==0xffffffff
483 || (i
<32 && (oldmask
& MASKBIT32(i
))!=0)
484 || (pTab
->aCol
[i
].colFlags
& COLFLAG_PRIMKEY
)!=0
486 testcase( oldmask
!=0xffffffff && i
==31 );
487 sqlite3ExprCodeGetColumnOfTable(v
, pTab
, iDataCur
, i
, regOld
+i
);
489 sqlite3VdbeAddOp2(v
, OP_Null
, 0, regOld
+i
);
492 if( chngRowid
==0 && pPk
==0 ){
493 sqlite3VdbeAddOp2(v
, OP_Copy
, regOldRowid
, regNewRowid
);
497 /* Populate the array of registers beginning at regNew with the new
498 ** row data. This array is used to check constants, create the new
499 ** table and index records, and as the values for any new.* references
502 ** If there are one or more BEFORE triggers, then do not populate the
503 ** registers associated with columns that are (a) not modified by
504 ** this UPDATE statement and (b) not accessed by new.* references. The
505 ** values for registers not modified by the UPDATE must be reloaded from
506 ** the database after the BEFORE triggers are fired anyway (as the trigger
507 ** may have modified them). So not loading those that are not going to
508 ** be used eliminates some redundant opcodes.
510 newmask
= sqlite3TriggerColmask(
511 pParse
, pTrigger
, pChanges
, 1, TRIGGER_BEFORE
, pTab
, onError
513 for(i
=0; i
<pTab
->nCol
; i
++){
514 if( i
==pTab
->iPKey
){
515 sqlite3VdbeAddOp2(v
, OP_Null
, 0, regNew
+i
);
519 sqlite3ExprCode(pParse
, pChanges
->a
[j
].pExpr
, regNew
+i
);
520 }else if( 0==(tmask
&TRIGGER_BEFORE
) || i
>31 || (newmask
& MASKBIT32(i
)) ){
521 /* This branch loads the value of a column that will not be changed
522 ** into a register. This is done if there are no BEFORE triggers, or
523 ** if there are one or more BEFORE triggers that use this value via
524 ** a new.* reference in a trigger program.
528 sqlite3ExprCodeGetColumnToReg(pParse
, pTab
, i
, iDataCur
, regNew
+i
);
530 sqlite3VdbeAddOp2(v
, OP_Null
, 0, regNew
+i
);
535 /* Fire any BEFORE UPDATE triggers. This happens before constraints are
536 ** verified. One could argue that this is wrong.
538 if( tmask
&TRIGGER_BEFORE
){
539 sqlite3TableAffinity(v
, pTab
, regNew
);
540 sqlite3CodeRowTrigger(pParse
, pTrigger
, TK_UPDATE
, pChanges
,
541 TRIGGER_BEFORE
, pTab
, regOldRowid
, onError
, labelContinue
);
543 /* The row-trigger may have deleted the row being updated. In this
544 ** case, jump to the next row. No updates or AFTER triggers are
545 ** required. This behavior - what happens when the row being updated
546 ** is deleted or renamed by a BEFORE trigger - is left undefined in the
550 sqlite3VdbeAddOp4Int(v
, OP_NotFound
, iDataCur
, labelContinue
,regKey
,nKey
);
553 sqlite3VdbeAddOp3(v
, OP_NotExists
, iDataCur
, labelContinue
, regOldRowid
);
557 /* If it did not delete it, the row-trigger may still have modified
558 ** some of the columns of the row being updated. Load the values for
559 ** all columns not modified by the update statement into their
560 ** registers in case this has happened.
562 for(i
=0; i
<pTab
->nCol
; i
++){
563 if( aXRef
[i
]<0 && i
!=pTab
->iPKey
){
564 sqlite3ExprCodeGetColumnOfTable(v
, pTab
, iDataCur
, i
, regNew
+i
);
570 int addr1
= 0; /* Address of jump instruction */
571 int bReplace
= 0; /* True if REPLACE conflict resolution might happen */
573 /* Do constraint checks. */
574 assert( regOldRowid
>0 );
575 sqlite3GenerateConstraintChecks(pParse
, pTab
, aRegIdx
, iDataCur
, iIdxCur
,
576 regNewRowid
, regOldRowid
, chngKey
, onError
, labelContinue
, &bReplace
,
579 /* Do FK constraint checks. */
581 sqlite3FkCheck(pParse
, pTab
, regOldRowid
, 0, aXRef
, chngKey
);
584 /* Delete the index entries associated with the current record. */
585 if( bReplace
|| chngKey
){
587 addr1
= sqlite3VdbeAddOp4Int(v
, OP_NotFound
, iDataCur
, 0, regKey
, nKey
);
589 addr1
= sqlite3VdbeAddOp3(v
, OP_NotExists
, iDataCur
, 0, regOldRowid
);
591 VdbeCoverageNeverTaken(v
);
593 sqlite3GenerateRowIndexDelete(pParse
, pTab
, iDataCur
, iIdxCur
, aRegIdx
, -1);
595 /* If changing the rowid value, or if there are foreign key constraints
596 ** to process, delete the old record. Otherwise, add a noop OP_Delete
597 ** to invoke the pre-update hook.
599 ** That (regNew==regnewRowid+1) is true is also important for the
600 ** pre-update hook. If the caller invokes preupdate_new(), the returned
601 ** value is copied from memory cell (regNewRowid+1+iCol), where iCol
602 ** is the column index supplied by the user.
604 assert( regNew
==regNewRowid
+1 );
605 #ifdef SQLITE_ENABLE_PREUPDATE_HOOK
606 sqlite3VdbeAddOp3(v
, OP_Delete
, iDataCur
,
607 OPFLAG_ISUPDATE
| ((hasFK
|| chngKey
|| pPk
!=0) ? 0 : OPFLAG_ISNOOP
),
610 if( !pParse
->nested
){
611 sqlite3VdbeChangeP4(v
, -1, (char*)pTab
, P4_TABLE
);
614 if( hasFK
|| chngKey
|| pPk
!=0 ){
615 sqlite3VdbeAddOp2(v
, OP_Delete
, iDataCur
, 0);
618 if( bReplace
|| chngKey
){
619 sqlite3VdbeJumpHere(v
, addr1
);
623 sqlite3FkCheck(pParse
, pTab
, 0, regNewRowid
, aXRef
, chngKey
);
626 /* Insert the new index entries and the new record. */
627 sqlite3CompleteInsertion(pParse
, pTab
, iDataCur
, iIdxCur
,
628 regNewRowid
, aRegIdx
, 1, 0, 0);
630 /* Do any ON CASCADE, SET NULL or SET DEFAULT operations required to
631 ** handle rows (possibly in other tables) that refer via a foreign key
632 ** to the row just updated. */
634 sqlite3FkActions(pParse
, pTab
, pChanges
, regOldRowid
, aXRef
, chngKey
);
638 /* Increment the row counter
640 if( (db
->flags
& SQLITE_CountRows
) && !pParse
->pTriggerTab
){
641 sqlite3VdbeAddOp2(v
, OP_AddImm
, regRowCount
, 1);
644 sqlite3CodeRowTrigger(pParse
, pTrigger
, TK_UPDATE
, pChanges
,
645 TRIGGER_AFTER
, pTab
, regOldRowid
, onError
, labelContinue
);
647 /* Repeat the above with the next record to be updated, until
648 ** all record selected by the WHERE clause have been updated.
651 /* Nothing to do at end-of-loop for a single-pass */
653 sqlite3VdbeResolveLabel(v
, labelContinue
);
654 sqlite3VdbeAddOp2(v
, OP_Next
, iEph
, addrTop
); VdbeCoverage(v
);
656 sqlite3VdbeGoto(v
, labelContinue
);
658 sqlite3VdbeResolveLabel(v
, labelBreak
);
660 /* Close all tables */
661 for(i
=0, pIdx
=pTab
->pIndex
; pIdx
; pIdx
=pIdx
->pNext
, i
++){
664 sqlite3VdbeAddOp2(v
, OP_Close
, iIdxCur
+i
, 0);
667 if( iDataCur
<iIdxCur
) sqlite3VdbeAddOp2(v
, OP_Close
, iDataCur
, 0);
669 /* Update the sqlite_sequence table by storing the content of the
670 ** maximum rowid counter values recorded while inserting into
671 ** autoincrement tables.
673 if( pParse
->nested
==0 && pParse
->pTriggerTab
==0 ){
674 sqlite3AutoincrementEnd(pParse
);
678 ** Return the number of rows that were changed. If this routine is
679 ** generating code because of a call to sqlite3NestedParse(), do not
680 ** invoke the callback function.
682 if( (db
->flags
&SQLITE_CountRows
) && !pParse
->pTriggerTab
&& !pParse
->nested
){
683 sqlite3VdbeAddOp2(v
, OP_ResultRow
, regRowCount
, 1);
684 sqlite3VdbeSetNumCols(v
, 1);
685 sqlite3VdbeSetColName(v
, 0, COLNAME_NAME
, "rows updated", SQLITE_STATIC
);
689 sqlite3AuthContextPop(&sContext
);
690 sqlite3DbFree(db
, aXRef
); /* Also frees aRegIdx[] and aToOpen[] */
691 sqlite3SrcListDelete(db
, pTabList
);
692 sqlite3ExprListDelete(db
, pChanges
);
693 sqlite3ExprDelete(db
, pWhere
);
696 /* Make sure "isView" and other macros defined above are undefined. Otherwise
697 ** they may interfere with compilation of other functions in this file
698 ** (or in another file, if this file becomes part of the amalgamation). */
706 #ifndef SQLITE_OMIT_VIRTUALTABLE
708 ** Generate code for an UPDATE of a virtual table.
710 ** There are two possible strategies - the default and the special
711 ** "onepass" strategy. Onepass is only used if the virtual table
712 ** implementation indicates that pWhere may match at most one row.
714 ** The default strategy is to create an ephemeral table that contains
715 ** for each row to be changed:
717 ** (A) The original rowid of that row.
718 ** (B) The revised rowid for the row.
719 ** (C) The content of every column in the row.
721 ** Then loop through the contents of this ephemeral table executing a
722 ** VUpdate for each row. When finished, drop the ephemeral table.
724 ** The "onepass" strategy does not use an ephemeral table. Instead, it
725 ** stores the same values (A, B and C above) in a register array and
726 ** makes a single invocation of VUpdate.
728 static void updateVirtualTable(
729 Parse
*pParse
, /* The parsing context */
730 SrcList
*pSrc
, /* The virtual table to be modified */
731 Table
*pTab
, /* The virtual table */
732 ExprList
*pChanges
, /* The columns to change in the UPDATE statement */
733 Expr
*pRowid
, /* Expression used to recompute the rowid */
734 int *aXRef
, /* Mapping from columns of pTab to entries in pChanges */
735 Expr
*pWhere
, /* WHERE clause of the UPDATE statement */
736 int onError
/* ON CONFLICT strategy */
738 Vdbe
*v
= pParse
->pVdbe
; /* Virtual machine under construction */
739 int ephemTab
; /* Table holding the result of the SELECT */
740 int i
; /* Loop counter */
741 sqlite3
*db
= pParse
->db
; /* Database connection */
742 const char *pVTab
= (const char*)sqlite3GetVTable(db
, pTab
);
744 int nArg
= 2 + pTab
->nCol
; /* Number of arguments to VUpdate */
745 int regArg
; /* First register in VUpdate arg array */
746 int regRec
; /* Register in which to assemble record */
747 int regRowid
; /* Register for ephem table rowid */
748 int iCsr
= pSrc
->a
[0].iCursor
; /* Cursor used for virtual table scan */
749 int aDummy
[2]; /* Unused arg for sqlite3WhereOkOnePass() */
750 int bOnePass
; /* True to use onepass strategy */
751 int addr
; /* Address of OP_OpenEphemeral */
753 /* Allocate nArg registers to martial the arguments to VUpdate. Then
754 ** create and open the ephemeral table in which the records created from
755 ** these arguments will be temporarily stored. */
757 ephemTab
= pParse
->nTab
++;
758 addr
= sqlite3VdbeAddOp2(v
, OP_OpenEphemeral
, ephemTab
, nArg
);
759 regArg
= pParse
->nMem
+ 1;
760 pParse
->nMem
+= nArg
;
761 regRec
= ++pParse
->nMem
;
762 regRowid
= ++pParse
->nMem
;
764 /* Start scanning the virtual table */
765 pWInfo
= sqlite3WhereBegin(pParse
, pSrc
, pWhere
, 0,0,WHERE_ONEPASS_DESIRED
,0);
766 if( pWInfo
==0 ) return;
768 /* Populate the argument registers. */
769 sqlite3VdbeAddOp2(v
, OP_Rowid
, iCsr
, regArg
);
771 sqlite3ExprCode(pParse
, pRowid
, regArg
+1);
773 sqlite3VdbeAddOp2(v
, OP_Rowid
, iCsr
, regArg
+1);
775 for(i
=0; i
<pTab
->nCol
; i
++){
777 sqlite3ExprCode(pParse
, pChanges
->a
[aXRef
[i
]].pExpr
, regArg
+2+i
);
779 sqlite3VdbeAddOp3(v
, OP_VColumn
, iCsr
, i
, regArg
+2+i
);
783 bOnePass
= sqlite3WhereOkOnePass(pWInfo
, aDummy
);
786 /* If using the onepass strategy, no-op out the OP_OpenEphemeral coded
787 ** above. Also, if this is a top-level parse (not a trigger), clear the
788 ** multi-write flag so that the VM does not open a statement journal */
789 sqlite3VdbeChangeToNoop(v
, addr
);
790 if( sqlite3IsToplevel(pParse
) ){
791 pParse
->isMultiWrite
= 0;
794 /* Create a record from the argument register contents and insert it into
795 ** the ephemeral table. */
796 sqlite3VdbeAddOp3(v
, OP_MakeRecord
, regArg
, nArg
, regRec
);
797 sqlite3VdbeAddOp2(v
, OP_NewRowid
, ephemTab
, regRowid
);
798 sqlite3VdbeAddOp3(v
, OP_Insert
, ephemTab
, regRec
, regRowid
);
803 /* End the virtual table scan */
804 sqlite3WhereEnd(pWInfo
);
806 /* Begin scannning through the ephemeral table. */
807 addr
= sqlite3VdbeAddOp1(v
, OP_Rewind
, ephemTab
); VdbeCoverage(v
);
809 /* Extract arguments from the current row of the ephemeral table and
810 ** invoke the VUpdate method. */
811 for(i
=0; i
<nArg
; i
++){
812 sqlite3VdbeAddOp3(v
, OP_Column
, ephemTab
, i
, regArg
+i
);
815 sqlite3VtabMakeWritable(pParse
, pTab
);
816 sqlite3VdbeAddOp4(v
, OP_VUpdate
, 0, nArg
, regArg
, pVTab
, P4_VTAB
);
817 sqlite3VdbeChangeP5(v
, onError
==OE_Default
? OE_Abort
: onError
);
818 sqlite3MayAbort(pParse
);
820 /* End of the ephemeral table scan. Or, if using the onepass strategy,
821 ** jump to here if the scan visited zero rows. */
823 sqlite3VdbeAddOp2(v
, OP_Next
, ephemTab
, addr
+1); VdbeCoverage(v
);
824 sqlite3VdbeJumpHere(v
, addr
);
825 sqlite3VdbeAddOp2(v
, OP_Close
, ephemTab
, 0);
827 sqlite3WhereEnd(pWInfo
);
830 #endif /* SQLITE_OMIT_VIRTUALTABLE */