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

/*** Initialize the temporary index cursor just opened as a sorter cursor.*/int sqlite3VdbeSorterInit(sqlite3 *db, VdbeCursor *pCsr){  int pgsz;                       /* Page size of main database */  int mxCache;                    /* Cache size */  VdbeSorter *pSorter;            /* The new sorter */  char *d;                        /* Dummy */  assert( pCsr->pKeyInfo && pCsr->pBt==0 );  pCsr->pSorter = pSorter = sqlite3DbMallocZero(db, sizeof(VdbeSorter));  if( pSorter==0 ){    return SQLITE_NOMEM;  }    pSorter->pUnpacked = sqlite3VdbeAllocUnpackedRecord(pCsr->pKeyInfo, 0, 0, &d);  if( pSorter->pUnpacked==0 ) return SQLITE_NOMEM;  assert( pSorter->pUnpacked==(UnpackedRecord *)d );  if( !sqlite3TempInMemory(db) ){    pgsz = sqlite3BtreeGetPageSize(db->aDb[0].pBt);    pSorter->mnPmaSize = SORTER_MIN_WORKING * pgsz;    mxCache = db->aDb[0].pSchema->cache_size;    if( mxCache<SORTER_MIN_WORKING ) mxCache = SORTER_MIN_WORKING;    pSorter->mxPmaSize = mxCache * pgsz;  }  return SQLITE_OK;}

/*** Build a trigger step out of an INSERT statement.  Return a pointer** to the new trigger step.**** The parser calls this routine when it sees an INSERT inside the** body of a trigger.*/TriggerStep *sqlite3TriggerInsertStep(  sqlite3 *db,        /* The database connection */  Token *pTableName,  /* Name of the table into which we insert */  IdList *pColumn,    /* List of columns in pTableName to insert into */  ExprList *pEList,   /* The VALUE clause: a list of values to be inserted */  Select *pSelect,    /* A SELECT statement that supplies values */  int orconf          /* The conflict algorithm (OE_Abort, OE_Replace, etc.) */){  TriggerStep *pTriggerStep;  assert(pEList == 0 || pSelect == 0);  assert(pEList != 0 || pSelect != 0 || db->mallocFailed);  pTriggerStep = (TriggerStep*)sqlite3DbMallocZero(db, sizeof(TriggerStep));  if( pTriggerStep ){    pTriggerStep->op = TK_INSERT;    pTriggerStep->pSelect = pSelect;    pTriggerStep->target  = *pTableName;    pTriggerStep->pIdList = pColumn;    pTriggerStep->pExprList = pEList;    pTriggerStep->orconf = orconf;    sqlitePersistTriggerStep(db, pTriggerStep);  }else{    sqlite3IdListDelete(pColumn);    sqlite3ExprListDelete(pEList);    sqlite3SelectDelete(pSelect);  }  return pTriggerStep;}

/*** Check to see if virtual table module pMod can be have an eponymous** virtual table instance.  If it can, create one if one does not already** exist. Return non-zero if the eponymous virtual table instance exists** when this routine returns, and return zero if it does not exist.**** An eponymous virtual table instance is one that is named after its** module, and more importantly, does not require a CREATE VIRTUAL TABLE** statement in order to come into existance.  Eponymous virtual table** instances always exist.  They cannot be DROP-ed.**** Any virtual table module for which xConnect and xCreate are the same** method can have an eponymous virtual table instance.*/int sqlite3VtabEponymousTableInit(Parse *pParse, Module *pMod){  const sqlite3_module *pModule = pMod->pModule;  Table *pTab;  char *zErr = 0;  int rc;  sqlite3 *db = pParse->db;  if( pMod->pEpoTab ) return 1;  if( pModule->xCreate!=0 && pModule->xCreate!=pModule->xConnect ) return 0;  pTab = sqlite3DbMallocZero(db, sizeof(Table));  if( pTab==0 ) return 0;  pTab->zName = sqlite3DbStrDup(db, pMod->zName);  if( pTab->zName==0 ){    sqlite3DbFree(db, pTab);    return 0;  }  pMod->pEpoTab = pTab;  pTab->nTabRef = 1;  pTab->pSchema = db->aDb[0].pSchema;  pTab->tabFlags |= TF_Virtual;  pTab->nModuleArg = 0;  pTab->iPKey = -1;  addModuleArgument(db, pTab, sqlite3DbStrDup(db, pTab->zName));  addModuleArgument(db, pTab, 0);  addModuleArgument(db, pTab, sqlite3DbStrDup(db, pTab->zName));  rc = vtabCallConstructor(db, pTab, pMod, pModule->xConnect, &zErr);  if( rc ){    sqlite3ErrorMsg(pParse, "%s", zErr);    sqlite3DbFree(db, zErr);    sqlite3VtabEponymousTableClear(db, pMod);    return 0;  }  return 1;}

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

