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

/*** Perform a read or write operation on a blob*/static int blobReadWrite(  sqlite3_blob *pBlob,   void *z,   int n,   int iOffset,   int (*xCall)(BtCursor*, u32, u32, void*)){  int rc;  Incrblob *p = (Incrblob *)pBlob;  Vdbe *v;  sqlite3 *db = p->db;    /* Request is out of range. Return a transient error. */  if( (iOffset+n)>p->nByte ){    return SQLITE_ERROR;  }  sqlite3_mutex_enter(db->mutex);  /* If there is no statement handle, then the blob-handle has  ** already been invalidated. Return SQLITE_ABORT in this case.  */  v = (Vdbe*)p->pStmt;  if( v==0 ){    rc = SQLITE_ABORT;  }else{    /* Call either BtreeData() or BtreePutData(). If SQLITE_ABORT is    ** returned, clean-up the statement handle.    */    assert( db == v->db );    sqlite3BtreeEnterCursor(p->pCsr);    rc = xCall(p->pCsr, iOffset+p->iOffset, n, z);    sqlite3BtreeLeaveCursor(p->pCsr);    if( rc==SQLITE_ABORT ){      sqlite3VdbeFinalize(v);      p->pStmt = 0;    }else{      db->errCode = rc;      v->rc = rc;    }  }  rc = sqlite3ApiExit(db, rc);  sqlite3_mutex_leave(db->mutex);  return rc;}

/*** This is the top-level implementation of sqlite3_step().  Call** sqlite3Step() to do most of the work.  If a schema error occurs,** call sqlite3Reprepare() and try again.*/int sqlite3_step(sqlite3_stmt *pStmt){  int rc = SQLITE_OK;      /* Result from sqlite3Step() */  int rc2 = SQLITE_OK;     /* Result from sqlite3Reprepare() */  Vdbe *v = (Vdbe*)pStmt;  /* the prepared statement */  int cnt = 0;             /* Counter to prevent infinite loop of reprepares */  sqlite3 *db;             /* The database connection */  if( vdbeSafetyNotNull(v) ){    return SQLITE_MISUSE_BKPT;  }  db = v->db;  sqlite3_mutex_enter(db->mutex);  v->doingRerun = 0;  while( (rc = sqlite3Step(v))==SQLITE_SCHEMA         && cnt++ < SQLITE_MAX_SCHEMA_RETRY         && (rc2 = rc = sqlite3Reprepare(v))==SQLITE_OK ){    sqlite3_reset(pStmt);    v->doingRerun = 1;    assert( v->expired==0 );  }  if( rc2!=SQLITE_OK ){    /* This case occurs after failing to recompile an sql statement.     ** The error message from the SQL compiler has already been loaded     ** into the database handle. This block copies the error message     ** from the database handle into the statement and sets the statement    ** program counter to 0 to ensure that when the statement is     ** finalized or reset the parser error message is available via    ** sqlite3_errmsg() and sqlite3_errcode().    */    const char *zErr = (const char *)sqlite3_value_text(db->pErr);     assert( zErr!=0 || db->mallocFailed );    sqlite3DbFree(db, v->zErrMsg);    if( !db->mallocFailed ){      v->zErrMsg = sqlite3DbStrDup(db, zErr);      v->rc = rc2;    } else {      v->zErrMsg = 0;      v->rc = rc = SQLITE_NOMEM;    }  }  rc = sqlite3ApiExit(db, rc);  sqlite3_mutex_leave(db->mutex);  return rc;}

/*** This function is used to set the schema of a virtual table.  It is only** valid to call this function from within the xCreate() or xConnect() of a** virtual table module.*/int sqlite3_declare_vtab(sqlite3 *db, const char *zCreateTable){  Parse sParse;  int rc = SQLITE_OK;  Table *pTab = db->pVTab;  char *zErr = 0;  if( !pTab ){    sqlite3Error(db, SQLITE_MISUSE, 0);    return SQLITE_MISUSE;  }  assert(pTab->isVirtual && pTab->nCol==0 && pTab->aCol==0);  memset(&sParse, 0, sizeof(Parse));  sParse.declareVtab = 1;  sParse.db = db;  if(       SQLITE_OK == sqlite3RunParser(&sParse, zCreateTable, &zErr) &&       sParse.pNewTable &&       !sParse.pNewTable->pSelect &&       !sParse.pNewTable->isVirtual   ){    pTab->aCol = sParse.pNewTable->aCol;    pTab->nCol = sParse.pNewTable->nCol;    sParse.pNewTable->nCol = 0;    sParse.pNewTable->aCol = 0;    db->pVTab = 0;  } else {    sqlite3Error(db, SQLITE_ERROR, zErr);    sqliteFree(zErr);    rc = SQLITE_ERROR;  }  sParse.declareVtab = 0;  sqlite3_finalize((sqlite3_stmt*)sParse.pVdbe);  sqlite3DeleteTable(sParse.pNewTable);  sParse.pNewTable = 0;  assert( (rc&0xff)==rc );  return sqlite3ApiExit(db, rc);}

int sqlite3_create_function16(  sqlite3 *db,  const void *zFunctionName,  int nArg,  int eTextRep,  void *p,  void (*xFunc)(sqlite3_context*,int,sqlite3_value**),  void (*xStep)(sqlite3_context*,int,sqlite3_value**),  void (*xFinal)(sqlite3_context*)){  int rc;  char *zFunc8;  assert( !sqlite3MallocFailed() );  zFunc8 = sqlite3utf16to8(zFunctionName, -1);  rc = sqlite3CreateFunc(db, zFunc8, nArg, eTextRep, p, xFunc, xStep, xFinal);  sqliteFree(zFunc8);  return sqlite3ApiExit(db, rc);}

/*** External API function used to create a new virtual-table module.*/int sqlite3_create_module(  sqlite3 *db,                    /* Database in which module is registered */  const char *zName,              /* Name assigned to this module */  const sqlite3_module *pModule,  /* The definition of the module */  void *pAux                      /* Context pointer for xCreate/xConnect */){  int nName = strlen(zName);  Module *pMod = (Module *)sqliteMallocRaw(sizeof(Module) + nName + 1);  if( pMod ){    char *zCopy = (char *)(&pMod[1]);    strcpy(zCopy, zName);    pMod->zName = zCopy;    pMod->pModule = pModule;    pMod->pAux = pAux;    pMod = (Module *)sqlite3HashInsert(&db->aModule, zCopy, nName, (void*)pMod);    sqliteFree(pMod);    sqlite3ResetInternalSchema(db, 0);  }  return sqlite3ApiExit(db, SQLITE_OK);}

/*** Register a new collation sequence with the database handle db.*/extern "C" int sqlite3_create_collation16(  sqlite3* db,   const char *zName,   int enc,   void* pCtx,  int(*xCompare)(void*,int,const void*,int,const void*)){  int rc = SQLITE_OK;  char *zName8;   sqlite3_mutex_enter(db->mutex);  assert( !db->mallocFailed );  zName8 = sqlite3Utf16to8(db, zName, -1);  if( zName8 ){    rc = createCollation(db, zName8, enc, pCtx, xCompare, 0);    sqlite3_free(zName8);  }  rc = sqlite3ApiExit(db, rc);  sqlite3_mutex_leave(db->mutex);  return rc;}

