blob: 1335c269ed2d55a4be032f26cdb48a5027f27e79 [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 ){
drh66a51672008-01-03 00:01:23 +000072 sqlite3VdbeChangeP4(v, -1, (const char *)pValue, P4_MEM);
drh29dda4a2005-07-21 18:23:20 +000073 }
danielk1977c7538b52009-07-27 10:05:04 +000074#ifndef SQLITE_OMIT_FLOATING_POINT
drheaf4f522013-12-22 22:45:14 +000075 if( pTab->aCol[i].affinity==SQLITE_AFF_REAL ){
danielk1977c7538b52009-07-27 10:05:04 +000076 sqlite3VdbeAddOp1(v, OP_RealAffinity, iReg);
77 }
78#endif
danielk1977aee18ef2005-03-09 12:26:50 +000079 }
80}
81
82/*
drhcce7d172000-05-31 15:34:51 +000083** Process an UPDATE statement.
drhb2fe7d82003-04-20 17:29:23 +000084**
85** UPDATE OR IGNORE table_wxyz SET a=b, c=d WHERE e<5 AND f NOT NULL;
86** \_______/ \________/ \______/ \________________/
87* onError pTabList pChanges pWhere
drhcce7d172000-05-31 15:34:51 +000088*/
danielk19774adee202004-05-08 08:23:19 +000089void sqlite3Update(
drhcce7d172000-05-31 15:34:51 +000090 Parse *pParse, /* The parser context */
drh113088e2003-03-20 01:16:58 +000091 SrcList *pTabList, /* The table in which we should change things */
drhcce7d172000-05-31 15:34:51 +000092 ExprList *pChanges, /* Things to be changed */
drh9cfcf5d2002-01-29 18:41:24 +000093 Expr *pWhere, /* The WHERE clause. May be null */
94 int onError /* How to handle constraint errors */
drhcce7d172000-05-31 15:34:51 +000095){
96 int i, j; /* Loop counters */
97 Table *pTab; /* The table to be updated */
drhc3e356f2013-11-04 18:34:46 +000098 int addrTop = 0; /* VDBE instruction address of the start of the loop */
drhcce7d172000-05-31 15:34:51 +000099 WhereInfo *pWInfo; /* Information about the WHERE clause */
100 Vdbe *v; /* The virtual database engine */
101 Index *pIdx; /* For looping over indices */
drhea22abe2013-10-25 19:17:17 +0000102 Index *pPk; /* The PRIMARY KEY index for WITHOUT ROWID tables */
drhcce7d172000-05-31 15:34:51 +0000103 int nIdx; /* Number of indices that need updating */
drh6a534992013-11-16 20:13:39 +0000104 int iBaseCur; /* Base cursor number */
drh77f64bb2013-10-31 12:13:37 +0000105 int iDataCur; /* Cursor for the canonical data btree */
106 int iIdxCur; /* Cursor for the first index */
drh9bb575f2004-09-06 17:24:11 +0000107 sqlite3 *db; /* The database structure */
drhaa9b8962008-01-08 02:57:55 +0000108 int *aRegIdx = 0; /* One register assigned to each index to be updated */
drhcce7d172000-05-31 15:34:51 +0000109 int *aXRef = 0; /* aXRef[i] is the index in pChanges->a[] of the
drh967e8b72000-06-21 13:59:10 +0000110 ** an expression for the i-th column of the table.
111 ** aXRef[i]==-1 if the i-th column is not changed. */
drh6a534992013-11-16 20:13:39 +0000112 u8 *aToOpen; /* 1 for tables and indices to be opened */
drhf8ffb272013-11-01 17:08:56 +0000113 u8 chngPk; /* PRIMARY KEY changed in a WITHOUT ROWID table */
114 u8 chngRowid; /* Rowid changed in a normal table */
115 u8 chngKey; /* Either chngPk or chngRowid */
drhf0863fe2005-06-12 21:35:51 +0000116 Expr *pRowidExpr = 0; /* Expression defining the new record number */
drh85e20962003-04-25 17:52:11 +0000117 AuthContext sContext; /* The authorization context */
danielk1977b3bce662005-01-29 08:32:43 +0000118 NameContext sNC; /* The name-context to resolve expressions in */
danielk1977da184232006-01-05 11:34:32 +0000119 int iDb; /* Database containing the table being updated */
drh08c88eb2008-04-10 13:33:18 +0000120 int okOnePass; /* True for one-pass algorithm without the FIFO */
dan1da40a32009-09-19 17:00:31 +0000121 int hasFK; /* True if foreign key processing is required */
drhea22abe2013-10-25 19:17:17 +0000122 int labelBreak; /* Jump here to break out of UPDATE loop */
123 int labelContinue; /* Jump here to continue next step of UPDATE loop */
drhcce7d172000-05-31 15:34:51 +0000124
drh798da522004-11-04 04:42:28 +0000125#ifndef SQLITE_OMIT_TRIGGER
danbb5f1682009-11-27 12:12:34 +0000126 int isView; /* True when updating a view (INSTEAD OF trigger) */
127 Trigger *pTrigger; /* List of triggers on pTab, if required */
128 int tmask; /* Mask of TRIGGER_BEFORE|TRIGGER_AFTER */
drh798da522004-11-04 04:42:28 +0000129#endif
drhfd7c9912009-12-01 22:09:25 +0000130 int newmask; /* Mask of NEW.* columns accessed by BEFORE triggers */
drhea22abe2013-10-25 19:17:17 +0000131 int iEph = 0; /* Ephemeral table holding all primary key values */
drh00f91cf2013-11-07 21:32:16 +0000132 int nKey = 0; /* Number of elements in regKey for WITHOUT ROWID */
drhfc8d4f92013-11-08 15:19:46 +0000133 int aiCurOnePass[2]; /* The write cursors opened by WHERE_ONEPASS */
danielk1977c3f9bad2002-05-15 08:30:12 +0000134
drh04adf412008-01-08 18:57:50 +0000135 /* Register Allocations */
136 int regRowCount = 0; /* A count of rows changed */
drh94f26a12015-09-29 12:32:56 +0000137 int regOldRowid = 0; /* The old rowid */
138 int regNewRowid = 0; /* The new rowid */
139 int regNew = 0; /* Content of the NEW.* table in triggers */
drhb8475df2011-12-09 16:21:19 +0000140 int regOld = 0; /* Content of OLD.* table in triggers */
drh4f21c4a2008-12-10 22:15:00 +0000141 int regRowSet = 0; /* Rowset of rows to be updated */
drhea22abe2013-10-25 19:17:17 +0000142 int regKey = 0; /* composite PRIMARY KEY value */
drh04adf412008-01-08 18:57:50 +0000143
drheeb844a2009-08-08 18:01:07 +0000144 memset(&sContext, 0, sizeof(sContext));
drh17435752007-08-16 04:30:38 +0000145 db = pParse->db;
146 if( pParse->nErr || db->mallocFailed ){
drh6f7adc82006-01-11 21:41:20 +0000147 goto update_cleanup;
148 }
drh113088e2003-03-20 01:16:58 +0000149 assert( pTabList->nSrc==1 );
drhdaffd0e2001-04-11 14:28:42 +0000150
drhb2fe7d82003-04-20 17:29:23 +0000151 /* Locate the table which we want to update.
drhcce7d172000-05-31 15:34:51 +0000152 */
danielk19774adee202004-05-08 08:23:19 +0000153 pTab = sqlite3SrcListLookup(pParse, pTabList);
drha69d9162003-04-17 22:57:53 +0000154 if( pTab==0 ) goto update_cleanup;
danielk1977da184232006-01-05 11:34:32 +0000155 iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
drhb7f91642004-10-31 02:22:47 +0000156
157 /* Figure out if we have any triggers and if the table being
dan76d462e2009-08-30 11:42:51 +0000158 ** updated is a view.
drhb7f91642004-10-31 02:22:47 +0000159 */
160#ifndef SQLITE_OMIT_TRIGGER
danbb5f1682009-11-27 12:12:34 +0000161 pTrigger = sqlite3TriggersExist(pParse, pTab, TK_UPDATE, pChanges, &tmask);
drh5cf590c2003-04-24 01:45:04 +0000162 isView = pTab->pSelect!=0;
danbb5f1682009-11-27 12:12:34 +0000163 assert( pTrigger || tmask==0 );
drhb7f91642004-10-31 02:22:47 +0000164#else
danielk19772f886d12009-02-28 10:47:41 +0000165# define pTrigger 0
drhb7f91642004-10-31 02:22:47 +0000166# define isView 0
danbb5f1682009-11-27 12:12:34 +0000167# define tmask 0
drhb7f91642004-10-31 02:22:47 +0000168#endif
169#ifdef SQLITE_OMIT_VIEW
170# undef isView
171# define isView 0
172#endif
173
danielk1977595a5232009-07-24 17:58:53 +0000174 if( sqlite3ViewGetColumnNames(pParse, pTab) ){
drh5cf590c2003-04-24 01:45:04 +0000175 goto update_cleanup;
drha69d9162003-04-17 22:57:53 +0000176 }
danbb5f1682009-11-27 12:12:34 +0000177 if( sqlite3IsReadOnly(pParse, pTab, tmask) ){
danielk1977b3d24bf2006-06-19 03:05:10 +0000178 goto update_cleanup;
drh5cf590c2003-04-24 01:45:04 +0000179 }
drhcce7d172000-05-31 15:34:51 +0000180
drh53e3fc72002-07-16 17:22:50 +0000181 /* Allocate a cursors for the main database table and for all indices.
182 ** The index cursors might not be used, but if they are used they
183 ** need to occur right after the database cursor. So go ahead and
184 ** allocate enough space, just in case.
185 */
drh6a534992013-11-16 20:13:39 +0000186 pTabList->a[0].iCursor = iBaseCur = iDataCur = pParse->nTab++;
drh313619f2013-10-31 20:34:06 +0000187 iIdxCur = iDataCur+1;
drh77f64bb2013-10-31 12:13:37 +0000188 pPk = HasRowid(pTab) ? 0 : sqlite3PrimaryKeyIndex(pTab);
189 for(nIdx=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, nIdx++){
drh48dd1d82014-05-27 18:18:58 +0000190 if( IsPrimaryKeyIndex(pIdx) && pPk!=0 ){
drh313619f2013-10-31 20:34:06 +0000191 iDataCur = pParse->nTab;
192 pTabList->a[0].iCursor = iDataCur;
193 }
drh53e3fc72002-07-16 17:22:50 +0000194 pParse->nTab++;
195 }
drh6fbe41a2013-10-30 20:22:55 +0000196
drh6a534992013-11-16 20:13:39 +0000197 /* Allocate space for aXRef[], aRegIdx[], and aToOpen[].
198 ** Initialize aXRef[] and aToOpen[] to their default values.
199 */
200 aXRef = sqlite3DbMallocRaw(db, sizeof(int) * (pTab->nCol+nIdx) + nIdx+2 );
201 if( aXRef==0 ) goto update_cleanup;
202 aRegIdx = aXRef+pTab->nCol;
203 aToOpen = (u8*)(aRegIdx+nIdx);
204 memset(aToOpen, 1, nIdx+1);
205 aToOpen[nIdx+1] = 0;
206 for(i=0; i<pTab->nCol; i++) aXRef[i] = -1;
207
danielk1977b3bce662005-01-29 08:32:43 +0000208 /* Initialize the name-context */
209 memset(&sNC, 0, sizeof(sNC));
210 sNC.pParse = pParse;
211 sNC.pSrcList = pTabList;
212
drh85e20962003-04-25 17:52:11 +0000213 /* Resolve the column names in all the expressions of the
214 ** of the UPDATE statement. Also find the column index
drhed6c8672003-01-12 18:02:16 +0000215 ** for each column to be updated in the pChanges array. For each
216 ** column to be updated, make sure we have authorization to change
drhf8ffb272013-11-01 17:08:56 +0000217 ** that column.
drhcce7d172000-05-31 15:34:51 +0000218 */
drhf8ffb272013-11-01 17:08:56 +0000219 chngRowid = chngPk = 0;
drhcce7d172000-05-31 15:34:51 +0000220 for(i=0; i<pChanges->nExpr; i++){
drh7d10d5a2008-08-20 16:35:10 +0000221 if( sqlite3ResolveExprNames(&sNC, pChanges->a[i].pExpr) ){
drhcce7d172000-05-31 15:34:51 +0000222 goto update_cleanup;
223 }
224 for(j=0; j<pTab->nCol; j++){
danielk19774adee202004-05-08 08:23:19 +0000225 if( sqlite3StrICmp(pTab->aCol[j].zName, pChanges->a[i].zName)==0 ){
drh9647ff82002-01-14 02:56:24 +0000226 if( j==pTab->iPKey ){
drhf8ffb272013-11-01 17:08:56 +0000227 chngRowid = 1;
drhf0863fe2005-06-12 21:35:51 +0000228 pRowidExpr = pChanges->a[i].pExpr;
drhf8ffb272013-11-01 17:08:56 +0000229 }else if( pPk && (pTab->aCol[j].colFlags & COLFLAG_PRIMKEY)!=0 ){
230 chngPk = 1;
drh4a324312001-12-21 14:30:42 +0000231 }
drhcce7d172000-05-31 15:34:51 +0000232 aXRef[j] = i;
233 break;
234 }
235 }
236 if( j>=pTab->nCol ){
drhea22abe2013-10-25 19:17:17 +0000237 if( pPk==0 && sqlite3IsRowid(pChanges->a[i].zName) ){
drh27228982013-05-06 13:22:50 +0000238 j = -1;
drhf8ffb272013-11-01 17:08:56 +0000239 chngRowid = 1;
drhf0863fe2005-06-12 21:35:51 +0000240 pRowidExpr = pChanges->a[i].pExpr;
drha0217ba2003-06-01 01:10:33 +0000241 }else{
danielk19774adee202004-05-08 08:23:19 +0000242 sqlite3ErrorMsg(pParse, "no such column: %s", pChanges->a[i].zName);
dan1db95102010-06-28 10:15:19 +0000243 pParse->checkSchema = 1;
drha0217ba2003-06-01 01:10:33 +0000244 goto update_cleanup;
245 }
drhcce7d172000-05-31 15:34:51 +0000246 }
drhed6c8672003-01-12 18:02:16 +0000247#ifndef SQLITE_OMIT_AUTHORIZATION
drhe5f9c642003-01-13 23:27:31 +0000248 {
249 int rc;
danielk19774adee202004-05-08 08:23:19 +0000250 rc = sqlite3AuthCheck(pParse, SQLITE_UPDATE, pTab->zName,
drh27228982013-05-06 13:22:50 +0000251 j<0 ? "ROWID" : pTab->aCol[j].zName,
252 db->aDb[iDb].zName);
drhe5f9c642003-01-13 23:27:31 +0000253 if( rc==SQLITE_DENY ){
254 goto update_cleanup;
255 }else if( rc==SQLITE_IGNORE ){
256 aXRef[j] = -1;
257 }
drhed6c8672003-01-12 18:02:16 +0000258 }
259#endif
drhcce7d172000-05-31 15:34:51 +0000260 }
drhf8ffb272013-11-01 17:08:56 +0000261 assert( (chngRowid & chngPk)==0 );
262 assert( chngRowid==0 || chngRowid==1 );
263 assert( chngPk==0 || chngPk==1 );
264 chngKey = chngRowid + chngPk;
drhcce7d172000-05-31 15:34:51 +0000265
drh5c82f4d2013-11-19 02:34:11 +0000266 /* The SET expressions are not actually used inside the WHERE loop.
267 ** So reset the colUsed mask
268 */
269 pTabList->a[0].colUsed = 0;
270
drhf8ffb272013-11-01 17:08:56 +0000271 hasFK = sqlite3FkRequired(pParse, pTab, aXRef, chngKey);
dane7a94d82009-10-01 16:09:04 +0000272
drh6a534992013-11-16 20:13:39 +0000273 /* There is one entry in the aRegIdx[] array for each index on the table
274 ** being updated. Fill in aRegIdx[] with a register number that will hold
drh1f9ca2c2015-08-25 16:57:52 +0000275 ** the key for accessing each index.
276 **
277 ** FIXME: Be smarter about omitting indexes that use expressions.
drhcce7d172000-05-31 15:34:51 +0000278 */
drhaa9b8962008-01-08 02:57:55 +0000279 for(j=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, j++){
280 int reg;
drhf8ffb272013-11-01 17:08:56 +0000281 if( chngKey || hasFK || pIdx->pPartIdxWhere || pIdx==pPk ){
drhaa9b8962008-01-08 02:57:55 +0000282 reg = ++pParse->nMem;
283 }else{
284 reg = 0;
drhf8ffb272013-11-01 17:08:56 +0000285 for(i=0; i<pIdx->nKeyCol; i++){
drh1f9ca2c2015-08-25 16:57:52 +0000286 i16 iIdxCol = pIdx->aiColumn[i];
287 if( iIdxCol<0 || aXRef[iIdxCol]>=0 ){
drhaa9b8962008-01-08 02:57:55 +0000288 reg = ++pParse->nMem;
289 break;
290 }
drh4a324312001-12-21 14:30:42 +0000291 }
drhcce7d172000-05-31 15:34:51 +0000292 }
drh6a534992013-11-16 20:13:39 +0000293 if( reg==0 ) aToOpen[j+1] = 0;
drhaa9b8962008-01-08 02:57:55 +0000294 aRegIdx[j] = reg;
drhcce7d172000-05-31 15:34:51 +0000295 }
296
dan165921a2009-08-28 18:53:45 +0000297 /* Begin generating code. */
danielk19774adee202004-05-08 08:23:19 +0000298 v = sqlite3GetVdbe(pParse);
drhcce7d172000-05-31 15:34:51 +0000299 if( v==0 ) goto update_cleanup;
drh4794f732004-11-05 17:17:50 +0000300 if( pParse->nested==0 ) sqlite3VdbeCountChanges(v);
danielk1977da184232006-01-05 11:34:32 +0000301 sqlite3BeginWriteOperation(pParse, 1, iDb);
drhcce7d172000-05-31 15:34:51 +0000302
dan165921a2009-08-28 18:53:45 +0000303 /* Allocate required registers. */
dan0f400372015-09-28 20:03:49 +0000304 if( !IsVirtual(pTab) ){
305 regRowSet = ++pParse->nMem;
306 regOldRowid = regNewRowid = ++pParse->nMem;
307 if( chngPk || pTrigger || hasFK ){
308 regOld = pParse->nMem + 1;
309 pParse->nMem += pTab->nCol;
310 }
311 if( chngKey || pTrigger || hasFK ){
312 regNewRowid = ++pParse->nMem;
313 }
314 regNew = pParse->nMem + 1;
dan165921a2009-08-28 18:53:45 +0000315 pParse->nMem += pTab->nCol;
316 }
dan165921a2009-08-28 18:53:45 +0000317
318 /* Start the view context. */
danielk19774273dea2006-06-17 06:31:18 +0000319 if( isView ){
320 sqlite3AuthContextPush(pParse, &sContext, pTab->zName);
321 }
322
drh9d2985c2005-09-08 01:58:42 +0000323 /* If we are trying to update a view, realize that view into
peter.d.reid60ec9142014-09-06 16:39:46 +0000324 ** an ephemeral table.
drh5cf590c2003-04-24 01:45:04 +0000325 */
shanefa4e62f2008-09-01 21:59:42 +0000326#if !defined(SQLITE_OMIT_VIEW) && !defined(SQLITE_OMIT_TRIGGER)
drh5cf590c2003-04-24 01:45:04 +0000327 if( isView ){
drh313619f2013-10-31 20:34:06 +0000328 sqlite3MaterializeView(pParse, pTab, pWhere, iDataCur);
drh0f35a6b2008-02-12 16:52:14 +0000329 }
shanefa4e62f2008-09-01 21:59:42 +0000330#endif
drh1013c932008-01-06 00:25:21 +0000331
drh0f35a6b2008-02-12 16:52:14 +0000332 /* Resolve the column names in all the expressions in the
333 ** WHERE clause.
334 */
drh7d10d5a2008-08-20 16:35:10 +0000335 if( sqlite3ResolveExprNames(&sNC, pWhere) ){
drh0f35a6b2008-02-12 16:52:14 +0000336 goto update_cleanup;
drh5cf590c2003-04-24 01:45:04 +0000337 }
338
dan0f400372015-09-28 20:03:49 +0000339#ifndef SQLITE_OMIT_VIRTUALTABLE
340 /* Virtual tables must be handled separately */
341 if( IsVirtual(pTab) ){
342 updateVirtualTable(pParse, pTabList, pTab, pChanges, pRowidExpr, aXRef,
343 pWhere, onError);
344 goto update_cleanup;
345 }
346#endif
347
drhcce7d172000-05-31 15:34:51 +0000348 /* Begin the database scan
349 */
drhea22abe2013-10-25 19:17:17 +0000350 if( HasRowid(pTab) ){
351 sqlite3VdbeAddOp3(v, OP_Null, 0, regRowSet, regOldRowid);
352 pWInfo = sqlite3WhereBegin(
drhfc8d4f92013-11-08 15:19:46 +0000353 pParse, pTabList, pWhere, 0, 0, WHERE_ONEPASS_DESIRED, iIdxCur
drhea22abe2013-10-25 19:17:17 +0000354 );
355 if( pWInfo==0 ) goto update_cleanup;
drhfc8d4f92013-11-08 15:19:46 +0000356 okOnePass = sqlite3WhereOkOnePass(pWInfo, aiCurOnePass);
drhea22abe2013-10-25 19:17:17 +0000357
358 /* Remember the rowid of every item to be updated.
359 */
drh313619f2013-10-31 20:34:06 +0000360 sqlite3VdbeAddOp2(v, OP_Rowid, iDataCur, regOldRowid);
drhea22abe2013-10-25 19:17:17 +0000361 if( !okOnePass ){
362 sqlite3VdbeAddOp2(v, OP_RowSetAdd, regRowSet, regOldRowid);
363 }
364
365 /* End the database scan loop.
366 */
367 sqlite3WhereEnd(pWInfo);
368 }else{
369 int iPk; /* First of nPk memory cells holding PRIMARY KEY value */
370 i16 nPk; /* Number of components of the PRIMARY KEY */
drh702ba9f2013-11-07 21:25:13 +0000371 int addrOpen; /* Address of the OpenEphemeral instruction */
drhcce7d172000-05-31 15:34:51 +0000372
drhea22abe2013-10-25 19:17:17 +0000373 assert( pPk!=0 );
374 nPk = pPk->nKeyCol;
375 iPk = pParse->nMem+1;
376 pParse->nMem += nPk;
377 regKey = ++pParse->nMem;
378 iEph = pParse->nTab++;
drh702ba9f2013-11-07 21:25:13 +0000379 sqlite3VdbeAddOp2(v, OP_Null, 0, iPk);
380 addrOpen = sqlite3VdbeAddOp2(v, OP_OpenEphemeral, iEph, nPk);
drh2ec2fb22013-11-06 19:59:23 +0000381 sqlite3VdbeSetP4KeyInfo(pParse, pPk);
drh702ba9f2013-11-07 21:25:13 +0000382 pWInfo = sqlite3WhereBegin(pParse, pTabList, pWhere, 0, 0,
drhfc8d4f92013-11-08 15:19:46 +0000383 WHERE_ONEPASS_DESIRED, iIdxCur);
drhea22abe2013-10-25 19:17:17 +0000384 if( pWInfo==0 ) goto update_cleanup;
drhfc8d4f92013-11-08 15:19:46 +0000385 okOnePass = sqlite3WhereOkOnePass(pWInfo, aiCurOnePass);
drhea22abe2013-10-25 19:17:17 +0000386 for(i=0; i<nPk; i++){
drh4b92f982015-09-29 17:20:14 +0000387 assert( pPk->aiColumn[i]>=0 );
drh77f64bb2013-10-31 12:13:37 +0000388 sqlite3ExprCodeGetColumnOfTable(v, pTab, iDataCur, pPk->aiColumn[i],
389 iPk+i);
drhea22abe2013-10-25 19:17:17 +0000390 }
drh702ba9f2013-11-07 21:25:13 +0000391 if( okOnePass ){
392 sqlite3VdbeChangeToNoop(v, addrOpen);
393 nKey = nPk;
394 regKey = iPk;
395 }else{
396 sqlite3VdbeAddOp4(v, OP_MakeRecord, iPk, nPk, regKey,
drhe9107692015-08-25 19:20:04 +0000397 sqlite3IndexAffinityStr(db, pPk), nPk);
drh702ba9f2013-11-07 21:25:13 +0000398 sqlite3VdbeAddOp2(v, OP_IdxInsert, iEph, regKey);
drh702ba9f2013-11-07 21:25:13 +0000399 }
drhea22abe2013-10-25 19:17:17 +0000400 sqlite3WhereEnd(pWInfo);
drh3d4501e2008-12-04 20:40:10 +0000401 }
drhcce7d172000-05-31 15:34:51 +0000402
drh1bee3d72001-10-15 00:44:35 +0000403 /* Initialize the count of updated rows
404 */
dan165921a2009-08-28 18:53:45 +0000405 if( (db->flags & SQLITE_CountRows) && !pParse->pTriggerTab ){
drh04adf412008-01-08 18:57:50 +0000406 regRowCount = ++pParse->nMem;
407 sqlite3VdbeAddOp2(v, OP_Integer, 0, regRowCount);
drh1bee3d72001-10-15 00:44:35 +0000408 }
409
drhfc8d4f92013-11-08 15:19:46 +0000410 labelBreak = sqlite3VdbeMakeLabel(v);
drhe289d602009-05-05 15:46:09 +0000411 if( !isView ){
danielk1977e448dc42008-01-02 11:50:51 +0000412 /*
413 ** Open every index that needs updating. Note that if any
414 ** index could potentially invoke a REPLACE conflict resolution
415 ** action, then we need to open all indices because we might need
416 ** to be deleting some records.
drh70ce3f02003-04-15 19:22:22 +0000417 */
danielk1977e448dc42008-01-02 11:50:51 +0000418 if( onError==OE_Replace ){
drh6a534992013-11-16 20:13:39 +0000419 memset(aToOpen, 1, nIdx+1);
danielk1977e448dc42008-01-02 11:50:51 +0000420 }else{
danielk1977e448dc42008-01-02 11:50:51 +0000421 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
422 if( pIdx->onError==OE_Replace ){
drh6a534992013-11-16 20:13:39 +0000423 memset(aToOpen, 1, nIdx+1);
danielk1977e448dc42008-01-02 11:50:51 +0000424 break;
425 }
426 }
drh5cf590c2003-04-24 01:45:04 +0000427 }
drh6a534992013-11-16 20:13:39 +0000428 if( okOnePass ){
429 if( aiCurOnePass[0]>=0 ) aToOpen[aiCurOnePass[0]-iBaseCur] = 0;
430 if( aiCurOnePass[1]>=0 ) aToOpen[aiCurOnePass[1]-iBaseCur] = 0;
danielk1977e448dc42008-01-02 11:50:51 +0000431 }
danfd261ec2015-10-22 20:54:33 +0000432 sqlite3OpenTableAndIndices(pParse, pTab, OP_OpenWrite, 0, iBaseCur, aToOpen,
drh6a534992013-11-16 20:13:39 +0000433 0, 0);
danielk1977e448dc42008-01-02 11:50:51 +0000434 }
danielk1977e448dc42008-01-02 11:50:51 +0000435
436 /* Top of the update loop */
drh702ba9f2013-11-07 21:25:13 +0000437 if( okOnePass ){
dandd8c4602014-10-28 16:50:10 +0000438 if( aToOpen[iDataCur-iBaseCur] && !isView ){
439 assert( pPk );
drh6a534992013-11-16 20:13:39 +0000440 sqlite3VdbeAddOp4Int(v, OP_NotFound, iDataCur, labelBreak, regKey, nKey);
drh5655c542014-02-19 19:14:34 +0000441 VdbeCoverageNeverTaken(v);
drh6a534992013-11-16 20:13:39 +0000442 }
drh702ba9f2013-11-07 21:25:13 +0000443 labelContinue = labelBreak;
drh2c3ea062014-08-04 21:26:58 +0000444 sqlite3VdbeAddOp2(v, OP_IsNull, pPk ? regKey : regOldRowid, labelBreak);
445 VdbeCoverageIf(v, pPk==0);
446 VdbeCoverageIf(v, pPk!=0);
drh702ba9f2013-11-07 21:25:13 +0000447 }else if( pPk ){
drhc3e356f2013-11-04 18:34:46 +0000448 labelContinue = sqlite3VdbeMakeLabel(v);
drh688852a2014-02-17 22:40:43 +0000449 sqlite3VdbeAddOp2(v, OP_Rewind, iEph, labelBreak); VdbeCoverage(v);
drhc3e356f2013-11-04 18:34:46 +0000450 addrTop = sqlite3VdbeAddOp2(v, OP_RowKey, iEph, regKey);
drh313619f2013-10-31 20:34:06 +0000451 sqlite3VdbeAddOp4Int(v, OP_NotFound, iDataCur, labelContinue, regKey, 0);
drh688852a2014-02-17 22:40:43 +0000452 VdbeCoverage(v);
drh08c88eb2008-04-10 13:33:18 +0000453 }else{
drhc3e356f2013-11-04 18:34:46 +0000454 labelContinue = sqlite3VdbeAddOp3(v, OP_RowSetRead, regRowSet, labelBreak,
drhea22abe2013-10-25 19:17:17 +0000455 regOldRowid);
drh688852a2014-02-17 22:40:43 +0000456 VdbeCoverage(v);
drhc3e356f2013-11-04 18:34:46 +0000457 sqlite3VdbeAddOp3(v, OP_NotExists, iDataCur, labelContinue, regOldRowid);
drh688852a2014-02-17 22:40:43 +0000458 VdbeCoverage(v);
drh08c88eb2008-04-10 13:33:18 +0000459 }
danielk1977e448dc42008-01-02 11:50:51 +0000460
dan1da40a32009-09-19 17:00:31 +0000461 /* If the record number will change, set register regNewRowid to
462 ** contain the new value. If the record number is not being modified,
463 ** then regNewRowid is the same register as regOldRowid, which is
464 ** already populated. */
drhf8ffb272013-11-01 17:08:56 +0000465 assert( chngKey || pTrigger || hasFK || regOldRowid==regNewRowid );
466 if( chngRowid ){
dan1da40a32009-09-19 17:00:31 +0000467 sqlite3ExprCode(pParse, pRowidExpr, regNewRowid);
drh688852a2014-02-17 22:40:43 +0000468 sqlite3VdbeAddOp1(v, OP_MustBeInt, regNewRowid); VdbeCoverage(v);
dan1da40a32009-09-19 17:00:31 +0000469 }
470
drhf8ffb272013-11-01 17:08:56 +0000471 /* Compute the old pre-UPDATE content of the row being changed, if that
472 ** information is needed */
473 if( chngPk || hasFK || pTrigger ){
dane7a94d82009-10-01 16:09:04 +0000474 u32 oldmask = (hasFK ? sqlite3FkOldmask(pParse, pTab) : 0);
danbb5f1682009-11-27 12:12:34 +0000475 oldmask |= sqlite3TriggerColmask(pParse,
476 pTrigger, pChanges, 0, TRIGGER_BEFORE|TRIGGER_AFTER, pTab, onError
477 );
drh25303782004-12-07 15:41:48 +0000478 for(i=0; i<pTab->nCol; i++){
drhf8ffb272013-11-01 17:08:56 +0000479 if( oldmask==0xffffffff
drh693e6712014-01-24 22:58:00 +0000480 || (i<32 && (oldmask & MASKBIT32(i))!=0)
drh00012df2013-11-05 01:59:07 +0000481 || (pTab->aCol[i].colFlags & COLFLAG_PRIMKEY)!=0
drhf8ffb272013-11-01 17:08:56 +0000482 ){
drh693e6712014-01-24 22:58:00 +0000483 testcase( oldmask!=0xffffffff && i==31 );
drh77f64bb2013-10-31 12:13:37 +0000484 sqlite3ExprCodeGetColumnOfTable(v, pTab, iDataCur, i, regOld+i);
danielk1977c3f9bad2002-05-15 08:30:12 +0000485 }else{
dan165921a2009-08-28 18:53:45 +0000486 sqlite3VdbeAddOp2(v, OP_Null, 0, regOld+i);
danielk1977c3f9bad2002-05-15 08:30:12 +0000487 }
488 }
drhf8ffb272013-11-01 17:08:56 +0000489 if( chngRowid==0 && pPk==0 ){
dan1da40a32009-09-19 17:00:31 +0000490 sqlite3VdbeAddOp2(v, OP_Copy, regOldRowid, regNewRowid);
491 }
dan165921a2009-08-28 18:53:45 +0000492 }
drh5cf590c2003-04-24 01:45:04 +0000493
dan165921a2009-08-28 18:53:45 +0000494 /* Populate the array of registers beginning at regNew with the new
peter.d.reid60ec9142014-09-06 16:39:46 +0000495 ** row data. This array is used to check constants, create the new
dan165921a2009-08-28 18:53:45 +0000496 ** table and index records, and as the values for any new.* references
danbb5f1682009-11-27 12:12:34 +0000497 ** made by triggers.
498 **
499 ** If there are one or more BEFORE triggers, then do not populate the
500 ** registers associated with columns that are (a) not modified by
501 ** this UPDATE statement and (b) not accessed by new.* references. The
502 ** values for registers not modified by the UPDATE must be reloaded from
503 ** the database after the BEFORE triggers are fired anyway (as the trigger
504 ** may have modified them). So not loading those that are not going to
505 ** be used eliminates some redundant opcodes.
506 */
507 newmask = sqlite3TriggerColmask(
508 pParse, pTrigger, pChanges, 1, TRIGGER_BEFORE, pTab, onError
509 );
dan165921a2009-08-28 18:53:45 +0000510 for(i=0; i<pTab->nCol; i++){
511 if( i==pTab->iPKey ){
drhedfac342013-12-19 02:56:01 +0000512 sqlite3VdbeAddOp2(v, OP_Null, 0, regNew+i);
dan165921a2009-08-28 18:53:45 +0000513 }else{
drh5cf590c2003-04-24 01:45:04 +0000514 j = aXRef[i];
danbb5f1682009-11-27 12:12:34 +0000515 if( j>=0 ){
516 sqlite3ExprCode(pParse, pChanges->a[j].pExpr, regNew+i);
drh693e6712014-01-24 22:58:00 +0000517 }else if( 0==(tmask&TRIGGER_BEFORE) || i>31 || (newmask & MASKBIT32(i)) ){
danbb5f1682009-11-27 12:12:34 +0000518 /* This branch loads the value of a column that will not be changed
519 ** into a register. This is done if there are no BEFORE triggers, or
520 ** if there are one or more BEFORE triggers that use this value via
521 ** a new.* reference in a trigger program.
522 */
drhfd7c9912009-12-01 22:09:25 +0000523 testcase( i==31 );
524 testcase( i==32 );
drhce78bc62015-10-15 19:21:51 +0000525 sqlite3ExprCodeGetColumnToReg(pParse, pTab, i, iDataCur, regNew+i);
drhedfac342013-12-19 02:56:01 +0000526 }else{
527 sqlite3VdbeAddOp2(v, OP_Null, 0, regNew+i);
drh5cf590c2003-04-24 01:45:04 +0000528 }
529 }
dan165921a2009-08-28 18:53:45 +0000530 }
drh5cf590c2003-04-24 01:45:04 +0000531
dan165921a2009-08-28 18:53:45 +0000532 /* Fire any BEFORE UPDATE triggers. This happens before constraints are
danbb5f1682009-11-27 12:12:34 +0000533 ** verified. One could argue that this is wrong.
534 */
535 if( tmask&TRIGGER_BEFORE ){
drh57bf4a82014-02-17 14:59:22 +0000536 sqlite3TableAffinity(v, pTab, regNew);
dan2832ad42009-08-31 15:27:27 +0000537 sqlite3CodeRowTrigger(pParse, pTrigger, TK_UPDATE, pChanges,
drhc3e356f2013-11-04 18:34:46 +0000538 TRIGGER_BEFORE, pTab, regOldRowid, onError, labelContinue);
danae0931e2009-09-09 15:06:10 +0000539
540 /* The row-trigger may have deleted the row being updated. In this
541 ** case, jump to the next row. No updates or AFTER triggers are
mistachkin48864df2013-03-21 21:20:32 +0000542 ** required. This behavior - what happens when the row being updated
danae0931e2009-09-09 15:06:10 +0000543 ** is deleted or renamed by a BEFORE trigger - is left undefined in the
danbb5f1682009-11-27 12:12:34 +0000544 ** documentation.
545 */
drhf8ffb272013-11-01 17:08:56 +0000546 if( pPk ){
drh702ba9f2013-11-07 21:25:13 +0000547 sqlite3VdbeAddOp4Int(v, OP_NotFound, iDataCur, labelContinue,regKey,nKey);
drh688852a2014-02-17 22:40:43 +0000548 VdbeCoverage(v);
drhf8ffb272013-11-01 17:08:56 +0000549 }else{
drhc3e356f2013-11-04 18:34:46 +0000550 sqlite3VdbeAddOp3(v, OP_NotExists, iDataCur, labelContinue, regOldRowid);
drh688852a2014-02-17 22:40:43 +0000551 VdbeCoverage(v);
drhf8ffb272013-11-01 17:08:56 +0000552 }
danbb5f1682009-11-27 12:12:34 +0000553
554 /* If it did not delete it, the row-trigger may still have modified
555 ** some of the columns of the row being updated. Load the values for
556 ** all columns not modified by the update statement into their
557 ** registers in case this has happened.
558 */
559 for(i=0; i<pTab->nCol; i++){
560 if( aXRef[i]<0 && i!=pTab->iPKey ){
drh313619f2013-10-31 20:34:06 +0000561 sqlite3ExprCodeGetColumnOfTable(v, pTab, iDataCur, i, regNew+i);
danbb5f1682009-11-27 12:12:34 +0000562 }
563 }
dan2832ad42009-08-31 15:27:27 +0000564 }
dan165921a2009-08-28 18:53:45 +0000565
566 if( !isView ){
drh728e0f92015-10-10 14:41:28 +0000567 int addr1 = 0; /* Address of jump instruction */
drhce60aa42013-11-08 01:09:15 +0000568 int bReplace = 0; /* True if REPLACE conflict resolution might happen */
dan165921a2009-08-28 18:53:45 +0000569
570 /* Do constraint checks. */
drhf8ffb272013-11-01 17:08:56 +0000571 assert( regOldRowid>0 );
572 sqlite3GenerateConstraintChecks(pParse, pTab, aRegIdx, iDataCur, iIdxCur,
drhce60aa42013-11-08 01:09:15 +0000573 regNewRowid, regOldRowid, chngKey, onError, labelContinue, &bReplace);
drh5cf590c2003-04-24 01:45:04 +0000574
dan1da40a32009-09-19 17:00:31 +0000575 /* Do FK constraint checks. */
dane7a94d82009-10-01 16:09:04 +0000576 if( hasFK ){
drhf8ffb272013-11-01 17:08:56 +0000577 sqlite3FkCheck(pParse, pTab, regOldRowid, 0, aXRef, chngKey);
dane7a94d82009-10-01 16:09:04 +0000578 }
dan1da40a32009-09-19 17:00:31 +0000579
dan165921a2009-08-28 18:53:45 +0000580 /* Delete the index entries associated with the current record. */
drhce60aa42013-11-08 01:09:15 +0000581 if( bReplace || chngKey ){
582 if( pPk ){
drh728e0f92015-10-10 14:41:28 +0000583 addr1 = sqlite3VdbeAddOp4Int(v, OP_NotFound, iDataCur, 0, regKey, nKey);
drhce60aa42013-11-08 01:09:15 +0000584 }else{
drh728e0f92015-10-10 14:41:28 +0000585 addr1 = sqlite3VdbeAddOp3(v, OP_NotExists, iDataCur, 0, regOldRowid);
drhce60aa42013-11-08 01:09:15 +0000586 }
drh5655c542014-02-19 19:14:34 +0000587 VdbeCoverageNeverTaken(v);
drh6fbe41a2013-10-30 20:22:55 +0000588 }
danf0ee1d32015-09-12 19:26:11 +0000589 sqlite3GenerateRowIndexDelete(pParse, pTab, iDataCur, iIdxCur, aRegIdx, -1);
dan165921a2009-08-28 18:53:45 +0000590
591 /* If changing the record number, delete the old record. */
drhf8ffb272013-11-01 17:08:56 +0000592 if( hasFK || chngKey || pPk!=0 ){
drh77f64bb2013-10-31 12:13:37 +0000593 sqlite3VdbeAddOp2(v, OP_Delete, iDataCur, 0);
drh5cf590c2003-04-24 01:45:04 +0000594 }
drhce60aa42013-11-08 01:09:15 +0000595 if( bReplace || chngKey ){
drh728e0f92015-10-10 14:41:28 +0000596 sqlite3VdbeJumpHere(v, addr1);
drh313619f2013-10-31 20:34:06 +0000597 }
dan9277efa2009-09-28 11:54:21 +0000598
dane7a94d82009-10-01 16:09:04 +0000599 if( hasFK ){
drhf8ffb272013-11-01 17:08:56 +0000600 sqlite3FkCheck(pParse, pTab, 0, regNewRowid, aXRef, chngKey);
dane7a94d82009-10-01 16:09:04 +0000601 }
dan165921a2009-08-28 18:53:45 +0000602
dan76d462e2009-08-30 11:42:51 +0000603 /* Insert the new index entries and the new record. */
drh77f64bb2013-10-31 12:13:37 +0000604 sqlite3CompleteInsertion(pParse, pTab, iDataCur, iIdxCur,
drh26198bb2013-10-31 11:15:09 +0000605 regNewRowid, aRegIdx, 1, 0, 0);
dan1da40a32009-09-19 17:00:31 +0000606
607 /* Do any ON CASCADE, SET NULL or SET DEFAULT operations required to
608 ** handle rows (possibly in other tables) that refer via a foreign key
609 ** to the row just updated. */
dane7a94d82009-10-01 16:09:04 +0000610 if( hasFK ){
drhf8ffb272013-11-01 17:08:56 +0000611 sqlite3FkActions(pParse, pTab, pChanges, regOldRowid, aXRef, chngKey);
dane7a94d82009-10-01 16:09:04 +0000612 }
drhcce7d172000-05-31 15:34:51 +0000613 }
614
drh0ca3e242002-01-29 23:07:02 +0000615 /* Increment the row counter
drh1bee3d72001-10-15 00:44:35 +0000616 */
dan165921a2009-08-28 18:53:45 +0000617 if( (db->flags & SQLITE_CountRows) && !pParse->pTriggerTab){
drh04adf412008-01-08 18:57:50 +0000618 sqlite3VdbeAddOp2(v, OP_AddImm, regRowCount, 1);
drh1bee3d72001-10-15 00:44:35 +0000619 }
620
dan165921a2009-08-28 18:53:45 +0000621 sqlite3CodeRowTrigger(pParse, pTrigger, TK_UPDATE, pChanges,
drhc3e356f2013-11-04 18:34:46 +0000622 TRIGGER_AFTER, pTab, regOldRowid, onError, labelContinue);
danielk1977c3f9bad2002-05-15 08:30:12 +0000623
drhcce7d172000-05-31 15:34:51 +0000624 /* Repeat the above with the next record to be updated, until
625 ** all record selected by the WHERE clause have been updated.
626 */
drh702ba9f2013-11-07 21:25:13 +0000627 if( okOnePass ){
628 /* Nothing to do at end-of-loop for a single-pass */
629 }else if( pPk ){
drhea22abe2013-10-25 19:17:17 +0000630 sqlite3VdbeResolveLabel(v, labelContinue);
drh688852a2014-02-17 22:40:43 +0000631 sqlite3VdbeAddOp2(v, OP_Next, iEph, addrTop); VdbeCoverage(v);
drh702ba9f2013-11-07 21:25:13 +0000632 }else{
drh076e85f2015-09-03 13:46:12 +0000633 sqlite3VdbeGoto(v, labelContinue);
drhea22abe2013-10-25 19:17:17 +0000634 }
635 sqlite3VdbeResolveLabel(v, labelBreak);
danielk1977c3f9bad2002-05-15 08:30:12 +0000636
danielk1977e448dc42008-01-02 11:50:51 +0000637 /* Close all tables */
638 for(i=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, i++){
drhb07028f2011-10-14 21:49:18 +0000639 assert( aRegIdx );
drhc51331d2013-11-16 23:16:31 +0000640 if( aToOpen[i+1] ){
drhfc8d4f92013-11-08 15:19:46 +0000641 sqlite3VdbeAddOp2(v, OP_Close, iIdxCur+i, 0);
danielk1977c3f9bad2002-05-15 08:30:12 +0000642 }
danielk1977e448dc42008-01-02 11:50:51 +0000643 }
drh77f64bb2013-10-31 12:13:37 +0000644 if( iDataCur<iIdxCur ) sqlite3VdbeAddOp2(v, OP_Close, iDataCur, 0);
danielk1977c3f9bad2002-05-15 08:30:12 +0000645
drh0b9f50d2009-06-23 20:28:53 +0000646 /* Update the sqlite_sequence table by storing the content of the
647 ** maximum rowid counter values recorded while inserting into
648 ** autoincrement tables.
649 */
dan165921a2009-08-28 18:53:45 +0000650 if( pParse->nested==0 && pParse->pTriggerTab==0 ){
drh0b9f50d2009-06-23 20:28:53 +0000651 sqlite3AutoincrementEnd(pParse);
652 }
653
drh1bee3d72001-10-15 00:44:35 +0000654 /*
danielk1977e7de6f22004-11-05 06:02:06 +0000655 ** Return the number of rows that were changed. If this routine is
656 ** generating code because of a call to sqlite3NestedParse(), do not
657 ** invoke the callback function.
drh1bee3d72001-10-15 00:44:35 +0000658 */
dan165921a2009-08-28 18:53:45 +0000659 if( (db->flags&SQLITE_CountRows) && !pParse->pTriggerTab && !pParse->nested ){
drh04adf412008-01-08 18:57:50 +0000660 sqlite3VdbeAddOp2(v, OP_ResultRow, regRowCount, 1);
danielk197722322fd2004-05-25 23:35:17 +0000661 sqlite3VdbeSetNumCols(v, 1);
danielk197710fb7492008-10-31 10:53:22 +0000662 sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "rows updated", SQLITE_STATIC);
drh1bee3d72001-10-15 00:44:35 +0000663 }
664
drhcce7d172000-05-31 15:34:51 +0000665update_cleanup:
danielk19774adee202004-05-08 08:23:19 +0000666 sqlite3AuthContextPop(&sContext);
drh6a534992013-11-16 20:13:39 +0000667 sqlite3DbFree(db, aXRef); /* Also frees aRegIdx[] and aToOpen[] */
drh633e6d52008-07-28 19:34:53 +0000668 sqlite3SrcListDelete(db, pTabList);
669 sqlite3ExprListDelete(db, pChanges);
670 sqlite3ExprDelete(db, pWhere);
drhcce7d172000-05-31 15:34:51 +0000671 return;
672}
dan75cbd982009-09-21 16:06:03 +0000673/* Make sure "isView" and other macros defined above are undefined. Otherwise
peter.d.reid60ec9142014-09-06 16:39:46 +0000674** they may interfere with compilation of other functions in this file
dan75cbd982009-09-21 16:06:03 +0000675** (or in another file, if this file becomes part of the amalgamation). */
676#ifdef isView
677 #undef isView
678#endif
679#ifdef pTrigger
680 #undef pTrigger
681#endif
drh9c419382006-06-16 21:13:21 +0000682
683#ifndef SQLITE_OMIT_VIRTUALTABLE
684/*
685** Generate code for an UPDATE of a virtual table.
686**
dan0f400372015-09-28 20:03:49 +0000687** There are two possible strategies - the default and the special
688** "onepass" strategy. Onepass is only used if the virtual table
689** implementation indicates that pWhere may match at most one row.
690**
691** The default strategy is to create an ephemeral table that contains
drh9c419382006-06-16 21:13:21 +0000692** for each row to be changed:
693**
694** (A) The original rowid of that row.
dan0f400372015-09-28 20:03:49 +0000695** (B) The revised rowid for the row.
drh9c419382006-06-16 21:13:21 +0000696** (C) The content of every column in the row.
697**
dan0f400372015-09-28 20:03:49 +0000698** Then loop through the contents of this ephemeral table executing a
699** VUpdate for each row. When finished, drop the ephemeral table.
drh9c419382006-06-16 21:13:21 +0000700**
dan0f400372015-09-28 20:03:49 +0000701** The "onepass" strategy does not use an ephemeral table. Instead, it
702** stores the same values (A, B and C above) in a register array and
703** makes a single invocation of VUpdate.
drh9c419382006-06-16 21:13:21 +0000704*/
705static void updateVirtualTable(
706 Parse *pParse, /* The parsing context */
707 SrcList *pSrc, /* The virtual table to be modified */
708 Table *pTab, /* The virtual table */
709 ExprList *pChanges, /* The columns to change in the UPDATE statement */
710 Expr *pRowid, /* Expression used to recompute the rowid */
711 int *aXRef, /* Mapping from columns of pTab to entries in pChanges */
danb061d052011-04-25 18:49:57 +0000712 Expr *pWhere, /* WHERE clause of the UPDATE statement */
713 int onError /* ON CONFLICT strategy */
drh9c419382006-06-16 21:13:21 +0000714){
715 Vdbe *v = pParse->pVdbe; /* Virtual machine under construction */
drh9c419382006-06-16 21:13:21 +0000716 int ephemTab; /* Table holding the result of the SELECT */
717 int i; /* Loop counter */
drh17435752007-08-16 04:30:38 +0000718 sqlite3 *db = pParse->db; /* Database connection */
danielk1977595a5232009-07-24 17:58:53 +0000719 const char *pVTab = (const char*)sqlite3GetVTable(db, pTab);
dan0f400372015-09-28 20:03:49 +0000720 WhereInfo *pWInfo;
721 int nArg = 2 + pTab->nCol; /* Number of arguments to VUpdate */
722 int regArg; /* First register in VUpdate arg array */
723 int regRec; /* Register in which to assemble record */
724 int regRowid; /* Register for ephem table rowid */
725 int iCsr = pSrc->a[0].iCursor; /* Cursor used for virtual table scan */
726 int aDummy[2]; /* Unused arg for sqlite3WhereOkOnePass() */
727 int bOnePass; /* True to use onepass strategy */
728 int addr; /* Address of OP_OpenEphemeral */
drh9c419382006-06-16 21:13:21 +0000729
dan0f400372015-09-28 20:03:49 +0000730 /* Allocate nArg registers to martial the arguments to VUpdate. Then
731 ** create and open the ephemeral table in which the records created from
732 ** these arguments will be temporarily stored. */
drh9c419382006-06-16 21:13:21 +0000733 assert( v );
734 ephemTab = pParse->nTab++;
dan0f400372015-09-28 20:03:49 +0000735 addr= sqlite3VdbeAddOp2(v, OP_OpenEphemeral, ephemTab, nArg);
736 regArg = pParse->nMem + 1;
737 pParse->nMem += nArg;
738 regRec = ++pParse->nMem;
739 regRowid = ++pParse->nMem;
drh9c419382006-06-16 21:13:21 +0000740
dan0f400372015-09-28 20:03:49 +0000741 /* Start scanning the virtual table */
742 pWInfo = sqlite3WhereBegin(pParse, pSrc, pWhere, 0,0,WHERE_ONEPASS_DESIRED,0);
743 if( pWInfo==0 ) return;
drh9c419382006-06-16 21:13:21 +0000744
dan0f400372015-09-28 20:03:49 +0000745 /* Populate the argument registers. */
746 sqlite3VdbeAddOp2(v, OP_Rowid, iCsr, regArg);
747 if( pRowid ){
748 sqlite3ExprCode(pParse, pRowid, regArg+1);
749 }else{
750 sqlite3VdbeAddOp2(v, OP_Rowid, iCsr, regArg+1);
751 }
drh9c419382006-06-16 21:13:21 +0000752 for(i=0; i<pTab->nCol; i++){
dan0f400372015-09-28 20:03:49 +0000753 if( aXRef[i]>=0 ){
754 sqlite3ExprCode(pParse, pChanges->a[aXRef[i]].pExpr, regArg+2+i);
755 }else{
756 sqlite3VdbeAddOp3(v, OP_VColumn, iCsr, i, regArg+2+i);
757 }
758 }
759
760 bOnePass = sqlite3WhereOkOnePass(pWInfo, aDummy);
761
762 if( bOnePass ){
763 /* If using the onepass strategy, no-op out the OP_OpenEphemeral coded
764 ** above. Also, if this is a top-level parse (not a trigger), clear the
765 ** multi-write flag so that the VM does not open a statement journal */
766 sqlite3VdbeChangeToNoop(v, addr);
drhc149f182015-09-29 13:25:15 +0000767 if( sqlite3IsToplevel(pParse) ){
dan0f400372015-09-28 20:03:49 +0000768 pParse->isMultiWrite = 0;
769 }
770 }else{
771 /* Create a record from the argument register contents and insert it into
772 ** the ephemeral table. */
773 sqlite3VdbeAddOp3(v, OP_MakeRecord, regArg, nArg, regRec);
774 sqlite3VdbeAddOp2(v, OP_NewRowid, ephemTab, regRowid);
775 sqlite3VdbeAddOp3(v, OP_Insert, ephemTab, regRec, regRowid);
776 }
777
dan0f400372015-09-28 20:03:49 +0000778
779 if( bOnePass==0 ){
dan354474a2015-09-29 10:11:26 +0000780 /* End the virtual table scan */
781 sqlite3WhereEnd(pWInfo);
782
dan0f400372015-09-28 20:03:49 +0000783 /* Begin scannning through the ephemeral table. */
dan354474a2015-09-29 10:11:26 +0000784 addr = sqlite3VdbeAddOp1(v, OP_Rewind, ephemTab); VdbeCoverage(v);
dan0f400372015-09-28 20:03:49 +0000785
786 /* Extract arguments from the current row of the ephemeral table and
787 ** invoke the VUpdate method. */
788 for(i=0; i<nArg; i++){
789 sqlite3VdbeAddOp3(v, OP_Column, ephemTab, i, regArg+i);
790 }
drh9c419382006-06-16 21:13:21 +0000791 }
drh4f3dd152008-04-28 18:46:43 +0000792 sqlite3VtabMakeWritable(pParse, pTab);
dan0f400372015-09-28 20:03:49 +0000793 sqlite3VdbeAddOp4(v, OP_VUpdate, 0, nArg, regArg, pVTab, P4_VTAB);
danb061d052011-04-25 18:49:57 +0000794 sqlite3VdbeChangeP5(v, onError==OE_Default ? OE_Abort : onError);
dane0af83a2009-09-08 19:15:01 +0000795 sqlite3MayAbort(pParse);
drh9c419382006-06-16 21:13:21 +0000796
dan354474a2015-09-29 10:11:26 +0000797 /* End of the ephemeral table scan. Or, if using the onepass strategy,
798 ** jump to here if the scan visited zero rows. */
dan0f400372015-09-28 20:03:49 +0000799 if( bOnePass==0 ){
800 sqlite3VdbeAddOp2(v, OP_Next, ephemTab, addr+1); VdbeCoverage(v);
801 sqlite3VdbeJumpHere(v, addr);
802 sqlite3VdbeAddOp2(v, OP_Close, ephemTab, 0);
dan354474a2015-09-29 10:11:26 +0000803 }else{
804 sqlite3WhereEnd(pWInfo);
dan0f400372015-09-28 20:03:49 +0000805 }
drh9c419382006-06-16 21:13:21 +0000806}
807#endif /* SQLITE_OMIT_VIRTUALTABLE */