if( db->flags & SQLITE_CountRows && !pParse->trigStack ){    sqlite3VdbeAddOp(v, OP_Integer, 0, 0);  }  if( triggers_exist ){    /* Create pseudo-tables for NEW and OLD    */    sqlite3VdbeAddOp(v, OP_OpenPseudo, oldIdx, 0);    sqlite3VdbeAddOp(v, OP_SetNumColumns, oldIdx, pTab->nCol);    sqlite3VdbeAddOp(v, OP_OpenPseudo, newIdx, 0);    sqlite3VdbeAddOp(v, OP_SetNumColumns, newIdx, pTab->nCol);    /* The top of the update loop for when there are triggers.    */    addr = sqlite3VdbeAddOp(v, OP_FifoRead, 0, 0);    if( !isView ){      sqlite3VdbeAddOp(v, OP_Dup, 0, 0);      sqlite3VdbeAddOp(v, OP_Dup, 0, 0);      /* Open a cursor and make it point to the record that is      ** being updated.      */      sqlite3OpenTable(pParse, iCur, iDb, pTab, OP_OpenRead);    }    sqlite3VdbeAddOp(v, OP_MoveGe, iCur, 0);    /* Generate the OLD table    */    sqlite3VdbeAddOp(v, OP_Rowid, iCur, 0);    sqlite3VdbeAddOp(v, OP_RowData, iCur, 0);    sqlite3VdbeAddOp(v, OP_Insert, oldIdx, 0);    /* Generate the NEW table    */    if( chngRowid ){      sqlite3ExprCodeAndCache(pParse, pRowidExpr);    }else{      sqlite3VdbeAddOp(v, OP_Rowid, iCur, 0);    }    for(i=0; i<pTab->nCol; i++){      if( i==pTab->iPKey ){        sqlite3VdbeAddOp(v, OP_Null, 0, 0);        continue;      }      j = aXRef[i];      if( j<0 ){        sqlite3VdbeAddOp(v, OP_Column, iCur, i);        sqlite3ColumnDefault(v, pTab, i);      }else{        sqlite3ExprCodeAndCache(pParse, pChanges->a[j].pExpr);      }    }    sqlite3VdbeAddOp(v, OP_MakeRecord, pTab->nCol, 0);    if( !isView ){      sqlite3TableAffinityStr(v, pTab);    }    if( pParse->nErr ) goto update_cleanup;    sqlite3VdbeAddOp(v, OP_Insert, newIdx, 0);    if( !isView ){      sqlite3VdbeAddOp(v, OP_Close, iCur, 0);    }    /* Fire the BEFORE and INSTEAD OF triggers    */    if( sqlite3CodeRowTrigger(pParse, TK_UPDATE, pChanges, TRIGGER_BEFORE, pTab,          newIdx, oldIdx, onError, addr) ){      goto update_cleanup;    }  }  if( !isView && !IsVirtual(pTab) ){    /*     ** Open every index that needs updating.  Note that if any    ** index could potentially invoke a REPLACE conflict resolution     ** action, then we need to open all indices because we might need    ** to be deleting some records.    */    sqlite3OpenTable(pParse, iCur, iDb, pTab, OP_OpenWrite);     if( onError==OE_Replace ){      openAll = 1;    }else{      openAll = 0;      for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){        if( pIdx->onError==OE_Replace ){          openAll = 1;          break;        }      }    }    for(i=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, i++){      if( openAll || aIdxUsed[i] ){        KeyInfo *pKey = sqlite3IndexKeyinfo(pParse, pIdx);        sqlite3VdbeAddOp(v, OP_Integer, iDb, 0);        sqlite3VdbeOp3(v, OP_OpenWrite, iCur+i+1, pIdx->tnum,                       (char*)pKey, P3_KEYINFO_HANDOFF);        assert( pParse->nTab>iCur+i+1 );      }    }    /* Loop over every record that needs updating.  We have to load    ** the old data for each record to be updated because some columns    ** might not change and we will need to copy the old value.    ** Also, the old data is needed to delete the old index entries.    ** So make the cursor point at the old record.    */    if( !triggers_exist ){      addr = sqlite3VdbeAddOp(v, OP_FifoRead, 0, 0);      sqlite3VdbeAddOp(v, OP_Dup, 0, 0);    }    sqlite3VdbeAddOp(v, OP_NotExists, iCur, addr);    /* If the record number will change, push the record number as it    ** will be after the update. (The old record number is currently    ** on top of the stack.)    */    if( chngRowid ){      sqlite3ExprCode(pParse, pRowidExpr);      sqlite3VdbeAddOp(v, OP_MustBeInt, 0, 0);    }    /* Compute new data for this record.      */    for(i=0; i<pTab->nCol; i++){      if( i==pTab->iPKey ){        sqlite3VdbeAddOp(v, OP_Null, 0, 0);        continue;      }      j = aXRef[i];      if( j<0 ){        sqlite3VdbeAddOp(v, OP_Column, iCur, i);        sqlite3ColumnDefault(v, pTab, i);      }else{        sqlite3ExprCode(pParse, pChanges->a[j].pExpr);      }    }    /* Do constraint checks    */    sqlite3GenerateConstraintChecks(pParse, pTab, iCur, aIdxUsed, chngRowid, 1,                                   onError, addr);    /* Delete the old indices for the current record.    */    sqlite3GenerateRowIndexDelete(v, pTab, iCur, aIdxUsed);    /* If changing the record number, delete the old record.    */    if( chngRowid ){      sqlite3VdbeAddOp(v, OP_Delete, iCur, 0);    }    /* Create the new index entries and the new record.    */    sqlite3CompleteInsertion(pParse, pTab, iCur, aIdxUsed, chngRowid, 1, -1);  }  /* Increment the row counter   */  if( db->flags & SQLITE_CountRows && !pParse->trigStack){    sqlite3VdbeAddOp(v, OP_AddImm, 1, 0);  }  /* If there are triggers, close all the cursors after each iteration  ** through the loop.  The fire the after triggers.  */  if( triggers_exist ){    if( !isView ){      for(i=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, i++){        if( openAll || aIdxUsed[i] )          sqlite3VdbeAddOp(v, OP_Close, iCur+i+1, 0);      }      sqlite3VdbeAddOp(v, OP_Close, iCur, 0);    }    if( sqlite3CodeRowTrigger(pParse, TK_UPDATE, pChanges, TRIGGER_AFTER, pTab,           newIdx, oldIdx, onError, addr) ){      goto update_cleanup;    }  }  /* Repeat the above with the next record to be updated, until  ** all record selected by the WHERE clause have been updated.  */  sqlite3VdbeAddOp(v, OP_Goto, 0, addr);  sqlite3VdbeJumpHere(v, addr);  /* Close all tables if there were no FOR EACH ROW triggers */  if( !triggers_exist ){    for(i=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, i++){      if( openAll || aIdxUsed[i] ){        sqlite3VdbeAddOp(v, OP_Close, iCur+i+1, 0);      }    }    sqlite3VdbeAddOp(v, OP_Close, iCur, 0);  }else{    sqlite3VdbeAddOp(v, OP_Close, newIdx, 0);    sqlite3VdbeAddOp(v, OP_Close, oldIdx, 0);  }  /*  ** Return the number of rows that were changed. If this routine is   ** generating code because of a call to sqlite3NestedParse(), do not  ** invoke the callback function.  */  if( db->flags & SQLITE_CountRows && !pParse->trigStack && pParse->nested==0 ){    sqlite3VdbeAddOp(v, OP_Callback, 1, 0);    sqlite3VdbeSetNumCols(v, 1);    sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "rows updated", P3_STATIC);  }update_cleanup:  sqlite3AuthContextPop(&sContext);  sqliteFree(apIdx);  sqliteFree(aXRef);  sqlite3SrcListDelete(pTabList);  sqlite3ExprListDelete(pChanges);  sqlite3ExprDelete(pWhere);  return;}#ifndef SQLITE_OMIT_VIRTUALTABLE/*** Generate code for an UPDATE of a virtual table.**** The strategy is that we create an ephemerial table that contains** for each row to be changed:****   (A)  The original rowid of that row.**   (B)  The revised rowid for the row. (note1)**   (C)  The content of every column in the row.**** Then we loop over this ephemeral table and for each row in** the ephermeral table call VUpdate.**** When finished, drop the ephemeral table.**** (note1) Actually, if we know in advance that (A) is always the same** as (B) we only store (A), then duplicate (A) when pulling** it out of the ephemeral table before calling VUpdate.*/static void updateVirtualTable(  Parse *pParse,       /* The parsing context */  SrcList *pSrc,       /* The virtual table to be modified */  Table *pTab,         /* The virtual table */  ExprList *pChanges,  /* The columns to change in the UPDATE statement */  Expr *pRowid,        /* Expression used to recompute the rowid */  int *aXRef,          /* Mapping from columns of pTab to entries in pChanges */  Expr *pWhere         /* WHERE clause of the UPDATE statement */){  Vdbe *v = pParse->pVdbe;  /* Virtual machine under construction */  ExprList *pEList = 0;     /* The result set of the SELECT statement */  Select *pSelect = 0;      /* The SELECT statement */  Expr *pExpr;              /* Temporary expression */  int ephemTab;             /* Table holding the result of the SELECT */  int i;                    /* Loop counter */  int addr;                 /* Address of top of loop */  /* Construct the SELECT statement that will find the new values for  ** all updated rows.   */  pEList = sqlite3ExprListAppend(0, sqlite3CreateIdExpr("_rowid_"), 0);  if( pRowid ){    pEList = sqlite3ExprListAppend(pEList, sqlite3ExprDup(pRowid), 0);  }  assert( pTab->iPKey<0 );  for(i=0; i<pTab->nCol; i++){    if( aXRef[i]>=0 ){      pExpr = sqlite3ExprDup(pChanges->a[aXRef[i]].pExpr);    }else{      pExpr = sqlite3CreateIdExpr(pTab->aCol[i].zName);    }    pEList = sqlite3ExprListAppend(pEList, pExpr, 0);  }  pSelect = sqlite3SelectNew(pEList, pSrc, pWhere, 0, 0, 0, 0, 0, 0);    /* Create the ephemeral table into which the update results will  ** be stored.  */  assert( v );  ephemTab = pParse->nTab++;  sqlite3VdbeAddOp(v, OP_OpenEphemeral, ephemTab, pTab->nCol+1+(pRowid!=0));  /* fill the ephemeral table   */  sqlite3Select(pParse, pSelect, SRT_Table, ephemTab, 0, 0, 0, 0);  /*  ** Generate code to scan the ephemeral table and call VDelete and  ** VInsert  */  sqlite3VdbeAddOp(v, OP_Rewind, ephemTab, 0);  addr = sqlite3VdbeCurrentAddr(v);  sqlite3VdbeAddOp(v, OP_Column,  ephemTab, 0);  if( pRowid ){    sqlite3VdbeAddOp(v, OP_Column, ephemTab, 1);  }else{    sqlite3VdbeAddOp(v, OP_Dup, 0, 0);  }  for(i=0; i<pTab->nCol; i++){    sqlite3VdbeAddOp(v, OP_Column, ephemTab, i+1+(pRowid!=0));  }  pParse->pVirtualLock = pTab;  sqlite3VdbeOp3(v, OP_VUpdate, 0, pTab->nCol+2,                      (const char*)pTab->pVtab, P3_VTAB);  sqlite3VdbeAddOp(v, OP_Next, ephemTab, addr);  sqlite3VdbeAddOp(v, OP_Close, ephemTab, 0);  /* Cleanup */  sqlite3SelectDelete(pSelect);  }#endif /* SQLITE_OMIT_VIRTUALTABLE */