自学教程：C++ sqlite3VdbeResolveLabel函数代码示例

/*** This routine generates VDBE code that causes the deletion of all** index entries associated with a single row of a single table, pTab**** Preconditions:****   1.  A read/write cursor "iDataCur" must be open on the canonical storage**       btree for the table pTab.  (This will be either the table itself**       for rowid tables or to the primary key index for WITHOUT ROWID**       tables.)****   2.  Read/write cursors for all indices of pTab must be open as**       cursor number iIdxCur+i for the i-th index.  (The pTab->pIndex**       index is the 0-th index.)****   3.  The "iDataCur" cursor must be already be positioned on the row**       that is to be deleted.*/void sqlite3GenerateRowIndexDelete(  Parse *pParse,     /* Parsing and code generating context */  Table *pTab,       /* Table containing the row to be deleted */  int iDataCur,      /* Cursor of table holding data. */  int iIdxCur,       /* First index cursor */  int *aRegIdx       /* Only delete if aRegIdx!=0 && aRegIdx[i]>0 */){  int i;             /* Index loop counter */  int r1;            /* Register holding an index key */  int iPartIdxLabel; /* Jump destination for skipping partial index entries */  Index *pIdx;       /* Current index */  Vdbe *v;           /* The prepared statement under construction */  Index *pPk;        /* PRIMARY KEY index, or NULL for rowid tables */  v = pParse->pVdbe;  pPk = HasRowid(pTab) ? 0 : sqlite3PrimaryKeyIndex(pTab);  for(i=0, pIdx=pTab->pIndex; pIdx; i++, pIdx=pIdx->pNext){    assert( iIdxCur+i!=iDataCur || pPk==pIdx );    if( aRegIdx!=0 && aRegIdx[i]==0 ) continue;    if( pIdx==pPk ) continue;    VdbeModuleComment((v, "GenRowIdxDel for %s", pIdx->zName));    r1 = sqlite3GenerateIndexKey(pParse, pIdx, iDataCur, 0, 1, &iPartIdxLabel);    sqlite3VdbeAddOp3(v, OP_IdxDelete, iIdxCur+i, r1,                      pIdx->uniqNotNull ? pIdx->nKeyCol : pIdx->nColumn);    sqlite3VdbeResolveLabel(v, iPartIdxLabel);  }}

/*** This routine generates VDBE code that causes the deletion of all** index entries associated with a single row of a single table.**** The VDBE must be in a particular state when this routine is called.** These are the requirements:****   1.  A read/write cursor pointing to pTab, the table containing the row**       to be deleted, must be opened as cursor number "iCur".****   2.  Read/write cursors for all indices of pTab must be open as**       cursor number iCur+i for the i-th index.****   3.  The "iCur" cursor must be pointing to the row that is to be**       deleted.*/void sqlite3GenerateRowIndexDelete(  Parse *pParse,     /* Parsing and code generating context */  Table *pTab,       /* Table containing the row to be deleted */  int iCur,          /* Cursor number for the table */  int *aRegIdx       /* Only delete if aRegIdx!=0 && aRegIdx[i]>0 */){  int i;  Index *pIdx;  int r1;  int iPartIdxLabel;  Vdbe *v = pParse->pVdbe;  for(i=1, pIdx=pTab->pIndex; pIdx; i++, pIdx=pIdx->pNext){    if( aRegIdx!=0 && aRegIdx[i-1]==0 ) continue;    r1 = sqlite3GenerateIndexKey(pParse, pIdx, iCur, 0, 0, &iPartIdxLabel);    sqlite3VdbeAddOp3(v, OP_IdxDelete, iCur+i, r1, pIdx->nColumn+1);    sqlite3VdbeResolveLabel(v, iPartIdxLabel);  }}

/*** This function is called to generate code that runs when table pTab is** being dropped from the database. The SrcList passed as the second argument** to this function contains a single entry guaranteed to resolve to** table pTab.**** Normally, no code is required. However, if either****   (a) The table is the parent table of a FK constraint, or**   (b) The table is the child table of a deferred FK constraint and it is**       determined at runtime that there are outstanding deferred FK **       constraint violations in the database,**** then the equivalent of "DELETE FROM <tbl>" is executed before dropping** the table from the database. Triggers are disabled while running this** DELETE, but foreign key actions are not.*/void sqlite3FkDropTable(Parse *pParse, SrcList *pName, Table *pTab){  sqlite3 *db = pParse->db;  if( (db->flags&SQLITE_ForeignKeys) && !IsVirtual(pTab) && !pTab->pSelect ){    int iSkip = 0;    Vdbe *v = sqlite3GetVdbe(pParse);    assert( v );                  /* VDBE has already been allocated */    if( sqlite3FkReferences(pTab)==0 ){      /* Search for a deferred foreign key constraint for which this table      ** is the child table. If one cannot be found, return without       ** generating any VDBE code. If one can be found, then jump over      ** the entire DELETE if there are no outstanding deferred constraints      ** when this statement is run.  */      FKey *p;      for(p=pTab->pFKey; p; p=p->pNextFrom){        if( p->isDeferred ) break;      }      if( !p ) return;      iSkip = sqlite3VdbeMakeLabel(v);      sqlite3VdbeAddOp2(v, OP_FkIfZero, 1, iSkip);    }    pParse->disableTriggers = 1;    sqlite3DeleteFrom(pParse, sqlite3SrcListDup(db, pName, 0), 0);    pParse->disableTriggers = 0;    /* If the DELETE has generated immediate foreign key constraint     ** violations, halt the VDBE and return an error at this point, before    ** any modifications to the schema are made. This is because statement    ** transactions are not able to rollback schema changes.  */    sqlite3VdbeAddOp2(v, OP_FkIfZero, 0, sqlite3VdbeCurrentAddr(v)+2);    sqlite3HaltConstraint(        pParse, OE_Abort, "foreign key constraint failed", P4_STATIC    );    if( iSkip ){      sqlite3VdbeResolveLabel(v, iSkip);    }  }}

//.........这里部分代码省略.........**       to be deleted, must be opened as cursor number $iCur.****   2.  Read/write cursors for all indices of pTab must be open as**       cursor number base+i for the i-th index.****   3.  The record number of the row to be deleted must be stored in**       memory cell iRowid.**** This routine generates code to remove both the table record and all ** index entries that point to that record.*/void sqlite3GenerateRowDelete(  Parse *pParse,     /* Parsing context */  Table *pTab,       /* Table containing the row to be deleted */  int iCur,          /* Cursor number for the table */  int iRowid,        /* Memory cell that contains the rowid to delete */  int count,         /* If non-zero, increment the row change counter */  Trigger *pTrigger, /* List of triggers to (potentially) fire */  int onconf         /* Default ON CONFLICT policy for triggers */){  Vdbe *v = pParse->pVdbe;        /* Vdbe */  int iOld = 0;                   /* First register in OLD.* array */  int iLabel;                     /* Label resolved to end of generated code */  /* Vdbe is guaranteed to have been allocated by this stage. */  assert( v );  /* Seek cursor iCur to the row to delete. If this row no longer exists   ** (this can happen if a trigger program has already deleted it), do  ** not attempt to delete it or fire any DELETE triggers.  */  iLabel = sqlite3VdbeMakeLabel(v);  sqlite3VdbeAddOp3(v, OP_NotExists, iCur, iLabel, iRowid);   /* If there are any triggers to fire, allocate a range of registers to  ** use for the old.* references in the triggers.  */  if( sqlite3FkRequired(pParse, pTab, 0, 0) || pTrigger ){    u32 mask;                     /* Mask of OLD.* columns in use */    int iCol;                     /* Iterator used while populating OLD.* */    /* TODO: Could use temporary registers here. Also could attempt to    ** avoid copying the contents of the rowid register.  */    mask = sqlite3TriggerColmask(        pParse, pTrigger, 0, 0, TRIGGER_BEFORE|TRIGGER_AFTER, pTab, onconf    );    mask |= sqlite3FkOldmask(pParse, pTab);    iOld = pParse->nMem+1;    pParse->nMem += (1 + pTab->nCol);    /* Populate the OLD.* pseudo-table register array. These values will be     ** used by any BEFORE and AFTER triggers that exist.  */    sqlite3VdbeAddOp2(v, OP_Copy, iRowid, iOld);    for(iCol=0; iCol<pTab->nCol; iCol++){      if( mask==0xffffffff || mask&(1<<iCol) ){        sqlite3ExprCodeGetColumnOfTable(v, pTab, iCur, iCol, iOld+iCol+1);      }    }    /* Invoke BEFORE DELETE trigger programs. */    sqlite3CodeRowTrigger(pParse, pTrigger,         TK_DELETE, 0, TRIGGER_BEFORE, pTab, iOld, onconf, iLabel    );    /* Seek the cursor to the row to be deleted again. It may be that    ** the BEFORE triggers coded above have already removed the row    ** being deleted. Do not attempt to delete the row a second time, and     ** do not fire AFTER triggers.  */    sqlite3VdbeAddOp3(v, OP_NotExists, iCur, iLabel, iRowid);    /* Do FK processing. This call checks that any FK constraints that    ** refer to this table (i.e. constraints attached to other tables)     ** are not violated by deleting this row.  */    sqlite3FkCheck(pParse, pTab, iOld, 0);  }  /* Delete the index and table entries. Skip this step if pTab is really  ** a view (in which case the only effect of the DELETE statement is to  ** fire the INSTEAD OF triggers).  */   if( pTab->pSelect==0 ){    sqlite3GenerateRowIndexDelete(pParse, pTab, iCur, 0);    sqlite3VdbeAddOp2(v, OP_Delete, iCur, (count?OPFLAG_NCHANGE:0));    if( count ){      sqlite3VdbeChangeP4(v, -1, pTab->zName, P4_TRANSIENT);    }  }  /* Do any ON CASCADE, SET NULL or SET DEFAULT operations required to  ** handle rows (possibly in other tables) that refer via a foreign key  ** to the row just deleted. */   sqlite3FkActions(pParse, pTab, 0, iOld);  /* Invoke AFTER DELETE trigger programs. */  sqlite3CodeRowTrigger(pParse, pTrigger,       TK_DELETE, 0, TRIGGER_AFTER, pTab, iOld, onconf, iLabel  );  /* Jump here if the row had already been deleted before any BEFORE  ** trigger programs were invoked. Or if a trigger program throws a   ** RAISE(IGNORE) exception.  */  sqlite3VdbeResolveLabel(v, iLabel);}

