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