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_master 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 parameter iReg is not negative, code an OP_RealAffinity instruction
  57 ** on register iReg. This is used when an equivalent integer value is
  58 ** stored in place of an 8-byte floating point value in order to save
  59 ** space.
  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       sqlite3VdbeChangeP4(v, -1, (const char *)pValue, P4_MEM);
  73     }
  74 #ifndef SQLITE_OMIT_FLOATING_POINT
  75     if( pTab->aCol[i].affinity==SQLITE_AFF_REAL ){
  76       sqlite3VdbeAddOp1(v, OP_RealAffinity, iReg);
  77     }
  78 #endif
  79   }
  80 }
  81
  82 /*
  83 ** Process an UPDATE statement.
  84 **
  85 **   UPDATE OR IGNORE table_wxyz SET a=b, c=d WHERE e<5 AND f NOT NULL;
  86 **          \_______/ \________/     \______/       \________________/
  87 *            onError   pTabList      pChanges             pWhere
  88 */
  89 void sqlite3Update(
  90   Parse *pParse,         /* The parser context */
  91   SrcList *pTabList,     /* The table in which we should change things */
  92   ExprList *pChanges,    /* Things to be changed */
  93   Expr *pWhere,          /* The WHERE clause.  May be null */
  94   int onError            /* How to handle constraint errors */
  95 ){
  96   int i, j;              /* Loop counters */
  97   Table *pTab;           /* The table to be updated */
  98   int addrTop = 0;       /* VDBE instruction address of the start of the loop */
  99   WhereInfo *pWInfo;     /* Information about the WHERE clause */
 100   Vdbe *v;               /* The virtual database engine */
 101   Index *pIdx;           /* For looping over indices */
 102   Index *pPk;            /* The PRIMARY KEY index for WITHOUT ROWID tables */
 103   int nIdx;              /* Number of indices that need updating */
 104   int iBaseCur;          /* Base cursor number */
 105   int iDataCur;          /* Cursor for the canonical data btree */
 106   int iIdxCur;           /* Cursor for the first index */
 107   sqlite3 *db;           /* The database structure */
 108   int *aRegIdx = 0;      /* One register assigned to each index to be updated */
 109   int *aXRef = 0;        /* aXRef[i] is the index in pChanges->a[] of the
 110                          ** an expression for the i-th column of the table.
 111                          ** aXRef[i]==-1 if the i-th column is not changed. */
 112   u8 *aToOpen;           /* 1 for tables and indices to be opened */
 113   u8 chngPk;             /* PRIMARY KEY changed in a WITHOUT ROWID table */
 114   u8 chngRowid;          /* Rowid changed in a normal table */
 115   u8 chngKey;            /* Either chngPk or chngRowid */
 116   Expr *pRowidExpr = 0;  /* Expression defining the new record number */
 117   AuthContext sContext;  /* The authorization context */
 118   NameContext sNC;       /* The name-context to resolve expressions in */
 119   int iDb;               /* Database containing the table being updated */
 120   int okOnePass;         /* True for one-pass algorithm without the FIFO */
 121   int hasFK;             /* True if foreign key processing is required */
 122   int labelBreak;        /* Jump here to break out of UPDATE loop */
 123   int labelContinue;     /* Jump here to continue next step of UPDATE loop */
 124
 125 #ifndef SQLITE_OMIT_TRIGGER
 126   int isView;            /* True when updating a view (INSTEAD OF trigger) */
 127   Trigger *pTrigger;     /* List of triggers on pTab, if required */
 128   int tmask;             /* Mask of TRIGGER_BEFORE|TRIGGER_AFTER */
 129 #endif
 130   int newmask;           /* Mask of NEW.* columns accessed by BEFORE triggers */
 131   int iEph = 0;          /* Ephemeral table holding all primary key values */
 132   int nKey = 0;          /* Number of elements in regKey for WITHOUT ROWID */
 133   int aiCurOnePass[2];   /* The write cursors opened by WHERE_ONEPASS */
 134
 135   /* Register Allocations */
 136   int regRowCount = 0;   /* A count of rows changed */
 137   int regOldRowid = 0;   /* The old rowid */
 138   int regNewRowid = 0;   /* The new rowid */
 139   int regNew = 0;        /* Content of the NEW.* table in triggers */
 140   int regOld = 0;        /* Content of OLD.* table in triggers */
 141   int regRowSet = 0;     /* Rowset of rows to be updated */
 142   int regKey = 0;        /* composite PRIMARY KEY value */
 143
 144   memset(&sContext, 0, sizeof(sContext));
 145   db = pParse->db;
 146   if( pParse->nErr || db->mallocFailed ){
 147     goto update_cleanup;
 148   }
 149   assert( pTabList->nSrc==1 );
 150
 151   /* Locate the table which we want to update.
 152   */
 153   pTab = sqlite3SrcListLookup(pParse, pTabList);
 154   if( pTab==0 ) goto update_cleanup;
 155   iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
 156
 157   /* Figure out if we have any triggers and if the table being
 158   ** updated is a view.
 159   */
 160 #ifndef SQLITE_OMIT_TRIGGER
 161   pTrigger = sqlite3TriggersExist(pParse, pTab, TK_UPDATE, pChanges, &tmask);
 162   isView = pTab->pSelect!=0;
 163   assert( pTrigger || tmask==0 );
 164 #else
 165 # define pTrigger 0
 166 # define isView 0
 167 # define tmask 0
 168 #endif
 169 #ifdef SQLITE_OMIT_VIEW
 170 # undef isView
 171 # define isView 0
 172 #endif
 173
 174   if( sqlite3ViewGetColumnNames(pParse, pTab) ){
 175     goto update_cleanup;
 176   }
 177   if( sqlite3IsReadOnly(pParse, pTab, tmask) ){
 178     goto update_cleanup;
 179   }
 180
 181   /* Allocate a cursors for the main database table and for all indices.
 182   ** The index cursors might not be used, but if they are used they
 183   ** need to occur right after the database cursor.  So go ahead and
 184   ** allocate enough space, just in case.
 185   */
 186   pTabList->a[0].iCursor = iBaseCur = iDataCur = pParse->nTab++;
 187   iIdxCur = iDataCur+1;
 188   pPk = HasRowid(pTab) ? 0 : sqlite3PrimaryKeyIndex(pTab);
 189   for(nIdx=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, nIdx++){
 190     if( IsPrimaryKeyIndex(pIdx) && pPk!=0 ){
 191       iDataCur = pParse->nTab;
 192       pTabList->a[0].iCursor = iDataCur;
 193     }
 194     pParse->nTab++;
 195   }
 196
 197   /* Allocate space for aXRef[], aRegIdx[], and aToOpen[].
 198   ** Initialize aXRef[] and aToOpen[] to their default values.
 199   */
 200   aXRef = sqlite3DbMallocRawNN(db, sizeof(int) * (pTab->nCol+nIdx) + nIdx+2 );
 201   if( aXRef==0 ) goto update_cleanup;
 202   aRegIdx = aXRef+pTab->nCol;
 203   aToOpen = (u8*)(aRegIdx+nIdx);
 204   memset(aToOpen, 1, nIdx+1);
 205   aToOpen[nIdx+1] = 0;
 206   for(i=0; i<pTab->nCol; i++) aXRef[i] = -1;
 207
 208   /* Initialize the name-context */
 209   memset(&sNC, 0, sizeof(sNC));
 210   sNC.pParse = pParse;
 211   sNC.pSrcList = pTabList;
 212
 213   /* Resolve the column names in all the expressions of the
 214   ** of the UPDATE statement.  Also find the column index
 215   ** for each column to be updated in the pChanges array.  For each
 216   ** column to be updated, make sure we have authorization to change
 217   ** that column.
 218   */
 219   chngRowid = chngPk = 0;
 220   for(i=0; i<pChanges->nExpr; i++){
 221     if( sqlite3ResolveExprNames(&sNC, pChanges->a[i].pExpr) ){
 222       goto update_cleanup;
 223     }
 224     for(j=0; j<pTab->nCol; j++){
 225       if( sqlite3StrICmp(pTab->aCol[j].zName, pChanges->a[i].zName)==0 ){
 226         if( j==pTab->iPKey ){
 227           chngRowid = 1;
 228           pRowidExpr = pChanges->a[i].pExpr;
 229         }else if( pPk && (pTab->aCol[j].colFlags & COLFLAG_PRIMKEY)!=0 ){
 230           chngPk = 1;
 231         }
 232         aXRef[j] = i;
 233         break;
 234       }
 235     }
 236     if( j>=pTab->nCol ){
 237       if( pPk==0 && sqlite3IsRowid(pChanges->a[i].zName) ){
 238         j = -1;
 239         chngRowid = 1;
 240         pRowidExpr = pChanges->a[i].pExpr;
 241       }else{
 242         sqlite3ErrorMsg(pParse, "no such column: %s", pChanges->a[i].zName);
 243         pParse->checkSchema = 1;
 244         goto update_cleanup;
 245       }
 246     }
 247 #ifndef SQLITE_OMIT_AUTHORIZATION
 248     {
 249       int rc;
 250       rc = sqlite3AuthCheck(pParse, SQLITE_UPDATE, pTab->zName,
 251                             j<0 ? "ROWID" : pTab->aCol[j].zName,
 252                             db->aDb[iDb].zDbSName);
 253       if( rc==SQLITE_DENY ){
 254         goto update_cleanup;
 255       }else if( rc==SQLITE_IGNORE ){
 256         aXRef[j] = -1;
 257       }
 258     }
 259 #endif
 260   }
 261   assert( (chngRowid & chngPk)==0 );
 262   assert( chngRowid==0 || chngRowid==1 );
 263   assert( chngPk==0 || chngPk==1 );
 264   chngKey = chngRowid + chngPk;
 265
 266   /* The SET expressions are not actually used inside the WHERE loop.
 267   ** So reset the colUsed mask. Unless this is a virtual table. In that
 268   ** case, set all bits of the colUsed mask (to ensure that the virtual
 269   ** table implementation makes all columns available).
 270   */
 271   pTabList->a[0].colUsed = IsVirtual(pTab) ? ALLBITS : 0;
 272
 273   hasFK = sqlite3FkRequired(pParse, pTab, aXRef, chngKey);
 274
 275   /* There is one entry in the aRegIdx[] array for each index on the table
 276   ** being updated.  Fill in aRegIdx[] with a register number that will hold
 277   ** the key for accessing each index.
 278   **
 279   ** FIXME:  Be smarter about omitting indexes that use expressions.
 280   */
 281   for(j=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, j++){
 282     int reg;
 283     if( chngKey || hasFK || pIdx->pPartIdxWhere || pIdx==pPk ){
 284       reg = ++pParse->nMem;
 285     }else{
 286       reg = 0;
 287       for(i=0; i<pIdx->nKeyCol; i++){
 288         i16 iIdxCol = pIdx->aiColumn[i];
 289         if( iIdxCol<0 || aXRef[iIdxCol]>=0 ){
 290           reg = ++pParse->nMem;
 291           break;
 292         }
 293       }
 294     }
 295     if( reg==0 ) aToOpen[j+1] = 0;
 296     aRegIdx[j] = reg;
 297   }
 298
 299   /* Begin generating code. */
 300   v = sqlite3GetVdbe(pParse);
 301   if( v==0 ) goto update_cleanup;
 302   if( pParse->nested==0 ) sqlite3VdbeCountChanges(v);
 303   sqlite3BeginWriteOperation(pParse, 1, iDb);
 304
 305   /* Allocate required registers. */
 306   if( !IsVirtual(pTab) ){
 307     regRowSet = ++pParse->nMem;
 308     regOldRowid = regNewRowid = ++pParse->nMem;
 309     if( chngPk || pTrigger || hasFK ){
 310       regOld = pParse->nMem + 1;
 311       pParse->nMem += pTab->nCol;
 312     }
 313     if( chngKey || pTrigger || hasFK ){
 314       regNewRowid = ++pParse->nMem;
 315     }
 316     regNew = pParse->nMem + 1;
 317     pParse->nMem += pTab->nCol;
 318   }
 319
 320   /* Start the view context. */
 321   if( isView ){
 322     sqlite3AuthContextPush(pParse, &sContext, pTab->zName);
 323   }
 324
 325   /* If we are trying to update a view, realize that view into
 326   ** an ephemeral table.
 327   */
 328 #if !defined(SQLITE_OMIT_VIEW) && !defined(SQLITE_OMIT_TRIGGER)
 329   if( isView ){
 330     sqlite3MaterializeView(pParse, pTab, pWhere, iDataCur);
 331   }
 332 #endif
 333
 334   /* Resolve the column names in all the expressions in the
 335   ** WHERE clause.
 336   */
 337   if( sqlite3ResolveExprNames(&sNC, pWhere) ){
 338     goto update_cleanup;
 339   }
 340
 341 #ifndef SQLITE_OMIT_VIRTUALTABLE
 342   /* Virtual tables must be handled separately */
 343   if( IsVirtual(pTab) ){
 344     updateVirtualTable(pParse, pTabList, pTab, pChanges, pRowidExpr, aXRef,
 345                        pWhere, onError);
 346     goto update_cleanup;
 347   }
 348 #endif
 349
 350   /* Begin the database scan
 351   */
 352   if( HasRowid(pTab) ){
 353     sqlite3VdbeAddOp3(v, OP_Null, 0, regRowSet, regOldRowid);
 354     pWInfo = sqlite3WhereBegin(
 355         pParse, pTabList, pWhere, 0, 0,
 356             WHERE_ONEPASS_DESIRED | WHERE_SEEK_TABLE, iIdxCur
 357     );
 358     if( pWInfo==0 ) goto update_cleanup;
 359     okOnePass = sqlite3WhereOkOnePass(pWInfo, aiCurOnePass);
 360
 361     /* Remember the rowid of every item to be updated.
 362     */
 363     sqlite3VdbeAddOp2(v, OP_Rowid, iDataCur, regOldRowid);
 364     if( !okOnePass ){
 365       sqlite3VdbeAddOp2(v, OP_RowSetAdd, regRowSet, regOldRowid);
 366     }
 367
 368     /* End the database scan loop.
 369     */
 370     sqlite3WhereEnd(pWInfo);
 371   }else{
 372     int iPk;         /* First of nPk memory cells holding PRIMARY KEY value */
 373     i16 nPk;         /* Number of components of the PRIMARY KEY */
 374     int addrOpen;    /* Address of the OpenEphemeral instruction */
 375
 376     assert( pPk!=0 );
 377     nPk = pPk->nKeyCol;
 378     iPk = pParse->nMem+1;
 379     pParse->nMem += nPk;
 380     regKey = ++pParse->nMem;
 381     iEph = pParse->nTab++;
 382     sqlite3VdbeAddOp2(v, OP_Null, 0, iPk);
 383     addrOpen = sqlite3VdbeAddOp2(v, OP_OpenEphemeral, iEph, nPk);
 384     sqlite3VdbeSetP4KeyInfo(pParse, pPk);
 385     pWInfo = sqlite3WhereBegin(pParse, pTabList, pWhere, 0, 0,
 386                                WHERE_ONEPASS_DESIRED, iIdxCur);
 387     if( pWInfo==0 ) goto update_cleanup;
 388     okOnePass = sqlite3WhereOkOnePass(pWInfo, aiCurOnePass);
 389     for(i=0; i<nPk; i++){
 390       assert( pPk->aiColumn[i]>=0 );
 391       sqlite3ExprCodeGetColumnOfTable(v, pTab, iDataCur, pPk->aiColumn[i],
 392                                       iPk+i);
 393     }
 394     if( okOnePass ){
 395       sqlite3VdbeChangeToNoop(v, addrOpen);
 396       nKey = nPk;
 397       regKey = iPk;
 398     }else{
 399       sqlite3VdbeAddOp4(v, OP_MakeRecord, iPk, nPk, regKey,
 400                         sqlite3IndexAffinityStr(db, pPk), nPk);
 401       sqlite3VdbeAddOp2(v, OP_IdxInsert, iEph, regKey);
 402     }
 403     sqlite3WhereEnd(pWInfo);
 404   }
 405
 406   /* Initialize the count of updated rows
 407   */
 408   if( (db->flags & SQLITE_CountRows) && !pParse->pTriggerTab ){
 409     regRowCount = ++pParse->nMem;
 410     sqlite3VdbeAddOp2(v, OP_Integer, 0, regRowCount);
 411   }
 412
 413   labelBreak = sqlite3VdbeMakeLabel(v);
 414   if( !isView ){
 415     /*
 416     ** Open every index that needs updating.  Note that if any
 417     ** index could potentially invoke a REPLACE conflict resolution
 418     ** action, then we need to open all indices because we might need
 419     ** to be deleting some records.
 420     */
 421     if( onError==OE_Replace ){
 422       memset(aToOpen, 1, nIdx+1);
 423     }else{
 424       for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
 425         if( pIdx->onError==OE_Replace ){
 426           memset(aToOpen, 1, nIdx+1);
 427           break;
 428         }
 429       }
 430     }
 431     if( okOnePass ){
 432       if( aiCurOnePass[0]>=0 ) aToOpen[aiCurOnePass[0]-iBaseCur] = 0;
 433       if( aiCurOnePass[1]>=0 ) aToOpen[aiCurOnePass[1]-iBaseCur] = 0;
 434     }
 435     sqlite3OpenTableAndIndices(pParse, pTab, OP_OpenWrite, 0, iBaseCur, aToOpen,
 436                                0, 0);
 437   }
 438
 439   /* Top of the update loop */
 440   if( okOnePass ){
 441     if( aToOpen[iDataCur-iBaseCur] && !isView ){
 442       assert( pPk );
 443       sqlite3VdbeAddOp4Int(v, OP_NotFound, iDataCur, labelBreak, regKey, nKey);
 444       VdbeCoverageNeverTaken(v);
 445     }
 446     labelContinue = labelBreak;
 447     sqlite3VdbeAddOp2(v, OP_IsNull, pPk ? regKey : regOldRowid, labelBreak);
 448     VdbeCoverageIf(v, pPk==0);
 449     VdbeCoverageIf(v, pPk!=0);
 450   }else if( pPk ){
 451     labelContinue = sqlite3VdbeMakeLabel(v);
 452     sqlite3VdbeAddOp2(v, OP_Rewind, iEph, labelBreak); VdbeCoverage(v);
 453     addrTop = sqlite3VdbeAddOp2(v, OP_RowKey, iEph, regKey);
 454     sqlite3VdbeAddOp4Int(v, OP_NotFound, iDataCur, labelContinue, regKey, 0);
 455     VdbeCoverage(v);
 456   }else{
 457     labelContinue = sqlite3VdbeAddOp3(v, OP_RowSetRead, regRowSet, labelBreak,
 458                              regOldRowid);
 459     VdbeCoverage(v);
 460     sqlite3VdbeAddOp3(v, OP_NotExists, iDataCur, labelContinue, regOldRowid);
 461     VdbeCoverage(v);
 462   }
 463
 464   /* If the record number will change, set register regNewRowid to
 465   ** contain the new value. If the record number is not being modified,
 466   ** then regNewRowid is the same register as regOldRowid, which is
 467   ** already populated.  */
 468   assert( chngKey || pTrigger || hasFK || regOldRowid==regNewRowid );
 469   if( chngRowid ){
 470     sqlite3ExprCode(pParse, pRowidExpr, regNewRowid);
 471     sqlite3VdbeAddOp1(v, OP_MustBeInt, regNewRowid); VdbeCoverage(v);
 472   }
 473
 474   /* Compute the old pre-UPDATE content of the row being changed, if that
 475   ** information is needed */
 476   if( chngPk || hasFK || pTrigger ){
 477     u32 oldmask = (hasFK ? sqlite3FkOldmask(pParse, pTab) : 0);
 478     oldmask |= sqlite3TriggerColmask(pParse,
 479         pTrigger, pChanges, 0, TRIGGER_BEFORE|TRIGGER_AFTER, pTab, onError
 480     );
 481     for(i=0; i<pTab->nCol; i++){
 482       if( oldmask==0xffffffff
 483        || (i<32 && (oldmask & MASKBIT32(i))!=0)
 484        || (pTab->aCol[i].colFlags & COLFLAG_PRIMKEY)!=0
 485       ){
 486         testcase(  oldmask!=0xffffffff && i==31 );
 487         sqlite3ExprCodeGetColumnOfTable(v, pTab, iDataCur, i, regOld+i);
 488       }else{
 489         sqlite3VdbeAddOp2(v, OP_Null, 0, regOld+i);
 490       }
 491     }
 492     if( chngRowid==0 && pPk==0 ){
 493       sqlite3VdbeAddOp2(v, OP_Copy, regOldRowid, regNewRowid);
 494     }
 495   }
 496
 497   /* Populate the array of registers beginning at regNew with the new
 498   ** row data. This array is used to check constants, create the new
 499   ** table and index records, and as the values for any new.* references
 500   ** made by triggers.
 501   **
 502   ** If there are one or more BEFORE triggers, then do not populate the
 503   ** registers associated with columns that are (a) not modified by
 504   ** this UPDATE statement and (b) not accessed by new.* references. The
 505   ** values for registers not modified by the UPDATE must be reloaded from
 506   ** the database after the BEFORE triggers are fired anyway (as the trigger
 507   ** may have modified them). So not loading those that are not going to
 508   ** be used eliminates some redundant opcodes.
 509   */
 510   newmask = sqlite3TriggerColmask(
 511       pParse, pTrigger, pChanges, 1, TRIGGER_BEFORE, pTab, onError
 512   );
 513   for(i=0; i<pTab->nCol; i++){
 514     if( i==pTab->iPKey ){
 515       sqlite3VdbeAddOp2(v, OP_Null, 0, regNew+i);
 516     }else{
 517       j = aXRef[i];
 518       if( j>=0 ){
 519         sqlite3ExprCode(pParse, pChanges->a[j].pExpr, regNew+i);
 520       }else if( 0==(tmask&TRIGGER_BEFORE) || i>31 || (newmask & MASKBIT32(i)) ){
 521         /* This branch loads the value of a column that will not be changed
 522         ** into a register. This is done if there are no BEFORE triggers, or
 523         ** if there are one or more BEFORE triggers that use this value via
 524         ** a new.* reference in a trigger program.
 525         */
 526         testcase( i==31 );
 527         testcase( i==32 );
 528         sqlite3ExprCodeGetColumnToReg(pParse, pTab, i, iDataCur, regNew+i);
 529       }else{
 530         sqlite3VdbeAddOp2(v, OP_Null, 0, regNew+i);
 531       }
 532     }
 533   }
 534
 535   /* Fire any BEFORE UPDATE triggers. This happens before constraints are
 536   ** verified. One could argue that this is wrong.
 537   */
 538   if( tmask&TRIGGER_BEFORE ){
 539     sqlite3TableAffinity(v, pTab, regNew);
 540     sqlite3CodeRowTrigger(pParse, pTrigger, TK_UPDATE, pChanges,
 541         TRIGGER_BEFORE, pTab, regOldRowid, onError, labelContinue);
 542
 543     /* The row-trigger may have deleted the row being updated. In this
 544     ** case, jump to the next row. No updates or AFTER triggers are
 545     ** required. This behavior - what happens when the row being updated
 546     ** is deleted or renamed by a BEFORE trigger - is left undefined in the
 547     ** documentation.
 548     */
 549     if( pPk ){
 550       sqlite3VdbeAddOp4Int(v, OP_NotFound, iDataCur, labelContinue,regKey,nKey);
 551       VdbeCoverage(v);
 552     }else{
 553       sqlite3VdbeAddOp3(v, OP_NotExists, iDataCur, labelContinue, regOldRowid);
 554       VdbeCoverage(v);
 555     }
 556
 557     /* If it did not delete it, the row-trigger may still have modified
 558     ** some of the columns of the row being updated. Load the values for
 559     ** all columns not modified by the update statement into their
 560     ** registers in case this has happened.
 561     */
 562     for(i=0; i<pTab->nCol; i++){
 563       if( aXRef[i]<0 && i!=pTab->iPKey ){
 564         sqlite3ExprCodeGetColumnOfTable(v, pTab, iDataCur, i, regNew+i);
 565       }
 566     }
 567   }
 568
 569   if( !isView ){
 570     int addr1 = 0;        /* Address of jump instruction */
 571     int bReplace = 0;     /* True if REPLACE conflict resolution might happen */
 572
 573     /* Do constraint checks. */
 574     assert( regOldRowid>0 );
 575     sqlite3GenerateConstraintChecks(pParse, pTab, aRegIdx, iDataCur, iIdxCur,
 576         regNewRowid, regOldRowid, chngKey, onError, labelContinue, &bReplace,
 577         aXRef);
 578
 579     /* Do FK constraint checks. */
 580     if( hasFK ){
 581       sqlite3FkCheck(pParse, pTab, regOldRowid, 0, aXRef, chngKey);
 582     }
 583
 584     /* Delete the index entries associated with the current record.  */
 585     if( bReplace || chngKey ){
 586       if( pPk ){
 587         addr1 = sqlite3VdbeAddOp4Int(v, OP_NotFound, iDataCur, 0, regKey, nKey);
 588       }else{
 589         addr1 = sqlite3VdbeAddOp3(v, OP_NotExists, iDataCur, 0, regOldRowid);
 590       }
 591       VdbeCoverageNeverTaken(v);
 592     }
 593     sqlite3GenerateRowIndexDelete(pParse, pTab, iDataCur, iIdxCur, aRegIdx, -1);
 594
 595     /* If changing the rowid value, or if there are foreign key constraints
 596     ** to process, delete the old record. Otherwise, add a noop OP_Delete
 597     ** to invoke the pre-update hook.
 598     **
 599     ** That (regNew==regnewRowid+1) is true is also important for the
 600     ** pre-update hook. If the caller invokes preupdate_new(), the returned
 601     ** value is copied from memory cell (regNewRowid+1+iCol), where iCol
 602     ** is the column index supplied by the user.
 603     */
 604     assert( regNew==regNewRowid+1 );
 605 #ifdef SQLITE_ENABLE_PREUPDATE_HOOK
 606     sqlite3VdbeAddOp3(v, OP_Delete, iDataCur,
 607         OPFLAG_ISUPDATE | ((hasFK || chngKey || pPk!=0) ? 0 : OPFLAG_ISNOOP),
 608         regNewRowid
 609     );
 610     if( !pParse->nested ){
 611       sqlite3VdbeChangeP4(v, -1, (char*)pTab, P4_TABLE);
 612     }
 613 #else
 614     if( hasFK || chngKey || pPk!=0 ){
 615       sqlite3VdbeAddOp2(v, OP_Delete, iDataCur, 0);
 616     }
 617 #endif
 618     if( bReplace || chngKey ){
 619       sqlite3VdbeJumpHere(v, addr1);
 620     }
 621
 622     if( hasFK ){
 623       sqlite3FkCheck(pParse, pTab, 0, regNewRowid, aXRef, chngKey);
 624     }
 625
 626     /* Insert the new index entries and the new record. */
 627     sqlite3CompleteInsertion(pParse, pTab, iDataCur, iIdxCur,
 628                              regNewRowid, aRegIdx, 1, 0, 0);
 629
 630     /* Do any ON CASCADE, SET NULL or SET DEFAULT operations required to
 631     ** handle rows (possibly in other tables) that refer via a foreign key
 632     ** to the row just updated. */
 633     if( hasFK ){
 634       sqlite3FkActions(pParse, pTab, pChanges, regOldRowid, aXRef, chngKey);
 635     }
 636   }
 637
 638   /* Increment the row counter
 639   */
 640   if( (db->flags & SQLITE_CountRows) && !pParse->pTriggerTab){
 641     sqlite3VdbeAddOp2(v, OP_AddImm, regRowCount, 1);
 642   }
 643
 644   sqlite3CodeRowTrigger(pParse, pTrigger, TK_UPDATE, pChanges,
 645       TRIGGER_AFTER, pTab, regOldRowid, onError, labelContinue);
 646
 647   /* Repeat the above with the next record to be updated, until
 648   ** all record selected by the WHERE clause have been updated.
 649   */
 650   if( okOnePass ){
 651     /* Nothing to do at end-of-loop for a single-pass */
 652   }else if( pPk ){
 653     sqlite3VdbeResolveLabel(v, labelContinue);
 654     sqlite3VdbeAddOp2(v, OP_Next, iEph, addrTop); VdbeCoverage(v);
 655   }else{
 656     sqlite3VdbeGoto(v, labelContinue);
 657   }
 658   sqlite3VdbeResolveLabel(v, labelBreak);
 659
 660   /* Close all tables */
 661   for(i=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, i++){
 662     assert( aRegIdx );
 663     if( aToOpen[i+1] ){
 664       sqlite3VdbeAddOp2(v, OP_Close, iIdxCur+i, 0);
 665     }
 666   }
 667   if( iDataCur<iIdxCur ) sqlite3VdbeAddOp2(v, OP_Close, iDataCur, 0);
 668
 669   /* Update the sqlite_sequence table by storing the content of the
 670   ** maximum rowid counter values recorded while inserting into
 671   ** autoincrement tables.
 672   */
 673   if( pParse->nested==0 && pParse->pTriggerTab==0 ){
 674     sqlite3AutoincrementEnd(pParse);
 675   }
 676
 677   /*
 678   ** Return the number of rows that were changed. If this routine is
 679   ** generating code because of a call to sqlite3NestedParse(), do not
 680   ** invoke the callback function.
 681   */
 682   if( (db->flags&SQLITE_CountRows) && !pParse->pTriggerTab && !pParse->nested ){
 683     sqlite3VdbeAddOp2(v, OP_ResultRow, regRowCount, 1);
 684     sqlite3VdbeSetNumCols(v, 1);
 685     sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "rows updated", SQLITE_STATIC);
 686   }
 687
 688 update_cleanup:
 689   sqlite3AuthContextPop(&sContext);
 690   sqlite3DbFree(db, aXRef); /* Also frees aRegIdx[] and aToOpen[] */
 691   sqlite3SrcListDelete(db, pTabList);
 692   sqlite3ExprListDelete(db, pChanges);
 693   sqlite3ExprDelete(db, pWhere);
 694   return;
 695 }
 696 /* Make sure "isView" and other macros defined above are undefined. Otherwise
 697 ** they may interfere with compilation of other functions in this file
 698 ** (or in another file, if this file becomes part of the amalgamation).  */
 699 #ifdef isView
 700  #undef isView
 701 #endif
 702 #ifdef pTrigger
 703  #undef pTrigger
 704 #endif
 705
 706 #ifndef SQLITE_OMIT_VIRTUALTABLE
 707 /*
 708 ** Generate code for an UPDATE of a virtual table.
 709 **
 710 ** There are two possible strategies - the default and the special
 711 ** "onepass" strategy. Onepass is only used if the virtual table
 712 ** implementation indicates that pWhere may match at most one row.
 713 **
 714 ** The default strategy is to create an ephemeral table that contains
 715 ** for each row to be changed:
 716 **
 717 **   (A)  The original rowid of that row.
 718 **   (B)  The revised rowid for the row.
 719 **   (C)  The content of every column in the row.
 720 **
 721 ** Then loop through the contents of this ephemeral table executing a
 722 ** VUpdate for each row. When finished, drop the ephemeral table.
 723 **
 724 ** The "onepass" strategy does not use an ephemeral table. Instead, it
 725 ** stores the same values (A, B and C above) in a register array and
 726 ** makes a single invocation of VUpdate.
 727 */
 728 static void updateVirtualTable(
 729   Parse *pParse,       /* The parsing context */
 730   SrcList *pSrc,       /* The virtual table to be modified */
 731   Table *pTab,         /* The virtual table */
 732   ExprList *pChanges,  /* The columns to change in the UPDATE statement */
 733   Expr *pRowid,        /* Expression used to recompute the rowid */
 734   int *aXRef,          /* Mapping from columns of pTab to entries in pChanges */
 735   Expr *pWhere,        /* WHERE clause of the UPDATE statement */
 736   int onError          /* ON CONFLICT strategy */
 737 ){
 738   Vdbe *v = pParse->pVdbe;  /* Virtual machine under construction */
 739   int ephemTab;             /* Table holding the result of the SELECT */
 740   int i;                    /* Loop counter */
 741   sqlite3 *db = pParse->db; /* Database connection */
 742   const char *pVTab = (const char*)sqlite3GetVTable(db, pTab);
 743   WhereInfo *pWInfo;
 744   int nArg = 2 + pTab->nCol;      /* Number of arguments to VUpdate */
 745   int regArg;                     /* First register in VUpdate arg array */
 746   int regRec;                     /* Register in which to assemble record */
 747   int regRowid;                   /* Register for ephem table rowid */
 748   int iCsr = pSrc->a[0].iCursor;  /* Cursor used for virtual table scan */
 749   int aDummy[2];                  /* Unused arg for sqlite3WhereOkOnePass() */
 750   int bOnePass;                   /* True to use onepass strategy */
 751   int addr;                       /* Address of OP_OpenEphemeral */
 752
 753   /* Allocate nArg registers to martial the arguments to VUpdate. Then
 754   ** create and open the ephemeral table in which the records created from
 755   ** these arguments will be temporarily stored. */
 756   assert( v );
 757   ephemTab = pParse->nTab++;
 758   addr= sqlite3VdbeAddOp2(v, OP_OpenEphemeral, ephemTab, nArg);
 759   regArg = pParse->nMem + 1;
 760   pParse->nMem += nArg;
 761   regRec = ++pParse->nMem;
 762   regRowid = ++pParse->nMem;
 763
 764   /* Start scanning the virtual table */
 765   pWInfo = sqlite3WhereBegin(pParse, pSrc, pWhere, 0,0,WHERE_ONEPASS_DESIRED,0);
 766   if( pWInfo==0 ) return;
 767
 768   /* Populate the argument registers. */
 769   sqlite3VdbeAddOp2(v, OP_Rowid, iCsr, regArg);
 770   if( pRowid ){
 771     sqlite3ExprCode(pParse, pRowid, regArg+1);
 772   }else{
 773     sqlite3VdbeAddOp2(v, OP_Rowid, iCsr, regArg+1);
 774   }
 775   for(i=0; i<pTab->nCol; i++){
 776     if( aXRef[i]>=0 ){
 777       sqlite3ExprCode(pParse, pChanges->a[aXRef[i]].pExpr, regArg+2+i);
 778     }else{
 779       sqlite3VdbeAddOp3(v, OP_VColumn, iCsr, i, regArg+2+i);
 780     }
 781   }
 782
 783   bOnePass = sqlite3WhereOkOnePass(pWInfo, aDummy);
 784
 785   if( bOnePass ){
 786     /* If using the onepass strategy, no-op out the OP_OpenEphemeral coded
 787     ** above. Also, if this is a top-level parse (not a trigger), clear the
 788     ** multi-write flag so that the VM does not open a statement journal */
 789     sqlite3VdbeChangeToNoop(v, addr);
 790     if( sqlite3IsToplevel(pParse) ){
 791       pParse->isMultiWrite = 0;
 792     }
 793   }else{
 794     /* Create a record from the argument register contents and insert it into
 795     ** the ephemeral table. */
 796     sqlite3VdbeAddOp3(v, OP_MakeRecord, regArg, nArg, regRec);
 797     sqlite3VdbeAddOp2(v, OP_NewRowid, ephemTab, regRowid);
 798     sqlite3VdbeAddOp3(v, OP_Insert, ephemTab, regRec, regRowid);
 799   }
 800
 801
 802   if( bOnePass==0 ){
 803     /* End the virtual table scan */
 804     sqlite3WhereEnd(pWInfo);
 805
 806     /* Begin scannning through the ephemeral table. */
 807     addr = sqlite3VdbeAddOp1(v, OP_Rewind, ephemTab); VdbeCoverage(v);
 808
 809     /* Extract arguments from the current row of the ephemeral table and
 810     ** invoke the VUpdate method.  */
 811     for(i=0; i<nArg; i++){
 812       sqlite3VdbeAddOp3(v, OP_Column, ephemTab, i, regArg+i);
 813     }
 814   }
 815   sqlite3VtabMakeWritable(pParse, pTab);
 816   sqlite3VdbeAddOp4(v, OP_VUpdate, 0, nArg, regArg, pVTab, P4_VTAB);
 817   sqlite3VdbeChangeP5(v, onError==OE_Default ? OE_Abort : onError);
 818   sqlite3MayAbort(pParse);
 819
 820   /* End of the ephemeral table scan. Or, if using the onepass strategy,
 821   ** jump to here if the scan visited zero rows. */
 822   if( bOnePass==0 ){
 823     sqlite3VdbeAddOp2(v, OP_Next, ephemTab, addr+1); VdbeCoverage(v);
 824     sqlite3VdbeJumpHere(v, addr);
 825     sqlite3VdbeAddOp2(v, OP_Close, ephemTab, 0);
 826   }else{
 827     sqlite3WhereEnd(pWInfo);
 828   }
 829 }
 830 #endif /* SQLITE_OMIT_VIRTUALTABLE */