/*** The actual function that does the work of creating a new module.** This function implements the sqlite3_create_module() and** sqlite3_create_module_v2() interfaces.*/static int createModule(  sqlite3 *db,                    /* Database in which module is registered */  const char *zName,              /* Name assigned to this module */  const sqlite3_module *pModule,  /* The definition of the module */  void *pAux,                     /* Context pointer for xCreate/xConnect */  void (*xDestroy)(void *)        /* Module destructor function */){  int rc = SQLITE_OK;  sqlite3_mutex_enter(db->mutex);  if( sqlite3HashFind(&db->aModule, zName) ){    rc = SQLITE_MISUSE_BKPT;  }else{    (void)sqlite3VtabCreateModule(db, zName, pModule, pAux, xDestroy);  }  rc = sqlite3ApiExit(db, rc);  if( rc!=SQLITE_OK && xDestroy ) xDestroy(pAux);  sqlite3_mutex_leave(db->mutex);  return rc;}

/*** This routine is the same as the sqlite3_complete() routine described** above, except that the parameter is required to be UTF-16 encoded, not** UTF-8.*/int sqlite3_complete16(const void *zSql){  sqlite3_value *pVal;  char const *zSql8;  int rc = SQLITE_NOMEM;#ifndef SQLITE_OMIT_AUTOINIT  rc = sqlite3_initialize();  if( rc ) return rc;#endif  pVal = sqlite3ValueNew(0);  sqlite3ValueSetStr(pVal, -1, zSql, SQLITE_UTF16NATIVE, SQLITE_STATIC);  zSql8 = sqlite3ValueText(pVal, SQLITE_UTF8);  if( zSql8 ){    rc = sqlite3_complete(zSql8);  }else{    rc = SQLITE_NOMEM;  }  sqlite3ValueFree(pVal);  return sqlite3ApiExit(0, rc);}

/*** Compile the UTF-16 encoded SQL statement zSql into a statement handle.*/static int sqlite3Prepare16(  sqlite3 *db,              /* Database handle. */   const void *zSql,         /* UTF-8 encoded SQL statement. */  int nBytes,               /* Length of zSql in bytes. */  int saveSqlFlag,          /* True to save SQL text into the sqlite3_stmt */  sqlite3_stmt **ppStmt,    /* OUT: A pointer to the prepared statement */  const void **pzTail       /* OUT: End of parsed string */){  /* This function currently works by first transforming the UTF-16  ** encoded string to UTF-8, then invoking sqlite3_prepare(). The  ** tricky bit is figuring out the pointer to return in *pzTail.  */  char *zSql8;  const char *zTail8 = 0;  int rc = SQLITE_OK;  assert( ppStmt );  *ppStmt = 0;  if( !sqlite3SafetyCheckOk(db) ){    return SQLITE_MISUSE;  }  sqlite3_mutex_enter(db->mutex);  zSql8 = sqlite3Utf16to8(db, zSql, nBytes);  if( zSql8 ){    rc = sqlite3LockAndPrepare(db, zSql8, -1, saveSqlFlag, 0, ppStmt, &zTail8);  }  if( zTail8 && pzTail ){    /* If sqlite3_prepare returns a tail pointer, we calculate the    ** equivalent pointer into the UTF-16 string by counting the unicode    ** characters between zSql8 and zTail8, and then returning a pointer    ** the same number of characters into the UTF-16 string.    */    int chars_parsed = sqlite3Utf8CharLen(zSql8, (int)(zTail8-zSql8));    *pzTail = (u8 *)zSql + sqlite3Utf16ByteLen(zSql, chars_parsed);  }  sqlite3DbFree(db, zSql8);   rc = sqlite3ApiExit(db, rc);  sqlite3_mutex_leave(db->mutex);  return rc;}

extern "C" int sqlite3_create_function16(  sqlite3 *db,  const void *zFunctionName,  int nArg,  int eTextRep,  void *p,  void (*xFunc)(sqlite3_context*,int,sqlite3_value**),  void (*xStep)(sqlite3_context*,int,sqlite3_value**),  void (*xFinal)(sqlite3_context*)){  int rc;  char *zFunc8;  sqlite3_mutex_enter(db->mutex);  assert( !db->mallocFailed );  zFunc8 = sqlite3Utf16to8(db, zFunctionName, -1);  rc = sqlite3CreateFunc(db, zFunc8, nArg, eTextRep, p, xFunc, xStep, xFinal);  sqlite3_free(zFunc8);  rc = sqlite3ApiExit(db, rc);  sqlite3_mutex_leave(db->mutex);  return rc;}

/*** The following routine destroys a virtual machine that is created by** the sqlite3_compile() routine. The integer returned is an SQLITE_** success/failure code that describes the result of executing the virtual** machine.**** This routine sets the error code and string returned by** sqlite3_errcode(), sqlite3_errmsg() and sqlite3_errmsg16().*/int sqlite3_finalize(sqlite3_stmt *pStmt){  int rc;  if( pStmt==0 ){    rc = SQLITE_OK;  }else{    Vdbe *v = (Vdbe*)pStmt;    sqlite3 *db = v->db;#if SQLITE_THREADSAFE    sqlite3_mutex *mutex;#endif    if( vdbeSafety(v) ) return SQLITE_MISUSE_BKPT;#if SQLITE_THREADSAFE    mutex = v->db->mutex;#endif    sqlite3_mutex_enter(mutex);    rc = sqlite3VdbeFinalize(v);    rc = sqlite3ApiExit(db, rc);    sqlite3_mutex_leave(mutex);  }  return rc;}

/*** The actual function that does the work of creating a new module.** This function implements the sqlite3_create_module() and** sqlite3_create_module_v2() interfaces.*/static int createModule(  sqlite3 *db,                    /* Database in which module is registered */  const char *zName,              /* Name assigned to this module */  const sqlite3_module *pModule,  /* The definition of the module */  void *pAux,                     /* Context pointer for xCreate/xConnect */  void (*xDestroy)(void *)        /* Module destructor function */){  int rc = SQLITE_OK;  int nName;  sqlite3_mutex_enter(db->mutex);  nName = sqlite3Strlen30(zName);  if( sqlite3HashFind(&db->aModule, zName) ){    rc = SQLITE_MISUSE_BKPT;  }else{    Module *pMod;    pMod = (Module *)sqlite3DbMallocRaw(db, sizeof(Module) + nName + 1);    if( pMod ){      Module *pDel;      char *zCopy = (char *)(&pMod[1]);      memcpy(zCopy, zName, nName+1);      pMod->zName = zCopy;      pMod->pModule = pModule;      pMod->pAux = pAux;      pMod->xDestroy = xDestroy;      pMod->pEpoTab = 0;      pDel = (Module *)sqlite3HashInsert(&db->aModule,zCopy,(void*)pMod);      assert( pDel==0 || pDel==pMod );      if( pDel ){        db->mallocFailed = 1;        sqlite3DbFree(db, pDel);      }    }  }  rc = sqlite3ApiExit(db, rc);  if( rc!=SQLITE_OK && xDestroy ) xDestroy(pAux);  sqlite3_mutex_leave(db->mutex);  return rc;}

/*** Convert the N-th element of pStmt->pColName[] into a string using** xFunc() then return that string.  If N is out of range, return 0.**** There are up to 5 names for each column.  useType determines which** name is returned.  Here are the names:****    0      The column name as it should be displayed for output**    1      The datatype name for the column**    2      The name of the database that the column derives from**    3      The name of the table that the column derives from**    4      The name of the table column that the result column derives from**** If the result is not a simple column reference (if it is an expression** or a constant) then useTypes 2, 3, and 4 return NULL.*/static const void *columnName(  sqlite3_stmt *pStmt,  int N,  const void *(*xFunc)(Mem*),  int useType){  const void *ret;  Vdbe *p = (Vdbe *)pStmt;  int n = sqlite3_column_count(pStmt);  if( p==0 || N>=n || N<0 ){    return 0;  }  N += useType*n;  ret = xFunc(&p->aColName[N]);  /* A malloc may have failed inside of the xFunc() call. If this is the case,  ** clear the mallocFailed flag and return NULL.  */  sqlite3ApiExit(0, 0);  return ret;}

/*** Return UTF-16 encoded English language explanation of the most recent** error.*/EXPORT_C const void *sqlite3_errmsg16(sqlite3 *db){  /* Because all the characters in the string are in the unicode  ** range 0x00-0xFF, if we pad the big-endian string with a   ** zero byte, we can obtain the little-endian string with  ** &big_endian[1].  */  static const char outOfMemBe[] = {    0, 'o', 0, 'u', 0, 't', 0, ' ',     0, 'o', 0, 'f', 0, ' ',     0, 'm', 0, 'e', 0, 'm', 0, 'o', 0, 'r', 0, 'y', 0, 0, 0  };  static const char misuseBe [] = {    0, 'l', 0, 'i', 0, 'b', 0, 'r', 0, 'a', 0, 'r', 0, 'y', 0, ' ',     0, 'r', 0, 'o', 0, 'u', 0, 't', 0, 'i', 0, 'n', 0, 'e', 0, ' ',     0, 'c', 0, 'a', 0, 'l', 0, 'l', 0, 'e', 0, 'd', 0, ' ',     0, 'o', 0, 'u', 0, 't', 0, ' ',     0, 'o', 0, 'f', 0, ' ',     0, 's', 0, 'e', 0, 'q', 0, 'u', 0, 'e', 0, 'n', 0, 'c', 0, 'e', 0, 0, 0  };  const void *z;  if( !db ){    return (void *)(&outOfMemBe[SQLITE_UTF16NATIVE==SQLITE_UTF16LE?1:0]);  }  if( sqlite3SafetyCheck(db) || db->errCode==SQLITE_MISUSE ){    return (void *)(&misuseBe[SQLITE_UTF16NATIVE==SQLITE_UTF16LE?1:0]);  }  sqlite3_mutex_enter(db->mutex);  assert( !db->mallocFailed );  z = sqlite3_value_text16(db->pErr);  if( z==0 ){    sqlite3ValueSetStr(db->pErr, -1, sqlite3ErrStr(db->errCode),         SQLITE_UTF8, SQLITE_STATIC);    z = sqlite3_value_text16(db->pErr);  }  sqlite3ApiExit(0, 0);  sqlite3_mutex_leave(db->mutex);  return z;}

/*** The following routine destroys a virtual machine that is created by** the sqlite3_compile() routine. The integer returned is an SQLITE_** success/failure code that describes the result of executing the virtual** machine.**** This routine sets the error code and string returned by** sqlite3_errcode(), sqlite3_errmsg() and sqlite3_errmsg16().*/int sqlite3_finalize(sqlite3_stmt *pStmt){  int rc;  if( pStmt==0 ){    /* IMPLEMENTATION-OF: R-57228-12904 Invoking sqlite3_finalize() on a NULL    ** pointer is a harmless no-op. */    rc = SQLITE_OK;  }else{    Vdbe *v = (Vdbe*)pStmt;    sqlite3 *db = v->db;#if SQLITE_THREADSAFE    sqlite3_mutex *mutex;#endif    if( vdbeSafety(v) ) return SQLITE_MISUSE_BKPT;#if SQLITE_THREADSAFE    mutex = v->db->mutex;#endif    sqlite3_mutex_enter(mutex);    rc = sqlite3VdbeFinalize(v);    rc = sqlite3ApiExit(db, rc);    sqlite3_mutex_leave(mutex);  }  return rc;}

/*** The actual function that does the work of creating a new module.** This function implements the sqlite3_create_module() and** sqlite3_create_module_v2() interfaces.*/static int createModule(  sqlite3 *db,                    /* Database in which module is registered */  const char *zName,              /* Name assigned to this module */  const sqlite3_module *pModule,  /* The definition of the module */  void *pAux,                     /* Context pointer for xCreate/xConnect */  void (*xDestroy)(void *)        /* Module destructor function */){  int rc, nName;  Module *pMod;  sqlite3_mutex_enter(db->mutex);  nName = sqlite3Strlen30(zName);  pMod = (Module *)sqlite3DbMallocRaw(db, sizeof(Module) + nName + 1);  if( pMod ){    Module *pDel;    char *zCopy = (char *)(&pMod[1]);    memcpy(zCopy, zName, nName+1);    pMod->zName = zCopy;    pMod->pModule = pModule;    pMod->pAux = pAux;    pMod->xDestroy = xDestroy;    pDel = (Module *)sqlite3HashInsert(&db->aModule, zCopy, nName, (void*)pMod);    if( pDel && pDel->xDestroy ){      pDel->xDestroy(pDel->pAux);    }    sqlite3DbFree(db, pDel);    if( pDel==pMod ){      db->mallocFailed = 1;    }    sqlite3ResetInternalSchema(db, 0);  }else if( xDestroy ){    xDestroy(pAux);  }  rc = sqlite3ApiExit(db, SQLITE_OK);  sqlite3_mutex_leave(db->mutex);  return rc;}

int sqlite3_step(sqlite3_stmt *pStmt){  int rc = SQLITE_MISUSE;  if( pStmt ){    int cnt = 0;    Vdbe *v = (Vdbe*)pStmt;    sqlite3 *db = v->db;    sqlite3_mutex_enter(db->mutex);    while( (rc = sqlite3Step(v))==SQLITE_SCHEMA           && cnt++ < 5           && vdbeReprepare(v) ){      sqlite3_reset(pStmt);      v->expired = 0;    }    if( rc==SQLITE_SCHEMA && v->zSql && db->pErr ){      /* This case occurs after failing to recompile an sql statement.       ** The error message from the SQL compiler has already been loaded       ** into the database handle. This block copies the error message       ** from the database handle into the statement and sets the statement      ** program counter to 0 to ensure that when the statement is       ** finalized or reset the parser error message is available via      ** sqlite3_errmsg() and sqlite3_errcode().      */      const char *zErr = (const char *)sqlite3_value_text(db->pErr);       sqlite3DbFree(db, v->zErrMsg);      if( !db->mallocFailed ){        v->zErrMsg = sqlite3DbStrDup(db, zErr);      } else {        v->zErrMsg = 0;        v->rc = SQLITE_NOMEM;      }    }    rc = sqlite3ApiExit(db, rc);    sqlite3_mutex_leave(db->mutex);  }  return rc;}

//.........这里部分代码省略.........  const char **pzTail       /* OUT: End of parsed string */){  Parse sParse;  char *zErrMsg = 0;  int rc = SQLITE_OK;  int i;  /* Assert that malloc() has not failed */  assert( !sqlite3MallocFailed() );  assert( ppStmt );  *ppStmt = 0;  if( sqlite3SafetyOn(db) ){    return SQLITE_MISUSE;  }  /* If any attached database schemas are locked, do not proceed with  ** compilation. Instead return SQLITE_LOCKED immediately.  */  for(i=0; i<db->nDb; i++) {    Btree *pBt = db->aDb[i].pBt;    if( pBt && sqlite3BtreeSchemaLocked(pBt) ){      const char *zDb = db->aDb[i].zName;      sqlite3Error(db, SQLITE_LOCKED, "database schema is locked: %s", zDb);      sqlite3SafetyOff(db);      return SQLITE_LOCKED;    }  }    memset(&sParse, 0, sizeof(sParse));  sParse.db = db;  if( nBytes>=0 && zSql[nBytes]!=0 ){    char *zSqlCopy = sqlite3StrNDup(zSql, nBytes);    sqlite3RunParser(&sParse, zSqlCopy, &zErrMsg);    sParse.zTail += zSql - zSqlCopy;    sqliteFree(zSqlCopy);  }else{    sqlite3RunParser(&sParse, zSql, &zErrMsg);  }  if( sqlite3MallocFailed() ){    sParse.rc = SQLITE_NOMEM;  }  if( sParse.rc==SQLITE_DONE ) sParse.rc = SQLITE_OK;  if( sParse.checkSchema && !schemaIsValid(db) ){    sParse.rc = SQLITE_SCHEMA;  }  if( sParse.rc==SQLITE_SCHEMA ){    sqlite3ResetInternalSchema(db, 0);  }  if( sqlite3MallocFailed() ){    sParse.rc = SQLITE_NOMEM;  }  if( pzTail ){    *pzTail = sParse.zTail;  }  rc = sParse.rc;#ifndef SQLITE_OMIT_EXPLAIN  if( rc==SQLITE_OK && sParse.pVdbe && sParse.explain ){    if( sParse.explain==2 ){      sqlite3VdbeSetNumCols(sParse.pVdbe, 3);      sqlite3VdbeSetColName(sParse.pVdbe, 0, COLNAME_NAME, "order", P3_STATIC);      sqlite3VdbeSetColName(sParse.pVdbe, 1, COLNAME_NAME, "from", P3_STATIC);      sqlite3VdbeSetColName(sParse.pVdbe, 2, COLNAME_NAME, "detail", P3_STATIC);    }else{      sqlite3VdbeSetNumCols(sParse.pVdbe, 5);      sqlite3VdbeSetColName(sParse.pVdbe, 0, COLNAME_NAME, "addr", P3_STATIC);      sqlite3VdbeSetColName(sParse.pVdbe, 1, COLNAME_NAME, "opcode", P3_STATIC);      sqlite3VdbeSetColName(sParse.pVdbe, 2, COLNAME_NAME, "p1", P3_STATIC);      sqlite3VdbeSetColName(sParse.pVdbe, 3, COLNAME_NAME, "p2", P3_STATIC);      sqlite3VdbeSetColName(sParse.pVdbe, 4, COLNAME_NAME, "p3", P3_STATIC);    }  }#endif  if( sqlite3SafetyOff(db) ){    rc = SQLITE_MISUSE;  }  if( rc==SQLITE_OK ){    if( saveSqlFlag ){      sqlite3VdbeSetSql(sParse.pVdbe, zSql, sParse.zTail - zSql);    }    *ppStmt = (sqlite3_stmt*)sParse.pVdbe;  }else if( sParse.pVdbe ){    sqlite3_finalize((sqlite3_stmt*)sParse.pVdbe);  }  if( zErrMsg ){    sqlite3Error(db, rc, "%s", zErrMsg);    sqliteFree(zErrMsg);  }else{    sqlite3Error(db, rc, 0);  }  rc = sqlite3ApiExit(db, rc);  sqlite3ReleaseThreadData();  assert( (rc&db->errMask)==rc );  return rc;}

//.........这里部分代码省略.........  char const **pzCollSeq,     /* OUTPUT: Collation sequence name */  int *pNotNull,              /* OUTPUT: True if NOT NULL constraint exists */  int *pPrimaryKey,           /* OUTPUT: True if column part of PK */  int *pAutoinc               /* OUTPUT: True if colums is auto-increment */){  int rc;  char *zErrMsg = 0;  Table *pTab = 0;  Column *pCol = 0;  int iCol;  char const *zDataType = 0;  char const *zCollSeq = 0;  int notnull = 0;  int primarykey = 0;  int autoinc = 0;  /* Ensure the database schema has been loaded */  if( sqlite3SafetyOn(db) ){    return SQLITE_MISUSE;  }  rc = sqlite3Init(db, &zErrMsg);  if( SQLITE_OK!=rc ){    goto error_out;  }  /* Locate the table in question */  pTab = sqlite3FindTable(db, zTableName, zDbName);  if( !pTab || pTab->pSelect ){    pTab = 0;    goto error_out;  }  /* Find the column for which info is requested */  if( sqlite3IsRowid(zColumnName) ){    iCol = pTab->iPKey;    if( iCol>=0 ){      pCol = &pTab->aCol[iCol];    }  }else{    for(iCol=0; iCol<pTab->nCol; iCol++){      pCol = &pTab->aCol[iCol];      if( 0==sqlite3StrICmp(pCol->zName, zColumnName) ){        break;      }    }    if( iCol==pTab->nCol ){      pTab = 0;      goto error_out;    }  }  /* The following block stores the meta information that will be returned  ** to the caller in local variables zDataType, zCollSeq, notnull, primarykey  ** and autoinc. At this point there are two possibilities:  **   **     1. The specified column name was rowid", "oid" or "_rowid_"   **        and there is no explicitly declared IPK column.   **  **     2. The table is not a view and the column name identified an   **        explicitly declared column. Copy meta information from *pCol.  */   if( pCol ){    zDataType = pCol->zType;    zCollSeq = pCol->zColl;    notnull = (pCol->notNull?1:0);    primarykey  = (pCol->isPrimKey?1:0);    autoinc = ((pTab->iPKey==iCol && pTab->autoInc)?1:0);  }else{    zDataType = "INTEGER";    primarykey = 1;  }  if( !zCollSeq ){    zCollSeq = "BINARY";  }error_out:  if( sqlite3SafetyOff(db) ){    rc = SQLITE_MISUSE;  }  /* Whether the function call succeeded or failed, set the output parameters  ** to whatever their local counterparts contain. If an error did occur,  ** this has the effect of zeroing all output parameters.  */  if( pzDataType ) *pzDataType = zDataType;  if( pzCollSeq ) *pzCollSeq = zCollSeq;  if( pNotNull ) *pNotNull = notnull;  if( pPrimaryKey ) *pPrimaryKey = primarykey;  if( pAutoinc ) *pAutoinc = autoinc;  if( SQLITE_OK==rc && !pTab ){    sqlite3SetString(&zErrMsg, "no such table column: ", zTableName, ".",         zColumnName, 0);    rc = SQLITE_ERROR;  }  sqlite3Error(db, rc, (zErrMsg?"%s":0), zErrMsg);  sqliteFree(zErrMsg);  return sqlite3ApiExit(db, rc);}

/*** This routine does the work of opening a database on behalf of** sqlite3_open() and sqlite3_open16(). The database filename "zFilename"  ** is UTF-8 encoded.*/static int openDatabase(  const char *zFilename, /* Database filename UTF-8 encoded */  sqlite3 **ppDb         /* OUT: Returned database handle */){  sqlite3 *db;  int rc;  CollSeq *pColl;  assert( !sqlite3MallocFailed() );  /* Allocate the sqlite data structure */  db = sqliteMalloc( sizeof(sqlite3) );  if( db==0 ) goto opendb_out;  db->priorNewRowid = 0;  db->magic = SQLITE_MAGIC_BUSY;  db->nDb = 2;  db->aDb = db->aDbStatic;  db->autoCommit = 1;  db->flags |= SQLITE_ShortColNames;  sqlite3HashInit(&db->aFunc, SQLITE_HASH_STRING, 0);  sqlite3HashInit(&db->aCollSeq, SQLITE_HASH_STRING, 0);  /* Add the default collation sequence BINARY. BINARY works for both UTF-8  ** and UTF-16, so add a version for each to avoid any unnecessary  ** conversions. The only error that can occur here is a malloc() failure.  */  if( createCollation(db, "BINARY", SQLITE_UTF8, 0, binCollFunc) ||      createCollation(db, "BINARY", SQLITE_UTF16BE, 0, binCollFunc) ||      createCollation(db, "BINARY", SQLITE_UTF16LE, 0, binCollFunc) ||      (db->pDfltColl = sqlite3FindCollSeq(db, SQLITE_UTF8, "BINARY", 6, 0))==0   ){    assert( sqlite3MallocFailed() );    db->magic = SQLITE_MAGIC_CLOSED;    goto opendb_out;  }  /* Also add a UTF-8 case-insensitive collation sequence. */  createCollation(db, "NOCASE", SQLITE_UTF8, 0, nocaseCollatingFunc);  /* Set flags on the built-in collating sequences */  db->pDfltColl->type = SQLITE_COLL_BINARY;  pColl = sqlite3FindCollSeq(db, SQLITE_UTF8, "NOCASE", 6, 0);  if( pColl ){    pColl->type = SQLITE_COLL_NOCASE;  }  /* Open the backend database driver */  rc = sqlite3BtreeFactory(db, zFilename, 0, MAX_PAGES, &db->aDb[0].pBt);  if( rc!=SQLITE_OK ){    sqlite3Error(db, rc, 0);    db->magic = SQLITE_MAGIC_CLOSED;    goto opendb_out;  }#ifndef SQLITE_OMIT_PARSER  db->aDb[0].pSchema = sqlite3SchemaGet(db->aDb[0].pBt);  db->aDb[1].pSchema = sqlite3SchemaGet(0);#endif  if( db->aDb[0].pSchema ){    ENC(db) = SQLITE_UTF8;  }  /* The default safety_level for the main database is 'full'; for the temp  ** database it is 'NONE'. This matches the pager layer defaults.    */  db->aDb[0].zName = "main";  db->aDb[0].safety_level = 3;#ifndef SQLITE_OMIT_TEMPDB  db->aDb[1].zName = "temp";  db->aDb[1].safety_level = 1;#endif  /* Register all built-in functions, but do not attempt to read the  ** database schema yet. This is delayed until the first time the database  ** is accessed.  */  if( !sqlite3MallocFailed() ){    sqlite3RegisterBuiltinFunctions(db);    sqlite3Error(db, SQLITE_OK, 0);  }  db->magic = SQLITE_MAGIC_OPEN;opendb_out:  if( SQLITE_NOMEM==(rc = sqlite3_errcode(db)) ){    sqlite3_close(db);    db = 0;  }  *ppDb = db;  return sqlite3ApiExit(0, rc);}

//.........这里部分代码省略.........  while( (rc==SQLITE_OK || (rc==SQLITE_SCHEMA && (++nRetry)<2)) && zSql[0] ){    int nCol;    char **azVals = 0;    pStmt = 0;    rc = sqlite3_prepare(db, zSql, -1, &pStmt, &zLeftover);    assert( rc==SQLITE_OK || pStmt==0 );    if( rc!=SQLITE_OK ){      continue;    }    if( !pStmt ){      /* this happens for a comment or white-space */      zSql = zLeftover;      continue;    }    callbackIsInit = 0;    nCol = sqlite3_column_count(pStmt);    while( 1 ){      int i;      rc = sqlite3_step(pStmt);      /* Invoke the callback function if required */      if( xCallback && (SQLITE_ROW==rc ||           (SQLITE_DONE==rc && !callbackIsInit                           && db->flags&SQLITE_NullCallback)) ){        if( !callbackIsInit ){          azCols = sqlite3DbMallocZero(db, 2*nCol*sizeof(const char*) + 1);          if( azCols==0 ){            goto exec_out;          }          for(i=0; i<nCol; i++){            azCols[i] = (char *)sqlite3_column_name(pStmt, i);            /* sqlite3VdbeSetColName() installs column names as UTF8            ** strings so there is no way for sqlite3_column_name() to fail. */            assert( azCols[i]!=0 );          }          callbackIsInit = 1;        }        if( rc==SQLITE_ROW ){          azVals = &azCols[nCol];          for(i=0; i<nCol; i++){            azVals[i] = (char *)sqlite3_column_text(pStmt, i);            if( !azVals[i] && sqlite3_column_type(pStmt, i)!=SQLITE_NULL ){              db->mallocFailed = 1;              goto exec_out;            }          }        }        if( xCallback(pArg, nCol, azVals, azCols) ){          rc = SQLITE_ABORT;          sqlite3VdbeFinalize((Vdbe *)pStmt);          pStmt = 0;          sqlite3Error(db, SQLITE_ABORT, 0);          goto exec_out;        }      }      if( rc!=SQLITE_ROW ){        rc = sqlite3VdbeFinalize((Vdbe *)pStmt);        pStmt = 0;        if( rc!=SQLITE_SCHEMA ){          nRetry = 0;          zSql = zLeftover;          while( sqlite3Isspace(zSql[0]) ) zSql++;        }        break;      }    }    sqlite3DbFree(db, azCols);    azCols = 0;  }exec_out:  if( pStmt ) sqlite3VdbeFinalize((Vdbe *)pStmt);  sqlite3DbFree(db, azCols);#ifdef SQLITE_ENABLE_SQLRR  SRRecExecEnd(db);#endif  rc = sqlite3ApiExit(db, rc);  if( rc!=SQLITE_OK && ALWAYS(rc==sqlite3_errcode(db)) && pzErrMsg ){    int nErrMsg = 1 + sqlite3Strlen30(sqlite3_errmsg(db));    *pzErrMsg = sqlite3Malloc(nErrMsg);    if( *pzErrMsg ){      memcpy(*pzErrMsg, sqlite3_errmsg(db), nErrMsg);    }else{      rc = SQLITE_NOMEM;      sqlite3Error(db, SQLITE_NOMEM, 0);    }  }else if( pzErrMsg ){    *pzErrMsg = 0;  }  assert( (rc&db->errMask)==rc );  sqlite3_mutex_leave(db->mutex);  return rc;}

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

//.........这里部分代码省略.........  if( zSql==0 ) zSql = "";  sqlite3_mutex_enter(db->mutex);  sqlite3Error(db, SQLITE_OK, 0);  while( (rc==SQLITE_OK || (rc==SQLITE_SCHEMA && (++nRetry)<2)) && zSql[0] ){    int nCol;    char **azVals = 0;    pStmt = 0;    rc = sqlite3_prepare(db, zSql, -1, &pStmt, &zLeftover);    assert( rc==SQLITE_OK || pStmt==0 );    if( rc!=SQLITE_OK ){      continue;    }    if( !pStmt ){      /* this happens for a comment or white-space */      zSql = zLeftover;      continue;    }    nCallback = 0;    nCol = sqlite3_column_count(pStmt);    while( 1 ){      int i;      rc = sqlite3_step(pStmt);      /* Invoke the callback function if required */      if( xCallback && (SQLITE_ROW==rc ||           (SQLITE_DONE==rc && !nCallback && db->flags&SQLITE_NullCallback)) ){        if( 0==nCallback ){          if( azCols==0 ){            azCols = sqlite3DbMallocZero(db, 2*nCol*sizeof(const char*) + 1);            if( azCols==0 ){              goto exec_out;            }          }          for(i=0; i<nCol; i++){            azCols[i] = (char *)sqlite3_column_name(pStmt, i);            /* sqlite3VdbeSetColName() installs column names as UTF8            ** strings so there is no way for sqlite3_column_name() to fail. */            assert( azCols[i]!=0 );          }          nCallback++;        }        if( rc==SQLITE_ROW ){          azVals = &azCols[nCol];          for(i=0; i<nCol; i++){            azVals[i] = (char *)sqlite3_column_text(pStmt, i);            if( !azVals[i] && sqlite3_column_type(pStmt, i)!=SQLITE_NULL ){              db->mallocFailed = 1;              goto exec_out;            }          }        }        if( xCallback(pArg, nCol, azVals, azCols) ){          rc = SQLITE_ABORT;          sqlite3_finalize(pStmt);          pStmt = 0;          sqlite3Error(db, SQLITE_ABORT, 0);          goto exec_out;        }      }      if( rc!=SQLITE_ROW ){        rc = sqlite3_finalize(pStmt);        pStmt = 0;        if( rc!=SQLITE_SCHEMA ){          nRetry = 0;          zSql = zLeftover;          while( sqlite3Isspace(zSql[0]) ) zSql++;        }        break;      }    }    sqlite3DbFree(db, azCols);    azCols = 0;  }exec_out:  if( pStmt ) sqlite3_finalize(pStmt);  sqlite3DbFree(db, azCols);  rc = sqlite3ApiExit(db, rc);  if( rc!=SQLITE_OK && rc==sqlite3_errcode(db) && pzErrMsg ){    int nErrMsg = 1 + sqlite3Strlen30(sqlite3_errmsg(db));    *pzErrMsg = sqlite3Malloc(nErrMsg);    if( *pzErrMsg ){      memcpy(*pzErrMsg, sqlite3_errmsg(db), nErrMsg);    }  }else if( pzErrMsg ){    *pzErrMsg = 0;  }  assert( (rc&db->errMask)==rc );  sqlite3_mutex_leave(db->mutex);  return rc;}

/*** Execute SQL code.  Return one of the SQLITE_ success/failure** codes.  Also write an error message into memory obtained from** malloc() and make *pzErrMsg point to that message.**** If the SQL is a query, then for each row in the query result** the xCallback() function is called.  pArg becomes the first** argument to xCallback().  If xCallback=NULL then no callback** is invoked, even for queries.*/int sqlite3_exec(  sqlite3 *db,                /* The database on which the SQL executes */  const char *zSql,           /* The SQL to be executed */  sqlite3_callback xCallback, /* Invoke this callback routine */  void *pArg,                 /* First argument to xCallback() */  char **pzErrMsg             /* Write error messages here */){  int rc = SQLITE_OK;  const char *zLeftover;  sqlite3_stmt *pStmt = 0;  char **azCols = 0;  int nRetry = 0;  int nCallback;  if( zSql==0 ) return SQLITE_OK;  while( (rc==SQLITE_OK || (rc==SQLITE_SCHEMA && (++nRetry)<2)) && zSql[0] ){    int nCol;    char **azVals = 0;    pStmt = 0;    rc = sqlite3_prepare(db, zSql, -1, &pStmt, &zLeftover);    assert( rc==SQLITE_OK || pStmt==0 );    if( rc!=SQLITE_OK ){      continue;    }    if( !pStmt ){      /* this happens for a comment or white-space */      zSql = zLeftover;      continue;    }    nCallback = 0;    nCol = sqlite3_column_count(pStmt);    azCols = sqliteMalloc(2*nCol*sizeof(const char *) + 1);    if( azCols==0 ){      goto exec_out;    }    while( 1 ){      int i;      rc = sqlite3_step(pStmt);      /* Invoke the callback function if required */      if( xCallback && (SQLITE_ROW==rc ||           (SQLITE_DONE==rc && !nCallback && db->flags&SQLITE_NullCallback)) ){        if( 0==nCallback ){          for(i=0; i<nCol; i++){            azCols[i] = (char *)sqlite3_column_name(pStmt, i);          }          nCallback++;        }        if( rc==SQLITE_ROW ){          azVals = &azCols[nCol];          for(i=0; i<nCol; i++){            azVals[i] = (char *)sqlite3_column_text(pStmt, i);          }        }        if( xCallback(pArg, nCol, azVals, azCols) ){          rc = SQLITE_ABORT;          goto exec_out;        }      }      if( rc!=SQLITE_ROW ){        rc = sqlite3_finalize(pStmt);        pStmt = 0;        if( rc!=SQLITE_SCHEMA ){          nRetry = 0;          zSql = zLeftover;          while( isspace((unsigned char)zSql[0]) ) zSql++;        }        break;      }    }    sqliteFree(azCols);    azCols = 0;  }exec_out:  if( pStmt ) sqlite3_finalize(pStmt);  if( azCols ) sqliteFree(azCols);  rc = sqlite3ApiExit(0, rc);  if( rc!=SQLITE_OK && rc==sqlite3_errcode(db) && pzErrMsg ){    int nErrMsg = 1 + strlen(sqlite3_errmsg(db));    *pzErrMsg = sqlite3_malloc(nErrMsg);    if( *pzErrMsg ){//.........这里部分代码省略.........

//.........这里部分代码省略.........      /* 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);      sqlite3DbFree(db, zErr);      zErr = sqlite3MPrintf(db, sqlite3_errmsg(db));      v = 0;    }  } while( nAttempt<5 && rc==SQLITE_SCHEMA );  if( rc==SQLITE_ROW ){    /* The row-record has been opened successfully. Check that the    ** column in question contains text or a blob. If it contains    ** text, it is up to the caller to get the encoding right.    */    Incrblob *pBlob;    u32 type = v->apCsr[0]->aType[iCol];    if( type<12 ){      sqlite3DbFree(db, zErr);      zErr = sqlite3MPrintf(db, "cannot open value of type %s",          type==0?"null": type==7?"real": "integer"      );      rc = SQLITE_ERROR;      goto blob_open_out;    }    pBlob = (Incrblob *)sqlite3DbMallocZero(db, sizeof(Incrblob));    if( db->mallocFailed ){      sqlite3DbFree(db, pBlob);      goto blob_open_out;    }    pBlob->flags = flags;    pBlob->pCsr =  v->apCsr[0]->pCursor;    sqlite3BtreeEnterCursor(pBlob->pCsr);    sqlite3BtreeCacheOverflow(pBlob->pCsr);    sqlite3BtreeLeaveCursor(pBlob->pCsr);    pBlob->pStmt = (sqlite3_stmt *)v;    pBlob->iOffset = v->apCsr[0]->aOffset[iCol];    pBlob->nByte = sqlite3VdbeSerialTypeLen(type);    pBlob->db = db;    *ppBlob = (sqlite3_blob *)pBlob;    rc = SQLITE_OK;  }else if( rc==SQLITE_OK ){    sqlite3DbFree(db, zErr);    zErr = sqlite3MPrintf(db, "no such rowid: %lld", iRow);    rc = SQLITE_ERROR;  }blob_open_out:  if( v && (rc!=SQLITE_OK || db->mallocFailed) ){    sqlite3VdbeFinalize(v);  }  sqlite3Error(db, rc, zErr);  sqlite3DbFree(db, zErr);  sqlite3StackFree(db, pParse);  rc = sqlite3ApiExit(db, rc);  sqlite3_mutex_leave(db->mutex);  return rc;}

//.........这里部分代码省略.........    if( p->rc==SQLITE_BUSY || p->rc==SQLITE_LOCKED ){      sqlite3_reset((sqlite3_stmt*)p);    }else{      return SQLITE_MISUSE_BKPT;    }#else    sqlite3_reset((sqlite3_stmt*)p);#endif  }  /* Check that malloc() has not failed. If it has, return early. */  db = p->db;  if( db->mallocFailed ){    p->rc = SQLITE_NOMEM;    return SQLITE_NOMEM;  }  if( p->pc<=0 && p->expired ){    p->rc = SQLITE_SCHEMA;    rc = SQLITE_ERROR;    goto end_of_step;  }  if( p->pc<0 ){    /* If there are no other statements currently running, then    ** reset the interrupt flag.  This prevents a call to sqlite3_interrupt    ** from interrupting a statement that has not yet started.    */    if( db->nVdbeActive==0 ){      db->u1.isInterrupted = 0;    }    assert( db->nVdbeWrite>0 || db->autoCommit==0         || (db->nDeferredCons==0 && db->nDeferredImmCons==0)    );#ifndef SQLITE_OMIT_TRACE    if( db->xProfile && !db->init.busy ){      sqlite3OsCurrentTimeInt64(db->pVfs, &p->startTime);    }#endif    db->nVdbeActive++;    if( p->readOnly==0 ) db->nVdbeWrite++;    if( p->bIsReader ) db->nVdbeRead++;    p->pc = 0;  }#ifndef SQLITE_OMIT_EXPLAIN  if( p->explain ){    rc = sqlite3VdbeList(p);  }else#endif /* SQLITE_OMIT_EXPLAIN */  {    db->nVdbeExec++;    rc = sqlite3VdbeExec(p);    db->nVdbeExec--;  }#ifndef SQLITE_OMIT_TRACE  /* Invoke the profile callback if there is one  */  if( rc!=SQLITE_ROW && db->xProfile && !db->init.busy && p->zSql ){    sqlite3_int64 iNow;    sqlite3OsCurrentTimeInt64(db->pVfs, &iNow);    db->xProfile(db->pProfileArg, p->zSql, (iNow - p->startTime)*1000000);  }#endif  if( rc==SQLITE_DONE ){    assert( p->rc==SQLITE_OK );    p->rc = doWalCallbacks(db);    if( p->rc!=SQLITE_OK ){      rc = SQLITE_ERROR;    }  }  db->errCode = rc;  if( SQLITE_NOMEM==sqlite3ApiExit(p->db, p->rc) ){    p->rc = SQLITE_NOMEM;  }end_of_step:  /* At this point local variable rc holds the value that should be   ** returned if this statement was compiled using the legacy   ** sqlite3_prepare() interface. According to the docs, this can only  ** be one of the values in the first assert() below. Variable p->rc   ** contains the value that would be returned if sqlite3_finalize()   ** were called on statement p.  */  assert( rc==SQLITE_ROW  || rc==SQLITE_DONE   || rc==SQLITE_ERROR        || rc==SQLITE_BUSY || rc==SQLITE_MISUSE  );  assert( p->rc!=SQLITE_ROW && p->rc!=SQLITE_DONE );  if( p->isPrepareV2 && rc!=SQLITE_ROW && rc!=SQLITE_DONE ){    /* If this statement was prepared using sqlite3_prepare_v2(), and an    ** error has occurred, then return the error code in p->rc to the    ** caller. Set the error code in the database handle to the same value.    */     rc = sqlite3VdbeTransferError(p);  }  return (rc&db->errMask);}

//.........这里部分代码省略.........  }  if( p->pc<=0 && p->expired ){    if( p->rc==SQLITE_OK ){      p->rc = SQLITE_SCHEMA;    }    rc = SQLITE_ERROR;    goto end_of_step;  }  db = p->db;  if( sqlite3SafetyOn(db) ){    p->rc = SQLITE_MISUSE;    return SQLITE_MISUSE;  }  if( p->pc<0 ){    /* If there are no other statements currently running, then    ** reset the interrupt flag.  This prevents a call to sqlite3_interrupt    ** from interrupting a statement that has not yet started.    */    if( db->activeVdbeCnt==0 ){      db->u1.isInterrupted = 0;    }#ifndef SQLITE_OMIT_TRACE    /* Invoke the trace callback if there is one    */    if( db->xTrace && !db->init.busy ){      assert( p->nOp>0 );      assert( p->aOp[p->nOp-1].opcode==OP_Noop );      assert( p->aOp[p->nOp-1].p3!=0 );      assert( p->aOp[p->nOp-1].p3type==P3_DYNAMIC );      sqlite3SafetyOff(db);      db->xTrace(db->pTraceArg, p->aOp[p->nOp-1].p3);      if( sqlite3SafetyOn(db) ){        p->rc = SQLITE_MISUSE;        return SQLITE_MISUSE;      }    }    if( db->xProfile && !db->init.busy ){      double rNow;      sqlite3OsCurrentTime(&rNow);      p->startTime = (rNow - (int)rNow)*3600.0*24.0*1000000000.0;    }#endif    /* Print a copy of SQL as it is executed if the SQL_TRACE pragma is turned    ** on in debugging mode.    */#ifdef SQLITE_DEBUG    if( (db->flags & SQLITE_SqlTrace)!=0 ){      sqlite3DebugPrintf("SQL-trace: %s/n", p->aOp[p->nOp-1].p3);    }#endif /* SQLITE_DEBUG */    db->activeVdbeCnt++;    p->pc = 0;  }#ifndef SQLITE_OMIT_EXPLAIN  if( p->explain ){    rc = sqlite3VdbeList(p);  }else#endif /* SQLITE_OMIT_EXPLAIN */  {    rc = sqlite3VdbeExec(p);  }  if( sqlite3SafetyOff(db) ){    rc = SQLITE_MISUSE;  }#ifndef SQLITE_OMIT_TRACE  /* Invoke the profile callback if there is one  */  if( rc!=SQLITE_ROW && db->xProfile && !db->init.busy ){    double rNow;    u64 elapseTime;    sqlite3OsCurrentTime(&rNow);    elapseTime = (rNow - (int)rNow)*3600.0*24.0*1000000000.0 - p->startTime;    assert( p->nOp>0 );    assert( p->aOp[p->nOp-1].opcode==OP_Noop );    assert( p->aOp[p->nOp-1].p3!=0 );    assert( p->aOp[p->nOp-1].p3type==P3_DYNAMIC );    db->xProfile(db->pProfileArg, p->aOp[p->nOp-1].p3, elapseTime);  }#endif  sqlite3Error(p->db, rc, 0);  p->rc = sqlite3ApiExit(p->db, p->rc);end_of_step:  assert( (rc&0xff)==rc );  if( p->zSql && (rc&0xff)<SQLITE_ROW ){    /* This behavior occurs if sqlite3_prepare_v2() was used to build    ** the prepared statement.  Return error codes directly */    return p->rc;  }else{    /* This is for legacy sqlite3_prepare() builds and when the code    ** is SQLITE_ROW or SQLITE_DONE */    return rc;  }}

/*** This function is used to set the schema of a virtual table.  It is only** valid to call this function from within the xCreate() or xConnect() of a** virtual table module.*/int sqlite3_declare_vtab(sqlite3 *db, const char *zCreateTable){  VtabCtx *pCtx;  Parse *pParse;  int rc = SQLITE_OK;  Table *pTab;  char *zErr = 0;#ifdef SQLITE_ENABLE_API_ARMOR  if( !sqlite3SafetyCheckOk(db) || zCreateTable==0 ){    return SQLITE_MISUSE_BKPT;  }#endif  sqlite3_mutex_enter(db->mutex);  pCtx = db->pVtabCtx;  if( !pCtx || pCtx->bDeclared ){    sqlite3Error(db, SQLITE_MISUSE);    sqlite3_mutex_leave(db->mutex);    return SQLITE_MISUSE_BKPT;  }  pTab = pCtx->pTab;  assert( (pTab->tabFlags & TF_Virtual)!=0 );  pParse = sqlite3StackAllocZero(db, sizeof(*pParse));  if( pParse==0 ){    rc = SQLITE_NOMEM_BKPT;  }else{    pParse->declareVtab = 1;    pParse->db = db;    pParse->nQueryLoop = 1;      if( SQLITE_OK==sqlite3RunParser(pParse, zCreateTable, &zErr)      && pParse->pNewTable     && !db->mallocFailed     && !pParse->pNewTable->pSelect     && (pParse->pNewTable->tabFlags & TF_Virtual)==0    ){      if( !pTab->aCol ){        Table *pNew = pParse->pNewTable;        Index *pIdx;        pTab->aCol = pNew->aCol;        pTab->nCol = pNew->nCol;        pTab->tabFlags |= pNew->tabFlags & (TF_WithoutRowid|TF_NoVisibleRowid);        pNew->nCol = 0;        pNew->aCol = 0;        assert( pTab->pIndex==0 );        if( !HasRowid(pNew) && pCtx->pVTable->pMod->pModule->xUpdate!=0 ){          rc = SQLITE_ERROR;        }        pIdx = pNew->pIndex;        if( pIdx ){          assert( pIdx->pNext==0 );          pTab->pIndex = pIdx;          pNew->pIndex = 0;          pIdx->pTable = pTab;        }      }      pCtx->bDeclared = 1;    }else{      sqlite3ErrorWithMsg(db, SQLITE_ERROR, (zErr ? "%s" : 0), zErr);      sqlite3DbFree(db, zErr);      rc = SQLITE_ERROR;    }    pParse->declareVtab = 0;      if( pParse->pVdbe ){      sqlite3VdbeFinalize(pParse->pVdbe);    }    sqlite3DeleteTable(db, pParse->pNewTable);    sqlite3ParserReset(pParse);    sqlite3StackFree(db, pParse);  }  assert( (rc&0xff)==rc );  rc = sqlite3ApiExit(db, rc);  sqlite3_mutex_leave(db->mutex);  return rc;}

/*** Execute the statement pStmt, either until a row of data is ready, the** statement is completely executed or an error occurs.**** This routine implements the bulk of the logic behind the sqlite_step()** API.  The only thing omitted is the automatic recompile if a ** schema change has occurred.  That detail is handled by the** outer sqlite3_step() wrapper procedure.*/static int sqlite3Step(Vdbe *p){  sqlite3 *db;  int rc;  assert(p);  if( p->magic!=VDBE_MAGIC_RUN ){    return SQLITE_MISUSE;  }  /* Assert that malloc() has not failed */  db = p->db;  if( db->mallocFailed ){    return SQLITE_NOMEM;  }  if( p->pc<=0 && p->expired ){    if( p->rc==SQLITE_OK ){      p->rc = SQLITE_SCHEMA;    }    rc = SQLITE_ERROR;    goto end_of_step;  }  if( sqlite3SafetyOn(db) ){    p->rc = SQLITE_MISUSE;    return SQLITE_MISUSE;  }  if( p->pc<0 ){    /* If there are no other statements currently running, then    ** reset the interrupt flag.  This prevents a call to sqlite3_interrupt    ** from interrupting a statement that has not yet started.    */    if( db->activeVdbeCnt==0 ){      db->u1.isInterrupted = 0;    }#ifndef SQLITE_OMIT_TRACE    if( db->xProfile && !db->init.busy ){      double rNow;      sqlite3OsCurrentTime(db->pVfs, &rNow);      p->startTime = (rNow - (int)rNow)*3600.0*24.0*1000000000.0;    }#endif    db->activeVdbeCnt++;    p->pc = 0;    stmtLruRemove(p);  }#ifndef SQLITE_OMIT_EXPLAIN  if( p->explain ){    rc = sqlite3VdbeList(p);  }else#endif /* SQLITE_OMIT_EXPLAIN */  {    rc = sqlite3VdbeExec(p);  }  if( sqlite3SafetyOff(db) ){    rc = SQLITE_MISUSE;  }#ifndef SQLITE_OMIT_TRACE  /* Invoke the profile callback if there is one  */  if( rc!=SQLITE_ROW && db->xProfile && !db->init.busy && p->nOp>0           && p->aOp[0].opcode==OP_Trace && p->aOp[0].p4.z!=0 ){    double rNow;    u64 elapseTime;    sqlite3OsCurrentTime(db->pVfs, &rNow);    elapseTime = (rNow - (int)rNow)*3600.0*24.0*1000000000.0 - p->startTime;    db->xProfile(db->pProfileArg, p->aOp[0].p4.z, elapseTime);  }#endif  db->errCode = rc;  /*sqlite3Error(p->db, rc, 0);*/  p->rc = sqlite3ApiExit(p->db, p->rc);end_of_step:  assert( (rc&0xff)==rc );  if( p->zSql && (rc&0xff)<SQLITE_ROW ){    /* This behavior occurs if sqlite3_prepare_v2() was used to build    ** the prepared statement.  Return error codes directly */    p->db->errCode = p->rc;    /* sqlite3Error(p->db, p->rc, 0); */    return p->rc;  }else{    /* This is for legacy sqlite3_prepare() builds and when the code    ** is SQLITE_ROW or SQLITE_DONE */    return rc;  }}