//.........这里部分代码省略.........   && 0==sqlite3FkRequired(pParse, pTab, 0, 0)  ){    assert( !isView );    sqlite3VdbeAddOp4(v, OP_Clear, pTab->tnum, iDb, memCnt,                      pTab->zName, P4_STATIC);    for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){      assert( pIdx->pSchema==pTab->pSchema );      sqlite3VdbeAddOp2(v, OP_Clear, pIdx->tnum, iDb);    }  }else#endif /* SQLITE_OMIT_TRUNCATE_OPTIMIZATION */  /* The usual case: There is a WHERE clause so we have to scan through  ** the table and pick which records to delete.  */  {    int iRowSet = ++pParse->nMem;   /* Register for rowset of rows to delete */    int iRowid = ++pParse->nMem;    /* Used for storing rowid values. */    int regRowid;                   /* Actual register containing rowids */    /* Collect rowids of every row to be deleted.    */    sqlite3VdbeAddOp2(v, OP_Null, 0, iRowSet);    pWInfo = sqlite3WhereBegin(        pParse, pTabList, pWhere, 0, 0, WHERE_DUPLICATES_OK, 0    );    if( pWInfo==0 ) goto delete_from_cleanup;    regRowid = sqlite3ExprCodeGetColumn(pParse, pTab, -1, iCur, iRowid, 0);    sqlite3VdbeAddOp2(v, OP_RowSetAdd, iRowSet, regRowid);    if( db->flags & SQLITE_CountRows ){      sqlite3VdbeAddOp2(v, OP_AddImm, memCnt, 1);    }    sqlite3WhereEnd(pWInfo);    /* Delete every item whose key was written to the list during the    ** database scan.  We have to delete items after the scan is complete    ** because deleting an item can change the scan order.  */    end = sqlite3VdbeMakeLabel(v);    /* Unless this is a view, open cursors for the table we are     ** deleting from and all its indices. If this is a view, then the    ** only effect this statement has is to fire the INSTEAD OF     ** triggers.  */    if( !isView ){      sqlite3OpenTableAndIndices(pParse, pTab, iCur, OP_OpenWrite);    }    addr = sqlite3VdbeAddOp3(v, OP_RowSetRead, iRowSet, end, iRowid);    /* Delete the row */#ifndef SQLITE_OMIT_VIRTUALTABLE    if( IsVirtual(pTab) ){      const char *pVTab = (const char *)sqlite3GetVTable(db, pTab);      sqlite3VtabMakeWritable(pParse, pTab);      sqlite3VdbeAddOp4(v, OP_VUpdate, 0, 1, iRowid, pVTab, P4_VTAB);      sqlite3VdbeChangeP5(v, OE_Abort);      sqlite3MayAbort(pParse);    }else#endif    {      int count = (pParse->nested==0);    /* True to count changes */      sqlite3GenerateRowDelete(pParse, pTab, iCur, iRowid, count, pTrigger, OE_Default);    }    /* End of the delete loop */    sqlite3VdbeAddOp2(v, OP_Goto, 0, addr);    sqlite3VdbeResolveLabel(v, end);    /* Close the cursors open on the table and its indexes. */    if( !isView && !IsVirtual(pTab) ){      for(i=1, pIdx=pTab->pIndex; pIdx; i++, pIdx=pIdx->pNext){        sqlite3VdbeAddOp2(v, OP_Close, iCur + i, pIdx->tnum);      }      sqlite3VdbeAddOp1(v, OP_Close, iCur);    }  }  /* Update the sqlite_sequence table by storing the content of the  ** maximum rowid counter values recorded while inserting into  ** autoincrement tables.  */  if( pParse->nested==0 && pParse->pTriggerTab==0 ){    sqlite3AutoincrementEnd(pParse);  }  /* Return the number of rows that were deleted. If this routine is   ** generating code because of a call to sqlite3NestedParse(), do not  ** invoke the callback function.  */  if( (db->flags&SQLITE_CountRows) && !pParse->nested && !pParse->pTriggerTab ){    sqlite3VdbeAddOp2(v, OP_ResultRow, memCnt, 1);    sqlite3VdbeSetNumCols(v, 1);    sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "rows deleted", SQLITE_STATIC);  }delete_from_cleanup:  sqlite3AuthContextPop(&sContext);  sqlite3SrcListDelete(db, pTabList);  sqlite3ExprDelete(db, pWhere);  return;}

//.........这里部分代码省略.........    ** pre-update hook. If the caller invokes preupdate_new(), the returned    ** value is copied from memory cell (regNewRowid+1+iCol), where iCol    ** is the column index supplied by the user.    */    assert( regNew==regNewRowid+1 );#ifdef SQLITE_ENABLE_PREUPDATE_HOOK    sqlite3VdbeAddOp3(v, OP_Delete, iDataCur,        OPFLAG_ISUPDATE | ((hasFK>1 || chngKey) ? 0 : OPFLAG_ISNOOP),        regNewRowid    );    if( eOnePass==ONEPASS_MULTI ){      assert( hasFK==0 && chngKey==0 );      sqlite3VdbeChangeP5(v, OPFLAG_SAVEPOSITION);    }    if( !pParse->nested ){      sqlite3VdbeAppendP4(v, pTab, P4_TABLE);    }#else    if( hasFK>1 || chngKey ){      sqlite3VdbeAddOp2(v, OP_Delete, iDataCur, 0);    }#endif    if( bReplace || chngKey ){      sqlite3VdbeJumpHere(v, addr1);    }    if( hasFK ){      sqlite3FkCheck(pParse, pTab, 0, regNewRowid, aXRef, chngKey);    }      /* Insert the new index entries and the new record. */    sqlite3CompleteInsertion(        pParse, pTab, iDataCur, iIdxCur, regNewRowid, aRegIdx,         OPFLAG_ISUPDATE | (eOnePass==ONEPASS_MULTI ? OPFLAG_SAVEPOSITION : 0),         0, 0    );    /* Do any ON CASCADE, SET NULL or SET DEFAULT operations required to    ** handle rows (possibly in other tables) that refer via a foreign key    ** to the row just updated. */     if( hasFK ){      sqlite3FkActions(pParse, pTab, pChanges, regOldRowid, aXRef, chngKey);    }  }  /* Increment the row counter   */  if( regRowCount ){    sqlite3VdbeAddOp2(v, OP_AddImm, regRowCount, 1);  }  sqlite3CodeRowTrigger(pParse, pTrigger, TK_UPDATE, pChanges,       TRIGGER_AFTER, pTab, regOldRowid, onError, labelContinue);  /* Repeat the above with the next record to be updated, until  ** all record selected by the WHERE clause have been updated.  */  if( eOnePass==ONEPASS_SINGLE ){    /* Nothing to do at end-of-loop for a single-pass */  }else if( eOnePass==ONEPASS_MULTI ){    sqlite3VdbeResolveLabel(v, labelContinue);    sqlite3WhereEnd(pWInfo);  }else if( pPk ){    sqlite3VdbeResolveLabel(v, labelContinue);    sqlite3VdbeAddOp2(v, OP_Next, iEph, addrTop); VdbeCoverage(v);  }else{    sqlite3VdbeGoto(v, labelContinue);  }  sqlite3VdbeResolveLabel(v, labelBreak);  /* Update the sqlite_sequence table by storing the content of the  ** maximum rowid counter values recorded while inserting into  ** autoincrement tables.  */  if( pParse->nested==0 && pParse->pTriggerTab==0 && pUpsert==0 ){    sqlite3AutoincrementEnd(pParse);  }  /*  ** Return the number of rows that were changed, if we are tracking  ** that information.  */  if( regRowCount ){    sqlite3VdbeAddOp2(v, OP_ResultRow, regRowCount, 1);    sqlite3VdbeSetNumCols(v, 1);    sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "rows updated", SQLITE_STATIC);  }update_cleanup:  sqlite3AuthContextPop(&sContext);  sqlite3DbFree(db, aXRef); /* Also frees aRegIdx[] and aToOpen[] */  sqlite3SrcListDelete(db, pTabList);  sqlite3ExprListDelete(db, pChanges);  sqlite3ExprDelete(db, pWhere);#if defined(SQLITE_ENABLE_UPDATE_DELETE_LIMIT)   sqlite3ExprListDelete(db, pOrderBy);  sqlite3ExprDelete(db, pLimit);#endif  return;}

