1/*
2** 2001 September 15
3**
4** The author disclaims copyright to this source code. In place of
5** a legal notice, here is a blessing:
6**
7** May you do good and not evil.
8** May you find forgiveness for yourself and forgive others.
9** May you share freely, never taking more than you give.
10**
11*************************************************************************
12** This file contains C code routines that are called by the parser
13** to handle UPDATE statements.
14*/
15#include "sqliteInt.h"
16
17#ifndef SQLITE_OMIT_VIRTUALTABLE
18/* 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 */
26 Expr *pWhere, /* WHERE clause of the UPDATE statement */
27 int onError /* ON CONFLICT strategy */
28);
29#endif /* SQLITE_OMIT_VIRTUALTABLE */
30
31/*
32** The most recently coded instruction was an OP_Column to retrieve the
33** i-th column of table pTab. This routine sets the P4 parameter of the
34** OP_Column to the default value, if any.
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
41** from the P4 parameter of the OP_Column instruction, is returned instead.
42** If the former, then all row-records are guaranteed to include a value
43** for the column and the P4 value is not required.
44**
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_schema table.)
50**
51** Therefore, the P4 parameter is only required if the default value for
52** the column is a literal number, string or null. The sqlite3ValueFromExpr()
53** function is capable of transforming these types of expressions into
54** sqlite3_value objects.
55**
56** 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.
60*/
61void sqlite3ColumnDefault(Vdbe *v, Table *pTab, int i, int iReg){
62 Column *pCol;
63 assert( pTab!=0 );
64 assert( pTab->nCol>i );
65 pCol = &pTab->aCol[i];
66 if( pCol->iDflt ){
67 sqlite3_value *pValue = 0;
68 u8 enc = ENC(sqlite3VdbeDb(v));
69 assert( !IsView(pTab) );
70 VdbeComment((v, "%s.%s", pTab->zName, pCol->zCnName));
71 assert( i<pTab->nCol );
72 sqlite3ValueFromExpr(sqlite3VdbeDb(v),
73 sqlite3ColumnExpr(pTab,pCol), enc,
74 pCol->affinity, &pValue);
75 if( pValue ){
76 sqlite3VdbeAppendP4(v, pValue, P4_MEM);
77 }
78 }
79#ifndef SQLITE_OMIT_FLOATING_POINT
80 if( pCol->affinity==SQLITE_AFF_REAL && !IsVirtual(pTab) ){
81 sqlite3VdbeAddOp1(v, OP_RealAffinity, iReg);
82 }
83#endif
84}
85
86/*
87** Check to see if column iCol of index pIdx references any of the
88** columns defined by aXRef and chngRowid. Return true if it does
89** and false if not. This is an optimization. False-positives are a
90** performance degradation, but false-negatives can result in a corrupt
91** index and incorrect answers.
92**
93** aXRef[j] will be non-negative if column j of the original table is
94** being updated. chngRowid will be true if the rowid of the table is
95** being updated.
96*/
97static int indexColumnIsBeingUpdated(
98 Index *pIdx, /* The index to check */
99 int iCol, /* Which column of the index to check */
100 int *aXRef, /* aXRef[j]>=0 if column j is being updated */
101 int chngRowid /* true if the rowid is being updated */
102){
103 i16 iIdxCol = pIdx->aiColumn[iCol];
104 assert( iIdxCol!=XN_ROWID ); /* Cannot index rowid */
105 if( iIdxCol>=0 ){
106 return aXRef[iIdxCol]>=0;
107 }
108 assert( iIdxCol==XN_EXPR );
109 assert( pIdx->aColExpr!=0 );
110 assert( pIdx->aColExpr->a[iCol].pExpr!=0 );
111 return sqlite3ExprReferencesUpdatedColumn(pIdx->aColExpr->a[iCol].pExpr,
112 aXRef,chngRowid);
113}
114
115/*
116** Check to see if index pIdx is a partial index whose conditional
117** expression might change values due to an UPDATE. Return true if
118** the index is subject to change and false if the index is guaranteed
119** to be unchanged. This is an optimization. False-positives are a
120** performance degradation, but false-negatives can result in a corrupt
121** index and incorrect answers.
122**
123** aXRef[j] will be non-negative if column j of the original table is
124** being updated. chngRowid will be true if the rowid of the table is
125** being updated.
126*/
127static int indexWhereClauseMightChange(
128 Index *pIdx, /* The index to check */
129 int *aXRef, /* aXRef[j]>=0 if column j is being updated */
130 int chngRowid /* true if the rowid is being updated */
131){
132 if( pIdx->pPartIdxWhere==0 ) return 0;
133 return sqlite3ExprReferencesUpdatedColumn(pIdx->pPartIdxWhere,
134 aXRef, chngRowid);
135}
136
137/*
138** Allocate and return a pointer to an expression of type TK_ROW with
139** Expr.iColumn set to value (iCol+1). The resolver will modify the
140** expression to be a TK_COLUMN reading column iCol of the first
141** table in the source-list (pSrc->a[0]).
142*/
143static Expr *exprRowColumn(Parse *pParse, int iCol){
144 Expr *pRet = sqlite3PExpr(pParse, TK_ROW, 0, 0);
145 if( pRet ) pRet->iColumn = iCol+1;
146 return pRet;
147}
148
149/*
150** Assuming both the pLimit and pOrderBy parameters are NULL, this function
151** generates VM code to run the query:
152**
153** SELECT <other-columns>, pChanges FROM pTabList WHERE pWhere
154**
155** and write the results to the ephemeral table already opened as cursor
156** iEph. None of pChanges, pTabList or pWhere are modified or consumed by
157** this function, they must be deleted by the caller.
158**
159** Or, if pLimit and pOrderBy are not NULL, and pTab is not a view:
160**
161** SELECT <other-columns>, pChanges FROM pTabList
162** WHERE pWhere
163** GROUP BY <other-columns>
164** ORDER BY pOrderBy LIMIT pLimit
165**
166** If pTab is a view, the GROUP BY clause is omitted.
167**
168** Exactly how results are written to table iEph, and exactly what
169** the <other-columns> in the query above are is determined by the type
170** of table pTabList->a[0].pTab.
171**
172** If the table is a WITHOUT ROWID table, then argument pPk must be its
173** PRIMARY KEY. In this case <other-columns> are the primary key columns
174** of the table, in order. The results of the query are written to ephemeral
175** table iEph as index keys, using OP_IdxInsert.
176**
177** If the table is actually a view, then <other-columns> are all columns of
178** the view. The results are written to the ephemeral table iEph as records
179** with automatically assigned integer keys.
180**
181** If the table is a virtual or ordinary intkey table, then <other-columns>
182** is its rowid. For a virtual table, the results are written to iEph as
183** records with automatically assigned integer keys For intkey tables, the
184** rowid value in <other-columns> is used as the integer key, and the
185** remaining fields make up the table record.
186*/
187static void updateFromSelect(
188 Parse *pParse, /* Parse context */
189 int iEph, /* Cursor for open eph. table */
190 Index *pPk, /* PK if table 0 is WITHOUT ROWID */
191 ExprList *pChanges, /* List of expressions to return */
192 SrcList *pTabList, /* List of tables to select from */
193 Expr *pWhere, /* WHERE clause for query */
194 ExprList *pOrderBy, /* ORDER BY clause */
195 Expr *pLimit /* LIMIT clause */
196){
197 int i;
198 SelectDest dest;
199 Select *pSelect = 0;
200 ExprList *pList = 0;
201 ExprList *pGrp = 0;
202 Expr *pLimit2 = 0;
203 ExprList *pOrderBy2 = 0;
204 sqlite3 *db = pParse->db;
205 Table *pTab = pTabList->a[0].pTab;
206 SrcList *pSrc;
207 Expr *pWhere2;
208 int eDest;
209
210#ifdef SQLITE_ENABLE_UPDATE_DELETE_LIMIT
211 if( pOrderBy && pLimit==0 ) {
212 sqlite3ErrorMsg(pParse, "ORDER BY without LIMIT on UPDATE");
213 return;
214 }
215 pOrderBy2 = sqlite3ExprListDup(db, pOrderBy, 0);
216 pLimit2 = sqlite3ExprDup(db, pLimit, 0);
217#else
218 UNUSED_PARAMETER(pOrderBy);
219 UNUSED_PARAMETER(pLimit);
220#endif
221
222 pSrc = sqlite3SrcListDup(db, pTabList, 0);
223 pWhere2 = sqlite3ExprDup(db, pWhere, 0);
224
225 assert( pTabList->nSrc>1 );
226 if( pSrc ){
227 pSrc->a[0].fg.notCte = 1;
228 pSrc->a[0].iCursor = -1;
229 pSrc->a[0].pTab->nTabRef--;
230 pSrc->a[0].pTab = 0;
231 }
232 if( pPk ){
233 for(i=0; i<pPk->nKeyCol; i++){
234 Expr *pNew = exprRowColumn(pParse, pPk->aiColumn[i]);
235#ifdef SQLITE_ENABLE_UPDATE_DELETE_LIMIT
236 if( pLimit ){
237 pGrp = sqlite3ExprListAppend(pParse, pGrp, sqlite3ExprDup(db, pNew, 0));
238 }
239#endif
240 pList = sqlite3ExprListAppend(pParse, pList, pNew);
241 }
242 eDest = IsVirtual(pTab) ? SRT_Table : SRT_Upfrom;
243 }else if( IsView(pTab) ){
244 for(i=0; i<pTab->nCol; i++){
245 pList = sqlite3ExprListAppend(pParse, pList, exprRowColumn(pParse, i));
246 }
247 eDest = SRT_Table;
248 }else{
249 eDest = IsVirtual(pTab) ? SRT_Table : SRT_Upfrom;
250 pList = sqlite3ExprListAppend(pParse, 0, sqlite3PExpr(pParse,TK_ROW,0,0));
251#ifdef SQLITE_ENABLE_UPDATE_DELETE_LIMIT
252 if( pLimit ){
253 pGrp = sqlite3ExprListAppend(pParse, 0, sqlite3PExpr(pParse,TK_ROW,0,0));
254 }
255#endif
256 }
257 assert( pChanges!=0 || pParse->db->mallocFailed );
258 if( pChanges ){
259 for(i=0; i<pChanges->nExpr; i++){
260 pList = sqlite3ExprListAppend(pParse, pList,
261 sqlite3ExprDup(db, pChanges->a[i].pExpr, 0)
262 );
263 }
264 }
265 pSelect = sqlite3SelectNew(pParse, pList,
266 pSrc, pWhere2, pGrp, 0, pOrderBy2, SF_UFSrcCheck|SF_IncludeHidden, pLimit2
267 );
268 if( pSelect ) pSelect->selFlags |= SF_OrderByReqd;
269 sqlite3SelectDestInit(&dest, eDest, iEph);
270 dest.iSDParm2 = (pPk ? pPk->nKeyCol : -1);
271 sqlite3Select(pParse, pSelect, &dest);
272 sqlite3SelectDelete(db, pSelect);
273}
274
275/*
276** Process an UPDATE statement.
277**
278** UPDATE OR IGNORE tbl SET a=b, c=d FROM tbl2... WHERE e<5 AND f NOT NULL;
279** \_______/ \_/ \______/ \_____/ \________________/
280** onError | pChanges | pWhere
281** \_______________________/
282** pTabList
283*/
284void sqlite3Update(
285 Parse *pParse, /* The parser context */
286 SrcList *pTabList, /* The table in which we should change things */
287 ExprList *pChanges, /* Things to be changed */
288 Expr *pWhere, /* The WHERE clause. May be null */
289 int onError, /* How to handle constraint errors */
290 ExprList *pOrderBy, /* ORDER BY clause. May be null */
291 Expr *pLimit, /* LIMIT clause. May be null */
292 Upsert *pUpsert /* ON CONFLICT clause, or null */
293){
294 int i, j, k; /* Loop counters */
295 Table *pTab; /* The table to be updated */
296 int addrTop = 0; /* VDBE instruction address of the start of the loop */
297 WhereInfo *pWInfo = 0; /* Information about the WHERE clause */
298 Vdbe *v; /* The virtual database engine */
299 Index *pIdx; /* For looping over indices */
300 Index *pPk; /* The PRIMARY KEY index for WITHOUT ROWID tables */
301 int nIdx; /* Number of indices that need updating */
302 int nAllIdx; /* Total number of indexes */
303 int iBaseCur; /* Base cursor number */
304 int iDataCur; /* Cursor for the canonical data btree */
305 int iIdxCur; /* Cursor for the first index */
306 sqlite3 *db; /* The database structure */
307 int *aRegIdx = 0; /* Registers for to each index and the main table */
308 int *aXRef = 0; /* aXRef[i] is the index in pChanges->a[] of the
309 ** an expression for the i-th column of the table.
310 ** aXRef[i]==-1 if the i-th column is not changed. */
311 u8 *aToOpen; /* 1 for tables and indices to be opened */
312 u8 chngPk; /* PRIMARY KEY changed in a WITHOUT ROWID table */
313 u8 chngRowid; /* Rowid changed in a normal table */
314 u8 chngKey; /* Either chngPk or chngRowid */
315 Expr *pRowidExpr = 0; /* Expression defining the new record number */
316 int iRowidExpr = -1; /* Index of "rowid=" (or IPK) assignment in pChanges */
317 AuthContext sContext; /* The authorization context */
318 NameContext sNC; /* The name-context to resolve expressions in */
319 int iDb; /* Database containing the table being updated */
320 int eOnePass; /* ONEPASS_XXX value from where.c */
321 int hasFK; /* True if foreign key processing is required */
322 int labelBreak; /* Jump here to break out of UPDATE loop */
323 int labelContinue; /* Jump here to continue next step of UPDATE loop */
324 int flags; /* Flags for sqlite3WhereBegin() */
325
326#ifndef SQLITE_OMIT_TRIGGER
327 int isView; /* True when updating a view (INSTEAD OF trigger) */
328 Trigger *pTrigger; /* List of triggers on pTab, if required */
329 int tmask; /* Mask of TRIGGER_BEFORE|TRIGGER_AFTER */
330#endif
331 int newmask; /* Mask of NEW.* columns accessed by BEFORE triggers */
332 int iEph = 0; /* Ephemeral table holding all primary key values */
333 int nKey = 0; /* Number of elements in regKey for WITHOUT ROWID */
334 int aiCurOnePass[2]; /* The write cursors opened by WHERE_ONEPASS */
335 int addrOpen = 0; /* Address of OP_OpenEphemeral */
336 int iPk = 0; /* First of nPk cells holding PRIMARY KEY value */
337 i16 nPk = 0; /* Number of components of the PRIMARY KEY */
338 int bReplace = 0; /* True if REPLACE conflict resolution might happen */
339 int bFinishSeek = 1; /* The OP_FinishSeek opcode is needed */
340 int nChangeFrom = 0; /* If there is a FROM, pChanges->nExpr, else 0 */
341
342 /* Register Allocations */
343 int regRowCount = 0; /* A count of rows changed */
344 int regOldRowid = 0; /* The old rowid */
345 int regNewRowid = 0; /* The new rowid */
346 int regNew = 0; /* Content of the NEW.* table in triggers */
347 int regOld = 0; /* Content of OLD.* table in triggers */
348 int regRowSet = 0; /* Rowset of rows to be updated */
349 int regKey = 0; /* composite PRIMARY KEY value */
350
351 memset(&sContext, 0, sizeof(sContext));
352 db = pParse->db;
353 assert( db->pParse==pParse );
354 if( pParse->nErr ){
355 goto update_cleanup;
356 }
357 assert( db->mallocFailed==0 );
358
359 /* Locate the table which we want to update.
360 */
361 pTab = sqlite3SrcListLookup(pParse, pTabList);
362 if( pTab==0 ) goto update_cleanup;
363 iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
364
365 /* Figure out if we have any triggers and if the table being
366 ** updated is a view.
367 */
368#ifndef SQLITE_OMIT_TRIGGER
369 pTrigger = sqlite3TriggersExist(pParse, pTab, TK_UPDATE, pChanges, &tmask);
370 isView = IsView(pTab);
371 assert( pTrigger || tmask==0 );
372#else
373# define pTrigger 0
374# define isView 0
375# define tmask 0
376#endif
377#ifdef SQLITE_OMIT_VIEW
378# undef isView
379# define isView 0
380#endif
381
382#if TREETRACE_ENABLED
383 if( sqlite3TreeTrace & 0x10000 ){
384 sqlite3TreeViewLine(0, "In sqlite3Update() at %s:%d", __FILE__, __LINE__);
385 sqlite3TreeViewUpdate(pParse->pWith, pTabList, pChanges, pWhere,
386 onError, pOrderBy, pLimit, pUpsert, pTrigger);
387 }
388#endif
389
390 /* If there was a FROM clause, set nChangeFrom to the number of expressions
391 ** in the change-list. Otherwise, set it to 0. There cannot be a FROM
392 ** clause if this function is being called to generate code for part of
393 ** an UPSERT statement. */
394 nChangeFrom = (pTabList->nSrc>1) ? pChanges->nExpr : 0;
395 assert( nChangeFrom==0 || pUpsert==0 );
396
397#ifdef SQLITE_ENABLE_UPDATE_DELETE_LIMIT
398 if( !isView && nChangeFrom==0 ){
399 pWhere = sqlite3LimitWhere(
400 pParse, pTabList, pWhere, pOrderBy, pLimit, "UPDATE"
401 );
402 pOrderBy = 0;
403 pLimit = 0;
404 }
405#endif
406
407 if( sqlite3ViewGetColumnNames(pParse, pTab) ){
408 goto update_cleanup;
409 }
410 if( sqlite3IsReadOnly(pParse, pTab, tmask) ){
411 goto update_cleanup;
412 }
413
414 /* Allocate a cursors for the main database table and for all indices.
415 ** The index cursors might not be used, but if they are used they
416 ** need to occur right after the database cursor. So go ahead and
417 ** allocate enough space, just in case.
418 */
419 iBaseCur = iDataCur = pParse->nTab++;
420 iIdxCur = iDataCur+1;
421 pPk = HasRowid(pTab) ? 0 : sqlite3PrimaryKeyIndex(pTab);
422 testcase( pPk!=0 && pPk!=pTab->pIndex );
423 for(nIdx=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, nIdx++){
424 if( pPk==pIdx ){
425 iDataCur = pParse->nTab;
426 }
427 pParse->nTab++;
428 }
429 if( pUpsert ){
430 /* On an UPSERT, reuse the same cursors already opened by INSERT */
431 iDataCur = pUpsert->iDataCur;
432 iIdxCur = pUpsert->iIdxCur;
433 pParse->nTab = iBaseCur;
434 }
435 pTabList->a[0].iCursor = iDataCur;
436
437 /* Allocate space for aXRef[], aRegIdx[], and aToOpen[].
438 ** Initialize aXRef[] and aToOpen[] to their default values.
439 */
440 aXRef = sqlite3DbMallocRawNN(db, sizeof(int) * (pTab->nCol+nIdx+1) + nIdx+2 );
441 if( aXRef==0 ) goto update_cleanup;
442 aRegIdx = aXRef+pTab->nCol;
443 aToOpen = (u8*)(aRegIdx+nIdx+1);
444 memset(aToOpen, 1, nIdx+1);
445 aToOpen[nIdx+1] = 0;
446 for(i=0; i<pTab->nCol; i++) aXRef[i] = -1;
447
448 /* Initialize the name-context */
449 memset(&sNC, 0, sizeof(sNC));
450 sNC.pParse = pParse;
451 sNC.pSrcList = pTabList;
452 sNC.uNC.pUpsert = pUpsert;
453 sNC.ncFlags = NC_UUpsert;
454
455 /* Begin generating code. */
456 v = sqlite3GetVdbe(pParse);
457 if( v==0 ) goto update_cleanup;
458
459 /* Resolve the column names in all the expressions of the
460 ** of the UPDATE statement. Also find the column index
461 ** for each column to be updated in the pChanges array. For each
462 ** column to be updated, make sure we have authorization to change
463 ** that column.
464 */
465 chngRowid = chngPk = 0;
466 for(i=0; i<pChanges->nExpr; i++){
467 u8 hCol = sqlite3StrIHash(pChanges->a[i].zEName);
468 /* If this is an UPDATE with a FROM clause, do not resolve expressions
469 ** here. The call to sqlite3Select() below will do that. */
470 if( nChangeFrom==0 && sqlite3ResolveExprNames(&sNC, pChanges->a[i].pExpr) ){
471 goto update_cleanup;
472 }
473 for(j=0; j<pTab->nCol; j++){
474 if( pTab->aCol[j].hName==hCol
475 && sqlite3StrICmp(pTab->aCol[j].zCnName, pChanges->a[i].zEName)==0
476 ){
477 if( j==pTab->iPKey ){
478 chngRowid = 1;
479 pRowidExpr = pChanges->a[i].pExpr;
480 iRowidExpr = i;
481 }else if( pPk && (pTab->aCol[j].colFlags & COLFLAG_PRIMKEY)!=0 ){
482 chngPk = 1;
483 }
484#ifndef SQLITE_OMIT_GENERATED_COLUMNS
485 else if( pTab->aCol[j].colFlags & COLFLAG_GENERATED ){
486 testcase( pTab->aCol[j].colFlags & COLFLAG_VIRTUAL );
487 testcase( pTab->aCol[j].colFlags & COLFLAG_STORED );
488 sqlite3ErrorMsg(pParse,
489 "cannot UPDATE generated column \"%s\"",
490 pTab->aCol[j].zCnName);
491 goto update_cleanup;
492 }
493#endif
494 aXRef[j] = i;
495 break;
496 }
497 }
498 if( j>=pTab->nCol ){
499 if( pPk==0 && sqlite3IsRowid(pChanges->a[i].zEName) ){
500 j = -1;
501 chngRowid = 1;
502 pRowidExpr = pChanges->a[i].pExpr;
503 iRowidExpr = i;
504 }else{
505 sqlite3ErrorMsg(pParse, "no such column: %s", pChanges->a[i].zEName);
506 pParse->checkSchema = 1;
507 goto update_cleanup;
508 }
509 }
510#ifndef SQLITE_OMIT_AUTHORIZATION
511 {
512 int rc;
513 rc = sqlite3AuthCheck(pParse, SQLITE_UPDATE, pTab->zName,
514 j<0 ? "ROWID" : pTab->aCol[j].zCnName,
515 db->aDb[iDb].zDbSName);
516 if( rc==SQLITE_DENY ){
517 goto update_cleanup;
518 }else if( rc==SQLITE_IGNORE ){
519 aXRef[j] = -1;
520 }
521 }
522#endif
523 }
524 assert( (chngRowid & chngPk)==0 );
525 assert( chngRowid==0 || chngRowid==1 );
526 assert( chngPk==0 || chngPk==1 );
527 chngKey = chngRowid + chngPk;
528
529#ifndef SQLITE_OMIT_GENERATED_COLUMNS
530 /* Mark generated columns as changing if their generator expressions
531 ** reference any changing column. The actual aXRef[] value for
532 ** generated expressions is not used, other than to check to see that it
533 ** is non-negative, so the value of aXRef[] for generated columns can be
534 ** set to any non-negative number. We use 99999 so that the value is
535 ** obvious when looking at aXRef[] in a symbolic debugger.
536 */
537 if( pTab->tabFlags & TF_HasGenerated ){
538 int bProgress;
539 testcase( pTab->tabFlags & TF_HasVirtual );
540 testcase( pTab->tabFlags & TF_HasStored );
541 do{
542 bProgress = 0;
543 for(i=0; i<pTab->nCol; i++){
544 if( aXRef[i]>=0 ) continue;
545 if( (pTab->aCol[i].colFlags & COLFLAG_GENERATED)==0 ) continue;
546 if( sqlite3ExprReferencesUpdatedColumn(
547 sqlite3ColumnExpr(pTab, &pTab->aCol[i]),
548 aXRef, chngRowid)
549 ){
550 aXRef[i] = 99999;
551 bProgress = 1;
552 }
553 }
554 }while( bProgress );
555 }
556#endif
557
558 /* The SET expressions are not actually used inside the WHERE loop.
559 ** So reset the colUsed mask. Unless this is a virtual table. In that
560 ** case, set all bits of the colUsed mask (to ensure that the virtual
561 ** table implementation makes all columns available).
562 */
563 pTabList->a[0].colUsed = IsVirtual(pTab) ? ALLBITS : 0;
564
565 hasFK = sqlite3FkRequired(pParse, pTab, aXRef, chngKey);
566
567 /* There is one entry in the aRegIdx[] array for each index on the table
568 ** being updated. Fill in aRegIdx[] with a register number that will hold
569 ** the key for accessing each index.
570 */
571 if( onError==OE_Replace ) bReplace = 1;
572 for(nAllIdx=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, nAllIdx++){
573 int reg;
574 if( chngKey || hasFK>1 || pIdx==pPk
575 || indexWhereClauseMightChange(pIdx,aXRef,chngRowid)
576 ){
577 reg = ++pParse->nMem;
578 pParse->nMem += pIdx->nColumn;
579 }else{
580 reg = 0;
581 for(i=0; i<pIdx->nKeyCol; i++){
582 if( indexColumnIsBeingUpdated(pIdx, i, aXRef, chngRowid) ){
583 reg = ++pParse->nMem;
584 pParse->nMem += pIdx->nColumn;
585 if( onError==OE_Default && pIdx->onError==OE_Replace ){
586 bReplace = 1;
587 }
588 break;
589 }
590 }
591 }
592 if( reg==0 ) aToOpen[nAllIdx+1] = 0;
593 aRegIdx[nAllIdx] = reg;
594 }
595 aRegIdx[nAllIdx] = ++pParse->nMem; /* Register storing the table record */
596 if( bReplace ){
597 /* If REPLACE conflict resolution might be invoked, open cursors on all
598 ** indexes in case they are needed to delete records. */
599 memset(aToOpen, 1, nIdx+1);
600 }
601
602 if( pParse->nested==0 ) sqlite3VdbeCountChanges(v);
603 sqlite3BeginWriteOperation(pParse, pTrigger || hasFK, iDb);
604
605 /* Allocate required registers. */
606 if( !IsVirtual(pTab) ){
607 /* For now, regRowSet and aRegIdx[nAllIdx] share the same register.
608 ** If regRowSet turns out to be needed, then aRegIdx[nAllIdx] will be
609 ** reallocated. aRegIdx[nAllIdx] is the register in which the main
610 ** table record is written. regRowSet holds the RowSet for the
611 ** two-pass update algorithm. */
612 assert( aRegIdx[nAllIdx]==pParse->nMem );
613 regRowSet = aRegIdx[nAllIdx];
614 regOldRowid = regNewRowid = ++pParse->nMem;
615 if( chngPk || pTrigger || hasFK ){
616 regOld = pParse->nMem + 1;
617 pParse->nMem += pTab->nCol;
618 }
619 if( chngKey || pTrigger || hasFK ){
620 regNewRowid = ++pParse->nMem;
621 }
622 regNew = pParse->nMem + 1;
623 pParse->nMem += pTab->nCol;
624 }
625
626 /* Start the view context. */
627 if( isView ){
628 sqlite3AuthContextPush(pParse, &sContext, pTab->zName);
629 }
630
631 /* If we are trying to update a view, realize that view into
632 ** an ephemeral table.
633 */
634#if !defined(SQLITE_OMIT_VIEW) && !defined(SQLITE_OMIT_TRIGGER)
635 if( nChangeFrom==0 && isView ){
636 sqlite3MaterializeView(pParse, pTab,
637 pWhere, pOrderBy, pLimit, iDataCur
638 );
639 pOrderBy = 0;
640 pLimit = 0;
641 }
642#endif
643
644 /* Resolve the column names in all the expressions in the
645 ** WHERE clause.
646 */
647 if( nChangeFrom==0 && sqlite3ResolveExprNames(&sNC, pWhere) ){
648 goto update_cleanup;
649 }
650
651#ifndef SQLITE_OMIT_VIRTUALTABLE
652 /* Virtual tables must be handled separately */
653 if( IsVirtual(pTab) ){
654 updateVirtualTable(pParse, pTabList, pTab, pChanges, pRowidExpr, aXRef,
655 pWhere, onError);
656 goto update_cleanup;
657 }
658#endif
659
660 /* Jump to labelBreak to abandon further processing of this UPDATE */
661 labelContinue = labelBreak = sqlite3VdbeMakeLabel(pParse);
662
663 /* Not an UPSERT. Normal processing. Begin by
664 ** initialize the count of updated rows */
665 if( (db->flags&SQLITE_CountRows)!=0
666 && !pParse->pTriggerTab
667 && !pParse->nested
668 && !pParse->bReturning
669 && pUpsert==0
670 ){
671 regRowCount = ++pParse->nMem;
672 sqlite3VdbeAddOp2(v, OP_Integer, 0, regRowCount);
673 }
674
675 if( nChangeFrom==0 && HasRowid(pTab) ){
676 sqlite3VdbeAddOp3(v, OP_Null, 0, regRowSet, regOldRowid);
677 iEph = pParse->nTab++;
678 addrOpen = sqlite3VdbeAddOp3(v, OP_OpenEphemeral, iEph, 0, regRowSet);
679 }else{
680 assert( pPk!=0 || HasRowid(pTab) );
681 nPk = pPk ? pPk->nKeyCol : 0;
682 iPk = pParse->nMem+1;
683 pParse->nMem += nPk;
684 pParse->nMem += nChangeFrom;
685 regKey = ++pParse->nMem;
686 if( pUpsert==0 ){
687 int nEphCol = nPk + nChangeFrom + (isView ? pTab->nCol : 0);
688 iEph = pParse->nTab++;
689 if( pPk ) sqlite3VdbeAddOp3(v, OP_Null, 0, iPk, iPk+nPk-1);
690 addrOpen = sqlite3VdbeAddOp2(v, OP_OpenEphemeral, iEph, nEphCol);
691 if( pPk ){
692 KeyInfo *pKeyInfo = sqlite3KeyInfoOfIndex(pParse, pPk);
693 if( pKeyInfo ){
694 pKeyInfo->nAllField = nEphCol;
695 sqlite3VdbeAppendP4(v, pKeyInfo, P4_KEYINFO);
696 }
697 }
698 if( nChangeFrom ){
699 updateFromSelect(
700 pParse, iEph, pPk, pChanges, pTabList, pWhere, pOrderBy, pLimit
701 );
702#ifndef SQLITE_OMIT_SUBQUERY
703 if( isView ) iDataCur = iEph;
704#endif
705 }
706 }
707 }
708
709 if( nChangeFrom ){
710 sqlite3MultiWrite(pParse);
711 eOnePass = ONEPASS_OFF;
712 nKey = nPk;
713 regKey = iPk;
714 }else{
715 if( pUpsert ){
716 /* If this is an UPSERT, then all cursors have already been opened by
717 ** the outer INSERT and the data cursor should be pointing at the row
718 ** that is to be updated. So bypass the code that searches for the
719 ** row(s) to be updated.
720 */
721 pWInfo = 0;
722 eOnePass = ONEPASS_SINGLE;
723 sqlite3ExprIfFalse(pParse, pWhere, labelBreak, SQLITE_JUMPIFNULL);
724 bFinishSeek = 0;
725 }else{
726 /* Begin the database scan.
727 **
728 ** Do not consider a single-pass strategy for a multi-row update if
729 ** there are any triggers or foreign keys to process, or rows may
730 ** be deleted as a result of REPLACE conflict handling. Any of these
731 ** things might disturb a cursor being used to scan through the table
732 ** or index, causing a single-pass approach to malfunction. */
733 flags = WHERE_ONEPASS_DESIRED;
734 if( !pParse->nested && !pTrigger && !hasFK && !chngKey && !bReplace ){
735 flags |= WHERE_ONEPASS_MULTIROW;
736 }
737 pWInfo = sqlite3WhereBegin(pParse, pTabList, pWhere,0,0,0,flags,iIdxCur);
738 if( pWInfo==0 ) goto update_cleanup;
739
740 /* A one-pass strategy that might update more than one row may not
741 ** be used if any column of the index used for the scan is being
742 ** updated. Otherwise, if there is an index on "b", statements like
743 ** the following could create an infinite loop:
744 **
745 ** UPDATE t1 SET b=b+1 WHERE b>?
746 **
747 ** Fall back to ONEPASS_OFF if where.c has selected a ONEPASS_MULTI
748 ** strategy that uses an index for which one or more columns are being
749 ** updated. */
750 eOnePass = sqlite3WhereOkOnePass(pWInfo, aiCurOnePass);
751 bFinishSeek = sqlite3WhereUsesDeferredSeek(pWInfo);
752 if( eOnePass!=ONEPASS_SINGLE ){
753 sqlite3MultiWrite(pParse);
754 if( eOnePass==ONEPASS_MULTI ){
755 int iCur = aiCurOnePass[1];
756 if( iCur>=0 && iCur!=iDataCur && aToOpen[iCur-iBaseCur] ){
757 eOnePass = ONEPASS_OFF;
758 }
759 assert( iCur!=iDataCur || !HasRowid(pTab) );
760 }
761 }
762 }
763
764 if( HasRowid(pTab) ){
765 /* Read the rowid of the current row of the WHERE scan. In ONEPASS_OFF
766 ** mode, write the rowid into the FIFO. In either of the one-pass modes,
767 ** leave it in register regOldRowid. */
768 sqlite3VdbeAddOp2(v, OP_Rowid, iDataCur, regOldRowid);
769 if( eOnePass==ONEPASS_OFF ){
770 aRegIdx[nAllIdx] = ++pParse->nMem;
771 sqlite3VdbeAddOp3(v, OP_Insert, iEph, regRowSet, regOldRowid);
772 }else{
773 if( ALWAYS(addrOpen) ) sqlite3VdbeChangeToNoop(v, addrOpen);
774 }
775 }else{
776 /* Read the PK of the current row into an array of registers. In
777 ** ONEPASS_OFF mode, serialize the array into a record and store it in
778 ** the ephemeral table. Or, in ONEPASS_SINGLE or MULTI mode, change
779 ** the OP_OpenEphemeral instruction to a Noop (the ephemeral table
780 ** is not required) and leave the PK fields in the array of registers. */
781 for(i=0; i<nPk; i++){
782 assert( pPk->aiColumn[i]>=0 );
783 sqlite3ExprCodeGetColumnOfTable(v, pTab, iDataCur,
784 pPk->aiColumn[i], iPk+i);
785 }
786 if( eOnePass ){
787 if( addrOpen ) sqlite3VdbeChangeToNoop(v, addrOpen);
788 nKey = nPk;
789 regKey = iPk;
790 }else{
791 sqlite3VdbeAddOp4(v, OP_MakeRecord, iPk, nPk, regKey,
792 sqlite3IndexAffinityStr(db, pPk), nPk);
793 sqlite3VdbeAddOp4Int(v, OP_IdxInsert, iEph, regKey, iPk, nPk);
794 }
795 }
796 }
797
798 if( pUpsert==0 ){
799 if( nChangeFrom==0 && eOnePass!=ONEPASS_MULTI ){
800 sqlite3WhereEnd(pWInfo);
801 }
802
803 if( !isView ){
804 int addrOnce = 0;
805
806 /* Open every index that needs updating. */
807 if( eOnePass!=ONEPASS_OFF ){
808 if( aiCurOnePass[0]>=0 ) aToOpen[aiCurOnePass[0]-iBaseCur] = 0;
809 if( aiCurOnePass[1]>=0 ) aToOpen[aiCurOnePass[1]-iBaseCur] = 0;
810 }
811
812 if( eOnePass==ONEPASS_MULTI && (nIdx-(aiCurOnePass[1]>=0))>0 ){
813 addrOnce = sqlite3VdbeAddOp0(v, OP_Once); VdbeCoverage(v);
814 }
815 sqlite3OpenTableAndIndices(pParse, pTab, OP_OpenWrite, 0, iBaseCur,
816 aToOpen, 0, 0);
817 if( addrOnce ){
818 sqlite3VdbeJumpHereOrPopInst(v, addrOnce);
819 }
820 }
821
822 /* Top of the update loop */
823 if( eOnePass!=ONEPASS_OFF ){
824 if( aiCurOnePass[0]!=iDataCur
825 && aiCurOnePass[1]!=iDataCur
826#ifdef SQLITE_ALLOW_ROWID_IN_VIEW
827 && !isView
828#endif
829 ){
830 assert( pPk );
831 sqlite3VdbeAddOp4Int(v, OP_NotFound, iDataCur, labelBreak, regKey,nKey);
832 VdbeCoverage(v);
833 }
834 if( eOnePass!=ONEPASS_SINGLE ){
835 labelContinue = sqlite3VdbeMakeLabel(pParse);
836 }
837 sqlite3VdbeAddOp2(v, OP_IsNull, pPk ? regKey : regOldRowid, labelBreak);
838 VdbeCoverageIf(v, pPk==0);
839 VdbeCoverageIf(v, pPk!=0);
840 }else if( pPk || nChangeFrom ){
841 labelContinue = sqlite3VdbeMakeLabel(pParse);
842 sqlite3VdbeAddOp2(v, OP_Rewind, iEph, labelBreak); VdbeCoverage(v);
843 addrTop = sqlite3VdbeCurrentAddr(v);
844 if( nChangeFrom ){
845 if( !isView ){
846 if( pPk ){
847 for(i=0; i<nPk; i++){
848 sqlite3VdbeAddOp3(v, OP_Column, iEph, i, iPk+i);
849 }
850 sqlite3VdbeAddOp4Int(
851 v, OP_NotFound, iDataCur, labelContinue, iPk, nPk
852 ); VdbeCoverage(v);
853 }else{
854 sqlite3VdbeAddOp2(v, OP_Rowid, iEph, regOldRowid);
855 sqlite3VdbeAddOp3(
856 v, OP_NotExists, iDataCur, labelContinue, regOldRowid
857 ); VdbeCoverage(v);
858 }
859 }
860 }else{
861 sqlite3VdbeAddOp2(v, OP_RowData, iEph, regKey);
862 sqlite3VdbeAddOp4Int(v, OP_NotFound, iDataCur, labelContinue, regKey,0);
863 VdbeCoverage(v);
864 }
865 }else{
866 sqlite3VdbeAddOp2(v, OP_Rewind, iEph, labelBreak); VdbeCoverage(v);
867 labelContinue = sqlite3VdbeMakeLabel(pParse);
868 addrTop = sqlite3VdbeAddOp2(v, OP_Rowid, iEph, regOldRowid);
869 VdbeCoverage(v);
870 sqlite3VdbeAddOp3(v, OP_NotExists, iDataCur, labelContinue, regOldRowid);
871 VdbeCoverage(v);
872 }
873 }
874
875 /* If the rowid value will change, set register regNewRowid to
876 ** contain the new value. If the rowid is not being modified,
877 ** then regNewRowid is the same register as regOldRowid, which is
878 ** already populated. */
879 assert( chngKey || pTrigger || hasFK || regOldRowid==regNewRowid );
880 if( chngRowid ){
881 assert( iRowidExpr>=0 );
882 if( nChangeFrom==0 ){
883 sqlite3ExprCode(pParse, pRowidExpr, regNewRowid);
884 }else{
885 sqlite3VdbeAddOp3(v, OP_Column, iEph, iRowidExpr, regNewRowid);
886 }
887 sqlite3VdbeAddOp1(v, OP_MustBeInt, regNewRowid); VdbeCoverage(v);
888 }
889
890 /* Compute the old pre-UPDATE content of the row being changed, if that
891 ** information is needed */
892 if( chngPk || hasFK || pTrigger ){
893 u32 oldmask = (hasFK ? sqlite3FkOldmask(pParse, pTab) : 0);
894 oldmask |= sqlite3TriggerColmask(pParse,
895 pTrigger, pChanges, 0, TRIGGER_BEFORE|TRIGGER_AFTER, pTab, onError
896 );
897 for(i=0; i<pTab->nCol; i++){
898 u32 colFlags = pTab->aCol[i].colFlags;
899 k = sqlite3TableColumnToStorage(pTab, i) + regOld;
900 if( oldmask==0xffffffff
901 || (i<32 && (oldmask & MASKBIT32(i))!=0)
902 || (colFlags & COLFLAG_PRIMKEY)!=0
903 ){
904 testcase( oldmask!=0xffffffff && i==31 );
905 sqlite3ExprCodeGetColumnOfTable(v, pTab, iDataCur, i, k);
906 }else{
907 sqlite3VdbeAddOp2(v, OP_Null, 0, k);
908 }
909 }
910 if( chngRowid==0 && pPk==0 ){
911 sqlite3VdbeAddOp2(v, OP_Copy, regOldRowid, regNewRowid);
912 }
913 }
914
915 /* Populate the array of registers beginning at regNew with the new
916 ** row data. This array is used to check constants, create the new
917 ** table and index records, and as the values for any new.* references
918 ** made by triggers.
919 **
920 ** If there are one or more BEFORE triggers, then do not populate the
921 ** registers associated with columns that are (a) not modified by
922 ** this UPDATE statement and (b) not accessed by new.* references. The
923 ** values for registers not modified by the UPDATE must be reloaded from
924 ** the database after the BEFORE triggers are fired anyway (as the trigger
925 ** may have modified them). So not loading those that are not going to
926 ** be used eliminates some redundant opcodes.
927 */
928 newmask = sqlite3TriggerColmask(
929 pParse, pTrigger, pChanges, 1, TRIGGER_BEFORE, pTab, onError
930 );
931 for(i=0, k=regNew; i<pTab->nCol; i++, k++){
932 if( i==pTab->iPKey ){
933 sqlite3VdbeAddOp2(v, OP_Null, 0, k);
934 }else if( (pTab->aCol[i].colFlags & COLFLAG_GENERATED)!=0 ){
935 if( pTab->aCol[i].colFlags & COLFLAG_VIRTUAL ) k--;
936 }else{
937 j = aXRef[i];
938 if( j>=0 ){
939 if( nChangeFrom ){
940 int nOff = (isView ? pTab->nCol : nPk);
941 assert( eOnePass==ONEPASS_OFF );
942 sqlite3VdbeAddOp3(v, OP_Column, iEph, nOff+j, k);
943 }else{
944 sqlite3ExprCode(pParse, pChanges->a[j].pExpr, k);
945 }
946 }else if( 0==(tmask&TRIGGER_BEFORE) || i>31 || (newmask & MASKBIT32(i)) ){
947 /* This branch loads the value of a column that will not be changed
948 ** into a register. This is done if there are no BEFORE triggers, or
949 ** if there are one or more BEFORE triggers that use this value via
950 ** a new.* reference in a trigger program.
951 */
952 testcase( i==31 );
953 testcase( i==32 );
954 sqlite3ExprCodeGetColumnOfTable(v, pTab, iDataCur, i, k);
955 bFinishSeek = 0;
956 }else{
957 sqlite3VdbeAddOp2(v, OP_Null, 0, k);
958 }
959 }
960 }
961#ifndef SQLITE_OMIT_GENERATED_COLUMNS
962 if( pTab->tabFlags & TF_HasGenerated ){
963 testcase( pTab->tabFlags & TF_HasVirtual );
964 testcase( pTab->tabFlags & TF_HasStored );
965 sqlite3ComputeGeneratedColumns(pParse, regNew, pTab);
966 }
967#endif
968
969 /* Fire any BEFORE UPDATE triggers. This happens before constraints are
970 ** verified. One could argue that this is wrong.
971 */
972 if( tmask&TRIGGER_BEFORE ){
973 sqlite3TableAffinity(v, pTab, regNew);
974 sqlite3CodeRowTrigger(pParse, pTrigger, TK_UPDATE, pChanges,
975 TRIGGER_BEFORE, pTab, regOldRowid, onError, labelContinue);
976
977 if( !isView ){
978 /* The row-trigger may have deleted the row being updated. In this
979 ** case, jump to the next row. No updates or AFTER triggers are
980 ** required. This behavior - what happens when the row being updated
981 ** is deleted or renamed by a BEFORE trigger - is left undefined in the
982 ** documentation.
983 */
984 if( pPk ){
985 sqlite3VdbeAddOp4Int(v, OP_NotFound,iDataCur,labelContinue,regKey,nKey);
986 VdbeCoverage(v);
987 }else{
988 sqlite3VdbeAddOp3(v, OP_NotExists, iDataCur, labelContinue,regOldRowid);
989 VdbeCoverage(v);
990 }
991
992 /* After-BEFORE-trigger-reload-loop:
993 ** If it did not delete it, the BEFORE trigger may still have modified
994 ** some of the columns of the row being updated. Load the values for
995 ** all columns not modified by the update statement into their registers
996 ** in case this has happened. Only unmodified columns are reloaded.
997 ** The values computed for modified columns use the values before the
998 ** BEFORE trigger runs. See test case trigger1-18.0 (added 2018-04-26)
999 ** for an example.
1000 */
1001 for(i=0, k=regNew; i<pTab->nCol; i++, k++){
1002 if( pTab->aCol[i].colFlags & COLFLAG_GENERATED ){
1003 if( pTab->aCol[i].colFlags & COLFLAG_VIRTUAL ) k--;
1004 }else if( aXRef[i]<0 && i!=pTab->iPKey ){
1005 sqlite3ExprCodeGetColumnOfTable(v, pTab, iDataCur, i, k);
1006 }
1007 }
1008#ifndef SQLITE_OMIT_GENERATED_COLUMNS
1009 if( pTab->tabFlags & TF_HasGenerated ){
1010 testcase( pTab->tabFlags & TF_HasVirtual );
1011 testcase( pTab->tabFlags & TF_HasStored );
1012 sqlite3ComputeGeneratedColumns(pParse, regNew, pTab);
1013 }
1014#endif
1015 }
1016 }
1017
1018 if( !isView ){
1019 /* Do constraint checks. */
1020 assert( regOldRowid>0 );
1021 sqlite3GenerateConstraintChecks(pParse, pTab, aRegIdx, iDataCur, iIdxCur,
1022 regNewRowid, regOldRowid, chngKey, onError, labelContinue, &bReplace,
1023 aXRef, 0);
1024
1025 /* If REPLACE conflict handling may have been used, or if the PK of the
1026 ** row is changing, then the GenerateConstraintChecks() above may have
1027 ** moved cursor iDataCur. Reseek it. */
1028 if( bReplace || chngKey ){
1029 if( pPk ){
1030 sqlite3VdbeAddOp4Int(v, OP_NotFound,iDataCur,labelContinue,regKey,nKey);
1031 }else{
1032 sqlite3VdbeAddOp3(v, OP_NotExists, iDataCur, labelContinue,regOldRowid);
1033 }
1034 VdbeCoverage(v);
1035 }
1036
1037 /* Do FK constraint checks. */
1038 if( hasFK ){
1039 sqlite3FkCheck(pParse, pTab, regOldRowid, 0, aXRef, chngKey);
1040 }
1041
1042 /* Delete the index entries associated with the current record. */
1043 sqlite3GenerateRowIndexDelete(pParse, pTab, iDataCur, iIdxCur, aRegIdx, -1);
1044
1045 /* We must run the OP_FinishSeek opcode to resolve a prior
1046 ** OP_DeferredSeek if there is any possibility that there have been
1047 ** no OP_Column opcodes since the OP_DeferredSeek was issued. But
1048 ** we want to avoid the OP_FinishSeek if possible, as running it
1049 ** costs CPU cycles. */
1050 if( bFinishSeek ){
1051 sqlite3VdbeAddOp1(v, OP_FinishSeek, iDataCur);
1052 }
1053
1054 /* If changing the rowid value, or if there are foreign key constraints
1055 ** to process, delete the old record. Otherwise, add a noop OP_Delete
1056 ** to invoke the pre-update hook.
1057 **
1058 ** That (regNew==regnewRowid+1) is true is also important for the
1059 ** pre-update hook. If the caller invokes preupdate_new(), the returned
1060 ** value is copied from memory cell (regNewRowid+1+iCol), where iCol
1061 ** is the column index supplied by the user.
1062 */
1063 assert( regNew==regNewRowid+1 );
1064#ifdef SQLITE_ENABLE_PREUPDATE_HOOK
1065 sqlite3VdbeAddOp3(v, OP_Delete, iDataCur,
1066 OPFLAG_ISUPDATE | ((hasFK>1 || chngKey) ? 0 : OPFLAG_ISNOOP),
1067 regNewRowid
1068 );
1069 if( eOnePass==ONEPASS_MULTI ){
1070 assert( hasFK==0 && chngKey==0 );
1071 sqlite3VdbeChangeP5(v, OPFLAG_SAVEPOSITION);
1072 }
1073 if( !pParse->nested ){
1074 sqlite3VdbeAppendP4(v, pTab, P4_TABLE);
1075 }
1076#else
1077 if( hasFK>1 || chngKey ){
1078 sqlite3VdbeAddOp2(v, OP_Delete, iDataCur, 0);
1079 }
1080#endif
1081
1082 if( hasFK ){
1083 sqlite3FkCheck(pParse, pTab, 0, regNewRowid, aXRef, chngKey);
1084 }
1085
1086 /* Insert the new index entries and the new record. */
1087 sqlite3CompleteInsertion(
1088 pParse, pTab, iDataCur, iIdxCur, regNewRowid, aRegIdx,
1089 OPFLAG_ISUPDATE | (eOnePass==ONEPASS_MULTI ? OPFLAG_SAVEPOSITION : 0),
1090 0, 0
1091 );
1092
1093 /* Do any ON CASCADE, SET NULL or SET DEFAULT operations required to
1094 ** handle rows (possibly in other tables) that refer via a foreign key
1095 ** to the row just updated. */
1096 if( hasFK ){
1097 sqlite3FkActions(pParse, pTab, pChanges, regOldRowid, aXRef, chngKey);
1098 }
1099 }
1100
1101 /* Increment the row counter
1102 */
1103 if( regRowCount ){
1104 sqlite3VdbeAddOp2(v, OP_AddImm, regRowCount, 1);
1105 }
1106
1107 sqlite3CodeRowTrigger(pParse, pTrigger, TK_UPDATE, pChanges,
1108 TRIGGER_AFTER, pTab, regOldRowid, onError, labelContinue);
1109
1110 /* Repeat the above with the next record to be updated, until
1111 ** all record selected by the WHERE clause have been updated.
1112 */
1113 if( eOnePass==ONEPASS_SINGLE ){
1114 /* Nothing to do at end-of-loop for a single-pass */
1115 }else if( eOnePass==ONEPASS_MULTI ){
1116 sqlite3VdbeResolveLabel(v, labelContinue);
1117 sqlite3WhereEnd(pWInfo);
1118 }else{
1119 sqlite3VdbeResolveLabel(v, labelContinue);
1120 sqlite3VdbeAddOp2(v, OP_Next, iEph, addrTop); VdbeCoverage(v);
1121 }
1122 sqlite3VdbeResolveLabel(v, labelBreak);
1123
1124 /* Update the sqlite_sequence table by storing the content of the
1125 ** maximum rowid counter values recorded while inserting into
1126 ** autoincrement tables.
1127 */
1128 if( pParse->nested==0 && pParse->pTriggerTab==0 && pUpsert==0 ){
1129 sqlite3AutoincrementEnd(pParse);
1130 }
1131
1132 /*
1133 ** Return the number of rows that were changed, if we are tracking
1134 ** that information.
1135 */
1136 if( regRowCount ){
1137 sqlite3CodeChangeCount(v, regRowCount, "rows updated");
1138 }
1139
1140update_cleanup:
1141 sqlite3AuthContextPop(&sContext);
1142 sqlite3DbFree(db, aXRef); /* Also frees aRegIdx[] and aToOpen[] */
1143 sqlite3SrcListDelete(db, pTabList);
1144 sqlite3ExprListDelete(db, pChanges);
1145 sqlite3ExprDelete(db, pWhere);
1146#if defined(SQLITE_ENABLE_UPDATE_DELETE_LIMIT)
1147 sqlite3ExprListDelete(db, pOrderBy);
1148 sqlite3ExprDelete(db, pLimit);
1149#endif
1150 return;
1151}
1152/* Make sure "isView" and other macros defined above are undefined. Otherwise
1153** they may interfere with compilation of other functions in this file
1154** (or in another file, if this file becomes part of the amalgamation). */
1155#ifdef isView
1156 #undef isView
1157#endif
1158#ifdef pTrigger
1159 #undef pTrigger
1160#endif
1161
1162#ifndef SQLITE_OMIT_VIRTUALTABLE
1163/*
1164** Generate code for an UPDATE of a virtual table.
1165**
1166** There are two possible strategies - the default and the special
1167** "onepass" strategy. Onepass is only used if the virtual table
1168** implementation indicates that pWhere may match at most one row.
1169**
1170** The default strategy is to create an ephemeral table that contains
1171** for each row to be changed:
1172**
1173** (A) The original rowid of that row.
1174** (B) The revised rowid for the row.
1175** (C) The content of every column in the row.
1176**
1177** Then loop through the contents of this ephemeral table executing a
1178** VUpdate for each row. When finished, drop the ephemeral table.
1179**
1180** The "onepass" strategy does not use an ephemeral table. Instead, it
1181** stores the same values (A, B and C above) in a register array and
1182** makes a single invocation of VUpdate.
1183*/
1184static void updateVirtualTable(
1185 Parse *pParse, /* The parsing context */
1186 SrcList *pSrc, /* The virtual table to be modified */
1187 Table *pTab, /* The virtual table */
1188 ExprList *pChanges, /* The columns to change in the UPDATE statement */
1189 Expr *pRowid, /* Expression used to recompute the rowid */
1190 int *aXRef, /* Mapping from columns of pTab to entries in pChanges */
1191 Expr *pWhere, /* WHERE clause of the UPDATE statement */
1192 int onError /* ON CONFLICT strategy */
1193){
1194 Vdbe *v = pParse->pVdbe; /* Virtual machine under construction */
1195 int ephemTab; /* Table holding the result of the SELECT */
1196 int i; /* Loop counter */
1197 sqlite3 *db = pParse->db; /* Database connection */
1198 const char *pVTab = (const char*)sqlite3GetVTable(db, pTab);
1199 WhereInfo *pWInfo = 0;
1200 int nArg = 2 + pTab->nCol; /* Number of arguments to VUpdate */
1201 int regArg; /* First register in VUpdate arg array */
1202 int regRec; /* Register in which to assemble record */
1203 int regRowid; /* Register for ephem table rowid */
1204 int iCsr = pSrc->a[0].iCursor; /* Cursor used for virtual table scan */
1205 int aDummy[2]; /* Unused arg for sqlite3WhereOkOnePass() */
1206 int eOnePass; /* True to use onepass strategy */
1207 int addr; /* Address of OP_OpenEphemeral */
1208
1209 /* Allocate nArg registers in which to gather the arguments for VUpdate. Then
1210 ** create and open the ephemeral table in which the records created from
1211 ** these arguments will be temporarily stored. */
1212 assert( v );
1213 ephemTab = pParse->nTab++;
1214 addr= sqlite3VdbeAddOp2(v, OP_OpenEphemeral, ephemTab, nArg);
1215 regArg = pParse->nMem + 1;
1216 pParse->nMem += nArg;
1217 if( pSrc->nSrc>1 ){
1218 Index *pPk = 0;
1219 Expr *pRow;
1220 ExprList *pList;
1221 if( HasRowid(pTab) ){
1222 if( pRowid ){
1223 pRow = sqlite3ExprDup(db, pRowid, 0);
1224 }else{
1225 pRow = sqlite3PExpr(pParse, TK_ROW, 0, 0);
1226 }
1227 }else{
1228 i16 iPk; /* PRIMARY KEY column */
1229 pPk = sqlite3PrimaryKeyIndex(pTab);
1230 assert( pPk!=0 );
1231 assert( pPk->nKeyCol==1 );
1232 iPk = pPk->aiColumn[0];
1233 if( aXRef[iPk]>=0 ){
1234 pRow = sqlite3ExprDup(db, pChanges->a[aXRef[iPk]].pExpr, 0);
1235 }else{
1236 pRow = exprRowColumn(pParse, iPk);
1237 }
1238 }
1239 pList = sqlite3ExprListAppend(pParse, 0, pRow);
1240
1241 for(i=0; i<pTab->nCol; i++){
1242 if( aXRef[i]>=0 ){
1243 pList = sqlite3ExprListAppend(pParse, pList,
1244 sqlite3ExprDup(db, pChanges->a[aXRef[i]].pExpr, 0)
1245 );
1246 }else{
1247 pList = sqlite3ExprListAppend(pParse, pList, exprRowColumn(pParse, i));
1248 }
1249 }
1250
1251 updateFromSelect(pParse, ephemTab, pPk, pList, pSrc, pWhere, 0, 0);
1252 sqlite3ExprListDelete(db, pList);
1253 eOnePass = ONEPASS_OFF;
1254 }else{
1255 regRec = ++pParse->nMem;
1256 regRowid = ++pParse->nMem;
1257
1258 /* Start scanning the virtual table */
1259 pWInfo = sqlite3WhereBegin(
1260 pParse, pSrc, pWhere, 0, 0, 0, WHERE_ONEPASS_DESIRED, 0
1261 );
1262 if( pWInfo==0 ) return;
1263
1264 /* Populate the argument registers. */
1265 for(i=0; i<pTab->nCol; i++){
1266 assert( (pTab->aCol[i].colFlags & COLFLAG_GENERATED)==0 );
1267 if( aXRef[i]>=0 ){
1268 sqlite3ExprCode(pParse, pChanges->a[aXRef[i]].pExpr, regArg+2+i);
1269 }else{
1270 sqlite3VdbeAddOp3(v, OP_VColumn, iCsr, i, regArg+2+i);
1271 sqlite3VdbeChangeP5(v, OPFLAG_NOCHNG);/* For sqlite3_vtab_nochange() */
1272 }
1273 }
1274 if( HasRowid(pTab) ){
1275 sqlite3VdbeAddOp2(v, OP_Rowid, iCsr, regArg);
1276 if( pRowid ){
1277 sqlite3ExprCode(pParse, pRowid, regArg+1);
1278 }else{
1279 sqlite3VdbeAddOp2(v, OP_Rowid, iCsr, regArg+1);
1280 }
1281 }else{
1282 Index *pPk; /* PRIMARY KEY index */
1283 i16 iPk; /* PRIMARY KEY column */
1284 pPk = sqlite3PrimaryKeyIndex(pTab);
1285 assert( pPk!=0 );
1286 assert( pPk->nKeyCol==1 );
1287 iPk = pPk->aiColumn[0];
1288 sqlite3VdbeAddOp3(v, OP_VColumn, iCsr, iPk, regArg);
1289 sqlite3VdbeAddOp2(v, OP_SCopy, regArg+2+iPk, regArg+1);
1290 }
1291
1292 eOnePass = sqlite3WhereOkOnePass(pWInfo, aDummy);
1293
1294 /* There is no ONEPASS_MULTI on virtual tables */
1295 assert( eOnePass==ONEPASS_OFF || eOnePass==ONEPASS_SINGLE );
1296
1297 if( eOnePass ){
1298 /* If using the onepass strategy, no-op out the OP_OpenEphemeral coded
1299 ** above. */
1300 sqlite3VdbeChangeToNoop(v, addr);
1301 sqlite3VdbeAddOp1(v, OP_Close, iCsr);
1302 }else{
1303 /* Create a record from the argument register contents and insert it into
1304 ** the ephemeral table. */
1305 sqlite3MultiWrite(pParse);
1306 sqlite3VdbeAddOp3(v, OP_MakeRecord, regArg, nArg, regRec);
1307#if defined(SQLITE_DEBUG) && !defined(SQLITE_ENABLE_NULL_TRIM)
1308 /* Signal an assert() within OP_MakeRecord that it is allowed to
1309 ** accept no-change records with serial_type 10 */
1310 sqlite3VdbeChangeP5(v, OPFLAG_NOCHNG_MAGIC);
1311#endif
1312 sqlite3VdbeAddOp2(v, OP_NewRowid, ephemTab, regRowid);
1313 sqlite3VdbeAddOp3(v, OP_Insert, ephemTab, regRec, regRowid);
1314 }
1315 }
1316
1317
1318 if( eOnePass==ONEPASS_OFF ){
1319 /* End the virtual table scan */
1320 if( pSrc->nSrc==1 ){
1321 sqlite3WhereEnd(pWInfo);
1322 }
1323
1324 /* Begin scannning through the ephemeral table. */
1325 addr = sqlite3VdbeAddOp1(v, OP_Rewind, ephemTab); VdbeCoverage(v);
1326
1327 /* Extract arguments from the current row of the ephemeral table and
1328 ** invoke the VUpdate method. */
1329 for(i=0; i<nArg; i++){
1330 sqlite3VdbeAddOp3(v, OP_Column, ephemTab, i, regArg+i);
1331 }
1332 }
1333 sqlite3VtabMakeWritable(pParse, pTab);
1334 sqlite3VdbeAddOp4(v, OP_VUpdate, 0, nArg, regArg, pVTab, P4_VTAB);
1335 sqlite3VdbeChangeP5(v, onError==OE_Default ? OE_Abort : onError);
1336 sqlite3MayAbort(pParse);
1337
1338 /* End of the ephemeral table scan. Or, if using the onepass strategy,
1339 ** jump to here if the scan visited zero rows. */
1340 if( eOnePass==ONEPASS_OFF ){
1341 sqlite3VdbeAddOp2(v, OP_Next, ephemTab, addr+1); VdbeCoverage(v);
1342 sqlite3VdbeJumpHere(v, addr);
1343 sqlite3VdbeAddOp2(v, OP_Close, ephemTab, 0);
1344 }else{
1345 sqlite3WhereEnd(pWInfo);
1346 }
1347}
1348#endif /* SQLITE_OMIT_VIRTUALTABLE */
1349