Lines Matching refs:pIter
11501 SQLITE_API int sqlite3changeset_next(sqlite3_changeset_iter *pIter);
11531 sqlite3_changeset_iter *pIter, /* Iterator object */
11565 sqlite3_changeset_iter *pIter, /* Iterator object */
11596 sqlite3_changeset_iter *pIter, /* Changeset iterator */
11630 sqlite3_changeset_iter *pIter, /* Changeset iterator */
11658 sqlite3_changeset_iter *pIter, /* Changeset iterator */
11675 sqlite3_changeset_iter *pIter, /* Changeset iterator */
11710 SQLITE_API int sqlite3changeset_finalize(sqlite3_changeset_iter *pIter);
61199 WalIterator *pIter = 0; /* Wal iterator context */
61244 rc = walIteratorInit(pWal, pInfo->nBackfill, &pIter);
61245 assert( rc==SQLITE_OK || pIter==0 );
61248 if( pIter
61273 while( rc==SQLITE_OK && 0==walIteratorNext(pIter, &iDbpage, &iFrame) ){
61358 walIteratorFree(pIter);
64603 BtLock *pIter;
64630 for(pIter=pBt->pLock; pIter; pIter=pIter->pNext){
64640 assert( pIter->eLock==READ_LOCK || pIter->eLock==WRITE_LOCK );
64641 assert( eLock==READ_LOCK || pIter->pBtree==p || pIter->eLock==READ_LOCK);
64642 if( pIter->pBtree!=p && pIter->iTable==iTab && pIter->eLock!=eLock ){
64643 sqlite3ConnectionBlocked(p->db, pIter->pBtree->db);
64676 BtLock *pIter;
64694 for(pIter=pBt->pLock; pIter; pIter=pIter->pNext){
64695 if( pIter->iTable==iTable && pIter->pBtree==p ){
64696 pLock = pIter;
65495 u8 *pIter; /* For scanning through pCell */
65503 pIter = pCell;
65511 nPayload = *pIter;
65513 u8 *pEnd = &pIter[8];
65516 nPayload = (nPayload<<7) | (*++pIter & 0x7f);
65517 }while( (*pIter)>=0x80 && pIter<pEnd );
65519 pIter++;
65527 iKey = *pIter;
65529 u8 *pEnd = &pIter[7];
65532 iKey = (iKey<<7) | (*++pIter & 0x7f);
65533 if( (*pIter)<0x80 ) break;
65534 if( pIter>=pEnd ){
65535 iKey = (iKey<<8) | *++pIter;
65540 pIter++;
65544 pInfo->pPayload = pIter;
65551 pInfo->nSize = nPayload + (u16)(pIter - pCell);
65563 u8 *pIter; /* For scanning through pCell */
65569 pIter = pCell + pPage->childPtrSize;
65570 nPayload = *pIter;
65572 u8 *pEnd = &pIter[8];
65575 nPayload = (nPayload<<7) | (*++pIter & 0x7f);
65576 }while( *(pIter)>=0x80 && pIter<pEnd );
65578 pIter++;
65581 pInfo->pPayload = pIter;
65588 pInfo->nSize = nPayload + (u16)(pIter - pCell);
65616 u8 *pIter = pCell + pPage->childPtrSize; /* For looping over bytes of pCell */
65629 nSize = *pIter;
65631 pEnd = &pIter[8];
65634 nSize = (nSize<<7) | (*++pIter & 0x7f);
65635 }while( *(pIter)>=0x80 && pIter<pEnd );
65637 pIter++;
65642 pEnd = &pIter[9];
65643 while( (*pIter++)&0x80 && pIter<pEnd );
65648 nSize += (u32)(pIter - pCell);
65658 nSize += 4 + (u16)(pIter - pCell);
65664 u8 *pIter = pCell + 4; /* For looping over bytes of pCell */
65679 pEnd = pIter + 9;
65680 while( (*pIter++)&0x80 && pIter<pEnd );
65681 assert( debuginfo.nSize==(u16)(pIter - pCell) || CORRUPT_DB );
65682 return (u16)(pIter - pCell);
67739 BtLock *pIter;
67740 for(pIter=pBt->pLock; pIter; pIter=pIter->pNext){
67741 if( pIter->pBtree!=p ){
67742 pBlock = pIter->pBtree->db;
96982 FileChunk *pIter;
96984 for(pIter=p->pFirst; pIter; pIter=pNext){
96985 pNext = pIter->pNext;
96986 sqlite3_free(pIter);
97004 FileChunk *pIter;
97005 for(pIter=copy.pFirst; pIter; pIter=pIter->pNext){
97009 rc = sqlite3OsWrite(pReal, (u8*)pIter->zChunk, nChunk, iOff);
170588 char *pIter; /* Used to iterate through aAll */
170592 pIter = pDL->pNextDocid;
170593 assert( pDL->aAll!=0 || pIter==0 );
170595 pIter = pDL->aAll;
170598 if( pIter==0 || pIter>=(pEnd = pDL->aAll + pDL->nAll) ){
170603 pIter += sqlite3Fts3GetVarint(pIter, &iDelta);
170609 pDL->pList = pIter;
170610 fts3PoslistCopy(0, &pIter);
170611 pDL->nList = (int)(pIter - pDL->pList);
170619 while( pIter<pEnd && *pIter==0 ) pIter++;
170621 pDL->pNextDocid = pIter;
170622 assert( pIter>=&pDL->aAll[pDL->nAll] || *pIter );
171954 char *pIter;
171967 pIter = pPhrase->doclist.pList;
172019 pIter = pPh->pOrPoslist;
172023 (pIter >= (pPh->doclist.aAll + pPh->doclist.nAll));
172024 while( (pIter==0 || DOCID_CMP(iDocid, pCsr->iPrevId)<0 ) && bEof==0 ){
172027 &pIter, &iDocid, &bEof
172031 bEof = !pPh->doclist.nAll || (pIter && pIter<=pPh->doclist.aAll);
172032 while( (pIter==0 || DOCID_CMP(iDocid, pCsr->iPrevId)>0 ) && bEof==0 ){
172036 &pIter, &iDocid, &dummy, &bEof
172040 pPh->pOrPoslist = pIter;
172046 pIter = pPhrase->pOrPoslist;
172048 pIter = 0;
172051 if( pIter==0 ) return SQLITE_OK;
172053 if( *pIter==0x01 ){
172054 pIter++;
172055 pIter += fts3GetVarint32(pIter, &iThis);
172060 fts3ColumnlistCopy(0, &pIter);
172061 if( *pIter==0x00 ) return SQLITE_OK;
172062 pIter++;
172063 pIter += fts3GetVarint32(pIter, &iThis);
172065 if( *pIter==0x00 ){
172066 pIter = 0;
172069 *ppOut = ((iCol==iThis)?pIter:0);
173407 Fts3Expr *pIter = pNotBranch;
173408 while( pIter->pLeft ){
173409 pIter = pIter->pLeft;
173411 pIter->pLeft = pRet;
173412 pRet->pParent = pIter;
178411 SegmentNode *pIter;
178414 for(pIter=pTree->pLeftmost; pIter && rc==SQLITE_OK; pIter=pIter->pRight){
178415 int nStart = fts3TreeFinishNode(pIter, iHeight, iNextLeaf);
178416 int nWrite = pIter->nData - nStart;
178418 rc = fts3WriteSegment(p, iNextFree, &pIter->aData[nStart], nWrite);
178420 iNextLeaf += (pIter->nEntry+1);
182369 char *pIter = *ppIter;
182370 if( pIter ){
182374 if( 0==(*pIter & 0xFE) ){
182376 pIter = 0;
182379 fts3GetDeltaPosition(&pIter, &iIter);
182383 *ppIter = pIter;
182390 static int fts3SnippetNextCandidate(SnippetIter *pIter){
182393 if( pIter->iCurrent<0 ){
182398 pIter->iCurrent = 0;
182403 for(i=0; i<pIter->nPhrase; i++){
182404 SnippetPhrase *pPhrase = &pIter->aPhrase[i];
182405 fts3SnippetAdvance(&pPhrase->pHead, &pPhrase->iHead, pIter->nSnippet);
182411 for(i=0; i<pIter->nPhrase; i++){
182412 SnippetPhrase *pPhrase = &pIter->aPhrase[i];
182421 pIter->iCurrent = iStart = iEnd - pIter->nSnippet + 1;
182422 for(i=0; i<pIter->nPhrase; i++){
182423 SnippetPhrase *pPhrase = &pIter->aPhrase[i];
182437 SnippetIter *pIter, /* Snippet iterator */
182444 int iStart = pIter->iCurrent; /* First token of snippet */
182450 for(i=0; i<pIter->nPhrase; i++){
182451 SnippetPhrase *pPhrase = &pIter->aPhrase[i];
182456 while( iCsr<(iStart+pIter->nSnippet) && iCsr>=iStart ){
182891 char *pIter = pPhrase->doclist.pList;
182901 if( pIter ) while( 1 ){
182902 int nHit = fts3ColumnlistCount(&pIter);
182910 assert( *pIter==0x00 || *pIter==0x01 );
182911 if( *pIter!=0x01 ) break;
182912 pIter++;
182913 pIter += fts3GetVarint32(pIter, &iCol);
183132 static int fts3LcsIteratorAdvance(LcsIterator *pIter){
183133 char *pRead = pIter->pRead;
183142 pIter->iPos += (int)(iRead-2);
183145 pIter->pRead = pRead;
183176 LcsIterator *pIter = &aIter[i];
183177 nToken -= pIter->pExpr->pPhrase->nToken;
183178 pIter->iPosOffset = nToken;
183205 LcsIterator *pIter = &aIter[i];
183206 if( pIter->pRead==0 ){
183210 if( pAdv==0 || pIter->iPos<pAdv->iPos ){
183211 pAdv = pIter;
183213 if( nThisLcs==0 || pIter->iPos==pIter[-1].iPos ){
194124 UBreakIterator *pIter; /* ICU break-iterator object */
194237 pCsr->pIter = ubrk_open(UBRK_WORD, p->zLocale, pCsr->aChar, iOut, &status);
194244 ubrk_first(pCsr->pIter);
194254 ubrk_close(pCsr->pIter);
194280 iStart = ubrk_current(pCsr->pIter);
194281 iEnd = ubrk_next(pCsr->pIter);
195747 static void rbuObjIterFreeCols(RbuObjIter *pIter){
195749 for(i=0; i<pIter->nTblCol; i++){
195750 sqlite3_free(pIter->azTblCol[i]);
195751 sqlite3_free(pIter->azTblType[i]);
195753 sqlite3_free(pIter->azTblCol);
195754 pIter->azTblCol = 0;
195755 pIter->azTblType = 0;
195756 pIter->aiSrcOrder = 0;
195757 pIter->abTblPk = 0;
195758 pIter->abNotNull = 0;
195759 pIter->nTblCol = 0;
195760 pIter->eType = 0; /* Invalid value */
195767 static void rbuObjIterClearStatements(RbuObjIter *pIter){
195770 sqlite3_finalize(pIter->pSelect);
195771 sqlite3_finalize(pIter->pInsert);
195772 sqlite3_finalize(pIter->pDelete);
195773 sqlite3_finalize(pIter->pTmpInsert);
195774 pUp = pIter->pRbuUpdate;
195781 sqlite3_free(pIter->aIdxCol);
195782 sqlite3_free(pIter->zIdxSql);
195784 pIter->pSelect = 0;
195785 pIter->pInsert = 0;
195786 pIter->pDelete = 0;
195787 pIter->pRbuUpdate = 0;
195788 pIter->pTmpInsert = 0;
195789 pIter->nCol = 0;
195790 pIter->nIdxCol = 0;
195791 pIter->aIdxCol = 0;
195792 pIter->zIdxSql = 0;
195799 static void rbuObjIterFinalize(RbuObjIter *pIter){
195800 rbuObjIterClearStatements(pIter);
195801 sqlite3_finalize(pIter->pTblIter);
195802 sqlite3_finalize(pIter->pIdxIter);
195803 rbuObjIterFreeCols(pIter);
195804 memset(pIter, 0, sizeof(RbuObjIter));
195815 static int rbuObjIterNext(sqlite3rbu *p, RbuObjIter *pIter){
195820 rbuObjIterClearStatements(pIter);
195821 if( pIter->zIdx==0 ){
195832 if( pIter->bCleanup ){
195833 rbuObjIterFreeCols(pIter);
195834 pIter->bCleanup = 0;
195835 rc = sqlite3_step(pIter->pTblIter);
195837 rc = resetAndCollectError(pIter->pTblIter, &p->zErrmsg);
195838 pIter->zTbl = 0;
195840 pIter->zTbl = (const char*)sqlite3_column_text(pIter->pTblIter, 0);
195841 pIter->zDataTbl = (const char*)sqlite3_column_text(pIter->pTblIter,1);
195842 rc = (pIter->zDataTbl && pIter->zTbl) ? SQLITE_OK : SQLITE_NOMEM;
195845 if( pIter->zIdx==0 ){
195846 sqlite3_stmt *pIdx = pIter->pIdxIter;
195847 rc = sqlite3_bind_text(pIdx, 1, pIter->zTbl, -1, SQLITE_STATIC);
195850 rc = sqlite3_step(pIter->pIdxIter);
195852 rc = resetAndCollectError(pIter->pIdxIter, &p->zErrmsg);
195853 pIter->bCleanup = 1;
195854 pIter->zIdx = 0;
195856 pIter->zIdx = (const char*)sqlite3_column_text(pIter->pIdxIter, 0);
195857 pIter->iTnum = sqlite3_column_int(pIter->pIdxIter, 1);
195858 pIter->bUnique = sqlite3_column_int(pIter->pIdxIter, 2);
195859 rc = pIter->zIdx ? SQLITE_OK : SQLITE_NOMEM;
195867 rbuObjIterFinalize(pIter);
195931 static int rbuObjIterFirst(sqlite3rbu *p, RbuObjIter *pIter){
195933 memset(pIter, 0, sizeof(RbuObjIter));
195935 rc = prepareFreeAndCollectError(p->dbRbu, &pIter->pTblIter, &p->zErrmsg,
195945 rc = prepareAndCollectError(p->dbMain, &pIter->pIdxIter, &p->zErrmsg,
195952 pIter->bCleanup = 1;
195954 return rbuObjIterNext(p, pIter);
196038 static void rbuAllocateIterArrays(sqlite3rbu *p, RbuObjIter *pIter, int nCol){
196044 pIter->azTblCol = azNew;
196045 pIter->azTblType = &azNew[nCol];
196046 pIter->aiSrcOrder = (int*)&pIter->azTblType[nCol];
196047 pIter->abTblPk = (u8*)&pIter->aiSrcOrder[nCol];
196048 pIter->abNotNull = (u8*)&pIter->abTblPk[nCol];
196049 pIter->abIndexed = (u8*)&pIter->abNotNull[nCol];
196220 static void rbuObjIterCacheIndexedCols(sqlite3rbu *p, RbuObjIter *pIter){
196225 memcpy(pIter->abIndexed, pIter->abTblPk, sizeof(u8)*pIter->nTblCol);
196227 sqlite3_mprintf("PRAGMA main.index_list = %Q", pIter->zTbl)
196231 pIter->nIndex = 0;
196238 memset(pIter->abIndexed, 0x01, sizeof(u8)*pIter->nTblCol);
196245 if( iCid>=0 ) pIter->abIndexed[iCid] = 1;
196247 memset(pIter->abIndexed, 0x01, sizeof(u8)*pIter->nTblCol);
196252 pIter->nIndex++;
196255 if( pIter->eType==RBU_PK_WITHOUT_ROWID ){
196257 pIter->nIndex--;
196261 if( bIndex==0 ) pIter->abIndexed = 0;
196274 static int rbuObjIterCacheTableInfo(sqlite3rbu *p, RbuObjIter *pIter){
196275 if( pIter->azTblCol==0 ){
196284 assert( pIter->eType==0 );
196285 rbuTableType(p, pIter->zTbl, &pIter->eType, &iTnum, &pIter->iPkTnum);
196286 if( p->rc==SQLITE_OK && pIter->eType==RBU_PK_NOTABLE ){
196288 p->zErrmsg = sqlite3_mprintf("no such table: %s", pIter->zTbl);
196291 if( pIter->zIdx==0 ) pIter->iTnum = iTnum;
196293 assert( pIter->eType==RBU_PK_NONE || pIter->eType==RBU_PK_IPK
196294 || pIter->eType==RBU_PK_EXTERNAL || pIter->eType==RBU_PK_WITHOUT_ROWID
196295 || pIter->eType==RBU_PK_VTAB
196302 sqlite3_mprintf("SELECT * FROM '%q'", pIter->zDataTbl)
196306 rbuAllocateIterArrays(p, pIter, nCol);
196312 pIter->aiSrcOrder[pIter->nTblCol] = pIter->nTblCol;
196313 pIter->azTblCol[pIter->nTblCol++] = zCopy;
196324 && bRbuRowid!=(pIter->eType==RBU_PK_VTAB || pIter->eType==RBU_PK_NONE)
196328 "table %q %s rbu_rowid column", pIter->zDataTbl,
196338 sqlite3_mprintf("PRAGMA table_info(%Q)", pIter->zTbl)
196344 for(i=iOrder; i<pIter->nTblCol; i++){
196345 if( 0==strcmp(zName, pIter->azTblCol[i]) ) break;
196347 if( i==pIter->nTblCol ){
196350 pIter->zDataTbl, zName
196358 SWAP(int, pIter->aiSrcOrder[i], pIter->aiSrcOrder[iOrder]);
196359 SWAP(char*, pIter->azTblCol[i], pIter->azTblCol[iOrder]);
196362 pIter->azTblType[iOrder] = rbuStrndup(zType, &p->rc);
196364 pIter->abTblPk[iOrder] = (u8)iPk;
196365 pIter->abNotNull[iOrder] = (u8)bNotNull || (iPk!=0);
196371 rbuObjIterCacheIndexedCols(p, pIter);
196372 assert( pIter->eType!=RBU_PK_VTAB || pIter->abIndexed==0 );
196373 assert( pIter->eType!=RBU_PK_VTAB || pIter->nIndex==0 );
196386 RbuObjIter *pIter /* Object iterator for column names */
196391 for(i=0; i<pIter->nTblCol; i++){
196392 const char *z = pIter->azTblCol[i];
196407 RbuObjIter *pIter, /* Object iterator for column names */
196417 for(i=0; i<pIter->nTblCol; i++){
196418 if( (int)pIter->abTblPk[i]==iPk ){
196419 const char *zCol = pIter->azTblCol[i];
196425 if( i==pIter->nTblCol ) break;
196452 RbuObjIter *pIter, /* RBU iterator object */
196461 "SELECT max(_rowid_) FROM \"%s%w\"", zWrite, pIter->zTbl
196470 char *zOrder = rbuObjIterGetPkList(p, pIter, "", ", ", " DESC");
196471 char *zSelect = rbuObjIterGetPkList(p, pIter, "quote(", "||','||", ")");
196472 char *zList = rbuObjIterGetPkList(p, pIter, "", ", ", "");
196478 zSelect, zWrite, pIter->zTbl, zOrder
196519 RbuObjIter *pIter /* RBU iterator object */
196532 sqlite3_mprintf("PRAGMA main.index_xinfo = %Q", pIter->zIdx)
196544 if( pIter->eType==RBU_PK_IPK ){
196546 for(i=0; pIter->abTblPk[i]==0; i++);
196547 assert( i<pIter->nTblCol );
196548 zCol = pIter->azTblCol[i];
196553 zCol = pIter->azTblCol[iCid];
196576 zSelect, pIter->zTbl, zOrder
196581 for(iCol=0; iCol<pIter->nCol; iCol++){
196632 RbuObjIter *pIter, /* Object iterator for column names */
196652 sqlite3_mprintf("PRAGMA main.index_xinfo = %Q", pIter->zIdx)
196666 pIter->aIdxCol[iSeq].nSpan, pIter->aIdxCol[iSeq].zSpan, zCollate
196673 if( pIter->eType==RBU_PK_IPK ){
196675 for(i=0; pIter->abTblPk[i]==0; i++);
196676 assert( i<pIter->nTblCol );
196677 zCol = pIter->azTblCol[i];
196685 zCol = pIter->azTblCol[iCid];
196686 zType = pIter->azTblType[iCid];
196691 if( pIter->bUnique==0 || sqlite3_column_int(pXInfo, 5) ){
196744 RbuObjIter *pIter,
196748 if( p->rc==SQLITE_OK && pIter->abIndexed ){
196751 for(i=0; i<pIter->nTblCol; i++){
196752 if( pIter->abIndexed[i] ){
196753 const char *zCol = pIter->azTblCol[i];
196766 if( pIter->eType==RBU_PK_EXTERNAL || pIter->eType==RBU_PK_NONE ){
196785 RbuObjIter *pIter
196788 if( pIter->eType==RBU_PK_VTAB || pIter->eType==RBU_PK_NONE ){
196789 zList = rbuMPrintf(p, "_rowid_ = ?%d", pIter->nTblCol+1);
196790 }else if( pIter->eType==RBU_PK_EXTERNAL ){
196793 for(i=0; i<pIter->nTblCol; i++){
196794 if( pIter->abTblPk[i] ){
196806 for(i=0; i<pIter->nTblCol; i++){
196807 if( pIter->abTblPk[i] ){
196808 const char *zCol = pIter->azTblCol[i];
196849 RbuObjIter *pIter,
196856 if( (int)strlen(zMask)!=pIter->nTblCol ){
196860 for(i=0; i<pIter->nTblCol; i++){
196861 char c = zMask[pIter->aiSrcOrder[i]];
196864 zList, zSep, pIter->azTblCol[i], i+1
196870 zList, zSep, pIter->azTblCol[i], pIter->azTblCol[i], i+1
196876 zList, zSep, pIter->azTblCol[i], pIter->azTblCol[i], i+1
196928 static char *rbuWithoutRowidPK(sqlite3rbu *p, RbuObjIter *pIter){
196930 assert( pIter->zIdx==0 );
196937 sqlite3_mprintf("PRAGMA main.index_list = %Q", pIter->zTbl)
196987 static void rbuCreateImposterTable2(sqlite3rbu *p, RbuObjIter *pIter){
196988 if( p->rc==SQLITE_OK && pIter->eType==RBU_PK_EXTERNAL ){
196989 int tnum = pIter->iPkTnum; /* Root page of PK index */
197023 iCid, pIter->azTblType[iCid], zCollate
197061 static void rbuCreateImposterTable(sqlite3rbu *p, RbuObjIter *pIter){
197062 if( p->rc==SQLITE_OK && pIter->eType!=RBU_PK_VTAB ){
197063 int tnum = pIter->iTnum;
197069 for(iCol=0; p->rc==SQLITE_OK && iCol<pIter->nTblCol; iCol++){
197071 const char *zCol = pIter->azTblCol[iCol];
197075 p->dbMain, "main", pIter->zTbl, zCol, 0, &zColl, 0, 0, 0
197078 if( pIter->eType==RBU_PK_IPK && pIter->abTblPk[iCol] ){
197084 zSql, zComma, zCol, pIter->azTblType[iCol], zPk, zColl,
197085 (pIter->abNotNull[iCol] ? " NOT NULL" : "")
197090 if( pIter->eType==RBU_PK_WITHOUT_ROWID ){
197091 char *zPk = rbuWithoutRowidPK(p, pIter);
197099 pIter->zTbl, zSql,
197100 (pIter->eType==RBU_PK_WITHOUT_ROWID ? " WITHOUT ROWID" : "")
197119 RbuObjIter *pIter,
197123 int bRbuRowid = (pIter->eType==RBU_PK_EXTERNAL || pIter->eType==RBU_PK_NONE);
197124 char *zBind = rbuObjIterGetBindlist(p, pIter->nTblCol + 1 + bRbuRowid);
197126 assert( pIter->pTmpInsert==0 );
197128 p->dbRbu, &pIter->pTmpInsert, &p->zErrmsg, sqlite3_mprintf(
197130 p->zStateDb, pIter->zDataTbl, zCollist, zRbuRowid, zBind
197165 static char *rbuObjIterGetIndexWhere(sqlite3rbu *p, RbuObjIter *pIter){
197170 assert( pIter->zIdxSql==0 && pIter->nIdxCol==0 && pIter->aIdxCol==0 );
197179 rc = sqlite3_bind_text(pStmt, 1, pIter->zIdx, -1, SQLITE_STATIC);
197183 pIter->zIdxSql = zSql = rbuStrndup(zSql, &rc);
197196 pIter->aIdxCol, (nIdxAlloc+16)*sizeof(RbuSpan)
197202 pIter->aIdxCol = aIdxCol;
197209 pIter->aIdxCol[0].zSpan = &zSql[i+1];
197216 int nSpan = &zSql[i] - pIter->aIdxCol[iIdxCol].zSpan;
197217 pIter->aIdxCol[iIdxCol++].nSpan = nSpan;
197222 int nSpan = &zSql[i] - pIter->aIdxCol[iIdxCol].zSpan;
197223 pIter->aIdxCol[iIdxCol++].nSpan = nSpan;
197224 pIter->aIdxCol[iIdxCol].zSpan = &zSql[i+1];
197248 pIter->nIdxCol = iIdxCol;
197267 RbuObjIter *pIter,
197270 assert( pIter->bCleanup==0 );
197271 if( pIter->pSelect==0 && rbuObjIterCacheTableInfo(p, pIter)==SQLITE_OK ){
197272 const int tnum = pIter->iTnum;
197275 const char *zIdx = pIter->zIdx;
197284 const char *zTbl = pIter->zTbl;
197292 assert( pIter->eType!=RBU_PK_VTAB );
197293 zPart = rbuObjIterGetIndexWhere(p, pIter);
197295 p, pIter, &zImposterCols, &zImposterPK, &zWhere, &nBind
197309 pIter->nCol = nBind;
197312 p->dbMain, &pIter->pInsert, &p->zErrmsg,
197320 p->dbMain, &pIter->pDelete, &p->zErrmsg,
197331 zStart = rbuVacuumIndexStart(p, pIter);
197341 pIter->zDataTbl,
197349 if( pIter->eType==RBU_PK_EXTERNAL || pIter->eType==RBU_PK_NONE ){
197352 zCollist, p->zStateDb, pIter->zDataTbl,
197362 zCollist, p->zStateDb, pIter->zDataTbl, zPart,
197363 zCollist, pIter->zDataTbl,
197370 p->rc = prepareFreeAndCollectError(p->dbRbu,&pIter->pSelect,pz,zSql);
197382 int bRbuRowid = (pIter->eType==RBU_PK_VTAB)
197383 ||(pIter->eType==RBU_PK_NONE)
197384 ||(pIter->eType==RBU_PK_EXTERNAL && rbuIsVacuum(p));
197385 const char *zTbl = pIter->zTbl; /* Table this step applies to */
197388 char *zBindings = rbuObjIterGetBindlist(p, pIter->nTblCol + bRbuRowid);
197389 char *zWhere = rbuObjIterGetWhere(p, pIter);
197390 char *zOldlist = rbuObjIterGetOldlist(p, pIter, "old");
197391 char *zNewlist = rbuObjIterGetOldlist(p, pIter, "new");
197393 zCollist = rbuObjIterGetCollist(p, pIter);
197394 pIter->nCol = pIter->nTblCol;
197397 rbuCreateImposterTable(p, pIter);
197398 rbuCreateImposterTable2(p, pIter);
197399 zWrite = (pIter->eType==RBU_PK_VTAB ? "" : "rbu_imp_");
197403 p->rc = prepareFreeAndCollectError(p->dbMain, &pIter->pInsert, pz,
197415 p->rc = prepareFreeAndCollectError(p->dbMain, &pIter->pDelete, pz,
197422 if( rbuIsVacuum(p)==0 && pIter->abIndexed ){
197424 if( pIter->eType==RBU_PK_EXTERNAL || pIter->eType==RBU_PK_NONE ){
197432 , p->zStateDb, pIter->zDataTbl
197433 , (pIter->eType==RBU_PK_EXTERNAL ? ", 0 AS rbu_rowid" : "")
197434 , pIter->zDataTbl
197457 if( pIter->eType==RBU_PK_EXTERNAL || pIter->eType==RBU_PK_NONE ){
197467 rbuObjIterPrepareTmpInsert(p, pIter, zCollist, zRbuRowid);
197481 zStart = rbuVacuumTableStart(p, pIter, bRbuRowid, zWrite);
197490 zOrder = rbuObjIterGetPkList(p, pIter, "", ", ", "");
197495 p->rc = prepareFreeAndCollectError(p->dbRbu, &pIter->pSelect, pz,
197501 pIter->zDataTbl, (zStart ? zStart : ""),
197534 RbuObjIter *pIter, /* Object iterator */
197549 for(pp=&pIter->pRbuUpdate; *pp; pp=&((*pp)->pNext)){
197553 pUp->pNext = pIter->pRbuUpdate;
197554 pIter->pRbuUpdate = pUp;
197563 for(pp=&pIter->pRbuUpdate; *pp!=pUp; pp=&((*pp)->pNext));
197568 pUp = (RbuUpdateStmt*)rbuMalloc(p, sizeof(RbuUpdateStmt)+pIter->nTblCol+1);
197572 char *zWhere = rbuObjIterGetWhere(p, pIter);
197573 char *zSet = rbuObjIterGetSetlist(p, pIter, zMask);
197577 memcpy(pUp->zMask, zMask, pIter->nTblCol);
197578 pUp->pNext = pIter->pRbuUpdate;
197579 pIter->pRbuUpdate = pUp;
197584 if( pIter->eType!=RBU_PK_VTAB ) zPrefix = "rbu_imp_";
197586 zPrefix, pIter->zTbl, zSet, zWhere
198277 RbuObjIter *pIter = &p->objiter;
198283 assert( eType!=RBU_DELETE || pIter->zIdx==0 );
198297 pWriter = pIter->pDelete;
198299 pWriter = pIter->pInsert;
198302 for(i=0; i<pIter->nCol; i++){
198307 && pIter->zIdx==0 && pIter->eType==RBU_PK_IPK && pIter->abTblPk[i]
198308 && sqlite3_column_type(pIter->pSelect, i)==SQLITE_NULL
198315 if( eType==RBU_DELETE && pIter->abTblPk[i]==0 ){
198319 pVal = sqlite3_column_value(pIter->pSelect, i);
198323 if( pIter->zIdx==0 ){
198324 if( pIter->eType==RBU_PK_VTAB
198325 || pIter->eType==RBU_PK_NONE
198326 || (pIter->eType==RBU_PK_EXTERNAL && rbuIsVacuum(p))
198335 assertColumnName(pIter->pSelect, pIter->nCol+1,
198338 pVal = sqlite3_column_value(pIter->pSelect, pIter->nCol+1);
198339 p->rc = sqlite3_bind_value(pWriter, pIter->nCol+1, pVal);
198360 RbuObjIter *pIter = &p->objiter;
198369 assert( eType!=RBU_UPDATE || pIter->zIdx==0 );
198371 if( pIter->zIdx==0 && (eType==RBU_IDX_DELETE || eType==RBU_IDX_INSERT) ){
198375 if( pIter->zIdx==0 ){
198389 rbuGetUpdateStmt(p, pIter, zMask, &pUpdate);
198392 for(i=0; p->rc==SQLITE_OK && i<pIter->nCol; i++){
198393 char c = zMask[pIter->aiSrcOrder[i]];
198394 pVal = sqlite3_column_value(pIter->pSelect, i);
198395 if( pIter->abTblPk[i] || c!='.' ){
198400 && (pIter->eType==RBU_PK_VTAB || pIter->eType==RBU_PK_NONE)
198403 assertColumnName(pIter->pSelect, pIter->nCol+1, "rbu_rowid");
198404 pVal = sqlite3_column_value(pIter->pSelect, pIter->nCol+1);
198405 p->rc = sqlite3_bind_value(pUpdate, pIter->nCol+1, pVal);
198592 RbuObjIter *pIter = &p->objiter;
198602 while( p->rc==SQLITE_OK && pIter->zTbl ){
198604 if( pIter->bCleanup ){
198608 if( rbuIsVacuum(p)==0 && pIter->abIndexed ){
198610 "DELETE FROM %s.'rbu_tmp_%q'", p->zStateDb, pIter->zDataTbl
198614 rbuObjIterPrepareAll(p, pIter, 0);
198618 int rc = sqlite3_step(pIter->pSelect);
198624 p->rc = sqlite3_reset(pIter->pSelect);
198629 rbuObjIterNext(p, pIter);
198633 assert( pIter->zTbl==0 );
198736 RbuObjIter *pIter = &p->objiter;
198739 while( rc==SQLITE_OK && pIter->zTbl && (pIter->bCleanup
198740 || rbuStrCompare(pIter->zIdx, pState->zIdx)
198741 || (pState->zDataTbl==0 && rbuStrCompare(pIter->zTbl, pState->zTbl))
198742 || (pState->zDataTbl && rbuStrCompare(pIter->zDataTbl, pState->zDataTbl))
198744 rc = rbuObjIterNext(p, pIter);
198747 if( rc==SQLITE_OK && !pIter->zTbl ){
199400 rbu_file *pIter;
199404 for(pIter=pRbuVfs->pMain; pIter; pIter=pIter->pMainNext);
199408 for(pIter=pRbuVfs->pMainRbu; pIter && pIter!=p; pIter=pIter->pMainRbuNext){}
199409 if( pIter==0 ){
204655 sqlite3_changeset_iter *pIter, /* Iterator handle */
204661 *pOp = pIter->op;
204662 *pnCol = pIter->nCol;
204663 *pzTab = pIter->zTab;
204664 if( pbIndirect ) *pbIndirect = pIter->bIndirect;
204675 sqlite3_changeset_iter *pIter, /* Iterator object */
204679 *pabPK = pIter->abPK;
204680 if( pnCol ) *pnCol = pIter->nCol;
204698 sqlite3_changeset_iter *pIter, /* Changeset iterator */
204702 if( pIter->op!=SQLITE_UPDATE && pIter->op!=SQLITE_DELETE ){
204705 if( iVal<0 || iVal>=pIter->nCol ){
204708 *ppValue = pIter->apValue[iVal];
204726 sqlite3_changeset_iter *pIter, /* Changeset iterator */
204730 if( pIter->op!=SQLITE_UPDATE && pIter->op!=SQLITE_INSERT ){
204733 if( iVal<0 || iVal>=pIter->nCol ){
204736 *ppValue = pIter->apValue[pIter->nCol+iVal];
204745 #define sessionChangesetNew(pIter, iVal) (pIter)->apValue[(pIter)->nCol+(iVal)]
204746 #define sessionChangesetOld(pIter, iVal) (pIter)->apValue[(iVal)]
204760 sqlite3_changeset_iter *pIter, /* Changeset iterator */
204764 if( !pIter->pConflict ){
204767 if( iVal<0 || iVal>=pIter->nCol ){
204770 *ppValue = sqlite3_column_value(pIter->pConflict, iVal);
204783 sqlite3_changeset_iter *pIter, /* Changeset iterator */
204786 if( pIter->pConflict || pIter->apValue ){
204789 *pnOut = pIter->nCol;
205335 sqlite3_changeset_iter *pIter, /* Iterator to read values from */
205353 (void)xValue(pIter, i, &pVal);
205385 sqlite3_changeset_iter *pIter, /* Changeset iterator */
205394 sqlite3changeset_op(pIter, &zDummy, &nCol, &op, 0);
205395 rc = sessionBindRow(pIter,
205421 sqlite3_changeset_iter *pIter /* Iterator pointing at current change */
205426 int eOp = pIter->op;
205429 const char *zTab = pIter->zTab;
205447 sqlite3changeset_old(pIter, i, &pVal);
205449 sqlite3changeset_new(pIter, i, &pVal);
205495 sqlite3_changeset_iter *pIter, /* Changeset iterator */
205506 sqlite3changeset_op(pIter, &zDummy, &nCol, &op, 0);
205514 rc = sessionSeekToRow(p->db, pIter, p->abPK, p->pSelect);
205521 pIter->pConflict = p->pSelect;
205522 res = xConflict(pCtx, eType, pIter);
205523 pIter->pConflict = 0;
205529 u8 *aBlob = &pIter->in.aData[pIter->in.iCurrent];
205530 int nBlob = pIter->in.iNext - pIter->in.iCurrent;
205535 res = xConflict(pCtx, eType+1, pIter);
205559 rc = sessionRebaseAdd(p, res, pIter);
205591 sqlite3_changeset_iter *pIter, /* Changeset iterator */
205607 sqlite3changeset_op(pIter, &zDummy, &nCol, &op, 0);
205622 u8 *abPK = (pIter->bPatchset ? p->abPK : 0);
205623 rc = sessionBindRow(pIter, sqlite3changeset_old, nCol, abPK, p->pDelete);
205633 SQLITE_CHANGESET_DATA, p, pIter, xConflict, pCtx, pbRetry
205637 SQLITE_CHANGESET_CONFLICT, p, pIter, xConflict, pCtx, 0
205646 sqlite3_value *pOld = sessionChangesetOld(pIter, i);
205647 sqlite3_value *pNew = sessionChangesetNew(pIter, i);
205658 sqlite3_bind_int(p->pUpdate, nCol*3+1, pbRetry==0 || pIter->bPatchset);
205673 SQLITE_CHANGESET_DATA, p, pIter, xConflict, pCtx, pbRetry
205679 SQLITE_CHANGESET_CONFLICT, p, pIter, xConflict, pCtx, 0
205689 rc = sessionSeekToRow(p->db, pIter, p->abPK, p->pSelect);
205697 rc = sessionBindRow(pIter, sqlite3changeset_new, nCol, 0, p->pInsert);
205706 SQLITE_CHANGESET_CONFLICT, p, pIter, xConflict, pCtx, pbReplace
205726 sqlite3_changeset_iter *pIter, /* Changeset iterator to read change from */
205735 rc = sessionApplyOneOp(pIter, pApply, xConflict, pCtx, &bReplace, &bRetry);
205745 assert( pIter->op==SQLITE_UPDATE || pIter->op==SQLITE_DELETE );
205746 rc = sessionApplyOneOp(pIter, pApply, xConflict, pCtx, 0, 0);
205755 assert( pIter->op==SQLITE_INSERT );
205758 rc = sessionBindRow(pIter,
205767 rc = sessionApplyOneOp(pIter, pApply, xConflict, pCtx, 0, 0);
205837 sqlite3_changeset_iter *pIter, /* Changeset to apply */
205860 pIter->in.bNoDiscard = 1;
205870 while( rc==SQLITE_OK && SQLITE_ROW==sqlite3changeset_next(pIter) ){
205875 sqlite3changeset_op(pIter, &zNew, &nCol, &op, 0);
205881 db, pIter->bPatchset, zTab, &sApply, xConflict, pCtx
205919 sqlite3changeset_pk(pIter, &abPK, 0);
205974 rc = sessionApplyOneWithRetry(db, pIter, &sApply, xConflict, pCtx);
205977 bPatchset = pIter->bPatchset;
205979 rc = sqlite3changeset_finalize(pIter);
205981 sqlite3changeset_finalize(pIter);
206051 sqlite3_changeset_iter *pIter; /* Iterator to skip through changeset */
206053 int rc = sessionChangesetStart(&pIter, 0, 0, nChangeset, pChangeset,bInverse);
206056 db, pIter, xFilter, xConflict, pCtx, ppRebase, pnRebase, flags
206109 sqlite3_changeset_iter *pIter; /* Iterator to skip through changeset */
206111 int rc = sessionChangesetStart(&pIter, xInput, pIn, 0, 0, bInverse);
206114 db, pIter, xFilter, xConflict, pCtx, ppRebase, pnRebase, flags
206336 sqlite3_changeset_iter *pIter, /* Iterator to read from */
206345 while( SQLITE_ROW==sessionChangesetNext(pIter, &aRec, &nRec, 0) ){
206356 pGrp->bPatch = pIter->bPatchset;
206357 }else if( pIter->bPatchset!=pGrp->bPatch ){
206362 sqlite3changeset_op(pIter, &zNew, &nCol, &op, &bIndirect);
206368 sqlite3changeset_pk(pIter, &abPK, 0);
206399 if( sessionGrowHash(pIter->bPatchset, pTab) ){
206404 pTab, (pIter->bPatchset && op==SQLITE_DELETE), aRec, pTab->nChange
206413 if( pIter->bPatchset ){
206426 pIter->bPatchset, pExist, op, bIndirect, aRec, nRec, &pChange
206436 if( rc==SQLITE_OK ) rc = pIter->rc;
206527 sqlite3_changeset_iter *pIter; /* Iterator opened on pData/nData */
206530 rc = sqlite3changeset_start(&pIter, nData, pData);
206532 rc = sessionChangesetToHash(pIter, pGrp, 0);
206534 sqlite3changeset_finalize(pIter);
206558 sqlite3_changeset_iter *pIter; /* Iterator opened on pData/nData */
206561 rc = sqlite3changeset_start_strm(&pIter, xInput, pIn);
206563 rc = sessionChangesetToHash(pIter, pGrp, 0);
206565 sqlite3changeset_finalize(pIter);
206712 sqlite3_changeset_iter *pIter, /* Iterator pointed at local change */
206726 *pOut++ = pIter->bIndirect;
206727 for(i=0; i<pIter->nCol; i++){
206730 if( pIter->abPK[i] || a2[0]==0 ){
206731 if( !pIter->abPK[i] ) bData = 1;
206746 for(i=0; i<pIter->nCol; i++){
206749 if( pIter->abPK[i] || a2[0]!=0xFF ){
206780 sqlite3_changeset_iter *pIter, /* Input data */
206793 while( SQLITE_ROW==sessionChangesetNext(pIter, &aRec, &nRec, &bNew) ){
206798 const char *zTab = pIter->zTab;
206805 if( pIter->bPatchset ){
206810 sessionAppendByte(&sOut, pIter->bPatchset ? 'P' : 'T', &rc);
206811 sessionAppendVarint(&sOut, pIter->nCol, &rc);
206812 sessionAppendBlob(&sOut, pIter->abPK, pIter->nCol, &rc);
206813 sessionAppendBlob(&sOut,(u8*)pIter->zTab,(int)strlen(pIter->zTab)+1,&rc);
206828 switch( pIter->op ){
206834 sessionAppendByte(&sOut, pIter->bIndirect, &rc);
206846 sessionSkipRecord(&pCsr, pIter->nCol);
206848 sessionAppendByte(&sOut, pIter->bIndirect, &rc);
206849 sessionAppendRecordMerge(&sOut, pIter->nCol,
206855 sessionAppendPartialUpdate(&sOut, pIter,
206862 assert( pIter->op==SQLITE_DELETE );
206866 sessionAppendByte(&sOut, pIter->bIndirect, &rc);
206867 sessionAppendRecordMerge(&sOut, pIter->nCol,
206876 sessionAppendByte(&sOut, pIter->op, &rc);
206877 sessionAppendByte(&sOut, pIter->bIndirect, &rc);
206931 sqlite3_changeset_iter *pIter = 0; /* Iterator opened on pData/nData */
206933 rc = sqlite3changeset_start(&pIter, nRebase, (void*)pRebase);
206935 rc = sessionChangesetToHash(pIter, &p->grp, 1);
206937 sqlite3changeset_finalize(pIter);
206949 sqlite3_changeset_iter *pIter = 0; /* Iterator to skip through input */
206950 int rc = sqlite3changeset_start(&pIter, nIn, (void*)pIn);
206953 rc = sessionRebase(p, pIter, 0, 0, pnOut, ppOut);
206954 sqlite3changeset_finalize(pIter);
206970 sqlite3_changeset_iter *pIter = 0; /* Iterator to skip through input */
206971 int rc = sqlite3changeset_start_strm(&pIter, xInput, pIn);
206974 rc = sessionRebase(p, pIter, xOutput, pOut, 0, 0);
206975 sqlite3changeset_finalize(pIter);
207908 Fts5PoslistReader *pIter /* Iterator object to initialize */
209969 static int fts5CInstIterNext(CInstIter *pIter){
209971 pIter->iStart = -1;
209972 pIter->iEnd = -1;
209974 while( rc==SQLITE_OK && pIter->iInst<pIter->nInst ){
209976 rc = pIter->pApi->xInst(pIter->pFts, pIter->iInst, &ip, &ic, &io);
209978 if( ic==pIter->iCol ){
209979 int iEnd = io - 1 + pIter->pApi->xPhraseSize(pIter->pFts, ip);
209980 if( pIter->iStart<0 ){
209981 pIter->iStart = io;
209982 pIter->iEnd = iEnd;
209983 }else if( io<=pIter->iEnd ){
209984 if( iEnd>pIter->iEnd ) pIter->iEnd = iEnd;
209989 pIter->iInst++;
210004 CInstIter *pIter
210008 memset(pIter, 0, sizeof(CInstIter));
210009 pIter->pApi = pApi;
210010 pIter->pFts = pFts;
210011 pIter->iCol = iCol;
210012 rc = pApi->xInstCount(pFts, &pIter->nInst);
210015 rc = fts5CInstIterNext(pIter);
210838 static int sqlite3Fts5PoslistReaderNext(Fts5PoslistReader *pIter){
210839 if( sqlite3Fts5PoslistNext64(pIter->a, pIter->n, &pIter->i, &pIter->iPos) ){
210840 pIter->bEof = 1;
210842 return pIter->bEof;
210847 Fts5PoslistReader *pIter /* Iterator object to initialize */
210849 memset(pIter, 0, sizeof(*pIter));
210850 pIter->a = a;
210851 pIter->n = n;
210852 sqlite3Fts5PoslistReaderNext(pIter);
210853 return pIter->bEof;
212093 Fts5IndexIter *pIter; /* Iterator for this term */
212359 if( 0==sqlite3Fts5IterEof(p->pIter) ){
212360 i64 iRowid = p->pIter->iRowid;
212390 Fts5IndexIter *pIter = p->pIter;
212391 if( sqlite3Fts5IterEof(pIter)==0 && pIter->iRowid==iRowid ){
212392 if( pIter->nData==0 ) continue;
212405 sqlite3Fts5PoslistReaderInit(pIter->pData, pIter->nData, &aIter[nIter]);
212496 a = (u8*)pTerm->pIter->pData;
212497 n = pTerm->pIter->nData;
212696 Fts5IndexIter *pIter, /* Iterator to advance */
212705 iRowid = pIter->iRowid;
212707 int rc = sqlite3Fts5IterNextFrom(pIter, iLast);
212708 if( rc || sqlite3Fts5IterEof(pIter) ){
212713 iRowid = pIter->iRowid;
212733 if( sqlite3Fts5IterEof(p->pIter)==0 ){
212734 i64 iRowid = p->pIter->iRowid;
212736 rc = sqlite3Fts5IterNextFrom(p->pIter, iLast);
212764 Fts5IndexIter *pIter = pTerm->pIter;
212765 if( sqlite3Fts5IterEof(pIter)==0 ){
212766 if( pIter->iRowid==pNode->iRowid && pIter->nData>0 ){
212787 Fts5IndexIter *pIter = pPhrase->aTerm[0].pIter;
212788 fts5BufferSet(&rc, &pPhrase->poslist, pIter->nData, pIter->pData);
212832 if( p->pIter ){
212833 sqlite3Fts5IterClose(p->pIter);
212834 p->pIter = 0;
212841 &p->pIter
212843 assert( (rc==SQLITE_OK)==(p->pIter!=0) );
212845 if( 0==sqlite3Fts5IterEof(p->pIter) ){
212973 iLast = pLeft->aTerm[0].pIter->iRowid;
212992 Fts5IndexIter *pIter = pPhrase->aTerm[j].pIter;
212993 if( pIter->iRowid==iLast || pIter->bEof ) continue;
212995 if( fts5ExprAdvanceto(pIter, bDesc, &iLast, &rc, &pNode->bEof) ){
213037 if( sqlite3Fts5IterEof(p->pIter)==0 ){
213038 i64 ii = p->pIter->iRowid;
213043 rc = sqlite3Fts5IterNextFrom(p->pIter, iFrom);
213045 rc = sqlite3Fts5IterNext(p->pIter);
213048 if( sqlite3Fts5IterEof(p->pIter)==0 ){
213061 Fts5IndexIter *pIter = pTerm->pIter;
213065 rc = sqlite3Fts5IterNextFrom(pIter, iFrom);
213067 rc = sqlite3Fts5IterNext(pIter);
213070 pNode->bEof = (rc || sqlite3Fts5IterEof(pIter));
213092 Fts5IndexIter *pIter = pPhrase->aTerm[0].pIter;
213098 pPhrase->poslist.n = pIter->nData;
213100 pPhrase->poslist.p = (u8*)pIter->pData;
213102 pNode->iRowid = pIter->iRowid;
213117 Fts5IndexIter *pIter = pNode->pNear->apPhrase[0]->aTerm[0].pIter;
213121 rc = sqlite3Fts5IterNextFrom(pIter, iFrom);
213123 rc = sqlite3Fts5IterNext(pIter);
213125 if( rc==SQLITE_OK && sqlite3Fts5IterEof(pIter)==0 ){
213475 sqlite3Fts5IterClose(pTerm->pIter);
213478 sqlite3Fts5IterClose(pSyn->pIter);
214881 *ppCollist = pPhrase->aTerm[0].pIter->pData;
214882 *pnCollist = pPhrase->aTerm[0].pIter->nData;
215348 Fts5HashEntry *pIter;
215349 for(pIter=pHash->aSlot[iSlot]; pIter; pIter=pIter->pHashNext){
215351 || (pIter->nKey+1>=nTerm && 0==memcmp(fts5EntryKey(pIter), pTerm, nTerm))
215353 Fts5HashEntry *pEntry = pIter;
216759 static int fts5DlidxIterNextR(Fts5Index *p, Fts5DlidxIter *pIter, int iLvl){
216760 Fts5DlidxLvl *pLvl = &pIter->aLvl[iLvl];
216762 assert( iLvl<pIter->nLvl );
216764 if( (iLvl+1) < pIter->nLvl ){
216765 fts5DlidxIterNextR(p, pIter, iLvl+1);
216770 FTS5_DLIDX_ROWID(pIter->iSegid, iLvl, pLvl[1].iLeafPgno)
216777 return pIter->aLvl[0].bEof;
216779 static int fts5DlidxIterNext(Fts5Index *p, Fts5DlidxIter *pIter){
216780 return fts5DlidxIterNextR(p, pIter, 0);
216794 static int fts5DlidxIterFirst(Fts5DlidxIter *pIter){
216796 for(i=0; i<pIter->nLvl; i++){
216797 fts5DlidxLvlNext(&pIter->aLvl[i]);
216799 return pIter->aLvl[0].bEof;
216803 static int fts5DlidxIterEof(Fts5Index *p, Fts5DlidxIter *pIter){
216804 return p->rc!=SQLITE_OK || pIter->aLvl[0].bEof;
216807 static void fts5DlidxIterLast(Fts5Index *p, Fts5DlidxIter *pIter){
216811 for(i=pIter->nLvl-1; p->rc==SQLITE_OK && i>=0; i--){
216812 Fts5DlidxLvl *pLvl = &pIter->aLvl[i];
216821 FTS5_DLIDX_ROWID(pIter->iSegid, i-1, pLvl->iLeafPgno)
216879 static int fts5DlidxIterPrevR(Fts5Index *p, Fts5DlidxIter *pIter, int iLvl){
216880 Fts5DlidxLvl *pLvl = &pIter->aLvl[iLvl];
216882 assert( iLvl<pIter->nLvl );
216884 if( (iLvl+1) < pIter->nLvl ){
216885 fts5DlidxIterPrevR(p, pIter, iLvl+1);
216890 FTS5_DLIDX_ROWID(pIter->iSegid, iLvl, pLvl[1].iLeafPgno)
216900 return pIter->aLvl[0].bEof;
216902 static int fts5DlidxIterPrev(Fts5Index *p, Fts5DlidxIter *pIter){
216903 return fts5DlidxIterPrevR(p, pIter, 0);
216909 static void fts5DlidxIterFree(Fts5DlidxIter *pIter){
216910 if( pIter ){
216912 for(i=0; i<pIter->nLvl; i++){
216913 fts5DataRelease(pIter->aLvl[i].pData);
216915 sqlite3_free(pIter);
216925 Fts5DlidxIter *pIter = 0;
216933 pNew = (Fts5DlidxIter*)sqlite3_realloc64(pIter, nByte);
216939 pIter = pNew;
216945 pIter->nLvl = i+1;
216950 pIter->iSegid = iSegid;
216952 fts5DlidxIterFirst(pIter);
216954 fts5DlidxIterLast(p, pIter);
216959 fts5DlidxIterFree(pIter);
216960 pIter = 0;
216963 return pIter;
216966 static i64 fts5DlidxIterRowid(Fts5DlidxIter *pIter){
216967 return pIter->aLvl[0].iRowid;
216969 static int fts5DlidxIterPgno(Fts5DlidxIter *pIter){
216970 return pIter->aLvl[0].iLeafPgno;
216978 Fts5SegIter *pIter /* Iterator to advance to next page */
216981 Fts5StructureSegment *pSeg = pIter->pSeg;
216982 fts5DataRelease(pIter->pLeaf);
216983 pIter->iLeafPgno++;
216984 if( pIter->pNextLeaf ){
216985 pIter->pLeaf = pIter->pNextLeaf;
216986 pIter->pNextLeaf = 0;
216987 }else if( pIter->iLeafPgno<=pSeg->pgnoLast ){
216988 pIter->pLeaf = fts5LeafRead(p,
216989 FTS5_SEGMENT_ROWID(pSeg->iSegid, pIter->iLeafPgno)
216992 pIter->pLeaf = 0;
216994 pLeaf = pIter->pLeaf;
216997 pIter->iPgidxOff = pLeaf->szLeaf;
216999 pIter->iEndofDoclist = pLeaf->nn+1;
217001 pIter->iPgidxOff += fts5GetVarint32(&pLeaf->p[pIter->iPgidxOff],
217002 pIter->iEndofDoclist
217035 static void fts5SegIterLoadNPos(Fts5Index *p, Fts5SegIter *pIter){
217037 int iOff = pIter->iLeafOffset; /* Offset to read at */
217038 ASSERT_SZLEAF_OK(pIter->pLeaf);
217040 int iEod = MIN(pIter->iEndofDoclist, pIter->pLeaf->szLeaf);
217041 pIter->bDel = 0;
217042 pIter->nPos = 1;
217043 if( iOff<iEod && pIter->pLeaf->p[iOff]==0 ){
217044 pIter->bDel = 1;
217046 if( iOff<iEod && pIter->pLeaf->p[iOff]==0 ){
217047 pIter->nPos = 1;
217050 pIter->nPos = 0;
217055 fts5FastGetVarint32(pIter->pLeaf->p, iOff, nSz);
217056 pIter->bDel = (nSz & 0x0001);
217057 pIter->nPos = nSz>>1;
217058 assert_nc( pIter->nPos>=0 );
217060 pIter->iLeafOffset = iOff;
217064 static void fts5SegIterLoadRowid(Fts5Index *p, Fts5SegIter *pIter){
217065 u8 *a = pIter->pLeaf->p; /* Buffer to read data from */
217066 int iOff = pIter->iLeafOffset;
217068 ASSERT_SZLEAF_OK(pIter->pLeaf);
217069 if( iOff>=pIter->pLeaf->szLeaf ){
217070 fts5SegIterNextPage(p, pIter);
217071 if( pIter->pLeaf==0 ){
217076 a = pIter->pLeaf->p;
217078 iOff += sqlite3Fts5GetVarint(&a[iOff], (u64*)&pIter->iRowid);
217079 pIter->iLeafOffset = iOff;
217097 static void fts5SegIterLoadTerm(Fts5Index *p, Fts5SegIter *pIter, int nKeep){
217098 u8 *a = pIter->pLeaf->p; /* Buffer to read data from */
217099 int iOff = pIter->iLeafOffset; /* Offset to read at */
217103 if( iOff+nNew>pIter->pLeaf->szLeaf || nKeep>pIter->term.n || nNew==0 ){
217107 pIter->term.n = nKeep;
217108 fts5BufferAppendBlob(&p->rc, &pIter->term, nNew, &a[iOff]);
217109 assert( pIter->term.n<=pIter->term.nSpace );
217111 pIter->iTermLeafOffset = iOff;
217112 pIter->iTermLeafPgno = pIter->iLeafPgno;
217113 pIter->iLeafOffset = iOff;
217115 if( pIter->iPgidxOff>=pIter->pLeaf->nn ){
217116 pIter->iEndofDoclist = pIter->pLeaf->nn+1;
217119 pIter->iPgidxOff += fts5GetVarint32(&a[pIter->iPgidxOff], nExtra);
217120 pIter->iEndofDoclist += nExtra;
217123 fts5SegIterLoadRowid(p, pIter);
217130 static void fts5SegIterSetNext(Fts5Index *p, Fts5SegIter *pIter){
217131 if( pIter->flags & FTS5_SEGITER_REVERSE ){
217132 pIter->xNext = fts5SegIterNext_Reverse;
217134 pIter->xNext = fts5SegIterNext_None;
217136 pIter->xNext = fts5SegIterNext;
217151 Fts5SegIter *pIter /* Object to populate */
217159 assert( pIter->pLeaf==0 );
217164 memset(pIter, 0, sizeof(*pIter));
217165 fts5SegIterSetNext(p, pIter);
217166 pIter->pSeg = pSeg;
217167 pIter->iLeafPgno = pSeg->pgnoFirst-1;
217168 fts5SegIterNextPage(p, pIter);
217172 pIter->iLeafOffset = 4;
217173 assert_nc( pIter->pLeaf->nn>4 );
217174 assert_nc( fts5LeafFirstTermOff(pIter->pLeaf)==4 );
217175 pIter->iPgidxOff = pIter->pLeaf->szLeaf+1;
217176 fts5SegIterLoadTerm(p, pIter, 0);
217177 fts5SegIterLoadNPos(p, pIter);
217196 static void fts5SegIterReverseInitPage(Fts5Index *p, Fts5SegIter *pIter){
217198 int n = pIter->pLeaf->szLeaf;
217199 int i = pIter->iLeafOffset;
217200 u8 *a = pIter->pLeaf->p;
217203 if( n>pIter->iEndofDoclist ){
217204 n = pIter->iEndofDoclist;
217207 ASSERT_SZLEAF_OK(pIter->pLeaf);
217225 pIter->iRowid += iDelta;
217228 if( iRowidOffset>=pIter->nRowidOffset ){
217229 int nNew = pIter->nRowidOffset + 8;
217230 int *aNew = (int*)sqlite3_realloc64(pIter->aRowidOffset,nNew*sizeof(int));
217235 pIter->aRowidOffset = aNew;
217236 pIter->nRowidOffset = nNew;
217239 pIter->aRowidOffset[iRowidOffset++] = pIter->iLeafOffset;
217240 pIter->iLeafOffset = i;
217242 pIter->iRowidOffset = iRowidOffset;
217243 fts5SegIterLoadNPos(p, pIter);
217249 static void fts5SegIterReverseNewPage(Fts5Index *p, Fts5SegIter *pIter){
217250 assert( pIter->flags & FTS5_SEGITER_REVERSE );
217251 assert( pIter->flags & FTS5_SEGITER_ONETERM );
217253 fts5DataRelease(pIter->pLeaf);
217254 pIter->pLeaf = 0;
217255 while( p->rc==SQLITE_OK && pIter->iLeafPgno>pIter->iTermLeafPgno ){
217257 pIter->iLeafPgno--;
217259 pIter->pSeg->iSegid, pIter->iLeafPgno
217265 if( pIter->iLeafPgno==pIter->iTermLeafPgno ){
217266 assert( pIter->pLeaf==0 );
217267 if( pIter->iTermLeafOffset<pNew->szLeaf ){
217268 pIter->pLeaf = pNew;
217269 pIter->iLeafOffset = pIter->iTermLeafOffset;
217275 pIter->pLeaf = pNew;
217276 pIter->iLeafOffset = iRowidOff;
217280 if( pIter->pLeaf ){
217281 u8 *a = &pIter->pLeaf->p[pIter->iLeafOffset];
217282 pIter->iLeafOffset += fts5GetVarint(a, (u64*)&pIter->iRowid);
217290 if( pIter->pLeaf ){
217291 pIter->iEndofDoclist = pIter->pLeaf->nn+1;
217292 fts5SegIterReverseInitPage(p, pIter);
217301 static int fts5MultiIterIsEmpty(Fts5Index *p, Fts5Iter *pIter){
217302 Fts5SegIter *pSeg = &pIter->aSeg[pIter->aFirst[1].iFirst];
217313 Fts5SegIter *pIter, /* Iterator to advance */
217316 assert( pIter->flags & FTS5_SEGITER_REVERSE );
217317 assert( pIter->pNextLeaf==0 );
217320 if( pIter->iRowidOffset>0 ){
217321 u8 *a = pIter->pLeaf->p;
217325 pIter->iRowidOffset--;
217326 pIter->iLeafOffset = pIter->aRowidOffset[pIter->iRowidOffset];
217327 fts5SegIterLoadNPos(p, pIter);
217328 iOff = pIter->iLeafOffset;
217330 iOff += pIter->nPos;
217333 pIter->iRowid -= iDelta;
217335 fts5SegIterReverseNewPage(p, pIter);
217347 Fts5SegIter *pIter, /* Iterator to advance */
217353 assert( (pIter->flags & FTS5_SEGITER_REVERSE)==0 );
217356 ASSERT_SZLEAF_OK(pIter->pLeaf);
217357 iOff = pIter->iLeafOffset;
217360 if( pIter->pSeg && iOff>=pIter->pLeaf->szLeaf ){
217361 fts5SegIterNextPage(p, pIter);
217362 if( p->rc || pIter->pLeaf==0 ) return;
217363 pIter->iRowid = 0;
217367 if( iOff<pIter->iEndofDoclist ){
217370 iOff += sqlite3Fts5GetVarint(&pIter->pLeaf->p[iOff], (u64*)&iDelta);
217371 pIter->iLeafOffset = iOff;
217372 pIter->iRowid += iDelta;
217373 }else if( (pIter->flags & FTS5_SEGITER_ONETERM)==0 ){
217374 if( pIter->pSeg ){
217376 if( iOff!=fts5LeafFirstTermOff(pIter->pLeaf) ){
217377 iOff += fts5GetVarint32(&pIter->pLeaf->p[iOff], nKeep);
217379 pIter->iLeafOffset = iOff;
217380 fts5SegIterLoadTerm(p, pIter, nKeep);
217388 pIter->pLeaf->p = (u8*)pList;
217389 pIter->pLeaf->nn = nList;
217390 pIter->pLeaf->szLeaf = nList;
217391 pIter->iEndofDoclist = nList;
217392 sqlite3Fts5BufferSet(&p->rc,&pIter->term, (int)strlen(zTerm), (u8*)zTerm);
217393 pIter->iLeafOffset = fts5GetVarint(pList, (u64*)&pIter->iRowid);
217401 fts5SegIterLoadNPos(p, pIter);
217405 fts5DataRelease(pIter->pLeaf);
217406 pIter->pLeaf = 0;
217419 Fts5SegIter *pIter, /* Iterator to advance */
217422 Fts5Data *pLeaf = pIter->pLeaf;
217437 iOff = pIter->iLeafOffset + pIter->nPos;
217441 assert_nc( iOff<=pIter->iEndofDoclist );
217442 if( iOff>=pIter->iEndofDoclist ){
217450 pIter->iRowid += iDelta;
217453 pIter->iLeafOffset = iOff;
217455 }else if( pIter->pSeg==0 ){
217459 assert( (pIter->flags & FTS5_SEGITER_ONETERM) || pbNewTerm );
217460 if( 0==(pIter->flags & FTS5_SEGITER_ONETERM) ){
217465 fts5DataRelease(pIter->pLeaf);
217466 pIter->pLeaf = 0;
217468 pIter->pLeaf->p = (u8*)pList;
217469 pIter->pLeaf->nn = nList;
217470 pIter->pLeaf->szLeaf = nList;
217471 pIter->iEndofDoclist = nList+1;
217472 sqlite3Fts5BufferSet(&p->rc, &pIter->term, (int)strlen(zTerm),
217474 pIter->iLeafOffset = fts5GetVarint(pList, (u64*)&pIter->iRowid);
217481 fts5SegIterNextPage(p, pIter);
217482 pLeaf = pIter->pLeaf;
217486 iOff += sqlite3Fts5GetVarint(&pLeaf->p[iOff], (u64*)&pIter->iRowid);
217487 pIter->iLeafOffset = iOff;
217490 pIter->iPgidxOff = pLeaf->szLeaf + fts5GetVarint32(
217491 &pLeaf->p[pLeaf->szLeaf], pIter->iEndofDoclist
217496 pIter->iPgidxOff = pLeaf->szLeaf + fts5GetVarint32(
217499 pIter->iLeafOffset = iOff;
217500 pIter->iEndofDoclist = iOff;
217512 if( pIter->pLeaf ){
217514 if( pIter->flags & FTS5_SEGITER_ONETERM ){
217515 fts5DataRelease(pIter->pLeaf);
217516 pIter->pLeaf = 0;
217518 fts5SegIterLoadTerm(p, pIter, nKeep);
217519 fts5SegIterLoadNPos(p, pIter);
217532 assert( pIter->iLeafOffset<=pIter->pLeaf->nn );
217533 fts5FastGetVarint32(pIter->pLeaf->p, pIter->iLeafOffset, nSz);
217534 pIter->bDel = (nSz & 0x0001);
217535 pIter->nPos = nSz>>1;
217536 assert_nc( pIter->nPos>=0 );
217553 static void fts5SegIterReverse(Fts5Index *p, Fts5SegIter *pIter){
217554 Fts5DlidxIter *pDlidx = pIter->pDlidx;
217559 int iSegid = pIter->pSeg->iSegid;
217563 Fts5Data *pLeaf = pIter->pLeaf; /* Current leaf data */
217569 if( pIter->iTermLeafPgno==pIter->iLeafPgno ){
217570 iPoslist = pIter->iTermLeafOffset;
217575 pIter->iLeafOffset = iPoslist;
217580 if( pIter->iEndofDoclist>=pLeaf->szLeaf ){
217582 Fts5StructureSegment *pSeg = pIter->pSeg;
217586 for(pgno=pIter->iLeafPgno+1; !p->rc && pgno<=pSeg->pgnoLast; pgno++){
217615 fts5DataRelease(pIter->pLeaf);
217616 pIter->pLeaf = pLast;
217617 pIter->iLeafPgno = pgnoLast;
217619 iOff += fts5GetVarint(&pLast->p[iOff], (u64*)&pIter->iRowid);
217620 pIter->iLeafOffset = iOff;
217623 pIter->iEndofDoclist = pLast->nn+1;
217625 pIter->iEndofDoclist = fts5LeafFirstTermOff(pLast);
217630 fts5SegIterReverseInitPage(p, pIter);
217639 static void fts5SegIterLoadDlidx(Fts5Index *p, Fts5SegIter *pIter){
217640 int iSeg = pIter->pSeg->iSegid;
217641 int bRev = (pIter->flags & FTS5_SEGITER_REVERSE);
217642 Fts5Data *pLeaf = pIter->pLeaf; /* Current leaf data */
217644 assert( pIter->flags & FTS5_SEGITER_ONETERM );
217645 assert( pIter->pDlidx==0 );
217650 if( pIter->iTermLeafPgno==pIter->iLeafPgno
217651 && pIter->iEndofDoclist<pLeaf->szLeaf
217656 pIter->pDlidx = fts5DlidxIterInit(p, bRev, iSeg, pIter->iTermLeafPgno);
217676 Fts5SegIter *pIter, /* Iterator to seek */
217680 const u8 *a = pIter->pLeaf->p;
217681 int szLeaf = pIter->pLeaf->szLeaf;
217682 int n = pIter->pLeaf->nn;
217750 fts5DataRelease(pIter->pLeaf);
217751 pIter->pLeaf = 0;
217755 fts5SegIterNextPage(p, pIter);
217756 if( pIter->pLeaf==0 ) return;
217757 a = pIter->pLeaf->p;
217758 if( fts5LeafIsTermless(pIter->pLeaf)==0 ){
217759 iPgidx = pIter->pLeaf->szLeaf;
217760 iPgidx += fts5GetVarint32(&pIter->pLeaf->p[iPgidx], iOff);
217761 if( iOff<4 || iOff>=pIter->pLeaf->szLeaf ){
217767 n = pIter->pLeaf->nn;
217776 pIter->iLeafOffset = iOff + nNew;
217777 if( pIter->iLeafOffset>n || nNew<1 ){
217781 pIter->iTermLeafOffset = pIter->iLeafOffset;
217782 pIter->iTermLeafPgno = pIter->iLeafPgno;
217784 fts5BufferSet(&p->rc, &pIter->term, nKeep, pTerm);
217785 fts5BufferAppendBlob(&p->rc, &pIter->term, nNew, &a[iOff]);
217788 pIter->iEndofDoclist = pIter->pLeaf->nn+1;
217792 pIter->iEndofDoclist = iTermOff + nExtra;
217794 pIter->iPgidxOff = iPgidx;
217796 fts5SegIterLoadRowid(p, pIter);
217797 fts5SegIterLoadNPos(p, pIter);
217824 Fts5SegIter *pIter /* Object to populate */
217833 memset(pIter, 0, sizeof(*pIter));
217834 pIter->pSeg = pSeg;
217855 pIter->iLeafPgno = iPg - 1;
217856 fts5SegIterNextPage(p, pIter);
217858 if( pIter->pLeaf ){
217859 fts5LeafSeek(p, bGe, pIter, pTerm, nTerm);
217863 pIter->flags |= FTS5_SEGITER_ONETERM;
217864 if( pIter->pLeaf ){
217866 pIter->flags |= FTS5_SEGITER_REVERSE;
217869 fts5SegIterLoadDlidx(p, pIter);
217872 fts5SegIterReverse(p, pIter);
217877 fts5SegIterSetNext(p, pIter);
217888 || pIter->pLeaf==0 /* 2 */
217889 || fts5BufferCompareBlob(&pIter->term, pTerm, nTerm)==0 /* 3 */
217890 || (bGe && fts5BufferCompareBlob(&pIter->term, pTerm, nTerm)>0) /* 4 */
217906 Fts5SegIter *pIter /* Object to populate */
217937 pIter->flags |= FTS5_SEGITER_ONETERM;
217941 sqlite3Fts5BufferSet(&p->rc, &pIter->term, n, z);
217943 pIter->pLeaf = pLeaf;
217944 pIter->iLeafOffset = fts5GetVarint(pLeaf->p, (u64*)&pIter->iRowid);
217945 pIter->iEndofDoclist = pLeaf->nn;
217948 pIter->flags |= FTS5_SEGITER_REVERSE;
217949 fts5SegIterReverseInitPage(p, pIter);
217951 fts5SegIterLoadNPos(p, pIter);
217955 fts5SegIterSetNext(p, pIter);
217961 static void fts5SegIterClear(Fts5SegIter *pIter){
217962 fts5BufferFree(&pIter->term);
217963 fts5DataRelease(pIter->pLeaf);
217964 fts5DataRelease(pIter->pNextLeaf);
217965 fts5DlidxIterFree(pIter->pDlidx);
217966 sqlite3_free(pIter->aRowidOffset);
217967 memset(pIter, 0, sizeof(Fts5SegIter));
217979 Fts5Iter *pIter,
217984 int i1 = p1 - pIter->aSeg;
217985 int i2 = p2 - pIter->aSeg;
218000 res = ((p1->iRowid > p2->iRowid)==pIter->bRev) ? -1 : 1;
218020 static void fts5AssertMultiIterSetup(Fts5Index *p, Fts5Iter *pIter){
218022 Fts5SegIter *pFirst = &pIter->aSeg[ pIter->aFirst[1].iFirst ];
218025 assert( (pFirst->pLeaf==0)==pIter->base.bEof );
218028 for(i=0; i<pIter->nSeg; i++){
218029 Fts5SegIter *p1 = &pIter->aSeg[i];
218033 || p1->iRowid==pIter->iSwitchRowid
218034 || (p1->iRowid<pIter->iSwitchRowid)==pIter->bRev
218038 for(i=0; i<pIter->nSeg; i+=2){
218039 Fts5SegIter *p1 = &pIter->aSeg[i];
218040 Fts5SegIter *p2 = &pIter->aSeg[i+1];
218041 Fts5CResult *pRes = &pIter->aFirst[(pIter->nSeg + i) / 2];
218042 fts5AssertComparisonResult(pIter, p1, p2, pRes);
218045 for(i=1; i<(pIter->nSeg / 2); i+=2){
218046 Fts5SegIter *p1 = &pIter->aSeg[ pIter->aFirst[i*2].iFirst ];
218047 Fts5SegIter *p2 = &pIter->aSeg[ pIter->aFirst[i*2+1].iFirst ];
218048 Fts5CResult *pRes = &pIter->aFirst[i];
218049 fts5AssertComparisonResult(pIter, p1, p2, pRes);
218065 static int fts5MultiIterDoCompare(Fts5Iter *pIter, int iOut){
218071 Fts5CResult *pRes = &pIter->aFirst[iOut];
218073 assert( iOut<pIter->nSeg && iOut>0 );
218074 assert( pIter->bRev==0 || pIter->bRev==1 );
218076 if( iOut>=(pIter->nSeg/2) ){
218077 i1 = (iOut - pIter->nSeg/2) * 2;
218080 i1 = pIter->aFirst[iOut*2].iFirst;
218081 i2 = pIter->aFirst[iOut*2+1].iFirst;
218083 p1 = &pIter->aSeg[i1];
218084 p2 = &pIter->aSeg[i2];
218101 res = ((p1->iRowid > p2->iRowid)==pIter->bRev) ? -1 : +1;
218121 Fts5SegIter *pIter, /* Iterator to advance */
218124 assert( iLeafPgno>pIter->iLeafPgno );
218126 if( iLeafPgno>pIter->pSeg->pgnoLast ){
218129 fts5DataRelease(pIter->pNextLeaf);
218130 pIter->pNextLeaf = 0;
218131 pIter->iLeafPgno = iLeafPgno-1;
218132 fts5SegIterNextPage(p, pIter);
218133 assert( p->rc!=SQLITE_OK || pIter->iLeafPgno==iLeafPgno );
218137 u8 *a = pIter->pLeaf->p;
218138 int n = pIter->pLeaf->szLeaf;
218140 iOff = fts5LeafFirstRowidOff(pIter->pLeaf);
218144 iOff += fts5GetVarint(&a[iOff], (u64*)&pIter->iRowid);
218145 pIter->iLeafOffset = iOff;
218146 fts5SegIterLoadNPos(p, pIter);
218159 Fts5SegIter *pIter, /* Iterator to advance */
218162 int bRev = (pIter->flags & FTS5_SEGITER_REVERSE);
218163 Fts5DlidxIter *pDlidx = pIter->pDlidx;
218164 int iLeafPgno = pIter->iLeafPgno;
218167 assert( pIter->flags & FTS5_SEGITER_ONETERM );
218168 assert( pIter->pDlidx );
218169 assert( pIter->pLeaf );
218176 assert_nc( iLeafPgno>=pIter->iLeafPgno || p->rc );
218177 if( iLeafPgno>pIter->iLeafPgno ){
218178 fts5SegIterGotoPage(p, pIter, iLeafPgno);
218182 assert( pIter->pNextLeaf==0 );
218183 assert( iMatch<pIter->iRowid );
218189 assert( fts5DlidxIterEof(p, pDlidx) || iLeafPgno<=pIter->iLeafPgno );
218191 if( iLeafPgno<pIter->iLeafPgno ){
218192 pIter->iLeafPgno = iLeafPgno+1;
218193 fts5SegIterReverseNewPage(p, pIter);
218199 if( bMove && p->rc==SQLITE_OK ) pIter->xNext(p, pIter, 0);
218200 if( pIter->pLeaf==0 ) break;
218201 if( bRev==0 && pIter->iRowid>=iMatch ) break;
218202 if( bRev!=0 && pIter->iRowid<=iMatch ) break;
218211 static void fts5MultiIterFree(Fts5Iter *pIter){
218212 if( pIter ){
218214 for(i=0; i<pIter->nSeg; i++){
218215 fts5SegIterClear(&pIter->aSeg[i]);
218217 fts5BufferFree(&pIter->poslist);
218218 sqlite3_free(pIter);
218224 Fts5Iter *pIter, /* Iterator to update aFirst[] array for */
218229 for(i=(pIter->nSeg+iChanged)/2; i>=iMinset && p->rc==SQLITE_OK; i=i/2){
218231 if( (iEq = fts5MultiIterDoCompare(pIter, i)) ){
218232 Fts5SegIter *pSeg = &pIter->aSeg[iEq];
218235 i = pIter->nSeg + iEq;
218251 Fts5Iter *pIter, /* Iterator to update aFirst[] array for */
218255 Fts5SegIter *pNew = &pIter->aSeg[iChanged];
218257 if( pNew->iRowid==pIter->iSwitchRowid
218258 || (pNew->iRowid<pIter->iSwitchRowid)==pIter->bRev
218261 Fts5SegIter *pOther = &pIter->aSeg[iChanged ^ 0x0001];
218262 pIter->iSwitchRowid = pIter->bRev ? SMALLEST_INT64 : LARGEST_INT64;
218263 for(i=(pIter->nSeg+iChanged)/2; 1; i=i/2){
218264 Fts5CResult *pRes = &pIter->aFirst[i];
218272 }else if( (pOther->iRowid>pNew->iRowid)==pIter->bRev ){
218273 pIter->iSwitchRowid = pOther->iRowid;
218275 }else if( (pOther->iRowid>pIter->iSwitchRowid)==pIter->bRev ){
218276 pIter->iSwitchRowid = pOther->iRowid;
218279 pRes->iFirst = (u16)(pNew - pIter->aSeg);
218282 pOther = &pIter->aSeg[ pIter->aFirst[i ^ 0x0001].iFirst ];
218293 static void fts5MultiIterSetEof(Fts5Iter *pIter){
218294 Fts5SegIter *pSeg = &pIter->aSeg[ pIter->aFirst[1].iFirst ];
218295 pIter->base.bEof = pSeg->pLeaf==0;
218296 pIter->iSwitchRowid = pSeg->iRowid;
218308 Fts5Iter *pIter,
218313 assert( pIter->base.bEof==0 );
218315 int iFirst = pIter->aFirst[1].iFirst;
218317 Fts5SegIter *pSeg = &pIter->aSeg[iFirst];
218326 || fts5MultiIterAdvanceRowid(pIter, iFirst, &pSeg)
218328 fts5MultiIterAdvanced(p, pIter, iFirst, 1);
218329 fts5MultiIterSetEof(pIter);
218330 pSeg = &pIter->aSeg[pIter->aFirst[1].iFirst];
218334 fts5AssertMultiIterSetup(p, pIter);
218335 assert( pSeg==&pIter->aSeg[pIter->aFirst[1].iFirst] && pSeg->pLeaf );
218336 if( pIter->bSkipEmpty==0 || pSeg->nPos ){
218337 pIter->xSetOutputs(pIter, pSeg);
218346 Fts5Iter *pIter,
218349 assert( pIter->bSkipEmpty );
218353 int iFirst = pIter->aFirst[1].iFirst;
218354 Fts5SegIter *pSeg = &pIter->aSeg[iFirst];
218360 || fts5MultiIterAdvanceRowid(pIter, iFirst, &pSeg)
218362 fts5MultiIterAdvanced(p, pIter, iFirst, 1);
218363 fts5MultiIterSetEof(pIter);
218366 fts5AssertMultiIterSetup(p, pIter);
218368 }while( fts5MultiIterIsEmpty(p, pIter) );
218653 static void fts5IterSetOutputs_None(Fts5Iter *pIter, Fts5SegIter *pSeg){
218654 assert( pIter->pIndex->pConfig->eDetail==FTS5_DETAIL_NONE );
218655 pIter->base.iRowid = pSeg->iRowid;
218656 pIter->base.nData = pSeg->nPos;
218663 static void fts5IterSetOutputs_Nocolset(Fts5Iter *pIter, Fts5SegIter *pSeg){
218664 pIter->base.iRowid = pSeg->iRowid;
218665 pIter->base.nData = pSeg->nPos;
218667 assert( pIter->pIndex->pConfig->eDetail!=FTS5_DETAIL_NONE );
218668 assert( pIter->pColset==0 );
218673 pIter->base.pData = &pSeg->pLeaf->p[pSeg->iLeafOffset];
218678 fts5BufferZero(&pIter->poslist);
218679 fts5SegiterPoslist(pIter->pIndex, pSeg, 0, &pIter->poslist);
218680 pIter->base.pData = pIter->poslist.p;
218688 static void fts5IterSetOutputs_ZeroColset(Fts5Iter *pIter, Fts5SegIter *pSeg){
218690 pIter->base.nData = 0;
218698 static void fts5IterSetOutputs_Col(Fts5Iter *pIter, Fts5SegIter *pSeg){
218699 fts5BufferZero(&pIter->poslist);
218700 fts5SegiterPoslist(pIter->pIndex, pSeg, pIter->pColset, &pIter->poslist);
218701 pIter->base.iRowid = pSeg->iRowid;
218702 pIter->base.pData = pIter->poslist.p;
218703 pIter->base.nData = pIter->poslist.n;
218716 static void fts5IterSetOutputs_Col100(Fts5Iter *pIter, Fts5SegIter *pSeg){
218718 assert( pIter->pIndex->pConfig->eDetail==FTS5_DETAIL_COLUMNS );
218719 assert( pIter->pColset );
218722 fts5IterSetOutputs_Col(pIter, pSeg);
218727 int *aiCol = pIter->pColset->aiCol;
218728 int *aiColEnd = &aiCol[pIter->pColset->nCol];
218730 u8 *aOut = pIter->poslist.p;
218733 pIter->base.iRowid = pSeg->iRowid;
218748 pIter->base.pData = pIter->poslist.p;
218749 pIter->base.nData = aOut - pIter->poslist.p;
218756 static void fts5IterSetOutputs_Full(Fts5Iter *pIter, Fts5SegIter *pSeg){
218757 Fts5Colset *pColset = pIter->pColset;
218758 pIter->base.iRowid = pSeg->iRowid;
218760 assert( pIter->pIndex->pConfig->eDetail==FTS5_DETAIL_FULL );
218768 pIter->base.nData = fts5IndexExtractCol(&a, pSeg->nPos,pColset->aiCol[0]);
218769 pIter->base.pData = a;
218771 int *pRc = &pIter->pIndex->rc;
218772 fts5BufferZero(&pIter->poslist);
218773 fts5IndexExtractColset(pRc, pColset, a, pSeg->nPos, &pIter->poslist);
218774 pIter->base.pData = pIter->poslist.p;
218775 pIter->base.nData = pIter->poslist.n;
218781 fts5BufferZero(&pIter->poslist);
218782 fts5SegiterPoslist(pIter->pIndex, pSeg, pColset, &pIter->poslist);
218783 pIter->base.pData = pIter->poslist.p;
218784 pIter->base.nData = pIter->poslist.n;
218788 static void fts5IterSetOutputCb(int *pRc, Fts5Iter *pIter){
218790 Fts5Config *pConfig = pIter->pIndex->pConfig;
218792 pIter->xSetOutputs = fts5IterSetOutputs_None;
218795 else if( pIter->pColset==0 ){
218796 pIter->xSetOutputs = fts5IterSetOutputs_Nocolset;
218799 else if( pIter->pColset->nCol==0 ){
218800 pIter->xSetOutputs = fts5IterSetOutputs_ZeroColset;
218804 pIter->xSetOutputs = fts5IterSetOutputs_Full;
218810 pIter->xSetOutputs = fts5IterSetOutputs_Col100;
218811 sqlite3Fts5BufferSize(pRc, &pIter->poslist, pConfig->nCol);
218813 pIter->xSetOutputs = fts5IterSetOutputs_Col;
218874 Fts5SegIter *pIter = &pNew->aSeg[iIter++];
218875 fts5SegIterHashInit(p, pTerm, nTerm, flags, pIter);
218880 Fts5SegIter *pIter = &pNew->aSeg[iIter++];
218882 fts5SegIterInit(p, pSeg, pIter);
218884 fts5SegIterSeekInit(p, pTerm, nTerm, flags, pSeg, pIter);
218939 Fts5SegIter *pIter = &pNew->aSeg[1];
218941 pIter->flags = FTS5_SEGITER_ONETERM;
218943 pIter->pLeaf = pData;
218944 pIter->iLeafOffset = fts5GetVarint(pData->p, (u64*)&pIter->iRowid);
218945 pIter->iEndofDoclist = pData->nn;
218949 pIter->flags |= FTS5_SEGITER_REVERSE;
218950 fts5SegIterReverseInitPage(p, pIter);
218952 fts5SegIterLoadNPos(p, pIter);
218958 fts5SegIterSetNext(p, pIter);
218970 static int fts5MultiIterEof(Fts5Index *p, Fts5Iter *pIter){
218972 || (pIter->aSeg[ pIter->aFirst[1].iFirst ].pLeaf==0)==pIter->base.bEof
218974 return (p->rc || pIter->base.bEof);
218982 static i64 fts5MultiIterRowid(Fts5Iter *pIter){
218983 assert( pIter->aSeg[ pIter->aFirst[1].iFirst ].pLeaf );
218984 return pIter->aSeg[ pIter->aFirst[1].iFirst ].iRowid;
218992 Fts5Iter *pIter,
218997 fts5MultiIterNext(p, pIter, 1, iMatch);
218998 if( fts5MultiIterEof(p, pIter) ) break;
218999 iRowid = fts5MultiIterRowid(pIter);
219000 if( pIter->bRev==0 && iRowid>=iMatch ) break;
219001 if( pIter->bRev!=0 && iRowid<=iMatch ) break;
219009 static const u8 *fts5MultiIterTerm(Fts5Iter *pIter, int *pn){
219010 Fts5SegIter *p = &pIter->aSeg[ pIter->aFirst[1].iFirst ];
219584 static void fts5TrimSegments(Fts5Index *p, Fts5Iter *pIter){
219588 for(i=0; i<pIter->nSeg && p->rc==SQLITE_OK; i++){
219589 Fts5SegIter *pSeg = &pIter->aSeg[i];
219671 Fts5Iter *pIter = 0; /* Iterator to read input data */
219725 for(fts5MultiIterNew(p, pStruct, flags, 0, 0, 0, iLvl, nInput, &pIter);
219726 fts5MultiIterEof(p, pIter)==0;
219727 fts5MultiIterNext(p, pIter, 0, 0)
219729 Fts5SegIter *pSegIter = &pIter->aSeg[ pIter->aFirst[1].iFirst ];
219734 pTerm = fts5MultiIterTerm(pIter, &nTerm);
219754 fts5WriteAppendRowid(p, &writer, fts5MultiIterRowid(pIter));
219775 if( fts5MultiIterEof(p, pIter) ){
219797 fts5TrimSegments(p, pIter);
219801 fts5MultiIterFree(pIter);
220256 static void fts5DoclistIterNext(Fts5DoclistIter *pIter){
220257 u8 *p = pIter->aPoslist + pIter->nSize + pIter->nPoslist;
220259 assert( pIter->aPoslist );
220260 if( p>=pIter->aEof ){
220261 pIter->aPoslist = 0;
220266 pIter->iRowid += iDelta;
220271 pIter->nSize = fts5GetVarint32(p, nPos);
220272 pIter->nPoslist = (nPos>>1);
220274 pIter->nPoslist = ((int)(p[0])) >> 1;
220275 pIter->nSize = 1;
220278 pIter->aPoslist = p;
220284 Fts5DoclistIter *pIter
220286 memset(pIter, 0, sizeof(*pIter));
220287 pIter->aPoslist = pBuf->p;
220288 pIter->aEof = &pBuf->p[pBuf->n];
220289 fts5DoclistIterNext(pIter);
220931 Fts5Iter *pIter = (Fts5Iter*)pIndexIter;
220932 assert( pIter->pIndex->rc==SQLITE_OK );
220933 fts5MultiIterNext(pIter->pIndex, pIter, 0, 0);
220934 return fts5IndexReturn(pIter->pIndex);
220941 Fts5Iter *pIter = (Fts5Iter*)pIndexIter;
220942 Fts5Index *p = pIter->pIndex;
220944 assert( pIter->pIndex->rc==SQLITE_OK );
220946 fts5MultiIterNext(p, pIter, 0, 0);
220948 Fts5SegIter *pSeg = &pIter->aSeg[ pIter->aFirst[1].iFirst ];
220952 pIter->base.bEof = 1;
220956 return fts5IndexReturn(pIter->pIndex);
220965 Fts5Iter *pIter = (Fts5Iter*)pIndexIter;
220966 fts5MultiIterNextFrom(pIter->pIndex, pIter, iMatch);
220967 return fts5IndexReturn(pIter->pIndex);
220985 Fts5Iter *pIter = (Fts5Iter*)pIndexIter;
220986 Fts5Index *pIndex = pIter->pIndex;
220987 fts5MultiIterFree(pIter);
221152 Fts5IndexIter *pIter = 0;
221153 int rc = sqlite3Fts5IndexQuery(p, z, n, flags, 0, &pIter);
221155 while( rc==SQLITE_OK && 0==sqlite3Fts5IterEof(pIter) ){
221156 i64 rowid = pIter->iRowid;
221162 for(sqlite3Fts5PoslistReaderInit(pIter->pData, pIter->nData, &sReader);
221172 rc = sqlite3Fts5IterNext(pIter);
221175 sqlite3Fts5IterClose(pIter);
221518 Fts5Iter *pIter; /* Used to iterate through entire index */
221555 for(fts5MultiIterNew(p, pStruct, flags, 0, 0, 0, -1, 0, &pIter);
221556 fts5MultiIterEof(p, pIter)==0;
221557 fts5MultiIterNext(p, pIter, 0, 0)
221562 i64 iRowid = fts5MultiIterRowid(pIter);
221563 char *z = (char*)fts5MultiIterTerm(pIter, &n);
221569 if( 0==fts5MultiIterIsEmpty(p, pIter) ){
221574 fts5SegiterPoslist(p, &pIter->aSeg[pIter->aFirst[1].iFirst], 0, &poslist);
221584 fts5MultiIterFree(pIter);
224194 Fts5PhraseIter *pIter,
224198 if( pIter->a>=pIter->b ){
224203 pIter->a += fts5GetVarint32(pIter->a, iVal);
224205 pIter->a += fts5GetVarint32(pIter->a, iVal);
224208 pIter->a += fts5GetVarint32(pIter->a, iVal);
224217 Fts5PhraseIter *pIter,
224222 int rc = fts5CsrPoslist(pCsr, iPhrase, &pIter->a, &n);
224224 pIter->b = &pIter->a[n];
224227 fts5ApiPhraseNext(pCtx, pIter, piCol, piOff);
224234 Fts5PhraseIter *pIter,
224241 if( pIter->a>=pIter->b ){
224245 pIter->a += fts5GetVarint32(&pIter->a[0], iIncr);
224251 if( pIter->a>=pIter->b ){
224255 if( pIter->a[0]==0x01 ) break;
224256 pIter->a += fts5GetVarint32(pIter->a, dummy);
224258 pIter->a += 1 + fts5GetVarint32(&pIter->a[1], *piCol);
224265 Fts5PhraseIter *pIter,
224278 pIter->a = &pSorter->aPoslist[i1];
224280 rc = sqlite3Fts5ExprPhraseCollist(pCsr->pExpr, iPhrase, &pIter->a, &n);
224283 pIter->b = &pIter->a[n];
224285 fts5ApiPhraseNextColumn(pCtx, pIter, piCol);
224289 rc = fts5CsrPoslist(pCsr, iPhrase, &pIter->a, &n);
224291 pIter->b = &pIter->a[n];
224294 }else if( pIter->a[0]==0x01 ){
224295 pIter->a += 1 + fts5GetVarint32(&pIter->a[1], *piCol);
228579 Fts5IndexIter *pIter; /* Term/rowid iterator object */
228912 sqlite3Fts5IterClose(pCsr->pIter);
228913 pCsr->pIter = 0;
228936 if( sqlite3Fts5IterEof(pCsr->pIter) ){
228941 zTerm = sqlite3Fts5IterTerm(pCsr->pIter, &nTerm);
228958 Fts5IndexIter *pIter = pCsr->pIter;
228962 assert( sqlite3Fts5IterEof(pIter)==0 );
228965 || sqlite3Fts5PoslistNext64(pIter->pData, pIter->nData, po, pp)
228970 rc = sqlite3Fts5IterNextScan(pCsr->pIter);
229006 if( sqlite3Fts5IterEof(pCsr->pIter) ){
229012 zTerm = sqlite3Fts5IterTerm(pCsr->pIter, &nTerm);
229035 pPos = pCsr->pIter->pData;
229036 nPos = pCsr->pIter->nData;
229084 rc = sqlite3Fts5IterNextScan(pCsr->pIter);
229089 zTerm = sqlite3Fts5IterTerm(pCsr->pIter, &nTerm);
229095 if( sqlite3Fts5IterEof(pCsr->pIter) ) break;
229165 rc = sqlite3Fts5IndexQuery(pIndex, zTerm, nTerm, f, 0, &pCsr->pIter);
229226 sqlite3_result_int64(pCtx, pCsr->pIter->iRowid);