//.........这里部分代码省略.........  ** not attempt to delete it or fire any DELETE triggers.  */  iLabel = sqlite3VdbeMakeLabel(v);  opSeek = HasRowid(pTab) ? OP_NotExists : OP_NotFound;  if( eMode==ONEPASS_OFF ){    sqlite3VdbeAddOp4Int(v, opSeek, iDataCur, iLabel, iPk, nPk);    VdbeCoverageIf(v, opSeek==OP_NotExists);    VdbeCoverageIf(v, opSeek==OP_NotFound);  }   /* If there are any triggers to fire, allocate a range of registers to  ** use for the old.* references in the triggers.  */  if( sqlite3FkRequired(pParse, pTab, 0, 0) || pTrigger ){    u32 mask;                     /* Mask of OLD.* columns in use */    int iCol;                     /* Iterator used while populating OLD.* */    int addrStart;                /* Start of BEFORE trigger programs */    /* TODO: Could use temporary registers here. Also could attempt to    ** avoid copying the contents of the rowid register.  */    mask = sqlite3TriggerColmask(        pParse, pTrigger, 0, 0, TRIGGER_BEFORE|TRIGGER_AFTER, pTab, onconf    );    mask |= sqlite3FkOldmask(pParse, pTab);    iOld = pParse->nMem+1;    pParse->nMem += (1 + pTab->nCol);    /* Populate the OLD.* pseudo-table register array. These values will be     ** used by any BEFORE and AFTER triggers that exist.  */    sqlite3VdbeAddOp2(v, OP_Copy, iPk, iOld);    for(iCol=0; iCol<pTab->nCol; iCol++){      testcase( mask!=0xffffffff && iCol==31 );      testcase( mask!=0xffffffff && iCol==32 );      if( mask==0xffffffff || (iCol<=31 && (mask & MASKBIT32(iCol))!=0) ){        sqlite3ExprCodeGetColumnOfTable(v, pTab, iDataCur, iCol, iOld+iCol+1);      }    }    /* Invoke BEFORE DELETE trigger programs. */    addrStart = sqlite3VdbeCurrentAddr(v);    sqlite3CodeRowTrigger(pParse, pTrigger,         TK_DELETE, 0, TRIGGER_BEFORE, pTab, iOld, onconf, iLabel    );    /* If any BEFORE triggers were coded, then seek the cursor to the     ** row to be deleted again. It may be that the BEFORE triggers moved    ** the cursor or of already deleted the row that the cursor was    ** pointing to.    */    if( addrStart<sqlite3VdbeCurrentAddr(v) ){      sqlite3VdbeAddOp4Int(v, opSeek, iDataCur, iLabel, iPk, nPk);      VdbeCoverageIf(v, opSeek==OP_NotExists);      VdbeCoverageIf(v, opSeek==OP_NotFound);    }    /* Do FK processing. This call checks that any FK constraints that    ** refer to this table (i.e. constraints attached to other tables)     ** are not violated by deleting this row.  */    sqlite3FkCheck(pParse, pTab, iOld, 0, 0, 0);  }  /* Delete the index and table entries. Skip this step if pTab is really  ** a view (in which case the only effect of the DELETE statement is to  ** fire the INSTEAD OF triggers).    **  ** If variable 'count' is non-zero, then this OP_Delete instruction should  ** invoke the update-hook. The pre-update-hook, on the other hand should  ** be invoked unless table pTab is a system table. The difference is that  ** the update-hook is not invoked for rows removed by REPLACE, but the   ** pre-update-hook is.  */   if( pTab->pSelect==0 ){    u8 p5 = 0;    sqlite3GenerateRowIndexDelete(pParse, pTab, iDataCur, iIdxCur,0,iIdxNoSeek);    sqlite3VdbeAddOp2(v, OP_Delete, iDataCur, (count?OPFLAG_NCHANGE:0));    sqlite3VdbeChangeP4(v, -1, (char*)pTab, P4_TABLE);    if( eMode!=ONEPASS_OFF ){      sqlite3VdbeChangeP5(v, OPFLAG_AUXDELETE);    }    if( iIdxNoSeek>=0 ){      sqlite3VdbeAddOp1(v, OP_Delete, iIdxNoSeek);    }    if( eMode==ONEPASS_MULTI ) p5 |= OPFLAG_SAVEPOSITION;    sqlite3VdbeChangeP5(v, p5);  }  /* Do any ON CASCADE, SET NULL or SET DEFAULT operations required to  ** handle rows (possibly in other tables) that refer via a foreign key  ** to the row just deleted. */   sqlite3FkActions(pParse, pTab, 0, iOld, 0, 0);  /* Invoke AFTER DELETE trigger programs. */  sqlite3CodeRowTrigger(pParse, pTrigger,       TK_DELETE, 0, TRIGGER_AFTER, pTab, iOld, onconf, iLabel  );  /* Jump here if the row had already been deleted before any BEFORE  ** trigger programs were invoked. Or if a trigger program throws a   ** RAISE(IGNORE) exception.  */  sqlite3VdbeResolveLabel(v, iLabel);  VdbeModuleComment((v, "END: GenRowDel()"));}

