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

/*** Construct a trigger step that implements an UPDATE statement and return** a pointer to that trigger step.  The parser calls this routine when it** sees an UPDATE statement inside the body of a CREATE TRIGGER.*/TriggerStep *sqlite3TriggerUpdateStep(    sqlite3 *db,         /* The database connection */    Token *pTableName,   /* Name of the table to be updated */    ExprList *pEList,    /* The SET clause: list of column and new values */    Expr *pWhere,        /* The WHERE clause */    u8 orconf            /* The conflict algorithm. (OE_Abort, OE_Ignore, etc) */    ){    TriggerStep *pTriggerStep;    pTriggerStep = triggerStepAllocate(db, TK_UPDATE, pTableName);    if (pTriggerStep){        pTriggerStep->pExprList = sqlite3ExprListDup(db, pEList, EXPRDUP_REDUCE);        pTriggerStep->pWhere = sqlite3ExprDup(db, pWhere, EXPRDUP_REDUCE);        pTriggerStep->orconf = orconf;    }    sqlite3ExprListDelete(db, pEList);    sqlite3ExprDelete(db, pWhere);    return pTriggerStep;}

/*** Construct a trigger step that implements an UPDATE statement and return** a pointer to that trigger step.  The parser calls this routine when it** sees an UPDATE statement inside the body of a CREATE TRIGGER.*/TriggerStep *sqlite3TriggerUpdateStep(  sqlite3 *db,         /* The database connection */  Token *pTableName,   /* Name of the table to be updated */  ExprList *pEList,    /* The SET clause: list of column and new values */  Expr *pWhere,        /* The WHERE clause */  int orconf           /* The conflict algorithm. (OE_Abort, OE_Ignore, etc) */){  TriggerStep *pTriggerStep = (TriggerStep*)sqlite3DbMallocZero(db, sizeof(TriggerStep));  if( pTriggerStep==0 ){     sqlite3ExprListDelete(pEList);     sqlite3ExprDelete(pWhere);     return 0;  }  pTriggerStep->op = TK_UPDATE;  pTriggerStep->target  = *pTableName;  pTriggerStep->pExprList = pEList;  pTriggerStep->pWhere = pWhere;  pTriggerStep->orconf = orconf;  sqlitePersistTriggerStep(db, pTriggerStep);  return pTriggerStep;}

/*** Construct a trigger step that implements a DELETE statement and return** a pointer to that trigger step.  The parser calls this routine when it** sees a DELETE statement inside the body of a CREATE TRIGGER.*/TriggerStep *sqlite3TriggerDeleteStep(  Parse *pParse,          /* Parser */  Token *pTableName,      /* The table from which rows are deleted */  Expr *pWhere,           /* The WHERE clause */  const char *zStart,     /* Start of SQL text */  const char *zEnd        /* End of SQL text */){  sqlite3 *db = pParse->db;  TriggerStep *pTriggerStep;  pTriggerStep = triggerStepAllocate(pParse, TK_DELETE, pTableName,zStart,zEnd);  if( pTriggerStep ){    if( IN_RENAME_OBJECT ){      pTriggerStep->pWhere = pWhere;      pWhere = 0;    }else{      pTriggerStep->pWhere = sqlite3ExprDup(db, pWhere, EXPRDUP_REDUCE);    }    pTriggerStep->orconf = OE_Default;  }  sqlite3ExprDelete(db, pWhere);  return pTriggerStep;}

//.........这里部分代码省略.........             */            db->init.orphanTrigger = 1;        }        goto trigger_cleanup;    }    if( IsVirtual(pTab) ){        sqlite3ErrorMsg(pParse, "cannot create triggers on virtual tables");        goto trigger_cleanup;    }        /* Check that the trigger name is not reserved and that no trigger of the     ** specified name exists */    zName = sqlite3NameFromToken(db, pName);    if( !zName || SQLITE_OK!=sqlite3CheckObjectName(pParse, zName) ){        goto trigger_cleanup;    }    assert( sqlite3SchemaMutexHeld(db, iDb, 0) );    if( sqlite3HashFind(&(db->aDb[iDb].pSchema->trigHash),                        zName, sqlite3Strlen30(zName)) ){        if( !noErr ){            sqlite3ErrorMsg(pParse, "trigger %T already exists", pName);        }else{            assert( !db->init.busy );            sqlite3CodeVerifySchema(pParse, iDb);        }        goto trigger_cleanup;    }        /* Do not create a trigger on a system table */    if( sqlite3StrNICmp(pTab->zName, "sqlite_", 7)==0 ){        sqlite3ErrorMsg(pParse, "cannot create trigger on system table");        pParse->nErr++;        goto trigger_cleanup;    }        /* INSTEAD of triggers are only for views and views only support INSTEAD     ** of triggers.     */    if( pTab->pSelect && tr_tm!=TK_INSTEAD ){        sqlite3ErrorMsg(pParse, "cannot create %s trigger on view: %S",                        (tr_tm == TK_BEFORE)?"BEFORE":"AFTER", pTableName, 0);        goto trigger_cleanup;    }    if( !pTab->pSelect && tr_tm==TK_INSTEAD ){        sqlite3ErrorMsg(pParse, "cannot create INSTEAD OF"                        " trigger on table: %S", pTableName, 0);        goto trigger_cleanup;    }    iTabDb = sqlite3SchemaToIndex(db, pTab->pSchema);    #ifndef SQLITE_OMIT_AUTHORIZATION    {        int code = SQLITE_CREATE_TRIGGER;        const char *zDb = db->aDb[iTabDb].zName;        const char *zDbTrig = isTemp ? db->aDb[1].zName : zDb;        if( iTabDb==1 || isTemp ) code = SQLITE_CREATE_TEMP_TRIGGER;        if( sqlite3AuthCheck(pParse, code, zName, pTab->zName, zDbTrig) ){            goto trigger_cleanup;        }        if( sqlite3AuthCheck(pParse, SQLITE_INSERT, SCHEMA_TABLE(iTabDb),0,zDb)){            goto trigger_cleanup;        }    }#endif        /* INSTEAD OF triggers can only appear on views and BEFORE triggers     ** cannot appear on views.  So we might as well translate every     ** INSTEAD OF trigger into a BEFORE trigger.  It simplifies code     ** elsewhere.     */    if (tr_tm == TK_INSTEAD){        tr_tm = TK_BEFORE;    }        /* Build the Trigger object */    pTrigger = (Trigger*)sqlite3DbMallocZero(db, sizeof(Trigger));    if( pTrigger==0 ) goto trigger_cleanup;    pTrigger->zName = zName;    zName = 0;    pTrigger->table = sqlite3DbStrDup(db, pTableName->a[0].zName);    pTrigger->pSchema = db->aDb[iDb].pSchema;    pTrigger->pTabSchema = pTab->pSchema;    pTrigger->op = (u8)op;    pTrigger->tr_tm = tr_tm==TK_BEFORE ? TRIGGER_BEFORE : TRIGGER_AFTER;    pTrigger->pWhen = sqlite3ExprDup(db, pWhen, EXPRDUP_REDUCE);    pTrigger->pColumns = sqlite3IdListDup(db, pColumns);    assert( pParse->pNewTrigger==0 );    pParse->pNewTrigger = pTrigger;    trigger_cleanup:    sqlite3DbFree(db, zName);    sqlite3SrcListDelete(db, pTableName);    sqlite3IdListDelete(db, pColumns);    sqlite3ExprDelete(db, pWhen);    if( !pParse->pNewTrigger ){        sqlite3DeleteTrigger(db, pTrigger);    }else{        assert( pParse->pNewTrigger==pTrigger );    }}

