blob: dd2b05c3e60501bdc0118951e5ee08b7a70de826 [file] [log] [blame]
drhcce7d172000-05-31 15:34:51 +00001/*
drhb19a2bc2001-09-16 00:13:26 +00002** 2001 September 15
drhcce7d172000-05-31 15:34:51 +00003**
drhb19a2bc2001-09-16 00:13:26 +00004** The author disclaims copyright to this source code. In place of
5** a legal notice, here is a blessing:
drhcce7d172000-05-31 15:34:51 +00006**
drhb19a2bc2001-09-16 00:13:26 +00007** 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.
drhcce7d172000-05-31 15:34:51 +000010**
drha3388cc2010-07-30 16:54:25 +000011*************************************************************************
drhcce7d172000-05-31 15:34:51 +000012** This file contains C code routines that are called by the parser
13** to handle UPDATE statements.
drhcce7d172000-05-31 15:34:51 +000014*/
15#include "sqliteInt.h"
16
drhedb193b2006-06-27 13:20:21 +000017#ifndef SQLITE_OMIT_VIRTUALTABLE
drh9c419382006-06-16 21:13:21 +000018/* Forward declaration */
19static 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 */
danb061d052011-04-25 18:49:57 +000026 Expr *pWhere, /* WHERE clause of the UPDATE statement */
27 int onError /* ON CONFLICT strategy */
drh9c419382006-06-16 21:13:21 +000028);
drhedb193b2006-06-27 13:20:21 +000029#endif /* SQLITE_OMIT_VIRTUALTABLE */
drh9c419382006-06-16 21:13:21 +000030
drhcce7d172000-05-31 15:34:51 +000031/*
drh8a512562005-11-14 22:29:05 +000032** The most recently coded instruction was an OP_Column to retrieve the
drh66a51672008-01-03 00:01:23 +000033** i-th column of table pTab. This routine sets the P4 parameter of the
danielk1977aee18ef2005-03-09 12:26:50 +000034** 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
drh66a51672008-01-03 00:01:23 +000041** from the P4 parameter of the OP_Column instruction, is returned instead.
danielk1977aee18ef2005-03-09 12:26:50 +000042** If the former, then all row-records are guaranteed to include a value
drh66a51672008-01-03 00:01:23 +000043** for the column and the P4 value is not required.
danielk1977aee18ef2005-03-09 12:26:50 +000044**
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**
drh66a51672008-01-03 00:01:23 +000051** Therefore, the P4 parameter is only required if the default value for
danielk1977aee18ef2005-03-09 12:26:50 +000052** 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.
danielk1977c7538b52009-07-27 10:05:04 +000055**
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.
danielk1977aee18ef2005-03-09 12:26:50 +000060*/
danielk1977c7538b52009-07-27 10:05:04 +000061void sqlite3ColumnDefault(Vdbe *v, Table *pTab, int i, int iReg){
drhe289d602009-05-05 15:46:09 +000062 assert( pTab!=0 );
63 if( !pTab->pSelect ){
dan7a419232013-08-06 20:01:43 +000064 sqlite3_value *pValue = 0;
danielk197714db2662006-01-09 16:12:04 +000065 u8 enc = ENC(sqlite3VdbeDb(v));
danielk1977aee18ef2005-03-09 12:26:50 +000066 Column *pCol = &pTab->aCol[i];
drhd4e70eb2008-01-02 00:34:36 +000067 VdbeComment((v, "%s.%s", pTab->zName, pCol->zName));
danielk1977c9cf6e32007-06-25 16:29:33 +000068 assert( i<pTab->nCol );
drhd4e70eb2008-01-02 00:34:36 +000069 sqlite3ValueFromExpr(sqlite3VdbeDb(v), pCol->pDflt, enc,
70 pCol->affinity, &pValue);
drh29dda4a2005-07-21 18:23:20 +000071 if( pValue ){
drhf14b7fb2016-12-07 21:35:55 +000072 sqlite3VdbeAppendP4(v, pValue, P4_MEM);
drh29dda4a2005-07-21 18:23:20 +000073 }
danielk1977aee18ef2005-03-09 12:26:50 +000074 }
drhda060052017-01-16 16:43:02 +000075#ifndef SQLITE_OMIT_FLOATING_POINT
76 if( pTab->aCol[i].affinity==SQLITE_AFF_REAL ){
77 sqlite3VdbeAddOp1(v, OP_RealAffinity, iReg);
78 }
79#endif
danielk1977aee18ef2005-03-09 12:26:50 +000080}
81
82/*
drhe9816d82018-09-15 21:38:48 +000083** Check to see if column iCol of index pIdx references any of the
84** columns defined by aXRef and chngRowid. Return true if it does
drh40b4e7a2018-09-17 20:47:38 +000085** and false if not. This is an optimization. False-positives are a
86** performance degradation, but false-negatives can result in a corrupt
87** index and incorrect answers.
drhe9816d82018-09-15 21:38:48 +000088**
drhe9816d82018-09-15 21:38:48 +000089** aXRef[j] will be non-negative if column j of the original table is
90** being updated. chngRowid will be true if the rowid of the table is
91** being updated.
92*/
drh2b7cdf62018-09-16 15:01:25 +000093static int indexColumnIsBeingUpdated(
94 Index *pIdx, /* The index to check */
95 int iCol, /* Which column of the index to check */
drhe9816d82018-09-15 21:38:48 +000096 int *aXRef, /* aXRef[j]>=0 if column j is being updated */
97 int chngRowid /* true if the rowid is being updated */
98){
drh2b7cdf62018-09-16 15:01:25 +000099 i16 iIdxCol = pIdx->aiColumn[iCol];
drh86f34922018-09-16 18:23:48 +0000100 assert( iIdxCol!=XN_ROWID ); /* Cannot index rowid */
drh2b7cdf62018-09-16 15:01:25 +0000101 if( iIdxCol>=0 ){
102 return aXRef[iIdxCol]>=0;
103 }
drh2b7cdf62018-09-16 15:01:25 +0000104 assert( iIdxCol==XN_EXPR );
drhe9816d82018-09-15 21:38:48 +0000105 assert( pIdx->aColExpr!=0 );
106 assert( pIdx->aColExpr->a[iCol].pExpr!=0 );
107 return sqlite3ExprReferencesUpdatedColumn(pIdx->aColExpr->a[iCol].pExpr,
108 aXRef,chngRowid);
109}
110
111/*
drh40b4e7a2018-09-17 20:47:38 +0000112** Check to see if index pIdx is a partial index whose conditional
113** expression might change values due to an UPDATE. Return true if
114** the index is subject to change and false if the index is guaranteed
115** to be unchanged. This is an optimization. False-positives are a
116** performance degradation, but false-negatives can result in a corrupt
117** index and incorrect answers.
118**
119** aXRef[j] will be non-negative if column j of the original table is
120** being updated. chngRowid will be true if the rowid of the table is
121** being updated.
122*/
123static int indexWhereClauseMightChange(
124 Index *pIdx, /* The index to check */
125 int *aXRef, /* aXRef[j]>=0 if column j is being updated */
126 int chngRowid /* true if the rowid is being updated */
127){
128 if( pIdx->pPartIdxWhere==0 ) return 0;
129 return sqlite3ExprReferencesUpdatedColumn(pIdx->pPartIdxWhere,
130 aXRef, chngRowid);
131}
132
133/*
drhcce7d172000-05-31 15:34:51 +0000134** Process an UPDATE statement.
drhb2fe7d82003-04-20 17:29:23 +0000135**
136** UPDATE OR IGNORE table_wxyz SET a=b, c=d WHERE e<5 AND f NOT NULL;
137** \_______/ \________/ \______/ \________________/
138* onError pTabList pChanges pWhere
drhcce7d172000-05-31 15:34:51 +0000139*/
dan3b61ebb2017-11-10 20:13:14 +0000140void sqlite3Update(
drhcce7d172000-05-31 15:34:51 +0000141 Parse *pParse, /* The parser context */
drh113088e2003-03-20 01:16:58 +0000142 SrcList *pTabList, /* The table in which we should change things */
drhcce7d172000-05-31 15:34:51 +0000143 ExprList *pChanges, /* Things to be changed */
drh9cfcf5d2002-01-29 18:41:24 +0000144 Expr *pWhere, /* The WHERE clause. May be null */
danb3c16b82017-11-09 19:53:06 +0000145 int onError, /* How to handle constraint errors */
dan3b61ebb2017-11-10 20:13:14 +0000146 ExprList *pOrderBy, /* ORDER BY clause. May be null */
drheac9fab2018-04-16 13:00:50 +0000147 Expr *pLimit, /* LIMIT clause. May be null */
148 Upsert *pUpsert /* ON CONFLICT clause, or null */
drhcce7d172000-05-31 15:34:51 +0000149){
150 int i, j; /* Loop counters */
151 Table *pTab; /* The table to be updated */
drhc3e356f2013-11-04 18:34:46 +0000152 int addrTop = 0; /* VDBE instruction address of the start of the loop */
drhcce7d172000-05-31 15:34:51 +0000153 WhereInfo *pWInfo; /* Information about the WHERE clause */
154 Vdbe *v; /* The virtual database engine */
155 Index *pIdx; /* For looping over indices */
drhea22abe2013-10-25 19:17:17 +0000156 Index *pPk; /* The PRIMARY KEY index for WITHOUT ROWID tables */
drhcce7d172000-05-31 15:34:51 +0000157 int nIdx; /* Number of indices that need updating */
drh6a534992013-11-16 20:13:39 +0000158 int iBaseCur; /* Base cursor number */
drh77f64bb2013-10-31 12:13:37 +0000159 int iDataCur; /* Cursor for the canonical data btree */
160 int iIdxCur; /* Cursor for the first index */
drh9bb575f2004-09-06 17:24:11 +0000161 sqlite3 *db; /* The database structure */
danf91c1312017-01-10 20:04:38 +0000162 int *aRegIdx = 0; /* First register in array assigned to each index */
drhcce7d172000-05-31 15:34:51 +0000163 int *aXRef = 0; /* aXRef[i] is the index in pChanges->a[] of the
drh967e8b72000-06-21 13:59:10 +0000164 ** an expression for the i-th column of the table.
165 ** aXRef[i]==-1 if the i-th column is not changed. */
drh6a534992013-11-16 20:13:39 +0000166 u8 *aToOpen; /* 1 for tables and indices to be opened */
drhf8ffb272013-11-01 17:08:56 +0000167 u8 chngPk; /* PRIMARY KEY changed in a WITHOUT ROWID table */
168 u8 chngRowid; /* Rowid changed in a normal table */
169 u8 chngKey; /* Either chngPk or chngRowid */
drhf0863fe2005-06-12 21:35:51 +0000170 Expr *pRowidExpr = 0; /* Expression defining the new record number */
drh85e20962003-04-25 17:52:11 +0000171 AuthContext sContext; /* The authorization context */
danielk1977b3bce662005-01-29 08:32:43 +0000172 NameContext sNC; /* The name-context to resolve expressions in */
danielk1977da184232006-01-05 11:34:32 +0000173 int iDb; /* Database containing the table being updated */
danf91c1312017-01-10 20:04:38 +0000174 int eOnePass; /* ONEPASS_XXX value from where.c */
dan1da40a32009-09-19 17:00:31 +0000175 int hasFK; /* True if foreign key processing is required */
drhea22abe2013-10-25 19:17:17 +0000176 int labelBreak; /* Jump here to break out of UPDATE loop */
177 int labelContinue; /* Jump here to continue next step of UPDATE loop */
danf91c1312017-01-10 20:04:38 +0000178 int flags; /* Flags for sqlite3WhereBegin() */
drhcce7d172000-05-31 15:34:51 +0000179
drh798da522004-11-04 04:42:28 +0000180#ifndef SQLITE_OMIT_TRIGGER
danbb5f1682009-11-27 12:12:34 +0000181 int isView; /* True when updating a view (INSTEAD OF trigger) */
182 Trigger *pTrigger; /* List of triggers on pTab, if required */
183 int tmask; /* Mask of TRIGGER_BEFORE|TRIGGER_AFTER */
drh798da522004-11-04 04:42:28 +0000184#endif
drhfd7c9912009-12-01 22:09:25 +0000185 int newmask; /* Mask of NEW.* columns accessed by BEFORE triggers */
drhea22abe2013-10-25 19:17:17 +0000186 int iEph = 0; /* Ephemeral table holding all primary key values */
drh00f91cf2013-11-07 21:32:16 +0000187 int nKey = 0; /* Number of elements in regKey for WITHOUT ROWID */
drhfc8d4f92013-11-08 15:19:46 +0000188 int aiCurOnePass[2]; /* The write cursors opened by WHERE_ONEPASS */
drhae051a82017-01-12 16:21:54 +0000189 int addrOpen = 0; /* Address of OP_OpenEphemeral */
190 int iPk = 0; /* First of nPk cells holding PRIMARY KEY value */
191 i16 nPk = 0; /* Number of components of the PRIMARY KEY */
dan2c6fec22017-01-11 19:03:08 +0000192 int bReplace = 0; /* True if REPLACE conflict resolution might happen */
danielk1977c3f9bad2002-05-15 08:30:12 +0000193
drh04adf412008-01-08 18:57:50 +0000194 /* Register Allocations */
195 int regRowCount = 0; /* A count of rows changed */
drh94f26a12015-09-29 12:32:56 +0000196 int regOldRowid = 0; /* The old rowid */
197 int regNewRowid = 0; /* The new rowid */
198 int regNew = 0; /* Content of the NEW.* table in triggers */
drhb8475df2011-12-09 16:21:19 +0000199 int regOld = 0; /* Content of OLD.* table in triggers */
drh4f21c4a2008-12-10 22:15:00 +0000200 int regRowSet = 0; /* Rowset of rows to be updated */
drhea22abe2013-10-25 19:17:17 +0000201 int regKey = 0; /* composite PRIMARY KEY value */
drh04adf412008-01-08 18:57:50 +0000202
drheeb844a2009-08-08 18:01:07 +0000203 memset(&sContext, 0, sizeof(sContext));
drh17435752007-08-16 04:30:38 +0000204 db = pParse->db;
205 if( pParse->nErr || db->mallocFailed ){
drh6f7adc82006-01-11 21:41:20 +0000206 goto update_cleanup;
207 }
drh113088e2003-03-20 01:16:58 +0000208 assert( pTabList->nSrc==1 );
drhdaffd0e2001-04-11 14:28:42 +0000209
drhb2fe7d82003-04-20 17:29:23 +0000210 /* Locate the table which we want to update.
drhcce7d172000-05-31 15:34:51 +0000211 */
danielk19774adee202004-05-08 08:23:19 +0000212 pTab = sqlite3SrcListLookup(pParse, pTabList);
drha69d9162003-04-17 22:57:53 +0000213 if( pTab==0 ) goto update_cleanup;
danielk1977da184232006-01-05 11:34:32 +0000214 iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
drhb7f91642004-10-31 02:22:47 +0000215
216 /* Figure out if we have any triggers and if the table being
dan76d462e2009-08-30 11:42:51 +0000217 ** updated is a view.
drhb7f91642004-10-31 02:22:47 +0000218 */
219#ifndef SQLITE_OMIT_TRIGGER
danbb5f1682009-11-27 12:12:34 +0000220 pTrigger = sqlite3TriggersExist(pParse, pTab, TK_UPDATE, pChanges, &tmask);
drh5cf590c2003-04-24 01:45:04 +0000221 isView = pTab->pSelect!=0;
danbb5f1682009-11-27 12:12:34 +0000222 assert( pTrigger || tmask==0 );
drhb7f91642004-10-31 02:22:47 +0000223#else
danielk19772f886d12009-02-28 10:47:41 +0000224# define pTrigger 0
drhb7f91642004-10-31 02:22:47 +0000225# define isView 0
danbb5f1682009-11-27 12:12:34 +0000226# define tmask 0
drhb7f91642004-10-31 02:22:47 +0000227#endif
228#ifdef SQLITE_OMIT_VIEW
229# undef isView
230# define isView 0
231#endif
232
danb3c16b82017-11-09 19:53:06 +0000233#ifdef SQLITE_ENABLE_UPDATE_DELETE_LIMIT
234 if( !isView ){
235 pWhere = sqlite3LimitWhere(
drh8c0833f2017-11-14 23:48:23 +0000236 pParse, pTabList, pWhere, pOrderBy, pLimit, "UPDATE"
danb3c16b82017-11-09 19:53:06 +0000237 );
238 pOrderBy = 0;
drh8c0833f2017-11-14 23:48:23 +0000239 pLimit = 0;
danb3c16b82017-11-09 19:53:06 +0000240 }
241#endif
242
danielk1977595a5232009-07-24 17:58:53 +0000243 if( sqlite3ViewGetColumnNames(pParse, pTab) ){
drh5cf590c2003-04-24 01:45:04 +0000244 goto update_cleanup;
drha69d9162003-04-17 22:57:53 +0000245 }
danbb5f1682009-11-27 12:12:34 +0000246 if( sqlite3IsReadOnly(pParse, pTab, tmask) ){
danielk1977b3d24bf2006-06-19 03:05:10 +0000247 goto update_cleanup;
drh5cf590c2003-04-24 01:45:04 +0000248 }
drhcce7d172000-05-31 15:34:51 +0000249
drh53e3fc72002-07-16 17:22:50 +0000250 /* Allocate a cursors for the main database table and for all indices.
251 ** The index cursors might not be used, but if they are used they
252 ** need to occur right after the database cursor. So go ahead and
253 ** allocate enough space, just in case.
254 */
drh2ac4e5c2018-04-20 00:40:19 +0000255 iBaseCur = iDataCur = pParse->nTab++;
drh313619f2013-10-31 20:34:06 +0000256 iIdxCur = iDataCur+1;
drh77f64bb2013-10-31 12:13:37 +0000257 pPk = HasRowid(pTab) ? 0 : sqlite3PrimaryKeyIndex(pTab);
drh2ac4e5c2018-04-20 00:40:19 +0000258 testcase( pPk!=0 && pPk!=pTab->pIndex );
drh77f64bb2013-10-31 12:13:37 +0000259 for(nIdx=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, nIdx++){
drh2ac4e5c2018-04-20 00:40:19 +0000260 if( pPk==pIdx ){
drh313619f2013-10-31 20:34:06 +0000261 iDataCur = pParse->nTab;
drh313619f2013-10-31 20:34:06 +0000262 }
drh53e3fc72002-07-16 17:22:50 +0000263 pParse->nTab++;
264 }
drh7fc3aba2018-04-20 13:18:51 +0000265 if( pUpsert ){
drhfb2213e2018-04-20 15:56:24 +0000266 /* On an UPSERT, reuse the same cursors already opened by INSERT */
drh7fc3aba2018-04-20 13:18:51 +0000267 iDataCur = pUpsert->iDataCur;
268 iIdxCur = pUpsert->iIdxCur;
269 pParse->nTab = iBaseCur;
270 }
drh2ac4e5c2018-04-20 00:40:19 +0000271 pTabList->a[0].iCursor = iDataCur;
drh53e3fc72002-07-16 17:22:50 +0000272
drh6a534992013-11-16 20:13:39 +0000273 /* Allocate space for aXRef[], aRegIdx[], and aToOpen[].
274 ** Initialize aXRef[] and aToOpen[] to their default values.
275 */
drh575fad62016-02-05 13:38:36 +0000276 aXRef = sqlite3DbMallocRawNN(db, sizeof(int) * (pTab->nCol+nIdx) + nIdx+2 );
drh6a534992013-11-16 20:13:39 +0000277 if( aXRef==0 ) goto update_cleanup;
278 aRegIdx = aXRef+pTab->nCol;
279 aToOpen = (u8*)(aRegIdx+nIdx);
280 memset(aToOpen, 1, nIdx+1);
281 aToOpen[nIdx+1] = 0;
282 for(i=0; i<pTab->nCol; i++) aXRef[i] = -1;
283
danielk1977b3bce662005-01-29 08:32:43 +0000284 /* Initialize the name-context */
285 memset(&sNC, 0, sizeof(sNC));
286 sNC.pParse = pParse;
287 sNC.pSrcList = pTabList;
drheac9fab2018-04-16 13:00:50 +0000288 sNC.uNC.pUpsert = pUpsert;
289 sNC.ncFlags = NC_UUpsert;
danielk1977b3bce662005-01-29 08:32:43 +0000290
drh85e20962003-04-25 17:52:11 +0000291 /* Resolve the column names in all the expressions of the
292 ** of the UPDATE statement. Also find the column index
drhed6c8672003-01-12 18:02:16 +0000293 ** for each column to be updated in the pChanges array. For each
294 ** column to be updated, make sure we have authorization to change
295 ** that column.
drhcce7d172000-05-31 15:34:51 +0000296 */
drhf8ffb272013-11-01 17:08:56 +0000297 chngRowid = chngPk = 0;
drhcce7d172000-05-31 15:34:51 +0000298 for(i=0; i<pChanges->nExpr; i++){
drh7d10d5a2008-08-20 16:35:10 +0000299 if( sqlite3ResolveExprNames(&sNC, pChanges->a[i].pExpr) ){
drhcce7d172000-05-31 15:34:51 +0000300 goto update_cleanup;
301 }
302 for(j=0; j<pTab->nCol; j++){
danielk19774adee202004-05-08 08:23:19 +0000303 if( sqlite3StrICmp(pTab->aCol[j].zName, pChanges->a[i].zName)==0 ){
drh9647ff82002-01-14 02:56:24 +0000304 if( j==pTab->iPKey ){
drhf0863fe2005-06-12 21:35:51 +0000305 chngRowid = 1;
306 pRowidExpr = pChanges->a[i].pExpr;
drhf8ffb272013-11-01 17:08:56 +0000307 }else if( pPk && (pTab->aCol[j].colFlags & COLFLAG_PRIMKEY)!=0 ){
308 chngPk = 1;
drh4a324312001-12-21 14:30:42 +0000309 }
drhcce7d172000-05-31 15:34:51 +0000310 aXRef[j] = i;
311 break;
312 }
313 }
314 if( j>=pTab->nCol ){
drhea22abe2013-10-25 19:17:17 +0000315 if( pPk==0 && sqlite3IsRowid(pChanges->a[i].zName) ){
drh27228982013-05-06 13:22:50 +0000316 j = -1;
drhf0863fe2005-06-12 21:35:51 +0000317 chngRowid = 1;
318 pRowidExpr = pChanges->a[i].pExpr;
drha0217ba2003-06-01 01:10:33 +0000319 }else{
danielk19774adee202004-05-08 08:23:19 +0000320 sqlite3ErrorMsg(pParse, "no such column: %s", pChanges->a[i].zName);
dan1db95102010-06-28 10:15:19 +0000321 pParse->checkSchema = 1;
drha0217ba2003-06-01 01:10:33 +0000322 goto update_cleanup;
323 }
drhcce7d172000-05-31 15:34:51 +0000324 }
drhed6c8672003-01-12 18:02:16 +0000325#ifndef SQLITE_OMIT_AUTHORIZATION
drhe5f9c642003-01-13 23:27:31 +0000326 {
327 int rc;
danielk19774adee202004-05-08 08:23:19 +0000328 rc = sqlite3AuthCheck(pParse, SQLITE_UPDATE, pTab->zName,
drh27228982013-05-06 13:22:50 +0000329 j<0 ? "ROWID" : pTab->aCol[j].zName,
drh69c33822016-08-18 14:33:11 +0000330 db->aDb[iDb].zDbSName);
drhe5f9c642003-01-13 23:27:31 +0000331 if( rc==SQLITE_DENY ){
332 goto update_cleanup;
333 }else if( rc==SQLITE_IGNORE ){
334 aXRef[j] = -1;
335 }
drhed6c8672003-01-12 18:02:16 +0000336 }
337#endif
drhcce7d172000-05-31 15:34:51 +0000338 }
drhf8ffb272013-11-01 17:08:56 +0000339 assert( (chngRowid & chngPk)==0 );
340 assert( chngRowid==0 || chngRowid==1 );
341 assert( chngPk==0 || chngPk==1 );
342 chngKey = chngRowid + chngPk;
drhcce7d172000-05-31 15:34:51 +0000343
dan1acb5392015-11-26 19:33:41 +0000344 /* The SET expressions are not actually used inside the WHERE loop.
345 ** So reset the colUsed mask. Unless this is a virtual table. In that
346 ** case, set all bits of the colUsed mask (to ensure that the virtual
347 ** table implementation makes all columns available).
drh5c82f4d2013-11-19 02:34:11 +0000348 */
drh8426e362016-03-08 01:32:30 +0000349 pTabList->a[0].colUsed = IsVirtual(pTab) ? ALLBITS : 0;
drh5c82f4d2013-11-19 02:34:11 +0000350
drhf8ffb272013-11-01 17:08:56 +0000351 hasFK = sqlite3FkRequired(pParse, pTab, aXRef, chngKey);
dane7a94d82009-10-01 16:09:04 +0000352
drh6a534992013-11-16 20:13:39 +0000353 /* There is one entry in the aRegIdx[] array for each index on the table
354 ** being updated. Fill in aRegIdx[] with a register number that will hold
drh1f9ca2c2015-08-25 16:57:52 +0000355 ** the key for accessing each index.
drhcce7d172000-05-31 15:34:51 +0000356 */
drhaa9b8962008-01-08 02:57:55 +0000357 for(j=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, j++){
358 int reg;
drh40b4e7a2018-09-17 20:47:38 +0000359 if( chngKey || hasFK>1 || pIdx==pPk
360 || indexWhereClauseMightChange(pIdx,aXRef,chngRowid)
361 ){
drhaa9b8962008-01-08 02:57:55 +0000362 reg = ++pParse->nMem;
drh2c4dfc32016-11-10 14:24:04 +0000363 pParse->nMem += pIdx->nColumn;
drhaa9b8962008-01-08 02:57:55 +0000364 }else{
365 reg = 0;
drhf8ffb272013-11-01 17:08:56 +0000366 for(i=0; i<pIdx->nKeyCol; i++){
drh2b7cdf62018-09-16 15:01:25 +0000367 if( indexColumnIsBeingUpdated(pIdx, i, aXRef, chngRowid) ){
drhaa9b8962008-01-08 02:57:55 +0000368 reg = ++pParse->nMem;
drh2c4dfc32016-11-10 14:24:04 +0000369 pParse->nMem += pIdx->nColumn;
dan2c6fec22017-01-11 19:03:08 +0000370 if( (onError==OE_Replace)
371 || (onError==OE_Default && pIdx->onError==OE_Replace)
372 ){
373 bReplace = 1;
374 }
drhaa9b8962008-01-08 02:57:55 +0000375 break;
376 }
drh4a324312001-12-21 14:30:42 +0000377 }
drhcce7d172000-05-31 15:34:51 +0000378 }
drh6a534992013-11-16 20:13:39 +0000379 if( reg==0 ) aToOpen[j+1] = 0;
drhaa9b8962008-01-08 02:57:55 +0000380 aRegIdx[j] = reg;
drhcce7d172000-05-31 15:34:51 +0000381 }
dan2c6fec22017-01-11 19:03:08 +0000382 if( bReplace ){
383 /* If REPLACE conflict resolution might be invoked, open cursors on all
384 ** indexes in case they are needed to delete records. */
385 memset(aToOpen, 1, nIdx+1);
386 }
drhcce7d172000-05-31 15:34:51 +0000387
dan165921a2009-08-28 18:53:45 +0000388 /* Begin generating code. */
danielk19774adee202004-05-08 08:23:19 +0000389 v = sqlite3GetVdbe(pParse);
drhcce7d172000-05-31 15:34:51 +0000390 if( v==0 ) goto update_cleanup;
drh4794f732004-11-05 17:17:50 +0000391 if( pParse->nested==0 ) sqlite3VdbeCountChanges(v);
drhac9151d2018-04-20 19:32:35 +0000392 sqlite3BeginWriteOperation(pParse, pTrigger || hasFK, iDb);
drhcce7d172000-05-31 15:34:51 +0000393
dan165921a2009-08-28 18:53:45 +0000394 /* Allocate required registers. */
dan0f400372015-09-28 20:03:49 +0000395 if( !IsVirtual(pTab) ){
396 regRowSet = ++pParse->nMem;
397 regOldRowid = regNewRowid = ++pParse->nMem;
398 if( chngPk || pTrigger || hasFK ){
399 regOld = pParse->nMem + 1;
400 pParse->nMem += pTab->nCol;
401 }
402 if( chngKey || pTrigger || hasFK ){
403 regNewRowid = ++pParse->nMem;
404 }
405 regNew = pParse->nMem + 1;
dan165921a2009-08-28 18:53:45 +0000406 pParse->nMem += pTab->nCol;
407 }
dan165921a2009-08-28 18:53:45 +0000408
409 /* Start the view context. */
danielk19774273dea2006-06-17 06:31:18 +0000410 if( isView ){
411 sqlite3AuthContextPush(pParse, &sContext, pTab->zName);
412 }
413
drh9d2985c2005-09-08 01:58:42 +0000414 /* If we are trying to update a view, realize that view into
peter.d.reid60ec9142014-09-06 16:39:46 +0000415 ** an ephemeral table.
drh5cf590c2003-04-24 01:45:04 +0000416 */
shanefa4e62f2008-09-01 21:59:42 +0000417#if !defined(SQLITE_OMIT_VIEW) && !defined(SQLITE_OMIT_TRIGGER)
drh5cf590c2003-04-24 01:45:04 +0000418 if( isView ){
danb3c16b82017-11-09 19:53:06 +0000419 sqlite3MaterializeView(pParse, pTab,
drh8c0833f2017-11-14 23:48:23 +0000420 pWhere, pOrderBy, pLimit, iDataCur
danb3c16b82017-11-09 19:53:06 +0000421 );
422 pOrderBy = 0;
drh8c0833f2017-11-14 23:48:23 +0000423 pLimit = 0;
drh0f35a6b2008-02-12 16:52:14 +0000424 }
shanefa4e62f2008-09-01 21:59:42 +0000425#endif
drh1013c932008-01-06 00:25:21 +0000426
drh0f35a6b2008-02-12 16:52:14 +0000427 /* Resolve the column names in all the expressions in the
428 ** WHERE clause.
429 */
drh7d10d5a2008-08-20 16:35:10 +0000430 if( sqlite3ResolveExprNames(&sNC, pWhere) ){
drh0f35a6b2008-02-12 16:52:14 +0000431 goto update_cleanup;
drh5cf590c2003-04-24 01:45:04 +0000432 }
433
dan0f400372015-09-28 20:03:49 +0000434#ifndef SQLITE_OMIT_VIRTUALTABLE
435 /* Virtual tables must be handled separately */
436 if( IsVirtual(pTab) ){
437 updateVirtualTable(pParse, pTabList, pTab, pChanges, pRowidExpr, aXRef,
438 pWhere, onError);
439 goto update_cleanup;
440 }
441#endif
442
drhfb2213e2018-04-20 15:56:24 +0000443 /* Jump to labelBreak to abandon further processing of this UPDATE */
drh4b8bd842018-04-20 20:09:22 +0000444 labelContinue = labelBreak = sqlite3VdbeMakeLabel(v);
danf91c1312017-01-10 20:04:38 +0000445
drh5deb1812018-04-20 16:27:57 +0000446 /* Not an UPSERT. Normal processing. Begin by
447 ** initialize the count of updated rows */
448 if( (db->flags&SQLITE_CountRows)!=0
449 && !pParse->pTriggerTab
450 && !pParse->nested
451 && pUpsert==0
452 ){
453 regRowCount = ++pParse->nMem;
454 sqlite3VdbeAddOp2(v, OP_Integer, 0, regRowCount);
455 }
456
457 if( HasRowid(pTab) ){
458 sqlite3VdbeAddOp3(v, OP_Null, 0, regRowSet, regOldRowid);
459 }else{
460 assert( pPk!=0 );
461 nPk = pPk->nKeyCol;
462 iPk = pParse->nMem+1;
463 pParse->nMem += nPk;
464 regKey = ++pParse->nMem;
465 if( pUpsert==0 ){
466 iEph = pParse->nTab++;
467 sqlite3VdbeAddOp3(v, OP_Null, 0, iPk, iPk+nPk-1);
468 addrOpen = sqlite3VdbeAddOp2(v, OP_OpenEphemeral, iEph, nPk);
469 sqlite3VdbeSetP4KeyInfo(pParse, pPk);
470 }
471 }
472
drhfb2213e2018-04-20 15:56:24 +0000473 if( pUpsert ){
474 /* If this is an UPSERT, then all cursors have already been opened by
475 ** the outer INSERT and the data cursor should be pointing at the row
476 ** that is to be updated. So bypass the code that searches for the
477 ** row(s) to be updated.
478 */
479 pWInfo = 0;
480 eOnePass = ONEPASS_SINGLE;
drhfb2213e2018-04-20 15:56:24 +0000481 sqlite3ExprIfFalse(pParse, pWhere, labelBreak, SQLITE_JUMPIFNULL);
482 }else{
drhfb2213e2018-04-20 15:56:24 +0000483 /* Begin the database scan.
484 **
485 ** Do not consider a single-pass strategy for a multi-row update if
486 ** there are any triggers or foreign keys to process, or rows may
487 ** be deleted as a result of REPLACE conflict handling. Any of these
488 ** things might disturb a cursor being used to scan through the table
489 ** or index, causing a single-pass approach to malfunction. */
490 flags = WHERE_ONEPASS_DESIRED|WHERE_SEEK_UNIQ_TABLE;
491 if( !pParse->nested && !pTrigger && !hasFK && !chngKey && !bReplace ){
492 flags |= WHERE_ONEPASS_MULTIROW;
493 }
494 pWInfo = sqlite3WhereBegin(pParse, pTabList, pWhere, 0, 0, flags, iIdxCur);
495 if( pWInfo==0 ) goto update_cleanup;
496
497 /* A one-pass strategy that might update more than one row may not
498 ** be used if any column of the index used for the scan is being
499 ** updated. Otherwise, if there is an index on "b", statements like
500 ** the following could create an infinite loop:
501 **
502 ** UPDATE t1 SET b=b+1 WHERE b>?
503 **
504 ** Fall back to ONEPASS_OFF if where.c has selected a ONEPASS_MULTI
505 ** strategy that uses an index for which one or more columns are being
506 ** updated. */
507 eOnePass = sqlite3WhereOkOnePass(pWInfo, aiCurOnePass);
drhac9151d2018-04-20 19:32:35 +0000508 if( eOnePass!=ONEPASS_SINGLE ){
509 sqlite3MultiWrite(pParse);
510 if( eOnePass==ONEPASS_MULTI ){
511 int iCur = aiCurOnePass[1];
512 if( iCur>=0 && iCur!=iDataCur && aToOpen[iCur-iBaseCur] ){
513 eOnePass = ONEPASS_OFF;
514 }
515 assert( iCur!=iDataCur || !HasRowid(pTab) );
drhfb2213e2018-04-20 15:56:24 +0000516 }
drhfb2213e2018-04-20 15:56:24 +0000517 }
518 }
519
danf91c1312017-01-10 20:04:38 +0000520 if( HasRowid(pTab) ){
521 /* Read the rowid of the current row of the WHERE scan. In ONEPASS_OFF
522 ** mode, write the rowid into the FIFO. In either of the one-pass modes,
523 ** leave it in register regOldRowid. */
524 sqlite3VdbeAddOp2(v, OP_Rowid, iDataCur, regOldRowid);
525 if( eOnePass==ONEPASS_OFF ){
526 sqlite3VdbeAddOp2(v, OP_RowSetAdd, regRowSet, regOldRowid);
527 }
528 }else{
529 /* Read the PK of the current row into an array of registers. In
530 ** ONEPASS_OFF mode, serialize the array into a record and store it in
531 ** the ephemeral table. Or, in ONEPASS_SINGLE or MULTI mode, change
532 ** the OP_OpenEphemeral instruction to a Noop (the ephemeral table
533 ** is not required) and leave the PK fields in the array of registers. */
drhea22abe2013-10-25 19:17:17 +0000534 for(i=0; i<nPk; i++){
drh4b92f982015-09-29 17:20:14 +0000535 assert( pPk->aiColumn[i]>=0 );
danf91c1312017-01-10 20:04:38 +0000536 sqlite3ExprCodeGetColumnOfTable(v, pTab, iDataCur,pPk->aiColumn[i],iPk+i);
drhea22abe2013-10-25 19:17:17 +0000537 }
danf91c1312017-01-10 20:04:38 +0000538 if( eOnePass ){
drhfb2213e2018-04-20 15:56:24 +0000539 if( addrOpen ) sqlite3VdbeChangeToNoop(v, addrOpen);
drh702ba9f2013-11-07 21:25:13 +0000540 nKey = nPk;
541 regKey = iPk;
542 }else{
543 sqlite3VdbeAddOp4(v, OP_MakeRecord, iPk, nPk, regKey,
drhe9107692015-08-25 19:20:04 +0000544 sqlite3IndexAffinityStr(db, pPk), nPk);
drh9b4eaeb2016-11-09 00:10:33 +0000545 sqlite3VdbeAddOp4Int(v, OP_IdxInsert, iEph, regKey, iPk, nPk);
drh702ba9f2013-11-07 21:25:13 +0000546 }
drh3d4501e2008-12-04 20:40:10 +0000547 }
drhcce7d172000-05-31 15:34:51 +0000548
drhfb2213e2018-04-20 15:56:24 +0000549 if( pUpsert==0 ){
550 if( eOnePass!=ONEPASS_MULTI ){
551 sqlite3WhereEnd(pWInfo);
552 }
553
554 if( !isView ){
555 int addrOnce = 0;
556
557 /* Open every index that needs updating. */
558 if( eOnePass!=ONEPASS_OFF ){
559 if( aiCurOnePass[0]>=0 ) aToOpen[aiCurOnePass[0]-iBaseCur] = 0;
560 if( aiCurOnePass[1]>=0 ) aToOpen[aiCurOnePass[1]-iBaseCur] = 0;
561 }
562
563 if( eOnePass==ONEPASS_MULTI && (nIdx-(aiCurOnePass[1]>=0))>0 ){
564 addrOnce = sqlite3VdbeAddOp0(v, OP_Once); VdbeCoverage(v);
565 }
566 sqlite3OpenTableAndIndices(pParse, pTab, OP_OpenWrite, 0, iBaseCur,
567 aToOpen, 0, 0);
568 if( addrOnce ) sqlite3VdbeJumpHere(v, addrOnce);
569 }
570
571 /* Top of the update loop */
danf91c1312017-01-10 20:04:38 +0000572 if( eOnePass!=ONEPASS_OFF ){
drhfb2213e2018-04-20 15:56:24 +0000573 if( !isView && aiCurOnePass[0]!=iDataCur && aiCurOnePass[1]!=iDataCur ){
574 assert( pPk );
575 sqlite3VdbeAddOp4Int(v, OP_NotFound, iDataCur, labelBreak, regKey,nKey);
drh6ccbd272018-07-10 17:10:44 +0000576 VdbeCoverage(v);
drhfb2213e2018-04-20 15:56:24 +0000577 }
drh4b8bd842018-04-20 20:09:22 +0000578 if( eOnePass!=ONEPASS_SINGLE ){
drhfb2213e2018-04-20 15:56:24 +0000579 labelContinue = sqlite3VdbeMakeLabel(v);
580 }
581 sqlite3VdbeAddOp2(v, OP_IsNull, pPk ? regKey : regOldRowid, labelBreak);
582 VdbeCoverageIf(v, pPk==0);
583 VdbeCoverageIf(v, pPk!=0);
584 }else if( pPk ){
danf91c1312017-01-10 20:04:38 +0000585 labelContinue = sqlite3VdbeMakeLabel(v);
drhfb2213e2018-04-20 15:56:24 +0000586 sqlite3VdbeAddOp2(v, OP_Rewind, iEph, labelBreak); VdbeCoverage(v);
587 addrTop = sqlite3VdbeAddOp2(v, OP_RowData, iEph, regKey);
588 sqlite3VdbeAddOp4Int(v, OP_NotFound, iDataCur, labelContinue, regKey, 0);
589 VdbeCoverage(v);
590 }else{
591 labelContinue = sqlite3VdbeAddOp3(v, OP_RowSetRead, regRowSet,labelBreak,
592 regOldRowid);
593 VdbeCoverage(v);
594 sqlite3VdbeAddOp3(v, OP_NotExists, iDataCur, labelContinue, regOldRowid);
595 VdbeCoverage(v);
danf91c1312017-01-10 20:04:38 +0000596 }
drh08c88eb2008-04-10 13:33:18 +0000597 }
danielk1977e448dc42008-01-02 11:50:51 +0000598
drh70076402018-04-12 19:51:22 +0000599 /* If the rowid value will change, set register regNewRowid to
600 ** contain the new value. If the rowid is not being modified,
dan1da40a32009-09-19 17:00:31 +0000601 ** then regNewRowid is the same register as regOldRowid, which is
602 ** already populated. */
drhf8ffb272013-11-01 17:08:56 +0000603 assert( chngKey || pTrigger || hasFK || regOldRowid==regNewRowid );
dan1da40a32009-09-19 17:00:31 +0000604 if( chngRowid ){
605 sqlite3ExprCode(pParse, pRowidExpr, regNewRowid);
drh688852a2014-02-17 22:40:43 +0000606 sqlite3VdbeAddOp1(v, OP_MustBeInt, regNewRowid); VdbeCoverage(v);
dan1da40a32009-09-19 17:00:31 +0000607 }
608
drhf8ffb272013-11-01 17:08:56 +0000609 /* Compute the old pre-UPDATE content of the row being changed, if that
610 ** information is needed */
611 if( chngPk || hasFK || pTrigger ){
dane7a94d82009-10-01 16:09:04 +0000612 u32 oldmask = (hasFK ? sqlite3FkOldmask(pParse, pTab) : 0);
danbb5f1682009-11-27 12:12:34 +0000613 oldmask |= sqlite3TriggerColmask(pParse,
614 pTrigger, pChanges, 0, TRIGGER_BEFORE|TRIGGER_AFTER, pTab, onError
615 );
drh25303782004-12-07 15:41:48 +0000616 for(i=0; i<pTab->nCol; i++){
drhf8ffb272013-11-01 17:08:56 +0000617 if( oldmask==0xffffffff
drh693e6712014-01-24 22:58:00 +0000618 || (i<32 && (oldmask & MASKBIT32(i))!=0)
drh00012df2013-11-05 01:59:07 +0000619 || (pTab->aCol[i].colFlags & COLFLAG_PRIMKEY)!=0
drhf8ffb272013-11-01 17:08:56 +0000620 ){
drh693e6712014-01-24 22:58:00 +0000621 testcase( oldmask!=0xffffffff && i==31 );
drh77f64bb2013-10-31 12:13:37 +0000622 sqlite3ExprCodeGetColumnOfTable(v, pTab, iDataCur, i, regOld+i);
danielk1977c3f9bad2002-05-15 08:30:12 +0000623 }else{
dan165921a2009-08-28 18:53:45 +0000624 sqlite3VdbeAddOp2(v, OP_Null, 0, regOld+i);
danielk1977c3f9bad2002-05-15 08:30:12 +0000625 }
626 }
drhf8ffb272013-11-01 17:08:56 +0000627 if( chngRowid==0 && pPk==0 ){
dan1da40a32009-09-19 17:00:31 +0000628 sqlite3VdbeAddOp2(v, OP_Copy, regOldRowid, regNewRowid);
629 }
dan165921a2009-08-28 18:53:45 +0000630 }
drh5cf590c2003-04-24 01:45:04 +0000631
dan165921a2009-08-28 18:53:45 +0000632 /* Populate the array of registers beginning at regNew with the new
peter.d.reid60ec9142014-09-06 16:39:46 +0000633 ** row data. This array is used to check constants, create the new
dan165921a2009-08-28 18:53:45 +0000634 ** table and index records, and as the values for any new.* references
danbb5f1682009-11-27 12:12:34 +0000635 ** made by triggers.
636 **
637 ** If there are one or more BEFORE triggers, then do not populate the
638 ** registers associated with columns that are (a) not modified by
639 ** this UPDATE statement and (b) not accessed by new.* references. The
640 ** values for registers not modified by the UPDATE must be reloaded from
641 ** the database after the BEFORE triggers are fired anyway (as the trigger
642 ** may have modified them). So not loading those that are not going to
643 ** be used eliminates some redundant opcodes.
644 */
645 newmask = sqlite3TriggerColmask(
646 pParse, pTrigger, pChanges, 1, TRIGGER_BEFORE, pTab, onError
647 );
dan165921a2009-08-28 18:53:45 +0000648 for(i=0; i<pTab->nCol; i++){
649 if( i==pTab->iPKey ){
drhedfac342013-12-19 02:56:01 +0000650 sqlite3VdbeAddOp2(v, OP_Null, 0, regNew+i);
dan165921a2009-08-28 18:53:45 +0000651 }else{
drh5cf590c2003-04-24 01:45:04 +0000652 j = aXRef[i];
danbb5f1682009-11-27 12:12:34 +0000653 if( j>=0 ){
654 sqlite3ExprCode(pParse, pChanges->a[j].pExpr, regNew+i);
drh693e6712014-01-24 22:58:00 +0000655 }else if( 0==(tmask&TRIGGER_BEFORE) || i>31 || (newmask & MASKBIT32(i)) ){
danbb5f1682009-11-27 12:12:34 +0000656 /* This branch loads the value of a column that will not be changed
657 ** into a register. This is done if there are no BEFORE triggers, or
658 ** if there are one or more BEFORE triggers that use this value via
659 ** a new.* reference in a trigger program.
660 */
drhfd7c9912009-12-01 22:09:25 +0000661 testcase( i==31 );
662 testcase( i==32 );
drh8c607192018-08-04 15:53:55 +0000663 sqlite3ExprCodeGetColumnOfTable(v, pTab, iDataCur, i, regNew+i);
drhedfac342013-12-19 02:56:01 +0000664 }else{
665 sqlite3VdbeAddOp2(v, OP_Null, 0, regNew+i);
drh5cf590c2003-04-24 01:45:04 +0000666 }
667 }
dan165921a2009-08-28 18:53:45 +0000668 }
drh5cf590c2003-04-24 01:45:04 +0000669
dan165921a2009-08-28 18:53:45 +0000670 /* Fire any BEFORE UPDATE triggers. This happens before constraints are
danbb5f1682009-11-27 12:12:34 +0000671 ** verified. One could argue that this is wrong.
672 */
673 if( tmask&TRIGGER_BEFORE ){
drh57bf4a82014-02-17 14:59:22 +0000674 sqlite3TableAffinity(v, pTab, regNew);
dan2832ad42009-08-31 15:27:27 +0000675 sqlite3CodeRowTrigger(pParse, pTrigger, TK_UPDATE, pChanges,
drhc3e356f2013-11-04 18:34:46 +0000676 TRIGGER_BEFORE, pTab, regOldRowid, onError, labelContinue);
danae0931e2009-09-09 15:06:10 +0000677
678 /* The row-trigger may have deleted the row being updated. In this
679 ** case, jump to the next row. No updates or AFTER triggers are
mistachkin48864df2013-03-21 21:20:32 +0000680 ** required. This behavior - what happens when the row being updated
danae0931e2009-09-09 15:06:10 +0000681 ** is deleted or renamed by a BEFORE trigger - is left undefined in the
danbb5f1682009-11-27 12:12:34 +0000682 ** documentation.
683 */
drhf8ffb272013-11-01 17:08:56 +0000684 if( pPk ){
drh702ba9f2013-11-07 21:25:13 +0000685 sqlite3VdbeAddOp4Int(v, OP_NotFound, iDataCur, labelContinue,regKey,nKey);
drh688852a2014-02-17 22:40:43 +0000686 VdbeCoverage(v);
drhf8ffb272013-11-01 17:08:56 +0000687 }else{
drhc3e356f2013-11-04 18:34:46 +0000688 sqlite3VdbeAddOp3(v, OP_NotExists, iDataCur, labelContinue, regOldRowid);
drh688852a2014-02-17 22:40:43 +0000689 VdbeCoverage(v);
drhf8ffb272013-11-01 17:08:56 +0000690 }
danbb5f1682009-11-27 12:12:34 +0000691
drh909066b2018-04-26 15:50:10 +0000692 /* After-BEFORE-trigger-reload-loop:
693 ** If it did not delete it, the BEFORE trigger may still have modified
danbb5f1682009-11-27 12:12:34 +0000694 ** some of the columns of the row being updated. Load the values for
drhde7ca502018-04-26 15:04:18 +0000695 ** all columns not modified by the update statement into their registers
696 ** in case this has happened. Only unmodified columns are reloaded.
697 ** The values computed for modified columns use the values before the
698 ** BEFORE trigger runs. See test case trigger1-18.0 (added 2018-04-26)
699 ** for an example.
danbb5f1682009-11-27 12:12:34 +0000700 */
701 for(i=0; i<pTab->nCol; i++){
702 if( aXRef[i]<0 && i!=pTab->iPKey ){
drh313619f2013-10-31 20:34:06 +0000703 sqlite3ExprCodeGetColumnOfTable(v, pTab, iDataCur, i, regNew+i);
danbb5f1682009-11-27 12:12:34 +0000704 }
705 }
dan2832ad42009-08-31 15:27:27 +0000706 }
dan165921a2009-08-28 18:53:45 +0000707
708 if( !isView ){
drh728e0f92015-10-10 14:41:28 +0000709 int addr1 = 0; /* Address of jump instruction */
dan165921a2009-08-28 18:53:45 +0000710
711 /* Do constraint checks. */
drhf8ffb272013-11-01 17:08:56 +0000712 assert( regOldRowid>0 );
713 sqlite3GenerateConstraintChecks(pParse, pTab, aRegIdx, iDataCur, iIdxCur,
drhbdb00222016-02-10 16:03:20 +0000714 regNewRowid, regOldRowid, chngKey, onError, labelContinue, &bReplace,
drh788d55a2018-04-13 01:15:09 +0000715 aXRef, 0);
drh5cf590c2003-04-24 01:45:04 +0000716
dan1da40a32009-09-19 17:00:31 +0000717 /* Do FK constraint checks. */
dane7a94d82009-10-01 16:09:04 +0000718 if( hasFK ){
drhf8ffb272013-11-01 17:08:56 +0000719 sqlite3FkCheck(pParse, pTab, regOldRowid, 0, aXRef, chngKey);
dane7a94d82009-10-01 16:09:04 +0000720 }
dan1da40a32009-09-19 17:00:31 +0000721
dan165921a2009-08-28 18:53:45 +0000722 /* Delete the index entries associated with the current record. */
drhce60aa42013-11-08 01:09:15 +0000723 if( bReplace || chngKey ){
724 if( pPk ){
drh728e0f92015-10-10 14:41:28 +0000725 addr1 = sqlite3VdbeAddOp4Int(v, OP_NotFound, iDataCur, 0, regKey, nKey);
drhce60aa42013-11-08 01:09:15 +0000726 }else{
drh728e0f92015-10-10 14:41:28 +0000727 addr1 = sqlite3VdbeAddOp3(v, OP_NotExists, iDataCur, 0, regOldRowid);
drhce60aa42013-11-08 01:09:15 +0000728 }
drh5655c542014-02-19 19:14:34 +0000729 VdbeCoverageNeverTaken(v);
drh6fbe41a2013-10-30 20:22:55 +0000730 }
danf0ee1d32015-09-12 19:26:11 +0000731 sqlite3GenerateRowIndexDelete(pParse, pTab, iDataCur, iIdxCur, aRegIdx, -1);
drh9b1c62d2011-03-30 21:04:43 +0000732
dan46c47d42011-03-01 18:42:07 +0000733 /* If changing the rowid value, or if there are foreign key constraints
734 ** to process, delete the old record. Otherwise, add a noop OP_Delete
735 ** to invoke the pre-update hook.
dan37db03b2011-03-16 19:59:18 +0000736 **
737 ** That (regNew==regnewRowid+1) is true is also important for the
drh9b1c62d2011-03-30 21:04:43 +0000738 ** pre-update hook. If the caller invokes preupdate_new(), the returned
dan37db03b2011-03-16 19:59:18 +0000739 ** value is copied from memory cell (regNewRowid+1+iCol), where iCol
740 ** is the column index supplied by the user.
dan46c47d42011-03-01 18:42:07 +0000741 */
dan37db03b2011-03-16 19:59:18 +0000742 assert( regNew==regNewRowid+1 );
drh74c33022016-03-30 12:56:55 +0000743#ifdef SQLITE_ENABLE_PREUPDATE_HOOK
drhcbf1b8e2013-11-11 22:55:26 +0000744 sqlite3VdbeAddOp3(v, OP_Delete, iDataCur,
dan940b5ea2017-04-11 19:58:55 +0000745 OPFLAG_ISUPDATE | ((hasFK>1 || chngKey) ? 0 : OPFLAG_ISNOOP),
dan46c47d42011-03-01 18:42:07 +0000746 regNewRowid
747 );
dane206ea72017-01-11 20:10:30 +0000748 if( eOnePass==ONEPASS_MULTI ){
749 assert( hasFK==0 && chngKey==0 );
750 sqlite3VdbeChangeP5(v, OPFLAG_SAVEPOSITION);
751 }
dan46c47d42011-03-01 18:42:07 +0000752 if( !pParse->nested ){
drhf14b7fb2016-12-07 21:35:55 +0000753 sqlite3VdbeAppendP4(v, pTab, P4_TABLE);
drh5cf590c2003-04-24 01:45:04 +0000754 }
drh74c33022016-03-30 12:56:55 +0000755#else
dan940b5ea2017-04-11 19:58:55 +0000756 if( hasFK>1 || chngKey ){
drh74c33022016-03-30 12:56:55 +0000757 sqlite3VdbeAddOp2(v, OP_Delete, iDataCur, 0);
758 }
759#endif
drhce60aa42013-11-08 01:09:15 +0000760 if( bReplace || chngKey ){
drh728e0f92015-10-10 14:41:28 +0000761 sqlite3VdbeJumpHere(v, addr1);
drh313619f2013-10-31 20:34:06 +0000762 }
dan9277efa2009-09-28 11:54:21 +0000763
dane7a94d82009-10-01 16:09:04 +0000764 if( hasFK ){
drhf8ffb272013-11-01 17:08:56 +0000765 sqlite3FkCheck(pParse, pTab, 0, regNewRowid, aXRef, chngKey);
dane7a94d82009-10-01 16:09:04 +0000766 }
dan165921a2009-08-28 18:53:45 +0000767
dan76d462e2009-08-30 11:42:51 +0000768 /* Insert the new index entries and the new record. */
danf91c1312017-01-10 20:04:38 +0000769 sqlite3CompleteInsertion(
770 pParse, pTab, iDataCur, iIdxCur, regNewRowid, aRegIdx,
771 OPFLAG_ISUPDATE | (eOnePass==ONEPASS_MULTI ? OPFLAG_SAVEPOSITION : 0),
772 0, 0
773 );
dan1da40a32009-09-19 17:00:31 +0000774
775 /* Do any ON CASCADE, SET NULL or SET DEFAULT operations required to
776 ** handle rows (possibly in other tables) that refer via a foreign key
777 ** to the row just updated. */
dane7a94d82009-10-01 16:09:04 +0000778 if( hasFK ){
drhf8ffb272013-11-01 17:08:56 +0000779 sqlite3FkActions(pParse, pTab, pChanges, regOldRowid, aXRef, chngKey);
dane7a94d82009-10-01 16:09:04 +0000780 }
drhcce7d172000-05-31 15:34:51 +0000781 }
782
drh0ca3e242002-01-29 23:07:02 +0000783 /* Increment the row counter
drh1bee3d72001-10-15 00:44:35 +0000784 */
drh79636912018-04-19 23:52:39 +0000785 if( regRowCount ){
drh04adf412008-01-08 18:57:50 +0000786 sqlite3VdbeAddOp2(v, OP_AddImm, regRowCount, 1);
drh1bee3d72001-10-15 00:44:35 +0000787 }
788
dan165921a2009-08-28 18:53:45 +0000789 sqlite3CodeRowTrigger(pParse, pTrigger, TK_UPDATE, pChanges,
drhc3e356f2013-11-04 18:34:46 +0000790 TRIGGER_AFTER, pTab, regOldRowid, onError, labelContinue);
danielk1977c3f9bad2002-05-15 08:30:12 +0000791
drhcce7d172000-05-31 15:34:51 +0000792 /* Repeat the above with the next record to be updated, until
793 ** all record selected by the WHERE clause have been updated.
794 */
danf91c1312017-01-10 20:04:38 +0000795 if( eOnePass==ONEPASS_SINGLE ){
drh702ba9f2013-11-07 21:25:13 +0000796 /* Nothing to do at end-of-loop for a single-pass */
danf91c1312017-01-10 20:04:38 +0000797 }else if( eOnePass==ONEPASS_MULTI ){
798 sqlite3VdbeResolveLabel(v, labelContinue);
799 sqlite3WhereEnd(pWInfo);
drh702ba9f2013-11-07 21:25:13 +0000800 }else if( pPk ){
drhea22abe2013-10-25 19:17:17 +0000801 sqlite3VdbeResolveLabel(v, labelContinue);
drh688852a2014-02-17 22:40:43 +0000802 sqlite3VdbeAddOp2(v, OP_Next, iEph, addrTop); VdbeCoverage(v);
drh702ba9f2013-11-07 21:25:13 +0000803 }else{
drh076e85f2015-09-03 13:46:12 +0000804 sqlite3VdbeGoto(v, labelContinue);
drhea22abe2013-10-25 19:17:17 +0000805 }
806 sqlite3VdbeResolveLabel(v, labelBreak);
danielk1977c3f9bad2002-05-15 08:30:12 +0000807
drh0b9f50d2009-06-23 20:28:53 +0000808 /* Update the sqlite_sequence table by storing the content of the
809 ** maximum rowid counter values recorded while inserting into
810 ** autoincrement tables.
811 */
drhf3d7bbb2018-04-21 03:06:29 +0000812 if( pParse->nested==0 && pParse->pTriggerTab==0 && pUpsert==0 ){
drh0b9f50d2009-06-23 20:28:53 +0000813 sqlite3AutoincrementEnd(pParse);
814 }
815
drh1bee3d72001-10-15 00:44:35 +0000816 /*
drh79636912018-04-19 23:52:39 +0000817 ** Return the number of rows that were changed, if we are tracking
818 ** that information.
drh1bee3d72001-10-15 00:44:35 +0000819 */
drh79636912018-04-19 23:52:39 +0000820 if( regRowCount ){
drh04adf412008-01-08 18:57:50 +0000821 sqlite3VdbeAddOp2(v, OP_ResultRow, regRowCount, 1);
danielk197722322fd2004-05-25 23:35:17 +0000822 sqlite3VdbeSetNumCols(v, 1);
danielk197710fb7492008-10-31 10:53:22 +0000823 sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "rows updated", SQLITE_STATIC);
drh1bee3d72001-10-15 00:44:35 +0000824 }
825
drhcce7d172000-05-31 15:34:51 +0000826update_cleanup:
danielk19774adee202004-05-08 08:23:19 +0000827 sqlite3AuthContextPop(&sContext);
drh6a534992013-11-16 20:13:39 +0000828 sqlite3DbFree(db, aXRef); /* Also frees aRegIdx[] and aToOpen[] */
drh633e6d52008-07-28 19:34:53 +0000829 sqlite3SrcListDelete(db, pTabList);
830 sqlite3ExprListDelete(db, pChanges);
831 sqlite3ExprDelete(db, pWhere);
dan3b61ebb2017-11-10 20:13:14 +0000832#if defined(SQLITE_ENABLE_UPDATE_DELETE_LIMIT)
danb3c16b82017-11-09 19:53:06 +0000833 sqlite3ExprListDelete(db, pOrderBy);
834 sqlite3ExprDelete(db, pLimit);
dan3b61ebb2017-11-10 20:13:14 +0000835#endif
drhcce7d172000-05-31 15:34:51 +0000836 return;
837}
dan75cbd982009-09-21 16:06:03 +0000838/* Make sure "isView" and other macros defined above are undefined. Otherwise
peter.d.reid60ec9142014-09-06 16:39:46 +0000839** they may interfere with compilation of other functions in this file
dan75cbd982009-09-21 16:06:03 +0000840** (or in another file, if this file becomes part of the amalgamation). */
841#ifdef isView
842 #undef isView
843#endif
844#ifdef pTrigger
845 #undef pTrigger
846#endif
drh9c419382006-06-16 21:13:21 +0000847
848#ifndef SQLITE_OMIT_VIRTUALTABLE
849/*
850** Generate code for an UPDATE of a virtual table.
851**
dan0f400372015-09-28 20:03:49 +0000852** There are two possible strategies - the default and the special
853** "onepass" strategy. Onepass is only used if the virtual table
854** implementation indicates that pWhere may match at most one row.
855**
856** The default strategy is to create an ephemeral table that contains
drh9c419382006-06-16 21:13:21 +0000857** for each row to be changed:
858**
859** (A) The original rowid of that row.
dan0f400372015-09-28 20:03:49 +0000860** (B) The revised rowid for the row.
drh9c419382006-06-16 21:13:21 +0000861** (C) The content of every column in the row.
862**
dan0f400372015-09-28 20:03:49 +0000863** Then loop through the contents of this ephemeral table executing a
864** VUpdate for each row. When finished, drop the ephemeral table.
drh9c419382006-06-16 21:13:21 +0000865**
dan0f400372015-09-28 20:03:49 +0000866** The "onepass" strategy does not use an ephemeral table. Instead, it
867** stores the same values (A, B and C above) in a register array and
868** makes a single invocation of VUpdate.
drh9c419382006-06-16 21:13:21 +0000869*/
870static void updateVirtualTable(
871 Parse *pParse, /* The parsing context */
872 SrcList *pSrc, /* The virtual table to be modified */
873 Table *pTab, /* The virtual table */
874 ExprList *pChanges, /* The columns to change in the UPDATE statement */
875 Expr *pRowid, /* Expression used to recompute the rowid */
876 int *aXRef, /* Mapping from columns of pTab to entries in pChanges */
danb061d052011-04-25 18:49:57 +0000877 Expr *pWhere, /* WHERE clause of the UPDATE statement */
878 int onError /* ON CONFLICT strategy */
drh9c419382006-06-16 21:13:21 +0000879){
880 Vdbe *v = pParse->pVdbe; /* Virtual machine under construction */
drh9c419382006-06-16 21:13:21 +0000881 int ephemTab; /* Table holding the result of the SELECT */
882 int i; /* Loop counter */
drh17435752007-08-16 04:30:38 +0000883 sqlite3 *db = pParse->db; /* Database connection */
danielk1977595a5232009-07-24 17:58:53 +0000884 const char *pVTab = (const char*)sqlite3GetVTable(db, pTab);
dan0f400372015-09-28 20:03:49 +0000885 WhereInfo *pWInfo;
886 int nArg = 2 + pTab->nCol; /* Number of arguments to VUpdate */
887 int regArg; /* First register in VUpdate arg array */
888 int regRec; /* Register in which to assemble record */
889 int regRowid; /* Register for ephem table rowid */
890 int iCsr = pSrc->a[0].iCursor; /* Cursor used for virtual table scan */
891 int aDummy[2]; /* Unused arg for sqlite3WhereOkOnePass() */
drh338e3112018-05-24 23:51:57 +0000892 int eOnePass; /* True to use onepass strategy */
dan0f400372015-09-28 20:03:49 +0000893 int addr; /* Address of OP_OpenEphemeral */
drh9c419382006-06-16 21:13:21 +0000894
drh24cd20f2018-01-11 13:43:04 +0000895 /* Allocate nArg registers in which to gather the arguments for VUpdate. Then
dan0f400372015-09-28 20:03:49 +0000896 ** create and open the ephemeral table in which the records created from
897 ** these arguments will be temporarily stored. */
drh9c419382006-06-16 21:13:21 +0000898 assert( v );
899 ephemTab = pParse->nTab++;
dan0f400372015-09-28 20:03:49 +0000900 addr= sqlite3VdbeAddOp2(v, OP_OpenEphemeral, ephemTab, nArg);
901 regArg = pParse->nMem + 1;
902 pParse->nMem += nArg;
903 regRec = ++pParse->nMem;
904 regRowid = ++pParse->nMem;
drh9c419382006-06-16 21:13:21 +0000905
dan0f400372015-09-28 20:03:49 +0000906 /* Start scanning the virtual table */
907 pWInfo = sqlite3WhereBegin(pParse, pSrc, pWhere, 0,0,WHERE_ONEPASS_DESIRED,0);
908 if( pWInfo==0 ) return;
drh9c419382006-06-16 21:13:21 +0000909
dan0f400372015-09-28 20:03:49 +0000910 /* Populate the argument registers. */
drh9c419382006-06-16 21:13:21 +0000911 for(i=0; i<pTab->nCol; i++){
dan0f400372015-09-28 20:03:49 +0000912 if( aXRef[i]>=0 ){
913 sqlite3ExprCode(pParse, pChanges->a[aXRef[i]].pExpr, regArg+2+i);
914 }else{
drhce2fbd12018-01-12 21:00:14 +0000915 sqlite3VdbeAddOp3(v, OP_VColumn, iCsr, i, regArg+2+i);
drh41fb3672018-01-12 23:18:38 +0000916 sqlite3VdbeChangeP5(v, 1); /* Enable sqlite3_vtab_nochange() */
dan0f400372015-09-28 20:03:49 +0000917 }
918 }
drhe3740f22017-08-10 15:19:39 +0000919 if( HasRowid(pTab) ){
920 sqlite3VdbeAddOp2(v, OP_Rowid, iCsr, regArg);
921 if( pRowid ){
922 sqlite3ExprCode(pParse, pRowid, regArg+1);
923 }else{
924 sqlite3VdbeAddOp2(v, OP_Rowid, iCsr, regArg+1);
925 }
926 }else{
927 Index *pPk; /* PRIMARY KEY index */
928 i16 iPk; /* PRIMARY KEY column */
929 pPk = sqlite3PrimaryKeyIndex(pTab);
930 assert( pPk!=0 );
931 assert( pPk->nKeyCol==1 );
932 iPk = pPk->aiColumn[0];
933 sqlite3VdbeAddOp3(v, OP_VColumn, iCsr, iPk, regArg);
934 sqlite3VdbeAddOp2(v, OP_SCopy, regArg+2+iPk, regArg+1);
935 }
dan0f400372015-09-28 20:03:49 +0000936
drh338e3112018-05-24 23:51:57 +0000937 eOnePass = sqlite3WhereOkOnePass(pWInfo, aDummy);
dan0f400372015-09-28 20:03:49 +0000938
drh338e3112018-05-24 23:51:57 +0000939 /* There is no ONEPASS_MULTI on virtual tables */
940 assert( eOnePass==ONEPASS_OFF || eOnePass==ONEPASS_SINGLE );
941
942 if( eOnePass ){
dan0f400372015-09-28 20:03:49 +0000943 /* If using the onepass strategy, no-op out the OP_OpenEphemeral coded
drhac9151d2018-04-20 19:32:35 +0000944 ** above. */
dan0f400372015-09-28 20:03:49 +0000945 sqlite3VdbeChangeToNoop(v, addr);
drh338e3112018-05-24 23:51:57 +0000946 sqlite3VdbeAddOp1(v, OP_Close, iCsr);
dan0f400372015-09-28 20:03:49 +0000947 }else{
948 /* Create a record from the argument register contents and insert it into
949 ** the ephemeral table. */
drhac9151d2018-04-20 19:32:35 +0000950 sqlite3MultiWrite(pParse);
dan0f400372015-09-28 20:03:49 +0000951 sqlite3VdbeAddOp3(v, OP_MakeRecord, regArg, nArg, regRec);
drh41fb3672018-01-12 23:18:38 +0000952#ifdef SQLITE_DEBUG
953 /* Signal an assert() within OP_MakeRecord that it is allowed to
954 ** accept no-change records with serial_type 10 */
955 sqlite3VdbeChangeP5(v, OPFLAG_NOCHNG_MAGIC);
956#endif
dan0f400372015-09-28 20:03:49 +0000957 sqlite3VdbeAddOp2(v, OP_NewRowid, ephemTab, regRowid);
958 sqlite3VdbeAddOp3(v, OP_Insert, ephemTab, regRec, regRowid);
959 }
960
dan0f400372015-09-28 20:03:49 +0000961
drh338e3112018-05-24 23:51:57 +0000962 if( eOnePass==ONEPASS_OFF ){
dan354474a2015-09-29 10:11:26 +0000963 /* End the virtual table scan */
964 sqlite3WhereEnd(pWInfo);
965
dan0f400372015-09-28 20:03:49 +0000966 /* Begin scannning through the ephemeral table. */
dan354474a2015-09-29 10:11:26 +0000967 addr = sqlite3VdbeAddOp1(v, OP_Rewind, ephemTab); VdbeCoverage(v);
dan0f400372015-09-28 20:03:49 +0000968
969 /* Extract arguments from the current row of the ephemeral table and
970 ** invoke the VUpdate method. */
971 for(i=0; i<nArg; i++){
972 sqlite3VdbeAddOp3(v, OP_Column, ephemTab, i, regArg+i);
973 }
drh9c419382006-06-16 21:13:21 +0000974 }
drh4f3dd152008-04-28 18:46:43 +0000975 sqlite3VtabMakeWritable(pParse, pTab);
dan0f400372015-09-28 20:03:49 +0000976 sqlite3VdbeAddOp4(v, OP_VUpdate, 0, nArg, regArg, pVTab, P4_VTAB);
danb061d052011-04-25 18:49:57 +0000977 sqlite3VdbeChangeP5(v, onError==OE_Default ? OE_Abort : onError);
dane0af83a2009-09-08 19:15:01 +0000978 sqlite3MayAbort(pParse);
drh9c419382006-06-16 21:13:21 +0000979
dan354474a2015-09-29 10:11:26 +0000980 /* End of the ephemeral table scan. Or, if using the onepass strategy,
981 ** jump to here if the scan visited zero rows. */
drh338e3112018-05-24 23:51:57 +0000982 if( eOnePass==ONEPASS_OFF ){
dan0f400372015-09-28 20:03:49 +0000983 sqlite3VdbeAddOp2(v, OP_Next, ephemTab, addr+1); VdbeCoverage(v);
984 sqlite3VdbeJumpHere(v, addr);
985 sqlite3VdbeAddOp2(v, OP_Close, ephemTab, 0);
dan354474a2015-09-29 10:11:26 +0000986 }else{
987 sqlite3WhereEnd(pWInfo);
dan0f400372015-09-28 20:03:49 +0000988 }
drh9c419382006-06-16 21:13:21 +0000989}
990#endif /* SQLITE_OMIT_VIRTUALTABLE */