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

/*** Drop a trigger given a pointer to that trigger. */void sqlite3DropTriggerPtr(Parse *pParse, Trigger *pTrigger){  Table   *pTable;  Vdbe *v;  sqlite3 *db = pParse->db;  int iDb;  iDb = sqlite3SchemaToIndex(pParse->db, pTrigger->pSchema);  assert( iDb>=0 && iDb<db->nDb );  pTable = tableOfTrigger(pTrigger);  assert( pTable );  assert( pTable->pSchema==pTrigger->pSchema || iDb==1 );#ifndef SQLITE_OMIT_AUTHORIZATION  {    int code = SQLITE_DROP_TRIGGER;    const char *zDb = db->aDb[iDb].zName;    const char *zTab = SCHEMA_TABLE(iDb);    if( iDb==1 ) code = SQLITE_DROP_TEMP_TRIGGER;    if( sqlite3AuthCheck(pParse, code, pTrigger->zName, pTable->zName, zDb) ||      sqlite3AuthCheck(pParse, SQLITE_DELETE, zTab, 0, zDb) ){      return;    }  }#endif  /* Generate code to destroy the database record of the trigger.  */  assert( pTable!=0 );  if( (v = sqlite3GetVdbe(pParse))!=0 ){    int base;    static const int iLn = VDBE_OFFSET_LINENO(2);    static const VdbeOpList dropTrigger[] = {      { OP_Rewind,     0, ADDR(9),  0},      { OP_String8,    0, 1,        0}, /* 1 */      { OP_Column,     0, 1,        2},      { OP_Ne,         2, ADDR(8),  1},      { OP_String8,    0, 1,        0}, /* 4: "trigger" */      { OP_Column,     0, 0,        2},      { OP_Ne,         2, ADDR(8),  1},      { OP_Delete,     0, 0,        0},      { OP_Next,       0, ADDR(1),  0}, /* 8 */    };    sqlite3BeginWriteOperation(pParse, 0, iDb);    sqlite3OpenMasterTable(pParse, iDb);    base = sqlite3VdbeAddOpList(v,  ArraySize(dropTrigger), dropTrigger, iLn);    sqlite3VdbeChangeP4(v, base+1, pTrigger->zName, P4_TRANSIENT);    sqlite3VdbeChangeP4(v, base+4, "trigger", P4_STATIC);    sqlite3ChangeCookie(pParse, iDb);    sqlite3VdbeAddOp2(v, OP_Close, 0, 0);    sqlite3VdbeAddOp4(v, OP_DropTrigger, iDb, 0, 0, pTrigger->zName, 0);    if( pParse->nMem<3 ){      pParse->nMem = 3;    }  }}

/* ** Generate code for the trigger program associated with trigger p on ** table pTab. The reg, orconf and ignoreJump parameters passed to this ** function are the same as those described in the header function for ** sqlite3CodeRowTrigger() */SQLITE_PRIVATE void sqlite3CodeRowTriggerDirect(                                                Parse *pParse,       /* Parse context */                                                Trigger *p,          /* Trigger to code */                                                Table *pTab,         /* The table to code triggers from */                                                int reg,             /* Reg array containing OLD.* and NEW.* values */                                                int orconf,          /* ON CONFLICT policy */                                                int ignoreJump       /* Instruction to jump to for RAISE(IGNORE) */){    Vdbe *v = sqlite3GetVdbe(pParse); /* Main VM */    TriggerPrg *pPrg;    pPrg = getRowTrigger(pParse, p, pTab, orconf);    assert( pPrg || pParse->nErr || pParse->db->mallocFailed );        /* Code the OP_Program opcode in the parent VDBE. P4 of the OP_Program     ** is a pointer to the sub-vdbe containing the trigger program.  */    if( pPrg ){        int bRecursive = (p->zName && 0==(pParse->db->flags&SQLITE_RecTriggers));                sqlite3VdbeAddOp3(v, OP_Program, reg, ignoreJump, ++pParse->nMem);        sqlite3VdbeChangeP4(v, -1, (const char *)pPrg->pProgram, P4_SUBPROGRAM);        VdbeComment(                    (v, "Call: %s.%s", (p->zName?p->zName:"fkey"), onErrorText(orconf)));                /* Set the P5 operand of the OP_Program instruction to non-zero if         ** recursive invocation of this trigger program is disallowed. Recursive         ** invocation is disallowed if (a) the sub-program is really a trigger,         ** not a foreign key action, and (b) the flag to enable recursive triggers         ** is clear.  */        sqlite3VdbeChangeP5(v, (u8)bRecursive);    }}

/*** Generate code that will assemble an index key and put it in register** regOut.  The key with be for index pIdx which is an index on pTab.** iCur is the index of a cursor open on the pTab table and pointing to** the entry that needs indexing.**** Return a register number which is the first in a block of** registers that holds the elements of the index key.  The** block of registers has already been deallocated by the time** this routine returns.*/int sqlite3GenerateIndexKey(  Parse *pParse,     /* Parsing context */  Index *pIdx,       /* The index for which to generate a key */  int iCur,          /* Cursor number for the pIdx->pTable table */  int regOut,        /* Write the new index key to this register */  int doMakeRec      /* Run the OP_MakeRecord instruction if true */){  Vdbe *v = pParse->pVdbe;  int j;  Table *pTab = pIdx->pTable;  int regBase;  int nCol;  nCol = pIdx->nColumn;  regBase = sqlite3GetTempRange(pParse, nCol+1);  sqlite3VdbeAddOp2(v, OP_Rowid, iCur, regBase+nCol);  for(j=0; j<nCol; j++){    int idx = pIdx->aiColumn[j];    if( idx==pTab->iPKey ){      sqlite3VdbeAddOp2(v, OP_SCopy, regBase+nCol, regBase+j);    }else{      sqlite3VdbeAddOp3(v, OP_Column, iCur, idx, regBase+j);      sqlite3ColumnDefault(v, pTab, idx, -1);    }  }  if( doMakeRec ){    sqlite3VdbeAddOp3(v, OP_MakeRecord, regBase, nCol+1, regOut);    sqlite3VdbeChangeP4(v, -1, sqlite3IndexAffinityStr(v, pIdx), 0);  }  sqlite3ReleaseTempRange(pParse, regBase, nCol+1);  return regBase;}

/*** Generate code that will assemble an index key and stores it in register** regOut.  The key with be for index pIdx which is an index on pTab.** iCur is the index of a cursor open on the pTab table and pointing to** the entry that needs indexing.  If pTab is a WITHOUT ROWID table, then** iCur must be the cursor of the PRIMARY KEY index.**** Return a register number which is the first in a block of** registers that holds the elements of the index key.  The** block of registers has already been deallocated by the time** this routine returns.**** If *piPartIdxLabel is not NULL, fill it in with a label and jump** to that label if pIdx is a partial index that should be skipped.** The label should be resolved using sqlite3ResolvePartIdxLabel().** A partial index should be skipped if its WHERE clause evaluates** to false or null.  If pIdx is not a partial index, *piPartIdxLabel** will be set to zero which is an empty label that is ignored by** sqlite3ResolvePartIdxLabel().**** The pPrior and regPrior parameters are used to implement a cache to** avoid unnecessary register loads.  If pPrior is not NULL, then it is** a pointer to a different index for which an index key has just been** computed into register regPrior.  If the current pIdx index is generating** its key into the same sequence of registers and if pPrior and pIdx share** a column in common, then the register corresponding to that column already** holds the correct value and the loading of that register is skipped.** This optimization is helpful when doing a DELETE or an INTEGRITY_CHECK ** on a table with multiple indices, and especially with the ROWID or** PRIMARY KEY columns of the index.*/int sqlite3GenerateIndexKey(  Parse *pParse,       /* Parsing context */  Index *pIdx,         /* The index for which to generate a key */  int iDataCur,        /* Cursor number from which to take column data */  int regOut,          /* Put the new key into this register if not 0 */  int prefixOnly,      /* Compute only a unique prefix of the key */  int *piPartIdxLabel, /* OUT: Jump to this label to skip partial index */  Index *pPrior,       /* Previously generated index key */  int regPrior         /* Register holding previous generated key */){  Vdbe *v = pParse->pVdbe;  int j;  int regBase;  int nCol;  if( piPartIdxLabel ){    if( pIdx->pPartIdxWhere ){      *piPartIdxLabel = sqlite3VdbeMakeLabel(v);      pParse->iSelfTab = iDataCur + 1;      sqlite3ExprIfFalseDup(pParse, pIdx->pPartIdxWhere, *piPartIdxLabel,                             SQLITE_JUMPIFNULL);      pParse->iSelfTab = 0;    }else{      *piPartIdxLabel = 0;    }  }  nCol = (prefixOnly && pIdx->uniqNotNull) ? pIdx->nKeyCol : pIdx->nColumn;  regBase = sqlite3GetTempRange(pParse, nCol);  if( pPrior && (regBase!=regPrior || pPrior->pPartIdxWhere) ) pPrior = 0;  for(j=0; j<nCol; j++){    if( pPrior     && pPrior->aiColumn[j]==pIdx->aiColumn[j]     && pPrior->aiColumn[j]!=XN_EXPR    ){      /* This column was already computed by the previous index */      continue;    }    sqlite3ExprCodeLoadIndexColumn(pParse, pIdx, iDataCur, j, regBase+j);    /* If the column affinity is REAL but the number is an integer, then it    ** might be stored in the table as an integer (using a compact    ** representation) then converted to REAL by an OP_RealAffinity opcode.    ** But we are getting ready to store this value back into an index, where    ** it should be converted by to INTEGER again.  So omit the OP_RealAffinity    ** opcode if it is present */    sqlite3VdbeDeletePriorOpcode(v, OP_RealAffinity);  }  if( regOut ){    sqlite3VdbeAddOp3(v, OP_MakeRecord, regBase, nCol, regOut);    if( pIdx->pTable->pSelect ){      const char *zAff = sqlite3IndexAffinityStr(pParse->db, pIdx);      sqlite3VdbeChangeP4(v, -1, zAff, P4_TRANSIENT);    }  }  sqlite3ReleaseTempRange(pParse, regBase, nCol);  return regBase;}

/*** Generate code that will assemble an index key and stores it in register** regOut.  The key with be for index pIdx which is an index on pTab.** iCur is the index of a cursor open on the pTab table and pointing to** the entry that needs indexing.  If pTab is a WITHOUT ROWID table, then** iCur must be the cursor of the PRIMARY KEY index.**** Return a register number which is the first in a block of** registers that holds the elements of the index key.  The** block of registers has already been deallocated by the time** this routine returns.**** If *piPartIdxLabel is not NULL, fill it in with a label and jump** to that label if pIdx is a partial index that should be skipped.** A partial index should be skipped if its WHERE clause evaluates** to false or null.  If pIdx is not a partial index, *piPartIdxLabel** will be set to zero which is an empty label that is ignored by** sqlite3VdbeResolveLabel().*/int sqlite3GenerateIndexKey(  Parse *pParse,       /* Parsing context */  Index *pIdx,         /* The index for which to generate a key */  int iDataCur,        /* Cursor number from which to take column data */  int regOut,          /* Put the new key into this register if not 0 */  int prefixOnly,      /* Compute only a unique prefix of the key */  int *piPartIdxLabel  /* OUT: Jump to this label to skip partial index */){  Vdbe *v = pParse->pVdbe;  int j;  Table *pTab = pIdx->pTable;  int regBase;  int nCol;  Index *pPk;  if( piPartIdxLabel ){    if( pIdx->pPartIdxWhere ){      *piPartIdxLabel = sqlite3VdbeMakeLabel(v);      pParse->iPartIdxTab = iDataCur;      sqlite3ExprIfFalse(pParse, pIdx->pPartIdxWhere, *piPartIdxLabel,                          SQLITE_JUMPIFNULL);    }else{      *piPartIdxLabel = 0;    }  }  nCol = (prefixOnly && pIdx->uniqNotNull) ? pIdx->nKeyCol : pIdx->nColumn;  regBase = sqlite3GetTempRange(pParse, nCol);  pPk = HasRowid(pTab) ? 0 : sqlite3PrimaryKeyIndex(pTab);  for(j=0; j<nCol; j++){    i16 idx = pIdx->aiColumn[j];    if( pPk ) idx = sqlite3ColumnOfIndex(pPk, idx);    if( idx<0 || idx==pTab->iPKey ){      sqlite3VdbeAddOp2(v, OP_Rowid, iDataCur, regBase+j);    }else{      sqlite3VdbeAddOp3(v, OP_Column, iDataCur, idx, regBase+j);      sqlite3ColumnDefault(v, pTab, pIdx->aiColumn[j], -1);    }  }  if( regOut ){    const char *zAff;    if( pTab->pSelect     || OptimizationDisabled(pParse->db, SQLITE_IdxRealAsInt)    ){      zAff = 0;    }else{      zAff = sqlite3IndexAffinityStr(v, pIdx);    }    sqlite3VdbeAddOp3(v, OP_MakeRecord, regBase, nCol, regOut);    sqlite3VdbeChangeP4(v, -1, zAff, P4_TRANSIENT);  }  sqlite3ReleaseTempRange(pParse, regBase, nCol);  return regBase;}

/*** Generate code that will assemble an index key and put it in register** regOut.  The key with be for index pIdx which is an index on pTab.** iCur is the index of a cursor open on the pTab table and pointing to** the entry that needs indexing.**** Return a register number which is the first in a block of** registers that holds the elements of the index key.  The** block of registers has already been deallocated by the time** this routine returns.**** If *piPartIdxLabel is not NULL, fill it in with a label and jump** to that label if pIdx is a partial index that should be skipped.** A partial index should be skipped if its WHERE clause evaluates** to false or null.  If pIdx is not a partial index, *piPartIdxLabel** will be set to zero which is an empty label that is ignored by** sqlite3VdbeResolveLabel().*/int sqlite3GenerateIndexKey(  Parse *pParse,       /* Parsing context */  Index *pIdx,         /* The index for which to generate a key */  int iCur,            /* Cursor number for the pIdx->pTable table */  int regOut,          /* Write the new index key to this register */  int doMakeRec,       /* Run the OP_MakeRecord instruction if true */  int *piPartIdxLabel  /* OUT: Jump to this label to skip partial index */){  Vdbe *v = pParse->pVdbe;  int j;  Table *pTab = pIdx->pTable;  int regBase;  int nCol;  if( piPartIdxLabel ){    if( pIdx->pPartIdxWhere ){      *piPartIdxLabel = sqlite3VdbeMakeLabel(v);      pParse->iPartIdxTab = iCur;      sqlite3ExprIfFalse(pParse, pIdx->pPartIdxWhere, *piPartIdxLabel,                          SQLITE_JUMPIFNULL);    }else{      *piPartIdxLabel = 0;    }  }  nCol = pIdx->nColumn;  regBase = sqlite3GetTempRange(pParse, nCol+1);  sqlite3VdbeAddOp2(v, OP_Rowid, iCur, regBase+nCol);  for(j=0; j<nCol; j++){    int idx = pIdx->aiColumn[j];    if( idx==pTab->iPKey ){      sqlite3VdbeAddOp2(v, OP_SCopy, regBase+nCol, regBase+j);    }else{      sqlite3VdbeAddOp3(v, OP_Column, iCur, idx, regBase+j);      sqlite3ColumnDefault(v, pTab, idx, -1);    }  }  if( doMakeRec ){    const char *zAff;    if( pTab->pSelect     || OptimizationDisabled(pParse->db, SQLITE_IdxRealAsInt)    ){      zAff = 0;    }else{      zAff = sqlite3IndexAffinityStr(v, pIdx);    }    sqlite3VdbeAddOp3(v, OP_MakeRecord, regBase, nCol+1, regOut);    sqlite3VdbeChangeP4(v, -1, zAff, P4_TRANSIENT);  }  sqlite3ReleaseTempRange(pParse, regBase, nCol+1);  return regBase;}

/*** The most recently coded instruction was an OP_Column to retrieve the** i-th column of table pTab. This routine sets the P4 parameter of the ** OP_Column to the default value, if any.**** The default value of a column is specified by a DEFAULT clause in the ** column definition. This was either supplied by the user when the table** was created, or added later to the table definition by an ALTER TABLE** command. If the latter, then the row-records in the table btree on disk** may not contain a value for the column and the default value, taken** from the P4 parameter of the OP_Column instruction, is returned instead.** If the former, then all row-records are guaranteed to include a value** for the column and the P4 value is not required.**** Column definitions created by an ALTER TABLE command may only have ** literal default values specified: a number, null or a string. (If a more** complicated default expression value was provided, it is evaluated ** when the ALTER TABLE is executed and one of the literal values written** into the sqlite_master table.)**** Therefore, the P4 parameter is only required if the default value for** the column is a literal number, string or null. The sqlite3ValueFromExpr()** function is capable of transforming these types of expressions into** sqlite3_value objects.*/void sqlite3ColumnDefault(Vdbe *v, Table *pTab, int i){  if( pTab && !pTab->pSelect ){    sqlite3_value *pValue;    u8 enc = ENC(sqlite3VdbeDb(v));    Column *pCol = &pTab->aCol[i];    VdbeComment((v, "%s.%s", pTab->zName, pCol->zName));    assert( i<pTab->nCol );    sqlite3ValueFromExpr(sqlite3VdbeDb(v), pCol->pDflt, enc,                          pCol->affinity, &pValue);    if( pValue ){      sqlite3VdbeChangeP4(v, -1, (const char *)pValue, P4_MEM);    }  }}

/*** This routine generates VDBE code that causes a single row of a** single table to be deleted.**** 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 "base".****   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 pops the top of the stack to remove the record number** and then 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          /* Increment the row change counter */){  int addr;  Vdbe *v;  v = pParse->pVdbe;  addr = sqlite3VdbeAddOp3(v, OP_NotExists, iCur, 0, iRowid);  sqlite3GenerateRowIndexDelete(pParse, pTab, iCur, 0);  sqlite3VdbeAddOp2(v, OP_Delete, iCur, (count?OPFLAG_NCHANGE:0));  if( count ){    sqlite3VdbeChangeP4(v, -1, pTab->zName, P4_STATIC);  }  sqlite3VdbeJumpHere(v, addr);}

