Lines Matching refs:pCsr
22921 VdbeCursor *pCsr; /* Cursor to read old values from */
22950 BtCursor *pCsr; /* An ephemeral table holding all values */
79596 ** Argument pCsr must be a cursor opened for writing on an
79605 SQLITE_PRIVATE int sqlite3BtreePutData(BtCursor *pCsr, u32 offset, u32 amt, void *z){
79607 assert( cursorOwnsBtShared(pCsr) );
79608 assert( sqlite3_mutex_held(pCsr->pBtree->db->mutex) );
79609 assert( pCsr->curFlags & BTCF_Incrblob );
79611 rc = restoreCursorPosition(pCsr);
79615 assert( pCsr->eState!=CURSOR_REQUIRESEEK );
79616 if( pCsr->eState!=CURSOR_VALID ){
79624 ** Note that pCsr must be open on a INTKEY table and saveCursorPosition()
79628 VVA_ONLY(rc =) saveAllCursors(pCsr->pBt, pCsr->pgnoRoot, pCsr);
79638 if( (pCsr->curFlags & BTCF_WriteFlag)==0 ){
79641 assert( (pCsr->pBt->btsFlags & BTS_READ_ONLY)==0
79642 && pCsr->pBt->inTransaction==TRANS_WRITE );
79643 assert( hasSharedCacheTableLock(pCsr->pBtree, pCsr->pgnoRoot, 0, 2) );
79644 assert( !hasReadConflicts(pCsr->pBtree, pCsr->pgnoRoot) );
79645 assert( pCsr->pPage->intKey );
79647 return accessPayload(pCsr, offset, amt, (unsigned char *)z, 1);
79699 SQLITE_PRIVATE int sqlite3BtreeCursorHasHint(BtCursor *pCsr, unsigned int mask){
79700 return (pCsr->hints & mask)!=0;
87799 VdbeCursor *pCsr, /* Cursor to grab old.* values from */
87826 assert( pCsr!=0 );
87827 assert( pCsr->eCurType==CURTYPE_BTREE );
87828 assert( pCsr->nField==pTab->nCol
87829 || (pCsr->nField==pTab->nCol+1 && op==SQLITE_DELETE && iReg==-1)
87833 preupdate.pCsr = pCsr;
87853 for(i=0; i<pCsr->nField; i++){
88799 rc = sqlite3BtreeNext(pRhs->pCsr, 0);
88802 rc = sqlite3BtreeFirst(pRhs->pCsr, &dummy);
88803 assert( rc==SQLITE_OK || sqlite3BtreeEof(pRhs->pCsr) );
88804 if( sqlite3BtreeEof(pRhs->pCsr) ) rc = SQLITE_DONE;
88810 sz = sqlite3BtreePayloadSize(pRhs->pCsr);
88811 rc = sqlite3VdbeMemFromBtreeZeroOffset(pRhs->pCsr,(int)sz,&sMem);
89844 if( iIdx>=p->pCsr->nField || iIdx<0 ){
89854 assert( p->pCsr->eCurType==CURTYPE_BTREE );
89855 nRec = sqlite3BtreePayloadSize(p->pCsr->uc.pCursor);
89858 rc = sqlite3BtreePayload(p->pCsr->uc.pCursor, 0, nRec, aRec);
89946 if( iIdx>=p->pCsr->nField || iIdx<0 ){
89980 p->aNew = (Mem *)sqlite3DbMallocZero(db, sizeof(Mem) * p->pCsr->nField);
89986 assert( iIdx>=0 && iIdx<p->pCsr->nField );
98407 pRhs->pCsr = pC->uc.pCursor;
99286 BtCursor *pCsr; /* Cursor pointing at blob row */
99351 p->pCsr = pC->uc.pCursor;
99352 sqlite3BtreeIncrblobCursor(p->pCsr);
99665 sqlite3BtreeEnterCursor(p->pCsr);
99683 iKey = sqlite3BtreeIntegerKey(p->pCsr);
99692 rc = xCall(p->pCsr, iOffset+p->iOffset, n, z);
99693 sqlite3BtreeLeaveCursor(p->pCsr);
100688 ** Usually, the sorter module uses the value of (pCsr->pKeyInfo->nKeyField)
100707 VdbeCursor *pCsr /* Cursor that holds the new sorter */
100712 KeyInfo *pKeyInfo; /* Copy of pCsr->pKeyInfo with db==0 */
100713 int szKeyInfo; /* Size of pCsr->pKeyInfo in bytes */
100739 assert( pCsr->pKeyInfo );
100740 assert( !pCsr->isEphemeral );
100741 assert( pCsr->eCurType==CURTYPE_SORTER );
100742 szKeyInfo = sizeof(KeyInfo) + (pCsr->pKeyInfo->nKeyField-1)*sizeof(CollSeq*);
100746 pCsr->uc.pSorter = pSorter;
100752 memcpy(pKeyInfo, pCsr->pKeyInfo, szKeyInfo);
101040 SQLITE_PRIVATE void sqlite3VdbeSorterClose(sqlite3 *db, VdbeCursor *pCsr){
101042 assert( pCsr->eCurType==CURTYPE_SORTER );
101043 pSorter = pCsr->uc.pSorter;
101048 pCsr->uc.pSorter = 0;
101544 const VdbeCursor *pCsr, /* Sorter cursor */
101555 assert( pCsr->eCurType==CURTYPE_SORTER );
101556 pSorter = pCsr->uc.pSorter;
102358 SQLITE_PRIVATE int sqlite3VdbeSorterRewind(const VdbeCursor *pCsr, int *pbEof){
102362 assert( pCsr->eCurType==CURTYPE_SORTER );
102363 pSorter = pCsr->uc.pSorter;
102410 SQLITE_PRIVATE int sqlite3VdbeSorterNext(sqlite3 *db, const VdbeCursor *pCsr){
102414 assert( pCsr->eCurType==CURTYPE_SORTER );
102415 pSorter = pCsr->uc.pSorter;
102475 SQLITE_PRIVATE int sqlite3VdbeSorterRowkey(const VdbeCursor *pCsr, Mem *pOut){
102479 assert( pCsr->eCurType==CURTYPE_SORTER );
102480 pSorter = pCsr->uc.pSorter;
102509 const VdbeCursor *pCsr, /* Sorter cursor */
102520 assert( pCsr->eCurType==CURTYPE_SORTER );
102521 pSorter = pCsr->uc.pSorter;
102523 pKeyInfo = pCsr->pKeyInfo;
136966 PragmaVtabCursor *pCsr;
136967 pCsr = (PragmaVtabCursor*)sqlite3_malloc(sizeof(*pCsr));
136968 if( pCsr==0 ) return SQLITE_NOMEM;
136969 memset(pCsr, 0, sizeof(PragmaVtabCursor));
136970 pCsr->base.pVtab = pVtab;
136971 *ppCursor = &pCsr->base;
136976 static void pragmaVtabCursorClear(PragmaVtabCursor *pCsr){
136978 sqlite3_finalize(pCsr->pPragma);
136979 pCsr->pPragma = 0;
136980 for(i=0; i<ArraySize(pCsr->azArg); i++){
136981 sqlite3_free(pCsr->azArg[i]);
136982 pCsr->azArg[i] = 0;
136988 PragmaVtabCursor *pCsr = (PragmaVtabCursor*)cur;
136989 pragmaVtabCursorClear(pCsr);
136990 sqlite3_free(pCsr);
136996 PragmaVtabCursor *pCsr = (PragmaVtabCursor*)pVtabCursor;
137000 pCsr->iRowid++;
137001 assert( pCsr->pPragma );
137002 if( SQLITE_ROW!=sqlite3_step(pCsr->pPragma) ){
137003 rc = sqlite3_finalize(pCsr->pPragma);
137004 pCsr->pPragma = 0;
137005 pragmaVtabCursorClear(pCsr);
137018 PragmaVtabCursor *pCsr = (PragmaVtabCursor*)pVtabCursor;
137027 pragmaVtabCursorClear(pCsr);
137031 assert( j<ArraySize(pCsr->azArg) );
137032 assert( pCsr->azArg[j]==0 );
137034 pCsr->azArg[j] = sqlite3_mprintf("%s", zText);
137035 if( pCsr->azArg[j]==0 ){
137042 if( pCsr->azArg[1] ){
137043 sqlite3_str_appendf(&acc, "%Q.", pCsr->azArg[1]);
137046 if( pCsr->azArg[0] ){
137047 sqlite3_str_appendf(&acc, "=%Q", pCsr->azArg[0]);
137051 rc = sqlite3_prepare_v2(pTab->db, zSql, -1, &pCsr->pPragma, 0);
137064 PragmaVtabCursor *pCsr = (PragmaVtabCursor*)pVtabCursor;
137065 return (pCsr->pPragma==0);
137076 PragmaVtabCursor *pCsr = (PragmaVtabCursor*)pVtabCursor;
137079 sqlite3_result_value(ctx, sqlite3_column_value(pCsr->pPragma, i));
137081 sqlite3_result_text(ctx, pCsr->azArg[i-pTab->iHidden],-1,SQLITE_TRANSIENT);
137090 PragmaVtabCursor *pCsr = (PragmaVtabCursor*)pVtabCursor;
137091 *p = pCsr->iRowid;
179184 int (*xLanguageid)(sqlite3_tokenizer_cursor *pCsr, int iLangid);
179871 SQLITE_PRIVATE int sqlite3Fts3EvalTestDeferred(Fts3Cursor *pCsr, int *pRc);
179916 SQLITE_PRIVATE int sqlite3Fts3MsrIncrRestart(Fts3MultiSegReader *pCsr);
179958 static int fts3EvalNext(Fts3Cursor *pCsr);
179959 static int fts3EvalStart(Fts3Cursor *pCsr);
181382 sqlite3_vtab_cursor *pCsr; /* Allocated cursor */
181390 *ppCsr = pCsr = (sqlite3_vtab_cursor *)sqlite3_malloc(sizeof(Fts3Cursor));
181391 if( !pCsr ){
181394 memset(pCsr, 0, sizeof(Fts3Cursor));
181399 ** Finalize the statement handle at pCsr->pStmt.
181405 static void fts3CursorFinalizeStmt(Fts3Cursor *pCsr){
181406 if( pCsr->bSeekStmt ){
181407 Fts3Table *p = (Fts3Table *)pCsr->base.pVtab;
181409 p->pSeekStmt = pCsr->pStmt;
181410 sqlite3_reset(pCsr->pStmt);
181411 pCsr->pStmt = 0;
181413 pCsr->bSeekStmt = 0;
181415 sqlite3_finalize(pCsr->pStmt);
181422 static void fts3ClearCursor(Fts3Cursor *pCsr){
181423 fts3CursorFinalizeStmt(pCsr);
181424 sqlite3Fts3FreeDeferredTokens(pCsr);
181425 sqlite3_free(pCsr->aDoclist);
181426 sqlite3Fts3MIBufferFree(pCsr->pMIBuffer);
181427 sqlite3Fts3ExprFree(pCsr->pExpr);
181428 memset(&(&pCsr->base)[1], 0, sizeof(Fts3Cursor)-sizeof(sqlite3_vtab_cursor));
181436 Fts3Cursor *pCsr = (Fts3Cursor *)pCursor;
181437 assert( ((Fts3Table *)pCsr->base.pVtab)->pSegments==0 );
181438 fts3ClearCursor(pCsr);
181439 assert( ((Fts3Table *)pCsr->base.pVtab)->pSegments==0 );
181440 sqlite3_free(pCsr);
181445 ** If pCsr->pStmt has not been prepared (i.e. if pCsr->pStmt==0), then
181450 ** (or the equivalent for a content=xxx table) and set pCsr->pStmt to
181453 static int fts3CursorSeekStmt(Fts3Cursor *pCsr){
181455 if( pCsr->pStmt==0 ){
181456 Fts3Table *p = (Fts3Table *)pCsr->base.pVtab;
181459 pCsr->pStmt = p->pSeekStmt;
181466 p->db, zSql,-1,SQLITE_PREPARE_PERSISTENT,&pCsr->pStmt,0
181471 if( rc==SQLITE_OK ) pCsr->bSeekStmt = 1;
181477 ** Position the pCsr->pStmt statement so that it is on the row
181481 static int fts3CursorSeek(sqlite3_context *pContext, Fts3Cursor *pCsr){
181483 if( pCsr->isRequireSeek ){
181484 rc = fts3CursorSeekStmt(pCsr);
181486 Fts3Table *pTab = (Fts3Table*)pCsr->base.pVtab;
181488 sqlite3_bind_int64(pCsr->pStmt, 1, pCsr->iPrevId);
181489 pCsr->isRequireSeek = 0;
181490 if( SQLITE_ROW==sqlite3_step(pCsr->pStmt) ){
181495 rc = sqlite3_reset(pCsr->pStmt);
181496 if( rc==SQLITE_OK && ((Fts3Table *)pCsr->base.pVtab)->zContentTbl==0 ){
181501 pCsr->isEof = 1;
182580 ** Append SegReader object pNew to the end of the pCsr->apSegment[] array.
182583 Fts3MultiSegReader *pCsr,
182586 if( (pCsr->nSegment%16)==0 ){
182588 sqlite3_int64 nByte = (pCsr->nSegment + 16)*sizeof(Fts3SegReader*);
182589 apNew = (Fts3SegReader **)sqlite3_realloc64(pCsr->apSegment, nByte);
182594 pCsr->apSegment = apNew;
182596 pCsr->apSegment[pCsr->nSegment++] = pNew;
182616 Fts3MultiSegReader *pCsr /* Cursor object to populate */
182632 rc = fts3SegReaderCursorAppend(pCsr, pSeg);
182660 rc = sqlite3Fts3SegReaderNew(pCsr->nSegment+1,
182666 rc = fts3SegReaderCursorAppend(pCsr, pSeg);
182690 Fts3MultiSegReader *pCsr /* Cursor object to populate */
182701 memset(pCsr, 0, sizeof(Fts3MultiSegReader));
182703 p, iLangid, iIndex, iLevel, zTerm, nTerm, isPrefix, isScan, pCsr
182718 Fts3MultiSegReader *pCsr /* Fts3MultiSegReader to modify */
182721 iLangid, 0, FTS3_SEGCURSOR_ALL, zTerm, nTerm, 0, 0,pCsr
182739 Fts3Cursor *pCsr, /* Virtual table cursor handle */
182752 Fts3Table *p = (Fts3Table *)pCsr->base.pVtab;
182758 rc = sqlite3Fts3SegReaderCursor(p, pCsr->iLangid,
182768 rc = sqlite3Fts3SegReaderCursor(p, pCsr->iLangid,
182773 p, pCsr->iLangid, zTerm, nTerm, pSegcsr
182781 rc = sqlite3Fts3SegReaderCursor(p, pCsr->iLangid,
182889 Fts3Cursor *pCsr = (Fts3Cursor *)pCursor;
182890 if( pCsr->eSearch==FTS3_DOCID_SEARCH || pCsr->eSearch==FTS3_FULLSCAN_SEARCH ){
182893 if( SQLITE_ROW!=sqlite3_step(pCsr->pStmt) ){
182894 pCsr->isEof = 1;
182895 rc = sqlite3_reset(pCsr->pStmt);
182897 pCsr->iPrevId = sqlite3_column_int64(pCsr->pStmt, 0);
182904 assert( ((Fts3Table *)pCsr->base.pVtab)->pSegments==0 );
182950 Fts3Cursor *pCsr = (Fts3Cursor *)pCursor;
182978 fts3ClearCursor(pCsr);
182981 pCsr->iMinDocid = fts3DocidRange(pDocidGe, SMALLEST_INT64);
182982 pCsr->iMaxDocid = fts3DocidRange(pDocidLe, LARGEST_INT64);
182985 pCsr->bDesc = (idxStr[0]=='D');
182987 pCsr->bDesc = p->bDescIdx;
182989 pCsr->eSearch = (i16)eSearch;
182999 pCsr->iLangid = 0;
183000 if( pLangid ) pCsr->iLangid = sqlite3_value_int(pLangid);
183003 rc = sqlite3Fts3ExprParse(p->pTokenizer, pCsr->iLangid,
183004 p->azColumn, p->bFts4, p->nColumn, iCol, zQuery, -1, &pCsr->pExpr,
183011 rc = fts3EvalStart(pCsr);
183014 pCsr->pNextId = pCsr->aDoclist;
183015 pCsr->iPrevId = 0;
183027 p->zReadExprlist, pCsr->iMinDocid, pCsr->iMaxDocid,
183028 (pCsr->bDesc ? "DESC" : "ASC")
183032 p->zReadExprlist, (pCsr->bDesc ? "DESC" : "ASC")
183038 p->db,zSql,-1,SQLITE_PREPARE_PERSISTENT,&pCsr->pStmt,0
183046 rc = fts3CursorSeekStmt(pCsr);
183048 rc = sqlite3_bind_value(pCsr->pStmt, 1, pCons);
183061 Fts3Cursor *pCsr = (Fts3Cursor*)pCursor;
183062 if( pCsr->isEof ){
183063 fts3ClearCursor(pCsr);
183064 pCsr->isEof = 1;
183066 return pCsr->isEof;
183076 Fts3Cursor *pCsr = (Fts3Cursor *) pCursor;
183077 *pRowid = pCsr->iPrevId;
183098 Fts3Cursor *pCsr = (Fts3Cursor *) pCursor;
183107 sqlite3_result_pointer(pCtx, pCsr, "fts3cursor", 0);
183112 sqlite3_result_int64(pCtx, pCsr->iPrevId);
183116 if( pCsr->pExpr ){
183117 sqlite3_result_int64(pCtx, pCsr->iLangid);
183130 rc = fts3CursorSeek(0, pCsr);
183131 if( rc==SQLITE_OK && sqlite3_data_count(pCsr->pStmt)-1>iCol ){
183132 sqlite3_result_value(pCtx, sqlite3_column_value(pCsr->pStmt, iCol+1));
183137 assert( ((Fts3Table *)pCsr->base.pVtab)->pSegments==0 );
183352 Fts3Cursor *pCsr; /* Cursor handle passed through apVal[0] */
183369 if( fts3FunctionArg(pContext, "snippet", apVal[0], &pCsr) ) return;
183386 }else if( SQLITE_OK==fts3CursorSeek(pContext, pCsr) ){
183387 sqlite3Fts3Snippet(pContext, pCsr, zStart, zEnd, zEllipsis, iCol, nToken);
183399 Fts3Cursor *pCsr; /* Cursor handle passed through apVal[0] */
183404 if( fts3FunctionArg(pContext, "offsets", apVal[0], &pCsr) ) return;
183405 assert( pCsr );
183406 if( SQLITE_OK==fts3CursorSeek(pContext, pCsr) ){
183407 sqlite3Fts3Offsets(pContext, pCsr);
183459 Fts3Cursor *pCsr; /* Cursor handle passed through apVal[0] */
183461 if( SQLITE_OK==fts3FunctionArg(pContext, "matchinfo", apVal[0], &pCsr) ){
183466 sqlite3Fts3Matchinfo(pContext, pCsr, zArg);
183805 Fts3Cursor *pCsr, /* FTS cursor handle */
183818 int rc = fts3TermSegReaderCursor(pCsr,
183830 fts3EvalAllocateReaders(pCsr, pExpr->pLeft, pnToken, pnOr, pRc);
183831 fts3EvalAllocateReaders(pCsr, pExpr->pRight, pnToken, pnOr, pRc);
183911 Fts3Cursor *pCsr, /* FTS Cursor handle */
183914 Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab;
183947 static int fts3EvalDeferredPhrase(Fts3Cursor *pCsr, Fts3Phrase *pPhrase){
184002 pPhrase->doclist.iDocid = pCsr->iPrevId;
184063 static int fts3EvalPhraseStart(Fts3Cursor *pCsr, int bOptOk, Fts3Phrase *p){
184064 Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab;
184075 && pCsr->bDesc==pTab->bDescIdx
184102 rc = fts3EvalPhraseLoad(pCsr, p);
184330 Fts3Cursor *pCsr, /* FTS Cursor handle */
184336 Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab;
184349 int bDescDoclist = pCsr->bDesc;
184431 Fts3Cursor *pCsr, /* FTS Cursor handle */
184437 Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab;
184440 rc = fts3EvalIncrPhraseNext(pCsr, p, pbEof);
184441 }else if( pCsr->bDesc!=pTab->bDescIdx && pDL->nAll ){
184470 Fts3Cursor *pCsr, /* FTS Cursor handle */
184484 *pRc = fts3EvalPhraseStart(pCsr, 1, pExpr->pPhrase);
184486 fts3EvalStartReaders(pCsr, pExpr->pLeft, pRc);
184487 fts3EvalStartReaders(pCsr, pExpr->pRight, pRc);
184523 Fts3Cursor *pCsr, /* FTS Cursor handle */
184541 *pRc = sqlite3Fts3MsrOvfl(pCsr, pTC->pToken->pSegcsr, &pTC->nOvfl);
184554 fts3EvalTokenCosts(pCsr, pRoot, pExpr->pLeft, ppTC, ppOr, pRc);
184560 fts3EvalTokenCosts(pCsr, pRoot, pExpr->pRight, ppTC, ppOr, pRc);
184576 static int fts3EvalAverageDocsize(Fts3Cursor *pCsr, int *pnPage){
184578 if( pCsr->nRowAvg==0 ){
184590 Fts3Table *p = (Fts3Table*)pCsr->base.pVtab;
184613 pCsr->nDoc = nDoc;
184614 pCsr->nRowAvg = (int)(((nByte / nDoc) + p->nPgsz) / p->nPgsz);
184615 assert( pCsr->nRowAvg>0 );
184619 *pnPage = pCsr->nRowAvg;
184638 Fts3Cursor *pCsr, /* FTS Cursor handle */
184643 Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab;
184674 rc = fts3EvalAverageDocsize(pCsr, &nDocSize);
184720 rc = sqlite3Fts3DeferToken(pCsr, pToken, pTC->iCol);
184760 ** the full-text query currently stored in pCsr->pExpr. To iterate through
184763 ** fts3EvalStart(pCsr);
184765 ** fts3EvalNext(pCsr);
184766 ** if( pCsr->bEof ) break;
184767 ** ... return row pCsr->iPrevId to the caller ...
184770 static int fts3EvalStart(Fts3Cursor *pCsr){
184771 Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab;
184777 fts3EvalAllocateReaders(pCsr, pCsr->pExpr, &nToken, &nOr, &rc);
184796 fts3EvalTokenCosts(pCsr, 0, pCsr->pExpr, &pTC, &ppOr, &rc);
184801 rc = fts3EvalSelectDeferred(pCsr, 0, aTC, nToken);
184803 rc = fts3EvalSelectDeferred(pCsr, apOr[ii], aTC, nToken);
184812 fts3EvalStartReaders(pCsr, pCsr->pExpr, &rc);
184927 Fts3Cursor *pCsr, /* FTS Cursor handle */
184932 int bDescDoclist = pCsr->bDesc; /* Used by DOCID_CMP() macro */
184946 fts3EvalNextRow(pCsr, pRight, pRc);
184952 fts3EvalNextRow(pCsr, pLeft, pRc);
184957 fts3EvalNextRow(pCsr, pLeft, pRc);
184958 fts3EvalNextRow(pCsr, pRight, pRc);
184963 fts3EvalNextRow(pCsr, pLeft, pRc);
184965 fts3EvalNextRow(pCsr, pRight, pRc);
184976 fts3EvalNextRow(pCsr, pRight, pRc);
184983 fts3EvalNextRow(pCsr, pLeft, pRc);
185001 fts3EvalNextRow(pCsr, pLeft, pRc);
185003 fts3EvalNextRow(pCsr, pRight, pRc);
185005 fts3EvalNextRow(pCsr, pLeft, pRc);
185006 fts3EvalNextRow(pCsr, pRight, pRc);
185025 fts3EvalNextRow(pCsr, pRight, pRc);
185029 fts3EvalNextRow(pCsr, pLeft, pRc);
185035 fts3EvalNextRow(pCsr, pRight, pRc);
185046 *pRc = fts3EvalPhraseNext(pCsr, pPhrase, &pExpr->bEof);
185143 ** expression passed as the second argument matches the row that pCsr
185152 Fts3Cursor *pCsr, /* FTS cursor handle */
185162 fts3EvalTestExpr(pCsr, pExpr->pLeft, pRc)
185163 && fts3EvalTestExpr(pCsr, pExpr->pRight, pRc)
185188 if( p->pRight->iDocid==pCsr->iPrevId ){
185192 if( p->iDocid==pCsr->iPrevId ){
185200 int bHit1 = fts3EvalTestExpr(pCsr, pExpr->pLeft, pRc);
185201 int bHit2 = fts3EvalTestExpr(pCsr, pExpr->pRight, pRc);
185208 fts3EvalTestExpr(pCsr, pExpr->pLeft, pRc)
185209 && !fts3EvalTestExpr(pCsr, pExpr->pRight, pRc)
185215 if( pCsr->pDeferred && (pExpr->bDeferred || (
185216 pExpr->iDocid==pCsr->iPrevId && pExpr->pPhrase->doclist.pList
185222 *pRc = fts3EvalDeferredPhrase(pCsr, pPhrase);
185224 pExpr->iDocid = pCsr->iPrevId;
185229 pExpr->bEof==0 && pExpr->iDocid==pCsr->iPrevId
185264 SQLITE_PRIVATE int sqlite3Fts3EvalTestDeferred(Fts3Cursor *pCsr, int *pRc){
185275 if( pCsr->pDeferred ){
185276 rc = fts3CursorSeek(0, pCsr);
185278 rc = sqlite3Fts3CacheDeferredDoclists(pCsr);
185281 bMiss = (0==fts3EvalTestExpr(pCsr, pCsr->pExpr, &rc));
185284 sqlite3Fts3FreeDeferredDoclists(pCsr);
185294 static int fts3EvalNext(Fts3Cursor *pCsr){
185296 Fts3Expr *pExpr = pCsr->pExpr;
185297 assert( pCsr->isEof==0 );
185299 pCsr->isEof = 1;
185302 if( pCsr->isRequireSeek==0 ){
185303 sqlite3_reset(pCsr->pStmt);
185305 assert( sqlite3_data_count(pCsr->pStmt)==0 );
185306 fts3EvalNextRow(pCsr, pExpr, &rc);
185307 pCsr->isEof = pExpr->bEof;
185308 pCsr->isRequireSeek = 1;
185309 pCsr->isMatchinfoNeeded = 1;
185310 pCsr->iPrevId = pExpr->iDocid;
185311 }while( pCsr->isEof==0 && sqlite3Fts3EvalTestDeferred(pCsr, &rc) );
185317 (pCsr->bDesc==0 && pCsr->iPrevId>pCsr->iMaxDocid)
185318 || (pCsr->bDesc!=0 && pCsr->iPrevId<pCsr->iMinDocid)
185320 pCsr->isEof = 1;
185336 Fts3Cursor *pCsr,
185354 *pRc = fts3EvalPhraseStart(pCsr, 0, pPhrase);
185365 fts3EvalRestart(pCsr, pExpr->pLeft, pRc);
185366 fts3EvalRestart(pCsr, pExpr->pRight, pRc);
185421 Fts3Cursor *pCsr, /* Cursor object */
185428 Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab;
185432 sqlite3_int64 iPrevId = pCsr->iPrevId;
185454 fts3EvalRestart(pCsr, pRoot, &rc);
185456 while( pCsr->isEof==0 && rc==SQLITE_OK ){
185460 if( pCsr->isRequireSeek==0 ) sqlite3_reset(pCsr->pStmt);
185461 assert( sqlite3_data_count(pCsr->pStmt)==0 );
185464 fts3EvalNextRow(pCsr, pRoot, &rc);
185465 pCsr->isEof = pRoot->bEof;
185466 pCsr->isRequireSeek = 1;
185467 pCsr->isMatchinfoNeeded = 1;
185468 pCsr->iPrevId = pRoot->iDocid;
185469 }while( pCsr->isEof==0
185471 && sqlite3Fts3EvalTestDeferred(pCsr, &rc)
185474 if( rc==SQLITE_OK && pCsr->isEof==0 ){
185479 pCsr->isEof = 0;
185480 pCsr->iPrevId = iPrevId;
185491 fts3EvalRestart(pCsr, pRoot, &rc);
185493 fts3EvalNextRow(pCsr, pRoot, &rc);
185533 Fts3Cursor *pCsr, /* FTS cursor handle */
185537 Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab;
185542 assert( pCsr->nDoc>0 );
185544 aiOut[iCol*3 + 1] = (u32)pCsr->nDoc;
185545 aiOut[iCol*3 + 2] = (u32)pCsr->nDoc;
185548 rc = fts3EvalGatherStats(pCsr, pExpr);
185581 Fts3Cursor *pCsr, /* FTS3 cursor object */
185587 Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab;
185602 if( iDocid!=pCsr->iPrevId || pExpr->bEof ){
185613 ** pCsr->iPrevId may lie earlier in the doclist buffer. Or, if the
185629 fts3EvalRestart(pCsr, pNear, &rc);
185631 fts3EvalNextRow(pCsr, pNear, &rc);
185641 fts3EvalNextRow(pCsr, pNear, &rc);
185658 if( pCsr->bDesc==bDescDoclist ){
185661 while( (pIter==0 || DOCID_CMP(iDocid, pCsr->iPrevId)<0 ) && bEof==0 ){
185669 while( (pIter==0 || DOCID_CMP(iDocid, pCsr->iPrevId)>0 ) && bEof==0 ){
185679 if( bEof || iDocid!=pCsr->iPrevId ) bMatch = 0;
185980 Fts3auxCursor *pCsr; /* Pointer to cursor object to return */
185984 pCsr = (Fts3auxCursor *)sqlite3_malloc(sizeof(Fts3auxCursor));
185985 if( !pCsr ) return SQLITE_NOMEM;
185986 memset(pCsr, 0, sizeof(Fts3auxCursor));
185988 *ppCsr = (sqlite3_vtab_cursor *)pCsr;
185997 Fts3auxCursor *pCsr = (Fts3auxCursor *)pCursor;
186000 sqlite3Fts3SegReaderFinish(&pCsr->csr);
186001 sqlite3_free((void *)pCsr->filter.zTerm);
186002 sqlite3_free(pCsr->zStop);
186003 sqlite3_free(pCsr->aStat);
186004 sqlite3_free(pCsr);
186008 static int fts3auxGrowStatArray(Fts3auxCursor *pCsr, int nSize){
186009 if( nSize>pCsr->nStat ){
186011 aNew = (struct Fts3auxColstats *)sqlite3_realloc64(pCsr->aStat,
186015 memset(&aNew[pCsr->nStat], 0,
186016 sizeof(struct Fts3auxColstats) * (nSize - pCsr->nStat)
186018 pCsr->aStat = aNew;
186019 pCsr->nStat = nSize;
186028 Fts3auxCursor *pCsr = (Fts3auxCursor *)pCursor;
186033 pCsr->iRowid++;
186035 for(pCsr->iCol++; pCsr->iCol<pCsr->nStat; pCsr->iCol++){
186036 if( pCsr->aStat[pCsr->iCol].nDoc>0 ) return SQLITE_OK;
186039 rc = sqlite3Fts3SegReaderStep(pFts3, &pCsr->csr);
186042 int nDoclist = pCsr->csr.nDoclist;
186043 char *aDoclist = pCsr->csr.aDoclist;
186048 if( pCsr->zStop ){
186049 int n = (pCsr->nStop<pCsr->csr.nTerm) ? pCsr->nStop : pCsr->csr.nTerm;
186050 int mc = memcmp(pCsr->zStop, pCsr->csr.zTerm, n);
186051 if( mc<0 || (mc==0 && pCsr->csr.nTerm>pCsr->nStop) ){
186052 pCsr->isEof = 1;
186057 if( fts3auxGrowStatArray(pCsr, 2) ) return SQLITE_NOMEM;
186058 memset(pCsr->aStat, 0, sizeof(struct Fts3auxColstats) * pCsr->nStat);
186069 pCsr->aStat[0].nDoc++;
186085 pCsr->aStat[1].nDoc++;
186096 pCsr->aStat[iCol+1].nOcc++;
186097 pCsr->aStat[0].nOcc++;
186108 if( fts3auxGrowStatArray(pCsr, iCol+2) ) return SQLITE_NOMEM;
186109 pCsr->aStat[iCol+1].nDoc++;
186115 pCsr->iCol = 0;
186117 pCsr->isEof = 1;
186132 Fts3auxCursor *pCsr = (Fts3auxCursor *)pCursor;
186169 testcase(pCsr->filter.zTerm);
186170 sqlite3Fts3SegReaderFinish(&pCsr->csr);
186171 sqlite3_free((void *)pCsr->filter.zTerm);
186172 sqlite3_free(pCsr->aStat);
186173 sqlite3_free(pCsr->zStop);
186174 memset(&pCsr->csr, 0, ((u8*)&pCsr[1]) - (u8*)&pCsr->csr);
186176 pCsr->filter.flags = FTS3_SEGMENT_REQUIRE_POS|FTS3_SEGMENT_IGNORE_EMPTY;
186177 if( isScan ) pCsr->filter.flags |= FTS3_SEGMENT_SCAN;
186183 pCsr->filter.zTerm = sqlite3_mprintf("%s", zStr);
186184 if( pCsr->filter.zTerm==0 ) return SQLITE_NOMEM;
186185 pCsr->filter.nTerm = (int)strlen(pCsr->filter.zTerm);
186190 pCsr->zStop = sqlite3_mprintf("%s", sqlite3_value_text(apVal[iLe]));
186191 if( pCsr->zStop==0 ) return SQLITE_NOMEM;
186192 pCsr->nStop = (int)strlen(pCsr->zStop);
186205 pCsr->iLangid = iLangVal;
186208 pCsr->filter.zTerm, pCsr->filter.nTerm, 0, isScan, &pCsr->csr
186211 rc = sqlite3Fts3SegReaderStart(pFts3, &pCsr->csr, &pCsr->filter);
186222 Fts3auxCursor *pCsr = (Fts3auxCursor *)pCursor;
186223 return pCsr->isEof;
186274 Fts3auxCursor *pCsr = (Fts3auxCursor *)pCursor;
186275 *pRowid = pCsr->iRowid;
186458 sqlite3_tokenizer_cursor *pCsr = 0;
186461 rc = pModule->xOpen(pTokenizer, z, n, &pCsr);
186462 assert( rc==SQLITE_OK || pCsr==0 );
186464 pCsr->pTokenizer = pTokenizer;
186466 rc = pModule->xLanguageid(pCsr, iLangid);
186468 pModule->xClose(pCsr);
186469 pCsr = 0;
186473 *ppCsr = pCsr;
188935 sqlite3_tokenizer_cursor *pCsr = 0;
188987 if( sqlite3Fts3OpenTokenizer(pTokenizer, 0, zInput, nInput, &pCsr) ){
188992 while( SQLITE_OK==p->xNext(pCsr, &zToken, &nToken, &iStart, &iEnd, &iPos) ){
189000 if( SQLITE_OK!=p->xClose(pCsr) ){
189491 sqlite3_tokenizer_cursor *pCsr; /* Cursor to iterate through zInput */
189690 Fts3tokCursor *pCsr;
189693 pCsr = (Fts3tokCursor *)sqlite3_malloc(sizeof(Fts3tokCursor));
189694 if( pCsr==0 ){
189697 memset(pCsr, 0, sizeof(Fts3tokCursor));
189699 *ppCsr = (sqlite3_vtab_cursor *)pCsr;
189707 static void fts3tokResetCursor(Fts3tokCursor *pCsr){
189708 if( pCsr->pCsr ){
189709 Fts3tokTable *pTab = (Fts3tokTable *)(pCsr->base.pVtab);
189710 pTab->pMod->xClose(pCsr->pCsr);
189711 pCsr->pCsr = 0;
189713 sqlite3_free(pCsr->zInput);
189714 pCsr->zInput = 0;
189715 pCsr->zToken = 0;
189716 pCsr->nToken = 0;
189717 pCsr->iStart = 0;
189718 pCsr->iEnd = 0;
189719 pCsr->iPos = 0;
189720 pCsr->iRowid = 0;
189727 Fts3tokCursor *pCsr = (Fts3tokCursor *)pCursor;
189729 fts3tokResetCursor(pCsr);
189730 sqlite3_free(pCsr);
189738 Fts3tokCursor *pCsr = (Fts3tokCursor *)pCursor;
189742 pCsr->iRowid++;
189743 rc = pTab->pMod->xNext(pCsr->pCsr,
189744 &pCsr->zToken, &pCsr->nToken,
189745 &pCsr->iStart, &pCsr->iEnd, &pCsr->iPos
189749 fts3tokResetCursor(pCsr);
189767 Fts3tokCursor *pCsr = (Fts3tokCursor *)pCursor;
189772 fts3tokResetCursor(pCsr);
189776 pCsr->zInput = sqlite3_malloc64(nByte+1);
189777 if( pCsr->zInput==0 ){
189780 if( nByte>0 ) memcpy(pCsr->zInput, zByte, nByte);
189781 pCsr->zInput[nByte] = 0;
189782 rc = pTab->pMod->xOpen(pTab->pTok, pCsr->zInput, nByte, &pCsr->pCsr);
189784 pCsr->pCsr->pTokenizer = pTab->pTok;
189797 Fts3tokCursor *pCsr = (Fts3tokCursor *)pCursor;
189798 return (pCsr->zToken==0);
189809 Fts3tokCursor *pCsr = (Fts3tokCursor *)pCursor;
189814 sqlite3_result_text(pCtx, pCsr->zInput, -1, SQLITE_TRANSIENT);
189817 sqlite3_result_text(pCtx, pCsr->zToken, pCsr->nToken, SQLITE_TRANSIENT);
189820 sqlite3_result_int(pCtx, pCsr->iStart);
189823 sqlite3_result_int(pCtx, pCsr->iEnd);
189827 sqlite3_result_int(pCtx, pCsr->iPos);
189840 Fts3tokCursor *pCsr = (Fts3tokCursor *)pCursor;
189841 *pRowid = (sqlite3_int64)pCsr->iRowid;
190693 sqlite3_tokenizer_cursor *pCsr;
190707 rc = sqlite3Fts3OpenTokenizer(pTokenizer, iLangid, zText, -1, &pCsr);
190714 && SQLITE_OK==(rc = xNext(pCsr, &zToken, &nToken, &iStart, &iEnd, &iPos))
190743 pModule->xClose(pCsr);
191450 Fts3Cursor *pCsr,
191454 Fts3Table *p = (Fts3Table*)pCsr->base.pVtab;
192640 Fts3MultiSegReader *pCsr, /* Cursor object */
192645 int nSeg = pCsr->nSegment;
192653 for(i=0; pCsr->bRestart==0 && i<pCsr->nSegment; i++){
192655 Fts3SegReader *pSeg = pCsr->apSegment[i];
192665 fts3SegReaderSort(pCsr->apSegment, nSeg, nSeg, fts3SegReaderCmp);
192672 Fts3MultiSegReader *pCsr, /* Cursor object */
192675 pCsr->pFilter = pFilter;
192676 return fts3SegReaderStart(p, pCsr, pFilter->zTerm, pFilter->nTerm);
192681 Fts3MultiSegReader *pCsr, /* Cursor object */
192688 int nSegment = pCsr->nSegment;
192693 assert( pCsr->pFilter==0 );
192697 rc = fts3SegReaderStart(p, pCsr, zTerm, nTerm);
192702 Fts3SegReader *pSeg = pCsr->apSegment[i];
192707 pCsr->nAdvance = i;
192710 for(i=0; i<pCsr->nAdvance; i++){
192711 rc = fts3SegReaderFirstDocid(p, pCsr->apSegment[i]);
192714 fts3SegReaderSort(pCsr->apSegment, i, i, xCmp);
192717 pCsr->iColFilter = iCol;
192734 SQLITE_PRIVATE int sqlite3Fts3MsrIncrRestart(Fts3MultiSegReader *pCsr){
192737 assert( pCsr->zTerm==0 );
192738 assert( pCsr->nTerm==0 );
192739 assert( pCsr->aDoclist==0 );
192740 assert( pCsr->nDoclist==0 );
192742 pCsr->nAdvance = 0;
192743 pCsr->bRestart = 1;
192744 for(i=0; i<pCsr->nSegment; i++){
192745 pCsr->apSegment[i]->pOffsetList = 0;
192746 pCsr->apSegment[i]->nOffsetList = 0;
192747 pCsr->apSegment[i]->iDocid = 0;
192753 static int fts3GrowSegReaderBuffer(Fts3MultiSegReader *pCsr, i64 nReq){
192754 if( nReq>pCsr->nBuffer ){
192756 pCsr->nBuffer = nReq*2;
192757 aNew = sqlite3_realloc64(pCsr->aBuffer, pCsr->nBuffer);
192761 pCsr->aBuffer = aNew;
192769 Fts3MultiSegReader *pCsr /* Cursor object */
192773 int isIgnoreEmpty = (pCsr->pFilter->flags & FTS3_SEGMENT_IGNORE_EMPTY);
192774 int isRequirePos = (pCsr->pFilter->flags & FTS3_SEGMENT_REQUIRE_POS);
192775 int isColFilter = (pCsr->pFilter->flags & FTS3_SEGMENT_COLUMN_FILTER);
192776 int isPrefix = (pCsr->pFilter->flags & FTS3_SEGMENT_PREFIX);
192777 int isScan = (pCsr->pFilter->flags & FTS3_SEGMENT_SCAN);
192778 int isFirst = (pCsr->pFilter->flags & FTS3_SEGMENT_FIRST);
192780 Fts3SegReader **apSegment = pCsr->apSegment;
192781 int nSegment = pCsr->nSegment;
192782 Fts3SegFilter *pFilter = pCsr->pFilter;
192787 if( pCsr->nSegment==0 ) return SQLITE_OK;
192793 /* Advance the first pCsr->nAdvance entries in the apSegment[] array
192796 for(i=0; i<pCsr->nAdvance; i++){
192805 fts3SegReaderSort(apSegment, nSegment, pCsr->nAdvance, fts3SegReaderCmp);
192806 pCsr->nAdvance = 0;
192812 pCsr->nTerm = apSegment[0]->nTerm;
192813 pCsr->zTerm = apSegment[0]->zTerm;
192823 if( pCsr->nTerm<pFilter->nTerm
192824 || (!isPrefix && pCsr->nTerm>pFilter->nTerm)
192825 || memcmp(pCsr->zTerm, pFilter->zTerm, pFilter->nTerm)
192834 && apSegment[nMerge]->nTerm==pCsr->nTerm
192835 && 0==memcmp(pCsr->zTerm, apSegment[nMerge]->zTerm, pCsr->nTerm)
192846 pCsr->nDoclist = apSegment[0]->nDoclist;
192848 rc = fts3MsrBufferData(pCsr, apSegment[0]->aDoclist,
192849 (i64)pCsr->nDoclist);
192850 pCsr->aDoclist = pCsr->aBuffer;
192852 pCsr->aDoclist = apSegment[0]->aDoclist;
192902 rc = fts3GrowSegReaderBuffer(pCsr,
192907 char *a = &pCsr->aBuffer[nDoclist];
192916 nDoclist += sqlite3Fts3PutVarint(&pCsr->aBuffer[nDoclist], iDelta);
192919 memcpy(&pCsr->aBuffer[nDoclist], pList, nList);
192921 pCsr->aBuffer[nDoclist++] = '\0';
192929 rc = fts3GrowSegReaderBuffer(pCsr, (i64)nDoclist+FTS3_NODE_PADDING);
192931 memset(&pCsr->aBuffer[nDoclist], 0, FTS3_NODE_PADDING);
192932 pCsr->aDoclist = pCsr->aBuffer;
192933 pCsr->nDoclist = nDoclist;
192937 pCsr->nAdvance = nMerge;
192945 Fts3MultiSegReader *pCsr /* Cursor object */
192947 if( pCsr ){
192949 for(i=0; i<pCsr->nSegment; i++){
192950 sqlite3Fts3SegReaderFree(pCsr->apSegment[i]);
192952 sqlite3_free(pCsr->apSegment);
192953 sqlite3_free(pCsr->aBuffer);
192955 pCsr->nSegment = 0;
192956 pCsr->apSegment = 0;
192957 pCsr->aBuffer = 0;
193527 Fts3MultiSegReader *pCsr /* Cursor object to populate */
193531 sqlite3_int64 nByte; /* Bytes allocated at pCsr->apSegment[] */
193534 memset(pCsr, 0, sizeof(*pCsr));
193536 pCsr->apSegment = (Fts3SegReader **)sqlite3_malloc64(nByte);
193538 if( pCsr->apSegment==0 ){
193541 memset(pCsr->apSegment, 0, nByte);
193548 assert( pCsr->nSegment==0 );
193556 &pCsr->apSegment[i]
193558 pCsr->nSegment++;
193892 ** Append the current term and doclist pointed to by cursor pCsr to the
193900 Fts3MultiSegReader *pCsr /* Cursor containing term and doclist */
193902 const char *zTerm = pCsr->zTerm;
193903 int nTerm = pCsr->nTerm;
193904 const char *aDoclist = pCsr->aDoclist;
193905 int nDoclist = pCsr->nDoclist;
194334 Fts3MultiSegReader *pCsr, /* Cursor that data will be read from */
194347 sqlite3_bind_int64(pLeafEst, 2, pCsr->nSegment);
194641 Fts3MultiSegReader *pCsr, /* Chomp all segments opened by this cursor */
194648 for(i=pCsr->nSegment-1; i>=0 && rc==SQLITE_OK; i--){
194653 ** somewhere in the pCsr->apSegment[] array. */
194654 for(j=0; ALWAYS(j<pCsr->nSegment); j++){
194655 pSeg = pCsr->apSegment[j];
194658 assert( j<pCsr->nSegment && pSeg->iIdx==i );
194678 if( rc==SQLITE_OK && nRem!=pCsr->nSegment ){
194803 Fts3MultiSegReader *pCsr; /* Cursor used to read input data */
194804 Fts3SegFilter *pFilter; /* Filter used with cursor pCsr */
194812 const int nAlloc = sizeof(*pCsr) + sizeof(*pFilter) + sizeof(*pWriter);
194816 pCsr = (Fts3MultiSegReader *)&pFilter[1];
194904 rc = fts3IncrmergeCsr(p, iAbsLevel, nSeg, pCsr);
194906 if( SQLITE_OK==rc && pCsr->nSegment==nSeg
194907 && SQLITE_OK==(rc = sqlite3Fts3SegReaderStart(p, pCsr, pFilter))
194910 rc = sqlite3Fts3SegReaderStep(p, pCsr);
194914 sqlite3Fts3SegReaderFinish(pCsr);
194918 const char *zKey = pCsr->zTerm;
194919 int nKey = pCsr->nTerm;
194922 rc = fts3IncrmergeWriter(p, iAbsLevel, iIdx, pCsr, pWriter);
194929 rc = fts3IncrmergeAppend(p, pWriter, pCsr);
194930 if( rc==SQLITE_OK ) rc = sqlite3Fts3SegReaderStep(p, pCsr);
194938 rc = fts3IncrmergeChomp(p, iAbsLevel, pCsr, &nSeg);
194955 sqlite3Fts3SegReaderFinish(pCsr);
195121 char *pCsr = csr.aDoclist;
195122 char *pEnd = &pCsr[csr.nDoclist];
195128 pCsr += sqlite3Fts3GetVarint(pCsr, &iDocid);
195129 while( pCsr<pEnd ){
195131 pCsr += sqlite3Fts3GetVarintU(pCsr, &iVal);
195132 if( pCsr<pEnd ){
195137 pCsr += sqlite3Fts3GetVarint(pCsr, &iCol);
195139 pCsr += sqlite3Fts3GetVarintU(pCsr, &iVal);
195349 SQLITE_PRIVATE void sqlite3Fts3FreeDeferredDoclists(Fts3Cursor *pCsr){
195351 for(pDef=pCsr->pDeferred; pDef; pDef=pDef->pNext){
195358 ** Free all entries in the pCsr->pDeffered list. Entries are added to
195361 SQLITE_PRIVATE void sqlite3Fts3FreeDeferredTokens(Fts3Cursor *pCsr){
195364 for(pDef=pCsr->pDeferred; pDef; pDef=pNext){
195369 pCsr->pDeferred = 0;
195373 ** Generate deferred-doclists for all tokens in the pCsr->pDeferred list
195374 ** based on the row that pCsr currently points to.
195380 SQLITE_PRIVATE int sqlite3Fts3CacheDeferredDoclists(Fts3Cursor *pCsr){
195382 if( pCsr->pDeferred ){
195384 sqlite3_int64 iDocid; /* Docid of the row pCsr points to */
195387 Fts3Table *p = (Fts3Table *)pCsr->base.pVtab;
195391 assert( pCsr->isRequireSeek==0 );
195392 iDocid = sqlite3_column_int64(pCsr->pStmt, 0);
195396 const char *zText = (const char *)sqlite3_column_text(pCsr->pStmt, i+1);
195399 rc = sqlite3Fts3OpenTokenizer(pT, pCsr->iLangid, zText, -1, &pTC);
195407 for(pDef=pCsr->pDeferred; pDef && rc==SQLITE_OK; pDef=pDef->pNext){
195423 for(pDef=pCsr->pDeferred; pDef && rc==SQLITE_OK; pDef=pDef->pNext){
195461 ** Add an entry for token pToken to the pCsr->pDeferred list.
195464 Fts3Cursor *pCsr, /* Fts3 table cursor */
195475 pDeferred->pNext = pCsr->pDeferred;
195477 pCsr->pDeferred = pDeferred;
195753 Fts3Cursor *pCsr; /* FTS3 Cursor */
195767 Fts3Cursor *pCsr; /* Cursor snippet is being generated from */
196015 ** pCsr.
196024 Fts3Cursor *pCsr, /* Fts3 cursor for current query */
196030 sCtx.pCsr = pCsr;
196031 rc = fts3ExprIterate(pCsr->pExpr, fts3ExprLoadDoclistsCb, (void *)&sCtx);
196138 char *pCsr = pPhrase->pTail;
196158 if( 0==(*pCsr & 0x0FE) ) break;
196159 fts3GetDeltaPosition(&pCsr, &iCsr);
196178 char *pCsr;
196182 rc = sqlite3Fts3EvalPhrasePoslist(p->pCsr, pExpr, p->iCol, &pCsr);
196183 assert( rc==SQLITE_OK || pCsr==0 );
196184 if( pCsr ){
196186 pPhrase->pList = pCsr;
196187 fts3GetDeltaPosition(&pCsr, &iFirst);
196191 pPhrase->pHead = pCsr;
196192 pPhrase->pTail = pCsr;
196222 Fts3Cursor *pCsr, /* Cursor to create snippet for */
196241 rc = fts3ExprLoadDoclists(pCsr, &nList, 0);
196258 sIter.pCsr = pCsr;
196263 rc = fts3ExprIterate(pCsr->pExpr, fts3SnippetFindPositions, (void*)&sIter);
196419 ** Extract the snippet text for fragment pFragment from cursor pCsr and
196423 Fts3Cursor *pCsr, /* FTS3 Cursor */
196433 Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab;
196446 zDoc = (const char *)sqlite3_column_text(pCsr->pStmt, iCol);
196448 if( sqlite3_column_type(pCsr->pStmt, iCol)!=SQLITE_NULL ){
196453 nDoc = sqlite3_column_bytes(pCsr->pStmt, iCol);
196457 rc = sqlite3Fts3OpenTokenizer(pTab->pTokenizer, pCsr->iLangid, zDoc,nDoc,&pC);
196496 pTab, pCsr->iLangid, nSnippet, &zDoc[iBegin], n, &iPos, &hlmask
196677 char *pCsr;
196678 rc = sqlite3Fts3EvalPhrasePoslist(p->pCursor, pExpr, i, &pCsr);
196679 if( pCsr ){
196680 p->aMatchinfo[iStart+i*3] = fts3ColumnlistCount(&pCsr);
196846 static int fts3MatchinfoLcs(Fts3Cursor *pCsr, MatchInfo *pInfo){
196856 aIter = sqlite3Fts3MallocZero(sizeof(LcsIterator) * pCsr->nPhrase);
196858 (void)fts3ExprIterate(pCsr->pExpr, fts3MatchinfoLcsCb, (void*)aIter);
196872 rc = sqlite3Fts3EvalPhrasePoslist(pCsr, pIt->pExpr, iCol, &pIt->pRead);
196935 Fts3Cursor *pCsr, /* FTS3 cursor object */
196942 Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab;
196990 rc = sqlite3Fts3SelectDocsize(pTab, pCsr->iPrevId, &pSelectDocsize);
197010 rc = fts3ExprLoadDoclists(pCsr, 0, 0);
197012 rc = fts3MatchinfoLcs(pCsr, pInfo);
197020 rc = fts3ExprLHitGather(pCsr->pExpr, pInfo);
197027 pExpr = pCsr->pExpr;
197028 rc = fts3ExprLoadDoclists(pCsr, 0, 0);
197031 if( pCsr->pDeferred ){
197036 sqlite3Fts3EvalTestDeferred(pCsr, &rc);
197053 ** Populate pCsr->aMatchinfo[] with data for the current row. The
197058 Fts3Cursor *pCsr, /* FTS3 Cursor object */
197062 Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab;
197070 sInfo.pCursor = pCsr;
197076 if( pCsr->pMIBuffer && strcmp(pCsr->pMIBuffer->zMatchinfo, zArg) ){
197077 sqlite3Fts3MIBufferFree(pCsr->pMIBuffer);
197078 pCsr->pMIBuffer = 0;
197086 if( pCsr->pMIBuffer==0 ){
197091 pCsr->nPhrase = fts3ExprPhraseCount(pCsr->pExpr);
197092 sInfo.nPhrase = pCsr->nPhrase;
197106 pCsr->pMIBuffer = fts3MIBufferNew(nMatchinfo, zArg);
197107 if( !pCsr->pMIBuffer ) rc = SQLITE_NOMEM;
197109 pCsr->isMatchinfoNeeded = 1;
197114 xDestroyOut = fts3MIBufferAlloc(pCsr->pMIBuffer, &aOut);
197122 sInfo.nPhrase = pCsr->nPhrase;
197123 rc = fts3MatchinfoValues(pCsr, bGlobal, &sInfo, zArg);
197125 fts3MIBufferSetGlobal(pCsr->pMIBuffer);
197133 int n = pCsr->pMIBuffer->nElem * sizeof(u32);
197143 Fts3Cursor *pCsr, /* Cursor object */
197150 Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab;
197167 if( !pCsr->pExpr ){
197205 rc = fts3BestSnippet(nFToken, pCsr, iRead, mCovered, &mSeen, &sF, &iS);
197228 rc = fts3SnippetText(pCsr, &aSnippet[i],
197254 Fts3Cursor *pCsr;
197273 rc = sqlite3Fts3EvalPhrasePoslist(p->pCsr, pExpr, p->iCol, &pList);
197295 Fts3Cursor *pCsr /* Cursor object */
197297 Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab;
197305 if( !pCsr->pExpr ){
197311 assert( pCsr->isRequireSeek==0 );
197314 rc = fts3ExprLoadDoclists(pCsr, 0, &nToken);
197323 sCtx.iDocid = pCsr->iPrevId;
197324 sCtx.pCsr = pCsr;
197344 rc = fts3ExprIterate(pCsr->pExpr, fts3ExprTermOffsetInit, (void*)&sCtx);
197353 zDoc = (const char *)sqlite3_column_text(pCsr->pStmt, iCol+1);
197354 nDoc = sqlite3_column_bytes(pCsr->pStmt, iCol+1);
197356 if( sqlite3_column_type(pCsr->pStmt, iCol+1)==SQLITE_NULL ){
197364 rc = sqlite3Fts3OpenTokenizer(pTab->pTokenizer, pCsr->iLangid,
197433 Fts3Cursor *pCsr, /* FTS3 table cursor */
197436 Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab;
197445 if( !pCsr->pExpr ){
197450 fts3GetMatchinfo(pContext, pCsr, zFormat);
197735 unicode_cursor *pCsr;
197737 pCsr = (unicode_cursor *)sqlite3_malloc(sizeof(unicode_cursor));
197738 if( pCsr==0 ){
197741 memset(pCsr, 0, sizeof(unicode_cursor));
197743 pCsr->aInput = (const unsigned char *)aInput;
197745 pCsr->nInput = 0;
197746 pCsr->aInput = (const unsigned char*)"";
197748 pCsr->nInput = (int)strlen(aInput);
197750 pCsr->nInput = nInput;
197753 *pp = &pCsr->base;
197763 unicode_cursor *pCsr = (unicode_cursor *) pCursor;
197764 sqlite3_free(pCsr->zToken);
197765 sqlite3_free(pCsr);
197781 unicode_cursor *pCsr = (unicode_cursor *)pC;
197782 unicode_tokenizer *p = ((unicode_tokenizer *)pCsr->base.pTokenizer);
197785 const unsigned char *z = &pCsr->aInput[pCsr->iOff];
197788 const unsigned char *zTerm = &pCsr->aInput[pCsr->nInput];
197800 zOut = pCsr->zToken;
197805 if( (zOut-pCsr->zToken)>=(pCsr->nAlloc-4) ){
197806 char *zNew = sqlite3_realloc64(pCsr->zToken, pCsr->nAlloc+64);
197808 zOut = &zNew[zOut - pCsr->zToken];
197809 pCsr->zToken = zNew;
197810 pCsr->nAlloc += 64;
197828 pCsr->iOff = (int)(z - pCsr->aInput);
197829 *paToken = pCsr->zToken;
197830 *pnToken = (int)(zOut - pCsr->zToken);
197831 *piStart = (int)(zStart - pCsr->aInput);
197832 *piEnd = (int)(zEnd - pCsr->aInput);
197833 *piPos = pCsr->iToken++;
202021 RtreeCursor *pCsr;
202023 pCsr = (RtreeCursor *)sqlite3_malloc64(sizeof(RtreeCursor));
202024 if( pCsr ){
202025 memset(pCsr, 0, sizeof(RtreeCursor));
202026 pCsr->base.pVtab = pVTab;
202030 *ppCursor = (sqlite3_vtab_cursor *)pCsr;
202039 static void resetCursor(RtreeCursor *pCsr){
202040 Rtree *pRtree = (Rtree *)(pCsr->base.pVtab);
202043 if( pCsr->aConstraint ){
202045 for(i=0; i<pCsr->nConstraint; i++){
202046 sqlite3_rtree_query_info *pInfo = pCsr->aConstraint[i].pInfo;
202052 sqlite3_free(pCsr->aConstraint);
202053 pCsr->aConstraint = 0;
202055 for(ii=0; ii<RTREE_CACHE_SZ; ii++) nodeRelease(pRtree, pCsr->aNode[ii]);
202056 sqlite3_free(pCsr->aPoint);
202057 pStmt = pCsr->pReadAux;
202058 memset(pCsr, 0, sizeof(RtreeCursor));
202059 pCsr->base.pVtab = (sqlite3_vtab*)pRtree;
202060 pCsr->pReadAux = pStmt;
202069 RtreeCursor *pCsr = (RtreeCursor *)cur;
202071 resetCursor(pCsr);
202072 sqlite3_finalize(pCsr->pReadAux);
202073 sqlite3_free(pCsr);
202086 RtreeCursor *pCsr = (RtreeCursor *)cur;
202087 return pCsr->atEOF;
202637 RtreeCursor *pCsr = (RtreeCursor *)pVtabCursor;
202641 RTREE_QUEUE_TRACE(pCsr, "POP-Nx:");
202642 if( pCsr->bAuxValid ){
202643 pCsr->bAuxValid = 0;
202644 sqlite3_reset(pCsr->pReadAux);
202646 rtreeSearchPointPop(pCsr);
202647 rc = rtreeStepToLeaf(pCsr);
202655 RtreeCursor *pCsr = (RtreeCursor *)pVtabCursor;
202656 RtreeSearchPoint *p = rtreeSearchPointFirst(pCsr);
202658 RtreeNode *pNode = rtreeNodeOfFirstSearchPoint(pCsr, &rc);
202660 *pRowid = nodeGetRowid(RTREE_OF_CURSOR(pCsr), pNode, p->iCell);
202670 RtreeCursor *pCsr = (RtreeCursor *)cur;
202671 RtreeSearchPoint *p = rtreeSearchPointFirst(pCsr);
202674 RtreeNode *pNode = rtreeNodeOfFirstSearchPoint(pCsr, &rc);
202692 if( !pCsr->bAuxValid ){
202693 if( pCsr->pReadAux==0 ){
202695 &pCsr->pReadAux, 0);
202698 sqlite3_bind_int64(pCsr->pReadAux, 1,
202700 rc = sqlite3_step(pCsr->pReadAux);
202702 pCsr->bAuxValid = 1;
202704 sqlite3_reset(pCsr->pReadAux);
202710 sqlite3_column_value(pCsr->pReadAux, i - pRtree->nDim2 + 1));
202784 RtreeCursor *pCsr = (RtreeCursor *)pVtabCursor;
202793 resetCursor(pCsr);
202795 pCsr->iStrategy = idxNum;
202812 p = rtreeSearchPointNew(pCsr, RTREE_ZERO, 0);
202813 assert( p!=0 ); /* Always returns pCsr->sPoint */
202814 pCsr->aNode[0] = pLeaf;
202819 RTREE_QUEUE_TRACE(pCsr, "PUSH-F1:");
202821 pCsr->atEOF = 1;
202829 pCsr->aConstraint = sqlite3_malloc64(sizeof(RtreeConstraint)*argc);
202830 pCsr->nConstraint = argc;
202831 if( !pCsr->aConstraint ){
202834 memset(pCsr->aConstraint, 0, sizeof(RtreeConstraint)*argc);
202835 memset(pCsr->anQueue, 0, sizeof(u32)*(pRtree->iDepth + 1));
202839 RtreeConstraint *p = &pCsr->aConstraint[ii];
202853 p->pInfo->anQueue = pCsr->anQueue;
202876 assert( pCsr->bPoint==0 ); /* Due to the resetCursor() call above */
202877 pNew = rtreeSearchPointNew(pCsr, RTREE_ZERO, (u8)(pRtree->iDepth+1));
202878 if( NEVER(pNew==0) ){ /* Because pCsr->bPoint was FALSE */
202884 assert( pCsr->bPoint==1 );
202885 pCsr->aNode[0] = pRoot;
202887 RTREE_QUEUE_TRACE(pCsr, "PUSH-Fm:");
202888 rc = rtreeStepToLeaf(pCsr);
206698 RtreeCursor *pCsr = (RtreeCursor *)pVtabCursor;
206706 resetCursor(pCsr);
206708 pCsr->iStrategy = idxNum;
206717 p = rtreeSearchPointNew(pCsr, RTREE_ZERO, 0);
206718 assert( p!=0 ); /* Always returns pCsr->sPoint */
206719 pCsr->aNode[0] = pLeaf;
206724 RTREE_QUEUE_TRACE(pCsr, "PUSH-F1:");
206726 pCsr->atEOF = 1;
206742 pCsr->aConstraint = p = sqlite3_malloc(sizeof(RtreeConstraint)*4);
206743 pCsr->nConstraint = 4;
206747 memset(pCsr->aConstraint, 0, sizeof(RtreeConstraint)*4);
206748 memset(pCsr->anQueue, 0, sizeof(u32)*(pRtree->iDepth + 1));
206788 pNew = rtreeSearchPointNew(pCsr, RTREE_ZERO, (u8)(pRtree->iDepth+1));
206796 assert( pCsr->bPoint==1 );
206797 pCsr->aNode[0] = pRoot;
206799 RTREE_QUEUE_TRACE(pCsr, "PUSH-Fm:");
206800 rc = rtreeStepToLeaf(pCsr);
206877 RtreeCursor *pCsr = (RtreeCursor *)cur;
206878 RtreeSearchPoint *p = rtreeSearchPointFirst(pCsr);
206880 RtreeNode *pNode = rtreeNodeOfFirstSearchPoint(pCsr, &rc);
206886 if( !pCsr->bAuxValid ){
206887 if( pCsr->pReadAux==0 ){
206889 &pCsr->pReadAux, 0);
206892 sqlite3_bind_int64(pCsr->pReadAux, 1,
206894 rc = sqlite3_step(pCsr->pReadAux);
206896 pCsr->bAuxValid = 1;
206898 sqlite3_reset(pCsr->pReadAux);
206903 sqlite3_result_value(ctx, sqlite3_column_value(pCsr->pReadAux, i+2));
208008 IcuCursor *pCsr;
208027 pCsr = (IcuCursor *)sqlite3_malloc64(
208032 if( !pCsr ){
208035 memset(pCsr, 0, sizeof(IcuCursor));
208036 pCsr->aChar = (UChar *)&pCsr[1];
208037 pCsr->aOffset = (int *)&pCsr->aChar[(nChar+3)&~3];
208039 pCsr->aOffset[iOut] = iInput;
208044 U16_APPEND(pCsr->aChar, iOut, nChar, c, isError);
208046 sqlite3_free(pCsr);
208049 pCsr->aOffset[iOut] = iInput;
208058 pCsr->pIter = ubrk_open(UBRK_WORD, p->zLocale, pCsr->aChar, iOut, &status);
208060 sqlite3_free(pCsr);
208063 pCsr->nChar = iOut;
208065 ubrk_first(pCsr->pIter);
208066 *ppCursor = (sqlite3_tokenizer_cursor *)pCsr;
208074 IcuCursor *pCsr = (IcuCursor *)pCursor;
208075 ubrk_close(pCsr->pIter);
208076 sqlite3_free(pCsr->zBuffer);
208077 sqlite3_free(pCsr);
208092 IcuCursor *pCsr = (IcuCursor *)pCursor;
208101 iStart = ubrk_current(pCsr->pIter);
208102 iEnd = ubrk_next(pCsr->pIter);
208109 U16_NEXT(pCsr->aChar, iWhite, pCsr->nChar, c);
208122 char *zNew = sqlite3_realloc(pCsr->zBuffer, nByte);
208126 pCsr->zBuffer = zNew;
208127 pCsr->nBuffer = nByte;
208131 pCsr->zBuffer, pCsr->nBuffer, &nByte, /* Output vars */
208132 &pCsr->aChar[iStart], iEnd-iStart, /* Input vars */
208135 } while( nByte>pCsr->nBuffer );
208137 *ppToken = pCsr->zBuffer;
208139 *piStartOffset = pCsr->aOffset[iStart];
208140 *piEndOffset = pCsr->aOffset[iEnd];
208141 *piPosition = pCsr->iToken++;
212799 char *pCsr = (char*)&p[1];
212802 p->zTarget = pCsr;
212804 pCsr += nTarget+1;
212806 p->zRbu = pCsr;
212808 pCsr += nRbu+1;
214473 StatCursor *pCsr;
214475 pCsr = (StatCursor *)sqlite3_malloc64(sizeof(StatCursor));
214476 if( pCsr==0 ){
214479 memset(pCsr, 0, sizeof(StatCursor));
214480 pCsr->base.pVtab = pVTab;
214481 pCsr->iDb = pTab->iDb;
214484 *ppCursor = (sqlite3_vtab_cursor *)pCsr;
214508 static void statResetCsr(StatCursor *pCsr){
214514 for(i=0; i<ArraySize(pCsr->aPage); i++){
214515 statClearPage(&pCsr->aPage[i]);
214516 sqlite3_free(pCsr->aPage[i].aPg);
214517 pCsr->aPage[i].aPg = 0;
214519 sqlite3_reset(pCsr->pStmt);
214520 pCsr->iPage = 0;
214521 sqlite3_free(pCsr->zPath);
214522 pCsr->zPath = 0;
214523 pCsr->isEof = 0;
214527 static void statResetCounts(StatCursor *pCsr){
214528 pCsr->nCell = 0;
214529 pCsr->nMxPayload = 0;
214530 pCsr->nUnused = 0;
214531 pCsr->nPayload = 0;
214532 pCsr->szPage = 0;
214533 pCsr->nPage = 0;
214540 StatCursor *pCsr = (StatCursor *)pCursor;
214541 statResetCsr(pCsr);
214542 sqlite3_finalize(pCsr->pStmt);
214543 sqlite3_free(pCsr);
214689 ** Populate the pCsr->iOffset and pCsr->szPage member variables. Based on
214690 ** the current value of pCsr->iPageno.
214692 static void statSizeAndOffset(StatCursor *pCsr){
214693 StatTable *pTab = (StatTable *)((sqlite3_vtab_cursor *)pCsr)->pVtab;
214703 x[0] = pCsr->iPageno;
214705 pCsr->iOffset = x[0];
214706 pCsr->szPage += x[1];
214709 pCsr->szPage += sqlite3BtreeGetPageSize(pBt);
214710 pCsr->iOffset = (i64)pCsr->szPage * (pCsr->iPageno - 1);
214748 ** entry will be the next page, but in aggregated mode (pCsr->isAgg!=0),
214755 StatCursor *pCsr = (StatCursor *)pCursor;
214757 Btree *pBt = pTab->db->aDb[pCsr->iDb].pBt;
214760 sqlite3_free(pCsr->zPath);
214761 pCsr->zPath = 0;
214764 if( pCsr->iPage<0 ){
214766 statResetCounts(pCsr);
214767 rc = sqlite3_step(pCsr->pStmt);
214770 u32 iRoot = (u32)sqlite3_column_int64(pCsr->pStmt, 1);
214773 pCsr->isEof = 1;
214774 return sqlite3_reset(pCsr->pStmt);
214776 rc = statGetPage(pBt, iRoot, &pCsr->aPage[0]);
214777 pCsr->aPage[0].iPgno = iRoot;
214778 pCsr->aPage[0].iCell = 0;
214779 if( !pCsr->isAgg ){
214780 pCsr->aPage[0].zPath = z = sqlite3_mprintf("/");
214783 pCsr->iPage = 0;
214784 pCsr->nPage = 1;
214786 pCsr->isEof = 1;
214787 return sqlite3_reset(pCsr->pStmt);
214791 StatPage *p = &pCsr->aPage[pCsr->iPage];
214792 if( !pCsr->isAgg ) statResetCounts(pCsr);
214801 pCsr->nPage++;
214802 statSizeAndOffset(pCsr);
214804 pCsr->nPayload += nUsable - 4;
214806 pCsr->nPayload += pCell->nLastOvfl;
214807 pCsr->nUnused += nUsable - 4 - pCell->nLastOvfl;
214811 if( !pCsr->isAgg ){
214812 pCsr->zName = (char *)sqlite3_column_text(pCsr->pStmt, 0);
214813 pCsr->iPageno = pCell->aOvfl[iOvfl];
214814 pCsr->zPagetype = "overflow";
214815 pCsr->zPath = z = sqlite3_mprintf(
214827 pCsr->iPage--;
214828 if( pCsr->isAgg && pCsr->iPage<0 ){
214835 pCsr->iPage++;
214836 if( pCsr->iPage>=ArraySize(pCsr->aPage) ){
214837 statResetCsr(pCsr);
214840 assert( p==&pCsr->aPage[pCsr->iPage-1] );
214848 pCsr->nPage++;
214850 if( !pCsr->isAgg ){
214863 StatPage *p = &pCsr->aPage[pCsr->iPage];
214864 pCsr->zName = (char *)sqlite3_column_text(pCsr->pStmt, 0);
214865 pCsr->iPageno = p->iPgno;
214869 statSizeAndOffset(pCsr);
214874 pCsr->zPagetype = "internal";
214878 pCsr->zPagetype = "leaf";
214881 pCsr->zPagetype = "corrupted";
214884 pCsr->nCell += p->nCell;
214885 pCsr->nUnused += p->nUnused;
214886 if( p->nMxPayload>pCsr->nMxPayload ) pCsr->nMxPayload = p->nMxPayload;
214887 if( !pCsr->isAgg ){
214888 pCsr->zPath = z = sqlite3_mprintf("%s", p->zPath);
214895 pCsr->nPayload += nPayload;
214900 if( pCsr->isAgg ) goto statNextRestart;
214908 StatCursor *pCsr = (StatCursor *)pCursor;
214909 return pCsr->isEof;
214921 StatCursor *pCsr = (StatCursor *)pCursor;
214929 statResetCsr(pCsr);
214930 sqlite3_finalize(pCsr->pStmt);
214931 pCsr->pStmt = 0;
214935 pCsr->iDb = sqlite3FindDbName(pTab->db, zDbase);
214936 if( pCsr->iDb<0 ){
214937 pCsr->iDb = 0;
214938 pCsr->isEof = 1;
214942 pCsr->iDb = pTab->iDb;
214950 pCsr->isAgg = sqlite3_value_double(argv[iArg++])!=0.0;
214952 pCsr->isAgg = 0;
214961 pTab->db->aDb[pCsr->iDb].zDbSName);
214972 rc = sqlite3_prepare_v2(pTab->db, zSql, -1, &pCsr->pStmt, 0);
214977 pCsr->iPage = -1;
214988 StatCursor *pCsr = (StatCursor *)pCursor;
214991 sqlite3_result_text(ctx, pCsr->zName, -1, SQLITE_TRANSIENT);
214994 if( !pCsr->isAgg ){
214995 sqlite3_result_text(ctx, pCsr->zPath, -1, SQLITE_TRANSIENT);
214999 if( pCsr->isAgg ){
215000 sqlite3_result_int64(ctx, pCsr->nPage);
215002 sqlite3_result_int64(ctx, pCsr->iPageno);
215006 if( !pCsr->isAgg ){
215007 sqlite3_result_text(ctx, pCsr->zPagetype, -1, SQLITE_STATIC);
215011 sqlite3_result_int(ctx, pCsr->nCell);
215014 sqlite3_result_int(ctx, pCsr->nPayload);
215017 sqlite3_result_int(ctx, pCsr->nUnused);
215020 sqlite3_result_int(ctx, pCsr->nMxPayload);
215023 if( !pCsr->isAgg ){
215024 sqlite3_result_int64(ctx, pCsr->iOffset);
215028 sqlite3_result_int(ctx, pCsr->szPage);
215032 int iDb = pCsr->iDb;
215037 sqlite3_result_int(ctx, pCsr->isAgg);
215045 StatCursor *pCsr = (StatCursor *)pCursor;
215046 *pRowid = pCsr->iPageno;
215254 DbpageCursor *pCsr;
215256 pCsr = (DbpageCursor *)sqlite3_malloc64(sizeof(DbpageCursor));
215257 if( pCsr==0 ){
215260 memset(pCsr, 0, sizeof(DbpageCursor));
215261 pCsr->base.pVtab = pVTab;
215262 pCsr->pgno = -1;
215265 *ppCursor = (sqlite3_vtab_cursor *)pCsr;
215273 DbpageCursor *pCsr = (DbpageCursor *)pCursor;
215274 if( pCsr->pPage1 ) sqlite3PagerUnrefPageOne(pCsr->pPage1);
215275 sqlite3_free(pCsr);
215284 DbpageCursor *pCsr = (DbpageCursor *)pCursor;
215285 pCsr->pgno++;
215290 DbpageCursor *pCsr = (DbpageCursor *)pCursor;
215291 return pCsr->pgno > pCsr->mxPgno;
215309 DbpageCursor *pCsr = (DbpageCursor *)pCursor;
215316 pCsr->pgno = 1;
215317 pCsr->mxPgno = 0;
215323 pCsr->iDb = sqlite3FindDbName(db, zSchema);
215324 if( pCsr->iDb<0 ) return SQLITE_OK;
215326 pCsr->iDb = 0;
215328 pBt = db->aDb[pCsr->iDb].pBt;
215330 pCsr->pPager = sqlite3BtreePager(pBt);
215331 pCsr->szPage = sqlite3BtreeGetPageSize(pBt);
215332 pCsr->mxPgno = sqlite3BtreeLastPage(pBt);
215335 pCsr->pgno = sqlite3_value_int(argv[idxNum>>1]);
215336 if( pCsr->pgno<1 || pCsr->pgno>pCsr->mxPgno ){
215337 pCsr->pgno = 1;
215338 pCsr->mxPgno = 0;
215340 pCsr->mxPgno = pCsr->pgno;
215343 assert( pCsr->pgno==1 );
215345 if( pCsr->pPage1 ) sqlite3PagerUnrefPageOne(pCsr->pPage1);
215346 rc = sqlite3PagerGet(pCsr->pPager, 1, &pCsr->pPage1, 0);
215355 DbpageCursor *pCsr = (DbpageCursor *)pCursor;
215359 sqlite3_result_int(ctx, pCsr->pgno);
215364 if( pCsr->pgno==((PENDING_BYTE/pCsr->szPage)+1) ){
215367 sqlite3_result_zeroblob(ctx, pCsr->szPage);
215369 rc = sqlite3PagerGet(pCsr->pPager, pCsr->pgno, (DbPage**)&pDbPage, 0);
215371 sqlite3_result_blob(ctx, sqlite3PagerGetData(pDbPage), pCsr->szPage,
215380 sqlite3_result_text(ctx, db->aDb[pCsr->iDb].zDbSName, -1, SQLITE_STATIC);
215388 DbpageCursor *pCsr = (DbpageCursor *)pCursor;
215389 *pRowid = pCsr->pgno;
216732 u8 *pCsr = pC->aRecord;
216743 eType = *pCsr++;
216752 sqlite3_int64 iVal = sessionGetI64(pCsr);
216762 pCsr += 8;
216768 nOld = sessionVarintGet(pCsr, &nByte);
216769 pCsr += nOld;
216774 && (nByte==0 || 0==memcmp(pCsr, sqlite3_value_blob(p), nByte))
216778 pCsr += nByte;
217761 u8 *pCsr = p->aRecord; /* Used to iterate through old.* values */
217769 int eType = *pCsr;
217782 sqlite3_int64 iVal = sessionGetI64(&pCsr[1]);
217797 int nHdr = 1 + sessionVarintGet(&pCsr[1], &n);
217802 && (n==0 || 0==memcmp(&pCsr[nHdr], sqlite3_column_blob(pStmt, i), n))
217817 sessionAppendBlob(pBuf, pCsr, nAdvance, &rc);
217831 pCsr += nAdvance;
221172 u8 *pCsr = aRec;
221173 sessionSkipRecord(&pCsr, pIter->nCol);
221177 pCsr, nRec-(pCsr-aRec),
236913 Fts5Cursor *pCsr; /* First in list of all open cursors */
236997 Fts5Cursor *pNext; /* Next cursor in Fts5Cursor.pCsr list */
237063 #define CsrFlagSet(pCsr, flag) ((pCsr)->csrflags |= (flag))
237064 #define CsrFlagClear(pCsr, flag) ((pCsr)->csrflags &= ~(flag))
237065 #define CsrFlagTest(pCsr, flag) ((pCsr)->csrflags & (flag))
237511 Fts5Cursor *pCsr;
237512 for(pCsr=pTab->pGlobal->pCsr; pCsr; pCsr=pCsr->pNext){
237513 if( pCsr->base.pVtab==(sqlite3_vtab*)pTab ) return SQLITE_OK;
237524 Fts5Cursor *pCsr = 0; /* New cursor object */
237531 pCsr = (Fts5Cursor*)sqlite3_malloc64(nByte);
237532 if( pCsr ){
237534 memset(pCsr, 0, (size_t)nByte);
237535 pCsr->aColumnSize = (int*)&pCsr[1];
237536 pCsr->pNext = pGlobal->pCsr;
237537 pGlobal->pCsr = pCsr;
237538 pCsr->iCsrId = ++pGlobal->iNextId;
237543 *ppCsr = (sqlite3_vtab_cursor*)pCsr;
237547 static int fts5StmtType(Fts5Cursor *pCsr){
237548 if( pCsr->ePlan==FTS5_PLAN_SCAN ){
237549 return (pCsr->bDesc) ? FTS5_STMT_SCAN_DESC : FTS5_STMT_SCAN_ASC;
237559 static void fts5CsrNewrow(Fts5Cursor *pCsr){
237560 CsrFlagSet(pCsr,
237568 static void fts5FreeCursorComponents(Fts5Cursor *pCsr){
237569 Fts5FullTable *pTab = (Fts5FullTable*)(pCsr->base.pVtab);
237573 sqlite3_free(pCsr->aInstIter);
237574 sqlite3_free(pCsr->aInst);
237575 if( pCsr->pStmt ){
237576 int eStmt = fts5StmtType(pCsr);
237577 sqlite3Fts5StorageStmtRelease(pTab->pStorage, eStmt, pCsr->pStmt);
237579 if( pCsr->pSorter ){
237580 Fts5Sorter *pSorter = pCsr->pSorter;
237585 if( pCsr->ePlan!=FTS5_PLAN_SOURCE ){
237586 sqlite3Fts5ExprFree(pCsr->pExpr);
237589 for(pData=pCsr->pAuxdata; pData; pData=pNext){
237595 sqlite3_finalize(pCsr->pRankArgStmt);
237596 sqlite3_free(pCsr->apRankArg);
237598 if( CsrFlagTest(pCsr, FTS5CSR_FREE_ZRANK) ){
237599 sqlite3_free(pCsr->zRank);
237600 sqlite3_free(pCsr->zRankArgs);
237604 memset(&pCsr->ePlan, 0, sizeof(Fts5Cursor) - ((u8*)&pCsr->ePlan - (u8*)pCsr));
237615 Fts5Cursor *pCsr = (Fts5Cursor*)pCursor;
237618 fts5FreeCursorComponents(pCsr);
237619 /* Remove the cursor from the Fts5Global.pCsr list */
237620 for(pp=&pTab->pGlobal->pCsr; (*pp)!=pCsr; pp=&(*pp)->pNext);
237621 *pp = pCsr->pNext;
237623 sqlite3_free(pCsr);
237628 static int fts5SorterNext(Fts5Cursor *pCsr){
237629 Fts5Sorter *pSorter = pCsr->pSorter;
237635 CsrFlagSet(pCsr, FTS5CSR_EOF|FTS5CSR_REQUIRE_CONTENT);
237660 fts5CsrNewrow(pCsr);
237672 Fts5Cursor *pCsr;
237673 for(pCsr=pTab->pGlobal->pCsr; pCsr; pCsr=pCsr->pNext){
237674 if( pCsr->ePlan==FTS5_PLAN_MATCH
237675 && pCsr->base.pVtab==(sqlite3_vtab*)pTab
237677 CsrFlagSet(pCsr, FTS5CSR_REQUIRE_RESEEK);
237694 static int fts5CursorReseek(Fts5Cursor *pCsr, int *pbSkip){
237697 if( CsrFlagTest(pCsr, FTS5CSR_REQUIRE_RESEEK) ){
237698 Fts5FullTable *pTab = (Fts5FullTable*)(pCsr->base.pVtab);
237699 int bDesc = pCsr->bDesc;
237700 i64 iRowid = sqlite3Fts5ExprRowid(pCsr->pExpr);
237702 rc = sqlite3Fts5ExprFirst(pCsr->pExpr, pTab->p.pIndex, iRowid, bDesc);
237703 if( rc==SQLITE_OK && iRowid!=sqlite3Fts5ExprRowid(pCsr->pExpr) ){
237707 CsrFlagClear(pCsr, FTS5CSR_REQUIRE_RESEEK);
237708 fts5CsrNewrow(pCsr);
237709 if( sqlite3Fts5ExprEof(pCsr->pExpr) ){
237710 CsrFlagSet(pCsr, FTS5CSR_EOF);
237727 Fts5Cursor *pCsr = (Fts5Cursor*)pCursor;
237730 assert( (pCsr->ePlan<3)==
237731 (pCsr->ePlan==FTS5_PLAN_MATCH || pCsr->ePlan==FTS5_PLAN_SOURCE)
237733 assert( !CsrFlagTest(pCsr, FTS5CSR_EOF) );
237735 if( pCsr->ePlan<3 ){
237737 if( (rc = fts5CursorReseek(pCsr, &bSkip)) || bSkip ) return rc;
237738 rc = sqlite3Fts5ExprNext(pCsr->pExpr, pCsr->iLastRowid);
237739 CsrFlagSet(pCsr, sqlite3Fts5ExprEof(pCsr->pExpr));
237740 fts5CsrNewrow(pCsr);
237742 switch( pCsr->ePlan ){
237744 CsrFlagSet(pCsr, FTS5CSR_EOF);
237750 rc = fts5SorterNext(pCsr);
237757 rc = sqlite3_step(pCsr->pStmt);
237760 CsrFlagSet(pCsr, FTS5CSR_EOF);
237761 rc = sqlite3_reset(pCsr->pStmt);
237810 Fts5Cursor *pCsr,
237818 const char *zRank = pCsr->zRank;
237819 const char *zRankArgs = pCsr->zRankArgs;
237821 nPhrase = sqlite3Fts5ExprPhraseCount(pCsr->pExpr);
237843 pCsr->pSorter = pSorter;
237846 pTab->pSortCsr = pCsr;
237847 rc = fts5SorterNext(pCsr);
237854 pCsr->pSorter = 0;
237860 static int fts5CursorFirst(Fts5FullTable *pTab, Fts5Cursor *pCsr, int bDesc){
237862 Fts5Expr *pExpr = pCsr->pExpr;
237863 rc = sqlite3Fts5ExprFirst(pExpr, pTab->p.pIndex, pCsr->iFirstRowid, bDesc);
237865 CsrFlagSet(pCsr, FTS5CSR_EOF);
237867 fts5CsrNewrow(pCsr);
237879 Fts5Cursor *pCsr,
237890 pCsr->ePlan = FTS5_PLAN_SPECIAL;
237893 pCsr->iSpecial = sqlite3Fts5IndexReads(pTab->p.pIndex);
237896 pCsr->iSpecial = pCsr->iCsrId;
237924 static int fts5FindRankFunction(Fts5Cursor *pCsr){
237925 Fts5FullTable *pTab = (Fts5FullTable*)(pCsr->base.pVtab);
237929 const char *zRank = pCsr->zRank;
237930 const char *zRankArgs = pCsr->zRankArgs;
237939 assert( rc==SQLITE_OK || pCsr->pRankArgStmt==0 );
237943 pCsr->nRankArg = sqlite3_column_count(pStmt);
237944 nByte = sizeof(sqlite3_value*)*pCsr->nRankArg;
237945 pCsr->apRankArg = (sqlite3_value**)sqlite3Fts5MallocZero(&rc, nByte);
237948 for(i=0; i<pCsr->nRankArg; i++){
237949 pCsr->apRankArg[i] = sqlite3_column_value(pStmt, i);
237952 pCsr->pRankArgStmt = pStmt;
237970 pCsr->pRank = pAux;
237977 Fts5Cursor *pCsr,
237992 pCsr->zRank = zRank;
237993 pCsr->zRankArgs = zRankArgs;
237994 CsrFlagSet(pCsr, FTS5CSR_FREE_ZRANK);
237996 pCsr->base.pVtab->zErrMsg = sqlite3_mprintf(
238002 pCsr->zRank = (char*)pConfig->zRank;
238003 pCsr->zRankArgs = (char*)pConfig->zRankArgs;
238005 pCsr->zRank = (char*)FTS5_DEFAULT_RANK;
238006 pCsr->zRankArgs = 0;
238042 Fts5Cursor *pCsr = (Fts5Cursor*)pCursor;
238063 if( pCsr->ePlan ){
238064 fts5FreeCursorComponents(pCsr);
238065 memset(&pCsr->ePlan, 0, sizeof(Fts5Cursor) - ((u8*)&pCsr->ePlan-(u8*)pCsr));
238068 assert( pCsr->pStmt==0 );
238069 assert( pCsr->pExpr==0 );
238070 assert( pCsr->csrflags==0 );
238071 assert( pCsr->pRank==0 );
238072 assert( pCsr->zRank==0 );
238073 assert( pCsr->zRankArgs==0 );
238098 rc = fts5SpecialMatch(pTab, pCsr, &zText[1]);
238104 rc = sqlite3Fts5ExprAnd(&pCsr->pExpr, pExpr);
238125 rc = sqlite3Fts5ExprAnd(&pCsr->pExpr, pExpr);
238143 pCsr->bDesc = bDesc = ((idxNum & FTS5_BI_ORDER_DESC) ? 1 : 0);
238153 pCsr->iFirstRowid = fts5GetRowidLimit(pRowidLe, LARGEST_INT64);
238154 pCsr->iLastRowid = fts5GetRowidLimit(pRowidGe, SMALLEST_INT64);
238156 pCsr->iLastRowid = fts5GetRowidLimit(pRowidLe, LARGEST_INT64);
238157 pCsr->iFirstRowid = fts5GetRowidLimit(pRowidGe, SMALLEST_INT64);
238169 assert( pCsr->iLastRowid==LARGEST_INT64 );
238170 assert( pCsr->iFirstRowid==SMALLEST_INT64 );
238172 pCsr->iLastRowid = pTab->pSortCsr->iFirstRowid;
238173 pCsr->iFirstRowid = pTab->pSortCsr->iLastRowid;
238175 pCsr->iLastRowid = pTab->pSortCsr->iLastRowid;
238176 pCsr->iFirstRowid = pTab->pSortCsr->iFirstRowid;
238178 pCsr->ePlan = FTS5_PLAN_SOURCE;
238179 pCsr->pExpr = pTab->pSortCsr->pExpr;
238180 rc = fts5CursorFirst(pTab, pCsr, bDesc);
238181 }else if( pCsr->pExpr ){
238182 rc = fts5CursorParseRank(pConfig, pCsr, pRank);
238185 pCsr->ePlan = FTS5_PLAN_SORTED_MATCH;
238186 rc = fts5CursorFirstSorted(pTab, pCsr, bDesc);
238188 pCsr->ePlan = FTS5_PLAN_MATCH;
238189 rc = fts5CursorFirst(pTab, pCsr, bDesc);
238200 pCsr->ePlan = (pRowidEq ? FTS5_PLAN_ROWID : FTS5_PLAN_SCAN);
238202 pTab->pStorage, fts5StmtType(pCsr), &pCsr->pStmt, &pTab->p.base.zErrMsg
238206 assert( pCsr->ePlan==FTS5_PLAN_ROWID );
238207 sqlite3_bind_value(pCsr->pStmt, 1, pRowidEq);
238209 sqlite3_bind_int64(pCsr->pStmt, 1, pCsr->iFirstRowid);
238210 sqlite3_bind_int64(pCsr->pStmt, 2, pCsr->iLastRowid);
238227 Fts5Cursor *pCsr = (Fts5Cursor*)pCursor;
238228 return (CsrFlagTest(pCsr, FTS5CSR_EOF) ? 1 : 0);
238234 static i64 fts5CursorRowid(Fts5Cursor *pCsr){
238235 assert( pCsr->ePlan==FTS5_PLAN_MATCH
238236 || pCsr->ePlan==FTS5_PLAN_SORTED_MATCH
238237 || pCsr->ePlan==FTS5_PLAN_SOURCE
238239 if( pCsr->pSorter ){
238240 return pCsr->pSorter->iRowid;
238242 return sqlite3Fts5ExprRowid(pCsr->pExpr);
238253 Fts5Cursor *pCsr = (Fts5Cursor*)pCursor;
238254 int ePlan = pCsr->ePlan;
238256 assert( CsrFlagTest(pCsr, FTS5CSR_EOF)==0 );
238265 *pRowid = fts5CursorRowid(pCsr);
238269 *pRowid = sqlite3_column_int64(pCsr->pStmt, 0);
238283 static int fts5SeekCursor(Fts5Cursor *pCsr, int bErrormsg){
238287 if( pCsr->pStmt==0 ){
238288 Fts5FullTable *pTab = (Fts5FullTable*)(pCsr->base.pVtab);
238289 int eStmt = fts5StmtType(pCsr);
238291 pTab->pStorage, eStmt, &pCsr->pStmt, (bErrormsg?&pTab->p.base.zErrMsg:0)
238294 assert( CsrFlagTest(pCsr, FTS5CSR_REQUIRE_CONTENT) );
238297 if( rc==SQLITE_OK && CsrFlagTest(pCsr, FTS5CSR_REQUIRE_CONTENT) ){
238298 Fts5Table *pTab = (Fts5Table*)(pCsr->base.pVtab);
238299 assert( pCsr->pExpr );
238300 sqlite3_reset(pCsr->pStmt);
238301 sqlite3_bind_int64(pCsr->pStmt, 1, fts5CursorRowid(pCsr));
238303 rc = sqlite3_step(pCsr->pStmt);
238307 CsrFlagClear(pCsr, FTS5CSR_REQUIRE_CONTENT);
238309 rc = sqlite3_reset(pCsr->pStmt);
238616 Fts5Cursor *pCsr = (Fts5Cursor*)pCtx;
238617 return pCsr->pAux->pUserData;
238621 Fts5Cursor *pCsr = (Fts5Cursor*)pCtx;
238622 return ((Fts5Table*)(pCsr->base.pVtab))->pConfig->nCol;
238630 Fts5Cursor *pCsr = (Fts5Cursor*)pCtx;
238631 Fts5FullTable *pTab = (Fts5FullTable*)(pCsr->base.pVtab);
238636 Fts5Cursor *pCsr = (Fts5Cursor*)pCtx;
238637 Fts5FullTable *pTab = (Fts5FullTable*)(pCsr->base.pVtab);
238647 Fts5Cursor *pCsr = (Fts5Cursor*)pCtx;
238648 Fts5Table *pTab = (Fts5Table*)(pCsr->base.pVtab);
238655 Fts5Cursor *pCsr = (Fts5Cursor*)pCtx;
238656 return sqlite3Fts5ExprPhraseCount(pCsr->pExpr);
238660 Fts5Cursor *pCsr = (Fts5Cursor*)pCtx;
238661 return sqlite3Fts5ExprPhraseSize(pCsr->pExpr, iPhrase);
238671 Fts5Cursor *pCsr = (Fts5Cursor*)pCtx;
238672 if( fts5IsContentless((Fts5FullTable*)(pCsr->base.pVtab))
238673 || pCsr->ePlan==FTS5_PLAN_SPECIAL
238678 rc = fts5SeekCursor(pCsr, 0);
238680 *pz = (const char*)sqlite3_column_text(pCsr->pStmt, iCol+1);
238681 *pn = sqlite3_column_bytes(pCsr->pStmt, iCol+1);
238688 Fts5Cursor *pCsr,
238693 Fts5Config *pConfig = ((Fts5Table*)(pCsr->base.pVtab))->pConfig;
238695 int bLive = (pCsr->pSorter==0);
238697 if( CsrFlagTest(pCsr, FTS5CSR_REQUIRE_POSLIST) ){
238702 aPopulator = sqlite3Fts5ExprClearPoslists(pCsr->pExpr, bLive);
238706 rc = fts5ApiColumnText((Fts5Context*)pCsr, i, &z, &n);
238709 pConfig, pCsr->pExpr, aPopulator, i, z, n
238715 if( pCsr->pSorter ){
238716 sqlite3Fts5ExprCheckPoslists(pCsr->pExpr, pCsr->pSorter->iRowid);
238719 CsrFlagClear(pCsr, FTS5CSR_REQUIRE_POSLIST);
238722 if( pCsr->pSorter && pConfig->eDetail==FTS5_DETAIL_FULL ){
238723 Fts5Sorter *pSorter = pCsr->pSorter;
238728 *pn = sqlite3Fts5ExprPoslist(pCsr->pExpr, iPhrase, pa);
238739 static int fts5CacheInstArray(Fts5Cursor *pCsr){
238743 int nCol = ((Fts5Table*)pCsr->base.pVtab)->pConfig->nCol;
238745 nIter = sqlite3Fts5ExprPhraseCount(pCsr->pExpr);
238746 if( pCsr->aInstIter==0 ){
238748 pCsr->aInstIter = (Fts5PoslistReader*)sqlite3Fts5MallocZero(&rc, nByte);
238750 aIter = pCsr->aInstIter;
238760 rc = fts5CsrPoslist(pCsr, i, &a, &n);
238780 if( nInst>=pCsr->nInstAlloc ){
238781 int nNewSize = pCsr->nInstAlloc ? pCsr->nInstAlloc*2 : 32;
238783 pCsr->aInst, nNewSize*sizeof(int)*3
238786 pCsr->aInst = aInst;
238787 pCsr->nInstAlloc = nNewSize;
238795 aInst = &pCsr->aInst[3 * (nInst-1)];
238807 pCsr->nInstCount = nInst;
238808 CsrFlagClear(pCsr, FTS5CSR_REQUIRE_INST);
238814 Fts5Cursor *pCsr = (Fts5Cursor*)pCtx;
238816 if( CsrFlagTest(pCsr, FTS5CSR_REQUIRE_INST)==0
238817 || SQLITE_OK==(rc = fts5CacheInstArray(pCsr)) ){
238818 *pnInst = pCsr->nInstCount;
238830 Fts5Cursor *pCsr = (Fts5Cursor*)pCtx;
238832 if( CsrFlagTest(pCsr, FTS5CSR_REQUIRE_INST)==0
238833 || SQLITE_OK==(rc = fts5CacheInstArray(pCsr))
238835 if( iIdx<0 || iIdx>=pCsr->nInstCount ){
238838 }else if( fts5IsOffsetless((Fts5Table*)pCsr->base.pVtab) ){
238839 *piPhrase = pCsr->aInst[iIdx*3];
238840 *piCol = pCsr->aInst[iIdx*3 + 2];
238844 *piPhrase = pCsr->aInst[iIdx*3];
238845 *piCol = pCsr->aInst[iIdx*3 + 1];
238846 *piOff = pCsr->aInst[iIdx*3 + 2];
238874 Fts5Cursor *pCsr = (Fts5Cursor*)pCtx;
238875 Fts5FullTable *pTab = (Fts5FullTable*)(pCsr->base.pVtab);
238879 if( CsrFlagTest(pCsr, FTS5CSR_REQUIRE_DOCSIZE) ){
238881 i64 iRowid = fts5CursorRowid(pCsr);
238882 rc = sqlite3Fts5StorageDocsize(pTab->pStorage, iRowid, pCsr->aColumnSize);
238887 pCsr->aColumnSize[i] = -1;
238895 void *p = (void*)(&pCsr->aColumnSize[i]);
238896 pCsr->aColumnSize[i] = 0;
238906 CsrFlagClear(pCsr, FTS5CSR_REQUIRE_DOCSIZE);
238912 *pnToken += pCsr->aColumnSize[i];
238915 *pnToken = pCsr->aColumnSize[iCol];
238931 Fts5Cursor *pCsr = (Fts5Cursor*)pCtx;
238936 for(pData=pCsr->pAuxdata; pData; pData=pData->pNext){
238937 if( pData->pAux==pCsr->pAux ) break;
238951 pData->pAux = pCsr->pAux;
238952 pData->pNext = pCsr->pAuxdata;
238953 pCsr->pAuxdata = pData;
238962 Fts5Cursor *pCsr = (Fts5Cursor*)pCtx;
238966 for(pData=pCsr->pAuxdata; pData; pData=pData->pNext){
238967 if( pData->pAux==pCsr->pAux ) break;
239009 Fts5Cursor *pCsr = (Fts5Cursor*)pCtx;
239011 int rc = fts5CsrPoslist(pCsr, iPhrase, &pIter->a, &n);
239027 Fts5Cursor *pCsr = (Fts5Cursor*)pCtx;
239028 Fts5Config *pConfig = ((Fts5Table*)(pCsr->base.pVtab))->pConfig;
239059 Fts5Cursor *pCsr = (Fts5Cursor*)pCtx;
239060 Fts5Config *pConfig = ((Fts5Table*)(pCsr->base.pVtab))->pConfig;
239063 Fts5Sorter *pSorter = pCsr->pSorter;
239070 rc = sqlite3Fts5ExprPhraseCollist(pCsr->pExpr, iPhrase, &pIter->a, &n);
239080 rc = fts5CsrPoslist(pCsr, iPhrase, &pIter->a, &n);
239134 Fts5Cursor *pCsr = (Fts5Cursor*)pCtx;
239135 Fts5FullTable *pTab = (Fts5FullTable*)(pCsr->base.pVtab);
239139 rc = fts5OpenMethod(pCsr->base.pVtab, (sqlite3_vtab_cursor**)&pNew);
239145 rc = sqlite3Fts5ExprClonePhrase(pCsr->pExpr, iPhrase, &pNew->pExpr);
239167 Fts5Cursor *pCsr,
239172 assert( pCsr->pAux==0 );
239173 pCsr->pAux = pAux;
239174 pAux->xFunc(&sFts5Api, (Fts5Context*)pCsr, context, argc, argv);
239175 pCsr->pAux = 0;
239179 Fts5Cursor *pCsr;
239180 for(pCsr=pGlobal->pCsr; pCsr; pCsr=pCsr->pNext){
239181 if( pCsr->iCsrId==iCsrId ) break;
239183 return pCsr;
239193 Fts5Cursor *pCsr;
239200 pCsr = fts5CursorFromCsrid(pAux->pGlobal, iCsrId);
239201 if( pCsr==0 || pCsr->ePlan==0 ){
239206 fts5ApiInvoke(pAux, pCsr, context, argc-1, &argv[1]);
239219 Fts5Cursor *pCsr;
239220 pCsr = fts5CursorFromCsrid(pGlobal, iCsrId);
239221 if( pCsr ){
239222 return (Fts5Table*)pCsr->base.pVtab;
239229 ** cursor pCsr via sqlite3_result_blob(). A position-list blob contains
239231 ** cursor pCsr.
239242 static int fts5PoslistBlob(sqlite3_context *pCtx, Fts5Cursor *pCsr){
239245 int nPhrase = sqlite3Fts5ExprPhraseCount(pCsr->pExpr);
239249 switch( ((Fts5Table*)(pCsr->base.pVtab))->pConfig->eDetail ){
239255 int nByte = sqlite3Fts5ExprPoslist(pCsr->pExpr, i, &dummy);
239263 nPoslist = sqlite3Fts5ExprPoslist(pCsr->pExpr, i, &pPoslist);
239274 rc = sqlite3Fts5ExprPhraseCollist(pCsr->pExpr, i, &dummy, &nByte);
239282 rc = sqlite3Fts5ExprPhraseCollist(pCsr->pExpr, i, &pPoslist, &nPoslist);
239306 Fts5Cursor *pCsr = (Fts5Cursor*)pCursor;
239309 assert( CsrFlagTest(pCsr, FTS5CSR_EOF)==0 );
239311 if( pCsr->ePlan==FTS5_PLAN_SPECIAL ){
239313 sqlite3_result_int64(pCtx, pCsr->iSpecial);
239322 sqlite3_result_int64(pCtx, pCsr->iCsrId);
239326 if( pCsr->ePlan==FTS5_PLAN_SOURCE ){
239327 fts5PoslistBlob(pCtx, pCsr);
239329 pCsr->ePlan==FTS5_PLAN_MATCH
239330 || pCsr->ePlan==FTS5_PLAN_SORTED_MATCH
239332 if( pCsr->pRank || SQLITE_OK==(rc = fts5FindRankFunction(pCsr)) ){
239333 fts5ApiInvoke(pCsr->pRank, pCsr, pCtx, pCsr->nRankArg, pCsr->apRankArg);
239338 rc = fts5SeekCursor(pCsr, 1);
239340 sqlite3_result_value(pCtx, sqlite3_column_value(pCsr->pStmt, iCol+1));
243796 Fts5VocabCursor *pCsr = 0;
243842 pCsr = (Fts5VocabCursor*)sqlite3Fts5MallocZero(&rc, nByte);
243845 if( pCsr ){
243846 pCsr->pFts5 = pFts5;
243847 pCsr->pStmt = pStmt;
243848 pCsr->aCnt = (i64*)&pCsr[1];
243849 pCsr->aDoc = &pCsr->aCnt[pFts5->pConfig->nCol];
243854 *ppCsr = (sqlite3_vtab_cursor*)pCsr;
243858 static void fts5VocabResetCursor(Fts5VocabCursor *pCsr){
243859 pCsr->rowid = 0;
243860 sqlite3Fts5IterClose(pCsr->pIter);
243861 sqlite3Fts5StructureRelease(pCsr->pStruct);
243862 pCsr->pStruct = 0;
243863 pCsr->pIter = 0;
243864 sqlite3_free(pCsr->zLeTerm);
243865 pCsr->nLeTerm = -1;
243866 pCsr->zLeTerm = 0;
243867 pCsr->bEof = 0;
243875 Fts5VocabCursor *pCsr = (Fts5VocabCursor*)pCursor;
243876 fts5VocabResetCursor(pCsr);
243877 sqlite3Fts5BufferFree(&pCsr->term);
243878 sqlite3_finalize(pCsr->pStmt);
243879 sqlite3_free(pCsr);
243883 static int fts5VocabInstanceNewTerm(Fts5VocabCursor *pCsr){
243886 if( sqlite3Fts5IterEof(pCsr->pIter) ){
243887 pCsr->bEof = 1;
243891 zTerm = sqlite3Fts5IterTerm(pCsr->pIter, &nTerm);
243892 if( pCsr->nLeTerm>=0 ){
243893 int nCmp = MIN(nTerm, pCsr->nLeTerm);
243894 int bCmp = memcmp(pCsr->zLeTerm, zTerm, nCmp);
243895 if( bCmp<0 || (bCmp==0 && pCsr->nLeTerm<nTerm) ){
243896 pCsr->bEof = 1;
243900 sqlite3Fts5BufferSet(&rc, &pCsr->term, nTerm, (const u8*)zTerm);
243905 static int fts5VocabInstanceNext(Fts5VocabCursor *pCsr){
243906 int eDetail = pCsr->pFts5->pConfig->eDetail;
243908 Fts5IndexIter *pIter = pCsr->pIter;
243909 i64 *pp = &pCsr->iInstPos;
243910 int *po = &pCsr->iInstOff;
243913 assert( pCsr->bEof==0 );
243917 pCsr->iInstPos = 0;
243918 pCsr->iInstOff = 0;
243920 rc = sqlite3Fts5IterNextScan(pCsr->pIter);
243922 rc = fts5VocabInstanceNewTerm(pCsr);
243923 if( pCsr->bEof || eDetail==FTS5_DETAIL_NONE ) break;
243926 pCsr->bEof = 1;
243938 Fts5VocabCursor *pCsr = (Fts5VocabCursor*)pCursor;
243940 int nCol = pCsr->pFts5->pConfig->nCol;
243943 rc = sqlite3Fts5StructureTest(pCsr->pFts5->pIndex, pCsr->pStruct);
243945 pCsr->rowid++;
243948 return fts5VocabInstanceNext(pCsr);
243952 for(pCsr->iCol++; pCsr->iCol<nCol; pCsr->iCol++){
243953 if( pCsr->aDoc[pCsr->iCol] ) break;
243957 if( pTab->eType!=FTS5_VOCAB_COL || pCsr->iCol>=nCol ){
243958 if( sqlite3Fts5IterEof(pCsr->pIter) ){
243959 pCsr->bEof = 1;
243964 zTerm = sqlite3Fts5IterTerm(pCsr->pIter, &nTerm);
243966 if( pCsr->nLeTerm>=0 ){
243967 int nCmp = MIN(nTerm, pCsr->nLeTerm);
243968 int bCmp = memcmp(pCsr->zLeTerm, zTerm, nCmp);
243969 if( bCmp<0 || (bCmp==0 && pCsr->nLeTerm<nTerm) ){
243970 pCsr->bEof = 1;
243975 sqlite3Fts5BufferSet(&rc, &pCsr->term, nTerm, (const u8*)zTerm);
243976 memset(pCsr->aCnt, 0, nCol * sizeof(i64));
243977 memset(pCsr->aDoc, 0, nCol * sizeof(i64));
243978 pCsr->iCol = 0;
243982 int eDetail = pCsr->pFts5->pConfig->eDetail;
243987 pPos = pCsr->pIter->pData;
243988 nPos = pCsr->pIter->nData;
243994 pCsr->aCnt[0]++;
243997 pCsr->aDoc[0]++;
244010 pCsr->aDoc[ii]++;
244013 pCsr->aCnt[ii]++;
244022 pCsr->aDoc[iPos]++;
244026 pCsr->aDoc[0]++;
244036 rc = sqlite3Fts5IterNextScan(pCsr->pIter);
244041 zTerm = sqlite3Fts5IterTerm(pCsr->pIter, &nTerm);
244042 if( nTerm!=pCsr->term.n
244043 || (nTerm>0 && memcmp(zTerm, pCsr->term.p, nTerm))
244047 if( sqlite3Fts5IterEof(pCsr->pIter) ) break;
244053 if( rc==SQLITE_OK && pCsr->bEof==0 && pTab->eType==FTS5_VOCAB_COL ){
244054 for(/* noop */; pCsr->iCol<nCol && pCsr->aDoc[pCsr->iCol]==0; pCsr->iCol++);
244055 if( pCsr->iCol==nCol ){
244073 Fts5VocabCursor *pCsr = (Fts5VocabCursor*)pCursor;
244088 fts5VocabResetCursor(pCsr);
244105 pCsr->nLeTerm = sqlite3_value_bytes(pLe);
244106 pCsr->zLeTerm = sqlite3_malloc(pCsr->nLeTerm+1);
244107 if( pCsr->zLeTerm==0 ){
244110 memcpy(pCsr->zLeTerm, zCopy, pCsr->nLeTerm+1);
244116 Fts5Index *pIndex = pCsr->pFts5->pIndex;
244117 rc = sqlite3Fts5IndexQuery(pIndex, zTerm, nTerm, f, 0, &pCsr->pIter);
244119 pCsr->pStruct = sqlite3Fts5StructureRef(pIndex);
244123 rc = fts5VocabInstanceNewTerm(pCsr);
244125 if( rc==SQLITE_OK && !pCsr->bEof
244127 || pCsr->pFts5->pConfig->eDetail!=FTS5_DETAIL_NONE)
244140 Fts5VocabCursor *pCsr = (Fts5VocabCursor*)pCursor;
244141 return pCsr->bEof;
244149 Fts5VocabCursor *pCsr = (Fts5VocabCursor*)pCursor;
244150 int eDetail = pCsr->pFts5->pConfig->eDetail;
244156 pCtx, (const char*)pCsr->term.p, pCsr->term.n, SQLITE_TRANSIENT
244162 const char *z = pCsr->pFts5->pConfig->azCol[pCsr->iCol];
244166 iVal = pCsr->aDoc[pCsr->iCol];
244168 iVal = pCsr->aCnt[pCsr->iCol];
244173 iVal = pCsr->aDoc[0];
244175 iVal = pCsr->aCnt[0];
244181 sqlite3_result_int64(pCtx, pCsr->pIter->iRowid);
244186 ii = FTS5_POS2COLUMN(pCsr->iInstPos);
244188 ii = (int)pCsr->iInstPos;
244190 if( ii>=0 && ii<pCsr->pFts5->pConfig->nCol ){
244191 const char *z = pCsr->pFts5->pConfig->azCol[ii];
244199 int ii = FTS5_POS2OFFSET(pCsr->iInstPos);
244220 Fts5VocabCursor *pCsr = (Fts5VocabCursor*)pCursor;
244221 *pRowid = pCsr->rowid;