//.........这里部分代码省略.........          assert( pExpr->x.pSelect==0 );          pOrig = pEList->a[j].pExpr;          if( (pNC->ncFlags&NC_AllowAgg)==0 && ExprHasProperty(pOrig, EP_Agg) ){            sqlite3ErrorMsg(pParse, "misuse of aliased aggregate %s", zAs);            return WRC_Abort;          }          resolveAlias(pParse, pEList, j, pExpr, "", nSubquery);          cnt = 1;          pMatch = 0;          assert( zTab==0 && zDb==0 );          goto lookupname_end;        }      }     }    /* Advance to the next name context.  The loop will exit when either    ** we have a match (cnt>0) or when we run out of name contexts.    */    if( cnt==0 ){      pNC = pNC->pNext;      nSubquery++;    }  }  /*  ** If X and Y are NULL (in other words if only the column name Z is  ** supplied) and the value of Z is enclosed in double-quotes, then  ** Z is a string literal if it doesn't match any column names.  In that  ** case, we need to return right away and not make any changes to  ** pExpr.  **  ** Because no reference was made to outer contexts, the pNC->nRef  ** fields are not changed in any context.  */  if( cnt==0 && zTab==0 && ExprHasProperty(pExpr,EP_DblQuoted) ){    pExpr->op = TK_STRING;    pExpr->pTab = 0;    return WRC_Prune;  }  /*  ** cnt==0 means there was not match.  cnt>1 means there were two or  ** more matches.  Either way, we have an error.  */  if( cnt!=1 ){    const char *zErr;    zErr = cnt==0 ? "no such column" : "ambiguous column name";    if( zDb ){      sqlite3ErrorMsg(pParse, "%s: %s.%s.%s", zErr, zDb, zTab, zCol);    }else if( zTab ){      sqlite3ErrorMsg(pParse, "%s: %s.%s", zErr, zTab, zCol);    }else{      sqlite3ErrorMsg(pParse, "%s: %s", zErr, zCol);    }    pParse->checkSchema = 1;    pTopNC->nErr++;  }  /* If a column from a table in pSrcList is referenced, then record  ** this fact in the pSrcList.a[].colUsed bitmask.  Column 0 causes  ** bit 0 to be set.  Column 1 sets bit 1.  And so forth.  If the  ** column number is greater than the number of bits in the bitmask  ** then set the high-order bit of the bitmask.  */  if( pExpr->iColumn>=0 && pMatch!=0 ){    int n = pExpr->iColumn;    testcase( n==BMS-1 );    if( n>=BMS ){      n = BMS-1;    }    assert( pMatch->iCursor==pExpr->iTable );    pMatch->colUsed |= ((Bitmask)1)<<n;  }  /* Clean up and return  */  sqlite3ExprDelete(db, pExpr->pLeft);  pExpr->pLeft = 0;  sqlite3ExprDelete(db, pExpr->pRight);  pExpr->pRight = 0;  pExpr->op = (isTrigger ? TK_TRIGGER : TK_COLUMN);lookupname_end:  if( cnt==1 ){    assert( pNC!=0 );    if( pExpr->op!=TK_AS ){      sqlite3AuthRead(pParse, pExpr, pSchema, pNC->pSrcList);    }    /* Increment the nRef value on all name contexts from TopNC up to    ** the point where the name matched. */    for(;;){      assert( pTopNC!=0 );      pTopNC->nRef++;      if( pTopNC==pNC ) break;      pTopNC = pTopNC->pNext;    }    return WRC_Prune;  } else {    return WRC_Abort;  }}

/*** Generate an expression tree to implement the WHERE, ORDER BY,** and LIMIT/OFFSET portion of DELETE and UPDATE statements.****     DELETE FROM table_wxyz WHERE a<5 ORDER BY a LIMIT 1;**                            /__________________________/**                               pLimitWhere (pInClause)*/Expr *sqlite3LimitWhere(  Parse *pParse,               /* The parser context */  SrcList *pSrc,               /* the FROM clause -- which tables to scan */  Expr *pWhere,                /* The WHERE clause.  May be null */  ExprList *pOrderBy,          /* The ORDER BY clause.  May be null */  Expr *pLimit,                /* The LIMIT clause.  May be null */  Expr *pOffset,               /* The OFFSET clause.  May be null */  char *zStmtType              /* Either DELETE or UPDATE.  For err msgs. */){  Expr *pWhereRowid = NULL;    /* WHERE rowid .. */  Expr *pInClause = NULL;      /* WHERE rowid IN ( select ) */  Expr *pSelectRowid = NULL;   /* SELECT rowid ... */  ExprList *pEList = NULL;     /* Expression list contaning only pSelectRowid */  SrcList *pSelectSrc = NULL;  /* SELECT rowid FROM x ... (dup of pSrc) */  Select *pSelect = NULL;      /* Complete SELECT tree */  /* Check that there isn't an ORDER BY without a LIMIT clause.  */  if( pOrderBy && (pLimit == 0) ) {    sqlite3ErrorMsg(pParse, "ORDER BY without LIMIT on %s", zStmtType);    goto limit_where_cleanup;  }  /* We only need to generate a select expression if there  ** is a limit/offset term to enforce.  */  if( pLimit == 0 ) {    /* if pLimit is null, pOffset will always be null as well. */    assert( pOffset == 0 );    return pWhere;  }  /* Generate a select expression tree to enforce the limit/offset   ** term for the DELETE or UPDATE statement.  For example:  **   DELETE FROM table_a WHERE col1=1 ORDER BY col2 LIMIT 1 OFFSET 1  ** becomes:  **   DELETE FROM table_a WHERE rowid IN (   **     SELECT rowid FROM table_a WHERE col1=1 ORDER BY col2 LIMIT 1 OFFSET 1  **   );  */  pSelectRowid = sqlite3PExpr(pParse, TK_ROW, 0, 0, 0);  if( pSelectRowid == 0 ) goto limit_where_cleanup;  pEList = sqlite3ExprListAppend(pParse, 0, pSelectRowid);  if( pEList == 0 ) goto limit_where_cleanup;  /* duplicate the FROM clause as it is needed by both the DELETE/UPDATE tree  ** and the SELECT subtree. */  pSelectSrc = sqlite3SrcListDup(pParse->db, pSrc, 0);  if( pSelectSrc == 0 ) {    sqlite3ExprListDelete(pParse->db, pEList);    goto limit_where_cleanup;  }  /* generate the SELECT expression tree. */  pSelect = sqlite3SelectNew(pParse,pEList,pSelectSrc,pWhere,0,0,                             pOrderBy,0,pLimit,pOffset);  if( pSelect == 0 ) return 0;  /* now generate the new WHERE rowid IN clause for the DELETE/UDPATE */  pWhereRowid = sqlite3PExpr(pParse, TK_ROW, 0, 0, 0);  pInClause = pWhereRowid ? sqlite3PExpr(pParse, TK_IN, pWhereRowid, 0, 0) : 0;  sqlite3PExprAddSelect(pParse, pInClause, pSelect);  return pInClause;limit_where_cleanup:  sqlite3ExprDelete(pParse->db, pWhere);  sqlite3ExprListDelete(pParse->db, pOrderBy);  sqlite3ExprDelete(pParse->db, pLimit);  sqlite3ExprDelete(pParse->db, pOffset);  return 0;}

