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

/*** Evaluate a view and store its result in an ephemeral table.  The** pWhere argument is an optional WHERE clause that restricts the** set of rows in the view that are to be added to the ephemeral table.*/void sqlite3MaterializeView(  Parse *pParse,       /* Parsing context */  Table *pView,        /* View definition */  Expr *pWhere,        /* Optional WHERE clause to be added */  int iCur             /* Cursor number for ephemerial table */){  SelectDest dest;  Select *pSel;  SrcList *pFrom;  sqlite3 *db = pParse->db;  int iDb = sqlite3SchemaToIndex(db, pView->pSchema);  pWhere = sqlite3ExprDup(db, pWhere, 0);  pFrom = sqlite3SrcListAppend(db, 0, 0, 0);  if( pFrom ){    assert( pFrom->nSrc==1 );    pFrom->a[0].zName = sqlite3DbStrDup(db, pView->zName);    pFrom->a[0].zDatabase = sqlite3DbStrDup(db, db->aDb[iDb].zName);    assert( pFrom->a[0].pOn==0 );    assert( pFrom->a[0].pUsing==0 );  }  pSel = sqlite3SelectNew(pParse, 0, pFrom, pWhere, 0, 0, 0, 0, 0, 0);  if( pSel ) pSel->selFlags |= SF_Materialize;  sqlite3SelectDestInit(&dest, SRT_EphemTab, iCur);  sqlite3Select(pParse, pSel, &dest);  sqlite3SelectDelete(db, pSel);}

/*** Evaluate a view and store its result in an ephemeral table.  The** pWhere argument is an optional WHERE clause that restricts the** set of rows in the view that are to be added to the ephemeral table.*/void sqlite3MaterializeView(  Parse *pParse,       /* Parsing context */  Table *pView,        /* View definition */  Expr *pWhere,        /* Optional WHERE clause to be added */  int iCur             /* Cursor number for ephemerial table */){  SelectDest dest;  Select *pDup;  sqlite3 *db = pParse->db;  pDup = sqlite3SelectDup(db, pView->pSelect, 0);  if( pWhere ){    SrcList *pFrom;        pWhere = sqlite3ExprDup(db, pWhere, 0);    pFrom = sqlite3SrcListAppend(db, 0, 0, 0);    if( pFrom ){      assert( pFrom->nSrc==1 );      pFrom->a[0].zAlias = sqlite3DbStrDup(db, pView->zName);      pFrom->a[0].pSelect = pDup;      assert( pFrom->a[0].pOn==0 );      assert( pFrom->a[0].pUsing==0 );    }else{      sqlite3SelectDelete(db, pDup);    }    pDup = sqlite3SelectNew(pParse, 0, pFrom, pWhere, 0, 0, 0, 0, 0, 0);    if( pDup ) pDup->selFlags |= SF_Materialize;  }  sqlite3SelectDestInit(&dest, SRT_EphemTab, iCur);  sqlite3Select(pParse, pDup, &dest);  sqlite3SelectDelete(db, pDup);}