/*** Create a new sqlite3_value object.*/sqlite3_value *sqlite3ValueNew(sqlite3 *db){  Mem *p = sqlite3DbMallocZero(db, sizeof(*p));  if( p ){    p->flags = MEM_Null;    p->type = SQLITE_NULL;    p->db = db;  }  return p;}

/* ** Turn a SELECT statement (that the pSelect parameter points to) into ** a trigger step.  Return a pointer to a TriggerStep structure. ** ** The parser calls this routine when it finds a SELECT statement in ** body of a TRIGGER. */SQLITE_PRIVATE TriggerStep *sqlite3TriggerSelectStep(sqlite3 *db, Select *pSelect){    TriggerStep *pTriggerStep = sqlite3DbMallocZero(db, sizeof(TriggerStep));    if( pTriggerStep==0 ) {        sqlite3SelectDelete(db, pSelect);        return 0;    }    pTriggerStep->op = TK_SELECT;    pTriggerStep->pSelect = pSelect;    pTriggerStep->orconf = OE_Default;    return pTriggerStep;}

/*** Turn a SELECT statement (that the pSelect parameter points to) into** a trigger step.  Return a pointer to a TriggerStep structure.**** The parser calls this routine when it finds a SELECT statement in** body of a TRIGGER.  */TriggerStep *sqlite3TriggerSelectStep(sqlite3 *db, Select *pSelect){  TriggerStep *pTriggerStep = (TriggerStep*)sqlite3DbMallocZero(db, sizeof(TriggerStep));  if( pTriggerStep==0 ) {    sqlite3SelectDelete(pSelect);    return 0;  }  pTriggerStep->op = TK_SELECT;  pTriggerStep->pSelect = pSelect;  pTriggerStep->orconf = OE_Default;  sqlitePersistTriggerStep(db, pTriggerStep);  return pTriggerStep;}

/*** Turn a SELECT statement (that the pSelect parameter points to) into** a trigger step.  Return a pointer to a TriggerStep structure.**** The parser calls this routine when it finds a SELECT statement in** body of a TRIGGER.  */TriggerStep *sqlite3TriggerSelectStep(  sqlite3 *db,                /* Database connection */  Select *pSelect,            /* The SELECT statement */  const char *zStart,         /* Start of SQL text */  const char *zEnd            /* End of SQL text */){  TriggerStep *pTriggerStep = sqlite3DbMallocZero(db, sizeof(TriggerStep));  if( pTriggerStep==0 ) {    sqlite3SelectDelete(db, pSelect);    return 0;  }  pTriggerStep->op = TK_SELECT;  pTriggerStep->pSelect = pSelect;  pTriggerStep->orconf = OE_Default;  pTriggerStep->zSpan = triggerSpanDup(db, zStart, zEnd);  return pTriggerStep;}

/*** Find and return the schema associated with a BTree.  Create** a new one if necessary.*/Schema *sqlite3SchemaGet(sqlite3 *db, Btree *pBt){  Schema * p;  if( pBt ){    p = (Schema *)sqlite3BtreeSchema(pBt, sizeof(Schema), sqlite3SchemaClear);  }else{    p = (Schema *)sqlite3DbMallocZero(0, sizeof(Schema));  }  if( !p ){    sqlite3OomFault(db);  }else if ( 0==p->file_format ){    sqlite3HashInit(&p->tblHash);    sqlite3HashInit(&p->idxHash);    sqlite3HashInit(&p->trigHash);    sqlite3HashInit(&p->fkeyHash);    p->enc = SQLITE_UTF8;  }  return p;}

/*** Set the auxiliary data pointer and delete function, for the iArg'th** argument to the user-function defined by pCtx. Any previous value is** deleted by calling the delete function specified when it was set.*/void sqlite3_set_auxdata(  sqlite3_context *pCtx,   int iArg,   void *pAux,   void (*xDelete)(void*)){  AuxData *pAuxData;  Vdbe *pVdbe = pCtx->pVdbe;  assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );  if( iArg<0 ) goto failed;#ifdef SQLITE_ENABLE_STAT3_OR_STAT4  if( pVdbe==0 ) goto failed;#else  assert( pVdbe!=0 );#endif  for(pAuxData=pVdbe->pAuxData; pAuxData; pAuxData=pAuxData->pNext){    if( pAuxData->iOp==pCtx->iOp && pAuxData->iArg==iArg ) break;  }  if( pAuxData==0 ){    pAuxData = sqlite3DbMallocZero(pVdbe->db, sizeof(AuxData));    if( !pAuxData ) goto failed;    pAuxData->iOp = pCtx->iOp;    pAuxData->iArg = iArg;    pAuxData->pNext = pVdbe->pAuxData;    pVdbe->pAuxData = pAuxData;    if( pCtx->fErrorOrAux==0 ){      pCtx->isError = 0;      pCtx->fErrorOrAux = 1;    }  }else if( pAuxData->xDelete ){    pAuxData->xDelete(pAuxData->pAux);  }  pAuxData->pAux = pAux;  pAuxData->xDelete = xDelete;  return;failed:  if( xDelete ){    xDelete(pAux);  }}

