12122 SQLITE_API int sqlite3changeset_next(sqlite3_changeset_iter *pIter);
12157   sqlite3_changeset_iter *pIter,  /* Iterator object */
12191   sqlite3_changeset_iter *pIter,  /* Iterator object */
12222   sqlite3_changeset_iter *pIter,  /* Changeset iterator */
12256   sqlite3_changeset_iter *pIter,  /* Changeset iterator */
12284   sqlite3_changeset_iter *pIter,  /* Changeset iterator */
12301   sqlite3_changeset_iter *pIter,  /* Changeset iterator */
12336 SQLITE_API int sqlite3changeset_finalize(sqlite3_changeset_iter *pIter);
68082   WalIterator *pIter = 0;         /* Wal iterator context */  local
68127       rc = walIteratorInit(pWal, pInfo->nBackfill, &pIter);
68128       assert( rc==SQLITE_OK || pIter==0 );
68131     if( pIter
68163       while( rc==SQLITE_OK && 0==walIteratorNext(pIter, &iDbpage, &iFrame) ){
68250   SEH_FREE_ON_ERROR(pIter, 0);
68251   walIteratorFree(pIter);
71884   BtLock *pIter;  local
71911   for(pIter=pBt->pLock; pIter; pIter=pIter->pNext){
71921     assert( pIter->eLock==READ_LOCK || pIter->eLock==WRITE_LOCK );
71922     assert( eLock==READ_LOCK || pIter->pBtree==p || pIter->eLock==READ_LOCK);
71923     if( pIter->pBtree!=p && pIter->iTable==iTab && pIter->eLock!=eLock ){
71924       sqlite3ConnectionBlocked(p->db, pIter->pBtree->db);
71957   BtLock *pIter;  local
71977   for(pIter=pBt->pLock; pIter; pIter=pIter->pNext){
71978     if( pIter->iTable==iTable && pIter->pBtree==p ){
71979       pLock = pIter;
72817   u8 *pIter;              /* For scanning through pCell */  local
72825   pIter = pCell;
72833   nPayload = *pIter;
72835     u8 *pEnd = &pIter[8];
72838       nPayload = (nPayload<<7) | (*++pIter & 0x7f);
72839     }while( (*pIter)>=0x80 && pIter<pEnd );
72841   pIter++;
72850   iKey = *pIter;
72853     iKey = (iKey<<7) ^ (x = *++pIter);
72855       iKey = (iKey<<7) ^ (x = *++pIter);
72857         iKey = (iKey<<7) ^ 0x10204000 ^ (x = *++pIter);
72859           iKey = (iKey<<7) ^ 0x4000 ^ (x = *++pIter);
72861             iKey = (iKey<<7) ^ 0x4000 ^ (x = *++pIter);
72863               iKey = (iKey<<7) ^ 0x4000 ^ (x = *++pIter);
72865                 iKey = (iKey<<7) ^ 0x4000 ^ (x = *++pIter);
72867                   iKey = (iKey<<8) ^ 0x8000 ^ (*++pIter);
72880   pIter++;
72884   pInfo->pPayload = pIter;
72893     pInfo->nSize = (u16)nPayload + (u16)(pIter - pCell);
72905   u8 *pIter;              /* For scanning through pCell */  local
72911   pIter = pCell + pPage->childPtrSize;
72912   nPayload = *pIter;
72914     u8 *pEnd = &pIter[8];
72917       nPayload = (nPayload<<7) | (*++pIter & 0x7f);
72918     }while( *(pIter)>=0x80 && pIter<pEnd );
72920   pIter++;
72923   pInfo->pPayload = pIter;
72932     pInfo->nSize = (u16)nPayload + (u16)(pIter - pCell);
72962   u8 *pIter = pCell + 4;                   /* For looping over bytes of pCell */  local
72976   nSize = *pIter;
72978     pEnd = &pIter[8];
72981       nSize = (nSize<<7) | (*++pIter & 0x7f);
72982     }while( *(pIter)>=0x80 && pIter<pEnd );
72984   pIter++;
72988     nSize += (u32)(pIter - pCell);
72998     nSize += 4 + (u16)(pIter - pCell);
73004   u8 *pIter = pCell;                       /* For looping over bytes of pCell */  local
73018   nSize = *pIter;
73020     pEnd = &pIter[8];
73023       nSize = (nSize<<7) | (*++pIter & 0x7f);
73024     }while( *(pIter)>=0x80 && pIter<pEnd );
73026   pIter++;
73030     nSize += (u32)(pIter - pCell);
73040     nSize += 4 + (u16)(pIter - pCell);
73046   u8 *pIter = pCell + 4; /* For looping over bytes of pCell */  local
73061   pEnd = pIter + 9;
73062   while( (*pIter++)&0x80 && pIter<pEnd );
73063   assert( debuginfo.nSize==(u16)(pIter - pCell) || CORRUPT_DB );
73064   return (u16)(pIter - pCell);
73067   u8 *pIter = pCell;   /* For looping over bytes of pCell */  local
73080   nSize = *pIter;
73082     pEnd = &pIter[8];
73085       nSize = (nSize<<7) | (*++pIter & 0x7f);
73086     }while( *(pIter)>=0x80 && pIter<pEnd );
73088   pIter++;
73092   if( (*pIter++)&0x80
73093    && (*pIter++)&0x80
73094    && (*pIter++)&0x80
73095    && (*pIter++)&0x80
73096    && (*pIter++)&0x80
73097    && (*pIter++)&0x80
73098    && (*pIter++)&0x80
73099    && (*pIter++)&0x80 ){ pIter++; }
73103     nSize += (u32)(pIter - pCell);
73113     nSize += 4 + (u16)(pIter - pCell);
75187       BtLock *pIter;  local
75188       for(pIter=pBt->pLock; pIter; pIter=pIter->pNext){
75189         if( pIter->pBtree!=p ){
75190           pBlock = pIter->pBtree->db;
107461   FileChunk *pIter;
107463   for(pIter=pFirst; pIter; pIter=pNext){
107464     pNext = pIter->pNext;
107465     sqlite3_free(pIter);
107482     FileChunk *pIter;
107483     for(pIter=copy.pFirst; pIter; pIter=pIter->pNext){
107487       rc = sqlite3OsWrite(pReal, (u8*)pIter->zChunk, nChunk, iOff);
107591     FileChunk *pIter = 0;
107597       for(pIter=p->pFirst; ALWAYS(pIter) && iOff<size; pIter=pIter->pNext){
107600       if( ALWAYS(pIter) ){
107601         memjrnlFreeChunks(pIter->pNext);
107602         pIter->pNext = 0;
107606     p->endpoint.pChunk = pIter;
136587 static Index *indexIteratorFirst(IndexIterator *pIter, int *pIx){
136588   assert( pIter->i==0 );
136589   if( pIter->eType ){
136590     *pIx = pIter->u.ax.aIdx[0].ix;
136591     return pIter->u.ax.aIdx[0].p;
136594     return pIter->u.lx.pIdx;
136599 static Index *indexIteratorNext(IndexIterator *pIter, int *pIx){
136600   if( pIter->eType ){
136601     int i = ++pIter->i;
136602     if( i>=pIter->u.ax.nIdx ){
136606     *pIx = pIter->u.ax.aIdx[i].ix;
136607     return pIter->u.ax.aIdx[i].p;
136610     pIter->u.lx.pIdx = pIter->u.lx.pIdx->pNext;
136611     return pIter->u.lx.pIdx;
193714   char *pIter;                            /* Used to iterate through aAll */
193718     pIter = pDL->pNextDocid;
193719     assert( pDL->aAll!=0 || pIter==0 );
193721     pIter = pDL->aAll;
193724   if( pIter==0 || pIter>=(pEnd = pDL->aAll + pDL->nAll) ){
193729     pIter += sqlite3Fts3GetVarint(pIter, &iDelta);
193735     pDL->pList = pIter;
193736     fts3PoslistCopy(0, &pIter);
193737     pDL->nList = (int)(pIter - pDL->pList);
193745     while( pIter<pEnd && *pIter==0 ) pIter++;
193747     pDL->pNextDocid = pIter;
193748     assert( pIter>=&pDL->aAll[pDL->nAll] || *pIter );
195112   char *pIter;
195125   pIter = pPhrase->doclist.pList;
195186       pIter = pPh->pOrPoslist;
195190           (pIter >= (pPh->doclist.aAll + pPh->doclist.nAll));
195191         while( (pIter==0 || DOCID_CMP(iDocid, pCsr->iPrevId)<0 ) && bEof==0 ){
195194               &pIter, &iDocid, &bEof
195198         bEof = !pPh->doclist.nAll || (pIter && pIter<=pPh->doclist.aAll);
195199         while( (pIter==0 || DOCID_CMP(iDocid, pCsr->iPrevId)>0 ) && bEof==0 ){
195203               &pIter, &iDocid, &dummy, &bEof
195207       pPh->pOrPoslist = pIter;
195213       pIter = pPhrase->pOrPoslist;
195215       pIter = 0;
195218   if( pIter==0 ) return SQLITE_OK;
195220   if( *pIter==0x01 ){
195221     pIter++;
195222     pIter += fts3GetVarint32(pIter, &iThis);
195227     fts3ColumnlistCopy(0, &pIter);
195228     if( *pIter==0x00 ) return SQLITE_OK;
195229     pIter++;
195230     pIter += fts3GetVarint32(pIter, &iThis);
195232   if( *pIter==0x00 ){
195233     pIter = 0;
195236   *ppOut = ((iCol==iThis)?pIter:0);
196609         Fts3Expr *pIter = pNotBranch;
196610         while( pIter->pLeft ){
196611           pIter = pIter->pLeft;
196613         pIter->pLeft = pRet;
196614         pRet->pParent = pIter;
201622     SegmentNode *pIter;
201625     for(pIter=pTree->pLeftmost; pIter && rc==SQLITE_OK; pIter=pIter->pRight){
201626       int nStart = fts3TreeFinishNode(pIter, iHeight, iNextLeaf);
201627       int nWrite = pIter->nData - nStart;
201629       rc = fts3WriteSegment(p, iNextFree, &pIter->aData[nStart], nWrite);
201631       iNextLeaf += (pIter->nEntry+1);
205628   char *pIter = *ppIter;
205629   if( pIter ){
205633       if( 0==(*pIter & 0xFE) ){
205635         pIter = 0;
205638       fts3GetDeltaPosition(&pIter, &iIter);
205642     *ppIter = pIter;
205649 static int fts3SnippetNextCandidate(SnippetIter *pIter){
205652   if( pIter->iCurrent<0 ){
205657     pIter->iCurrent = 0;
205662     for(i=0; i<pIter->nPhrase; i++){
205663       SnippetPhrase *pPhrase = &pIter->aPhrase[i];
205664       fts3SnippetAdvance(&pPhrase->pHead, &pPhrase->iHead, pIter->nSnippet);
205670     for(i=0; i<pIter->nPhrase; i++){
205671       SnippetPhrase *pPhrase = &pIter->aPhrase[i];
205680     assert( pIter->nSnippet>=0 );
205681     pIter->iCurrent = iStart = iEnd - pIter->nSnippet + 1;
205682     for(i=0; i<pIter->nPhrase; i++){
205683       SnippetPhrase *pPhrase = &pIter->aPhrase[i];
205697   SnippetIter *pIter,             /* Snippet iterator */
205704   int iStart = pIter->iCurrent;   /* First token of snippet */
205710   for(i=0; i<pIter->nPhrase; i++){
205711     SnippetPhrase *pPhrase = &pIter->aPhrase[i];
205716       while( iCsr<(iStart+pIter->nSnippet) && iCsr>=iStart ){
205729         for(j=0; j<pPhrase->nToken && j<pIter->nSnippet; j++){
206153   char *pIter = pPhrase->doclist.pList;
206163   if( pIter ) while( 1 ){
206164     int nHit = fts3ColumnlistCount(&pIter);
206172     assert( *pIter==0x00 || *pIter==0x01 );
206173     if( *pIter!=0x01 ) break;
206174     pIter++;
206175     pIter += fts3GetVarint32(pIter, &iCol);
206394 static int fts3LcsIteratorAdvance(LcsIterator *pIter){
206399   if( NEVER(pIter==0) ) return 1;
206400   pRead = pIter->pRead;
206406     pIter->iPos += (int)(iRead-2);
206409   pIter->pRead = pRead;
206439     LcsIterator *pIter = &aIter[i];
206440     nToken -= pIter->pExpr->pPhrase->nToken;
206441     pIter->iPosOffset = nToken;
206468         LcsIterator *pIter = &aIter[i];
206469         if( pIter->pRead==0 ){
206473           if( pAdv==0 || pIter->iPos<pAdv->iPos ){
206474             pAdv = pIter;
206476           if( nThisLcs==0 || pIter->iPos==pIter[-1].iPos ){
220409   UBreakIterator *pIter;      /* ICU break-iterator object */
220522   pCsr->pIter = ubrk_open(UBRK_WORD, p->zLocale, pCsr->aChar, iOut, &status);
220529   ubrk_first(pCsr->pIter);
220539   ubrk_close(pCsr->pIter);
220565     iStart = ubrk_current(pCsr->pIter);
220566     iEnd = ubrk_next(pCsr->pIter);
222092 static void rbuObjIterFreeCols(RbuObjIter *pIter){
222094   for(i=0; i<pIter->nTblCol; i++){
222095     sqlite3_free(pIter->azTblCol[i]);
222096     sqlite3_free(pIter->azTblType[i]);
222098   sqlite3_free(pIter->azTblCol);
222099   pIter->azTblCol = 0;
222100   pIter->azTblType = 0;
222101   pIter->aiSrcOrder = 0;
222102   pIter->abTblPk = 0;
222103   pIter->abNotNull = 0;
222104   pIter->nTblCol = 0;
222105   pIter->eType = 0;               /* Invalid value */
222112 static void rbuObjIterClearStatements(RbuObjIter *pIter){
222115   sqlite3_finalize(pIter->pSelect);
222116   sqlite3_finalize(pIter->pInsert);
222117   sqlite3_finalize(pIter->pDelete);
222118   sqlite3_finalize(pIter->pTmpInsert);
222119   pUp = pIter->pRbuUpdate;
222126   sqlite3_free(pIter->aIdxCol);
222127   sqlite3_free(pIter->zIdxSql);
222129   pIter->pSelect = 0;
222130   pIter->pInsert = 0;
222131   pIter->pDelete = 0;
222132   pIter->pRbuUpdate = 0;
222133   pIter->pTmpInsert = 0;
222134   pIter->nCol = 0;
222135   pIter->nIdxCol = 0;
222136   pIter->aIdxCol = 0;
222137   pIter->zIdxSql = 0;
222144 static void rbuObjIterFinalize(RbuObjIter *pIter){
222145   rbuObjIterClearStatements(pIter);
222146   sqlite3_finalize(pIter->pTblIter);
222147   sqlite3_finalize(pIter->pIdxIter);
222148   rbuObjIterFreeCols(pIter);
222149   memset(pIter, 0, sizeof(RbuObjIter));
222160 static int rbuObjIterNext(sqlite3rbu *p, RbuObjIter *pIter){
222165     rbuObjIterClearStatements(pIter);
222166     if( pIter->zIdx==0 ){
222177       if( pIter->bCleanup ){
222178         rbuObjIterFreeCols(pIter);
222179         pIter->bCleanup = 0;
222180         rc = sqlite3_step(pIter->pTblIter);
222182           rc = resetAndCollectError(pIter->pTblIter, &p->zErrmsg);
222183           pIter->zTbl = 0;
222184           pIter->zDataTbl = 0;
222186           pIter->zTbl = (const char*)sqlite3_column_text(pIter->pTblIter, 0);
222187           pIter->zDataTbl = (const char*)sqlite3_column_text(pIter->pTblIter,1);
222188           rc = (pIter->zDataTbl && pIter->zTbl) ? SQLITE_OK : SQLITE_NOMEM;
222191         if( pIter->zIdx==0 ){
222192           sqlite3_stmt *pIdx = pIter->pIdxIter;
222193           rc = sqlite3_bind_text(pIdx, 1, pIter->zTbl, -1, SQLITE_STATIC);
222196           rc = sqlite3_step(pIter->pIdxIter);
222198             rc = resetAndCollectError(pIter->pIdxIter, &p->zErrmsg);
222199             pIter->bCleanup = 1;
222200             pIter->zIdx = 0;
222202             pIter->zIdx = (const char*)sqlite3_column_text(pIter->pIdxIter, 0);
222203             pIter->iTnum = sqlite3_column_int(pIter->pIdxIter, 1);
222204             pIter->bUnique = sqlite3_column_int(pIter->pIdxIter, 2);
222205             rc = pIter->zIdx ? SQLITE_OK : SQLITE_NOMEM;
222213     rbuObjIterFinalize(pIter);
222277 static int rbuObjIterFirst(sqlite3rbu *p, RbuObjIter *pIter){
222279   memset(pIter, 0, sizeof(RbuObjIter));
222281   rc = prepareFreeAndCollectError(p->dbRbu, &pIter->pTblIter, &p->zErrmsg,
222291     rc = prepareAndCollectError(p->dbMain, &pIter->pIdxIter, &p->zErrmsg,
222298   pIter->bCleanup = 1;
222300   return rbuObjIterNext(p, pIter);
222384 static void rbuAllocateIterArrays(sqlite3rbu *p, RbuObjIter *pIter, int nCol){
222390     pIter->azTblCol = azNew;
222391     pIter->azTblType = &azNew[nCol];
222392     pIter->aiSrcOrder = (int*)&pIter->azTblType[nCol];
222393     pIter->abTblPk = (u8*)&pIter->aiSrcOrder[nCol];
222394     pIter->abNotNull = (u8*)&pIter->abTblPk[nCol];
222395     pIter->abIndexed = (u8*)&pIter->abNotNull[nCol];
222568 static void rbuObjIterCacheIndexedCols(sqlite3rbu *p, RbuObjIter *pIter){
222573     memcpy(pIter->abIndexed, pIter->abTblPk, sizeof(u8)*pIter->nTblCol);
222575         sqlite3_mprintf("PRAGMA main.index_list = %Q", pIter->zTbl)
222579   pIter->nIndex = 0;
222586       memset(pIter->abIndexed, 0x01, sizeof(u8)*pIter->nTblCol);
222593       if( iCid>=0 ) pIter->abIndexed[iCid] = 1;
222595         memset(pIter->abIndexed, 0x01, sizeof(u8)*pIter->nTblCol);
222600     pIter->nIndex++;
222603   if( pIter->eType==RBU_PK_WITHOUT_ROWID ){
222605     pIter->nIndex--;
222609   if( bIndex==0 ) pIter->abIndexed = 0;
222622 static int rbuObjIterCacheTableInfo(sqlite3rbu *p, RbuObjIter *pIter){
222623   if( pIter->azTblCol==0 ){
222632     assert( pIter->eType==0 );
222633     rbuTableType(p, pIter->zTbl, &pIter->eType, &iTnum, &pIter->iPkTnum);
222634     if( p->rc==SQLITE_OK && pIter->eType==RBU_PK_NOTABLE ){
222636       p->zErrmsg = sqlite3_mprintf("no such table: %s", pIter->zTbl);
222639     if( pIter->zIdx==0 ) pIter->iTnum = iTnum;
222641     assert( pIter->eType==RBU_PK_NONE || pIter->eType==RBU_PK_IPK
222642          || pIter->eType==RBU_PK_EXTERNAL || pIter->eType==RBU_PK_WITHOUT_ROWID
222643          || pIter->eType==RBU_PK_VTAB
222650         sqlite3_mprintf("SELECT * FROM '%q'", pIter->zDataTbl)
222654       rbuAllocateIterArrays(p, pIter, nCol);
222660         pIter->aiSrcOrder[pIter->nTblCol] = pIter->nTblCol;
222661         pIter->azTblCol[pIter->nTblCol++] = zCopy;
222672      && bRbuRowid!=(pIter->eType==RBU_PK_VTAB || pIter->eType==RBU_PK_NONE)
222676           "table %q %s rbu_rowid column", pIter->zDataTbl,
222686           sqlite3_mprintf("PRAGMA table_info(%Q)", pIter->zTbl)
222692       for(i=iOrder; i<pIter->nTblCol; i++){
222693         if( 0==strcmp(zName, pIter->azTblCol[i]) ) break;
222695       if( i==pIter->nTblCol ){
222698             pIter->zDataTbl, zName
222706           SWAP(int, pIter->aiSrcOrder[i], pIter->aiSrcOrder[iOrder]);
222707           SWAP(char*, pIter->azTblCol[i], pIter->azTblCol[iOrder]);
222710         pIter->azTblType[iOrder] = rbuStrndup(zType, &p->rc);
222712         pIter->abTblPk[iOrder] = (u8)iPk;
222713         pIter->abNotNull[iOrder] = (u8)bNotNull || (iPk!=0);
222719     rbuObjIterCacheIndexedCols(p, pIter);
222720     assert( pIter->eType!=RBU_PK_VTAB || pIter->abIndexed==0 );
222721     assert( pIter->eType!=RBU_PK_VTAB || pIter->nIndex==0 );
222734   RbuObjIter *pIter               /* Object iterator for column names */
222739   for(i=0; i<pIter->nTblCol; i++){
222740     const char *z = pIter->azTblCol[i];
222755   RbuObjIter *pIter,              /* Object iterator for column names */
222765     for(i=0; i<pIter->nTblCol; i++){
222766       if( (int)pIter->abTblPk[i]==iPk ){
222767         const char *zCol = pIter->azTblCol[i];
222773     if( i==pIter->nTblCol ) break;
222800   RbuObjIter *pIter,              /* RBU iterator object */
222809           "SELECT max(_rowid_) FROM \"%s%w\"", zWrite, pIter->zTbl
222818     char *zOrder = rbuObjIterGetPkList(p, pIter, "", ", ", " DESC");
222819     char *zSelect = rbuObjIterGetPkList(p, pIter, "quote(", "||','||", ")");
222820     char *zList = rbuObjIterGetPkList(p, pIter, "", ", ", "");
222826                 zSelect, zWrite, pIter->zTbl, zOrder
222867   RbuObjIter *pIter               /* RBU iterator object */
222880       sqlite3_mprintf("PRAGMA main.index_xinfo = %Q", pIter->zIdx)
222892       if( pIter->eType==RBU_PK_IPK ){
222894         for(i=0; pIter->abTblPk[i]==0; i++);
222895         assert( i<pIter->nTblCol );
222896         zCol = pIter->azTblCol[i];
222901       zCol = pIter->azTblCol[iCid];
222924           zSelect, pIter->zTbl, zOrder
222929       for(iCol=0; iCol<pIter->nCol; iCol++){
222982   RbuObjIter *pIter,              /* Object iterator for column names */
223002         sqlite3_mprintf("PRAGMA main.index_xinfo = %Q", pIter->zIdx)
223016           pIter->aIdxCol[iSeq].nSpan, pIter->aIdxCol[iSeq].zSpan, zCollate
223023         if( pIter->eType==RBU_PK_IPK ){
223025           for(i=0; pIter->abTblPk[i]==0; i++);
223026           assert( i<pIter->nTblCol );
223027           zCol = pIter->azTblCol[i];
223035         zCol = pIter->azTblCol[iCid];
223036         zType = pIter->azTblType[iCid];
223041     if( pIter->bUnique==0 || sqlite3_column_int(pXInfo, 5) ){
223094   RbuObjIter *pIter,
223098   if( p->rc==SQLITE_OK && pIter->abIndexed ){
223101     for(i=0; i<pIter->nTblCol; i++){
223102       if( pIter->abIndexed[i] ){
223103         const char *zCol = pIter->azTblCol[i];
223116     if( pIter->eType==RBU_PK_EXTERNAL || pIter->eType==RBU_PK_NONE ){
223135   RbuObjIter *pIter
223138   if( pIter->eType==RBU_PK_VTAB || pIter->eType==RBU_PK_NONE ){
223139     zList = rbuMPrintf(p, "_rowid_ = ?%d", pIter->nTblCol+1);
223140   }else if( pIter->eType==RBU_PK_EXTERNAL ){
223143     for(i=0; i<pIter->nTblCol; i++){
223144       if( pIter->abTblPk[i] ){
223156     for(i=0; i<pIter->nTblCol; i++){
223157       if( pIter->abTblPk[i] ){
223158         const char *zCol = pIter->azTblCol[i];
223199   RbuObjIter *pIter,
223206     if( (int)strlen(zMask)!=pIter->nTblCol ){
223210       for(i=0; i<pIter->nTblCol; i++){
223211         char c = zMask[pIter->aiSrcOrder[i]];
223214               zList, zSep, pIter->azTblCol[i], i+1
223220               zList, zSep, pIter->azTblCol[i], pIter->azTblCol[i], i+1
223226               zList, zSep, pIter->azTblCol[i], pIter->azTblCol[i], i+1
223278 static char *rbuWithoutRowidPK(sqlite3rbu *p, RbuObjIter *pIter){
223280   assert( pIter->zIdx==0 );
223287         sqlite3_mprintf("PRAGMA main.index_list = %Q", pIter->zTbl)
223337 static void rbuCreateImposterTable2(sqlite3rbu *p, RbuObjIter *pIter){
223338   if( p->rc==SQLITE_OK && pIter->eType==RBU_PK_EXTERNAL ){
223339     int tnum = pIter->iPkTnum;    /* Root page of PK index */
223373             iCid, pIter->azTblType[iCid], zCollate
223411 static void rbuCreateImposterTable(sqlite3rbu *p, RbuObjIter *pIter){
223412   if( p->rc==SQLITE_OK && pIter->eType!=RBU_PK_VTAB ){
223413     int tnum = pIter->iTnum;
223419     for(iCol=0; p->rc==SQLITE_OK && iCol<pIter->nTblCol; iCol++){
223421       const char *zCol = pIter->azTblCol[iCol];
223425           p->dbMain, "main", pIter->zTbl, zCol, 0, &zColl, 0, 0, 0
223428       if( pIter->eType==RBU_PK_IPK && pIter->abTblPk[iCol] ){
223434           zSql, zComma, zCol, pIter->azTblType[iCol], zPk, zColl,
223435           (pIter->abNotNull[iCol] ? " NOT NULL" : "")
223440     if( pIter->eType==RBU_PK_WITHOUT_ROWID ){
223441       char *zPk = rbuWithoutRowidPK(p, pIter);
223449         pIter->zTbl, zSql,
223450         (pIter->eType==RBU_PK_WITHOUT_ROWID ? " WITHOUT ROWID" : "")
223469   RbuObjIter *pIter,
223473   int bRbuRowid = (pIter->eType==RBU_PK_EXTERNAL || pIter->eType==RBU_PK_NONE);
223474   char *zBind = rbuObjIterGetBindlist(p, pIter->nTblCol + 1 + bRbuRowid);
223476     assert( pIter->pTmpInsert==0 );
223478         p->dbRbu, &pIter->pTmpInsert, &p->zErrmsg, sqlite3_mprintf(
223480           p->zStateDb, pIter->zDataTbl, zCollist, zRbuRowid, zBind
223515 static char *rbuObjIterGetIndexWhere(sqlite3rbu *p, RbuObjIter *pIter){
223520   assert( pIter->zIdxSql==0 && pIter->nIdxCol==0 && pIter->aIdxCol==0 );
223529     rc = sqlite3_bind_text(pStmt, 1, pIter->zIdx, -1, SQLITE_STATIC);
223533         pIter->zIdxSql = zSql = rbuStrndup(zSql, &rc);
223546                 pIter->aIdxCol, (nIdxAlloc+16)*sizeof(RbuSpan)
223552             pIter->aIdxCol = aIdxCol;
223559               pIter->aIdxCol[0].zSpan = &zSql[i+1];
223566               int nSpan = (int)(&zSql[i] - pIter->aIdxCol[iIdxCol].zSpan);
223567               pIter->aIdxCol[iIdxCol++].nSpan = nSpan;
223572             int nSpan = (int)(&zSql[i] - pIter->aIdxCol[iIdxCol].zSpan);
223573             pIter->aIdxCol[iIdxCol++].nSpan = nSpan;
223574             pIter->aIdxCol[iIdxCol].zSpan = &zSql[i+1];
223598         pIter->nIdxCol = iIdxCol;
223617   RbuObjIter *pIter,
223620   assert( pIter->bCleanup==0 );
223621   if( pIter->pSelect==0 && rbuObjIterCacheTableInfo(p, pIter)==SQLITE_OK ){
223622     const int tnum = pIter->iTnum;
223625     const char *zIdx = pIter->zIdx;
223634       const char *zTbl = pIter->zTbl;
223642       assert( pIter->eType!=RBU_PK_VTAB );
223643       zPart = rbuObjIterGetIndexWhere(p, pIter);
223645           p, pIter, &zImposterCols, &zImposterPK, &zWhere, &nBind
223659       pIter->nCol = nBind;
223662             p->dbMain, &pIter->pInsert, &p->zErrmsg,
223670             p->dbMain, &pIter->pDelete, &p->zErrmsg,
223681             zStart = rbuVacuumIndexStart(p, pIter);
223691               pIter->zDataTbl,
223699         if( pIter->eType==RBU_PK_EXTERNAL || pIter->eType==RBU_PK_NONE ){
223702               zCollist, p->zStateDb, pIter->zDataTbl,
223712               zCollist, p->zStateDb, pIter->zDataTbl, zPart,
223713               zCollist, pIter->zDataTbl,
223720           p->rc = prepareFreeAndCollectError(p->dbRbu,&pIter->pSelect,pz,zSql);
223732       int bRbuRowid = (pIter->eType==RBU_PK_VTAB)
223733                     ||(pIter->eType==RBU_PK_NONE)
223734                     ||(pIter->eType==RBU_PK_EXTERNAL && rbuIsVacuum(p));
223735       const char *zTbl = pIter->zTbl;       /* Table this step applies to */
223738       char *zBindings = rbuObjIterGetBindlist(p, pIter->nTblCol + bRbuRowid);
223739       char *zWhere = rbuObjIterGetWhere(p, pIter);
223740       char *zOldlist = rbuObjIterGetOldlist(p, pIter, "old");
223741       char *zNewlist = rbuObjIterGetOldlist(p, pIter, "new");
223743       zCollist = rbuObjIterGetCollist(p, pIter);
223744       pIter->nCol = pIter->nTblCol;
223747       rbuCreateImposterTable(p, pIter);
223748       rbuCreateImposterTable2(p, pIter);
223749       zWrite = (pIter->eType==RBU_PK_VTAB ? "" : "rbu_imp_");
223753         p->rc = prepareFreeAndCollectError(p->dbMain, &pIter->pInsert, pz,
223765         p->rc = prepareFreeAndCollectError(p->dbMain, &pIter->pDelete, pz,
223772       if( rbuIsVacuum(p)==0 && pIter->abIndexed ){
223774         if( pIter->eType==RBU_PK_EXTERNAL || pIter->eType==RBU_PK_NONE ){
223782             , p->zStateDb, pIter->zDataTbl
223783             , (pIter->eType==RBU_PK_EXTERNAL ? ", 0 AS rbu_rowid" : "")
223784             , pIter->zDataTbl
223807         if( pIter->eType==RBU_PK_EXTERNAL || pIter->eType==RBU_PK_NONE ){
223817         rbuObjIterPrepareTmpInsert(p, pIter, zCollist, zRbuRowid);
223831             zStart = rbuVacuumTableStart(p, pIter, bRbuRowid, zWrite);
223840             zOrder = rbuObjIterGetPkList(p, pIter, "", ", ", "");
223845           p->rc = prepareFreeAndCollectError(p->dbRbu, &pIter->pSelect, pz,
223851                 pIter->zDataTbl, (zStart ? zStart : ""),
223884   RbuObjIter *pIter,              /* Object iterator */
223899   for(pp=&pIter->pRbuUpdate; *pp; pp=&((*pp)->pNext)){
223903       pUp->pNext = pIter->pRbuUpdate;
223904       pIter->pRbuUpdate = pUp;
223913     for(pp=&pIter->pRbuUpdate; *pp!=pUp; pp=&((*pp)->pNext));
223918     pUp = (RbuUpdateStmt*)rbuMalloc(p, sizeof(RbuUpdateStmt)+pIter->nTblCol+1);
223922     char *zWhere = rbuObjIterGetWhere(p, pIter);
223923     char *zSet = rbuObjIterGetSetlist(p, pIter, zMask);
223927     memcpy(pUp->zMask, zMask, pIter->nTblCol);
223928     pUp->pNext = pIter->pRbuUpdate;
223929     pIter->pRbuUpdate = pUp;
223934       if( pIter->eType!=RBU_PK_VTAB ) zPrefix = "rbu_imp_";
223936           zPrefix, pIter->zTbl, zSet, zWhere
224656   RbuObjIter *pIter = &p->objiter;
224662   assert( eType!=RBU_DELETE || pIter->zIdx==0 );
224676     pWriter = pIter->pDelete;
224678     pWriter = pIter->pInsert;
224681   for(i=0; i<pIter->nCol; i++){
224686      && pIter->zIdx==0 && pIter->eType==RBU_PK_IPK && pIter->abTblPk[i]
224687      && sqlite3_column_type(pIter->pSelect, i)==SQLITE_NULL
224694     if( eType==RBU_DELETE && pIter->abTblPk[i]==0 ){
224698     pVal = sqlite3_column_value(pIter->pSelect, i);
224702   if( pIter->zIdx==0 ){
224703     if( pIter->eType==RBU_PK_VTAB
224704      || pIter->eType==RBU_PK_NONE
224705      || (pIter->eType==RBU_PK_EXTERNAL && rbuIsVacuum(p))
224714       assertColumnName(pIter->pSelect, pIter->nCol+1,
224717       pVal = sqlite3_column_value(pIter->pSelect, pIter->nCol+1);
224718       p->rc = sqlite3_bind_value(pWriter, pIter->nCol+1, pVal);
224739   RbuObjIter *pIter = &p->objiter;
224748     assert( eType!=RBU_UPDATE || pIter->zIdx==0 );
224750     if( pIter->zIdx==0 && (eType==RBU_IDX_DELETE || eType==RBU_IDX_INSERT) ){
224754       if( pIter->zIdx==0 ){
224768       rbuGetUpdateStmt(p, pIter, zMask, &pUpdate);
224771         for(i=0; p->rc==SQLITE_OK && i<pIter->nCol; i++){
224772           char c = zMask[pIter->aiSrcOrder[i]];
224773           pVal = sqlite3_column_value(pIter->pSelect, i);
224774           if( pIter->abTblPk[i] || c!='.' ){
224779          && (pIter->eType==RBU_PK_VTAB || pIter->eType==RBU_PK_NONE)
224782           assertColumnName(pIter->pSelect, pIter->nCol+1, "rbu_rowid");
224783           pVal = sqlite3_column_value(pIter->pSelect, pIter->nCol+1);
224784           p->rc = sqlite3_bind_value(pUpdate, pIter->nCol+1, pVal);
224971         RbuObjIter *pIter = &p->objiter;
224981         while( p->rc==SQLITE_OK && pIter->zTbl ){
224983           if( pIter->bCleanup ){
224987             if( rbuIsVacuum(p)==0 && pIter->abIndexed ){
224989                   "DELETE FROM %s.'rbu_tmp_%q'", p->zStateDb, pIter->zDataTbl
224993             rbuObjIterPrepareAll(p, pIter, 0);
224997               int rc = sqlite3_step(pIter->pSelect);
225003               p->rc = sqlite3_reset(pIter->pSelect);
225008           rbuObjIterNext(p, pIter);
225012           assert( pIter->zTbl==0 );
225115     RbuObjIter *pIter = &p->objiter;
225118     while( rc==SQLITE_OK && pIter->zTbl && (pIter->bCleanup
225119        || rbuStrCompare(pIter->zIdx, pState->zIdx)
225120        || (pState->zDataTbl==0 && rbuStrCompare(pIter->zTbl, pState->zTbl))
225121        || (pState->zDataTbl && rbuStrCompare(pIter->zDataTbl, pState->zDataTbl))
225123       rc = rbuObjIterNext(p, pIter);
225126     if( rc==SQLITE_OK && !pIter->zTbl ){
225838   rbu_file *pIter;
225842     for(pIter=pRbuVfs->pMain; pIter; pIter=pIter->pMainNext);
225846     for(pIter=pRbuVfs->pMainRbu; pIter && pIter!=p; pIter=pIter->pMainRbuNext){}
225847     if( pIter==0 ){
232047   sqlite3_changeset_iter *pIter,  /* Iterator handle */
232053   *pOp = pIter->op;
232054   *pnCol = pIter->nCol;
232055   *pzTab = pIter->zTab;
232056   if( pbIndirect ) *pbIndirect = pIter->bIndirect;
232067   sqlite3_changeset_iter *pIter,  /* Iterator object */
232071   *pabPK = pIter->abPK;
232072   if( pnCol ) *pnCol = pIter->nCol;
232090   sqlite3_changeset_iter *pIter,  /* Changeset iterator */
232094   if( pIter->op!=SQLITE_UPDATE && pIter->op!=SQLITE_DELETE ){
232097   if( iVal<0 || iVal>=pIter->nCol ){
232100   *ppValue = pIter->apValue[iVal];
232118   sqlite3_changeset_iter *pIter,  /* Changeset iterator */
232122   if( pIter->op!=SQLITE_UPDATE && pIter->op!=SQLITE_INSERT ){
232125   if( iVal<0 || iVal>=pIter->nCol ){
232128   *ppValue = pIter->apValue[pIter->nCol+iVal];
232137 #define sessionChangesetNew(pIter, iVal) (pIter)->apValue[(pIter)->nCol+(iVal)]
232138 #define sessionChangesetOld(pIter, iVal) (pIter)->apValue[(iVal)]
232152   sqlite3_changeset_iter *pIter,  /* Changeset iterator */
232156   if( !pIter->pConflict ){
232159   if( iVal<0 || iVal>=pIter->nCol ){
232162   *ppValue = sqlite3_column_value(pIter->pConflict, iVal);
232175   sqlite3_changeset_iter *pIter,  /* Changeset iterator */
232178   if( pIter->pConflict || pIter->apValue ){
232181   *pnOut = pIter->nCol;
232444   sqlite3_changeset_iter *pIter,
232451   int nCol = pIter->nCol;
232452   int nU32 = (pIter->nCol+33)/32;
232465     for(ii=0; ii<pIter->nCol; ii++){
232466       if( sessionChangesetNew(pIter, ii) ){
232504       int bStat1 = (sqlite3_stricmp(pIter->zTab, "sqlite_stat1")==0);
232517         sessionAppendIdent(&buf, pIter->zTab, &rc);
232521         for(ii=0; ii<pIter->nCol; ii++){
232522           if( p->abPK[ii]==0 && sessionChangesetNew(pIter, ii) ){
232534         for(ii=0; ii<pIter->nCol; ii++){
232535           if( p->abPK[ii] || (bPatchset==0 && sessionChangesetOld(pIter, ii)) ){
232794   sqlite3_changeset_iter *pIter,  /* Iterator to read values from */
232812       (void)xValue(pIter, i, &pVal);
232843   sqlite3_changeset_iter *pIter,  /* Changeset iterator */
232853   sqlite3changeset_op(pIter, &zDummy, &nCol, &op, 0);
232854   rc = sessionBindRow(pIter,
232864         sqlite3changeset_new(pIter, ii, &pVal);
232892   sqlite3_changeset_iter *pIter   /* Iterator pointing at current change */
232897     int eOp = pIter->op;
232900       const char *zTab = pIter->zTab;
232918         sqlite3changeset_old(pIter, i, &pVal);
232920         sqlite3changeset_new(pIter, i, &pVal);
232966   sqlite3_changeset_iter *pIter,  /* Changeset iterator */
232977   sqlite3changeset_op(pIter, &zDummy, &nCol, &op, 0);
232985     rc = sessionSeekToRow(pIter, p);
232997       pIter->pConflict = p->pSelect;
232998       res = xConflict(pCtx, eType, pIter);
232999       pIter->pConflict = 0;
233006       u8 *aBlob = &pIter->in.aData[pIter->in.iCurrent];
233007       int nBlob = pIter->in.iNext - pIter->in.iCurrent;
233012       res = xConflict(pCtx, eType+1, pIter);
233036       rc = sessionRebaseAdd(p, res, pIter);
233068   sqlite3_changeset_iter *pIter,  /* Changeset iterator */
233084   sqlite3changeset_op(pIter, &zDummy, &nCol, &op, 0);
233099     u8 *abPK = (pIter->bPatchset ? p->abPK : 0);
233100     rc = sessionBindRow(pIter, sqlite3changeset_old, nCol, abPK, p->pDelete);
233110           SQLITE_CHANGESET_DATA, p, pIter, xConflict, pCtx, pbRetry
233114           SQLITE_CHANGESET_CONFLICT, p, pIter, xConflict, pCtx, 0
233121     int bPatchset = (pbRetry==0 || pIter->bPatchset);
233123     rc = sessionUpdateFind(pIter, p, bPatchset, &pUp);
233127       sqlite3_value *pOld = sessionChangesetOld(pIter, i);
233128       sqlite3_value *pNew = sessionChangesetNew(pIter, i);
233149           SQLITE_CHANGESET_DATA, p, pIter, xConflict, pCtx, pbRetry
233155           SQLITE_CHANGESET_CONFLICT, p, pIter, xConflict, pCtx, 0
233165       rc = sessionSeekToRow(pIter, p);
233173       rc = sessionBindRow(pIter, sqlite3changeset_new, nCol, 0, p->pInsert);
233182           SQLITE_CHANGESET_CONFLICT, p, pIter, xConflict, pCtx, pbReplace
233202   sqlite3_changeset_iter *pIter,  /* Changeset iterator to read change from */
233211   rc = sessionApplyOneOp(pIter, pApply, xConflict, pCtx, &bReplace, &bRetry);
233221       assert( pIter->op==SQLITE_UPDATE || pIter->op==SQLITE_DELETE );
233222       rc = sessionApplyOneOp(pIter, pApply, xConflict, pCtx, 0, 0);
233231       assert( pIter->op==SQLITE_INSERT );
233234         rc = sessionBindRow(pIter,
233243         rc = sessionApplyOneOp(pIter, pApply, xConflict, pCtx, 0, 0);
233315   sqlite3_changeset_iter *pIter,  /* Changeset to apply */
233345   pIter->in.bNoDiscard = 1;
233356   while( rc==SQLITE_OK && SQLITE_ROW==sqlite3changeset_next(pIter) ){
233361     sqlite3changeset_op(pIter, &zNew, &nCol, &op, 0);
233367           db, pIter->bPatchset, zTab, &sApply, xConflict, pCtx
233405         sqlite3changeset_pk(pIter, &abPK, 0);
233460     rc = sessionApplyOneWithRetry(db, pIter, &sApply, xConflict, pCtx);
233463   bPatchset = pIter->bPatchset;
233465     rc = sqlite3changeset_finalize(pIter);
233467     sqlite3changeset_finalize(pIter);
233548   sqlite3_changeset_iter *pIter;  /* Iterator to skip through changeset */
233550   int rc = sessionChangesetStart(&pIter, 0, 0, nChangeset, pChangeset, bInv, 1);
233554         db, pIter, xFilter, xConflict, pCtx, ppRebase, pnRebase, flags
233608   sqlite3_changeset_iter *pIter;  /* Iterator to skip through changeset */
233610   int rc = sessionChangesetStart(&pIter, xInput, pIn, 0, 0, bInverse, 1);
233613         db, pIter, xFilter, xConflict, pCtx, ppRebase, pnRebase, flags
233957   sqlite3_changeset_iter *pIter,
233967   sqlite3changeset_pk(pIter, &abPK, &nCol);
234022   sqlite3_changeset_iter *pIter,
234034   u8 *aRec = &pIter->in.aData[pIter->in.iCurrent + 2];
234035   int nRec = (pIter->in.iNext - pIter->in.iCurrent) - 2;
234043     pGrp->bPatch = pIter->bPatchset;
234044   }else if( pIter->bPatchset!=pGrp->bPatch ){
234050     sqlite3changeset_op(pIter, &zTab, &nCol, &op, &bIndirect);
234051     rc = sessionChangesetFindTable(pGrp, zTab, pIter, &pTab);
234062   if( rc==SQLITE_OK && sessionGrowHash(0, pIter->bPatchset, pTab) ){
234070         pTab, (pIter->bPatchset && op==SQLITE_DELETE), aRec, pTab->nChange
234075       if( pIter->bPatchset ){
234090         pIter->bPatchset, pExist, op, bIndirect, aRec, nRec, &pChange
234099   if( rc==SQLITE_OK ) rc = pIter->rc;
234108   sqlite3_changeset_iter *pIter,   /* Iterator to read from */
234116   pIter->in.bNoDiscard = 1;
234117   while( SQLITE_ROW==(sessionChangesetNext(pIter, &aRec, &nRec, 0)) ){
234118     rc = sessionOneChangeToHash(pGrp, pIter, bRebase);
234122   if( rc==SQLITE_OK ) rc = pIter->rc;
234238   sqlite3_changeset_iter *pIter;  /* Iterator opened on pData/nData */
234241   rc = sqlite3changeset_start(&pIter, nData, pData);
234243     rc = sessionChangesetToHash(pIter, pGrp, 0);
234245   sqlite3changeset_finalize(pIter);
234254   sqlite3_changeset_iter *pIter
234258   if( pIter->in.iCurrent==pIter->in.iNext
234259    || pIter->rc!=SQLITE_OK
234260    || pIter->bInvert
234265     pIter->in.bNoDiscard = 1;
234266     rc = sessionOneChangeToHash(pGrp, pIter, 0);
234291   sqlite3_changeset_iter *pIter;  /* Iterator opened on pData/nData */
234294   rc = sqlite3changeset_start_strm(&pIter, xInput, pIn);
234296     rc = sessionChangesetToHash(pIter, pGrp, 0);
234298   sqlite3changeset_finalize(pIter);
234447   sqlite3_changeset_iter *pIter,  /* Iterator pointed at local change */
234461     *pOut++ = pIter->bIndirect;
234462     for(i=0; i<pIter->nCol; i++){
234465       if( pIter->abPK[i] || a2[0]==0 ){
234466         if( !pIter->abPK[i] && a1[0] ) bData = 1;
234481       for(i=0; i<pIter->nCol; i++){
234484         if( pIter->abPK[i] || a2[0]!=0xFF ){
234515   sqlite3_changeset_iter *pIter,  /* Input data */
234528   while( SQLITE_ROW==sessionChangesetNext(pIter, &aRec, &nRec, &bNew) ){
234533       const char *zTab = pIter->zTab;
234540       if( pIter->bPatchset ){
234545       sessionAppendByte(&sOut, pIter->bPatchset ? 'P' : 'T', &rc);
234546       sessionAppendVarint(&sOut, pIter->nCol, &rc);
234547       sessionAppendBlob(&sOut, pIter->abPK, pIter->nCol, &rc);
234548       sessionAppendBlob(&sOut,(u8*)pIter->zTab,(int)strlen(pIter->zTab)+1,&rc);
234563       switch( pIter->op ){
234569               sessionAppendByte(&sOut, pIter->bIndirect, &rc);
234581               sessionSkipRecord(&pCsr, pIter->nCol);
234583               sessionAppendByte(&sOut, pIter->bIndirect, &rc);
234584               sessionAppendRecordMerge(&sOut, pIter->nCol,
234590             sessionAppendPartialUpdate(&sOut, pIter,
234597           assert( pIter->op==SQLITE_DELETE );
234601             sessionAppendByte(&sOut, pIter->bIndirect, &rc);
234602             sessionAppendRecordMerge(&sOut, pIter->nCol,
234611       sessionAppendByte(&sOut, pIter->op, &rc);
234612       sessionAppendByte(&sOut, pIter->bIndirect, &rc);
234666   sqlite3_changeset_iter *pIter = 0;   /* Iterator opened on pData/nData */
234668   rc = sqlite3changeset_start(&pIter, nRebase, (void*)pRebase);
234670     rc = sessionChangesetToHash(pIter, &p->grp, 1);
234672   sqlite3changeset_finalize(pIter);
234684   sqlite3_changeset_iter *pIter = 0;   /* Iterator to skip through input */
234685   int rc = sqlite3changeset_start(&pIter, nIn, (void*)pIn);
234688     rc = sessionRebase(p, pIter, 0, 0, pnOut, ppOut);
234689     sqlite3changeset_finalize(pIter);
234705   sqlite3_changeset_iter *pIter = 0;   /* Iterator to skip through input */
234706   int rc = sqlite3changeset_start_strm(&pIter, xInput, pIn);
234709     rc = sessionRebase(p, pIter, xOutput, pOut, 0, 0);
234710     sqlite3changeset_finalize(pIter);
235926   Fts5PoslistReader *pIter        /* Iterator object to initialize */
238077 static int fts5CInstIterNext(CInstIter *pIter){
238079   pIter->iStart = -1;
238080   pIter->iEnd = -1;
238082   while( rc==SQLITE_OK && pIter->iInst<pIter->nInst ){
238084     rc = pIter->pApi->xInst(pIter->pFts, pIter->iInst, &ip, &ic, &io);
238086       if( ic==pIter->iCol ){
238087         int iEnd = io - 1 + pIter->pApi->xPhraseSize(pIter->pFts, ip);
238088         if( pIter->iStart<0 ){
238089           pIter->iStart = io;
238090           pIter->iEnd = iEnd;
238091         }else if( io<=pIter->iEnd ){
238092           if( iEnd>pIter->iEnd ) pIter->iEnd = iEnd;
238097       pIter->iInst++;
238112   CInstIter *pIter
238116   memset(pIter, 0, sizeof(CInstIter));
238117   pIter->pApi = pApi;
238118   pIter->pFts = pFts;
238119   pIter->iCol = iCol;
238120   rc = pApi->xInstCount(pFts, &pIter->nInst);
238123     rc = fts5CInstIterNext(pIter);
239057 static int sqlite3Fts5PoslistReaderNext(Fts5PoslistReader *pIter){
239058   if( sqlite3Fts5PoslistNext64(pIter->a, pIter->n, &pIter->i, &pIter->iPos) ){
239059     pIter->bEof = 1;
239061   return pIter->bEof;
239066   Fts5PoslistReader *pIter        /* Iterator object to initialize */
239068   memset(pIter, 0, sizeof(*pIter));
239069   pIter->a = a;
239070   pIter->n = n;
239071   sqlite3Fts5PoslistReaderNext(pIter);
239072   return pIter->bEof;
240499   Fts5IndexIter *pIter;           /* Iterator for this term */
240891     if( 0==sqlite3Fts5IterEof(p->pIter) ){
240892       i64 iRowid = p->pIter->iRowid;
240922     Fts5IndexIter *pIter = p->pIter;
240923     if( sqlite3Fts5IterEof(pIter)==0 && pIter->iRowid==iRowid ){
240924       if( pIter->nData==0 ) continue;
240937       sqlite3Fts5PoslistReaderInit(pIter->pData, pIter->nData, &aIter[nIter]);
241028       a = (u8*)pTerm->pIter->pData;
241029       n = pTerm->pIter->nData;
241228   Fts5IndexIter *pIter,           /* Iterator to advance */
241237   iRowid = pIter->iRowid;
241239     int rc = sqlite3Fts5IterNextFrom(pIter, iLast);
241240     if( rc || sqlite3Fts5IterEof(pIter) ){
241245     iRowid = pIter->iRowid;
241265     if( sqlite3Fts5IterEof(p->pIter)==0 ){
241266       i64 iRowid = p->pIter->iRowid;
241268         rc = sqlite3Fts5IterNextFrom(p->pIter, iLast);
241296       Fts5IndexIter *pIter = pTerm->pIter;
241297       if( sqlite3Fts5IterEof(pIter)==0 ){
241298         if( pIter->iRowid==pNode->iRowid && pIter->nData>0 ){
241319         Fts5IndexIter *pIter = pPhrase->aTerm[0].pIter;
241320         fts5BufferSet(&rc, &pPhrase->poslist, pIter->nData, pIter->pData);
241364           if( p->pIter ){
241365             sqlite3Fts5IterClose(p->pIter);
241366             p->pIter = 0;
241373               &p->pIter
241375           assert( (rc==SQLITE_OK)==(p->pIter!=0) );
241377           if( 0==sqlite3Fts5IterEof(p->pIter) ){
241505     iLast = pLeft->aTerm[0].pIter->iRowid;
241524           Fts5IndexIter *pIter = pPhrase->aTerm[j].pIter;
241525           if( pIter->iRowid==iLast ) continue;
241527           if( fts5ExprAdvanceto(pIter, bDesc, &iLast, &rc, &pNode->bEof) ){
241569       if( sqlite3Fts5IterEof(p->pIter)==0 ){
241570         i64 ii = p->pIter->iRowid;
241575             rc = sqlite3Fts5IterNextFrom(p->pIter, iFrom);
241577             rc = sqlite3Fts5IterNext(p->pIter);
241580           if( sqlite3Fts5IterEof(p->pIter)==0 ){
241593     Fts5IndexIter *pIter = pTerm->pIter;
241597       rc = sqlite3Fts5IterNextFrom(pIter, iFrom);
241599       rc = sqlite3Fts5IterNext(pIter);
241602     pNode->bEof = (rc || sqlite3Fts5IterEof(pIter));
241624   Fts5IndexIter *pIter = pPhrase->aTerm[0].pIter;
241630   pPhrase->poslist.n = pIter->nData;
241632     pPhrase->poslist.p = (u8*)pIter->pData;
241634   pNode->iRowid = pIter->iRowid;
241649   Fts5IndexIter *pIter = pNode->pNear->apPhrase[0]->aTerm[0].pIter;
241653     rc = sqlite3Fts5IterNextFrom(pIter, iFrom);
241655     rc = sqlite3Fts5IterNext(pIter);
241657   if( rc==SQLITE_OK && sqlite3Fts5IterEof(pIter)==0 ){
242007       sqlite3Fts5IterClose(pTerm->pIter);
242010         sqlite3Fts5IterClose(pSyn->pIter);
243449               pT->pIter, pToken, nToken, iRowid, iCol, iTokOff
243577       *ppCollist = pPhrase->aTerm[0].pIter->pData;
243578       *pnCollist = pPhrase->aTerm[0].pIter->nData;
243640         pTerm->pIter, pTerm->pTerm, pTerm->nQueryTerm,
243659       sqlite3Fts5IndexIterClearTokendata(pT->pIter);
244127     Fts5HashEntry *pIter;
244128     for(pIter=pHash->aSlot[iSlot]; pIter; pIter=pIter->pHashNext){
244130        || (pIter->nKey>=nTerm && 0==memcmp(fts5EntryKey(pIter), pTerm, nTerm))
244132         Fts5HashEntry *pEntry = pIter;
245837 static int fts5DlidxIterNextR(Fts5Index *p, Fts5DlidxIter *pIter, int iLvl){
245838   Fts5DlidxLvl *pLvl = &pIter->aLvl[iLvl];
245840   assert( iLvl<pIter->nLvl );
245842     if( (iLvl+1) < pIter->nLvl ){
245843       fts5DlidxIterNextR(p, pIter, iLvl+1);
245848             FTS5_DLIDX_ROWID(pIter->iSegid, iLvl, pLvl[1].iLeafPgno)
245855   return pIter->aLvl[0].bEof;
245857 static int fts5DlidxIterNext(Fts5Index *p, Fts5DlidxIter *pIter){
245858   return fts5DlidxIterNextR(p, pIter, 0);
245872 static int fts5DlidxIterFirst(Fts5DlidxIter *pIter){
245874   for(i=0; i<pIter->nLvl; i++){
245875     fts5DlidxLvlNext(&pIter->aLvl[i]);
245877   return pIter->aLvl[0].bEof;
245881 static int fts5DlidxIterEof(Fts5Index *p, Fts5DlidxIter *pIter){
245882   return p->rc!=SQLITE_OK || pIter->aLvl[0].bEof;
245885 static void fts5DlidxIterLast(Fts5Index *p, Fts5DlidxIter *pIter){
245889   for(i=pIter->nLvl-1; p->rc==SQLITE_OK && i>=0; i--){
245890     Fts5DlidxLvl *pLvl = &pIter->aLvl[i];
245899           FTS5_DLIDX_ROWID(pIter->iSegid, i-1, pLvl->iLeafPgno)
245940 static int fts5DlidxIterPrevR(Fts5Index *p, Fts5DlidxIter *pIter, int iLvl){
245941   Fts5DlidxLvl *pLvl = &pIter->aLvl[iLvl];
245943   assert( iLvl<pIter->nLvl );
245945     if( (iLvl+1) < pIter->nLvl ){
245946       fts5DlidxIterPrevR(p, pIter, iLvl+1);
245951             FTS5_DLIDX_ROWID(pIter->iSegid, iLvl, pLvl[1].iLeafPgno)
245961   return pIter->aLvl[0].bEof;
245963 static int fts5DlidxIterPrev(Fts5Index *p, Fts5DlidxIter *pIter){
245964   return fts5DlidxIterPrevR(p, pIter, 0);
245970 static void fts5DlidxIterFree(Fts5DlidxIter *pIter){
245971   if( pIter ){
245973     for(i=0; i<pIter->nLvl; i++){
245974       fts5DataRelease(pIter->aLvl[i].pData);
245976     sqlite3_free(pIter);
245986   Fts5DlidxIter *pIter = 0;
245994     pNew = (Fts5DlidxIter*)sqlite3_realloc64(pIter, nByte);
246000       pIter = pNew;
246006       pIter->nLvl = i+1;
246011     pIter->iSegid = iSegid;
246013       fts5DlidxIterFirst(pIter);
246015       fts5DlidxIterLast(p, pIter);
246020     fts5DlidxIterFree(pIter);
246021     pIter = 0;
246024   return pIter;
246027 static i64 fts5DlidxIterRowid(Fts5DlidxIter *pIter){
246028   return pIter->aLvl[0].iRowid;
246030 static int fts5DlidxIterPgno(Fts5DlidxIter *pIter){
246031   return pIter->aLvl[0].iLeafPgno;
246039   Fts5SegIter *pIter              /* Iterator to advance to next page */
246042   Fts5StructureSegment *pSeg = pIter->pSeg;
246043   fts5DataRelease(pIter->pLeaf);
246044   pIter->iLeafPgno++;
246045   if( pIter->pNextLeaf ){
246046     pIter->pLeaf = pIter->pNextLeaf;
246047     pIter->pNextLeaf = 0;
246048   }else if( pIter->iLeafPgno<=pSeg->pgnoLast ){
246049     pIter->pLeaf = fts5LeafRead(p,
246050         FTS5_SEGMENT_ROWID(pSeg->iSegid, pIter->iLeafPgno)
246053     pIter->pLeaf = 0;
246055   pLeaf = pIter->pLeaf;
246058     pIter->iPgidxOff = pLeaf->szLeaf;
246060       pIter->iEndofDoclist = pLeaf->nn+1;
246062       pIter->iPgidxOff += fts5GetVarint32(&pLeaf->p[pIter->iPgidxOff],
246063           pIter->iEndofDoclist
246096 static void fts5SegIterLoadNPos(Fts5Index *p, Fts5SegIter *pIter){
246098     int iOff = pIter->iLeafOffset;  /* Offset to read at */
246099     ASSERT_SZLEAF_OK(pIter->pLeaf);
246101       int iEod = MIN(pIter->iEndofDoclist, pIter->pLeaf->szLeaf);
246102       pIter->bDel = 0;
246103       pIter->nPos = 1;
246104       if( iOff<iEod && pIter->pLeaf->p[iOff]==0 ){
246105         pIter->bDel = 1;
246107         if( iOff<iEod && pIter->pLeaf->p[iOff]==0 ){
246108           pIter->nPos = 1;
246111           pIter->nPos = 0;
246116       fts5FastGetVarint32(pIter->pLeaf->p, iOff, nSz);
246117       pIter->bDel = (nSz & 0x0001);
246118       pIter->nPos = nSz>>1;
246119       assert_nc( pIter->nPos>=0 );
246121     pIter->iLeafOffset = iOff;
246125 static void fts5SegIterLoadRowid(Fts5Index *p, Fts5SegIter *pIter){
246126   u8 *a = pIter->pLeaf->p;        /* Buffer to read data from */
246127   i64 iOff = pIter->iLeafOffset;
246129   ASSERT_SZLEAF_OK(pIter->pLeaf);
246130   while( iOff>=pIter->pLeaf->szLeaf ){
246131     fts5SegIterNextPage(p, pIter);
246132     if( pIter->pLeaf==0 ){
246137     a = pIter->pLeaf->p;
246139   iOff += sqlite3Fts5GetVarint(&a[iOff], (u64*)&pIter->iRowid);
246140   pIter->iLeafOffset = iOff;
246158 static void fts5SegIterLoadTerm(Fts5Index *p, Fts5SegIter *pIter, int nKeep){
246159   u8 *a = pIter->pLeaf->p;        /* Buffer to read data from */
246160   i64 iOff = pIter->iLeafOffset;  /* Offset to read at */
246164   if( iOff+nNew>pIter->pLeaf->szLeaf || nKeep>pIter->term.n || nNew==0 ){
246168   pIter->term.n = nKeep;
246169   fts5BufferAppendBlob(&p->rc, &pIter->term, nNew, &a[iOff]);
246170   assert( pIter->term.n<=pIter->term.nSpace );
246172   pIter->iTermLeafOffset = iOff;
246173   pIter->iTermLeafPgno = pIter->iLeafPgno;
246174   pIter->iLeafOffset = iOff;
246176   if( pIter->iPgidxOff>=pIter->pLeaf->nn ){
246177     pIter->iEndofDoclist = pIter->pLeaf->nn+1;
246180     pIter->iPgidxOff += fts5GetVarint32(&a[pIter->iPgidxOff], nExtra);
246181     pIter->iEndofDoclist += nExtra;
246184   fts5SegIterLoadRowid(p, pIter);
246191 static void fts5SegIterSetNext(Fts5Index *p, Fts5SegIter *pIter){
246192   if( pIter->flags & FTS5_SEGITER_REVERSE ){
246193     pIter->xNext = fts5SegIterNext_Reverse;
246195     pIter->xNext = fts5SegIterNext_None;
246197     pIter->xNext = fts5SegIterNext;
246206 static void fts5SegIterAllocTombstone(Fts5Index *p, Fts5SegIter *pIter){
246207   const i64 nTomb = (i64)pIter->pSeg->nPgTombstone;
246215       pIter->pTombArray = pNew;
246231   Fts5SegIter *pIter              /* Object to populate */
246239     assert( pIter->pLeaf==0 );
246244     memset(pIter, 0, sizeof(*pIter));
246245     fts5SegIterSetNext(p, pIter);
246246     pIter->pSeg = pSeg;
246247     pIter->iLeafPgno = pSeg->pgnoFirst-1;
246249       fts5SegIterNextPage(p, pIter);
246250     }while( p->rc==SQLITE_OK && pIter->pLeaf && pIter->pLeaf->nn==4 );
246253   if( p->rc==SQLITE_OK && pIter->pLeaf ){
246254     pIter->iLeafOffset = 4;
246255     assert( pIter->pLeaf!=0 );
246256     assert_nc( pIter->pLeaf->nn>4 );
246257     assert_nc( fts5LeafFirstTermOff(pIter->pLeaf)==4 );
246258     pIter->iPgidxOff = pIter->pLeaf->szLeaf+1;
246259     fts5SegIterLoadTerm(p, pIter, 0);
246260     fts5SegIterLoadNPos(p, pIter);
246261     fts5SegIterAllocTombstone(p, pIter);
246280 static void fts5SegIterReverseInitPage(Fts5Index *p, Fts5SegIter *pIter){
246282   int n = pIter->pLeaf->szLeaf;
246283   int i = pIter->iLeafOffset;
246284   u8 *a = pIter->pLeaf->p;
246287   if( n>pIter->iEndofDoclist ){
246288     n = pIter->iEndofDoclist;
246291   ASSERT_SZLEAF_OK(pIter->pLeaf);
246309     pIter->iRowid += iDelta;
246312     if( iRowidOffset>=pIter->nRowidOffset ){
246313       int nNew = pIter->nRowidOffset + 8;
246314       int *aNew = (int*)sqlite3_realloc64(pIter->aRowidOffset,nNew*sizeof(int));
246319       pIter->aRowidOffset = aNew;
246320       pIter->nRowidOffset = nNew;
246323     pIter->aRowidOffset[iRowidOffset++] = pIter->iLeafOffset;
246324     pIter->iLeafOffset = i;
246326   pIter->iRowidOffset = iRowidOffset;
246327   fts5SegIterLoadNPos(p, pIter);
246333 static void fts5SegIterReverseNewPage(Fts5Index *p, Fts5SegIter *pIter){
246334   assert( pIter->flags & FTS5_SEGITER_REVERSE );
246335   assert( pIter->flags & FTS5_SEGITER_ONETERM );
246337   fts5DataRelease(pIter->pLeaf);
246338   pIter->pLeaf = 0;
246339   while( p->rc==SQLITE_OK && pIter->iLeafPgno>pIter->iTermLeafPgno ){
246341     pIter->iLeafPgno--;
246343           pIter->pSeg->iSegid, pIter->iLeafPgno
246349       if( pIter->iLeafPgno==pIter->iTermLeafPgno ){
246350         assert( pIter->pLeaf==0 );
246351         if( pIter->iTermLeafOffset<pNew->szLeaf ){
246352           pIter->pLeaf = pNew;
246353           pIter->iLeafOffset = pIter->iTermLeafOffset;
246362             pIter->pLeaf = pNew;
246363             pIter->iLeafOffset = iRowidOff;
246368       if( pIter->pLeaf ){
246369         u8 *a = &pIter->pLeaf->p[pIter->iLeafOffset];
246370         pIter->iLeafOffset += fts5GetVarint(a, (u64*)&pIter->iRowid);
246378   if( pIter->pLeaf ){
246379     pIter->iEndofDoclist = pIter->pLeaf->nn+1;
246380     fts5SegIterReverseInitPage(p, pIter);
246389 static int fts5MultiIterIsEmpty(Fts5Index *p, Fts5Iter *pIter){
246390   Fts5SegIter *pSeg = &pIter->aSeg[pIter->aFirst[1].iFirst];
246401   Fts5SegIter *pIter,             /* Iterator to advance */
246404   assert( pIter->flags & FTS5_SEGITER_REVERSE );
246405   assert( pIter->pNextLeaf==0 );
246408   if( pIter->iRowidOffset>0 ){
246409     u8 *a = pIter->pLeaf->p;
246413     pIter->iRowidOffset--;
246414     pIter->iLeafOffset = pIter->aRowidOffset[pIter->iRowidOffset];
246415     fts5SegIterLoadNPos(p, pIter);
246416     iOff = pIter->iLeafOffset;
246418       iOff += pIter->nPos;
246421     pIter->iRowid -= iDelta;
246423     fts5SegIterReverseNewPage(p, pIter);
246435   Fts5SegIter *pIter,             /* Iterator to advance */
246441   assert( (pIter->flags & FTS5_SEGITER_REVERSE)==0 );
246444   ASSERT_SZLEAF_OK(pIter->pLeaf);
246445   iOff = pIter->iLeafOffset;
246448   while( pIter->pSeg && iOff>=pIter->pLeaf->szLeaf ){
246449     fts5SegIterNextPage(p, pIter);
246450     if( p->rc || pIter->pLeaf==0 ) return;
246451     pIter->iRowid = 0;
246455   if( iOff<pIter->iEndofDoclist ){
246458     iOff += sqlite3Fts5GetVarint(&pIter->pLeaf->p[iOff], (u64*)&iDelta);
246459     pIter->iLeafOffset = iOff;
246460     pIter->iRowid += iDelta;
246461   }else if( (pIter->flags & FTS5_SEGITER_ONETERM)==0 ){
246462     if( pIter->pSeg ){
246464       if( iOff!=fts5LeafFirstTermOff(pIter->pLeaf) ){
246465         iOff += fts5GetVarint32(&pIter->pLeaf->p[iOff], nKeep);
246467       pIter->iLeafOffset = iOff;
246468       fts5SegIterLoadTerm(p, pIter, nKeep);
246477       pIter->pLeaf->p = (u8*)pList;
246478       pIter->pLeaf->nn = nList;
246479       pIter->pLeaf->szLeaf = nList;
246480       pIter->iEndofDoclist = nList;
246481       sqlite3Fts5BufferSet(&p->rc,&pIter->term, nTerm, (u8*)zTerm);
246482       pIter->iLeafOffset = fts5GetVarint(pList, (u64*)&pIter->iRowid);
246490   fts5SegIterLoadNPos(p, pIter);
246494   fts5DataRelease(pIter->pLeaf);
246495   pIter->pLeaf = 0;
246508   Fts5SegIter *pIter,             /* Iterator to advance */
246511   Fts5Data *pLeaf = pIter->pLeaf;
246526   iOff = pIter->iLeafOffset + pIter->nPos;
246530     assert_nc( iOff<=pIter->iEndofDoclist );
246531     if( iOff>=pIter->iEndofDoclist ){
246539       pIter->iRowid += iDelta;
246542     pIter->iLeafOffset = iOff;
246544   }else if( pIter->pSeg==0 ){
246549     assert( (pIter->flags & FTS5_SEGITER_ONETERM) || pbNewTerm );
246550     if( 0==(pIter->flags & FTS5_SEGITER_ONETERM) ){
246555       fts5DataRelease(pIter->pLeaf);
246556       pIter->pLeaf = 0;
246558       pIter->pLeaf->p = (u8*)pList;
246559       pIter->pLeaf->nn = nList;
246560       pIter->pLeaf->szLeaf = nList;
246561       pIter->iEndofDoclist = nList+1;
246562       sqlite3Fts5BufferSet(&p->rc, &pIter->term, nTerm, (u8*)zTerm);
246563       pIter->iLeafOffset = fts5GetVarint(pList, (u64*)&pIter->iRowid);
246570       fts5SegIterNextPage(p, pIter);
246571       pLeaf = pIter->pLeaf;
246575         iOff += sqlite3Fts5GetVarint(&pLeaf->p[iOff], (u64*)&pIter->iRowid);
246576         pIter->iLeafOffset = iOff;
246579           pIter->iPgidxOff = pLeaf->szLeaf + fts5GetVarint32(
246580               &pLeaf->p[pLeaf->szLeaf], pIter->iEndofDoclist
246585         pIter->iPgidxOff = pLeaf->szLeaf + fts5GetVarint32(
246588         pIter->iLeafOffset = iOff;
246589         pIter->iEndofDoclist = iOff;
246601   if( pIter->pLeaf ){
246603       if( pIter->flags & FTS5_SEGITER_ONETERM ){
246604         fts5DataRelease(pIter->pLeaf);
246605         pIter->pLeaf = 0;
246607         fts5SegIterLoadTerm(p, pIter, nKeep);
246608         fts5SegIterLoadNPos(p, pIter);
246616       assert_nc( pIter->iLeafOffset<=pIter->pLeaf->nn );
246617       fts5FastGetVarint32(pIter->pLeaf->p, pIter->iLeafOffset, nSz);
246618       pIter->bDel = (nSz & 0x0001);
246619       pIter->nPos = nSz>>1;
246620       assert_nc( pIter->nPos>=0 );
246637 static void fts5SegIterReverse(Fts5Index *p, Fts5SegIter *pIter){
246638   Fts5DlidxIter *pDlidx = pIter->pDlidx;
246643     int iSegid = pIter->pSeg->iSegid;
246647     Fts5Data *pLeaf = pIter->pLeaf;         /* Current leaf data */
246653     if( pIter->iTermLeafPgno==pIter->iLeafPgno ){
246654       iPoslist = pIter->iTermLeafOffset;
246659     pIter->iLeafOffset = iPoslist;
246664     if( pIter->iEndofDoclist>=pLeaf->szLeaf ){
246666       Fts5StructureSegment *pSeg = pIter->pSeg;
246670       for(pgno=pIter->iLeafPgno+1; !p->rc && pgno<=pSeg->pgnoLast; pgno++){
246699     fts5DataRelease(pIter->pLeaf);
246700     pIter->pLeaf = pLast;
246701     pIter->iLeafPgno = pgnoLast;
246707     iOff += fts5GetVarint(&pLast->p[iOff], (u64*)&pIter->iRowid);
246708     pIter->iLeafOffset = iOff;
246711       pIter->iEndofDoclist = pLast->nn+1;
246713       pIter->iEndofDoclist = fts5LeafFirstTermOff(pLast);
246717   fts5SegIterReverseInitPage(p, pIter);
246726 static void fts5SegIterLoadDlidx(Fts5Index *p, Fts5SegIter *pIter){
246727   int iSeg = pIter->pSeg->iSegid;
246728   int bRev = (pIter->flags & FTS5_SEGITER_REVERSE);
246729   Fts5Data *pLeaf = pIter->pLeaf; /* Current leaf data */
246731   assert( pIter->flags & FTS5_SEGITER_ONETERM );
246732   assert( pIter->pDlidx==0 );
246737   if( pIter->iTermLeafPgno==pIter->iLeafPgno
246738    && pIter->iEndofDoclist<pLeaf->szLeaf
246743   pIter->pDlidx = fts5DlidxIterInit(p, bRev, iSeg, pIter->iTermLeafPgno);
246763   Fts5SegIter *pIter,             /* Iterator to seek */
246767   const u8 *a = pIter->pLeaf->p;
246768   u32 n = (u32)pIter->pLeaf->nn;
246779   iPgidx = (u32)pIter->pLeaf->szLeaf;
246836     fts5DataRelease(pIter->pLeaf);
246837     pIter->pLeaf = 0;
246841       fts5SegIterNextPage(p, pIter);
246842       if( pIter->pLeaf==0 ) return;
246843       a = pIter->pLeaf->p;
246844       if( fts5LeafIsTermless(pIter->pLeaf)==0 ){
246845         iPgidx = (u32)pIter->pLeaf->szLeaf;
246846         iPgidx += fts5GetVarint32(&pIter->pLeaf->p[iPgidx], iOff);
246847         if( iOff<4 || (i64)iOff>=pIter->pLeaf->szLeaf ){
246853           n = (u32)pIter->pLeaf->nn;
246866   pIter->iLeafOffset = iOff + nNew;
246867   pIter->iTermLeafOffset = pIter->iLeafOffset;
246868   pIter->iTermLeafPgno = pIter->iLeafPgno;
246870   fts5BufferSet(&p->rc, &pIter->term, nKeep, pTerm);
246871   fts5BufferAppendBlob(&p->rc, &pIter->term, nNew, &a[iOff]);
246874     pIter->iEndofDoclist = pIter->pLeaf->nn+1;
246878     pIter->iEndofDoclist = iTermOff + nExtra;
246880   pIter->iPgidxOff = iPgidx;
246882   fts5SegIterLoadRowid(p, pIter);
246883   fts5SegIterLoadNPos(p, pIter);
246910   Fts5SegIter *pIter              /* Object to populate */
246919   memset(pIter, 0, sizeof(*pIter));
246920   pIter->pSeg = pSeg;
246941   pIter->iLeafPgno = iPg - 1;
246942   fts5SegIterNextPage(p, pIter);
246944   if( pIter->pLeaf ){
246945     fts5LeafSeek(p, bGe, pIter, pTerm, nTerm);
246949     pIter->flags |= FTS5_SEGITER_ONETERM;
246950     if( pIter->pLeaf ){
246952         pIter->flags |= FTS5_SEGITER_REVERSE;
246955         fts5SegIterLoadDlidx(p, pIter);
246958         fts5SegIterReverse(p, pIter);
246963   fts5SegIterSetNext(p, pIter);
246965     fts5SegIterAllocTombstone(p, pIter);
246977    || pIter->pLeaf==0                                               /* 2 */
246978    || fts5BufferCompareBlob(&pIter->term, pTerm, nTerm)==0          /* 3 */
246979    || (bGe && fts5BufferCompareBlob(&pIter->term, pTerm, nTerm)>0)  /* 4 */
247009   Fts5SegIter *pIter              /* Object to populate */
247031   memset(pIter, 0, sizeof(*pIter));
247032   pIter->pSeg = pSeg;
247033   pIter->flags |= FTS5_SEGITER_ONETERM;
247035     pIter->iLeafPgno = iPg - 1;
247036     fts5SegIterNextPage(p, pIter);
247037     fts5SegIterSetNext(p, pIter);
247039   if( pIter->pLeaf ){
247040     const u8 *a = pIter->pLeaf->p;
247043     pIter->iPgidxOff = pIter->pLeaf->szLeaf;
247044     pIter->iPgidxOff += fts5GetVarint32(&a[pIter->iPgidxOff], iTermOff);
247045     pIter->iLeafOffset = iTermOff;
247046     fts5SegIterLoadTerm(p, pIter, 0);
247047     fts5SegIterLoadNPos(p, pIter);
247048     if( bDlidx ) fts5SegIterLoadDlidx(p, pIter);
247051         fts5BufferCompareBlob(&pIter->term, (const u8*)pTerm, nTerm)>0
247068   Fts5SegIter *pIter              /* Object to populate */
247106     pIter->flags |= FTS5_SEGITER_ONETERM;
247110     sqlite3Fts5BufferSet(&p->rc, &pIter->term, n, z);
247112     pIter->pLeaf = pLeaf;
247113     pIter->iLeafOffset = fts5GetVarint(pLeaf->p, (u64*)&pIter->iRowid);
247114     pIter->iEndofDoclist = pLeaf->nn;
247117       pIter->flags |= FTS5_SEGITER_REVERSE;
247118       fts5SegIterReverseInitPage(p, pIter);
247120       fts5SegIterLoadNPos(p, pIter);
247124   fts5SegIterSetNext(p, pIter);
247161 static void fts5SegIterClear(Fts5SegIter *pIter){
247162   fts5BufferFree(&pIter->term);
247163   fts5DataRelease(pIter->pLeaf);
247164   fts5DataRelease(pIter->pNextLeaf);
247165   fts5TombstoneArrayDelete(pIter->pTombArray);
247166   fts5DlidxIterFree(pIter->pDlidx);
247167   sqlite3_free(pIter->aRowidOffset);
247168   memset(pIter, 0, sizeof(Fts5SegIter));
247180   Fts5Iter *pIter,
247185   int i1 = p1 - pIter->aSeg;
247186   int i2 = p2 - pIter->aSeg;
247201         res = ((p1->iRowid > p2->iRowid)==pIter->bRev) ? -1 : 1;
247221 static void fts5AssertMultiIterSetup(Fts5Index *p, Fts5Iter *pIter){
247223     Fts5SegIter *pFirst = &pIter->aSeg[ pIter->aFirst[1].iFirst ];
247226     assert( (pFirst->pLeaf==0)==pIter->base.bEof );
247229     for(i=0; i<pIter->nSeg; i++){
247230       Fts5SegIter *p1 = &pIter->aSeg[i];
247234            || p1->iRowid==pIter->iSwitchRowid
247235            || (p1->iRowid<pIter->iSwitchRowid)==pIter->bRev
247239     for(i=0; i<pIter->nSeg; i+=2){
247240       Fts5SegIter *p1 = &pIter->aSeg[i];
247241       Fts5SegIter *p2 = &pIter->aSeg[i+1];
247242       Fts5CResult *pRes = &pIter->aFirst[(pIter->nSeg + i) / 2];
247243       fts5AssertComparisonResult(pIter, p1, p2, pRes);
247246     for(i=1; i<(pIter->nSeg / 2); i+=2){
247247       Fts5SegIter *p1 = &pIter->aSeg[ pIter->aFirst[i*2].iFirst ];
247248       Fts5SegIter *p2 = &pIter->aSeg[ pIter->aFirst[i*2+1].iFirst ];
247249       Fts5CResult *pRes = &pIter->aFirst[i];
247250       fts5AssertComparisonResult(pIter, p1, p2, pRes);
247266 static int fts5MultiIterDoCompare(Fts5Iter *pIter, int iOut){
247272   Fts5CResult *pRes = &pIter->aFirst[iOut];
247274   assert( iOut<pIter->nSeg && iOut>0 );
247275   assert( pIter->bRev==0 || pIter->bRev==1 );
247277   if( iOut>=(pIter->nSeg/2) ){
247278     i1 = (iOut - pIter->nSeg/2) * 2;
247281     i1 = pIter->aFirst[iOut*2].iFirst;
247282     i2 = pIter->aFirst[iOut*2+1].iFirst;
247284   p1 = &pIter->aSeg[i1];
247285   p2 = &pIter->aSeg[i2];
247301       res = ((p1->iRowid > p2->iRowid)==pIter->bRev) ? -1 : +1;
247322   Fts5SegIter *pIter,             /* Iterator to advance */
247325   assert( iLeafPgno>pIter->iLeafPgno );
247327   if( iLeafPgno>pIter->pSeg->pgnoLast ){
247330     fts5DataRelease(pIter->pNextLeaf);
247331     pIter->pNextLeaf = 0;
247332     pIter->iLeafPgno = iLeafPgno-1;
247336       fts5SegIterNextPage(p, pIter);
247337       if( pIter->pLeaf==0 ) break;
247338       iOff = fts5LeafFirstRowidOff(pIter->pLeaf);
247340         u8 *a = pIter->pLeaf->p;
247341         int n = pIter->pLeaf->szLeaf;
247345           iOff += fts5GetVarint(&a[iOff], (u64*)&pIter->iRowid);
247346           pIter->iLeafOffset = iOff;
247347           fts5SegIterLoadNPos(p, pIter);
247362   Fts5SegIter *pIter,             /* Iterator to advance */
247365   int bRev = (pIter->flags & FTS5_SEGITER_REVERSE);
247366   Fts5DlidxIter *pDlidx = pIter->pDlidx;
247367   int iLeafPgno = pIter->iLeafPgno;
247370   assert( pIter->flags & FTS5_SEGITER_ONETERM );
247371   assert( pIter->pDlidx );
247372   assert( pIter->pLeaf );
247379     assert_nc( iLeafPgno>=pIter->iLeafPgno || p->rc );
247380     if( iLeafPgno>pIter->iLeafPgno ){
247381       fts5SegIterGotoPage(p, pIter, iLeafPgno);
247385     assert( pIter->pNextLeaf==0 );
247386     assert( iMatch<pIter->iRowid );
247392     assert( fts5DlidxIterEof(p, pDlidx) || iLeafPgno<=pIter->iLeafPgno );
247394     if( iLeafPgno<pIter->iLeafPgno ){
247395       pIter->iLeafPgno = iLeafPgno+1;
247396       fts5SegIterReverseNewPage(p, pIter);
247402     if( bMove && p->rc==SQLITE_OK ) pIter->xNext(p, pIter, 0);
247403     if( pIter->pLeaf==0 ) break;
247404     if( bRev==0 && pIter->iRowid>=iMatch ) break;
247405     if( bRev!=0 && pIter->iRowid<=iMatch ) break;
247413 static void fts5MultiIterFree(Fts5Iter *pIter){
247414   if( pIter ){
247416     for(i=0; i<pIter->nSeg; i++){
247417       fts5SegIterClear(&pIter->aSeg[i]);
247419     fts5BufferFree(&pIter->poslist);
247420     sqlite3_free(pIter);
247426   Fts5Iter *pIter,                /* Iterator to update aFirst[] array for */
247431   for(i=(pIter->nSeg+iChanged)/2; i>=iMinset && p->rc==SQLITE_OK; i=i/2){
247433     if( (iEq = fts5MultiIterDoCompare(pIter, i)) ){
247434       Fts5SegIter *pSeg = &pIter->aSeg[iEq];
247437       i = pIter->nSeg + iEq;
247453   Fts5Iter *pIter,                /* Iterator to update aFirst[] array for */
247457   Fts5SegIter *pNew = &pIter->aSeg[iChanged];
247459   if( pNew->iRowid==pIter->iSwitchRowid
247460    || (pNew->iRowid<pIter->iSwitchRowid)==pIter->bRev
247463     Fts5SegIter *pOther = &pIter->aSeg[iChanged ^ 0x0001];
247464     pIter->iSwitchRowid = pIter->bRev ? SMALLEST_INT64 : LARGEST_INT64;
247465     for(i=(pIter->nSeg+iChanged)/2; 1; i=i/2){
247466       Fts5CResult *pRes = &pIter->aFirst[i];
247474         }else if( (pOther->iRowid>pNew->iRowid)==pIter->bRev ){
247475           pIter->iSwitchRowid = pOther->iRowid;
247477         }else if( (pOther->iRowid>pIter->iSwitchRowid)==pIter->bRev ){
247478           pIter->iSwitchRowid = pOther->iRowid;
247481       pRes->iFirst = (u16)(pNew - pIter->aSeg);
247484       pOther = &pIter->aSeg[ pIter->aFirst[i ^ 0x0001].iFirst ];
247495 static void fts5MultiIterSetEof(Fts5Iter *pIter){
247496   Fts5SegIter *pSeg = &pIter->aSeg[ pIter->aFirst[1].iFirst ];
247497   pIter->base.bEof = pSeg->pLeaf==0;
247498   pIter->iSwitchRowid = pSeg->iRowid;
247551 static int fts5MultiIterIsDeleted(Fts5Iter *pIter){
247552   int iFirst = pIter->aFirst[1].iFirst;
247553   Fts5SegIter *pSeg = &pIter->aSeg[iFirst];
247564       pArray->apTombstone[iPg] = fts5DataRead(pIter->pIndex,
247589   Fts5Iter *pIter,
247594   assert( pIter->base.bEof==0 );
247596     int iFirst = pIter->aFirst[1].iFirst;
247598     Fts5SegIter *pSeg = &pIter->aSeg[iFirst];
247607      || fts5MultiIterAdvanceRowid(pIter, iFirst, &pSeg)
247609       fts5MultiIterAdvanced(p, pIter, iFirst, 1);
247610       fts5MultiIterSetEof(pIter);
247611       pSeg = &pIter->aSeg[pIter->aFirst[1].iFirst];
247615     fts5AssertMultiIterSetup(p, pIter);
247616     assert( pSeg==&pIter->aSeg[pIter->aFirst[1].iFirst] && pSeg->pLeaf );
247617     if( (pIter->bSkipEmpty==0 || pSeg->nPos)
247618       && 0==fts5MultiIterIsDeleted(pIter)
247620       pIter->xSetOutputs(pIter, pSeg);
247629   Fts5Iter *pIter,
247632   assert( pIter->bSkipEmpty );
247636       int iFirst = pIter->aFirst[1].iFirst;
247637       Fts5SegIter *pSeg = &pIter->aSeg[iFirst];
247643        || fts5MultiIterAdvanceRowid(pIter, iFirst, &pSeg)
247645         fts5MultiIterAdvanced(p, pIter, iFirst, 1);
247646         fts5MultiIterSetEof(pIter);
247649       fts5AssertMultiIterSetup(p, pIter);
247651     }while( (fts5MultiIterIsEmpty(p, pIter) || fts5MultiIterIsDeleted(pIter))
247894   Fts5Iter *pIter
247903     if( pColset->nCol>1 && sqlite3Fts5BufferSize(pRc, &pIter->poslist, nPos) ){
247911           pIter->base.pData = pIter->poslist.p;
247912           pIter->base.nData = pIter->poslist.n;
247925           pIter->base.pData = aCopy;
247926           pIter->base.nData = p-aCopy;
247929         fts5BufferSafeAppendBlob(&pIter->poslist, aCopy, p-aCopy);
247932         pIter->base.pData = pIter->poslist.p;
247933         pIter->base.nData = pIter->poslist.n;
247950 static void fts5IterSetOutputs_None(Fts5Iter *pIter, Fts5SegIter *pSeg){
247951   assert( pIter->pIndex->pConfig->eDetail==FTS5_DETAIL_NONE );
247952   pIter->base.iRowid = pSeg->iRowid;
247953   pIter->base.nData = pSeg->nPos;
247960 static void fts5IterSetOutputs_Nocolset(Fts5Iter *pIter, Fts5SegIter *pSeg){
247961   pIter->base.iRowid = pSeg->iRowid;
247962   pIter->base.nData = pSeg->nPos;
247964   assert( pIter->pIndex->pConfig->eDetail!=FTS5_DETAIL_NONE );
247965   assert( pIter->pColset==0 );
247970     pIter->base.pData = &pSeg->pLeaf->p[pSeg->iLeafOffset];
247975     fts5BufferZero(&pIter->poslist);
247976     fts5SegiterPoslist(pIter->pIndex, pSeg, 0, &pIter->poslist);
247977     pIter->base.pData = pIter->poslist.p;
247985 static void fts5IterSetOutputs_ZeroColset(Fts5Iter *pIter, Fts5SegIter *pSeg){
247987   pIter->base.nData = 0;
247995 static void fts5IterSetOutputs_Col(Fts5Iter *pIter, Fts5SegIter *pSeg){
247996   fts5BufferZero(&pIter->poslist);
247997   fts5SegiterPoslist(pIter->pIndex, pSeg, pIter->pColset, &pIter->poslist);
247998   pIter->base.iRowid = pSeg->iRowid;
247999   pIter->base.pData = pIter->poslist.p;
248000   pIter->base.nData = pIter->poslist.n;
248013 static void fts5IterSetOutputs_Col100(Fts5Iter *pIter, Fts5SegIter *pSeg){
248015   assert( pIter->pIndex->pConfig->eDetail==FTS5_DETAIL_COLUMNS );
248016   assert( pIter->pColset );
248019     fts5IterSetOutputs_Col(pIter, pSeg);
248024     int *aiCol = pIter->pColset->aiCol;
248025     int *aiColEnd = &aiCol[pIter->pColset->nCol];
248027     u8 *aOut = pIter->poslist.p;
248030     pIter->base.iRowid = pSeg->iRowid;
248045     pIter->base.pData = pIter->poslist.p;
248046     pIter->base.nData = aOut - pIter->poslist.p;
248053 static void fts5IterSetOutputs_Full(Fts5Iter *pIter, Fts5SegIter *pSeg){
248054   Fts5Colset *pColset = pIter->pColset;
248055   pIter->base.iRowid = pSeg->iRowid;
248057   assert( pIter->pIndex->pConfig->eDetail==FTS5_DETAIL_FULL );
248064     int *pRc = &pIter->pIndex->rc;
248065     fts5BufferZero(&pIter->poslist);
248066     fts5IndexExtractColset(pRc, pColset, a, pSeg->nPos, pIter);
248071     fts5BufferZero(&pIter->poslist);
248072     fts5SegiterPoslist(pIter->pIndex, pSeg, pColset, &pIter->poslist);
248073     pIter->base.pData = pIter->poslist.p;
248074     pIter->base.nData = pIter->poslist.n;
248078 static void fts5IterSetOutputCb(int *pRc, Fts5Iter *pIter){
248079   assert( pIter!=0 || (*pRc)!=SQLITE_OK );
248081     Fts5Config *pConfig = pIter->pIndex->pConfig;
248083       pIter->xSetOutputs = fts5IterSetOutputs_None;
248086     else if( pIter->pColset==0 ){
248087       pIter->xSetOutputs = fts5IterSetOutputs_Nocolset;
248090     else if( pIter->pColset->nCol==0 ){
248091       pIter->xSetOutputs = fts5IterSetOutputs_ZeroColset;
248095       pIter->xSetOutputs = fts5IterSetOutputs_Full;
248101         pIter->xSetOutputs = fts5IterSetOutputs_Col100;
248102         sqlite3Fts5BufferSize(pRc, &pIter->poslist, pConfig->nCol);
248104         pIter->xSetOutputs = fts5IterSetOutputs_Col;
248114 static void fts5MultiIterFinishSetup(Fts5Index *p, Fts5Iter *pIter){
248116   for(iIter=pIter->nSeg-1; iIter>0; iIter--){
248118     if( (iEq = fts5MultiIterDoCompare(pIter, iIter)) ){
248119       Fts5SegIter *pSeg = &pIter->aSeg[iEq];
248121       fts5MultiIterAdvanced(p, pIter, iEq, iIter);
248124   fts5MultiIterSetEof(pIter);
248125   fts5AssertMultiIterSetup(p, pIter);
248127   if( (pIter->bSkipEmpty && fts5MultiIterIsEmpty(p, pIter))
248128    || fts5MultiIterIsDeleted(pIter)
248130     fts5MultiIterNext(p, pIter, 0, 0);
248131   }else if( pIter->base.bEof==0 ){
248132     Fts5SegIter *pSeg = &pIter->aSeg[pIter->aFirst[1].iFirst];
248133     pIter->xSetOutputs(pIter, pSeg);
248194         Fts5SegIter *pIter = &pNew->aSeg[iIter++];
248195         fts5SegIterHashInit(p, pTerm, nTerm, flags, pIter);
248200           Fts5SegIter *pIter = &pNew->aSeg[iIter++];
248202             fts5SegIterInit(p, pSeg, pIter);
248204             fts5SegIterSeekInit(p, pTerm, nTerm, flags, pSeg, pIter);
248246     Fts5SegIter *pIter = &pNew->aSeg[1];
248247     pIter->flags = FTS5_SEGITER_ONETERM;
248249       pIter->pLeaf = pData;
248250       pIter->iLeafOffset = fts5GetVarint(pData->p, (u64*)&pIter->iRowid);
248251       pIter->iEndofDoclist = pData->nn;
248255         pIter->flags |= FTS5_SEGITER_REVERSE;
248256         fts5SegIterReverseInitPage(p, pIter);
248258         fts5SegIterLoadNPos(p, pIter);
248264     fts5SegIterSetNext(p, pIter);
248276 static int fts5MultiIterEof(Fts5Index *p, Fts5Iter *pIter){
248277   assert( pIter!=0 || p->rc!=SQLITE_OK );
248279       || (pIter->aSeg[ pIter->aFirst[1].iFirst ].pLeaf==0)==pIter->base.bEof
248281   return (p->rc || pIter->base.bEof);
248289 static i64 fts5MultiIterRowid(Fts5Iter *pIter){
248290   assert( pIter->aSeg[ pIter->aFirst[1].iFirst ].pLeaf );
248291   return pIter->aSeg[ pIter->aFirst[1].iFirst ].iRowid;
248299   Fts5Iter *pIter,
248304     fts5MultiIterNext(p, pIter, 1, iMatch);
248305     if( fts5MultiIterEof(p, pIter) ) break;
248306     iRowid = fts5MultiIterRowid(pIter);
248307     if( pIter->bRev==0 && iRowid>=iMatch ) break;
248308     if( pIter->bRev!=0 && iRowid<=iMatch ) break;
248316 static const u8 *fts5MultiIterTerm(Fts5Iter *pIter, int *pn){
248317   Fts5SegIter *p = &pIter->aSeg[ pIter->aFirst[1].iFirst ];
248896 static void fts5TrimSegments(Fts5Index *p, Fts5Iter *pIter){
248900   for(i=0; i<pIter->nSeg && p->rc==SQLITE_OK; i++){
248901     Fts5SegIter *pSeg = &pIter->aSeg[i];
248983   Fts5Iter *pIter = 0;       /* Iterator to read input data */
249043   for(fts5MultiIterNew(p, pStruct, flags, 0, 0, 0, iLvl, nInput, &pIter);
249044       fts5MultiIterEof(p, pIter)==0;
249045       fts5MultiIterNext(p, pIter, 0, 0)
249047     Fts5SegIter *pSegIter = &pIter->aSeg[ pIter->aFirst[1].iFirst ];
249052     pTerm = fts5MultiIterTerm(pIter, &nTerm);
249072     fts5WriteAppendRowid(p, &writer, fts5MultiIterRowid(pIter));
249093   assert( pIter!=0 || p->rc!=SQLITE_OK );
249094   if( fts5MultiIterEof(p, pIter) ){
249119     fts5TrimSegments(p, pIter);
249123   fts5MultiIterFree(pIter);
249753   Fts5Iter *pIter = 0;            /* Used to find term instance */
249773   fts5MultiIterNew(p, pStruct, f, 0, (const u8*)zTerm, nTerm, -1, 0, &pIter);
249774   if( fts5MultiIterEof(p, pIter)==0 ){
249775     i64 iThis = fts5MultiIterRowid(pIter);
249777       fts5MultiIterNextFrom(p, pIter, iRowid);
249781      && fts5MultiIterEof(p, pIter)==0
249782      && iRowid==fts5MultiIterRowid(pIter)
249784       Fts5SegIter *pSeg = &pIter->aSeg[pIter->aFirst[1].iFirst];
249789   fts5MultiIterFree(pIter);
250189 static void fts5DoclistIterNext(Fts5DoclistIter *pIter){
250190   u8 *p = pIter->aPoslist + pIter->nSize + pIter->nPoslist;
250192   assert( pIter->aPoslist || (p==0 && pIter->aPoslist==0) );
250193   if( p>=pIter->aEof ){
250194     pIter->aPoslist = 0;
250199     pIter->iRowid += iDelta;
250204       pIter->nSize = fts5GetVarint32(p, nPos);
250205       pIter->nPoslist = (nPos>>1);
250207       pIter->nPoslist = ((int)(p[0])) >> 1;
250208       pIter->nSize = 1;
250211     pIter->aPoslist = p;
250212     if( &pIter->aPoslist[pIter->nPoslist]>pIter->aEof ){
250213       pIter->aPoslist = 0;
250220   Fts5DoclistIter *pIter
250222   memset(pIter, 0, sizeof(*pIter));
250224     pIter->aPoslist = pBuf->p;
250225     pIter->aEof = &pBuf->p[pBuf->n];
250226     fts5DoclistIterNext(pIter);
250543   void (*xVisit)(Fts5Index*, void *pCtx, Fts5Iter *pIter, const u8*, int),
251236     Fts5Iter *pIter = (Fts5Iter*)pIndexIter;
251237     Fts5Index *pIndex = pIter->pIndex;
251238     fts5TokendataIterDelete(pIter->pTokenDataIter);
251239     fts5MultiIterFree(pIter);
251286 static void fts5IterSetOutputsTokendata(Fts5Iter *pIter){
251292   Fts5TokenDataIter *pT = pIter->pTokenDataIter;
251294   pIter->base.nData = 0;
251295   pIter->base.pData = 0;
251303         pIter->base.pData = p->base.pData;
251304         pIter->base.nData = p->base.nData;
251313     pIter->base.bEof = 1;
251315     int eDetail = pIter->pIndex->pConfig->eDetail;
251316     pIter->base.bEof = 0;
251317     pIter->base.iRowid = iRowid;
251320       fts5TokendataIterAppendMap(pIter->pIndex, pT, iMin, 0, iRowid, -1);
251330             &pIter->pIndex->rc,
251350       if( fts5BufferGrow(&pIter->pIndex->rc, &pIter->poslist, nByte+nHit*10) ){
251361           pIter->pIndex->rc = SQLITE_NOMEM;
251368       pIter->poslist.n = 0;
251388         sqlite3Fts5PoslistSafeAppend(&pIter->poslist, &iPrev, iMinPos);
251399       pIter->base.pData = pIter->poslist.p;
251400       pIter->base.nData = pIter->poslist.n;
251412 static void fts5TokendataIterNext(Fts5Iter *pIter, int bFrom, i64 iFrom){
251414   Fts5TokenDataIter *pT = pIter->pTokenDataIter;
251415   Fts5Index *pIndex = pIter->pIndex;
251420      && (p->base.iRowid==pIter->base.iRowid || (bFrom && p->base.iRowid<iFrom))
251433     fts5IterSetOutputsTokendata(pIter);
251441 static void fts5TokendataSetTermIfEof(Fts5Iter *pIter, Fts5Buffer *pTerm){
251442   if( pIter && pIter->aSeg[0].pLeaf==0 ){
251443     fts5BufferSet(&pIter->pIndex->rc, &pIter->aSeg[0].term, pTerm->n, pTerm->p);
251560       Fts5Iter *pIter = pSet->apIter[ii];
251562       for(iSeg=0; iSeg<pIter->nSeg; iSeg++){
251563         pIter->aSeg[iSeg].flags |= FTS5_SEGITER_ONETERM;
251565       fts5MultiIterFinishSetup(p, pIter);
251696   Fts5Iter *pIter = (Fts5Iter*)pIndexIter;
251697   assert( pIter->pIndex->rc==SQLITE_OK );
251698   if( pIter->nSeg==0 ){
251699     assert( pIter->pTokenDataIter );
251700     fts5TokendataIterNext(pIter, 0, 0);
251702     fts5MultiIterNext(pIter->pIndex, pIter, 0, 0);
251704   return fts5IndexReturn(pIter->pIndex);
251711   Fts5Iter *pIter = (Fts5Iter*)pIndexIter;
251712   Fts5Index *p = pIter->pIndex;
251714   assert( pIter->pIndex->rc==SQLITE_OK );
251716   fts5MultiIterNext(p, pIter, 0, 0);
251718     Fts5SegIter *pSeg = &pIter->aSeg[ pIter->aFirst[1].iFirst ];
251722       pIter->base.bEof = 1;
251726   return fts5IndexReturn(pIter->pIndex);
251735   Fts5Iter *pIter = (Fts5Iter*)pIndexIter;
251736   if( pIter->nSeg==0 ){
251737     assert( pIter->pTokenDataIter );
251738     fts5TokendataIterNext(pIter, 1, iMatch);
251740     fts5MultiIterNextFrom(pIter->pIndex, pIter, iMatch);
251742   return fts5IndexReturn(pIter->pIndex);
251762   Fts5Iter *pIter,
251766   Fts5Index *p = pIter->pIndex;
251792     pIter->pTokenDataIter = ctx.pT;
251817   Fts5Iter *pIter = (Fts5Iter*)pIndexIter;
251818   Fts5TokenDataIter *pT = pIter->pTokenDataIter;
251825   assert( pT || (pToken && pIter->nSeg>0) );
251827     int rc = fts5SetupPrefixIterTokendata(pIter, pToken, nToken);
251829     pT = pIter->pTokenDataIter;
251857     if( pIter->nSeg==0 ){
251876   Fts5Iter *pIter = (Fts5Iter*)pIndexIter;
251877   if( pIter && pIter->pTokenDataIter
251878    && (pIter->nSeg==0 || pIter->pIndex->pConfig->eDetail!=FTS5_DETAIL_FULL)
251880     pIter->pTokenDataIter->nMap = 0;
251896   Fts5Iter *pIter = (Fts5Iter*)pIndexIter;
251897   Fts5TokenDataIter *pT = pIter->pTokenDataIter;
251898   Fts5Index *p = pIter->pIndex;
251902   assert( pIter->pTokenDataIter || pIter->nSeg>0 );
251903   if( pIter->nSeg>0 ){
251908       pIter->pTokenDataIter = pT;
252439   Fts5IndexIter *pIter = 0;
252441       p, z, n, (flags | FTS5INDEX_QUERY_NOTOKENDATA), 0, &pIter
252444   while( rc==SQLITE_OK && ALWAYS(pIter!=0) && 0==sqlite3Fts5IterEof(pIter) ){
252445     i64 rowid = pIter->iRowid;
252451       for(sqlite3Fts5PoslistReaderInit(pIter->pData, pIter->nData, &sReader);
252461       rc = sqlite3Fts5IterNext(pIter);
252464   fts5IterClose(pIter);
252823   Fts5Iter *pIter;                /* Used to iterate through entire index */
252862   for(fts5MultiIterNew(p, pStruct, flags, 0, 0, 0, -1, 0, &pIter);
252863       fts5MultiIterEof(p, pIter)==0;
252864       fts5MultiIterNext(p, pIter, 0, 0)
252869     i64 iRowid = fts5MultiIterRowid(pIter);
252870     char *z = (char*)fts5MultiIterTerm(pIter, &n);
252877       if( 0==fts5MultiIterIsEmpty(p, pIter) ){
252882       fts5SegiterPoslist(p, &pIter->aSeg[pIter->aFirst[1].iFirst], 0, &poslist);
252893   fts5MultiIterFree(pIter);
256306   Fts5PhraseIter *pIter,
256309   if( pIter->a>=pIter->b ){
256314     pIter->a += fts5GetVarint32(pIter->a, iVal);
256320       pIter->a += fts5GetVarint32(pIter->a, iVal);
256323       pIter->a += fts5GetVarint32(pIter->a, iVal);
256332   Fts5PhraseIter *pIter,
256337   int rc = fts5CsrPoslist(pCsr, iPhrase, &pIter->a, &n);
256339     assert( pIter->a || n==0 );
256340     pIter->b = (pIter->a ? &pIter->a[n] : 0);
256343     fts5ApiPhraseNext(pCtx, pIter, piCol, piOff);
256350   Fts5PhraseIter *pIter,
256357     if( pIter->a>=pIter->b ){
256361       pIter->a += fts5GetVarint32(&pIter->a[0], iIncr);
256367       if( pIter->a>=pIter->b ){
256371       if( pIter->a[0]==0x01 ) break;
256372       pIter->a += fts5GetVarint32(pIter->a, dummy);
256374     pIter->a += 1 + fts5GetVarint32(&pIter->a[1], *piCol);
256381   Fts5PhraseIter *pIter,
256394       pIter->a = &pSorter->aPoslist[i1];
256396       rc = sqlite3Fts5ExprPhraseCollist(pCsr->pExpr, iPhrase, &pIter->a, &n);
256399       assert( pIter->a || n==0 );
256400       pIter->b = (pIter->a ? &pIter->a[n] : 0);
256402       fts5ApiPhraseNextColumn(pCtx, pIter, piCol);
256406     rc = fts5CsrPoslist(pCsr, iPhrase, &pIter->a, &n);
256408       assert( pIter->a || n==0 );
256409       pIter->b = (pIter->a ? &pIter->a[n] : 0);
256412       }else if( pIter->a[0]==0x01 ){
256413         pIter->a += 1 + fts5GetVarint32(&pIter->a[1], *piCol);
261793   Fts5IndexIter *pIter;           /* Term/rowid iterator object */
262132   sqlite3Fts5IterClose(pCsr->pIter);
262135   pCsr->pIter = 0;
262158   if( sqlite3Fts5IterEof(pCsr->pIter) ){
262163     zTerm = sqlite3Fts5IterTerm(pCsr->pIter, &nTerm);
262180   Fts5IndexIter *pIter = pCsr->pIter;
262184   assert( sqlite3Fts5IterEof(pIter)==0 );
262187       || sqlite3Fts5PoslistNext64(pIter->pData, pIter->nData, po, pp)
262192     rc = sqlite3Fts5IterNextScan(pCsr->pIter);
262230     if( sqlite3Fts5IterEof(pCsr->pIter) ){
262236       zTerm = sqlite3Fts5IterTerm(pCsr->pIter, &nTerm);
262259         pPos = pCsr->pIter->pData;
262260         nPos = pCsr->pIter->nData;
262318           rc = sqlite3Fts5IterNextScan(pCsr->pIter);
262323           zTerm = sqlite3Fts5IterTerm(pCsr->pIter, &nTerm);
262329           if( sqlite3Fts5IterEof(pCsr->pIter) ) break;
262400     rc = sqlite3Fts5IndexQuery(pIndex, zTerm, nTerm, f, 0, &pCsr->pIter);
262464         sqlite3_result_int64(pCtx, pCsr->pIter->iRowid);