Lines Matching refs:pCsr
23634 VdbeCursor *pCsr; /* Cursor to read old values from */ member
23663 BtCursor *pCsr; /* An ephemeral table holding all values */ member
81871 SQLITE_PRIVATE int sqlite3BtreePutData(BtCursor *pCsr, u32 offset, u32 amt, void *z){
81873 assert( cursorOwnsBtShared(pCsr) );
81874 assert( sqlite3_mutex_held(pCsr->pBtree->db->mutex) );
81875 assert( pCsr->curFlags & BTCF_Incrblob );
81877 rc = restoreCursorPosition(pCsr);
81881 assert( pCsr->eState!=CURSOR_REQUIRESEEK );
81882 if( pCsr->eState!=CURSOR_VALID ){
81894 VVA_ONLY(rc =) saveAllCursors(pCsr->pBt, pCsr->pgnoRoot, pCsr);
81904 if( (pCsr->curFlags & BTCF_WriteFlag)==0 ){
81907 assert( (pCsr->pBt->btsFlags & BTS_READ_ONLY)==0
81908 && pCsr->pBt->inTransaction==TRANS_WRITE );
81909 assert( hasSharedCacheTableLock(pCsr->pBtree, pCsr->pgnoRoot, 0, 2) );
81910 assert( !hasReadConflicts(pCsr->pBtree, pCsr->pgnoRoot) );
81911 assert( pCsr->pPage->intKey );
81913 return accessPayload(pCsr, offset, amt, (unsigned char *)z, 1);
81965 SQLITE_PRIVATE int sqlite3BtreeCursorHasHint(BtCursor *pCsr, unsigned int mask){
81966 return (pCsr->hints & mask)!=0;
90303 VdbeCursor *pCsr, /* Cursor to grab old.* values from */
90340 assert( pCsr!=0 );
90341 assert( pCsr->eCurType==CURTYPE_BTREE );
90342 assert( pCsr->nField==nRealCol
90343 || (pCsr->nField==nRealCol+1 && op==SQLITE_DELETE && iReg==-1)
90347 preupdate.pCsr = pCsr;
90367 for(i=0; i<pCsr->nField; i++){
91411 rc = sqlite3BtreeNext(pRhs->pCsr, 0);
91414 rc = sqlite3BtreeFirst(pRhs->pCsr, &dummy);
91415 assert( rc==SQLITE_OK || sqlite3BtreeEof(pRhs->pCsr) );
91416 if( sqlite3BtreeEof(pRhs->pCsr) ) rc = SQLITE_DONE;
91422 sz = sqlite3BtreePayloadSize(pRhs->pCsr);
91423 rc = sqlite3VdbeMemFromBtreeZeroOffset(pRhs->pCsr,(int)sz,&sMem);
92554 if( iIdx>=p->pCsr->nField || iIdx<0 ){
92564 assert( p->pCsr->eCurType==CURTYPE_BTREE );
92565 nRec = sqlite3BtreePayloadSize(p->pCsr->uc.pCursor);
92568 rc = sqlite3BtreePayload(p->pCsr->uc.pCursor, 0, nRec, aRec);
92677 if( iIdx>=p->pCsr->nField || iIdx<0 ){
92711 p->aNew = (Mem *)sqlite3DbMallocZero(db, sizeof(Mem) * p->pCsr->nField);
92717 assert( iIdx>=0 && iIdx<p->pCsr->nField );
101377 pRhs->pCsr = pC->uc.pCursor;
102312 BtCursor *pCsr; /* Cursor pointing at blob row */
102376 p->pCsr = pC->uc.pCursor;
102377 sqlite3BtreeIncrblobCursor(p->pCsr);
102690 sqlite3BtreeEnterCursor(p->pCsr);
102708 iKey = sqlite3BtreeIntegerKey(p->pCsr);
102717 rc = xCall(p->pCsr, iOffset+p->iOffset, n, z);
102718 sqlite3BtreeLeaveCursor(p->pCsr);
103732 VdbeCursor *pCsr /* Cursor that holds the new sorter */
103764 assert( pCsr->pKeyInfo );
103765 assert( !pCsr->isEphemeral );
103766 assert( pCsr->eCurType==CURTYPE_SORTER );
103767 szKeyInfo = sizeof(KeyInfo) + (pCsr->pKeyInfo->nKeyField-1)*sizeof(CollSeq*);
103771 pCsr->uc.pSorter = pSorter;
103777 memcpy(pKeyInfo, pCsr->pKeyInfo, szKeyInfo);
104065 SQLITE_PRIVATE void sqlite3VdbeSorterClose(sqlite3 *db, VdbeCursor *pCsr){
104067 assert( pCsr->eCurType==CURTYPE_SORTER );
104068 pSorter = pCsr->uc.pSorter;
104073 pCsr->uc.pSorter = 0;
104569 const VdbeCursor *pCsr, /* Sorter cursor */
104580 assert( pCsr->eCurType==CURTYPE_SORTER );
104581 pSorter = pCsr->uc.pSorter;
105383 SQLITE_PRIVATE int sqlite3VdbeSorterRewind(const VdbeCursor *pCsr, int *pbEof){
105387 assert( pCsr->eCurType==CURTYPE_SORTER );
105388 pSorter = pCsr->uc.pSorter;
105435 SQLITE_PRIVATE int sqlite3VdbeSorterNext(sqlite3 *db, const VdbeCursor *pCsr){
105439 assert( pCsr->eCurType==CURTYPE_SORTER );
105440 pSorter = pCsr->uc.pSorter;
105500 SQLITE_PRIVATE int sqlite3VdbeSorterRowkey(const VdbeCursor *pCsr, Mem *pOut){
105504 assert( pCsr->eCurType==CURTYPE_SORTER );
105505 pSorter = pCsr->uc.pSorter;
105534 const VdbeCursor *pCsr, /* Sorter cursor */
105545 assert( pCsr->eCurType==CURTYPE_SORTER );
105546 pSorter = pCsr->uc.pSorter;
105548 pKeyInfo = pCsr->pKeyInfo;
141624 PragmaVtabCursor *pCsr;
141625 pCsr = (PragmaVtabCursor*)sqlite3_malloc(sizeof(*pCsr));
141626 if( pCsr==0 ) return SQLITE_NOMEM;
141627 memset(pCsr, 0, sizeof(PragmaVtabCursor));
141628 pCsr->base.pVtab = pVtab;
141629 *ppCursor = &pCsr->base;
141634 static void pragmaVtabCursorClear(PragmaVtabCursor *pCsr){
141636 sqlite3_finalize(pCsr->pPragma);
141637 pCsr->pPragma = 0;
141638 pCsr->iRowid = 0;
141639 for(i=0; i<ArraySize(pCsr->azArg); i++){
141640 sqlite3_free(pCsr->azArg[i]);
141641 pCsr->azArg[i] = 0;
141647 PragmaVtabCursor *pCsr = (PragmaVtabCursor*)cur;
141648 pragmaVtabCursorClear(pCsr);
141649 sqlite3_free(pCsr);
141655 PragmaVtabCursor *pCsr = (PragmaVtabCursor*)pVtabCursor;
141659 pCsr->iRowid++;
141660 assert( pCsr->pPragma );
141661 if( SQLITE_ROW!=sqlite3_step(pCsr->pPragma) ){
141662 rc = sqlite3_finalize(pCsr->pPragma);
141663 pCsr->pPragma = 0;
141664 pragmaVtabCursorClear(pCsr);
141677 PragmaVtabCursor *pCsr = (PragmaVtabCursor*)pVtabCursor;
141686 pragmaVtabCursorClear(pCsr);
141690 assert( j<ArraySize(pCsr->azArg) );
141691 assert( pCsr->azArg[j]==0 );
141693 pCsr->azArg[j] = sqlite3_mprintf("%s", zText);
141694 if( pCsr->azArg[j]==0 ){
141701 if( pCsr->azArg[1] ){
141702 sqlite3_str_appendf(&acc, "%Q.", pCsr->azArg[1]);
141705 if( pCsr->azArg[0] ){
141706 sqlite3_str_appendf(&acc, "=%Q", pCsr->azArg[0]);
141710 rc = sqlite3_prepare_v2(pTab->db, zSql, -1, &pCsr->pPragma, 0);
141723 PragmaVtabCursor *pCsr = (PragmaVtabCursor*)pVtabCursor;
141724 return (pCsr->pPragma==0);
141735 PragmaVtabCursor *pCsr = (PragmaVtabCursor*)pVtabCursor;
141738 sqlite3_result_value(ctx, sqlite3_column_value(pCsr->pPragma, i));
141740 sqlite3_result_text(ctx, pCsr->azArg[i-pTab->iHidden],-1,SQLITE_TRANSIENT);
141749 PragmaVtabCursor *pCsr = (PragmaVtabCursor*)pVtabCursor;
141750 *p = pCsr->iRowid;
185688 int (*xLanguageid)(sqlite3_tokenizer_cursor *pCsr, int iLangid);
186376 SQLITE_PRIVATE int sqlite3Fts3EvalTestDeferred(Fts3Cursor *pCsr, int *pRc);
186421 SQLITE_PRIVATE int sqlite3Fts3MsrIncrRestart(Fts3MultiSegReader *pCsr);
186467 static int fts3EvalNext(Fts3Cursor *pCsr);
186468 static int fts3EvalStart(Fts3Cursor *pCsr);
187892 sqlite3_vtab_cursor *pCsr; /* Allocated cursor */
187900 *ppCsr = pCsr = (sqlite3_vtab_cursor *)sqlite3_malloc(sizeof(Fts3Cursor));
187901 if( !pCsr ){
187904 memset(pCsr, 0, sizeof(Fts3Cursor));
187915 static void fts3CursorFinalizeStmt(Fts3Cursor *pCsr){
187916 if( pCsr->bSeekStmt ){
187917 Fts3Table *p = (Fts3Table *)pCsr->base.pVtab;
187919 p->pSeekStmt = pCsr->pStmt;
187920 sqlite3_reset(pCsr->pStmt);
187921 pCsr->pStmt = 0;
187923 pCsr->bSeekStmt = 0;
187925 sqlite3_finalize(pCsr->pStmt);
187932 static void fts3ClearCursor(Fts3Cursor *pCsr){
187933 fts3CursorFinalizeStmt(pCsr);
187934 sqlite3Fts3FreeDeferredTokens(pCsr);
187935 sqlite3_free(pCsr->aDoclist);
187936 sqlite3Fts3MIBufferFree(pCsr->pMIBuffer);
187937 sqlite3Fts3ExprFree(pCsr->pExpr);
187938 memset(&(&pCsr->base)[1], 0, sizeof(Fts3Cursor)-sizeof(sqlite3_vtab_cursor));
187946 Fts3Cursor *pCsr = (Fts3Cursor *)pCursor;
187947 assert( ((Fts3Table *)pCsr->base.pVtab)->pSegments==0 );
187948 fts3ClearCursor(pCsr);
187949 assert( ((Fts3Table *)pCsr->base.pVtab)->pSegments==0 );
187950 sqlite3_free(pCsr);
187963 static int fts3CursorSeekStmt(Fts3Cursor *pCsr){
187965 if( pCsr->pStmt==0 ){
187966 Fts3Table *p = (Fts3Table *)pCsr->base.pVtab;
187969 pCsr->pStmt = p->pSeekStmt;
187976 p->db, zSql,-1,SQLITE_PREPARE_PERSISTENT,&pCsr->pStmt,0
187981 if( rc==SQLITE_OK ) pCsr->bSeekStmt = 1;
187991 static int fts3CursorSeek(sqlite3_context *pContext, Fts3Cursor *pCsr){
187993 if( pCsr->isRequireSeek ){
187994 rc = fts3CursorSeekStmt(pCsr);
187996 Fts3Table *pTab = (Fts3Table*)pCsr->base.pVtab;
187998 sqlite3_bind_int64(pCsr->pStmt, 1, pCsr->iPrevId);
187999 pCsr->isRequireSeek = 0;
188000 if( SQLITE_ROW==sqlite3_step(pCsr->pStmt) ){
188005 rc = sqlite3_reset(pCsr->pStmt);
188006 if( rc==SQLITE_OK && ((Fts3Table *)pCsr->base.pVtab)->zContentTbl==0 ){
188011 pCsr->isEof = 1;
189093 Fts3MultiSegReader *pCsr,
189096 if( (pCsr->nSegment%16)==0 ){
189098 sqlite3_int64 nByte = (pCsr->nSegment + 16)*sizeof(Fts3SegReader*);
189099 apNew = (Fts3SegReader **)sqlite3_realloc64(pCsr->apSegment, nByte);
189104 pCsr->apSegment = apNew;
189106 pCsr->apSegment[pCsr->nSegment++] = pNew;
189126 Fts3MultiSegReader *pCsr /* Cursor object to populate */
189142 rc = fts3SegReaderCursorAppend(pCsr, pSeg);
189170 rc = sqlite3Fts3SegReaderNew(pCsr->nSegment+1,
189176 rc = fts3SegReaderCursorAppend(pCsr, pSeg);
189200 Fts3MultiSegReader *pCsr /* Cursor object to populate */
189211 memset(pCsr, 0, sizeof(Fts3MultiSegReader));
189213 p, iLangid, iIndex, iLevel, zTerm, nTerm, isPrefix, isScan, pCsr
189228 Fts3MultiSegReader *pCsr /* Fts3MultiSegReader to modify */
189231 iLangid, 0, FTS3_SEGCURSOR_ALL, zTerm, nTerm, 0, 0,pCsr
189249 Fts3Cursor *pCsr, /* Virtual table cursor handle */
189262 Fts3Table *p = (Fts3Table *)pCsr->base.pVtab;
189268 rc = sqlite3Fts3SegReaderCursor(p, pCsr->iLangid,
189278 rc = sqlite3Fts3SegReaderCursor(p, pCsr->iLangid,
189283 p, pCsr->iLangid, zTerm, nTerm, pSegcsr
189291 rc = sqlite3Fts3SegReaderCursor(p, pCsr->iLangid,
189399 Fts3Cursor *pCsr = (Fts3Cursor *)pCursor;
189400 if( pCsr->eSearch==FTS3_DOCID_SEARCH || pCsr->eSearch==FTS3_FULLSCAN_SEARCH ){
189403 if( SQLITE_ROW!=sqlite3_step(pCsr->pStmt) ){
189404 pCsr->isEof = 1;
189405 rc = sqlite3_reset(pCsr->pStmt);
189407 pCsr->iPrevId = sqlite3_column_int64(pCsr->pStmt, 0);
189414 assert( ((Fts3Table *)pCsr->base.pVtab)->pSegments==0 );
189460 Fts3Cursor *pCsr = (Fts3Cursor *)pCursor;
189488 fts3ClearCursor(pCsr);
189491 pCsr->iMinDocid = fts3DocidRange(pDocidGe, SMALLEST_INT64);
189492 pCsr->iMaxDocid = fts3DocidRange(pDocidLe, LARGEST_INT64);
189495 pCsr->bDesc = (idxStr[0]=='D');
189497 pCsr->bDesc = p->bDescIdx;
189499 pCsr->eSearch = (i16)eSearch;
189509 pCsr->iLangid = 0;
189510 if( pLangid ) pCsr->iLangid = sqlite3_value_int(pLangid);
189513 rc = sqlite3Fts3ExprParse(p->pTokenizer, pCsr->iLangid,
189514 p->azColumn, p->bFts4, p->nColumn, iCol, zQuery, -1, &pCsr->pExpr,
189521 rc = fts3EvalStart(pCsr);
189524 pCsr->pNextId = pCsr->aDoclist;
189525 pCsr->iPrevId = 0;
189537 p->zReadExprlist, pCsr->iMinDocid, pCsr->iMaxDocid,
189538 (pCsr->bDesc ? "DESC" : "ASC")
189542 p->zReadExprlist, (pCsr->bDesc ? "DESC" : "ASC")
189548 p->db,zSql,-1,SQLITE_PREPARE_PERSISTENT,&pCsr->pStmt,0
189556 rc = fts3CursorSeekStmt(pCsr);
189558 rc = sqlite3_bind_value(pCsr->pStmt, 1, pCons);
189571 Fts3Cursor *pCsr = (Fts3Cursor*)pCursor;
189572 if( pCsr->isEof ){
189573 fts3ClearCursor(pCsr);
189574 pCsr->isEof = 1;
189576 return pCsr->isEof;
189586 Fts3Cursor *pCsr = (Fts3Cursor *) pCursor;
189587 *pRowid = pCsr->iPrevId;
189608 Fts3Cursor *pCsr = (Fts3Cursor *) pCursor;
189617 sqlite3_result_pointer(pCtx, pCsr, "fts3cursor", 0);
189622 sqlite3_result_int64(pCtx, pCsr->iPrevId);
189626 if( pCsr->pExpr ){
189627 sqlite3_result_int64(pCtx, pCsr->iLangid);
189640 rc = fts3CursorSeek(0, pCsr);
189641 if( rc==SQLITE_OK && sqlite3_data_count(pCsr->pStmt)-1>iCol ){
189642 sqlite3_result_value(pCtx, sqlite3_column_value(pCsr->pStmt, iCol+1));
189647 assert( ((Fts3Table *)pCsr->base.pVtab)->pSegments==0 );
189862 Fts3Cursor *pCsr; /* Cursor handle passed through apVal[0] */
189879 if( fts3FunctionArg(pContext, "snippet", apVal[0], &pCsr) ) return;
189896 }else if( SQLITE_OK==fts3CursorSeek(pContext, pCsr) ){
189897 sqlite3Fts3Snippet(pContext, pCsr, zStart, zEnd, zEllipsis, iCol, nToken);
189909 Fts3Cursor *pCsr; /* Cursor handle passed through apVal[0] */
189914 if( fts3FunctionArg(pContext, "offsets", apVal[0], &pCsr) ) return;
189915 assert( pCsr );
189916 if( SQLITE_OK==fts3CursorSeek(pContext, pCsr) ){
189917 sqlite3Fts3Offsets(pContext, pCsr);
189969 Fts3Cursor *pCsr; /* Cursor handle passed through apVal[0] */
189971 if( SQLITE_OK==fts3FunctionArg(pContext, "matchinfo", apVal[0], &pCsr) ){
189976 sqlite3Fts3Matchinfo(pContext, pCsr, zArg);
190371 Fts3Cursor *pCsr, /* FTS cursor handle */
190384 int rc = fts3TermSegReaderCursor(pCsr,
190396 fts3EvalAllocateReaders(pCsr, pExpr->pLeft, pnToken, pnOr, pRc);
190397 fts3EvalAllocateReaders(pCsr, pExpr->pRight, pnToken, pnOr, pRc);
190477 Fts3Cursor *pCsr, /* FTS Cursor handle */
190480 Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab;
190513 static int fts3EvalDeferredPhrase(Fts3Cursor *pCsr, Fts3Phrase *pPhrase){
190568 pPhrase->doclist.iDocid = pCsr->iPrevId;
190629 static int fts3EvalPhraseStart(Fts3Cursor *pCsr, int bOptOk, Fts3Phrase *p){
190630 Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab;
190641 && pCsr->bDesc==pTab->bDescIdx
190668 rc = fts3EvalPhraseLoad(pCsr, p);
190896 Fts3Cursor *pCsr, /* FTS Cursor handle */
190902 Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab;
190915 int bDescDoclist = pCsr->bDesc;
190997 Fts3Cursor *pCsr, /* FTS Cursor handle */
191003 Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab;
191006 rc = fts3EvalIncrPhraseNext(pCsr, p, pbEof);
191007 }else if( pCsr->bDesc!=pTab->bDescIdx && pDL->nAll ){
191036 Fts3Cursor *pCsr, /* FTS Cursor handle */
191050 *pRc = fts3EvalPhraseStart(pCsr, 1, pExpr->pPhrase);
191052 fts3EvalStartReaders(pCsr, pExpr->pLeft, pRc);
191053 fts3EvalStartReaders(pCsr, pExpr->pRight, pRc);
191089 Fts3Cursor *pCsr, /* FTS Cursor handle */
191107 *pRc = sqlite3Fts3MsrOvfl(pCsr, pTC->pToken->pSegcsr, &pTC->nOvfl);
191120 fts3EvalTokenCosts(pCsr, pRoot, pExpr->pLeft, ppTC, ppOr, pRc);
191126 fts3EvalTokenCosts(pCsr, pRoot, pExpr->pRight, ppTC, ppOr, pRc);
191142 static int fts3EvalAverageDocsize(Fts3Cursor *pCsr, int *pnPage){
191144 if( pCsr->nRowAvg==0 ){
191156 Fts3Table *p = (Fts3Table*)pCsr->base.pVtab;
191179 pCsr->nDoc = nDoc;
191180 pCsr->nRowAvg = (int)(((nByte / nDoc) + p->nPgsz) / p->nPgsz);
191181 assert( pCsr->nRowAvg>0 );
191185 *pnPage = pCsr->nRowAvg;
191204 Fts3Cursor *pCsr, /* FTS Cursor handle */
191209 Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab;
191240 rc = fts3EvalAverageDocsize(pCsr, &nDocSize);
191286 rc = sqlite3Fts3DeferToken(pCsr, pToken, pTC->iCol);
191336 static int fts3EvalStart(Fts3Cursor *pCsr){
191337 Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab;
191343 fts3EvalAllocateReaders(pCsr, pCsr->pExpr, &nToken, &nOr, &rc);
191362 fts3EvalTokenCosts(pCsr, 0, pCsr->pExpr, &pTC, &ppOr, &rc);
191367 rc = fts3EvalSelectDeferred(pCsr, 0, aTC, nToken);
191369 rc = fts3EvalSelectDeferred(pCsr, apOr[ii], aTC, nToken);
191378 fts3EvalStartReaders(pCsr, pCsr->pExpr, &rc);
191493 Fts3Cursor *pCsr, /* FTS Cursor handle */
191498 int bDescDoclist = pCsr->bDesc; /* Used by DOCID_CMP() macro */
191511 fts3EvalNextRow(pCsr, pRight, pRc);
191517 fts3EvalNextRow(pCsr, pLeft, pRc);
191522 fts3EvalNextRow(pCsr, pLeft, pRc);
191523 fts3EvalNextRow(pCsr, pRight, pRc);
191528 fts3EvalNextRow(pCsr, pLeft, pRc);
191530 fts3EvalNextRow(pCsr, pRight, pRc);
191541 fts3EvalNextRow(pCsr, pRight, pRc);
191548 fts3EvalNextRow(pCsr, pLeft, pRc);
191566 fts3EvalNextRow(pCsr, pLeft, pRc);
191568 fts3EvalNextRow(pCsr, pRight, pRc);
191570 fts3EvalNextRow(pCsr, pLeft, pRc);
191571 fts3EvalNextRow(pCsr, pRight, pRc);
191590 fts3EvalNextRow(pCsr, pRight, pRc);
191594 fts3EvalNextRow(pCsr, pLeft, pRc);
191600 fts3EvalNextRow(pCsr, pRight, pRc);
191611 *pRc = fts3EvalPhraseNext(pCsr, pPhrase, &pExpr->bEof);
191717 Fts3Cursor *pCsr, /* FTS cursor handle */
191727 fts3EvalTestExpr(pCsr, pExpr->pLeft, pRc)
191728 && fts3EvalTestExpr(pCsr, pExpr->pRight, pRc)
191753 if( p->pRight->iDocid==pCsr->iPrevId ){
191757 if( p->iDocid==pCsr->iPrevId ){
191765 int bHit1 = fts3EvalTestExpr(pCsr, pExpr->pLeft, pRc);
191766 int bHit2 = fts3EvalTestExpr(pCsr, pExpr->pRight, pRc);
191773 fts3EvalTestExpr(pCsr, pExpr->pLeft, pRc)
191774 && !fts3EvalTestExpr(pCsr, pExpr->pRight, pRc)
191780 if( pCsr->pDeferred && (pExpr->bDeferred || (
191781 pExpr->iDocid==pCsr->iPrevId && pExpr->pPhrase->doclist.pList
191787 *pRc = fts3EvalDeferredPhrase(pCsr, pPhrase);
191789 pExpr->iDocid = pCsr->iPrevId;
191794 pExpr->bEof==0 && pExpr->iDocid==pCsr->iPrevId
191829 SQLITE_PRIVATE int sqlite3Fts3EvalTestDeferred(Fts3Cursor *pCsr, int *pRc){
191840 if( pCsr->pDeferred ){
191841 rc = fts3CursorSeek(0, pCsr);
191843 rc = sqlite3Fts3CacheDeferredDoclists(pCsr);
191846 bMiss = (0==fts3EvalTestExpr(pCsr, pCsr->pExpr, &rc));
191849 sqlite3Fts3FreeDeferredDoclists(pCsr);
191859 static int fts3EvalNext(Fts3Cursor *pCsr){
191861 Fts3Expr *pExpr = pCsr->pExpr;
191862 assert( pCsr->isEof==0 );
191864 pCsr->isEof = 1;
191867 if( pCsr->isRequireSeek==0 ){
191868 sqlite3_reset(pCsr->pStmt);
191870 assert( sqlite3_data_count(pCsr->pStmt)==0 );
191871 fts3EvalNextRow(pCsr, pExpr, &rc);
191872 pCsr->isEof = pExpr->bEof;
191873 pCsr->isRequireSeek = 1;
191874 pCsr->isMatchinfoNeeded = 1;
191875 pCsr->iPrevId = pExpr->iDocid;
191876 }while( pCsr->isEof==0 && sqlite3Fts3EvalTestDeferred(pCsr, &rc) );
191882 (pCsr->bDesc==0 && pCsr->iPrevId>pCsr->iMaxDocid)
191883 || (pCsr->bDesc!=0 && pCsr->iPrevId<pCsr->iMinDocid)
191885 pCsr->isEof = 1;
191901 Fts3Cursor *pCsr,
191919 *pRc = fts3EvalPhraseStart(pCsr, 0, pPhrase);
191930 fts3EvalRestart(pCsr, pExpr->pLeft, pRc);
191931 fts3EvalRestart(pCsr, pExpr->pRight, pRc);
192002 Fts3Cursor *pCsr, /* Cursor object */
192009 Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab;
192012 sqlite3_int64 iPrevId = pCsr->iPrevId;
192030 fts3EvalRestart(pCsr, pRoot, &rc);
192032 while( pCsr->isEof==0 && rc==SQLITE_OK ){
192036 if( pCsr->isRequireSeek==0 ) sqlite3_reset(pCsr->pStmt);
192037 assert( sqlite3_data_count(pCsr->pStmt)==0 );
192040 fts3EvalNextRow(pCsr, pRoot, &rc);
192041 pCsr->isEof = pRoot->bEof;
192042 pCsr->isRequireSeek = 1;
192043 pCsr->isMatchinfoNeeded = 1;
192044 pCsr->iPrevId = pRoot->iDocid;
192045 }while( pCsr->isEof==0
192047 && sqlite3Fts3EvalTestDeferred(pCsr, &rc)
192050 if( rc==SQLITE_OK && pCsr->isEof==0 ){
192055 pCsr->isEof = 0;
192056 pCsr->iPrevId = iPrevId;
192067 fts3EvalRestart(pCsr, pRoot, &rc);
192069 fts3EvalNextRow(pCsr, pRoot, &rc);
192109 Fts3Cursor *pCsr, /* FTS cursor handle */
192113 Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab;
192118 assert( pCsr->nDoc>0 );
192120 aiOut[iCol*3 + 1] = (u32)pCsr->nDoc;
192121 aiOut[iCol*3 + 2] = (u32)pCsr->nDoc;
192124 rc = fts3EvalGatherStats(pCsr, pExpr);
192157 Fts3Cursor *pCsr, /* FTS3 cursor object */
192163 Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab;
192178 if( iDocid!=pCsr->iPrevId || pExpr->bEof ){
192211 fts3EvalRestart(pCsr, pRun, &rc);
192213 fts3EvalNextRow(pCsr, pRun, &rc);
192223 fts3EvalNextRow(pCsr, pRun, &rc);
192240 if( pCsr->bDesc==bDescDoclist ){
192243 while( (pIter==0 || DOCID_CMP(iDocid, pCsr->iPrevId)<0 ) && bEof==0 ){
192251 while( (pIter==0 || DOCID_CMP(iDocid, pCsr->iPrevId)>0 ) && bEof==0 ){
192261 if( bEof || iDocid!=pCsr->iPrevId ) bMatch = 0;
192562 Fts3auxCursor *pCsr; /* Pointer to cursor object to return */
192566 pCsr = (Fts3auxCursor *)sqlite3_malloc(sizeof(Fts3auxCursor));
192567 if( !pCsr ) return SQLITE_NOMEM;
192568 memset(pCsr, 0, sizeof(Fts3auxCursor));
192570 *ppCsr = (sqlite3_vtab_cursor *)pCsr;
192579 Fts3auxCursor *pCsr = (Fts3auxCursor *)pCursor;
192582 sqlite3Fts3SegReaderFinish(&pCsr->csr);
192583 sqlite3_free((void *)pCsr->filter.zTerm);
192584 sqlite3_free(pCsr->zStop);
192585 sqlite3_free(pCsr->aStat);
192586 sqlite3_free(pCsr);
192590 static int fts3auxGrowStatArray(Fts3auxCursor *pCsr, int nSize){
192591 if( nSize>pCsr->nStat ){
192593 aNew = (struct Fts3auxColstats *)sqlite3_realloc64(pCsr->aStat,
192597 memset(&aNew[pCsr->nStat], 0,
192598 sizeof(struct Fts3auxColstats) * (nSize - pCsr->nStat)
192600 pCsr->aStat = aNew;
192601 pCsr->nStat = nSize;
192610 Fts3auxCursor *pCsr = (Fts3auxCursor *)pCursor;
192615 pCsr->iRowid++;
192617 for(pCsr->iCol++; pCsr->iCol<pCsr->nStat; pCsr->iCol++){
192618 if( pCsr->aStat[pCsr->iCol].nDoc>0 ) return SQLITE_OK;
192621 rc = sqlite3Fts3SegReaderStep(pFts3, &pCsr->csr);
192624 int nDoclist = pCsr->csr.nDoclist;
192625 char *aDoclist = pCsr->csr.aDoclist;
192630 if( pCsr->zStop ){
192631 int n = (pCsr->nStop<pCsr->csr.nTerm) ? pCsr->nStop : pCsr->csr.nTerm;
192632 int mc = memcmp(pCsr->zStop, pCsr->csr.zTerm, n);
192633 if( mc<0 || (mc==0 && pCsr->csr.nTerm>pCsr->nStop) ){
192634 pCsr->isEof = 1;
192639 if( fts3auxGrowStatArray(pCsr, 2) ) return SQLITE_NOMEM;
192640 memset(pCsr->aStat, 0, sizeof(struct Fts3auxColstats) * pCsr->nStat);
192651 pCsr->aStat[0].nDoc++;
192667 pCsr->aStat[1].nDoc++;
192678 pCsr->aStat[iCol+1].nOcc++;
192679 pCsr->aStat[0].nOcc++;
192690 if( fts3auxGrowStatArray(pCsr, iCol+2) ) return SQLITE_NOMEM;
192691 pCsr->aStat[iCol+1].nDoc++;
192697 pCsr->iCol = 0;
192699 pCsr->isEof = 1;
192714 Fts3auxCursor *pCsr = (Fts3auxCursor *)pCursor;
192751 testcase(pCsr->filter.zTerm);
192752 sqlite3Fts3SegReaderFinish(&pCsr->csr);
192753 sqlite3_free((void *)pCsr->filter.zTerm);
192754 sqlite3_free(pCsr->aStat);
192755 sqlite3_free(pCsr->zStop);
192756 memset(&pCsr->csr, 0, ((u8*)&pCsr[1]) - (u8*)&pCsr->csr);
192758 pCsr->filter.flags = FTS3_SEGMENT_REQUIRE_POS|FTS3_SEGMENT_IGNORE_EMPTY;
192759 if( isScan ) pCsr->filter.flags |= FTS3_SEGMENT_SCAN;
192765 pCsr->filter.zTerm = sqlite3_mprintf("%s", zStr);
192766 if( pCsr->filter.zTerm==0 ) return SQLITE_NOMEM;
192767 pCsr->filter.nTerm = (int)strlen(pCsr->filter.zTerm);
192772 pCsr->zStop = sqlite3_mprintf("%s", sqlite3_value_text(apVal[iLe]));
192773 if( pCsr->zStop==0 ) return SQLITE_NOMEM;
192774 pCsr->nStop = (int)strlen(pCsr->zStop);
192787 pCsr->iLangid = iLangVal;
192790 pCsr->filter.zTerm, pCsr->filter.nTerm, 0, isScan, &pCsr->csr
192793 rc = sqlite3Fts3SegReaderStart(pFts3, &pCsr->csr, &pCsr->filter);
192804 Fts3auxCursor *pCsr = (Fts3auxCursor *)pCursor;
192805 return pCsr->isEof;
192856 Fts3auxCursor *pCsr = (Fts3auxCursor *)pCursor;
192857 *pRowid = pCsr->iRowid;
193041 sqlite3_tokenizer_cursor *pCsr = 0;
193044 rc = pModule->xOpen(pTokenizer, z, n, &pCsr);
193045 assert( rc==SQLITE_OK || pCsr==0 );
193047 pCsr->pTokenizer = pTokenizer;
193049 rc = pModule->xLanguageid(pCsr, iLangid);
193051 pModule->xClose(pCsr);
193052 pCsr = 0;
193056 *ppCsr = pCsr;
195518 sqlite3_tokenizer_cursor *pCsr = 0;
195570 if( sqlite3Fts3OpenTokenizer(pTokenizer, 0, zInput, nInput, &pCsr) ){
195575 while( SQLITE_OK==p->xNext(pCsr, &zToken, &nToken, &iStart, &iEnd, &iPos) ){
195583 if( SQLITE_OK!=p->xClose(pCsr) ){
196074 sqlite3_tokenizer_cursor *pCsr; /* Cursor to iterate through zInput */
196273 Fts3tokCursor *pCsr;
196276 pCsr = (Fts3tokCursor *)sqlite3_malloc(sizeof(Fts3tokCursor));
196277 if( pCsr==0 ){
196280 memset(pCsr, 0, sizeof(Fts3tokCursor));
196282 *ppCsr = (sqlite3_vtab_cursor *)pCsr;
196290 static void fts3tokResetCursor(Fts3tokCursor *pCsr){
196291 if( pCsr->pCsr ){
196292 Fts3tokTable *pTab = (Fts3tokTable *)(pCsr->base.pVtab);
196293 pTab->pMod->xClose(pCsr->pCsr);
196294 pCsr->pCsr = 0;
196296 sqlite3_free(pCsr->zInput);
196297 pCsr->zInput = 0;
196298 pCsr->zToken = 0;
196299 pCsr->nToken = 0;
196300 pCsr->iStart = 0;
196301 pCsr->iEnd = 0;
196302 pCsr->iPos = 0;
196303 pCsr->iRowid = 0;
196310 Fts3tokCursor *pCsr = (Fts3tokCursor *)pCursor;
196312 fts3tokResetCursor(pCsr);
196313 sqlite3_free(pCsr);
196321 Fts3tokCursor *pCsr = (Fts3tokCursor *)pCursor;
196325 pCsr->iRowid++;
196326 rc = pTab->pMod->xNext(pCsr->pCsr,
196327 &pCsr->zToken, &pCsr->nToken,
196328 &pCsr->iStart, &pCsr->iEnd, &pCsr->iPos
196332 fts3tokResetCursor(pCsr);
196350 Fts3tokCursor *pCsr = (Fts3tokCursor *)pCursor;
196355 fts3tokResetCursor(pCsr);
196359 pCsr->zInput = sqlite3_malloc64(nByte+1);
196360 if( pCsr->zInput==0 ){
196363 if( nByte>0 ) memcpy(pCsr->zInput, zByte, nByte);
196364 pCsr->zInput[nByte] = 0;
196365 rc = pTab->pMod->xOpen(pTab->pTok, pCsr->zInput, nByte, &pCsr->pCsr);
196367 pCsr->pCsr->pTokenizer = pTab->pTok;
196380 Fts3tokCursor *pCsr = (Fts3tokCursor *)pCursor;
196381 return (pCsr->zToken==0);
196392 Fts3tokCursor *pCsr = (Fts3tokCursor *)pCursor;
196397 sqlite3_result_text(pCtx, pCsr->zInput, -1, SQLITE_TRANSIENT);
196400 sqlite3_result_text(pCtx, pCsr->zToken, pCsr->nToken, SQLITE_TRANSIENT);
196403 sqlite3_result_int(pCtx, pCsr->iStart);
196406 sqlite3_result_int(pCtx, pCsr->iEnd);
196410 sqlite3_result_int(pCtx, pCsr->iPos);
196423 Fts3tokCursor *pCsr = (Fts3tokCursor *)pCursor;
196424 *pRowid = (sqlite3_int64)pCsr->iRowid;
197277 sqlite3_tokenizer_cursor *pCsr;
197291 rc = sqlite3Fts3OpenTokenizer(pTokenizer, iLangid, zText, -1, &pCsr);
197298 && SQLITE_OK==(rc = xNext(pCsr, &zToken, &nToken, &iStart, &iEnd, &iPos))
197327 pModule->xClose(pCsr);
198034 Fts3Cursor *pCsr,
198038 Fts3Table *p = (Fts3Table*)pCsr->base.pVtab;
199226 Fts3MultiSegReader *pCsr, /* Cursor object */
199231 int nSeg = pCsr->nSegment;
199239 for(i=0; pCsr->bRestart==0 && i<pCsr->nSegment; i++){
199241 Fts3SegReader *pSeg = pCsr->apSegment[i];
199251 fts3SegReaderSort(pCsr->apSegment, nSeg, nSeg, fts3SegReaderCmp);
199258 Fts3MultiSegReader *pCsr, /* Cursor object */
199261 pCsr->pFilter = pFilter;
199262 return fts3SegReaderStart(p, pCsr, pFilter->zTerm, pFilter->nTerm);
199267 Fts3MultiSegReader *pCsr, /* Cursor object */
199274 int nSegment = pCsr->nSegment;
199279 assert( pCsr->pFilter==0 );
199283 rc = fts3SegReaderStart(p, pCsr, zTerm, nTerm);
199288 Fts3SegReader *pSeg = pCsr->apSegment[i];
199293 pCsr->nAdvance = i;
199296 for(i=0; i<pCsr->nAdvance; i++){
199297 rc = fts3SegReaderFirstDocid(p, pCsr->apSegment[i]);
199300 fts3SegReaderSort(pCsr->apSegment, i, i, xCmp);
199303 pCsr->iColFilter = iCol;
199320 SQLITE_PRIVATE int sqlite3Fts3MsrIncrRestart(Fts3MultiSegReader *pCsr){
199323 assert( pCsr->zTerm==0 );
199324 assert( pCsr->nTerm==0 );
199325 assert( pCsr->aDoclist==0 );
199326 assert( pCsr->nDoclist==0 );
199328 pCsr->nAdvance = 0;
199329 pCsr->bRestart = 1;
199330 for(i=0; i<pCsr->nSegment; i++){
199331 pCsr->apSegment[i]->pOffsetList = 0;
199332 pCsr->apSegment[i]->nOffsetList = 0;
199333 pCsr->apSegment[i]->iDocid = 0;
199339 static int fts3GrowSegReaderBuffer(Fts3MultiSegReader *pCsr, i64 nReq){
199340 if( nReq>pCsr->nBuffer ){
199342 pCsr->nBuffer = nReq*2;
199343 aNew = sqlite3_realloc64(pCsr->aBuffer, pCsr->nBuffer);
199347 pCsr->aBuffer = aNew;
199355 Fts3MultiSegReader *pCsr /* Cursor object */
199359 int isIgnoreEmpty = (pCsr->pFilter->flags & FTS3_SEGMENT_IGNORE_EMPTY);
199360 int isRequirePos = (pCsr->pFilter->flags & FTS3_SEGMENT_REQUIRE_POS);
199361 int isColFilter = (pCsr->pFilter->flags & FTS3_SEGMENT_COLUMN_FILTER);
199362 int isPrefix = (pCsr->pFilter->flags & FTS3_SEGMENT_PREFIX);
199363 int isScan = (pCsr->pFilter->flags & FTS3_SEGMENT_SCAN);
199364 int isFirst = (pCsr->pFilter->flags & FTS3_SEGMENT_FIRST);
199366 Fts3SegReader **apSegment = pCsr->apSegment;
199367 int nSegment = pCsr->nSegment;
199368 Fts3SegFilter *pFilter = pCsr->pFilter;
199373 if( pCsr->nSegment==0 ) return SQLITE_OK;
199382 for(i=0; i<pCsr->nAdvance; i++){
199391 fts3SegReaderSort(apSegment, nSegment, pCsr->nAdvance, fts3SegReaderCmp);
199392 pCsr->nAdvance = 0;
199398 pCsr->nTerm = apSegment[0]->nTerm;
199399 pCsr->zTerm = apSegment[0]->zTerm;
199409 if( pCsr->nTerm<pFilter->nTerm
199410 || (!isPrefix && pCsr->nTerm>pFilter->nTerm)
199411 || memcmp(pCsr->zTerm, pFilter->zTerm, pFilter->nTerm)
199420 && apSegment[nMerge]->nTerm==pCsr->nTerm
199421 && 0==memcmp(pCsr->zTerm, apSegment[nMerge]->zTerm, pCsr->nTerm)
199432 pCsr->nDoclist = apSegment[0]->nDoclist;
199434 rc = fts3MsrBufferData(pCsr, apSegment[0]->aDoclist,
199435 (i64)pCsr->nDoclist);
199436 pCsr->aDoclist = pCsr->aBuffer;
199438 pCsr->aDoclist = apSegment[0]->aDoclist;
199488 rc = fts3GrowSegReaderBuffer(pCsr,
199493 char *a = &pCsr->aBuffer[nDoclist];
199502 nDoclist += sqlite3Fts3PutVarint(&pCsr->aBuffer[nDoclist], iDelta);
199505 memcpy(&pCsr->aBuffer[nDoclist], pList, nList);
199507 pCsr->aBuffer[nDoclist++] = '\0';
199515 rc = fts3GrowSegReaderBuffer(pCsr, (i64)nDoclist+FTS3_NODE_PADDING);
199517 memset(&pCsr->aBuffer[nDoclist], 0, FTS3_NODE_PADDING);
199518 pCsr->aDoclist = pCsr->aBuffer;
199519 pCsr->nDoclist = nDoclist;
199523 pCsr->nAdvance = nMerge;
199531 Fts3MultiSegReader *pCsr /* Cursor object */
199533 if( pCsr ){
199535 for(i=0; i<pCsr->nSegment; i++){
199536 sqlite3Fts3SegReaderFree(pCsr->apSegment[i]);
199538 sqlite3_free(pCsr->apSegment);
199539 sqlite3_free(pCsr->aBuffer);
199541 pCsr->nSegment = 0;
199542 pCsr->apSegment = 0;
199543 pCsr->aBuffer = 0;
200116 Fts3MultiSegReader *pCsr /* Cursor object to populate */
200123 memset(pCsr, 0, sizeof(*pCsr));
200125 pCsr->apSegment = (Fts3SegReader **)sqlite3_malloc64(nByte);
200127 if( pCsr->apSegment==0 ){
200130 memset(pCsr->apSegment, 0, nByte);
200137 assert( pCsr->nSegment==0 );
200145 &pCsr->apSegment[i]
200147 pCsr->nSegment++;
200491 Fts3MultiSegReader *pCsr /* Cursor containing term and doclist */
200493 const char *zTerm = pCsr->zTerm;
200494 int nTerm = pCsr->nTerm;
200495 const char *aDoclist = pCsr->aDoclist;
200496 int nDoclist = pCsr->nDoclist;
200930 Fts3MultiSegReader *pCsr, /* Cursor that data will be read from */
200943 sqlite3_bind_int64(pLeafEst, 2, pCsr->nSegment);
201237 Fts3MultiSegReader *pCsr, /* Chomp all segments opened by this cursor */
201244 for(i=pCsr->nSegment-1; i>=0 && rc==SQLITE_OK; i--){
201250 for(j=0; ALWAYS(j<pCsr->nSegment); j++){
201251 pSeg = pCsr->apSegment[j];
201254 assert( j<pCsr->nSegment && pSeg->iIdx==i );
201274 if( rc==SQLITE_OK && nRem!=pCsr->nSegment ){
201399 Fts3MultiSegReader *pCsr; /* Cursor used to read input data */
201408 const int nAlloc = sizeof(*pCsr) + sizeof(*pFilter) + sizeof(*pWriter);
201412 pCsr = (Fts3MultiSegReader *)&pFilter[1];
201500 rc = fts3IncrmergeCsr(p, iAbsLevel, nSeg, pCsr);
201502 if( SQLITE_OK==rc && pCsr->nSegment==nSeg
201503 && SQLITE_OK==(rc = sqlite3Fts3SegReaderStart(p, pCsr, pFilter))
201506 rc = sqlite3Fts3SegReaderStep(p, pCsr);
201510 sqlite3Fts3SegReaderFinish(pCsr);
201514 const char *zKey = pCsr->zTerm;
201515 int nKey = pCsr->nTerm;
201518 rc = fts3IncrmergeWriter(p, iAbsLevel, iIdx, pCsr, pWriter);
201525 rc = fts3IncrmergeAppend(p, pWriter, pCsr);
201526 if( rc==SQLITE_OK ) rc = sqlite3Fts3SegReaderStep(p, pCsr);
201534 rc = fts3IncrmergeChomp(p, iAbsLevel, pCsr, &nSeg);
201551 sqlite3Fts3SegReaderFinish(pCsr);
201717 char *pCsr = csr.aDoclist;
201718 char *pEnd = &pCsr[csr.nDoclist];
201724 pCsr += sqlite3Fts3GetVarint(pCsr, &iDocid);
201725 while( pCsr<pEnd ){
201727 pCsr += sqlite3Fts3GetVarintU(pCsr, &iVal);
201728 if( pCsr<pEnd ){
201733 pCsr += sqlite3Fts3GetVarint(pCsr, &iCol);
201735 pCsr += sqlite3Fts3GetVarintU(pCsr, &iVal);
201953 SQLITE_PRIVATE void sqlite3Fts3FreeDeferredDoclists(Fts3Cursor *pCsr){
201955 for(pDef=pCsr->pDeferred; pDef; pDef=pDef->pNext){
201965 SQLITE_PRIVATE void sqlite3Fts3FreeDeferredTokens(Fts3Cursor *pCsr){
201968 for(pDef=pCsr->pDeferred; pDef; pDef=pNext){
201973 pCsr->pDeferred = 0;
201984 SQLITE_PRIVATE int sqlite3Fts3CacheDeferredDoclists(Fts3Cursor *pCsr){
201986 if( pCsr->pDeferred ){
201991 Fts3Table *p = (Fts3Table *)pCsr->base.pVtab;
201995 assert( pCsr->isRequireSeek==0 );
201996 iDocid = sqlite3_column_int64(pCsr->pStmt, 0);
202000 const char *zText = (const char *)sqlite3_column_text(pCsr->pStmt, i+1);
202003 rc = sqlite3Fts3OpenTokenizer(pT, pCsr->iLangid, zText, -1, &pTC);
202011 for(pDef=pCsr->pDeferred; pDef && rc==SQLITE_OK; pDef=pDef->pNext){
202027 for(pDef=pCsr->pDeferred; pDef && rc==SQLITE_OK; pDef=pDef->pNext){
202068 Fts3Cursor *pCsr, /* Fts3 table cursor */
202079 pDeferred->pNext = pCsr->pDeferred;
202081 pCsr->pDeferred = pDeferred;
202357 Fts3Cursor *pCsr; /* FTS3 Cursor */
202371 Fts3Cursor *pCsr; /* Cursor snippet is being generated from */
202627 Fts3Cursor *pCsr, /* Fts3 cursor for current query */
202633 sCtx.pCsr = pCsr;
202634 rc = sqlite3Fts3ExprIterate(pCsr->pExpr,fts3ExprLoadDoclistsCb,(void*)&sCtx);
202741 char *pCsr = pPhrase->pTail;
202761 if( 0==(*pCsr & 0x0FE) ) break;
202762 fts3GetDeltaPosition(&pCsr, &iCsr);
202782 char *pCsr;
202786 rc = sqlite3Fts3EvalPhrasePoslist(p->pCsr, pExpr, p->iCol, &pCsr);
202787 assert( rc==SQLITE_OK || pCsr==0 );
202788 if( pCsr ){
202790 pPhrase->pList = pCsr;
202791 fts3GetDeltaPosition(&pCsr, &iFirst);
202795 pPhrase->pHead = pCsr;
202796 pPhrase->pTail = pCsr;
202826 Fts3Cursor *pCsr, /* Cursor to create snippet for */
202845 rc = fts3ExprLoadDoclists(pCsr, &nList, 0);
202862 sIter.pCsr = pCsr;
202868 pCsr->pExpr, fts3SnippetFindPositions, (void*)&sIter
203029 Fts3Cursor *pCsr, /* FTS3 Cursor */
203039 Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab;
203052 zDoc = (const char *)sqlite3_column_text(pCsr->pStmt, iCol);
203054 if( sqlite3_column_type(pCsr->pStmt, iCol)!=SQLITE_NULL ){
203059 nDoc = sqlite3_column_bytes(pCsr->pStmt, iCol);
203063 rc = sqlite3Fts3OpenTokenizer(pTab->pTokenizer, pCsr->iLangid, zDoc,nDoc,&pC);
203102 pTab, pCsr->iLangid, nSnippet, &zDoc[iBegin], n, &iPos, &hlmask
203283 char *pCsr;
203284 rc = sqlite3Fts3EvalPhrasePoslist(p->pCursor, pExpr, i, &pCsr);
203285 if( pCsr ){
203286 p->aMatchinfo[iStart+i*3] = fts3ColumnlistCount(&pCsr);
203452 static int fts3MatchinfoLcs(Fts3Cursor *pCsr, MatchInfo *pInfo){
203462 aIter = sqlite3Fts3MallocZero(sizeof(LcsIterator) * pCsr->nPhrase);
203464 (void)sqlite3Fts3ExprIterate(pCsr->pExpr, fts3MatchinfoLcsCb, (void*)aIter);
203478 rc = sqlite3Fts3EvalPhrasePoslist(pCsr, pIt->pExpr, iCol, &pIt->pRead);
203541 Fts3Cursor *pCsr, /* FTS3 cursor object */
203548 Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab;
203596 rc = sqlite3Fts3SelectDocsize(pTab, pCsr->iPrevId, &pSelectDocsize);
203616 rc = fts3ExprLoadDoclists(pCsr, 0, 0);
203618 rc = fts3MatchinfoLcs(pCsr, pInfo);
203626 rc = fts3ExprLHitGather(pCsr->pExpr, pInfo);
203633 pExpr = pCsr->pExpr;
203634 rc = fts3ExprLoadDoclists(pCsr, 0, 0);
203637 if( pCsr->pDeferred ){
203642 sqlite3Fts3EvalTestDeferred(pCsr, &rc);
203664 Fts3Cursor *pCsr, /* FTS3 Cursor object */
203668 Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab;
203676 sInfo.pCursor = pCsr;
203682 if( pCsr->pMIBuffer && strcmp(pCsr->pMIBuffer->zMatchinfo, zArg) ){
203683 sqlite3Fts3MIBufferFree(pCsr->pMIBuffer);
203684 pCsr->pMIBuffer = 0;
203692 if( pCsr->pMIBuffer==0 ){
203697 pCsr->nPhrase = fts3ExprPhraseCount(pCsr->pExpr);
203698 sInfo.nPhrase = pCsr->nPhrase;
203712 pCsr->pMIBuffer = fts3MIBufferNew(nMatchinfo, zArg);
203713 if( !pCsr->pMIBuffer ) rc = SQLITE_NOMEM;
203715 pCsr->isMatchinfoNeeded = 1;
203720 xDestroyOut = fts3MIBufferAlloc(pCsr->pMIBuffer, &aOut);
203728 sInfo.nPhrase = pCsr->nPhrase;
203729 rc = fts3MatchinfoValues(pCsr, bGlobal, &sInfo, zArg);
203731 fts3MIBufferSetGlobal(pCsr->pMIBuffer);
203739 int n = pCsr->pMIBuffer->nElem * sizeof(u32);
203749 Fts3Cursor *pCsr, /* Cursor object */
203756 Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab;
203773 if( !pCsr->pExpr ){
203811 rc = fts3BestSnippet(nFToken, pCsr, iRead, mCovered, &mSeen, &sF, &iS);
203834 rc = fts3SnippetText(pCsr, &aSnippet[i],
203860 Fts3Cursor *pCsr;
203879 rc = sqlite3Fts3EvalPhrasePoslist(p->pCsr, pExpr, p->iCol, &pList);
203901 Fts3Cursor *pCsr /* Cursor object */
203903 Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab;
203911 if( !pCsr->pExpr ){
203917 assert( pCsr->isRequireSeek==0 );
203920 rc = fts3ExprLoadDoclists(pCsr, 0, &nToken);
203929 sCtx.iDocid = pCsr->iPrevId;
203930 sCtx.pCsr = pCsr;
203951 pCsr->pExpr, fts3ExprTermOffsetInit, (void*)&sCtx
203961 zDoc = (const char *)sqlite3_column_text(pCsr->pStmt, iCol+1);
203962 nDoc = sqlite3_column_bytes(pCsr->pStmt, iCol+1);
203964 if( sqlite3_column_type(pCsr->pStmt, iCol+1)==SQLITE_NULL ){
203972 rc = sqlite3Fts3OpenTokenizer(pTab->pTokenizer, pCsr->iLangid,
204041 Fts3Cursor *pCsr, /* FTS3 table cursor */
204044 Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab;
204053 if( !pCsr->pExpr ){
204058 fts3GetMatchinfo(pContext, pCsr, zFormat);
204343 unicode_cursor *pCsr;
204345 pCsr = (unicode_cursor *)sqlite3_malloc(sizeof(unicode_cursor));
204346 if( pCsr==0 ){
204349 memset(pCsr, 0, sizeof(unicode_cursor));
204351 pCsr->aInput = (const unsigned char *)aInput;
204353 pCsr->nInput = 0;
204354 pCsr->aInput = (const unsigned char*)"";
204356 pCsr->nInput = (int)strlen(aInput);
204358 pCsr->nInput = nInput;
204361 *pp = &pCsr->base;
204371 unicode_cursor *pCsr = (unicode_cursor *) pCursor;
204372 sqlite3_free(pCsr->zToken);
204373 sqlite3_free(pCsr);
204389 unicode_cursor *pCsr = (unicode_cursor *)pC;
204390 unicode_tokenizer *p = ((unicode_tokenizer *)pCsr->base.pTokenizer);
204393 const unsigned char *z = &pCsr->aInput[pCsr->iOff];
204396 const unsigned char *zTerm = &pCsr->aInput[pCsr->nInput];
204408 zOut = pCsr->zToken;
204413 if( (zOut-pCsr->zToken)>=(pCsr->nAlloc-4) ){
204414 char *zNew = sqlite3_realloc64(pCsr->zToken, pCsr->nAlloc+64);
204416 zOut = &zNew[zOut - pCsr->zToken];
204417 pCsr->zToken = zNew;
204418 pCsr->nAlloc += 64;
204436 pCsr->iOff = (int)(z - pCsr->aInput);
204437 *paToken = pCsr->zToken;
204438 *pnToken = (int)(zOut - pCsr->zToken);
204439 *piStart = (int)(zStart - pCsr->aInput);
204440 *piEnd = (int)(zEnd - pCsr->aInput);
204441 *piPos = pCsr->iToken++;
211396 RtreeCursor *pCsr;
211398 pCsr = (RtreeCursor *)sqlite3_malloc64(sizeof(RtreeCursor));
211399 if( pCsr ){
211400 memset(pCsr, 0, sizeof(RtreeCursor));
211401 pCsr->base.pVtab = pVTab;
211405 *ppCursor = (sqlite3_vtab_cursor *)pCsr;
211414 static void resetCursor(RtreeCursor *pCsr){
211415 Rtree *pRtree = (Rtree *)(pCsr->base.pVtab);
211418 if( pCsr->aConstraint ){
211420 for(i=0; i<pCsr->nConstraint; i++){
211421 sqlite3_rtree_query_info *pInfo = pCsr->aConstraint[i].pInfo;
211427 sqlite3_free(pCsr->aConstraint);
211428 pCsr->aConstraint = 0;
211430 for(ii=0; ii<RTREE_CACHE_SZ; ii++) nodeRelease(pRtree, pCsr->aNode[ii]);
211431 sqlite3_free(pCsr->aPoint);
211432 pStmt = pCsr->pReadAux;
211433 memset(pCsr, 0, sizeof(RtreeCursor));
211434 pCsr->base.pVtab = (sqlite3_vtab*)pRtree;
211435 pCsr->pReadAux = pStmt;
211444 RtreeCursor *pCsr = (RtreeCursor *)cur;
211446 resetCursor(pCsr);
211447 sqlite3_finalize(pCsr->pReadAux);
211448 sqlite3_free(pCsr);
211463 RtreeCursor *pCsr = (RtreeCursor *)cur;
211464 return pCsr->atEOF;
212014 RtreeCursor *pCsr = (RtreeCursor *)pVtabCursor;
212018 RTREE_QUEUE_TRACE(pCsr, "POP-Nx:");
212019 if( pCsr->bAuxValid ){
212020 pCsr->bAuxValid = 0;
212021 sqlite3_reset(pCsr->pReadAux);
212023 rtreeSearchPointPop(pCsr);
212024 rc = rtreeStepToLeaf(pCsr);
212032 RtreeCursor *pCsr = (RtreeCursor *)pVtabCursor;
212033 RtreeSearchPoint *p = rtreeSearchPointFirst(pCsr);
212035 RtreeNode *pNode = rtreeNodeOfFirstSearchPoint(pCsr, &rc);
212040 *pRowid = nodeGetRowid(RTREE_OF_CURSOR(pCsr), pNode, p->iCell);
212051 RtreeCursor *pCsr = (RtreeCursor *)cur;
212052 RtreeSearchPoint *p = rtreeSearchPointFirst(pCsr);
212055 RtreeNode *pNode = rtreeNodeOfFirstSearchPoint(pCsr, &rc);
212074 if( !pCsr->bAuxValid ){
212075 if( pCsr->pReadAux==0 ){
212077 &pCsr->pReadAux, 0);
212080 sqlite3_bind_int64(pCsr->pReadAux, 1,
212082 rc = sqlite3_step(pCsr->pReadAux);
212084 pCsr->bAuxValid = 1;
212086 sqlite3_reset(pCsr->pReadAux);
212092 sqlite3_column_value(pCsr->pReadAux, i - pRtree->nDim2 + 1));
212168 RtreeCursor *pCsr = (RtreeCursor *)pVtabCursor;
212177 resetCursor(pCsr);
212179 pCsr->iStrategy = idxNum;
212197 p = rtreeSearchPointNew(pCsr, RTREE_ZERO, 0);
212199 pCsr->aNode[0] = pLeaf;
212204 RTREE_QUEUE_TRACE(pCsr, "PUSH-F1:");
212206 pCsr->atEOF = 1;
212214 pCsr->aConstraint = sqlite3_malloc64(sizeof(RtreeConstraint)*argc);
212215 pCsr->nConstraint = argc;
212216 if( !pCsr->aConstraint ){
212219 memset(pCsr->aConstraint, 0, sizeof(RtreeConstraint)*argc);
212220 memset(pCsr->anQueue, 0, sizeof(u32)*(pRtree->iDepth + 1));
212224 RtreeConstraint *p = &pCsr->aConstraint[ii];
212238 p->pInfo->anQueue = pCsr->anQueue;
212274 assert( pCsr->bPoint==0 ); /* Due to the resetCursor() call above */
212275 pNew = rtreeSearchPointNew(pCsr, RTREE_ZERO, (u8)(pRtree->iDepth+1));
212282 assert( pCsr->bPoint==1 );
212283 pCsr->aNode[0] = pRoot;
212285 RTREE_QUEUE_TRACE(pCsr, "PUSH-Fm:");
212286 rc = rtreeStepToLeaf(pCsr);
215970 RtreeCursor *pCsr = (RtreeCursor *)pVtabCursor;
215979 resetCursor(pCsr);
215981 pCsr->iStrategy = idxNum;
215990 p = rtreeSearchPointNew(pCsr, RTREE_ZERO, 0);
215992 pCsr->aNode[0] = pLeaf;
215997 RTREE_QUEUE_TRACE(pCsr, "PUSH-F1:");
215999 pCsr->atEOF = 1;
216015 pCsr->aConstraint = p = sqlite3_malloc(sizeof(RtreeConstraint)*4);
216016 pCsr->nConstraint = 4;
216020 memset(pCsr->aConstraint, 0, sizeof(RtreeConstraint)*4);
216021 memset(pCsr->anQueue, 0, sizeof(u32)*(pRtree->iDepth + 1));
216061 pNew = rtreeSearchPointNew(pCsr, RTREE_ZERO, (u8)(pRtree->iDepth+1));
216069 assert( pCsr->bPoint==1 );
216070 pCsr->aNode[0] = pRoot;
216072 RTREE_QUEUE_TRACE(pCsr, "PUSH-Fm:");
216073 rc = rtreeStepToLeaf(pCsr);
216151 RtreeCursor *pCsr = (RtreeCursor *)cur;
216152 RtreeSearchPoint *p = rtreeSearchPointFirst(pCsr);
216154 RtreeNode *pNode = rtreeNodeOfFirstSearchPoint(pCsr, &rc);
216160 if( !pCsr->bAuxValid ){
216161 if( pCsr->pReadAux==0 ){
216163 &pCsr->pReadAux, 0);
216166 sqlite3_bind_int64(pCsr->pReadAux, 1,
216168 rc = sqlite3_step(pCsr->pReadAux);
216170 pCsr->bAuxValid = 1;
216172 sqlite3_reset(pCsr->pReadAux);
216177 sqlite3_result_value(ctx, sqlite3_column_value(pCsr->pReadAux, i+2));
217317 IcuCursor *pCsr;
217336 pCsr = (IcuCursor *)sqlite3_malloc64(
217341 if( !pCsr ){
217344 memset(pCsr, 0, sizeof(IcuCursor));
217345 pCsr->aChar = (UChar *)&pCsr[1];
217346 pCsr->aOffset = (int *)&pCsr->aChar[(nChar+3)&~3];
217348 pCsr->aOffset[iOut] = iInput;
217353 U16_APPEND(pCsr->aChar, iOut, nChar, c, isError);
217355 sqlite3_free(pCsr);
217358 pCsr->aOffset[iOut] = iInput;
217367 pCsr->pIter = ubrk_open(UBRK_WORD, p->zLocale, pCsr->aChar, iOut, &status);
217369 sqlite3_free(pCsr);
217372 pCsr->nChar = iOut;
217374 ubrk_first(pCsr->pIter);
217375 *ppCursor = (sqlite3_tokenizer_cursor *)pCsr;
217383 IcuCursor *pCsr = (IcuCursor *)pCursor;
217384 ubrk_close(pCsr->pIter);
217385 sqlite3_free(pCsr->zBuffer);
217386 sqlite3_free(pCsr);
217401 IcuCursor *pCsr = (IcuCursor *)pCursor;
217410 iStart = ubrk_current(pCsr->pIter);
217411 iEnd = ubrk_next(pCsr->pIter);
217418 U16_NEXT(pCsr->aChar, iWhite, pCsr->nChar, c);
217431 char *zNew = sqlite3_realloc(pCsr->zBuffer, nByte);
217435 pCsr->zBuffer = zNew;
217436 pCsr->nBuffer = nByte;
217440 pCsr->zBuffer, pCsr->nBuffer, &nByte, /* Output vars */
217441 &pCsr->aChar[iStart], iEnd-iStart, /* Input vars */
217444 } while( nByte>pCsr->nBuffer );
217446 *ppToken = pCsr->zBuffer;
217448 *piStartOffset = pCsr->aOffset[iStart];
217449 *piEndOffset = pCsr->aOffset[iEnd];
217450 *piPosition = pCsr->iToken++;
222127 char *pCsr = (char*)&p[1];
222130 p->zTarget = pCsr;
222132 pCsr += nTarget+1;
222134 p->zRbu = pCsr;
222136 pCsr += nRbu+1;
223830 StatCursor *pCsr;
223832 pCsr = (StatCursor *)sqlite3_malloc64(sizeof(StatCursor));
223833 if( pCsr==0 ){
223836 memset(pCsr, 0, sizeof(StatCursor));
223837 pCsr->base.pVtab = pVTab;
223838 pCsr->iDb = pTab->iDb;
223841 *ppCursor = (sqlite3_vtab_cursor *)pCsr;
223865 static void statResetCsr(StatCursor *pCsr){
223871 for(i=0; i<ArraySize(pCsr->aPage); i++){
223872 statClearPage(&pCsr->aPage[i]);
223873 sqlite3_free(pCsr->aPage[i].aPg);
223874 pCsr->aPage[i].aPg = 0;
223876 sqlite3_reset(pCsr->pStmt);
223877 pCsr->iPage = 0;
223878 sqlite3_free(pCsr->zPath);
223879 pCsr->zPath = 0;
223880 pCsr->isEof = 0;
223884 static void statResetCounts(StatCursor *pCsr){
223885 pCsr->nCell = 0;
223886 pCsr->nMxPayload = 0;
223887 pCsr->nUnused = 0;
223888 pCsr->nPayload = 0;
223889 pCsr->szPage = 0;
223890 pCsr->nPage = 0;
223897 StatCursor *pCsr = (StatCursor *)pCursor;
223898 statResetCsr(pCsr);
223899 sqlite3_finalize(pCsr->pStmt);
223900 sqlite3_free(pCsr);
224049 static void statSizeAndOffset(StatCursor *pCsr){
224050 StatTable *pTab = (StatTable *)((sqlite3_vtab_cursor *)pCsr)->pVtab;
224060 x[0] = pCsr->iPageno;
224062 pCsr->iOffset = x[0];
224063 pCsr->szPage += x[1];
224066 pCsr->szPage += sqlite3BtreeGetPageSize(pBt);
224067 pCsr->iOffset = (i64)pCsr->szPage * (pCsr->iPageno - 1);
224112 StatCursor *pCsr = (StatCursor *)pCursor;
224114 Btree *pBt = pTab->db->aDb[pCsr->iDb].pBt;
224117 sqlite3_free(pCsr->zPath);
224118 pCsr->zPath = 0;
224121 if( pCsr->iPage<0 ){
224123 statResetCounts(pCsr);
224124 rc = sqlite3_step(pCsr->pStmt);
224127 u32 iRoot = (u32)sqlite3_column_int64(pCsr->pStmt, 1);
224130 pCsr->isEof = 1;
224131 return sqlite3_reset(pCsr->pStmt);
224133 rc = statGetPage(pBt, iRoot, &pCsr->aPage[0]);
224134 pCsr->aPage[0].iPgno = iRoot;
224135 pCsr->aPage[0].iCell = 0;
224136 if( !pCsr->isAgg ){
224137 pCsr->aPage[0].zPath = z = sqlite3_mprintf("/");
224140 pCsr->iPage = 0;
224141 pCsr->nPage = 1;
224143 pCsr->isEof = 1;
224144 return sqlite3_reset(pCsr->pStmt);
224148 StatPage *p = &pCsr->aPage[pCsr->iPage];
224149 if( !pCsr->isAgg ) statResetCounts(pCsr);
224158 pCsr->nPage++;
224159 statSizeAndOffset(pCsr);
224161 pCsr->nPayload += nUsable - 4;
224163 pCsr->nPayload += pCell->nLastOvfl;
224164 pCsr->nUnused += nUsable - 4 - pCell->nLastOvfl;
224168 if( !pCsr->isAgg ){
224169 pCsr->zName = (char *)sqlite3_column_text(pCsr->pStmt, 0);
224170 pCsr->iPageno = pCell->aOvfl[iOvfl];
224171 pCsr->zPagetype = "overflow";
224172 pCsr->zPath = z = sqlite3_mprintf(
224184 pCsr->iPage--;
224185 if( pCsr->isAgg && pCsr->iPage<0 ){
224192 pCsr->iPage++;
224193 if( pCsr->iPage>=ArraySize(pCsr->aPage) ){
224194 statResetCsr(pCsr);
224197 assert( p==&pCsr->aPage[pCsr->iPage-1] );
224205 pCsr->nPage++;
224207 if( !pCsr->isAgg ){
224220 StatPage *p = &pCsr->aPage[pCsr->iPage];
224221 pCsr->zName = (char *)sqlite3_column_text(pCsr->pStmt, 0);
224222 pCsr->iPageno = p->iPgno;
224226 statSizeAndOffset(pCsr);
224231 pCsr->zPagetype = "internal";
224235 pCsr->zPagetype = "leaf";
224238 pCsr->zPagetype = "corrupted";
224241 pCsr->nCell += p->nCell;
224242 pCsr->nUnused += p->nUnused;
224243 if( p->nMxPayload>pCsr->nMxPayload ) pCsr->nMxPayload = p->nMxPayload;
224244 if( !pCsr->isAgg ){
224245 pCsr->zPath = z = sqlite3_mprintf("%s", p->zPath);
224252 pCsr->nPayload += nPayload;
224257 if( pCsr->isAgg ) goto statNextRestart;
224265 StatCursor *pCsr = (StatCursor *)pCursor;
224266 return pCsr->isEof;
224278 StatCursor *pCsr = (StatCursor *)pCursor;
224288 statResetCsr(pCsr);
224289 sqlite3_finalize(pCsr->pStmt);
224290 pCsr->pStmt = 0;
224294 pCsr->iDb = sqlite3FindDbName(pTab->db, zDbase);
224295 if( pCsr->iDb<0 ){
224296 pCsr->iDb = 0;
224297 pCsr->isEof = 1;
224301 pCsr->iDb = pTab->iDb;
224309 pCsr->isAgg = sqlite3_value_double(argv[iArg++])!=0.0;
224311 pCsr->isAgg = 0;
224320 pTab->db->aDb[pCsr->iDb].zDbSName);
224331 rc = sqlite3_prepare_v2(pTab->db, zSql, -1, &pCsr->pStmt, 0);
224336 pCsr->iPage = -1;
224347 StatCursor *pCsr = (StatCursor *)pCursor;
224350 sqlite3_result_text(ctx, pCsr->zName, -1, SQLITE_TRANSIENT);
224353 if( !pCsr->isAgg ){
224354 sqlite3_result_text(ctx, pCsr->zPath, -1, SQLITE_TRANSIENT);
224358 if( pCsr->isAgg ){
224359 sqlite3_result_int64(ctx, pCsr->nPage);
224361 sqlite3_result_int64(ctx, pCsr->iPageno);
224365 if( !pCsr->isAgg ){
224366 sqlite3_result_text(ctx, pCsr->zPagetype, -1, SQLITE_STATIC);
224370 sqlite3_result_int64(ctx, pCsr->nCell);
224373 sqlite3_result_int64(ctx, pCsr->nPayload);
224376 sqlite3_result_int64(ctx, pCsr->nUnused);
224379 sqlite3_result_int64(ctx, pCsr->nMxPayload);
224382 if( !pCsr->isAgg ){
224383 sqlite3_result_int64(ctx, pCsr->iOffset);
224387 sqlite3_result_int64(ctx, pCsr->szPage);
224391 int iDb = pCsr->iDb;
224396 sqlite3_result_int(ctx, pCsr->isAgg);
224404 StatCursor *pCsr = (StatCursor *)pCursor;
224405 *pRowid = pCsr->iPageno;
224619 DbpageCursor *pCsr;
224621 pCsr = (DbpageCursor *)sqlite3_malloc64(sizeof(DbpageCursor));
224622 if( pCsr==0 ){
224625 memset(pCsr, 0, sizeof(DbpageCursor));
224626 pCsr->base.pVtab = pVTab;
224627 pCsr->pgno = -1;
224630 *ppCursor = (sqlite3_vtab_cursor *)pCsr;
224638 DbpageCursor *pCsr = (DbpageCursor *)pCursor;
224639 if( pCsr->pPage1 ) sqlite3PagerUnrefPageOne(pCsr->pPage1);
224640 sqlite3_free(pCsr);
224649 DbpageCursor *pCsr = (DbpageCursor *)pCursor;
224650 pCsr->pgno++;
224655 DbpageCursor *pCsr = (DbpageCursor *)pCursor;
224656 return pCsr->pgno > pCsr->mxPgno;
224674 DbpageCursor *pCsr = (DbpageCursor *)pCursor;
224683 pCsr->pgno = 1;
224684 pCsr->mxPgno = 0;
224690 pCsr->iDb = sqlite3FindDbName(db, zSchema);
224691 if( pCsr->iDb<0 ) return SQLITE_OK;
224693 pCsr->iDb = 0;
224695 pBt = db->aDb[pCsr->iDb].pBt;
224697 pCsr->pPager = sqlite3BtreePager(pBt);
224698 pCsr->szPage = sqlite3BtreeGetPageSize(pBt);
224699 pCsr->mxPgno = sqlite3BtreeLastPage(pBt);
224702 pCsr->pgno = sqlite3_value_int(argv[idxNum>>1]);
224703 if( pCsr->pgno<1 || pCsr->pgno>pCsr->mxPgno ){
224704 pCsr->pgno = 1;
224705 pCsr->mxPgno = 0;
224707 pCsr->mxPgno = pCsr->pgno;
224710 assert( pCsr->pgno==1 );
224712 if( pCsr->pPage1 ) sqlite3PagerUnrefPageOne(pCsr->pPage1);
224713 rc = sqlite3PagerGet(pCsr->pPager, 1, &pCsr->pPage1, 0);
224722 DbpageCursor *pCsr = (DbpageCursor *)pCursor;
224726 sqlite3_result_int(ctx, pCsr->pgno);
224731 if( pCsr->pgno==((PENDING_BYTE/pCsr->szPage)+1) ){
224734 sqlite3_result_zeroblob(ctx, pCsr->szPage);
224736 rc = sqlite3PagerGet(pCsr->pPager, pCsr->pgno, (DbPage**)&pDbPage, 0);
224738 sqlite3_result_blob(ctx, sqlite3PagerGetData(pDbPage), pCsr->szPage,
224747 sqlite3_result_text(ctx, db->aDb[pCsr->iDb].zDbSName, -1, SQLITE_STATIC);
224755 DbpageCursor *pCsr = (DbpageCursor *)pCursor;
224756 *pRowid = pCsr->pgno;
226474 u8 *pCsr = pC->aRecord;
226477 pCsr += 9;
226489 eType = *pCsr++;
226498 sqlite3_int64 iVal = sessionGetI64(pCsr);
226508 pCsr += 8;
226514 nOld = sessionVarintGet(pCsr, &nByte);
226515 pCsr += nOld;
226520 && (nByte==0 || 0==memcmp(pCsr, sqlite3_value_blob(p), nByte))
226524 pCsr += nByte;
227502 u8 *pCsr = p->aRecord; /* Used to iterate through old.* values */
227510 int eType = *pCsr;
227523 sqlite3_int64 iVal = sessionGetI64(&pCsr[1]);
227538 int nHdr = 1 + sessionVarintGet(&pCsr[1], &n);
227543 && (n==0 || 0==memcmp(&pCsr[nHdr], sqlite3_column_blob(pStmt, i), n))
227558 sessionAppendBlob(pBuf, pCsr, nAdvance, &rc);
227572 pCsr += nAdvance;
231238 u8 *pCsr = aRec;
231239 sessionSkipRecord(&pCsr, pIter->nCol);
231243 pCsr, nRec-(pCsr-aRec),
249389 Fts5StructVcsr *pCsr = (Fts5StructVcsr*)cur;
249390 fts5StructureRelease(pCsr->pStruct);
249391 sqlite3_free(pCsr);
249400 Fts5StructVcsr *pCsr = (Fts5StructVcsr*)cur;
249401 Fts5Structure *p = pCsr->pStruct;
249403 assert( pCsr->pStruct );
249404 pCsr->iSeg++;
249405 pCsr->iRowid++;
249406 while( pCsr->iLevel<p->nLevel && pCsr->iSeg>=p->aLevel[pCsr->iLevel].nSeg ){
249407 pCsr->iLevel++;
249408 pCsr->iSeg = 0;
249410 if( pCsr->iLevel>=p->nLevel ){
249411 fts5StructureRelease(pCsr->pStruct);
249412 pCsr->pStruct = 0;
249422 Fts5StructVcsr *pCsr = (Fts5StructVcsr*)cur;
249423 return pCsr->pStruct==0;
249430 Fts5StructVcsr *pCsr = (Fts5StructVcsr*)cur;
249431 *piRowid = pCsr->iRowid;
249444 Fts5StructVcsr *pCsr = (Fts5StructVcsr*)cur;
249445 Fts5Structure *p = pCsr->pStruct;
249446 Fts5StructureSegment *pSeg = &p->aLevel[pCsr->iLevel].aSeg[pCsr->iSeg];
249450 sqlite3_result_int(ctx, pCsr->iLevel);
249453 sqlite3_result_int(ctx, pCsr->iSeg);
249456 sqlite3_result_int(ctx, pCsr->iSeg < p->aLevel[pCsr->iLevel].nMerge);
249497 Fts5StructVcsr *pCsr = (Fts5StructVcsr *)pVtabCursor;
249504 fts5StructureRelease(pCsr->pStruct);
249505 pCsr->pStruct = 0;
249509 rc = fts5StructureDecode(aBlob, nBlob, 0, &pCsr->pStruct);
249511 pCsr->iLevel = 0;
249512 pCsr->iRowid = 0;
249513 pCsr->iSeg = -1;
249679 Fts5Cursor *pCsr; /* First in list of all open cursors */
249831 #define CsrFlagSet(pCsr, flag) ((pCsr)->csrflags |= (flag))
249832 #define CsrFlagClear(pCsr, flag) ((pCsr)->csrflags &= ~(flag))
249833 #define CsrFlagTest(pCsr, flag) ((pCsr)->csrflags & (flag))
250289 Fts5Cursor *pCsr;
250290 for(pCsr=pTab->pGlobal->pCsr; pCsr; pCsr=pCsr->pNext){
250291 if( pCsr->base.pVtab==(sqlite3_vtab*)pTab ) return SQLITE_OK;
250302 Fts5Cursor *pCsr = 0; /* New cursor object */
250309 pCsr = (Fts5Cursor*)sqlite3_malloc64(nByte);
250310 if( pCsr ){
250312 memset(pCsr, 0, (size_t)nByte);
250313 pCsr->aColumnSize = (int*)&pCsr[1];
250314 pCsr->pNext = pGlobal->pCsr;
250315 pGlobal->pCsr = pCsr;
250316 pCsr->iCsrId = ++pGlobal->iNextId;
250321 *ppCsr = (sqlite3_vtab_cursor*)pCsr;
250325 static int fts5StmtType(Fts5Cursor *pCsr){
250326 if( pCsr->ePlan==FTS5_PLAN_SCAN ){
250327 return (pCsr->bDesc) ? FTS5_STMT_SCAN_DESC : FTS5_STMT_SCAN_ASC;
250337 static void fts5CsrNewrow(Fts5Cursor *pCsr){
250338 CsrFlagSet(pCsr,
250346 static void fts5FreeCursorComponents(Fts5Cursor *pCsr){
250347 Fts5FullTable *pTab = (Fts5FullTable*)(pCsr->base.pVtab);
250351 sqlite3_free(pCsr->aInstIter);
250352 sqlite3_free(pCsr->aInst);
250353 if( pCsr->pStmt ){
250354 int eStmt = fts5StmtType(pCsr);
250355 sqlite3Fts5StorageStmtRelease(pTab->pStorage, eStmt, pCsr->pStmt);
250357 if( pCsr->pSorter ){
250358 Fts5Sorter *pSorter = pCsr->pSorter;
250363 if( pCsr->ePlan!=FTS5_PLAN_SOURCE ){
250364 sqlite3Fts5ExprFree(pCsr->pExpr);
250367 for(pData=pCsr->pAuxdata; pData; pData=pNext){
250373 sqlite3_finalize(pCsr->pRankArgStmt);
250374 sqlite3_free(pCsr->apRankArg);
250376 if( CsrFlagTest(pCsr, FTS5CSR_FREE_ZRANK) ){
250377 sqlite3_free(pCsr->zRank);
250378 sqlite3_free(pCsr->zRankArgs);
250382 memset(&pCsr->ePlan, 0, sizeof(Fts5Cursor) - ((u8*)&pCsr->ePlan - (u8*)pCsr));
250393 Fts5Cursor *pCsr = (Fts5Cursor*)pCursor;
250396 fts5FreeCursorComponents(pCsr);
250398 for(pp=&pTab->pGlobal->pCsr; (*pp)!=pCsr; pp=&(*pp)->pNext);
250399 *pp = pCsr->pNext;
250401 sqlite3_free(pCsr);
250406 static int fts5SorterNext(Fts5Cursor *pCsr){
250407 Fts5Sorter *pSorter = pCsr->pSorter;
250413 CsrFlagSet(pCsr, FTS5CSR_EOF|FTS5CSR_REQUIRE_CONTENT);
250438 fts5CsrNewrow(pCsr);
250450 Fts5Cursor *pCsr;
250451 for(pCsr=pTab->pGlobal->pCsr; pCsr; pCsr=pCsr->pNext){
250452 if( pCsr->ePlan==FTS5_PLAN_MATCH
250453 && pCsr->base.pVtab==(sqlite3_vtab*)pTab
250455 CsrFlagSet(pCsr, FTS5CSR_REQUIRE_RESEEK);
250472 static int fts5CursorReseek(Fts5Cursor *pCsr, int *pbSkip){
250475 if( CsrFlagTest(pCsr, FTS5CSR_REQUIRE_RESEEK) ){
250476 Fts5FullTable *pTab = (Fts5FullTable*)(pCsr->base.pVtab);
250477 int bDesc = pCsr->bDesc;
250478 i64 iRowid = sqlite3Fts5ExprRowid(pCsr->pExpr);
250480 rc = sqlite3Fts5ExprFirst(pCsr->pExpr, pTab->p.pIndex, iRowid, bDesc);
250481 if( rc==SQLITE_OK && iRowid!=sqlite3Fts5ExprRowid(pCsr->pExpr) ){
250485 CsrFlagClear(pCsr, FTS5CSR_REQUIRE_RESEEK);
250486 fts5CsrNewrow(pCsr);
250487 if( sqlite3Fts5ExprEof(pCsr->pExpr) ){
250488 CsrFlagSet(pCsr, FTS5CSR_EOF);
250505 Fts5Cursor *pCsr = (Fts5Cursor*)pCursor;
250508 assert( (pCsr->ePlan<3)==
250509 (pCsr->ePlan==FTS5_PLAN_MATCH || pCsr->ePlan==FTS5_PLAN_SOURCE)
250511 assert( !CsrFlagTest(pCsr, FTS5CSR_EOF) );
250517 if( pCsr->ePlan==FTS5_PLAN_MATCH
250520 sqlite3Fts5ExprClearTokens(pCsr->pExpr);
250523 if( pCsr->ePlan<3 ){
250525 if( (rc = fts5CursorReseek(pCsr, &bSkip)) || bSkip ) return rc;
250526 rc = sqlite3Fts5ExprNext(pCsr->pExpr, pCsr->iLastRowid);
250527 CsrFlagSet(pCsr, sqlite3Fts5ExprEof(pCsr->pExpr));
250528 fts5CsrNewrow(pCsr);
250530 switch( pCsr->ePlan ){
250532 CsrFlagSet(pCsr, FTS5CSR_EOF);
250538 rc = fts5SorterNext(pCsr);
250545 rc = sqlite3_step(pCsr->pStmt);
250548 CsrFlagSet(pCsr, FTS5CSR_EOF);
250549 rc = sqlite3_reset(pCsr->pStmt);
250598 Fts5Cursor *pCsr,
250606 const char *zRank = pCsr->zRank;
250607 const char *zRankArgs = pCsr->zRankArgs;
250609 nPhrase = sqlite3Fts5ExprPhraseCount(pCsr->pExpr);
250631 pCsr->pSorter = pSorter;
250634 pTab->pSortCsr = pCsr;
250635 rc = fts5SorterNext(pCsr);
250642 pCsr->pSorter = 0;
250648 static int fts5CursorFirst(Fts5FullTable *pTab, Fts5Cursor *pCsr, int bDesc){
250650 Fts5Expr *pExpr = pCsr->pExpr;
250651 rc = sqlite3Fts5ExprFirst(pExpr, pTab->p.pIndex, pCsr->iFirstRowid, bDesc);
250653 CsrFlagSet(pCsr, FTS5CSR_EOF);
250655 fts5CsrNewrow(pCsr);
250667 Fts5Cursor *pCsr,
250678 pCsr->ePlan = FTS5_PLAN_SPECIAL;
250681 pCsr->iSpecial = sqlite3Fts5IndexReads(pTab->p.pIndex);
250684 pCsr->iSpecial = pCsr->iCsrId;
250712 static int fts5FindRankFunction(Fts5Cursor *pCsr){
250713 Fts5FullTable *pTab = (Fts5FullTable*)(pCsr->base.pVtab);
250717 const char *zRank = pCsr->zRank;
250718 const char *zRankArgs = pCsr->zRankArgs;
250727 assert( rc==SQLITE_OK || pCsr->pRankArgStmt==0 );
250731 pCsr->nRankArg = sqlite3_column_count(pStmt);
250732 nByte = sizeof(sqlite3_value*)*pCsr->nRankArg;
250733 pCsr->apRankArg = (sqlite3_value**)sqlite3Fts5MallocZero(&rc, nByte);
250736 for(i=0; i<pCsr->nRankArg; i++){
250737 pCsr->apRankArg[i] = sqlite3_column_value(pStmt, i);
250740 pCsr->pRankArgStmt = pStmt;
250758 pCsr->pRank = pAux;
250765 Fts5Cursor *pCsr,
250780 pCsr->zRank = zRank;
250781 pCsr->zRankArgs = zRankArgs;
250782 CsrFlagSet(pCsr, FTS5CSR_FREE_ZRANK);
250784 pCsr->base.pVtab->zErrMsg = sqlite3_mprintf(
250790 pCsr->zRank = (char*)pConfig->zRank;
250791 pCsr->zRankArgs = (char*)pConfig->zRankArgs;
250793 pCsr->zRank = (char*)FTS5_DEFAULT_RANK;
250794 pCsr->zRankArgs = 0;
250830 Fts5Cursor *pCsr = (Fts5Cursor*)pCursor;
250851 if( pCsr->ePlan ){
250852 fts5FreeCursorComponents(pCsr);
250853 memset(&pCsr->ePlan, 0, sizeof(Fts5Cursor) - ((u8*)&pCsr->ePlan-(u8*)pCsr));
250856 assert( pCsr->pStmt==0 );
250857 assert( pCsr->pExpr==0 );
250858 assert( pCsr->csrflags==0 );
250859 assert( pCsr->pRank==0 );
250860 assert( pCsr->zRank==0 );
250861 assert( pCsr->zRankArgs==0 );
250886 rc = fts5SpecialMatch(pTab, pCsr, &zText[1]);
250892 rc = sqlite3Fts5ExprAnd(&pCsr->pExpr, pExpr);
250913 rc = sqlite3Fts5ExprAnd(&pCsr->pExpr, pExpr);
250931 pCsr->bDesc = bDesc = ((idxNum & FTS5_BI_ORDER_DESC) ? 1 : 0);
250941 pCsr->iFirstRowid = fts5GetRowidLimit(pRowidLe, LARGEST_INT64);
250942 pCsr->iLastRowid = fts5GetRowidLimit(pRowidGe, SMALLEST_INT64);
250944 pCsr->iLastRowid = fts5GetRowidLimit(pRowidLe, LARGEST_INT64);
250945 pCsr->iFirstRowid = fts5GetRowidLimit(pRowidGe, SMALLEST_INT64);
250960 assert( pCsr->iLastRowid==LARGEST_INT64 );
250961 assert( pCsr->iFirstRowid==SMALLEST_INT64 );
250963 pCsr->iLastRowid = pTab->pSortCsr->iFirstRowid;
250964 pCsr->iFirstRowid = pTab->pSortCsr->iLastRowid;
250966 pCsr->iLastRowid = pTab->pSortCsr->iLastRowid;
250967 pCsr->iFirstRowid = pTab->pSortCsr->iFirstRowid;
250969 pCsr->ePlan = FTS5_PLAN_SOURCE;
250970 pCsr->pExpr = pTab->pSortCsr->pExpr;
250971 rc = fts5CursorFirst(pTab, pCsr, bDesc);
250972 }else if( pCsr->pExpr ){
250974 rc = fts5CursorParseRank(pConfig, pCsr, pRank);
250977 pCsr->ePlan = FTS5_PLAN_SORTED_MATCH;
250978 rc = fts5CursorFirstSorted(pTab, pCsr, bDesc);
250980 pCsr->ePlan = FTS5_PLAN_MATCH;
250981 rc = fts5CursorFirst(pTab, pCsr, bDesc);
250992 pCsr->ePlan = (pRowidEq ? FTS5_PLAN_ROWID : FTS5_PLAN_SCAN);
250994 pTab->pStorage, fts5StmtType(pCsr), &pCsr->pStmt, &pTab->p.base.zErrMsg
250998 assert( pCsr->ePlan==FTS5_PLAN_ROWID );
250999 sqlite3_bind_value(pCsr->pStmt, 1, pRowidEq);
251001 sqlite3_bind_int64(pCsr->pStmt, 1, pCsr->iFirstRowid);
251002 sqlite3_bind_int64(pCsr->pStmt, 2, pCsr->iLastRowid);
251019 Fts5Cursor *pCsr = (Fts5Cursor*)pCursor;
251020 return (CsrFlagTest(pCsr, FTS5CSR_EOF) ? 1 : 0);
251026 static i64 fts5CursorRowid(Fts5Cursor *pCsr){
251027 assert( pCsr->ePlan==FTS5_PLAN_MATCH
251028 || pCsr->ePlan==FTS5_PLAN_SORTED_MATCH
251029 || pCsr->ePlan==FTS5_PLAN_SOURCE
251031 if( pCsr->pSorter ){
251032 return pCsr->pSorter->iRowid;
251034 return sqlite3Fts5ExprRowid(pCsr->pExpr);
251045 Fts5Cursor *pCsr = (Fts5Cursor*)pCursor;
251046 int ePlan = pCsr->ePlan;
251048 assert( CsrFlagTest(pCsr, FTS5CSR_EOF)==0 );
251057 *pRowid = fts5CursorRowid(pCsr);
251061 *pRowid = sqlite3_column_int64(pCsr->pStmt, 0);
251075 static int fts5SeekCursor(Fts5Cursor *pCsr, int bErrormsg){
251079 if( pCsr->pStmt==0 ){
251080 Fts5FullTable *pTab = (Fts5FullTable*)(pCsr->base.pVtab);
251081 int eStmt = fts5StmtType(pCsr);
251083 pTab->pStorage, eStmt, &pCsr->pStmt, (bErrormsg?&pTab->p.base.zErrMsg:0)
251086 assert( CsrFlagTest(pCsr, FTS5CSR_REQUIRE_CONTENT) );
251089 if( rc==SQLITE_OK && CsrFlagTest(pCsr, FTS5CSR_REQUIRE_CONTENT) ){
251090 Fts5Table *pTab = (Fts5Table*)(pCsr->base.pVtab);
251091 assert( pCsr->pExpr );
251092 sqlite3_reset(pCsr->pStmt);
251093 sqlite3_bind_int64(pCsr->pStmt, 1, fts5CursorRowid(pCsr));
251095 rc = sqlite3_step(pCsr->pStmt);
251099 CsrFlagClear(pCsr, FTS5CSR_REQUIRE_CONTENT);
251101 rc = sqlite3_reset(pCsr->pStmt);
251456 Fts5Cursor *pCsr = (Fts5Cursor*)pCtx;
251457 return pCsr->pAux->pUserData;
251461 Fts5Cursor *pCsr = (Fts5Cursor*)pCtx;
251462 return ((Fts5Table*)(pCsr->base.pVtab))->pConfig->nCol;
251470 Fts5Cursor *pCsr = (Fts5Cursor*)pCtx;
251471 Fts5FullTable *pTab = (Fts5FullTable*)(pCsr->base.pVtab);
251476 Fts5Cursor *pCsr = (Fts5Cursor*)pCtx;
251477 Fts5FullTable *pTab = (Fts5FullTable*)(pCsr->base.pVtab);
251487 Fts5Cursor *pCsr = (Fts5Cursor*)pCtx;
251488 Fts5Table *pTab = (Fts5Table*)(pCsr->base.pVtab);
251495 Fts5Cursor *pCsr = (Fts5Cursor*)pCtx;
251496 return sqlite3Fts5ExprPhraseCount(pCsr->pExpr);
251500 Fts5Cursor *pCsr = (Fts5Cursor*)pCtx;
251501 return sqlite3Fts5ExprPhraseSize(pCsr->pExpr, iPhrase);
251511 Fts5Cursor *pCsr = (Fts5Cursor*)pCtx;
251512 Fts5Table *pTab = (Fts5Table*)(pCsr->base.pVtab);
251515 }else if( fts5IsContentless((Fts5FullTable*)(pCsr->base.pVtab))
251516 || pCsr->ePlan==FTS5_PLAN_SPECIAL
251521 rc = fts5SeekCursor(pCsr, 0);
251523 *pz = (const char*)sqlite3_column_text(pCsr->pStmt, iCol+1);
251524 *pn = sqlite3_column_bytes(pCsr->pStmt, iCol+1);
251531 Fts5Cursor *pCsr,
251536 Fts5Config *pConfig = ((Fts5Table*)(pCsr->base.pVtab))->pConfig;
251538 int bLive = (pCsr->pSorter==0);
251540 if( iPhrase<0 || iPhrase>=sqlite3Fts5ExprPhraseCount(pCsr->pExpr) ){
251542 }else if( CsrFlagTest(pCsr, FTS5CSR_REQUIRE_POSLIST) ){
251546 aPopulator = sqlite3Fts5ExprClearPoslists(pCsr->pExpr, bLive);
251550 rc = fts5ApiColumnText((Fts5Context*)pCsr, i, &z, &n);
251553 pConfig, pCsr->pExpr, aPopulator, i, z, n
251559 if( pCsr->pSorter ){
251560 sqlite3Fts5ExprCheckPoslists(pCsr->pExpr, pCsr->pSorter->iRowid);
251563 CsrFlagClear(pCsr, FTS5CSR_REQUIRE_POSLIST);
251567 if( pCsr->pSorter && pConfig->eDetail==FTS5_DETAIL_FULL ){
251568 Fts5Sorter *pSorter = pCsr->pSorter;
251573 *pn = sqlite3Fts5ExprPoslist(pCsr->pExpr, iPhrase, pa);
251589 static int fts5CacheInstArray(Fts5Cursor *pCsr){
251593 int nCol = ((Fts5Table*)pCsr->base.pVtab)->pConfig->nCol;
251595 nIter = sqlite3Fts5ExprPhraseCount(pCsr->pExpr);
251596 if( pCsr->aInstIter==0 ){
251598 pCsr->aInstIter = (Fts5PoslistReader*)sqlite3Fts5MallocZero(&rc, nByte);
251600 aIter = pCsr->aInstIter;
251610 rc = fts5CsrPoslist(pCsr, i, &a, &n);
251630 if( nInst>=pCsr->nInstAlloc ){
251631 int nNewSize = pCsr->nInstAlloc ? pCsr->nInstAlloc*2 : 32;
251633 pCsr->aInst, nNewSize*sizeof(int)*3
251636 pCsr->aInst = aInst;
251637 pCsr->nInstAlloc = nNewSize;
251645 aInst = &pCsr->aInst[3 * (nInst-1)];
251657 pCsr->nInstCount = nInst;
251658 CsrFlagClear(pCsr, FTS5CSR_REQUIRE_INST);
251664 Fts5Cursor *pCsr = (Fts5Cursor*)pCtx;
251666 if( CsrFlagTest(pCsr, FTS5CSR_REQUIRE_INST)==0
251667 || SQLITE_OK==(rc = fts5CacheInstArray(pCsr)) ){
251668 *pnInst = pCsr->nInstCount;
251680 Fts5Cursor *pCsr = (Fts5Cursor*)pCtx;
251682 if( CsrFlagTest(pCsr, FTS5CSR_REQUIRE_INST)==0
251683 || SQLITE_OK==(rc = fts5CacheInstArray(pCsr))
251685 if( iIdx<0 || iIdx>=pCsr->nInstCount ){
251688 *piPhrase = pCsr->aInst[iIdx*3];
251689 *piCol = pCsr->aInst[iIdx*3 + 1];
251690 *piOff = pCsr->aInst[iIdx*3 + 2];
251718 Fts5Cursor *pCsr = (Fts5Cursor*)pCtx;
251719 Fts5FullTable *pTab = (Fts5FullTable*)(pCsr->base.pVtab);
251723 if( CsrFlagTest(pCsr, FTS5CSR_REQUIRE_DOCSIZE) ){
251725 i64 iRowid = fts5CursorRowid(pCsr);
251726 rc = sqlite3Fts5StorageDocsize(pTab->pStorage, iRowid, pCsr->aColumnSize);
251731 pCsr->aColumnSize[i] = -1;
251739 void *p = (void*)(&pCsr->aColumnSize[i]);
251740 pCsr->aColumnSize[i] = 0;
251750 CsrFlagClear(pCsr, FTS5CSR_REQUIRE_DOCSIZE);
251756 *pnToken += pCsr->aColumnSize[i];
251759 *pnToken = pCsr->aColumnSize[iCol];
251775 Fts5Cursor *pCsr = (Fts5Cursor*)pCtx;
251780 for(pData=pCsr->pAuxdata; pData; pData=pData->pNext){
251781 if( pData->pAux==pCsr->pAux ) break;
251795 pData->pAux = pCsr->pAux;
251796 pData->pNext = pCsr->pAuxdata;
251797 pCsr->pAuxdata = pData;
251806 Fts5Cursor *pCsr = (Fts5Cursor*)pCtx;
251810 for(pData=pCsr->pAuxdata; pData; pData=pData->pNext){
251811 if( pData->pAux==pCsr->pAux ) break;
251853 Fts5Cursor *pCsr = (Fts5Cursor*)pCtx;
251855 int rc = fts5CsrPoslist(pCsr, iPhrase, &pIter->a, &n);
251871 Fts5Cursor *pCsr = (Fts5Cursor*)pCtx;
251872 Fts5Config *pConfig = ((Fts5Table*)(pCsr->base.pVtab))->pConfig;
251903 Fts5Cursor *pCsr = (Fts5Cursor*)pCtx;
251904 Fts5Config *pConfig = ((Fts5Table*)(pCsr->base.pVtab))->pConfig;
251907 Fts5Sorter *pSorter = pCsr->pSorter;
251914 rc = sqlite3Fts5ExprPhraseCollist(pCsr->pExpr, iPhrase, &pIter->a, &n);
251924 rc = fts5CsrPoslist(pCsr, iPhrase, &pIter->a, &n);
251951 Fts5Cursor *pCsr = (Fts5Cursor*)pCtx;
251952 return sqlite3Fts5ExprQueryToken(pCsr->pExpr, iPhrase, iToken, ppOut, pnOut);
251964 Fts5Cursor *pCsr = (Fts5Cursor*)pCtx;
251966 if( CsrFlagTest(pCsr, FTS5CSR_REQUIRE_INST)==0
251967 || SQLITE_OK==(rc = fts5CacheInstArray(pCsr))
251969 if( iIdx<0 || iIdx>=pCsr->nInstCount ){
251972 int iPhrase = pCsr->aInst[iIdx*3];
251973 int iCol = pCsr->aInst[iIdx*3 + 1];
251974 int iOff = pCsr->aInst[iIdx*3 + 2];
251975 i64 iRowid = fts5CursorRowid(pCsr);
251977 pCsr->pExpr, iRowid, iPhrase, iCol, iOff, iToken, ppOut, pnOut
252023 Fts5Cursor *pCsr = (Fts5Cursor*)pCtx;
252024 Fts5FullTable *pTab = (Fts5FullTable*)(pCsr->base.pVtab);
252028 rc = fts5OpenMethod(pCsr->base.pVtab, (sqlite3_vtab_cursor**)&pNew);
252034 rc = sqlite3Fts5ExprClonePhrase(pCsr->pExpr, iPhrase, &pNew->pExpr);
252056 Fts5Cursor *pCsr,
252061 assert( pCsr->pAux==0 );
252062 pCsr->pAux = pAux;
252063 pAux->xFunc(&sFts5Api, (Fts5Context*)pCsr, context, argc, argv);
252064 pCsr->pAux = 0;
252068 Fts5Cursor *pCsr;
252069 for(pCsr=pGlobal->pCsr; pCsr; pCsr=pCsr->pNext){
252070 if( pCsr->iCsrId==iCsrId ) break;
252072 return pCsr;
252082 Fts5Cursor *pCsr;
252089 pCsr = fts5CursorFromCsrid(pAux->pGlobal, iCsrId);
252090 if( pCsr==0 || pCsr->ePlan==0 ){
252095 fts5ApiInvoke(pAux, pCsr, context, argc-1, &argv[1]);
252108 Fts5Cursor *pCsr;
252109 pCsr = fts5CursorFromCsrid(pGlobal, iCsrId);
252110 if( pCsr ){
252111 return (Fts5Table*)pCsr->base.pVtab;
252131 static int fts5PoslistBlob(sqlite3_context *pCtx, Fts5Cursor *pCsr){
252134 int nPhrase = sqlite3Fts5ExprPhraseCount(pCsr->pExpr);
252138 switch( ((Fts5Table*)(pCsr->base.pVtab))->pConfig->eDetail ){
252144 int nByte = sqlite3Fts5ExprPoslist(pCsr->pExpr, i, &dummy);
252152 nPoslist = sqlite3Fts5ExprPoslist(pCsr->pExpr, i, &pPoslist);
252163 rc = sqlite3Fts5ExprPhraseCollist(pCsr->pExpr, i, &dummy, &nByte);
252171 rc = sqlite3Fts5ExprPhraseCollist(pCsr->pExpr, i, &pPoslist, &nPoslist);
252195 Fts5Cursor *pCsr = (Fts5Cursor*)pCursor;
252198 assert( CsrFlagTest(pCsr, FTS5CSR_EOF)==0 );
252200 if( pCsr->ePlan==FTS5_PLAN_SPECIAL ){
252202 sqlite3_result_int64(pCtx, pCsr->iSpecial);
252211 sqlite3_result_int64(pCtx, pCsr->iCsrId);
252215 if( pCsr->ePlan==FTS5_PLAN_SOURCE ){
252216 fts5PoslistBlob(pCtx, pCsr);
252218 pCsr->ePlan==FTS5_PLAN_MATCH
252219 || pCsr->ePlan==FTS5_PLAN_SORTED_MATCH
252221 if( pCsr->pRank || SQLITE_OK==(rc = fts5FindRankFunction(pCsr)) ){
252222 fts5ApiInvoke(pCsr->pRank, pCsr, pCtx, pCsr->nRankArg, pCsr->apRankArg);
252227 rc = fts5SeekCursor(pCsr, 1);
252229 sqlite3_result_value(pCtx, sqlite3_column_value(pCsr->pStmt, iCol+1));
256860 Fts5VocabCursor *pCsr = 0;
256906 pCsr = (Fts5VocabCursor*)sqlite3Fts5MallocZero(&rc, nByte);
256909 if( pCsr ){
256910 pCsr->pFts5 = pFts5;
256911 pCsr->pStmt = pStmt;
256912 pCsr->aCnt = (i64*)&pCsr[1];
256913 pCsr->aDoc = &pCsr->aCnt[pFts5->pConfig->nCol];
256918 *ppCsr = (sqlite3_vtab_cursor*)pCsr;
256922 static void fts5VocabResetCursor(Fts5VocabCursor *pCsr){
256923 pCsr->rowid = 0;
256924 sqlite3Fts5IterClose(pCsr->pIter);
256925 sqlite3Fts5StructureRelease(pCsr->pStruct);
256926 pCsr->pStruct = 0;
256927 pCsr->pIter = 0;
256928 sqlite3_free(pCsr->zLeTerm);
256929 pCsr->nLeTerm = -1;
256930 pCsr->zLeTerm = 0;
256931 pCsr->bEof = 0;
256939 Fts5VocabCursor *pCsr = (Fts5VocabCursor*)pCursor;
256940 fts5VocabResetCursor(pCsr);
256941 sqlite3Fts5BufferFree(&pCsr->term);
256942 sqlite3_finalize(pCsr->pStmt);
256943 sqlite3_free(pCsr);
256947 static int fts5VocabInstanceNewTerm(Fts5VocabCursor *pCsr){
256950 if( sqlite3Fts5IterEof(pCsr->pIter) ){
256951 pCsr->bEof = 1;
256955 zTerm = sqlite3Fts5IterTerm(pCsr->pIter, &nTerm);
256956 if( pCsr->nLeTerm>=0 ){
256957 int nCmp = MIN(nTerm, pCsr->nLeTerm);
256958 int bCmp = memcmp(pCsr->zLeTerm, zTerm, nCmp);
256959 if( bCmp<0 || (bCmp==0 && pCsr->nLeTerm<nTerm) ){
256960 pCsr->bEof = 1;
256964 sqlite3Fts5BufferSet(&rc, &pCsr->term, nTerm, (const u8*)zTerm);
256969 static int fts5VocabInstanceNext(Fts5VocabCursor *pCsr){
256970 int eDetail = pCsr->pFts5->pConfig->eDetail;
256972 Fts5IndexIter *pIter = pCsr->pIter;
256973 i64 *pp = &pCsr->iInstPos;
256974 int *po = &pCsr->iInstOff;
256977 assert( pCsr->bEof==0 );
256981 pCsr->iInstPos = 0;
256982 pCsr->iInstOff = 0;
256984 rc = sqlite3Fts5IterNextScan(pCsr->pIter);
256986 rc = fts5VocabInstanceNewTerm(pCsr);
256987 if( pCsr->bEof || eDetail==FTS5_DETAIL_NONE ) break;
256990 pCsr->bEof = 1;
257002 Fts5VocabCursor *pCsr = (Fts5VocabCursor*)pCursor;
257004 int nCol = pCsr->pFts5->pConfig->nCol;
257007 rc = sqlite3Fts5StructureTest(pCsr->pFts5->pIndex, pCsr->pStruct);
257009 pCsr->rowid++;
257012 return fts5VocabInstanceNext(pCsr);
257016 for(pCsr->iCol++; pCsr->iCol<nCol; pCsr->iCol++){
257017 if( pCsr->aDoc[pCsr->iCol] ) break;
257021 if( pTab->eType!=FTS5_VOCAB_COL || pCsr->iCol>=nCol ){
257022 if( sqlite3Fts5IterEof(pCsr->pIter) ){
257023 pCsr->bEof = 1;
257028 zTerm = sqlite3Fts5IterTerm(pCsr->pIter, &nTerm);
257030 if( pCsr->nLeTerm>=0 ){
257031 int nCmp = MIN(nTerm, pCsr->nLeTerm);
257032 int bCmp = memcmp(pCsr->zLeTerm, zTerm, nCmp);
257033 if( bCmp<0 || (bCmp==0 && pCsr->nLeTerm<nTerm) ){
257034 pCsr->bEof = 1;
257039 sqlite3Fts5BufferSet(&rc, &pCsr->term, nTerm, (const u8*)zTerm);
257040 memset(pCsr->aCnt, 0, nCol * sizeof(i64));
257041 memset(pCsr->aDoc, 0, nCol * sizeof(i64));
257042 pCsr->iCol = 0;
257046 int eDetail = pCsr->pFts5->pConfig->eDetail;
257051 pPos = pCsr->pIter->pData;
257052 nPos = pCsr->pIter->nData;
257058 pCsr->aCnt[0]++;
257061 pCsr->aDoc[0]++;
257074 pCsr->aDoc[ii]++;
257077 pCsr->aCnt[ii]++;
257086 pCsr->aDoc[iPos]++;
257090 pCsr->aDoc[0]++;
257100 rc = sqlite3Fts5IterNextScan(pCsr->pIter);
257105 zTerm = sqlite3Fts5IterTerm(pCsr->pIter, &nTerm);
257106 if( nTerm!=pCsr->term.n
257107 || (nTerm>0 && memcmp(zTerm, pCsr->term.p, nTerm))
257111 if( sqlite3Fts5IterEof(pCsr->pIter) ) break;
257117 if( rc==SQLITE_OK && pCsr->bEof==0 && pTab->eType==FTS5_VOCAB_COL ){
257118 for(/* noop */; pCsr->iCol<nCol && pCsr->aDoc[pCsr->iCol]==0; pCsr->iCol++);
257119 if( pCsr->iCol==nCol ){
257137 Fts5VocabCursor *pCsr = (Fts5VocabCursor*)pCursor;
257152 fts5VocabResetCursor(pCsr);
257169 pCsr->nLeTerm = sqlite3_value_bytes(pLe);
257170 pCsr->zLeTerm = sqlite3_malloc(pCsr->nLeTerm+1);
257171 if( pCsr->zLeTerm==0 ){
257174 memcpy(pCsr->zLeTerm, zCopy, pCsr->nLeTerm+1);
257180 Fts5Index *pIndex = pCsr->pFts5->pIndex;
257181 rc = sqlite3Fts5IndexQuery(pIndex, zTerm, nTerm, f, 0, &pCsr->pIter);
257183 pCsr->pStruct = sqlite3Fts5StructureRef(pIndex);
257187 rc = fts5VocabInstanceNewTerm(pCsr);
257189 if( rc==SQLITE_OK && !pCsr->bEof
257191 || pCsr->pFts5->pConfig->eDetail!=FTS5_DETAIL_NONE)
257204 Fts5VocabCursor *pCsr = (Fts5VocabCursor*)pCursor;
257205 return pCsr->bEof;
257213 Fts5VocabCursor *pCsr = (Fts5VocabCursor*)pCursor;
257214 int eDetail = pCsr->pFts5->pConfig->eDetail;
257220 pCtx, (const char*)pCsr->term.p, pCsr->term.n, SQLITE_TRANSIENT
257226 const char *z = pCsr->pFts5->pConfig->azCol[pCsr->iCol];
257230 iVal = pCsr->aDoc[pCsr->iCol];
257232 iVal = pCsr->aCnt[pCsr->iCol];
257237 iVal = pCsr->aDoc[0];
257239 iVal = pCsr->aCnt[0];
257245 sqlite3_result_int64(pCtx, pCsr->pIter->iRowid);
257250 ii = FTS5_POS2COLUMN(pCsr->iInstPos);
257252 ii = (int)pCsr->iInstPos;
257254 if( ii>=0 && ii<pCsr->pFts5->pConfig->nCol ){
257255 const char *z = pCsr->pFts5->pConfig->azCol[ii];
257263 int ii = FTS5_POS2OFFSET(pCsr->iInstPos);
257284 Fts5VocabCursor *pCsr = (Fts5VocabCursor*)pCursor;
257285 *pRowid = pCsr->rowid;