blob: c5a01f89693a4b1541259254bba90f1438d8cd98 [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
drh1e32bed2020-06-19 13:33:53 +000049** into the sqlite_schema table.)
danielk1977aee18ef2005-03-09 12:26:50 +000050**
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**
drh8c1febb2020-05-16 18:01:02 +000056** If column as REAL affinity and the table is an ordinary b-tree table
57** (not a virtual table) then the value might have been stored as an
58** integer. In that case, add an OP_RealAffinity opcode to make sure
59** it has been converted into REAL.
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
drh8c1febb2020-05-16 18:01:02 +000076 if( pTab->aCol[i].affinity==SQLITE_AFF_REAL && !IsVirtual(pTab) ){
drhda060052017-01-16 16:43:02 +000077 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/*
dan576d5a82020-07-15 18:30:01 +0000134** Allocate and return a pointer to an expression of type TK_ROW with
135** Expr.iColumn set to value (iCol+1). The resolver will modify the
136** expression to be a TK_COLUMN reading column iCol of the first
137** table in the source-list (pSrc->a[0]).
138*/
139static Expr *exprRowColumn(Parse *pParse, int iCol){
140 Expr *pRet = sqlite3PExpr(pParse, TK_ROW, 0, 0);
141 if( pRet ) pRet->iColumn = iCol+1;
142 return pRet;
143}
144
145/*
146** Assuming both the pLimit and pOrderBy parameters are NULL, this function
147** generates VM code to run the query:
dan69887c92020-04-27 20:55:33 +0000148**
dan576d5a82020-07-15 18:30:01 +0000149** SELECT <other-columns>, pChanges FROM pTabList WHERE pWhere
dan69887c92020-04-27 20:55:33 +0000150**
151** and write the results to the ephemeral table already opened as cursor
152** iEph. None of pChanges, pTabList or pWhere are modified or consumed by
153** this function, they must be deleted by the caller.
154**
dan576d5a82020-07-15 18:30:01 +0000155** Or, if pLimit and pOrderBy are not NULL, and pTab is not a view:
156**
157** SELECT <other-columns>, pChanges FROM pTabList
158** WHERE pWhere
159** GROUP BY <other-columns>
160** ORDER BY pOrderBy LIMIT pLimit
161**
162** If pTab is a view, the GROUP BY clause is omitted.
163**
dan69887c92020-04-27 20:55:33 +0000164** Exactly how results are written to table iEph, and exactly what
165** the <other-columns> in the query above are is determined by the type
166** of table pTabList->a[0].pTab.
167**
168** If the table is a WITHOUT ROWID table, then argument pPk must be its
169** PRIMARY KEY. In this case <other-columns> are the primary key columns
170** of the table, in order. The results of the query are written to ephemeral
171** table iEph as index keys, using OP_IdxInsert.
172**
173** If the table is actually a view, then <other-columns> are all columns of
174** the view. The results are written to the ephemeral table iEph as records
175** with automatically assigned integer keys.
176**
177** If the table is a virtual or ordinary intkey table, then <other-columns>
178** is its rowid. For a virtual table, the results are written to iEph as
179** records with automatically assigned integer keys For intkey tables, the
180** rowid value in <other-columns> is used as the integer key, and the
181** remaining fields make up the table record.
182*/
dan576d5a82020-07-15 18:30:01 +0000183static void updateFromSelect(
dan69887c92020-04-27 20:55:33 +0000184 Parse *pParse, /* Parse context */
185 int iEph, /* Cursor for open eph. table */
186 Index *pPk, /* PK if table 0 is WITHOUT ROWID */
187 ExprList *pChanges, /* List of expressions to return */
188 SrcList *pTabList, /* List of tables to select from */
danf2972b62020-04-29 20:11:01 +0000189 Expr *pWhere, /* WHERE clause for query */
drha7c74002020-07-18 18:44:59 +0000190 ExprList *pOrderBy, /* ORDER BY clause */
191 Expr *pLimit /* LIMIT clause */
dan69887c92020-04-27 20:55:33 +0000192){
193 int i;
dan69887c92020-04-27 20:55:33 +0000194 SelectDest dest;
195 Select *pSelect = 0;
196 ExprList *pList = 0;
dan576d5a82020-07-15 18:30:01 +0000197 ExprList *pGrp = 0;
dan7e1d9512020-07-17 15:34:54 +0000198 Expr *pLimit2 = 0;
199 ExprList *pOrderBy2 = 0;
dan1e113842020-04-30 15:49:56 +0000200 sqlite3 *db = pParse->db;
201 Table *pTab = pTabList->a[0].pTab;
202 SrcList *pSrc;
203 Expr *pWhere2;
dan69887c92020-04-27 20:55:33 +0000204 int eDest;
205
dan7e1d9512020-07-17 15:34:54 +0000206#ifdef SQLITE_ENABLE_UPDATE_DELETE_LIMIT
dan1e113842020-04-30 15:49:56 +0000207 if( pOrderBy && pLimit==0 ) {
208 sqlite3ErrorMsg(pParse, "ORDER BY without LIMIT on UPDATE");
209 return;
210 }
dan7e1d9512020-07-17 15:34:54 +0000211 pOrderBy2 = sqlite3ExprListDup(db, pOrderBy, 0);
212 pLimit2 = sqlite3ExprDup(db, pLimit, 0);
drha7c74002020-07-18 18:44:59 +0000213#else
214 UNUSED_PARAMETER(pOrderBy);
215 UNUSED_PARAMETER(pLimit);
dan7e1d9512020-07-17 15:34:54 +0000216#endif
dan1e113842020-04-30 15:49:56 +0000217
218 pSrc = sqlite3SrcListDup(db, pTabList, 0);
219 pWhere2 = sqlite3ExprDup(db, pWhere, 0);
dan1e113842020-04-30 15:49:56 +0000220
dan69887c92020-04-27 20:55:33 +0000221 assert( pTabList->nSrc>1 );
222 if( pSrc ){
drhcd1499f2021-05-20 00:44:04 +0000223 pSrc->a[0].fg.notCte = 1;
dan69887c92020-04-27 20:55:33 +0000224 pSrc->a[0].iCursor = -1;
225 pSrc->a[0].pTab->nTabRef--;
226 pSrc->a[0].pTab = 0;
227 }
228 if( pPk ){
229 for(i=0; i<pPk->nKeyCol; i++){
dan576d5a82020-07-15 18:30:01 +0000230 Expr *pNew = exprRowColumn(pParse, pPk->aiColumn[i]);
dan7e1d9512020-07-17 15:34:54 +0000231#ifdef SQLITE_ENABLE_UPDATE_DELETE_LIMIT
danf2972b62020-04-29 20:11:01 +0000232 if( pLimit ){
dan576d5a82020-07-15 18:30:01 +0000233 pGrp = sqlite3ExprListAppend(pParse, pGrp, sqlite3ExprDup(db, pNew, 0));
danf2972b62020-04-29 20:11:01 +0000234 }
dan7e1d9512020-07-17 15:34:54 +0000235#endif
danf2972b62020-04-29 20:11:01 +0000236 pList = sqlite3ExprListAppend(pParse, pList, pNew);
dan69887c92020-04-27 20:55:33 +0000237 }
dan4d906f12020-10-12 14:29:11 +0000238 eDest = IsVirtual(pTab) ? SRT_Table : SRT_Upfrom;
dan69887c92020-04-27 20:55:33 +0000239 }else if( pTab->pSelect ){
dan576d5a82020-07-15 18:30:01 +0000240 for(i=0; i<pTab->nCol; i++){
241 pList = sqlite3ExprListAppend(pParse, pList, exprRowColumn(pParse, i));
242 }
dan69887c92020-04-27 20:55:33 +0000243 eDest = SRT_Table;
244 }else{
dan9ed322d2020-04-29 17:41:29 +0000245 eDest = IsVirtual(pTab) ? SRT_Table : SRT_Upfrom;
dan576d5a82020-07-15 18:30:01 +0000246 pList = sqlite3ExprListAppend(pParse, 0, sqlite3PExpr(pParse,TK_ROW,0,0));
dan7e1d9512020-07-17 15:34:54 +0000247#ifdef SQLITE_ENABLE_UPDATE_DELETE_LIMIT
danf2972b62020-04-29 20:11:01 +0000248 if( pLimit ){
dan576d5a82020-07-15 18:30:01 +0000249 pGrp = sqlite3ExprListAppend(pParse, 0, sqlite3PExpr(pParse,TK_ROW,0,0));
danf2972b62020-04-29 20:11:01 +0000250 }
dan7e1d9512020-07-17 15:34:54 +0000251#endif
dan69887c92020-04-27 20:55:33 +0000252 }
drh2be1f2a2021-04-09 22:20:20 +0000253 assert( pChanges!=0 || pParse->db->mallocFailed );
254 if( pChanges ){
dan8b023cf2020-04-30 18:28:40 +0000255 for(i=0; i<pChanges->nExpr; i++){
256 pList = sqlite3ExprListAppend(pParse, pList,
257 sqlite3ExprDup(db, pChanges->a[i].pExpr, 0)
258 );
259 }
dan69887c92020-04-27 20:55:33 +0000260 }
dan243210b2020-07-15 15:32:59 +0000261 pSelect = sqlite3SelectNew(pParse, pList,
dan5daf69e2021-07-05 11:27:13 +0000262 pSrc, pWhere2, pGrp, 0, pOrderBy2, SF_UFSrcCheck|SF_IncludeHidden, pLimit2
danf2972b62020-04-29 20:11:01 +0000263 );
drh0fb78f02021-07-16 01:19:19 +0000264 if( pSelect ) pSelect->selFlags |= SF_OrderByReqd;
dan69887c92020-04-27 20:55:33 +0000265 sqlite3SelectDestInit(&dest, eDest, iEph);
dan9ed322d2020-04-29 17:41:29 +0000266 dest.iSDParm2 = (pPk ? pPk->nKeyCol : -1);
dan69887c92020-04-27 20:55:33 +0000267 sqlite3Select(pParse, pSelect, &dest);
268 sqlite3SelectDelete(db, pSelect);
269}
270
271/*
drhcce7d172000-05-31 15:34:51 +0000272** Process an UPDATE statement.
drhb2fe7d82003-04-20 17:29:23 +0000273**
dan243210b2020-07-15 15:32:59 +0000274** UPDATE OR IGNORE tbl SET a=b, c=d FROM tbl2... WHERE e<5 AND f NOT NULL;
275** \_______/ \_/ \______/ \_____/ \________________/
276** onError | pChanges | pWhere
277** \_______________________/
278** pTabList
drhcce7d172000-05-31 15:34:51 +0000279*/
dan3b61ebb2017-11-10 20:13:14 +0000280void sqlite3Update(
drhcce7d172000-05-31 15:34:51 +0000281 Parse *pParse, /* The parser context */
drh113088e2003-03-20 01:16:58 +0000282 SrcList *pTabList, /* The table in which we should change things */
drhcce7d172000-05-31 15:34:51 +0000283 ExprList *pChanges, /* Things to be changed */
drh9cfcf5d2002-01-29 18:41:24 +0000284 Expr *pWhere, /* The WHERE clause. May be null */
danb3c16b82017-11-09 19:53:06 +0000285 int onError, /* How to handle constraint errors */
dan3b61ebb2017-11-10 20:13:14 +0000286 ExprList *pOrderBy, /* ORDER BY clause. May be null */
drheac9fab2018-04-16 13:00:50 +0000287 Expr *pLimit, /* LIMIT clause. May be null */
288 Upsert *pUpsert /* ON CONFLICT clause, or null */
drhcce7d172000-05-31 15:34:51 +0000289){
drh8a53ce22019-10-17 15:59:03 +0000290 int i, j, k; /* Loop counters */
drhcce7d172000-05-31 15:34:51 +0000291 Table *pTab; /* The table to be updated */
drhc3e356f2013-11-04 18:34:46 +0000292 int addrTop = 0; /* VDBE instruction address of the start of the loop */
drhaec7dc62020-07-18 18:03:26 +0000293 WhereInfo *pWInfo = 0; /* Information about the WHERE clause */
drhcce7d172000-05-31 15:34:51 +0000294 Vdbe *v; /* The virtual database engine */
295 Index *pIdx; /* For looping over indices */
drhea22abe2013-10-25 19:17:17 +0000296 Index *pPk; /* The PRIMARY KEY index for WITHOUT ROWID tables */
drhcce7d172000-05-31 15:34:51 +0000297 int nIdx; /* Number of indices that need updating */
drh9e9374b2019-05-08 19:06:59 +0000298 int nAllIdx; /* Total number of indexes */
drh6a534992013-11-16 20:13:39 +0000299 int iBaseCur; /* Base cursor number */
drh77f64bb2013-10-31 12:13:37 +0000300 int iDataCur; /* Cursor for the canonical data btree */
301 int iIdxCur; /* Cursor for the first index */
drh9bb575f2004-09-06 17:24:11 +0000302 sqlite3 *db; /* The database structure */
drha7c3b932019-05-07 19:13:42 +0000303 int *aRegIdx = 0; /* Registers for to each index and the main table */
drhcce7d172000-05-31 15:34:51 +0000304 int *aXRef = 0; /* aXRef[i] is the index in pChanges->a[] of the
drh967e8b72000-06-21 13:59:10 +0000305 ** an expression for the i-th column of the table.
306 ** aXRef[i]==-1 if the i-th column is not changed. */
drh6a534992013-11-16 20:13:39 +0000307 u8 *aToOpen; /* 1 for tables and indices to be opened */
drhf8ffb272013-11-01 17:08:56 +0000308 u8 chngPk; /* PRIMARY KEY changed in a WITHOUT ROWID table */
309 u8 chngRowid; /* Rowid changed in a normal table */
310 u8 chngKey; /* Either chngPk or chngRowid */
drhf0863fe2005-06-12 21:35:51 +0000311 Expr *pRowidExpr = 0; /* Expression defining the new record number */
dan243210b2020-07-15 15:32:59 +0000312 int iRowidExpr = -1; /* Index of "rowid=" (or IPK) assignment in pChanges */
drh85e20962003-04-25 17:52:11 +0000313 AuthContext sContext; /* The authorization context */
danielk1977b3bce662005-01-29 08:32:43 +0000314 NameContext sNC; /* The name-context to resolve expressions in */
danielk1977da184232006-01-05 11:34:32 +0000315 int iDb; /* Database containing the table being updated */
danf91c1312017-01-10 20:04:38 +0000316 int eOnePass; /* ONEPASS_XXX value from where.c */
dan1da40a32009-09-19 17:00:31 +0000317 int hasFK; /* True if foreign key processing is required */
drhea22abe2013-10-25 19:17:17 +0000318 int labelBreak; /* Jump here to break out of UPDATE loop */
319 int labelContinue; /* Jump here to continue next step of UPDATE loop */
danf91c1312017-01-10 20:04:38 +0000320 int flags; /* Flags for sqlite3WhereBegin() */
drhcce7d172000-05-31 15:34:51 +0000321
drh798da522004-11-04 04:42:28 +0000322#ifndef SQLITE_OMIT_TRIGGER
danbb5f1682009-11-27 12:12:34 +0000323 int isView; /* True when updating a view (INSTEAD OF trigger) */
324 Trigger *pTrigger; /* List of triggers on pTab, if required */
325 int tmask; /* Mask of TRIGGER_BEFORE|TRIGGER_AFTER */
drh798da522004-11-04 04:42:28 +0000326#endif
drhfd7c9912009-12-01 22:09:25 +0000327 int newmask; /* Mask of NEW.* columns accessed by BEFORE triggers */
drhea22abe2013-10-25 19:17:17 +0000328 int iEph = 0; /* Ephemeral table holding all primary key values */
drh00f91cf2013-11-07 21:32:16 +0000329 int nKey = 0; /* Number of elements in regKey for WITHOUT ROWID */
drhfc8d4f92013-11-08 15:19:46 +0000330 int aiCurOnePass[2]; /* The write cursors opened by WHERE_ONEPASS */
drhae051a82017-01-12 16:21:54 +0000331 int addrOpen = 0; /* Address of OP_OpenEphemeral */
332 int iPk = 0; /* First of nPk cells holding PRIMARY KEY value */
333 i16 nPk = 0; /* Number of components of the PRIMARY KEY */
dan2c6fec22017-01-11 19:03:08 +0000334 int bReplace = 0; /* True if REPLACE conflict resolution might happen */
drhbe3da242019-12-29 00:52:41 +0000335 int bFinishSeek = 1; /* The OP_FinishSeek opcode is needed */
dan243210b2020-07-15 15:32:59 +0000336 int nChangeFrom = 0; /* If there is a FROM, pChanges->nExpr, else 0 */
danielk1977c3f9bad2002-05-15 08:30:12 +0000337
drh04adf412008-01-08 18:57:50 +0000338 /* Register Allocations */
339 int regRowCount = 0; /* A count of rows changed */
drh94f26a12015-09-29 12:32:56 +0000340 int regOldRowid = 0; /* The old rowid */
341 int regNewRowid = 0; /* The new rowid */
342 int regNew = 0; /* Content of the NEW.* table in triggers */
drhb8475df2011-12-09 16:21:19 +0000343 int regOld = 0; /* Content of OLD.* table in triggers */
drh4f21c4a2008-12-10 22:15:00 +0000344 int regRowSet = 0; /* Rowset of rows to be updated */
drhea22abe2013-10-25 19:17:17 +0000345 int regKey = 0; /* composite PRIMARY KEY value */
drh04adf412008-01-08 18:57:50 +0000346
drheeb844a2009-08-08 18:01:07 +0000347 memset(&sContext, 0, sizeof(sContext));
drh17435752007-08-16 04:30:38 +0000348 db = pParse->db;
349 if( pParse->nErr || db->mallocFailed ){
drh6f7adc82006-01-11 21:41:20 +0000350 goto update_cleanup;
351 }
drhdaffd0e2001-04-11 14:28:42 +0000352
drhb2fe7d82003-04-20 17:29:23 +0000353 /* Locate the table which we want to update.
drhcce7d172000-05-31 15:34:51 +0000354 */
danielk19774adee202004-05-08 08:23:19 +0000355 pTab = sqlite3SrcListLookup(pParse, pTabList);
drha69d9162003-04-17 22:57:53 +0000356 if( pTab==0 ) goto update_cleanup;
danielk1977da184232006-01-05 11:34:32 +0000357 iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
drhb7f91642004-10-31 02:22:47 +0000358
359 /* Figure out if we have any triggers and if the table being
dan76d462e2009-08-30 11:42:51 +0000360 ** updated is a view.
drhb7f91642004-10-31 02:22:47 +0000361 */
362#ifndef SQLITE_OMIT_TRIGGER
danbb5f1682009-11-27 12:12:34 +0000363 pTrigger = sqlite3TriggersExist(pParse, pTab, TK_UPDATE, pChanges, &tmask);
drh5cf590c2003-04-24 01:45:04 +0000364 isView = pTab->pSelect!=0;
danbb5f1682009-11-27 12:12:34 +0000365 assert( pTrigger || tmask==0 );
drhb7f91642004-10-31 02:22:47 +0000366#else
danielk19772f886d12009-02-28 10:47:41 +0000367# define pTrigger 0
drhb7f91642004-10-31 02:22:47 +0000368# define isView 0
danbb5f1682009-11-27 12:12:34 +0000369# define tmask 0
drhb7f91642004-10-31 02:22:47 +0000370#endif
371#ifdef SQLITE_OMIT_VIEW
372# undef isView
373# define isView 0
374#endif
dan243210b2020-07-15 15:32:59 +0000375
376 /* If there was a FROM clause, set nChangeFrom to the number of expressions
377 ** in the change-list. Otherwise, set it to 0. There cannot be a FROM
378 ** clause if this function is being called to generate code for part of
379 ** an UPSERT statement. */
dan69887c92020-04-27 20:55:33 +0000380 nChangeFrom = (pTabList->nSrc>1) ? pChanges->nExpr : 0;
381 assert( nChangeFrom==0 || pUpsert==0 );
drhb7f91642004-10-31 02:22:47 +0000382
danb3c16b82017-11-09 19:53:06 +0000383#ifdef SQLITE_ENABLE_UPDATE_DELETE_LIMIT
danf2972b62020-04-29 20:11:01 +0000384 if( !isView && nChangeFrom==0 ){
danb3c16b82017-11-09 19:53:06 +0000385 pWhere = sqlite3LimitWhere(
drh8c0833f2017-11-14 23:48:23 +0000386 pParse, pTabList, pWhere, pOrderBy, pLimit, "UPDATE"
danb3c16b82017-11-09 19:53:06 +0000387 );
388 pOrderBy = 0;
drh8c0833f2017-11-14 23:48:23 +0000389 pLimit = 0;
danb3c16b82017-11-09 19:53:06 +0000390 }
391#endif
392
danielk1977595a5232009-07-24 17:58:53 +0000393 if( sqlite3ViewGetColumnNames(pParse, pTab) ){
drh5cf590c2003-04-24 01:45:04 +0000394 goto update_cleanup;
drha69d9162003-04-17 22:57:53 +0000395 }
danbb5f1682009-11-27 12:12:34 +0000396 if( sqlite3IsReadOnly(pParse, pTab, tmask) ){
danielk1977b3d24bf2006-06-19 03:05:10 +0000397 goto update_cleanup;
drh5cf590c2003-04-24 01:45:04 +0000398 }
drhcce7d172000-05-31 15:34:51 +0000399
drh53e3fc72002-07-16 17:22:50 +0000400 /* Allocate a cursors for the main database table and for all indices.
401 ** The index cursors might not be used, but if they are used they
402 ** need to occur right after the database cursor. So go ahead and
403 ** allocate enough space, just in case.
404 */
drh2ac4e5c2018-04-20 00:40:19 +0000405 iBaseCur = iDataCur = pParse->nTab++;
drh313619f2013-10-31 20:34:06 +0000406 iIdxCur = iDataCur+1;
drh77f64bb2013-10-31 12:13:37 +0000407 pPk = HasRowid(pTab) ? 0 : sqlite3PrimaryKeyIndex(pTab);
drh2ac4e5c2018-04-20 00:40:19 +0000408 testcase( pPk!=0 && pPk!=pTab->pIndex );
drh77f64bb2013-10-31 12:13:37 +0000409 for(nIdx=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, nIdx++){
drh2ac4e5c2018-04-20 00:40:19 +0000410 if( pPk==pIdx ){
drh313619f2013-10-31 20:34:06 +0000411 iDataCur = pParse->nTab;
drh313619f2013-10-31 20:34:06 +0000412 }
drh53e3fc72002-07-16 17:22:50 +0000413 pParse->nTab++;
414 }
drh7fc3aba2018-04-20 13:18:51 +0000415 if( pUpsert ){
drhfb2213e2018-04-20 15:56:24 +0000416 /* On an UPSERT, reuse the same cursors already opened by INSERT */
drh7fc3aba2018-04-20 13:18:51 +0000417 iDataCur = pUpsert->iDataCur;
418 iIdxCur = pUpsert->iIdxCur;
419 pParse->nTab = iBaseCur;
420 }
drh2ac4e5c2018-04-20 00:40:19 +0000421 pTabList->a[0].iCursor = iDataCur;
drh53e3fc72002-07-16 17:22:50 +0000422
drh6a534992013-11-16 20:13:39 +0000423 /* Allocate space for aXRef[], aRegIdx[], and aToOpen[].
424 ** Initialize aXRef[] and aToOpen[] to their default values.
425 */
drha7c3b932019-05-07 19:13:42 +0000426 aXRef = sqlite3DbMallocRawNN(db, sizeof(int) * (pTab->nCol+nIdx+1) + nIdx+2 );
drh6a534992013-11-16 20:13:39 +0000427 if( aXRef==0 ) goto update_cleanup;
428 aRegIdx = aXRef+pTab->nCol;
drha7c3b932019-05-07 19:13:42 +0000429 aToOpen = (u8*)(aRegIdx+nIdx+1);
drh6a534992013-11-16 20:13:39 +0000430 memset(aToOpen, 1, nIdx+1);
431 aToOpen[nIdx+1] = 0;
432 for(i=0; i<pTab->nCol; i++) aXRef[i] = -1;
433
danielk1977b3bce662005-01-29 08:32:43 +0000434 /* Initialize the name-context */
435 memset(&sNC, 0, sizeof(sNC));
436 sNC.pParse = pParse;
437 sNC.pSrcList = pTabList;
drheac9fab2018-04-16 13:00:50 +0000438 sNC.uNC.pUpsert = pUpsert;
439 sNC.ncFlags = NC_UUpsert;
danielk1977b3bce662005-01-29 08:32:43 +0000440
mistachkin16fd04c2019-10-16 17:46:22 +0000441 /* Begin generating code. */
442 v = sqlite3GetVdbe(pParse);
443 if( v==0 ) goto update_cleanup;
444
drh85e20962003-04-25 17:52:11 +0000445 /* Resolve the column names in all the expressions of the
446 ** of the UPDATE statement. Also find the column index
drhed6c8672003-01-12 18:02:16 +0000447 ** for each column to be updated in the pChanges array. For each
448 ** column to be updated, make sure we have authorization to change
449 ** that column.
drhcce7d172000-05-31 15:34:51 +0000450 */
drhf8ffb272013-11-01 17:08:56 +0000451 chngRowid = chngPk = 0;
drhcce7d172000-05-31 15:34:51 +0000452 for(i=0; i<pChanges->nExpr; i++){
dan69887c92020-04-27 20:55:33 +0000453 /* If this is an UPDATE with a FROM clause, do not resolve expressions
454 ** here. The call to sqlite3Select() below will do that. */
455 if( nChangeFrom==0 && sqlite3ResolveExprNames(&sNC, pChanges->a[i].pExpr) ){
drhcce7d172000-05-31 15:34:51 +0000456 goto update_cleanup;
457 }
458 for(j=0; j<pTab->nCol; j++){
drh41cee662019-12-12 20:22:34 +0000459 if( sqlite3StrICmp(pTab->aCol[j].zName, pChanges->a[i].zEName)==0 ){
drh9647ff82002-01-14 02:56:24 +0000460 if( j==pTab->iPKey ){
drhf0863fe2005-06-12 21:35:51 +0000461 chngRowid = 1;
462 pRowidExpr = pChanges->a[i].pExpr;
dan74657872020-05-01 18:43:49 +0000463 iRowidExpr = i;
drhf8ffb272013-11-01 17:08:56 +0000464 }else if( pPk && (pTab->aCol[j].colFlags & COLFLAG_PRIMKEY)!=0 ){
465 chngPk = 1;
drh4a324312001-12-21 14:30:42 +0000466 }
drh8a53ce22019-10-17 15:59:03 +0000467#ifndef SQLITE_OMIT_GENERATED_COLUMNS
drh427b96a2019-10-22 13:01:24 +0000468 else if( pTab->aCol[j].colFlags & COLFLAG_GENERATED ){
drh6ab61d72019-10-23 15:47:33 +0000469 testcase( pTab->aCol[j].colFlags & COLFLAG_VIRTUAL );
470 testcase( pTab->aCol[j].colFlags & COLFLAG_STORED );
drh8a53ce22019-10-17 15:59:03 +0000471 sqlite3ErrorMsg(pParse,
472 "cannot UPDATE generated column \"%s\"",
473 pTab->aCol[j].zName);
474 goto update_cleanup;
475 }
476#endif
drhcce7d172000-05-31 15:34:51 +0000477 aXRef[j] = i;
478 break;
479 }
480 }
481 if( j>=pTab->nCol ){
drh41cee662019-12-12 20:22:34 +0000482 if( pPk==0 && sqlite3IsRowid(pChanges->a[i].zEName) ){
drh27228982013-05-06 13:22:50 +0000483 j = -1;
drhf0863fe2005-06-12 21:35:51 +0000484 chngRowid = 1;
485 pRowidExpr = pChanges->a[i].pExpr;
dan74657872020-05-01 18:43:49 +0000486 iRowidExpr = i;
drha0217ba2003-06-01 01:10:33 +0000487 }else{
drh41cee662019-12-12 20:22:34 +0000488 sqlite3ErrorMsg(pParse, "no such column: %s", pChanges->a[i].zEName);
dan1db95102010-06-28 10:15:19 +0000489 pParse->checkSchema = 1;
drha0217ba2003-06-01 01:10:33 +0000490 goto update_cleanup;
491 }
drhcce7d172000-05-31 15:34:51 +0000492 }
drhed6c8672003-01-12 18:02:16 +0000493#ifndef SQLITE_OMIT_AUTHORIZATION
drhe5f9c642003-01-13 23:27:31 +0000494 {
495 int rc;
danielk19774adee202004-05-08 08:23:19 +0000496 rc = sqlite3AuthCheck(pParse, SQLITE_UPDATE, pTab->zName,
drh27228982013-05-06 13:22:50 +0000497 j<0 ? "ROWID" : pTab->aCol[j].zName,
drh69c33822016-08-18 14:33:11 +0000498 db->aDb[iDb].zDbSName);
drhe5f9c642003-01-13 23:27:31 +0000499 if( rc==SQLITE_DENY ){
500 goto update_cleanup;
501 }else if( rc==SQLITE_IGNORE ){
502 aXRef[j] = -1;
503 }
drhed6c8672003-01-12 18:02:16 +0000504 }
505#endif
drhcce7d172000-05-31 15:34:51 +0000506 }
drhf8ffb272013-11-01 17:08:56 +0000507 assert( (chngRowid & chngPk)==0 );
508 assert( chngRowid==0 || chngRowid==1 );
509 assert( chngPk==0 || chngPk==1 );
510 chngKey = chngRowid + chngPk;
drhcce7d172000-05-31 15:34:51 +0000511
drh7e7fd732019-10-22 13:59:23 +0000512#ifndef SQLITE_OMIT_GENERATED_COLUMNS
513 /* Mark generated columns as changing if their generator expressions
514 ** reference any changing column. The actual aXRef[] value for
515 ** generated expressions is not used, other than to check to see that it
516 ** is non-negative, so the value of aXRef[] for generated columns can be
517 ** set to any non-negative number. We use 99999 so that the value is
518 ** obvious when looking at aXRef[] in a symbolic debugger.
519 */
520 if( pTab->tabFlags & TF_HasGenerated ){
521 int bProgress;
522 testcase( pTab->tabFlags & TF_HasVirtual );
523 testcase( pTab->tabFlags & TF_HasStored );
524 do{
525 bProgress = 0;
526 for(i=0; i<pTab->nCol; i++){
527 if( aXRef[i]>=0 ) continue;
528 if( (pTab->aCol[i].colFlags & COLFLAG_GENERATED)==0 ) continue;
529 if( sqlite3ExprReferencesUpdatedColumn(pTab->aCol[i].pDflt,
530 aXRef, chngRowid) ){
531 aXRef[i] = 99999;
532 bProgress = 1;
533 }
534 }
535 }while( bProgress );
536 }
537#endif
538
dan1acb5392015-11-26 19:33:41 +0000539 /* The SET expressions are not actually used inside the WHERE loop.
540 ** So reset the colUsed mask. Unless this is a virtual table. In that
541 ** case, set all bits of the colUsed mask (to ensure that the virtual
542 ** table implementation makes all columns available).
drh5c82f4d2013-11-19 02:34:11 +0000543 */
drh8426e362016-03-08 01:32:30 +0000544 pTabList->a[0].colUsed = IsVirtual(pTab) ? ALLBITS : 0;
drh5c82f4d2013-11-19 02:34:11 +0000545
drhf8ffb272013-11-01 17:08:56 +0000546 hasFK = sqlite3FkRequired(pParse, pTab, aXRef, chngKey);
dane7a94d82009-10-01 16:09:04 +0000547
drh6a534992013-11-16 20:13:39 +0000548 /* There is one entry in the aRegIdx[] array for each index on the table
549 ** being updated. Fill in aRegIdx[] with a register number that will hold
drh1f9ca2c2015-08-25 16:57:52 +0000550 ** the key for accessing each index.
drhcce7d172000-05-31 15:34:51 +0000551 */
drh247c1b42019-01-22 13:45:48 +0000552 if( onError==OE_Replace ) bReplace = 1;
drh9e9374b2019-05-08 19:06:59 +0000553 for(nAllIdx=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, nAllIdx++){
drhaa9b8962008-01-08 02:57:55 +0000554 int reg;
drh40b4e7a2018-09-17 20:47:38 +0000555 if( chngKey || hasFK>1 || pIdx==pPk
556 || indexWhereClauseMightChange(pIdx,aXRef,chngRowid)
557 ){
drhaa9b8962008-01-08 02:57:55 +0000558 reg = ++pParse->nMem;
drh2c4dfc32016-11-10 14:24:04 +0000559 pParse->nMem += pIdx->nColumn;
drhaa9b8962008-01-08 02:57:55 +0000560 }else{
561 reg = 0;
drhf8ffb272013-11-01 17:08:56 +0000562 for(i=0; i<pIdx->nKeyCol; i++){
drh2b7cdf62018-09-16 15:01:25 +0000563 if( indexColumnIsBeingUpdated(pIdx, i, aXRef, chngRowid) ){
drhaa9b8962008-01-08 02:57:55 +0000564 reg = ++pParse->nMem;
drh2c4dfc32016-11-10 14:24:04 +0000565 pParse->nMem += pIdx->nColumn;
drh247c1b42019-01-22 13:45:48 +0000566 if( onError==OE_Default && pIdx->onError==OE_Replace ){
dan2c6fec22017-01-11 19:03:08 +0000567 bReplace = 1;
568 }
drhaa9b8962008-01-08 02:57:55 +0000569 break;
570 }
drh4a324312001-12-21 14:30:42 +0000571 }
drhcce7d172000-05-31 15:34:51 +0000572 }
drh9e9374b2019-05-08 19:06:59 +0000573 if( reg==0 ) aToOpen[nAllIdx+1] = 0;
574 aRegIdx[nAllIdx] = reg;
drhcce7d172000-05-31 15:34:51 +0000575 }
drh9e9374b2019-05-08 19:06:59 +0000576 aRegIdx[nAllIdx] = ++pParse->nMem; /* Register storing the table record */
dan2c6fec22017-01-11 19:03:08 +0000577 if( bReplace ){
578 /* If REPLACE conflict resolution might be invoked, open cursors on all
579 ** indexes in case they are needed to delete records. */
580 memset(aToOpen, 1, nIdx+1);
581 }
drhcce7d172000-05-31 15:34:51 +0000582
drh4794f732004-11-05 17:17:50 +0000583 if( pParse->nested==0 ) sqlite3VdbeCountChanges(v);
drhac9151d2018-04-20 19:32:35 +0000584 sqlite3BeginWriteOperation(pParse, pTrigger || hasFK, iDb);
drhcce7d172000-05-31 15:34:51 +0000585
dan165921a2009-08-28 18:53:45 +0000586 /* Allocate required registers. */
dan0f400372015-09-28 20:03:49 +0000587 if( !IsVirtual(pTab) ){
drh9e9374b2019-05-08 19:06:59 +0000588 /* For now, regRowSet and aRegIdx[nAllIdx] share the same register.
589 ** If regRowSet turns out to be needed, then aRegIdx[nAllIdx] will be
590 ** reallocated. aRegIdx[nAllIdx] is the register in which the main
591 ** table record is written. regRowSet holds the RowSet for the
592 ** two-pass update algorithm. */
593 assert( aRegIdx[nAllIdx]==pParse->nMem );
594 regRowSet = aRegIdx[nAllIdx];
dan0f400372015-09-28 20:03:49 +0000595 regOldRowid = regNewRowid = ++pParse->nMem;
596 if( chngPk || pTrigger || hasFK ){
597 regOld = pParse->nMem + 1;
598 pParse->nMem += pTab->nCol;
599 }
600 if( chngKey || pTrigger || hasFK ){
601 regNewRowid = ++pParse->nMem;
602 }
603 regNew = pParse->nMem + 1;
dan165921a2009-08-28 18:53:45 +0000604 pParse->nMem += pTab->nCol;
605 }
dan165921a2009-08-28 18:53:45 +0000606
607 /* Start the view context. */
danielk19774273dea2006-06-17 06:31:18 +0000608 if( isView ){
609 sqlite3AuthContextPush(pParse, &sContext, pTab->zName);
610 }
611
drh9d2985c2005-09-08 01:58:42 +0000612 /* If we are trying to update a view, realize that view into
peter.d.reid60ec9142014-09-06 16:39:46 +0000613 ** an ephemeral table.
drh5cf590c2003-04-24 01:45:04 +0000614 */
shanefa4e62f2008-09-01 21:59:42 +0000615#if !defined(SQLITE_OMIT_VIEW) && !defined(SQLITE_OMIT_TRIGGER)
dan69887c92020-04-27 20:55:33 +0000616 if( nChangeFrom==0 && isView ){
danb3c16b82017-11-09 19:53:06 +0000617 sqlite3MaterializeView(pParse, pTab,
drh8c0833f2017-11-14 23:48:23 +0000618 pWhere, pOrderBy, pLimit, iDataCur
danb3c16b82017-11-09 19:53:06 +0000619 );
620 pOrderBy = 0;
drh8c0833f2017-11-14 23:48:23 +0000621 pLimit = 0;
drh0f35a6b2008-02-12 16:52:14 +0000622 }
shanefa4e62f2008-09-01 21:59:42 +0000623#endif
drh1013c932008-01-06 00:25:21 +0000624
drh0f35a6b2008-02-12 16:52:14 +0000625 /* Resolve the column names in all the expressions in the
626 ** WHERE clause.
627 */
dan69887c92020-04-27 20:55:33 +0000628 if( nChangeFrom==0 && sqlite3ResolveExprNames(&sNC, pWhere) ){
drh0f35a6b2008-02-12 16:52:14 +0000629 goto update_cleanup;
drh5cf590c2003-04-24 01:45:04 +0000630 }
631
dan0f400372015-09-28 20:03:49 +0000632#ifndef SQLITE_OMIT_VIRTUALTABLE
633 /* Virtual tables must be handled separately */
634 if( IsVirtual(pTab) ){
635 updateVirtualTable(pParse, pTabList, pTab, pChanges, pRowidExpr, aXRef,
636 pWhere, onError);
637 goto update_cleanup;
638 }
639#endif
640
drhfb2213e2018-04-20 15:56:24 +0000641 /* Jump to labelBreak to abandon further processing of this UPDATE */
drhec4ccdb2018-12-29 02:26:59 +0000642 labelContinue = labelBreak = sqlite3VdbeMakeLabel(pParse);
danf91c1312017-01-10 20:04:38 +0000643
drh5deb1812018-04-20 16:27:57 +0000644 /* Not an UPSERT. Normal processing. Begin by
645 ** initialize the count of updated rows */
646 if( (db->flags&SQLITE_CountRows)!=0
647 && !pParse->pTriggerTab
648 && !pParse->nested
drhd086aa02021-01-29 21:31:59 +0000649 && !pParse->bReturning
drh5deb1812018-04-20 16:27:57 +0000650 && pUpsert==0
651 ){
652 regRowCount = ++pParse->nMem;
653 sqlite3VdbeAddOp2(v, OP_Integer, 0, regRowCount);
654 }
655
dan69887c92020-04-27 20:55:33 +0000656 if( nChangeFrom==0 && HasRowid(pTab) ){
drh5deb1812018-04-20 16:27:57 +0000657 sqlite3VdbeAddOp3(v, OP_Null, 0, regRowSet, regOldRowid);
drhea248722020-11-14 20:03:34 +0000658 iEph = pParse->nTab++;
drh32881be2020-11-17 21:26:13 +0000659 addrOpen = sqlite3VdbeAddOp3(v, OP_OpenEphemeral, iEph, 0, regRowSet);
drh5deb1812018-04-20 16:27:57 +0000660 }else{
dan69887c92020-04-27 20:55:33 +0000661 assert( pPk!=0 || HasRowid(pTab) );
662 nPk = pPk ? pPk->nKeyCol : 0;
drh5deb1812018-04-20 16:27:57 +0000663 iPk = pParse->nMem+1;
664 pParse->nMem += nPk;
dan69887c92020-04-27 20:55:33 +0000665 pParse->nMem += nChangeFrom;
drh5deb1812018-04-20 16:27:57 +0000666 regKey = ++pParse->nMem;
667 if( pUpsert==0 ){
dan69887c92020-04-27 20:55:33 +0000668 int nEphCol = nPk + nChangeFrom + (isView ? pTab->nCol : 0);
drh5deb1812018-04-20 16:27:57 +0000669 iEph = pParse->nTab++;
dan69887c92020-04-27 20:55:33 +0000670 if( pPk ) sqlite3VdbeAddOp3(v, OP_Null, 0, iPk, iPk+nPk-1);
671 addrOpen = sqlite3VdbeAddOp2(v, OP_OpenEphemeral, iEph, nEphCol);
danbe952c12020-07-13 20:10:29 +0000672 if( pPk ){
673 KeyInfo *pKeyInfo = sqlite3KeyInfoOfIndex(pParse, pPk);
674 if( pKeyInfo ){
675 pKeyInfo->nAllField = nEphCol;
676 sqlite3VdbeAppendP4(v, pKeyInfo, P4_KEYINFO);
677 }
678 }
dan69887c92020-04-27 20:55:33 +0000679 if( nChangeFrom ){
dan576d5a82020-07-15 18:30:01 +0000680 updateFromSelect(
danf2972b62020-04-29 20:11:01 +0000681 pParse, iEph, pPk, pChanges, pTabList, pWhere, pOrderBy, pLimit
682 );
dan69887c92020-04-27 20:55:33 +0000683#ifndef SQLITE_OMIT_SUBQUERY
684 if( isView ) iDataCur = iEph;
685#endif
686 }
drh5deb1812018-04-20 16:27:57 +0000687 }
688 }
689
dan69887c92020-04-27 20:55:33 +0000690 if( nChangeFrom ){
691 sqlite3MultiWrite(pParse);
692 eOnePass = ONEPASS_OFF;
dan74657872020-05-01 18:43:49 +0000693 nKey = nPk;
694 regKey = iPk;
drhfb2213e2018-04-20 15:56:24 +0000695 }else{
dan69887c92020-04-27 20:55:33 +0000696 if( pUpsert ){
697 /* If this is an UPSERT, then all cursors have already been opened by
698 ** the outer INSERT and the data cursor should be pointing at the row
699 ** that is to be updated. So bypass the code that searches for the
700 ** row(s) to be updated.
701 */
702 pWInfo = 0;
703 eOnePass = ONEPASS_SINGLE;
704 sqlite3ExprIfFalse(pParse, pWhere, labelBreak, SQLITE_JUMPIFNULL);
705 bFinishSeek = 0;
706 }else{
707 /* Begin the database scan.
708 **
709 ** Do not consider a single-pass strategy for a multi-row update if
710 ** there are any triggers or foreign keys to process, or rows may
711 ** be deleted as a result of REPLACE conflict handling. Any of these
712 ** things might disturb a cursor being used to scan through the table
713 ** or index, causing a single-pass approach to malfunction. */
drh68c0c712020-08-14 20:04:26 +0000714 flags = WHERE_ONEPASS_DESIRED;
dan69887c92020-04-27 20:55:33 +0000715 if( !pParse->nested && !pTrigger && !hasFK && !chngKey && !bReplace ){
716 flags |= WHERE_ONEPASS_MULTIROW;
717 }
718 pWInfo = sqlite3WhereBegin(pParse, pTabList, pWhere, 0, 0, flags,iIdxCur);
719 if( pWInfo==0 ) goto update_cleanup;
720
721 /* A one-pass strategy that might update more than one row may not
722 ** be used if any column of the index used for the scan is being
723 ** updated. Otherwise, if there is an index on "b", statements like
724 ** the following could create an infinite loop:
725 **
726 ** UPDATE t1 SET b=b+1 WHERE b>?
727 **
728 ** Fall back to ONEPASS_OFF if where.c has selected a ONEPASS_MULTI
729 ** strategy that uses an index for which one or more columns are being
730 ** updated. */
731 eOnePass = sqlite3WhereOkOnePass(pWInfo, aiCurOnePass);
732 bFinishSeek = sqlite3WhereUsesDeferredSeek(pWInfo);
733 if( eOnePass!=ONEPASS_SINGLE ){
734 sqlite3MultiWrite(pParse);
735 if( eOnePass==ONEPASS_MULTI ){
736 int iCur = aiCurOnePass[1];
737 if( iCur>=0 && iCur!=iDataCur && aToOpen[iCur-iBaseCur] ){
738 eOnePass = ONEPASS_OFF;
739 }
740 assert( iCur!=iDataCur || !HasRowid(pTab) );
drhac9151d2018-04-20 19:32:35 +0000741 }
dan69887c92020-04-27 20:55:33 +0000742 }
743 }
744
745 if( HasRowid(pTab) ){
746 /* Read the rowid of the current row of the WHERE scan. In ONEPASS_OFF
747 ** mode, write the rowid into the FIFO. In either of the one-pass modes,
748 ** leave it in register regOldRowid. */
749 sqlite3VdbeAddOp2(v, OP_Rowid, iDataCur, regOldRowid);
750 if( eOnePass==ONEPASS_OFF ){
dan69887c92020-04-27 20:55:33 +0000751 aRegIdx[nAllIdx] = ++pParse->nMem;
drhea248722020-11-14 20:03:34 +0000752 sqlite3VdbeAddOp3(v, OP_Insert, iEph, regRowSet, regOldRowid);
753 }else{
drh32881be2020-11-17 21:26:13 +0000754 if( ALWAYS(addrOpen) ) sqlite3VdbeChangeToNoop(v, addrOpen);
dan69887c92020-04-27 20:55:33 +0000755 }
756 }else{
757 /* Read the PK of the current row into an array of registers. In
758 ** ONEPASS_OFF mode, serialize the array into a record and store it in
759 ** the ephemeral table. Or, in ONEPASS_SINGLE or MULTI mode, change
760 ** the OP_OpenEphemeral instruction to a Noop (the ephemeral table
761 ** is not required) and leave the PK fields in the array of registers. */
762 for(i=0; i<nPk; i++){
763 assert( pPk->aiColumn[i]>=0 );
764 sqlite3ExprCodeGetColumnOfTable(v, pTab, iDataCur,
765 pPk->aiColumn[i], iPk+i);
766 }
767 if( eOnePass ){
768 if( addrOpen ) sqlite3VdbeChangeToNoop(v, addrOpen);
769 nKey = nPk;
770 regKey = iPk;
771 }else{
772 sqlite3VdbeAddOp4(v, OP_MakeRecord, iPk, nPk, regKey,
773 sqlite3IndexAffinityStr(db, pPk), nPk);
774 sqlite3VdbeAddOp4Int(v, OP_IdxInsert, iEph, regKey, iPk, nPk);
drhfb2213e2018-04-20 15:56:24 +0000775 }
drhfb2213e2018-04-20 15:56:24 +0000776 }
777 }
778
drhfb2213e2018-04-20 15:56:24 +0000779 if( pUpsert==0 ){
dan69887c92020-04-27 20:55:33 +0000780 if( nChangeFrom==0 && eOnePass!=ONEPASS_MULTI ){
drhfb2213e2018-04-20 15:56:24 +0000781 sqlite3WhereEnd(pWInfo);
782 }
783
784 if( !isView ){
785 int addrOnce = 0;
786
787 /* Open every index that needs updating. */
788 if( eOnePass!=ONEPASS_OFF ){
789 if( aiCurOnePass[0]>=0 ) aToOpen[aiCurOnePass[0]-iBaseCur] = 0;
790 if( aiCurOnePass[1]>=0 ) aToOpen[aiCurOnePass[1]-iBaseCur] = 0;
791 }
792
793 if( eOnePass==ONEPASS_MULTI && (nIdx-(aiCurOnePass[1]>=0))>0 ){
794 addrOnce = sqlite3VdbeAddOp0(v, OP_Once); VdbeCoverage(v);
795 }
796 sqlite3OpenTableAndIndices(pParse, pTab, OP_OpenWrite, 0, iBaseCur,
797 aToOpen, 0, 0);
drhdc4f6fc2020-02-07 19:44:13 +0000798 if( addrOnce ){
799 sqlite3VdbeJumpHereOrPopInst(v, addrOnce);
800 }
drhfb2213e2018-04-20 15:56:24 +0000801 }
802
803 /* Top of the update loop */
danf91c1312017-01-10 20:04:38 +0000804 if( eOnePass!=ONEPASS_OFF ){
drh6e5020e2021-04-07 15:45:01 +0000805 if( aiCurOnePass[0]!=iDataCur
806 && aiCurOnePass[1]!=iDataCur
807#ifdef SQLITE_ALLOW_ROWID_IN_VIEW
808 && !isView
809#endif
810 ){
drhfb2213e2018-04-20 15:56:24 +0000811 assert( pPk );
812 sqlite3VdbeAddOp4Int(v, OP_NotFound, iDataCur, labelBreak, regKey,nKey);
drh6ccbd272018-07-10 17:10:44 +0000813 VdbeCoverage(v);
drhfb2213e2018-04-20 15:56:24 +0000814 }
drh4b8bd842018-04-20 20:09:22 +0000815 if( eOnePass!=ONEPASS_SINGLE ){
drhec4ccdb2018-12-29 02:26:59 +0000816 labelContinue = sqlite3VdbeMakeLabel(pParse);
drhfb2213e2018-04-20 15:56:24 +0000817 }
818 sqlite3VdbeAddOp2(v, OP_IsNull, pPk ? regKey : regOldRowid, labelBreak);
819 VdbeCoverageIf(v, pPk==0);
820 VdbeCoverageIf(v, pPk!=0);
dan69887c92020-04-27 20:55:33 +0000821 }else if( pPk || nChangeFrom ){
drhec4ccdb2018-12-29 02:26:59 +0000822 labelContinue = sqlite3VdbeMakeLabel(pParse);
drhfb2213e2018-04-20 15:56:24 +0000823 sqlite3VdbeAddOp2(v, OP_Rewind, iEph, labelBreak); VdbeCoverage(v);
dan69887c92020-04-27 20:55:33 +0000824 addrTop = sqlite3VdbeCurrentAddr(v);
825 if( nChangeFrom ){
826 if( !isView ){
827 if( pPk ){
828 for(i=0; i<nPk; i++){
829 sqlite3VdbeAddOp3(v, OP_Column, iEph, i, iPk+i);
830 }
831 sqlite3VdbeAddOp4Int(
832 v, OP_NotFound, iDataCur, labelContinue, iPk, nPk
drh6265c472020-07-16 00:45:25 +0000833 ); VdbeCoverage(v);
dan69887c92020-04-27 20:55:33 +0000834 }else{
835 sqlite3VdbeAddOp2(v, OP_Rowid, iEph, regOldRowid);
836 sqlite3VdbeAddOp3(
837 v, OP_NotExists, iDataCur, labelContinue, regOldRowid
drh6265c472020-07-16 00:45:25 +0000838 ); VdbeCoverage(v);
dan69887c92020-04-27 20:55:33 +0000839 }
840 }
dan69887c92020-04-27 20:55:33 +0000841 }else{
842 sqlite3VdbeAddOp2(v, OP_RowData, iEph, regKey);
843 sqlite3VdbeAddOp4Int(v, OP_NotFound, iDataCur, labelContinue, regKey,0);
844 VdbeCoverage(v);
845 }
drhfb2213e2018-04-20 15:56:24 +0000846 }else{
drhea248722020-11-14 20:03:34 +0000847 sqlite3VdbeAddOp2(v, OP_Rewind, iEph, labelBreak); VdbeCoverage(v);
848 labelContinue = sqlite3VdbeMakeLabel(pParse);
849 addrTop = sqlite3VdbeAddOp2(v, OP_Rowid, iEph, regOldRowid);
drhfb2213e2018-04-20 15:56:24 +0000850 VdbeCoverage(v);
851 sqlite3VdbeAddOp3(v, OP_NotExists, iDataCur, labelContinue, regOldRowid);
852 VdbeCoverage(v);
danf91c1312017-01-10 20:04:38 +0000853 }
drh08c88eb2008-04-10 13:33:18 +0000854 }
danielk1977e448dc42008-01-02 11:50:51 +0000855
drh70076402018-04-12 19:51:22 +0000856 /* If the rowid value will change, set register regNewRowid to
857 ** contain the new value. If the rowid is not being modified,
dan1da40a32009-09-19 17:00:31 +0000858 ** then regNewRowid is the same register as regOldRowid, which is
859 ** already populated. */
drhf8ffb272013-11-01 17:08:56 +0000860 assert( chngKey || pTrigger || hasFK || regOldRowid==regNewRowid );
dan1da40a32009-09-19 17:00:31 +0000861 if( chngRowid ){
dan74657872020-05-01 18:43:49 +0000862 assert( iRowidExpr>=0 );
863 if( nChangeFrom==0 ){
864 sqlite3ExprCode(pParse, pRowidExpr, regNewRowid);
865 }else{
866 sqlite3VdbeAddOp3(v, OP_Column, iEph, iRowidExpr, regNewRowid);
867 }
drh688852a2014-02-17 22:40:43 +0000868 sqlite3VdbeAddOp1(v, OP_MustBeInt, regNewRowid); VdbeCoverage(v);
dan1da40a32009-09-19 17:00:31 +0000869 }
870
drhf8ffb272013-11-01 17:08:56 +0000871 /* Compute the old pre-UPDATE content of the row being changed, if that
872 ** information is needed */
873 if( chngPk || hasFK || pTrigger ){
dane7a94d82009-10-01 16:09:04 +0000874 u32 oldmask = (hasFK ? sqlite3FkOldmask(pParse, pTab) : 0);
danbb5f1682009-11-27 12:12:34 +0000875 oldmask |= sqlite3TriggerColmask(pParse,
876 pTrigger, pChanges, 0, TRIGGER_BEFORE|TRIGGER_AFTER, pTab, onError
877 );
drhff37c402019-10-31 20:54:20 +0000878 for(i=0; i<pTab->nCol; i++){
drh8a53ce22019-10-17 15:59:03 +0000879 u32 colFlags = pTab->aCol[i].colFlags;
drhff37c402019-10-31 20:54:20 +0000880 k = sqlite3TableColumnToStorage(pTab, i) + regOld;
drhf8ffb272013-11-01 17:08:56 +0000881 if( oldmask==0xffffffff
drh693e6712014-01-24 22:58:00 +0000882 || (i<32 && (oldmask & MASKBIT32(i))!=0)
drh8a53ce22019-10-17 15:59:03 +0000883 || (colFlags & COLFLAG_PRIMKEY)!=0
drhf8ffb272013-11-01 17:08:56 +0000884 ){
drh693e6712014-01-24 22:58:00 +0000885 testcase( oldmask!=0xffffffff && i==31 );
drh6df9c4b2019-10-18 12:52:08 +0000886 sqlite3ExprCodeGetColumnOfTable(v, pTab, iDataCur, i, k);
danielk1977c3f9bad2002-05-15 08:30:12 +0000887 }else{
drh8a53ce22019-10-17 15:59:03 +0000888 sqlite3VdbeAddOp2(v, OP_Null, 0, k);
danielk1977c3f9bad2002-05-15 08:30:12 +0000889 }
890 }
drhf8ffb272013-11-01 17:08:56 +0000891 if( chngRowid==0 && pPk==0 ){
dan1da40a32009-09-19 17:00:31 +0000892 sqlite3VdbeAddOp2(v, OP_Copy, regOldRowid, regNewRowid);
893 }
dan165921a2009-08-28 18:53:45 +0000894 }
drh5cf590c2003-04-24 01:45:04 +0000895
dan165921a2009-08-28 18:53:45 +0000896 /* Populate the array of registers beginning at regNew with the new
peter.d.reid60ec9142014-09-06 16:39:46 +0000897 ** row data. This array is used to check constants, create the new
dan165921a2009-08-28 18:53:45 +0000898 ** table and index records, and as the values for any new.* references
danbb5f1682009-11-27 12:12:34 +0000899 ** made by triggers.
900 **
901 ** If there are one or more BEFORE triggers, then do not populate the
902 ** registers associated with columns that are (a) not modified by
903 ** this UPDATE statement and (b) not accessed by new.* references. The
904 ** values for registers not modified by the UPDATE must be reloaded from
905 ** the database after the BEFORE triggers are fired anyway (as the trigger
906 ** may have modified them). So not loading those that are not going to
907 ** be used eliminates some redundant opcodes.
908 */
909 newmask = sqlite3TriggerColmask(
910 pParse, pTrigger, pChanges, 1, TRIGGER_BEFORE, pTab, onError
911 );
drh8a53ce22019-10-17 15:59:03 +0000912 for(i=0, k=regNew; i<pTab->nCol; i++, k++){
dan165921a2009-08-28 18:53:45 +0000913 if( i==pTab->iPKey ){
drh8a53ce22019-10-17 15:59:03 +0000914 sqlite3VdbeAddOp2(v, OP_Null, 0, k);
drhc1431142019-10-17 17:54:05 +0000915 }else if( (pTab->aCol[i].colFlags & COLFLAG_GENERATED)!=0 ){
916 if( pTab->aCol[i].colFlags & COLFLAG_VIRTUAL ) k--;
dan165921a2009-08-28 18:53:45 +0000917 }else{
drh5cf590c2003-04-24 01:45:04 +0000918 j = aXRef[i];
danbb5f1682009-11-27 12:12:34 +0000919 if( j>=0 ){
dan69887c92020-04-27 20:55:33 +0000920 if( nChangeFrom ){
dan69887c92020-04-27 20:55:33 +0000921 int nOff = (isView ? pTab->nCol : nPk);
drha7c74002020-07-18 18:44:59 +0000922 assert( eOnePass==ONEPASS_OFF );
dan69887c92020-04-27 20:55:33 +0000923 sqlite3VdbeAddOp3(v, OP_Column, iEph, nOff+j, k);
924 }else{
925 sqlite3ExprCode(pParse, pChanges->a[j].pExpr, k);
926 }
drh693e6712014-01-24 22:58:00 +0000927 }else if( 0==(tmask&TRIGGER_BEFORE) || i>31 || (newmask & MASKBIT32(i)) ){
danbb5f1682009-11-27 12:12:34 +0000928 /* This branch loads the value of a column that will not be changed
929 ** into a register. This is done if there are no BEFORE triggers, or
930 ** if there are one or more BEFORE triggers that use this value via
931 ** a new.* reference in a trigger program.
932 */
drhfd7c9912009-12-01 22:09:25 +0000933 testcase( i==31 );
934 testcase( i==32 );
drh6df9c4b2019-10-18 12:52:08 +0000935 sqlite3ExprCodeGetColumnOfTable(v, pTab, iDataCur, i, k);
drhbe3da242019-12-29 00:52:41 +0000936 bFinishSeek = 0;
drhedfac342013-12-19 02:56:01 +0000937 }else{
drh8a53ce22019-10-17 15:59:03 +0000938 sqlite3VdbeAddOp2(v, OP_Null, 0, k);
drh5cf590c2003-04-24 01:45:04 +0000939 }
940 }
dan165921a2009-08-28 18:53:45 +0000941 }
drhc1431142019-10-17 17:54:05 +0000942#ifndef SQLITE_OMIT_GENERATED_COLUMNS
drh427b96a2019-10-22 13:01:24 +0000943 if( pTab->tabFlags & TF_HasGenerated ){
944 testcase( pTab->tabFlags & TF_HasVirtual );
945 testcase( pTab->tabFlags & TF_HasStored );
drhdd6cc9b2019-10-19 18:47:27 +0000946 sqlite3ComputeGeneratedColumns(pParse, regNew, pTab);
drhc1431142019-10-17 17:54:05 +0000947 }
948#endif
drh5cf590c2003-04-24 01:45:04 +0000949
dan165921a2009-08-28 18:53:45 +0000950 /* Fire any BEFORE UPDATE triggers. This happens before constraints are
danbb5f1682009-11-27 12:12:34 +0000951 ** verified. One could argue that this is wrong.
952 */
953 if( tmask&TRIGGER_BEFORE ){
drh57bf4a82014-02-17 14:59:22 +0000954 sqlite3TableAffinity(v, pTab, regNew);
dan2832ad42009-08-31 15:27:27 +0000955 sqlite3CodeRowTrigger(pParse, pTrigger, TK_UPDATE, pChanges,
drhc3e356f2013-11-04 18:34:46 +0000956 TRIGGER_BEFORE, pTab, regOldRowid, onError, labelContinue);
danae0931e2009-09-09 15:06:10 +0000957
dan69887c92020-04-27 20:55:33 +0000958 if( !isView ){
959 /* The row-trigger may have deleted the row being updated. In this
960 ** case, jump to the next row. No updates or AFTER triggers are
961 ** required. This behavior - what happens when the row being updated
962 ** is deleted or renamed by a BEFORE trigger - is left undefined in the
963 ** documentation.
964 */
965 if( pPk ){
dan74657872020-05-01 18:43:49 +0000966 sqlite3VdbeAddOp4Int(v, OP_NotFound,iDataCur,labelContinue,regKey,nKey);
dan69887c92020-04-27 20:55:33 +0000967 VdbeCoverage(v);
968 }else{
969 sqlite3VdbeAddOp3(v, OP_NotExists, iDataCur, labelContinue,regOldRowid);
970 VdbeCoverage(v);
danbb5f1682009-11-27 12:12:34 +0000971 }
dan69887c92020-04-27 20:55:33 +0000972
973 /* After-BEFORE-trigger-reload-loop:
974 ** If it did not delete it, the BEFORE trigger may still have modified
975 ** some of the columns of the row being updated. Load the values for
976 ** all columns not modified by the update statement into their registers
977 ** in case this has happened. Only unmodified columns are reloaded.
978 ** The values computed for modified columns use the values before the
979 ** BEFORE trigger runs. See test case trigger1-18.0 (added 2018-04-26)
980 ** for an example.
981 */
982 for(i=0, k=regNew; i<pTab->nCol; i++, k++){
983 if( pTab->aCol[i].colFlags & COLFLAG_GENERATED ){
984 if( pTab->aCol[i].colFlags & COLFLAG_VIRTUAL ) k--;
985 }else if( aXRef[i]<0 && i!=pTab->iPKey ){
986 sqlite3ExprCodeGetColumnOfTable(v, pTab, iDataCur, i, k);
987 }
988 }
drhc1431142019-10-17 17:54:05 +0000989#ifndef SQLITE_OMIT_GENERATED_COLUMNS
dan69887c92020-04-27 20:55:33 +0000990 if( pTab->tabFlags & TF_HasGenerated ){
991 testcase( pTab->tabFlags & TF_HasVirtual );
992 testcase( pTab->tabFlags & TF_HasStored );
993 sqlite3ComputeGeneratedColumns(pParse, regNew, pTab);
994 }
drhc1431142019-10-17 17:54:05 +0000995#endif
dan69887c92020-04-27 20:55:33 +0000996 }
dan2832ad42009-08-31 15:27:27 +0000997 }
dan165921a2009-08-28 18:53:45 +0000998
999 if( !isView ){
dan165921a2009-08-28 18:53:45 +00001000 /* Do constraint checks. */
drhf8ffb272013-11-01 17:08:56 +00001001 assert( regOldRowid>0 );
1002 sqlite3GenerateConstraintChecks(pParse, pTab, aRegIdx, iDataCur, iIdxCur,
drhbdb00222016-02-10 16:03:20 +00001003 regNewRowid, regOldRowid, chngKey, onError, labelContinue, &bReplace,
drh788d55a2018-04-13 01:15:09 +00001004 aXRef, 0);
drh5cf590c2003-04-24 01:45:04 +00001005
danf66bfcb2019-08-31 17:14:35 +00001006 /* If REPLACE conflict handling may have been used, or if the PK of the
1007 ** row is changing, then the GenerateConstraintChecks() above may have
1008 ** moved cursor iDataCur. Reseek it. */
1009 if( bReplace || chngKey ){
1010 if( pPk ){
1011 sqlite3VdbeAddOp4Int(v, OP_NotFound,iDataCur,labelContinue,regKey,nKey);
1012 }else{
1013 sqlite3VdbeAddOp3(v, OP_NotExists, iDataCur, labelContinue,regOldRowid);
1014 }
drh81d25cf2019-08-31 20:26:06 +00001015 VdbeCoverageNeverTaken(v);
danf66bfcb2019-08-31 17:14:35 +00001016 }
1017
dan1da40a32009-09-19 17:00:31 +00001018 /* Do FK constraint checks. */
dane7a94d82009-10-01 16:09:04 +00001019 if( hasFK ){
drhf8ffb272013-11-01 17:08:56 +00001020 sqlite3FkCheck(pParse, pTab, regOldRowid, 0, aXRef, chngKey);
dane7a94d82009-10-01 16:09:04 +00001021 }
dan1da40a32009-09-19 17:00:31 +00001022
dan165921a2009-08-28 18:53:45 +00001023 /* Delete the index entries associated with the current record. */
danf0ee1d32015-09-12 19:26:11 +00001024 sqlite3GenerateRowIndexDelete(pParse, pTab, iDataCur, iIdxCur, aRegIdx, -1);
drh9b1c62d2011-03-30 21:04:43 +00001025
drhbe3da242019-12-29 00:52:41 +00001026 /* We must run the OP_FinishSeek opcode to resolve a prior
1027 ** OP_DeferredSeek if there is any possibility that there have been
1028 ** no OP_Column opcodes since the OP_DeferredSeek was issued. But
1029 ** we want to avoid the OP_FinishSeek if possible, as running it
1030 ** costs CPU cycles. */
1031 if( bFinishSeek ){
1032 sqlite3VdbeAddOp1(v, OP_FinishSeek, iDataCur);
drhd3ee3ad2019-12-26 23:16:18 +00001033 }
drhd3ee3ad2019-12-26 23:16:18 +00001034
dan46c47d42011-03-01 18:42:07 +00001035 /* If changing the rowid value, or if there are foreign key constraints
1036 ** to process, delete the old record. Otherwise, add a noop OP_Delete
1037 ** to invoke the pre-update hook.
dan37db03b2011-03-16 19:59:18 +00001038 **
1039 ** That (regNew==regnewRowid+1) is true is also important for the
drh9b1c62d2011-03-30 21:04:43 +00001040 ** pre-update hook. If the caller invokes preupdate_new(), the returned
dan37db03b2011-03-16 19:59:18 +00001041 ** value is copied from memory cell (regNewRowid+1+iCol), where iCol
1042 ** is the column index supplied by the user.
dan46c47d42011-03-01 18:42:07 +00001043 */
dan37db03b2011-03-16 19:59:18 +00001044 assert( regNew==regNewRowid+1 );
drh74c33022016-03-30 12:56:55 +00001045#ifdef SQLITE_ENABLE_PREUPDATE_HOOK
drhcbf1b8e2013-11-11 22:55:26 +00001046 sqlite3VdbeAddOp3(v, OP_Delete, iDataCur,
dan940b5ea2017-04-11 19:58:55 +00001047 OPFLAG_ISUPDATE | ((hasFK>1 || chngKey) ? 0 : OPFLAG_ISNOOP),
dan46c47d42011-03-01 18:42:07 +00001048 regNewRowid
1049 );
dane206ea72017-01-11 20:10:30 +00001050 if( eOnePass==ONEPASS_MULTI ){
1051 assert( hasFK==0 && chngKey==0 );
1052 sqlite3VdbeChangeP5(v, OPFLAG_SAVEPOSITION);
1053 }
dan46c47d42011-03-01 18:42:07 +00001054 if( !pParse->nested ){
drhf14b7fb2016-12-07 21:35:55 +00001055 sqlite3VdbeAppendP4(v, pTab, P4_TABLE);
drh5cf590c2003-04-24 01:45:04 +00001056 }
drh74c33022016-03-30 12:56:55 +00001057#else
dan940b5ea2017-04-11 19:58:55 +00001058 if( hasFK>1 || chngKey ){
drh74c33022016-03-30 12:56:55 +00001059 sqlite3VdbeAddOp2(v, OP_Delete, iDataCur, 0);
1060 }
1061#endif
dan9277efa2009-09-28 11:54:21 +00001062
dane7a94d82009-10-01 16:09:04 +00001063 if( hasFK ){
drhf8ffb272013-11-01 17:08:56 +00001064 sqlite3FkCheck(pParse, pTab, 0, regNewRowid, aXRef, chngKey);
dane7a94d82009-10-01 16:09:04 +00001065 }
dan165921a2009-08-28 18:53:45 +00001066
dan76d462e2009-08-30 11:42:51 +00001067 /* Insert the new index entries and the new record. */
danf91c1312017-01-10 20:04:38 +00001068 sqlite3CompleteInsertion(
1069 pParse, pTab, iDataCur, iIdxCur, regNewRowid, aRegIdx,
1070 OPFLAG_ISUPDATE | (eOnePass==ONEPASS_MULTI ? OPFLAG_SAVEPOSITION : 0),
1071 0, 0
1072 );
dan1da40a32009-09-19 17:00:31 +00001073
1074 /* Do any ON CASCADE, SET NULL or SET DEFAULT operations required to
1075 ** handle rows (possibly in other tables) that refer via a foreign key
1076 ** to the row just updated. */
dane7a94d82009-10-01 16:09:04 +00001077 if( hasFK ){
drhf8ffb272013-11-01 17:08:56 +00001078 sqlite3FkActions(pParse, pTab, pChanges, regOldRowid, aXRef, chngKey);
dane7a94d82009-10-01 16:09:04 +00001079 }
drhcce7d172000-05-31 15:34:51 +00001080 }
1081
drh0ca3e242002-01-29 23:07:02 +00001082 /* Increment the row counter
drh1bee3d72001-10-15 00:44:35 +00001083 */
drh79636912018-04-19 23:52:39 +00001084 if( regRowCount ){
drh04adf412008-01-08 18:57:50 +00001085 sqlite3VdbeAddOp2(v, OP_AddImm, regRowCount, 1);
drh1bee3d72001-10-15 00:44:35 +00001086 }
1087
dan165921a2009-08-28 18:53:45 +00001088 sqlite3CodeRowTrigger(pParse, pTrigger, TK_UPDATE, pChanges,
drhc3e356f2013-11-04 18:34:46 +00001089 TRIGGER_AFTER, pTab, regOldRowid, onError, labelContinue);
danielk1977c3f9bad2002-05-15 08:30:12 +00001090
drhcce7d172000-05-31 15:34:51 +00001091 /* Repeat the above with the next record to be updated, until
1092 ** all record selected by the WHERE clause have been updated.
1093 */
danf91c1312017-01-10 20:04:38 +00001094 if( eOnePass==ONEPASS_SINGLE ){
drh702ba9f2013-11-07 21:25:13 +00001095 /* Nothing to do at end-of-loop for a single-pass */
danf91c1312017-01-10 20:04:38 +00001096 }else if( eOnePass==ONEPASS_MULTI ){
1097 sqlite3VdbeResolveLabel(v, labelContinue);
1098 sqlite3WhereEnd(pWInfo);
drh32881be2020-11-17 21:26:13 +00001099 }else{
drhea22abe2013-10-25 19:17:17 +00001100 sqlite3VdbeResolveLabel(v, labelContinue);
drh688852a2014-02-17 22:40:43 +00001101 sqlite3VdbeAddOp2(v, OP_Next, iEph, addrTop); VdbeCoverage(v);
drhea22abe2013-10-25 19:17:17 +00001102 }
1103 sqlite3VdbeResolveLabel(v, labelBreak);
danielk1977c3f9bad2002-05-15 08:30:12 +00001104
drh0b9f50d2009-06-23 20:28:53 +00001105 /* Update the sqlite_sequence table by storing the content of the
1106 ** maximum rowid counter values recorded while inserting into
1107 ** autoincrement tables.
1108 */
drhf3d7bbb2018-04-21 03:06:29 +00001109 if( pParse->nested==0 && pParse->pTriggerTab==0 && pUpsert==0 ){
drh0b9f50d2009-06-23 20:28:53 +00001110 sqlite3AutoincrementEnd(pParse);
1111 }
1112
drh1bee3d72001-10-15 00:44:35 +00001113 /*
drh79636912018-04-19 23:52:39 +00001114 ** Return the number of rows that were changed, if we are tracking
1115 ** that information.
drh1bee3d72001-10-15 00:44:35 +00001116 */
drh79636912018-04-19 23:52:39 +00001117 if( regRowCount ){
drh18e56072021-01-31 15:50:36 +00001118 sqlite3VdbeAddOp2(v, OP_ChngCntRow, regRowCount, 1);
danielk197722322fd2004-05-25 23:35:17 +00001119 sqlite3VdbeSetNumCols(v, 1);
danielk197710fb7492008-10-31 10:53:22 +00001120 sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "rows updated", SQLITE_STATIC);
drh1bee3d72001-10-15 00:44:35 +00001121 }
1122
drhcce7d172000-05-31 15:34:51 +00001123update_cleanup:
danielk19774adee202004-05-08 08:23:19 +00001124 sqlite3AuthContextPop(&sContext);
drh6a534992013-11-16 20:13:39 +00001125 sqlite3DbFree(db, aXRef); /* Also frees aRegIdx[] and aToOpen[] */
drh633e6d52008-07-28 19:34:53 +00001126 sqlite3SrcListDelete(db, pTabList);
1127 sqlite3ExprListDelete(db, pChanges);
1128 sqlite3ExprDelete(db, pWhere);
dan3b61ebb2017-11-10 20:13:14 +00001129#if defined(SQLITE_ENABLE_UPDATE_DELETE_LIMIT)
danb3c16b82017-11-09 19:53:06 +00001130 sqlite3ExprListDelete(db, pOrderBy);
1131 sqlite3ExprDelete(db, pLimit);
dan3b61ebb2017-11-10 20:13:14 +00001132#endif
drhcce7d172000-05-31 15:34:51 +00001133 return;
1134}
dan75cbd982009-09-21 16:06:03 +00001135/* Make sure "isView" and other macros defined above are undefined. Otherwise
peter.d.reid60ec9142014-09-06 16:39:46 +00001136** they may interfere with compilation of other functions in this file
dan75cbd982009-09-21 16:06:03 +00001137** (or in another file, if this file becomes part of the amalgamation). */
1138#ifdef isView
1139 #undef isView
1140#endif
1141#ifdef pTrigger
1142 #undef pTrigger
1143#endif
drh9c419382006-06-16 21:13:21 +00001144
1145#ifndef SQLITE_OMIT_VIRTUALTABLE
1146/*
1147** Generate code for an UPDATE of a virtual table.
1148**
dan0f400372015-09-28 20:03:49 +00001149** There are two possible strategies - the default and the special
1150** "onepass" strategy. Onepass is only used if the virtual table
1151** implementation indicates that pWhere may match at most one row.
1152**
1153** The default strategy is to create an ephemeral table that contains
drh9c419382006-06-16 21:13:21 +00001154** for each row to be changed:
1155**
1156** (A) The original rowid of that row.
dan0f400372015-09-28 20:03:49 +00001157** (B) The revised rowid for the row.
drh9c419382006-06-16 21:13:21 +00001158** (C) The content of every column in the row.
1159**
dan0f400372015-09-28 20:03:49 +00001160** Then loop through the contents of this ephemeral table executing a
1161** VUpdate for each row. When finished, drop the ephemeral table.
drh9c419382006-06-16 21:13:21 +00001162**
dan0f400372015-09-28 20:03:49 +00001163** The "onepass" strategy does not use an ephemeral table. Instead, it
1164** stores the same values (A, B and C above) in a register array and
1165** makes a single invocation of VUpdate.
drh9c419382006-06-16 21:13:21 +00001166*/
1167static void updateVirtualTable(
1168 Parse *pParse, /* The parsing context */
1169 SrcList *pSrc, /* The virtual table to be modified */
1170 Table *pTab, /* The virtual table */
1171 ExprList *pChanges, /* The columns to change in the UPDATE statement */
1172 Expr *pRowid, /* Expression used to recompute the rowid */
1173 int *aXRef, /* Mapping from columns of pTab to entries in pChanges */
danb061d052011-04-25 18:49:57 +00001174 Expr *pWhere, /* WHERE clause of the UPDATE statement */
1175 int onError /* ON CONFLICT strategy */
drh9c419382006-06-16 21:13:21 +00001176){
1177 Vdbe *v = pParse->pVdbe; /* Virtual machine under construction */
drh9c419382006-06-16 21:13:21 +00001178 int ephemTab; /* Table holding the result of the SELECT */
1179 int i; /* Loop counter */
drh17435752007-08-16 04:30:38 +00001180 sqlite3 *db = pParse->db; /* Database connection */
danielk1977595a5232009-07-24 17:58:53 +00001181 const char *pVTab = (const char*)sqlite3GetVTable(db, pTab);
drha7c74002020-07-18 18:44:59 +00001182 WhereInfo *pWInfo = 0;
dan0f400372015-09-28 20:03:49 +00001183 int nArg = 2 + pTab->nCol; /* Number of arguments to VUpdate */
1184 int regArg; /* First register in VUpdate arg array */
1185 int regRec; /* Register in which to assemble record */
1186 int regRowid; /* Register for ephem table rowid */
1187 int iCsr = pSrc->a[0].iCursor; /* Cursor used for virtual table scan */
1188 int aDummy[2]; /* Unused arg for sqlite3WhereOkOnePass() */
drh338e3112018-05-24 23:51:57 +00001189 int eOnePass; /* True to use onepass strategy */
dan0f400372015-09-28 20:03:49 +00001190 int addr; /* Address of OP_OpenEphemeral */
drh9c419382006-06-16 21:13:21 +00001191
drh24cd20f2018-01-11 13:43:04 +00001192 /* Allocate nArg registers in which to gather the arguments for VUpdate. Then
dan0f400372015-09-28 20:03:49 +00001193 ** create and open the ephemeral table in which the records created from
1194 ** these arguments will be temporarily stored. */
drh9c419382006-06-16 21:13:21 +00001195 assert( v );
1196 ephemTab = pParse->nTab++;
dan0f400372015-09-28 20:03:49 +00001197 addr= sqlite3VdbeAddOp2(v, OP_OpenEphemeral, ephemTab, nArg);
1198 regArg = pParse->nMem + 1;
1199 pParse->nMem += nArg;
dan69887c92020-04-27 20:55:33 +00001200 if( pSrc->nSrc>1 ){
dan4d906f12020-10-12 14:29:11 +00001201 Index *pPk = 0;
dan576d5a82020-07-15 18:30:01 +00001202 Expr *pRow;
1203 ExprList *pList;
dan4d906f12020-10-12 14:29:11 +00001204 if( HasRowid(pTab) ){
1205 if( pRowid ){
1206 pRow = sqlite3ExprDup(db, pRowid, 0);
1207 }else{
1208 pRow = sqlite3PExpr(pParse, TK_ROW, 0, 0);
1209 }
drhe3740f22017-08-10 15:19:39 +00001210 }else{
dan4d906f12020-10-12 14:29:11 +00001211 i16 iPk; /* PRIMARY KEY column */
1212 pPk = sqlite3PrimaryKeyIndex(pTab);
1213 assert( pPk!=0 );
1214 assert( pPk->nKeyCol==1 );
1215 iPk = pPk->aiColumn[0];
1216 if( aXRef[iPk]>=0 ){
1217 pRow = sqlite3ExprDup(db, pChanges->a[aXRef[iPk]].pExpr, 0);
1218 }else{
1219 pRow = exprRowColumn(pParse, iPk);
1220 }
drhe3740f22017-08-10 15:19:39 +00001221 }
dan576d5a82020-07-15 18:30:01 +00001222 pList = sqlite3ExprListAppend(pParse, 0, pRow);
1223
dan69887c92020-04-27 20:55:33 +00001224 for(i=0; i<pTab->nCol; i++){
1225 if( aXRef[i]>=0 ){
1226 pList = sqlite3ExprListAppend(pParse, pList,
1227 sqlite3ExprDup(db, pChanges->a[aXRef[i]].pExpr, 0)
1228 );
1229 }else{
dan576d5a82020-07-15 18:30:01 +00001230 pList = sqlite3ExprListAppend(pParse, pList, exprRowColumn(pParse, i));
dan69887c92020-04-27 20:55:33 +00001231 }
1232 }
1233
dan4d906f12020-10-12 14:29:11 +00001234 updateFromSelect(pParse, ephemTab, pPk, pList, pSrc, pWhere, 0, 0);
dan69887c92020-04-27 20:55:33 +00001235 sqlite3ExprListDelete(db, pList);
1236 eOnePass = ONEPASS_OFF;
drhe3740f22017-08-10 15:19:39 +00001237 }else{
dan69887c92020-04-27 20:55:33 +00001238 regRec = ++pParse->nMem;
1239 regRowid = ++pParse->nMem;
dan0f400372015-09-28 20:03:49 +00001240
dan69887c92020-04-27 20:55:33 +00001241 /* Start scanning the virtual table */
1242 pWInfo = sqlite3WhereBegin(pParse, pSrc,pWhere,0,0,WHERE_ONEPASS_DESIRED,0);
1243 if( pWInfo==0 ) return;
dan0f400372015-09-28 20:03:49 +00001244
dan69887c92020-04-27 20:55:33 +00001245 /* Populate the argument registers. */
1246 for(i=0; i<pTab->nCol; i++){
1247 assert( (pTab->aCol[i].colFlags & COLFLAG_GENERATED)==0 );
1248 if( aXRef[i]>=0 ){
1249 sqlite3ExprCode(pParse, pChanges->a[aXRef[i]].pExpr, regArg+2+i);
1250 }else{
1251 sqlite3VdbeAddOp3(v, OP_VColumn, iCsr, i, regArg+2+i);
1252 sqlite3VdbeChangeP5(v, OPFLAG_NOCHNG);/* For sqlite3_vtab_nochange() */
1253 }
1254 }
1255 if( HasRowid(pTab) ){
1256 sqlite3VdbeAddOp2(v, OP_Rowid, iCsr, regArg);
1257 if( pRowid ){
1258 sqlite3ExprCode(pParse, pRowid, regArg+1);
1259 }else{
1260 sqlite3VdbeAddOp2(v, OP_Rowid, iCsr, regArg+1);
1261 }
1262 }else{
1263 Index *pPk; /* PRIMARY KEY index */
1264 i16 iPk; /* PRIMARY KEY column */
1265 pPk = sqlite3PrimaryKeyIndex(pTab);
1266 assert( pPk!=0 );
1267 assert( pPk->nKeyCol==1 );
1268 iPk = pPk->aiColumn[0];
1269 sqlite3VdbeAddOp3(v, OP_VColumn, iCsr, iPk, regArg);
1270 sqlite3VdbeAddOp2(v, OP_SCopy, regArg+2+iPk, regArg+1);
1271 }
drh338e3112018-05-24 23:51:57 +00001272
dan69887c92020-04-27 20:55:33 +00001273 eOnePass = sqlite3WhereOkOnePass(pWInfo, aDummy);
1274
1275 /* There is no ONEPASS_MULTI on virtual tables */
1276 assert( eOnePass==ONEPASS_OFF || eOnePass==ONEPASS_SINGLE );
1277
1278 if( eOnePass ){
1279 /* If using the onepass strategy, no-op out the OP_OpenEphemeral coded
1280 ** above. */
1281 sqlite3VdbeChangeToNoop(v, addr);
1282 sqlite3VdbeAddOp1(v, OP_Close, iCsr);
1283 }else{
1284 /* Create a record from the argument register contents and insert it into
1285 ** the ephemeral table. */
1286 sqlite3MultiWrite(pParse);
1287 sqlite3VdbeAddOp3(v, OP_MakeRecord, regArg, nArg, regRec);
drhda369332020-06-29 20:09:04 +00001288#if defined(SQLITE_DEBUG) && !defined(SQLITE_ENABLE_NULL_TRIM)
dan69887c92020-04-27 20:55:33 +00001289 /* Signal an assert() within OP_MakeRecord that it is allowed to
1290 ** accept no-change records with serial_type 10 */
1291 sqlite3VdbeChangeP5(v, OPFLAG_NOCHNG_MAGIC);
drh41fb3672018-01-12 23:18:38 +00001292#endif
dan69887c92020-04-27 20:55:33 +00001293 sqlite3VdbeAddOp2(v, OP_NewRowid, ephemTab, regRowid);
1294 sqlite3VdbeAddOp3(v, OP_Insert, ephemTab, regRec, regRowid);
1295 }
dan0f400372015-09-28 20:03:49 +00001296 }
1297
dan0f400372015-09-28 20:03:49 +00001298
drh338e3112018-05-24 23:51:57 +00001299 if( eOnePass==ONEPASS_OFF ){
dan354474a2015-09-29 10:11:26 +00001300 /* End the virtual table scan */
dan69887c92020-04-27 20:55:33 +00001301 if( pSrc->nSrc==1 ){
1302 sqlite3WhereEnd(pWInfo);
1303 }
dan354474a2015-09-29 10:11:26 +00001304
dan0f400372015-09-28 20:03:49 +00001305 /* Begin scannning through the ephemeral table. */
dan354474a2015-09-29 10:11:26 +00001306 addr = sqlite3VdbeAddOp1(v, OP_Rewind, ephemTab); VdbeCoverage(v);
dan0f400372015-09-28 20:03:49 +00001307
1308 /* Extract arguments from the current row of the ephemeral table and
1309 ** invoke the VUpdate method. */
1310 for(i=0; i<nArg; i++){
1311 sqlite3VdbeAddOp3(v, OP_Column, ephemTab, i, regArg+i);
1312 }
drh9c419382006-06-16 21:13:21 +00001313 }
drh4f3dd152008-04-28 18:46:43 +00001314 sqlite3VtabMakeWritable(pParse, pTab);
dan0f400372015-09-28 20:03:49 +00001315 sqlite3VdbeAddOp4(v, OP_VUpdate, 0, nArg, regArg, pVTab, P4_VTAB);
danb061d052011-04-25 18:49:57 +00001316 sqlite3VdbeChangeP5(v, onError==OE_Default ? OE_Abort : onError);
dane0af83a2009-09-08 19:15:01 +00001317 sqlite3MayAbort(pParse);
drh9c419382006-06-16 21:13:21 +00001318
dan354474a2015-09-29 10:11:26 +00001319 /* End of the ephemeral table scan. Or, if using the onepass strategy,
1320 ** jump to here if the scan visited zero rows. */
drh338e3112018-05-24 23:51:57 +00001321 if( eOnePass==ONEPASS_OFF ){
dan0f400372015-09-28 20:03:49 +00001322 sqlite3VdbeAddOp2(v, OP_Next, ephemTab, addr+1); VdbeCoverage(v);
1323 sqlite3VdbeJumpHere(v, addr);
1324 sqlite3VdbeAddOp2(v, OP_Close, ephemTab, 0);
dan354474a2015-09-29 10:11:26 +00001325 }else{
1326 sqlite3WhereEnd(pWInfo);
dan0f400372015-09-28 20:03:49 +00001327 }
drh9c419382006-06-16 21:13:21 +00001328}
1329#endif /* SQLITE_OMIT_VIRTUALTABLE */