Lines Matching refs:pIter
11883 SQLITE_API int sqlite3changeset_next(sqlite3_changeset_iter *pIter);
11918 sqlite3_changeset_iter *pIter, /* Iterator object */
11952 sqlite3_changeset_iter *pIter, /* Iterator object */
11983 sqlite3_changeset_iter *pIter, /* Changeset iterator */
12017 sqlite3_changeset_iter *pIter, /* Changeset iterator */
12045 sqlite3_changeset_iter *pIter, /* Changeset iterator */
12062 sqlite3_changeset_iter *pIter, /* Changeset iterator */
12097 SQLITE_API int sqlite3changeset_finalize(sqlite3_changeset_iter *pIter);
67108 WalIterator *pIter = 0; /* Wal iterator context */
67153 rc = walIteratorInit(pWal, pInfo->nBackfill, &pIter);
67154 assert( rc==SQLITE_OK || pIter==0 );
67157 if( pIter
67189 while( rc==SQLITE_OK && 0==walIteratorNext(pIter, &iDbpage, &iFrame) ){
67276 SEH_FREE_ON_ERROR(pIter, 0);
67277 walIteratorFree(pIter);
70874 BtLock *pIter;
70901 for(pIter=pBt->pLock; pIter; pIter=pIter->pNext){
70911 assert( pIter->eLock==READ_LOCK || pIter->eLock==WRITE_LOCK );
70912 assert( eLock==READ_LOCK || pIter->pBtree==p || pIter->eLock==READ_LOCK);
70913 if( pIter->pBtree!=p && pIter->iTable==iTab && pIter->eLock!=eLock ){
70914 sqlite3ConnectionBlocked(p->db, pIter->pBtree->db);
70947 BtLock *pIter;
70967 for(pIter=pBt->pLock; pIter; pIter=pIter->pNext){
70968 if( pIter->iTable==iTable && pIter->pBtree==p ){
70969 pLock = pIter;
71806 u8 *pIter; /* For scanning through pCell */
71814 pIter = pCell;
71822 nPayload = *pIter;
71824 u8 *pEnd = &pIter[8];
71827 nPayload = (nPayload<<7) | (*++pIter & 0x7f);
71828 }while( (*pIter)>=0x80 && pIter<pEnd );
71830 pIter++;
71839 iKey = *pIter;
71842 iKey = (iKey<<7) ^ (x = *++pIter);
71844 iKey = (iKey<<7) ^ (x = *++pIter);
71846 iKey = (iKey<<7) ^ 0x10204000 ^ (x = *++pIter);
71848 iKey = (iKey<<7) ^ 0x4000 ^ (x = *++pIter);
71850 iKey = (iKey<<7) ^ 0x4000 ^ (x = *++pIter);
71852 iKey = (iKey<<7) ^ 0x4000 ^ (x = *++pIter);
71854 iKey = (iKey<<7) ^ 0x4000 ^ (x = *++pIter);
71856 iKey = (iKey<<8) ^ 0x8000 ^ (*++pIter);
71869 pIter++;
71873 pInfo->pPayload = pIter;
71880 pInfo->nSize = nPayload + (u16)(pIter - pCell);
71892 u8 *pIter; /* For scanning through pCell */
71898 pIter = pCell + pPage->childPtrSize;
71899 nPayload = *pIter;
71901 u8 *pEnd = &pIter[8];
71904 nPayload = (nPayload<<7) | (*++pIter & 0x7f);
71905 }while( *(pIter)>=0x80 && pIter<pEnd );
71907 pIter++;
71910 pInfo->pPayload = pIter;
71917 pInfo->nSize = nPayload + (u16)(pIter - pCell);
71947 u8 *pIter = pCell + 4; /* For looping over bytes of pCell */
71961 nSize = *pIter;
71963 pEnd = &pIter[8];
71966 nSize = (nSize<<7) | (*++pIter & 0x7f);
71967 }while( *(pIter)>=0x80 && pIter<pEnd );
71969 pIter++;
71973 nSize += (u32)(pIter - pCell);
71983 nSize += 4 + (u16)(pIter - pCell);
71989 u8 *pIter = pCell; /* For looping over bytes of pCell */
72003 nSize = *pIter;
72005 pEnd = &pIter[8];
72008 nSize = (nSize<<7) | (*++pIter & 0x7f);
72009 }while( *(pIter)>=0x80 && pIter<pEnd );
72011 pIter++;
72015 nSize += (u32)(pIter - pCell);
72025 nSize += 4 + (u16)(pIter - pCell);
72031 u8 *pIter = pCell + 4; /* For looping over bytes of pCell */
72046 pEnd = pIter + 9;
72047 while( (*pIter++)&0x80 && pIter<pEnd );
72048 assert( debuginfo.nSize==(u16)(pIter - pCell) || CORRUPT_DB );
72049 return (u16)(pIter - pCell);
72052 u8 *pIter = pCell; /* For looping over bytes of pCell */
72065 nSize = *pIter;
72067 pEnd = &pIter[8];
72070 nSize = (nSize<<7) | (*++pIter & 0x7f);
72071 }while( *(pIter)>=0x80 && pIter<pEnd );
72073 pIter++;
72077 if( (*pIter++)&0x80
72078 && (*pIter++)&0x80
72079 && (*pIter++)&0x80
72080 && (*pIter++)&0x80
72081 && (*pIter++)&0x80
72082 && (*pIter++)&0x80
72083 && (*pIter++)&0x80
72084 && (*pIter++)&0x80 ){ pIter++; }
72088 nSize += (u32)(pIter - pCell);
72098 nSize += 4 + (u16)(pIter - pCell);
74171 BtLock *pIter;
74172 for(pIter=pBt->pLock; pIter; pIter=pIter->pNext){
74173 if( pIter->pBtree!=p ){
74174 pBlock = pIter->pBtree->db;
106153 FileChunk *pIter;
106155 for(pIter=pFirst; pIter; pIter=pNext){
106156 pNext = pIter->pNext;
106157 sqlite3_free(pIter);
106174 FileChunk *pIter;
106175 for(pIter=copy.pFirst; pIter; pIter=pIter->pNext){
106179 rc = sqlite3OsWrite(pReal, (u8*)pIter->zChunk, nChunk, iOff);
106283 FileChunk *pIter = 0;
106289 for(pIter=p->pFirst; ALWAYS(pIter) && iOff<size; pIter=pIter->pNext){
106292 if( ALWAYS(pIter) ){
106293 memjrnlFreeChunks(pIter->pNext);
106294 pIter->pNext = 0;
106298 p->endpoint.pChunk = pIter;
134649 static Index *indexIteratorFirst(IndexIterator *pIter, int *pIx){
134650 assert( pIter->i==0 );
134651 if( pIter->eType ){
134652 *pIx = pIter->u.ax.aIdx[0].ix;
134653 return pIter->u.ax.aIdx[0].p;
134656 return pIter->u.lx.pIdx;
134661 static Index *indexIteratorNext(IndexIterator *pIter, int *pIx){
134662 if( pIter->eType ){
134663 int i = ++pIter->i;
134664 if( i>=pIter->u.ax.nIdx ){
134668 *pIx = pIter->u.ax.aIdx[i].ix;
134669 return pIter->u.ax.aIdx[i].p;
134672 pIter->u.lx.pIdx = pIter->u.lx.pIdx->pNext;
134673 return pIter->u.lx.pIdx;
190784 char *pIter; /* Used to iterate through aAll */
190788 pIter = pDL->pNextDocid;
190789 assert( pDL->aAll!=0 || pIter==0 );
190791 pIter = pDL->aAll;
190794 if( pIter==0 || pIter>=(pEnd = pDL->aAll + pDL->nAll) ){
190799 pIter += sqlite3Fts3GetVarint(pIter, &iDelta);
190805 pDL->pList = pIter;
190806 fts3PoslistCopy(0, &pIter);
190807 pDL->nList = (int)(pIter - pDL->pList);
190815 while( pIter<pEnd && *pIter==0 ) pIter++;
190817 pDL->pNextDocid = pIter;
190818 assert( pIter>=&pDL->aAll[pDL->nAll] || *pIter );
192164 char *pIter;
192177 pIter = pPhrase->doclist.pList;
192238 pIter = pPh->pOrPoslist;
192242 (pIter >= (pPh->doclist.aAll + pPh->doclist.nAll));
192243 while( (pIter==0 || DOCID_CMP(iDocid, pCsr->iPrevId)<0 ) && bEof==0 ){
192246 &pIter, &iDocid, &bEof
192250 bEof = !pPh->doclist.nAll || (pIter && pIter<=pPh->doclist.aAll);
192251 while( (pIter==0 || DOCID_CMP(iDocid, pCsr->iPrevId)>0 ) && bEof==0 ){
192255 &pIter, &iDocid, &dummy, &bEof
192259 pPh->pOrPoslist = pIter;
192265 pIter = pPhrase->pOrPoslist;
192267 pIter = 0;
192270 if( pIter==0 ) return SQLITE_OK;
192272 if( *pIter==0x01 ){
192273 pIter++;
192274 pIter += fts3GetVarint32(pIter, &iThis);
192279 fts3ColumnlistCopy(0, &pIter);
192280 if( *pIter==0x00 ) return SQLITE_OK;
192281 pIter++;
192282 pIter += fts3GetVarint32(pIter, &iThis);
192284 if( *pIter==0x00 ){
192285 pIter = 0;
192288 *ppOut = ((iCol==iThis)?pIter:0);
193637 Fts3Expr *pIter = pNotBranch;
193638 while( pIter->pLeft ){
193639 pIter = pIter->pLeft;
193641 pIter->pLeft = pRet;
193642 pRet->pParent = pIter;
198655 SegmentNode *pIter;
198658 for(pIter=pTree->pLeftmost; pIter && rc==SQLITE_OK; pIter=pIter->pRight){
198659 int nStart = fts3TreeFinishNode(pIter, iHeight, iNextLeaf);
198660 int nWrite = pIter->nData - nStart;
198662 rc = fts3WriteSegment(p, iNextFree, &pIter->aData[nStart], nWrite);
198664 iNextLeaf += (pIter->nEntry+1);
202657 char *pIter = *ppIter;
202658 if( pIter ){
202662 if( 0==(*pIter & 0xFE) ){
202664 pIter = 0;
202667 fts3GetDeltaPosition(&pIter, &iIter);
202671 *ppIter = pIter;
202678 static int fts3SnippetNextCandidate(SnippetIter *pIter){
202681 if( pIter->iCurrent<0 ){
202686 pIter->iCurrent = 0;
202691 for(i=0; i<pIter->nPhrase; i++){
202692 SnippetPhrase *pPhrase = &pIter->aPhrase[i];
202693 fts3SnippetAdvance(&pPhrase->pHead, &pPhrase->iHead, pIter->nSnippet);
202699 for(i=0; i<pIter->nPhrase; i++){
202700 SnippetPhrase *pPhrase = &pIter->aPhrase[i];
202709 pIter->iCurrent = iStart = iEnd - pIter->nSnippet + 1;
202710 for(i=0; i<pIter->nPhrase; i++){
202711 SnippetPhrase *pPhrase = &pIter->aPhrase[i];
202725 SnippetIter *pIter, /* Snippet iterator */
202732 int iStart = pIter->iCurrent; /* First token of snippet */
202738 for(i=0; i<pIter->nPhrase; i++){
202739 SnippetPhrase *pPhrase = &pIter->aPhrase[i];
202744 while( iCsr<(iStart+pIter->nSnippet) && iCsr>=iStart ){
202757 for(j=0; j<pPhrase->nToken && j<pIter->nSnippet; j++){
203181 char *pIter = pPhrase->doclist.pList;
203191 if( pIter ) while( 1 ){
203192 int nHit = fts3ColumnlistCount(&pIter);
203200 assert( *pIter==0x00 || *pIter==0x01 );
203201 if( *pIter!=0x01 ) break;
203202 pIter++;
203203 pIter += fts3GetVarint32(pIter, &iCol);
203422 static int fts3LcsIteratorAdvance(LcsIterator *pIter){
203427 if( NEVER(pIter==0) ) return 1;
203428 pRead = pIter->pRead;
203434 pIter->iPos += (int)(iRead-2);
203437 pIter->pRead = pRead;
203467 LcsIterator *pIter = &aIter[i];
203468 nToken -= pIter->pExpr->pPhrase->nToken;
203469 pIter->iPosOffset = nToken;
203496 LcsIterator *pIter = &aIter[i];
203497 if( pIter->pRead==0 ){
203501 if( pAdv==0 || pIter->iPos<pAdv->iPos ){
203502 pAdv = pIter;
203504 if( nThisLcs==0 || pIter->iPos==pIter[-1].iPos ){
217254 UBreakIterator *pIter; /* ICU break-iterator object */
217367 pCsr->pIter = ubrk_open(UBRK_WORD, p->zLocale, pCsr->aChar, iOut, &status);
217374 ubrk_first(pCsr->pIter);
217384 ubrk_close(pCsr->pIter);
217410 iStart = ubrk_current(pCsr->pIter);
217411 iEnd = ubrk_next(pCsr->pIter);
218915 static void rbuObjIterFreeCols(RbuObjIter *pIter){
218917 for(i=0; i<pIter->nTblCol; i++){
218918 sqlite3_free(pIter->azTblCol[i]);
218919 sqlite3_free(pIter->azTblType[i]);
218921 sqlite3_free(pIter->azTblCol);
218922 pIter->azTblCol = 0;
218923 pIter->azTblType = 0;
218924 pIter->aiSrcOrder = 0;
218925 pIter->abTblPk = 0;
218926 pIter->abNotNull = 0;
218927 pIter->nTblCol = 0;
218928 pIter->eType = 0; /* Invalid value */
218935 static void rbuObjIterClearStatements(RbuObjIter *pIter){
218938 sqlite3_finalize(pIter->pSelect);
218939 sqlite3_finalize(pIter->pInsert);
218940 sqlite3_finalize(pIter->pDelete);
218941 sqlite3_finalize(pIter->pTmpInsert);
218942 pUp = pIter->pRbuUpdate;
218949 sqlite3_free(pIter->aIdxCol);
218950 sqlite3_free(pIter->zIdxSql);
218952 pIter->pSelect = 0;
218953 pIter->pInsert = 0;
218954 pIter->pDelete = 0;
218955 pIter->pRbuUpdate = 0;
218956 pIter->pTmpInsert = 0;
218957 pIter->nCol = 0;
218958 pIter->nIdxCol = 0;
218959 pIter->aIdxCol = 0;
218960 pIter->zIdxSql = 0;
218967 static void rbuObjIterFinalize(RbuObjIter *pIter){
218968 rbuObjIterClearStatements(pIter);
218969 sqlite3_finalize(pIter->pTblIter);
218970 sqlite3_finalize(pIter->pIdxIter);
218971 rbuObjIterFreeCols(pIter);
218972 memset(pIter, 0, sizeof(RbuObjIter));
218983 static int rbuObjIterNext(sqlite3rbu *p, RbuObjIter *pIter){
218988 rbuObjIterClearStatements(pIter);
218989 if( pIter->zIdx==0 ){
219000 if( pIter->bCleanup ){
219001 rbuObjIterFreeCols(pIter);
219002 pIter->bCleanup = 0;
219003 rc = sqlite3_step(pIter->pTblIter);
219005 rc = resetAndCollectError(pIter->pTblIter, &p->zErrmsg);
219006 pIter->zTbl = 0;
219007 pIter->zDataTbl = 0;
219009 pIter->zTbl = (const char*)sqlite3_column_text(pIter->pTblIter, 0);
219010 pIter->zDataTbl = (const char*)sqlite3_column_text(pIter->pTblIter,1);
219011 rc = (pIter->zDataTbl && pIter->zTbl) ? SQLITE_OK : SQLITE_NOMEM;
219014 if( pIter->zIdx==0 ){
219015 sqlite3_stmt *pIdx = pIter->pIdxIter;
219016 rc = sqlite3_bind_text(pIdx, 1, pIter->zTbl, -1, SQLITE_STATIC);
219019 rc = sqlite3_step(pIter->pIdxIter);
219021 rc = resetAndCollectError(pIter->pIdxIter, &p->zErrmsg);
219022 pIter->bCleanup = 1;
219023 pIter->zIdx = 0;
219025 pIter->zIdx = (const char*)sqlite3_column_text(pIter->pIdxIter, 0);
219026 pIter->iTnum = sqlite3_column_int(pIter->pIdxIter, 1);
219027 pIter->bUnique = sqlite3_column_int(pIter->pIdxIter, 2);
219028 rc = pIter->zIdx ? SQLITE_OK : SQLITE_NOMEM;
219036 rbuObjIterFinalize(pIter);
219100 static int rbuObjIterFirst(sqlite3rbu *p, RbuObjIter *pIter){
219102 memset(pIter, 0, sizeof(RbuObjIter));
219104 rc = prepareFreeAndCollectError(p->dbRbu, &pIter->pTblIter, &p->zErrmsg,
219114 rc = prepareAndCollectError(p->dbMain, &pIter->pIdxIter, &p->zErrmsg,
219121 pIter->bCleanup = 1;
219123 return rbuObjIterNext(p, pIter);
219207 static void rbuAllocateIterArrays(sqlite3rbu *p, RbuObjIter *pIter, int nCol){
219213 pIter->azTblCol = azNew;
219214 pIter->azTblType = &azNew[nCol];
219215 pIter->aiSrcOrder = (int*)&pIter->azTblType[nCol];
219216 pIter->abTblPk = (u8*)&pIter->aiSrcOrder[nCol];
219217 pIter->abNotNull = (u8*)&pIter->abTblPk[nCol];
219218 pIter->abIndexed = (u8*)&pIter->abNotNull[nCol];
219391 static void rbuObjIterCacheIndexedCols(sqlite3rbu *p, RbuObjIter *pIter){
219396 memcpy(pIter->abIndexed, pIter->abTblPk, sizeof(u8)*pIter->nTblCol);
219398 sqlite3_mprintf("PRAGMA main.index_list = %Q", pIter->zTbl)
219402 pIter->nIndex = 0;
219409 memset(pIter->abIndexed, 0x01, sizeof(u8)*pIter->nTblCol);
219416 if( iCid>=0 ) pIter->abIndexed[iCid] = 1;
219418 memset(pIter->abIndexed, 0x01, sizeof(u8)*pIter->nTblCol);
219423 pIter->nIndex++;
219426 if( pIter->eType==RBU_PK_WITHOUT_ROWID ){
219428 pIter->nIndex--;
219432 if( bIndex==0 ) pIter->abIndexed = 0;
219445 static int rbuObjIterCacheTableInfo(sqlite3rbu *p, RbuObjIter *pIter){
219446 if( pIter->azTblCol==0 ){
219455 assert( pIter->eType==0 );
219456 rbuTableType(p, pIter->zTbl, &pIter->eType, &iTnum, &pIter->iPkTnum);
219457 if( p->rc==SQLITE_OK && pIter->eType==RBU_PK_NOTABLE ){
219459 p->zErrmsg = sqlite3_mprintf("no such table: %s", pIter->zTbl);
219462 if( pIter->zIdx==0 ) pIter->iTnum = iTnum;
219464 assert( pIter->eType==RBU_PK_NONE || pIter->eType==RBU_PK_IPK
219465 || pIter->eType==RBU_PK_EXTERNAL || pIter->eType==RBU_PK_WITHOUT_ROWID
219466 || pIter->eType==RBU_PK_VTAB
219473 sqlite3_mprintf("SELECT * FROM '%q'", pIter->zDataTbl)
219477 rbuAllocateIterArrays(p, pIter, nCol);
219483 pIter->aiSrcOrder[pIter->nTblCol] = pIter->nTblCol;
219484 pIter->azTblCol[pIter->nTblCol++] = zCopy;
219495 && bRbuRowid!=(pIter->eType==RBU_PK_VTAB || pIter->eType==RBU_PK_NONE)
219499 "table %q %s rbu_rowid column", pIter->zDataTbl,
219509 sqlite3_mprintf("PRAGMA table_info(%Q)", pIter->zTbl)
219515 for(i=iOrder; i<pIter->nTblCol; i++){
219516 if( 0==strcmp(zName, pIter->azTblCol[i]) ) break;
219518 if( i==pIter->nTblCol ){
219521 pIter->zDataTbl, zName
219529 SWAP(int, pIter->aiSrcOrder[i], pIter->aiSrcOrder[iOrder]);
219530 SWAP(char*, pIter->azTblCol[i], pIter->azTblCol[iOrder]);
219533 pIter->azTblType[iOrder] = rbuStrndup(zType, &p->rc);
219535 pIter->abTblPk[iOrder] = (u8)iPk;
219536 pIter->abNotNull[iOrder] = (u8)bNotNull || (iPk!=0);
219542 rbuObjIterCacheIndexedCols(p, pIter);
219543 assert( pIter->eType!=RBU_PK_VTAB || pIter->abIndexed==0 );
219544 assert( pIter->eType!=RBU_PK_VTAB || pIter->nIndex==0 );
219557 RbuObjIter *pIter /* Object iterator for column names */
219562 for(i=0; i<pIter->nTblCol; i++){
219563 const char *z = pIter->azTblCol[i];
219578 RbuObjIter *pIter, /* Object iterator for column names */
219588 for(i=0; i<pIter->nTblCol; i++){
219589 if( (int)pIter->abTblPk[i]==iPk ){
219590 const char *zCol = pIter->azTblCol[i];
219596 if( i==pIter->nTblCol ) break;
219623 RbuObjIter *pIter, /* RBU iterator object */
219632 "SELECT max(_rowid_) FROM \"%s%w\"", zWrite, pIter->zTbl
219641 char *zOrder = rbuObjIterGetPkList(p, pIter, "", ", ", " DESC");
219642 char *zSelect = rbuObjIterGetPkList(p, pIter, "quote(", "||','||", ")");
219643 char *zList = rbuObjIterGetPkList(p, pIter, "", ", ", "");
219649 zSelect, zWrite, pIter->zTbl, zOrder
219690 RbuObjIter *pIter /* RBU iterator object */
219703 sqlite3_mprintf("PRAGMA main.index_xinfo = %Q", pIter->zIdx)
219715 if( pIter->eType==RBU_PK_IPK ){
219717 for(i=0; pIter->abTblPk[i]==0; i++);
219718 assert( i<pIter->nTblCol );
219719 zCol = pIter->azTblCol[i];
219724 zCol = pIter->azTblCol[iCid];
219747 zSelect, pIter->zTbl, zOrder
219752 for(iCol=0; iCol<pIter->nCol; iCol++){
219805 RbuObjIter *pIter, /* Object iterator for column names */
219825 sqlite3_mprintf("PRAGMA main.index_xinfo = %Q", pIter->zIdx)
219839 pIter->aIdxCol[iSeq].nSpan, pIter->aIdxCol[iSeq].zSpan, zCollate
219846 if( pIter->eType==RBU_PK_IPK ){
219848 for(i=0; pIter->abTblPk[i]==0; i++);
219849 assert( i<pIter->nTblCol );
219850 zCol = pIter->azTblCol[i];
219858 zCol = pIter->azTblCol[iCid];
219859 zType = pIter->azTblType[iCid];
219864 if( pIter->bUnique==0 || sqlite3_column_int(pXInfo, 5) ){
219917 RbuObjIter *pIter,
219921 if( p->rc==SQLITE_OK && pIter->abIndexed ){
219924 for(i=0; i<pIter->nTblCol; i++){
219925 if( pIter->abIndexed[i] ){
219926 const char *zCol = pIter->azTblCol[i];
219939 if( pIter->eType==RBU_PK_EXTERNAL || pIter->eType==RBU_PK_NONE ){
219958 RbuObjIter *pIter
219961 if( pIter->eType==RBU_PK_VTAB || pIter->eType==RBU_PK_NONE ){
219962 zList = rbuMPrintf(p, "_rowid_ = ?%d", pIter->nTblCol+1);
219963 }else if( pIter->eType==RBU_PK_EXTERNAL ){
219966 for(i=0; i<pIter->nTblCol; i++){
219967 if( pIter->abTblPk[i] ){
219979 for(i=0; i<pIter->nTblCol; i++){
219980 if( pIter->abTblPk[i] ){
219981 const char *zCol = pIter->azTblCol[i];
220022 RbuObjIter *pIter,
220029 if( (int)strlen(zMask)!=pIter->nTblCol ){
220033 for(i=0; i<pIter->nTblCol; i++){
220034 char c = zMask[pIter->aiSrcOrder[i]];
220037 zList, zSep, pIter->azTblCol[i], i+1
220043 zList, zSep, pIter->azTblCol[i], pIter->azTblCol[i], i+1
220049 zList, zSep, pIter->azTblCol[i], pIter->azTblCol[i], i+1
220101 static char *rbuWithoutRowidPK(sqlite3rbu *p, RbuObjIter *pIter){
220103 assert( pIter->zIdx==0 );
220110 sqlite3_mprintf("PRAGMA main.index_list = %Q", pIter->zTbl)
220160 static void rbuCreateImposterTable2(sqlite3rbu *p, RbuObjIter *pIter){
220161 if( p->rc==SQLITE_OK && pIter->eType==RBU_PK_EXTERNAL ){
220162 int tnum = pIter->iPkTnum; /* Root page of PK index */
220196 iCid, pIter->azTblType[iCid], zCollate
220234 static void rbuCreateImposterTable(sqlite3rbu *p, RbuObjIter *pIter){
220235 if( p->rc==SQLITE_OK && pIter->eType!=RBU_PK_VTAB ){
220236 int tnum = pIter->iTnum;
220242 for(iCol=0; p->rc==SQLITE_OK && iCol<pIter->nTblCol; iCol++){
220244 const char *zCol = pIter->azTblCol[iCol];
220248 p->dbMain, "main", pIter->zTbl, zCol, 0, &zColl, 0, 0, 0
220251 if( pIter->eType==RBU_PK_IPK && pIter->abTblPk[iCol] ){
220257 zSql, zComma, zCol, pIter->azTblType[iCol], zPk, zColl,
220258 (pIter->abNotNull[iCol] ? " NOT NULL" : "")
220263 if( pIter->eType==RBU_PK_WITHOUT_ROWID ){
220264 char *zPk = rbuWithoutRowidPK(p, pIter);
220272 pIter->zTbl, zSql,
220273 (pIter->eType==RBU_PK_WITHOUT_ROWID ? " WITHOUT ROWID" : "")
220292 RbuObjIter *pIter,
220296 int bRbuRowid = (pIter->eType==RBU_PK_EXTERNAL || pIter->eType==RBU_PK_NONE);
220297 char *zBind = rbuObjIterGetBindlist(p, pIter->nTblCol + 1 + bRbuRowid);
220299 assert( pIter->pTmpInsert==0 );
220301 p->dbRbu, &pIter->pTmpInsert, &p->zErrmsg, sqlite3_mprintf(
220303 p->zStateDb, pIter->zDataTbl, zCollist, zRbuRowid, zBind
220338 static char *rbuObjIterGetIndexWhere(sqlite3rbu *p, RbuObjIter *pIter){
220343 assert( pIter->zIdxSql==0 && pIter->nIdxCol==0 && pIter->aIdxCol==0 );
220352 rc = sqlite3_bind_text(pStmt, 1, pIter->zIdx, -1, SQLITE_STATIC);
220356 pIter->zIdxSql = zSql = rbuStrndup(zSql, &rc);
220369 pIter->aIdxCol, (nIdxAlloc+16)*sizeof(RbuSpan)
220375 pIter->aIdxCol = aIdxCol;
220382 pIter->aIdxCol[0].zSpan = &zSql[i+1];
220389 int nSpan = &zSql[i] - pIter->aIdxCol[iIdxCol].zSpan;
220390 pIter->aIdxCol[iIdxCol++].nSpan = nSpan;
220395 int nSpan = &zSql[i] - pIter->aIdxCol[iIdxCol].zSpan;
220396 pIter->aIdxCol[iIdxCol++].nSpan = nSpan;
220397 pIter->aIdxCol[iIdxCol].zSpan = &zSql[i+1];
220421 pIter->nIdxCol = iIdxCol;
220440 RbuObjIter *pIter,
220443 assert( pIter->bCleanup==0 );
220444 if( pIter->pSelect==0 && rbuObjIterCacheTableInfo(p, pIter)==SQLITE_OK ){
220445 const int tnum = pIter->iTnum;
220448 const char *zIdx = pIter->zIdx;
220457 const char *zTbl = pIter->zTbl;
220465 assert( pIter->eType!=RBU_PK_VTAB );
220466 zPart = rbuObjIterGetIndexWhere(p, pIter);
220468 p, pIter, &zImposterCols, &zImposterPK, &zWhere, &nBind
220482 pIter->nCol = nBind;
220485 p->dbMain, &pIter->pInsert, &p->zErrmsg,
220493 p->dbMain, &pIter->pDelete, &p->zErrmsg,
220504 zStart = rbuVacuumIndexStart(p, pIter);
220514 pIter->zDataTbl,
220522 if( pIter->eType==RBU_PK_EXTERNAL || pIter->eType==RBU_PK_NONE ){
220525 zCollist, p->zStateDb, pIter->zDataTbl,
220535 zCollist, p->zStateDb, pIter->zDataTbl, zPart,
220536 zCollist, pIter->zDataTbl,
220543 p->rc = prepareFreeAndCollectError(p->dbRbu,&pIter->pSelect,pz,zSql);
220555 int bRbuRowid = (pIter->eType==RBU_PK_VTAB)
220556 ||(pIter->eType==RBU_PK_NONE)
220557 ||(pIter->eType==RBU_PK_EXTERNAL && rbuIsVacuum(p));
220558 const char *zTbl = pIter->zTbl; /* Table this step applies to */
220561 char *zBindings = rbuObjIterGetBindlist(p, pIter->nTblCol + bRbuRowid);
220562 char *zWhere = rbuObjIterGetWhere(p, pIter);
220563 char *zOldlist = rbuObjIterGetOldlist(p, pIter, "old");
220564 char *zNewlist = rbuObjIterGetOldlist(p, pIter, "new");
220566 zCollist = rbuObjIterGetCollist(p, pIter);
220567 pIter->nCol = pIter->nTblCol;
220570 rbuCreateImposterTable(p, pIter);
220571 rbuCreateImposterTable2(p, pIter);
220572 zWrite = (pIter->eType==RBU_PK_VTAB ? "" : "rbu_imp_");
220576 p->rc = prepareFreeAndCollectError(p->dbMain, &pIter->pInsert, pz,
220588 p->rc = prepareFreeAndCollectError(p->dbMain, &pIter->pDelete, pz,
220595 if( rbuIsVacuum(p)==0 && pIter->abIndexed ){
220597 if( pIter->eType==RBU_PK_EXTERNAL || pIter->eType==RBU_PK_NONE ){
220605 , p->zStateDb, pIter->zDataTbl
220606 , (pIter->eType==RBU_PK_EXTERNAL ? ", 0 AS rbu_rowid" : "")
220607 , pIter->zDataTbl
220630 if( pIter->eType==RBU_PK_EXTERNAL || pIter->eType==RBU_PK_NONE ){
220640 rbuObjIterPrepareTmpInsert(p, pIter, zCollist, zRbuRowid);
220654 zStart = rbuVacuumTableStart(p, pIter, bRbuRowid, zWrite);
220663 zOrder = rbuObjIterGetPkList(p, pIter, "", ", ", "");
220668 p->rc = prepareFreeAndCollectError(p->dbRbu, &pIter->pSelect, pz,
220674 pIter->zDataTbl, (zStart ? zStart : ""),
220707 RbuObjIter *pIter, /* Object iterator */
220722 for(pp=&pIter->pRbuUpdate; *pp; pp=&((*pp)->pNext)){
220726 pUp->pNext = pIter->pRbuUpdate;
220727 pIter->pRbuUpdate = pUp;
220736 for(pp=&pIter->pRbuUpdate; *pp!=pUp; pp=&((*pp)->pNext));
220741 pUp = (RbuUpdateStmt*)rbuMalloc(p, sizeof(RbuUpdateStmt)+pIter->nTblCol+1);
220745 char *zWhere = rbuObjIterGetWhere(p, pIter);
220746 char *zSet = rbuObjIterGetSetlist(p, pIter, zMask);
220750 memcpy(pUp->zMask, zMask, pIter->nTblCol);
220751 pUp->pNext = pIter->pRbuUpdate;
220752 pIter->pRbuUpdate = pUp;
220757 if( pIter->eType!=RBU_PK_VTAB ) zPrefix = "rbu_imp_";
220759 zPrefix, pIter->zTbl, zSet, zWhere
221477 RbuObjIter *pIter = &p->objiter;
221483 assert( eType!=RBU_DELETE || pIter->zIdx==0 );
221497 pWriter = pIter->pDelete;
221499 pWriter = pIter->pInsert;
221502 for(i=0; i<pIter->nCol; i++){
221507 && pIter->zIdx==0 && pIter->eType==RBU_PK_IPK && pIter->abTblPk[i]
221508 && sqlite3_column_type(pIter->pSelect, i)==SQLITE_NULL
221515 if( eType==RBU_DELETE && pIter->abTblPk[i]==0 ){
221519 pVal = sqlite3_column_value(pIter->pSelect, i);
221523 if( pIter->zIdx==0 ){
221524 if( pIter->eType==RBU_PK_VTAB
221525 || pIter->eType==RBU_PK_NONE
221526 || (pIter->eType==RBU_PK_EXTERNAL && rbuIsVacuum(p))
221535 assertColumnName(pIter->pSelect, pIter->nCol+1,
221538 pVal = sqlite3_column_value(pIter->pSelect, pIter->nCol+1);
221539 p->rc = sqlite3_bind_value(pWriter, pIter->nCol+1, pVal);
221560 RbuObjIter *pIter = &p->objiter;
221569 assert( eType!=RBU_UPDATE || pIter->zIdx==0 );
221571 if( pIter->zIdx==0 && (eType==RBU_IDX_DELETE || eType==RBU_IDX_INSERT) ){
221575 if( pIter->zIdx==0 ){
221589 rbuGetUpdateStmt(p, pIter, zMask, &pUpdate);
221592 for(i=0; p->rc==SQLITE_OK && i<pIter->nCol; i++){
221593 char c = zMask[pIter->aiSrcOrder[i]];
221594 pVal = sqlite3_column_value(pIter->pSelect, i);
221595 if( pIter->abTblPk[i] || c!='.' ){
221600 && (pIter->eType==RBU_PK_VTAB || pIter->eType==RBU_PK_NONE)
221603 assertColumnName(pIter->pSelect, pIter->nCol+1, "rbu_rowid");
221604 pVal = sqlite3_column_value(pIter->pSelect, pIter->nCol+1);
221605 p->rc = sqlite3_bind_value(pUpdate, pIter->nCol+1, pVal);
221792 RbuObjIter *pIter = &p->objiter;
221802 while( p->rc==SQLITE_OK && pIter->zTbl ){
221804 if( pIter->bCleanup ){
221808 if( rbuIsVacuum(p)==0 && pIter->abIndexed ){
221810 "DELETE FROM %s.'rbu_tmp_%q'", p->zStateDb, pIter->zDataTbl
221814 rbuObjIterPrepareAll(p, pIter, 0);
221818 int rc = sqlite3_step(pIter->pSelect);
221824 p->rc = sqlite3_reset(pIter->pSelect);
221829 rbuObjIterNext(p, pIter);
221833 assert( pIter->zTbl==0 );
221936 RbuObjIter *pIter = &p->objiter;
221939 while( rc==SQLITE_OK && pIter->zTbl && (pIter->bCleanup
221940 || rbuStrCompare(pIter->zIdx, pState->zIdx)
221941 || (pState->zDataTbl==0 && rbuStrCompare(pIter->zTbl, pState->zTbl))
221942 || (pState->zDataTbl && rbuStrCompare(pIter->zDataTbl, pState->zDataTbl))
221944 rc = rbuObjIterNext(p, pIter);
221947 if( rc==SQLITE_OK && !pIter->zTbl ){
222657 rbu_file *pIter;
222661 for(pIter=pRbuVfs->pMain; pIter; pIter=pIter->pMainNext);
222665 for(pIter=pRbuVfs->pMainRbu; pIter && pIter!=p; pIter=pIter->pMainRbuNext){}
222666 if( pIter==0 ){
228724 sqlite3_changeset_iter *pIter, /* Iterator handle */
228730 *pOp = pIter->op;
228731 *pnCol = pIter->nCol;
228732 *pzTab = pIter->zTab;
228733 if( pbIndirect ) *pbIndirect = pIter->bIndirect;
228744 sqlite3_changeset_iter *pIter, /* Iterator object */
228748 *pabPK = pIter->abPK;
228749 if( pnCol ) *pnCol = pIter->nCol;
228767 sqlite3_changeset_iter *pIter, /* Changeset iterator */
228771 if( pIter->op!=SQLITE_UPDATE && pIter->op!=SQLITE_DELETE ){
228774 if( iVal<0 || iVal>=pIter->nCol ){
228777 *ppValue = pIter->apValue[iVal];
228795 sqlite3_changeset_iter *pIter, /* Changeset iterator */
228799 if( pIter->op!=SQLITE_UPDATE && pIter->op!=SQLITE_INSERT ){
228802 if( iVal<0 || iVal>=pIter->nCol ){
228805 *ppValue = pIter->apValue[pIter->nCol+iVal];
228814 #define sessionChangesetNew(pIter, iVal) (pIter)->apValue[(pIter)->nCol+(iVal)]
228815 #define sessionChangesetOld(pIter, iVal) (pIter)->apValue[(iVal)]
228829 sqlite3_changeset_iter *pIter, /* Changeset iterator */
228833 if( !pIter->pConflict ){
228836 if( iVal<0 || iVal>=pIter->nCol ){
228839 *ppValue = sqlite3_column_value(pIter->pConflict, iVal);
228852 sqlite3_changeset_iter *pIter, /* Changeset iterator */
228855 if( pIter->pConflict || pIter->apValue ){
228858 *pnOut = pIter->nCol;
229121 sqlite3_changeset_iter *pIter,
229128 int nCol = pIter->nCol;
229129 int nU32 = (pIter->nCol+33)/32;
229142 for(ii=0; ii<pIter->nCol; ii++){
229143 if( sessionChangesetNew(pIter, ii) ){
229181 int bStat1 = (sqlite3_stricmp(pIter->zTab, "sqlite_stat1")==0);
229194 sessionAppendIdent(&buf, pIter->zTab, &rc);
229198 for(ii=0; ii<pIter->nCol; ii++){
229199 if( p->abPK[ii]==0 && sessionChangesetNew(pIter, ii) ){
229211 for(ii=0; ii<pIter->nCol; ii++){
229212 if( p->abPK[ii] || (bPatchset==0 && sessionChangesetOld(pIter, ii)) ){
229471 sqlite3_changeset_iter *pIter, /* Iterator to read values from */
229489 (void)xValue(pIter, i, &pVal);
229520 sqlite3_changeset_iter *pIter, /* Changeset iterator */
229530 sqlite3changeset_op(pIter, &zDummy, &nCol, &op, 0);
229531 rc = sessionBindRow(pIter,
229541 sqlite3changeset_new(pIter, ii, &pVal);
229569 sqlite3_changeset_iter *pIter /* Iterator pointing at current change */
229574 int eOp = pIter->op;
229577 const char *zTab = pIter->zTab;
229595 sqlite3changeset_old(pIter, i, &pVal);
229597 sqlite3changeset_new(pIter, i, &pVal);
229643 sqlite3_changeset_iter *pIter, /* Changeset iterator */
229654 sqlite3changeset_op(pIter, &zDummy, &nCol, &op, 0);
229662 rc = sessionSeekToRow(pIter, p);
229674 pIter->pConflict = p->pSelect;
229675 res = xConflict(pCtx, eType, pIter);
229676 pIter->pConflict = 0;
229683 u8 *aBlob = &pIter->in.aData[pIter->in.iCurrent];
229684 int nBlob = pIter->in.iNext - pIter->in.iCurrent;
229689 res = xConflict(pCtx, eType+1, pIter);
229713 rc = sessionRebaseAdd(p, res, pIter);
229745 sqlite3_changeset_iter *pIter, /* Changeset iterator */
229761 sqlite3changeset_op(pIter, &zDummy, &nCol, &op, 0);
229776 u8 *abPK = (pIter->bPatchset ? p->abPK : 0);
229777 rc = sessionBindRow(pIter, sqlite3changeset_old, nCol, abPK, p->pDelete);
229787 SQLITE_CHANGESET_DATA, p, pIter, xConflict, pCtx, pbRetry
229791 SQLITE_CHANGESET_CONFLICT, p, pIter, xConflict, pCtx, 0
229798 int bPatchset = (pbRetry==0 || pIter->bPatchset);
229800 rc = sessionUpdateFind(pIter, p, bPatchset, &pUp);
229804 sqlite3_value *pOld = sessionChangesetOld(pIter, i);
229805 sqlite3_value *pNew = sessionChangesetNew(pIter, i);
229826 SQLITE_CHANGESET_DATA, p, pIter, xConflict, pCtx, pbRetry
229832 SQLITE_CHANGESET_CONFLICT, p, pIter, xConflict, pCtx, 0
229842 rc = sessionSeekToRow(pIter, p);
229850 rc = sessionBindRow(pIter, sqlite3changeset_new, nCol, 0, p->pInsert);
229859 SQLITE_CHANGESET_CONFLICT, p, pIter, xConflict, pCtx, pbReplace
229879 sqlite3_changeset_iter *pIter, /* Changeset iterator to read change from */
229888 rc = sessionApplyOneOp(pIter, pApply, xConflict, pCtx, &bReplace, &bRetry);
229898 assert( pIter->op==SQLITE_UPDATE || pIter->op==SQLITE_DELETE );
229899 rc = sessionApplyOneOp(pIter, pApply, xConflict, pCtx, 0, 0);
229908 assert( pIter->op==SQLITE_INSERT );
229911 rc = sessionBindRow(pIter,
229920 rc = sessionApplyOneOp(pIter, pApply, xConflict, pCtx, 0, 0);
229992 sqlite3_changeset_iter *pIter, /* Changeset to apply */
230015 pIter->in.bNoDiscard = 1;
230027 while( rc==SQLITE_OK && SQLITE_ROW==sqlite3changeset_next(pIter) ){
230032 sqlite3changeset_op(pIter, &zNew, &nCol, &op, 0);
230038 db, pIter->bPatchset, zTab, &sApply, xConflict, pCtx
230076 sqlite3changeset_pk(pIter, &abPK, 0);
230130 rc = sessionApplyOneWithRetry(db, pIter, &sApply, xConflict, pCtx);
230133 bPatchset = pIter->bPatchset;
230135 rc = sqlite3changeset_finalize(pIter);
230137 sqlite3changeset_finalize(pIter);
230207 sqlite3_changeset_iter *pIter; /* Iterator to skip through changeset */
230209 int rc = sessionChangesetStart(&pIter, 0, 0, nChangeset, pChangeset, bInv, 1);
230219 db, pIter, xFilter, xConflict, pCtx, ppRebase, pnRebase, flags
230278 sqlite3_changeset_iter *pIter; /* Iterator to skip through changeset */
230280 int rc = sessionChangesetStart(&pIter, xInput, pIn, 0, 0, bInverse, 1);
230283 db, pIter, xFilter, xConflict, pCtx, ppRebase, pnRebase, flags
230623 sqlite3_changeset_iter *pIter,
230633 sqlite3changeset_pk(pIter, &abPK, &nCol);
230688 sqlite3_changeset_iter *pIter,
230700 u8 *aRec = &pIter->in.aData[pIter->in.iCurrent + 2];
230701 int nRec = (pIter->in.iNext - pIter->in.iCurrent) - 2;
230707 pGrp->bPatch = pIter->bPatchset;
230708 }else if( pIter->bPatchset!=pGrp->bPatch ){
230714 sqlite3changeset_op(pIter, &zTab, &nCol, &op, &bIndirect);
230715 rc = sessionChangesetFindTable(pGrp, zTab, pIter, &pTab);
230726 if( rc==SQLITE_OK && sessionGrowHash(0, pIter->bPatchset, pTab) ){
230734 pTab, (pIter->bPatchset && op==SQLITE_DELETE), aRec, pTab->nChange
230739 if( pIter->bPatchset ){
230754 pIter->bPatchset, pExist, op, bIndirect, aRec, nRec, &pChange
230763 if( rc==SQLITE_OK ) rc = pIter->rc;
230772 sqlite3_changeset_iter *pIter, /* Iterator to read from */
230780 while( SQLITE_ROW==(sessionChangesetNext(pIter, &aRec, &nRec, 0)) ){
230781 rc = sessionOneChangeToHash(pGrp, pIter, bRebase);
230785 if( rc==SQLITE_OK ) rc = pIter->rc;
230901 sqlite3_changeset_iter *pIter; /* Iterator opened on pData/nData */
230904 rc = sqlite3changeset_start(&pIter, nData, pData);
230906 rc = sessionChangesetToHash(pIter, pGrp, 0);
230908 sqlite3changeset_finalize(pIter);
230917 sqlite3_changeset_iter *pIter
230919 if( pIter->in.iCurrent==pIter->in.iNext
230920 || pIter->rc!=SQLITE_OK
230921 || pIter->bInvert
230926 return sessionOneChangeToHash(pGrp, pIter, 0);
230949 sqlite3_changeset_iter *pIter; /* Iterator opened on pData/nData */
230952 rc = sqlite3changeset_start_strm(&pIter, xInput, pIn);
230954 rc = sessionChangesetToHash(pIter, pGrp, 0);
230956 sqlite3changeset_finalize(pIter);
231105 sqlite3_changeset_iter *pIter, /* Iterator pointed at local change */
231119 *pOut++ = pIter->bIndirect;
231120 for(i=0; i<pIter->nCol; i++){
231123 if( pIter->abPK[i] || a2[0]==0 ){
231124 if( !pIter->abPK[i] && a1[0] ) bData = 1;
231139 for(i=0; i<pIter->nCol; i++){
231142 if( pIter->abPK[i] || a2[0]!=0xFF ){
231173 sqlite3_changeset_iter *pIter, /* Input data */
231186 while( SQLITE_ROW==sessionChangesetNext(pIter, &aRec, &nRec, &bNew) ){
231191 const char *zTab = pIter->zTab;
231198 if( pIter->bPatchset ){
231203 sessionAppendByte(&sOut, pIter->bPatchset ? 'P' : 'T', &rc);
231204 sessionAppendVarint(&sOut, pIter->nCol, &rc);
231205 sessionAppendBlob(&sOut, pIter->abPK, pIter->nCol, &rc);
231206 sessionAppendBlob(&sOut,(u8*)pIter->zTab,(int)strlen(pIter->zTab)+1,&rc);
231221 switch( pIter->op ){
231227 sessionAppendByte(&sOut, pIter->bIndirect, &rc);
231239 sessionSkipRecord(&pCsr, pIter->nCol);
231241 sessionAppendByte(&sOut, pIter->bIndirect, &rc);
231242 sessionAppendRecordMerge(&sOut, pIter->nCol,
231248 sessionAppendPartialUpdate(&sOut, pIter,
231255 assert( pIter->op==SQLITE_DELETE );
231259 sessionAppendByte(&sOut, pIter->bIndirect, &rc);
231260 sessionAppendRecordMerge(&sOut, pIter->nCol,
231269 sessionAppendByte(&sOut, pIter->op, &rc);
231270 sessionAppendByte(&sOut, pIter->bIndirect, &rc);
231324 sqlite3_changeset_iter *pIter = 0; /* Iterator opened on pData/nData */
231326 rc = sqlite3changeset_start(&pIter, nRebase, (void*)pRebase);
231328 rc = sessionChangesetToHash(pIter, &p->grp, 1);
231330 sqlite3changeset_finalize(pIter);
231342 sqlite3_changeset_iter *pIter = 0; /* Iterator to skip through input */
231343 int rc = sqlite3changeset_start(&pIter, nIn, (void*)pIn);
231346 rc = sessionRebase(p, pIter, 0, 0, pnOut, ppOut);
231347 sqlite3changeset_finalize(pIter);
231363 sqlite3_changeset_iter *pIter = 0; /* Iterator to skip through input */
231364 int rc = sqlite3changeset_start_strm(&pIter, xInput, pIn);
231367 rc = sessionRebase(p, pIter, xOutput, pOut, 0, 0);
231368 sqlite3changeset_finalize(pIter);
232379 Fts5PoslistReader *pIter /* Iterator object to initialize */
234517 static int fts5CInstIterNext(CInstIter *pIter){
234519 pIter->iStart = -1;
234520 pIter->iEnd = -1;
234522 while( rc==SQLITE_OK && pIter->iInst<pIter->nInst ){
234524 rc = pIter->pApi->xInst(pIter->pFts, pIter->iInst, &ip, &ic, &io);
234526 if( ic==pIter->iCol ){
234527 int iEnd = io - 1 + pIter->pApi->xPhraseSize(pIter->pFts, ip);
234528 if( pIter->iStart<0 ){
234529 pIter->iStart = io;
234530 pIter->iEnd = iEnd;
234531 }else if( io<=pIter->iEnd ){
234532 if( iEnd>pIter->iEnd ) pIter->iEnd = iEnd;
234537 pIter->iInst++;
234552 CInstIter *pIter
234556 memset(pIter, 0, sizeof(CInstIter));
234557 pIter->pApi = pApi;
234558 pIter->pFts = pFts;
234559 pIter->iCol = iCol;
234560 rc = pApi->xInstCount(pFts, &pIter->nInst);
234563 rc = fts5CInstIterNext(pIter);
235429 static int sqlite3Fts5PoslistReaderNext(Fts5PoslistReader *pIter){
235430 if( sqlite3Fts5PoslistNext64(pIter->a, pIter->n, &pIter->i, &pIter->iPos) ){
235431 pIter->bEof = 1;
235433 return pIter->bEof;
235438 Fts5PoslistReader *pIter /* Iterator object to initialize */
235440 memset(pIter, 0, sizeof(*pIter));
235441 pIter->a = a;
235442 pIter->n = n;
235443 sqlite3Fts5PoslistReaderNext(pIter);
235444 return pIter->bEof;
236776 Fts5IndexIter *pIter; /* Iterator for this term */
237168 if( 0==sqlite3Fts5IterEof(p->pIter) ){
237169 i64 iRowid = p->pIter->iRowid;
237199 Fts5IndexIter *pIter = p->pIter;
237200 if( sqlite3Fts5IterEof(pIter)==0 && pIter->iRowid==iRowid ){
237201 if( pIter->nData==0 ) continue;
237214 sqlite3Fts5PoslistReaderInit(pIter->pData, pIter->nData, &aIter[nIter]);
237305 a = (u8*)pTerm->pIter->pData;
237306 n = pTerm->pIter->nData;
237505 Fts5IndexIter *pIter, /* Iterator to advance */
237514 iRowid = pIter->iRowid;
237516 int rc = sqlite3Fts5IterNextFrom(pIter, iLast);
237517 if( rc || sqlite3Fts5IterEof(pIter) ){
237522 iRowid = pIter->iRowid;
237542 if( sqlite3Fts5IterEof(p->pIter)==0 ){
237543 i64 iRowid = p->pIter->iRowid;
237545 rc = sqlite3Fts5IterNextFrom(p->pIter, iLast);
237573 Fts5IndexIter *pIter = pTerm->pIter;
237574 if( sqlite3Fts5IterEof(pIter)==0 ){
237575 if( pIter->iRowid==pNode->iRowid && pIter->nData>0 ){
237596 Fts5IndexIter *pIter = pPhrase->aTerm[0].pIter;
237597 fts5BufferSet(&rc, &pPhrase->poslist, pIter->nData, pIter->pData);
237641 if( p->pIter ){
237642 sqlite3Fts5IterClose(p->pIter);
237643 p->pIter = 0;
237650 &p->pIter
237652 assert( (rc==SQLITE_OK)==(p->pIter!=0) );
237654 if( 0==sqlite3Fts5IterEof(p->pIter) ){
237782 iLast = pLeft->aTerm[0].pIter->iRowid;
237801 Fts5IndexIter *pIter = pPhrase->aTerm[j].pIter;
237802 if( pIter->iRowid==iLast || pIter->bEof ) continue;
237804 if( fts5ExprAdvanceto(pIter, bDesc, &iLast, &rc, &pNode->bEof) ){
237846 if( sqlite3Fts5IterEof(p->pIter)==0 ){
237847 i64 ii = p->pIter->iRowid;
237852 rc = sqlite3Fts5IterNextFrom(p->pIter, iFrom);
237854 rc = sqlite3Fts5IterNext(p->pIter);
237857 if( sqlite3Fts5IterEof(p->pIter)==0 ){
237870 Fts5IndexIter *pIter = pTerm->pIter;
237874 rc = sqlite3Fts5IterNextFrom(pIter, iFrom);
237876 rc = sqlite3Fts5IterNext(pIter);
237879 pNode->bEof = (rc || sqlite3Fts5IterEof(pIter));
237901 Fts5IndexIter *pIter = pPhrase->aTerm[0].pIter;
237907 pPhrase->poslist.n = pIter->nData;
237909 pPhrase->poslist.p = (u8*)pIter->pData;
237911 pNode->iRowid = pIter->iRowid;
237926 Fts5IndexIter *pIter = pNode->pNear->apPhrase[0]->aTerm[0].pIter;
237930 rc = sqlite3Fts5IterNextFrom(pIter, iFrom);
237932 rc = sqlite3Fts5IterNext(pIter);
237934 if( rc==SQLITE_OK && sqlite3Fts5IterEof(pIter)==0 ){
238284 sqlite3Fts5IterClose(pTerm->pIter);
238287 sqlite3Fts5IterClose(pSyn->pIter);
239719 pT->pIter, pToken, nToken, iRowid, iCol, iTokOff
239846 *ppCollist = pPhrase->aTerm[0].pIter->pData;
239847 *pnCollist = pPhrase->aTerm[0].pIter->nData;
239910 pTerm->pIter, iRowid, iCol, iOff+iToken, ppOut, pnOut
239929 sqlite3Fts5IndexIterClearTokendata(pT->pIter);
240397 Fts5HashEntry *pIter;
240398 for(pIter=pHash->aSlot[iSlot]; pIter; pIter=pIter->pHashNext){
240400 || (pIter->nKey>=nTerm && 0==memcmp(fts5EntryKey(pIter), pTerm, nTerm))
240402 Fts5HashEntry *pEntry = pIter;
242090 static int fts5DlidxIterNextR(Fts5Index *p, Fts5DlidxIter *pIter, int iLvl){
242091 Fts5DlidxLvl *pLvl = &pIter->aLvl[iLvl];
242093 assert( iLvl<pIter->nLvl );
242095 if( (iLvl+1) < pIter->nLvl ){
242096 fts5DlidxIterNextR(p, pIter, iLvl+1);
242101 FTS5_DLIDX_ROWID(pIter->iSegid, iLvl, pLvl[1].iLeafPgno)
242108 return pIter->aLvl[0].bEof;
242110 static int fts5DlidxIterNext(Fts5Index *p, Fts5DlidxIter *pIter){
242111 return fts5DlidxIterNextR(p, pIter, 0);
242125 static int fts5DlidxIterFirst(Fts5DlidxIter *pIter){
242127 for(i=0; i<pIter->nLvl; i++){
242128 fts5DlidxLvlNext(&pIter->aLvl[i]);
242130 return pIter->aLvl[0].bEof;
242134 static int fts5DlidxIterEof(Fts5Index *p, Fts5DlidxIter *pIter){
242135 return p->rc!=SQLITE_OK || pIter->aLvl[0].bEof;
242138 static void fts5DlidxIterLast(Fts5Index *p, Fts5DlidxIter *pIter){
242142 for(i=pIter->nLvl-1; p->rc==SQLITE_OK && i>=0; i--){
242143 Fts5DlidxLvl *pLvl = &pIter->aLvl[i];
242152 FTS5_DLIDX_ROWID(pIter->iSegid, i-1, pLvl->iLeafPgno)
242193 static int fts5DlidxIterPrevR(Fts5Index *p, Fts5DlidxIter *pIter, int iLvl){
242194 Fts5DlidxLvl *pLvl = &pIter->aLvl[iLvl];
242196 assert( iLvl<pIter->nLvl );
242198 if( (iLvl+1) < pIter->nLvl ){
242199 fts5DlidxIterPrevR(p, pIter, iLvl+1);
242204 FTS5_DLIDX_ROWID(pIter->iSegid, iLvl, pLvl[1].iLeafPgno)
242214 return pIter->aLvl[0].bEof;
242216 static int fts5DlidxIterPrev(Fts5Index *p, Fts5DlidxIter *pIter){
242217 return fts5DlidxIterPrevR(p, pIter, 0);
242223 static void fts5DlidxIterFree(Fts5DlidxIter *pIter){
242224 if( pIter ){
242226 for(i=0; i<pIter->nLvl; i++){
242227 fts5DataRelease(pIter->aLvl[i].pData);
242229 sqlite3_free(pIter);
242239 Fts5DlidxIter *pIter = 0;
242247 pNew = (Fts5DlidxIter*)sqlite3_realloc64(pIter, nByte);
242253 pIter = pNew;
242259 pIter->nLvl = i+1;
242264 pIter->iSegid = iSegid;
242266 fts5DlidxIterFirst(pIter);
242268 fts5DlidxIterLast(p, pIter);
242273 fts5DlidxIterFree(pIter);
242274 pIter = 0;
242277 return pIter;
242280 static i64 fts5DlidxIterRowid(Fts5DlidxIter *pIter){
242281 return pIter->aLvl[0].iRowid;
242283 static int fts5DlidxIterPgno(Fts5DlidxIter *pIter){
242284 return pIter->aLvl[0].iLeafPgno;
242292 Fts5SegIter *pIter /* Iterator to advance to next page */
242295 Fts5StructureSegment *pSeg = pIter->pSeg;
242296 fts5DataRelease(pIter->pLeaf);
242297 pIter->iLeafPgno++;
242298 if( pIter->pNextLeaf ){
242299 pIter->pLeaf = pIter->pNextLeaf;
242300 pIter->pNextLeaf = 0;
242301 }else if( pIter->iLeafPgno<=pSeg->pgnoLast ){
242302 pIter->pLeaf = fts5LeafRead(p,
242303 FTS5_SEGMENT_ROWID(pSeg->iSegid, pIter->iLeafPgno)
242306 pIter->pLeaf = 0;
242308 pLeaf = pIter->pLeaf;
242311 pIter->iPgidxOff = pLeaf->szLeaf;
242313 pIter->iEndofDoclist = pLeaf->nn+1;
242315 pIter->iPgidxOff += fts5GetVarint32(&pLeaf->p[pIter->iPgidxOff],
242316 pIter->iEndofDoclist
242349 static void fts5SegIterLoadNPos(Fts5Index *p, Fts5SegIter *pIter){
242351 int iOff = pIter->iLeafOffset; /* Offset to read at */
242352 ASSERT_SZLEAF_OK(pIter->pLeaf);
242354 int iEod = MIN(pIter->iEndofDoclist, pIter->pLeaf->szLeaf);
242355 pIter->bDel = 0;
242356 pIter->nPos = 1;
242357 if( iOff<iEod && pIter->pLeaf->p[iOff]==0 ){
242358 pIter->bDel = 1;
242360 if( iOff<iEod && pIter->pLeaf->p[iOff]==0 ){
242361 pIter->nPos = 1;
242364 pIter->nPos = 0;
242369 fts5FastGetVarint32(pIter->pLeaf->p, iOff, nSz);
242370 pIter->bDel = (nSz & 0x0001);
242371 pIter->nPos = nSz>>1;
242372 assert_nc( pIter->nPos>=0 );
242374 pIter->iLeafOffset = iOff;
242378 static void fts5SegIterLoadRowid(Fts5Index *p, Fts5SegIter *pIter){
242379 u8 *a = pIter->pLeaf->p; /* Buffer to read data from */
242380 i64 iOff = pIter->iLeafOffset;
242382 ASSERT_SZLEAF_OK(pIter->pLeaf);
242383 while( iOff>=pIter->pLeaf->szLeaf ){
242384 fts5SegIterNextPage(p, pIter);
242385 if( pIter->pLeaf==0 ){
242390 a = pIter->pLeaf->p;
242392 iOff += sqlite3Fts5GetVarint(&a[iOff], (u64*)&pIter->iRowid);
242393 pIter->iLeafOffset = iOff;
242411 static void fts5SegIterLoadTerm(Fts5Index *p, Fts5SegIter *pIter, int nKeep){
242412 u8 *a = pIter->pLeaf->p; /* Buffer to read data from */
242413 i64 iOff = pIter->iLeafOffset; /* Offset to read at */
242417 if( iOff+nNew>pIter->pLeaf->szLeaf || nKeep>pIter->term.n || nNew==0 ){
242421 pIter->term.n = nKeep;
242422 fts5BufferAppendBlob(&p->rc, &pIter->term, nNew, &a[iOff]);
242423 assert( pIter->term.n<=pIter->term.nSpace );
242425 pIter->iTermLeafOffset = iOff;
242426 pIter->iTermLeafPgno = pIter->iLeafPgno;
242427 pIter->iLeafOffset = iOff;
242429 if( pIter->iPgidxOff>=pIter->pLeaf->nn ){
242430 pIter->iEndofDoclist = pIter->pLeaf->nn+1;
242433 pIter->iPgidxOff += fts5GetVarint32(&a[pIter->iPgidxOff], nExtra);
242434 pIter->iEndofDoclist += nExtra;
242437 fts5SegIterLoadRowid(p, pIter);
242444 static void fts5SegIterSetNext(Fts5Index *p, Fts5SegIter *pIter){
242445 if( pIter->flags & FTS5_SEGITER_REVERSE ){
242446 pIter->xNext = fts5SegIterNext_Reverse;
242448 pIter->xNext = fts5SegIterNext_None;
242450 pIter->xNext = fts5SegIterNext;
242459 static void fts5SegIterAllocTombstone(Fts5Index *p, Fts5SegIter *pIter){
242460 const int nTomb = pIter->pSeg->nPgTombstone;
242468 pIter->pTombArray = pNew;
242484 Fts5SegIter *pIter /* Object to populate */
242492 assert( pIter->pLeaf==0 );
242497 memset(pIter, 0, sizeof(*pIter));
242498 fts5SegIterSetNext(p, pIter);
242499 pIter->pSeg = pSeg;
242500 pIter->iLeafPgno = pSeg->pgnoFirst-1;
242502 fts5SegIterNextPage(p, pIter);
242503 }while( p->rc==SQLITE_OK && pIter->pLeaf && pIter->pLeaf->nn==4 );
242506 if( p->rc==SQLITE_OK && pIter->pLeaf ){
242507 pIter->iLeafOffset = 4;
242508 assert( pIter->pLeaf!=0 );
242509 assert_nc( pIter->pLeaf->nn>4 );
242510 assert_nc( fts5LeafFirstTermOff(pIter->pLeaf)==4 );
242511 pIter->iPgidxOff = pIter->pLeaf->szLeaf+1;
242512 fts5SegIterLoadTerm(p, pIter, 0);
242513 fts5SegIterLoadNPos(p, pIter);
242514 fts5SegIterAllocTombstone(p, pIter);
242533 static void fts5SegIterReverseInitPage(Fts5Index *p, Fts5SegIter *pIter){
242535 int n = pIter->pLeaf->szLeaf;
242536 int i = pIter->iLeafOffset;
242537 u8 *a = pIter->pLeaf->p;
242540 if( n>pIter->iEndofDoclist ){
242541 n = pIter->iEndofDoclist;
242544 ASSERT_SZLEAF_OK(pIter->pLeaf);
242562 pIter->iRowid += iDelta;
242565 if( iRowidOffset>=pIter->nRowidOffset ){
242566 int nNew = pIter->nRowidOffset + 8;
242567 int *aNew = (int*)sqlite3_realloc64(pIter->aRowidOffset,nNew*sizeof(int));
242572 pIter->aRowidOffset = aNew;
242573 pIter->nRowidOffset = nNew;
242576 pIter->aRowidOffset[iRowidOffset++] = pIter->iLeafOffset;
242577 pIter->iLeafOffset = i;
242579 pIter->iRowidOffset = iRowidOffset;
242580 fts5SegIterLoadNPos(p, pIter);
242586 static void fts5SegIterReverseNewPage(Fts5Index *p, Fts5SegIter *pIter){
242587 assert( pIter->flags & FTS5_SEGITER_REVERSE );
242588 assert( pIter->flags & FTS5_SEGITER_ONETERM );
242590 fts5DataRelease(pIter->pLeaf);
242591 pIter->pLeaf = 0;
242592 while( p->rc==SQLITE_OK && pIter->iLeafPgno>pIter->iTermLeafPgno ){
242594 pIter->iLeafPgno--;
242596 pIter->pSeg->iSegid, pIter->iLeafPgno
242602 if( pIter->iLeafPgno==pIter->iTermLeafPgno ){
242603 assert( pIter->pLeaf==0 );
242604 if( pIter->iTermLeafOffset<pNew->szLeaf ){
242605 pIter->pLeaf = pNew;
242606 pIter->iLeafOffset = pIter->iTermLeafOffset;
242615 pIter->pLeaf = pNew;
242616 pIter->iLeafOffset = iRowidOff;
242621 if( pIter->pLeaf ){
242622 u8 *a = &pIter->pLeaf->p[pIter->iLeafOffset];
242623 pIter->iLeafOffset += fts5GetVarint(a, (u64*)&pIter->iRowid);
242631 if( pIter->pLeaf ){
242632 pIter->iEndofDoclist = pIter->pLeaf->nn+1;
242633 fts5SegIterReverseInitPage(p, pIter);
242642 static int fts5MultiIterIsEmpty(Fts5Index *p, Fts5Iter *pIter){
242643 Fts5SegIter *pSeg = &pIter->aSeg[pIter->aFirst[1].iFirst];
242654 Fts5SegIter *pIter, /* Iterator to advance */
242657 assert( pIter->flags & FTS5_SEGITER_REVERSE );
242658 assert( pIter->pNextLeaf==0 );
242661 if( pIter->iRowidOffset>0 ){
242662 u8 *a = pIter->pLeaf->p;
242666 pIter->iRowidOffset--;
242667 pIter->iLeafOffset = pIter->aRowidOffset[pIter->iRowidOffset];
242668 fts5SegIterLoadNPos(p, pIter);
242669 iOff = pIter->iLeafOffset;
242671 iOff += pIter->nPos;
242674 pIter->iRowid -= iDelta;
242676 fts5SegIterReverseNewPage(p, pIter);
242688 Fts5SegIter *pIter, /* Iterator to advance */
242694 assert( (pIter->flags & FTS5_SEGITER_REVERSE)==0 );
242697 ASSERT_SZLEAF_OK(pIter->pLeaf);
242698 iOff = pIter->iLeafOffset;
242701 while( pIter->pSeg && iOff>=pIter->pLeaf->szLeaf ){
242702 fts5SegIterNextPage(p, pIter);
242703 if( p->rc || pIter->pLeaf==0 ) return;
242704 pIter->iRowid = 0;
242708 if( iOff<pIter->iEndofDoclist ){
242711 iOff += sqlite3Fts5GetVarint(&pIter->pLeaf->p[iOff], (u64*)&iDelta);
242712 pIter->iLeafOffset = iOff;
242713 pIter->iRowid += iDelta;
242714 }else if( (pIter->flags & FTS5_SEGITER_ONETERM)==0 ){
242715 if( pIter->pSeg ){
242717 if( iOff!=fts5LeafFirstTermOff(pIter->pLeaf) ){
242718 iOff += fts5GetVarint32(&pIter->pLeaf->p[iOff], nKeep);
242720 pIter->iLeafOffset = iOff;
242721 fts5SegIterLoadTerm(p, pIter, nKeep);
242730 pIter->pLeaf->p = (u8*)pList;
242731 pIter->pLeaf->nn = nList;
242732 pIter->pLeaf->szLeaf = nList;
242733 pIter->iEndofDoclist = nList;
242734 sqlite3Fts5BufferSet(&p->rc,&pIter->term, nTerm, (u8*)zTerm);
242735 pIter->iLeafOffset = fts5GetVarint(pList, (u64*)&pIter->iRowid);
242743 fts5SegIterLoadNPos(p, pIter);
242747 fts5DataRelease(pIter->pLeaf);
242748 pIter->pLeaf = 0;
242761 Fts5SegIter *pIter, /* Iterator to advance */
242764 Fts5Data *pLeaf = pIter->pLeaf;
242779 iOff = pIter->iLeafOffset + pIter->nPos;
242783 assert_nc( iOff<=pIter->iEndofDoclist );
242784 if( iOff>=pIter->iEndofDoclist ){
242792 pIter->iRowid += iDelta;
242795 pIter->iLeafOffset = iOff;
242797 }else if( pIter->pSeg==0 ){
242802 assert( (pIter->flags & FTS5_SEGITER_ONETERM) || pbNewTerm );
242803 if( 0==(pIter->flags & FTS5_SEGITER_ONETERM) ){
242808 fts5DataRelease(pIter->pLeaf);
242809 pIter->pLeaf = 0;
242811 pIter->pLeaf->p = (u8*)pList;
242812 pIter->pLeaf->nn = nList;
242813 pIter->pLeaf->szLeaf = nList;
242814 pIter->iEndofDoclist = nList+1;
242815 sqlite3Fts5BufferSet(&p->rc, &pIter->term, nTerm, (u8*)zTerm);
242816 pIter->iLeafOffset = fts5GetVarint(pList, (u64*)&pIter->iRowid);
242823 fts5SegIterNextPage(p, pIter);
242824 pLeaf = pIter->pLeaf;
242828 iOff += sqlite3Fts5GetVarint(&pLeaf->p[iOff], (u64*)&pIter->iRowid);
242829 pIter->iLeafOffset = iOff;
242832 pIter->iPgidxOff = pLeaf->szLeaf + fts5GetVarint32(
242833 &pLeaf->p[pLeaf->szLeaf], pIter->iEndofDoclist
242838 pIter->iPgidxOff = pLeaf->szLeaf + fts5GetVarint32(
242841 pIter->iLeafOffset = iOff;
242842 pIter->iEndofDoclist = iOff;
242854 if( pIter->pLeaf ){
242856 if( pIter->flags & FTS5_SEGITER_ONETERM ){
242857 fts5DataRelease(pIter->pLeaf);
242858 pIter->pLeaf = 0;
242860 fts5SegIterLoadTerm(p, pIter, nKeep);
242861 fts5SegIterLoadNPos(p, pIter);
242869 assert_nc( pIter->iLeafOffset<=pIter->pLeaf->nn );
242870 fts5FastGetVarint32(pIter->pLeaf->p, pIter->iLeafOffset, nSz);
242871 pIter->bDel = (nSz & 0x0001);
242872 pIter->nPos = nSz>>1;
242873 assert_nc( pIter->nPos>=0 );
242890 static void fts5SegIterReverse(Fts5Index *p, Fts5SegIter *pIter){
242891 Fts5DlidxIter *pDlidx = pIter->pDlidx;
242896 int iSegid = pIter->pSeg->iSegid;
242900 Fts5Data *pLeaf = pIter->pLeaf; /* Current leaf data */
242906 if( pIter->iTermLeafPgno==pIter->iLeafPgno ){
242907 iPoslist = pIter->iTermLeafOffset;
242912 pIter->iLeafOffset = iPoslist;
242917 if( pIter->iEndofDoclist>=pLeaf->szLeaf ){
242919 Fts5StructureSegment *pSeg = pIter->pSeg;
242923 for(pgno=pIter->iLeafPgno+1; !p->rc && pgno<=pSeg->pgnoLast; pgno++){
242952 fts5DataRelease(pIter->pLeaf);
242953 pIter->pLeaf = pLast;
242954 pIter->iLeafPgno = pgnoLast;
242960 iOff += fts5GetVarint(&pLast->p[iOff], (u64*)&pIter->iRowid);
242961 pIter->iLeafOffset = iOff;
242964 pIter->iEndofDoclist = pLast->nn+1;
242966 pIter->iEndofDoclist = fts5LeafFirstTermOff(pLast);
242970 fts5SegIterReverseInitPage(p, pIter);
242979 static void fts5SegIterLoadDlidx(Fts5Index *p, Fts5SegIter *pIter){
242980 int iSeg = pIter->pSeg->iSegid;
242981 int bRev = (pIter->flags & FTS5_SEGITER_REVERSE);
242982 Fts5Data *pLeaf = pIter->pLeaf; /* Current leaf data */
242984 assert( pIter->flags & FTS5_SEGITER_ONETERM );
242985 assert( pIter->pDlidx==0 );
242990 if( pIter->iTermLeafPgno==pIter->iLeafPgno
242991 && pIter->iEndofDoclist<pLeaf->szLeaf
242996 pIter->pDlidx = fts5DlidxIterInit(p, bRev, iSeg, pIter->iTermLeafPgno);
243016 Fts5SegIter *pIter, /* Iterator to seek */
243020 const u8 *a = pIter->pLeaf->p;
243021 u32 n = (u32)pIter->pLeaf->nn;
243032 iPgidx = (u32)pIter->pLeaf->szLeaf;
243089 fts5DataRelease(pIter->pLeaf);
243090 pIter->pLeaf = 0;
243094 fts5SegIterNextPage(p, pIter);
243095 if( pIter->pLeaf==0 ) return;
243096 a = pIter->pLeaf->p;
243097 if( fts5LeafIsTermless(pIter->pLeaf)==0 ){
243098 iPgidx = (u32)pIter->pLeaf->szLeaf;
243099 iPgidx += fts5GetVarint32(&pIter->pLeaf->p[iPgidx], iOff);
243100 if( iOff<4 || (i64)iOff>=pIter->pLeaf->szLeaf ){
243106 n = (u32)pIter->pLeaf->nn;
243119 pIter->iLeafOffset = iOff + nNew;
243120 pIter->iTermLeafOffset = pIter->iLeafOffset;
243121 pIter->iTermLeafPgno = pIter->iLeafPgno;
243123 fts5BufferSet(&p->rc, &pIter->term, nKeep, pTerm);
243124 fts5BufferAppendBlob(&p->rc, &pIter->term, nNew, &a[iOff]);
243127 pIter->iEndofDoclist = pIter->pLeaf->nn+1;
243131 pIter->iEndofDoclist = iTermOff + nExtra;
243133 pIter->iPgidxOff = iPgidx;
243135 fts5SegIterLoadRowid(p, pIter);
243136 fts5SegIterLoadNPos(p, pIter);
243163 Fts5SegIter *pIter /* Object to populate */
243172 memset(pIter, 0, sizeof(*pIter));
243173 pIter->pSeg = pSeg;
243194 pIter->iLeafPgno = iPg - 1;
243195 fts5SegIterNextPage(p, pIter);
243197 if( pIter->pLeaf ){
243198 fts5LeafSeek(p, bGe, pIter, pTerm, nTerm);
243202 pIter->flags |= FTS5_SEGITER_ONETERM;
243203 if( pIter->pLeaf ){
243205 pIter->flags |= FTS5_SEGITER_REVERSE;
243208 fts5SegIterLoadDlidx(p, pIter);
243211 fts5SegIterReverse(p, pIter);
243216 fts5SegIterSetNext(p, pIter);
243218 fts5SegIterAllocTombstone(p, pIter);
243230 || pIter->pLeaf==0 /* 2 */
243231 || fts5BufferCompareBlob(&pIter->term, pTerm, nTerm)==0 /* 3 */
243232 || (bGe && fts5BufferCompareBlob(&pIter->term, pTerm, nTerm)>0) /* 4 */
243262 Fts5SegIter *pIter /* Object to populate */
243284 memset(pIter, 0, sizeof(*pIter));
243285 pIter->pSeg = pSeg;
243286 pIter->flags |= FTS5_SEGITER_ONETERM;
243288 pIter->iLeafPgno = iPg - 1;
243289 fts5SegIterNextPage(p, pIter);
243290 fts5SegIterSetNext(p, pIter);
243292 if( pIter->pLeaf ){
243293 const u8 *a = pIter->pLeaf->p;
243296 pIter->iPgidxOff = pIter->pLeaf->szLeaf;
243297 pIter->iPgidxOff += fts5GetVarint32(&a[pIter->iPgidxOff], iTermOff);
243298 pIter->iLeafOffset = iTermOff;
243299 fts5SegIterLoadTerm(p, pIter, 0);
243300 fts5SegIterLoadNPos(p, pIter);
243301 if( bDlidx ) fts5SegIterLoadDlidx(p, pIter);
243304 fts5BufferCompareBlob(&pIter->term, (const u8*)pTerm, nTerm)>0
243321 Fts5SegIter *pIter /* Object to populate */
243359 pIter->flags |= FTS5_SEGITER_ONETERM;
243363 sqlite3Fts5BufferSet(&p->rc, &pIter->term, n, z);
243365 pIter->pLeaf = pLeaf;
243366 pIter->iLeafOffset = fts5GetVarint(pLeaf->p, (u64*)&pIter->iRowid);
243367 pIter->iEndofDoclist = pLeaf->nn;
243370 pIter->flags |= FTS5_SEGITER_REVERSE;
243371 fts5SegIterReverseInitPage(p, pIter);
243373 fts5SegIterLoadNPos(p, pIter);
243377 fts5SegIterSetNext(p, pIter);
243414 static void fts5SegIterClear(Fts5SegIter *pIter){
243415 fts5BufferFree(&pIter->term);
243416 fts5DataRelease(pIter->pLeaf);
243417 fts5DataRelease(pIter->pNextLeaf);
243418 fts5TombstoneArrayDelete(pIter->pTombArray);
243419 fts5DlidxIterFree(pIter->pDlidx);
243420 sqlite3_free(pIter->aRowidOffset);
243421 memset(pIter, 0, sizeof(Fts5SegIter));
243433 Fts5Iter *pIter,
243438 int i1 = p1 - pIter->aSeg;
243439 int i2 = p2 - pIter->aSeg;
243454 res = ((p1->iRowid > p2->iRowid)==pIter->bRev) ? -1 : 1;
243474 static void fts5AssertMultiIterSetup(Fts5Index *p, Fts5Iter *pIter){
243476 Fts5SegIter *pFirst = &pIter->aSeg[ pIter->aFirst[1].iFirst ];
243479 assert( (pFirst->pLeaf==0)==pIter->base.bEof );
243482 for(i=0; i<pIter->nSeg; i++){
243483 Fts5SegIter *p1 = &pIter->aSeg[i];
243487 || p1->iRowid==pIter->iSwitchRowid
243488 || (p1->iRowid<pIter->iSwitchRowid)==pIter->bRev
243492 for(i=0; i<pIter->nSeg; i+=2){
243493 Fts5SegIter *p1 = &pIter->aSeg[i];
243494 Fts5SegIter *p2 = &pIter->aSeg[i+1];
243495 Fts5CResult *pRes = &pIter->aFirst[(pIter->nSeg + i) / 2];
243496 fts5AssertComparisonResult(pIter, p1, p2, pRes);
243499 for(i=1; i<(pIter->nSeg / 2); i+=2){
243500 Fts5SegIter *p1 = &pIter->aSeg[ pIter->aFirst[i*2].iFirst ];
243501 Fts5SegIter *p2 = &pIter->aSeg[ pIter->aFirst[i*2+1].iFirst ];
243502 Fts5CResult *pRes = &pIter->aFirst[i];
243503 fts5AssertComparisonResult(pIter, p1, p2, pRes);
243519 static int fts5MultiIterDoCompare(Fts5Iter *pIter, int iOut){
243525 Fts5CResult *pRes = &pIter->aFirst[iOut];
243527 assert( iOut<pIter->nSeg && iOut>0 );
243528 assert( pIter->bRev==0 || pIter->bRev==1 );
243530 if( iOut>=(pIter->nSeg/2) ){
243531 i1 = (iOut - pIter->nSeg/2) * 2;
243534 i1 = pIter->aFirst[iOut*2].iFirst;
243535 i2 = pIter->aFirst[iOut*2+1].iFirst;
243537 p1 = &pIter->aSeg[i1];
243538 p2 = &pIter->aSeg[i2];
243554 res = ((p1->iRowid > p2->iRowid)==pIter->bRev) ? -1 : +1;
243575 Fts5SegIter *pIter, /* Iterator to advance */
243578 assert( iLeafPgno>pIter->iLeafPgno );
243580 if( iLeafPgno>pIter->pSeg->pgnoLast ){
243583 fts5DataRelease(pIter->pNextLeaf);
243584 pIter->pNextLeaf = 0;
243585 pIter->iLeafPgno = iLeafPgno-1;
243589 fts5SegIterNextPage(p, pIter);
243590 if( pIter->pLeaf==0 ) break;
243591 iOff = fts5LeafFirstRowidOff(pIter->pLeaf);
243593 u8 *a = pIter->pLeaf->p;
243594 int n = pIter->pLeaf->szLeaf;
243598 iOff += fts5GetVarint(&a[iOff], (u64*)&pIter->iRowid);
243599 pIter->iLeafOffset = iOff;
243600 fts5SegIterLoadNPos(p, pIter);
243615 Fts5SegIter *pIter, /* Iterator to advance */
243618 int bRev = (pIter->flags & FTS5_SEGITER_REVERSE);
243619 Fts5DlidxIter *pDlidx = pIter->pDlidx;
243620 int iLeafPgno = pIter->iLeafPgno;
243623 assert( pIter->flags & FTS5_SEGITER_ONETERM );
243624 assert( pIter->pDlidx );
243625 assert( pIter->pLeaf );
243632 assert_nc( iLeafPgno>=pIter->iLeafPgno || p->rc );
243633 if( iLeafPgno>pIter->iLeafPgno ){
243634 fts5SegIterGotoPage(p, pIter, iLeafPgno);
243638 assert( pIter->pNextLeaf==0 );
243639 assert( iMatch<pIter->iRowid );
243645 assert( fts5DlidxIterEof(p, pDlidx) || iLeafPgno<=pIter->iLeafPgno );
243647 if( iLeafPgno<pIter->iLeafPgno ){
243648 pIter->iLeafPgno = iLeafPgno+1;
243649 fts5SegIterReverseNewPage(p, pIter);
243655 if( bMove && p->rc==SQLITE_OK ) pIter->xNext(p, pIter, 0);
243656 if( pIter->pLeaf==0 ) break;
243657 if( bRev==0 && pIter->iRowid>=iMatch ) break;
243658 if( bRev!=0 && pIter->iRowid<=iMatch ) break;
243666 static void fts5MultiIterFree(Fts5Iter *pIter){
243667 if( pIter ){
243669 for(i=0; i<pIter->nSeg; i++){
243670 fts5SegIterClear(&pIter->aSeg[i]);
243672 fts5BufferFree(&pIter->poslist);
243673 sqlite3_free(pIter);
243679 Fts5Iter *pIter, /* Iterator to update aFirst[] array for */
243684 for(i=(pIter->nSeg+iChanged)/2; i>=iMinset && p->rc==SQLITE_OK; i=i/2){
243686 if( (iEq = fts5MultiIterDoCompare(pIter, i)) ){
243687 Fts5SegIter *pSeg = &pIter->aSeg[iEq];
243690 i = pIter->nSeg + iEq;
243706 Fts5Iter *pIter, /* Iterator to update aFirst[] array for */
243710 Fts5SegIter *pNew = &pIter->aSeg[iChanged];
243712 if( pNew->iRowid==pIter->iSwitchRowid
243713 || (pNew->iRowid<pIter->iSwitchRowid)==pIter->bRev
243716 Fts5SegIter *pOther = &pIter->aSeg[iChanged ^ 0x0001];
243717 pIter->iSwitchRowid = pIter->bRev ? SMALLEST_INT64 : LARGEST_INT64;
243718 for(i=(pIter->nSeg+iChanged)/2; 1; i=i/2){
243719 Fts5CResult *pRes = &pIter->aFirst[i];
243727 }else if( (pOther->iRowid>pNew->iRowid)==pIter->bRev ){
243728 pIter->iSwitchRowid = pOther->iRowid;
243730 }else if( (pOther->iRowid>pIter->iSwitchRowid)==pIter->bRev ){
243731 pIter->iSwitchRowid = pOther->iRowid;
243734 pRes->iFirst = (u16)(pNew - pIter->aSeg);
243737 pOther = &pIter->aSeg[ pIter->aFirst[i ^ 0x0001].iFirst ];
243748 static void fts5MultiIterSetEof(Fts5Iter *pIter){
243749 Fts5SegIter *pSeg = &pIter->aSeg[ pIter->aFirst[1].iFirst ];
243750 pIter->base.bEof = pSeg->pLeaf==0;
243751 pIter->iSwitchRowid = pSeg->iRowid;
243804 static int fts5MultiIterIsDeleted(Fts5Iter *pIter){
243805 int iFirst = pIter->aFirst[1].iFirst;
243806 Fts5SegIter *pSeg = &pIter->aSeg[iFirst];
243817 pArray->apTombstone[iPg] = fts5DataRead(pIter->pIndex,
243842 Fts5Iter *pIter,
243847 assert( pIter->base.bEof==0 );
243849 int iFirst = pIter->aFirst[1].iFirst;
243851 Fts5SegIter *pSeg = &pIter->aSeg[iFirst];
243860 || fts5MultiIterAdvanceRowid(pIter, iFirst, &pSeg)
243862 fts5MultiIterAdvanced(p, pIter, iFirst, 1);
243863 fts5MultiIterSetEof(pIter);
243864 pSeg = &pIter->aSeg[pIter->aFirst[1].iFirst];
243868 fts5AssertMultiIterSetup(p, pIter);
243869 assert( pSeg==&pIter->aSeg[pIter->aFirst[1].iFirst] && pSeg->pLeaf );
243870 if( (pIter->bSkipEmpty==0 || pSeg->nPos)
243871 && 0==fts5MultiIterIsDeleted(pIter)
243873 pIter->xSetOutputs(pIter, pSeg);
243882 Fts5Iter *pIter,
243885 assert( pIter->bSkipEmpty );
243889 int iFirst = pIter->aFirst[1].iFirst;
243890 Fts5SegIter *pSeg = &pIter->aSeg[iFirst];
243896 || fts5MultiIterAdvanceRowid(pIter, iFirst, &pSeg)
243898 fts5MultiIterAdvanced(p, pIter, iFirst, 1);
243899 fts5MultiIterSetEof(pIter);
243902 fts5AssertMultiIterSetup(p, pIter);
243904 }while( (fts5MultiIterIsEmpty(p, pIter) || fts5MultiIterIsDeleted(pIter))
244148 Fts5Iter *pIter
244157 if( pColset->nCol>1 && sqlite3Fts5BufferSize(pRc, &pIter->poslist, nPos) ){
244165 pIter->base.pData = pIter->poslist.p;
244166 pIter->base.nData = pIter->poslist.n;
244179 pIter->base.pData = aCopy;
244180 pIter->base.nData = p-aCopy;
244183 fts5BufferSafeAppendBlob(&pIter->poslist, aCopy, p-aCopy);
244186 pIter->base.pData = pIter->poslist.p;
244187 pIter->base.nData = pIter->poslist.n;
244204 static void fts5IterSetOutputs_None(Fts5Iter *pIter, Fts5SegIter *pSeg){
244205 assert( pIter->pIndex->pConfig->eDetail==FTS5_DETAIL_NONE );
244206 pIter->base.iRowid = pSeg->iRowid;
244207 pIter->base.nData = pSeg->nPos;
244214 static void fts5IterSetOutputs_Nocolset(Fts5Iter *pIter, Fts5SegIter *pSeg){
244215 pIter->base.iRowid = pSeg->iRowid;
244216 pIter->base.nData = pSeg->nPos;
244218 assert( pIter->pIndex->pConfig->eDetail!=FTS5_DETAIL_NONE );
244219 assert( pIter->pColset==0 );
244224 pIter->base.pData = &pSeg->pLeaf->p[pSeg->iLeafOffset];
244229 fts5BufferZero(&pIter->poslist);
244230 fts5SegiterPoslist(pIter->pIndex, pSeg, 0, &pIter->poslist);
244231 pIter->base.pData = pIter->poslist.p;
244239 static void fts5IterSetOutputs_ZeroColset(Fts5Iter *pIter, Fts5SegIter *pSeg){
244241 pIter->base.nData = 0;
244249 static void fts5IterSetOutputs_Col(Fts5Iter *pIter, Fts5SegIter *pSeg){
244250 fts5BufferZero(&pIter->poslist);
244251 fts5SegiterPoslist(pIter->pIndex, pSeg, pIter->pColset, &pIter->poslist);
244252 pIter->base.iRowid = pSeg->iRowid;
244253 pIter->base.pData = pIter->poslist.p;
244254 pIter->base.nData = pIter->poslist.n;
244267 static void fts5IterSetOutputs_Col100(Fts5Iter *pIter, Fts5SegIter *pSeg){
244269 assert( pIter->pIndex->pConfig->eDetail==FTS5_DETAIL_COLUMNS );
244270 assert( pIter->pColset );
244273 fts5IterSetOutputs_Col(pIter, pSeg);
244278 int *aiCol = pIter->pColset->aiCol;
244279 int *aiColEnd = &aiCol[pIter->pColset->nCol];
244281 u8 *aOut = pIter->poslist.p;
244284 pIter->base.iRowid = pSeg->iRowid;
244299 pIter->base.pData = pIter->poslist.p;
244300 pIter->base.nData = aOut - pIter->poslist.p;
244307 static void fts5IterSetOutputs_Full(Fts5Iter *pIter, Fts5SegIter *pSeg){
244308 Fts5Colset *pColset = pIter->pColset;
244309 pIter->base.iRowid = pSeg->iRowid;
244311 assert( pIter->pIndex->pConfig->eDetail==FTS5_DETAIL_FULL );
244318 int *pRc = &pIter->pIndex->rc;
244319 fts5BufferZero(&pIter->poslist);
244320 fts5IndexExtractColset(pRc, pColset, a, pSeg->nPos, pIter);
244325 fts5BufferZero(&pIter->poslist);
244326 fts5SegiterPoslist(pIter->pIndex, pSeg, pColset, &pIter->poslist);
244327 pIter->base.pData = pIter->poslist.p;
244328 pIter->base.nData = pIter->poslist.n;
244332 static void fts5IterSetOutputCb(int *pRc, Fts5Iter *pIter){
244333 assert( pIter!=0 || (*pRc)!=SQLITE_OK );
244335 Fts5Config *pConfig = pIter->pIndex->pConfig;
244337 pIter->xSetOutputs = fts5IterSetOutputs_None;
244340 else if( pIter->pColset==0 ){
244341 pIter->xSetOutputs = fts5IterSetOutputs_Nocolset;
244344 else if( pIter->pColset->nCol==0 ){
244345 pIter->xSetOutputs = fts5IterSetOutputs_ZeroColset;
244349 pIter->xSetOutputs = fts5IterSetOutputs_Full;
244355 pIter->xSetOutputs = fts5IterSetOutputs_Col100;
244356 sqlite3Fts5BufferSize(pRc, &pIter->poslist, pConfig->nCol);
244358 pIter->xSetOutputs = fts5IterSetOutputs_Col;
244368 static void fts5MultiIterFinishSetup(Fts5Index *p, Fts5Iter *pIter){
244370 for(iIter=pIter->nSeg-1; iIter>0; iIter--){
244372 if( (iEq = fts5MultiIterDoCompare(pIter, iIter)) ){
244373 Fts5SegIter *pSeg = &pIter->aSeg[iEq];
244375 fts5MultiIterAdvanced(p, pIter, iEq, iIter);
244378 fts5MultiIterSetEof(pIter);
244379 fts5AssertMultiIterSetup(p, pIter);
244381 if( (pIter->bSkipEmpty && fts5MultiIterIsEmpty(p, pIter))
244382 || fts5MultiIterIsDeleted(pIter)
244384 fts5MultiIterNext(p, pIter, 0, 0);
244385 }else if( pIter->base.bEof==0 ){
244386 Fts5SegIter *pSeg = &pIter->aSeg[pIter->aFirst[1].iFirst];
244387 pIter->xSetOutputs(pIter, pSeg);
244448 Fts5SegIter *pIter = &pNew->aSeg[iIter++];
244449 fts5SegIterHashInit(p, pTerm, nTerm, flags, pIter);
244454 Fts5SegIter *pIter = &pNew->aSeg[iIter++];
244456 fts5SegIterInit(p, pSeg, pIter);
244458 fts5SegIterSeekInit(p, pTerm, nTerm, flags, pSeg, pIter);
244500 Fts5SegIter *pIter = &pNew->aSeg[1];
244501 pIter->flags = FTS5_SEGITER_ONETERM;
244503 pIter->pLeaf = pData;
244504 pIter->iLeafOffset = fts5GetVarint(pData->p, (u64*)&pIter->iRowid);
244505 pIter->iEndofDoclist = pData->nn;
244509 pIter->flags |= FTS5_SEGITER_REVERSE;
244510 fts5SegIterReverseInitPage(p, pIter);
244512 fts5SegIterLoadNPos(p, pIter);
244518 fts5SegIterSetNext(p, pIter);
244530 static int fts5MultiIterEof(Fts5Index *p, Fts5Iter *pIter){
244531 assert( pIter!=0 || p->rc!=SQLITE_OK );
244533 || (pIter->aSeg[ pIter->aFirst[1].iFirst ].pLeaf==0)==pIter->base.bEof
244535 return (p->rc || pIter->base.bEof);
244543 static i64 fts5MultiIterRowid(Fts5Iter *pIter){
244544 assert( pIter->aSeg[ pIter->aFirst[1].iFirst ].pLeaf );
244545 return pIter->aSeg[ pIter->aFirst[1].iFirst ].iRowid;
244553 Fts5Iter *pIter,
244558 fts5MultiIterNext(p, pIter, 1, iMatch);
244559 if( fts5MultiIterEof(p, pIter) ) break;
244560 iRowid = fts5MultiIterRowid(pIter);
244561 if( pIter->bRev==0 && iRowid>=iMatch ) break;
244562 if( pIter->bRev!=0 && iRowid<=iMatch ) break;
244570 static const u8 *fts5MultiIterTerm(Fts5Iter *pIter, int *pn){
244571 Fts5SegIter *p = &pIter->aSeg[ pIter->aFirst[1].iFirst ];
245150 static void fts5TrimSegments(Fts5Index *p, Fts5Iter *pIter){
245154 for(i=0; i<pIter->nSeg && p->rc==SQLITE_OK; i++){
245155 Fts5SegIter *pSeg = &pIter->aSeg[i];
245237 Fts5Iter *pIter = 0; /* Iterator to read input data */
245297 for(fts5MultiIterNew(p, pStruct, flags, 0, 0, 0, iLvl, nInput, &pIter);
245298 fts5MultiIterEof(p, pIter)==0;
245299 fts5MultiIterNext(p, pIter, 0, 0)
245301 Fts5SegIter *pSegIter = &pIter->aSeg[ pIter->aFirst[1].iFirst ];
245306 pTerm = fts5MultiIterTerm(pIter, &nTerm);
245326 fts5WriteAppendRowid(p, &writer, fts5MultiIterRowid(pIter));
245347 assert( pIter!=0 || p->rc!=SQLITE_OK );
245348 if( fts5MultiIterEof(p, pIter) ){
245373 fts5TrimSegments(p, pIter);
245377 fts5MultiIterFree(pIter);
245991 Fts5Iter *pIter = 0; /* Used to find term instance */
245993 fts5MultiIterNew(p, pStruct, f, 0, (const u8*)zTerm, nTerm, -1, 0, &pIter);
245994 if( fts5MultiIterEof(p, pIter)==0 ){
245995 i64 iThis = fts5MultiIterRowid(pIter);
245997 fts5MultiIterNextFrom(p, pIter, iRowid);
246001 && fts5MultiIterEof(p, pIter)==0
246002 && iRowid==fts5MultiIterRowid(pIter)
246004 Fts5SegIter *pSeg = &pIter->aSeg[pIter->aFirst[1].iFirst];
246009 fts5MultiIterFree(pIter);
246405 static void fts5DoclistIterNext(Fts5DoclistIter *pIter){
246406 u8 *p = pIter->aPoslist + pIter->nSize + pIter->nPoslist;
246408 assert( pIter->aPoslist || (p==0 && pIter->aPoslist==0) );
246409 if( p>=pIter->aEof ){
246410 pIter->aPoslist = 0;
246415 pIter->iRowid += iDelta;
246420 pIter->nSize = fts5GetVarint32(p, nPos);
246421 pIter->nPoslist = (nPos>>1);
246423 pIter->nPoslist = ((int)(p[0])) >> 1;
246424 pIter->nSize = 1;
246427 pIter->aPoslist = p;
246428 if( &pIter->aPoslist[pIter->nPoslist]>pIter->aEof ){
246429 pIter->aPoslist = 0;
246436 Fts5DoclistIter *pIter
246438 memset(pIter, 0, sizeof(*pIter));
246440 pIter->aPoslist = pBuf->p;
246441 pIter->aEof = &pBuf->p[pBuf->n];
246442 fts5DoclistIterNext(pIter);
247235 static void fts5IterSetOutputsTokendata(Fts5Iter *pIter){
247241 Fts5TokenDataIter *pT = pIter->pTokenDataIter;
247243 pIter->base.nData = 0;
247244 pIter->base.pData = 0;
247252 pIter->base.pData = p->base.pData;
247253 pIter->base.nData = p->base.nData;
247262 pIter->base.bEof = 1;
247264 int eDetail = pIter->pIndex->pConfig->eDetail;
247265 pIter->base.bEof = 0;
247266 pIter->base.iRowid = iRowid;
247269 fts5TokendataIterAppendMap(pIter->pIndex, pT, iMin, iRowid, -1);
247279 &pIter->pIndex->rc,
247299 if( fts5BufferGrow(&pIter->pIndex->rc, &pIter->poslist, nByte+nHit*10) ){
247310 pIter->pIndex->rc = SQLITE_NOMEM;
247317 pIter->poslist.n = 0;
247337 sqlite3Fts5PoslistSafeAppend(&pIter->poslist, &iPrev, iMinPos);
247348 pIter->base.pData = pIter->poslist.p;
247349 pIter->base.nData = pIter->poslist.n;
247361 static void fts5TokendataIterNext(Fts5Iter *pIter, int bFrom, i64 iFrom){
247363 Fts5TokenDataIter *pT = pIter->pTokenDataIter;
247364 Fts5Index *pIndex = pIter->pIndex;
247369 && (p->base.iRowid==pIter->base.iRowid || (bFrom && p->base.iRowid<iFrom))
247382 fts5IterSetOutputsTokendata(pIter);
247390 static void fts5TokendataSetTermIfEof(Fts5Iter *pIter, Fts5Buffer *pTerm){
247391 if( pIter && pIter->aSeg[0].pLeaf==0 ){
247392 fts5BufferSet(&pIter->pIndex->rc, &pIter->aSeg[0].term, pTerm->n, pTerm->p);
247509 Fts5Iter *pIter = pSet->apIter[ii];
247511 for(iSeg=0; iSeg<pIter->nSeg; iSeg++){
247512 pIter->aSeg[iSeg].flags |= FTS5_SEGITER_ONETERM;
247514 fts5MultiIterFinishSetup(p, pIter);
247639 Fts5Iter *pIter = (Fts5Iter*)pIndexIter;
247640 assert( pIter->pIndex->rc==SQLITE_OK );
247641 if( pIter->pTokenDataIter ){
247642 fts5TokendataIterNext(pIter, 0, 0);
247644 fts5MultiIterNext(pIter->pIndex, pIter, 0, 0);
247646 return fts5IndexReturn(pIter->pIndex);
247653 Fts5Iter *pIter = (Fts5Iter*)pIndexIter;
247654 Fts5Index *p = pIter->pIndex;
247656 assert( pIter->pIndex->rc==SQLITE_OK );
247658 fts5MultiIterNext(p, pIter, 0, 0);
247660 Fts5SegIter *pSeg = &pIter->aSeg[ pIter->aFirst[1].iFirst ];
247664 pIter->base.bEof = 1;
247668 return fts5IndexReturn(pIter->pIndex);
247677 Fts5Iter *pIter = (Fts5Iter*)pIndexIter;
247678 if( pIter->pTokenDataIter ){
247679 fts5TokendataIterNext(pIter, 1, iMatch);
247681 fts5MultiIterNextFrom(pIter->pIndex, pIter, iMatch);
247683 return fts5IndexReturn(pIter->pIndex);
247710 Fts5Iter *pIter = (Fts5Iter*)pIndexIter;
247711 Fts5TokenDataIter *pT = pIter->pTokenDataIter;
247754 Fts5Iter *pIter = (Fts5Iter*)pIndexIter;
247755 if( pIter && pIter->pTokenDataIter ){
247756 pIter->pTokenDataIter->nMap = 0;
247772 Fts5Iter *pIter = (Fts5Iter*)pIndexIter;
247773 Fts5TokenDataIter *pT = pIter->pTokenDataIter;
247774 Fts5Index *p = pIter->pIndex;
247778 assert( pIter->pTokenDataIter );
247795 Fts5Iter *pIter = (Fts5Iter*)pIndexIter;
247796 Fts5Index *pIndex = pIter->pIndex;
247797 fts5TokendataIterDelete(pIter->pTokenDataIter);
247798 fts5MultiIterFree(pIter);
248304 Fts5IndexIter *pIter = 0;
248306 p, z, n, (flags | FTS5INDEX_QUERY_NOTOKENDATA), 0, &pIter
248309 while( rc==SQLITE_OK && ALWAYS(pIter!=0) && 0==sqlite3Fts5IterEof(pIter) ){
248310 i64 rowid = pIter->iRowid;
248316 for(sqlite3Fts5PoslistReaderInit(pIter->pData, pIter->nData, &sReader);
248326 rc = sqlite3Fts5IterNext(pIter);
248329 sqlite3Fts5IterClose(pIter);
248688 Fts5Iter *pIter; /* Used to iterate through entire index */
248727 for(fts5MultiIterNew(p, pStruct, flags, 0, 0, 0, -1, 0, &pIter);
248728 fts5MultiIterEof(p, pIter)==0;
248729 fts5MultiIterNext(p, pIter, 0, 0)
248734 i64 iRowid = fts5MultiIterRowid(pIter);
248735 char *z = (char*)fts5MultiIterTerm(pIter, &n);
248742 if( 0==fts5MultiIterIsEmpty(p, pIter) ){
248747 fts5SegiterPoslist(p, &pIter->aSeg[pIter->aFirst[1].iFirst], 0, &poslist);
248758 fts5MultiIterFree(pIter);
251827 Fts5PhraseIter *pIter,
251831 if( pIter->a>=pIter->b ){
251836 pIter->a += fts5GetVarint32(pIter->a, iVal);
251838 pIter->a += fts5GetVarint32(pIter->a, iVal);
251841 pIter->a += fts5GetVarint32(pIter->a, iVal);
251850 Fts5PhraseIter *pIter,
251855 int rc = fts5CsrPoslist(pCsr, iPhrase, &pIter->a, &n);
251857 assert( pIter->a || n==0 );
251858 pIter->b = (pIter->a ? &pIter->a[n] : 0);
251861 fts5ApiPhraseNext(pCtx, pIter, piCol, piOff);
251868 Fts5PhraseIter *pIter,
251875 if( pIter->a>=pIter->b ){
251879 pIter->a += fts5GetVarint32(&pIter->a[0], iIncr);
251885 if( pIter->a>=pIter->b ){
251889 if( pIter->a[0]==0x01 ) break;
251890 pIter->a += fts5GetVarint32(pIter->a, dummy);
251892 pIter->a += 1 + fts5GetVarint32(&pIter->a[1], *piCol);
251899 Fts5PhraseIter *pIter,
251912 pIter->a = &pSorter->aPoslist[i1];
251914 rc = sqlite3Fts5ExprPhraseCollist(pCsr->pExpr, iPhrase, &pIter->a, &n);
251917 assert( pIter->a || n==0 );
251918 pIter->b = (pIter->a ? &pIter->a[n] : 0);
251920 fts5ApiPhraseNextColumn(pCtx, pIter, piCol);
251924 rc = fts5CsrPoslist(pCsr, iPhrase, &pIter->a, &n);
251926 assert( pIter->a || n==0 );
251927 pIter->b = (pIter->a ? &pIter->a[n] : 0);
251930 }else if( pIter->a[0]==0x01 ){
251931 pIter->a += 1 + fts5GetVarint32(&pIter->a[1], *piCol);
256590 Fts5IndexIter *pIter; /* Term/rowid iterator object */
256924 sqlite3Fts5IterClose(pCsr->pIter);
256927 pCsr->pIter = 0;
256950 if( sqlite3Fts5IterEof(pCsr->pIter) ){
256955 zTerm = sqlite3Fts5IterTerm(pCsr->pIter, &nTerm);
256972 Fts5IndexIter *pIter = pCsr->pIter;
256976 assert( sqlite3Fts5IterEof(pIter)==0 );
256979 || sqlite3Fts5PoslistNext64(pIter->pData, pIter->nData, po, pp)
256984 rc = sqlite3Fts5IterNextScan(pCsr->pIter);
257022 if( sqlite3Fts5IterEof(pCsr->pIter) ){
257028 zTerm = sqlite3Fts5IterTerm(pCsr->pIter, &nTerm);
257051 pPos = pCsr->pIter->pData;
257052 nPos = pCsr->pIter->nData;
257100 rc = sqlite3Fts5IterNextScan(pCsr->pIter);
257105 zTerm = sqlite3Fts5IterTerm(pCsr->pIter, &nTerm);
257111 if( sqlite3Fts5IterEof(pCsr->pIter) ) break;
257181 rc = sqlite3Fts5IndexQuery(pIndex, zTerm, nTerm, f, 0, &pCsr->pIter);
257245 sqlite3_result_int64(pCtx, pCsr->pIter->iRowid);