src/update.c

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