/* ** Allocate and return a pointer to a new sqlite3_value object. If ** the second argument to this function is NULL, the object is allocated ** by calling sqlite3ValueNew(). ** ** Otherwise, if the second argument is non-zero, then this function is ** being called indirectly by sqlite3Stat4ProbeSetValue(). If it has not ** already been allocated, allocate the UnpackedRecord structure that ** that function will return to its caller here. Then return a pointer ** an sqlite3_value within the UnpackedRecord.a[] array. */static sqlite3_value *valueNew(sqlite3 *db, struct ValueNewStat4Ctx *p){#ifdef SQLITE_ENABLE_STAT3_OR_STAT4    if( p ){        UnpackedRecord *pRec = p->ppRec[0];                if( pRec==0 ){            Index *pIdx = p->pIdx;      /* Index being probed */            int nByte;                  /* Bytes of space to allocate */            int i;                      /* Counter variable */            int nCol = pIdx->nColumn+1; /* Number of index columns including rowid */                        nByte = sizeof(Mem) * nCol + sizeof(UnpackedRecord);            pRec = (UnpackedRecord*)sqlite3DbMallocZero(db, nByte);            if( pRec ){                pRec->pKeyInfo = sqlite3IndexKeyinfo(p->pParse, pIdx);                if( pRec->pKeyInfo ){                    assert( pRec->pKeyInfo->nField+1==nCol );                    pRec->pKeyInfo->enc = ENC(db);                    pRec->flags = UNPACKED_PREFIX_MATCH;                    pRec->aMem = (Mem *)&pRec[1];                    for(i=0; i<nCol; i++){                        pRec->aMem[i].flags = MEM_Null;                        pRec->aMem[i].type = SQLITE_NULL;                        pRec->aMem[i].db = db;                    }                }else{                    sqlite3DbFree(db, pRec);                    pRec = 0;                }            }            if( pRec==0 ) return 0;            p->ppRec[0] = pRec;        }                pRec->nField = p->iVal+1;        return &pRec->aMem[p->iVal];    }#else    UNUSED_PARAMETER(p);#endif /* defined(SQLITE_ENABLE_STAT3_OR_STAT4) */    return sqlite3ValueNew(db);}

/*** Locate and return an entry from the db.aCollSeq hash table. If the entry** specified by zName and nName is not found and parameter 'create' is** true, then create a new entry. Otherwise return NULL.**** Each pointer stored in the sqlite3.aCollSeq hash table contains an** array of three CollSeq structures. The first is the collation sequence** prefferred for UTF-8, the second UTF-16le, and the third UTF-16be.**** Stored immediately after the three collation sequences is a copy of** the collation sequence name. A pointer to this string is stored in** each collation sequence structure.*/static CollSeq *findCollSeqEntry(  sqlite3 *db,  const char *zName,  int nName,  int create){  CollSeq *pColl;  if( nName<0 ) nName = sqlite3Strlen(db, zName);  pColl = sqlite3HashFind(&db->aCollSeq, zName, nName);  if( 0==pColl && create ){    pColl = sqlite3DbMallocZero(db, 3*sizeof(*pColl) + nName + 1 );    if( pColl ){      CollSeq *pDel = 0;      pColl[0].zName = (char*)&pColl[3];      pColl[0].enc = SQLITE_UTF8;      pColl[1].zName = (char*)&pColl[3];      pColl[1].enc = SQLITE_UTF16LE;      pColl[2].zName = (char*)&pColl[3];      pColl[2].enc = SQLITE_UTF16BE;      memcpy(pColl[0].zName, zName, nName);      pColl[0].zName[nName] = 0;      pDel = sqlite3HashInsert(&db->aCollSeq, pColl[0].zName, nName, pColl);      /* If a malloc() failure occured in sqlite3HashInsert(), it will       ** return the pColl pointer to be deleted (because it wasn't added      ** to the hash table).      */      assert( pDel==0 || pDel==pColl );      if( pDel!=0 ){        db->mallocFailed = 1;        sqlite3DbFree(db, pDel);        pColl = 0;      }    }  }  return pColl;}

/*** Locate and return an entry from the db.aCollSeq hash table. If the entry** specified by zName and nName is not found and parameter 'create' is** true, then create a new entry. Otherwise return NULL.**** Each pointer stored in the sqlite3.aCollSeq hash table contains an** array of three CollSeq structures. The first is the collation sequence** preferred for UTF-8, the second UTF-16le, and the third UTF-16be.**** Stored immediately after the three collation sequences is a copy of** the collation sequence name. A pointer to this string is stored in** each collation sequence structure.*/static CollSeq *findCollSeqEntry(  sqlite3 *db,          /* Database connection */  const char *zName,    /* Name of the collating sequence */  int create            /* Create a new entry if true */){  CollSeq *pColl;  pColl = sqlite3HashFind(&db->aCollSeq, zName);  if( 0==pColl && create ){    int nName = sqlite3Strlen30(zName) + 1;    pColl = sqlite3DbMallocZero(db, 3*sizeof(*pColl) + nName);    if( pColl ){      CollSeq *pDel = 0;      pColl[0].zName = (char*)&pColl[3];      pColl[0].enc = SQLITE_UTF8;      pColl[1].zName = (char*)&pColl[3];      pColl[1].enc = SQLITE_UTF16LE;      pColl[2].zName = (char*)&pColl[3];      pColl[2].enc = SQLITE_UTF16BE;      memcpy(pColl[0].zName, zName, nName);      pDel = sqlite3HashInsert(&db->aCollSeq, pColl[0].zName, pColl);      /* If a malloc() failure occurred in sqlite3HashInsert(), it will       ** return the pColl pointer to be deleted (because it wasn't added      ** to the hash table).      */      assert( pDel==0 || pDel==pColl );      if( pDel!=0 ){        sqlite3OomFault(db);        sqlite3DbFree(db, pDel);        pColl = 0;      }    }  }  return pColl;}

/*** Locate a user function given a name, a number of arguments and a flag** indicating whether the function prefers UTF-16 over UTF-8.  Return a** pointer to the FuncDef structure that defines that function, or return** NULL if the function does not exist.**** If the createFlag argument is true, then a new (blank) FuncDef** structure is created and liked into the "db" structure if a** no matching function previously existed.**** If nArg is -2, then the first valid function found is returned.  A** function is valid if xSFunc is non-zero.  The nArg==(-2)** case is used to see if zName is a valid function name for some number** of arguments.  If nArg is -2, then createFlag must be 0.**** If createFlag is false, then a function with the required name and** number of arguments may be returned even if the eTextRep flag does not** match that requested.*/FuncDef *sqlite3FindFunction(  sqlite3 *db,       /* An open database */  const char *zName, /* Name of the function.  zero-terminated */  int nArg,          /* Number of arguments.  -1 means any number */  u8 enc,            /* Preferred text encoding */  u8 createFlag      /* Create new entry if true and does not otherwise exist */){  FuncDef *p;         /* Iterator variable */  FuncDef *pBest = 0; /* Best match found so far */  int bestScore = 0;  /* Score of best match */  int h;              /* Hash value */  int nName;          /* Length of the name */  assert( nArg>=(-2) );  assert( nArg>=(-1) || createFlag==0 );  nName = sqlite3Strlen30(zName);  /* First search for a match amongst the application-defined functions.  */  p = (FuncDef*)sqlite3HashFind(&db->aFunc, zName);  while( p ){    int score = matchQuality(p, nArg, enc);    if( score>bestScore ){      pBest = p;      bestScore = score;    }    p = p->pNext;  }  /* If no match is found, search the built-in functions.  **  ** If the DBFLAG_PreferBuiltin flag is set, then search the built-in  ** functions even if a prior app-defined function was found.  And give  ** priority to built-in functions.  **  ** Except, if createFlag is true, that means that we are trying to  ** install a new function.  Whatever FuncDef structure is returned it will  ** have fields overwritten with new information appropriate for the  ** new function.  But the FuncDefs for built-in functions are read-only.  ** So we must not search for built-ins when creating a new function.  */   if( !createFlag && (pBest==0 || (db->mDbFlags & DBFLAG_PreferBuiltin)!=0) ){    bestScore = 0;    h = (sqlite3UpperToLower[(u8)zName[0]] + nName) % SQLITE_FUNC_HASH_SZ;    p = functionSearch(h, zName);    while( p ){      int score = matchQuality(p, nArg, enc);      if( score>bestScore ){        pBest = p;        bestScore = score;      }      p = p->pNext;    }  }  /* If the createFlag parameter is true and the search did not reveal an  ** exact match for the name, number of arguments and encoding, then add a  ** new entry to the hash table and return it.  */  if( createFlag && bestScore<FUNC_PERFECT_MATCH &&       (pBest = sqlite3DbMallocZero(db, sizeof(*pBest)+nName+1))!=0 ){    FuncDef *pOther;    pBest->zName = (const char*)&pBest[1];    pBest->nArg = (u16)nArg;    pBest->funcFlags = enc;    memcpy((char*)&pBest[1], zName, nName+1);    pOther = (FuncDef*)sqlite3HashInsert(&db->aFunc, pBest->zName, pBest);    if( pOther==pBest ){      sqlite3DbFree(db, pBest);      sqlite3OomFault(db);      return 0;    }else{      pBest->pNext = pOther;    }  }  if( pBest && (pBest->xSFunc || createFlag) ){    return pBest;  }  return 0;}

/*** Locate a user function given a name, a number of arguments and a flag** indicating whether the function prefers UTF-16 over UTF-8.  Return a** pointer to the FuncDef structure that defines that function, or return** NULL if the function does not exist.**** If the createFlag argument is true, then a new (blank) FuncDef** structure is created and liked into the "db" structure if a** no matching function previously existed.  When createFlag is true** and the nArg parameter is -1, then only a function that accepts** any number of arguments will be returned.**** If createFlag is false and nArg is -1, then the first valid** function found is returned.  A function is valid if either xFunc** or xStep is non-zero.**** If createFlag is false, then a function with the required name and** number of arguments may be returned even if the eTextRep flag does not** match that requested.*/FuncDef *sqlite3FindFunction(  sqlite3 *db,       /* An open database */  const char *zName, /* Name of the function.  Not null-terminated */  int nName,         /* Number of characters in the name */  int nArg,          /* Number of arguments.  -1 means any number */  u8 enc,            /* Preferred text encoding */  int createFlag     /* Create new entry if true and does not otherwise exist */){  FuncDef *p;         /* Iterator variable */  FuncDef *pBest = 0; /* Best match found so far */  int bestScore = 0;  /* Score of best match */  int h;              /* Hash value */  assert( enc==SQLITE_UTF8 || enc==SQLITE_UTF16LE || enc==SQLITE_UTF16BE );  if( nArg<-1 ) nArg = -1;  h = (sqlite3UpperToLower[(u8)zName[0]] + nName) % ArraySize(db->aFunc.a);  /* First search for a match amongst the application-defined functions.  */  p = functionSearch(&db->aFunc, h, zName, nName);  while( p ){    int score = matchQuality(p, nArg, enc);    if( score>bestScore ){      pBest = p;      bestScore = score;    }    p = p->pNext;  }  /* If no match is found, search the built-in functions.  **  ** Except, if createFlag is true, that means that we are trying to  ** install a new function.  Whatever FuncDef structure is returned will  ** have fields overwritten with new information appropriate for the  ** new function.  But the FuncDefs for built-in functions are read-only.  ** So we must not search for built-ins when creating a new function.  */   if( !createFlag && !pBest ){    FuncDefHash *pHash = &GLOBAL(FuncDefHash, sqlite3GlobalFunctions);    p = functionSearch(pHash, h, zName, nName);    while( p ){      int score = matchQuality(p, nArg, enc);      if( score>bestScore ){        pBest = p;        bestScore = score;      }      p = p->pNext;    }  }  /* If the createFlag parameter is true and the search did not reveal an  ** exact match for the name, number of arguments and encoding, then add a  ** new entry to the hash table and return it.  */  if( createFlag && (bestScore<6 || pBest->nArg!=nArg) &&       (pBest = sqlite3DbMallocZero(db, sizeof(*pBest)+nName+1))!=0 ){    pBest->zName = (char *)&pBest[1];    pBest->nArg = (u16)nArg;    pBest->iPrefEnc = enc;    memcpy(pBest->zName, zName, nName);    pBest->zName[nName] = 0;    sqlite3FuncDefInsert(&db->aFunc, pBest);  }  if( pBest && (pBest->xStep || pBest->xFunc || createFlag) ){    return pBest;  }  return 0;}

/*** 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 nRetry = 0;             /* Number of retry attempts */  int callbackIsInit;         /* True if callback data is initialized */  if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT;  if( zSql==0 ) zSql = "";#ifdef SQLITE_ENABLE_SQLRR  SRRecExec(db, zSql);#endif    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;    }    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;      }//.........这里部分代码省略.........

/*** Locate a user function given a name, a number of arguments and a flag** indicating whether the function prefers UTF-16 over UTF-8.  Return a** pointer to the FuncDef structure that defines that function, or return** NULL if the function does not exist.**** If the createFlag argument is true, then a new (blank) FuncDef** structure is created and liked into the "db" structure if a** no matching function previously existed.  When createFlag is true** and the nArg parameter is -1, then only a function that accepts** any number of arguments will be returned.**** If createFlag is false and nArg is -1, then the first valid** function found is returned.  A function is valid if either xFunc** or xStep is non-zero.**** If createFlag is false, then a function with the required name and** number of arguments may be returned even if the eTextRep flag does not** match that requested.*/FuncDef *sqlite3FindFunction(  sqlite3 *db,       /* An open database */  const char *zName, /* Name of the function.  Not null-terminated */  int nName,         /* Number of characters in the name */  int nArg,          /* Number of arguments.  -1 means any number */  u8 enc,            /* Preferred text encoding */  int createFlag     /* Create new entry if true and does not otherwise exist */){  FuncDef *p;         /* Iterator variable */  FuncDef *pFirst;    /* First function with this name */  FuncDef *pBest = 0; /* Best match found so far */  int bestmatch = 0;    assert( enc==SQLITE_UTF8 || enc==SQLITE_UTF16LE || enc==SQLITE_UTF16BE );  if( nArg<-1 ) nArg = -1;  pFirst = (FuncDef*)sqlite3HashFind(&db->aFunc, zName, nName);  for(p=pFirst; p; p=p->pNext){    /* During the search for the best function definition, bestmatch is set    ** as follows to indicate the quality of the match with the definition    ** pointed to by pBest:    **    ** 0: pBest is NULL. No match has been found.    ** 1: A variable arguments function that prefers UTF-8 when a UTF-16    **    encoding is requested, or vice versa.    ** 2: A variable arguments function that uses UTF-16BE when UTF-16LE is    **    requested, or vice versa.    ** 3: A variable arguments function using the same text encoding.    ** 4: A function with the exact number of arguments requested that    **    prefers UTF-8 when a UTF-16 encoding is requested, or vice versa.    ** 5: A function with the exact number of arguments requested that    **    prefers UTF-16LE when UTF-16BE is requested, or vice versa.    ** 6: An exact match.    **    ** A larger value of 'matchqual' indicates a more desirable match.    */    if( p->nArg==-1 || p->nArg==nArg || nArg==-1 ){      int match = 1;          /* Quality of this match */      if( p->nArg==nArg || nArg==-1 ){        match = 4;      }      if( enc==p->iPrefEnc ){        match += 2;      }      else if( (enc==SQLITE_UTF16LE && p->iPrefEnc==SQLITE_UTF16BE) ||               (enc==SQLITE_UTF16BE && p->iPrefEnc==SQLITE_UTF16LE) ){        match += 1;      }      if( match>bestmatch ){        pBest = p;        bestmatch = match;      }    }  }  /* If the createFlag parameter is true, and the seach did not reveal an  ** exact match for the name, number of arguments and encoding, then add a  ** new entry to the hash table and return it.  */  if( createFlag && bestmatch<6 &&       (pBest = sqlite3DbMallocZero(db, sizeof(*pBest)+nName))!=0 ){    pBest->nArg = nArg;    pBest->pNext = pFirst;    pBest->iPrefEnc = enc;    memcpy(pBest->zName, zName, nName);    pBest->zName[nName] = 0;    if( pBest==sqlite3HashInsert(&db->aFunc,pBest->zName,nName,(void*)pBest) ){      db->mallocFailed = 1;      sqlite3DbFree(db, pBest);      return 0;    }  }  if( pBest && (pBest->xStep || pBest->xFunc || createFlag) ){    return pBest;  }  return 0;}

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

//.........这里部分代码省略.........        }        return SQLITE_ERROR;    }        zEntry = zProc ? zProc : "sqlite3_extension_init";        handle = sqlite3OsDlOpen(pVfs, zFile);#if SQLITE_OS_UNIX || SQLITE_OS_WIN    for(ii=0; ii<ArraySize(azEndings) && handle==0; ii++){        char *zAltFile = sqlite3_mprintf("%s.%s", zFile, azEndings[ii]);        if( zAltFile==0 ) return SQLITE_NOMEM;        handle = sqlite3OsDlOpen(pVfs, zAltFile);        sqlite3_free(zAltFile);    }#endif    if( handle==0 ){        if( pzErrMsg ){            *pzErrMsg = zErrmsg = sqlite3_malloc(nMsg);            if( zErrmsg ){                sqlite3_snprintf(nMsg, zErrmsg,                                 "unable to open shared library [%s]", zFile);                sqlite3OsDlError(pVfs, nMsg-1, zErrmsg);            }        }        return SQLITE_ERROR;    }    xInit = (int(*)(sqlite3*,char**,const sqlite3_api_routines*))    sqlite3OsDlSym(pVfs, handle, zEntry);        /* If no entry point was specified and the default legacy     ** entry point name "sqlite3_extension_init" was not found, then     ** construct an entry point name "sqlite3_X_init" where the X is     ** replaced by the lowercase value of every ASCII alphabetic     ** character in the filename after the last "/" upto the first ".",     ** and eliding the first three characters if they are "lib".     ** Examples:     **     **    /usr/local/lib/libExample5.4.3.so ==>  sqlite3_example_init     **    C:/lib/mathfuncs.dll              ==>  sqlite3_mathfuncs_init     */    if( xInit==0 && zProc==0 ){        int iFile, iEntry, c;        int ncFile = sqlite3Strlen30(zFile);        zAltEntry = sqlite3_malloc(ncFile+30);        if( zAltEntry==0 ){            sqlite3OsDlClose(pVfs, handle);            return SQLITE_NOMEM;        }        memcpy(zAltEntry, "sqlite3_", 8);        for(iFile=ncFile-1; iFile>=0 && zFile[iFile]!='/'; iFile--){}        iFile++;        if( sqlite3_strnicmp(zFile+iFile, "lib", 3)==0 ) iFile += 3;        for(iEntry=8; (c = zFile[iFile])!=0 && c!='.'; iFile++){            if( sqlite3Isalpha(c) ){                zAltEntry[iEntry++] = (char)sqlite3UpperToLower[(unsigned)c];            }        }        memcpy(zAltEntry+iEntry, "_init", 6);        zEntry = zAltEntry;        xInit = (int(*)(sqlite3*,char**,const sqlite3_api_routines*))        sqlite3OsDlSym(pVfs, handle, zEntry);    }    if( xInit==0 ){        if( pzErrMsg ){            nMsg += sqlite3Strlen30(zEntry);            *pzErrMsg = zErrmsg = sqlite3_malloc(nMsg);            if( zErrmsg ){                sqlite3_snprintf(nMsg, zErrmsg,                                 "no entry point [%s] in shared library [%s]", zEntry, zFile);                sqlite3OsDlError(pVfs, nMsg-1, zErrmsg);            }        }        sqlite3OsDlClose(pVfs, handle);        sqlite3_free(zAltEntry);        return SQLITE_ERROR;    }    sqlite3_free(zAltEntry);    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;}

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

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

/*** 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;  int nMsg = 300 + sqlite3Strlen30(zFile);  if( pzErrMsg ) *pzErrMsg = 0;  /* 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 ){      *pzErrMsg = zErrmsg = sqlite3_malloc(nMsg);      if( zErrmsg ){        sqlite3_snprintf(nMsg, zErrmsg,             "unable to open shared library [%s]", zFile);        sqlite3OsDlError(pVfs, nMsg-1, zErrmsg);      }    }    return SQLITE_ERROR;  }  xInit = (int(*)(sqlite3*,char**,const sqlite3_api_routines*))                   sqlite3OsDlSym(pVfs, handle, zProc);  if( xInit==0 ){    if( pzErrMsg ){      nMsg += sqlite3Strlen30(zProc);      *pzErrMsg = zErrmsg = sqlite3_malloc(nMsg);      if( zErrmsg ){        sqlite3_snprintf(nMsg, zErrmsg,            "no entry point [%s] in shared library [%s]", zProc,zFile);        sqlite3OsDlError(pVfs, nMsg-1, zErrmsg);      }      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 );    }}

/*** Once the sorter has been populated, this function is called to prepare** for iterating through its contents in sorted order.*/int sqlite3VdbeSorterRewind(sqlite3 *db, VdbeCursor *pCsr, int *pbEof){  VdbeSorter *pSorter = pCsr->pSorter;  int rc;                         /* Return code */  sqlite3_file *pTemp2 = 0;       /* Second temp file to use */  i64 iWrite2 = 0;                /* Write offset for pTemp2 */  int nIter;                      /* Number of iterators used */  int nByte;                      /* Bytes of space required for aIter/aTree */  int N = 2;                      /* Power of 2 >= nIter */  assert( pSorter );  /* If no data has been written to disk, then do not do so now. Instead,  ** sort the VdbeSorter.pRecord list. The vdbe layer will read data directly  ** from the in-memory list.  */  if( pSorter->nPMA==0 ){    *pbEof = !pSorter->pRecord;    assert( pSorter->aTree==0 );    return vdbeSorterSort(pCsr);  }  /* Write the current b-tree to a PMA. Close the b-tree cursor. */  rc = vdbeSorterListToPMA(db, pCsr);  if( rc!=SQLITE_OK ) return rc;  /* Allocate space for aIter[] and aTree[]. */  nIter = pSorter->nPMA;  if( nIter>SORTER_MAX_MERGE_COUNT ) nIter = SORTER_MAX_MERGE_COUNT;  assert( nIter>0 );  while( N<nIter ) N += N;  nByte = N * (sizeof(int) + sizeof(VdbeSorterIter));  pSorter->aIter = (VdbeSorterIter *)sqlite3DbMallocZero(db, nByte);  if( !pSorter->aIter ) return SQLITE_NOMEM;  pSorter->aTree = (int *)&pSorter->aIter[N];  pSorter->nTree = N;  do {    int iNew;                     /* Index of new, merged, PMA */    for(iNew=0;         rc==SQLITE_OK && iNew*SORTER_MAX_MERGE_COUNT<pSorter->nPMA;         iNew++    ){      i64 nWrite;                 /* Number of bytes in new PMA */      /* If there are SORTER_MAX_MERGE_COUNT or less PMAs in file pTemp1,      ** initialize an iterator for each of them and break out of the loop.      ** These iterators will be incrementally merged as the VDBE layer calls      ** sqlite3VdbeSorterNext().      **      ** Otherwise, if pTemp1 contains more than SORTER_MAX_MERGE_COUNT PMAs,      ** initialize interators for SORTER_MAX_MERGE_COUNT of them. These PMAs      ** are merged into a single PMA that is written to file pTemp2.      */      rc = vdbeSorterInitMerge(db, pCsr, &nWrite);      assert( rc!=SQLITE_OK || pSorter->aIter[ pSorter->aTree[1] ].pFile );      if( rc!=SQLITE_OK || pSorter->nPMA<=SORTER_MAX_MERGE_COUNT ){        break;      }      /* Open the second temp file, if it is not already open. */      if( pTemp2==0 ){        assert( iWrite2==0 );        rc = vdbeSorterOpenTempFile(db, &pTemp2);      }      if( rc==SQLITE_OK ){        rc = vdbeSorterWriteVarint(pTemp2, nWrite, &iWrite2);      }      if( rc==SQLITE_OK ){        int bEof = 0;        while( rc==SQLITE_OK && bEof==0 ){          int nToWrite;          VdbeSorterIter *pIter = &pSorter->aIter[ pSorter->aTree[1] ];          assert( pIter->pFile );          nToWrite = pIter->nKey + sqlite3VarintLen(pIter->nKey);          rc = sqlite3OsWrite(pTemp2, pIter->aAlloc, nToWrite, iWrite2);          iWrite2 += nToWrite;          if( rc==SQLITE_OK ){            rc = sqlite3VdbeSorterNext(db, pCsr, &bEof);          }        }      }    }    if( pSorter->nPMA<=SORTER_MAX_MERGE_COUNT ){      break;    }else{      sqlite3_file *pTmp = pSorter->pTemp1;      pSorter->nPMA = iNew;      pSorter->pTemp1 = pTemp2;      pTemp2 = pTmp;      pSorter->iWriteOff = iWrite2;      pSorter->iReadOff = 0;      iWrite2 = 0;    }//.........这里部分代码省略.........

/*** Invoke a virtual table constructor (either xCreate or xConnect). The** pointer to the function to invoke is passed as the fourth parameter** to this procedure.*/static int vtabCallConstructor(  sqlite3 *db,   Table *pTab,  Module *pMod,  int (*xConstruct)(sqlite3*,void*,int,const char*const*,sqlite3_vtab**,char**),  char **pzErr){  VtabCtx sCtx;  VTable *pVTable;  int rc;  const char *const*azArg = (const char *const*)pTab->azModuleArg;  int nArg = pTab->nModuleArg;  char *zErr = 0;  char *zModuleName;  int iDb;  VtabCtx *pCtx;  /* Check that the virtual-table is not already being initialized */  for(pCtx=db->pVtabCtx; pCtx; pCtx=pCtx->pPrior){    if( pCtx->pTab==pTab ){      *pzErr = sqlite3MPrintf(db,           "vtable constructor called recursively: %s", pTab->zName      );      return SQLITE_LOCKED;    }  }  zModuleName = sqlite3MPrintf(db, "%s", pTab->zName);  if( !zModuleName ){    return SQLITE_NOMEM_BKPT;  }  pVTable = sqlite3DbMallocZero(db, sizeof(VTable));  if( !pVTable ){    sqlite3DbFree(db, zModuleName);    return SQLITE_NOMEM_BKPT;  }  pVTable->db = db;  pVTable->pMod = pMod;  iDb = sqlite3SchemaToIndex(db, pTab->pSchema);  pTab->azModuleArg[1] = db->aDb[iDb].zDbSName;  /* Invoke the virtual table constructor */  assert( &db->pVtabCtx );  assert( xConstruct );  sCtx.pTab = pTab;  sCtx.pVTable = pVTable;  sCtx.pPrior = db->pVtabCtx;  sCtx.bDeclared = 0;  db->pVtabCtx = &sCtx;  rc = xConstruct(db, pMod->pAux, nArg, azArg, &pVTable->pVtab, &zErr);  db->pVtabCtx = sCtx.pPrior;  if( rc==SQLITE_NOMEM ) sqlite3OomFault(db);  assert( sCtx.pTab==pTab );  if( SQLITE_OK!=rc ){    if( zErr==0 ){      *pzErr = sqlite3MPrintf(db, "vtable constructor failed: %s", zModuleName);    }else {      *pzErr = sqlite3MPrintf(db, "%s", zErr);      sqlite3_free(zErr);    }    sqlite3DbFree(db, pVTable);  }else if( ALWAYS(pVTable->pVtab) ){    /* Justification of ALWAYS():  A correct vtab constructor must allocate    ** the sqlite3_vtab object if successful.  */    memset(pVTable->pVtab, 0, sizeof(pVTable->pVtab[0]));    pVTable->pVtab->pModule = pMod->pModule;    pVTable->nRef = 1;    if( sCtx.bDeclared==0 ){      const char *zFormat = "vtable constructor did not declare schema: %s";      *pzErr = sqlite3MPrintf(db, zFormat, pTab->zName);      sqlite3VtabUnlock(pVTable);      rc = SQLITE_ERROR;    }else{      int iCol;      u8 oooHidden = 0;      /* If everything went according to plan, link the new VTable structure      ** into the linked list headed by pTab->pVTable. Then loop through the       ** columns of the table to see if any of them contain the token "hidden".      ** If so, set the Column COLFLAG_HIDDEN flag and remove the token from      ** the type string.  */      pVTable->pNext = pTab->pVTable;      pTab->pVTable = pVTable;      for(iCol=0; iCol<pTab->nCol; iCol++){        char *zType = sqlite3ColumnType(&pTab->aCol[iCol], "");        int nType;        int i = 0;        nType = sqlite3Strlen30(zType);        for(i=0; i<nType; i++){          if( 0==sqlite3StrNICmp("hidden", &zType[i], 6)           && (i==0 || zType[i-1]==' ')           && (zType[i+6]=='/0' || zType[i+6]==' ')//.........这里部分代码省略.........

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