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

  bool termSubsumes(const TERM& t1,const TERM& t2)    {      CALL("termSubsumes(const TERM& t1,const TERM& t2)");      ALWAYS(_termTraversal1.reset(t1));      _termTraversal2.reset(t2);      do	{	  if (_termTraversal1.symbol() != _termTraversal2.symbol()) return false;	  ALWAYS(_termTraversal1.next());	  _termTraversal2.next();	}      while (_termTraversal2);      return true;      }; // bool termSubsumes(const TERM& t1,const TERM& t2)

      bool nextPair(ulong& x,ulong& y)      {       CALL("nextPair(ulong& x,ulong& y)");       if (_yClass.nextElement(y))         {	 if (_currX < y) { x = _currX; }         else // result must be swapped	  { 	   x = y;           y = _currX;          };         return true;         };       if (_xClass.nextElement(_currX))  	{         _yClass.reset();         ALWAYS(_yClass.nextElement(y));         if (_currX < y) { x = _currX; }         else // result must be swapped	  { 	   x = y;           y = _currX;          };	 return true;        };       return false;      }; 

/*** This function is invoked by the vdbe to call the xDestroy method** of the virtual table named zTab in database iDb. This occurs** when a DROP TABLE is mentioned.**** This call is a no-op if zTab is not a virtual table.*/int sqlite3VtabCallDestroy(sqlite3 *db, int iDb, const char *zTab){  int rc = SQLITE_OK;  Table *pTab;  pTab = sqlite3FindTable(db, zTab, db->aDb[iDb].zDbSName);  if( pTab!=0 && ALWAYS(pTab->pVTable!=0) ){    VTable *p;    int (*xDestroy)(sqlite3_vtab *);    for(p=pTab->pVTable; p; p=p->pNext){      assert( p->pVtab );      if( p->pVtab->nRef>0 ){        return SQLITE_LOCKED;      }    }    p = vtabDisconnectAll(db, pTab);    xDestroy = p->pMod->pModule->xDestroy;    assert( xDestroy!=0 );  /* Checked before the virtual table is created */    rc = xDestroy(p->pVtab);    /* Remove the sqlite3_vtab* from the aVTrans[] array, if applicable */    if( rc==SQLITE_OK ){      assert( pTab->pVTable==p && p->pNext==0 );      p->pVtab = 0;      pTab->pVTable = 0;      sqlite3VtabUnlock(p);    }  }  return rc;}

static PgHdr *pcacheSortDirtyList(PgHdr *pIn){  PgHdr *a[N_SORT_BUCKET], *p;  int i;  memset(a, 0, sizeof(a));  while( pIn ){    p = pIn;    pIn = p->pDirty;    p->pDirty = 0;    for(i=0; ALWAYS(i<N_SORT_BUCKET-1); i++){      if( a[i]==0 ){        a[i] = p;        break;      }else{        p = pcacheMergeDirtyList(a[i], p);        a[i] = 0;      }    }    if( NEVER(i==N_SORT_BUCKET-1) ){      /* To get here, there need to be 2^(N_SORT_BUCKET) elements in      ** the input list.  But that is impossible.      */      a[i] = pcacheMergeDirtyList(a[i], p);    }  }  p = a[0];  for(i=1; i<N_SORT_BUCKET; i++){    p = pcacheMergeDirtyList(p, a[i]);  }  return p;}

/*** The first character of the string pointed to by argument z is guaranteed** to be an open-quote character (see function fts5_isopenquote()).**** This function searches for the corresponding close-quote character within** the string and, if found, dequotes the string in place and adds a new** nul-terminator byte.**** If the close-quote is found, the value returned is the byte offset of** the character immediately following it. Or, if the close-quote is not ** found, -1 is returned. If -1 is returned, the buffer is left in an ** undefined state.*/static int fts5Dequote(char *z){  char q;  int iIn = 1;  int iOut = 0;  q = z[0];  /* Set stack variable q to the close-quote character */  assert( q=='[' || q=='/'' || q=='"' || q=='`' );  if( q=='[' ) q = ']';    while( ALWAYS(z[iIn]) ){    if( z[iIn]==q ){      if( z[iIn+1]!=q ){        /* Character iIn was the close quote. */        iIn++;        break;      }else{        /* Character iIn and iIn+1 form an escaped quote character. Skip        ** the input cursor past both and copy a single quote character         ** to the output buffer. */        iIn += 2;        z[iOut++] = q;      }    }else{      z[iOut++] = z[iIn++];    }  }  z[iOut] = '/0';  return iIn;}

/*** Drop every cache entry whose page number is greater than "pgno". The** caller must ensure that there are no outstanding references to any pages** other than page 1 with a page number greater than pgno.**** If there is a reference to page 1 and the pgno parameter passed to this** function is 0, then the data area associated with page 1 is zeroed, but** the page object is not dropped.*/void sqlite3PcacheTruncate(PCache *pCache, Pgno pgno){  if( pCache->pCache ){    PgHdr *p;    PgHdr *pNext;    pcacheTrace(("%p.TRUNCATE %d/n",pCache,pgno));    for(p=pCache->pDirty; p; p=pNext){      pNext = p->pDirtyNext;      /* This routine never gets call with a positive pgno except right      ** after sqlite3PcacheCleanAll().  So if there are dirty pages,      ** it must be that pgno==0.      */      assert( p->pgno>0 );      if( p->pgno>pgno ){        assert( p->flags&PGHDR_DIRTY );        sqlite3PcacheMakeClean(p);      }    }    if( pgno==0 && pCache->nRefSum ){      sqlite3_pcache_page *pPage1;      pPage1 = sqlite3GlobalConfig.pcache2.xFetch(pCache->pCache,1,0);      if( ALWAYS(pPage1) ){  /* Page 1 is always available in cache, because                             ** pCache->nRefSum>0 */        memset(pPage1->pBuf, 0, pCache->szPage);        pgno = 1;      }    }    sqlite3GlobalConfig.pcache2.xTruncate(pCache->pCache, pgno+1);  }}

/* This function (for internal use only) locates an element in an** hash table that matches the given key.  The hash for this key has** already been computed and is passed as the 4th parameter.*/static HashElem *findElementGivenHash(  const Hash *pH,     /* The pH to be searched */  const char *pKey,   /* The key we are searching for */  int nKey,           /* Bytes in key (not counting zero terminator) */  unsigned int h      /* The hash for this key. */){  HashElem *elem;                /* Used to loop thru the element list */  int count;                     /* Number of elements left to test */  if( pH->ht ){    struct _ht *pEntry = &pH->ht[h];    elem = pEntry->chain;    count = pEntry->count;  }else{    elem = pH->first;    count = pH->count;  }  while( count-- && ALWAYS(elem) ){    if( elem->nKey==nKey && sqlite3StrNICmp(elem->pKey,pKey,nKey)==0 ){       return elem;    }    elem = elem->next;  }  return 0;}

/*** Convert an SQL-style quoted string into a normal string by removing** the quote characters.  The conversion is done in-place.  If the** input does not begin with a quote character, then this routine** is a no-op.**** The input string must be zero-terminated.  A new zero-terminator** is added to the dequoted string.**** The return value is -1 if no dequoting occurs or the length of the** dequoted string, exclusive of the zero terminator, if dequoting does** occur.**** 2002-Feb-14: This routine is extended to remove MS-Access style** brackets from around identifers.  For example:  "[a-b-c]" becomes** "a-b-c".*/int sqlite3Dequote(char *z){  char quote;  int i, j;  if( z==0 ) return -1;  quote = z[0];  switch( quote ){    case '/'':  break;    case '"':   break;    case '`':   break;                /* For MySQL compatibility */    case '[':   quote = ']';  break;  /* For MS SqlServer compatibility */    default:    return -1;  }  for(i=1, j=0; ALWAYS(z[i]); i++){    if( z[i]==quote ){      if( z[i+1]==quote ){        z[j++] = quote;        i++;      }else{        break;      }    }else{      z[j++] = z[i];    }  }  z[j] = 0;  return j;}

/*** The MEM structure is already a MEM_Real.  Try to also make it a** MEM_Int if we can.*/void sqlite3VdbeIntegerAffinity(Mem *pMem){  assert( pMem->flags & MEM_Real );  assert( (pMem->flags & MEM_RowSet)==0 );  assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );  assert( EIGHT_BYTE_ALIGNMENT(pMem) );  pMem->u.i = doubleToInt64(pMem->r);  /* Only mark the value as an integer if  **  **    (1) the round-trip conversion real->int->real is a no-op, and  **    (2) The integer is neither the largest nor the smallest  **        possible integer (ticket #3922)  **  ** The second and third terms in the following conditional enforces  ** the second condition under the assumption that addition overflow causes  ** values to wrap around.  On x86 hardware, the third term is always  ** true and could be omitted.  But we leave it in because other  ** architectures might behave differently.  */  if( pMem->r==(double)pMem->u.i   && pMem->u.i>SMALLEST_INT64#if defined(__i486__) || defined(__x86_64__)   && ALWAYS(pMem->u.i<LARGEST_INT64)#else   && pMem->u.i<LARGEST_INT64#endif  ){    pMem->flags |= MEM_Int;  }}

/*** This function is invoked by the vdbe to call the xCreate method** of the virtual table named zTab in database iDb. **** If an error occurs, *pzErr is set to point to an English language** description of the error and an SQLITE_XXX error code is returned.** In this case the caller must call sqlite3DbFree(db, ) on *pzErr.*/int sqlite3VtabCallCreate(sqlite3 *db, int iDb, const char *zTab, char **pzErr){  int rc = SQLITE_OK;  Table *pTab;  Module *pMod;  const char *zMod;  pTab = sqlite3FindTable(db, zTab, db->aDb[iDb].zDbSName);  assert( pTab && (pTab->tabFlags & TF_Virtual)!=0 && !pTab->pVTable );  /* Locate the required virtual table module */  zMod = pTab->azModuleArg[0];  pMod = (Module*)sqlite3HashFind(&db->aModule, zMod);  /* If the module has been registered and includes a Create method,   ** invoke it now. If the module has not been registered, return an   ** error. Otherwise, do nothing.  */  if( pMod==0 || pMod->pModule->xCreate==0 || pMod->pModule->xDestroy==0 ){    *pzErr = sqlite3MPrintf(db, "no such module: %s", zMod);    rc = SQLITE_ERROR;  }else{    rc = vtabCallConstructor(db, pTab, pMod, pMod->pModule->xCreate, pzErr);  }  /* Justification of ALWAYS():  The xConstructor method is required to  ** create a valid sqlite3_vtab if it returns SQLITE_OK. */  if( rc==SQLITE_OK && ALWAYS(sqlite3GetVTable(db, pTab)) ){    rc = growVTrans(db);    if( rc==SQLITE_OK ){      addToVTrans(db, sqlite3GetVTable(db, pTab));    }  }  return rc;}

/*** The text between zStart and zEnd represents a phrase within a larger** SQL statement.  Make a copy of this phrase in space obtained form** sqlite3DbMalloc().  Omit leading and trailing whitespace.*/char *sqlite3DbSpanDup(sqlite3 *db, const char *zStart, const char *zEnd){  int n;  while( sqlite3Isspace(zStart[0]) ) zStart++;  n = (int)(zEnd - zStart);  while( ALWAYS(n>0) && sqlite3Isspace(zStart[n-1]) ) n--;  return sqlite3DbStrNDup(db, zStart, n);}

static PgHdr *pcacheSortDirtyList(PgHdr *pIn){  PgHdr *a[N_SORT_BUCKET], *p;  int i;  memset(a, 0, sizeof(a));  while( pIn ){    p = pIn;    pIn = p->pDirty;    p->pDirty = 0;    for(i=0; ALWAYS(i<N_SORT_BUCKET-1); i++){      if( a[i]==0 ){        a[i] = p;        break;      }else{        p = pcacheMergeDirtyList(a[i], p);        a[i] = 0;      }    }    if( NEVER(i==N_SORT_BUCKET-1) ){      a[i] = pcacheMergeDirtyList(a[i], p);    }  }  p = a[0];  for(i=1; i<N_SORT_BUCKET; i++){    p = pcacheMergeDirtyList(p, a[i]);  }  return p;}

/*** This routine takes the module argument that has been accumulating** in pParse->zArg[] and appends it to the list of arguments on the** virtual table currently under construction in pParse->pTable.*/static void addArgumentToVtab(Parse *pParse){  if( pParse->sArg.z && ALWAYS(pParse->pNewTable) ){    const char *z = (const char*)pParse->sArg.z;    int n = pParse->sArg.n;    sqlite3 *db = pParse->db;    addModuleArgument(db, pParse->pNewTable, sqlite3DbStrNDup(db, z, n));  }}

/*** Set the LIKEOPT flag on the 2-argument function with the given name.*/static void setLikeOptFlag(sqlite3 *db, const char *zName, u8 flagVal){  FuncDef *pDef;  pDef = sqlite3FindFunction(db, zName, sqlite3Strlen30(zName),                             2, SQLITE_UTF8, 0);  if( ALWAYS(pDef) ){    pDef->flags = flagVal;  }}

/*** Free a page object allocated by pcache1AllocPage().**** The pointer is allowed to be NULL, which is prudent.  But it turns out** that the current implementation happens to never call this routine** with a NULL pointer, so we mark the NULL test with ALWAYS().*/static void pcache1FreePage(PgHdr1 *p){  if( ALWAYS(p) ){    if( p->pCache->bPurgeable ){      pcache1.nCurrentPage--;    }    pcache1Free(PGHDR1_TO_PAGE(p));  }}

/*** Free a page object allocated by pcache1AllocPage().**** The pointer is allowed to be NULL, which is prudent.  But it turns out** that the current implementation happens to never call this routine** with a NULL pointer, so we mark the NULL test with ALWAYS().*/static void pcache1FreePage(PgHdr1 *p){  if( ALWAYS(p) ){    PCache1 *pCache = p->pCache;    if( pCache->bPurgeable ){      pCache->pGroup->nCurrentPage--;    }    pcache1Free(PGHDR1_TO_PAGE(p));  }}

 void reset(EquivalenceRelation& rel,const ulong& x,const ulong& y) {  CALL("MergedPairs::reset(EquivalenceRelation& rel,const ulong& x,const ulong& y)");  ASSERT(!rel.Equivalent(x,y));  rel.Normalize();  _xClass.init(rel,x);  _yClass.init(rel,y);  ALWAYS(_xClass.nextElement(_currX));  };

static void minMaxFinalize(sqlite3_context *context){  sqlite3_value *pRes;  pRes = (sqlite3_value *)sqlite3_aggregate_context(context, 0);  if( pRes ){    if( ALWAYS(pRes->flags) ){      sqlite3_result_value(context, pRes);    }    sqlite3VdbeMemRelease(pRes);  }}

/*** This is the top-level implementation of sqlite3_step().  Call** sqlite3Step() to do most of the work.  If a schema error occurs,** call sqlite3Reprepare() and try again.*/int sqlite3_step(sqlite3_stmt *pStmt){  int rc = SQLITE_OK;      /* Result from sqlite3Step() */  int rc2 = SQLITE_OK;     /* Result from sqlite3Reprepare() */  Vdbe *v = (Vdbe*)pStmt;  /* the prepared statement */  int cnt = 0;             /* Counter to prevent infinite loop of reprepares */  sqlite3 *db;             /* The database connection */  if( vdbeSafetyNotNull(v) ){    return SQLITE_MISUSE_BKPT;  }  db = v->db;  sqlite3_mutex_enter(db->mutex);  v->doingRerun = 0;  while( (rc = sqlite3Step(v))==SQLITE_SCHEMA         && cnt++ < SQLITE_MAX_SCHEMA_RETRY         && (rc2 = rc = sqlite3Reprepare(v))==SQLITE_OK ){    sqlite3_reset(pStmt);    v->doingRerun = 1;    assert( v->expired==0 );  }  if( rc2!=SQLITE_OK && ALWAYS(v->isPrepareV2) && ALWAYS(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);      v->rc = rc2;    } else {      v->zErrMsg = 0;      v->rc = rc = SQLITE_NOMEM;    }  }  rc = sqlite3ApiExit(db, rc);  sqlite3_mutex_leave(db->mutex);  return rc;}

 void  operator delete(void* obj)  {  CALL("LitRedexPair::operator delete(void* obj)");   #ifdef DEBUG_ALLOC_OBJ_TYPE   ALWAYS(_classDesc.registerDeallocated(sizeof(LitRedexPair)));   BK::GlobAlloc::deallocate(obj,sizeof(LitRedexPair),&_classDesc);  #else   BK::GlobAlloc::deallocate(obj,sizeof(LitRedexPair));    #endif  };

 void* operator new(size_t)  {   CALL("LitRedexPair::operator new(size_t)");  #ifdef DEBUG_ALLOC_OBJ_TYPE   ALWAYS(_classDesc.registerAllocated(sizeof(LitRedexPair)));   return BK::GlobAlloc::allocate(sizeof(LitRedexPair),&_classDesc);   #else   return BK::GlobAlloc::allocate(sizeof(LitRedexPair));   #endif  };

/*** Subqueries stores the original database, table and column names for their** result sets in ExprList.a[].zSpan, in the form "DATABASE.TABLE.COLUMN".** Check to see if the zSpan given to this routine matches the zDb, zTab,** and zCol.  If any of zDb, zTab, and zCol are NULL then those fields will** match anything.*/int sqlite3MatchSpanName(  const char *zSpan,  const char *zCol,  const char *zTab,  const char *zDb){  int n;  for(n=0; ALWAYS(zSpan[n]) && zSpan[n]!='.'; n++){}  if( zDb && (sqlite3StrNICmp(zSpan, zDb, n)!=0 || zDb[n]!=0) ){    return 0;  }  zSpan += n+1;  for(n=0; ALWAYS(zSpan[n]) && zSpan[n]!='.'; n++){}  if( zTab && (sqlite3StrNICmp(zSpan, zTab, n)!=0 || zTab[n]!=0) ){    return 0;  }  zSpan += n+1;  if( zCol && sqlite3StrICmp(zSpan, zCol)!=0 ){    return 0;  }  return 1;}

/*** Free a page object allocated by pcache1AllocPage().**** The pointer is allowed to be NULL, which is prudent.  But it turns out** that the current implementation happens to never call this routine** with a NULL pointer, so we mark the NULL test with ALWAYS().*/static void pcache1FreePage(PgHdr1 *p){  if( ALWAYS(p) ){    PCache1 *pCache = p->pCache;    assert( sqlite3_mutex_held(p->pCache->pGroup->mutex) );    pcache1Free(p->page.pBuf);#ifdef SQLITE_PCACHE_SEPARATE_HEADER    sqlite3_free(p);#endif    if( pCache->bPurgeable ){      pCache->pGroup->nCurrentPage--;    }  }}

/* ** The pExpr should be a TK_COLUMN expression.  The table referred to ** is in pTabList or else it is the NEW or OLD table of a trigger. ** Check to see if it is OK to read this particular column. ** ** If the auth function returns SQLITE_IGNORE, change the TK_COLUMN ** instruction into a TK_NULL.  If the auth function returns SQLITE_DENY, ** then generate an error. */SQLITE_PRIVATE void sqlite3AuthRead(                                    Parse *pParse,        /* The parser context */                                    Expr *pExpr,          /* The expression to check authorization on */                                    Schema *pSchema,      /* The schema of the expression */                                    SrcList *pTabList     /* All table that pExpr might refer to */){    sqlite3 *db = pParse->db;    Table *pTab = 0;      /* The table being read */    const char *zCol;     /* Name of the column of the table */    int iSrc;             /* Index in pTabList->a[] of table being read */    int iDb;              /* The index of the database the expression refers to */    int iCol;             /* Index of column in table */        if( db->xAuth==0 ) return;    iDb = sqlite3SchemaToIndex(pParse->db, pSchema);    if( iDb<0 ){        /* An attempt to read a column out of a subquery or other         ** temporary table. */        return;    }        assert( pExpr->op==TK_COLUMN || pExpr->op==TK_TRIGGER );    if( pExpr->op==TK_TRIGGER ){        pTab = pParse->pTriggerTab;    }else{        assert( pTabList );        for(iSrc=0; ALWAYS(iSrc<pTabList->nSrc); iSrc++){            if( pExpr->iTable==pTabList->a[iSrc].iCursor ){                pTab = pTabList->a[iSrc].pTab;                break;            }        }    }    iCol = pExpr->iColumn;    if( NEVER(pTab==0) ) return;        if( iCol>=0 ){        assert( iCol<pTab->nCol );        zCol = pTab->aCol[iCol].zName;    }else if( pTab->iPKey>=0 ){        assert( pTab->iPKey<pTab->nCol );        zCol = pTab->aCol[pTab->iPKey].zName;    }else{        zCol = "ROWID";    }    assert( iDb>=0 && iDb<db->nDb );    if( SQLITE_IGNORE==sqlite3AuthReadCol(pParse, pTab->zName, zCol, iDb) ){        pExpr->op = TK_NULL;    }}

/*** Flush any buffered data to disk and clean up the file-writer object.** The results of using the file-writer after this call are undefined.** Return SQLITE_OK if flushing the buffered data succeeds or is not ** required. Otherwise, return an SQLite error code.**** Before returning, set *piEof to the offset immediately following the** last byte written to the file.*/static int fileWriterFinish(sqlite3 *db, FileWriter *p, i64 *piEof){  int rc;  if( p->eFWErr==0 && ALWAYS(p->aBuffer) && p->iBufEnd>p->iBufStart ){    p->eFWErr = sqlite3OsWrite(p->pFile,         &p->aBuffer[p->iBufStart], p->iBufEnd - p->iBufStart,         p->iWriteOff + p->iBufStart    );  }  *piEof = (p->iWriteOff + p->iBufEnd);  sqlite3DbFree(db, p->aBuffer);  rc = p->eFWErr;  memset(p, 0, sizeof(FileWriter));  return rc;}

/*** Make sure the page is marked as clean. If it isn't clean already,** make it so.*/void sqlite3PcacheMakeClean(PgHdr *p){  assert( sqlite3PcachePageSanity(p) );  if( ALWAYS((p->flags & PGHDR_DIRTY)!=0) ){    assert( (p->flags & PGHDR_CLEAN)==0 );    pcacheManageDirtyList(p, PCACHE_DIRTYLIST_REMOVE);    p->flags &= ~(PGHDR_DIRTY|PGHDR_NEED_SYNC|PGHDR_WRITEABLE);    p->flags |= PGHDR_CLEAN;    pcacheTrace(("%p.CLEAN %d/n",p->pCache,p->pgno));    assert( sqlite3PcachePageSanity(p) );    if( p->nRef==0 ){      pcacheUnpin(p);    }  }}

/*** Free an outstanding memory allocation.*/static void memsys5FreeUnsafe(void *pOld){  u32 size, iLogsize;  int iBlock;  /* Set iBlock to the index of the block pointed to by pOld in   ** the array of mem5.szAtom byte blocks pointed to by mem5.zPool.  */  iBlock = (int)(((u8 *)pOld-mem5.zPool)/mem5.szAtom);  /* Check that the pointer pOld points to a valid, non-free block. */  assert( iBlock>=0 && iBlock<mem5.nBlock );  assert( ((u8 *)pOld-mem5.zPool)%mem5.szAtom==0 );  assert( (mem5.aCtrl[iBlock] & CTRL_FREE)==0 );  iLogsize = mem5.aCtrl[iBlock] & CTRL_LOGSIZE;  size = 1<<iLogsize;  assert( iBlock+size-1<(u32)mem5.nBlock );  mem5.aCtrl[iBlock] |= CTRL_FREE;  mem5.aCtrl[iBlock+size-1] |= CTRL_FREE;  assert( mem5.currentCount>0 );  assert( mem5.currentOut>=(size*mem5.szAtom) );  mem5.currentCount--;  mem5.currentOut -= size*mem5.szAtom;  assert( mem5.currentOut>0 || mem5.currentCount==0 );  assert( mem5.currentCount>0 || mem5.currentOut==0 );  mem5.aCtrl[iBlock] = CTRL_FREE | iLogsize;  while( ALWAYS(iLogsize<LOGMAX) ){    int iBuddy;    if( (iBlock>>iLogsize) & 1 ){      iBuddy = iBlock - size;    }else{      iBuddy = iBlock + size;    }    assert( iBuddy>=0 );    if( (iBuddy+(1<<iLogsize))>mem5.nBlock ) break;    if( mem5.aCtrl[iBuddy]!=(CTRL_FREE | iLogsize) ) break;    memsys5Unlink(iBuddy, iLogsize);    iLogsize++;    if( iBuddy<iBlock ){      mem5.aCtrl[iBuddy] = CTRL_FREE | iLogsize;      mem5.aCtrl[iBlock] = 0;      iBlock = iBuddy;    }else{      mem5.aCtrl[iBlock] = CTRL_FREE | iLogsize;      mem5.aCtrl[iBuddy] = 0;    }    size *= 2;  }

/*** Remove a trigger from the hash tables of the sqlite* pointer.*/void sqlite3UnlinkAndDeleteTrigger(sqlite3 *db, int iDb, const char *zName){  Hash *pHash = &(db->aDb[iDb].pSchema->trigHash);  Trigger *pTrigger;  pTrigger = sqlite3HashInsert(pHash, zName, sqlite3Strlen30(zName), 0);  if( ALWAYS(pTrigger) ){    if( pTrigger->pSchema==pTrigger->pTabSchema ){      Table *pTab = tableOfTrigger(pTrigger);      Trigger **pp;      for(pp=&pTab->pTrigger; *pp!=pTrigger; pp=&((*pp)->pNext));      *pp = (*pp)->pNext;    }    sqlite3DeleteTrigger(db, pTrigger);    db->flags |= SQLITE_InternChanges;  }}

/*** We already know that pExpr is a binary operator where both operands are** column references.  This routine checks to see if pExpr is an equivalence** relation:**   1.  The SQLITE_Transitive optimization must be enabled**   2.  Must be either an == or an IS operator**   3.  Not originating in the ON clause of an OUTER JOIN**   4.  The affinities of A and B must be compatible**   5a. Both operands use the same collating sequence OR**   5b. The overall collating sequence is BINARY** If this routine returns TRUE, that means that the RHS can be substituted** for the LHS anyplace else in the WHERE clause where the LHS column occurs.** This is an optimization.  No harm comes from returning 0.  But if 1 is** returned when it should not be, then incorrect answers might result.*/static int termIsEquivalence(Parse *pParse, Expr *pExpr){  char aff1, aff2;  CollSeq *pColl;  const char *zColl1, *zColl2;  if( !OptimizationEnabled(pParse->db, SQLITE_Transitive) ) return 0;  if( pExpr->op!=TK_EQ && pExpr->op!=TK_IS ) return 0;  if( ExprHasProperty(pExpr, EP_FromJoin) ) return 0;  aff1 = sqlite3ExprAffinity(pExpr->pLeft);  aff2 = sqlite3ExprAffinity(pExpr->pRight);  if( aff1!=aff2   && (!sqlite3IsNumericAffinity(aff1) || !sqlite3IsNumericAffinity(aff2))  ){    return 0;  }  pColl = sqlite3BinaryCompareCollSeq(pParse, pExpr->pLeft, pExpr->pRight);  if( pColl==0 || sqlite3StrICmp(pColl->zName, "BINARY")==0 ) return 1;  pColl = sqlite3ExprCollSeq(pParse, pExpr->pLeft);  /* Since pLeft and pRight are both a column references, their collating  ** sequence should always be defined. */  zColl1 = ALWAYS(pColl) ? pColl->zName : 0;  pColl = sqlite3ExprCollSeq(pParse, pExpr->pRight);  zColl2 = ALWAYS(pColl) ? pColl->zName : 0;  return sqlite3StrICmp(zColl1, zColl2)==0;}

int sqlite3WalkSelectFrom(Walker *pWalker, Select *p){  SrcList *pSrc;  int i;  struct SrcList_item *pItem;  pSrc = p->pSrc;  if( ALWAYS(pSrc) ){    for(i=pSrc->nSrc, pItem=pSrc->a; i>0; i--, pItem++){      if( sqlite3WalkSelect(pWalker, pItem->pSelect) ){        return WRC_Abort;      }    }  }  return WRC_Continue;}