/*** The most recently coded instruction was an OP_Column to retrieve the** i-th column of table pTab. This routine sets the P4 parameter of the ** OP_Column to the default value, if any.**** The default value of a column is specified by a DEFAULT clause in the ** column definition. This was either supplied by the user when the table** was created, or added later to the table definition by an ALTER TABLE** command. If the latter, then the row-records in the table btree on disk** may not contain a value for the column and the default value, taken** from the P4 parameter of the OP_Column instruction, is returned instead.** If the former, then all row-records are guaranteed to include a value** for the column and the P4 value is not required.**** Column definitions created by an ALTER TABLE command may only have ** literal default values specified: a number, null or a string. (If a more** complicated default expression value was provided, it is evaluated ** when the ALTER TABLE is executed and one of the literal values written** into the sqlite_master table.)**** Therefore, the P4 parameter is only required if the default value for** the column is a literal number, string or null. The sqlite3ValueFromExpr()** function is capable of transforming these types of expressions into** sqlite3_value objects.**** If parameter iReg is not negative, code an OP_RealAffinity instruction** on register iReg. This is used when an equivalent integer value is ** stored in place of an 8-byte floating point value in order to save ** space.*/void sqlite3ColumnDefault(Vdbe *v, Table *pTab, int i, int iReg){  assert( pTab!=0 );  if( !pTab->pSelect ){    sqlite3_value *pValue = 0;    u8 enc = ENC(sqlite3VdbeDb(v));    Column *pCol = &pTab->aCol[i];    VdbeComment((v, "%s.%s", pTab->zName, pCol->zName));    assert( i<pTab->nCol );    sqlite3ValueFromExpr(sqlite3VdbeDb(v), pCol->pDflt, enc,                          pCol->affinity, &pValue);    if( pValue ){      sqlite3VdbeChangeP4(v, -1, (const char *)pValue, P4_MEM);    }#ifndef SQLITE_OMIT_FLOATING_POINT    if( pTab->aCol[i].affinity==SQLITE_AFF_REAL ){      sqlite3VdbeAddOp1(v, OP_RealAffinity, iReg);    }#endif  }}

/*** This routine generates VDBE code that causes a single row of a** single table to be deleted.**** 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 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, //.........这里部分代码省略.........

/*** 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;  int regArgs;#ifndef SQLITE_OMIT_AUTHORIZATION  assert( db->mallocFailed || pAuthArg );  if( pAuthArg ){    char *zAuthArg = sqlite3NameFromToken(db, &pAuthArg->span);    if( !zAuthArg ){      goto attach_end;    }    rc = sqlite3AuthCheck(pParse, type, zAuthArg, 0, 0);    sqlite3_free(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);  regArgs = sqlite3GetTempRange(pParse, 3);  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-nFunc, regArgs);    sqlite3VdbeChangeP5(v, nFunc);    pFunc = sqlite3FindFunction(db, zFunc, strlen(zFunc), nFunc, SQLITE_UTF8,0);    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(pFilename);  sqlite3ExprDelete(pDbname);  sqlite3ExprDelete(pKey);}

//.........这里部分代码省略.........            sqlite3DbFree(db, zErr);            zErr = sqlite3MPrintf(db,                             "cannot open indexed column for writing");            rc = SQLITE_ERROR;            (void)sqlite3SafetyOff(db);            sqlite3BtreeLeaveAll(db);            goto blob_open_out;          }        }      }    }    v = sqlite3VdbeCreate(db);    if( v ){      int iDb = sqlite3SchemaToIndex(db, pTab->pSchema);      sqlite3VdbeAddOpList(v, sizeof(openBlob)/sizeof(VdbeOpList), openBlob);      flags = !!flags;                 /* flags = (flags ? 1 : 0); */      /* Configure the OP_Transaction */      sqlite3VdbeChangeP1(v, 0, iDb);      sqlite3VdbeChangeP2(v, 0, flags);      /* Configure the OP_VerifyCookie */      sqlite3VdbeChangeP1(v, 1, iDb);      sqlite3VdbeChangeP2(v, 1, pTab->pSchema->schema_cookie);      /* Make sure a mutex is held on the table to be accessed */      sqlite3VdbeUsesBtree(v, iDb);       /* Configure the OP_TableLock instruction */      sqlite3VdbeChangeP1(v, 2, iDb);      sqlite3VdbeChangeP2(v, 2, pTab->tnum);      sqlite3VdbeChangeP3(v, 2, flags);      sqlite3VdbeChangeP4(v, 2, pTab->zName, P4_TRANSIENT);      /* Remove either the OP_OpenWrite or OpenRead. Set the P2       ** parameter of the other to pTab->tnum.  */      sqlite3VdbeChangeToNoop(v, 4 - flags, 1);      sqlite3VdbeChangeP2(v, 3 + flags, pTab->tnum);      sqlite3VdbeChangeP3(v, 3 + flags, iDb);      /* Configure the number of columns. Configure the cursor to      ** think that the table has one more column than it really      ** does. An OP_Column to retrieve this imaginary column will      ** always return an SQL NULL. This is useful because it means      ** we can invoke OP_Column to fill in the vdbe cursors type       ** and offset cache without causing any IO.      */      sqlite3VdbeChangeP4(v, 3+flags, SQLITE_INT_TO_PTR(pTab->nCol+1),P4_INT32);      sqlite3VdbeChangeP2(v, 7, pTab->nCol);      if( !db->mallocFailed ){        sqlite3VdbeMakeReady(v, 1, 1, 1, 0);      }    }       sqlite3BtreeLeaveAll(db);    rc = sqlite3SafetyOff(db);    if( NEVER(rc!=SQLITE_OK) || db->mallocFailed ){      goto blob_open_out;    }    sqlite3_bind_int64((sqlite3_stmt *)v, 1, iRow);    rc = sqlite3_step((sqlite3_stmt *)v);    if( rc!=SQLITE_ROW ){      nAttempt++;      rc = sqlite3_finalize((sqlite3_stmt *)v);

/*** This routine generates code that opens the sqlite_stat1 table for** writing with cursor iStatCur. If the library was built with the** SQLITE_ENABLE_STAT2 macro defined, then the sqlite_stat2 table is** opened for writing using cursor (iStatCur+1)**** If the sqlite_stat1 tables does not previously exist, it is created.** Similarly, if the sqlite_stat2 table does not exist and the library** is compiled with SQLITE_ENABLE_STAT2 defined, it is created. **** Argument zWhere may be a pointer to a buffer containing a table name,** or it may be a NULL pointer. If it is not NULL, then all entries in** the sqlite_stat1 and (if applicable) sqlite_stat2 tables associated** with the named table are deleted. If zWhere==0, then code is generated** to delete all stat table entries.*/static void openStatTable(  Parse *pParse,          /* Parsing context */  int iDb,                /* The database we are looking in */  int iStatCur,           /* Open the sqlite_stat1 table on this cursor */  const char *zWhere,     /* Delete entries for this table or index */  const char *zWhereType  /* Either "tbl" or "idx" */){  static const struct {    const char *zName;    const char *zCols;  } aTable[] = {    { "sqlite_stat1", "tbl,idx,stat" },#ifdef SQLITE_ENABLE_STAT2    { "sqlite_stat2", "tbl,idx,sampleno,sample" },#endif  };  int aRoot[] = {0, 0};  u8 aCreateTbl[] = {0, 0};  int i;  sqlite3 *db = pParse->db;  Db *pDb;  Vdbe *v = sqlite3GetVdbe(pParse);  if( v==0 ) return;  assert( sqlite3BtreeHoldsAllMutexes(db) );  assert( sqlite3VdbeDb(v)==db );  pDb = &db->aDb[iDb];  for(i=0; i<ArraySize(aTable); i++){    const char *zTab = aTable[i].zName;    Table *pStat;    if( (pStat = sqlite3FindTable(db, zTab, pDb->zName))==0 ){      /* The sqlite_stat[12] table does not exist. Create it. Note that a       ** side-effect of the CREATE TABLE statement is to leave the rootpage       ** of the new table in register pParse->regRoot. This is important       ** because the OpenWrite opcode below will be needing it. */      sqlite3NestedParse(pParse,          "CREATE TABLE %Q.%s(%s)", pDb->zName, zTab, aTable[i].zCols      );      aRoot[i] = pParse->regRoot;      aCreateTbl[i] = 1;    }else{      /* The table already exists. If zWhere is not NULL, delete all entries       ** associated with the table zWhere. If zWhere is NULL, delete the      ** entire contents of the table. */      aRoot[i] = pStat->tnum;      sqlite3TableLock(pParse, iDb, aRoot[i], 1, zTab);      if( zWhere ){        sqlite3NestedParse(pParse,           "DELETE FROM %Q.%s WHERE %s=%Q", pDb->zName, zTab, zWhereType, zWhere        );      }else{        /* The sqlite_stat[12] table already exists.  Delete all rows. */        sqlite3VdbeAddOp2(v, OP_Clear, aRoot[i], iDb);      }    }  }  /* Open the sqlite_stat[12] tables for writing. */  for(i=0; i<ArraySize(aTable); i++){    sqlite3VdbeAddOp3(v, OP_OpenWrite, iStatCur+i, aRoot[i], iDb);    sqlite3VdbeChangeP4(v, -1, (char *)3, P4_INT32);    sqlite3VdbeChangeP5(v, aCreateTbl[i]);  }}

//.........这里部分代码省略.........          }        }      }#endif      for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){        int j;        for(j=0; j<pIdx->nColumn; j++){          if( pIdx->aiColumn[j]==iCol ){            zFault = "indexed";          }        }      }      if( zFault ){        sqlite3DbFree(db, zErr);        zErr = sqlite3MPrintf(db, "cannot open %s column for writing", zFault);        rc = SQLITE_ERROR;        sqlite3BtreeLeaveAll(db);        goto blob_open_out;      }    }    pBlob->pStmt = (sqlite3_stmt *)sqlite3VdbeCreate(db);    assert( pBlob->pStmt || db->mallocFailed );    if( pBlob->pStmt ){      Vdbe *v = (Vdbe *)pBlob->pStmt;      int iDb = sqlite3SchemaToIndex(db, pTab->pSchema);      sqlite3VdbeAddOpList(v, sizeof(openBlob)/sizeof(VdbeOpList), openBlob);      /* Configure the OP_Transaction */      sqlite3VdbeChangeP1(v, 0, iDb);      sqlite3VdbeChangeP2(v, 0, flags);      /* Configure the OP_VerifyCookie */      sqlite3VdbeChangeP1(v, 1, iDb);      sqlite3VdbeChangeP2(v, 1, pTab->pSchema->schema_cookie);      sqlite3VdbeChangeP3(v, 1, pTab->pSchema->iGeneration);      /* Make sure a mutex is held on the table to be accessed */      sqlite3VdbeUsesBtree(v, iDb);       /* Configure the OP_TableLock instruction */#ifdef SQLITE_OMIT_SHARED_CACHE      sqlite3VdbeChangeToNoop(v, 2);#else      sqlite3VdbeChangeP1(v, 2, iDb);      sqlite3VdbeChangeP2(v, 2, pTab->tnum);      sqlite3VdbeChangeP3(v, 2, flags);      sqlite3VdbeChangeP4(v, 2, pTab->zName, P4_TRANSIENT);#endif      /* Remove either the OP_OpenWrite or OpenRead. Set the P2       ** parameter of the other to pTab->tnum.  */      sqlite3VdbeChangeToNoop(v, 4 - flags);      sqlite3VdbeChangeP2(v, 3 + flags, pTab->tnum);      sqlite3VdbeChangeP3(v, 3 + flags, iDb);      /* Configure the number of columns. Configure the cursor to      ** think that the table has one more column than it really      ** does. An OP_Column to retrieve this imaginary column will      ** always return an SQL NULL. This is useful because it means      ** we can invoke OP_Column to fill in the vdbe cursors type       ** and offset cache without causing any IO.      */      sqlite3VdbeChangeP4(v, 3+flags, SQLITE_INT_TO_PTR(pTab->nCol+1),P4_INT32);      sqlite3VdbeChangeP2(v, 7, pTab->nCol);      if( !db->mallocFailed ){        pParse->nVar = 1;        pParse->nMem = 1;        pParse->nTab = 1;        sqlite3VdbeMakeReady(v, pParse);      }    }       pBlob->flags = flags;    pBlob->iCol = iCol;    pBlob->db = db;    sqlite3BtreeLeaveAll(db);    if( db->mallocFailed ){      goto blob_open_out;    }    sqlite3_bind_int64(pBlob->pStmt, 1, iRow);    rc = blobSeekToRow(pBlob, iRow, &zErr);  } while( (++nAttempt)<5 && rc==SQLITE_SCHEMA );blob_open_out:  if( rc==SQLITE_OK && db->mallocFailed==0 ){    *ppBlob = (sqlite3_blob *)pBlob;  }else{    if( pBlob && pBlob->pStmt ) sqlite3VdbeFinalize((Vdbe *)pBlob->pStmt);    sqlite3DbFree(db, pBlob);  }  sqlite3Error(db, rc, (zErr ? "%s" : 0), zErr);  sqlite3DbFree(db, zErr);  sqlite3StackFree(db, pParse);  rc = sqlite3ApiExit(db, rc);  sqlite3_mutex_leave(db->mutex);  return rc;}

/*** This function is called when a row is inserted into or deleted from the ** child table of foreign key constraint pFKey. If an SQL UPDATE is executed ** on the child table of pFKey, this function is invoked twice for each row** affected - once to "delete" the old row, and then again to "insert" the** new row.**** Each time it is called, this function generates VDBE code to locate the** row in the parent table that corresponds to the row being inserted into ** or deleted from the child table. If the parent row can be found, no ** special action is taken. Otherwise, if the parent row can *not* be** found in the parent table:****   Operation | FK type   | Action taken**   --------------------------------------------------------------------------**   INSERT      immediate   Increment the "immediate constraint counter".****   DELETE      immediate   Decrement the "immediate constraint counter".****   INSERT      deferred    Increment the "deferred constraint counter".****   DELETE      deferred    Decrement the "deferred constraint counter".**** These operations are identified in the comment at the top of this file ** (fkey.c) as "I.1" and "D.1".*/static void fkLookupParent(  Parse *pParse,        /* Parse context */  int iDb,              /* Index of database housing pTab */  Table *pTab,          /* Parent table of FK pFKey */  Index *pIdx,          /* Unique index on parent key columns in pTab */  FKey *pFKey,          /* Foreign key constraint */  int *aiCol,           /* Map from parent key columns to child table columns */  int regData,          /* Address of array containing child table row */  int nIncr,            /* Increment constraint counter by this */  int isIgnore          /* If true, pretend pTab contains all NULL values */){  int i;                                    /* Iterator variable */  Vdbe *v = sqlite3GetVdbe(pParse);         /* Vdbe to add code to */  int iCur = pParse->nTab - 1;              /* Cursor number to use */  int iOk = sqlite3VdbeMakeLabel(v);        /* jump here if parent key found */  /* If nIncr is less than zero, then check at runtime if there are any  ** outstanding constraints to resolve. If there are not, there is no need  ** to check if deleting this row resolves any outstanding violations.  **  ** Check if any of the key columns in the child table row are NULL. If   ** any are, then the constraint is considered satisfied. No need to   ** search for a matching row in the parent table.  */  if( nIncr<0 ){    sqlite3VdbeAddOp2(v, OP_FkIfZero, pFKey->isDeferred, iOk);  }  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),//.........这里部分代码省略.........

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);}

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

//.........这里部分代码省略.........    /* 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 rowid value, or if there are foreign key constraints    ** to process, delete the old record. Otherwise, add a noop OP_Delete    ** to invoke the pre-update hook.    **    ** That (regNew==regnewRowid+1) is true is also important for the     ** 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 || chngKey || pPk!=0) ? 0 : OPFLAG_ISNOOP),        regNewRowid    );    if( !pParse->nested ){      sqlite3VdbeChangeP4(v, -1, (char*)pTab, P4_TABLE);    }#else    if( hasFK || chngKey || pPk!=0 ){      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, 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);  }

/*** 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);}

//.........这里部分代码省略.........  */#if !defined(SQLITE_OMIT_VIEW) && !defined(SQLITE_OMIT_TRIGGER)  if( isView ){    sqlite3MaterializeView(pParse, pTab, pWhere, iCur);  }#endif  /* Resolve the column names in the WHERE clause.  */  memset(&sNC, 0, sizeof(sNC));  sNC.pParse = pParse;  sNC.pSrcList = pTabList;  if( sqlite3ResolveExprNames(&sNC, pWhere) ){    goto delete_from_cleanup;  }  /* Initialize the counter of the number of rows deleted, if  ** we are counting rows.  */  if( db->flags & SQLITE_CountRows ){    memCnt = ++pParse->nMem;    sqlite3VdbeAddOp2(v, OP_Integer, 0, memCnt);  }#ifndef SQLITE_OMIT_TRUNCATE_OPTIMIZATION  /* 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( rcauth==SQLITE_OK && pWhere==0 && !triggers_exist && !IsVirtual(pTab) ){    assert( !isView );    sqlite3VdbeAddOp3(v, OP_Clear, pTab->tnum, iDb, memCnt);    if( !pParse->nested ){      sqlite3VdbeChangeP4(v, -1, 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 iRowid = ++pParse->nMem;    /* Used for storing rowid values. */    int iRowSet = ++pParse->nMem;   /* Register for rowset of rows to delete */    /* Begin the database scan    */    pWInfo = sqlite3WhereBegin(pParse, pTabList, pWhere, 0, 0);    if( pWInfo==0 ) goto delete_from_cleanup;    /* Remember the rowid of every item to be deleted.    */    sqlite3VdbeAddOp2(v, IsVirtual(pTab) ? OP_VRowid : OP_Rowid, iCur, iRowid);    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.

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

//.........这里部分代码省略.........      /* Make sure all the indices are constructed correctly.      */      for(x=sqliteHashFirst(pTbls); x && !isQuick; x=sqliteHashNext(x)){        Table *pTab = sqliteHashData(x);        Index *pIdx;        int loopTop;        if( pTab->pIndex==0 ) continue;        addr = sqlite3VdbeAddOp1(v, OP_IfPos, 1);  /* Stop if out of errors */        sqlite3VdbeAddOp2(v, OP_Halt, 0, 0);        sqlite3VdbeJumpHere(v, addr);        sqlite3OpenTableAndIndices(pParse, pTab, 1, OP_OpenRead);        sqlite3VdbeAddOp2(v, OP_Integer, 0, 2);  /* reg(2) will count entries */        loopTop = sqlite3VdbeAddOp2(v, OP_Rewind, 1, 0);        sqlite3VdbeAddOp2(v, OP_AddImm, 2, 1);   /* increment entry count */        for(j=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, j++){          int jmp2;          static const VdbeOpList idxErr[] = {            { OP_AddImm,      1, -1,  0},            { OP_String8,     0,  3,  0},    /* 1 */            { OP_Rowid,       1,  4,  0},            { OP_String8,     0,  5,  0},    /* 3 */            { OP_String8,     0,  6,  0},    /* 4 */            { OP_Concat,      4,  3,  3},            { OP_Concat,      5,  3,  3},            { OP_Concat,      6,  3,  3},            { OP_ResultRow,   3,  1,  0},            { OP_IfPos,       1,  0,  0},    /* 9 */            { OP_Halt,        0,  0,  0},          };          sqlite3GenerateIndexKey(pParse, pIdx, 1, 3, 1);          jmp2 = sqlite3VdbeAddOp3(v, OP_Found, j+2, 0, 3);          addr = sqlite3VdbeAddOpList(v, ArraySize(idxErr), idxErr);          sqlite3VdbeChangeP4(v, addr+1, "rowid ", P4_STATIC);          sqlite3VdbeChangeP4(v, addr+3, " missing from index ", P4_STATIC);          sqlite3VdbeChangeP4(v, addr+4, pIdx->zName, P4_STATIC);          sqlite3VdbeJumpHere(v, addr+9);          sqlite3VdbeJumpHere(v, jmp2);        }        sqlite3VdbeAddOp2(v, OP_Next, 1, loopTop+1);        sqlite3VdbeJumpHere(v, loopTop);        for(j=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, j++){          static const VdbeOpList cntIdx[] = {             { OP_Integer,      0,  3,  0},             { OP_Rewind,       0,  0,  0},  /* 1 */             { OP_AddImm,       3,  1,  0},             { OP_Next,         0,  0,  0},  /* 3 */             { OP_Eq,           2,  0,  3},  /* 4 */             { OP_AddImm,       1, -1,  0},             { OP_String8,      0,  2,  0},  /* 6 */             { OP_String8,      0,  3,  0},  /* 7 */             { OP_Concat,       3,  2,  2},             { OP_ResultRow,    2,  1,  0},          };          if( pIdx->tnum==0 ) continue;          addr = sqlite3VdbeAddOp1(v, OP_IfPos, 1);          sqlite3VdbeAddOp2(v, OP_Halt, 0, 0);          sqlite3VdbeJumpHere(v, addr);          addr = sqlite3VdbeAddOpList(v, ArraySize(cntIdx), cntIdx);          sqlite3VdbeChangeP1(v, addr+1, j+2);          sqlite3VdbeChangeP2(v, addr+1, addr+4);          sqlite3VdbeChangeP1(v, addr+3, j+2);          sqlite3VdbeChangeP2(v, addr+3, addr+2);          sqlite3VdbeJumpHere(v, addr+4);          sqlite3VdbeChangeP4(v, addr+6,                      "wrong # of entries in index ", P4_STATIC);