Lines Matching refs:pIter
12412 SQLITE_API int sqlite3changeset_next(sqlite3_changeset_iter *pIter);
12418 ** The pIter argument passed to this function may either be an iterator
12447 sqlite3_changeset_iter *pIter, /* Iterator object */
12466 ** the table modified by the change that iterator pIter currently points to.
12481 sqlite3_changeset_iter *pIter, /* Iterator object */
12490 ** The pIter argument passed to this function may either be an iterator
12512 sqlite3_changeset_iter *pIter, /* Changeset iterator */
12521 ** The pIter argument passed to this function may either be an iterator
12546 sqlite3_changeset_iter *pIter, /* Changeset iterator */
12574 sqlite3_changeset_iter *pIter, /* Changeset iterator */
12591 sqlite3_changeset_iter *pIter, /* Changeset iterator */
12626 SQLITE_API int sqlite3changeset_finalize(sqlite3_changeset_iter *pIter);
69625 WalIterator *pIter = 0; /* Wal iterator context */
69670 rc = walIteratorInit(pWal, pInfo->nBackfill, &pIter);
69671 assert( rc==SQLITE_OK || pIter==0 );
69674 if( pIter
69719 while( rc==SQLITE_OK && 0==walIteratorNext(pIter, &iDbpage, &iFrame) ){
69807 SEH_FREE_ON_ERROR(pIter, 0);
69808 walIteratorFree(pIter);
73450 BtLock *pIter;
73477 for(pIter=pBt->pLock; pIter; pIter=pIter->pNext){
73478 /* The condition (pIter->eLock!=eLock) in the following if(...)
73481 ** (eLock==WRITE_LOCK || pIter->eLock==WRITE_LOCK)
73487 assert( pIter->eLock==READ_LOCK || pIter->eLock==WRITE_LOCK );
73488 assert( eLock==READ_LOCK || pIter->pBtree==p || pIter->eLock==READ_LOCK);
73489 if( pIter->pBtree!=p && pIter->iTable==iTab && pIter->eLock!=eLock ){
73490 sqlite3ConnectionBlocked(p->db, pIter->pBtree->db);
73523 BtLock *pIter;
73543 for(pIter=pBt->pLock; pIter; pIter=pIter->pNext){
73544 if( pIter->iTable==iTable && pIter->pBtree==p ){
73545 pLock = pIter;
74383 u8 *pIter; /* For scanning through pCell */
74391 pIter = pCell;
74395 ** pIter += getVarint32(pIter, nPayload);
74399 nPayload = *pIter;
74401 u8 *pEnd = &pIter[8];
74404 nPayload = (nPayload<<7) | (*++pIter & 0x7f);
74405 }while( (*pIter)>=0x80 && pIter<pEnd );
74408 pIter++;
74412 ** pIter += getVarint(pIter, (u64*)&pInfo->nKey);
74417 iKey = *pIter;
74420 iKey = (iKey<<7) ^ (x = *++pIter);
74422 iKey = (iKey<<7) ^ (x = *++pIter);
74424 iKey = (iKey<<7) ^ 0x10204000 ^ (x = *++pIter);
74426 iKey = (iKey<<7) ^ 0x4000 ^ (x = *++pIter);
74428 iKey = (iKey<<7) ^ 0x4000 ^ (x = *++pIter);
74430 iKey = (iKey<<7) ^ 0x4000 ^ (x = *++pIter);
74432 iKey = (iKey<<7) ^ 0x4000 ^ (x = *++pIter);
74434 iKey = (iKey<<8) ^ 0x8000 ^ (*++pIter);
74447 pIter++;
74451 pInfo->pPayload = pIter;
74459 pInfo->nSize = (u16)nPayload + (u16)(pIter - pCell);
74471 u8 *pIter; /* For scanning through pCell */
74477 pIter = pCell + pPage->childPtrSize;
74478 nPayload = *pIter;
74480 u8 *pEnd = &pIter[8];
74483 nPayload = (nPayload<<7) | (*++pIter & 0x7f);
74484 }while( *(pIter)>=0x80 && pIter<pEnd );
74486 pIter++;
74489 pInfo->pPayload = pIter;
74498 pInfo->nSize = (u16)nPayload + (u16)(pIter - pCell);
74528 u8 *pIter = pCell + 4; /* For looping over bytes of pCell */
74542 nSize = *pIter;
74544 pEnd = &pIter[8];
74547 nSize = (nSize<<7) | (*++pIter & 0x7f);
74548 }while( *(pIter)>=0x80 && pIter<pEnd );
74550 pIter++;
74554 nSize += (u32)(pIter - pCell);
74564 nSize += 4 + (u16)(pIter - pCell);
74570 u8 *pIter = pCell; /* For looping over bytes of pCell */
74584 nSize = *pIter;
74586 pEnd = &pIter[8];
74589 nSize = (nSize<<7) | (*++pIter & 0x7f);
74590 }while( *(pIter)>=0x80 && pIter<pEnd );
74592 pIter++;
74596 nSize += (u32)(pIter - pCell);
74606 nSize += 4 + (u16)(pIter - pCell);
74612 u8 *pIter
74627 pEnd = pIter + 9;
74628 while( (*pIter++)&0x80 && pIter<pEnd );
74629 assert( debuginfo.nSize==(u16)(pIter - pCell) || CORRUPT_DB );
74630 return (u16)(pIter - pCell);
74633 u8 *pIter = pCell; /* For looping over bytes of pCell */
74646 nSize = *pIter;
74648 pEnd = &pIter[8];
74651 nSize = (nSize<<7) | (*++pIter & 0x7f);
74652 }while( *(pIter)>=0x80 && pIter<pEnd );
74654 pIter++;
74655 /* pIter now points at the 64-bit integer key value, a variable length
74656 ** integer. The following block moves pIter to point at the first byte
74658 if( (*pIter++)&0x80
74659 && (*pIter++)&0x80
74660 && (*pIter++)&0x80
74661 && (*pIter++)&0x80
74662 && (*pIter++)&0x80
74663 && (*pIter++)&0x80
74664 && (*pIter++)&0x80
74665 && (*pIter++)&0x80 ){ pIter++; }
74669 nSize += (u32)(pIter - pCell);
74679 nSize += 4 + (u16)(pIter - pCell);
76758 BtLock *pIter;
76759 for(pIter=pBt->pLock; pIter; pIter=pIter->pNext){
76760 if( pIter->pBtree!=p ){
76761 pBlock = pIter->pBtree->db;
109750 FileChunk *pIter;
109752 for(pIter=pFirst; pIter; pIter=pNext){
109753 pNext = pIter->pNext;
109754 sqlite3_free(pIter);
109771 FileChunk *pIter;
109772 for(pIter=copy.pFirst; pIter; pIter=pIter->pNext){
109776 rc = sqlite3OsWrite(pReal, (u8*)pIter->zChunk, nChunk, iOff);
109880 FileChunk *pIter = 0;
109886 for(pIter=p->pFirst; ALWAYS(pIter) && iOff<size; pIter=pIter->pNext){
109889 if( ALWAYS(pIter) ){
109890 memjrnlFreeChunks(pIter->pNext);
109891 pIter->pNext = 0;
109895 p->endpoint.pChunk = pIter;
140436 static Index *indexIteratorFirst(IndexIterator *pIter, int *pIx){
140437 assert( pIter->i==0 );
140438 if( pIter->eType ){
140439 *pIx = pIter->u.ax.aIdx[0].ix;
140440 return pIter->u.ax.aIdx[0].p;
140443 return pIter->u.lx.pIdx;
140448 static Index *indexIteratorNext(IndexIterator *pIter, int *pIx){
140449 if( pIter->eType ){
140450 int i = ++pIter->i;
140451 if( i>=pIter->u.ax.nIdx ){
140455 *pIx = pIter->u.ax.aIdx[i].ix;
140456 return pIter->u.ax.aIdx[i].p;
140459 pIter->u.lx.pIdx = pIter->u.lx.pIdx->pNext;
140460 return pIter->u.lx.pIdx;
198256 char *pIter; /* Used to iterate through aAll */
198260 pIter = pDL->pNextDocid;
198261 assert( pDL->aAll!=0 || pIter==0 );
198263 pIter = pDL->aAll;
198266 if( pIter==0 || pIter>=(pEnd = pDL->aAll + pDL->nAll) ){
198271 pIter += sqlite3Fts3GetVarint(pIter, &iDelta);
198277 pDL->pList = pIter;
198278 fts3PoslistCopy(0, &pIter);
198279 pDL->nList = (int)(pIter - pDL->pList);
198281 /* pIter now points just past the 0x00 that terminates the position-
198283 ** edited in place by fts3EvalNearTrim(), then pIter may not actually
198285 ** with this case by advancing pIter past the zero-padding added by
198287 while( pIter<pEnd && *pIter==0 ) pIter++;
198289 pDL->pNextDocid = pIter;
198290 assert( pIter>=&pDL->aAll[pDL->nAll] || *pIter );
199654 char *pIter;
199667 pIter = pPhrase->doclist.pList;
199728 pIter = pPh->pOrPoslist;
199732 (pIter >= (pPh->doclist.aAll + pPh->doclist.nAll));
199733 while( (pIter==0 || DOCID_CMP(iDocid, pCsr->iPrevId)<0 ) && bEof==0 ){
199736 &pIter, &iDocid, &bEof
199740 bEof = !pPh->doclist.nAll || (pIter && pIter<=pPh->doclist.aAll);
199741 while( (pIter==0 || DOCID_CMP(iDocid, pCsr->iPrevId)>0 ) && bEof==0 ){
199745 &pIter, &iDocid, &dummy, &bEof
199749 pPh->pOrPoslist = pIter;
199755 pIter = pPhrase->pOrPoslist;
199757 pIter = 0;
199760 if( pIter==0 ) return SQLITE_OK;
199762 if( *pIter==0x01 ){
199763 pIter++;
199764 pIter += fts3GetVarint32(pIter, &iThis);
199769 fts3ColumnlistCopy(0, &pIter);
199770 if( *pIter==0x00 ) return SQLITE_OK;
199771 pIter++;
199772 pIter += fts3GetVarint32(pIter, &iThis);
199774 if( *pIter==0x00 ){
199775 pIter = 0;
199778 *ppOut = ((iCol==iThis)?pIter:0);
201151 Fts3Expr *pIter = pNotBranch;
201152 while( pIter->pLeft ){
201153 pIter = pIter->pLeft;
201155 pIter->pLeft = pRet;
201156 pRet->pParent = pIter;
206186 SegmentNode *pIter;
206189 for(pIter=pTree->pLeftmost; pIter && rc==SQLITE_OK; pIter=pIter->pRight){
206190 int nStart = fts3TreeFinishNode(pIter, iHeight, iNextLeaf);
206191 int nWrite = pIter->nData - nStart;
206193 rc = fts3WriteSegment(p, iNextFree, &pIter->aData[nStart], nWrite);
206195 iNextLeaf += (pIter->nEntry+1);
210188 char *pIter = *ppIter;
210189 if( pIter ){
210193 if( 0==(*pIter & 0xFE) ){
210195 pIter = 0;
210198 fts3GetDeltaPosition(&pIter, &iIter);
210202 *ppIter = pIter;
210209 static int fts3SnippetNextCandidate(SnippetIter *pIter){
210212 if( pIter->iCurrent<0 ){
210217 pIter->iCurrent = 0;
210222 for(i=0; i<pIter->nPhrase; i++){
210223 SnippetPhrase *pPhrase = &pIter->aPhrase[i];
210224 fts3SnippetAdvance(&pPhrase->pHead, &pPhrase->iHead, pIter->nSnippet);
210230 for(i=0; i<pIter->nPhrase; i++){
210231 SnippetPhrase *pPhrase = &pIter->aPhrase[i];
210240 assert( pIter->nSnippet>=0 );
210241 pIter->iCurrent = iStart = iEnd - pIter->nSnippet + 1;
210242 for(i=0; i<pIter->nPhrase; i++){
210243 SnippetPhrase *pPhrase = &pIter->aPhrase[i];
210254 ** iterator pIter.
210257 SnippetIter *pIter, /* Snippet iterator */
210264 int iStart = pIter->iCurrent; /* First token of snippet */
210270 for(i=0; i<pIter->nPhrase; i++){
210271 SnippetPhrase *pPhrase = &pIter->aPhrase[i];
210276 while( iCsr<(iStart+pIter->nSnippet) && iCsr>=iStart ){
210289 for(j=0; j<pPhrase->nToken && j<pIter->nSnippet; j++){
210713 char *pIter = pPhrase->doclist.pList;
210723 if( pIter ) while( 1 ){
210724 int nHit = fts3ColumnlistCount(&pIter);
210732 assert( *pIter==0x00 || *pIter==0x01 );
210733 if( *pIter!=0x01 ) break;
210734 pIter++;
210735 pIter += fts3GetVarint32(pIter, &iCol);
210954 static int fts3LcsIteratorAdvance(LcsIterator *pIter){
210959 if( NEVER(pIter==0) ) return 1;
210960 pRead = pIter->pRead;
210966 pIter->iPos += (int)(iRead-2);
210969 pIter->pRead = pRead;
210999 LcsIterator *pIter = &aIter[i];
211000 nToken -= pIter->pExpr->pPhrase->nToken;
211001 pIter->iPosOffset = nToken;
211028 LcsIterator *pIter = &aIter[i];
211029 if( pIter->pRead==0 ){
211033 if( pAdv==0 || pIter->iPos<pAdv->iPos ){
211034 pAdv = pIter;
211036 if( nThisLcs==0 || pIter->iPos==pIter[-1].iPos ){
225050 UBreakIterator *pIter; /* ICU break-iterator object */
225163 pCsr->pIter = ubrk_open(UBRK_WORD, p->zLocale, pCsr->aChar, iOut, &status);
225170 ubrk_first(pCsr->pIter);
225180 ubrk_close(pCsr->pIter);
225206 iStart = ubrk_current(pCsr->pIter);
225207 iEnd = ubrk_next(pCsr->pIter);
226733 static void rbuObjIterFreeCols(RbuObjIter *pIter){
226735 for(i=0; i<pIter->nTblCol; i++){
226736 sqlite3_free(pIter->azTblCol[i]);
226737 sqlite3_free(pIter->azTblType[i]);
226739 sqlite3_free(pIter->azTblCol);
226740 pIter->azTblCol = 0;
226741 pIter->azTblType = 0;
226742 pIter->aiSrcOrder = 0;
226743 pIter->abTblPk = 0;
226744 pIter->abNotNull = 0;
226745 pIter->nTblCol = 0;
226746 pIter->eType = 0; /* Invalid value */
226753 static void rbuObjIterClearStatements(RbuObjIter *pIter){
226756 sqlite3_finalize(pIter->pSelect);
226757 sqlite3_finalize(pIter->pInsert);
226758 sqlite3_finalize(pIter->pDelete);
226759 sqlite3_finalize(pIter->pTmpInsert);
226760 pUp = pIter->pRbuUpdate;
226767 sqlite3_free(pIter->aIdxCol);
226768 sqlite3_free(pIter->zIdxSql);
226770 pIter->pSelect = 0;
226771 pIter->pInsert = 0;
226772 pIter->pDelete = 0;
226773 pIter->pRbuUpdate = 0;
226774 pIter->pTmpInsert = 0;
226775 pIter->nCol = 0;
226776 pIter->nIdxCol = 0;
226777 pIter->aIdxCol = 0;
226778 pIter->zIdxSql = 0;
226785 static void rbuObjIterFinalize(RbuObjIter *pIter){
226786 rbuObjIterClearStatements(pIter);
226787 sqlite3_finalize(pIter->pTblIter);
226788 sqlite3_finalize(pIter->pIdxIter);
226789 rbuObjIterFreeCols(pIter);
226790 memset(pIter, 0, sizeof(RbuObjIter));
226801 static int rbuObjIterNext(sqlite3rbu *p, RbuObjIter *pIter){
226806 rbuObjIterClearStatements(pIter);
226807 if( pIter->zIdx==0 ){
226818 if( pIter->bCleanup ){
226819 rbuObjIterFreeCols(pIter);
226820 pIter->bCleanup = 0;
226821 rc = sqlite3_step(pIter->pTblIter);
226823 rc = resetAndCollectError(pIter->pTblIter, &p->zErrmsg);
226824 pIter->zTbl = 0;
226825 pIter->zDataTbl = 0;
226827 pIter->zTbl = (const char*)sqlite3_column_text(pIter->pTblIter, 0);
226828 pIter->zDataTbl = (const char*)sqlite3_column_text(pIter->pTblIter,1);
226829 rc = (pIter->zDataTbl && pIter->zTbl) ? SQLITE_OK : SQLITE_NOMEM;
226832 if( pIter->zIdx==0 ){
226833 sqlite3_stmt *pIdx = pIter->pIdxIter;
226834 rc = sqlite3_bind_text(pIdx, 1, pIter->zTbl, -1, SQLITE_STATIC);
226837 rc = sqlite3_step(pIter->pIdxIter);
226839 rc = resetAndCollectError(pIter->pIdxIter, &p->zErrmsg);
226840 pIter->bCleanup = 1;
226841 pIter->zIdx = 0;
226843 pIter->zIdx = (const char*)sqlite3_column_text(pIter->pIdxIter, 0);
226844 pIter->iTnum = sqlite3_column_int(pIter->pIdxIter, 1);
226845 pIter->bUnique = sqlite3_column_int(pIter->pIdxIter, 2);
226846 rc = pIter->zIdx ? SQLITE_OK : SQLITE_NOMEM;
226854 rbuObjIterFinalize(pIter);
226918 static int rbuObjIterFirst(sqlite3rbu *p, RbuObjIter *pIter){
226920 memset(pIter, 0, sizeof(RbuObjIter));
226922 rc = prepareFreeAndCollectError(p->dbRbu, &pIter->pTblIter, &p->zErrmsg,
226932 rc = prepareAndCollectError(p->dbMain, &pIter->pIdxIter, &p->zErrmsg,
226939 pIter->bCleanup = 1;
226941 return rbuObjIterNext(p, pIter);
227021 ** Allocate and zero the pIter->azTblCol[] and abTblPk[] arrays so that
227025 static void rbuAllocateIterArrays(sqlite3rbu *p, RbuObjIter *pIter, int nCol){
227031 pIter->azTblCol = azNew;
227032 pIter->azTblType = &azNew[nCol];
227033 pIter->aiSrcOrder = (int*)&pIter->azTblType[nCol];
227034 pIter->abTblPk = (u8*)&pIter->aiSrcOrder[nCol];
227035 pIter->abNotNull = (u8*)&pIter->abTblPk[nCol];
227036 pIter->abIndexed = (u8*)&pIter->abNotNull[nCol];
227207 ** the pIter->abIndexed[] array.
227209 static void rbuObjIterCacheIndexedCols(sqlite3rbu *p, RbuObjIter *pIter){
227214 memcpy(pIter->abIndexed, pIter->abTblPk, sizeof(u8)*pIter->nTblCol);
227216 sqlite3_mprintf("PRAGMA main.index_list = %Q", pIter->zTbl)
227220 pIter->nIndex = 0;
227227 memset(pIter->abIndexed, 0x01, sizeof(u8)*pIter->nTblCol);
227234 if( iCid>=0 ) pIter->abIndexed[iCid] = 1;
227236 memset(pIter->abIndexed, 0x01, sizeof(u8)*pIter->nTblCol);
227241 pIter->nIndex++;
227244 if( pIter->eType==RBU_PK_WITHOUT_ROWID ){
227246 pIter->nIndex--;
227250 if( bIndex==0 ) pIter->abIndexed = 0;
227255 ** If they are not already populated, populate the pIter->azTblCol[],
227256 ** pIter->abTblPk[], pIter->nTblCol and pIter->bRowid variables according to
227263 static int rbuObjIterCacheTableInfo(sqlite3rbu *p, RbuObjIter *pIter){
227264 if( pIter->azTblCol==0 ){
227273 assert( pIter->eType==0 );
227274 rbuTableType(p, pIter->zTbl, &pIter->eType, &iTnum, &pIter->iPkTnum);
227275 if( p->rc==SQLITE_OK && pIter->eType==RBU_PK_NOTABLE ){
227277 p->zErrmsg = sqlite3_mprintf("no such table: %s", pIter->zTbl);
227280 if( pIter->zIdx==0 ) pIter->iTnum = iTnum;
227282 assert( pIter->eType==RBU_PK_NONE || pIter->eType==RBU_PK_IPK
227283 || pIter->eType==RBU_PK_EXTERNAL || pIter->eType==RBU_PK_WITHOUT_ROWID
227284 || pIter->eType==RBU_PK_VTAB
227291 sqlite3_mprintf("SELECT * FROM '%q'", pIter->zDataTbl)
227295 rbuAllocateIterArrays(p, pIter, nCol);
227301 pIter->aiSrcOrder[pIter->nTblCol] = pIter->nTblCol;
227302 pIter->azTblCol[pIter->nTblCol++] = zCopy;
227313 && bRbuRowid!=(pIter->eType==RBU_PK_VTAB || pIter->eType==RBU_PK_NONE)
227317 "table %q %s rbu_rowid column", pIter->zDataTbl,
227327 sqlite3_mprintf("PRAGMA table_info(%Q)", pIter->zTbl)
227333 for(i=iOrder; i<pIter->nTblCol; i++){
227334 if( 0==strcmp(zName, pIter->azTblCol[i]) ) break;
227336 if( i==pIter->nTblCol ){
227339 pIter->zDataTbl, zName
227347 SWAP(int, pIter->aiSrcOrder[i], pIter->aiSrcOrder[iOrder]);
227348 SWAP(char*, pIter->azTblCol[i], pIter->azTblCol[iOrder]);
227351 pIter->azTblType[iOrder] = rbuStrndup(zType, &p->rc);
227353 pIter->abTblPk[iOrder] = (u8)iPk;
227354 pIter->abNotNull[iOrder] = (u8)bNotNull || (iPk!=0);
227360 rbuObjIterCacheIndexedCols(p, pIter);
227361 assert( pIter->eType!=RBU_PK_VTAB || pIter->abIndexed==0 );
227362 assert( pIter->eType!=RBU_PK_VTAB || pIter->nIndex==0 );
227371 ** column names currently stored in the pIter->azTblCol[] array.
227375 RbuObjIter *pIter /* Object iterator for column names */
227380 for(i=0; i<pIter->nTblCol; i++){
227381 const char *z = pIter->azTblCol[i];
227396 RbuObjIter *pIter, /* Object iterator for column names */
227406 for(i=0; i<pIter->nTblCol; i++){
227407 if( (int)pIter->abTblPk[i]==iPk ){
227408 const char *zCol = pIter->azTblCol[i];
227414 if( i==pIter->nTblCol ) break;
227441 RbuObjIter *pIter, /* RBU iterator object */
227450 "SELECT max(_rowid_) FROM \"%s%w\"", zWrite, pIter->zTbl
227459 char *zOrder = rbuObjIterGetPkList(p, pIter, "", ", ", " DESC");
227460 char *zSelect = rbuObjIterGetPkList(p, pIter, "quote(", "||','||", ")");
227461 char *zList = rbuObjIterGetPkList(p, pIter, "", ", ", "");
227467 zSelect, zWrite, pIter->zTbl, zOrder
227508 RbuObjIter *pIter /* RBU iterator object */
227521 sqlite3_mprintf("PRAGMA main.index_xinfo = %Q", pIter->zIdx)
227533 if( pIter->eType==RBU_PK_IPK ){
227535 for(i=0; pIter->abTblPk[i]==0; i++);
227536 assert( i<pIter->nTblCol );
227537 zCol = pIter->azTblCol[i];
227542 zCol = pIter->azTblCol[iCid];
227565 zSelect, pIter->zTbl, zOrder
227570 for(iCol=0; iCol<pIter->nCol; iCol++){
227623 RbuObjIter *pIter, /* Object iterator for column names */
227643 sqlite3_mprintf("PRAGMA main.index_xinfo = %Q", pIter->zIdx)
227657 pIter->aIdxCol[iSeq].nSpan, pIter->aIdxCol[iSeq].zSpan, zCollate
227664 if( pIter->eType==RBU_PK_IPK ){
227666 for(i=0; pIter->abTblPk[i]==0; i++);
227667 assert( i<pIter->nTblCol );
227668 zCol = pIter->azTblCol[i];
227676 zCol = pIter->azTblCol[iCid];
227677 zType = pIter->azTblType[iCid];
227682 if( pIter->bUnique==0 || sqlite3_column_int(pXInfo, 5) ){
227735 RbuObjIter *pIter,
227739 if( p->rc==SQLITE_OK && pIter->abIndexed ){
227742 for(i=0; i<pIter->nTblCol; i++){
227743 if( pIter->abIndexed[i] ){
227744 const char *zCol = pIter->azTblCol[i];
227757 if( pIter->eType==RBU_PK_EXTERNAL || pIter->eType==RBU_PK_NONE ){
227776 RbuObjIter *pIter
227779 if( pIter->eType==RBU_PK_VTAB || pIter->eType==RBU_PK_NONE ){
227780 zList = rbuMPrintf(p, "_rowid_ = ?%d", pIter->nTblCol+1);
227781 }else if( pIter->eType==RBU_PK_EXTERNAL ){
227784 for(i=0; i<pIter->nTblCol; i++){
227785 if( pIter->abTblPk[i] ){
227797 for(i=0; i<pIter->nTblCol; i++){
227798 if( pIter->abTblPk[i] ){
227799 const char *zCol = pIter->azTblCol[i];
227840 RbuObjIter *pIter,
227847 if( (int)strlen(zMask)!=pIter->nTblCol ){
227851 for(i=0; i<pIter->nTblCol; i++){
227852 char c = zMask[pIter->aiSrcOrder[i]];
227855 zList, zSep, pIter->azTblCol[i], i+1
227861 zList, zSep, pIter->azTblCol[i], pIter->azTblCol[i], i+1
227867 zList, zSep, pIter->azTblCol[i], pIter->azTblCol[i], i+1
227919 static char *rbuWithoutRowidPK(sqlite3rbu *p, RbuObjIter *pIter){
227921 assert( pIter->zIdx==0 );
227924 sqlite3_stmt *pXList = 0; /* PRAGMA index_list = (pIter->zTbl) */
227928 sqlite3_mprintf("PRAGMA main.index_list = %Q", pIter->zTbl)
227978 static void rbuCreateImposterTable2(sqlite3rbu *p, RbuObjIter *pIter){
227979 if( p->rc==SQLITE_OK && pIter->eType==RBU_PK_EXTERNAL ){
227980 int tnum = pIter->iPkTnum; /* Root page of PK index */
228014 iCid, pIter->azTblType[iCid], zCollate
228052 static void rbuCreateImposterTable(sqlite3rbu *p, RbuObjIter *pIter){
228053 if( p->rc==SQLITE_OK && pIter->eType!=RBU_PK_VTAB ){
228054 int tnum = pIter->iTnum;
228060 for(iCol=0; p->rc==SQLITE_OK && iCol<pIter->nTblCol; iCol++){
228062 const char *zCol = pIter->azTblCol[iCol];
228066 p->dbMain, "main", pIter->zTbl, zCol, 0, &zColl, 0, 0, 0
228069 if( pIter->eType==RBU_PK_IPK && pIter->abTblPk[iCol] ){
228075 zSql, zComma, zCol, pIter->azTblType[iCol], zPk, zColl,
228076 (pIter->abNotNull[iCol] ? " NOT NULL" : "")
228081 if( pIter->eType==RBU_PK_WITHOUT_ROWID ){
228082 char *zPk = rbuWithoutRowidPK(p, pIter);
228090 pIter->zTbl, zSql,
228091 (pIter->eType==RBU_PK_WITHOUT_ROWID ? " WITHOUT ROWID" : "")
228110 RbuObjIter *pIter,
228114 int bRbuRowid = (pIter->eType==RBU_PK_EXTERNAL || pIter->eType==RBU_PK_NONE);
228115 char *zBind = rbuObjIterGetBindlist(p, pIter->nTblCol + 1 + bRbuRowid);
228117 assert( pIter->pTmpInsert==0 );
228119 p->dbRbu, &pIter->pTmpInsert, &p->zErrmsg, sqlite3_mprintf(
228121 p->zStateDb, pIter->zDataTbl, zCollist, zRbuRowid, zBind
228156 static char *rbuObjIterGetIndexWhere(sqlite3rbu *p, RbuObjIter *pIter){
228161 assert( pIter->zIdxSql==0 && pIter->nIdxCol==0 && pIter->aIdxCol==0 );
228170 rc = sqlite3_bind_text(pStmt, 1, pIter->zIdx, -1, SQLITE_STATIC);
228174 pIter->zIdxSql = zSql = rbuStrndup(zSql, &rc);
228184 /* If necessary, grow the pIter->aIdxCol[] array */
228187 pIter->aIdxCol, nIdxAlloc*sizeof(RbuSpan) + 16*sizeof(RbuSpan)
228193 pIter->aIdxCol = aIdxCol;
228200 pIter->aIdxCol[0].zSpan = &zSql[i+1];
228207 int nSpan = (int)(&zSql[i] - pIter->aIdxCol[iIdxCol].zSpan);
228208 pIter->aIdxCol[iIdxCol++].nSpan = nSpan;
228213 int nSpan = (int)(&zSql[i] - pIter->aIdxCol[iIdxCol].zSpan);
228214 pIter->aIdxCol[iIdxCol++].nSpan = nSpan;
228215 pIter->aIdxCol[iIdxCol].zSpan = &zSql[i+1];
228239 pIter->nIdxCol = iIdxCol;
228258 RbuObjIter *pIter,
228261 assert( pIter->bCleanup==0 );
228262 if( pIter->pSelect==0 && rbuObjIterCacheTableInfo(p, pIter)==SQLITE_OK ){
228263 const int tnum = pIter->iTnum;
228266 const char *zIdx = pIter->zIdx;
228275 const char *zTbl = pIter->zTbl;
228283 assert( pIter->eType!=RBU_PK_VTAB );
228284 zPart = rbuObjIterGetIndexWhere(p, pIter);
228286 p, pIter, &zImposterCols, &zImposterPK, &zWhere, &nBind
228300 pIter->nCol = nBind;
228303 p->dbMain, &pIter->pInsert, &p->zErrmsg,
228311 p->dbMain, &pIter->pDelete, &p->zErrmsg,
228322 zStart = rbuVacuumIndexStart(p, pIter);
228332 pIter->zDataTbl,
228340 if( pIter->eType==RBU_PK_EXTERNAL || pIter->eType==RBU_PK_NONE ){
228343 zCollist, p->zStateDb, pIter->zDataTbl,
228353 zCollist, p->zStateDb, pIter->zDataTbl, zPart,
228354 zCollist, pIter->zDataTbl,
228361 p->rc = prepareFreeAndCollectError(p->dbRbu,&pIter->pSelect,pz,zSql);
228373 int bRbuRowid = (pIter->eType==RBU_PK_VTAB)
228374 ||(pIter->eType==RBU_PK_NONE)
228375 ||(pIter->eType==RBU_PK_EXTERNAL && rbuIsVacuum(p));
228376 const char *zTbl = pIter->zTbl; /* Table this step applies to */
228379 char *zBindings = rbuObjIterGetBindlist(p, pIter->nTblCol + bRbuRowid);
228380 char *zWhere = rbuObjIterGetWhere(p, pIter);
228381 char *zOldlist = rbuObjIterGetOldlist(p, pIter, "old");
228382 char *zNewlist = rbuObjIterGetOldlist(p, pIter, "new");
228384 zCollist = rbuObjIterGetCollist(p, pIter);
228385 pIter->nCol = pIter->nTblCol;
228388 rbuCreateImposterTable(p, pIter);
228389 rbuCreateImposterTable2(p, pIter);
228390 zWrite = (pIter->eType==RBU_PK_VTAB ? "" : "rbu_imp_");
228394 p->rc = prepareFreeAndCollectError(p->dbMain, &pIter->pInsert, pz,
228406 p->rc = prepareFreeAndCollectError(p->dbMain, &pIter->pDelete, pz,
228413 if( rbuIsVacuum(p)==0 && pIter->abIndexed ){
228415 if( pIter->eType==RBU_PK_EXTERNAL || pIter->eType==RBU_PK_NONE ){
228423 , p->zStateDb, pIter->zDataTbl
228424 , (pIter->eType==RBU_PK_EXTERNAL ? ", 0 AS rbu_rowid" : "")
228425 , pIter->zDataTbl
228448 if( pIter->eType==RBU_PK_EXTERNAL || pIter->eType==RBU_PK_NONE ){
228458 rbuObjIterPrepareTmpInsert(p, pIter, zCollist, zRbuRowid);
228472 zStart = rbuVacuumTableStart(p, pIter, bRbuRowid, zWrite);
228481 zOrder = rbuObjIterGetPkList(p, pIter, "", ", ", "");
228486 p->rc = prepareFreeAndCollectError(p->dbRbu, &pIter->pSelect, pz,
228492 pIter->zDataTbl, (zStart ? zStart : ""),
228517 ** table object that pIter currently points to, assuming that the
228525 RbuObjIter *pIter, /* Object iterator */
228540 for(pp=&pIter->pRbuUpdate; *pp; pp=&((*pp)->pNext)){
228544 pUp->pNext = pIter->pRbuUpdate;
228545 pIter->pRbuUpdate = pUp;
228554 for(pp=&pIter->pRbuUpdate; *pp!=pUp; pp=&((*pp)->pNext));
228559 pUp = (RbuUpdateStmt*)rbuMalloc(p, sizeof(RbuUpdateStmt)+pIter->nTblCol+1);
228563 char *zWhere = rbuObjIterGetWhere(p, pIter);
228564 char *zSet = rbuObjIterGetSetlist(p, pIter, zMask);
228568 memcpy(pUp->zMask, zMask, pIter->nTblCol);
228569 pUp->pNext = pIter->pRbuUpdate;
228570 pIter->pRbuUpdate = pUp;
228575 if( pIter->eType!=RBU_PK_VTAB ) zPrefix = "rbu_imp_";
228577 zPrefix, pIter->zTbl, zSet, zWhere
229297 RbuObjIter *pIter = &p->objiter;
229303 assert( eType!=RBU_DELETE || pIter->zIdx==0 );
229317 pWriter = pIter->pDelete;
229319 pWriter = pIter->pInsert;
229322 for(i=0; i<pIter->nCol; i++){
229327 && pIter->zIdx==0 && pIter->eType==RBU_PK_IPK && pIter->abTblPk[i]
229328 && sqlite3_column_type(pIter->pSelect, i)==SQLITE_NULL
229335 if( eType==RBU_DELETE && pIter->abTblPk[i]==0 ){
229339 pVal = sqlite3_column_value(pIter->pSelect, i);
229343 if( pIter->zIdx==0 ){
229344 if( pIter->eType==RBU_PK_VTAB
229345 || pIter->eType==RBU_PK_NONE
229346 || (pIter->eType==RBU_PK_EXTERNAL && rbuIsVacuum(p))
229353 ** Hence column_value(pIter->nCol+1).
229355 assertColumnName(pIter->pSelect, pIter->nCol+1,
229358 pVal = sqlite3_column_value(pIter->pSelect, pIter->nCol+1);
229359 p->rc = sqlite3_bind_value(pWriter, pIter->nCol+1, pVal);
229380 RbuObjIter *pIter = &p->objiter;
229389 assert( eType!=RBU_UPDATE || pIter->zIdx==0 );
229391 if( pIter->zIdx==0 && (eType==RBU_IDX_DELETE || eType==RBU_IDX_INSERT) ){
229395 if( pIter->zIdx==0 ){
229409 rbuGetUpdateStmt(p, pIter, zMask, &pUpdate);
229412 for(i=0; p->rc==SQLITE_OK && i<pIter->nCol; i++){
229413 char c = zMask[pIter->aiSrcOrder[i]];
229414 pVal = sqlite3_column_value(pIter->pSelect, i);
229415 if( pIter->abTblPk[i] || c!='.' ){
229420 && (pIter->eType==RBU_PK_VTAB || pIter->eType==RBU_PK_NONE)
229423 assertColumnName(pIter->pSelect, pIter->nCol+1, "rbu_rowid");
229424 pVal = sqlite3_column_value(pIter->pSelect, pIter->nCol+1);
229425 p->rc = sqlite3_bind_value(pUpdate, pIter->nCol+1, pVal);
229612 RbuObjIter *pIter = &p->objiter;
229622 while( p->rc==SQLITE_OK && pIter->zTbl ){
229624 if( pIter->bCleanup ){
229628 if( rbuIsVacuum(p)==0 && pIter->abIndexed ){
229630 "DELETE FROM %s.'rbu_tmp_%q'", p->zStateDb, pIter->zDataTbl
229634 rbuObjIterPrepareAll(p, pIter, 0);
229638 int rc = sqlite3_step(pIter->pSelect);
229644 p->rc = sqlite3_reset(pIter->pSelect);
229649 rbuObjIterNext(p, pIter);
229653 assert( pIter->zTbl==0 );
229756 RbuObjIter *pIter = &p->objiter;
229759 while( rc==SQLITE_OK && pIter->zTbl && (pIter->bCleanup
229760 || rbuStrCompare(pIter->zIdx, pState->zIdx)
229761 || (pState->zDataTbl==0 && rbuStrCompare(pIter->zTbl, pState->zTbl))
229762 || (pState->zDataTbl && rbuStrCompare(pIter->zDataTbl, pState->zDataTbl))
229764 rc = rbuObjIterNext(p, pIter);
229767 if( rc==SQLITE_OK && !pIter->zTbl ){
230479 rbu_file *pIter;
230483 for(pIter=pRbuVfs->pMain; pIter; pIter=pIter->pMainNext);
230487 for(pIter=pRbuVfs->pMainRbu; pIter && pIter!=p; pIter=pIter->pMainRbuNext){}
230488 if( pIter==0 ){
237304 sqlite3_changeset_iter *pIter, /* Iterator handle */
237310 *pOp = pIter->op;
237311 *pnCol = pIter->nCol;
237312 *pzTab = pIter->zTab;
237313 if( pbIndirect ) *pbIndirect = pIter->bIndirect;
237319 ** the database table affected by the change that pIter currently points
237324 sqlite3_changeset_iter *pIter, /* Iterator object */
237328 *pabPK = pIter->abPK;
237329 if( pnCol ) *pnCol = pIter->nCol;
237347 sqlite3_changeset_iter *pIter, /* Changeset iterator */
237351 if( pIter->op!=SQLITE_UPDATE && pIter->op!=SQLITE_DELETE ){
237354 if( iVal<0 || iVal>=pIter->nCol ){
237357 *ppValue = pIter->apValue[iVal];
237375 sqlite3_changeset_iter *pIter, /* Changeset iterator */
237379 if( pIter->op!=SQLITE_UPDATE && pIter->op!=SQLITE_INSERT ){
237382 if( iVal<0 || iVal>=pIter->nCol ){
237385 *ppValue = pIter->apValue[pIter->nCol+iVal];
237394 #define sessionChangesetNew(pIter, iVal) (pIter)->apValue[(pIter)->nCol+(iVal)]
237395 #define sessionChangesetOld(pIter, iVal) (pIter)->apValue[(iVal)]
237409 sqlite3_changeset_iter *pIter, /* Changeset iterator */
237413 if( !pIter->pConflict ){
237416 if( iVal<0 || iVal>=pIter->nCol ){
237419 *ppValue = sqlite3_column_value(pIter->pConflict, iVal);
237432 sqlite3_changeset_iter *pIter, /* Changeset iterator */
237435 if( pIter->pConflict || pIter->apValue ){
237438 *pnOut = pIter->nCol;
237702 sqlite3_changeset_iter *pIter,
237709 int nCol = pIter->nCol;
237710 int nU32 = (pIter->nCol+33)/32;
237723 for(ii=0; ii<pIter->nCol; ii++){
237724 if( sessionChangesetNew(pIter, ii) ){
237762 int bStat1 = (sqlite3_stricmp(pIter->zTab, "sqlite_stat1")==0);
237775 sessionAppendIdent(&buf, pIter->zTab, &rc);
237779 for(ii=0; ii<pIter->nCol; ii++){
237780 if( p->abPK[ii]==0 && sessionChangesetNew(pIter, ii) ){
237792 for(ii=0; ii<pIter->nCol; ii++){
237793 if( p->abPK[ii] || (bPatchset==0 && sessionChangesetOld(pIter, ii)) ){
238034 ** Iterator pIter must point to an SQLITE_INSERT entry. This function
238048 sqlite3_changeset_iter *pIter, /* Iterator to read values from */
238066 (void)xValue(pIter, i, &pVal);
238082 ** iterator pIter points to to the SELECT and attempts to seek to the table
238097 sqlite3_changeset_iter *pIter, /* Changeset iterator */
238107 sqlite3changeset_op(pIter, &zDummy, &nCol, &op, 0);
238108 rc = sessionBindRow(pIter,
238118 sqlite3changeset_new(pIter, ii, &pVal);
238146 sqlite3_changeset_iter *pIter /* Iterator pointing at current change */
238151 int eOp = pIter->op;
238154 const char *zTab = pIter->zTab;
238172 sqlite3changeset_old(pIter, i, &pVal);
238174 sqlite3changeset_new(pIter, i, &pVal);
238220 sqlite3_changeset_iter *pIter, /* Changeset iterator */
238231 sqlite3changeset_op(pIter, &zDummy, &nCol, &op, 0);
238239 rc = sessionSeekToRow(pIter, p);
238249 pIter->pConflict = p->pSelect;
238250 res = xConflict(pCtx, eType, pIter);
238251 pIter->pConflict = 0;
238258 u8 *aBlob = &pIter->in.aData[pIter->in.iCurrent];
238259 int nBlob = pIter->in.iNext - pIter->in.iCurrent;
238266 res = xConflict(pCtx, eType+1, pIter);
238290 rc = sessionRebaseAdd(p, res, pIter);
238322 sqlite3_changeset_iter *pIter, /* Changeset iterator */
238338 sqlite3changeset_op(pIter, &zDummy, &nCol, &op, 0);
238353 u8 *abPK = (pIter->bPatchset ? p->abPK : 0);
238354 rc = sessionBindRow(pIter, sqlite3changeset_old, nCol, abPK, p->pDelete);
238364 SQLITE_CHANGESET_DATA, p, pIter, xConflict, pCtx, pbRetry
238368 SQLITE_CHANGESET_CONFLICT, p, pIter, xConflict, pCtx, 0
238375 int bPatchset = (pbRetry==0 || pIter->bPatchset);
238377 rc = sessionUpdateFind(pIter, p, bPatchset, &pUp);
238381 sqlite3_value *pOld = sessionChangesetOld(pIter, i);
238382 sqlite3_value *pNew = sessionChangesetNew(pIter, i);
238403 SQLITE_CHANGESET_DATA, p, pIter, xConflict, pCtx, pbRetry
238409 SQLITE_CHANGESET_CONFLICT, p, pIter, xConflict, pCtx, 0
238419 rc = sessionSeekToRow(pIter, p);
238427 rc = sessionBindRow(pIter, sqlite3changeset_new, nCol, 0, p->pInsert);
238436 SQLITE_CHANGESET_CONFLICT, p, pIter, xConflict, pCtx, pbReplace
238456 sqlite3_changeset_iter *pIter, /* Changeset iterator to read change from */
238465 rc = sessionApplyOneOp(pIter, pApply, xConflict, pCtx, &bReplace, &bRetry);
238475 assert( pIter->op==SQLITE_UPDATE || pIter->op==SQLITE_DELETE );
238476 rc = sessionApplyOneOp(pIter, pApply, xConflict, pCtx, 0, 0);
238485 assert( pIter->op==SQLITE_INSERT );
238488 rc = sessionBindRow(pIter,
238497 rc = sessionApplyOneOp(pIter, pApply, xConflict, pCtx, 0, 0);
238561 ** Argument pIter is a changeset iterator that has been initialized, but
238569 sqlite3_changeset_iter *pIter, /* Changeset to apply */
238603 pIter->in.bNoDiscard = 1;
238614 while( rc==SQLITE_OK && SQLITE_ROW==sqlite3changeset_next(pIter) ){
238619 sqlite3changeset_op(pIter, &zNew, &nCol, &op, 0);
238625 db, pIter->bPatchset, zTab, &sApply, xConflict, pCtx
238663 sqlite3changeset_pk(pIter, &abPK, 0);
238719 if( xFilterIter && 0==xFilterIter(pCtx, pIter) ) continue;
238721 rc = sessionApplyOneWithRetry(db, pIter, &sApply, xConflict, pCtx);
238724 bPatchset = pIter->bPatchset;
238726 rc = sqlite3changeset_finalize(pIter);
238728 sqlite3changeset_finalize(pIter);
238862 sqlite3_changeset_iter *pIter; /* Iterator to skip through changeset */
238865 &pIter, xInput, pIn, nChangeset, pChangeset, bInverse, 1
238868 rc = sessionChangesetApply(db, pIter,
239361 ** change currently pointed to by iterator pIter to changegroup pGrp.
239369 sqlite3_changeset_iter *pIter,
239386 if( pIter ){
239387 sqlite3changeset_pk(pIter, &abPK, &nCol);
239428 if( pIter && !sessionChangesetCheckCompat(pTab, nCol, abPK) ){
239506 ** Add the change currently indicated by iterator pIter to the hash table
239511 sqlite3_changeset_iter *pIter,
239514 u8 *aRec = &pIter->in.aData[pIter->in.iCurrent + 2];
239515 int nRec = (pIter->in.iNext - pIter->in.iCurrent) - 2;
239527 pGrp->bPatch = pIter->bPatchset;
239528 }else if( pIter->bPatchset!=pGrp->bPatch ){
239533 sqlite3changeset_op(pIter, &zTab, &nCol, &op, &bIndirect);
239534 rc = sessionChangesetFindTable(pGrp, zTab, pIter, &pTab);
239543 if( rc==SQLITE_OK ) rc = pIter->rc;
239552 sqlite3_changeset_iter *pIter, /* Iterator to read from */
239560 pIter->in.bNoDiscard = 1;
239561 while( SQLITE_ROW==(sessionChangesetNext(pIter, &aRec, &nRec, 0)) ){
239562 rc = sessionOneChangeIterToHash(pGrp, pIter, bRebase);
239566 if( rc==SQLITE_OK ) rc = pIter->rc;
239709 sqlite3_changeset_iter *pIter; /* Iterator opened on pData/nData */
239712 rc = sqlite3changeset_start(&pIter, nData, pData);
239714 rc = sessionChangesetToHash(pIter, pGrp, 0);
239716 sqlite3changeset_finalize(pIter);
239725 sqlite3_changeset_iter *pIter
239729 if( pIter->in.iCurrent==pIter->in.iNext
239730 || pIter->rc!=SQLITE_OK
239731 || pIter->bInvert
239736 pIter->in.bNoDiscard = 1;
239737 rc = sessionOneChangeIterToHash(pGrp, pIter, 0);
239762 sqlite3_changeset_iter *pIter; /* Iterator opened on pData/nData */
239765 rc = sqlite3changeset_start_strm(&pIter, xInput, pIn);
239767 rc = sessionChangesetToHash(pIter, pGrp, 0);
239769 sqlite3changeset_finalize(pIter);
239924 sqlite3_changeset_iter *pIter, /* Iterator pointed at local change */
239938 *pOut++ = pIter->bIndirect;
239939 for(i=0; i<pIter->nCol; i++){
239942 if( pIter->abPK[i] || a2[0]==0 ){
239943 if( !pIter->abPK[i] && a1[0] ) bData = 1;
239958 for(i=0; i<pIter->nCol; i++){
239961 if( pIter->abPK[i] || a2[0]!=0xFF ){
239976 ** pIter is configured to iterate through a changeset. This function rebases
239992 sqlite3_changeset_iter *pIter, /* Input data */
240005 while( SQLITE_ROW==sessionChangesetNext(pIter, &aRec, &nRec, &bNew) ){
240010 const char *zTab = pIter->zTab;
240017 if( pIter->bPatchset ){
240022 sessionAppendByte(&sOut, pIter->bPatchset ? 'P' : 'T', &rc);
240023 sessionAppendVarint(&sOut, pIter->nCol, &rc);
240024 sessionAppendBlob(&sOut, pIter->abPK, pIter->nCol, &rc);
240025 sessionAppendBlob(&sOut,(u8*)pIter->zTab,(int)strlen(pIter->zTab)+1,&rc);
240040 switch( pIter->op ){
240046 sessionAppendByte(&sOut, pIter->bIndirect, &rc);
240058 sessionSkipRecord(&pCsr, pIter->nCol);
240060 sessionAppendByte(&sOut, pIter->bIndirect, &rc);
240061 sessionAppendRecordMerge(&sOut, pIter->nCol,
240067 sessionAppendPartialUpdate(&sOut, pIter,
240074 assert( pIter->op==SQLITE_DELETE );
240078 sessionAppendByte(&sOut, pIter->bIndirect, &rc);
240079 sessionAppendRecordMerge(&sOut, pIter->nCol,
240088 sessionAppendByte(&sOut, pIter->op, &rc);
240089 sessionAppendByte(&sOut, pIter->bIndirect, &rc);
240143 sqlite3_changeset_iter *pIter = 0; /* Iterator opened on pData/nData */
240145 rc = sqlite3changeset_start(&pIter, nRebase, (void*)pRebase);
240147 rc = sessionChangesetToHash(pIter, &p->grp, 1);
240149 sqlite3changeset_finalize(pIter);
240161 sqlite3_changeset_iter *pIter = 0; /* Iterator to skip through input */
240162 int rc = sqlite3changeset_start(&pIter, nIn, (void*)pIn);
240165 rc = sessionRebase(p, pIter, 0, 0, pnOut, ppOut);
240166 sqlite3changeset_finalize(pIter);
240182 sqlite3_changeset_iter *pIter = 0; /* Iterator to skip through input */
240183 int rc = sqlite3changeset_start_strm(&pIter, xInput, pIn);
240186 rc = sessionRebase(p, pIter, xOutput, pOut, 0, 0);
240187 sqlite3changeset_finalize(pIter);
241724 Fts5PoslistReader *pIter /* Iterator object to initialize */
243894 static int fts5CInstIterNext(CInstIter *pIter){
243896 pIter->iStart = -1;
243897 pIter->iEnd = -1;
243899 while( rc==SQLITE_OK && pIter->iInst<pIter->nInst ){
243901 rc = pIter->pApi->xInst(pIter->pFts, pIter->iInst, &ip, &ic, &io);
243903 if( ic==pIter->iCol ){
243904 int iEnd = io - 1 + pIter->pApi->xPhraseSize(pIter->pFts, ip);
243905 if( pIter->iStart<0 ){
243906 pIter->iStart = io;
243907 pIter->iEnd = iEnd;
243908 }else if( io<=pIter->iEnd ){
243909 if( iEnd>pIter->iEnd ) pIter->iEnd = iEnd;
243914 pIter->iInst++;
243929 CInstIter *pIter
243933 memset(pIter, 0, sizeof(CInstIter));
243934 pIter->pApi = pApi;
243935 pIter->pFts = pFts;
243936 pIter->iCol = iCol;
243937 rc = pApi->xInstCount(pFts, &pIter->nInst);
243940 rc = fts5CInstIterNext(pIter);
244874 static int sqlite3Fts5PoslistReaderNext(Fts5PoslistReader *pIter){
244875 if( sqlite3Fts5PoslistNext64(pIter->a, pIter->n, &pIter->i, &pIter->iPos) ){
244876 pIter->bEof = 1;
244878 return pIter->bEof;
244883 Fts5PoslistReader *pIter /* Iterator object to initialize */
244885 memset(pIter, 0, sizeof(*pIter));
244886 pIter->a = a;
244887 pIter->n = n;
244888 sqlite3Fts5PoslistReaderNext(pIter);
244889 return pIter->bEof;
246314 Fts5IndexIter *pIter; /* Iterator for this term */
246706 if( 0==sqlite3Fts5IterEof(p->pIter) ){
246707 i64 iRowid = p->pIter->iRowid;
246737 Fts5IndexIter *pIter = p->pIter;
246738 if( sqlite3Fts5IterEof(pIter)==0 && pIter->iRowid==iRowid ){
246739 if( pIter->nData==0 ) continue;
246752 sqlite3Fts5PoslistReaderInit(pIter->pData, pIter->nData, &aIter[nIter]);
246843 a = (u8*)pTerm->pIter->pData;
246844 n = pTerm->pIter->nData;
247034 ** Advance iterator pIter until it points to a value equal to or laster
247043 Fts5IndexIter *pIter, /* Iterator to advance */
247052 iRowid = pIter->iRowid;
247054 int rc = sqlite3Fts5IterNextFrom(pIter, iLast);
247055 if( rc || sqlite3Fts5IterEof(pIter) ){
247060 iRowid = pIter->iRowid;
247080 if( sqlite3Fts5IterEof(p->pIter)==0 ){
247081 i64 iRowid = p->pIter->iRowid;
247083 rc = sqlite3Fts5IterNextFrom(p->pIter, iLast);
247111 Fts5IndexIter *pIter = pTerm->pIter;
247112 if( sqlite3Fts5IterEof(pIter)==0 ){
247113 if( pIter->iRowid==pNode->iRowid && pIter->nData>0 ){
247134 Fts5IndexIter *pIter = pPhrase->aTerm[0].pIter;
247135 fts5BufferSet(&rc, &pPhrase->poslist, pIter->nData, pIter->pData);
247179 if( p->pIter ){
247180 sqlite3Fts5IterClose(p->pIter);
247181 p->pIter = 0;
247188 &p->pIter
247190 assert( (rc==SQLITE_OK)==(p->pIter!=0) );
247192 if( 0==sqlite3Fts5IterEof(p->pIter) ){
247320 iLast = pLeft->aTerm[0].pIter->iRowid;
247339 Fts5IndexIter *pIter = pPhrase->aTerm[j].pIter;
247340 if( pIter->iRowid==iLast ) continue;
247342 if( fts5ExprAdvanceto(pIter, bDesc, &iLast, &rc, &pNode->bEof) ){
247384 if( sqlite3Fts5IterEof(p->pIter)==0 ){
247385 i64 ii = p->pIter->iRowid;
247390 rc = sqlite3Fts5IterNextFrom(p->pIter, iFrom);
247392 rc = sqlite3Fts5IterNext(p->pIter);
247395 if( sqlite3Fts5IterEof(p->pIter)==0 ){
247408 Fts5IndexIter *pIter = pTerm->pIter;
247412 rc = sqlite3Fts5IterNextFrom(pIter, iFrom);
247414 rc = sqlite3Fts5IterNext(pIter);
247417 pNode->bEof = (rc || sqlite3Fts5IterEof(pIter));
247439 Fts5IndexIter *pIter = pPhrase->aTerm[0].pIter;
247445 pPhrase->poslist.n = pIter->nData;
247447 pPhrase->poslist.p = (u8*)pIter->pData;
247449 pNode->iRowid = pIter->iRowid;
247464 Fts5IndexIter *pIter = pNode->pNear->apPhrase[0]->aTerm[0].pIter;
247468 rc = sqlite3Fts5IterNextFrom(pIter, iFrom);
247470 rc = sqlite3Fts5IterNext(pIter);
247472 if( rc==SQLITE_OK && sqlite3Fts5IterEof(pIter)==0 ){
247831 sqlite3Fts5IterClose(pTerm->pIter);
247834 sqlite3Fts5IterClose(pSyn->pIter);
249273 pT->pIter, pToken, nToken, iRowid, iCol, iTokOff
249401 *ppCollist = pPhrase->aTerm[0].pIter->pData;
249402 *pnCollist = pPhrase->aTerm[0].pIter->nData;
249464 pTerm->pIter, pTerm->pTerm, pTerm->nQueryTerm,
249483 sqlite3Fts5IndexIterClearTokendata(pT->pIter);
249951 Fts5HashEntry *pIter;
249952 for(pIter=pHash->aSlot[iSlot]; pIter; pIter=pIter->pHashNext){
249954 || (pIter->nKey>=nTerm && 0==memcmp(fts5EntryKey(pIter), pTerm, nTerm))
249956 Fts5HashEntry *pEntry = pIter;
250645 static int fts5IndexCorruptIter(Fts5Index *pIdx, Fts5SegIter *pIter){
250649 pIter->iLeafPgno, pIter->pSeg->iSegid, pIdx->pConfig->zName
250653 #define FTS5_CORRUPT_ITER(pIdx, pIter) fts5IndexCorruptIter(pIdx, pIter)
251697 static int fts5DlidxIterNextR(Fts5Index *p, Fts5DlidxIter *pIter, int iLvl){
251698 Fts5DlidxLvl *pLvl = &pIter->aLvl[iLvl];
251700 assert( iLvl<pIter->nLvl );
251702 if( (iLvl+1) < pIter->nLvl ){
251703 fts5DlidxIterNextR(p, pIter, iLvl+1);
251708 FTS5_DLIDX_ROWID(pIter->iSegid, iLvl, pLvl[1].iLeafPgno)
251715 return pIter->aLvl[0].bEof;
251717 static int fts5DlidxIterNext(Fts5Index *p, Fts5DlidxIter *pIter){
251718 return fts5DlidxIterNextR(p, pIter, 0);
251729 ** When this function is called pIter->iLeafPgno is the page number the
251732 static int fts5DlidxIterFirst(Fts5DlidxIter *pIter){
251734 for(i=0; i<pIter->nLvl; i++){
251735 fts5DlidxLvlNext(&pIter->aLvl[i]);
251737 return pIter->aLvl[0].bEof;
251741 static int fts5DlidxIterEof(Fts5Index *p, Fts5DlidxIter *pIter){
251742 return p->rc!=SQLITE_OK || pIter->aLvl[0].bEof;
251745 static void fts5DlidxIterLast(Fts5Index *p, Fts5DlidxIter *pIter){
251749 for(i=pIter->nLvl-1; p->rc==SQLITE_OK && i>=0; i--){
251750 Fts5DlidxLvl *pLvl = &pIter->aLvl[i];
251759 FTS5_DLIDX_ROWID(pIter->iSegid, i-1, pLvl->iLeafPgno)
251800 static int fts5DlidxIterPrevR(Fts5Index *p, Fts5DlidxIter *pIter, int iLvl){
251801 Fts5DlidxLvl *pLvl = &pIter->aLvl[iLvl];
251803 assert( iLvl<pIter->nLvl );
251805 if( (iLvl+1) < pIter->nLvl ){
251806 fts5DlidxIterPrevR(p, pIter, iLvl+1);
251811 FTS5_DLIDX_ROWID(pIter->iSegid, iLvl, pLvl[1].iLeafPgno)
251821 return pIter->aLvl[0].bEof;
251823 static int fts5DlidxIterPrev(Fts5Index *p, Fts5DlidxIter *pIter){
251824 return fts5DlidxIterPrevR(p, pIter, 0);
251830 static void fts5DlidxIterFree(Fts5DlidxIter *pIter){
251831 if( pIter ){
251833 for(i=0; i<pIter->nLvl; i++){
251834 fts5DataRelease(pIter->aLvl[i].pData);
251836 sqlite3_free(pIter);
251846 Fts5DlidxIter *pIter = 0;
251854 pNew = (Fts5DlidxIter*)sqlite3_realloc64(pIter, nByte);
251860 pIter = pNew;
251866 pIter->nLvl = i+1;
251871 pIter->iSegid = iSegid;
251873 fts5DlidxIterFirst(pIter);
251875 fts5DlidxIterLast(p, pIter);
251880 fts5DlidxIterFree(pIter);
251881 pIter = 0;
251884 return pIter;
251887 static i64 fts5DlidxIterRowid(Fts5DlidxIter *pIter){
251888 return pIter->aLvl[0].iRowid;
251890 static int fts5DlidxIterPgno(Fts5DlidxIter *pIter){
251891 return pIter->aLvl[0].iLeafPgno;
251899 Fts5SegIter *pIter /* Iterator to advance to next page */
251902 Fts5StructureSegment *pSeg = pIter->pSeg;
251903 fts5DataRelease(pIter->pLeaf);
251904 pIter->iLeafPgno++;
251905 if( pIter->pNextLeaf ){
251906 pIter->pLeaf = pIter->pNextLeaf;
251907 pIter->pNextLeaf = 0;
251908 }else if( pIter->iLeafPgno<=pSeg->pgnoLast ){
251909 pIter->pLeaf = fts5LeafRead(p,
251910 FTS5_SEGMENT_ROWID(pSeg->iSegid, pIter->iLeafPgno)
251913 pIter->pLeaf = 0;
251915 pLeaf = pIter->pLeaf;
251918 pIter->iPgidxOff = pLeaf->szLeaf;
251920 pIter->iEndofDoclist = pLeaf->nn+1;
251922 pIter->iPgidxOff += fts5GetVarint32(&pLeaf->p[pIter->iPgidxOff],
251923 pIter->iEndofDoclist
251956 static void fts5SegIterLoadNPos(Fts5Index *p, Fts5SegIter *pIter){
251958 int iOff = pIter->iLeafOffset; /* Offset to read at */
251959 ASSERT_SZLEAF_OK(pIter->pLeaf);
251961 int iEod = MIN(pIter->iEndofDoclist, pIter->pLeaf->szLeaf);
251962 pIter->bDel = 0;
251963 pIter->nPos = 1;
251964 if( iOff<iEod && pIter->pLeaf->p[iOff]==0 ){
251965 pIter->bDel = 1;
251967 if( iOff<iEod && pIter->pLeaf->p[iOff]==0 ){
251968 pIter->nPos = 1;
251971 pIter->nPos = 0;
251976 fts5FastGetVarint32(pIter->pLeaf->p, iOff, nSz);
251977 pIter->bDel = (nSz & 0x0001);
251978 pIter->nPos = nSz>>1;
251979 assert_nc( pIter->nPos>=0 );
251981 pIter->iLeafOffset = iOff;
251985 static void fts5SegIterLoadRowid(Fts5Index *p, Fts5SegIter *pIter){
251986 u8 *a = pIter->pLeaf->p; /* Buffer to read data from */
251987 i64 iOff = pIter->iLeafOffset;
251989 ASSERT_SZLEAF_OK(pIter->pLeaf);
251990 while( iOff>=pIter->pLeaf->szLeaf ){
251991 fts5SegIterNextPage(p, pIter);
251992 if( pIter->pLeaf==0 ){
251993 if( p->rc==SQLITE_OK ) FTS5_CORRUPT_ITER(p, pIter);
251997 a = pIter->pLeaf->p;
251999 iOff += sqlite3Fts5GetVarint(&a[iOff], (u64*)&pIter->iRowid);
252000 pIter->iLeafOffset = iOff;
252018 static void fts5SegIterLoadTerm(Fts5Index *p, Fts5SegIter *pIter, int nKeep){
252019 u8 *a = pIter->pLeaf->p; /* Buffer to read data from */
252020 i64 iOff = pIter->iLeafOffset; /* Offset to read at */
252024 if( iOff+nNew>pIter->pLeaf->szLeaf || nKeep>pIter->term.n || nNew==0 ){
252025 FTS5_CORRUPT_ITER(p, pIter);
252028 pIter->term.n = nKeep;
252029 fts5BufferAppendBlob(&p->rc, &pIter->term, nNew, &a[iOff]);
252030 assert( pIter->term.n<=pIter->term.nSpace );
252032 pIter->iTermLeafOffset = iOff;
252033 pIter->iTermLeafPgno = pIter->iLeafPgno;
252034 pIter->iLeafOffset = iOff;
252036 if( pIter->iPgidxOff>=pIter->pLeaf->nn ){
252037 pIter->iEndofDoclist = pIter->pLeaf->nn+1;
252040 pIter->iPgidxOff += fts5GetVarint32(&a[pIter->iPgidxOff], nExtra);
252041 pIter->iEndofDoclist += nExtra;
252044 fts5SegIterLoadRowid(p, pIter);
252051 static void fts5SegIterSetNext(Fts5Index *p, Fts5SegIter *pIter){
252052 if( pIter->flags & FTS5_SEGITER_REVERSE ){
252053 pIter->xNext = fts5SegIterNext_Reverse;
252055 pIter->xNext = fts5SegIterNext_None;
252057 pIter->xNext = fts5SegIterNext;
252062 ** Allocate a tombstone hash page array object (pIter->pTombArray) for
252066 static void fts5SegIterAllocTombstone(Fts5Index *p, Fts5SegIter *pIter){
252067 const i64 nTomb = (i64)pIter->pSeg->nPgTombstone;
252075 pIter->pTombArray = pNew;
252081 ** Initialize the iterator object pIter to iterate through the entries in
252091 Fts5SegIter *pIter /* Object to populate */
252097 ** The caller will see the (pIter->pLeaf==0) and assume the iterator is
252099 assert( pIter->pLeaf==0 );
252104 memset(pIter, 0, sizeof(*pIter));
252105 fts5SegIterSetNext(p, pIter);
252106 pIter->pSeg = pSeg;
252107 pIter->iLeafPgno = pSeg->pgnoFirst-1;
252109 fts5SegIterNextPage(p, pIter);
252110 }while( p->rc==SQLITE_OK && pIter->pLeaf && pIter->pLeaf->nn==4 );
252113 if( p->rc==SQLITE_OK && pIter->pLeaf ){
252114 pIter->iLeafOffset = 4;
252115 assert( pIter->pLeaf!=0 );
252116 assert_nc( pIter->pLeaf->nn>4 );
252117 assert_nc( fts5LeafFirstTermOff(pIter->pLeaf)==4 );
252118 pIter->iPgidxOff = pIter->pLeaf->szLeaf+1;
252119 fts5SegIterLoadTerm(p, pIter, 0);
252120 fts5SegIterLoadNPos(p, pIter);
252121 fts5SegIterAllocTombstone(p, pIter);
252140 static void fts5SegIterReverseInitPage(Fts5Index *p, Fts5SegIter *pIter){
252142 int n = pIter->pLeaf->szLeaf;
252143 int i = pIter->iLeafOffset;
252144 u8 *a = pIter->pLeaf->p;
252147 if( n>pIter->iEndofDoclist ){
252148 n = pIter->iEndofDoclist;
252151 ASSERT_SZLEAF_OK(pIter->pLeaf);
252170 pIter->iRowid += iDelta;
252172 /* If necessary, grow the pIter->aRowidOffset[] array. */
252173 if( iRowidOffset>=pIter->nRowidOffset ){
252174 i64 nNew = pIter->nRowidOffset + 8;
252175 int *aNew = (int*)sqlite3_realloc64(pIter->aRowidOffset,nNew*sizeof(int));
252180 pIter->aRowidOffset = aNew;
252181 pIter->nRowidOffset = nNew;
252184 pIter->aRowidOffset[iRowidOffset++] = pIter->iLeafOffset;
252185 pIter->iLeafOffset = i;
252187 pIter->iRowidOffset = iRowidOffset;
252188 fts5SegIterLoadNPos(p, pIter);
252194 static void fts5SegIterReverseNewPage(Fts5Index *p, Fts5SegIter *pIter){
252195 assert( pIter->flags & FTS5_SEGITER_REVERSE );
252196 assert( pIter->flags & FTS5_SEGITER_ONETERM );
252198 fts5DataRelease(pIter->pLeaf);
252199 pIter->pLeaf = 0;
252200 while( p->rc==SQLITE_OK && pIter->iLeafPgno>pIter->iTermLeafPgno ){
252202 pIter->iLeafPgno--;
252204 pIter->pSeg->iSegid, pIter->iLeafPgno
252209 ** In this case leave pIter->pLeaf==0, this iterator is at EOF. */
252210 if( pIter->iLeafPgno==pIter->iTermLeafPgno ){
252211 assert( pIter->pLeaf==0 );
252212 if( pIter->iTermLeafOffset<pNew->szLeaf ){
252213 pIter->pLeaf = pNew;
252214 pIter->iLeafOffset = pIter->iTermLeafOffset;
252221 FTS5_CORRUPT_ITER(p, pIter);
252223 pIter->pLeaf = pNew;
252224 pIter->iLeafOffset = iRowidOff;
252229 if( pIter->pLeaf ){
252230 u8 *a = &pIter->pLeaf->p[pIter->iLeafOffset];
252231 pIter->iLeafOffset += fts5GetVarint(a, (u64*)&pIter->iRowid);
252239 if( pIter->pLeaf ){
252240 pIter->iEndofDoclist = pIter->pLeaf->nn+1;
252241 fts5SegIterReverseInitPage(p, pIter);
252250 static int fts5MultiIterIsEmpty(Fts5Index *p, Fts5Iter *pIter){
252251 Fts5SegIter *pSeg = &pIter->aSeg[pIter->aFirst[1].iFirst];
252256 ** Advance iterator pIter to the next entry.
252262 Fts5SegIter *pIter, /* Iterator to advance */
252265 assert( pIter->flags & FTS5_SEGITER_REVERSE );
252266 assert( pIter->pNextLeaf==0 );
252269 if( pIter->iRowidOffset>0 ){
252270 u8 *a = pIter->pLeaf->p;
252274 pIter->iRowidOffset--;
252275 pIter->iLeafOffset = pIter->aRowidOffset[pIter->iRowidOffset];
252276 fts5SegIterLoadNPos(p, pIter);
252277 iOff = pIter->iLeafOffset;
252279 iOff += pIter->nPos;
252282 pIter->iRowid -= iDelta;
252284 fts5SegIterReverseNewPage(p, pIter);
252289 ** Advance iterator pIter to the next entry.
252296 Fts5SegIter *pIter, /* Iterator to advance */
252302 assert( (pIter->flags & FTS5_SEGITER_REVERSE)==0 );
252305 ASSERT_SZLEAF_OK(pIter->pLeaf);
252306 iOff = pIter->iLeafOffset;
252309 while( pIter->pSeg && iOff>=pIter->pLeaf->szLeaf ){
252310 fts5SegIterNextPage(p, pIter);
252311 if( p->rc || pIter->pLeaf==0 ) return;
252312 pIter->iRowid = 0;
252316 if( iOff<pIter->iEndofDoclist ){
252319 iOff += sqlite3Fts5GetVarint(&pIter->pLeaf->p[iOff], (u64*)&iDelta);
252320 pIter->iLeafOffset = iOff;
252321 pIter->iRowid += iDelta;
252322 }else if( (pIter->flags & FTS5_SEGITER_ONETERM)==0 ){
252323 if( pIter->pSeg ){
252325 if( iOff!=fts5LeafFirstTermOff(pIter->pLeaf) ){
252326 iOff += fts5GetVarint32(&pIter->pLeaf->p[iOff], nKeep);
252328 pIter->iLeafOffset = iOff;
252329 fts5SegIterLoadTerm(p, pIter, nKeep);
252338 pIter->pLeaf->p = (u8*)pList;
252339 pIter->pLeaf->nn = nList;
252340 pIter->pLeaf->szLeaf = nList;
252341 pIter->iEndofDoclist = nList;
252342 sqlite3Fts5BufferSet(&p->rc,&pIter->term, nTerm, (u8*)zTerm);
252343 pIter->iLeafOffset = fts5GetVarint(pList, (u64*)&pIter->iRowid);
252351 fts5SegIterLoadNPos(p, pIter);
252355 fts5DataRelease(pIter->pLeaf);
252356 pIter->pLeaf = 0;
252361 ** Advance iterator pIter to the next entry.
252369 Fts5SegIter *pIter, /* Iterator to advance */
252372 Fts5Data *pLeaf = pIter->pLeaf;
252387 iOff = pIter->iLeafOffset + pIter->nPos;
252391 assert_nc( iOff<=pIter->iEndofDoclist );
252392 if( iOff>=pIter->iEndofDoclist ){
252400 pIter->iRowid += iDelta;
252403 pIter->iLeafOffset = iOff;
252405 }else if( pIter->pSeg==0 ){
252410 assert( (pIter->flags & FTS5_SEGITER_ONETERM) || pbNewTerm );
252411 if( 0==(pIter->flags & FTS5_SEGITER_ONETERM) ){
252416 fts5DataRelease(pIter->pLeaf);
252417 pIter->pLeaf = 0;
252419 pIter->pLeaf->p = (u8*)pList;
252420 pIter->pLeaf->nn = nList;
252421 pIter->pLeaf->szLeaf = nList;
252422 pIter->iEndofDoclist = nList+1;
252423 sqlite3Fts5BufferSet(&p->rc, &pIter->term, nTerm, (u8*)zTerm);
252424 pIter->iLeafOffset = fts5GetVarint(pList, (u64*)&pIter->iRowid);
252431 fts5SegIterNextPage(p, pIter);
252432 pLeaf = pIter->pLeaf;
252436 iOff += sqlite3Fts5GetVarint(&pLeaf->p[iOff], (u64*)&pIter->iRowid);
252437 pIter->iLeafOffset = iOff;
252440 pIter->iPgidxOff = pLeaf->szLeaf + fts5GetVarint32(
252441 &pLeaf->p[pLeaf->szLeaf], pIter->iEndofDoclist
252446 pIter->iPgidxOff = pLeaf->szLeaf + fts5GetVarint32(
252449 pIter->iLeafOffset = iOff;
252450 pIter->iEndofDoclist = iOff;
252455 FTS5_CORRUPT_ITER(p, pIter);
252462 if( pIter->pLeaf ){
252464 if( pIter->flags & FTS5_SEGITER_ONETERM ){
252465 fts5DataRelease(pIter->pLeaf);
252466 pIter->pLeaf = 0;
252468 fts5SegIterLoadTerm(p, pIter, nKeep);
252469 fts5SegIterLoadNPos(p, pIter);
252477 assert_nc( pIter->iLeafOffset<=pIter->pLeaf->nn );
252478 fts5FastGetVarint32(pIter->pLeaf->p, pIter->iLeafOffset, nSz);
252479 pIter->bDel = (nSz & 0x0001);
252480 pIter->nPos = nSz>>1;
252481 assert_nc( pIter->nPos>=0 );
252494 ** Iterator pIter currently points to the first rowid in a doclist. This
252498 static void fts5SegIterReverse(Fts5Index *p, Fts5SegIter *pIter){
252499 Fts5DlidxIter *pDlidx = pIter->pDlidx;
252504 int iSegid = pIter->pSeg->iSegid;
252508 Fts5Data *pLeaf = pIter->pLeaf; /* Current leaf data */
252514 if( pIter->iTermLeafPgno==pIter->iLeafPgno ){
252515 iPoslist = pIter->iTermLeafOffset;
252520 pIter->iLeafOffset = iPoslist;
252525 if( pIter->iEndofDoclist>=pLeaf->szLeaf ){
252527 Fts5StructureSegment *pSeg = pIter->pSeg;
252531 for(pgno=pIter->iLeafPgno+1; !p->rc && pgno<=pSeg->pgnoLast; pgno++){
252551 ** pIter->iLeafOffset is already set to point to the position-list size
252560 fts5DataRelease(pIter->pLeaf);
252561 pIter->pLeaf = pLast;
252562 pIter->iLeafPgno = pgnoLast;
252566 FTS5_CORRUPT_ITER(p, pIter);
252569 iOff += fts5GetVarint(&pLast->p[iOff], (u64*)&pIter->iRowid);
252570 pIter->iLeafOffset = iOff;
252573 pIter->iEndofDoclist = pLast->nn+1;
252575 pIter->iEndofDoclist = fts5LeafFirstTermOff(pLast);
252580 fts5SegIterReverseInitPage(p, pIter);
252584 ** Iterator pIter currently points to the first rowid of a doclist.
252587 ** doclist-index from disk and initialize an iterator at (pIter->pDlidx).
252589 static void fts5SegIterLoadDlidx(Fts5Index *p, Fts5SegIter *pIter){
252590 int iSeg = pIter->pSeg->iSegid;
252591 int bRev = (pIter->flags & FTS5_SEGITER_REVERSE);
252592 Fts5Data *pLeaf = pIter->pLeaf; /* Current leaf data */
252594 assert( pIter->flags & FTS5_SEGITER_ONETERM );
252595 assert( pIter->pDlidx==0 );
252600 if( pIter->iTermLeafPgno==pIter->iLeafPgno
252601 && pIter->iEndofDoclist<pLeaf->szLeaf
252606 pIter->pDlidx = fts5DlidxIterInit(p, bRev, iSeg, pIter->iTermLeafPgno);
252626 Fts5SegIter *pIter, /* Iterator to seek */
252630 const u8 *a = pIter->pLeaf->p;
252631 u32 n = (u32)pIter->pLeaf->nn;
252642 iPgidx = (u32)pIter->pLeaf->szLeaf;
252646 FTS5_CORRUPT_ITER(p, pIter);
252689 FTS5_CORRUPT_ITER(p, pIter);
252699 fts5DataRelease(pIter->pLeaf);
252700 pIter->pLeaf = 0;
252704 fts5SegIterNextPage(p, pIter);
252705 if( pIter->pLeaf==0 ) return;
252706 a = pIter->pLeaf->p;
252707 if( fts5LeafIsTermless(pIter->pLeaf)==0 ){
252708 iPgidx = (u32)pIter->pLeaf->szLeaf;
252709 iPgidx += fts5GetVarint32(&pIter->pLeaf->p[iPgidx], iOff);
252710 if( iOff<4 || (i64)iOff>=pIter->pLeaf->szLeaf ){
252711 FTS5_CORRUPT_ITER(p, pIter);
252716 n = (u32)pIter->pLeaf->nn;
252726 FTS5_CORRUPT_ITER(p, pIter);
252729 pIter->iLeafOffset = iOff + nNew;
252730 pIter->iTermLeafOffset = pIter->iLeafOffset;
252731 pIter->iTermLeafPgno = pIter->iLeafPgno;
252733 fts5BufferSet(&p->rc, &pIter->term, nKeep, pTerm);
252734 fts5BufferAppendBlob(&p->rc, &pIter->term, nNew, &a[iOff]);
252737 pIter->iEndofDoclist = pIter->pLeaf->nn+1;
252741 pIter->iEndofDoclist = iTermOff + nExtra;
252743 pIter->iPgidxOff = iPgidx;
252745 fts5SegIterLoadRowid(p, pIter);
252746 fts5SegIterLoadNPos(p, pIter);
252762 ** Initialize the object pIter to point to term pTerm/nTerm within segment
252773 Fts5SegIter *pIter /* Object to populate */
252782 memset(pIter, 0, sizeof(*pIter));
252783 pIter->pSeg = pSeg;
252804 pIter->iLeafPgno = iPg - 1;
252805 fts5SegIterNextPage(p, pIter);
252807 if( pIter->pLeaf ){
252808 fts5LeafSeek(p, bGe, pIter, pTerm, nTerm);
252812 pIter->flags |= FTS5_SEGITER_ONETERM;
252813 if( pIter->pLeaf ){
252815 pIter->flags |= FTS5_SEGITER_REVERSE;
252818 fts5SegIterLoadDlidx(p, pIter);
252821 fts5SegIterReverse(p, pIter);
252826 fts5SegIterSetNext(p, pIter);
252828 fts5SegIterAllocTombstone(p, pIter);
252840 || pIter->pLeaf==0 /* 2 */
252841 || fts5BufferCompareBlob(&pIter->term, pTerm, nTerm)==0 /* 3 */
252842 || (bGe && fts5BufferCompareBlob(&pIter->term, pTerm, nTerm)>0) /* 4 */
252872 Fts5SegIter *pIter /* Object to populate */
252894 memset(pIter, 0, sizeof(*pIter));
252895 pIter->pSeg = pSeg;
252896 pIter->flags |= FTS5_SEGITER_ONETERM;
252898 pIter->iLeafPgno = iPg - 1;
252899 fts5SegIterNextPage(p, pIter);
252900 fts5SegIterSetNext(p, pIter);
252902 if( pIter->pLeaf ){
252903 const u8 *a = pIter->pLeaf->p;
252906 pIter->iPgidxOff = pIter->pLeaf->szLeaf;
252907 pIter->iPgidxOff += fts5GetVarint32(&a[pIter->iPgidxOff], iTermOff);
252908 pIter->iLeafOffset = iTermOff;
252909 fts5SegIterLoadTerm(p, pIter, 0);
252910 fts5SegIterLoadNPos(p, pIter);
252911 if( bDlidx ) fts5SegIterLoadDlidx(p, pIter);
252914 fts5BufferCompareBlob(&pIter->term, (const u8*)pTerm, nTerm)>0
252920 ** Initialize the object pIter to point to term pTerm/nTerm within the
252931 Fts5SegIter *pIter /* Object to populate */
252969 pIter->flags |= FTS5_SEGITER_ONETERM;
252973 sqlite3Fts5BufferSet(&p->rc, &pIter->term, n, z);
252975 pIter->pLeaf = pLeaf;
252976 pIter->iLeafOffset = fts5GetVarint(pLeaf->p, (u64*)&pIter->iRowid);
252977 pIter->iEndofDoclist = pLeaf->nn;
252980 pIter->flags |= FTS5_SEGITER_REVERSE;
252981 fts5SegIterReverseInitPage(p, pIter);
252983 fts5SegIterLoadNPos(p, pIter);
252987 fts5SegIterSetNext(p, pIter);
253024 static void fts5SegIterClear(Fts5SegIter *pIter){
253025 fts5BufferFree(&pIter->term);
253026 fts5DataRelease(pIter->pLeaf);
253027 fts5DataRelease(pIter->pNextLeaf);
253028 fts5TombstoneArrayDelete(pIter->pTombArray);
253029 fts5DlidxIterFree(pIter->pDlidx);
253030 sqlite3_free(pIter->aRowidOffset);
253031 memset(pIter, 0, sizeof(Fts5SegIter));
253043 Fts5Iter *pIter,
253048 int i1 = p1 - pIter->aSeg;
253049 int i2 = p2 - pIter->aSeg;
253064 res = ((p1->iRowid > p2->iRowid)==pIter->bRev) ? -1 : 1;
253081 ** statement used to verify that the contents of the pIter->aFirst[] array
253084 static void fts5AssertMultiIterSetup(Fts5Index *p, Fts5Iter *pIter){
253086 Fts5SegIter *pFirst = &pIter->aSeg[ pIter->aFirst[1].iFirst ];
253089 assert( (pFirst->pLeaf==0)==pIter->base.bEof );
253091 pIter->iSwitchRowid is set correctly. */
253092 for(i=0; i<pIter->nSeg; i++){
253093 Fts5SegIter *p1 = &pIter->aSeg[i];
253097 || p1->iRowid==pIter->iSwitchRowid
253098 || (p1->iRowid<pIter->iSwitchRowid)==pIter->bRev
253102 for(i=0; i<pIter->nSeg; i+=2){
253103 Fts5SegIter *p1 = &pIter->aSeg[i];
253104 Fts5SegIter *p2 = &pIter->aSeg[i+1];
253105 Fts5CResult *pRes = &pIter->aFirst[(pIter->nSeg + i) / 2];
253106 fts5AssertComparisonResult(pIter, p1, p2, pRes);
253109 for(i=1; i<(pIter->nSeg / 2); i+=2){
253110 Fts5SegIter *p1 = &pIter->aSeg[ pIter->aFirst[i*2].iFirst ];
253111 Fts5SegIter *p2 = &pIter->aSeg[ pIter->aFirst[i*2+1].iFirst ];
253112 Fts5CResult *pRes = &pIter->aFirst[i];
253113 fts5AssertComparisonResult(pIter, p1, p2, pRes);
253122 ** Do the comparison necessary to populate pIter->aFirst[iOut].
253125 ** in the pIter->aSeg[] array that is (a) not at EOF, and (b) pointing
253129 static int fts5MultiIterDoCompare(Fts5Iter *pIter, int iOut){
253135 Fts5CResult *pRes = &pIter->aFirst[iOut];
253137 assert( iOut<pIter->nSeg && iOut>0 );
253138 assert( pIter->bRev==0 || pIter->bRev==1 );
253140 if( iOut>=(pIter->nSeg/2) ){
253141 i1 = (iOut - pIter->nSeg/2) * 2;
253144 i1 = pIter->aFirst[iOut*2].iFirst;
253145 i2 = pIter->aFirst[iOut*2+1].iFirst;
253147 p1 = &pIter->aSeg[i1];
253148 p2 = &pIter->aSeg[i2];
253164 res = ((p1->iRowid > p2->iRowid)==pIter->bRev) ? -1 : +1;
253185 Fts5SegIter *pIter, /* Iterator to advance */
253188 assert( iLeafPgno>pIter->iLeafPgno );
253190 if( iLeafPgno>pIter->pSeg->pgnoLast ){
253193 fts5DataRelease(pIter->pNextLeaf);
253194 pIter->pNextLeaf = 0;
253195 pIter->iLeafPgno = iLeafPgno-1;
253199 fts5SegIterNextPage(p, pIter);
253200 if( pIter->pLeaf==0 ) break;
253201 iOff = fts5LeafFirstRowidOff(pIter->pLeaf);
253203 u8 *a = pIter->pLeaf->p;
253204 int n = pIter->pLeaf->szLeaf;
253208 iOff += fts5GetVarint(&a[iOff], (u64*)&pIter->iRowid);
253209 pIter->iLeafOffset = iOff;
253210 fts5SegIterLoadNPos(p, pIter);
253225 Fts5SegIter *pIter, /* Iterator to advance */
253228 int bRev = (pIter->flags & FTS5_SEGITER_REVERSE);
253229 Fts5DlidxIter *pDlidx = pIter->pDlidx;
253230 int iLeafPgno = pIter->iLeafPgno;
253233 assert( pIter->flags & FTS5_SEGITER_ONETERM );
253234 assert( pIter->pDlidx );
253235 assert( pIter->pLeaf );
253242 assert_nc( iLeafPgno>=pIter->iLeafPgno || p->rc );
253243 if( iLeafPgno>pIter->iLeafPgno ){
253244 fts5SegIterGotoPage(p, pIter, iLeafPgno);
253248 assert( pIter->pNextLeaf==0 );
253249 assert( iMatch<pIter->iRowid );
253255 assert( fts5DlidxIterEof(p, pDlidx) || iLeafPgno<=pIter->iLeafPgno );
253257 if( iLeafPgno<pIter->iLeafPgno ){
253258 pIter->iLeafPgno = iLeafPgno+1;
253259 fts5SegIterReverseNewPage(p, pIter);
253265 if( bMove && p->rc==SQLITE_OK ) pIter->xNext(p, pIter, 0);
253266 if( pIter->pLeaf==0 ) break;
253267 if( bRev==0 && pIter->iRowid>=iMatch ) break;
253268 if( bRev!=0 && pIter->iRowid<=iMatch ) break;
253276 static void fts5MultiIterFree(Fts5Iter *pIter){
253277 if( pIter ){
253279 for(i=0; i<pIter->nSeg; i++){
253280 fts5SegIterClear(&pIter->aSeg[i]);
253282 fts5BufferFree(&pIter->poslist);
253283 sqlite3_free(pIter);
253289 Fts5Iter *pIter, /* Iterator to update aFirst[] array for */
253294 for(i=(pIter->nSeg+iChanged)/2; i>=iMinset && p->rc==SQLITE_OK; i=i/2){
253296 if( (iEq = fts5MultiIterDoCompare(pIter, i)) ){
253297 Fts5SegIter *pSeg = &pIter->aSeg[iEq];
253300 i = pIter->nSeg + iEq;
253306 ** Sub-iterator iChanged of iterator pIter has just been advanced. It still
253308 ** attempts to update the contents of the pIter->aFirst[] accordingly.
253316 Fts5Iter *pIter, /* Iterator to update aFirst[] array for */
253320 Fts5SegIter *pNew = &pIter->aSeg[iChanged];
253322 if( pNew->iRowid==pIter->iSwitchRowid
253323 || (pNew->iRowid<pIter->iSwitchRowid)==pIter->bRev
253326 Fts5SegIter *pOther = &pIter->aSeg[iChanged ^ 0x0001];
253327 pIter->iSwitchRowid = pIter->bRev ? SMALLEST_INT64 : LARGEST_INT64;
253328 for(i=(pIter->nSeg+iChanged)/2; 1; i=i/2){
253329 Fts5CResult *pRes = &pIter->aFirst[i];
253337 }else if( (pOther->iRowid>pNew->iRowid)==pIter->bRev ){
253338 pIter->iSwitchRowid = pOther->iRowid;
253340 }else if( (pOther->iRowid>pIter->iSwitchRowid)==pIter->bRev ){
253341 pIter->iSwitchRowid = pOther->iRowid;
253344 pRes->iFirst = (u16)(pNew - pIter->aSeg);
253347 pOther = &pIter->aSeg[ pIter->aFirst[i ^ 0x0001].iFirst ];
253356 ** Set the pIter->bEof variable based on the state of the sub-iterators.
253358 static void fts5MultiIterSetEof(Fts5Iter *pIter){
253359 Fts5SegIter *pSeg = &pIter->aSeg[ pIter->aFirst[1].iFirst ];
253360 pIter->base.bEof = pSeg->pLeaf==0;
253361 pIter->iSwitchRowid = pSeg->iRowid;
253414 static int fts5MultiIterIsDeleted(Fts5Iter *pIter){
253415 int iFirst = pIter->aFirst[1].iFirst;
253416 Fts5SegIter *pSeg = &pIter->aSeg[iFirst];
253427 pArray->apTombstone[iPg] = fts5DataRead(pIter->pIndex,
253452 Fts5Iter *pIter,
253457 assert( pIter->base.bEof==0 );
253459 int iFirst = pIter->aFirst[1].iFirst;
253461 Fts5SegIter *pSeg = &pIter->aSeg[iFirst];
253470 || fts5MultiIterAdvanceRowid(pIter, iFirst, &pSeg)
253472 fts5MultiIterAdvanced(p, pIter, iFirst, 1);
253473 fts5MultiIterSetEof(pIter);
253474 pSeg = &pIter->aSeg[pIter->aFirst[1].iFirst];
253478 fts5AssertMultiIterSetup(p, pIter);
253479 assert( pSeg==&pIter->aSeg[pIter->aFirst[1].iFirst] && pSeg->pLeaf );
253480 if( (pIter->bSkipEmpty==0 || pSeg->nPos)
253481 && 0==fts5MultiIterIsDeleted(pIter)
253483 pIter->xSetOutputs(pIter, pSeg);
253492 Fts5Iter *pIter,
253495 assert( pIter->bSkipEmpty );
253499 int iFirst = pIter->aFirst[1].iFirst;
253500 Fts5SegIter *pSeg = &pIter->aSeg[iFirst];
253506 || fts5MultiIterAdvanceRowid(pIter, iFirst, &pSeg)
253508 fts5MultiIterAdvanced(p, pIter, iFirst, 1);
253509 fts5MultiIterSetEof(pIter);
253512 fts5AssertMultiIterSetup(p, pIter);
253514 }while( (fts5MultiIterIsEmpty(p, pIter) || fts5MultiIterIsDeleted(pIter))
253703 ** Iterator pIter currently points to a valid entry (not EOF). This
253744 ** and sets pIter->base.pData/nData to point to the new position list.
253745 ** If memory is required for the new position list, use buffer pIter->poslist.
253747 ** pIter->base.pData/nData to point directly to it.
253757 Fts5Iter *pIter
253766 if( pColset->nCol>1 && sqlite3Fts5BufferSize(pRc, &pIter->poslist, nPos) ){
253774 pIter->base.pData = pIter->poslist.p;
253775 pIter->base.nData = pIter->poslist.n;
253788 pIter->base.pData = aCopy;
253789 pIter->base.nData = p-aCopy;
253792 fts5BufferSafeAppendBlob(&pIter->poslist, aCopy, p-aCopy);
253795 pIter->base.pData = pIter->poslist.p;
253796 pIter->base.nData = pIter->poslist.n;
253813 static void fts5IterSetOutputs_None(Fts5Iter *pIter, Fts5SegIter *pSeg){
253814 assert( pIter->pIndex->pConfig->eDetail==FTS5_DETAIL_NONE );
253815 pIter->base.iRowid = pSeg->iRowid;
253816 pIter->base.nData = pSeg->nPos;
253823 static void fts5IterSetOutputs_Nocolset(Fts5Iter *pIter, Fts5SegIter *pSeg){
253824 pIter->base.iRowid = pSeg->iRowid;
253825 pIter->base.nData = pSeg->nPos;
253827 assert( pIter->pIndex->pConfig->eDetail!=FTS5_DETAIL_NONE );
253828 assert( pIter->pColset==0 );
253833 pIter->base.pData = &pSeg->pLeaf->p[pSeg->iLeafOffset];
253838 fts5BufferZero(&pIter->poslist);
253839 fts5SegiterPoslist(pIter->pIndex, pSeg, 0, &pIter->poslist);
253840 pIter->base.pData = pIter->poslist.p;
253848 static void fts5IterSetOutputs_ZeroColset(Fts5Iter *pIter, Fts5SegIter *pSeg){
253850 pIter->base.nData = 0;
253858 static void fts5IterSetOutputs_Col(Fts5Iter *pIter, Fts5SegIter *pSeg){
253859 fts5BufferZero(&pIter->poslist);
253860 fts5SegiterPoslist(pIter->pIndex, pSeg, pIter->pColset, &pIter->poslist);
253861 pIter->base.iRowid = pSeg->iRowid;
253862 pIter->base.pData = pIter->poslist.p;
253863 pIter->base.nData = pIter->poslist.n;
253876 static void fts5IterSetOutputs_Col100(Fts5Iter *pIter, Fts5SegIter *pSeg){
253878 assert( pIter->pIndex->pConfig->eDetail==FTS5_DETAIL_COLUMNS );
253879 assert( pIter->pColset );
253882 fts5IterSetOutputs_Col(pIter, pSeg);
253887 int *aiCol = pIter->pColset->aiCol;
253888 int *aiColEnd = &aiCol[pIter->pColset->nCol];
253890 u8 *aOut = pIter->poslist.p;
253893 pIter->base.iRowid = pSeg->iRowid;
253908 pIter->base.pData = pIter->poslist.p;
253909 pIter->base.nData = aOut - pIter->poslist.p;
253916 static void fts5IterSetOutputs_Full(Fts5Iter *pIter, Fts5SegIter *pSeg){
253917 Fts5Colset *pColset = pIter->pColset;
253918 pIter->base.iRowid = pSeg->iRowid;
253920 assert( pIter->pIndex->pConfig->eDetail==FTS5_DETAIL_FULL );
253927 int *pRc = &pIter->pIndex->rc;
253928 fts5BufferZero(&pIter->poslist);
253929 fts5IndexExtractColset(pRc, pColset, a, pSeg->nPos, pIter);
253934 fts5BufferZero(&pIter->poslist);
253935 fts5SegiterPoslist(pIter->pIndex, pSeg, pColset, &pIter->poslist);
253936 pIter->base.pData = pIter->poslist.p;
253937 pIter->base.nData = pIter->poslist.n;
253941 static void fts5IterSetOutputCb(int *pRc, Fts5Iter *pIter){
253942 assert( pIter!=0 || (*pRc)!=SQLITE_OK );
253944 Fts5Config *pConfig = pIter->pIndex->pConfig;
253946 pIter->xSetOutputs = fts5IterSetOutputs_None;
253949 else if( pIter->pColset==0 ){
253950 pIter->xSetOutputs = fts5IterSetOutputs_Nocolset;
253953 else if( pIter->pColset->nCol==0 ){
253954 pIter->xSetOutputs = fts5IterSetOutputs_ZeroColset;
253958 pIter->xSetOutputs = fts5IterSetOutputs_Full;
253964 pIter->xSetOutputs = fts5IterSetOutputs_Col100;
253965 sqlite3Fts5BufferSize(pRc, &pIter->poslist, pConfig->nCol);
253967 pIter->xSetOutputs = fts5IterSetOutputs_Col;
253974 ** All the component segment-iterators of pIter have been set up. This
253975 ** functions finishes setup for iterator pIter itself.
253977 static void fts5MultiIterFinishSetup(Fts5Index *p, Fts5Iter *pIter){
253979 for(iIter=pIter->nSeg-1; iIter>0; iIter--){
253981 if( (iEq = fts5MultiIterDoCompare(pIter, iIter)) ){
253982 Fts5SegIter *pSeg = &pIter->aSeg[iEq];
253984 fts5MultiIterAdvanced(p, pIter, iEq, iIter);
253987 fts5MultiIterSetEof(pIter);
253988 fts5AssertMultiIterSetup(p, pIter);
253990 if( (pIter->bSkipEmpty && fts5MultiIterIsEmpty(p, pIter))
253991 || fts5MultiIterIsDeleted(pIter)
253993 fts5MultiIterNext(p, pIter, 0, 0);
253994 }else if( pIter->base.bEof==0 ){
253995 Fts5SegIter *pSeg = &pIter->aSeg[pIter->aFirst[1].iFirst];
253996 pIter->xSetOutputs(pIter, pSeg);
254057 Fts5SegIter *pIter = &pNew->aSeg[iIter++];
254058 fts5SegIterHashInit(p, pTerm, nTerm, flags, pIter);
254063 Fts5SegIter *pIter = &pNew->aSeg[iIter++];
254065 fts5SegIterInit(p, pSeg, pIter);
254067 fts5SegIterSeekInit(p, pTerm, nTerm, flags, pSeg, pIter);
254109 Fts5SegIter *pIter = &pNew->aSeg[1];
254110 pIter->flags = FTS5_SEGITER_ONETERM;
254112 pIter->pLeaf = pData;
254113 pIter->iLeafOffset = fts5GetVarint(pData->p, (u64*)&pIter->iRowid);
254114 pIter->iEndofDoclist = pData->nn;
254118 pIter->flags |= FTS5_SEGITER_REVERSE;
254119 fts5SegIterReverseInitPage(p, pIter);
254121 fts5SegIterLoadNPos(p, pIter);
254127 fts5SegIterSetNext(p, pIter);
254139 static int fts5MultiIterEof(Fts5Index *p, Fts5Iter *pIter){
254140 assert( pIter!=0 || p->rc!=SQLITE_OK );
254142 || (pIter->aSeg[ pIter->aFirst[1].iFirst ].pLeaf==0)==pIter->base.bEof
254144 return (p->rc || pIter->base.bEof);
254152 static i64 fts5MultiIterRowid(Fts5Iter *pIter){
254153 assert( pIter->aSeg[ pIter->aFirst[1].iFirst ].pLeaf );
254154 return pIter->aSeg[ pIter->aFirst[1].iFirst ].iRowid;
254162 Fts5Iter *pIter,
254167 fts5MultiIterNext(p, pIter, 1, iMatch);
254168 if( fts5MultiIterEof(p, pIter) ) break;
254169 iRowid = fts5MultiIterRowid(pIter);
254170 if( pIter->bRev==0 && iRowid>=iMatch ) break;
254171 if( pIter
254179 static const u8 *fts5MultiIterTerm(Fts5Iter *pIter, int *pn){
254180 Fts5SegIter *p = &pIter->aSeg[ pIter->aFirst[1].iFirst ];
254755 ** Iterator pIter was used to iterate through the input segments of on an
254759 static void fts5TrimSegments(Fts5Index *p, Fts5Iter *pIter){
254763 for(i=0; i<pIter->nSeg && p->rc==SQLITE_OK; i++){
254764 Fts5SegIter *pSeg = &pIter->aSeg[i];
254846 Fts5Iter *pIter = 0; /* Iterator to read input data */
254906 for(fts5MultiIterNew(p, pStruct, flags, 0, 0, 0, iLvl, nInput, &pIter);
254907 fts5MultiIterEof(p, pIter)==0;
254908 fts5MultiIterNext(p, pIter, 0, 0)
254910 Fts5SegIter *pSegIter = &pIter->aSeg[ pIter->aFirst[1].iFirst ];
254915 pTerm = fts5MultiIterTerm(pIter, &nTerm);
254935 fts5WriteAppendRowid(p, &writer, fts5MultiIterRowid(pIter));
254956 assert( pIter!=0 || p->rc!=SQLITE_OK );
254957 if( fts5MultiIterEof(p, pIter) ){
254982 fts5TrimSegments(p, pIter);
254986 fts5MultiIterFree(pIter);
255621 Fts5Iter *pIter = 0; /* Used to find term instance */
255641 fts5MultiIterNew(p, pStruct, f, 0, (const u8*)zTerm, nTerm, -1, 0, &pIter);
255642 if( fts5MultiIterEof(p, pIter)==0 ){
255643 i64 iThis = fts5MultiIterRowid(pIter);
255645 fts5MultiIterNextFrom(p, pIter, iRowid);
255649 && fts5MultiIterEof(p, pIter)==0
255650 && iRowid==fts5MultiIterRowid(pIter)
255652 Fts5SegIter *pSeg = &pIter->aSeg[pIter->aFirst[1].iFirst];
255657 fts5MultiIterFree(pIter);
256057 static void fts5DoclistIterNext(Fts5DoclistIter *pIter){
256058 u8 *p = pIter->aPoslist + pIter->nSize + pIter->nPoslist;
256060 assert( pIter->aPoslist || (p==0 && pIter->aPoslist==0) );
256061 if( p>=pIter->aEof ){
256062 pIter->aPoslist = 0;
256067 pIter->iRowid += iDelta;
256072 pIter->nSize = fts5GetVarint32(p, nPos);
256073 pIter->nPoslist = (nPos>>1);
256075 pIter->nPoslist = ((int)(p[0])) >> 1;
256076 pIter->nSize = 1;
256079 pIter->aPoslist = p;
256080 if( &pIter->aPoslist[pIter->nPoslist]>pIter->aEof ){
256081 pIter->aPoslist = 0;
256088 Fts5DoclistIter *pIter
256090 memset(pIter, 0, sizeof(*pIter));
256092 pIter->aPoslist = pBuf->p;
256093 pIter->aEof = &pBuf->p[pBuf->n];
256094 fts5DoclistIterNext(pIter);
256411 void (*xVisit)(Fts5Index*, void *pCtx, Fts5Iter *pIter, const u8*, int),
257107 Fts5Iter *pIter = (Fts5Iter*)pIndexIter;
257108 Fts5Index *pIndex = pIter->pIndex;
257109 fts5TokendataIterDelete(pIter->pTokenDataIter);
257110 fts5MultiIterFree(pIter);
257154 ** (pIter->pTokenDataIter!=0). This function sets the iterator output
257155 ** variables (pIter->base.*) according to the contents of the current
257158 static void fts5IterSetOutputsTokendata(Fts5Iter *pIter){
257164 Fts5TokenDataIter *pT = pIter->pTokenDataIter;
257166 pIter->base.nData = 0;
257167 pIter->base.pData = 0;
257175 pIter->base.pData = p->base.pData;
257176 pIter->base.nData = p->base.nData;
257185 pIter->base.bEof = 1;
257187 int eDetail = pIter->pIndex->pConfig->eDetail;
257188 pIter->base.bEof = 0;
257189 pIter->base.iRowid = iRowid;
257192 fts5TokendataIterAppendMap(pIter->pIndex, pT, iMin, 0, iRowid, -1);
257202 &pIter->pIndex->rc,
257222 if( fts5BufferGrow(&pIter->pIndex->rc, &pIter->poslist, nByte+nHit*10) ){
257233 pIter->pIndex->rc = SQLITE_NOMEM;
257240 pIter->poslist.n = 0;
257260 sqlite3Fts5PoslistSafeAppend(&pIter->poslist, &iPrev, iMinPos);
257271 pIter->base.pData = pIter->poslist.p;
257272 pIter->base.nData = pIter->poslist.n;
257279 ** (pIter->pTokenDataIter!=0). This function advances the iterator. If
257284 static void fts5TokendataIterNext(Fts5Iter *pIter, int bFrom, i64 iFrom){
257286 Fts5TokenDataIter *pT = pIter->pTokenDataIter;
257287 Fts5Index *pIndex = pIter->pIndex;
257292 && (p->base.iRowid==pIter->base.iRowid || (bFrom && p->base.iRowid<iFrom))
257305 fts5IterSetOutputsTokendata(pIter);
257311 ** set pIter->term to a copy of buffer pTerm.
257313 static void fts5TokendataSetTermIfEof(Fts5Iter *pIter, Fts5Buffer *pTerm){
257314 if( pIter && pIter->aSeg[0].pLeaf==0 ){
257315 fts5BufferSet(&pIter->pIndex->rc, &pIter->aSeg[0].term, pTerm->n, pTerm->p);
257432 Fts5Iter *pIter = pSet->apIter[ii];
257434 for(iSeg=0; iSeg<pIter->nSeg; iSeg++){
257435 pIter->aSeg[iSeg].flags |= FTS5_SEGITER_ONETERM;
257437 fts5MultiIterFinishSetup(p, pIter);
257568 Fts5Iter *pIter = (Fts5Iter*)pIndexIter;
257569 assert( pIter->pIndex->rc==SQLITE_OK );
257570 if( pIter->nSeg==0 ){
257571 assert( pIter->pTokenDataIter );
257572 fts5TokendataIterNext(pIter, 0, 0);
257574 fts5MultiIterNext(pIter->pIndex, pIter, 0, 0);
257576 return fts5IndexReturn(pIter->pIndex);
257583 Fts5Iter *pIter = (Fts5Iter*)pIndexIter;
257584 Fts5Index *p = pIter->pIndex;
257586 assert( pIter->pIndex->rc==SQLITE_OK );
257588 fts5MultiIterNext(p, pIter, 0, 0);
257590 Fts5SegIter *pSeg = &pIter->aSeg[ pIter->aFirst[1].iFirst ];
257594 pIter->base.bEof = 1;
257598 return fts5IndexReturn(pIter->pIndex);
257607 Fts5Iter *pIter = (Fts5Iter*)pIndexIter;
257608 if( pIter->nSeg==0 ){
257609 assert( pIter->pTokenDataIter );
257610 fts5TokendataIterNext(pIter, 1, iMatch);
257612 fts5MultiIterNextFrom(pIter->pIndex, pIter, iMatch);
257614 return fts5IndexReturn(pIter->pIndex);
257629 ** pIter is a prefix query. This function populates pIter->pTokenDataIter
257634 Fts5Iter *pIter,
257638 Fts5Index *p = pIter->pIndex;
257664 pIter->pTokenDataIter = ctx.pT;
257677 ** iterator (pIter->pTokenDataIter!=0).
257689 Fts5Iter *pIter = (Fts5Iter*)pIndexIter;
257690 Fts5TokenDataIter *pT = pIter->pTokenDataIter;
257697 assert( pT || (pToken && pIter->nSeg>0) );
257699 int rc = fts5SetupPrefixIterTokendata(pIter, pToken, nToken);
257701 pT = pIter->pTokenDataIter;
257729 if( pIter->nSeg==0 ){
257748 Fts5Iter *pIter = (Fts5Iter*)pIndexIter;
257749 if( pIter && pIter->pTokenDataIter
257750 && (pIter->nSeg==0 || pIter->pIndex->pConfig->eDetail!=FTS5_DETAIL_FULL)
257752 pIter->pTokenDataIter->nMap = 0;
257768 Fts5Iter *pIter = (Fts5Iter*)pIndexIter;
257769 Fts5TokenDataIter *pT = pIter->pTokenDataIter;
257770 Fts5Index *p = pIter->pIndex;
257774 assert( pIter->pTokenDataIter || pIter->nSeg>0 );
257775 if( pIter->nSeg>0 ){
257780 pIter->pTokenDataIter = pT;
258311 Fts5IndexIter *pIter = 0;
258313 p, z, n, (flags | FTS5INDEX_QUERY_NOTOKENDATA), 0, &pIter
258316 while( rc==SQLITE_OK && ALWAYS(pIter!=0) && 0==sqlite3Fts5IterEof(pIter) ){
258317 i64 rowid = pIter->iRowid;
258323 for(sqlite3Fts5PoslistReaderInit(pIter->pData, pIter->nData, &sReader);
258333 rc = sqlite3Fts5IterNext(pIter);
258336 fts5IterClose(pIter);
258706 Fts5Iter *pIter; /* Used to iterate through entire index */
258746 for(fts5MultiIterNew(p, pStruct, flags, 0, 0, 0, -1, 0, &pIter);
258747 fts5MultiIterEof(p, pIter)==0;
258748 fts5MultiIterNext(p, pIter, 0, 0)
258753 i64 iRowid = fts5MultiIterRowid(pIter);
258754 char *z = (char*)fts5MultiIterTerm(pIter, &n);
258761 if( 0==fts5MultiIterIsEmpty(p, pIter) ){
258766 fts5SegiterPoslist(p, &pIter->aSeg[pIter->aFirst[1].iFirst], 0, &poslist);
258777 fts5MultiIterFree(pIter);
262247 Fts5PhraseIter *pIter,
262250 if( pIter->a>=pIter->b ){
262255 pIter->a += fts5GetVarint32(pIter->a, iVal);
262261 pIter->a += fts5GetVarint32(pIter->a, iVal);
262264 pIter->a += fts5GetVarint32(pIter->a, iVal);
262273 Fts5PhraseIter *pIter,
262278 int rc = fts5CsrPoslist(pCsr, iPhrase, &pIter->a, &n);
262280 assert( pIter->a || n==0 );
262281 pIter->b = (pIter->a ? &pIter->a[n] : 0);
262284 fts5ApiPhraseNext(pCtx, pIter, piCol, piOff);
262291 Fts5PhraseIter *pIter,
262298 if( pIter->a>=pIter->b ){
262302 pIter->a += fts5GetVarint32(&pIter->a[0], iIncr);
262308 if( pIter->a>=pIter->b ){
262312 if( pIter->a[0]==0x01 ) break;
262313 pIter->a += fts5GetVarint32(pIter->a, dummy);
262315 pIter->a += 1 + fts5GetVarint32(&pIter->a[1], *piCol);
262322 Fts5PhraseIter *pIter,
262335 pIter->a = &pSorter->aPoslist[i1];
262337 rc = sqlite3Fts5ExprPhraseCollist(pCsr->pExpr, iPhrase, &pIter->a, &n);
262340 assert( pIter->a || n==0 );
262341 pIter->b = (pIter->a ? &pIter->a[n] : 0);
262343 fts5ApiPhraseNextColumn(pCtx, pIter, piCol);
262347 rc = fts5CsrPoslist(pCsr, iPhrase, &pIter->a, &n);
262349 assert( pIter->a || n==0 );
262350 pIter->b = (pIter->a ? &pIter->a[n] : 0);
262353 }else if( pIter->a[0]==0x01 ){
262354 pIter->a += 1 + fts5GetVarint32(&pIter->a[1], *piCol);
267735 Fts5IndexIter *pIter; /* Term/rowid iterator object */
268079 sqlite3Fts5IterClose(pCsr->pIter);
268082 pCsr->pIter = 0;
268111 if( sqlite3Fts5IterEof(pCsr->pIter) ){
268116 zTerm = sqlite3Fts5IterTerm(pCsr->pIter, &nTerm);
268133 Fts5IndexIter *pIter = pCsr->pIter;
268137 assert( sqlite3Fts5IterEof(pIter)==0 );
268140 || sqlite3Fts5PoslistNext64(pIter->pData, pIter->nData, po, pp)
268145 rc = sqlite3Fts5IterNextScan(pCsr->pIter);
268183 if( sqlite3Fts5IterEof(pCsr->pIter) ){
268189 zTerm = sqlite3Fts5IterTerm(pCsr->pIter, &nTerm);
268212 pPos = pCsr->pIter->pData;
268213 nPos = pCsr->pIter->nData;
268271 rc = sqlite3Fts5IterNextScan(pCsr->pIter);
268276 zTerm = sqlite3Fts5IterTerm(pCsr->pIter, &nTerm);
268282 if( sqlite3Fts5IterEof(pCsr->pIter) ) break;
268353 rc = sqlite3Fts5IndexQuery(pIndex, zTerm, nTerm, f, 0, &pCsr->pIter);
268417 sqlite3_result_int64(pCtx, pCsr->pIter->iRowid);
Indexes created Tue Jun 09 00:24:00 UTC 2026