//.........这里部分代码省略.........  pTab = sqlite3SrcListLookup(pParse, pTableName);  if( pName2->n==0 && pTab && pTab->iDb==1 ){    iDb = 1;  }  /* Ensure the table name matches database name and that the table exists */  if( sqlite3_malloc_failed ) goto trigger_cleanup;  assert( pTableName->nSrc==1 );  if( sqlite3FixInit(&sFix, pParse, iDb, "trigger", pName) &&       sqlite3FixSrcList(&sFix, pTableName) ){    goto trigger_cleanup;  }  pTab = sqlite3SrcListLookup(pParse, pTableName);  if( !pTab ){    /* The table does not exist. */    goto trigger_cleanup;  }  /* Check that the trigger name is not reserved and that no trigger of the  ** specified name exists */  zName = sqlite3NameFromToken(pName);  if( !zName || SQLITE_OK!=sqlite3CheckObjectName(pParse, zName) ){    goto trigger_cleanup;  }  if( sqlite3HashFind(&(db->aDb[iDb].trigHash), zName,pName->n+1) ){    sqlite3ErrorMsg(pParse, "trigger %T already exists", pName);    goto trigger_cleanup;  }  /* Do not create a trigger on a system table */  if( (iDb!=1 && sqlite3StrICmp(pTab->zName, MASTER_NAME)==0) ||       (iDb==1 && sqlite3StrICmp(pTab->zName, TEMP_MASTER_NAME)==0)   ){    sqlite3ErrorMsg(pParse, "cannot create trigger on system table");    pParse->nErr++;    goto trigger_cleanup;  }  /* INSTEAD of triggers are only for views and views only support INSTEAD  ** of triggers.  */  if( pTab->pSelect && tr_tm!=TK_INSTEAD ){    sqlite3ErrorMsg(pParse, "cannot create %s trigger on view: %S",         (tr_tm == TK_BEFORE)?"BEFORE":"AFTER", pTableName, 0);    goto trigger_cleanup;  }  if( !pTab->pSelect && tr_tm==TK_INSTEAD ){    sqlite3ErrorMsg(pParse, "cannot create INSTEAD OF"        " trigger on table: %S", pTableName, 0);    goto trigger_cleanup;  }#ifndef SQLITE_OMIT_AUTHORIZATION  {    int code = SQLITE_CREATE_TRIGGER;    const char *zDb = db->aDb[pTab->iDb].zName;    const char *zDbTrig = isTemp ? db->aDb[1].zName : zDb;    if( pTab->iDb==1 || isTemp ) code = SQLITE_CREATE_TEMP_TRIGGER;    if( sqlite3AuthCheck(pParse, code, zName, pTab->zName, zDbTrig) ){      goto trigger_cleanup;    }    if( sqlite3AuthCheck(pParse, SQLITE_INSERT, SCHEMA_TABLE(pTab->iDb), 0, zDb)){      goto trigger_cleanup;    }  }#endif  /* INSTEAD OF triggers can only appear on views and BEFORE triggers  ** cannot appear on views.  So we might as well translate every  ** INSTEAD OF trigger into a BEFORE trigger.  It simplifies code  ** elsewhere.  */  if (tr_tm == TK_INSTEAD){    tr_tm = TK_BEFORE;  }  /* Build the Trigger object */  pTrigger = (Trigger*)sqliteMalloc(sizeof(Trigger));  if( pTrigger==0 ) goto trigger_cleanup;  pTrigger->name = zName;  zName = 0;  pTrigger->table = sqliteStrDup(pTableName->a[0].zName);  if( sqlite3_malloc_failed ) goto trigger_cleanup;  pTrigger->iDb = iDb;  pTrigger->iTabDb = pTab->iDb;  pTrigger->op = op;  pTrigger->tr_tm = tr_tm;  pTrigger->pWhen = sqlite3ExprDup(pWhen);  pTrigger->pColumns = sqlite3IdListDup(pColumns);  pTrigger->foreach = foreach;  sqlite3TokenCopy(&pTrigger->nameToken,pName);  assert( pParse->pNewTrigger==0 );  pParse->pNewTrigger = pTrigger;trigger_cleanup:  sqliteFree(zName);  sqlite3SrcListDelete(pTableName);  sqlite3IdListDelete(pColumns);  sqlite3ExprDelete(pWhen);}

//.........这里部分代码省略.........    */    if( triggers_exist ){      sqlite3VdbeAddOp(v, OP_OpenPseudo, oldIdx, 0);      sqlite3VdbeAddOp(v, OP_SetNumColumns, oldIdx, pTab->nCol);    }    /* 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.    */    sqlite3VdbeAddOp(v, OP_ListRewind, 0, 0);    end = sqlite3VdbeMakeLabel(v);    /* This is the beginning of the delete loop when there are    ** row triggers.    */    if( triggers_exist ){      addr = sqlite3VdbeAddOp(v, OP_ListRead, 0, end);      if( !isView ){        sqlite3VdbeAddOp(v, OP_Dup, 0, 0);        sqlite3OpenTableForReading(v, iCur, pTab);      }      sqlite3VdbeAddOp(v, OP_MoveGe, iCur, 0);      sqlite3VdbeAddOp(v, OP_Recno, iCur, 0);      sqlite3VdbeAddOp(v, OP_RowData, iCur, 0);      sqlite3VdbeAddOp(v, OP_PutIntKey, oldIdx, 0);      if( !isView ){        sqlite3VdbeAddOp(v, OP_Close, iCur, 0);      }      (void)sqlite3CodeRowTrigger(pParse, TK_DELETE, 0, TRIGGER_BEFORE, pTab,          -1, oldIdx, (pParse->trigStack)?pParse->trigStack->orconf:OE_Default,          addr);    }    if( !isView ){      /* Open cursors for the table we are deleting from and all its      ** indices.  If there are row triggers, this happens inside the      ** OP_ListRead loop because the cursor have to all be closed      ** before the trigger fires.  If there are no row triggers, the      ** cursors are opened only once on the outside the loop.      */      sqlite3OpenTableAndIndices(pParse, pTab, iCur, OP_OpenWrite);      /* This is the beginning of the delete loop when there are no      ** row triggers */      if( !triggers_exist ){         addr = sqlite3VdbeAddOp(v, OP_ListRead, 0, end);      }      /* Delete the row */      sqlite3GenerateRowDelete(db, v, pTab, iCur, pParse->nested==0);    }    /* If there are row triggers, close all cursors then invoke    ** the AFTER triggers    */    if( triggers_exist ){      if( !isView ){        for(i=1, pIdx=pTab->pIndex; pIdx; i++, pIdx=pIdx->pNext){          sqlite3VdbeAddOp(v, OP_Close, iCur + i, pIdx->tnum);        }        sqlite3VdbeAddOp(v, OP_Close, iCur, 0);      }      (void)sqlite3CodeRowTrigger(pParse, TK_DELETE, 0, TRIGGER_AFTER, pTab, -1,          oldIdx, (pParse->trigStack)?pParse->trigStack->orconf:OE_Default,          addr);    }    /* End of the delete loop */    sqlite3VdbeAddOp(v, OP_Goto, 0, addr);    sqlite3VdbeResolveLabel(v, end);    sqlite3VdbeAddOp(v, OP_ListReset, 0, 0);    /* Close the cursors after the loop if there are no row triggers */    if( !triggers_exist ){      for(i=1, pIdx=pTab->pIndex; pIdx; i++, pIdx=pIdx->pNext){        sqlite3VdbeAddOp(v, OP_Close, iCur + i, pIdx->tnum);      }      sqlite3VdbeAddOp(v, OP_Close, iCur, 0);    }  }  /*  ** 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==0 && !pParse->trigStack ){    sqlite3VdbeAddOp(v, OP_Callback, 1, 0);    sqlite3VdbeSetNumCols(v, 1);    sqlite3VdbeSetColName(v, 0, "rows deleted", P3_STATIC);  }delete_from_cleanup:  sqlite3AuthContextPop(&sContext);  sqlite3SrcListDelete(pTabList);  sqlite3ExprDelete(pWhere);  return;}

//.........这里部分代码省略.........        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;}