/*** This is called to code FOR EACH ROW triggers.**** When the code that this function generates is executed, the following ** must be true:**** 1. No cursors may be open in the main database.  (But newIdx and oldIdx**    can be indices of cursors in temporary tables.  See below.)**** 2. If the triggers being coded are ON INSERT or ON UPDATE triggers, then**    a temporary vdbe cursor (index newIdx) must be open and pointing at**    a row containing values to be substituted for new.* expressions in the**    trigger program(s).**** 3. If the triggers being coded are ON DELETE or ON UPDATE triggers, then**    a temporary vdbe cursor (index oldIdx) must be open and pointing at**    a row containing values to be substituted for old.* expressions in the**    trigger program(s).***/int sqlite3CodeRowTrigger(  Parse *pParse,       /* Parse context */  int op,              /* One of TK_UPDATE, TK_INSERT, TK_DELETE */  ExprList *pChanges,  /* Changes list for any UPDATE OF triggers */  int tr_tm,           /* One of TK_BEFORE, TK_AFTER */  Table *pTab,         /* The table to code triggers from */  int newIdx,          /* The indice of the "new" row to access */  int oldIdx,          /* The indice of the "old" row to access */  int orconf,          /* ON CONFLICT policy */  int ignoreJump       /* Instruction to jump to for RAISE(IGNORE) */){  Trigger * pTrigger;  TriggerStack * pTriggerStack;  assert(op == TK_UPDATE || op == TK_INSERT || op == TK_DELETE);  assert(tr_tm == TK_BEFORE || tr_tm == TK_AFTER );  assert(newIdx != -1 || oldIdx != -1);  pTrigger = pTab->pTrigger;  while( pTrigger ){    int fire_this = 0;    /* determine whether we should code this trigger */    if( pTrigger->op == op && pTrigger->tr_tm == tr_tm &&         pTrigger->foreach == TK_ROW ){      fire_this = 1;      pTriggerStack = pParse->trigStack;      while( pTriggerStack ){        if( pTriggerStack->pTrigger == pTrigger ){	  fire_this = 0;	}        pTriggerStack = pTriggerStack->pNext;      }      if( op == TK_UPDATE && pTrigger->pColumns &&          !checkColumnOverLap(pTrigger->pColumns, pChanges) ){        fire_this = 0;      }    }    if( fire_this && (pTriggerStack = sqliteMalloc(sizeof(TriggerStack)))!=0 ){      int endTrigger;      SrcList dummyTablist;      Expr * whenExpr;      AuthContext sContext;      dummyTablist.nSrc = 0;      /* Push an entry on to the trigger stack */      pTriggerStack->pTrigger = pTrigger;      pTriggerStack->newIdx = newIdx;      pTriggerStack->oldIdx = oldIdx;      pTriggerStack->pTab = pTab;      pTriggerStack->pNext = pParse->trigStack;      pTriggerStack->ignoreJump = ignoreJump;      pParse->trigStack = pTriggerStack;      sqlite3AuthContextPush(pParse, &sContext, pTrigger->name);      /* code the WHEN clause */      endTrigger = sqlite3VdbeMakeLabel(pParse->pVdbe);      whenExpr = sqlite3ExprDup(pTrigger->pWhen);      if( sqlite3ExprResolveIds(pParse, &dummyTablist, 0, whenExpr) ){        pParse->trigStack = pParse->trigStack->pNext;        sqliteFree(pTriggerStack);        sqlite3ExprDelete(whenExpr);        return 1;      }      sqlite3ExprIfFalse(pParse, whenExpr, endTrigger, 1);      sqlite3ExprDelete(whenExpr);      sqlite3VdbeAddOp(pParse->pVdbe, OP_ContextPush, 0, 0);      codeTriggerProgram(pParse, pTrigger->step_list, orconf);       sqlite3VdbeAddOp(pParse->pVdbe, OP_ContextPop, 0, 0);      /* Pop the entry off the trigger stack */      pParse->trigStack = pParse->trigStack->pNext;      sqlite3AuthContextPop(&sContext);      sqliteFree(pTriggerStack);      sqlite3VdbeResolveLabel(pParse->pVdbe, endTrigger);//.........这里部分代码省略.........

//.........这里部分代码省略.........  for(i=0; i<pFKey->nCol; i++){    int iReg = aiCol[i] + regData + 1;    sqlite3VdbeAddOp2(v, OP_IsNull, iReg, iOk);  }  if( isIgnore==0 ){    if( pIdx==0 ){      /* If pIdx is NULL, then the parent key is the INTEGER PRIMARY KEY      ** column of the parent table (table pTab).  */      int iMustBeInt;               /* Address of MustBeInt instruction */      int regTemp = sqlite3GetTempReg(pParse);        /* Invoke MustBeInt to coerce the child key value to an integer (i.e.       ** apply the affinity of the parent key). If this fails, then there      ** is no matching parent key. Before using MustBeInt, make a copy of      ** the value. Otherwise, the value inserted into the child key column      ** will have INTEGER affinity applied to it, which may not be correct.  */      sqlite3VdbeAddOp2(v, OP_SCopy, aiCol[0]+1+regData, regTemp);      iMustBeInt = sqlite3VdbeAddOp2(v, OP_MustBeInt, regTemp, 0);        /* If the parent table is the same as the child table, and we are about      ** to increment the constraint-counter (i.e. this is an INSERT operation),      ** then check if the row being inserted matches itself. If so, do not      ** increment the constraint-counter.  */      if( pTab==pFKey->pFrom && nIncr==1 ){        sqlite3VdbeAddOp3(v, OP_Eq, regData, iOk, regTemp);      }        sqlite3OpenTable(pParse, iCur, iDb, pTab, OP_OpenRead);      sqlite3VdbeAddOp3(v, OP_NotExists, iCur, 0, regTemp);      sqlite3VdbeAddOp2(v, OP_Goto, 0, iOk);      sqlite3VdbeJumpHere(v, sqlite3VdbeCurrentAddr(v)-2);      sqlite3VdbeJumpHere(v, iMustBeInt);      sqlite3ReleaseTempReg(pParse, regTemp);    }else{      int nCol = pFKey->nCol;      int regTemp = sqlite3GetTempRange(pParse, nCol);      int regRec = sqlite3GetTempReg(pParse);      KeyInfo *pKey = sqlite3IndexKeyinfo(pParse, pIdx);        sqlite3VdbeAddOp3(v, OP_OpenRead, iCur, pIdx->tnum, iDb);      sqlite3VdbeChangeP4(v, -1, (char*)pKey, P4_KEYINFO_HANDOFF);      for(i=0; i<nCol; i++){        sqlite3VdbeAddOp2(v, OP_Copy, aiCol[i]+1+regData, regTemp+i);      }        /* If the parent table is the same as the child table, and we are about      ** to increment the constraint-counter (i.e. this is an INSERT operation),      ** then check if the row being inserted matches itself. If so, do not      ** increment the constraint-counter.       **      ** If any of the parent-key values are NULL, then the row cannot match       ** itself. So set JUMPIFNULL to make sure we do the OP_Found if any      ** of the parent-key values are NULL (at this point it is known that      ** none of the child key values are).      */      if( pTab==pFKey->pFrom && nIncr==1 ){        int iJump = sqlite3VdbeCurrentAddr(v) + nCol + 1;        for(i=0; i<nCol; i++){          int iChild = aiCol[i]+1+regData;          int iParent = pIdx->aiColumn[i]+1+regData;          assert( aiCol[i]!=pTab->iPKey );          if( pIdx->aiColumn[i]==pTab->iPKey ){            /* The parent key is a composite key that includes the IPK column */            iParent = regData;          }          sqlite3VdbeAddOp3(v, OP_Ne, iChild, iJump, iParent);          sqlite3VdbeChangeP5(v, SQLITE_JUMPIFNULL);        }        sqlite3VdbeAddOp2(v, OP_Goto, 0, iOk);      }        sqlite3VdbeAddOp3(v, OP_MakeRecord, regTemp, nCol, regRec);      sqlite3VdbeChangeP4(v, -1, sqlite3IndexAffinityStr(v,pIdx), P4_TRANSIENT);      sqlite3VdbeAddOp4Int(v, OP_Found, iCur, iOk, regRec, 0);        sqlite3ReleaseTempReg(pParse, regRec);      sqlite3ReleaseTempRange(pParse, regTemp, nCol);    }  }  if( !pFKey->isDeferred && !pParse->pToplevel && !pParse->isMultiWrite ){    /* Special case: If this is an INSERT statement that will insert exactly    ** one row into the table, raise a constraint immediately instead of    ** incrementing a counter. This is necessary as the VM code is being    ** generated for will not open a statement transaction.  */    assert( nIncr==1 );    sqlite3HaltConstraint(        pParse, OE_Abort, "foreign key constraint failed", P4_STATIC    );  }else{    if( nIncr>0 && pFKey->isDeferred==0 ){      sqlite3ParseToplevel(pParse)->mayAbort = 1;    }    sqlite3VdbeAddOp2(v, OP_FkCounter, pFKey->isDeferred, nIncr);  }  sqlite3VdbeResolveLabel(v, iOk);  sqlite3VdbeAddOp1(v, OP_Close, iCur);}

/*** Generate code to do an analysis of all indices associated with** a single table.*/static void analyzeOneTable(  Parse *pParse,   /* Parser context */  Table *pTab,     /* Table whose indices are to be analyzed */  int iStatCur,    /* Cursor that writes to the sqlite_stat1 table */  int iMem         /* Available memory locations begin here */){  Index *pIdx;     /* An index to being analyzed */  int iIdxCur;     /* Cursor number for index being analyzed */  int nCol;        /* Number of columns in the index */  Vdbe *v;         /* The virtual machine being built up */  int i;           /* Loop counter */  int topOfLoop;   /* The top of the loop */  int endOfLoop;   /* The end of the loop */  int addr;        /* The address of an instruction */  int iDb;         /* Index of database containing pTab */  v = sqlite3GetVdbe(pParse);  if( v==0 || pTab==0 || pTab->pIndex==0 ){    /* Do no analysis for tables that have no indices */    return;  }  assert( sqlite3BtreeHoldsAllMutexes(pParse->db) );  iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);  assert( iDb>=0 );#ifndef SQLITE_OMIT_AUTHORIZATION  if( sqlite3AuthCheck(pParse, SQLITE_ANALYZE, pTab->zName, 0,      pParse->db->aDb[iDb].zName ) ){    return;  }#endif  /* Establish a read-lock on the table at the shared-cache level. */  sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName);  iIdxCur = pParse->nTab;  for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){    KeyInfo *pKey = sqlite3IndexKeyinfo(pParse, pIdx);    /* Open a cursor to the index to be analyzed    */    assert( iDb==sqlite3SchemaToIndex(pParse->db, pIdx->pSchema) );    sqlite3VdbeAddOp(v, OP_Integer, iDb, 0);    VdbeComment((v, "# %s", pIdx->zName));    sqlite3VdbeOp3(v, OP_OpenRead, iIdxCur, pIdx->tnum,        (char *)pKey, P3_KEYINFO_HANDOFF);    nCol = pIdx->nColumn;    if( iMem+nCol*2>=pParse->nMem ){      pParse->nMem = iMem+nCol*2+1;    }    sqlite3VdbeAddOp(v, OP_SetNumColumns, iIdxCur, nCol+1);    /* Memory cells are used as follows:    **    **    mem[iMem]:             The total number of rows in the table.    **    mem[iMem+1]:           Number of distinct values in column 1    **    ...    **    mem[iMem+nCol]:        Number of distinct values in column N    **    mem[iMem+nCol+1]       Last observed value of column 1    **    ...    **    mem[iMem+nCol+nCol]:   Last observed value of column N    **    ** Cells iMem through iMem+nCol are initialized to 0.  The others    ** are initialized to NULL.    */    for(i=0; i<=nCol; i++){      sqlite3VdbeAddOp(v, OP_MemInt, 0, iMem+i);    }    for(i=0; i<nCol; i++){      sqlite3VdbeAddOp(v, OP_MemNull, iMem+nCol+i+1, 0);    }    /* Do the analysis.    */    endOfLoop = sqlite3VdbeMakeLabel(v);    sqlite3VdbeAddOp(v, OP_Rewind, iIdxCur, endOfLoop);    topOfLoop = sqlite3VdbeCurrentAddr(v);    sqlite3VdbeAddOp(v, OP_MemIncr, 1, iMem);    for(i=0; i<nCol; i++){      sqlite3VdbeAddOp(v, OP_Column, iIdxCur, i);      sqlite3VdbeAddOp(v, OP_MemLoad, iMem+nCol+i+1, 0);      sqlite3VdbeAddOp(v, OP_Ne, 0x100, 0);    }    sqlite3VdbeAddOp(v, OP_Goto, 0, endOfLoop);    for(i=0; i<nCol; i++){      addr = sqlite3VdbeAddOp(v, OP_MemIncr, 1, iMem+i+1);      sqlite3VdbeChangeP2(v, topOfLoop + 3*i + 3, addr);      sqlite3VdbeAddOp(v, OP_Column, iIdxCur, i);      sqlite3VdbeAddOp(v, OP_MemStore, iMem+nCol+i+1, 1);    }    sqlite3VdbeResolveLabel(v, endOfLoop);    sqlite3VdbeAddOp(v, OP_Next, iIdxCur, topOfLoop);    sqlite3VdbeAddOp(v, OP_Close, iIdxCur, 0);    /* Store the results.      **    ** The result is a single row of the sqlite_stat1 table.  The first//.........这里部分代码省略.........

//.........这里部分代码省略.........        sqlite3VdbeAddOp2(v, OP_Integer, SQLITE_INDEX_SAMPLES, regTemp2);        sqlite3VdbeAddOp3(v, OP_Subtract, regSampleno, regTemp2, regTemp2);        sqlite3VdbeAddOp3(v, OP_Divide, regTemp2, regTemp, regTemp);        sqlite3VdbeAddOp3(v, OP_Add, regSamplerecno, regTemp, regSamplerecno);        sqlite3VdbeJumpHere(v, ne);        sqlite3VdbeAddOp2(v, OP_AddImm, regRecno, 1);#endif        /* Always record the very first row */        sqlite3VdbeAddOp1(v, OP_IfNot, iMem+1);      }      assert( pIdx->azColl!=0 );      assert( pIdx->azColl[i]!=0 );      pColl = sqlite3LocateCollSeq(pParse, pIdx->azColl[i]);      sqlite3VdbeAddOp4(v, OP_Ne, regCol, 0, iMem+nCol+i+1,                       (char*)pColl, P4_COLLSEQ);      sqlite3VdbeChangeP5(v, SQLITE_NULLEQ);    }    if( db->mallocFailed ){      /* If a malloc failure has occurred, then the result of the expression       ** passed as the second argument to the call to sqlite3VdbeJumpHere()       ** below may be negative. Which causes an assert() to fail (or an      ** out-of-bounds write if SQLITE_DEBUG is not defined).  */      return;    }    sqlite3VdbeAddOp2(v, OP_Goto, 0, endOfLoop);    for(i=0; i<nCol; i++){      int addr2 = sqlite3VdbeCurrentAddr(v) - (nCol*2);      if( i==0 ){        sqlite3VdbeJumpHere(v, addr2-1);  /* Set jump dest for the OP_IfNot */      }      sqlite3VdbeJumpHere(v, addr2);      /* Set jump dest for the OP_Ne */      sqlite3VdbeAddOp2(v, OP_AddImm, iMem+i+1, 1);      sqlite3VdbeAddOp3(v, OP_Column, iIdxCur, i, iMem+nCol+i+1);    }    /* End of the analysis loop. */    sqlite3VdbeResolveLabel(v, endOfLoop);    sqlite3VdbeAddOp2(v, OP_Next, iIdxCur, topOfLoop);    sqlite3VdbeAddOp1(v, OP_Close, iIdxCur);    /* Store the results in sqlite_stat1.    **    ** The result is a single row of the sqlite_stat1 table.  The first    ** two columns are the names of the table and index.  The third column    ** is a string composed of a list of integer statistics about the    ** index.  The first integer in the list is the total number of entries    ** in the index.  There is one additional integer in the list for each    ** column of the table.  This additional integer is a guess of how many    ** rows of the table the index will select.  If D is the count of distinct    ** values and K is the total number of rows, then the integer is computed    ** as:    **    **        I = (K+D-1)/D    **    ** If K==0 then no entry is made into the sqlite_stat1 table.      ** If K>0 then it is always the case the D>0 so division by zero    ** is never possible.    */    sqlite3VdbeAddOp2(v, OP_SCopy, iMem, regSampleno);    if( jZeroRows<0 ){      jZeroRows = sqlite3VdbeAddOp1(v, OP_IfNot, iMem);    }    for(i=0; i<nCol; i++){      sqlite3VdbeAddOp4(v, OP_String8, 0, regTemp, 0, " ", 0);      sqlite3VdbeAddOp3(v, OP_Concat, regTemp, regSampleno, regSampleno);      sqlite3VdbeAddOp3(v, OP_Add, iMem, iMem+i+1, regTemp);      sqlite3VdbeAddOp2(v, OP_AddImm, regTemp, -1);      sqlite3VdbeAddOp3(v, OP_Divide, iMem+i+1, regTemp, regTemp);      sqlite3VdbeAddOp1(v, OP_ToInt, regTemp);      sqlite3VdbeAddOp3(v, OP_Concat, regTemp, regSampleno, regSampleno);    }    sqlite3VdbeAddOp4(v, OP_MakeRecord, regTabname, 3, regRec, "aaa", 0);    sqlite3VdbeAddOp2(v, OP_NewRowid, iStatCur, regRowid);    sqlite3VdbeAddOp3(v, OP_Insert, iStatCur, regRec, regRowid);    sqlite3VdbeChangeP5(v, OPFLAG_APPEND);  }  /* If the table has no indices, create a single sqlite_stat1 entry  ** containing NULL as the index name and the row count as the content.  */  if( pTab->pIndex==0 ){    sqlite3VdbeAddOp3(v, OP_OpenRead, iIdxCur, pTab->tnum, iDb);    VdbeComment((v, "%s", pTab->zName));    sqlite3VdbeAddOp2(v, OP_Count, iIdxCur, regSampleno);    sqlite3VdbeAddOp1(v, OP_Close, iIdxCur);    jZeroRows = sqlite3VdbeAddOp1(v, OP_IfNot, regSampleno);  }else{    sqlite3VdbeJumpHere(v, jZeroRows);    jZeroRows = sqlite3VdbeAddOp0(v, OP_Goto);  }  sqlite3VdbeAddOp2(v, OP_Null, 0, regIdxname);  sqlite3VdbeAddOp4(v, OP_MakeRecord, regTabname, 3, regRec, "aaa", 0);  sqlite3VdbeAddOp2(v, OP_NewRowid, iStatCur, regRowid);  sqlite3VdbeAddOp3(v, OP_Insert, iStatCur, regRec, regRowid);  sqlite3VdbeChangeP5(v, OPFLAG_APPEND);  if( pParse->nMem<regRec ) pParse->nMem = regRec;  sqlite3VdbeJumpHere(v, jZeroRows);}

//.........这里部分代码省略.........  ExprList *pChanges,  /* Changes list for any UPDATE OF triggers */  int tr_tm,           /* One of TRIGGER_BEFORE, TRIGGER_AFTER */  Table *pTab,         /* The table to code triggers from */  int newIdx,          /* The indice of the "new" row to access */  int oldIdx,          /* The indice of the "old" row to access */  int orconf,          /* ON CONFLICT policy */  int ignoreJump,      /* Instruction to jump to for RAISE(IGNORE) */  u32 *piOldColMask,   /* OUT: Mask of columns used from the OLD.* table */  u32 *piNewColMask    /* OUT: Mask of columns used from the NEW.* table */){  Trigger *p;  sqlite3 *db = pParse->db;  TriggerStack trigStackEntry;  trigStackEntry.oldColMask = 0;  trigStackEntry.newColMask = 0;  assert(op == TK_UPDATE || op == TK_INSERT || op == TK_DELETE);  assert(tr_tm == TRIGGER_BEFORE || tr_tm == TRIGGER_AFTER );  assert(newIdx != -1 || oldIdx != -1);  for(p=pTrigger; p; p=p->pNext){    int fire_this = 0;    /* Sanity checking:  The schema for the trigger and for the table are    ** always defined.  The trigger must be in the same schema as the table    ** or else it must be a TEMP trigger. */    assert( p->pSchema!=0 );    assert( p->pTabSchema!=0 );    assert( p->pSchema==p->pTabSchema || p->pSchema==db->aDb[1].pSchema );    /* Determine whether we should code this trigger */    if(       p->op==op &&       p->tr_tm==tr_tm &&       checkColumnOverlap(p->pColumns,pChanges)    ){      TriggerStack *pS;      /* Pointer to trigger-stack entry */      for(pS=pParse->trigStack; pS && p!=pS->pTrigger; pS=pS->pNext){}      if( !pS ){        fire_this = 1;      }#if 0    /* Give no warning for recursive triggers.  Just do not do them */      else{        sqlite3ErrorMsg(pParse, "recursive triggers not supported (%s)",            p->name);        return SQLITE_ERROR;      }#endif    }     if( fire_this ){      int endTrigger;      Expr * whenExpr;      AuthContext sContext;      NameContext sNC;#ifndef SQLITE_OMIT_TRACE      sqlite3VdbeAddOp4(pParse->pVdbe, OP_Trace, 0, 0, 0,                        sqlite3MPrintf(db, "-- TRIGGER %s", p->name),                        P4_DYNAMIC);#endif      memset(&sNC, 0, sizeof(sNC));      sNC.pParse = pParse;      /* Push an entry on to the trigger stack */      trigStackEntry.pTrigger = p;      trigStackEntry.newIdx = newIdx;      trigStackEntry.oldIdx = oldIdx;      trigStackEntry.pTab = pTab;      trigStackEntry.pNext = pParse->trigStack;      trigStackEntry.ignoreJump = ignoreJump;      pParse->trigStack = &trigStackEntry;      sqlite3AuthContextPush(pParse, &sContext, p->name);      /* code the WHEN clause */      endTrigger = sqlite3VdbeMakeLabel(pParse->pVdbe);      whenExpr = sqlite3ExprDup(db, p->pWhen, 0);      if( db->mallocFailed || sqlite3ResolveExprNames(&sNC, whenExpr) ){        pParse->trigStack = trigStackEntry.pNext;        sqlite3ExprDelete(db, whenExpr);        return 1;      }      sqlite3ExprIfFalse(pParse, whenExpr, endTrigger, SQLITE_JUMPIFNULL);      sqlite3ExprDelete(db, whenExpr);      codeTriggerProgram(pParse, p->step_list, orconf);       /* Pop the entry off the trigger stack */      pParse->trigStack = trigStackEntry.pNext;      sqlite3AuthContextPop(&sContext);      sqlite3VdbeResolveLabel(pParse->pVdbe, endTrigger);    }  }  if( piOldColMask ) *piOldColMask |= trigStackEntry.oldColMask;  if( piNewColMask ) *piNewColMask |= trigStackEntry.newColMask;  return 0;}

//.........这里部分代码省略.........        regNewRowid, regOldRowid, chngKey, onError, labelContinue, &bReplace);    /* Do FK constraint checks. */    if( hasFK ){      sqlite3FkCheck(pParse, pTab, regOldRowid, 0, aXRef, chngKey);    }    /* Delete the index entries associated with the current record.  */    if( bReplace || chngKey ){      if( pPk ){        addr1 = sqlite3VdbeAddOp4Int(v, OP_NotFound, iDataCur, 0, regKey, nKey);      }else{        addr1 = sqlite3VdbeAddOp3(v, OP_NotExists, iDataCur, 0, regOldRowid);      }      VdbeCoverageNeverTaken(v);    }    sqlite3GenerateRowIndexDelete(pParse, pTab, iDataCur, iIdxCur, aRegIdx, -1);      /* If changing the record number, delete the old record.  */    if( hasFK || chngKey || pPk!=0 ){      sqlite3VdbeAddOp2(v, OP_Delete, iDataCur, 0);    }    if( bReplace || chngKey ){      sqlite3VdbeJumpHere(v, addr1);    }    if( hasFK ){      sqlite3FkCheck(pParse, pTab, 0, regNewRowid, aXRef, chngKey);    }      /* Insert the new index entries and the new record. */    sqlite3CompleteInsertion(pParse, pTab, iDataCur, iIdxCur,                             regNewRowid, aRegIdx, 1, 0, 0);    /* Do any ON CASCADE, SET NULL or SET DEFAULT operations required to    ** handle rows (possibly in other tables) that refer via a foreign key    ** to the row just updated. */     if( hasFK ){      sqlite3FkActions(pParse, pTab, pChanges, regOldRowid, aXRef, chngKey);    }  }  /* Increment the row counter   */  if( (db->flags & SQLITE_CountRows) && !pParse->pTriggerTab){    sqlite3VdbeAddOp2(v, OP_AddImm, regRowCount, 1);  }  sqlite3CodeRowTrigger(pParse, pTrigger, TK_UPDATE, pChanges,       TRIGGER_AFTER, pTab, regOldRowid, onError, labelContinue);  /* Repeat the above with the next record to be updated, until  ** all record selected by the WHERE clause have been updated.  */  if( okOnePass ){    /* Nothing to do at end-of-loop for a single-pass */  }else if( pPk ){    sqlite3VdbeResolveLabel(v, labelContinue);    sqlite3VdbeAddOp2(v, OP_Next, iEph, addrTop); VdbeCoverage(v);  }else{    sqlite3VdbeGoto(v, labelContinue);  }  sqlite3VdbeResolveLabel(v, labelBreak);  /* Close all tables */  for(i=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, i++){    assert( aRegIdx );    if( aToOpen[i+1] ){      sqlite3VdbeAddOp2(v, OP_Close, iIdxCur+i, 0);    }  }  if( iDataCur<iIdxCur ) sqlite3VdbeAddOp2(v, OP_Close, iDataCur, 0);  /* Update the sqlite_sequence table by storing the content of the  ** maximum rowid counter values recorded while inserting into  ** autoincrement tables.  */  if( pParse->nested==0 && pParse->pTriggerTab==0 ){    sqlite3AutoincrementEnd(pParse);  }  /*  ** 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->pTriggerTab && !pParse->nested ){    sqlite3VdbeAddOp2(v, OP_ResultRow, regRowCount, 1);    sqlite3VdbeSetNumCols(v, 1);    sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "rows updated", SQLITE_STATIC);  }update_cleanup:  sqlite3AuthContextPop(&sContext);  sqlite3DbFree(db, aXRef); /* Also frees aRegIdx[] and aToOpen[] */  sqlite3SrcListDelete(db, pTabList);  sqlite3ExprListDelete(db, pChanges);  sqlite3ExprDelete(db, pWhere);  return;}

//.........这里部分代码省略.........  }  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.    */    if( !okOnePass ) 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 || aRegIdx[i]>0 ){        KeyInfo *pKey = sqlite3IndexKeyinfo(pParse, pIdx);        sqlite3VdbeAddOp4(v, OP_OpenWrite, iCur+i+1, pIdx->tnum, iDb,                       (char*)pKey, P4_KEYINFO_HANDOFF);        assert( pParse->nTab>iCur+i+1 );      }    }  }    /* Jump back to this point if a trigger encounters an IGNORE constraint. */  if( triggers_exist ){    sqlite3VdbeResolveLabel(v, addr);  }  /* Top of the update loop */  if( okOnePass ){    int a1 = sqlite3VdbeAddOp1(v, OP_NotNull, regOldRowid);    addr = sqlite3VdbeAddOp0(v, OP_Goto);    sqlite3VdbeJumpHere(v, a1);  }else{    addr = sqlite3VdbeAddOp3(v, OP_RowSetRead, regRowSet, 0, regOldRowid);  }  if( triggers_exist ){    int regRowid;    int regRow;    int regCols;    /* Make cursor iCur point to the record that is being updated.    */    sqlite3VdbeAddOp3(v, OP_NotExists, iCur, addr, regOldRowid);    /* Generate the OLD table    */    regRowid = sqlite3GetTempReg(pParse);    regRow = sqlite3GetTempReg(pParse);    sqlite3VdbeAddOp2(v, OP_Rowid, iCur, regRowid);    if( !old_col_mask ){      sqlite3VdbeAddOp2(v, OP_Null, 0, regRow);    }else{      sqlite3VdbeAddOp2(v, OP_RowData, iCur, regRow);    }    sqlite3VdbeAddOp3(v, OP_Insert, oldIdx, regRow, regRowid);

//.........这里部分代码省略.........    sqlite3VdbeAddOp2(v, OP_RowSetAdd, iRowSet, iRowid);    if( db->flags & SQLITE_CountRows ){      sqlite3VdbeAddOp2(v, OP_AddImm, memCnt, 1);    }    /* End the database scan loop.    */    sqlite3WhereEnd(pWInfo);    /* Open the pseudo-table used to store OLD if there are triggers.    */    if( triggers_exist ){      sqlite3VdbeAddOp2(v, OP_SetNumColumns, 0, pTab->nCol);      sqlite3VdbeAddOp1(v, OP_OpenPseudo, oldIdx);    }    /* Delete every item whose key was written to the list during the    ** database scan.  We have to delete items after the scan is complete    ** because deleting an item can change the scan order.    */    end = sqlite3VdbeMakeLabel(v);    if( !isView ){      /* Open cursors for the table we are deleting from and       ** all its indices.      */      sqlite3OpenTableAndIndices(pParse, pTab, iCur, OP_OpenWrite);    }    /* This is the beginning of the delete loop. If a trigger encounters    ** an IGNORE constraint, it jumps back to here.    */    if( triggers_exist ){      sqlite3VdbeResolveLabel(v, addr);    }    addr = sqlite3VdbeAddOp3(v, OP_RowSetRead, iRowSet, end, iRowid);    if( triggers_exist ){      int iData = ++pParse->nMem;   /* For storing row data of OLD table */      /* If the record is no longer present in the table, jump to the      ** next iteration of the loop through the contents of the fifo.      */      sqlite3VdbeAddOp3(v, OP_NotExists, iCur, addr, iRowid);      /* Populate the OLD.* pseudo-table */      if( old_col_mask ){        sqlite3VdbeAddOp2(v, OP_RowData, iCur, iData);      }else{        sqlite3VdbeAddOp2(v, OP_Null, 0, iData);      }      sqlite3VdbeAddOp3(v, OP_Insert, oldIdx, iData, iRowid);      /* Jump back and run the BEFORE triggers */      sqlite3VdbeAddOp2(v, OP_Goto, 0, iBeginBeforeTrigger);      sqlite3VdbeJumpHere(v, iEndBeforeTrigger);    }    if( !isView ){      /* Delete the row */#ifndef SQLITE_OMIT_VIRTUALTABLE      if( IsVirtual(pTab) ){        const char *pVtab = (const char *)pTab->pVtab;        sqlite3VtabMakeWritable(pParse, pTab);        sqlite3VdbeAddOp4(v, OP_VUpdate, 0, 1, iRowid, pVtab, P4_VTAB);      }else

//.........这里部分代码省略.........  /* If we are trying to delete from a view, construct that view into  ** a temporary table.  */  if( isView ){    Select *pView = sqlite3SelectDup(pTab->pSelect);    sqlite3Select(pParse, pView, SRT_TempTable, iCur, 0, 0, 0, 0);    sqlite3SelectDelete(pView);  }  /* Initialize the counter of the number of rows deleted, if  ** we are counting rows.  */  if( db->flags & SQLITE_CountRows ){    sqlite3VdbeAddOp(v, OP_Integer, 0, 0);  }  /* Special case: A DELETE without a WHERE clause deletes everything.  ** It is easier just to erase the whole table.  Note, however, that  ** this means that the row change count will be incorrect.  */  if( pWhere==0 && !triggers_exist ){    if( db->flags & SQLITE_CountRows ){      /* If counting rows deleted, just count the total number of      ** entries in the table. */      int endOfLoop = sqlite3VdbeMakeLabel(v);      int addr;      if( !isView ){        sqlite3OpenTableForReading(v, iCur, pTab);      }      sqlite3VdbeAddOp(v, OP_Rewind, iCur, sqlite3VdbeCurrentAddr(v)+2);      addr = sqlite3VdbeAddOp(v, OP_AddImm, 1, 0);      sqlite3VdbeAddOp(v, OP_Next, iCur, addr);      sqlite3VdbeResolveLabel(v, endOfLoop);      sqlite3VdbeAddOp(v, OP_Close, iCur, 0);    }    if( !isView ){      sqlite3VdbeAddOp(v, OP_Clear, pTab->tnum, pTab->iDb);      for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){        sqlite3VdbeAddOp(v, OP_Clear, pIdx->tnum, pIdx->iDb);      }    }  }  /* The usual case: There is a WHERE clause so we have to scan through  ** the table and pick which records to delete.  */  else{    /* Ensure all required collation sequences are available. */    for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){      if( sqlite3CheckIndexCollSeq(pParse, pIdx) ){        goto delete_from_cleanup;      }    }    /* Begin the database scan    */    pWInfo = sqlite3WhereBegin(pParse, pTabList, pWhere, 0);    if( pWInfo==0 ) goto delete_from_cleanup;    /* Remember the rowid of every item to be deleted.    */    sqlite3VdbeAddOp(v, OP_Recno, iCur, 0);    sqlite3VdbeAddOp(v, OP_ListWrite, 0, 0);    if( db->flags & SQLITE_CountRows ){      sqlite3VdbeAddOp(v, OP_AddImm, 1, 0);

//.........这里部分代码省略.........**** 1. No cursors may be open in the main database.  (But newIdx and oldIdx**    can be indices of cursors in temporary tables.  See below.)**** 2. If the triggers being coded are ON INSERT or ON UPDATE triggers, then**    a temporary vdbe cursor (index newIdx) must be open and pointing at**    a row containing values to be substituted for new.* expressions in the**    trigger program(s).**** 3. If the triggers being coded are ON DELETE or ON UPDATE triggers, then**    a temporary vdbe cursor (index oldIdx) must be open and pointing at**    a row containing values to be substituted for old.* expressions in the**    trigger program(s).***/int sqlite3CodeRowTrigger(  Parse *pParse,       /* Parse context */  int op,              /* One of TK_UPDATE, TK_INSERT, TK_DELETE */  ExprList *pChanges,  /* Changes list for any UPDATE OF triggers */  int tr_tm,           /* One of TRIGGER_BEFORE, TRIGGER_AFTER */  Table *pTab,         /* The table to code triggers from */  int newIdx,          /* The indice of the "new" row to access */  int oldIdx,          /* The indice of the "old" row to access */  int orconf,          /* ON CONFLICT policy */  int ignoreJump       /* Instruction to jump to for RAISE(IGNORE) */){  Trigger *p;  TriggerStack trigStackEntry;  assert(op == TK_UPDATE || op == TK_INSERT || op == TK_DELETE);  assert(tr_tm == TRIGGER_BEFORE || tr_tm == TRIGGER_AFTER );  assert(newIdx != -1 || oldIdx != -1);  for(p=pTab->pTrigger; p; p=p->pNext){    int fire_this = 0;    sqlite3 *db = pParse->db;    /* Determine whether we should code this trigger */    if(       p->op==op &&       p->tr_tm==tr_tm &&       (p->pSchema==p->pTabSchema || p->pSchema==db->aDb[1].pSchema) &&      (op!=TK_UPDATE||!p->pColumns||checkColumnOverLap(p->pColumns,pChanges))    ){      TriggerStack *pS;      /* Pointer to trigger-stack entry */      for(pS=pParse->trigStack; pS && p!=pS->pTrigger; pS=pS->pNext){}      if( !pS ){        fire_this = 1;      }#if 0    /* Give no warning for recursive triggers.  Just do not do them */      else{        sqlite3ErrorMsg(pParse, "recursive triggers not supported (%s)",            p->name);        return SQLITE_ERROR;      }#endif    }     if( fire_this ){      int endTrigger;      Expr * whenExpr;      AuthContext sContext;      NameContext sNC;      memset(&sNC, 0, sizeof(sNC));      sNC.pParse = pParse;      /* Push an entry on to the trigger stack */      trigStackEntry.pTrigger = p;      trigStackEntry.newIdx = newIdx;      trigStackEntry.oldIdx = oldIdx;      trigStackEntry.pTab = pTab;      trigStackEntry.pNext = pParse->trigStack;      trigStackEntry.ignoreJump = ignoreJump;      pParse->trigStack = &trigStackEntry;      sqlite3AuthContextPush(pParse, &sContext, p->name);      /* code the WHEN clause */      endTrigger = sqlite3VdbeMakeLabel(pParse->pVdbe);      whenExpr = sqlite3ExprDup(db, p->pWhen);      if( db->mallocFailed || sqlite3ExprResolveNames(&sNC, whenExpr) ){        pParse->trigStack = trigStackEntry.pNext;        sqlite3ExprDelete(whenExpr);        return 1;      }      sqlite3ExprIfFalse(pParse, whenExpr, endTrigger, 1);      sqlite3ExprDelete(whenExpr);      codeTriggerProgram(pParse, p->step_list, orconf);       /* Pop the entry off the trigger stack */      pParse->trigStack = trigStackEntry.pNext;      sqlite3AuthContextPop(&sContext);      sqlite3VdbeResolveLabel(pParse->pVdbe, endTrigger);    }  }  return 0;}

//.........这里部分代码省略.........        iAddrOnce = sqlite3VdbeAddOp0(v, OP_Once); VdbeCoverage(v);      }      testcase( IsVirtual(pTab) );      sqlite3OpenTableAndIndices(pParse, pTab, OP_OpenWrite, OPFLAG_FORDELETE,                                 iTabCur, aToOpen, &iDataCur, &iIdxCur);      assert( pPk || IsVirtual(pTab) || iDataCur==iTabCur );      assert( pPk || IsVirtual(pTab) || iIdxCur==iDataCur+1 );      if( eOnePass==ONEPASS_MULTI ) sqlite3VdbeJumpHere(v, iAddrOnce);    }      /* Set up a loop over the rowids/primary-keys that were found in the    ** where-clause loop above.    */    if( eOnePass!=ONEPASS_OFF ){      assert( nKey==nPk );  /* OP_Found will use an unpacked key */      if( !IsVirtual(pTab) && aToOpen[iDataCur-iTabCur] ){        assert( pPk!=0 || pTab->pSelect!=0 );        sqlite3VdbeAddOp4Int(v, OP_NotFound, iDataCur, addrBypass, iKey, nKey);        VdbeCoverage(v);      }    }else if( pPk ){      addrLoop = sqlite3VdbeAddOp1(v, OP_Rewind, iEphCur); VdbeCoverage(v);      sqlite3VdbeAddOp2(v, OP_RowKey, iEphCur, iKey);      assert( nKey==0 );  /* OP_Found will use a composite key */    }else{      addrLoop = sqlite3VdbeAddOp3(v, OP_RowSetRead, iRowSet, 0, iKey);      VdbeCoverage(v);      assert( nKey==1 );    }        /* Delete the row */#ifndef SQLITE_OMIT_VIRTUALTABLE    if( IsVirtual(pTab) ){      const char *pVTab = (const char *)sqlite3GetVTable(db, pTab);      sqlite3VtabMakeWritable(pParse, pTab);      sqlite3VdbeAddOp4(v, OP_VUpdate, 0, 1, iKey, pVTab, P4_VTAB);      sqlite3VdbeChangeP5(v, OE_Abort);      assert( eOnePass==ONEPASS_OFF || eOnePass==ONEPASS_SINGLE );      sqlite3MayAbort(pParse);      if( eOnePass==ONEPASS_SINGLE && sqlite3IsToplevel(pParse) ){        pParse->isMultiWrite = 0;      }    }else#endif    {      int count = (pParse->nested==0);    /* True to count changes */      int iIdxNoSeek = -1;      if( bComplex==0 && aiCurOnePass[1]!=iDataCur ){        iIdxNoSeek = aiCurOnePass[1];      }      sqlite3GenerateRowDelete(pParse, pTab, pTrigger, iDataCur, iIdxCur,          iKey, nKey, count, OE_Default, eOnePass, iIdxNoSeek);    }      /* End of the loop over all rowids/primary-keys. */    if( eOnePass!=ONEPASS_OFF ){      sqlite3VdbeResolveLabel(v, addrBypass);      sqlite3WhereEnd(pWInfo);    }else if( pPk ){      sqlite3VdbeAddOp2(v, OP_Next, iEphCur, addrLoop+1); VdbeCoverage(v);      sqlite3VdbeJumpHere(v, addrLoop);    }else{      sqlite3VdbeGoto(v, addrLoop);      sqlite3VdbeJumpHere(v, addrLoop);    }           /* Close the cursors open on the table and its indexes. */    if( !isView && !IsVirtual(pTab) ){      if( !pPk ) sqlite3VdbeAddOp1(v, OP_Close, iDataCur);      for(i=0, pIdx=pTab->pIndex; pIdx; i++, pIdx=pIdx->pNext){        sqlite3VdbeAddOp1(v, OP_Close, iIdxCur + i);      }    }  } /* End non-truncate path */  /* Update the sqlite_sequence table by storing the content of the  ** maximum rowid counter values recorded while inserting into  ** autoincrement tables.  */  if( pParse->nested==0 && pParse->pTriggerTab==0 ){    sqlite3AutoincrementEnd(pParse);  }  /* Return the number of rows that were deleted. If this routine is   ** generating code because of a call to sqlite3NestedParse(), do not  ** invoke the callback function.  */  if( (db->flags&SQLITE_CountRows) && !pParse->nested && !pParse->pTriggerTab ){    sqlite3VdbeAddOp2(v, OP_ResultRow, memCnt, 1);    sqlite3VdbeSetNumCols(v, 1);    sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "rows deleted", SQLITE_STATIC);  }delete_from_cleanup:  sqlite3AuthContextPop(&sContext);  sqlite3SrcListDelete(db, pTabList);  sqlite3ExprDelete(db, pWhere);  sqlite3DbFree(db, aToOpen);  return;}

/* ** Create and populate a new TriggerPrg object with a sub-program ** implementing trigger pTrigger with ON CONFLICT policy orconf. */static TriggerPrg *codeRowTrigger(                                  Parse *pParse,       /* Current parse context */                                  Trigger *pTrigger,   /* Trigger to code */                                  Table *pTab,         /* The table pTrigger is attached to */                                  int orconf           /* ON CONFLICT policy to code trigger program with */){    Parse *pTop = sqlite3ParseToplevel(pParse);    sqlite3 *db = pParse->db;   /* Database handle */    TriggerPrg *pPrg;           /* Value to return */    Expr *pWhen = 0;            /* Duplicate of trigger WHEN expression */    Vdbe *v;                    /* Temporary VM */    NameContext sNC;            /* Name context for sub-vdbe */    SubProgram *pProgram = 0;   /* Sub-vdbe for trigger program */    Parse *pSubParse;           /* Parse context for sub-vdbe */    int iEndTrigger = 0;        /* Label to jump to if WHEN is false */        assert( pTrigger->zName==0 || pTab==tableOfTrigger(pTrigger) );    assert( pTop->pVdbe );        /* Allocate the TriggerPrg and SubProgram objects. To ensure that they     ** are freed if an error occurs, link them into the Parse.pTriggerPrg     ** list of the top-level Parse object sooner rather than later.  */    pPrg = sqlite3DbMallocZero(db, sizeof(TriggerPrg));    if( !pPrg ) return 0;    pPrg->pNext = pTop->pTriggerPrg;    pTop->pTriggerPrg = pPrg;    pPrg->pProgram = pProgram = sqlite3DbMallocZero(db, sizeof(SubProgram));    if( !pProgram ) return 0;    sqlite3VdbeLinkSubProgram(pTop->pVdbe, pProgram);    pPrg->pTrigger = pTrigger;    pPrg->orconf = orconf;    pPrg->aColmask[0] = 0xffffffff;    pPrg->aColmask[1] = 0xffffffff;        /* Allocate and populate a new Parse context to use for coding the     ** trigger sub-program.  */    pSubParse = sqlite3StackAllocZero(db, sizeof(Parse));    if( !pSubParse ) return 0;    memset(&sNC, 0, sizeof(sNC));    sNC.pParse = pSubParse;    pSubParse->db = db;    pSubParse->pTriggerTab = pTab;    pSubParse->pToplevel = pTop;    pSubParse->zAuthContext = pTrigger->zName;    pSubParse->eTriggerOp = pTrigger->op;    pSubParse->nQueryLoop = pParse->nQueryLoop;        v = sqlite3GetVdbe(pSubParse);    if( v ){        VdbeComment((v, "Start: %s.%s (%s %s%s%s ON %s)",                     pTrigger->zName, onErrorText(orconf),                     (pTrigger->tr_tm==TRIGGER_BEFORE ? "BEFORE" : "AFTER"),                     (pTrigger->op==TK_UPDATE ? "UPDATE" : ""),                     (pTrigger->op==TK_INSERT ? "INSERT" : ""),                     (pTrigger->op==TK_DELETE ? "DELETE" : ""),                     pTab->zName                     ));#ifndef SQLITE_OMIT_TRACE        sqlite3VdbeChangeP4(v, -1,                            sqlite3MPrintf(db, "-- TRIGGER %s", pTrigger->zName), P4_DYNAMIC                            );#endif                /* If one was specified, code the WHEN clause. If it evaluates to false         ** (or NULL) the sub-vdbe is immediately halted by jumping to the         ** OP_Halt inserted at the end of the program.  */        if( pTrigger->pWhen ){            pWhen = sqlite3ExprDup(db, pTrigger->pWhen, 0);            if( SQLITE_OK==sqlite3ResolveExprNames(&sNC, pWhen)               && db->mallocFailed==0               ){                iEndTrigger = sqlite3VdbeMakeLabel(v);                sqlite3ExprIfFalse(pSubParse, pWhen, iEndTrigger, SQLITE_JUMPIFNULL);            }            sqlite3ExprDelete(db, pWhen);        }                /* Code the trigger program into the sub-vdbe. */        codeTriggerProgram(pSubParse, pTrigger->step_list, orconf);                /* Insert an OP_Halt at the end of the sub-program. */        if( iEndTrigger ){            sqlite3VdbeResolveLabel(v, iEndTrigger);        }        sqlite3VdbeAddOp0(v, OP_Halt);        VdbeComment((v, "End: %s.%s", pTrigger->zName, onErrorText(orconf)));                transferParseError(pParse, pSubParse);        if( db->mallocFailed==0 ){            pProgram->aOp = sqlite3VdbeTakeOpArray(v, &pProgram->nOp, &pTop->nMaxArg);        }        pProgram->nMem = pSubParse->nMem;        pProgram->nCsr = pSubParse->nTab;        pProgram->nOnce = pSubParse->nOnce;        pProgram->token = (void *)pTrigger;        pPrg->aColmask[0] = pSubParse->oldmask;//.........这里部分代码省略.........

/*** If a prior call to sqlite3GenerateIndexKey() generated a jump-over label** because it was a partial index, then this routine should be called to** resolve that label.*/void sqlite3ResolvePartIdxLabel(Parse *pParse, int iLabel){  if( iLabel ){    sqlite3VdbeResolveLabel(pParse->pVdbe, iLabel);    sqlite3ExprCachePop(pParse);  }}

/*** This is called to code FOR EACH ROW triggers.**** When the code that this function generates is executed, the following ** must be true:**** 1. No cursors may be open in the main database.  (But newIdx and oldIdx**    can be indices of cursors in temporary tables.  See below.)**** 2. If the triggers being coded are ON INSERT or ON UPDATE triggers, then**    a temporary vdbe cursor (index newIdx) must be open and pointing at**    a row containing values to be substituted for new.* expressions in the**    trigger program(s).**** 3. If the triggers being coded are ON DELETE or ON UPDATE triggers, then**    a temporary vdbe cursor (index oldIdx) must be open and pointing at**    a row containing values to be substituted for old.* expressions in the**    trigger program(s).***/int sqlite3CodeRowTrigger(  Parse *pParse,       /* Parse context */  int op,              /* One of TK_UPDATE, TK_INSERT, TK_DELETE */  ExprList *pChanges,  /* Changes list for any UPDATE OF triggers */  int tr_tm,           /* One of TRIGGER_BEFORE, TRIGGER_AFTER */  Table *pTab,         /* The table to code triggers from */  int newIdx,          /* The indice of the "new" row to access */  int oldIdx,          /* The indice of the "old" row to access */  int orconf,          /* ON CONFLICT policy */  int ignoreJump       /* Instruction to jump to for RAISE(IGNORE) */){  Trigger *pTrigger;  TriggerStack *pStack;  TriggerStack trigStackEntry;  assert(op == TK_UPDATE || op == TK_INSERT || op == TK_DELETE);  assert(tr_tm == TRIGGER_BEFORE || tr_tm == TRIGGER_AFTER );  assert(newIdx != -1 || oldIdx != -1);  pTrigger = pTab->pTrigger;  while( pTrigger ){    int fire_this = 0;    /* determine whether we should code this trigger */    if( pTrigger->op == op && pTrigger->tr_tm == tr_tm ){      fire_this = 1;      for(pStack=pParse->trigStack; pStack; pStack=pStack->pNext){        if( pStack->pTrigger==pTrigger ){	  fire_this = 0;	}      }      if( op == TK_UPDATE && pTrigger->pColumns &&          !checkColumnOverLap(pTrigger->pColumns, pChanges) ){        fire_this = 0;      }    }     if( fire_this ){      int endTrigger;      Expr * whenExpr;      AuthContext sContext;      NameContext sNC;      memset(&sNC, 0, sizeof(sNC));      sNC.pParse = pParse;      /* Push an entry on to the trigger stack */      trigStackEntry.pTrigger = pTrigger;      trigStackEntry.newIdx = newIdx;      trigStackEntry.oldIdx = oldIdx;      trigStackEntry.pTab = pTab;      trigStackEntry.pNext = pParse->trigStack;      trigStackEntry.ignoreJump = ignoreJump;      pParse->trigStack = &trigStackEntry;      sqlite3AuthContextPush(pParse, &sContext, pTrigger->name);      /* code the WHEN clause */      endTrigger = sqlite3VdbeMakeLabel(pParse->pVdbe);      whenExpr = sqlite3ExprDup(pTrigger->pWhen);      if( sqlite3ExprResolveNames(&sNC, whenExpr) ){        pParse->trigStack = trigStackEntry.pNext;        sqlite3ExprDelete(whenExpr);        return 1;      }      sqlite3ExprIfFalse(pParse, whenExpr, endTrigger, 1);      sqlite3ExprDelete(whenExpr);      codeTriggerProgram(pParse, pTrigger->step_list, orconf);       /* Pop the entry off the trigger stack */      pParse->trigStack = trigStackEntry.pNext;      sqlite3AuthContextPop(&sContext);      sqlite3VdbeResolveLabel(pParse->pVdbe, endTrigger);    }    pTrigger = pTrigger->pNext;  }  return 0;}