/*** The following set of routines walk through the parse tree and assign** a specific database to all table references where the database name** was left unspecified in the original SQL statement.  The pFix structure** must have been initialized by a prior call to sqlite3FixInit().**** These routines are used to make sure that an index, trigger, or** view in one database does not refer to objects in a different database.** (Exception: indices, triggers, and views in the TEMP database are** allowed to refer to anything.)  If a reference is explicitly made** to an object in a different database, an error message is added to** pParse->zErrMsg and these routines return non-zero.  If everything** checks out, these routines return 0.*/int sqlite3FixSrcList(  DbFixer *pFix,       /* Context of the fixation */  SrcList *pList       /* The Source list to check and modify */){  int i;  const char *zDb;  struct SrcList_item *pItem;  if( NEVER(pList==0) ) return 0;  zDb = pFix->zDb;  for(i=0, pItem=pList->a; i<pList->nSrc; i++, pItem++){    if( pItem->zDatabase==0 ){      pItem->zDatabase = sqlite3DbStrDup(pFix->pParse->db, zDb);    }else if( sqlite3StrICmp(pItem->zDatabase,zDb)!=0 ){      sqlite3ErrorMsg(pFix->pParse,         "%s %T cannot reference objects in database %s",         pFix->zType, pFix->pName, pItem->zDatabase);      return 1;    }#if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_TRIGGER)    if( sqlite3FixSelect(pFix, pItem->pSelect) ) return 1;    if( sqlite3FixExpr(pFix, pItem->pOn) ) return 1;#endif  }  return 0;}

/*** Usage: client_compile ID SQL**** Compile a new virtual machine.*/static int tcl_client_compile(  void *NotUsed,  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */  int argc,              /* Number of arguments */  const char **argv      /* Text of each argument */){  int i;  if( argc!=3 ){    Tcl_AppendResult(interp, "wrong # args: should be /"", argv[0],       " ID SQL", 0);    return TCL_ERROR;  }  i = parse_client_id(interp, argv[1]);  if( i<0 ) return TCL_ERROR;  if( !threadset[i].busy ){    Tcl_AppendResult(interp, "no such thread", 0);    return TCL_ERROR;  }  client_wait(&threadset[i]);  threadset[i].xOp = do_compile;  sqlite3_free(threadset[i].zArg);  threadset[i].zArg = sqlite3DbStrDup(0, argv[2]);  threadset[i].opnum++;  return TCL_OK;}

/*** The first parameter (pDef) is a function implementation.  The** second parameter (pExpr) is the first argument to this function.** If pExpr is a column in a virtual table, then let the virtual** table implementation have an opportunity to overload the function.**** This routine is used to allow virtual table implementations to** overload MATCH, LIKE, GLOB, and REGEXP operators.**** Return either the pDef argument (indicating no change) or a ** new FuncDef structure that is marked as ephemeral using the** SQLITE_FUNC_EPHEM flag.*/FuncDef *sqlite3VtabOverloadFunction(  sqlite3 *db,    /* Database connection for reporting malloc problems */  FuncDef *pDef,  /* Function to possibly overload */  int nArg,       /* Number of arguments to the function */  Expr *pExpr     /* First argument to the function */){  Table *pTab;  sqlite3_vtab *pVtab;  sqlite3_module *pMod;  void (*xSFunc)(sqlite3_context*,int,sqlite3_value**) = 0;  void *pArg = 0;  FuncDef *pNew;  int rc = 0;  char *zLowerName;  unsigned char *z;  /* Check to see the left operand is a column in a virtual table */  if( NEVER(pExpr==0) ) return pDef;  if( pExpr->op!=TK_COLUMN ) return pDef;  pTab = pExpr->pTab;  if( NEVER(pTab==0) ) return pDef;  if( (pTab->tabFlags & TF_Virtual)==0 ) return pDef;  pVtab = sqlite3GetVTable(db, pTab)->pVtab;  assert( pVtab!=0 );  assert( pVtab->pModule!=0 );  pMod = (sqlite3_module *)pVtab->pModule;  if( pMod->xFindFunction==0 ) return pDef;   /* Call the xFindFunction method on the virtual table implementation  ** to see if the implementation wants to overload this function   */  zLowerName = sqlite3DbStrDup(db, pDef->zName);  if( zLowerName ){    for(z=(unsigned char*)zLowerName; *z; z++){      *z = sqlite3UpperToLower[*z];    }    rc = pMod->xFindFunction(pVtab, nArg, zLowerName, &xSFunc, &pArg);    sqlite3DbFree(db, zLowerName);  }  if( rc==0 ){    return pDef;  }  /* Create a new ephemeral function definition for the overloaded  ** function */  pNew = sqlite3DbMallocZero(db, sizeof(*pNew)                             + sqlite3Strlen30(pDef->zName) + 1);  if( pNew==0 ){    return pDef;  }  *pNew = *pDef;  pNew->zName = (const char*)&pNew[1];  memcpy((char*)&pNew[1], pDef->zName, sqlite3Strlen30(pDef->zName)+1);  pNew->xSFunc = xSFunc;  pNew->pUserData = pArg;  pNew->funcFlags |= SQLITE_FUNC_EPHEM;  return pNew;}

/*** The parser calls this routine when it first sees a CREATE VIRTUAL TABLE** statement.  The module name has been parsed, but the optional list** of parameters that follow the module name are still pending.*/void sqlite3VtabBeginParse(  Parse *pParse,        /* Parsing context */  Token *pName1,        /* Name of new table, or database name */  Token *pName2,        /* Name of new table or NULL */  Token *pModuleName    /* Name of the module for the virtual table */){  int iDb;              /* The database the table is being created in */  Table *pTable;        /* The new virtual table */  sqlite3 *db;          /* Database connection */  if( pParse->db->flags & SQLITE_SharedCache ){    sqlite3ErrorMsg(pParse, "Cannot use virtual tables in shared-cache mode");    return;  }  sqlite3StartTable(pParse, pName1, pName2, 0, 0, 1, 0);  pTable = pParse->pNewTable;  if( pTable==0 || pParse->nErr ) return;  assert( 0==pTable->pIndex );  db = pParse->db;  iDb = sqlite3SchemaToIndex(db, pTable->pSchema);  assert( iDb>=0 );  pTable->isVirtual = 1;  pTable->nModuleArg = 0;  addModuleArgument(db, pTable, sqlite3NameFromToken(db, pModuleName));  addModuleArgument(db, pTable, sqlite3DbStrDup(db, db->aDb[iDb].zName));  addModuleArgument(db, pTable, sqlite3DbStrDup(db, pTable->zName));  pParse->sNameToken.n = pModuleName->z + pModuleName->n - pName1->z;#ifndef SQLITE_OMIT_AUTHORIZATION  /* Creating a virtual table invokes the authorization callback twice.  ** The first invocation, to obtain permission to INSERT a row into the  ** sqlite_master table, has already been made by sqlite3StartTable().  ** The second call, to obtain permission to create the table, is made now.  */  if( pTable->azModuleArg ){    sqlite3AuthCheck(pParse, SQLITE_CREATE_VTABLE, pTable->zName,             pTable->azModuleArg[0], pParse->db->aDb[iDb].zName);  }#endif}

/*** Convert the pStep->zTarget string into a SrcList and return a pointer** to that SrcList.**** This routine adds a specific database name, if needed, to the target when** forming the SrcList.  This prevents a trigger in one database from** referring to a target in another database.  An exception is when the** trigger is in TEMP in which case it can refer to any other database it** wants.*/static SrcList *targetSrcList(  Parse *pParse,       /* The parsing context */  TriggerStep *pStep   /* The trigger containing the target token */){  sqlite3 *db = pParse->db;  int iDb;             /* Index of the database to use */  SrcList *pSrc;       /* SrcList to be returned */  pSrc = sqlite3SrcListAppend(db, 0, 0, 0);  if( pSrc ){    assert( pSrc->nSrc>0 );    pSrc->a[pSrc->nSrc-1].zName = sqlite3DbStrDup(db, pStep->zTarget);    iDb = sqlite3SchemaToIndex(db, pStep->pTrig->pSchema);    if( iDb==0 || iDb>=2 ){      assert( iDb<db->nDb );      pSrc->a[pSrc->nSrc-1].zDatabase = sqlite3DbStrDup(db, db->aDb[iDb].zName);    }  }  return pSrc;}

/*** Turn the pExpr expression into an alias for the iCol-th column of the** result set in pEList.**** If the result set column is a simple column reference, then this routine** makes an exact copy.  But for any other kind of expression, this** routine make a copy of the result set column as the argument to the** TK_AS operator.  The TK_AS operator causes the expression to be** evaluated just once and then reused for each alias.**** The reason for suppressing the TK_AS term when the expression is a simple** column reference is so that the column reference will be recognized as** usable by indices within the WHERE clause processing logic. **** Hack:  The TK_AS operator is inhibited if zType[0]=='G'.  This means** that in a GROUP BY clause, the expression is evaluated twice.  Hence:****     SELECT random()%5 AS x, count(*) FROM tab GROUP BY x**** Is equivalent to:****     SELECT random()%5 AS x, count(*) FROM tab GROUP BY random()%5**** The result of random()%5 in the GROUP BY clause is probably different** from the result in the result-set.  We might fix this someday.  Or** then again, we might not...*/static void resolveAlias(  Parse *pParse,         /* Parsing context */  ExprList *pEList,      /* A result set */  int iCol,              /* A column in the result set.  0..pEList->nExpr-1 */  Expr *pExpr,           /* Transform this into an alias to the result set */  const char *zType      /* "GROUP" or "ORDER" or "" */){  Expr *pOrig;           /* The iCol-th column of the result set */  Expr *pDup;            /* Copy of pOrig */  sqlite3 *db;           /* The database connection */  assert( iCol>=0 && iCol<pEList->nExpr );  pOrig = pEList->a[iCol].pExpr;  assert( pOrig!=0 );  assert( pOrig->flags & EP_Resolved );  db = pParse->db;  if( pOrig->op!=TK_COLUMN && zType[0]!='G' ){    pDup = sqlite3ExprDup(db, pOrig, 0);    pDup = sqlite3PExpr(pParse, TK_AS, pDup, 0, 0);    if( pDup==0 ) return;    if( pEList->a[iCol].iAlias==0 ){      pEList->a[iCol].iAlias = (u16)(++pParse->nAlias);    }    pDup->iTable = pEList->a[iCol].iAlias;  }else if( ExprHasProperty(pOrig, EP_IntValue) || pOrig->u.zToken==0 ){    pDup = sqlite3ExprDup(db, pOrig, 0);    if( pDup==0 ) return;  }else{    char *zToken = pOrig->u.zToken;    assert( zToken!=0 );    pOrig->u.zToken = 0;    pDup = sqlite3ExprDup(db, pOrig, 0);    pOrig->u.zToken = zToken;    if( pDup==0 ) return;    assert( (pDup->flags & (EP_Reduced|EP_TokenOnly))==0 );    pDup->flags2 |= EP2_MallocedToken;    pDup->u.zToken = sqlite3DbStrDup(db, zToken);  }  if( pExpr->flags & EP_ExpCollate ){    pDup->pColl = pExpr->pColl;    pDup->flags |= EP_ExpCollate;  }  /* Before calling sqlite3ExprDelete(), set the EP_Static flag. This   ** prevents ExprDelete() from deleting the Expr structure itself,  ** allowing it to be repopulated by the memcpy() on the following line.  */  ExprSetProperty(pExpr, EP_Static);  sqlite3ExprDelete(db, pExpr);  memcpy(pExpr, pDup, sizeof(*pExpr));  sqlite3DbFree(db, pDup);}

/*** Turn the pExpr expression into an alias for the iCol-th column of the** result set in pEList.**** If the result set column is a simple column reference, then this routine** makes an exact copy.  But for any other kind of expression, this** routine make a copy of the result set column as the argument to the** TK_AS operator.  The TK_AS operator causes the expression to be** evaluated just once and then reused for each alias.**** The reason for suppressing the TK_AS term when the expression is a simple** column reference is so that the column reference will be recognized as** usable by indices within the WHERE clause processing logic. **** The TK_AS operator is inhibited if zType[0]=='G'.  This means** that in a GROUP BY clause, the expression is evaluated twice.  Hence:****     SELECT random()%5 AS x, count(*) FROM tab GROUP BY x**** Is equivalent to:****     SELECT random()%5 AS x, count(*) FROM tab GROUP BY random()%5**** The result of random()%5 in the GROUP BY clause is probably different** from the result in the result-set.  On the other hand Standard SQL does** not allow the GROUP BY clause to contain references to result-set columns.** So this should never come up in well-formed queries.**** If the reference is followed by a COLLATE operator, then make sure** the COLLATE operator is preserved.  For example:****     SELECT a+b, c+d FROM t1 ORDER BY 1 COLLATE nocase;**** Should be transformed into:****     SELECT a+b, c+d FROM t1 ORDER BY (a+b) COLLATE nocase;**** The nSubquery parameter specifies how many levels of subquery the** alias is removed from the original expression.  The usually value is** zero but it might be more if the alias is contained within a subquery** of the original expression.  The Expr.op2 field of TK_AGG_FUNCTION** structures must be increased by the nSubquery amount.*/static void resolveAlias(  Parse *pParse,         /* Parsing context */  ExprList *pEList,      /* A result set */  int iCol,              /* A column in the result set.  0..pEList->nExpr-1 */  Expr *pExpr,           /* Transform this into an alias to the result set */  const char *zType,     /* "GROUP" or "ORDER" or "" */  int nSubquery          /* Number of subqueries that the label is moving */){  Expr *pOrig;           /* The iCol-th column of the result set */  Expr *pDup;            /* Copy of pOrig */  sqlite3 *db;           /* The database connection */  assert( iCol>=0 && iCol<pEList->nExpr );  pOrig = pEList->a[iCol].pExpr;  assert( pOrig!=0 );  assert( pOrig->flags & EP_Resolved );  db = pParse->db;  pDup = sqlite3ExprDup(db, pOrig, 0);  if( pDup==0 ) return;  if( pOrig->op!=TK_COLUMN && zType[0]!='G' ){    incrAggFunctionDepth(pDup, nSubquery);    pDup = sqlite3PExpr(pParse, TK_AS, pDup, 0, 0);    if( pDup==0 ) return;    ExprSetProperty(pDup, EP_Skip);    if( pEList->a[iCol].u.x.iAlias==0 ){      pEList->a[iCol].u.x.iAlias = (u16)(++pParse->nAlias);    }    pDup->iTable = pEList->a[iCol].u.x.iAlias;  }  if( pExpr->op==TK_COLLATE ){    pDup = sqlite3ExprAddCollateString(pParse, pDup, pExpr->u.zToken);  }  /* Before calling sqlite3ExprDelete(), set the EP_Static flag. This   ** prevents ExprDelete() from deleting the Expr structure itself,  ** allowing it to be repopulated by the memcpy() on the following line.  ** The pExpr->u.zToken might point into memory that will be freed by the  ** sqlite3DbFree(db, pDup) on the last line of this block, so be sure to  ** make a copy of the token before doing the sqlite3DbFree().  */  ExprSetProperty(pExpr, EP_Static);  sqlite3ExprDelete(db, pExpr);  memcpy(pExpr, pDup, sizeof(*pExpr));  if( !ExprHasProperty(pExpr, EP_IntValue) && pExpr->u.zToken!=0 ){    assert( (pExpr->flags & (EP_Reduced|EP_TokenOnly))==0 );    pExpr->u.zToken = sqlite3DbStrDup(db, pExpr->u.zToken);    pExpr->flags |= EP_MemToken;  }  sqlite3DbFree(db, pDup);}

/*** Convert a UTF-16 string in the native encoding into a UTF-8 string.** Memory to hold the UTF-8 string is obtained from sqlite3_malloc and must** be freed by the calling function.**** NULL is returned if there is an allocation error.*/char *sqlite3Utf16to8(sqlite3 *db, const void *z, int nByte){  Mem m;  memset(&m, 0, sizeof(m));  m.db = db;  sqlite3VdbeMemSetStr(&m, z, nByte, SQLITE_UTF16NATIVE, SQLITE_STATIC);  sqlite3VdbeChangeEncoding(&m, SQLITE_UTF8);  if( db->mallocFailed ){    sqlite3VdbeMemRelease(&m);    m.z = 0;  }  assert( (m.flags & MEM_Term)!=0 || db->mallocFailed );  assert( (m.flags & MEM_Str)!=0 || db->mallocFailed );  return (m.flags & MEM_Dyn)!=0 ? m.z : sqlite3DbStrDup(db, m.z);}

/*** 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 ){    int savedPc = v->pc;    rc2 = rc = sqlite3Reprepare(v);    if( rc!=SQLITE_OK) break;    sqlite3_reset(pStmt);    if( savedPc>=0 ) 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;}

/* ** Echo virtual table module xCreate method.*/static int echoCreate(  sqlite3 *db,  void *pAux,  int argc, const char *const*argv,  sqlite3_vtab **ppVtab,  char **pzErr){  int rc = SQLITE_OK;  appendToEchoModule(((EchoModule *)pAux)->interp, "xCreate");  rc = echoConstructor(db, pAux, argc, argv, ppVtab, pzErr);  /* If there were two arguments passed to the module at the SQL level   ** (i.e. "CREATE VIRTUAL TABLE tbl USING echo(arg1, arg2)"), then   ** the second argument is used as a table name. Attempt to create  ** such a table with a single column, "logmsg". This table will  ** be used to log calls to the xUpdate method. It will be deleted  ** when the virtual table is DROPed.  **  ** Note: The main point of this is to test that we can drop tables  ** from within an xDestroy method call.  */  if( rc==SQLITE_OK && argc==5 ){    char *zSql;    echo_vtab *pVtab = *(echo_vtab **)ppVtab;    pVtab->zLogName = sqlite3_mprintf("%s", argv[4]);    zSql = sqlite3_mprintf("CREATE TABLE %Q(logmsg)", pVtab->zLogName);    rc = sqlite3_exec(db, zSql, 0, 0, 0);    sqlite3_free(zSql);    if( rc!=SQLITE_OK ){      *pzErr = sqlite3DbStrDup(0, sqlite3_errmsg(db));    }  }  if( *ppVtab && rc!=SQLITE_OK ){    echoDestructor(*ppVtab);    *ppVtab = 0;  }  if( rc==SQLITE_OK ){    (*(echo_vtab**)ppVtab)->inTransaction = 1;  }  return rc;}

/*** The parser calls this routine when it first sees a CREATE VIRTUAL TABLE** statement.  The module name has been parsed, but the optional list** of parameters that follow the module name are still pending.*/void sqlite3VtabBeginParse(  Parse *pParse,        /* Parsing context */  Token *pName1,        /* Name of new table, or database name */  Token *pName2,        /* Name of new table or NULL */  Token *pModuleName,   /* Name of the module for the virtual table */  int ifNotExists       /* No error if the table already exists */){  int iDb;              /* The database the table is being created in */  Table *pTable;        /* The new virtual table */  sqlite3 *db;          /* Database connection */  sqlite3StartTable(pParse, pName1, pName2, 0, 0, 1, ifNotExists);  pTable = pParse->pNewTable;  if( pTable==0 ) return;  assert( 0==pTable->pIndex );  db = pParse->db;  iDb = sqlite3SchemaToIndex(db, pTable->pSchema);  assert( iDb>=0 );  pTable->tabFlags |= TF_Virtual;  pTable->nModuleArg = 0;  addModuleArgument(db, pTable, sqlite3NameFromToken(db, pModuleName));  addModuleArgument(db, pTable, 0);  addModuleArgument(db, pTable, sqlite3DbStrDup(db, pTable->zName));  assert( (pParse->sNameToken.z==pName2->z && pName2->z!=0)       || (pParse->sNameToken.z==pName1->z && pName2->z==0)  );  pParse->sNameToken.n = (int)(      &pModuleName->z[pModuleName->n] - pParse->sNameToken.z  );#ifndef SQLITE_OMIT_AUTHORIZATION  /* Creating a virtual table invokes the authorization callback twice.  ** The first invocation, to obtain permission to INSERT a row into the  ** sqlite_master table, has already been made by sqlite3StartTable().  ** The second call, to obtain permission to create the table, is made now.  */  if( pTable->azModuleArg ){    sqlite3AuthCheck(pParse, SQLITE_CREATE_VTABLE, pTable->zName,             pTable->azModuleArg[0], pParse->db->aDb[iDb].zDbSName);  }#endif}

/*** Invoke the xSync method of all virtual tables in the sqlite3.aVTrans** array. Return the error code for the first error that occurs, or** SQLITE_OK if all xSync operations are successful.**** Set *pzErrmsg to point to a buffer that should be released using ** sqlite3DbFree() containing an error message, if one is available.*/int sqlite3VtabSync(sqlite3 *db, char **pzErrmsg){  int i;  int rc = SQLITE_OK;  VTable **aVTrans = db->aVTrans;  db->aVTrans = 0;  for(i=0; rc==SQLITE_OK && i<db->nVTrans; i++){    int (*x)(sqlite3_vtab *);    sqlite3_vtab *pVtab = aVTrans[i]->pVtab;    if( pVtab && (x = pVtab->pModule->xSync)!=0 ){      rc = x(pVtab);      sqlite3DbFree(db, *pzErrmsg);      *pzErrmsg = sqlite3DbStrDup(db, pVtab->zErrMsg);      sqlite3_free(pVtab->zErrMsg);    }  }  db->aVTrans = aVTrans;  return rc;}

/*** Invoke the 'collation needed' callback to request a collation sequence** in the encoding enc of name zName, length nName.*/static void callCollNeeded(sqlite3 *db, int enc, const char *zName){  assert( !db->xCollNeeded || !db->xCollNeeded16 );  if( db->xCollNeeded ){    char *zExternal = sqlite3DbStrDup(db, zName);    if( !zExternal ) return;    db->xCollNeeded(db->pCollNeededArg, db, enc, zExternal);    sqlite3DbFree(db, zExternal);  }#ifndef SQLITE_OMIT_UTF16  if( db->xCollNeeded16 ){    char const *zExternal;    sqlite3_value *pTmp = sqlite3ValueNew(db);    sqlite3ValueSetStr(pTmp, -1, zName, SQLITE_UTF8, SQLITE_STATIC);    zExternal = sqlite3ValueText(pTmp, SQLITE_UTF16NATIVE);    if( zExternal ){      db->xCollNeeded16(db->pCollNeededArg, db, (int)ENC(db), zExternal);    }    sqlite3ValueFree(pTmp);  }#endif}

/*** Usage:    client_create NAME  FILENAME**** NAME should be an upper case letter.  Start the thread running with** an open connection to the given database.*/static int tcl_client_create(  void *NotUsed,  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */  int argc,              /* Number of arguments */  const char **argv      /* Text of each argument */){  int i;  pthread_t x;  int rc;  if( argc!=3 ){    Tcl_AppendResult(interp, "wrong # args: should be /"", argv[0],       " ID FILENAME", 0);    return TCL_ERROR;  }  i = parse_client_id(interp, argv[1]);  if( i<0 ) return TCL_ERROR;  if( threadset[i].busy ){    Tcl_AppendResult(interp, "thread ", argv[1], " is already running", 0);    return TCL_ERROR;  }  threadset[i].busy = 1;  sqlite3_free(threadset[i].zFilename);  threadset[i].zFilename = sqlite3DbStrDup(0, argv[2]);  threadset[i].opnum = 1;  threadset[i].completed = 0;  rc = pthread_create(&x, 0, client_main, &threadset[i]);  if( rc ){    Tcl_AppendResult(interp, "failed to create the thread", 0);    sqlite3_free(threadset[i].zFilename);    threadset[i].busy = 0;    return TCL_ERROR;  }  pthread_detach(x);  sqlite3_server_start();  return TCL_OK;}

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

//.........这里部分代码省略.........  ** the value sets a specific directory to be used for temporary files.  ** Setting to a null string reverts to the default temporary directory search.  ** If temporary directory is changed, then invalidateTempStorage.  **  */  if( sqlite3StrICmp(zLeft, "temp_store_directory")==0 ){    if( !zRight ){      if( sqlite3_temp_directory ){        sqlite3VdbeSetNumCols(v, 1);        sqlite3VdbeSetColName(v, 0, COLNAME_NAME,             "temp_store_directory", P4_STATIC);        sqlite3VdbeAddOp4(v, OP_String8, 0, 1, 0, sqlite3_temp_directory, 0);        sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 1);      }    }else{#ifndef SQLITE_OMIT_WSD      if( zRight[0] ){        int rc;        int res;        rc = sqlite3OsAccess(db->pVfs, zRight, SQLITE_ACCESS_READWRITE, &res);        if( rc!=SQLITE_OK || res==0 ){          sqlite3ErrorMsg(pParse, "not a writable directory");          goto pragma_out;        }      }      if( SQLITE_TEMP_STORE==0       || (SQLITE_TEMP_STORE==1 && db->temp_store<=1)       || (SQLITE_TEMP_STORE==2 && db->temp_store==1)      ){        invalidateTempStorage(pParse);      }      sqlite3_free(sqlite3_temp_directory);      if( zRight[0] ){        sqlite3_temp_directory = sqlite3DbStrDup(0, zRight);      }else{        sqlite3_temp_directory = 0;      }#endif /* SQLITE_OMIT_WSD */    }  }else  /*  **   PRAGMA [database.]synchronous  **   PRAGMA [database.]synchronous=OFF|ON|NORMAL|FULL  **  ** Return or set the local value of the synchronous flag.  Changing  ** the local value does not make changes to the disk file and the  ** default value will be restored the next time the database is  ** opened.  */  if( sqlite3StrICmp(zLeft,"synchronous")==0 ){    if( sqlite3ReadSchema(pParse) ) goto pragma_out;    if( !zRight ){      returnSingleInt(pParse, "synchronous", pDb->safety_level-1);    }else{      if( !db->autoCommit ){        sqlite3ErrorMsg(pParse,             "Safety level may not be changed inside a transaction");      }else{        pDb->safety_level = getSafetyLevel(zRight)+1;      }    }  }else#endif /* SQLITE_OMIT_PAGER_PRAGMAS */#ifndef SQLITE_OMIT_FLAG_PRAGMAS

/*** 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;         /* Return code */  const char *zLeftover;      /* Tail of unprocessed SQL */  sqlite3_stmt *pStmt = 0;    /* The current SQL statement */  char **azCols = 0;          /* Names of result columns */  int callbackIsInit;         /* True if callback data is initialized */  if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT;  if( zSql==0 ) zSql = "";  sqlite3_mutex_enter(db->mutex);  sqlite3Error(db, SQLITE_OK);  while( rc==SQLITE_OK && zSql[0] ){    int nCol;    char **azVals = 0;    pStmt = 0;    rc = sqlite3_prepare_v2(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 = sqlite3DbMallocRaw(db, (2*nCol+1)*sizeof(const char*));          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 ){              sqlite3OomFault(db);              goto exec_out;            }          }          azVals[i] = 0;        }        if( xCallback(pArg, nCol, azVals, azCols) ){          /* EVIDENCE-OF: R-38229-40159 If the callback function to          ** sqlite3_exec() returns non-zero, then sqlite3_exec() will          ** return SQLITE_ABORT. */          rc = SQLITE_ABORT;          sqlite3VdbeFinalize((Vdbe *)pStmt);          pStmt = 0;          sqlite3Error(db, SQLITE_ABORT);          goto exec_out;        }      }      if( rc!=SQLITE_ROW ){        rc = sqlite3VdbeFinalize((Vdbe *)pStmt);        pStmt = 0;        zSql = zLeftover;        while( sqlite3Isspace(zSql[0]) ) zSql++;        break;      }    }//.........这里部分代码省略.........

/*** Free any prior content in *pz and replace it with a copy of zNew.*/void sqlite3SetString(char **pz, sqlite3 *db, const char *zNew){  sqlite3DbFree(db, *pz);  *pz = sqlite3DbStrDup(db, zNew);}

/*** This function is called by the parser after the table-name in** an "ALTER TABLE <table-name> ADD" statement is parsed. Argument ** pSrc is the full-name of the table being altered.**** This routine makes a (partial) copy of the Table structure** for the table being altered and sets Parse.pNewTable to point** to it. Routines called by the parser as the column definition** is parsed (i.e. sqlite3AddColumn()) add the new Column data to ** the copy. The copy of the Table structure is deleted by tokenize.c ** after parsing is finished.**** Routine sqlite3AlterFinishAddColumn() will be called to complete** coding the "ALTER TABLE ... ADD" statement.*/void sqlite3AlterBeginAddColumn(Parse *pParse, SrcList *pSrc){  Table *pNew;  Table *pTab;  Vdbe *v;  int iDb;  int i;  int nAlloc;  sqlite3 *db = pParse->db;  /* Look up the table being altered. */  assert( pParse->pNewTable==0 );  assert( sqlite3BtreeHoldsAllMutexes(db) );  if( db->mallocFailed ) goto exit_begin_add_column;  pTab = sqlite3LocateTable(pParse, 0, pSrc->a[0].zName, pSrc->a[0].zDatabase);  if( !pTab ) goto exit_begin_add_column;#ifndef SQLITE_OMIT_VIRTUALTABLE  if( IsVirtual(pTab) ){    sqlite3ErrorMsg(pParse, "virtual tables may not be altered");    goto exit_begin_add_column;  }#endif  /* Make sure this is not an attempt to ALTER a view. */  if( pTab->pSelect ){    sqlite3ErrorMsg(pParse, "Cannot add a column to a view");    goto exit_begin_add_column;  }  assert( pTab->addColOffset>0 );  iDb = sqlite3SchemaToIndex(db, pTab->pSchema);  /* Put a copy of the Table struct in Parse.pNewTable for the  ** sqlite3AddColumn() function and friends to modify.  But modify  ** the name by adding an "sqlite_altertab_" prefix.  By adding this  ** prefix, we insure that the name will not collide with an existing  ** table because user table are not allowed to have the "sqlite_"  ** prefix on their name.  */  pNew = (Table*)sqlite3DbMallocZero(db, sizeof(Table));  if( !pNew ) goto exit_begin_add_column;  pParse->pNewTable = pNew;  pNew->nRef = 1;  pNew->db = db;  pNew->nCol = pTab->nCol;  assert( pNew->nCol>0 );  nAlloc = (((pNew->nCol-1)/8)*8)+8;  assert( nAlloc>=pNew->nCol && nAlloc%8==0 && nAlloc-pNew->nCol<8 );  pNew->aCol = (Column*)sqlite3DbMallocZero(db, sizeof(Column)*nAlloc);  pNew->zName = sqlite3MPrintf(db, "sqlite_altertab_%s", pTab->zName);  if( !pNew->aCol || !pNew->zName ){    db->mallocFailed = 1;    goto exit_begin_add_column;  }  memcpy(pNew->aCol, pTab->aCol, sizeof(Column)*pNew->nCol);  for(i=0; i<pNew->nCol; i++){    Column *pCol = &pNew->aCol[i];    pCol->zName = sqlite3DbStrDup(db, pCol->zName);    pCol->zColl = 0;    pCol->zType = 0;    pCol->pDflt = 0;  }  pNew->pSchema = db->aDb[iDb].pSchema;  pNew->addColOffset = pTab->addColOffset;  pNew->nRef = 1;  /* Begin a transaction and increment the schema cookie.  */  sqlite3BeginWriteOperation(pParse, 0, iDb);  v = sqlite3GetVdbe(pParse);  if( !v ) goto exit_begin_add_column;  sqlite3ChangeCookie(pParse, iDb);exit_begin_add_column:  sqlite3SrcListDelete(db, pSrc);  return;}

/*** An SQL user-function registered to do the work of an ATTACH statement. The** three arguments to the function come directly from an attach statement:****     ATTACH DATABASE x AS y KEY z****     SELECT sqlite_attach(x, y, z)**** If the optional "KEY z" syntax is omitted, an SQL NULL is passed as the** third argument.*/static void attachFunc(  sqlite3_context *context,  int NotUsed,  sqlite3_value **argv){  int i;  int rc = 0;  sqlite3 *db = sqlite3_context_db_handle(context);  const char *zName;  const char *zFile;  Db *aNew;  char *zErrDyn = 0;  UNUSED_PARAMETER(NotUsed);  zFile = (const char *)sqlite3_value_text(argv[0]);  zName = (const char *)sqlite3_value_text(argv[1]);  if( zFile==0 ) zFile = "";  if( zName==0 ) zName = "";  /* Check for the following errors:  **  **     * Too many attached databases,  **     * Transaction currently open  **     * Specified database name already being used.  */  if( db->nDb>=db->aLimit[SQLITE_LIMIT_ATTACHED]+2 ){    zErrDyn = sqlite3MPrintf(db, "too many attached databases - max %d",       db->aLimit[SQLITE_LIMIT_ATTACHED]    );    goto attach_error;  }  if( !db->autoCommit ){    zErrDyn = sqlite3MPrintf(db, "cannot ATTACH database within transaction");    goto attach_error;  }  for(i=0; i<db->nDb; i++){    char *z = db->aDb[i].zName;    assert( z && zName );    if( sqlite3StrICmp(z, zName)==0 ){      zErrDyn = sqlite3MPrintf(db, "database %s is already in use", zName);      goto attach_error;    }  }  /* Allocate the new entry in the db->aDb[] array and initialise the schema  ** hash tables.  */  if( db->aDb==db->aDbStatic ){    aNew = sqlite3DbMallocRaw(db, sizeof(db->aDb[0])*3 );    if( aNew==0 ) return;    memcpy(aNew, db->aDb, sizeof(db->aDb[0])*2);  }else{    aNew = sqlite3DbRealloc(db, db->aDb, sizeof(db->aDb[0])*(db->nDb+1) );    if( aNew==0 ) return;  }  db->aDb = aNew;  aNew = &db->aDb[db->nDb];  memset(aNew, 0, sizeof(*aNew));  /* Open the database file. If the btree is successfully opened, use  ** it to obtain the database schema. At this point the schema may  ** or may not be initialised.  */  rc = sqlite3BtreeFactory(db, zFile, 0, SQLITE_DEFAULT_CACHE_SIZE,                           db->openFlags | SQLITE_OPEN_MAIN_DB,                           &aNew->pBt);  db->nDb++;  if( rc==SQLITE_CONSTRAINT ){    rc = SQLITE_ERROR;    zErrDyn = sqlite3MPrintf(db, "database is already attached");  }else if( rc==SQLITE_OK ){    Pager *pPager;    aNew->pSchema = sqlite3SchemaGet(db, aNew->pBt);    if( !aNew->pSchema ){      rc = SQLITE_NOMEM;    }else if( aNew->pSchema->file_format && aNew->pSchema->enc!=ENC(db) ){      zErrDyn = sqlite3MPrintf(db,         "attached databases must use the same text encoding as main database");      rc = SQLITE_ERROR;    }    pPager = sqlite3BtreePager(aNew->pBt);    sqlite3PagerLockingMode(pPager, db->dfltLockMode);    sqlite3PagerJournalMode(pPager, db->dfltJournalMode);  }  aNew->zName = sqlite3DbStrDup(db, zName);  aNew->safety_level = 3;#if SQLITE_HAS_CODEC//.........这里部分代码省略.........

/*** Create a new sqlite3_value object, containing the value of pExpr.**** This only works for very simple expressions that consist of one constant** token (i.e. "5", "5.1", "'a string'"). If the expression can** be converted directly into a value, then the value is allocated and** a pointer written to *ppVal. The caller is responsible for deallocating** the value by passing it to sqlite3ValueFree() later on. If the expression** cannot be converted to a value, then *ppVal is set to NULL.*/int sqlite3ValueFromExpr(  sqlite3 *db,              /* The database connection */  Expr *pExpr,              /* The expression to evaluate */  u8 enc,                   /* Encoding to use */  u8 affinity,              /* Affinity to use */  sqlite3_value **ppVal     /* Write the new value here */){  int op;  char *zVal = 0;  sqlite3_value *pVal = 0;  if( !pExpr ){    *ppVal = 0;    return SQLITE_OK;  }  op = pExpr->op;  if( op==TK_REGISTER ){    op = pExpr->op2;  }  if( op==TK_STRING || op==TK_FLOAT || op==TK_INTEGER ){    pVal = sqlite3ValueNew(db);    if( pVal==0 ) goto no_mem;    if( ExprHasProperty(pExpr, EP_IntValue) ){      sqlite3VdbeMemSetInt64(pVal, (i64)pExpr->u.iValue);    }else{      zVal = sqlite3DbStrDup(db, pExpr->u.zToken);      if( zVal==0 ) goto no_mem;      sqlite3ValueSetStr(pVal, -1, zVal, SQLITE_UTF8, SQLITE_DYNAMIC);      if( op==TK_FLOAT ) pVal->type = SQLITE_FLOAT;    }    if( (op==TK_INTEGER || op==TK_FLOAT ) && affinity==SQLITE_AFF_NONE ){      sqlite3ValueApplyAffinity(pVal, SQLITE_AFF_NUMERIC, SQLITE_UTF8);    }else{      sqlite3ValueApplyAffinity(pVal, affinity, SQLITE_UTF8);    }    if( enc!=SQLITE_UTF8 ){      sqlite3VdbeChangeEncoding(pVal, enc);    }  }else if( op==TK_UMINUS ) {    if( SQLITE_OK==sqlite3ValueFromExpr(db,pExpr->pLeft,enc,affinity,&pVal) ){      pVal->u.i = -1 * pVal->u.i;      /* (double)-1 In case of SQLITE_OMIT_FLOATING_POINT... */      pVal->r = (double)-1 * pVal->r;    }  }#ifndef SQLITE_OMIT_BLOB_LITERAL  else if( op==TK_BLOB ){    int nVal;    assert( pExpr->u.zToken[0]=='x' || pExpr->u.zToken[0]=='X' );    assert( pExpr->u.zToken[1]=='/'' );    pVal = sqlite3ValueNew(db);    if( !pVal ) goto no_mem;    zVal = &pExpr->u.zToken[2];    nVal = sqlite3Strlen30(zVal)-1;    assert( zVal[nVal]=='/'' );    sqlite3VdbeMemSetStr(pVal, sqlite3HexToBlob(db, zVal, nVal), nVal/2,                         0, SQLITE_DYNAMIC);  }#endif  *ppVal = pVal;  return SQLITE_OK;no_mem:  db->mallocFailed = 1;  sqlite3DbFree(db, zVal);  sqlite3ValueFree(pVal);  *ppVal = 0;  return SQLITE_NOMEM;}

static void attachFunc(  sqlite3_context *context,  int NotUsed,  sqlite3_value **argv){  int i;  int rc = 0;  sqlite3 *db = sqlite3_context_db_handle(context);  const char *zName;  const char *zFile;  Db *aNew;  char *zErrDyn = 0;  UNUSED_PARAMETER(NotUsed);  zFile = (const char *)sqlite3_value_text(argv[0]);  zName = (const char *)sqlite3_value_text(argv[1]);  if( zFile==0 ) zFile = "";  if( zName==0 ) zName = "";  if( db->nDb>=db->aLimit[SQLITE_LIMIT_ATTACHED]+2 ){    zErrDyn = sqlite3MPrintf(db, "too many attached databases - max %d",       db->aLimit[SQLITE_LIMIT_ATTACHED]    );    goto attach_error;  }  if( !db->autoCommit ){    zErrDyn = sqlite3MPrintf(db, "cannot ATTACH database within transaction");    goto attach_error;  }  for(i=0; i<db->nDb; i++){    char *z = db->aDb[i].zName;    assert( z && zName );    if( sqlite3StrICmp(z, zName)==0 ){      zErrDyn = sqlite3MPrintf(db, "database %s is already in use", zName);      goto attach_error;    }  }  if( db->aDb==db->aDbStatic ){    aNew = sqlite3DbMallocRaw(db, sizeof(db->aDb[0])*3 );    if( aNew==0 ) return;    memcpy(aNew, db->aDb, sizeof(db->aDb[0])*2);  }else{    aNew = sqlite3DbRealloc(db, db->aDb, sizeof(db->aDb[0])*(db->nDb+1) );    if( aNew==0 ) return;  }  db->aDb = aNew;  aNew = &db->aDb[db->nDb];  memset(aNew, 0, sizeof(*aNew));  rc = sqlite3BtreeOpen(zFile, db, &aNew->pBt, 0,                        db->openFlags | SQLITE_OPEN_MAIN_DB);  db->nDb++;  if( rc==SQLITE_CONSTRAINT ){    rc = SQLITE_ERROR;    zErrDyn = sqlite3MPrintf(db, "database is already attached");  }else if( rc==SQLITE_OK ){    Pager *pPager;    aNew->pSchema = sqlite3SchemaGet(db, aNew->pBt);    if( !aNew->pSchema ){      rc = SQLITE_NOMEM;    }else if( aNew->pSchema->file_format && aNew->pSchema->enc!=ENC(db) ){      zErrDyn = sqlite3MPrintf(db,         "attached databases must use the same text encoding as main database");      rc = SQLITE_ERROR;    }    pPager = sqlite3BtreePager(aNew->pBt);    sqlite3PagerLockingMode(pPager, db->dfltLockMode);    sqlite3BtreeSecureDelete(aNew->pBt,                             sqlite3BtreeSecureDelete(db->aDb[0].pBt,-1) );  }  aNew->safety_level = 3;  aNew->zName = sqlite3DbStrDup(db, zName);  if( rc==SQLITE_OK && aNew->zName==0 ){    rc = SQLITE_NOMEM;  }#ifdef SQLITE_HAS_CODEC  if( rc==SQLITE_OK ){    extern int sqlite3CodecAttach(sqlite3*, int, const void*, int);    extern void sqlite3CodecGetKey(sqlite3*, int, void**, int*);    int nKey;    char *zKey;    int t = sqlite3_value_type(argv[2]);    switch( t ){      case SQLITE_INTEGER:      case SQLITE_FLOAT:        zErrDyn = sqlite3DbStrDup(db, "Invalid key value");        rc = SQLITE_ERROR;        break;              case SQLITE_TEXT:      case SQLITE_BLOB:        nKey = sqlite3_value_bytes(argv[2]);        zKey = (char *)sqlite3_value_blob(argv[2]);        rc = sqlite3CodecAttach(db, db->nDb-1, zKey, nKey);        break;//.........这里部分代码省略.........

/*** Attempt to load an SQLite extension library contained in the file** zFile.  The entry point is zProc.  zProc may be 0 in which case a** default entry point name (sqlite3_extension_init) is used.  Use** of the default name is recommended.**** Return SQLITE_OK on success and SQLITE_ERROR if something goes wrong.**** If an error occurs and pzErrMsg is not 0, then fill *pzErrMsg with ** error message text.  The calling function should free this memory** by calling sqlite3DbFree(db, ).*/static int sqlite3LoadExtension(  sqlite3 *db,          /* Load the extension into this database connection */  const char *zFile,    /* Name of the shared library containing extension */  const char *zProc,    /* Entry point.  Use "sqlite3_extension_init" if 0 */  char **pzErrMsg       /* Put error message here if not 0 */){  sqlite3_vfs *pVfs = db->pVfs;  void *handle;  int (*xInit)(sqlite3*,char**,const sqlite3_api_routines*);  char *zErrmsg = 0;  void **aHandle;  /* Ticket #1863.  To avoid a creating security problems for older  ** applications that relink against newer versions of SQLite, the  ** ability to run load_extension is turned off by default.  One  ** must call sqlite3_enable_load_extension() to turn on extension  ** loading.  Otherwise you get the following error.  */  if( (db->flags & SQLITE_LoadExtension)==0 ){    if( pzErrMsg ){      *pzErrMsg = sqlite3_mprintf("not authorized");    }    return SQLITE_ERROR;  }  if( zProc==0 ){    zProc = "sqlite3_extension_init";  }  handle = sqlite3OsDlOpen(pVfs, zFile);  if( handle==0 ){    if( pzErrMsg ){      char zErr[256];      zErr[sizeof(zErr)-1] = '/0';      sqlite3_snprintf(sizeof(zErr)-1, zErr,           "unable to open shared library [%s]", zFile);      sqlite3OsDlError(pVfs, sizeof(zErr)-1, zErr);      *pzErrMsg = sqlite3DbStrDup(0, zErr);    }    return SQLITE_ERROR;  }  xInit = (int(*)(sqlite3*,char**,const sqlite3_api_routines*))                   sqlite3OsDlSym(pVfs, handle, zProc);  if( xInit==0 ){    if( pzErrMsg ){      char zErr[256];      zErr[sizeof(zErr)-1] = '/0';      sqlite3_snprintf(sizeof(zErr)-1, zErr,          "no entry point [%s] in shared library [%s]", zProc,zFile);      sqlite3OsDlError(pVfs, sizeof(zErr)-1, zErr);      *pzErrMsg = sqlite3DbStrDup(0, zErr);      sqlite3OsDlClose(pVfs, handle);    }    return SQLITE_ERROR;  }else if( xInit(db, &zErrmsg, &sqlite3Apis) ){    if( pzErrMsg ){      *pzErrMsg = sqlite3_mprintf("error during initialization: %s", zErrmsg);    }    sqlite3_free(zErrmsg);    sqlite3OsDlClose(pVfs, handle);    return SQLITE_ERROR;  }  /* Append the new shared library handle to the db->aExtension array. */  aHandle = sqlite3DbMallocZero(db, sizeof(handle)*(db->nExtension+1));  if( aHandle==0 ){    return SQLITE_NOMEM;  }  if( db->nExtension>0 ){    memcpy(aHandle, db->aExtension, sizeof(handle)*db->nExtension);  }  sqlite3DbFree(db, db->aExtension);  db->aExtension = aHandle;  db->aExtension[db->nExtension++] = handle;  return SQLITE_OK;}

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

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

//.........这里部分代码省略.........    sqlite3_free(zErr);    return;  }  assert( pVfs );  flags |= SQLITE_OPEN_MAIN_DB;  rc = sqlite3BtreeOpen(pVfs, zPath, db, &aNew->pBt, 0, flags);  sqlite3_free( zPath );  db->nDb++;  if( rc==SQLITE_CONSTRAINT ){    rc = SQLITE_ERROR;    zErrDyn = sqlite3MPrintf(db, "database is already attached");  }else if( rc==SQLITE_OK ){    Pager *pPager;    aNew->pSchema = sqlite3SchemaGet(db, aNew->pBt);    if( !aNew->pSchema ){      rc = SQLITE_NOMEM;    }else if( aNew->pSchema->file_format && aNew->pSchema->enc!=ENC(db) ){      zErrDyn = sqlite3MPrintf(db,        "attached databases must use the same text encoding as main database");      rc = SQLITE_ERROR;    }    sqlite3BtreeEnter(aNew->pBt);    pPager = sqlite3BtreePager(aNew->pBt);    sqlite3PagerLockingMode(pPager, db->dfltLockMode);    sqlite3BtreeSecureDelete(aNew->pBt,                             sqlite3BtreeSecureDelete(db->aDb[0].pBt,-1) );#ifndef SQLITE_OMIT_PAGER_PRAGMAS    sqlite3BtreeSetPagerFlags(aNew->pBt,                      PAGER_SYNCHRONOUS_FULL | (db->flags & PAGER_FLAGS_MASK));#endif    sqlite3BtreeLeave(aNew->pBt);  }  aNew->safety_level = 3;  aNew->zName = sqlite3DbStrDup(db, zName);  if( rc==SQLITE_OK && aNew->zName==0 ){    rc = SQLITE_NOMEM;  }#ifdef SQLITE_HAS_CODEC  if( rc==SQLITE_OK ){    extern int sqlite3CodecAttach(sqlite3*, int, const void*, int);    extern void sqlite3CodecGetKey(sqlite3*, int, void**, int*);    int nKey;    char *zKey;    int t = sqlite3_value_type(argv[2]);    switch( t ){      case SQLITE_INTEGER:      case SQLITE_FLOAT:        zErrDyn = sqlite3DbStrDup(db, "Invalid key value");        rc = SQLITE_ERROR;        break;      case SQLITE_TEXT:      case SQLITE_BLOB:        nKey = sqlite3_value_bytes(argv[2]);        zKey = (char *)sqlite3_value_blob(argv[2]);        rc = sqlite3CodecAttach(db, db->nDb-1, zKey, nKey);        break;      case SQLITE_NULL:        /* No key specified.  Use the key from the main database */        sqlite3CodecGetKey(db, 0, (void**)&zKey, &nKey);        if( nKey>0 || sqlite3BtreeGetOptimalReserve(db->aDb[0].pBt)>0 ){          rc = sqlite3CodecAttach(db, db->nDb-1, zKey, nKey);        }