Lines Matching refs:pIter
11558 SQLITE_API int sqlite3changeset_next(sqlite3_changeset_iter *pIter);
11564 ** The pIter argument passed to this function may either be an iterator
11593 sqlite3_changeset_iter *pIter, /* Iterator object */
11612 ** the table modified by the change that iterator pIter currently points to.
11627 sqlite3_changeset_iter *pIter, /* Iterator object */
11636 ** The pIter argument passed to this function may either be an iterator
11658 sqlite3_changeset_iter *pIter, /* Changeset iterator */
11667 ** The pIter argument passed to this function may either be an iterator
11692 sqlite3_changeset_iter *pIter, /* Changeset iterator */
11720 sqlite3_changeset_iter *pIter, /* Changeset iterator */
11737 sqlite3_changeset_iter *pIter, /* Changeset iterator */
11772 SQLITE_API int sqlite3changeset_finalize(sqlite3_changeset_iter *pIter);
65409 WalIterator *pIter = 0; /* Wal iterator context */
65454 rc = walIteratorInit(pWal, pInfo->nBackfill, &pIter);
65455 assert( rc==SQLITE_OK || pIter==0 );
65458 if( pIter
65491 while( rc==SQLITE_OK && 0==walIteratorNext(pIter, &iDbpage, &iFrame) ){
65578 walIteratorFree(pIter);
68908 BtLock *pIter;
68935 for(pIter=pBt->pLock; pIter; pIter=pIter->pNext){
68936 /* The condition (pIter->eLock!=eLock) in the following if(...)
68939 ** (eLock==WRITE_LOCK || pIter->eLock==WRITE_LOCK)
68945 assert( pIter->eLock==READ_LOCK || pIter->eLock==WRITE_LOCK );
68946 assert( eLock==READ_LOCK || pIter->pBtree==p || pIter->eLock==READ_LOCK);
68947 if( pIter->pBtree!=p && pIter->iTable==iTab && pIter->eLock!=eLock ){
68948 sqlite3ConnectionBlocked(p->db, pIter->pBtree->db);
68981 BtLock *pIter;
68999 for(pIter=pBt->pLock; pIter; pIter=pIter->pNext){
69000 if( pIter->iTable==iTable && pIter->pBtree==p ){
69001 pLock = pIter;
69816 u8 *pIter; /* For scanning through pCell */
69824 pIter = pCell;
69828 ** pIter += getVarint32(pIter, nPayload);
69832 nPayload = *pIter;
69834 u8 *pEnd = &pIter[8];
69837 nPayload = (nPayload<<7) | (*++pIter & 0x7f);
69838 }while( (*pIter)>=0x80 && pIter<pEnd );
69840 pIter++;
69844 ** pIter += getVarint(pIter, (u64*)&pInfo->nKey);
69849 iKey = *pIter;
69852 iKey = ((iKey&0x7f)<<7) | ((x = *++pIter) & 0x7f);
69854 iKey = (iKey<<7) | ((x =*++pIter) & 0x7f);
69856 iKey = (iKey<<7) | ((x = *++pIter) & 0x7f);
69858 iKey = (iKey<<7) | ((x = *++pIter) & 0x7f);
69860 iKey = (iKey<<7) | ((x = *++pIter) & 0x7f);
69862 iKey = (iKey<<7) | ((x = *++pIter) & 0x7f);
69864 iKey = (iKey<<7) | ((x = *++pIter) & 0x7f);
69866 iKey = (iKey<<8) | (*++pIter);
69875 pIter++;
69879 pInfo->pPayload = pIter;
69886 pInfo->nSize = nPayload + (u16)(pIter - pCell);
69898 u8 *pIter; /* For scanning through pCell */
69904 pIter = pCell + pPage->childPtrSize;
69905 nPayload = *pIter;
69907 u8 *pEnd = &pIter[8];
69910 nPayload = (nPayload<<7) | (*++pIter & 0x7f);
69911 }while( *(pIter)>=0x80 && pIter<pEnd );
69913 pIter++;
69916 pInfo->pPayload = pIter;
69923 pInfo->nSize = nPayload + (u16)(pIter - pCell);
69952 u8 *pIter = pCell + pPage->childPtrSize; /* For looping over bytes of pCell */
69965 nSize = *pIter;
69967 pEnd = &pIter[8];
69970 nSize = (nSize<<7) | (*++pIter & 0x7f);
69971 }while( *(pIter)>=0x80 && pIter<pEnd );
69973 pIter++;
69977 nSize += (u32)(pIter - pCell);
69987 nSize += 4 + (u16)(pIter - pCell);
69993 u8 *pIter = pCell + 4; /* For looping over bytes of pCell */
70008 pEnd = pIter + 9;
70009 while( (*pIter++)&0x80 && pIter<pEnd );
70010 assert( debuginfo.nSize==(u16)(pIter - pCell) || CORRUPT_DB );
70011 return (u16)(pIter - pCell);
70014 u8 *pIter = pCell; /* For looping over bytes of pCell */
70027 nSize = *pIter;
70029 pEnd = &pIter[8];
70032 nSize = (nSize<<7) | (*++pIter & 0x7f);
70033 }while( *(pIter)>=0x80 && pIter<pEnd );
70035 pIter++;
70036 /* pIter now points at the 64-bit integer key value, a variable length
70037 ** integer. The following block moves pIter to point at the first byte
70039 if( (*pIter++)&0x80
70040 && (*pIter++)&0x80
70041 && (*pIter++)&0x80
70042 && (*pIter++)&0x80
70043 && (*pIter++)&0x80
70044 && (*pIter++)&0x80
70045 && (*pIter++)&0x80
70046 && (*pIter++)&0x80 ){ pIter++; }
70050 nSize += (u32)(pIter - pCell);
70060 nSize += 4 + (u16)(pIter - pCell);
72168 BtLock *pIter;
72169 for(pIter=pBt->pLock; pIter; pIter=pIter->pNext){
72170 if( pIter->pBtree!=p ){
72171 pBlock = pIter->pBtree->db;
103106 FileChunk *pIter;
103108 for(pIter=pFirst; pIter; pIter=pNext){
103109 pNext = pIter->pNext;
103110 sqlite3_free(pIter);
103127 FileChunk *pIter;
103128 for(pIter=copy.pFirst; pIter; pIter=pIter->pNext){
103132 rc = sqlite3OsWrite(pReal, (u8*)pIter->zChunk, nChunk, iOff);
103236 FileChunk *pIter = 0;
103242 for(pIter=p->pFirst; ALWAYS(pIter) && iOff<size; pIter=pIter->pNext){
103245 if( ALWAYS(pIter) ){
103246 memjrnlFreeChunks(pIter->pNext);
103247 pIter->pNext = 0;
103251 p->endpoint.pChunk = pIter;
130149 static Index *indexIteratorFirst(IndexIterator *pIter, int *pIx){
130150 assert( pIter->i==0 );
130151 if( pIter->eType ){
130152 *pIx = pIter->u.ax.aIdx[0].ix;
130153 return pIter->u.ax.aIdx[0].p;
130156 return pIter->u.lx.pIdx;
130161 static Index *indexIteratorNext(IndexIterator *pIter, int *pIx){
130162 if( pIter->eType ){
130163 int i = ++pIter->i;
130164 if( i>=pIter->u.ax.nIdx ){
130168 *pIx = pIter->u.ax.aIdx[i].ix;
130169 return pIter->u.ax.aIdx[i].p;
130172 pIter->u.lx.pIdx = pIter->u.lx.pIdx->pNext;
130173 return pIter->u.lx.pIdx;
184218 char *pIter; /* Used to iterate through aAll */
184222 pIter = pDL->pNextDocid;
184223 assert( pDL->aAll!=0 || pIter==0 );
184225 pIter = pDL->aAll;
184228 if( pIter==0 || pIter>=(pEnd = pDL->aAll + pDL->nAll) ){
184233 pIter += sqlite3Fts3GetVarint(pIter, &iDelta);
184239 pDL->pList = pIter;
184240 fts3PoslistCopy(0, &pIter);
184241 pDL->nList = (int)(pIter - pDL->pList);
184243 /* pIter now points just past the 0x00 that terminates the position-
184245 ** edited in place by fts3EvalNearTrim(), then pIter may not actually
184247 ** with this case by advancing pIter past the zero-padding added by
184249 while( pIter<pEnd && *pIter==0 ) pIter++;
184251 pDL->pNextDocid = pIter;
184252 assert( pIter>=&pDL->aAll[pDL->nAll] || *pIter );
185588 char *pIter;
185601 pIter = pPhrase->doclist.pList;
185656 pIter = pPh->pOrPoslist;
185660 (pIter >= (pPh->doclist.aAll + pPh->doclist.nAll));
185661 while( (pIter==0 || DOCID_CMP(iDocid, pCsr->iPrevId)<0 ) && bEof==0 ){
185664 &pIter, &iDocid, &bEof
185668 bEof = !pPh->doclist.nAll || (pIter && pIter<=pPh->doclist.aAll);
185669 while( (pIter==0 || DOCID_CMP(iDocid, pCsr->iPrevId)>0 ) && bEof==0 ){
185673 &pIter, &iDocid, &dummy, &bEof
185677 pPh->pOrPoslist = pIter;
185683 pIter = pPhrase->pOrPoslist;
185685 pIter = 0;
185688 if( pIter==0 ) return SQLITE_OK;
185690 if( *pIter==0x01 ){
185691 pIter++;
185692 pIter += fts3GetVarint32(pIter, &iThis);
185697 fts3ColumnlistCopy(0, &pIter);
185698 if( *pIter==0x00 ) return SQLITE_OK;
185699 pIter++;
185700 pIter += fts3GetVarint32(pIter, &iThis);
185702 if( *pIter==0x00 ){
185703 pIter = 0;
185706 *ppOut = ((iCol==iThis)?pIter:0);
187054 Fts3Expr *pIter = pNotBranch;
187055 while( pIter->pLeft ){
187056 pIter = pIter->pLeft;
187058 pIter->pLeft = pRet;
187059 pRet->pParent = pIter;
192071 SegmentNode *pIter;
192074 for(pIter=pTree->pLeftmost; pIter && rc==SQLITE_OK; pIter=pIter->pRight){
192075 int nStart = fts3TreeFinishNode(pIter, iHeight, iNextLeaf);
192076 int nWrite = pIter->nData - nStart;
192078 rc = fts3WriteSegment(p, iNextFree, &pIter->aData[nStart], nWrite);
192080 iNextLeaf += (pIter->nEntry+1);
196054 char *pIter = *ppIter;
196055 if( pIter ){
196059 if( 0==(*pIter & 0xFE) ){
196061 pIter = 0;
196064 fts3GetDeltaPosition(&pIter, &iIter);
196068 *ppIter = pIter;
196075 static int fts3SnippetNextCandidate(SnippetIter *pIter){
196078 if( pIter->iCurrent<0 ){
196083 pIter->iCurrent = 0;
196088 for(i=0; i<pIter->nPhrase; i++){
196089 SnippetPhrase *pPhrase = &pIter->aPhrase[i];
196090 fts3SnippetAdvance(&pPhrase->pHead, &pPhrase->iHead, pIter->nSnippet);
196096 for(i=0; i<pIter->nPhrase; i++){
196097 SnippetPhrase *pPhrase = &pIter->aPhrase[i];
196106 pIter->iCurrent = iStart = iEnd - pIter->nSnippet + 1;
196107 for(i=0; i<pIter->nPhrase; i++){
196108 SnippetPhrase *pPhrase = &pIter->aPhrase[i];
196119 ** iterator pIter.
196122 SnippetIter *pIter, /* Snippet iterator */
196129 int iStart = pIter->iCurrent; /* First token of snippet */
196135 for(i=0; i<pIter->nPhrase; i++){
196136 SnippetPhrase *pPhrase = &pIter->aPhrase[i];
196141 while( iCsr<(iStart+pIter->nSnippet) && iCsr>=iStart ){
196575 char *pIter = pPhrase->doclist.pList;
196585 if( pIter ) while( 1 ){
196586 int nHit = fts3ColumnlistCount(&pIter);
196594 assert( *pIter==0x00 || *pIter==0x01 );
196595 if( *pIter!=0x01 ) break;
196596 pIter++;
196597 pIter += fts3GetVarint32(pIter, &iCol);
196816 static int fts3LcsIteratorAdvance(LcsIterator *pIter){
196821 if( NEVER(pIter==0) ) return 1;
196822 pRead = pIter->pRead;
196828 pIter->iPos += (int)(iRead-2);
196831 pIter->pRead = pRead;
196861 LcsIterator *pIter = &aIter[i];
196862 nToken -= pIter->pExpr->pPhrase->nToken;
196863 pIter->iPosOffset = nToken;
196890 LcsIterator *pIter = &aIter[i];
196891 if( pIter->pRead==0 ){
196895 if( pAdv==0 || pIter->iPos<pAdv->iPos ){
196896 pAdv = pIter;
196898 if( nThisLcs==0 || pIter->iPos==pIter[-1].iPos ){
207945 UBreakIterator *pIter; /* ICU break-iterator object */
208058 pCsr->pIter = ubrk_open(UBRK_WORD, p->zLocale, pCsr->aChar, iOut, &status);
208065 ubrk_first(pCsr->pIter);
208075 ubrk_close(pCsr->pIter);
208101 iStart = ubrk_current(pCsr->pIter);
208102 iEnd = ubrk_next(pCsr->pIter);
209605 static void rbuObjIterFreeCols(RbuObjIter *pIter){
209607 for(i=0; i<pIter->nTblCol; i++){
209608 sqlite3_free(pIter->azTblCol[i]);
209609 sqlite3_free(pIter->azTblType[i]);
209611 sqlite3_free(pIter->azTblCol);
209612 pIter->azTblCol = 0;
209613 pIter->azTblType = 0;
209614 pIter->aiSrcOrder = 0;
209615 pIter->abTblPk = 0;
209616 pIter->abNotNull = 0;
209617 pIter->nTblCol = 0;
209618 pIter->eType = 0; /* Invalid value */
209625 static void rbuObjIterClearStatements(RbuObjIter *pIter){
209628 sqlite3_finalize(pIter->pSelect);
209629 sqlite3_finalize(pIter->pInsert);
209630 sqlite3_finalize(pIter->pDelete);
209631 sqlite3_finalize(pIter->pTmpInsert);
209632 pUp = pIter->pRbuUpdate;
209639 sqlite3_free(pIter->aIdxCol);
209640 sqlite3_free(pIter->zIdxSql);
209642 pIter->pSelect = 0;
209643 pIter->pInsert = 0;
209644 pIter->pDelete = 0;
209645 pIter->pRbuUpdate = 0;
209646 pIter->pTmpInsert = 0;
209647 pIter->nCol = 0;
209648 pIter->nIdxCol = 0;
209649 pIter->aIdxCol = 0;
209650 pIter->zIdxSql = 0;
209657 static void rbuObjIterFinalize(RbuObjIter *pIter){
209658 rbuObjIterClearStatements(pIter);
209659 sqlite3_finalize(pIter->pTblIter);
209660 sqlite3_finalize(pIter->pIdxIter);
209661 rbuObjIterFreeCols(pIter);
209662 memset(pIter, 0, sizeof(RbuObjIter));
209673 static int rbuObjIterNext(sqlite3rbu *p, RbuObjIter *pIter){
209678 rbuObjIterClearStatements(pIter);
209679 if( pIter->zIdx==0 ){
209690 if( pIter->bCleanup ){
209691 rbuObjIterFreeCols(pIter);
209692 pIter->bCleanup = 0;
209693 rc = sqlite3_step(pIter->pTblIter);
209695 rc = resetAndCollectError(pIter->pTblIter, &p->zErrmsg);
209696 pIter->zTbl = 0;
209698 pIter->zTbl = (const char*)sqlite3_column_text(pIter->pTblIter, 0);
209699 pIter->zDataTbl = (const char*)sqlite3_column_text(pIter->pTblIter,1);
209700 rc = (pIter->zDataTbl && pIter->zTbl) ? SQLITE_OK : SQLITE_NOMEM;
209703 if( pIter->zIdx==0 ){
209704 sqlite3_stmt *pIdx = pIter->pIdxIter;
209705 rc = sqlite3_bind_text(pIdx, 1, pIter->zTbl, -1, SQLITE_STATIC);
209708 rc = sqlite3_step(pIter->pIdxIter);
209710 rc = resetAndCollectError(pIter->pIdxIter, &p->zErrmsg);
209711 pIter->bCleanup = 1;
209712 pIter->zIdx = 0;
209714 pIter->zIdx = (const char*)sqlite3_column_text(pIter->pIdxIter, 0);
209715 pIter->iTnum = sqlite3_column_int(pIter->pIdxIter, 1);
209716 pIter->bUnique = sqlite3_column_int(pIter->pIdxIter, 2);
209717 rc = pIter->zIdx ? SQLITE_OK : SQLITE_NOMEM;
209725 rbuObjIterFinalize(pIter);
209789 static int rbuObjIterFirst(sqlite3rbu *p, RbuObjIter *pIter){
209791 memset(pIter, 0, sizeof(RbuObjIter));
209793 rc = prepareFreeAndCollectError(p->dbRbu, &pIter->pTblIter, &p->zErrmsg,
209803 rc = prepareAndCollectError(p->dbMain, &pIter->pIdxIter, &p->zErrmsg,
209810 pIter->bCleanup = 1;
209812 return rbuObjIterNext(p, pIter);
209892 ** Allocate and zero the pIter->azTblCol[] and abTblPk[] arrays so that
209896 static void rbuAllocateIterArrays(sqlite3rbu *p, RbuObjIter *pIter, int nCol){
209902 pIter->azTblCol = azNew;
209903 pIter->azTblType = &azNew[nCol];
209904 pIter->aiSrcOrder = (int*)&pIter->azTblType[nCol];
209905 pIter->abTblPk = (u8*)&pIter->aiSrcOrder[nCol];
209906 pIter->abNotNull = (u8*)&pIter->abTblPk[nCol];
209907 pIter->abIndexed = (u8*)&pIter->abNotNull[nCol];
210078 ** the pIter->abIndexed[] array.
210080 static void rbuObjIterCacheIndexedCols(sqlite3rbu *p, RbuObjIter *pIter){
210085 memcpy(pIter->abIndexed, pIter->abTblPk, sizeof(u8)*pIter->nTblCol);
210087 sqlite3_mprintf("PRAGMA main.index_list = %Q", pIter->zTbl)
210091 pIter->nIndex = 0;
210098 memset(pIter->abIndexed, 0x01, sizeof(u8)*pIter->nTblCol);
210105 if( iCid>=0 ) pIter->abIndexed[iCid] = 1;
210107 memset(pIter->abIndexed, 0x01, sizeof(u8)*pIter->nTblCol);
210112 pIter->nIndex++;
210115 if( pIter->eType==RBU_PK_WITHOUT_ROWID ){
210117 pIter->nIndex--;
210121 if( bIndex==0 ) pIter->abIndexed = 0;
210126 ** If they are not already populated, populate the pIter->azTblCol[],
210127 ** pIter->abTblPk[], pIter->nTblCol and pIter->bRowid variables according to
210134 static int rbuObjIterCacheTableInfo(sqlite3rbu *p, RbuObjIter *pIter){
210135 if( pIter->azTblCol==0 ){
210144 assert( pIter->eType==0 );
210145 rbuTableType(p, pIter->zTbl, &pIter->eType, &iTnum, &pIter->iPkTnum);
210146 if( p->rc==SQLITE_OK && pIter->eType==RBU_PK_NOTABLE ){
210148 p->zErrmsg = sqlite3_mprintf("no such table: %s", pIter->zTbl);
210151 if( pIter->zIdx==0 ) pIter->iTnum = iTnum;
210153 assert( pIter->eType==RBU_PK_NONE || pIter->eType==RBU_PK_IPK
210154 || pIter->eType==RBU_PK_EXTERNAL || pIter->eType==RBU_PK_WITHOUT_ROWID
210155 || pIter->eType==RBU_PK_VTAB
210162 sqlite3_mprintf("SELECT * FROM '%q'", pIter->zDataTbl)
210166 rbuAllocateIterArrays(p, pIter, nCol);
210172 pIter->aiSrcOrder[pIter->nTblCol] = pIter->nTblCol;
210173 pIter->azTblCol[pIter->nTblCol++] = zCopy;
210184 && bRbuRowid!=(pIter->eType==RBU_PK_VTAB || pIter->eType==RBU_PK_NONE)
210188 "table %q %s rbu_rowid column", pIter->zDataTbl,
210198 sqlite3_mprintf("PRAGMA table_info(%Q)", pIter->zTbl)
210204 for(i=iOrder; i<pIter->nTblCol; i++){
210205 if( 0==strcmp(zName, pIter->azTblCol[i]) ) break;
210207 if( i==pIter->nTblCol ){
210210 pIter->zDataTbl, zName
210218 SWAP(int, pIter->aiSrcOrder[i], pIter->aiSrcOrder[iOrder]);
210219 SWAP(char*, pIter->azTblCol[i], pIter->azTblCol[iOrder]);
210222 pIter->azTblType[iOrder] = rbuStrndup(zType, &p->rc);
210224 pIter->abTblPk[iOrder] = (u8)iPk;
210225 pIter->abNotNull[iOrder] = (u8)bNotNull || (iPk!=0);
210231 rbuObjIterCacheIndexedCols(p, pIter);
210232 assert( pIter->eType!=RBU_PK_VTAB || pIter->abIndexed==0 );
210233 assert( pIter->eType!=RBU_PK_VTAB || pIter->nIndex==0 );
210242 ** column names currently stored in the pIter->azTblCol[] array.
210246 RbuObjIter *pIter /* Object iterator for column names */
210251 for(i=0; i<pIter->nTblCol; i++){
210252 const char *z = pIter->azTblCol[i];
210267 RbuObjIter *pIter, /* Object iterator for column names */
210277 for(i=0; i<pIter->nTblCol; i++){
210278 if( (int)pIter->abTblPk[i]==iPk ){
210279 const char *zCol = pIter->azTblCol[i];
210285 if( i==pIter->nTblCol ) break;
210312 RbuObjIter *pIter, /* RBU iterator object */
210321 "SELECT max(_rowid_) FROM \"%s%w\"", zWrite, pIter->zTbl
210330 char *zOrder = rbuObjIterGetPkList(p, pIter, "", ", ", " DESC");
210331 char *zSelect = rbuObjIterGetPkList(p, pIter, "quote(", "||','||", ")");
210332 char *zList = rbuObjIterGetPkList(p, pIter, "", ", ", "");
210338 zSelect, zWrite, pIter->zTbl, zOrder
210379 RbuObjIter *pIter /* RBU iterator object */
210392 sqlite3_mprintf("PRAGMA main.index_xinfo = %Q", pIter->zIdx)
210404 if( pIter->eType==RBU_PK_IPK ){
210406 for(i=0; pIter->abTblPk[i]==0; i++);
210407 assert( i<pIter->nTblCol );
210408 zCol = pIter->azTblCol[i];
210413 zCol = pIter->azTblCol[iCid];
210436 zSelect, pIter->zTbl, zOrder
210441 for(iCol=0; iCol<pIter->nCol; iCol++){
210494 RbuObjIter *pIter, /* Object iterator for column names */
210514 sqlite3_mprintf("PRAGMA main.index_xinfo = %Q", pIter->zIdx)
210528 pIter->aIdxCol[iSeq].nSpan, pIter->aIdxCol[iSeq].zSpan, zCollate
210535 if( pIter->eType==RBU_PK_IPK ){
210537 for(i=0; pIter->abTblPk[i]==0; i++);
210538 assert( i<pIter->nTblCol );
210539 zCol = pIter->azTblCol[i];
210547 zCol = pIter->azTblCol[iCid];
210548 zType = pIter->azTblType[iCid];
210553 if( pIter->bUnique==0 || sqlite3_column_int(pXInfo, 5) ){
210606 RbuObjIter *pIter,
210610 if( p->rc==SQLITE_OK && pIter->abIndexed ){
210613 for(i=0; i<pIter->nTblCol; i++){
210614 if( pIter->abIndexed[i] ){
210615 const char *zCol = pIter->azTblCol[i];
210628 if( pIter->eType==RBU_PK_EXTERNAL || pIter->eType==RBU_PK_NONE ){
210647 RbuObjIter *pIter
210650 if( pIter->eType==RBU_PK_VTAB || pIter->eType==RBU_PK_NONE ){
210651 zList = rbuMPrintf(p, "_rowid_ = ?%d", pIter->nTblCol+1);
210652 }else if( pIter->eType==RBU_PK_EXTERNAL ){
210655 for(i=0; i<pIter->nTblCol; i++){
210656 if( pIter->abTblPk[i] ){
210668 for(i=0; i<pIter->nTblCol; i++){
210669 if( pIter->abTblPk[i] ){
210670 const char *zCol = pIter->azTblCol[i];
210711 RbuObjIter *pIter,
210718 if( (int)strlen(zMask)!=pIter->nTblCol ){
210722 for(i=0; i<pIter->nTblCol; i++){
210723 char c = zMask[pIter->aiSrcOrder[i]];
210726 zList, zSep, pIter->azTblCol[i], i+1
210732 zList, zSep, pIter->azTblCol[i], pIter->azTblCol[i], i+1
210738 zList, zSep, pIter->azTblCol[i], pIter->azTblCol[i], i+1
210790 static char *rbuWithoutRowidPK(sqlite3rbu *p, RbuObjIter *pIter){
210792 assert( pIter->zIdx==0 );
210795 sqlite3_stmt *pXList = 0; /* PRAGMA index_list = (pIter->zTbl) */
210799 sqlite3_mprintf("PRAGMA main.index_list = %Q", pIter->zTbl)
210849 static void rbuCreateImposterTable2(sqlite3rbu *p, RbuObjIter *pIter){
210850 if( p->rc==SQLITE_OK && pIter->eType==RBU_PK_EXTERNAL ){
210851 int tnum = pIter->iPkTnum; /* Root page of PK index */
210885 iCid, pIter->azTblType[iCid], zCollate
210923 static void rbuCreateImposterTable(sqlite3rbu *p, RbuObjIter *pIter){
210924 if( p->rc==SQLITE_OK && pIter->eType!=RBU_PK_VTAB ){
210925 int tnum = pIter->iTnum;
210931 for(iCol=0; p->rc==SQLITE_OK && iCol<pIter->nTblCol; iCol++){
210933 const char *zCol = pIter->azTblCol[iCol];
210937 p->dbMain, "main", pIter->zTbl, zCol, 0, &zColl, 0, 0, 0
210940 if( pIter->eType==RBU_PK_IPK && pIter->abTblPk[iCol] ){
210946 zSql, zComma, zCol, pIter->azTblType[iCol], zPk, zColl,
210947 (pIter->abNotNull[iCol] ? " NOT NULL" : "")
210952 if( pIter->eType==RBU_PK_WITHOUT_ROWID ){
210953 char *zPk = rbuWithoutRowidPK(p, pIter);
210961 pIter->zTbl, zSql,
210962 (pIter->eType==RBU_PK_WITHOUT_ROWID ? " WITHOUT ROWID" : "")
210981 RbuObjIter *pIter,
210985 int bRbuRowid = (pIter->eType==RBU_PK_EXTERNAL || pIter->eType==RBU_PK_NONE);
210986 char *zBind = rbuObjIterGetBindlist(p, pIter->nTblCol + 1 + bRbuRowid);
210988 assert( pIter->pTmpInsert==0 );
210990 p->dbRbu, &pIter->pTmpInsert, &p->zErrmsg, sqlite3_mprintf(
210992 p->zStateDb, pIter->zDataTbl, zCollist, zRbuRowid, zBind
211027 static char *rbuObjIterGetIndexWhere(sqlite3rbu *p, RbuObjIter *pIter){
211032 assert( pIter->zIdxSql==0 && pIter->nIdxCol==0 && pIter->aIdxCol==0 );
211041 rc = sqlite3_bind_text(pStmt, 1, pIter->zIdx, -1, SQLITE_STATIC);
211045 pIter->zIdxSql = zSql = rbuStrndup(zSql, &rc);
211055 /* If necessary, grow the pIter->aIdxCol[] array */
211058 pIter->aIdxCol, (nIdxAlloc+16)*sizeof(RbuSpan)
211064 pIter->aIdxCol = aIdxCol;
211071 pIter->aIdxCol[0].zSpan = &zSql[i+1];
211078 int nSpan = &zSql[i] - pIter->aIdxCol[iIdxCol].zSpan;
211079 pIter->aIdxCol[iIdxCol++].nSpan = nSpan;
211084 int nSpan = &zSql[i] - pIter->aIdxCol[iIdxCol].zSpan;
211085 pIter->aIdxCol[iIdxCol++].nSpan = nSpan;
211086 pIter->aIdxCol[iIdxCol].zSpan = &zSql[i+1];
211110 pIter->nIdxCol = iIdxCol;
211129 RbuObjIter *pIter,
211132 assert( pIter->bCleanup==0 );
211133 if( pIter->pSelect==0 && rbuObjIterCacheTableInfo(p, pIter)==SQLITE_OK ){
211134 const int tnum = pIter->iTnum;
211137 const char *zIdx = pIter->zIdx;
211146 const char *zTbl = pIter->zTbl;
211154 assert( pIter->eType!=RBU_PK_VTAB );
211155 zPart = rbuObjIterGetIndexWhere(p, pIter);
211157 p, pIter, &zImposterCols, &zImposterPK, &zWhere, &nBind
211171 pIter->nCol = nBind;
211174 p->dbMain, &pIter->pInsert, &p->zErrmsg,
211182 p->dbMain, &pIter->pDelete, &p->zErrmsg,
211193 zStart = rbuVacuumIndexStart(p, pIter);
211203 pIter->zDataTbl,
211211 if( pIter->eType==RBU_PK_EXTERNAL || pIter->eType==RBU_PK_NONE ){
211214 zCollist, p->zStateDb, pIter->zDataTbl,
211224 zCollist, p->zStateDb, pIter->zDataTbl, zPart,
211225 zCollist, pIter->zDataTbl,
211232 p->rc = prepareFreeAndCollectError(p->dbRbu,&pIter->pSelect,pz,zSql);
211244 int bRbuRowid = (pIter->eType==RBU_PK_VTAB)
211245 ||(pIter->eType==RBU_PK_NONE)
211246 ||(pIter->eType==RBU_PK_EXTERNAL && rbuIsVacuum(p));
211247 const char *zTbl = pIter->zTbl; /* Table this step applies to */
211250 char *zBindings = rbuObjIterGetBindlist(p, pIter->nTblCol + bRbuRowid);
211251 char *zWhere = rbuObjIterGetWhere(p, pIter);
211252 char *zOldlist = rbuObjIterGetOldlist(p, pIter, "old");
211253 char *zNewlist = rbuObjIterGetOldlist(p, pIter, "new");
211255 zCollist = rbuObjIterGetCollist(p, pIter);
211256 pIter->nCol = pIter->nTblCol;
211259 rbuCreateImposterTable(p, pIter);
211260 rbuCreateImposterTable2(p, pIter);
211261 zWrite = (pIter->eType==RBU_PK_VTAB ? "" : "rbu_imp_");
211265 p->rc = prepareFreeAndCollectError(p->dbMain, &pIter->pInsert, pz,
211277 p->rc = prepareFreeAndCollectError(p->dbMain, &pIter->pDelete, pz,
211284 if( rbuIsVacuum(p)==0 && pIter->abIndexed ){
211286 if( pIter->eType==RBU_PK_EXTERNAL || pIter->eType==RBU_PK_NONE ){
211294 , p->zStateDb, pIter->zDataTbl
211295 , (pIter->eType==RBU_PK_EXTERNAL ? ", 0 AS rbu_rowid" : "")
211296 , pIter->zDataTbl
211319 if( pIter->eType==RBU_PK_EXTERNAL || pIter->eType==RBU_PK_NONE ){
211329 rbuObjIterPrepareTmpInsert(p, pIter, zCollist, zRbuRowid);
211343 zStart = rbuVacuumTableStart(p, pIter, bRbuRowid, zWrite);
211352 zOrder = rbuObjIterGetPkList(p, pIter, "", ", ", "");
211357 p->rc = prepareFreeAndCollectError(p->dbRbu, &pIter->pSelect, pz,
211363 pIter->zDataTbl, (zStart ? zStart : ""),
211388 ** table object that pIter currently points to, assuming that the
211396 RbuObjIter *pIter, /* Object iterator */
211411 for(pp=&pIter->pRbuUpdate; *pp; pp=&((*pp)->pNext)){
211415 pUp->pNext = pIter->pRbuUpdate;
211416 pIter->pRbuUpdate = pUp;
211425 for(pp=&pIter->pRbuUpdate; *pp!=pUp; pp=&((*pp)->pNext));
211430 pUp = (RbuUpdateStmt*)rbuMalloc(p, sizeof(RbuUpdateStmt)+pIter->nTblCol+1);
211434 char *zWhere = rbuObjIterGetWhere(p, pIter);
211435 char *zSet = rbuObjIterGetSetlist(p, pIter, zMask);
211439 memcpy(pUp->zMask, zMask, pIter->nTblCol);
211440 pUp->pNext = pIter->pRbuUpdate;
211441 pIter->pRbuUpdate = pUp;
211446 if( pIter->eType!=RBU_PK_VTAB ) zPrefix = "rbu_imp_";
211448 zPrefix, pIter->zTbl, zSet, zWhere
212150 RbuObjIter *pIter = &p->objiter;
212156 assert( eType!=RBU_DELETE || pIter->zIdx==0 );
212170 pWriter = pIter->pDelete;
212172 pWriter = pIter->pInsert;
212175 for(i=0; i<pIter->nCol; i++){
212180 && pIter->zIdx==0 && pIter->eType==RBU_PK_IPK && pIter->abTblPk[i]
212181 && sqlite3_column_type(pIter->pSelect, i)==SQLITE_NULL
212188 if( eType==RBU_DELETE && pIter->abTblPk[i]==0 ){
212192 pVal = sqlite3_column_value(pIter->pSelect, i);
212196 if( pIter->zIdx==0 ){
212197 if( pIter->eType==RBU_PK_VTAB
212198 || pIter->eType==RBU_PK_NONE
212199 || (pIter->eType==RBU_PK_EXTERNAL && rbuIsVacuum(p))
212206 ** Hence column_value(pIter->nCol+1).
212208 assertColumnName(pIter->pSelect, pIter->nCol+1,
212211 pVal = sqlite3_column_value(pIter->pSelect, pIter->nCol+1);
212212 p->rc = sqlite3_bind_value(pWriter, pIter->nCol+1, pVal);
212233 RbuObjIter *pIter = &p->objiter;
212242 assert( eType!=RBU_UPDATE || pIter->zIdx==0 );
212244 if( pIter->zIdx==0 && (eType==RBU_IDX_DELETE || eType==RBU_IDX_INSERT) ){
212248 if( pIter->zIdx==0 ){
212262 rbuGetUpdateStmt(p, pIter, zMask, &pUpdate);
212265 for(i=0; p->rc==SQLITE_OK && i<pIter->nCol; i++){
212266 char c = zMask[pIter->aiSrcOrder[i]];
212267 pVal = sqlite3_column_value(pIter->pSelect, i);
212268 if( pIter->abTblPk[i] || c!='.' ){
212273 && (pIter->eType==RBU_PK_VTAB || pIter->eType==RBU_PK_NONE)
212276 assertColumnName(pIter->pSelect, pIter->nCol+1, "rbu_rowid");
212277 pVal = sqlite3_column_value(pIter->pSelect, pIter->nCol+1);
212278 p->rc = sqlite3_bind_value(pUpdate, pIter->nCol+1, pVal);
212465 RbuObjIter *pIter = &p->objiter;
212475 while( p->rc==SQLITE_OK && pIter->zTbl ){
212477 if( pIter->bCleanup ){
212481 if( rbuIsVacuum(p)==0 && pIter->abIndexed ){
212483 "DELETE FROM %s.'rbu_tmp_%q'", p->zStateDb, pIter->zDataTbl
212487 rbuObjIterPrepareAll(p, pIter, 0);
212491 int rc = sqlite3_step(pIter->pSelect);
212497 p->rc = sqlite3_reset(pIter->pSelect);
212502 rbuObjIterNext(p, pIter);
212506 assert( pIter->zTbl==0 );
212609 RbuObjIter *pIter = &p->objiter;
212612 while( rc==SQLITE_OK && pIter->zTbl && (pIter->bCleanup
212613 || rbuStrCompare(pIter->zIdx, pState->zIdx)
212614 || (pState->zDataTbl==0 && rbuStrCompare(pIter->zTbl, pState->zTbl))
212615 || (pState->zDataTbl && rbuStrCompare(pIter->zDataTbl, pState->zDataTbl))
212617 rc = rbuObjIterNext(p, pIter);
212620 if( rc==SQLITE_OK && !pIter->zTbl ){
213329 rbu_file *pIter;
213333 for(pIter=pRbuVfs->pMain; pIter; pIter=pIter->pMainNext);
213337 for(pIter=pRbuVfs->pMainRbu; pIter && pIter!=p; pIter=pIter->pMainRbuNext){}
213338 if( pIter==0 ){
218919 sqlite3_changeset_iter *pIter, /* Iterator handle */
218925 *pOp = pIter->op;
218926 *pnCol = pIter->nCol;
218927 *pzTab = pIter->zTab;
218928 if( pbIndirect ) *pbIndirect = pIter->bIndirect;
218934 ** the database table affected by the change that pIter currently points
218939 sqlite3_changeset_iter *pIter, /* Iterator object */
218943 *pabPK = pIter->abPK;
218944 if( pnCol ) *pnCol = pIter->nCol;
218962 sqlite3_changeset_iter *pIter, /* Changeset iterator */
218966 if( pIter->op!=SQLITE_UPDATE && pIter->op!=SQLITE_DELETE ){
218969 if( iVal<0 || iVal>=pIter->nCol ){
218972 *ppValue = pIter->apValue[iVal];
218990 sqlite3_changeset_iter *pIter, /* Changeset iterator */
218994 if( pIter->op!=SQLITE_UPDATE && pIter->op!=SQLITE_INSERT ){
218997 if( iVal<0 || iVal>=pIter->nCol ){
219000 *ppValue = pIter->apValue[pIter->nCol+iVal];
219009 #define sessionChangesetNew(pIter, iVal) (pIter)->apValue[(pIter)->nCol+(iVal)]
219010 #define sessionChangesetOld(pIter, iVal) (pIter)->apValue[(iVal)]
219024 sqlite3_changeset_iter *pIter, /* Changeset iterator */
219028 if( !pIter->pConflict ){
219031 if( iVal<0 || iVal>=pIter->nCol ){
219034 *ppValue = sqlite3_column_value(pIter->pConflict, iVal);
219047 sqlite3_changeset_iter *pIter, /* Changeset iterator */
219050 if( pIter->pConflict || pIter->apValue ){
219053 *pnOut = pIter->nCol;
219314 sqlite3_changeset_iter *pIter,
219321 int nCol = pIter->nCol;
219322 int nU32 = (pIter->nCol+33)/32;
219335 for(ii=0; ii<pIter->nCol; ii++){
219336 if( sessionChangesetNew(pIter, ii) ){
219374 int bStat1 = (sqlite3_stricmp(pIter->zTab, "sqlite_stat1")==0);
219387 sessionAppendIdent(&buf, pIter->zTab, &rc);
219391 for(ii=0; ii<pIter->nCol; ii++){
219392 if( p->abPK[ii]==0 && sessionChangesetNew(pIter, ii) ){
219404 for(ii=0; ii<pIter->nCol; ii++){
219405 if( p->abPK[ii] || (bPatchset==0 && sessionChangesetOld(pIter, ii)) ){
219648 ** Iterator pIter must point to an SQLITE_INSERT entry. This function
219662 sqlite3_changeset_iter *pIter, /* Iterator to read values from */
219680 (void)xValue(pIter, i, &pVal);
219696 ** iterator pIter points to to the SELECT and attempts to seek to the table
219712 sqlite3_changeset_iter *pIter, /* Changeset iterator */
219721 sqlite3changeset_op(pIter, &zDummy, &nCol, &op, 0);
219722 rc = sessionBindRow(pIter,
219748 sqlite3_changeset_iter *pIter /* Iterator pointing at current change */
219753 int eOp = pIter->op;
219756 const char *zTab = pIter->zTab;
219774 sqlite3changeset_old(pIter, i, &pVal);
219776 sqlite3changeset_new(pIter, i, &pVal);
219822 sqlite3_changeset_iter *pIter, /* Changeset iterator */
219833 sqlite3changeset_op(pIter, &zDummy, &nCol, &op, 0);
219841 rc = sessionSeekToRow(p->db, pIter, p->abPK, p->pSelect);
219848 pIter->pConflict = p->pSelect;
219849 res = xConflict(pCtx, eType, pIter);
219850 pIter->pConflict = 0;
219856 u8 *aBlob = &pIter->in.aData[pIter->in.iCurrent];
219857 int nBlob = pIter->in.iNext - pIter->in.iCurrent;
219862 res = xConflict(pCtx, eType+1, pIter);
219886 rc = sessionRebaseAdd(p, res, pIter);
219918 sqlite3_changeset_iter *pIter, /* Changeset iterator */
219934 sqlite3changeset_op(pIter, &zDummy, &nCol, &op, 0);
219949 u8 *abPK = (pIter->bPatchset ? p->abPK : 0);
219950 rc = sessionBindRow(pIter, sqlite3changeset_old, nCol, abPK, p->pDelete);
219960 SQLITE_CHANGESET_DATA, p, pIter, xConflict, pCtx, pbRetry
219964 SQLITE_CHANGESET_CONFLICT, p, pIter, xConflict, pCtx, 0
219971 int bPatchset = (pbRetry==0 || pIter->bPatchset);
219973 rc = sessionUpdateFind(pIter, p, bPatchset, &pUp);
219977 sqlite3_value *pOld = sessionChangesetOld(pIter, i);
219978 sqlite3_value *pNew = sessionChangesetNew(pIter, i);
219999 SQLITE_CHANGESET_DATA, p, pIter, xConflict, pCtx, pbRetry
220005 SQLITE_CHANGESET_CONFLICT, p, pIter, xConflict, pCtx, 0
220015 rc = sessionSeekToRow(p->db, pIter, p->abPK, p->pSelect);
220023 rc = sessionBindRow(pIter, sqlite3changeset_new, nCol, 0, p->pInsert);
220032 SQLITE_CHANGESET_CONFLICT, p, pIter, xConflict, pCtx, pbReplace
220052 sqlite3_changeset_iter *pIter, /* Changeset iterator to read change from */
220061 rc = sessionApplyOneOp(pIter, pApply, xConflict, pCtx, &bReplace, &bRetry);
220071 assert( pIter->op==SQLITE_UPDATE || pIter->op==SQLITE_DELETE );
220072 rc = sessionApplyOneOp(pIter, pApply, xConflict, pCtx, 0, 0);
220081 assert( pIter->op==SQLITE_INSERT );
220084 rc = sessionBindRow(pIter,
220093 rc = sessionApplyOneOp(pIter, pApply, xConflict, pCtx, 0, 0);
220157 ** Argument pIter is a changeset iterator that has been initialized, but
220165 sqlite3_changeset_iter *pIter, /* Changeset to apply */
220188 pIter->in.bNoDiscard = 1;
220199 while( rc==SQLITE_OK && SQLITE_ROW==sqlite3changeset_next(pIter) ){
220204 sqlite3changeset_op(pIter, &zNew, &nCol, &op, 0);
220210 db, pIter->bPatchset, zTab, &sApply, xConflict, pCtx
220247 sqlite3changeset_pk(pIter, &abPK, 0);
220301 rc = sessionApplyOneWithRetry(db, pIter, &sApply, xConflict, pCtx);
220304 bPatchset = pIter->bPatchset;
220306 rc = sqlite3changeset_finalize(pIter);
220308 sqlite3changeset_finalize(pIter);
220378 sqlite3_changeset_iter *pIter; /* Iterator to skip through changeset */
220380 int rc = sessionChangesetStart(&pIter, 0, 0, nChangeset, pChangeset, bInv, 1);
220383 db, pIter, xFilter, xConflict, pCtx, ppRebase, pnRebase, flags
220436 sqlite3_changeset_iter *pIter; /* Iterator to skip through changeset */
220438 int rc = sessionChangesetStart(&pIter, xInput, pIn, 0, 0, bInverse, 1);
220441 db, pIter, xFilter, xConflict, pCtx, ppRebase, pnRebase, flags
220663 sqlite3_changeset_iter *pIter, /* Iterator to read from */
220672 while( SQLITE_ROW==sessionChangesetNext(pIter, &aRec, &nRec, 0) ){
220683 pGrp->bPatch = pIter->bPatchset;
220684 }else if( pIter->bPatchset!=pGrp->bPatch ){
220689 sqlite3changeset_op(pIter, &zNew, &nCol, &op, &bIndirect);
220695 sqlite3changeset_pk(pIter, &abPK, 0);
220726 if( sessionGrowHash(0, pIter->bPatchset, pTab) ){
220731 pTab, (pIter->bPatchset && op==SQLITE_DELETE), aRec, pTab->nChange
220740 if( pIter->bPatchset ){
220753 pIter->bPatchset, pExist, op, bIndirect, aRec, nRec, &pChange
220763 if( rc==SQLITE_OK ) rc = pIter->rc;
220854 sqlite3_changeset_iter *pIter; /* Iterator opened on pData/nData */
220857 rc = sqlite3changeset_start(&pIter, nData, pData);
220859 rc = sessionChangesetToHash(pIter, pGrp, 0);
220861 sqlite3changeset_finalize(pIter);
220885 sqlite3_changeset_iter *pIter; /* Iterator opened on pData/nData */
220888 rc = sqlite3changeset_start_strm(&pIter, xInput, pIn);
220890 rc = sessionChangesetToHash(pIter, pGrp, 0);
220892 sqlite3changeset_finalize(pIter);
221039 sqlite3_changeset_iter *pIter, /* Iterator pointed at local change */
221053 *pOut++ = pIter->bIndirect;
221054 for(i=0; i<pIter->nCol; i++){
221057 if( pIter->abPK[i] || a2[0]==0 ){
221058 if( !pIter->abPK[i] && a1[0] ) bData = 1;
221073 for(i=0; i<pIter->nCol; i++){
221076 if( pIter->abPK[i] || a2[0]!=0xFF ){
221091 ** pIter is configured to iterate through a changeset. This function rebases
221107 sqlite3_changeset_iter *pIter, /* Input data */
221120 while( SQLITE_ROW==sessionChangesetNext(pIter, &aRec, &nRec, &bNew) ){
221125 const char *zTab = pIter->zTab;
221132 if( pIter->bPatchset ){
221137 sessionAppendByte(&sOut, pIter->bPatchset ? 'P' : 'T', &rc);
221138 sessionAppendVarint(&sOut, pIter->nCol, &rc);
221139 sessionAppendBlob(&sOut, pIter->abPK, pIter->nCol, &rc);
221140 sessionAppendBlob(&sOut,(u8*)pIter->zTab,(int)strlen(pIter->zTab)+1,&rc);
221155 switch( pIter->op ){
221161 sessionAppendByte(&sOut, pIter->bIndirect, &rc);
221173 sessionSkipRecord(&pCsr, pIter->nCol);
221175 sessionAppendByte(&sOut, pIter->bIndirect, &rc);
221176 sessionAppendRecordMerge(&sOut, pIter->nCol,
221182 sessionAppendPartialUpdate(&sOut, pIter,
221189 assert( pIter->op==SQLITE_DELETE );
221193 sessionAppendByte(&sOut, pIter->bIndirect, &rc);
221194 sessionAppendRecordMerge(&sOut, pIter->nCol,
221203 sessionAppendByte(&sOut, pIter->op, &rc);
221204 sessionAppendByte(&sOut, pIter->bIndirect, &rc);
221258 sqlite3_changeset_iter *pIter = 0; /* Iterator opened on pData/nData */
221260 rc = sqlite3changeset_start(&pIter, nRebase, (void*)pRebase);
221262 rc = sessionChangesetToHash(pIter, &p->grp, 1);
221264 sqlite3changeset_finalize(pIter);
221276 sqlite3_changeset_iter *pIter = 0; /* Iterator to skip through input */
221277 int rc = sqlite3changeset_start(&pIter, nIn, (void*)pIn);
221280 rc = sessionRebase(p, pIter, 0, 0, pnOut, ppOut);
221281 sqlite3changeset_finalize(pIter);
221297 sqlite3_changeset_iter *pIter = 0; /* Iterator to skip through input */
221298 int rc = sqlite3changeset_start_strm(&pIter, xInput, pIn);
221301 rc = sessionRebase(p, pIter, xOutput, pOut, 0, 0);
221302 sqlite3changeset_finalize(pIter);
222250 Fts5PoslistReader *pIter /* Iterator object to initialize */
224336 static int fts5CInstIterNext(CInstIter *pIter){
224338 pIter->iStart = -1;
224339 pIter->iEnd = -1;
224341 while( rc==SQLITE_OK && pIter->iInst<pIter->nInst ){
224343 rc = pIter->pApi->xInst(pIter->pFts, pIter->iInst, &ip, &ic, &io);
224345 if( ic==pIter->iCol ){
224346 int iEnd = io - 1 + pIter->pApi->xPhraseSize(pIter->pFts, ip);
224347 if( pIter->iStart<0 ){
224348 pIter->iStart = io;
224349 pIter->iEnd = iEnd;
224350 }else if( io<=pIter->iEnd ){
224351 if( iEnd>pIter->iEnd ) pIter->iEnd = iEnd;
224356 pIter->iInst++;
224371 CInstIter *pIter
224375 memset(pIter, 0, sizeof(CInstIter));
224376 pIter->pApi = pApi;
224377 pIter->pFts = pFts;
224378 pIter->iCol = iCol;
224379 rc = pApi->xInstCount(pFts, &pIter->nInst);
224382 rc = fts5CInstIterNext(pIter);
225206 static int sqlite3Fts5PoslistReaderNext(Fts5PoslistReader *pIter){
225207 if( sqlite3Fts5PoslistNext64(pIter->a, pIter->n, &pIter->i, &pIter->iPos) ){
225208 pIter->bEof = 1;
225210 return pIter->bEof;
225215 Fts5PoslistReader *pIter /* Iterator object to initialize */
225217 memset(pIter, 0, sizeof(*pIter));
225218 pIter->a = a;
225219 pIter->n = n;
225220 sqlite3Fts5PoslistReaderNext(pIter);
225221 return pIter->bEof;
226466 Fts5IndexIter *pIter; /* Iterator for this term */
226813 if( 0==sqlite3Fts5IterEof(p->pIter) ){
226814 i64 iRowid = p->pIter->iRowid;
226844 Fts5IndexIter *pIter = p->pIter;
226845 if( sqlite3Fts5IterEof(pIter)==0 && pIter->iRowid==iRowid ){
226846 if( pIter->nData==0 ) continue;
226859 sqlite3Fts5PoslistReaderInit(pIter->pData, pIter->nData, &aIter[nIter]);
226950 a = (u8*)pTerm->pIter->pData;
226951 n = pTerm->pIter->nData;
227141 ** Advance iterator pIter until it points to a value equal to or laster
227150 Fts5IndexIter *pIter, /* Iterator to advance */
227159 iRowid = pIter->iRowid;
227161 int rc = sqlite3Fts5IterNextFrom(pIter, iLast);
227162 if( rc || sqlite3Fts5IterEof(pIter) ){
227167 iRowid = pIter->iRowid;
227187 if( sqlite3Fts5IterEof(p->pIter)==0 ){
227188 i64 iRowid = p->pIter->iRowid;
227190 rc = sqlite3Fts5IterNextFrom(p->pIter, iLast);
227218 Fts5IndexIter *pIter = pTerm->pIter;
227219 if( sqlite3Fts5IterEof(pIter)==0 ){
227220 if( pIter->iRowid==pNode->iRowid && pIter->nData>0 ){
227241 Fts5IndexIter *pIter = pPhrase->aTerm[0].pIter;
227242 fts5BufferSet(&rc, &pPhrase->poslist, pIter->nData, pIter->pData);
227286 if( p->pIter ){
227287 sqlite3Fts5IterClose(p->pIter);
227288 p->pIter = 0;
227295 &p->pIter
227297 assert( (rc==SQLITE_OK)==(p->pIter!=0) );
227299 if( 0==sqlite3Fts5IterEof(p->pIter) ){
227427 iLast = pLeft->aTerm[0].pIter->iRowid;
227446 Fts5IndexIter *pIter = pPhrase->aTerm[j].pIter;
227447 if( pIter->iRowid==iLast || pIter->bEof ) continue;
227449 if( fts5ExprAdvanceto(pIter, bDesc, &iLast, &rc, &pNode->bEof) ){
227491 if( sqlite3Fts5IterEof(p->pIter)==0 ){
227492 i64 ii = p->pIter->iRowid;
227497 rc = sqlite3Fts5IterNextFrom(p->pIter, iFrom);
227499 rc = sqlite3Fts5IterNext(p->pIter);
227502 if( sqlite3Fts5IterEof(p->pIter)==0 ){
227515 Fts5IndexIter *pIter = pTerm->pIter;
227519 rc = sqlite3Fts5IterNextFrom(pIter, iFrom);
227521 rc = sqlite3Fts5IterNext(pIter);
227524 pNode->bEof = (rc || sqlite3Fts5IterEof(pIter));
227546 Fts5IndexIter *pIter = pPhrase->aTerm[0].pIter;
227552 pPhrase->poslist.n = pIter->nData;
227554 pPhrase->poslist.p = (u8*)pIter->pData;
227556 pNode->iRowid = pIter->iRowid;
227571 Fts5IndexIter *pIter = pNode->pNear->apPhrase[0]->aTerm[0].pIter;
227575 rc = sqlite3Fts5IterNextFrom(pIter, iFrom);
227577 rc = sqlite3Fts5IterNext(pIter);
227579 if( rc==SQLITE_OK && sqlite3Fts5IterEof(pIter)==0 ){
227929 sqlite3Fts5IterClose(pTerm->pIter);
227932 sqlite3Fts5IterClose(pSyn->pIter);
229434 *ppCollist = pPhrase->aTerm[0].pIter->pData;
229435 *pnCollist = pPhrase->aTerm[0].pIter->nData;
229901 Fts5HashEntry *pIter;
229902 for(pIter=pHash->aSlot[iSlot]; pIter; pIter=pIter->pHashNext){
229904 || (pIter->nKey+1>=nTerm && 0==memcmp(fts5EntryKey(pIter), pTerm, nTerm))
229906 Fts5HashEntry *pEntry = pIter;
231370 static int fts5DlidxIterNextR(Fts5Index *p, Fts5DlidxIter *pIter, int iLvl){
231371 Fts5DlidxLvl *pLvl = &pIter->aLvl[iLvl];
231373 assert( iLvl<pIter->nLvl );
231375 if( (iLvl+1) < pIter->nLvl ){
231376 fts5DlidxIterNextR(p, pIter, iLvl+1);
231381 FTS5_DLIDX_ROWID(pIter->iSegid, iLvl, pLvl[1].iLeafPgno)
231388 return pIter->aLvl[0].bEof;
231390 static int fts5DlidxIterNext(Fts5Index *p, Fts5DlidxIter *pIter){
231391 return fts5DlidxIterNextR(p, pIter, 0);
231402 ** When this function is called pIter->iLeafPgno is the page number the
231405 static int fts5DlidxIterFirst(Fts5DlidxIter *pIter){
231407 for(i=0; i<pIter->nLvl; i++){
231408 fts5DlidxLvlNext(&pIter->aLvl[i]);
231410 return pIter->aLvl[0].bEof;
231414 static int fts5DlidxIterEof(Fts5Index *p, Fts5DlidxIter *pIter){
231415 return p->rc!=SQLITE_OK || pIter->aLvl[0].bEof;
231418 static void fts5DlidxIterLast(Fts5Index *p, Fts5DlidxIter *pIter){
231422 for(i=pIter->nLvl-1; p->rc==SQLITE_OK && i>=0; i--){
231423 Fts5DlidxLvl *pLvl = &pIter->aLvl[i];
231432 FTS5_DLIDX_ROWID(pIter->iSegid, i-1, pLvl->iLeafPgno)
231490 static int fts5DlidxIterPrevR(Fts5Index *p, Fts5DlidxIter *pIter, int iLvl){
231491 Fts5DlidxLvl *pLvl = &pIter->aLvl[iLvl];
231493 assert( iLvl<pIter->nLvl );
231495 if( (iLvl+1) < pIter->nLvl ){
231496 fts5DlidxIterPrevR(p, pIter, iLvl+1);
231501 FTS5_DLIDX_ROWID(pIter->iSegid, iLvl, pLvl[1].iLeafPgno)
231511 return pIter->aLvl[0].bEof;
231513 static int fts5DlidxIterPrev(Fts5Index *p, Fts5DlidxIter *pIter){
231514 return fts5DlidxIterPrevR(p, pIter, 0);
231520 static void fts5DlidxIterFree(Fts5DlidxIter *pIter){
231521 if( pIter ){
231523 for(i=0; i<pIter->nLvl; i++){
231524 fts5DataRelease(pIter->aLvl[i].pData);
231526 sqlite3_free(pIter);
231536 Fts5DlidxIter *pIter = 0;
231544 pNew = (Fts5DlidxIter*)sqlite3_realloc64(pIter, nByte);
231550 pIter = pNew;
231556 pIter->nLvl = i+1;
231561 pIter->iSegid = iSegid;
231563 fts5DlidxIterFirst(pIter);
231565 fts5DlidxIterLast(p, pIter);
231570 fts5DlidxIterFree(pIter);
231571 pIter = 0;
231574 return pIter;
231577 static i64 fts5DlidxIterRowid(Fts5DlidxIter *pIter){
231578 return pIter->aLvl[0].iRowid;
231580 static int fts5DlidxIterPgno(Fts5DlidxIter *pIter){
231581 return pIter->aLvl[0].iLeafPgno;
231589 Fts5SegIter *pIter /* Iterator to advance to next page */
231592 Fts5StructureSegment *pSeg = pIter->pSeg;
231593 fts5DataRelease(pIter->pLeaf);
231594 pIter->iLeafPgno++;
231595 if( pIter->pNextLeaf ){
231596 pIter->pLeaf = pIter->pNextLeaf;
231597 pIter->pNextLeaf = 0;
231598 }else if( pIter->iLeafPgno<=pSeg->pgnoLast ){
231599 pIter->pLeaf = fts5LeafRead(p,
231600 FTS5_SEGMENT_ROWID(pSeg->iSegid, pIter->iLeafPgno)
231603 pIter->pLeaf = 0;
231605 pLeaf = pIter->pLeaf;
231608 pIter->iPgidxOff = pLeaf->szLeaf;
231610 pIter->iEndofDoclist = pLeaf->nn+1;
231612 pIter->iPgidxOff += fts5GetVarint32(&pLeaf->p[pIter->iPgidxOff],
231613 pIter->iEndofDoclist
231646 static void fts5SegIterLoadNPos(Fts5Index *p, Fts5SegIter *pIter){
231648 int iOff = pIter->iLeafOffset; /* Offset to read at */
231649 ASSERT_SZLEAF_OK(pIter->pLeaf);
231651 int iEod = MIN(pIter->iEndofDoclist, pIter->pLeaf->szLeaf);
231652 pIter->bDel = 0;
231653 pIter->nPos = 1;
231654 if( iOff<iEod && pIter->pLeaf->p[iOff]==0 ){
231655 pIter->bDel = 1;
231657 if( iOff<iEod && pIter->pLeaf->p[iOff]==0 ){
231658 pIter->nPos = 1;
231661 pIter->nPos = 0;
231666 fts5FastGetVarint32(pIter->pLeaf->p, iOff, nSz);
231667 pIter->bDel = (nSz & 0x0001);
231668 pIter->nPos = nSz>>1;
231669 assert_nc( pIter->nPos>=0 );
231671 pIter->iLeafOffset = iOff;
231675 static void fts5SegIterLoadRowid(Fts5Index *p, Fts5SegIter *pIter){
231676 u8 *a = pIter->pLeaf->p; /* Buffer to read data from */
231677 i64 iOff = pIter->iLeafOffset;
231679 ASSERT_SZLEAF_OK(pIter->pLeaf);
231680 if( iOff>=pIter->pLeaf->szLeaf ){
231681 fts5SegIterNextPage(p, pIter);
231682 if( pIter->pLeaf==0 ){
231687 a = pIter->pLeaf->p;
231689 iOff += sqlite3Fts5GetVarint(&a[iOff], (u64*)&pIter->iRowid);
231690 pIter->iLeafOffset = iOff;
231708 static void fts5SegIterLoadTerm(Fts5Index *p, Fts5SegIter *pIter, int nKeep){
231709 u8 *a = pIter->pLeaf->p; /* Buffer to read data from */
231710 i64 iOff = pIter->iLeafOffset; /* Offset to read at */
231714 if( iOff+nNew>pIter->pLeaf->szLeaf || nKeep>pIter->term.n || nNew==0 ){
231718 pIter->term.n = nKeep;
231719 fts5BufferAppendBlob(&p->rc, &pIter->term, nNew, &a[iOff]);
231720 assert( pIter->term.n<=pIter->term.nSpace );
231722 pIter->iTermLeafOffset = iOff;
231723 pIter->iTermLeafPgno = pIter->iLeafPgno;
231724 pIter->iLeafOffset = iOff;
231726 if( pIter->iPgidxOff>=pIter->pLeaf->nn ){
231727 pIter->iEndofDoclist = pIter->pLeaf->nn+1;
231730 pIter->iPgidxOff += fts5GetVarint32(&a[pIter->iPgidxOff], nExtra);
231731 pIter->iEndofDoclist += nExtra;
231734 fts5SegIterLoadRowid(p, pIter);
231741 static void fts5SegIterSetNext(Fts5Index *p, Fts5SegIter *pIter){
231742 if( pIter->flags & FTS5_SEGITER_REVERSE ){
231743 pIter->xNext = fts5SegIterNext_Reverse;
231745 pIter->xNext = fts5SegIterNext_None;
231747 pIter->xNext = fts5SegIterNext;
231752 ** Initialize the iterator object pIter to iterate through the entries in
231762 Fts5SegIter *pIter /* Object to populate */
231768 ** The caller will see the (pIter->pLeaf==0) and assume the iterator is
231770 assert( pIter->pLeaf==0 );
231775 memset(pIter, 0, sizeof(*pIter));
231776 fts5SegIterSetNext(p, pIter);
231777 pIter->pSeg = pSeg;
231778 pIter->iLeafPgno = pSeg->pgnoFirst-1;
231779 fts5SegIterNextPage(p, pIter);
231783 pIter->iLeafOffset = 4;
231784 assert( pIter->pLeaf!=0 );
231785 assert_nc( pIter->pLeaf->nn>4 );
231786 assert_nc( fts5LeafFirstTermOff(pIter->pLeaf)==4 );
231787 pIter->iPgidxOff = pIter->pLeaf->szLeaf+1;
231788 fts5SegIterLoadTerm(p, pIter, 0);
231789 fts5SegIterLoadNPos(p, pIter);
231808 static void fts5SegIterReverseInitPage(Fts5Index *p, Fts5SegIter *pIter){
231810 int n = pIter->pLeaf->szLeaf;
231811 int i = pIter->iLeafOffset;
231812 u8 *a = pIter->pLeaf->p;
231815 if( n>pIter->iEndofDoclist ){
231816 n = pIter->iEndofDoclist;
231819 ASSERT_SZLEAF_OK(pIter->pLeaf);
231837 pIter->iRowid += iDelta;
231839 /* If necessary, grow the pIter->aRowidOffset[] array. */
231840 if( iRowidOffset>=pIter->nRowidOffset ){
231841 int nNew = pIter->nRowidOffset + 8;
231842 int *aNew = (int*)sqlite3_realloc64(pIter->aRowidOffset,nNew*sizeof(int));
231847 pIter->aRowidOffset = aNew;
231848 pIter->nRowidOffset = nNew;
231851 pIter->aRowidOffset[iRowidOffset++] = pIter->iLeafOffset;
231852 pIter->iLeafOffset = i;
231854 pIter->iRowidOffset = iRowidOffset;
231855 fts5SegIterLoadNPos(p, pIter);
231861 static void fts5SegIterReverseNewPage(Fts5Index *p, Fts5SegIter *pIter){
231862 assert( pIter->flags & FTS5_SEGITER_REVERSE );
231863 assert( pIter->flags & FTS5_SEGITER_ONETERM );
231865 fts5DataRelease(pIter->pLeaf);
231866 pIter->pLeaf = 0;
231867 while( p->rc==SQLITE_OK && pIter->iLeafPgno>pIter->iTermLeafPgno ){
231869 pIter->iLeafPgno--;
231871 pIter->pSeg->iSegid, pIter->iLeafPgno
231876 ** In this case leave pIter->pLeaf==0, this iterator is at EOF. */
231877 if( pIter->iLeafPgno==pIter->iTermLeafPgno ){
231878 assert( pIter->pLeaf==0 );
231879 if( pIter->iTermLeafOffset<pNew->szLeaf ){
231880 pIter->pLeaf = pNew;
231881 pIter->iLeafOffset = pIter->iTermLeafOffset;
231890 pIter->pLeaf = pNew;
231891 pIter->iLeafOffset = iRowidOff;
231896 if( pIter->pLeaf ){
231897 u8 *a = &pIter->pLeaf->p[pIter->iLeafOffset];
231898 pIter->iLeafOffset += fts5GetVarint(a, (u64*)&pIter->iRowid);
231906 if( pIter->pLeaf ){
231907 pIter->iEndofDoclist = pIter->pLeaf->nn+1;
231908 fts5SegIterReverseInitPage(p, pIter);
231917 static int fts5MultiIterIsEmpty(Fts5Index *p, Fts5Iter *pIter){
231918 Fts5SegIter *pSeg = &pIter->aSeg[pIter->aFirst[1].iFirst];
231923 ** Advance iterator pIter to the next entry.
231929 Fts5SegIter *pIter, /* Iterator to advance */
231932 assert( pIter->flags & FTS5_SEGITER_REVERSE );
231933 assert( pIter->pNextLeaf==0 );
231936 if( pIter->iRowidOffset>0 ){
231937 u8 *a = pIter->pLeaf->p;
231941 pIter->iRowidOffset--;
231942 pIter->iLeafOffset = pIter->aRowidOffset[pIter->iRowidOffset];
231943 fts5SegIterLoadNPos(p, pIter);
231944 iOff = pIter->iLeafOffset;
231946 iOff += pIter->nPos;
231949 pIter->iRowid -= iDelta;
231951 fts5SegIterReverseNewPage(p, pIter);
231956 ** Advance iterator pIter to the next entry.
231963 Fts5SegIter *pIter, /* Iterator to advance */
231969 assert( (pIter->flags & FTS5_SEGITER_REVERSE)==0 );
231972 ASSERT_SZLEAF_OK(pIter->pLeaf);
231973 iOff = pIter->iLeafOffset;
231976 if( pIter->pSeg && iOff>=pIter->pLeaf->szLeaf ){
231977 fts5SegIterNextPage(p, pIter);
231978 if( p->rc || pIter->pLeaf==0 ) return;
231979 pIter->iRowid = 0;
231983 if( iOff<pIter->iEndofDoclist ){
231986 iOff += sqlite3Fts5GetVarint(&pIter->pLeaf->p[iOff], (u64*)&iDelta);
231987 pIter->iLeafOffset = iOff;
231988 pIter->iRowid += iDelta;
231989 }else if( (pIter->flags & FTS5_SEGITER_ONETERM)==0 ){
231990 if( pIter->pSeg ){
231992 if( iOff!=fts5LeafFirstTermOff(pIter->pLeaf) ){
231993 iOff += fts5GetVarint32(&pIter->pLeaf->p[iOff], nKeep);
231995 pIter->iLeafOffset = iOff;
231996 fts5SegIterLoadTerm(p, pIter, nKeep);
232004 pIter->pLeaf->p = (u8*)pList;
232005 pIter->pLeaf->nn = nList;
232006 pIter->pLeaf->szLeaf = nList;
232007 pIter->iEndofDoclist = nList;
232008 sqlite3Fts5BufferSet(&p->rc,&pIter->term, (int)strlen(zTerm), (u8*)zTerm);
232009 pIter->iLeafOffset = fts5GetVarint(pList, (u64*)&pIter->iRowid);
232017 fts5SegIterLoadNPos(p, pIter);
232021 fts5DataRelease(pIter->pLeaf);
232022 pIter->pLeaf = 0;
232027 ** Advance iterator pIter to the next entry.
232035 Fts5SegIter *pIter, /* Iterator to advance */
232038 Fts5Data *pLeaf = pIter->pLeaf;
232053 iOff = pIter->iLeafOffset + pIter->nPos;
232057 assert_nc( iOff<=pIter->iEndofDoclist );
232058 if( iOff>=pIter->iEndofDoclist ){
232066 pIter->iRowid += iDelta;
232069 pIter->iLeafOffset = iOff;
232071 }else if( pIter->pSeg==0 ){
232075 assert( (pIter->flags & FTS5_SEGITER_ONETERM) || pbNewTerm );
232076 if( 0==(pIter->flags & FTS5_SEGITER_ONETERM) ){
232081 fts5DataRelease(pIter->pLeaf);
232082 pIter->pLeaf = 0;
232084 pIter->pLeaf->p = (u8*)pList;
232085 pIter->pLeaf->nn = nList;
232086 pIter->pLeaf->szLeaf = nList;
232087 pIter->iEndofDoclist = nList+1;
232088 sqlite3Fts5BufferSet(&p->rc, &pIter->term, (int)strlen(zTerm),
232090 pIter->iLeafOffset = fts5GetVarint(pList, (u64*)&pIter->iRowid);
232097 fts5SegIterNextPage(p, pIter);
232098 pLeaf = pIter->pLeaf;
232102 iOff += sqlite3Fts5GetVarint(&pLeaf->p[iOff], (u64*)&pIter->iRowid);
232103 pIter->iLeafOffset = iOff;
232106 pIter->iPgidxOff = pLeaf->szLeaf + fts5GetVarint32(
232107 &pLeaf->p[pLeaf->szLeaf], pIter->iEndofDoclist
232112 pIter->iPgidxOff = pLeaf->szLeaf + fts5GetVarint32(
232115 pIter->iLeafOffset = iOff;
232116 pIter->iEndofDoclist = iOff;
232128 if( pIter->pLeaf ){
232130 if( pIter->flags & FTS5_SEGITER_ONETERM ){
232131 fts5DataRelease(pIter->pLeaf);
232132 pIter->pLeaf = 0;
232134 fts5SegIterLoadTerm(p, pIter, nKeep);
232135 fts5SegIterLoadNPos(p, pIter);
232143 assert_nc( pIter->iLeafOffset<=pIter->pLeaf->nn );
232144 fts5FastGetVarint32(pIter->pLeaf->p, pIter->iLeafOffset, nSz);
232145 pIter->bDel = (nSz & 0x0001);
232146 pIter->nPos = nSz>>1;
232147 assert_nc( pIter->nPos>=0 );
232160 ** Iterator pIter currently points to the first rowid in a doclist. This
232164 static void fts5SegIterReverse(Fts5Index *p, Fts5SegIter *pIter){
232165 Fts5DlidxIter *pDlidx = pIter->pDlidx;
232170 int iSegid = pIter->pSeg->iSegid;
232174 Fts5Data *pLeaf = pIter->pLeaf; /* Current leaf data */
232180 if( pIter->iTermLeafPgno==pIter->iLeafPgno ){
232181 iPoslist = pIter->iTermLeafOffset;
232186 pIter->iLeafOffset = iPoslist;
232191 if( pIter->iEndofDoclist>=pLeaf->szLeaf ){
232193 Fts5StructureSegment *pSeg = pIter->pSeg;
232197 for(pgno=pIter->iLeafPgno+1; !p->rc && pgno<=pSeg->pgnoLast; pgno++){
232217 ** pIter->iLeafOffset is already set to point to the position-list size
232226 fts5DataRelease(pIter->pLeaf);
232227 pIter->pLeaf = pLast;
232228 pIter->iLeafPgno = pgnoLast;
232234 iOff += fts5GetVarint(&pLast->p[iOff], (u64*)&pIter->iRowid);
232235 pIter->iLeafOffset = iOff;
232238 pIter->iEndofDoclist = pLast->nn+1;
232240 pIter->iEndofDoclist = fts5LeafFirstTermOff(pLast);
232244 fts5SegIterReverseInitPage(p, pIter);
232248 ** Iterator pIter currently points to the first rowid of a doclist.
232251 ** doclist-index from disk and initialize an iterator at (pIter->pDlidx).
232253 static void fts5SegIterLoadDlidx(Fts5Index *p, Fts5SegIter *pIter){
232254 int iSeg = pIter->pSeg->iSegid;
232255 int bRev = (pIter->flags & FTS5_SEGITER_REVERSE);
232256 Fts5Data *pLeaf = pIter->pLeaf; /* Current leaf data */
232258 assert( pIter->flags & FTS5_SEGITER_ONETERM );
232259 assert( pIter->pDlidx==0 );
232264 if( pIter->iTermLeafPgno==pIter->iLeafPgno
232265 && pIter->iEndofDoclist<pLeaf->szLeaf
232270 pIter->pDlidx = fts5DlidxIterInit(p, bRev, iSeg, pIter->iTermLeafPgno);
232290 Fts5SegIter *pIter, /* Iterator to seek */
232294 const u8 *a = pIter->pLeaf->p;
232295 u32 n = (u32)pIter->pLeaf->nn;
232306 iPgidx = (u32)pIter->pLeaf->szLeaf;
232363 fts5DataRelease(pIter->pLeaf);
232364 pIter->pLeaf = 0;
232368 fts5SegIterNextPage(p, pIter);
232369 if( pIter->pLeaf==0 ) return;
232370 a = pIter->pLeaf->p;
232371 if( fts5LeafIsTermless(pIter->pLeaf)==0 ){
232372 iPgidx = (u32)pIter->pLeaf->szLeaf;
232373 iPgidx += fts5GetVarint32(&pIter->pLeaf->p[iPgidx], iOff);
232374 if( iOff<4 || (i64)iOff>=pIter->pLeaf->szLeaf ){
232380 n = (u32)pIter->pLeaf->nn;
232393 pIter->iLeafOffset = iOff + nNew;
232394 pIter->iTermLeafOffset = pIter->iLeafOffset;
232395 pIter->iTermLeafPgno = pIter->iLeafPgno;
232397 fts5BufferSet(&p->rc, &pIter->term, nKeep, pTerm);
232398 fts5BufferAppendBlob(&p->rc, &pIter->term, nNew, &a[iOff]);
232401 pIter->iEndofDoclist = pIter->pLeaf->nn+1;
232405 pIter->iEndofDoclist = iTermOff + nExtra;
232407 pIter->iPgidxOff = iPgidx;
232409 fts5SegIterLoadRowid(p, pIter);
232410 fts5SegIterLoadNPos(p, pIter);
232426 ** Initialize the object pIter to point to term pTerm/nTerm within segment
232437 Fts5SegIter *pIter /* Object to populate */
232446 memset(pIter, 0, sizeof(*pIter));
232447 pIter->pSeg = pSeg;
232468 pIter->iLeafPgno = iPg - 1;
232469 fts5SegIterNextPage(p, pIter);
232471 if( pIter->pLeaf ){
232472 fts5LeafSeek(p, bGe, pIter, pTerm, nTerm);
232476 pIter->flags |= FTS5_SEGITER_ONETERM;
232477 if( pIter->pLeaf ){
232479 pIter->flags |= FTS5_SEGITER_REVERSE;
232482 fts5SegIterLoadDlidx(p, pIter);
232485 fts5SegIterReverse(p, pIter);
232490 fts5SegIterSetNext(p, pIter);
232501 || pIter->pLeaf==0 /* 2 */
232502 || fts5BufferCompareBlob(&pIter->term, pTerm, nTerm)==0 /* 3 */
232503 || (bGe && fts5BufferCompareBlob(&pIter->term, pTerm, nTerm)>0) /* 4 */
232508 ** Initialize the object pIter to point to term pTerm/nTerm within the
232519 Fts5SegIter *pIter /* Object to populate */
232550 pIter->flags |= FTS5_SEGITER_ONETERM;
232554 sqlite3Fts5BufferSet(&p->rc, &pIter->term, n, z);
232556 pIter->pLeaf = pLeaf;
232557 pIter->iLeafOffset = fts5GetVarint(pLeaf->p, (u64*)&pIter->iRowid);
232558 pIter->iEndofDoclist = pLeaf->nn;
232561 pIter->flags |= FTS5_SEGITER_REVERSE;
232562 fts5SegIterReverseInitPage(p, pIter);
232564 fts5SegIterLoadNPos(p, pIter);
232568 fts5SegIterSetNext(p, pIter);
232574 static void fts5SegIterClear(Fts5SegIter *pIter){
232575 fts5BufferFree(&pIter->term);
232576 fts5DataRelease(pIter->pLeaf);
232577 fts5DataRelease(pIter->pNextLeaf);
232578 fts5DlidxIterFree(pIter->pDlidx);
232579 sqlite3_free(pIter->aRowidOffset);
232580 memset(pIter, 0, sizeof(Fts5SegIter));
232592 Fts5Iter *pIter,
232597 int i1 = p1 - pIter->aSeg;
232598 int i2 = p2 - pIter->aSeg;
232613 res = ((p1->iRowid > p2->iRowid)==pIter->bRev) ? -1 : 1;
232630 ** statement used to verify that the contents of the pIter->aFirst[] array
232633 static void fts5AssertMultiIterSetup(Fts5Index *p, Fts5Iter *pIter){
232635 Fts5SegIter *pFirst = &pIter->aSeg[ pIter->aFirst[1].iFirst ];
232638 assert( (pFirst->pLeaf==0)==pIter->base.bEof );
232640 /* Check that pIter->iSwitchRowid is set correctly. */
232641 for(i=0; i<pIter->nSeg; i++){
232642 Fts5SegIter *p1 = &pIter->aSeg[i];
232646 || p1->iRowid==pIter->iSwitchRowid
232647 || (p1->iRowid<pIter->iSwitchRowid)==pIter->bRev
232651 for(i=0; i<pIter->nSeg; i+=2){
232652 Fts5SegIter *p1 = &pIter->aSeg[i];
232653 Fts5SegIter *p2 = &pIter->aSeg[i+1];
232654 Fts5CResult *pRes = &pIter->aFirst[(pIter->nSeg + i) / 2];
232655 fts5AssertComparisonResult(pIter, p1, p2, pRes);
232658 for(i=1; i<(pIter->nSeg / 2); i+=2){
232659 Fts5SegIter *p1 = &pIter->aSeg[ pIter->aFirst[i*2].iFirst ];
232660 Fts5SegIter *p2 = &pIter->aSeg[ pIter->aFirst[i*2+1].iFirst ];
232661 Fts5CResult *pRes = &pIter->aFirst[i];
232662 fts5AssertComparisonResult(pIter, p1, p2, pRes);
232671 ** Do the comparison necessary to populate pIter->aFirst[iOut].
232674 ** in the pIter->aSeg[] array that is (a) not at EOF, and (b) pointing
232678 static int fts5MultiIterDoCompare(Fts5Iter *pIter, int iOut){
232684 Fts5CResult *pRes = &pIter->aFirst[iOut];
232686 assert( iOut<pIter->nSeg && iOut>0 );
232687 assert( pIter->bRev==0 || pIter->bRev==1 );
232689 if( iOut>=(pIter->nSeg/2) ){
232690 i1 = (iOut - pIter->nSeg/2) * 2;
232693 i1 = pIter->aFirst[iOut*2].iFirst;
232694 i2 = pIter->aFirst[iOut*2+1].iFirst;
232696 p1 = &pIter->aSeg[i1];
232697 p2 = &pIter->aSeg[i2];
232714 res = ((p1->iRowid > p2->iRowid)==pIter->bRev) ? -1 : +1;
232734 Fts5SegIter *pIter, /* Iterator to advance */
232737 assert( iLeafPgno>pIter->iLeafPgno );
232739 if( iLeafPgno>pIter->pSeg->pgnoLast ){
232742 fts5DataRelease(pIter->pNextLeaf);
232743 pIter->pNextLeaf = 0;
232744 pIter->iLeafPgno = iLeafPgno-1;
232745 fts5SegIterNextPage(p, pIter);
232746 assert( p->rc!=SQLITE_OK || pIter->iLeafPgno==iLeafPgno );
232748 if( p->rc==SQLITE_OK && ALWAYS(pIter->pLeaf!=0) ){
232750 u8 *a = pIter->pLeaf->p;
232751 int n = pIter->pLeaf->szLeaf;
232753 iOff = fts5LeafFirstRowidOff(pIter->pLeaf);
232757 iOff += fts5GetVarint(&a[iOff], (u64*)&pIter->iRowid);
232758 pIter->iLeafOffset = iOff;
232759 fts5SegIterLoadNPos(p, pIter);
232772 Fts5SegIter *pIter, /* Iterator to advance */
232775 int bRev = (pIter->flags & FTS5_SEGITER_REVERSE);
232776 Fts5DlidxIter *pDlidx = pIter->pDlidx;
232777 int iLeafPgno = pIter->iLeafPgno;
232780 assert( pIter->flags & FTS5_SEGITER_ONETERM );
232781 assert( pIter->pDlidx );
232782 assert( pIter->pLeaf );
232789 assert_nc( iLeafPgno>=pIter->iLeafPgno || p->rc );
232790 if( iLeafPgno>pIter->iLeafPgno ){
232791 fts5SegIterGotoPage(p, pIter, iLeafPgno);
232795 assert( pIter->pNextLeaf==0 );
232796 assert( iMatch<pIter->iRowid );
232802 assert( fts5DlidxIterEof(p, pDlidx) || iLeafPgno<=pIter->iLeafPgno );
232804 if( iLeafPgno<pIter->iLeafPgno ){
232805 pIter->iLeafPgno = iLeafPgno+1;
232806 fts5SegIterReverseNewPage(p, pIter);
232812 if( bMove && p->rc==SQLITE_OK ) pIter->xNext(p, pIter, 0);
232813 if( pIter->pLeaf==0 ) break;
232814 if( bRev==0 && pIter->iRowid>=iMatch ) break;
232815 if( bRev!=0 && pIter->iRowid<=iMatch ) break;
232824 static void fts5MultiIterFree(Fts5Iter *pIter){
232825 if( pIter ){
232827 for(i=0; i<pIter->nSeg; i++){
232828 fts5SegIterClear(&pIter->aSeg[i]);
232830 fts5BufferFree(&pIter->poslist);
232831 sqlite3_free(pIter);
232837 Fts5Iter *pIter, /* Iterator to update aFirst[] array for */
232842 for(i=(pIter->nSeg+iChanged)/2; i>=iMinset && p->rc==SQLITE_OK; i=i/2){
232844 if( (iEq = fts5MultiIterDoCompare(pIter, i)) ){
232845 Fts5SegIter *pSeg = &pIter->aSeg[iEq];
232848 i = pIter->nSeg + iEq;
232854 ** Sub-iterator iChanged of iterator pIter has just been advanced. It still
232856 ** attempts to update the contents of the pIter->aFirst[] accordingly.
232864 Fts5Iter *pIter, /* Iterator to update aFirst[] array for */
232868 Fts5SegIter *pNew = &pIter->aSeg[iChanged];
232870 if( pNew->iRowid==pIter->iSwitchRowid
232871 || (pNew->iRowid<pIter->iSwitchRowid)==pIter->bRev
232874 Fts5SegIter *pOther = &pIter->aSeg[iChanged ^ 0x0001];
232875 pIter->iSwitchRowid = pIter->bRev ? SMALLEST_INT64 : LARGEST_INT64;
232876 for(i=(pIter->nSeg+iChanged)/2; 1; i=i/2){
232877 Fts5CResult *pRes = &pIter->aFirst[i];
232885 }else if( (pOther->iRowid>pNew->iRowid)==pIter->bRev ){
232886 pIter->iSwitchRowid = pOther->iRowid;
232888 }else if( (pOther->iRowid>pIter->iSwitchRowid)==pIter->bRev ){
232889 pIter->iSwitchRowid = pOther->iRowid;
232892 pRes->iFirst = (u16)(pNew - pIter->aSeg);
232895 pOther = &pIter->aSeg[ pIter->aFirst[i ^ 0x0001].iFirst ];
232904 ** Set the pIter->bEof variable based on the state of the sub-iterators.
232906 static void fts5MultiIterSetEof(Fts5Iter *pIter){
232907 Fts5SegIter *pSeg = &pIter->aSeg[ pIter->aFirst[1].iFirst ];
232908 pIter->base.bEof = pSeg->pLeaf==0;
232909 pIter->iSwitchRowid = pSeg->iRowid;
232921 Fts5Iter *pIter,
232926 assert( pIter->base.bEof==0 );
232928 int iFirst = pIter->aFirst[1].iFirst;
232930 Fts5SegIter *pSeg = &pIter->aSeg[iFirst];
232939 || fts5MultiIterAdvanceRowid(pIter, iFirst, &pSeg)
232941 fts5MultiIterAdvanced(p, pIter, iFirst, 1);
232942 fts5MultiIterSetEof(pIter);
232943 pSeg = &pIter->aSeg[pIter->aFirst[1].iFirst];
232947 fts5AssertMultiIterSetup(p, pIter);
232948 assert( pSeg==&pIter->aSeg[pIter->aFirst[1].iFirst] && pSeg->pLeaf );
232949 if( pIter->bSkipEmpty==0 || pSeg->nPos ){
232950 pIter->xSetOutputs(pIter, pSeg);
232959 Fts5Iter *pIter,
232962 assert( pIter->bSkipEmpty );
232966 int iFirst = pIter->aFirst[1].iFirst;
232967 Fts5SegIter *pSeg = &pIter->aSeg[iFirst];
232973 || fts5MultiIterAdvanceRowid(pIter, iFirst, &pSeg)
232975 fts5MultiIterAdvanced(p, pIter, iFirst, 1);
232976 fts5MultiIterSetEof(pIter);
232979 fts5AssertMultiIterSetup(p, pIter);
232981 }while( fts5MultiIterIsEmpty(p, pIter) );
233169 ** Iterator pIter currently points to a valid entry (not EOF). This
233210 ** and sets pIter->base.pData/nData to point to the new position list.
233211 ** If memory is required for the new position list, use buffer pIter->poslist.
233213 ** pIter->base.pData/nData to point directly to it.
233223 Fts5Iter *pIter
233232 if( pColset->nCol>1 && sqlite3Fts5BufferSize(pRc, &pIter->poslist, nPos) ){
233240 pIter->base.pData = pIter->poslist.p;
233241 pIter->base.nData = pIter->poslist.n;
233254 pIter->base.pData = aCopy;
233255 pIter->base.nData = p-aCopy;
233258 fts5BufferSafeAppendBlob(&pIter->poslist, aCopy, p-aCopy);
233261 pIter->base.pData = pIter->poslist.p;
233262 pIter->base.nData = pIter->poslist.n;
233279 static void fts5IterSetOutputs_None(Fts5Iter *pIter, Fts5SegIter *pSeg){
233280 assert( pIter->pIndex->pConfig->eDetail==FTS5_DETAIL_NONE );
233281 pIter->base.iRowid = pSeg->iRowid;
233282 pIter->base.nData = pSeg->nPos;
233289 static void fts5IterSetOutputs_Nocolset(Fts5Iter *pIter, Fts5SegIter *pSeg){
233290 pIter->base.iRowid = pSeg->iRowid;
233291 pIter->base.nData = pSeg->nPos;
233293 assert( pIter->pIndex->pConfig->eDetail!=FTS5_DETAIL_NONE );
233294 assert( pIter->pColset==0 );
233299 pIter->base.pData = &pSeg->pLeaf->p[pSeg->iLeafOffset];
233304 fts5BufferZero(&pIter->poslist);
233305 fts5SegiterPoslist(pIter->pIndex, pSeg, 0, &pIter->poslist);
233306 pIter->base.pData = pIter->poslist.p;
233314 static void fts5IterSetOutputs_ZeroColset(Fts5Iter *pIter, Fts5SegIter *pSeg){
233316 pIter->base.nData = 0;
233324 static void fts5IterSetOutputs_Col(Fts5Iter *pIter, Fts5SegIter *pSeg){
233325 fts5BufferZero(&pIter->poslist);
233326 fts5SegiterPoslist(pIter->pIndex, pSeg, pIter->pColset, &pIter->poslist);
233327 pIter->base.iRowid = pSeg->iRowid;
233328 pIter->base.pData = pIter->poslist.p;
233329 pIter->base.nData = pIter->poslist.n;
233342 static void fts5IterSetOutputs_Col100(Fts5Iter *pIter, Fts5SegIter *pSeg){
233344 assert( pIter->pIndex->pConfig->eDetail==FTS5_DETAIL_COLUMNS );
233345 assert( pIter->pColset );
233348 fts5IterSetOutputs_Col(pIter, pSeg);
233353 int *aiCol = pIter->pColset->aiCol;
233354 int *aiColEnd = &aiCol[pIter->pColset->nCol];
233356 u8 *aOut = pIter->poslist.p;
233359 pIter->base.iRowid = pSeg->iRowid;
233374 pIter->base.pData = pIter->poslist.p;
233375 pIter->base.nData = aOut - pIter->poslist.p;
233382 static void fts5IterSetOutputs_Full(Fts5Iter *pIter, Fts5SegIter *pSeg){
233383 Fts5Colset *pColset = pIter->pColset;
233384 pIter->base.iRowid = pSeg->iRowid;
233386 assert( pIter->pIndex->pConfig->eDetail==FTS5_DETAIL_FULL );
233393 int *pRc = &pIter->pIndex->rc;
233394 fts5BufferZero(&pIter->poslist);
233395 fts5IndexExtractColset(pRc, pColset, a, pSeg->nPos, pIter);
233400 fts5BufferZero(&pIter->poslist);
233401 fts5SegiterPoslist(pIter->pIndex, pSeg, pColset, &pIter->poslist);
233402 pIter->base.pData = pIter->poslist.p;
233403 pIter->base.nData = pIter->poslist.n;
233407 static void fts5IterSetOutputCb(int *pRc, Fts5Iter *pIter){
233408 assert( pIter!=0 || (*pRc)!=SQLITE_OK );
233410 Fts5Config *pConfig = pIter->pIndex->pConfig;
233412 pIter->xSetOutputs = fts5IterSetOutputs_None;
233415 else if( pIter->pColset==0 ){
233416 pIter->xSetOutputs = fts5IterSetOutputs_Nocolset;
233419 else if( pIter->pColset->nCol==0 ){
233420 pIter->xSetOutputs = fts5IterSetOutputs_ZeroColset;
233424 pIter->xSetOutputs = fts5IterSetOutputs_Full;
233430 pIter->xSetOutputs = fts5IterSetOutputs_Col100;
233431 sqlite3Fts5BufferSize(pRc, &pIter->poslist, pConfig->nCol);
233433 pIter->xSetOutputs = fts5IterSetOutputs_Col;
233497 Fts5SegIter *pIter = &pNew->aSeg[iIter++];
233498 fts5SegIterHashInit(p, pTerm, nTerm, flags, pIter);
233503 Fts5SegIter *pIter = &pNew->aSeg[iIter++];
233505 fts5SegIterInit(p, pSeg, pIter);
233507 fts5SegIterSeekInit(p, pTerm, nTerm, flags, pSeg, pIter);
233566 Fts5SegIter *pIter = &pNew->aSeg[1];
233568 pIter->flags = FTS5_SEGITER_ONETERM;
233570 pIter->pLeaf = pData;
233571 pIter->iLeafOffset = fts5GetVarint(pData->p, (u64*)&pIter->iRowid);
233572 pIter->iEndofDoclist = pData->nn;
233576 pIter->flags |= FTS5_SEGITER_REVERSE;
233577 fts5SegIterReverseInitPage(p, pIter);
233579 fts5SegIterLoadNPos(p, pIter);
233585 fts5SegIterSetNext(p, pIter);
233597 static int fts5MultiIterEof(Fts5Index *p, Fts5Iter *pIter){
233598 assert( pIter!=0 || p->rc!=SQLITE_OK );
233600 || (pIter->aSeg[ pIter->aFirst[1].iFirst ].pLeaf==0)==pIter->base.bEof
233602 return (p->rc || pIter->base.bEof);
233610 static i64 fts5MultiIterRowid(Fts5Iter *pIter){
233611 assert( pIter->aSeg[ pIter->aFirst[1].iFirst ].pLeaf );
233612 return pIter->aSeg[ pIter->aFirst[1].iFirst ].iRowid;
233620 Fts5Iter *pIter,
233625 fts5MultiIterNext(p, pIter, 1, iMatch);
233626 if( fts5MultiIterEof(p, pIter) ) break;
233627 iRowid = fts5MultiIterRowid(pIter);
233628 if( pIter->bRev==0 && iRowid>=iMatch ) break;
233629 if( pIter->bRev!=0 && iRowid<=iMatch ) break;
233637 static const u8 *fts5MultiIterTerm(Fts5Iter *pIter, int *pn){
233638 Fts5SegIter *p = &pIter->aSeg[ pIter->aFirst[1].iFirst ];
234210 ** Iterator pIter was used to iterate through the input segments of on an
234214 static void fts5TrimSegments(Fts5Index *p, Fts5Iter *pIter){
234218 for(i=0; i<pIter->nSeg && p->rc==SQLITE_OK; i++){
234219 Fts5SegIter *pSeg = &pIter->aSeg[i];
234301 Fts5Iter *pIter = 0; /* Iterator to read input data */
234355 for(fts5MultiIterNew(p, pStruct, flags, 0, 0, 0, iLvl, nInput, &pIter);
234356 fts5MultiIterEof(p, pIter)==0;
234357 fts5MultiIterNext(p, pIter, 0, 0)
234359 Fts5SegIter *pSegIter = &pIter->aSeg[ pIter->aFirst[1].iFirst ];
234364 pTerm = fts5MultiIterTerm(pIter, &nTerm);
234384 fts5WriteAppendRowid(p, &writer, fts5MultiIterRowid(pIter));
234405 assert( pIter!=0 || p->rc!=SQLITE_OK );
234406 if( fts5MultiIterEof(p, pIter) ){
234428 fts5TrimSegments(p, pIter);
234432 fts5MultiIterFree(pIter);
234887 static void fts5DoclistIterNext(Fts5DoclistIter *pIter){
234888 u8 *p = pIter->aPoslist + pIter->nSize + pIter->nPoslist;
234890 assert( pIter->aPoslist || (p==0 && pIter->aPoslist==0) );
234891 if( p>=pIter->aEof ){
234892 pIter->aPoslist = 0;
234897 pIter->iRowid += iDelta;
234902 pIter->nSize = fts5GetVarint32(p, nPos);
234903 pIter->nPoslist = (nPos>>1);
234905 pIter->nPoslist = ((int)(p[0])) >> 1;
234906 pIter->nSize = 1;
234909 pIter->aPoslist = p;
234910 if( &pIter->aPoslist[pIter->nPoslist]>pIter->aEof ){
234911 pIter->aPoslist = 0;
234918 Fts5DoclistIter *pIter
234920 memset(pIter, 0, sizeof(*pIter));
234922 pIter->aPoslist = pBuf->p;
234923 pIter->aEof = &pBuf->p[pBuf->n];
234924 fts5DoclistIterNext(pIter);
235647 Fts5Iter *pIter = (Fts5Iter*)pIndexIter;
235648 assert( pIter->pIndex->rc==SQLITE_OK );
235649 fts5MultiIterNext(pIter->pIndex, pIter, 0, 0);
235650 return fts5IndexReturn(pIter->pIndex);
235657 Fts5Iter *pIter = (Fts5Iter*)pIndexIter;
235658 Fts5Index *p = pIter->pIndex;
235660 assert( pIter->pIndex->rc==SQLITE_OK );
235662 fts5MultiIterNext(p, pIter, 0, 0);
235664 Fts5SegIter *pSeg = &pIter->aSeg[ pIter->aFirst[1].iFirst ];
235668 pIter->base.bEof = 1;
235672 return fts5IndexReturn(pIter->pIndex);
235681 Fts5Iter *pIter = (Fts5Iter*)pIndexIter;
235682 fts5MultiIterNextFrom(pIter->pIndex, pIter, iMatch);
235683 return fts5IndexReturn(pIter->pIndex);
235702 Fts5Iter *pIter = (Fts5Iter*)pIndexIter;
235703 Fts5Index *pIndex = pIter->pIndex;
235704 fts5MultiIterFree(pIter);
235869 Fts5IndexIter *pIter = 0;
235870 int rc = sqlite3Fts5IndexQuery(p, z, n, flags, 0, &pIter);
235872 while( rc==SQLITE_OK && ALWAYS(pIter!=0) && 0==sqlite3Fts5IterEof(pIter) ){
235873 i64 rowid = pIter->iRowid;
235879 for(sqlite3Fts5PoslistReaderInit(pIter->pData, pIter->nData, &sReader);
235889 rc = sqlite3Fts5IterNext(pIter);
235892 sqlite3Fts5IterClose(pIter);
236235 Fts5Iter *pIter; /* Used to iterate through entire index */
236274 for(fts5MultiIterNew(p, pStruct, flags, 0, 0, 0, -1, 0, &pIter);
236275 fts5MultiIterEof(p, pIter)==0;
236276 fts5MultiIterNext(p, pIter, 0, 0)
236281 i64 iRowid = fts5MultiIterRowid(pIter);
236282 char *z = (char*)fts5MultiIterTerm(pIter, &n);
236289 if( 0==fts5MultiIterIsEmpty(p, pIter) ){
236294 fts5SegiterPoslist(p, &pIter->aSeg[pIter->aFirst[1].iFirst], 0, &poslist);
236305 fts5MultiIterFree(pIter);
238983 Fts5PhraseIter *pIter,
238987 if( pIter->a>=pIter->b ){
238992 pIter->a += fts5GetVarint32(pIter->a, iVal);
238994 pIter->a += fts5GetVarint32(pIter->a, iVal);
238997 pIter->a += fts5GetVarint32(pIter->a, iVal);
239006 Fts5PhraseIter *pIter,
239011 int rc = fts5CsrPoslist(pCsr, iPhrase, &pIter->a, &n);
239013 assert( pIter->a || n==0 );
239014 pIter->b = (pIter->a ? &pIter->a[n] : 0);
239017 fts5ApiPhraseNext(pCtx, pIter, piCol, piOff);
239024 Fts5PhraseIter *pIter,
239031 if( pIter->a>=pIter->b ){
239035 pIter->a += fts5GetVarint32(&pIter->a[0], iIncr);
239041 if( pIter->a>=pIter->b ){
239045 if( pIter->a[0]==0x01 ) break;
239046 pIter->a += fts5GetVarint32(pIter->a, dummy);
239048 pIter->a += 1 + fts5GetVarint32(&pIter->a[1], *piCol);
239055 Fts5PhraseIter *pIter,
239068 pIter->a = &pSorter->aPoslist[i1];
239070 rc = sqlite3Fts5ExprPhraseCollist(pCsr->pExpr, iPhrase, &pIter->a, &n);
239073 assert( pIter->a || n==0 );
239074 pIter->b = (pIter->a ? &pIter->a[n] : 0);
239076 fts5ApiPhraseNextColumn(pCtx, pIter, piCol);
239080 rc = fts5CsrPoslist(pCsr, iPhrase, &pIter->a, &n);
239082 assert( pIter->a || n==0 );
239083 pIter->b = (pIter->a ? &pIter->a[n] : 0);
239086 }else if( pIter->a[0]==0x01 ){
239087 pIter->a += 1 + fts5GetVarint32(&pIter->a[1], *piCol);
243526 Fts5IndexIter *pIter; /* Term/rowid iterator object */
243860 sqlite3Fts5IterClose(pCsr->pIter);
243863 pCsr->pIter = 0;
243886 if( sqlite3Fts5IterEof(pCsr->pIter) ){
243891 zTerm = sqlite3Fts5IterTerm(pCsr->pIter, &nTerm);
243908 Fts5IndexIter *pIter = pCsr->pIter;
243912 assert( sqlite3Fts5IterEof(pIter)==0 );
243915 || sqlite3Fts5PoslistNext64(pIter->pData, pIter->nData, po, pp)
243920 rc = sqlite3Fts5IterNextScan(pCsr->pIter);
243958 if( sqlite3Fts5IterEof(pCsr->pIter) ){
243964 zTerm = sqlite3Fts5IterTerm(pCsr->pIter, &nTerm);
243987 pPos = pCsr->pIter->pData;
243988 nPos = pCsr->pIter->nData;
244036 rc = sqlite3Fts5IterNextScan(pCsr->pIter);
244041 zTerm = sqlite3Fts5IterTerm(pCsr->pIter, &nTerm);
244047 if( sqlite3Fts5IterEof(pCsr->pIter) ) break;
244117 rc = sqlite3Fts5IndexQuery(pIndex, zTerm, nTerm, f, 0, &pCsr->pIter);
244181 sqlite3_result_int64(pCtx, pCsr->pIter->iRowid);