Lines Matching refs:pIter
11616 SQLITE_API int sqlite3changeset_next(sqlite3_changeset_iter *pIter);
11622 ** The pIter argument passed to this function may either be an iterator
11651 sqlite3_changeset_iter *pIter, /* Iterator object */
11670 ** the table modified by the change that iterator pIter currently points to.
11685 sqlite3_changeset_iter *pIter, /* Iterator object */
11694 ** The pIter argument passed to this function may either be an iterator
11716 sqlite3_changeset_iter *pIter, /* Changeset iterator */
11725 ** The pIter argument passed to this function may either be an iterator
11750 sqlite3_changeset_iter *pIter, /* Changeset iterator */
11778 sqlite3_changeset_iter *pIter, /* Changeset iterator */
11795 sqlite3_changeset_iter *pIter, /* Changeset iterator */
11830 SQLITE_API int sqlite3changeset_finalize(sqlite3_changeset_iter *pIter);
61802 WalIterator *pIter = 0; /* Wal iterator context */
61847 rc = walIteratorInit(pWal, pInfo->nBackfill, &pIter);
61848 assert( rc==SQLITE_OK || pIter==0 );
61851 if( pIter
61884 while( rc==SQLITE_OK && 0==walIteratorNext(pIter, &iDbpage, &iFrame) ){
61969 walIteratorFree(pIter);
65246 BtLock *pIter;
65273 for(pIter=pBt->pLock; pIter; pIter=pIter->pNext){
65274 /* The condition (pIter->eLock!=eLock) in the following if(...)
65277 ** (eLock==WRITE_LOCK || pIter->eLock==WRITE_LOCK)
65283 assert( pIter->eLock==READ_LOCK || pIter->eLock==WRITE_LOCK );
65284 assert( eLock==READ_LOCK || pIter->pBtree==p || pIter->eLock==READ_LOCK);
65285 if( pIter->pBtree!=p && pIter->iTable==iTab && pIter->eLock!=eLock ){
65286 sqlite3ConnectionBlocked(p->db, pIter->pBtree->db);
65319 BtLock *pIter;
65337 for(pIter=pBt->pLock; pIter; pIter=pIter->pNext){
65338 if( pIter->iTable==iTable && pIter->pBtree==p ){
65339 pLock = pIter;
66156 u8 *pIter; /* For scanning through pCell */
66164 pIter = pCell;
66168 ** pIter += getVarint32(pIter, nPayload);
66172 nPayload = *pIter;
66174 u8 *pEnd = &pIter[8];
66177 nPayload = (nPayload<<7) | (*++pIter & 0x7f);
66178 }while( (*pIter)>=0x80 && pIter<pEnd );
66180 pIter++;
66184 ** pIter += getVarint(pIter, (u64*)&pInfo->nKey);
66188 iKey = *pIter;
66190 u8 *pEnd = &pIter[7];
66193 iKey = (iKey<<7) | (*++pIter & 0x7f);
66194 if( (*pIter)<0x80 ) break;
66195 if( pIter>=pEnd ){
66196 iKey = (iKey<<8) | *++pIter;
66201 pIter++;
66205 pInfo->pPayload = pIter;
66212 pInfo->nSize = nPayload + (u16)(pIter - pCell);
66224 u8 *pIter; /* For scanning through pCell */
66230 pIter = pCell + pPage->childPtrSize;
66231 nPayload = *pIter;
66233 u8 *pEnd = &pIter[8];
66236 nPayload = (nPayload<<7) | (*++pIter & 0x7f);
66237 }while( *(pIter)>=0x80 && pIter<pEnd );
66239 pIter++;
66242 pInfo->pPayload = pIter;
66249 pInfo->nSize = nPayload + (u16)(pIter - pCell);
66277 u8 *pIter = pCell + pPage->childPtrSize; /* For looping over bytes of pCell */
66290 nSize = *pIter;
66292 pEnd = &pIter[8];
66295 nSize = (nSize<<7) | (*++pIter & 0x7f);
66296 }while( *(pIter)>=0x80 && pIter<pEnd );
66298 pIter++;
66300 /* pIter now points at the 64-bit integer key value, a variable length
66301 ** integer. The following block moves pIter to point at the first byte
66303 pEnd = &pIter[9];
66304 while( (*pIter++)&0x80 && pIter<pEnd );
66309 nSize += (u32)(pIter - pCell);
66319 nSize += 4 + (u16)(pIter - pCell);
66325 u8 *pIter = pCell + 4; /* For looping over bytes of pCell */
66340 pEnd = pIter + 9;
66341 while( (*pIter++)&0x80 && pIter<pEnd );
66342 assert( debuginfo.nSize==(u16)(pIter - pCell) || CORRUPT_DB );
66343 return (u16)(pIter - pCell);
68404 BtLock *pIter;
68405 for(pIter=pBt->pLock; pIter; pIter=pIter->pNext){
68406 if( pIter->pBtree!=p ){
68407 pBlock = pIter->pBtree->db;
98074 FileChunk *pIter;
98076 for(pIter=pFirst; pIter; pIter=pNext){
98077 pNext = pIter->pNext;
98078 sqlite3_free(pIter);
98095 FileChunk *pIter;
98096 for(pIter=copy.pFirst; pIter; pIter=pIter->pNext){
98100 rc = sqlite3OsWrite(pReal, (u8*)pIter->zChunk, nChunk, iOff);
98200 FileChunk *pIter = 0;
98207 for(pIter=p->pFirst; ALWAYS(pIter) && iOff<=size; pIter=pIter->pNext){
98210 if( ALWAYS(pIter) ){
98211 memjrnlFreeChunks(pIter->pNext);
98212 pIter->pNext = 0;
98216 p->endpoint.pChunk = pIter;
123618 static Index *indexIteratorFirst(IndexIterator *pIter, int *pIx){
123619 assert( pIter->i==0 );
123620 if( pIter->eType ){
123621 *pIx = pIter->u.ax.aIdx[0].ix;
123622 return pIter->u.ax.aIdx[0].p;
123625 return pIter->u.lx.pIdx;
123630 static Index *indexIteratorNext(IndexIterator *pIter, int *pIx){
123631 if( pIter->eType ){
123632 int i = ++pIter->i;
123633 if( i>=pIter->u.ax.nIdx ){
123637 *pIx = pIter->u.ax.aIdx[i].ix;
123638 return pIter->u.ax.aIdx[i].p;
123641 pIter->u.lx.pIdx = pIter->u.lx.pIdx->pNext;
123642 return pIter->u.lx.pIdx;
174564 char *pIter; /* Used to iterate through aAll */
174568 pIter = pDL->pNextDocid;
174569 assert( pDL->aAll!=0 || pIter==0 );
174571 pIter = pDL->aAll;
174574 if( pIter==0 || pIter>=(pEnd = pDL->aAll + pDL->nAll) ){
174579 pIter += sqlite3Fts3GetVarint(pIter, &iDelta);
174585 pDL->pList = pIter;
174586 fts3PoslistCopy(0, &pIter);
174587 pDL->nList = (int)(pIter - pDL->pList);
174589 /* pIter now points just past the 0x00 that terminates the position-
174591 ** edited in place by fts3EvalNearTrim(), then pIter may not actually
174593 ** with this case by advancing pIter past the zero-padding added by
174595 while( pIter<pEnd && *pIter==0 ) pIter++;
174597 pDL->pNextDocid = pIter;
174598 assert( pIter>=&pDL->aAll[pDL->nAll] || *pIter );
175936 char *pIter;
175949 pIter = pPhrase->doclist.pList;
176001 pIter = pPh->pOrPoslist;
176005 (pIter >= (pPh->doclist.aAll + pPh->doclist.nAll));
176006 while( (pIter==0 || DOCID_CMP(iDocid, pCsr->iPrevId)<0 ) && bEof==0 ){
176009 &pIter, &iDocid, &bEof
176013 bEof = !pPh->doclist.nAll || (pIter && pIter<=pPh->doclist.aAll);
176014 while( (pIter==0 || DOCID_CMP(iDocid, pCsr->iPrevId)>0 ) && bEof==0 ){
176018 &pIter, &iDocid, &dummy, &bEof
176022 pPh->pOrPoslist = pIter;
176028 pIter = pPhrase->pOrPoslist;
176030 pIter = 0;
176033 if( pIter==0 ) return SQLITE_OK;
176035 if( *pIter==0x01 ){
176036 pIter++;
176037 pIter += fts3GetVarint32(pIter, &iThis);
176042 fts3ColumnlistCopy(0, &pIter);
176043 if( *pIter==0x00 ) return SQLITE_OK;
176044 pIter++;
176045 pIter += fts3GetVarint32(pIter, &iThis);
176047 if( *pIter==0x00 ){
176048 pIter = 0;
176051 *ppOut = ((iCol==iThis)?pIter:0);
177394 Fts3Expr *pIter = pNotBranch;
177395 while( pIter->pLeft ){
177396 pIter = pIter->pLeft;
177398 pIter->pLeft = pRet;
177399 pRet->pParent = pIter;
182401 SegmentNode *pIter;
182404 for(pIter=pTree->pLeftmost; pIter && rc==SQLITE_OK; pIter=pIter->pRight){
182405 int nStart = fts3TreeFinishNode(pIter, iHeight, iNextLeaf);
182406 int nWrite = pIter->nData - nStart;
182408 rc = fts3WriteSegment(p, iNextFree, &pIter->aData[nStart], nWrite);
182410 iNextLeaf += (pIter->nEntry+1);
186372 char *pIter = *ppIter;
186373 if( pIter ){
186377 if( 0==(*pIter & 0xFE) ){
186379 pIter = 0;
186382 fts3GetDeltaPosition(&pIter, &iIter);
186386 *ppIter = pIter;
186393 static int fts3SnippetNextCandidate(SnippetIter *pIter){
186396 if( pIter->iCurrent<0 ){
186401 pIter->iCurrent = 0;
186406 for(i=0; i<pIter->nPhrase; i++){
186407 SnippetPhrase *pPhrase = &pIter->aPhrase[i];
186408 fts3SnippetAdvance(&pPhrase->pHead, &pPhrase->iHead, pIter->nSnippet);
186414 for(i=0; i<pIter->nPhrase; i++){
186415 SnippetPhrase *pPhrase = &pIter->aPhrase[i];
186424 pIter->iCurrent = iStart = iEnd - pIter->nSnippet + 1;
186425 for(i=0; i<pIter->nPhrase; i++){
186426 SnippetPhrase *pPhrase = &pIter->aPhrase[i];
186437 ** iterator pIter.
186440 SnippetIter *pIter, /* Snippet iterator */
186447 int iStart = pIter->iCurrent; /* First token of snippet */
186453 for(i=0; i<pIter->nPhrase; i++){
186454 SnippetPhrase *pPhrase = &pIter->aPhrase[i];
186459 while( iCsr<(iStart+pIter->nSnippet) && iCsr>=iStart ){
186894 char *pIter = pPhrase->doclist.pList;
186904 if( pIter ) while( 1 ){
186905 int nHit = fts3ColumnlistCount(&pIter);
186913 assert( *pIter==0x00 || *pIter==0x01 );
186914 if( *pIter!=0x01 ) break;
186915 pIter++;
186916 pIter += fts3GetVarint32(pIter, &iCol);
187135 static int fts3LcsIteratorAdvance(LcsIterator *pIter){
187136 char *pRead = pIter->pRead;
187145 pIter->iPos += (int)(iRead-2);
187148 pIter->pRead = pRead;
187179 LcsIterator *pIter = &aIter[i];
187180 nToken -= pIter->pExpr->pPhrase->nToken;
187181 pIter->iPosOffset = nToken;
187208 LcsIterator *pIter = &aIter[i];
187209 if( pIter->pRead==0 ){
187213 if( pAdv==0 || pIter->iPos<pAdv->iPos ){
187214 pAdv = pIter;
187216 if( nThisLcs==0 || pIter->iPos==pIter[-1].iPos ){
198153 UBreakIterator *pIter; /* ICU break-iterator object */
198266 pCsr->pIter = ubrk_open(UBRK_WORD, p->zLocale, pCsr->aChar, iOut, &status);
198273 ubrk_first(pCsr->pIter);
198283 ubrk_close(pCsr->pIter);
198309 iStart = ubrk_current(pCsr->pIter);
198310 iEnd = ubrk_next(pCsr->pIter);
199776 static void rbuObjIterFreeCols(RbuObjIter *pIter){
199778 for(i=0; i<pIter->nTblCol; i++){
199779 sqlite3_free(pIter->azTblCol[i]);
199780 sqlite3_free(pIter->azTblType[i]);
199782 sqlite3_free(pIter->azTblCol);
199783 pIter->azTblCol = 0;
199784 pIter->azTblType = 0;
199785 pIter->aiSrcOrder = 0;
199786 pIter->abTblPk = 0;
199787 pIter->abNotNull = 0;
199788 pIter->nTblCol = 0;
199789 pIter->eType = 0; /* Invalid value */
199796 static void rbuObjIterClearStatements(RbuObjIter *pIter){
199799 sqlite3_finalize(pIter->pSelect);
199800 sqlite3_finalize(pIter->pInsert);
199801 sqlite3_finalize(pIter->pDelete);
199802 sqlite3_finalize(pIter->pTmpInsert);
199803 pUp = pIter->pRbuUpdate;
199810 sqlite3_free(pIter->aIdxCol);
199811 sqlite3_free(pIter->zIdxSql);
199813 pIter->pSelect = 0;
199814 pIter->pInsert = 0;
199815 pIter->pDelete = 0;
199816 pIter->pRbuUpdate = 0;
199817 pIter->pTmpInsert = 0;
199818 pIter->nCol = 0;
199819 pIter->nIdxCol = 0;
199820 pIter->aIdxCol = 0;
199821 pIter->zIdxSql = 0;
199828 static void rbuObjIterFinalize(RbuObjIter *pIter){
199829 rbuObjIterClearStatements(pIter);
199830 sqlite3_finalize(pIter->pTblIter);
199831 sqlite3_finalize(pIter->pIdxIter);
199832 rbuObjIterFreeCols(pIter);
199833 memset(pIter, 0, sizeof(RbuObjIter));
199844 static int rbuObjIterNext(sqlite3rbu *p, RbuObjIter *pIter){
199849 rbuObjIterClearStatements(pIter);
199850 if( pIter->zIdx==0 ){
199861 if( pIter->bCleanup ){
199862 rbuObjIterFreeCols(pIter);
199863 pIter->bCleanup = 0;
199864 rc = sqlite3_step(pIter->pTblIter);
199866 rc = resetAndCollectError(pIter->pTblIter, &p->zErrmsg);
199867 pIter->zTbl = 0;
199869 pIter->zTbl = (const char*)sqlite3_column_text(pIter->pTblIter, 0);
199870 pIter->zDataTbl = (const char*)sqlite3_column_text(pIter->pTblIter,1);
199871 rc = (pIter->zDataTbl && pIter->zTbl) ? SQLITE_OK : SQLITE_NOMEM;
199874 if( pIter->zIdx==0 ){
199875 sqlite3_stmt *pIdx = pIter->pIdxIter;
199876 rc = sqlite3_bind_text(pIdx, 1, pIter->zTbl, -1, SQLITE_STATIC);
199879 rc = sqlite3_step(pIter->pIdxIter);
199881 rc = resetAndCollectError(pIter->pIdxIter, &p->zErrmsg);
199882 pIter->bCleanup = 1;
199883 pIter->zIdx = 0;
199885 pIter->zIdx = (const char*)sqlite3_column_text(pIter->pIdxIter, 0);
199886 pIter->iTnum = sqlite3_column_int(pIter->pIdxIter, 1);
199887 pIter->bUnique = sqlite3_column_int(pIter->pIdxIter, 2);
199888 rc = pIter->zIdx ? SQLITE_OK : SQLITE_NOMEM;
199896 rbuObjIterFinalize(pIter);
199960 static int rbuObjIterFirst(sqlite3rbu *p, RbuObjIter *pIter){
199962 memset(pIter, 0, sizeof(RbuObjIter));
199964 rc = prepareFreeAndCollectError(p->dbRbu, &pIter->pTblIter, &p->zErrmsg,
199974 rc = prepareAndCollectError(p->dbMain, &pIter->pIdxIter, &p->zErrmsg,
199981 pIter->bCleanup = 1;
199983 return rbuObjIterNext(p, pIter);
200063 ** Allocate and zero the pIter->azTblCol[] and abTblPk[] arrays so that
200067 static void rbuAllocateIterArrays(sqlite3rbu *p, RbuObjIter *pIter, int nCol){
200073 pIter->azTblCol = azNew;
200074 pIter->azTblType = &azNew[nCol];
200075 pIter->aiSrcOrder = (int*)&pIter->azTblType[nCol];
200076 pIter->abTblPk = (u8*)&pIter->aiSrcOrder[nCol];
200077 pIter->abNotNull = (u8*)&pIter->abTblPk[nCol];
200078 pIter->abIndexed = (u8*)&pIter->abNotNull[nCol];
200247 ** the pIter->abIndexed[] array.
200249 static void rbuObjIterCacheIndexedCols(sqlite3rbu *p, RbuObjIter *pIter){
200254 memcpy(pIter->abIndexed, pIter->abTblPk, sizeof(u8)*pIter->nTblCol);
200256 sqlite3_mprintf("PRAGMA main.index_list = %Q", pIter->zTbl)
200260 pIter->nIndex = 0;
200267 memset(pIter->abIndexed, 0x01, sizeof(u8)*pIter->nTblCol);
200274 if( iCid>=0 ) pIter->abIndexed[iCid] = 1;
200276 memset(pIter->abIndexed, 0x01, sizeof(u8)*pIter->nTblCol);
200281 pIter->nIndex++;
200284 if( pIter->eType==RBU_PK_WITHOUT_ROWID ){
200286 pIter->nIndex--;
200290 if( bIndex==0 ) pIter->abIndexed = 0;
200295 ** If they are not already populated, populate the pIter->azTblCol[],
200296 ** pIter->abTblPk[], pIter->nTblCol and pIter->bRowid variables according to
200303 static int rbuObjIterCacheTableInfo(sqlite3rbu *p, RbuObjIter *pIter){
200304 if( pIter->azTblCol==0 ){
200313 assert( pIter->eType==0 );
200314 rbuTableType(p, pIter->zTbl, &pIter->eType, &iTnum, &pIter->iPkTnum);
200315 if( p->rc==SQLITE_OK && pIter->eType==RBU_PK_NOTABLE ){
200317 p->zErrmsg = sqlite3_mprintf("no such table: %s", pIter->zTbl);
200320 if( pIter->zIdx==0 ) pIter->iTnum = iTnum;
200322 assert( pIter->eType==RBU_PK_NONE || pIter->eType==RBU_PK_IPK
200323 || pIter->eType==RBU_PK_EXTERNAL || pIter->eType==RBU_PK_WITHOUT_ROWID
200324 || pIter->eType==RBU_PK_VTAB
200331 sqlite3_mprintf("SELECT * FROM '%q'", pIter->zDataTbl)
200335 rbuAllocateIterArrays(p, pIter, nCol);
200341 pIter->aiSrcOrder[pIter->nTblCol] = pIter->nTblCol;
200342 pIter->azTblCol[pIter->nTblCol++] = zCopy;
200353 && bRbuRowid!=(pIter->eType==RBU_PK_VTAB || pIter->eType==RBU_PK_NONE)
200357 "table %q %s rbu_rowid column", pIter->zDataTbl,
200367 sqlite3_mprintf("PRAGMA table_info(%Q)", pIter->zTbl)
200373 for(i=iOrder; i<pIter->nTblCol; i++){
200374 if( 0==strcmp(zName, pIter->azTblCol[i]) ) break;
200376 if( i==pIter->nTblCol ){
200379 pIter->zDataTbl, zName
200387 SWAP(int, pIter->aiSrcOrder[i], pIter->aiSrcOrder[iOrder]);
200388 SWAP(char*, pIter->azTblCol[i], pIter->azTblCol[iOrder]);
200391 pIter->azTblType[iOrder] = rbuStrndup(zType, &p->rc);
200393 pIter->abTblPk[iOrder] = (u8)iPk;
200394 pIter->abNotNull[iOrder] = (u8)bNotNull || (iPk!=0);
200400 rbuObjIterCacheIndexedCols(p, pIter);
200401 assert( pIter->eType!=RBU_PK_VTAB || pIter->abIndexed==0 );
200402 assert( pIter->eType!=RBU_PK_VTAB || pIter->nIndex==0 );
200411 ** column names currently stored in the pIter->azTblCol[] array.
200415 RbuObjIter *pIter /* Object iterator for column names */
200420 for(i=0; i<pIter->nTblCol; i++){
200421 const char *z = pIter->azTblCol[i];
200436 RbuObjIter *pIter, /* Object iterator for column names */
200446 for(i=0; i<pIter->nTblCol; i++){
200447 if( (int)pIter->abTblPk[i]==iPk ){
200448 const char *zCol = pIter->azTblCol[i];
200454 if( i==pIter->nTblCol ) break;
200481 RbuObjIter *pIter, /* RBU iterator object */
200490 "SELECT max(_rowid_) FROM \"%s%w\"", zWrite, pIter->zTbl
200499 char *zOrder = rbuObjIterGetPkList(p, pIter, "", ", ", " DESC");
200500 char *zSelect = rbuObjIterGetPkList(p, pIter, "quote(", "||','||", ")");
200501 char *zList = rbuObjIterGetPkList(p, pIter, "", ", ", "");
200507 zSelect, zWrite, pIter->zTbl, zOrder
200548 RbuObjIter *pIter /* RBU iterator object */
200561 sqlite3_mprintf("PRAGMA main.index_xinfo = %Q", pIter->zIdx)
200573 if( pIter->eType==RBU_PK_IPK ){
200575 for(i=0; pIter->abTblPk[i]==0; i++);
200576 assert( i<pIter->nTblCol );
200577 zCol = pIter->azTblCol[i];
200582 zCol = pIter->azTblCol[iCid];
200605 zSelect, pIter->zTbl, zOrder
200610 for(iCol=0; iCol<pIter->nCol; iCol++){
200661 RbuObjIter *pIter, /* Object iterator for column names */
200681 sqlite3_mprintf("PRAGMA main.index_xinfo = %Q", pIter->zIdx)
200695 pIter->aIdxCol[iSeq].nSpan, pIter->aIdxCol[iSeq].zSpan, zCollate
200702 if( pIter->eType==RBU_PK_IPK ){
200704 for(i=0; pIter->abTblPk[i]==0; i++);
200705 assert( i<pIter->nTblCol );
200706 zCol = pIter->azTblCol[i];
200714 zCol = pIter->azTblCol[iCid];
200715 zType = pIter->azTblType[iCid];
200720 if( pIter->bUnique==0 || sqlite3_column_int(pXInfo, 5) ){
200773 RbuObjIter *pIter,
200777 if( p->rc==SQLITE_OK && pIter->abIndexed ){
200780 for(i=0; i<pIter->nTblCol; i++){
200781 if( pIter->abIndexed[i] ){
200782 const char *zCol = pIter->azTblCol[i];
200795 if( pIter->eType==RBU_PK_EXTERNAL || pIter->eType==RBU_PK_NONE ){
200814 RbuObjIter *pIter
200817 if( pIter->eType==RBU_PK_VTAB || pIter->eType==RBU_PK_NONE ){
200818 zList = rbuMPrintf(p, "_rowid_ = ?%d", pIter->nTblCol+1);
200819 }else if( pIter->eType==RBU_PK_EXTERNAL ){
200822 for(i=0; i<pIter->nTblCol; i++){
200823 if( pIter->abTblPk[i] ){
200835 for(i=0; i<pIter->nTblCol; i++){
200836 if( pIter->abTblPk[i] ){
200837 const char *zCol = pIter->azTblCol[i];
200878 RbuObjIter *pIter,
200885 if( (int)strlen(zMask)!=pIter->nTblCol ){
200889 for(i=0; i<pIter->nTblCol; i++){
200890 char c = zMask[pIter->aiSrcOrder[i]];
200893 zList, zSep, pIter->azTblCol[i], i+1
200899 zList, zSep, pIter->azTblCol[i], pIter->azTblCol[i], i+1
200905 zList, zSep, pIter->azTblCol[i], pIter->azTblCol[i], i+1
200957 static char *rbuWithoutRowidPK(sqlite3rbu *p, RbuObjIter *pIter){
200959 assert( pIter->zIdx==0 );
200962 sqlite3_stmt *pXList = 0; /* PRAGMA index_list = (pIter->zTbl) */
200966 sqlite3_mprintf("PRAGMA main.index_list = %Q", pIter->zTbl)
201016 static void rbuCreateImposterTable2(sqlite3rbu *p, RbuObjIter *pIter){
201017 if( p->rc==SQLITE_OK && pIter->eType==RBU_PK_EXTERNAL ){
201018 int tnum = pIter->iPkTnum; /* Root page of PK index */
201052 iCid, pIter->azTblType[iCid], zCollate
201090 static void rbuCreateImposterTable(sqlite3rbu *p, RbuObjIter *pIter){
201091 if( p->rc==SQLITE_OK && pIter->eType!=RBU_PK_VTAB ){
201092 int tnum = pIter->iTnum;
201098 for(iCol=0; p->rc==SQLITE_OK && iCol<pIter->nTblCol; iCol++){
201100 const char *zCol = pIter->azTblCol[iCol];
201104 p->dbMain, "main", pIter->zTbl, zCol, 0, &zColl, 0, 0, 0
201107 if( pIter->eType==RBU_PK_IPK && pIter->abTblPk[iCol] ){
201113 zSql, zComma, zCol, pIter->azTblType[iCol], zPk, zColl,
201114 (pIter->abNotNull[iCol] ? " NOT NULL" : "")
201119 if( pIter->eType==RBU_PK_WITHOUT_ROWID ){
201120 char *zPk = rbuWithoutRowidPK(p, pIter);
201128 pIter->zTbl, zSql,
201129 (pIter->eType==RBU_PK_WITHOUT_ROWID ? " WITHOUT ROWID" : "")
201148 RbuObjIter *pIter,
201152 int bRbuRowid = (pIter->eType==RBU_PK_EXTERNAL || pIter->eType==RBU_PK_NONE);
201153 char *zBind = rbuObjIterGetBindlist(p, pIter->nTblCol + 1 + bRbuRowid);
201155 assert( pIter->pTmpInsert==0 );
201157 p->dbRbu, &pIter->pTmpInsert, &p->zErrmsg, sqlite3_mprintf(
201159 p->zStateDb, pIter->zDataTbl, zCollist, zRbuRowid, zBind
201194 static char *rbuObjIterGetIndexWhere(sqlite3rbu *p, RbuObjIter *pIter){
201199 assert( pIter->zIdxSql==0 && pIter->nIdxCol==0 && pIter->aIdxCol==0 );
201208 rc = sqlite3_bind_text(pStmt, 1, pIter->zIdx, -1, SQLITE_STATIC);
201212 pIter->zIdxSql = zSql = rbuStrndup(zSql, &rc);
201222 /* If necessary, grow the pIter->aIdxCol[] array */
201225 pIter->aIdxCol, (nIdxAlloc+16)*sizeof(RbuSpan)
201231 pIter->aIdxCol = aIdxCol;
201238 pIter->aIdxCol[0].zSpan = &zSql[i+1];
201245 int nSpan = &zSql[i] - pIter->aIdxCol[iIdxCol].zSpan;
201246 pIter->aIdxCol[iIdxCol++].nSpan = nSpan;
201251 int nSpan = &zSql[i] - pIter->aIdxCol[iIdxCol].zSpan;
201252 pIter->aIdxCol[iIdxCol++].nSpan = nSpan;
201253 pIter->aIdxCol[iIdxCol].zSpan = &zSql[i+1];
201277 pIter->nIdxCol = iIdxCol;
201296 RbuObjIter *pIter,
201299 assert( pIter->bCleanup==0 );
201300 if( pIter->pSelect==0 && rbuObjIterCacheTableInfo(p, pIter)==SQLITE_OK ){
201301 const int tnum = pIter->iTnum;
201304 const char *zIdx = pIter->zIdx;
201313 const char *zTbl = pIter->zTbl;
201321 assert( pIter->eType!=RBU_PK_VTAB );
201322 zPart = rbuObjIterGetIndexWhere(p, pIter);
201324 p, pIter, &zImposterCols, &zImposterPK, &zWhere, &nBind
201338 pIter->nCol = nBind;
201341 p->dbMain, &pIter->pInsert, &p->zErrmsg,
201349 p->dbMain, &pIter->pDelete, &p->zErrmsg,
201360 zStart = rbuVacuumIndexStart(p, pIter);
201370 pIter->zDataTbl,
201378 if( pIter->eType==RBU_PK_EXTERNAL || pIter->eType==RBU_PK_NONE ){
201381 zCollist, p->zStateDb, pIter->zDataTbl,
201391 zCollist, p->zStateDb, pIter->zDataTbl, zPart,
201392 zCollist, pIter->zDataTbl,
201399 p->rc = prepareFreeAndCollectError(p->dbRbu,&pIter->pSelect,pz,zSql);
201411 int bRbuRowid = (pIter->eType==RBU_PK_VTAB)
201412 ||(pIter->eType==RBU_PK_NONE)
201413 ||(pIter->eType==RBU_PK_EXTERNAL && rbuIsVacuum(p));
201414 const char *zTbl = pIter->zTbl; /* Table this step applies to */
201417 char *zBindings = rbuObjIterGetBindlist(p, pIter->nTblCol + bRbuRowid);
201418 char *zWhere = rbuObjIterGetWhere(p, pIter);
201419 char *zOldlist = rbuObjIterGetOldlist(p, pIter, "old");
201420 char *zNewlist = rbuObjIterGetOldlist(p, pIter, "new");
201422 zCollist = rbuObjIterGetCollist(p, pIter);
201423 pIter->nCol = pIter->nTblCol;
201426 rbuCreateImposterTable(p, pIter);
201427 rbuCreateImposterTable2(p, pIter);
201428 zWrite = (pIter->eType==RBU_PK_VTAB ? "" : "rbu_imp_");
201432 p->rc = prepareFreeAndCollectError(p->dbMain, &pIter->pInsert, pz,
201444 p->rc = prepareFreeAndCollectError(p->dbMain, &pIter->pDelete, pz,
201451 if( rbuIsVacuum(p)==0 && pIter->abIndexed ){
201453 if( pIter->eType==RBU_PK_EXTERNAL || pIter->eType==RBU_PK_NONE ){
201461 , p->zStateDb, pIter->zDataTbl
201462 , (pIter->eType==RBU_PK_EXTERNAL ? ", 0 AS rbu_rowid" : "")
201463 , pIter->zDataTbl
201486 if( pIter->eType==RBU_PK_EXTERNAL || pIter->eType==RBU_PK_NONE ){
201496 rbuObjIterPrepareTmpInsert(p, pIter, zCollist, zRbuRowid);
201510 zStart = rbuVacuumTableStart(p, pIter, bRbuRowid, zWrite);
201519 zOrder = rbuObjIterGetPkList(p, pIter, "", ", ", "");
201524 p->rc = prepareFreeAndCollectError(p->dbRbu, &pIter->pSelect, pz,
201530 pIter->zDataTbl, (zStart ? zStart : ""),
201555 ** table object that pIter currently points to, assuming that the
201563 RbuObjIter *pIter, /* Object iterator */
201578 for(pp=&pIter->pRbuUpdate; *pp; pp=&((*pp)->pNext)){
201582 pUp->pNext = pIter->pRbuUpdate;
201583 pIter->pRbuUpdate = pUp;
201592 for(pp=&pIter->pRbuUpdate; *pp!=pUp; pp=&((*pp)->pNext));
201597 pUp = (RbuUpdateStmt*)rbuMalloc(p, sizeof(RbuUpdateStmt)+pIter->nTblCol+1);
201601 char *zWhere = rbuObjIterGetWhere(p, pIter);
201602 char *zSet = rbuObjIterGetSetlist(p, pIter, zMask);
201606 memcpy(pUp->zMask, zMask, pIter->nTblCol);
201607 pUp->pNext = pIter->pRbuUpdate;
201608 pIter->pRbuUpdate = pUp;
201613 if( pIter->eType!=RBU_PK_VTAB ) zPrefix = "rbu_imp_";
201615 zPrefix, pIter->zTbl, zSet, zWhere
202306 RbuObjIter *pIter = &p->objiter;
202312 assert( eType!=RBU_DELETE || pIter->zIdx==0 );
202326 pWriter = pIter->pDelete;
202328 pWriter = pIter->pInsert;
202331 for(i=0; i<pIter->nCol; i++){
202336 && pIter->zIdx==0 && pIter->eType==RBU_PK_IPK && pIter->abTblPk[i]
202337 && sqlite3_column_type(pIter->pSelect, i)==SQLITE_NULL
202344 if( eType==RBU_DELETE && pIter->abTblPk[i]==0 ){
202348 pVal = sqlite3_column_value(pIter->pSelect, i);
202352 if( pIter->zIdx==0 ){
202353 if( pIter->eType==RBU_PK_VTAB
202354 || pIter->eType==RBU_PK_NONE
202355 || (pIter->eType==RBU_PK_EXTERNAL && rbuIsVacuum(p))
202362 ** Hence column_value(pIter->nCol+1).
202364 assertColumnName(pIter->pSelect, pIter->nCol+1,
202367 pVal = sqlite3_column_value(pIter->pSelect, pIter->nCol+1);
202368 p->rc = sqlite3_bind_value(pWriter, pIter->nCol+1, pVal);
202389 RbuObjIter *pIter = &p->objiter;
202398 assert( eType!=RBU_UPDATE || pIter->zIdx==0 );
202400 if( pIter->zIdx==0 && (eType==RBU_IDX_DELETE || eType==RBU_IDX_INSERT) ){
202404 if( pIter->zIdx==0 ){
202418 rbuGetUpdateStmt(p, pIter, zMask, &pUpdate);
202421 for(i=0; p->rc==SQLITE_OK && i<pIter->nCol; i++){
202422 char c = zMask[pIter->aiSrcOrder[i]];
202423 pVal = sqlite3_column_value(pIter->pSelect, i);
202424 if( pIter->abTblPk[i] || c!='.' ){
202429 && (pIter->eType==RBU_PK_VTAB || pIter->eType==RBU_PK_NONE)
202432 assertColumnName(pIter->pSelect, pIter->nCol+1, "rbu_rowid");
202433 pVal = sqlite3_column_value(pIter->pSelect, pIter->nCol+1);
202434 p->rc = sqlite3_bind_value(pUpdate, pIter->nCol+1, pVal);
202621 RbuObjIter *pIter = &p->objiter;
202631 while( p->rc==SQLITE_OK && pIter->zTbl ){
202633 if( pIter->bCleanup ){
202637 if( rbuIsVacuum(p)==0 && pIter->abIndexed ){
202639 "DELETE FROM %s.'rbu_tmp_%q'", p->zStateDb, pIter->zDataTbl
202643 rbuObjIterPrepareAll(p, pIter, 0);
202647 int rc = sqlite3_step(pIter->pSelect);
202653 p->rc = sqlite3_reset(pIter->pSelect);
202658 rbuObjIterNext(p, pIter);
202662 assert( pIter->zTbl==0 );
202765 RbuObjIter *pIter = &p->objiter;
202768 while( rc==SQLITE_OK && pIter->zTbl && (pIter->bCleanup
202769 || rbuStrCompare(pIter->zIdx, pState->zIdx)
202770 || (pState->zDataTbl==0 && rbuStrCompare(pIter->zTbl, pState->zTbl))
202771 || (pState->zDataTbl && rbuStrCompare(pIter->zDataTbl, pState->zDataTbl))
202773 rc = rbuObjIterNext(p, pIter);
202776 if( rc==SQLITE_OK && !pIter->zTbl ){
203429 rbu_file *pIter;
203433 for(pIter=pRbuVfs->pMain; pIter; pIter=pIter->pMainNext);
203437 for(pIter=pRbuVfs->pMainRbu; pIter && pIter!=p; pIter=pIter->pMainRbuNext){}
203438 if( pIter==0 ){
208763 sqlite3_changeset_iter *pIter, /* Iterator handle */
208769 *pOp = pIter->op;
208770 *pnCol = pIter->nCol;
208771 *pzTab = pIter->zTab;
208772 if( pbIndirect ) *pbIndirect = pIter->bIndirect;
208778 ** the database table affected by the change that pIter currently points
208783 sqlite3_changeset_iter *pIter, /* Iterator object */
208787 *pabPK = pIter->abPK;
208788 if( pnCol ) *pnCol = pIter->nCol;
208806 sqlite3_changeset_iter *pIter, /* Changeset iterator */
208810 if( pIter->op!=SQLITE_UPDATE && pIter->op!=SQLITE_DELETE ){
208813 if( iVal<0 || iVal>=pIter->nCol ){
208816 *ppValue = pIter->apValue[iVal];
208834 sqlite3_changeset_iter *pIter, /* Changeset iterator */
208838 if( pIter->op!=SQLITE_UPDATE && pIter->op!=SQLITE_INSERT ){
208841 if( iVal<0 || iVal>=pIter->nCol ){
208844 *ppValue = pIter->apValue[pIter->nCol+iVal];
208853 #define sessionChangesetNew(pIter, iVal) (pIter)->apValue[(pIter)->nCol+(iVal)]
208854 #define sessionChangesetOld(pIter, iVal) (pIter)->apValue[(iVal)]
208868 sqlite3_changeset_iter *pIter, /* Changeset iterator */
208872 if( !pIter->pConflict ){
208875 if( iVal<0 || iVal>=pIter->nCol ){
208878 *ppValue = sqlite3_column_value(pIter->pConflict, iVal);
208891 sqlite3_changeset_iter *pIter, /* Changeset iterator */
208894 if( pIter->pConflict || pIter->apValue ){
208897 *pnOut = pIter->nCol;
209158 sqlite3_changeset_iter *pIter,
209165 int nCol = pIter->nCol;
209166 int nU32 = (pIter->nCol+33)/32;
209179 for(ii=0; ii<pIter->nCol; ii++){
209180 if( sessionChangesetNew(pIter, ii) ){
209218 int bStat1 = (sqlite3_stricmp(pIter->zTab, "sqlite_stat1")==0);
209231 sessionAppendIdent(&buf, pIter->zTab, &rc);
209235 for(ii=0; ii<pIter->nCol; ii++){
209236 if( p->abPK[ii]==0 && sessionChangesetNew(pIter, ii) ){
209248 for(ii=0; ii<pIter->nCol; ii++){
209249 if( p->abPK[ii] || (bPatchset==0 && sessionChangesetOld(pIter, ii)) ){
209492 ** Iterator pIter must point to an SQLITE_INSERT entry. This function
209506 sqlite3_changeset_iter *pIter, /* Iterator to read values from */
209524 (void)xValue(pIter, i, &pVal);
209540 ** iterator pIter points to to the SELECT and attempts to seek to the table
209556 sqlite3_changeset_iter *pIter, /* Changeset iterator */
209565 sqlite3changeset_op(pIter, &zDummy, &nCol, &op, 0);
209566 rc = sessionBindRow(pIter,
209592 sqlite3_changeset_iter *pIter /* Iterator pointing at current change */
209597 int eOp = pIter->op;
209600 const char *zTab = pIter->zTab;
209618 sqlite3changeset_old(pIter, i, &pVal);
209620 sqlite3changeset_new(pIter, i, &pVal);
209666 sqlite3_changeset_iter *pIter, /* Changeset iterator */
209677 sqlite3changeset_op(pIter, &zDummy, &nCol, &op, 0);
209685 rc = sessionSeekToRow(p->db, pIter, p->abPK, p->pSelect);
209692 pIter->pConflict = p->pSelect;
209693 res = xConflict(pCtx, eType, pIter);
209694 pIter->pConflict = 0;
209700 u8 *aBlob = &pIter->in.aData[pIter->in.iCurrent];
209701 int nBlob = pIter->in.iNext - pIter->in.iCurrent;
209706 res = xConflict(pCtx, eType+1, pIter);
209730 rc = sessionRebaseAdd(p, res, pIter);
209762 sqlite3_changeset_iter *pIter, /* Changeset iterator */
209778 sqlite3changeset_op(pIter, &zDummy, &nCol, &op, 0);
209793 u8 *abPK = (pIter->bPatchset ? p->abPK : 0);
209794 rc = sessionBindRow(pIter, sqlite3changeset_old, nCol, abPK, p->pDelete);
209804 SQLITE_CHANGESET_DATA, p, pIter, xConflict, pCtx, pbRetry
209808 SQLITE_CHANGESET_CONFLICT, p, pIter, xConflict, pCtx, 0
209815 int bPatchset = (pbRetry==0 || pIter->bPatchset);
209817 rc = sessionUpdateFind(pIter, p, bPatchset, &pUp);
209821 sqlite3_value *pOld = sessionChangesetOld(pIter, i);
209822 sqlite3_value *pNew = sessionChangesetNew(pIter, i);
209843 SQLITE_CHANGESET_DATA, p, pIter, xConflict, pCtx, pbRetry
209849 SQLITE_CHANGESET_CONFLICT, p, pIter, xConflict, pCtx, 0
209859 rc = sessionSeekToRow(p->db, pIter, p->abPK, p->pSelect);
209867 rc = sessionBindRow(pIter, sqlite3changeset_new, nCol, 0, p->pInsert);
209876 SQLITE_CHANGESET_CONFLICT, p, pIter, xConflict, pCtx, pbReplace
209896 sqlite3_changeset_iter *pIter, /* Changeset iterator to read change from */
209905 rc = sessionApplyOneOp(pIter, pApply, xConflict, pCtx, &bReplace, &bRetry);
209915 assert( pIter->op==SQLITE_UPDATE || pIter->op==SQLITE_DELETE );
209916 rc = sessionApplyOneOp(pIter, pApply, xConflict, pCtx, 0, 0);
209925 assert( pIter->op==SQLITE_INSERT );
209928 rc = sessionBindRow(pIter,
209937 rc = sessionApplyOneOp(pIter, pApply, xConflict, pCtx, 0, 0);
210001 ** Argument pIter is a changeset iterator that has been initialized, but
210009 sqlite3_changeset_iter *pIter, /* Changeset to apply */
210032 pIter->in.bNoDiscard = 1;
210043 while( rc==SQLITE_OK && SQLITE_ROW==sqlite3changeset_next(pIter) ){
210048 sqlite3changeset_op(pIter, &zNew, &nCol, &op, 0);
210054 db, pIter->bPatchset, zTab, &sApply, xConflict, pCtx
210091 sqlite3changeset_pk(pIter, &abPK, 0);
210145 rc = sessionApplyOneWithRetry(db, pIter, &sApply, xConflict, pCtx);
210148 bPatchset = pIter->bPatchset;
210150 rc = sqlite3changeset_finalize(pIter);
210152 sqlite3changeset_finalize(pIter);
210222 sqlite3_changeset_iter *pIter; /* Iterator to skip through changeset */
210224 int rc = sessionChangesetStart(&pIter, 0, 0, nChangeset, pChangeset, bInv, 1);
210227 db, pIter, xFilter, xConflict, pCtx, ppRebase, pnRebase, flags
210280 sqlite3_changeset_iter *pIter; /* Iterator to skip through changeset */
210282 int rc = sessionChangesetStart(&pIter, xInput, pIn, 0, 0, bInverse, 1);
210285 db, pIter, xFilter, xConflict, pCtx, ppRebase, pnRebase, flags
210507 sqlite3_changeset_iter *pIter, /* Iterator to read from */
210516 while( SQLITE_ROW==sessionChangesetNext(pIter, &aRec, &nRec, 0) ){
210527 pGrp->bPatch = pIter->bPatchset;
210528 }else if( pIter->bPatchset!=pGrp->bPatch ){
210533 sqlite3changeset_op(pIter, &zNew, &nCol, &op, &bIndirect);
210539 sqlite3changeset_pk(pIter, &abPK, 0);
210570 if( sessionGrowHash(0, pIter->bPatchset, pTab) ){
210575 pTab, (pIter->bPatchset && op==SQLITE_DELETE), aRec, pTab->nChange
210584 if( pIter->bPatchset ){
210597 pIter->bPatchset, pExist, op, bIndirect, aRec, nRec, &pChange
210607 if( rc==SQLITE_OK ) rc = pIter->rc;
210698 sqlite3_changeset_iter *pIter; /* Iterator opened on pData/nData */
210701 rc = sqlite3changeset_start(&pIter, nData, pData);
210703 rc = sessionChangesetToHash(pIter, pGrp, 0);
210705 sqlite3changeset_finalize(pIter);
210729 sqlite3_changeset_iter *pIter; /* Iterator opened on pData/nData */
210732 rc = sqlite3changeset_start_strm(&pIter, xInput, pIn);
210734 rc = sessionChangesetToHash(pIter, pGrp, 0);
210736 sqlite3changeset_finalize(pIter);
210883 sqlite3_changeset_iter *pIter, /* Iterator pointed at local change */
210897 *pOut++ = pIter->bIndirect;
210898 for(i=0; i<pIter->nCol; i++){
210901 if( pIter->abPK[i] || a2[0]==0 ){
210902 if( !pIter->abPK[i] && a1[0] ) bData = 1;
210917 for(i=0; i<pIter->nCol; i++){
210920 if( pIter->abPK[i] || a2[0]!=0xFF ){
210935 ** pIter is configured to iterate through a changeset. This function rebases
210951 sqlite3_changeset_iter *pIter, /* Input data */
210964 while( SQLITE_ROW==sessionChangesetNext(pIter, &aRec, &nRec, &bNew) ){
210969 const char *zTab = pIter->zTab;
210976 if( pIter->bPatchset ){
210981 sessionAppendByte(&sOut, pIter->bPatchset ? 'P' : 'T', &rc);
210982 sessionAppendVarint(&sOut, pIter->nCol, &rc);
210983 sessionAppendBlob(&sOut, pIter->abPK, pIter->nCol, &rc);
210984 sessionAppendBlob(&sOut,(u8*)pIter->zTab,(int)strlen(pIter->zTab)+1,&rc);
210999 switch( pIter->op ){
211005 sessionAppendByte(&sOut, pIter->bIndirect, &rc);
211017 sessionSkipRecord(&pCsr, pIter->nCol);
211019 sessionAppendByte(&sOut, pIter->bIndirect, &rc);
211020 sessionAppendRecordMerge(&sOut, pIter->nCol,
211026 sessionAppendPartialUpdate(&sOut, pIter,
211033 assert( pIter->op==SQLITE_DELETE );
211037 sessionAppendByte(&sOut, pIter->bIndirect, &rc);
211038 sessionAppendRecordMerge(&sOut, pIter->nCol,
211047 sessionAppendByte(&sOut, pIter->op, &rc);
211048 sessionAppendByte(&sOut, pIter->bIndirect, &rc);
211102 sqlite3_changeset_iter *pIter = 0; /* Iterator opened on pData/nData */
211104 rc = sqlite3changeset_start(&pIter, nRebase, (void*)pRebase);
211106 rc = sessionChangesetToHash(pIter, &p->grp, 1);
211108 sqlite3changeset_finalize(pIter);
211120 sqlite3_changeset_iter *pIter = 0; /* Iterator to skip through input */
211121 int rc = sqlite3changeset_start(&pIter, nIn, (void*)pIn);
211124 rc = sessionRebase(p, pIter, 0, 0, pnOut, ppOut);
211125 sqlite3changeset_finalize(pIter);
211141 sqlite3_changeset_iter *pIter = 0; /* Iterator to skip through input */
211142 int rc = sqlite3changeset_start_strm(&pIter, xInput, pIn);
211145 rc = sessionRebase(p, pIter, xOutput, pOut, 0, 0);
211146 sqlite3changeset_finalize(pIter);
212082 Fts5PoslistReader *pIter /* Iterator object to initialize */
214166 static int fts5CInstIterNext(CInstIter *pIter){
214168 pIter->iStart = -1;
214169 pIter->iEnd = -1;
214171 while( rc==SQLITE_OK && pIter->iInst<pIter->nInst ){
214173 rc = pIter->pApi->xInst(pIter->pFts, pIter->iInst, &ip, &ic, &io);
214175 if( ic==pIter->iCol ){
214176 int iEnd = io - 1 + pIter->pApi->xPhraseSize(pIter->pFts, ip);
214177 if( pIter->iStart<0 ){
214178 pIter->iStart = io;
214179 pIter->iEnd = iEnd;
214180 }else if( io<=pIter->iEnd ){
214181 if( iEnd>pIter->iEnd ) pIter->iEnd = iEnd;
214186 pIter->iInst++;
214201 CInstIter *pIter
214205 memset(pIter, 0, sizeof(CInstIter));
214206 pIter->pApi = pApi;
214207 pIter->pFts = pFts;
214208 pIter->iCol = iCol;
214209 rc = pApi->xInstCount(pFts, &pIter->nInst);
214212 rc = fts5CInstIterNext(pIter);
215033 static int sqlite3Fts5PoslistReaderNext(Fts5PoslistReader *pIter){
215034 if( sqlite3Fts5PoslistNext64(pIter->a, pIter->n, &pIter->i, &pIter->iPos) ){
215035 pIter->bEof = 1;
215037 return pIter->bEof;
215042 Fts5PoslistReader *pIter /* Iterator object to initialize */
215044 memset(pIter, 0, sizeof(*pIter));
215045 pIter->a = a;
215046 pIter->n = n;
215047 sqlite3Fts5PoslistReaderNext(pIter);
215048 return pIter->bEof;
216286 Fts5IndexIter *pIter; /* Iterator for this term */
216631 if( 0==sqlite3Fts5IterEof(p->pIter) ){
216632 i64 iRowid = p->pIter->iRowid;
216662 Fts5IndexIter *pIter = p->pIter;
216663 if( sqlite3Fts5IterEof(pIter)==0 && pIter->iRowid==iRowid ){
216664 if( pIter->nData==0 ) continue;
216677 sqlite3Fts5PoslistReaderInit(pIter->pData, pIter->nData, &aIter[nIter]);
216768 a = (u8*)pTerm->pIter->pData;
216769 n = pTerm->pIter->nData;
216959 ** Advance iterator pIter until it points to a value equal to or laster
216968 Fts5IndexIter *pIter, /* Iterator to advance */
216977 iRowid = pIter->iRowid;
216979 int rc = sqlite3Fts5IterNextFrom(pIter, iLast);
216980 if( rc || sqlite3Fts5IterEof(pIter) ){
216985 iRowid = pIter->iRowid;
217005 if( sqlite3Fts5IterEof(p->pIter)==0 ){
217006 i64 iRowid = p->pIter->iRowid;
217008 rc = sqlite3Fts5IterNextFrom(p->pIter, iLast);
217036 Fts5IndexIter *pIter = pTerm->pIter;
217037 if( sqlite3Fts5IterEof(pIter)==0 ){
217038 if( pIter->iRowid==pNode->iRowid && pIter->nData>0 ){
217059 Fts5IndexIter *pIter = pPhrase->aTerm[0].pIter;
217060 fts5BufferSet(&rc, &pPhrase->poslist, pIter->nData, pIter->pData);
217104 if( p->pIter ){
217105 sqlite3Fts5IterClose(p->pIter);
217106 p->pIter = 0;
217113 &p->pIter
217115 assert( (rc==SQLITE_OK)==(p->pIter!=0) );
217117 if( 0==sqlite3Fts5IterEof(p->pIter) ){
217245 iLast = pLeft->aTerm[0].pIter->iRowid;
217264 Fts5IndexIter *pIter = pPhrase->aTerm[j].pIter;
217265 if( pIter->iRowid==iLast || pIter->bEof ) continue;
217267 if( fts5ExprAdvanceto(pIter, bDesc, &iLast, &rc, &pNode->bEof) ){
217309 if( sqlite3Fts5IterEof(p->pIter)==0 ){
217310 i64 ii = p->pIter->iRowid;
217315 rc = sqlite3Fts5IterNextFrom(p->pIter, iFrom);
217317 rc = sqlite3Fts5IterNext(p->pIter);
217320 if( sqlite3Fts5IterEof(p->pIter)==0 ){
217333 Fts5IndexIter *pIter = pTerm->pIter;
217337 rc = sqlite3Fts5IterNextFrom(pIter, iFrom);
217339 rc = sqlite3Fts5IterNext(pIter);
217342 pNode->bEof = (rc || sqlite3Fts5IterEof(pIter));
217364 Fts5IndexIter *pIter = pPhrase->aTerm[0].pIter;
217370 pPhrase->poslist.n = pIter->nData;
217372 pPhrase->poslist.p = (u8*)pIter->pData;
217374 pNode->iRowid = pIter->iRowid;
217389 Fts5IndexIter *pIter = pNode->pNear->apPhrase[0]->aTerm[0].pIter;
217393 rc = sqlite3Fts5IterNextFrom(pIter, iFrom);
217395 rc = sqlite3Fts5IterNext(pIter);
217397 if( rc==SQLITE_OK && sqlite3Fts5IterEof(pIter)==0 ){
217747 sqlite3Fts5IterClose(pTerm->pIter);
217750 sqlite3Fts5IterClose(pSyn->pIter);
219237 *ppCollist = pPhrase->aTerm[0].pIter->pData;
219238 *pnCollist = pPhrase->aTerm[0].pIter->nData;
219704 Fts5HashEntry *pIter;
219705 for(pIter=pHash->aSlot[iSlot]; pIter; pIter=pIter->pHashNext){
219707 || (pIter->nKey+1>=nTerm && 0==memcmp(fts5EntryKey(pIter), pTerm, nTerm))
219709 Fts5HashEntry *pEntry = pIter;
221115 static int fts5DlidxIterNextR(Fts5Index *p, Fts5DlidxIter *pIter, int iLvl){
221116 Fts5DlidxLvl *pLvl = &pIter->aLvl[iLvl];
221118 assert( iLvl<pIter->nLvl );
221120 if( (iLvl+1) < pIter->nLvl ){
221121 fts5DlidxIterNextR(p, pIter, iLvl+1);
221126 FTS5_DLIDX_ROWID(pIter->iSegid, iLvl, pLvl[1].iLeafPgno)
221133 return pIter->aLvl[0].bEof;
221135 static int fts5DlidxIterNext(Fts5Index *p, Fts5DlidxIter *pIter){
221136 return fts5DlidxIterNextR(p, pIter, 0);
221147 ** When this function is called pIter->iLeafPgno is the page number the
221150 static int fts5DlidxIterFirst(Fts5DlidxIter *pIter){
221152 for(i=0; i<pIter->nLvl; i++){
221153 fts5DlidxLvlNext(&pIter->aLvl[i]);
221155 return pIter->aLvl[0].bEof;
221159 static int fts5DlidxIterEof(Fts5Index *p, Fts5DlidxIter *pIter){
221160 return p->rc!=SQLITE_OK || pIter->aLvl[0].bEof;
221163 static void fts5DlidxIterLast(Fts5Index *p, Fts5DlidxIter *pIter){
221167 for(i=pIter->nLvl-1; p->rc==SQLITE_OK && i>=0; i--){
221168 Fts5DlidxLvl *pLvl = &pIter->aLvl[i];
221177 FTS5_DLIDX_ROWID(pIter->iSegid, i-1, pLvl->iLeafPgno)
221235 static int fts5DlidxIterPrevR(Fts5Index *p, Fts5DlidxIter *pIter, int iLvl){
221236 Fts5DlidxLvl *pLvl = &pIter->aLvl[iLvl];
221238 assert( iLvl<pIter->nLvl );
221240 if( (iLvl+1) < pIter->nLvl ){
221241 fts5DlidxIterPrevR(p, pIter, iLvl+1);
221246 FTS5_DLIDX_ROWID(pIter->iSegid, iLvl, pLvl[1].iLeafPgno)
221256 return pIter->aLvl[0].bEof;
221258 static int fts5DlidxIterPrev(Fts5Index *p, Fts5DlidxIter *pIter){
221259 return fts5DlidxIterPrevR(p, pIter, 0);
221265 static void fts5DlidxIterFree(Fts5DlidxIter *pIter){
221266 if( pIter ){
221268 for(i=0; i<pIter->nLvl; i++){
221269 fts5DataRelease(pIter->aLvl[i].pData);
221271 sqlite3_free(pIter);
221281 Fts5DlidxIter *pIter = 0;
221289 pNew = (Fts5DlidxIter*)sqlite3_realloc64(pIter, nByte);
221295 pIter = pNew;
221301 pIter->nLvl = i+1;
221306 pIter->iSegid = iSegid;
221308 fts5DlidxIterFirst(pIter);
221310 fts5DlidxIterLast(p, pIter);
221315 fts5DlidxIterFree(pIter);
221316 pIter = 0;
221319 return pIter;
221322 static i64 fts5DlidxIterRowid(Fts5DlidxIter *pIter){
221323 return pIter->aLvl[0].iRowid;
221325 static int fts5DlidxIterPgno(Fts5DlidxIter *pIter){
221326 return pIter->aLvl[0].iLeafPgno;
221334 Fts5SegIter *pIter /* Iterator to advance to next page */
221337 Fts5StructureSegment *pSeg = pIter->pSeg;
221338 fts5DataRelease(pIter->pLeaf);
221339 pIter->iLeafPgno++;
221340 if( pIter->pNextLeaf ){
221341 pIter->pLeaf = pIter->pNextLeaf;
221342 pIter->pNextLeaf = 0;
221343 }else if( pIter->iLeafPgno<=pSeg->pgnoLast ){
221344 pIter->pLeaf = fts5LeafRead(p,
221345 FTS5_SEGMENT_ROWID(pSeg->iSegid, pIter->iLeafPgno)
221348 pIter->pLeaf = 0;
221350 pLeaf = pIter->pLeaf;
221353 pIter->iPgidxOff = pLeaf->szLeaf;
221355 pIter->iEndofDoclist = pLeaf->nn+1;
221357 pIter->iPgidxOff += fts5GetVarint32(&pLeaf->p[pIter->iPgidxOff],
221358 pIter->iEndofDoclist
221391 static void fts5SegIterLoadNPos(Fts5Index *p, Fts5SegIter *pIter){
221393 int iOff = pIter->iLeafOffset; /* Offset to read at */
221394 ASSERT_SZLEAF_OK(pIter->pLeaf);
221396 int iEod = MIN(pIter->iEndofDoclist, pIter->pLeaf->szLeaf);
221397 pIter->bDel = 0;
221398 pIter->nPos = 1;
221399 if( iOff<iEod && pIter->pLeaf->p[iOff]==0 ){
221400 pIter->bDel = 1;
221402 if( iOff<iEod && pIter->pLeaf->p[iOff]==0 ){
221403 pIter->nPos = 1;
221406 pIter->nPos = 0;
221411 fts5FastGetVarint32(pIter->pLeaf->p, iOff, nSz);
221412 pIter->bDel = (nSz & 0x0001);
221413 pIter->nPos = nSz>>1;
221414 assert_nc( pIter->nPos>=0 );
221416 pIter->iLeafOffset = iOff;
221420 static void fts5SegIterLoadRowid(Fts5Index *p, Fts5SegIter *pIter){
221421 u8 *a = pIter->pLeaf->p; /* Buffer to read data from */
221422 int iOff = pIter->iLeafOffset;
221424 ASSERT_SZLEAF_OK(pIter->pLeaf);
221425 if( iOff>=pIter->pLeaf->szLeaf ){
221426 fts5SegIterNextPage(p, pIter);
221427 if( pIter->pLeaf==0 ){
221432 a = pIter->pLeaf->p;
221434 iOff += sqlite3Fts5GetVarint(&a[iOff], (u64*)&pIter->iRowid);
221435 pIter->iLeafOffset = iOff;
221453 static void fts5SegIterLoadTerm(Fts5Index *p, Fts5SegIter *pIter, int nKeep){
221454 u8 *a = pIter->pLeaf->p; /* Buffer to read data from */
221455 int iOff = pIter->iLeafOffset; /* Offset to read at */
221459 if( iOff+nNew>pIter->pLeaf->szLeaf || nKeep>pIter->term.n || nNew==0 ){
221463 pIter->term.n = nKeep;
221464 fts5BufferAppendBlob(&p->rc, &pIter->term, nNew, &a[iOff]);
221465 assert( pIter->term.n<=pIter->term.nSpace );
221467 pIter->iTermLeafOffset = iOff;
221468 pIter->iTermLeafPgno = pIter->iLeafPgno;
221469 pIter->iLeafOffset = iOff;
221471 if( pIter->iPgidxOff>=pIter->pLeaf->nn ){
221472 pIter->iEndofDoclist = pIter->pLeaf->nn+1;
221475 pIter->iPgidxOff += fts5GetVarint32(&a[pIter->iPgidxOff], nExtra);
221476 pIter->iEndofDoclist += nExtra;
221479 fts5SegIterLoadRowid(p, pIter);
221486 static void fts5SegIterSetNext(Fts5Index *p, Fts5SegIter *pIter){
221487 if( pIter->flags & FTS5_SEGITER_REVERSE ){
221488 pIter->xNext = fts5SegIterNext_Reverse;
221490 pIter->xNext = fts5SegIterNext_None;
221492 pIter->xNext = fts5SegIterNext;
221497 ** Initialize the iterator object pIter to iterate through the entries in
221507 Fts5SegIter *pIter /* Object to populate */
221513 ** The caller will see the (pIter->pLeaf==0) and assume the iterator is
221515 assert( pIter->pLeaf==0 );
221520 memset(pIter, 0, sizeof(*pIter));
221521 fts5SegIterSetNext(p, pIter);
221522 pIter->pSeg = pSeg;
221523 pIter->iLeafPgno = pSeg->pgnoFirst-1;
221524 fts5SegIterNextPage(p, pIter);
221528 pIter->iLeafOffset = 4;
221529 assert_nc( pIter->pLeaf->nn>4 );
221530 assert_nc( fts5LeafFirstTermOff(pIter->pLeaf)==4 );
221531 pIter->iPgidxOff = pIter->pLeaf->szLeaf+1;
221532 fts5SegIterLoadTerm(p, pIter, 0);
221533 fts5SegIterLoadNPos(p, pIter);
221552 static void fts5SegIterReverseInitPage(Fts5Index *p, Fts5SegIter *pIter){
221554 int n = pIter->pLeaf->szLeaf;
221555 int i = pIter->iLeafOffset;
221556 u8 *a = pIter->pLeaf->p;
221559 if( n>pIter->iEndofDoclist ){
221560 n = pIter->iEndofDoclist;
221563 ASSERT_SZLEAF_OK(pIter->pLeaf);
221581 pIter->iRowid += iDelta;
221583 /* If necessary, grow the pIter->aRowidOffset[] array. */
221584 if( iRowidOffset>=pIter->nRowidOffset ){
221585 int nNew = pIter->nRowidOffset + 8;
221586 int *aNew = (int*)sqlite3_realloc64(pIter->aRowidOffset,nNew*sizeof(int));
221591 pIter->aRowidOffset = aNew;
221592 pIter->nRowidOffset = nNew;
221595 pIter->aRowidOffset[iRowidOffset++] = pIter->iLeafOffset;
221596 pIter->iLeafOffset = i;
221598 pIter->iRowidOffset = iRowidOffset;
221599 fts5SegIterLoadNPos(p, pIter);
221605 static void fts5SegIterReverseNewPage(Fts5Index *p, Fts5SegIter *pIter){
221606 assert( pIter->flags & FTS5_SEGITER_REVERSE );
221607 assert( pIter->flags & FTS5_SEGITER_ONETERM );
221609 fts5DataRelease(pIter->pLeaf);
221610 pIter->pLeaf = 0;
221611 while( p->rc==SQLITE_OK && pIter->iLeafPgno>pIter->iTermLeafPgno ){
221613 pIter->iLeafPgno--;
221615 pIter->pSeg->iSegid, pIter->iLeafPgno
221620 ** In this case leave pIter->pLeaf==0, this iterator is at EOF. */
221621 if( pIter->iLeafPgno==pIter->iTermLeafPgno ){
221622 assert( pIter->pLeaf==0 );
221623 if( pIter->iTermLeafOffset<pNew->szLeaf ){
221624 pIter->pLeaf = pNew;
221625 pIter->iLeafOffset = pIter->iTermLeafOffset;
221631 pIter->pLeaf = pNew;
221632 pIter->iLeafOffset = iRowidOff;
221636 if( pIter->pLeaf ){
221637 u8 *a = &pIter->pLeaf->p[pIter->iLeafOffset];
221638 pIter->iLeafOffset += fts5GetVarint(a, (u64*)&pIter->iRowid);
221646 if( pIter->pLeaf ){
221647 pIter->iEndofDoclist = pIter->pLeaf->nn+1;
221648 fts5SegIterReverseInitPage(p, pIter);
221657 static int fts5MultiIterIsEmpty(Fts5Index *p, Fts5Iter *pIter){
221658 Fts5SegIter *pSeg = &pIter->aSeg[pIter->aFirst[1].iFirst];
221663 ** Advance iterator pIter to the next entry.
221669 Fts5SegIter *pIter, /* Iterator to advance */
221672 assert( pIter->flags & FTS5_SEGITER_REVERSE );
221673 assert( pIter->pNextLeaf==0 );
221676 if( pIter->iRowidOffset>0 ){
221677 u8 *a = pIter->pLeaf->p;
221681 pIter->iRowidOffset--;
221682 pIter->iLeafOffset = pIter->aRowidOffset[pIter->iRowidOffset];
221683 fts5SegIterLoadNPos(p, pIter);
221684 iOff = pIter->iLeafOffset;
221686 iOff += pIter->nPos;
221689 pIter->iRowid -= iDelta;
221691 fts5SegIterReverseNewPage(p, pIter);
221696 ** Advance iterator pIter to the next entry.
221703 Fts5SegIter *pIter, /* Iterator to advance */
221709 assert( (pIter->flags & FTS5_SEGITER_REVERSE)==0 );
221712 ASSERT_SZLEAF_OK(pIter->pLeaf);
221713 iOff = pIter->iLeafOffset;
221716 if( pIter->pSeg && iOff>=pIter->pLeaf->szLeaf ){
221717 fts5SegIterNextPage(p, pIter);
221718 if( p->rc || pIter->pLeaf==0 ) return;
221719 pIter->iRowid = 0;
221723 if( iOff<pIter->iEndofDoclist ){
221726 iOff += sqlite3Fts5GetVarint(&pIter->pLeaf->p[iOff], (u64*)&iDelta);
221727 pIter->iLeafOffset = iOff;
221728 pIter->iRowid += iDelta;
221729 }else if( (pIter->flags & FTS5_SEGITER_ONETERM)==0 ){
221730 if( pIter->pSeg ){
221732 if( iOff!=fts5LeafFirstTermOff(pIter->pLeaf) ){
221733 iOff += fts5GetVarint32(&pIter->pLeaf->p[iOff], nKeep);
221735 pIter->iLeafOffset = iOff;
221736 fts5SegIterLoadTerm(p, pIter, nKeep);
221744 pIter->pLeaf->p = (u8*)pList;
221745 pIter->pLeaf->nn = nList;
221746 pIter->pLeaf->szLeaf = nList;
221747 pIter->iEndofDoclist = nList;
221748 sqlite3Fts5BufferSet(&p->rc,&pIter->term, (int)strlen(zTerm), (u8*)zTerm);
221749 pIter->iLeafOffset = fts5GetVarint(pList, (u64*)&pIter->iRowid);
221757 fts5SegIterLoadNPos(p, pIter);
221761 fts5DataRelease(pIter->pLeaf);
221762 pIter->pLeaf = 0;
221767 ** Advance iterator pIter to the next entry.
221775 Fts5SegIter *pIter, /* Iterator to advance */
221778 Fts5Data *pLeaf = pIter->pLeaf;
221793 iOff = pIter->iLeafOffset + pIter->nPos;
221797 assert_nc( iOff<=pIter->iEndofDoclist );
221798 if( iOff>=pIter->iEndofDoclist ){
221806 pIter->iRowid += iDelta;
221809 pIter->iLeafOffset = iOff;
221811 }else if( pIter->pSeg==0 ){
221815 assert( (pIter->flags & FTS5_SEGITER_ONETERM) || pbNewTerm );
221816 if( 0==(pIter->flags & FTS5_SEGITER_ONETERM) ){
221821 fts5DataRelease(pIter->pLeaf);
221822 pIter->pLeaf = 0;
221824 pIter->pLeaf->p = (u8*)pList;
221825 pIter->pLeaf->nn = nList;
221826 pIter->pLeaf->szLeaf = nList;
221827 pIter->iEndofDoclist = nList+1;
221828 sqlite3Fts5BufferSet(&p->rc, &pIter->term, (int)strlen(zTerm),
221830 pIter->iLeafOffset = fts5GetVarint(pList, (u64*)&pIter->iRowid);
221837 fts5SegIterNextPage(p, pIter);
221838 pLeaf = pIter->pLeaf;
221842 iOff += sqlite3Fts5GetVarint(&pLeaf->p[iOff], (u64*)&pIter->iRowid);
221843 pIter->iLeafOffset = iOff;
221846 pIter->iPgidxOff = pLeaf->szLeaf + fts5GetVarint32(
221847 &pLeaf->p[pLeaf->szLeaf], pIter->iEndofDoclist
221852 pIter->iPgidxOff = pLeaf->szLeaf + fts5GetVarint32(
221855 pIter->iLeafOffset = iOff;
221856 pIter->iEndofDoclist = iOff;
221868 if( pIter->pLeaf ){
221870 if( pIter->flags & FTS5_SEGITER_ONETERM ){
221871 fts5DataRelease(pIter->pLeaf);
221872 pIter->pLeaf = 0;
221874 fts5SegIterLoadTerm(p, pIter, nKeep);
221875 fts5SegIterLoadNPos(p, pIter);
221884 assert_nc( pIter->iLeafOffset<=pIter->pLeaf->nn );
221885 fts5FastGetVarint32(pIter->pLeaf->p, pIter->iLeafOffset, nSz);
221886 pIter->bDel = (nSz & 0x0001);
221887 pIter->nPos = nSz>>1;
221888 assert_nc( pIter->nPos>=0 );
221901 ** Iterator pIter currently points to the first rowid in a doclist. This
221905 static void fts5SegIterReverse(Fts5Index *p, Fts5SegIter *pIter){
221906 Fts5DlidxIter *pDlidx = pIter->pDlidx;
221911 int iSegid = pIter->pSeg->iSegid;
221915 Fts5Data *pLeaf = pIter->pLeaf; /* Current leaf data */
221921 if( pIter->iTermLeafPgno==pIter->iLeafPgno ){
221922 iPoslist = pIter->iTermLeafOffset;
221927 pIter->iLeafOffset = iPoslist;
221932 if( pIter->iEndofDoclist>=pLeaf->szLeaf ){
221934 Fts5StructureSegment *pSeg = pIter->pSeg;
221938 for(pgno=pIter->iLeafPgno+1; !p->rc && pgno<=pSeg->pgnoLast; pgno++){
221958 ** pIter->iLeafOffset is already set to point to the position-list size
221967 fts5DataRelease(pIter->pLeaf);
221968 pIter->pLeaf = pLast;
221969 pIter->iLeafPgno = pgnoLast;
221971 iOff += fts5GetVarint(&pLast->p[iOff], (u64*)&pIter->iRowid);
221972 pIter->iLeafOffset = iOff;
221975 pIter->iEndofDoclist = pLast->nn+1;
221977 pIter->iEndofDoclist = fts5LeafFirstTermOff(pLast);
221982 fts5SegIterReverseInitPage(p, pIter);
221986 ** Iterator pIter currently points to the first rowid of a doclist.
221989 ** doclist-index from disk and initialize an iterator at (pIter->pDlidx).
221991 static void fts5SegIterLoadDlidx(Fts5Index *p, Fts5SegIter *pIter){
221992 int iSeg = pIter->pSeg->iSegid;
221993 int bRev = (pIter->flags & FTS5_SEGITER_REVERSE);
221994 Fts5Data *pLeaf = pIter->pLeaf; /* Current leaf data */
221996 assert( pIter->flags & FTS5_SEGITER_ONETERM );
221997 assert( pIter->pDlidx==0 );
222002 if( pIter->iTermLeafPgno==pIter->iLeafPgno
222003 && pIter->iEndofDoclist<pLeaf->szLeaf
222008 pIter->pDlidx = fts5DlidxIterInit(p, bRev, iSeg, pIter->iTermLeafPgno);
222028 Fts5SegIter *pIter, /* Iterator to seek */
222032 const u8 *a = pIter->pLeaf->p;
222033 int szLeaf = pIter->pLeaf->szLeaf;
222034 int n = pIter->pLeaf->nn;
222102 fts5DataRelease(pIter->pLeaf);
222103 pIter->pLeaf = 0;
222107 fts5SegIterNextPage(p, pIter);
222108 if( pIter->pLeaf==0 ) return;
222109 a = pIter->pLeaf->p;
222110 if( fts5LeafIsTermless(pIter->pLeaf)==0 ){
222111 iPgidx = pIter->pLeaf->szLeaf;
222112 iPgidx += fts5GetVarint32(&pIter->pLeaf->p[iPgidx], iOff);
222113 if( iOff<4 || iOff>=pIter->pLeaf->szLeaf ){
222119 n = pIter->pLeaf->nn;
222132 pIter->iLeafOffset = iOff + nNew;
222133 pIter->iTermLeafOffset = pIter->iLeafOffset;
222134 pIter->iTermLeafPgno = pIter->iLeafPgno;
222136 fts5BufferSet(&p->rc, &pIter->term, nKeep, pTerm);
222137 fts5BufferAppendBlob(&p->rc, &pIter->term, nNew, &a[iOff]);
222140 pIter->iEndofDoclist = pIter->pLeaf->nn+1;
222144 pIter->iEndofDoclist = iTermOff + nExtra;
222146 pIter->iPgidxOff = iPgidx;
222148 fts5SegIterLoadRowid(p, pIter);
222149 fts5SegIterLoadNPos(p, pIter);
222165 ** Initialize the object pIter to point to term pTerm/nTerm within segment
222176 Fts5SegIter *pIter /* Object to populate */
222185 memset(pIter, 0, sizeof(*pIter));
222186 pIter->pSeg = pSeg;
222207 pIter->iLeafPgno = iPg - 1;
222208 fts5SegIterNextPage(p, pIter);
222210 if( pIter->pLeaf ){
222211 fts5LeafSeek(p, bGe, pIter, pTerm, nTerm);
222215 pIter->flags |= FTS5_SEGITER_ONETERM;
222216 if( pIter->pLeaf ){
222218 pIter->flags |= FTS5_SEGITER_REVERSE;
222221 fts5SegIterLoadDlidx(p, pIter);
222224 fts5SegIterReverse(p, pIter);
222229 fts5SegIterSetNext(p, pIter);
222240 || pIter->pLeaf==0 /* 2 */
222241 || fts5BufferCompareBlob(&pIter->term, pTerm, nTerm)==0 /* 3 */
222242 || (bGe && fts5BufferCompareBlob(&pIter->term, pTerm, nTerm)>0) /* 4 */
222247 ** Initialize the object pIter to point to term pTerm/nTerm within the
222258 Fts5SegIter *pIter /* Object to populate */
222289 pIter->flags |= FTS5_SEGITER_ONETERM;
222293 sqlite3Fts5BufferSet(&p->rc, &pIter->term, n, z);
222295 pIter->pLeaf = pLeaf;
222296 pIter->iLeafOffset = fts5GetVarint(pLeaf->p, (u64*)&pIter->iRowid);
222297 pIter->iEndofDoclist = pLeaf->nn;
222300 pIter->flags |= FTS5_SEGITER_REVERSE;
222301 fts5SegIterReverseInitPage(p, pIter);
222303 fts5SegIterLoadNPos(p, pIter);
222307 fts5SegIterSetNext(p, pIter);
222313 static void fts5SegIterClear(Fts5SegIter *pIter){
222314 fts5BufferFree(&pIter->term);
222315 fts5DataRelease(pIter->pLeaf);
222316 fts5DataRelease(pIter->pNextLeaf);
222317 fts5DlidxIterFree(pIter->pDlidx);
222318 sqlite3_free(pIter->aRowidOffset);
222319 memset(pIter, 0, sizeof(Fts5SegIter));
222331 Fts5Iter *pIter,
222336 int i1 = p1 - pIter->aSeg;
222337 int i2 = p2 - pIter->aSeg;
222352 res = ((p1->iRowid > p2->iRowid)==pIter->bRev) ? -1 : 1;
222369 ** statement used to verify that the contents of the pIter->aFirst[] array
222372 static void fts5AssertMultiIterSetup(Fts5Index *p, Fts5Iter *pIter){
222374 Fts5SegIter *pFirst = &pIter->aSeg[ pIter->aFirst[1].iFirst ];
222377 assert( (pFirst->pLeaf==0)==pIter->base.bEof );
222379 /* Check that pIter->iSwitchRowid is set correctly. */
222380 for(i=0; i<pIter->nSeg; i++){
222381 Fts5SegIter *p1 = &pIter->aSeg[i];
222385 || p1->iRowid==pIter->iSwitchRowid
222386 || (p1->iRowid<pIter->iSwitchRowid)==pIter->bRev
222390 for(i=0; i<pIter->nSeg; i+=2){
222391 Fts5SegIter *p1 = &pIter->aSeg[i];
222392 Fts5SegIter *p2 = &pIter->aSeg[i+1];
222393 Fts5CResult *pRes = &pIter->aFirst[(pIter->nSeg + i) / 2];
222394 fts5AssertComparisonResult(pIter, p1, p2, pRes);
222397 for(i=1; i<(pIter->nSeg / 2); i+=2){
222398 Fts5SegIter *p1 = &pIter->aSeg[ pIter->aFirst[i*2].iFirst ];
222399 Fts5SegIter *p2 = &pIter->aSeg[ pIter->aFirst[i*2+1].iFirst ];
222400 Fts5CResult *pRes = &pIter->aFirst[i];
222401 fts5AssertComparisonResult(pIter, p1, p2, pRes);
222410 ** Do the comparison necessary to populate pIter->aFirst[iOut].
222413 ** in the pIter->aSeg[] array that is (a) not at EOF, and (b) pointing
222417 static int fts5MultiIterDoCompare(Fts5Iter *pIter, int iOut){
222423 Fts5CResult *pRes = &pIter->aFirst[iOut];
222425 assert( iOut<pIter->nSeg && iOut>0 );
222426 assert( pIter->bRev==0 || pIter->bRev==1 );
222428 if( iOut>=(pIter->nSeg/2) ){
222429 i1 = (iOut - pIter->nSeg/2) * 2;
222432 i1 = pIter->aFirst[iOut*2].iFirst;
222433 i2 = pIter->aFirst[iOut*2+1].iFirst;
222435 p1 = &pIter->aSeg[i1];
222436 p2 = &pIter->aSeg[i2];
222453 res = ((p1->iRowid > p2->iRowid)==pIter->bRev) ? -1 : +1;
222473 Fts5SegIter *pIter, /* Iterator to advance */
222476 assert( iLeafPgno>pIter->iLeafPgno );
222478 if( iLeafPgno>pIter->pSeg->pgnoLast ){
222481 fts5DataRelease(pIter->pNextLeaf);
222482 pIter->pNextLeaf = 0;
222483 pIter->iLeafPgno = iLeafPgno-1;
222484 fts5SegIterNextPage(p, pIter);
222485 assert( p->rc!=SQLITE_OK || pIter->iLeafPgno==iLeafPgno );
222489 u8 *a = pIter->pLeaf->p;
222490 int n = pIter->pLeaf->szLeaf;
222492 iOff = fts5LeafFirstRowidOff(pIter->pLeaf);
222496 iOff += fts5GetVarint(&a[iOff], (u64*)&pIter->iRowid);
222497 pIter->iLeafOffset = iOff;
222498 fts5SegIterLoadNPos(p, pIter);
222511 Fts5SegIter *pIter, /* Iterator to advance */
222514 int bRev = (pIter->flags & FTS5_SEGITER_REVERSE);
222515 Fts5DlidxIter *pDlidx = pIter->pDlidx;
222516 int iLeafPgno = pIter->iLeafPgno;
222519 assert( pIter->flags & FTS5_SEGITER_ONETERM );
222520 assert( pIter->pDlidx );
222521 assert( pIter->pLeaf );
222528 assert_nc( iLeafPgno>=pIter->iLeafPgno || p->rc );
222529 if( iLeafPgno>pIter->iLeafPgno ){
222530 fts5SegIterGotoPage(p, pIter, iLeafPgno);
222534 assert( pIter->pNextLeaf==0 );
222535 assert( iMatch<pIter->iRowid );
222541 assert( fts5DlidxIterEof(p, pDlidx) || iLeafPgno<=pIter->iLeafPgno );
222543 if( iLeafPgno<pIter->iLeafPgno ){
222544 pIter->iLeafPgno = iLeafPgno+1;
222545 fts5SegIterReverseNewPage(p, pIter);
222551 if( bMove && p->rc==SQLITE_OK ) pIter->xNext(p, pIter, 0);
222552 if( pIter->pLeaf==0 ) break;
222553 if( bRev==0 && pIter->iRowid>=iMatch ) break;
222554 if( bRev!=0 && pIter->iRowid<=iMatch ) break;
222563 static void fts5MultiIterFree(Fts5Iter *pIter){
222564 if( pIter ){
222566 for(i=0; i<pIter->nSeg; i++){
222567 fts5SegIterClear(&pIter->aSeg[i]);
222569 fts5BufferFree(&pIter->poslist);
222570 sqlite3_free(pIter);
222576 Fts5Iter *pIter, /* Iterator to update aFirst[] array for */
222581 for(i=(pIter->nSeg+iChanged)/2; i>=iMinset && p->rc==SQLITE_OK; i=i/2){
222583 if( (iEq = fts5MultiIterDoCompare(pIter, i)) ){
222584 Fts5SegIter *pSeg = &pIter->aSeg[iEq];
222587 i = pIter->nSeg + iEq;
222593 ** Sub-iterator iChanged of iterator pIter has just been advanced. It still
222595 ** attempts to update the contents of the pIter->aFirst[] accordingly.
222603 Fts5Iter *pIter, /* Iterator to update aFirst[] array for */
222607 Fts5SegIter *pNew = &pIter->aSeg[iChanged];
222609 if( pNew->iRowid==pIter->iSwitchRowid
222610 || (pNew->iRowid<pIter->iSwitchRowid)==pIter->bRev
222613 Fts5SegIter *pOther = &pIter->aSeg[iChanged ^ 0x0001];
222614 pIter->iSwitchRowid = pIter->bRev ? SMALLEST_INT64 : LARGEST_INT64;
222615 for(i=(pIter->nSeg+iChanged)/2; 1; i=i/2){
222616 Fts5CResult *pRes = &pIter->aFirst[i];
222624 }else if( (pOther->iRowid>pNew->iRowid)==pIter->bRev ){
222625 pIter->iSwitchRowid = pOther->iRowid;
222627 }else if( (pOther->iRowid>pIter->iSwitchRowid)==pIter->bRev ){
222628 pIter->iSwitchRowid = pOther->iRowid;
222631 pRes->iFirst = (u16)(pNew - pIter->aSeg);
222634 pOther = &pIter->aSeg[ pIter->aFirst[i ^ 0x0001].iFirst ];
222643 ** Set the pIter->bEof variable based on the state of the sub-iterators.
222645 static void fts5MultiIterSetEof(Fts5Iter *pIter){
222646 Fts5SegIter *pSeg = &pIter->aSeg[ pIter->aFirst[1].iFirst ];
222647 pIter->base.bEof = pSeg->pLeaf==0;
222648 pIter->iSwitchRowid = pSeg->iRowid;
222660 Fts5Iter *pIter,
222665 assert( pIter->base.bEof==0 );
222667 int iFirst = pIter->aFirst[1].iFirst;
222669 Fts5SegIter *pSeg = &pIter->aSeg[iFirst];
222678 || fts5MultiIterAdvanceRowid(pIter, iFirst, &pSeg)
222680 fts5MultiIterAdvanced(p, pIter, iFirst, 1);
222681 fts5MultiIterSetEof(pIter);
222682 pSeg = &pIter->aSeg[pIter->aFirst[1].iFirst];
222686 fts5AssertMultiIterSetup(p, pIter);
222687 assert( pSeg==&pIter->aSeg[pIter->aFirst[1].iFirst] && pSeg->pLeaf );
222688 if( pIter->bSkipEmpty==0 || pSeg->nPos ){
222689 pIter->xSetOutputs(pIter, pSeg);
222698 Fts5Iter *pIter,
222701 assert( pIter->bSkipEmpty );
222705 int iFirst = pIter->aFirst[1].iFirst;
222706 Fts5SegIter *pSeg = &pIter->aSeg[iFirst];
222712 || fts5MultiIterAdvanceRowid(pIter, iFirst, &pSeg)
222714 fts5MultiIterAdvanced(p, pIter, iFirst, 1);
222715 fts5MultiIterSetEof(pIter);
222718 fts5AssertMultiIterSetup(p, pIter);
222720 }while( fts5MultiIterIsEmpty(p, pIter) );
222908 ** Iterator pIter currently points to a valid entry (not EOF). This
222945 ** and sets pIter->base.pData/nData to point to the new position list.
222946 ** If memory is required for the new position list, use buffer pIter->poslist.
222948 ** pIter->base.pData/nData to point directly to it.
222958 Fts5Iter *pIter
222967 if( pColset->nCol>1 && sqlite3Fts5BufferSize(pRc, &pIter->poslist, nPos) ){
222975 pIter->base.pData = pIter->poslist.p;
222976 pIter->base.nData = pIter->poslist.n;
222989 pIter->base.pData = aCopy;
222990 pIter->base.nData = p-aCopy;
222993 fts5BufferSafeAppendBlob(&pIter->poslist, aCopy, p-aCopy);
222996 pIter->base.pData = pIter->poslist.p;
222997 pIter->base.nData = pIter->poslist.n;
223014 static void fts5IterSetOutputs_None(Fts5Iter *pIter, Fts5SegIter *pSeg){
223015 assert( pIter->pIndex->pConfig->eDetail==FTS5_DETAIL_NONE );
223016 pIter->base.iRowid = pSeg->iRowid;
223017 pIter->base.nData = pSeg->nPos;
223024 static void fts5IterSetOutputs_Nocolset(Fts5Iter *pIter, Fts5SegIter *pSeg){
223025 pIter->base.iRowid = pSeg->iRowid;
223026 pIter->base.nData = pSeg->nPos;
223028 assert( pIter->pIndex->pConfig->eDetail!=FTS5_DETAIL_NONE );
223029 assert( pIter->pColset==0 );
223034 pIter->base.pData = &pSeg->pLeaf->p[pSeg->iLeafOffset];
223039 fts5BufferZero(&pIter->poslist);
223040 fts5SegiterPoslist(pIter->pIndex, pSeg, 0, &pIter->poslist);
223041 pIter->base.pData = pIter->poslist.p;
223049 static void fts5IterSetOutputs_ZeroColset(Fts5Iter *pIter, Fts5SegIter *pSeg){
223051 pIter->base.nData = 0;
223059 static void fts5IterSetOutputs_Col(Fts5Iter *pIter, Fts5SegIter *pSeg){
223060 fts5BufferZero(&pIter->poslist);
223061 fts5SegiterPoslist(pIter->pIndex, pSeg, pIter->pColset, &pIter->poslist);
223062 pIter->base.iRowid = pSeg->iRowid;
223063 pIter->base.pData = pIter->poslist.p;
223064 pIter->base.nData = pIter->poslist.n;
223077 static void fts5IterSetOutputs_Col100(Fts5Iter *pIter, Fts5SegIter *pSeg){
223079 assert( pIter->pIndex->pConfig->eDetail==FTS5_DETAIL_COLUMNS );
223080 assert( pIter->pColset );
223083 fts5IterSetOutputs_Col(pIter, pSeg);
223088 int *aiCol = pIter->pColset->aiCol;
223089 int *aiColEnd = &aiCol[pIter->pColset->nCol];
223091 u8 *aOut = pIter->poslist.p;
223094 pIter->base.iRowid = pSeg->iRowid;
223109 pIter->base.pData = pIter->poslist.p;
223110 pIter->base.nData = aOut - pIter->poslist.p;
223117 static void fts5IterSetOutputs_Full(Fts5Iter *pIter, Fts5SegIter *pSeg){
223118 Fts5Colset *pColset = pIter->pColset;
223119 pIter->base.iRowid = pSeg->iRowid;
223121 assert( pIter->pIndex->pConfig->eDetail==FTS5_DETAIL_FULL );
223128 int *pRc = &pIter->pIndex->rc;
223129 fts5BufferZero(&pIter->poslist);
223130 fts5IndexExtractColset(pRc, pColset, a, pSeg->nPos, pIter);
223135 fts5BufferZero(&pIter->poslist);
223136 fts5SegiterPoslist(pIter->pIndex, pSeg, pColset, &pIter->poslist);
223137 pIter->base.pData = pIter->poslist.p;
223138 pIter->base.nData = pIter->poslist.n;
223142 static void fts5IterSetOutputCb(int *pRc, Fts5Iter *pIter){
223144 Fts5Config *pConfig = pIter->pIndex->pConfig;
223146 pIter->xSetOutputs = fts5IterSetOutputs_None;
223149 else if( pIter->pColset==0 ){
223150 pIter->xSetOutputs = fts5IterSetOutputs_Nocolset;
223153 else if( pIter->pColset->nCol==0 ){
223154 pIter->xSetOutputs = fts5IterSetOutputs_ZeroColset;
223158 pIter->xSetOutputs = fts5IterSetOutputs_Full;
223164 pIter->xSetOutputs = fts5IterSetOutputs_Col100;
223165 sqlite3Fts5BufferSize(pRc, &pIter->poslist, pConfig->nCol);
223167 pIter->xSetOutputs = fts5IterSetOutputs_Col;
223228 Fts5SegIter *pIter = &pNew->aSeg[iIter++];
223229 fts5SegIterHashInit(p, pTerm, nTerm, flags, pIter);
223234 Fts5SegIter *pIter = &pNew->aSeg[iIter++];
223236 fts5SegIterInit(p, pSeg, pIter);
223238 fts5SegIterSeekInit(p, pTerm, nTerm, flags, pSeg, pIter);
223293 Fts5SegIter *pIter = &pNew->aSeg[1];
223295 pIter->flags = FTS5_SEGITER_ONETERM;
223297 pIter->pLeaf = pData;
223298 pIter->iLeafOffset = fts5GetVarint(pData->p, (u64*)&pIter->iRowid);
223299 pIter->iEndofDoclist = pData->nn;
223303 pIter->flags |= FTS5_SEGITER_REVERSE;
223304 fts5SegIterReverseInitPage(p, pIter);
223306 fts5SegIterLoadNPos(p, pIter);
223312 fts5SegIterSetNext(p, pIter);
223324 static int fts5MultiIterEof(Fts5Index *p, Fts5Iter *pIter){
223326 || (pIter->aSeg[ pIter->aFirst[1].iFirst ].pLeaf==0)==pIter->base.bEof
223328 return (p->rc || pIter->base.bEof);
223336 static i64 fts5MultiIterRowid(Fts5Iter *pIter){
223337 assert( pIter->aSeg[ pIter->aFirst[1].iFirst ].pLeaf );
223338 return pIter->aSeg[ pIter->aFirst[1].iFirst ].iRowid;
223346 Fts5Iter *pIter,
223351 fts5MultiIterNext(p, pIter, 1, iMatch);
223352 if( fts5MultiIterEof(p, pIter) ) break;
223353 iRowid = fts5MultiIterRowid(pIter);
223354 if( pIter->bRev==0 && iRowid>=iMatch ) break;
223355 if( pIter->bRev!=0 && iRowid<=iMatch ) break;
223363 static const u8 *fts5MultiIterTerm(Fts5Iter *pIter, int *pn){
223364 Fts5SegIter *p = &pIter->aSeg[ pIter->aFirst[1].iFirst ];
223934 ** Iterator pIter was used to iterate through the input segments of on an
223938 static void fts5TrimSegments(Fts5Index *p, Fts5Iter *pIter){
223942 for(i=0; i<pIter->nSeg && p->rc==SQLITE_OK; i++){
223943 Fts5SegIter *pSeg = &pIter->aSeg[i];
224025 Fts5Iter *pIter = 0; /* Iterator to read input data */
224079 for(fts5MultiIterNew(p, pStruct, flags, 0, 0, 0, iLvl, nInput, &pIter);
224080 fts5MultiIterEof(p, pIter)==0;
224081 fts5MultiIterNext(p, pIter, 0, 0)
224083 Fts5SegIter *pSegIter = &pIter->aSeg[ pIter->aFirst[1].iFirst ];
224088 pTerm = fts5MultiIterTerm(pIter, &nTerm);
224108 fts5WriteAppendRowid(p, &writer, fts5MultiIterRowid(pIter));
224129 if( fts5MultiIterEof(p, pIter) ){
224151 fts5TrimSegments(p, pIter);
224155 fts5MultiIterFree(pIter);
224610 static void fts5DoclistIterNext(Fts5DoclistIter *pIter){
224611 u8 *p = pIter->aPoslist + pIter->nSize + pIter->nPoslist;
224613 assert( pIter->aPoslist || (p==0 && pIter->aPoslist==0) );
224614 if( p>=pIter->aEof ){
224615 pIter->aPoslist = 0;
224620 pIter->iRowid += iDelta;
224625 pIter->nSize = fts5GetVarint32(p, nPos);
224626 pIter->nPoslist = (nPos>>1);
224628 pIter->nPoslist = ((int)(p[0])) >> 1;
224629 pIter->nSize = 1;
224632 pIter->aPoslist = p;
224633 if( &pIter->aPoslist[pIter->nPoslist]>pIter->aEof ){
224634 pIter->aPoslist = 0;
224641 Fts5DoclistIter *pIter
224643 memset(pIter, 0, sizeof(*pIter));
224645 pIter->aPoslist = pBuf->p;
224646 pIter->aEof = &pBuf->p[pBuf->n];
224647 fts5DoclistIterNext(pIter);
225365 Fts5Iter *pIter = (Fts5Iter*)pIndexIter;
225366 assert( pIter->pIndex->rc==SQLITE_OK );
225367 fts5MultiIterNext(pIter->pIndex, pIter, 0, 0);
225368 return fts5IndexReturn(pIter->pIndex);
225375 Fts5Iter *pIter = (Fts5Iter*)pIndexIter;
225376 Fts5Index *p = pIter->pIndex;
225378 assert( pIter->pIndex->rc==SQLITE_OK );
225380 fts5MultiIterNext(p, pIter, 0, 0);
225382 Fts5SegIter *pSeg = &pIter->aSeg[ pIter->aFirst[1].iFirst ];
225386 pIter->base.bEof = 1;
225390 return fts5IndexReturn(pIter->pIndex);
225399 Fts5Iter *pIter = (Fts5Iter*)pIndexIter;
225400 fts5MultiIterNextFrom(pIter->pIndex, pIter, iMatch);
225401 return fts5IndexReturn(pIter->pIndex);
225420 Fts5Iter *pIter = (Fts5Iter*)pIndexIter;
225421 Fts5Index *pIndex = pIter->pIndex;
225422 fts5MultiIterFree(pIter);
225587 Fts5IndexIter *pIter = 0;
225588 int rc = sqlite3Fts5IndexQuery(p, z, n, flags, 0, &pIter);
225590 while( rc==SQLITE_OK && 0==sqlite3Fts5IterEof(pIter) ){
225591 i64 rowid = pIter->iRowid;
225597 for(sqlite3Fts5PoslistReaderInit(pIter->pData, pIter->nData, &sReader);
225607 rc = sqlite3Fts5IterNext(pIter);
225610 sqlite3Fts5IterClose(pIter);
225953 Fts5Iter *pIter; /* Used to iterate through entire index */
225990 for(fts5MultiIterNew(p, pStruct, flags, 0, 0, 0, -1, 0, &pIter);
225991 fts5MultiIterEof(p, pIter)==0;
225992 fts5MultiIterNext(p, pIter, 0, 0)
225997 i64 iRowid = fts5MultiIterRowid(pIter);
225998 char *z = (char*)fts5MultiIterTerm(pIter, &n);
226004 if( 0==fts5MultiIterIsEmpty(p, pIter) ){
226009 fts5SegiterPoslist(p, &pIter->aSeg[pIter->aFirst[1].iFirst], 0, &poslist);
226020 fts5MultiIterFree(pIter);
228668 Fts5PhraseIter *pIter,
228672 if( pIter->a>=pIter->b ){
228677 pIter->a += fts5GetVarint32(pIter->a, iVal);
228679 pIter->a += fts5GetVarint32(pIter->a, iVal);
228682 pIter->a += fts5GetVarint32(pIter->a, iVal);
228691 Fts5PhraseIter *pIter,
228696 int rc = fts5CsrPoslist(pCsr, iPhrase, &pIter->a, &n);
228698 assert( pIter->a || n==0 );
228699 pIter->b = (pIter->a ? &pIter->a[n] : 0);
228702 fts5ApiPhraseNext(pCtx, pIter, piCol, piOff);
228709 Fts5PhraseIter *pIter,
228716 if( pIter->a>=pIter->b ){
228720 pIter->a += fts5GetVarint32(&pIter->a[0], iIncr);
228726 if( pIter->a>=pIter->b ){
228730 if( pIter->a[0]==0x01 ) break;
228731 pIter->a += fts5GetVarint32(pIter->a, dummy);
228733 pIter->a += 1 + fts5GetVarint32(&pIter->a[1], *piCol);
228740 Fts5PhraseIter *pIter,
228753 pIter->a = &pSorter->aPoslist[i1];
228755 rc = sqlite3Fts5ExprPhraseCollist(pCsr->pExpr, iPhrase, &pIter->a, &n);
228758 assert( pIter->a || n==0 );
228759 pIter->b = (pIter->a ? &pIter->a[n] : 0);
228761 fts5ApiPhraseNextColumn(pCtx, pIter, piCol);
228765 rc = fts5CsrPoslist(pCsr, iPhrase, &pIter->a, &n);
228767 assert( pIter->a || n==0 );
228768 pIter->b = (pIter->a ? &pIter->a[n] : 0);
228771 }else if( pIter->a[0]==0x01 ){
228772 pIter->a += 1 + fts5GetVarint32(&pIter->a[1], *piCol);
233204 Fts5IndexIter *pIter; /* Term/rowid iterator object */
233537 sqlite3Fts5IterClose(pCsr->pIter);
233538 pCsr->pIter = 0;
233561 if( sqlite3Fts5IterEof(pCsr->pIter) ){
233566 zTerm = sqlite3Fts5IterTerm(pCsr->pIter, &nTerm);
233583 Fts5IndexIter *pIter = pCsr->pIter;
233587 assert( sqlite3Fts5IterEof(pIter)==0 );
233590 || sqlite3Fts5PoslistNext64(pIter->pData, pIter->nData, po, pp)
233595 rc = sqlite3Fts5IterNextScan(pCsr->pIter);
233631 if( sqlite3Fts5IterEof(pCsr->pIter) ){
233637 zTerm = sqlite3Fts5IterTerm(pCsr->pIter, &nTerm);
233660 pPos = pCsr->pIter->pData;
233661 nPos = pCsr->pIter->nData;
233709 rc = sqlite3Fts5IterNextScan(pCsr->pIter);
233714 zTerm = sqlite3Fts5IterTerm(pCsr->pIter, &nTerm);
233720 if( sqlite3Fts5IterEof(pCsr->pIter) ) break;
233790 rc = sqlite3Fts5IndexQuery(pIndex, zTerm, nTerm, f, 0, &pCsr->pIter);
233851 sqlite3_result_int64(pCtx, pCsr->pIter->iRowid);