/*** This procedure generates VDBE code for a single invocation of either the** sqlite_detach() or sqlite_attach() SQL user functions.*/static void codeAttach(  Parse *pParse,       /* The parser context */  int type,            /* Either SQLITE_ATTACH or SQLITE_DETACH */  const char *zFunc,   /* Either "sqlite_attach" or "sqlite_detach */  int nFunc,           /* Number of args to pass to zFunc */  Expr *pAuthArg,      /* Expression to pass to authorization callback */  Expr *pFilename,     /* Name of database file */  Expr *pDbname,       /* Name of the database to use internally */  Expr *pKey           /* Database key for encryption extension */){  int rc;  NameContext sName;  Vdbe *v;  FuncDef *pFunc;  sqlite3* db = pParse->db;#ifndef SQLITE_OMIT_AUTHORIZATION  assert( sqlite3ThreadDataReadOnly()->mallocFailed || pAuthArg );  if( pAuthArg ){    char *zAuthArg = sqlite3NameFromToken(&pAuthArg->span);    if( !zAuthArg ){      goto attach_end;    }    rc = sqlite3AuthCheck(pParse, type, zAuthArg, 0, 0);    sqliteFree(zAuthArg);    if(rc!=SQLITE_OK ){      goto attach_end;    }  }#endif /* SQLITE_OMIT_AUTHORIZATION */  memset(&sName, 0, sizeof(NameContext));  sName.pParse = pParse;  if(       SQLITE_OK!=(rc = resolveAttachExpr(&sName, pFilename)) ||      SQLITE_OK!=(rc = resolveAttachExpr(&sName, pDbname)) ||      SQLITE_OK!=(rc = resolveAttachExpr(&sName, pKey))  ){    pParse->nErr++;    goto attach_end;  }  v = sqlite3GetVdbe(pParse);  sqlite3ExprCode(pParse, pFilename);  sqlite3ExprCode(pParse, pDbname);  sqlite3ExprCode(pParse, pKey);  assert(v || sqlite3ThreadDataReadOnly()->mallocFailed);  if( v ){    sqlite3VdbeAddOp(v, OP_Function, 0, nFunc);    pFunc = sqlite3FindFunction(db, zFunc, strlen(zFunc), nFunc, SQLITE_UTF8,0);    sqlite3VdbeChangeP3(v, -1, (char *)pFunc, P3_FUNCDEF);    /* Code an OP_Expire. For an ATTACH statement, set P1 to true (expire this    ** statement only). For DETACH, set it to false (expire all existing    ** statements).    */    sqlite3VdbeAddOp(v, OP_Expire, (type==SQLITE_ATTACH), 0);  }  attach_end:  sqlite3ExprDelete(pFilename);  sqlite3ExprDelete(pDbname);  sqlite3ExprDelete(pKey);}

//.........这里部分代码省略.........    ** some of the columns of the row being updated. Load the values for     ** all columns not modified by the update statement into their     ** registers in case this has happened.    */    for(i=0; i<pTab->nCol; i++){      if( aXRef[i]<0 && i!=pTab->iPKey ){        sqlite3VdbeAddOp3(v, OP_Column, iCur, i, regNew+i);        sqlite3ColumnDefault(v, pTab, i, regNew+i);      }    }  }  if( !isView ){    int j1;                       /* Address of jump instruction */    /* Do constraint checks. */    sqlite3GenerateConstraintChecks(pParse, pTab, iCur, regNewRowid,        aRegIdx, (chngRowid?regOldRowid:0), 1, onError, addr, 0);    /* Do FK constraint checks. */    if( hasFK ){      sqlite3FkCheck(pParse, pTab, regOldRowid, 0);    }    /* Delete the index entries associated with the current record.  */    j1 = sqlite3VdbeAddOp3(v, OP_NotExists, iCur, 0, regOldRowid);    sqlite3GenerateRowIndexDelete(pParse, pTab, iCur, aRegIdx);      /* If changing the record number, delete the old record.  */    if( hasFK || chngRowid ){      sqlite3VdbeAddOp2(v, OP_Delete, iCur, 0);    }    sqlite3VdbeJumpHere(v, j1);    if( hasFK ){      sqlite3FkCheck(pParse, pTab, 0, regNewRowid);    }      /* Insert the new index entries and the new record. */    sqlite3CompleteInsertion(pParse, pTab, iCur, 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);    }  }  /* 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, addr);  /* Repeat the above with the next record to be updated, until  ** all record selected by the WHERE clause have been updated.  */  sqlite3VdbeAddOp2(v, OP_Goto, 0, addr);  sqlite3VdbeJumpHere(v, addr);  /* Close all tables */  for(i=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, i++){    if( openAll || aRegIdx[i]>0 ){      sqlite3VdbeAddOp2(v, OP_Close, iCur+i+1, 0);    }  }  sqlite3VdbeAddOp2(v, OP_Close, iCur, 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, aRegIdx);  sqlite3DbFree(db, aXRef);  sqlite3SrcListDelete(db, pTabList);  sqlite3ExprListDelete(db, pChanges);  sqlite3ExprDelete(db, pWhere);  return;}

static void codeAttach(  Parse *pParse,         int type,              FuncDef const *pFunc,  Expr *pAuthArg,        Expr *pFilename,       Expr *pDbname,         Expr *pKey           ){  int rc;  NameContext sName;  Vdbe *v;  sqlite3* db = pParse->db;  int regArgs;  memset(&sName, 0, sizeof(NameContext));  sName.pParse = pParse;  if(       SQLITE_OK!=(rc = resolveAttachExpr(&sName, pFilename)) ||      SQLITE_OK!=(rc = resolveAttachExpr(&sName, pDbname)) ||      SQLITE_OK!=(rc = resolveAttachExpr(&sName, pKey))  ){    pParse->nErr++;    goto attach_end;  }#ifndef SQLITE_OMIT_AUTHORIZATION  if( pAuthArg ){    char *zAuthArg;    if( pAuthArg->op==TK_STRING ){      zAuthArg = pAuthArg->u.zToken;    }else{      zAuthArg = 0;    }    rc = sqlite3AuthCheck(pParse, type, zAuthArg, 0, 0);    if(rc!=SQLITE_OK ){      goto attach_end;    }  }#endif   v = sqlite3GetVdbe(pParse);  regArgs = sqlite3GetTempRange(pParse, 4);  sqlite3ExprCode(pParse, pFilename, regArgs);  sqlite3ExprCode(pParse, pDbname, regArgs+1);  sqlite3ExprCode(pParse, pKey, regArgs+2);  assert( v || db->mallocFailed );  if( v ){    sqlite3VdbeAddOp3(v, OP_Function, 0, regArgs+3-pFunc->nArg, regArgs+3);    assert( pFunc->nArg==-1 || (pFunc->nArg&0xff)==pFunc->nArg );    sqlite3VdbeChangeP5(v, (u8)(pFunc->nArg));    sqlite3VdbeChangeP4(v, -1, (char *)pFunc, P4_FUNCDEF);    sqlite3VdbeAddOp1(v, OP_Expire, (type==SQLITE_ATTACH));  }  attach_end:  sqlite3ExprDelete(db, pFilename);  sqlite3ExprDelete(db, pDbname);  sqlite3ExprDelete(db, pKey);}

//.........这里部分代码省略.........    ** will be after the update. (The old record number is currently    ** on top of the stack.)    */    if( chngRowid ){      sqlite3ExprCode(pParse, pRowidExpr, regNewRowid);      sqlite3VdbeAddOp1(v, OP_MustBeInt, regNewRowid);    }    /* Compute new data for this record.      */    for(i=0; i<pTab->nCol; i++){      if( i==pTab->iPKey ){        sqlite3VdbeAddOp2(v, OP_Null, 0, regData+i);        continue;      }      j = aXRef[i];      if( j<0 ){        sqlite3VdbeAddOp3(v, OP_Column, iCur, i, regData+i);        sqlite3ColumnDefault(v, pTab, i);      }else{        sqlite3ExprCode(pParse, pChanges->a[j].pExpr, regData+i);      }    }    /* Do constraint checks    */    sqlite3GenerateConstraintChecks(pParse, pTab, iCur, regNewRowid,                                    aRegIdx, chngRowid, 1,                                    onError, addr);    /* Delete the old indices for the current record.    */    j1 = sqlite3VdbeAddOp3(v, OP_NotExists, iCur, 0, regOldRowid);    sqlite3GenerateRowIndexDelete(pParse, pTab, iCur, aRegIdx);    /* If changing the record number, delete the old record.    */    if( chngRowid ){      sqlite3VdbeAddOp2(v, OP_Delete, iCur, 0);    }    sqlite3VdbeJumpHere(v, j1);    /* Create the new index entries and the new record.    */    sqlite3CompleteInsertion(pParse, pTab, iCur, regNewRowid,                              aRegIdx, 1, -1, 0);  }  /* Increment the row counter   */  if( db->flags & SQLITE_CountRows && !pParse->trigStack){    sqlite3VdbeAddOp2(v, OP_AddImm, regRowCount, 1);  }  /* If there are triggers, close all the cursors after each iteration  ** through the loop.  The fire the after triggers.  */  if( triggers_exist ){    sqlite3VdbeAddOp2(v, OP_Goto, 0, iBeginAfterTrigger);    sqlite3VdbeJumpHere(v, iEndAfterTrigger);  }  /* Repeat the above with the next record to be updated, until  ** all record selected by the WHERE clause have been updated.  */  sqlite3VdbeAddOp2(v, OP_Goto, 0, addr);  sqlite3VdbeJumpHere(v, addr);  /* Close all tables */  for(i=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, i++){    if( openAll || aRegIdx[i]>0 ){      sqlite3VdbeAddOp2(v, OP_Close, iCur+i+1, 0);    }  }  sqlite3VdbeAddOp2(v, OP_Close, iCur, 0);  if( triggers_exist ){    sqlite3VdbeAddOp2(v, OP_Close, newIdx, 0);    sqlite3VdbeAddOp2(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 ){    sqlite3VdbeAddOp2(v, OP_ResultRow, regRowCount, 1);    sqlite3VdbeSetNumCols(v, 1);    sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "rows updated", SQLITE_STATIC);  }update_cleanup:  sqlite3AuthContextPop(&sContext);  sqlite3DbFree(db, aRegIdx);  sqlite3DbFree(db, aXRef);  sqlite3SrcListDelete(db, pTabList);  sqlite3ExprListDelete(db, pChanges);  sqlite3ExprDelete(db, pWhere);  return;}

//.........这里部分代码省略.........          pNew = sqlite3PExpr(pParse, TK_DOT,             sqlite3PExpr(pParse, TK_ID, 0, 0, &tNew),            sqlite3PExpr(pParse, TK_ID, 0, 0, &tToCol)          , 0);        }else if( action==OE_SetDflt ){          Expr *pDflt = pFKey->pFrom->aCol[iFromCol].pDflt;          if( pDflt ){            pNew = sqlite3ExprDup(db, pDflt, 0);          }else{            pNew = sqlite3PExpr(pParse, TK_NULL, 0, 0, 0);          }        }else{          pNew = sqlite3PExpr(pParse, TK_NULL, 0, 0, 0);        }        pList = sqlite3ExprListAppend(pParse, pList, pNew);        sqlite3ExprListSetName(pParse, pList, &tFromCol, 0);      }    }    sqlite3DbFree(db, aiCol);    zFrom = pFKey->pFrom->zName;    nFrom = sqlite3Strlen30(zFrom);    if( action==OE_Restrict ){      Token tFrom;      Expr *pRaise;       tFrom.z = zFrom;      tFrom.n = nFrom;      pRaise = sqlite3Expr(db, TK_RAISE, "foreign key constraint failed");      if( pRaise ){        pRaise->affinity = OE_Abort;      }      pSelect = sqlite3SelectNew(pParse,           sqlite3ExprListAppend(pParse, 0, pRaise),          sqlite3SrcListAppend(db, 0, &tFrom, 0),          pWhere,          0, 0, 0, 0, 0, 0      );      pWhere = 0;    }    /* Disable lookaside memory allocation */    enableLookaside = db->lookaside.bEnabled;    db->lookaside.bEnabled = 0;    pTrigger = (Trigger *)sqlite3DbMallocZero(db,         sizeof(Trigger) +         /* struct Trigger */        sizeof(TriggerStep) +     /* Single step in trigger program */        nFrom + 1                 /* Space for pStep->target.z */    );    if( pTrigger ){      pStep = pTrigger->step_list = (TriggerStep *)&pTrigger[1];      pStep->target.z = (char *)&pStep[1];      pStep->target.n = nFrom;      memcpy((char *)pStep->target.z, zFrom, nFrom);        pStep->pWhere = sqlite3ExprDup(db, pWhere, EXPRDUP_REDUCE);      pStep->pExprList = sqlite3ExprListDup(db, pList, EXPRDUP_REDUCE);      pStep->pSelect = sqlite3SelectDup(db, pSelect, EXPRDUP_REDUCE);      if( pWhen ){        pWhen = sqlite3PExpr(pParse, TK_NOT, pWhen, 0, 0);        pTrigger->pWhen = sqlite3ExprDup(db, pWhen, EXPRDUP_REDUCE);      }    }    /* Re-enable the lookaside buffer, if it was disabled earlier. */    db->lookaside.bEnabled = enableLookaside;    sqlite3ExprDelete(db, pWhere);    sqlite3ExprDelete(db, pWhen);    sqlite3ExprListDelete(db, pList);    sqlite3SelectDelete(db, pSelect);    if( db->mallocFailed==1 ){      fkTriggerDelete(db, pTrigger);      return 0;    }    assert( pStep!=0 );    switch( action ){      case OE_Restrict:        pStep->op = TK_SELECT;         break;      case OE_Cascade:         if( !pChanges ){           pStep->op = TK_DELETE;           break;         }      default:        pStep->op = TK_UPDATE;    }    pStep->pTrig = pTrigger;    pTrigger->pSchema = pTab->pSchema;    pTrigger->pTabSchema = pTab->pSchema;    pFKey->apTrigger[iAction] = pTrigger;    pTrigger->op = (pChanges ? TK_UPDATE : TK_DELETE);  }  return pTrigger;}

//.........这里部分代码省略.........){  sqlite3 *db = pParse->db;       /* Database handle */  int i;                          /* Iterator variable */  Expr *pWhere = 0;               /* WHERE clause to scan with */  NameContext sNameContext;       /* Context used to resolve WHERE clause */  WhereInfo *pWInfo;              /* Context used by sqlite3WhereXXX() */  int iFkIfZero = 0;              /* Address of OP_FkIfZero */  Vdbe *v = sqlite3GetVdbe(pParse);  assert( !pIdx || pIdx->pTable==pTab );  if( nIncr<0 ){    iFkIfZero = sqlite3VdbeAddOp2(v, OP_FkIfZero, pFKey->isDeferred, 0);  }  /* Create an Expr object representing an SQL expression like:  **  **   <parent-key1> = <child-key1> AND <parent-key2> = <child-key2> ...  **  ** The collation sequence used for the comparison should be that of  ** the parent key columns. The affinity of the parent key column should  ** be applied to each child key value before the comparison takes place.  */  for(i=0; i<pFKey->nCol; i++){    Expr *pLeft;                  /* Value from parent table row */    Expr *pRight;                 /* Column ref to child table */    Expr *pEq;                    /* Expression (pLeft = pRight) */    int iCol;                     /* Index of column in child table */     const char *zCol;             /* Name of column in child table */    pLeft = sqlite3Expr(db, TK_REGISTER, 0);    if( pLeft ){      /* Set the collation sequence and affinity of the LHS of each TK_EQ      ** expression to the parent key column defaults.  */      if( pIdx ){        Column *pCol;        iCol = pIdx->aiColumn[i];        pCol = &pTab->aCol[iCol];        if( pTab->iPKey==iCol ) iCol = -1;        pLeft->iTable = regData+iCol+1;        pLeft->affinity = pCol->affinity;        pLeft->pColl = sqlite3LocateCollSeq(pParse, pCol->zColl);      }else{        pLeft->iTable = regData;        pLeft->affinity = SQLITE_AFF_INTEGER;      }    }    iCol = aiCol ? aiCol[i] : pFKey->aCol[0].iFrom;    assert( iCol>=0 );    zCol = pFKey->pFrom->aCol[iCol].zName;    pRight = sqlite3Expr(db, TK_ID, zCol);    pEq = sqlite3PExpr(pParse, TK_EQ, pLeft, pRight, 0);    pWhere = sqlite3ExprAnd(db, pWhere, pEq);  }  /* If the child table is the same as the parent table, and this scan  ** is taking place as part of a DELETE operation (operation D.2), omit the  ** row being deleted from the scan by adding ($rowid != rowid) to the WHERE   ** clause, where $rowid is the rowid of the row being deleted.  */  if( pTab==pFKey->pFrom && nIncr>0 ){    Expr *pEq;                    /* Expression (pLeft = pRight) */    Expr *pLeft;                  /* Value from parent table row */    Expr *pRight;                 /* Column ref to child table */    pLeft = sqlite3Expr(db, TK_REGISTER, 0);    pRight = sqlite3Expr(db, TK_COLUMN, 0);    if( pLeft && pRight ){      pLeft->iTable = regData;      pLeft->affinity = SQLITE_AFF_INTEGER;      pRight->iTable = pSrc->a[0].iCursor;      pRight->iColumn = -1;    }    pEq = sqlite3PExpr(pParse, TK_NE, pLeft, pRight, 0);    pWhere = sqlite3ExprAnd(db, pWhere, pEq);  }  /* Resolve the references in the WHERE clause. */  memset(&sNameContext, 0, sizeof(NameContext));  sNameContext.pSrcList = pSrc;  sNameContext.pParse = pParse;  sqlite3ResolveExprNames(&sNameContext, pWhere);  /* Create VDBE to loop through the entries in pSrc that match the WHERE  ** clause. If the constraint is not deferred, throw an exception for  ** each row found. Otherwise, for deferred constraints, increment the  ** deferred constraint counter by nIncr for each row selected.  */  pWInfo = sqlite3WhereBegin(pParse, pSrc, pWhere, 0, 0, 0);  if( nIncr>0 && pFKey->isDeferred==0 ){    sqlite3ParseToplevel(pParse)->mayAbort = 1;  }  sqlite3VdbeAddOp2(v, OP_FkCounter, pFKey->isDeferred, nIncr);  if( pWInfo ){    sqlite3WhereEnd(pWInfo);  }  /* Clean up the WHERE clause constructed above. */  sqlite3ExprDelete(db, pWhere);  if( iFkIfZero ){    sqlite3VdbeJumpHere(v, iFkIfZero);  }}

/*** The input to this routine is an WhereTerm structure with only the** "pExpr" field filled in.  The job of this routine is to analyze the** subexpression and populate all the other fields of the WhereTerm** structure.**** If the expression is of the form "<expr> <op> X" it gets commuted** to the standard form of "X <op> <expr>".**** If the expression is of the form "X <op> Y" where both X and Y are** columns, then the original expression is unchanged and a new virtual** term of the form "Y <op> X" is added to the WHERE clause and** analyzed separately.  The original term is marked with TERM_COPIED** and the new term is marked with TERM_DYNAMIC (because it's pExpr** needs to be freed with the WhereClause) and TERM_VIRTUAL (because it** is a commuted copy of a prior term.)  The original term has nChild=1** and the copy has idxParent set to the index of the original term.*/static void exprAnalyze(  SrcList *pSrc,            /* the FROM clause */  WhereClause *pWC,         /* the WHERE clause */  int idxTerm               /* Index of the term to be analyzed */){  WhereInfo *pWInfo = pWC->pWInfo; /* WHERE clause processing context */  WhereTerm *pTerm;                /* The term to be analyzed */  WhereMaskSet *pMaskSet;          /* Set of table index masks */  Expr *pExpr;                     /* The expression to be analyzed */  Bitmask prereqLeft;              /* Prerequesites of the pExpr->pLeft */  Bitmask prereqAll;               /* Prerequesites of pExpr */  Bitmask extraRight = 0;          /* Extra dependencies on LEFT JOIN */  Expr *pStr1 = 0;                 /* RHS of LIKE/GLOB operator */  int isComplete = 0;              /* RHS of LIKE/GLOB ends with wildcard */  int noCase = 0;                  /* uppercase equivalent to lowercase */  int op;                          /* Top-level operator.  pExpr->op */  Parse *pParse = pWInfo->pParse;  /* Parsing context */  sqlite3 *db = pParse->db;        /* Database connection */  if( db->mallocFailed ){    return;  }  pTerm = &pWC->a[idxTerm];  pMaskSet = &pWInfo->sMaskSet;  pExpr = pTerm->pExpr;  assert( pExpr->op!=TK_AS && pExpr->op!=TK_COLLATE );  prereqLeft = sqlite3WhereExprUsage(pMaskSet, pExpr->pLeft);  op = pExpr->op;  if( op==TK_IN ){    assert( pExpr->pRight==0 );    if( ExprHasProperty(pExpr, EP_xIsSelect) ){      pTerm->prereqRight = exprSelectUsage(pMaskSet, pExpr->x.pSelect);    }else{      pTerm->prereqRight = sqlite3WhereExprListUsage(pMaskSet, pExpr->x.pList);    }  }else if( op==TK_ISNULL ){    pTerm->prereqRight = 0;  }else{    pTerm->prereqRight = sqlite3WhereExprUsage(pMaskSet, pExpr->pRight);  }  prereqAll = sqlite3WhereExprUsage(pMaskSet, pExpr);  if( ExprHasProperty(pExpr, EP_FromJoin) ){    Bitmask x = sqlite3WhereGetMask(pMaskSet, pExpr->iRightJoinTable);    prereqAll |= x;    extraRight = x-1;  /* ON clause terms may not be used with an index                       ** on left table of a LEFT JOIN.  Ticket #3015 */  }  pTerm->prereqAll = prereqAll;  pTerm->leftCursor = -1;  pTerm->iParent = -1;  pTerm->eOperator = 0;  if( allowedOp(op) ){    Expr *pLeft = sqlite3ExprSkipCollate(pExpr->pLeft);    Expr *pRight = sqlite3ExprSkipCollate(pExpr->pRight);    u16 opMask = (pTerm->prereqRight & prereqLeft)==0 ? WO_ALL : WO_EQUIV;    if( pLeft->op==TK_COLUMN ){      pTerm->leftCursor = pLeft->iTable;      pTerm->u.leftColumn = pLeft->iColumn;      pTerm->eOperator = operatorMask(op) & opMask;    }    if( op==TK_IS ) pTerm->wtFlags |= TERM_IS;    if( pRight && pRight->op==TK_COLUMN ){      WhereTerm *pNew;      Expr *pDup;      u16 eExtraOp = 0;        /* Extra bits for pNew->eOperator */      if( pTerm->leftCursor>=0 ){        int idxNew;        pDup = sqlite3ExprDup(db, pExpr, 0);        if( db->mallocFailed ){          sqlite3ExprDelete(db, pDup);          return;        }        idxNew = whereClauseInsert(pWC, pDup, TERM_VIRTUAL|TERM_DYNAMIC);        if( idxNew==0 ) return;        pNew = &pWC->a[idxNew];        markTermAsChild(pWC, idxNew, idxTerm);        if( op==TK_IS ) pNew->wtFlags |= TERM_IS;        pTerm = &pWC->a[idxTerm];        pTerm->wtFlags |= TERM_COPIED;        if( termIsEquivalence(pParse, pDup) ){          pTerm->eOperator |= WO_EQUIV;//.........这里部分代码省略.........

/* ** 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( 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#endif      {        sqlite3GenerateRowDelete(pParse, pTab, iCur, iRowid, pParse->nested==0);      }    }    /* If there are row triggers, close all cursors then invoke    ** the AFTER triggers    */    if( triggers_exist ){      /* Jump back and run the AFTER triggers */      sqlite3VdbeAddOp2(v, OP_Goto, 0, iBeginAfterTrigger);      sqlite3VdbeJumpHere(v, iEndAfterTrigger);    }    /* End of the delete loop */    sqlite3VdbeAddOp2(v, OP_Goto, 0, addr);    sqlite3VdbeResolveLabel(v, end);    /* Close the cursors after the loop if there are no row triggers */    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);    }  }  /*  ** 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==0 && !pParse->trigStack ){    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;}

/*** Generate an expression tree to implement the WHERE, ORDER BY,** and LIMIT/OFFSET portion of DELETE and UPDATE statements.****     DELETE FROM table_wxyz WHERE a<5 ORDER BY a LIMIT 1;**                            /__________________________/**                               pLimitWhere (pInClause)*/Expr *sqlite3LimitWhere(  Parse *pParse,               /* The parser context */  SrcList *pSrc,               /* the FROM clause -- which tables to scan */  Expr *pWhere,                /* The WHERE clause.  May be null */  ExprList *pOrderBy,          /* The ORDER BY clause.  May be null */  Expr *pLimit,                /* The LIMIT clause.  May be null */  char *zStmtType              /* Either DELETE or UPDATE.  For err msgs. */){  sqlite3 *db = pParse->db;  Expr *pLhs = NULL;           /* LHS of IN(SELECT...) operator */  Expr *pInClause = NULL;      /* WHERE rowid IN ( select ) */  ExprList *pEList = NULL;     /* Expression list contaning only pSelectRowid */  SrcList *pSelectSrc = NULL;  /* SELECT rowid FROM x ... (dup of pSrc) */  Select *pSelect = NULL;      /* Complete SELECT tree */  Table *pTab;  /* Check that there isn't an ORDER BY without a LIMIT clause.  */  if( pOrderBy && pLimit==0 ) {    sqlite3ErrorMsg(pParse, "ORDER BY without LIMIT on %s", zStmtType);    sqlite3ExprDelete(pParse->db, pWhere);    sqlite3ExprListDelete(pParse->db, pOrderBy);    return 0;  }  /* We only need to generate a select expression if there  ** is a limit/offset term to enforce.  */  if( pLimit == 0 ) {    return pWhere;  }  /* Generate a select expression tree to enforce the limit/offset   ** term for the DELETE or UPDATE statement.  For example:  **   DELETE FROM table_a WHERE col1=1 ORDER BY col2 LIMIT 1 OFFSET 1  ** becomes:  **   DELETE FROM table_a WHERE rowid IN (   **     SELECT rowid FROM table_a WHERE col1=1 ORDER BY col2 LIMIT 1 OFFSET 1  **   );  */  pTab = pSrc->a[0].pTab;  if( HasRowid(pTab) ){    pLhs = sqlite3PExpr(pParse, TK_ROW, 0, 0);    pEList = sqlite3ExprListAppend(        pParse, 0, sqlite3PExpr(pParse, TK_ROW, 0, 0)    );  }else{    Index *pPk = sqlite3PrimaryKeyIndex(pTab);    if( pPk->nKeyCol==1 ){      const char *zName = pTab->aCol[pPk->aiColumn[0]].zName;      pLhs = sqlite3Expr(db, TK_ID, zName);      pEList = sqlite3ExprListAppend(pParse, 0, sqlite3Expr(db, TK_ID, zName));    }else{      int i;      for(i=0; i<pPk->nKeyCol; i++){        Expr *p = sqlite3Expr(db, TK_ID, pTab->aCol[pPk->aiColumn[i]].zName);        pEList = sqlite3ExprListAppend(pParse, pEList, p);      }      pLhs = sqlite3PExpr(pParse, TK_VECTOR, 0, 0);      if( pLhs ){        pLhs->x.pList = sqlite3ExprListDup(db, pEList, 0);      }    }  }  /* duplicate the FROM clause as it is needed by both the DELETE/UPDATE tree  ** and the SELECT subtree. */  pSrc->a[0].pTab = 0;  pSelectSrc = sqlite3SrcListDup(pParse->db, pSrc, 0);  pSrc->a[0].pTab = pTab;  pSrc->a[0].pIBIndex = 0;  /* generate the SELECT expression tree. */  pSelect = sqlite3SelectNew(pParse, pEList, pSelectSrc, pWhere, 0 ,0,       pOrderBy,0,pLimit  );  /* now generate the new WHERE rowid IN clause for the DELETE/UDPATE */  pInClause = sqlite3PExpr(pParse, TK_IN, pLhs, 0);  sqlite3PExprAddSelect(pParse, pInClause, pSelect);  return pInClause;}

//.........这里部分代码省略.........      j = aXRef[i];      if( j>=0 ){        sqlite3ExprCode(pParse, pChanges->a[j].pExpr, regNew+i);      }else if( 0==(tmask&TRIGGER_BEFORE) || i>31 || (newmask&(1<<i)) ){        testcase( i==31 );        testcase( i==32 );        sqlite3VdbeAddOp3(v, OP_Column, iCur, i, regNew+i);        sqlite3ColumnDefault(v, pTab, i, regNew+i);      }    }  }  if( tmask&TRIGGER_BEFORE ){    sqlite3VdbeAddOp2(v, OP_Affinity, regNew, pTab->nCol);    sqlite3TableAffinityStr(v, pTab);    sqlite3CodeRowTrigger(pParse, pTrigger, TK_UPDATE, pChanges,         TRIGGER_BEFORE, pTab, regOldRowid, onError, addr);    sqlite3VdbeAddOp3(v, OP_NotExists, iCur, addr, regOldRowid);    for(i=0; i<pTab->nCol; i++){      if( aXRef[i]<0 && i!=pTab->iPKey ){        sqlite3VdbeAddOp3(v, OP_Column, iCur, i, regNew+i);        sqlite3ColumnDefault(v, pTab, i, regNew+i);      }    }  }  if( !isView ){    int j1;                               sqlite3GenerateConstraintChecks(pParse, pTab, iCur, regNewRowid,        aRegIdx, (chngRowid?regOldRowid:0), 1, onError, addr, 0);        if( hasFK ){      sqlite3FkCheck(pParse, pTab, regOldRowid, 0);    }        j1 = sqlite3VdbeAddOp3(v, OP_NotExists, iCur, 0, regOldRowid);    sqlite3GenerateRowIndexDelete(pParse, pTab, iCur, aRegIdx);          if( hasFK || chngRowid ){      sqlite3VdbeAddOp2(v, OP_Delete, iCur, 0);    }    sqlite3VdbeJumpHere(v, j1);    if( hasFK ){      sqlite3FkCheck(pParse, pTab, 0, regNewRowid);    }          sqlite3CompleteInsertion(pParse, pTab, iCur, regNewRowid, aRegIdx, 1, 0, 0);     if( hasFK ){      sqlite3FkActions(pParse, pTab, pChanges, regOldRowid);    }  }  if( (db->flags & SQLITE_CountRows) && !pParse->pTriggerTab){    sqlite3VdbeAddOp2(v, OP_AddImm, regRowCount, 1);  }  sqlite3CodeRowTrigger(pParse, pTrigger, TK_UPDATE, pChanges,       TRIGGER_AFTER, pTab, regOldRowid, onError, addr);  sqlite3VdbeAddOp2(v, OP_Goto, 0, addr);  sqlite3VdbeJumpHere(v, addr);    for(i=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, i++){    if( openAll || aRegIdx[i]>0 ){      sqlite3VdbeAddOp2(v, OP_Close, iCur+i+1, 0);    }  }  sqlite3VdbeAddOp2(v, OP_Close, iCur, 0);  if( pParse->nested==0 && pParse->pTriggerTab==0 ){    sqlite3AutoincrementEnd(pParse);  }  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, aRegIdx);  sqlite3DbFree(db, aXRef);  sqlite3SrcListDelete(db, pTabList);  sqlite3ExprListDelete(db, pChanges);  sqlite3ExprDelete(db, pWhere);  return;}

//.........这里部分代码省略.........   && 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;}

//.........这里部分代码省略.........        if( zAs!=0 && sqlite3StrICmp(zAs, zCol)==0 ){          Expr *pOrig;          assert( pExpr->pLeft==0 && pExpr->pRight==0 );          assert( pExpr->x.pList==0 );          assert( pExpr->x.pSelect==0 );          pOrig = pEList->a[j].pExpr;          if( !pNC->allowAgg && ExprHasProperty(pOrig, EP_Agg) ){            sqlite3ErrorMsg(pParse, "misuse of aliased aggregate %s", zAs);            return WRC_Abort;          }          resolveAlias(pParse, pEList, j, pExpr, "");          cnt = 1;          pMatch = 0;          assert( zTab==0 && zDb==0 );          goto lookupname_end;        }      }     }    /* Advance to the next name context.  The loop will exit when either    ** we have a match (cnt>0) or when we run out of name contexts.    */    if( cnt==0 ){      pNC = pNC->pNext;    }  }  /*  ** If X and Y are NULL (in other words if only the column name Z is  ** supplied) and the value of Z is enclosed in double-quotes, then  ** Z is a string literal if it doesn't match any column names.  In that  ** case, we need to return right away and not make any changes to  ** pExpr.  **  ** Because no reference was made to outer contexts, the pNC->nRef  ** fields are not changed in any context.  */  if( cnt==0 && zTab==0 && ExprHasProperty(pExpr,EP_DblQuoted) ){    pExpr->op = TK_STRING;    pExpr->pTab = 0;    return WRC_Prune;  }  /*  ** cnt==0 means there was not match.  cnt>1 means there were two or  ** more matches.  Either way, we have an error.  */  if( cnt!=1 ){    const char *zErr;    zErr = cnt==0 ? "no such column" : "ambiguous column name";    if( zDb ){      sqlite3ErrorMsg(pParse, "%s: %s.%s.%s", zErr, zDb, zTab, zCol);    }else if( zTab ){      sqlite3ErrorMsg(pParse, "%s: %s.%s", zErr, zTab, zCol);    }else{      sqlite3ErrorMsg(pParse, "%s: %s", zErr, zCol);    }    pTopNC->nErr++;  }  /* If a column from a table in pSrcList is referenced, then record  ** this fact in the pSrcList.a[].colUsed bitmask.  Column 0 causes  ** bit 0 to be set.  Column 1 sets bit 1.  And so forth.  If the  ** column number is greater than the number of bits in the bitmask  ** then set the high-order bit of the bitmask.  */  if( pExpr->iColumn>=0 && pMatch!=0 ){    int n = pExpr->iColumn;    testcase( n==BMS-1 );    if( n>=BMS ){      n = BMS-1;    }    assert( pMatch->iCursor==pExpr->iTable );    pMatch->colUsed |= ((Bitmask)1)<<n;  }  /* Clean up and return  */  sqlite3ExprDelete(db, pExpr->pLeft);  pExpr->pLeft = 0;  sqlite3ExprDelete(db, pExpr->pRight);  pExpr->pRight = 0;  pExpr->op = (isTrigger ? TK_TRIGGER : TK_COLUMN);lookupname_end:  if( cnt==1 ){    assert( pNC!=0 );    sqlite3AuthRead(pParse, pExpr, pSchema, pNC->pSrcList);    /* Increment the nRef value on all name contexts from TopNC up to    ** the point where the name matched. */    for(;;){      assert( pTopNC!=0 );      pTopNC->nRef++;      if( pTopNC==pNC ) break;      pTopNC = pTopNC->pNext;    }    return WRC_Prune;  } else {    return WRC_Abort;  }}

//.........这里部分代码省略.........    /* Compute new data for this record.      */    for(i=0; i<pTab->nCol; i++){      if( i==pTab->iPKey ){        sqlite3VdbeAddOp(v, OP_String8, 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, chngRecno, 1,                                   onError, addr);    /* Delete the old indices for the current record.    */    sqlite3GenerateRowIndexDelete(db, v, pTab, iCur, aIdxUsed);    /* If changing the record number, delete the old record.    */    if( chngRecno ){      sqlite3VdbeAddOp(v, OP_Delete, iCur, 0);    }    /* Create the new index entries and the new record.    */    sqlite3CompleteInsertion(pParse, pTab, iCur, aIdxUsed, chngRecno, 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);  sqlite3VdbeChangeP2(v, addr, sqlite3VdbeCurrentAddr(v));  sqlite3VdbeAddOp(v, OP_ListReset, 0, 0);  /* 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, "rows updated", P3_STATIC);  }update_cleanup:  sqlite3AuthContextPop(&sContext);  sqliteFree(apIdx);  sqliteFree(aXRef);  sqlite3SrcListDelete(pTabList);  sqlite3ExprListDelete(pChanges);  sqlite3ExprDelete(pWhere);  return;}

/*** Analyze the ORDER BY clause in a compound SELECT statement.   Modify** each term of the ORDER BY clause is a constant integer between 1** and N where N is the number of columns in the compound SELECT.**** ORDER BY terms that are already an integer between 1 and N are** unmodified.  ORDER BY terms that are integers outside the range of** 1 through N generate an error.  ORDER BY terms that are expressions** are matched against result set expressions of compound SELECT** beginning with the left-most SELECT and working toward the right.** At the first match, the ORDER BY expression is transformed into** the integer column number.**** Return the number of errors seen.*/static int resolveCompoundOrderBy(  Parse *pParse,        /* Parsing context.  Leave error messages here */  Select *pSelect       /* The SELECT statement containing the ORDER BY */){  int i;  ExprList *pOrderBy;  ExprList *pEList;  sqlite3 *db;  int moreToDo = 1;  pOrderBy = pSelect->pOrderBy;  if( pOrderBy==0 ) return 0;  db = pParse->db;#if SQLITE_MAX_COLUMN  if( pOrderBy->nExpr>db->aLimit[SQLITE_LIMIT_COLUMN] ){    sqlite3ErrorMsg(pParse, "too many terms in ORDER BY clause");    return 1;  }#endif  for(i=0; i<pOrderBy->nExpr; i++){    pOrderBy->a[i].done = 0;  }  pSelect->pNext = 0;  while( pSelect->pPrior ){    pSelect->pPrior->pNext = pSelect;    pSelect = pSelect->pPrior;  }  while( pSelect && moreToDo ){    struct ExprList_item *pItem;    moreToDo = 0;    pEList = pSelect->pEList;    assert( pEList!=0 );    for(i=0, pItem=pOrderBy->a; i<pOrderBy->nExpr; i++, pItem++){      int iCol = -1;      Expr *pE, *pDup;      if( pItem->done ) continue;      pE = pItem->pExpr;      if( sqlite3ExprIsInteger(pE, &iCol) ){        if( iCol<=0 || iCol>pEList->nExpr ){          resolveOutOfRangeError(pParse, "ORDER", i+1, pEList->nExpr);          return 1;        }      }else{        iCol = resolveAsName(pParse, pEList, pE);        if( iCol==0 ){          pDup = sqlite3ExprDup(db, pE, 0);          if( !db->mallocFailed ){            assert(pDup);            iCol = resolveOrderByTermToExprList(pParse, pSelect, pDup);          }          sqlite3ExprDelete(db, pDup);        }      }      if( iCol>0 ){        CollSeq *pColl = pE->pColl;        int flags = pE->flags & EP_ExpCollate;        sqlite3ExprDelete(db, pE);        pItem->pExpr = pE = sqlite3Expr(db, TK_INTEGER, 0);        if( pE==0 ) return 1;        pE->pColl = pColl;        pE->flags |= EP_IntValue | flags;        pE->u.iValue = iCol;        pItem->iCol = (u16)iCol;        pItem->done = 1;      }else{        moreToDo = 1;      }    }    pSelect = pSelect->pNext;  }  for(i=0; i<pOrderBy->nExpr; i++){    if( pOrderBy->a[i].done==0 ){      sqlite3ErrorMsg(pParse, "%r ORDER BY term does not match any "            "column in the result set", i+1);      return 1;    }  }  return 0;}

/*** This procedure generates VDBE code for a single invocation of either the** sqlite_detach() or sqlite_attach() SQL user functions.*/static void codeAttach(  Parse *pParse,       /* The parser context */  int type,            /* Either SQLITE_ATTACH or SQLITE_DETACH */  FuncDef *pFunc,      /* FuncDef wrapper for detachFunc() or attachFunc() */  Expr *pAuthArg,      /* Expression to pass to authorization callback */  Expr *pFilename,     /* Name of database file */  Expr *pDbname,       /* Name of the database to use internally */  Expr *pKey           /* Database key for encryption extension */){  int rc;  NameContext sName;  Vdbe *v;  sqlite3* db = pParse->db;  int regArgs;  memset(&sName, 0, sizeof(NameContext));  sName.pParse = pParse;  if(       SQLITE_OK!=(rc = resolveAttachExpr(&sName, pFilename)) ||      SQLITE_OK!=(rc = resolveAttachExpr(&sName, pDbname)) ||      SQLITE_OK!=(rc = resolveAttachExpr(&sName, pKey))  ){    pParse->nErr++;    goto attach_end;  }#ifndef SQLITE_OMIT_AUTHORIZATION  if( pAuthArg ){    char *zAuthArg = pAuthArg->u.zToken;    if( NEVER(zAuthArg==0) ){      goto attach_end;    }    rc = sqlite3AuthCheck(pParse, type, zAuthArg, 0, 0);    if(rc!=SQLITE_OK ){      goto attach_end;    }  }#endif /* SQLITE_OMIT_AUTHORIZATION */  v = sqlite3GetVdbe(pParse);  regArgs = sqlite3GetTempRange(pParse, 4);  sqlite3ExprCode(pParse, pFilename, regArgs);  sqlite3ExprCode(pParse, pDbname, regArgs+1);  sqlite3ExprCode(pParse, pKey, regArgs+2);  assert( v || db->mallocFailed );  if( v ){    sqlite3VdbeAddOp3(v, OP_Function, 0, regArgs+3-pFunc->nArg, regArgs+3);    assert( pFunc->nArg==-1 || (pFunc->nArg&0xff)==pFunc->nArg );    sqlite3VdbeChangeP5(v, (u8)(pFunc->nArg));    sqlite3VdbeChangeP4(v, -1, (char *)pFunc, P4_FUNCDEF);    /* Code an OP_Expire. For an ATTACH statement, set P1 to true (expire this    ** statement only). For DETACH, set it to false (expire all existing    ** statements).    */    sqlite3VdbeAddOp1(v, OP_Expire, (type==SQLITE_ATTACH));  }  attach_end:  sqlite3ExprDelete(db, pFilename);  sqlite3ExprDelete(db, pDbname);  sqlite3ExprDelete(db, pKey);}

//.........这里部分代码省略.........    ** 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;}

/*** 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);//.........这里部分代码省略.........

/*** 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 *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);//.........这里部分代码省略.........

//.........这里部分代码省略.........        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;}

//.........这里部分代码省略.........  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;}