Lines Matching defs:pCsr
21454 VdbeCursor *pCsr; /* Cursor to read old values from */
75556 ** Argument pCsr must be a cursor opened for writing on an
75565 SQLITE_PRIVATE int sqlite3BtreePutData(BtCursor *pCsr, u32 offset, u32 amt, void *z){
75567 assert( cursorOwnsBtShared(pCsr) );
75568 assert( sqlite3_mutex_held(pCsr->pBtree->db->mutex) );
75569 assert( pCsr->curFlags & BTCF_Incrblob );
75571 rc = restoreCursorPosition(pCsr);
75575 assert( pCsr->eState!=CURSOR_REQUIRESEEK );
75576 if( pCsr->eState!=CURSOR_VALID ){
75584 ** Note that pCsr must be open on a INTKEY table and saveCursorPosition()
75588 VVA_ONLY(rc =) saveAllCursors(pCsr->pBt, pCsr->pgnoRoot, pCsr);
75598 if( (pCsr->curFlags & BTCF_WriteFlag)==0 ){
75601 assert( (pCsr->pBt->btsFlags & BTS_READ_ONLY)==0
75602 && pCsr->pBt->inTransaction==TRANS_WRITE );
75603 assert( hasSharedCacheTableLock(pCsr->pBtree, pCsr->pgnoRoot, 0, 2) );
75604 assert( !hasReadConflicts(pCsr->pBtree, pCsr->pgnoRoot) );
75605 assert( pCsr->pPage->intKey );
75607 return accessPayload(pCsr, offset, amt, (unsigned char *)z, 1);
75659 SQLITE_PRIVATE int sqlite3BtreeCursorHasHint(BtCursor *pCsr, unsigned int mask){
75660 return (pCsr->hints & mask)!=0;
83568 VdbeCursor *pCsr, /* Cursor to grab old.* values from */
83594 assert( pCsr->nField==pTab->nCol
83595 || (pCsr->nField==pTab->nCol+1 && op==SQLITE_DELETE && iReg==-1)
83599 preupdate.pCsr = pCsr;
83618 for(i=0; i<pCsr->nField; i++){
85462 if( iIdx>=p->pCsr->nField || iIdx<0 ){
85472 nRec = sqlite3BtreePayloadSize(p->pCsr->uc.pCursor);
85475 rc = sqlite3BtreePayload(p->pCsr->uc.pCursor, 0, nRec, aRec);
85552 if( iIdx>=p->pCsr->nField || iIdx<0 ){
85586 p->aNew = (Mem *)sqlite3DbMallocZero(db, sizeof(Mem) * p->pCsr->nField);
85592 assert( iIdx>=0 && iIdx<p->pCsr->nField );
94265 BtCursor *pCsr; /* Cursor pointing at blob row */
94327 p->pCsr = pC->uc.pCursor;
94328 sqlite3BtreeIncrblobCursor(p->pCsr);
94639 sqlite3BtreeEnterCursor(p->pCsr);
94657 iKey = sqlite3BtreeIntegerKey(p->pCsr);
94664 rc = xCall(p->pCsr, iOffset+p->iOffset, n, z);
94665 sqlite3BtreeLeaveCursor(p->pCsr);
95659 ** Usually, the sorter module uses the value of (pCsr->pKeyInfo->nKeyField)
95678 VdbeCursor *pCsr /* Cursor that holds the new sorter */
95683 KeyInfo *pKeyInfo; /* Copy of pCsr->pKeyInfo with db==0 */
95684 int szKeyInfo; /* Size of pCsr->pKeyInfo in bytes */
95710 assert( pCsr->pKeyInfo && pCsr->pBtx==0 );
95711 assert( pCsr->eCurType==CURTYPE_SORTER );
95712 szKeyInfo = sizeof(KeyInfo) + (pCsr->pKeyInfo->nKeyField-1)*sizeof(CollSeq*);
95716 pCsr->uc.pSorter = pSorter;
95722 memcpy(pKeyInfo, pCsr->pKeyInfo, szKeyInfo);
96009 SQLITE_PRIVATE void sqlite3VdbeSorterClose(sqlite3 *db, VdbeCursor *pCsr){
96011 assert( pCsr->eCurType==CURTYPE_SORTER );
96012 pSorter = pCsr->uc.pSorter;
96017 pCsr->uc.pSorter = 0;
96513 const VdbeCursor *pCsr, /* Sorter cursor */
96524 assert( pCsr->eCurType==CURTYPE_SORTER );
96525 pSorter = pCsr->uc.pSorter;
97326 SQLITE_PRIVATE int sqlite3VdbeSorterRewind(const VdbeCursor *pCsr, int *pbEof){
97330 assert( pCsr->eCurType==CURTYPE_SORTER );
97331 pSorter = pCsr->uc.pSorter;
97378 SQLITE_PRIVATE int sqlite3VdbeSorterNext(sqlite3 *db, const VdbeCursor *pCsr){
97382 assert( pCsr->eCurType==CURTYPE_SORTER );
97383 pSorter = pCsr->uc.pSorter;
97443 SQLITE_PRIVATE int sqlite3VdbeSorterRowkey(const VdbeCursor *pCsr, Mem *pOut){
97447 assert( pCsr->eCurType==CURTYPE_SORTER );
97448 pSorter = pCsr->uc.pSorter;
97477 const VdbeCursor *pCsr, /* Sorter cursor */
97488 assert( pCsr->eCurType==CURTYPE_SORTER );
97489 pSorter = pCsr->uc.pSorter;
97491 pKeyInfo = pCsr->pKeyInfo;
129965 PragmaVtabCursor *pCsr;
129966 pCsr = (PragmaVtabCursor*)sqlite3_malloc(sizeof(*pCsr));
129967 if( pCsr==0 ) return SQLITE_NOMEM;
129968 memset(pCsr, 0, sizeof(PragmaVtabCursor));
129969 pCsr->base.pVtab = pVtab;
129970 *ppCursor = &pCsr->base;
129975 static void pragmaVtabCursorClear(PragmaVtabCursor *pCsr){
129977 sqlite3_finalize(pCsr->pPragma);
129978 pCsr->pPragma = 0;
129979 for(i=0; i<ArraySize(pCsr->azArg); i++){
129980 sqlite3_free(pCsr->azArg[i]);
129981 pCsr->azArg[i] = 0;
129987 PragmaVtabCursor *pCsr = (PragmaVtabCursor*)cur;
129988 pragmaVtabCursorClear(pCsr);
129989 sqlite3_free(pCsr);
129995 PragmaVtabCursor *pCsr = (PragmaVtabCursor*)pVtabCursor;
129999 pCsr->iRowid++;
130000 assert( pCsr->pPragma );
130001 if( SQLITE_ROW!=sqlite3_step(pCsr->pPragma) ){
130002 rc = sqlite3_finalize(pCsr->pPragma);
130003 pCsr->pPragma = 0;
130004 pragmaVtabCursorClear(pCsr);
130017 PragmaVtabCursor *pCsr = (PragmaVtabCursor*)pVtabCursor;
130026 pragmaVtabCursorClear(pCsr);
130030 assert( j<ArraySize(pCsr->azArg) );
130031 assert( pCsr->azArg[j]==0 );
130033 pCsr->azArg[j] = sqlite3_mprintf("%s", zText);
130034 if( pCsr->azArg[j]==0 ){
130041 if( pCsr->azArg[1] ){
130042 sqlite3_str_appendf(&acc, "%Q.", pCsr->azArg[1]);
130045 if( pCsr->azArg[0] ){
130046 sqlite3_str_appendf(&acc, "=%Q", pCsr->azArg[0]);
130050 rc = sqlite3_prepare_v2(pTab->db, zSql, -1, &pCsr->pPragma, 0);
130063 PragmaVtabCursor *pCsr = (PragmaVtabCursor*)pVtabCursor;
130064 return (pCsr->pPragma==0);
130075 PragmaVtabCursor *pCsr = (PragmaVtabCursor*)pVtabCursor;
130078 sqlite3_result_value(ctx, sqlite3_column_value(pCsr->pPragma, i));
130080 sqlite3_result_text(ctx, pCsr->azArg[i-pTab->iHidden],-1,SQLITE_TRANSIENT);
130089 PragmaVtabCursor *pCsr = (PragmaVtabCursor*)pVtabCursor;
130090 *p = pCsr->iRowid;
169549 int (*xLanguageid)(sqlite3_tokenizer_cursor *pCsr, int iLangid);
170235 SQLITE_PRIVATE int sqlite3Fts3EvalTestDeferred(Fts3Cursor *pCsr, int *pRc);
170279 SQLITE_PRIVATE int sqlite3Fts3MsrIncrRestart(Fts3MultiSegReader *pCsr);
170315 static int fts3EvalNext(Fts3Cursor *pCsr);
170316 static int fts3EvalStart(Fts3Cursor *pCsr);
171744 sqlite3_vtab_cursor *pCsr; /* Allocated cursor */
171752 *ppCsr = pCsr = (sqlite3_vtab_cursor *)sqlite3_malloc(sizeof(Fts3Cursor));
171753 if( !pCsr ){
171756 memset(pCsr, 0, sizeof(Fts3Cursor));
171761 ** Finalize the statement handle at pCsr->pStmt.
171767 static void fts3CursorFinalizeStmt(Fts3Cursor *pCsr){
171768 if( pCsr->bSeekStmt ){
171769 Fts3Table *p = (Fts3Table *)pCsr->base.pVtab;
171771 p->pSeekStmt = pCsr->pStmt;
171772 sqlite3_reset(pCsr->pStmt);
171773 pCsr->pStmt = 0;
171775 pCsr->bSeekStmt = 0;
171777 sqlite3_finalize(pCsr->pStmt);
171784 static void fts3ClearCursor(Fts3Cursor *pCsr){
171785 fts3CursorFinalizeStmt(pCsr);
171786 sqlite3Fts3FreeDeferredTokens(pCsr);
171787 sqlite3_free(pCsr->aDoclist);
171788 sqlite3Fts3MIBufferFree(pCsr->pMIBuffer);
171789 sqlite3Fts3ExprFree(pCsr->pExpr);
171790 memset(&(&pCsr->base)[1], 0, sizeof(Fts3Cursor)-sizeof(sqlite3_vtab_cursor));
171798 Fts3Cursor *pCsr = (Fts3Cursor *)pCursor;
171799 assert( ((Fts3Table *)pCsr->base.pVtab)->pSegments==0 );
171800 fts3ClearCursor(pCsr);
171801 assert( ((Fts3Table *)pCsr->base.pVtab)->pSegments==0 );
171802 sqlite3_free(pCsr);
171807 ** If pCsr->pStmt has not been prepared (i.e. if pCsr->pStmt==0), then
171812 ** (or the equivalent for a content=xxx table) and set pCsr->pStmt to
171815 static int fts3CursorSeekStmt(Fts3Cursor *pCsr){
171817 if( pCsr->pStmt==0 ){
171818 Fts3Table *p = (Fts3Table *)pCsr->base.pVtab;
171821 pCsr->pStmt = p->pSeekStmt;
171828 p->db, zSql,-1,SQLITE_PREPARE_PERSISTENT,&pCsr->pStmt,0
171833 if( rc==SQLITE_OK ) pCsr->bSeekStmt = 1;
171839 ** Position the pCsr->pStmt statement so that it is on the row
171843 static int fts3CursorSeek(sqlite3_context *pContext, Fts3Cursor *pCsr){
171845 if( pCsr->isRequireSeek ){
171846 rc = fts3CursorSeekStmt(pCsr);
171848 Fts3Table *pTab = (Fts3Table*)pCsr->base.pVtab;
171850 sqlite3_bind_int64(pCsr->pStmt, 1, pCsr->iPrevId);
171851 pCsr->isRequireSeek = 0;
171852 if( SQLITE_ROW==sqlite3_step(pCsr->pStmt) ){
171857 rc = sqlite3_reset(pCsr->pStmt);
171858 if( rc==SQLITE_OK && ((Fts3Table *)pCsr->base.pVtab)->zContentTbl==0 ){
171863 pCsr->isEof = 1;
172942 ** Append SegReader object pNew to the end of the pCsr->apSegment[] array.
172945 Fts3MultiSegReader *pCsr,
172948 if( (pCsr->nSegment%16)==0 ){
172950 sqlite3_int64 nByte = (pCsr->nSegment + 16)*sizeof(Fts3SegReader*);
172951 apNew = (Fts3SegReader **)sqlite3_realloc64(pCsr->apSegment, nByte);
172956 pCsr->apSegment = apNew;
172958 pCsr->apSegment[pCsr->nSegment++] = pNew;
172978 Fts3MultiSegReader *pCsr /* Cursor object to populate */
172994 rc = fts3SegReaderCursorAppend(pCsr, pSeg);
173022 rc = sqlite3Fts3SegReaderNew(pCsr->nSegment+1,
173028 rc = fts3SegReaderCursorAppend(pCsr, pSeg);
173052 Fts3MultiSegReader *pCsr /* Cursor object to populate */
173063 memset(pCsr, 0, sizeof(Fts3MultiSegReader));
173065 p, iLangid, iIndex, iLevel, zTerm, nTerm, isPrefix, isScan, pCsr
173080 Fts3MultiSegReader *pCsr /* Fts3MultiSegReader to modify */
173083 iLangid, 0, FTS3_SEGCURSOR_ALL, zTerm, nTerm, 0, 0,pCsr
173101 Fts3Cursor *pCsr, /* Virtual table cursor handle */
173114 Fts3Table *p = (Fts3Table *)pCsr->base.pVtab;
173120 rc = sqlite3Fts3SegReaderCursor(p, pCsr->iLangid,
173130 rc = sqlite3Fts3SegReaderCursor(p, pCsr->iLangid,
173135 p, pCsr->iLangid, zTerm, nTerm, pSegcsr
173143 rc = sqlite3Fts3SegReaderCursor(p, pCsr->iLangid,
173251 Fts3Cursor *pCsr = (Fts3Cursor *)pCursor;
173252 if( pCsr->eSearch==FTS3_DOCID_SEARCH || pCsr->eSearch==FTS3_FULLSCAN_SEARCH ){
173255 if( SQLITE_ROW!=sqlite3_step(pCsr->pStmt) ){
173256 pCsr->isEof = 1;
173257 rc = sqlite3_reset(pCsr->pStmt);
173259 pCsr->iPrevId = sqlite3_column_int64(pCsr->pStmt, 0);
173266 assert( ((Fts3Table *)pCsr->base.pVtab)->pSegments==0 );
173312 Fts3Cursor *pCsr = (Fts3Cursor *)pCursor;
173340 fts3ClearCursor(pCsr);
173343 pCsr->iMinDocid = fts3DocidRange(pDocidGe, SMALLEST_INT64);
173344 pCsr->iMaxDocid = fts3DocidRange(pDocidLe, LARGEST_INT64);
173347 pCsr->bDesc = (idxStr[0]=='D');
173349 pCsr->bDesc = p->bDescIdx;
173351 pCsr->eSearch = (i16)eSearch;
173361 pCsr->iLangid = 0;
173362 if( pLangid ) pCsr->iLangid = sqlite3_value_int(pLangid);
173365 rc = sqlite3Fts3ExprParse(p->pTokenizer, pCsr->iLangid,
173366 p->azColumn, p->bFts4, p->nColumn, iCol, zQuery, -1, &pCsr->pExpr,
173373 rc = fts3EvalStart(pCsr);
173376 pCsr->pNextId = pCsr->aDoclist;
173377 pCsr->iPrevId = 0;
173389 p->zReadExprlist, pCsr->iMinDocid, pCsr->iMaxDocid,
173390 (pCsr->bDesc ? "DESC" : "ASC")
173394 p->zReadExprlist, (pCsr->bDesc ? "DESC" : "ASC")
173400 p->db,zSql,-1,SQLITE_PREPARE_PERSISTENT,&pCsr->pStmt,0
173408 rc = fts3CursorSeekStmt(pCsr);
173410 rc = sqlite3_bind_value(pCsr->pStmt, 1, pCons);
173423 Fts3Cursor *pCsr = (Fts3Cursor*)pCursor;
173424 if( pCsr->isEof ){
173425 fts3ClearCursor(pCsr);
173426 pCsr->isEof = 1;
173428 return pCsr->isEof;
173438 Fts3Cursor *pCsr = (Fts3Cursor *) pCursor;
173439 *pRowid = pCsr->iPrevId;
173460 Fts3Cursor *pCsr = (Fts3Cursor *) pCursor;
173469 sqlite3_result_pointer(pCtx, pCsr, "fts3cursor", 0);
173474 sqlite3_result_int64(pCtx, pCsr->iPrevId);
173478 if( pCsr->pExpr ){
173479 sqlite3_result_int64(pCtx, pCsr->iLangid);
173492 rc = fts3CursorSeek(0, pCsr);
173493 if( rc==SQLITE_OK && sqlite3_data_count(pCsr->pStmt)-1>iCol ){
173494 sqlite3_result_value(pCtx, sqlite3_column_value(pCsr->pStmt, iCol+1));
173499 assert( ((Fts3Table *)pCsr->base.pVtab)->pSegments==0 );
173708 Fts3Cursor *pCsr; /* Cursor handle passed through apVal[0] */
173725 if( fts3FunctionArg(pContext, "snippet", apVal[0], &pCsr) ) return;
173742 }else if( SQLITE_OK==fts3CursorSeek(pContext, pCsr) ){
173743 sqlite3Fts3Snippet(pContext, pCsr, zStart, zEnd, zEllipsis, iCol, nToken);
173755 Fts3Cursor *pCsr; /* Cursor handle passed through apVal[0] */
173760 if( fts3FunctionArg(pContext, "offsets", apVal[0], &pCsr) ) return;
173761 assert( pCsr );
173762 if( SQLITE_OK==fts3CursorSeek(pContext, pCsr) ){
173763 sqlite3Fts3Offsets(pContext, pCsr);
173815 Fts3Cursor *pCsr; /* Cursor handle passed through apVal[0] */
173817 if( SQLITE_OK==fts3FunctionArg(pContext, "matchinfo", apVal[0], &pCsr) ){
173822 sqlite3Fts3Matchinfo(pContext, pCsr, zArg);
174154 Fts3Cursor *pCsr, /* FTS cursor handle */
174167 int rc = fts3TermSegReaderCursor(pCsr,
174179 fts3EvalAllocateReaders(pCsr, pExpr->pLeft, pnToken, pnOr, pRc);
174180 fts3EvalAllocateReaders(pCsr, pExpr->pRight, pnToken, pnOr, pRc);
174260 Fts3Cursor *pCsr, /* FTS Cursor handle */
174263 Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab;
174296 static int fts3EvalDeferredPhrase(Fts3Cursor *pCsr, Fts3Phrase *pPhrase){
174350 pPhrase->doclist.iDocid = pCsr->iPrevId;
174409 static int fts3EvalPhraseStart(Fts3Cursor *pCsr, int bOptOk, Fts3Phrase *p){
174410 Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab;
174421 && pCsr->bDesc==pTab->bDescIdx
174448 rc = fts3EvalPhraseLoad(pCsr, p);
174676 Fts3Cursor *pCsr, /* FTS Cursor handle */
174682 Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab;
174695 int bDescDoclist = pCsr->bDesc;
174777 Fts3Cursor *pCsr, /* FTS Cursor handle */
174783 Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab;
174786 rc = fts3EvalIncrPhraseNext(pCsr, p, pbEof);
174787 }else if( pCsr->bDesc!=pTab->bDescIdx && pDL->nAll ){
174816 Fts3Cursor *pCsr, /* FTS Cursor handle */
174830 *pRc = fts3EvalPhraseStart(pCsr, 1, pExpr->pPhrase);
174832 fts3EvalStartReaders(pCsr, pExpr->pLeft, pRc);
174833 fts3EvalStartReaders(pCsr, pExpr->pRight, pRc);
174869 Fts3Cursor *pCsr, /* FTS Cursor handle */
174887 *pRc = sqlite3Fts3MsrOvfl(pCsr, pTC->pToken->pSegcsr, &pTC->nOvfl);
174900 fts3EvalTokenCosts(pCsr, pRoot, pExpr->pLeft, ppTC, ppOr, pRc);
174906 fts3EvalTokenCosts(pCsr, pRoot, pExpr->pRight, ppTC, ppOr, pRc);
174922 static int fts3EvalAverageDocsize(Fts3Cursor *pCsr, int *pnPage){
174924 if( pCsr->nRowAvg==0 ){
174936 Fts3Table *p = (Fts3Table*)pCsr->base.pVtab;
174959 pCsr->nDoc = nDoc;
174960 pCsr->nRowAvg = (int)(((nByte / nDoc) + p->nPgsz) / p->nPgsz);
174961 assert( pCsr->nRowAvg>0 );
174965 *pnPage = pCsr->nRowAvg;
174984 Fts3Cursor *pCsr, /* FTS Cursor handle */
174989 Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab;
175020 rc = fts3EvalAverageDocsize(pCsr, &nDocSize);
175066 rc = sqlite3Fts3DeferToken(pCsr, pToken, pTC->iCol);
175106 ** the full-text query currently stored in pCsr->pExpr. To iterate through
175109 ** fts3EvalStart(pCsr);
175111 ** fts3EvalNext(pCsr);
175112 ** if( pCsr->bEof ) break;
175113 ** ... return row pCsr->iPrevId to the caller ...
175116 static int fts3EvalStart(Fts3Cursor *pCsr){
175117 Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab;
175123 fts3EvalAllocateReaders(pCsr, pCsr->pExpr, &nToken, &nOr, &rc);
175143 fts3EvalTokenCosts(pCsr, 0, pCsr->pExpr, &pTC, &ppOr, &rc);
175148 rc = fts3EvalSelectDeferred(pCsr, 0, aTC, nToken);
175150 rc = fts3EvalSelectDeferred(pCsr, apOr[ii], aTC, nToken);
175159 fts3EvalStartReaders(pCsr, pCsr->pExpr, &rc);
175274 Fts3Cursor *pCsr, /* FTS Cursor handle */
175279 int bDescDoclist = pCsr->bDesc; /* Used by DOCID_CMP() macro */
175293 fts3EvalNextRow(pCsr, pRight, pRc);
175299 fts3EvalNextRow(pCsr, pLeft, pRc);
175304 fts3EvalNextRow(pCsr, pLeft, pRc);
175305 fts3EvalNextRow(pCsr, pRight, pRc);
175310 fts3EvalNextRow(pCsr, pLeft, pRc);
175312 fts3EvalNextRow(pCsr, pRight, pRc);
175323 fts3EvalNextRow(pCsr, pRight, pRc);
175330 fts3EvalNextRow(pCsr, pLeft, pRc);
175348 fts3EvalNextRow(pCsr, pLeft, pRc);
175350 fts3EvalNextRow(pCsr, pRight, pRc);
175352 fts3EvalNextRow(pCsr, pLeft, pRc);
175353 fts3EvalNextRow(pCsr, pRight, pRc);
175372 fts3EvalNextRow(pCsr, pRight, pRc);
175376 fts3EvalNextRow(pCsr, pLeft, pRc);
175382 fts3EvalNextRow(pCsr, pRight, pRc);
175393 *pRc = fts3EvalPhraseNext(pCsr, pPhrase, &pExpr->bEof);
175490 ** expression passed as the second argument matches the row that pCsr
175499 Fts3Cursor *pCsr, /* FTS cursor handle */
175509 fts3EvalTestExpr(pCsr, pExpr->pLeft, pRc)
175510 && fts3EvalTestExpr(pCsr, pExpr->pRight, pRc)
175535 if( p->pRight->iDocid==pCsr->iPrevId ){
175539 if( p->iDocid==pCsr->iPrevId ){
175547 int bHit1 = fts3EvalTestExpr(pCsr, pExpr->pLeft, pRc);
175548 int bHit2 = fts3EvalTestExpr(pCsr, pExpr->pRight, pRc);
175555 fts3EvalTestExpr(pCsr, pExpr->pLeft, pRc)
175556 && !fts3EvalTestExpr(pCsr, pExpr->pRight, pRc)
175562 if( pCsr->pDeferred
175563 && (pExpr->iDocid==pCsr->iPrevId || pExpr->bDeferred)
175570 *pRc = fts3EvalDeferredPhrase(pCsr, pPhrase);
175572 pExpr->iDocid = pCsr->iPrevId;
175577 pExpr->bEof==0 && pExpr->iDocid==pCsr->iPrevId
175612 SQLITE_PRIVATE int sqlite3Fts3EvalTestDeferred(Fts3Cursor *pCsr, int *pRc){
175623 if( pCsr->pDeferred ){
175624 rc = fts3CursorSeek(0, pCsr);
175626 rc = sqlite3Fts3CacheDeferredDoclists(pCsr);
175629 bMiss = (0==fts3EvalTestExpr(pCsr, pCsr->pExpr, &rc));
175632 sqlite3Fts3FreeDeferredDoclists(pCsr);
175642 static int fts3EvalNext(Fts3Cursor *pCsr){
175644 Fts3Expr *pExpr = pCsr->pExpr;
175645 assert( pCsr->isEof==0 );
175647 pCsr->isEof = 1;
175650 if( pCsr->isRequireSeek==0 ){
175651 sqlite3_reset(pCsr->pStmt);
175653 assert( sqlite3_data_count(pCsr->pStmt)==0 );
175654 fts3EvalNextRow(pCsr, pExpr, &rc);
175655 pCsr->isEof = pExpr->bEof;
175656 pCsr->isRequireSeek = 1;
175657 pCsr->isMatchinfoNeeded = 1;
175658 pCsr->iPrevId = pExpr->iDocid;
175659 }while( pCsr->isEof==0 && sqlite3Fts3EvalTestDeferred(pCsr, &rc) );
175665 (pCsr->bDesc==0 && pCsr->iPrevId>pCsr->iMaxDocid)
175666 || (pCsr->bDesc!=0 && pCsr->iPrevId<pCsr->iMinDocid)
175668 pCsr->isEof = 1;
175684 Fts3Cursor *pCsr,
175702 *pRc = fts3EvalPhraseStart(pCsr, 0, pPhrase);
175713 fts3EvalRestart(pCsr, pExpr->pLeft, pRc);
175714 fts3EvalRestart(pCsr, pExpr->pRight, pRc);
175769 Fts3Cursor *pCsr, /* Cursor object */
175776 Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab;
175780 sqlite3_int64 iPrevId = pCsr->iPrevId;
175802 fts3EvalRestart(pCsr, pRoot, &rc);
175804 while( pCsr->isEof==0 && rc==SQLITE_OK ){
175808 if( pCsr->isRequireSeek==0 ) sqlite3_reset(pCsr->pStmt);
175809 assert( sqlite3_data_count(pCsr->pStmt)==0 );
175812 fts3EvalNextRow(pCsr, pRoot, &rc);
175813 pCsr->isEof = pRoot->bEof;
175814 pCsr->isRequireSeek = 1;
175815 pCsr->isMatchinfoNeeded = 1;
175816 pCsr->iPrevId = pRoot->iDocid;
175817 }while( pCsr->isEof==0
175819 && sqlite3Fts3EvalTestDeferred(pCsr, &rc)
175822 if( rc==SQLITE_OK && pCsr->isEof==0 ){
175827 pCsr->isEof = 0;
175828 pCsr->iPrevId = iPrevId;
175839 fts3EvalRestart(pCsr, pRoot, &rc);
175841 fts3EvalNextRow(pCsr, pRoot, &rc);
175881 Fts3Cursor *pCsr, /* FTS cursor handle */
175885 Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab;
175890 assert( pCsr->nDoc>0 );
175892 aiOut[iCol*3 + 1] = (u32)pCsr->nDoc;
175893 aiOut[iCol*3 + 2] = (u32)pCsr->nDoc;
175896 rc = fts3EvalGatherStats(pCsr, pExpr);
175929 Fts3Cursor *pCsr, /* FTS3 cursor object */
175935 Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab;
175950 if( iDocid!=pCsr->iPrevId || pExpr->bEof ){
175961 ** pCsr->iPrevId may lie earlier in the doclist buffer. Or, if the
175977 fts3EvalRestart(pCsr, pNear, &rc);
175979 fts3EvalNextRow(pCsr, pNear, &rc);
175986 fts3EvalNextRow(pCsr, pNear, &rc);
176003 if( pCsr->bDesc==bDescDoclist ){
176006 while( (pIter==0 || DOCID_CMP(iDocid, pCsr->iPrevId)<0 ) && bEof==0 ){
176014 while( (pIter==0 || DOCID_CMP(iDocid, pCsr->iPrevId)>0 ) && bEof==0 ){
176024 if( bEof || iDocid!=pCsr->iPrevId ) bMatch = 0;
176325 Fts3auxCursor *pCsr; /* Pointer to cursor object to return */
176329 pCsr = (Fts3auxCursor *)sqlite3_malloc(sizeof(Fts3auxCursor));
176330 if( !pCsr ) return SQLITE_NOMEM;
176331 memset(pCsr, 0, sizeof(Fts3auxCursor));
176333 *ppCsr = (sqlite3_vtab_cursor *)pCsr;
176342 Fts3auxCursor *pCsr = (Fts3auxCursor *)pCursor;
176345 sqlite3Fts3SegReaderFinish(&pCsr->csr);
176346 sqlite3_free((void *)pCsr->filter.zTerm);
176347 sqlite3_free(pCsr->zStop);
176348 sqlite3_free(pCsr->aStat);
176349 sqlite3_free(pCsr);
176353 static int fts3auxGrowStatArray(Fts3auxCursor *pCsr, int nSize){
176354 if( nSize>pCsr->nStat ){
176356 aNew = (struct Fts3auxColstats *)sqlite3_realloc64(pCsr->aStat,
176360 memset(&aNew[pCsr->nStat], 0,
176361 sizeof(struct Fts3auxColstats) * (nSize - pCsr->nStat)
176363 pCsr->aStat = aNew;
176364 pCsr->nStat = nSize;
176373 Fts3auxCursor *pCsr = (Fts3auxCursor *)pCursor;
176378 pCsr->iRowid++;
176380 for(pCsr->iCol++; pCsr->iCol<pCsr->nStat; pCsr->iCol++){
176381 if( pCsr->aStat[pCsr->iCol].nDoc>0 ) return SQLITE_OK;
176384 rc = sqlite3Fts3SegReaderStep(pFts3, &pCsr->csr);
176387 int nDoclist = pCsr->csr.nDoclist;
176388 char *aDoclist = pCsr->csr.aDoclist;
176393 if( pCsr->zStop ){
176394 int n = (pCsr->nStop<pCsr->csr.nTerm) ? pCsr->nStop : pCsr->csr.nTerm;
176395 int mc = memcmp(pCsr->zStop, pCsr->csr.zTerm, n);
176396 if( mc<0 || (mc==0 && pCsr->csr.nTerm>pCsr->nStop) ){
176397 pCsr->isEof = 1;
176402 if( fts3auxGrowStatArray(pCsr, 2) ) return SQLITE_NOMEM;
176403 memset(pCsr->aStat, 0, sizeof(struct Fts3auxColstats) * pCsr->nStat);
176413 pCsr->aStat[0].nDoc++;
176429 pCsr->aStat[1].nDoc++;
176440 pCsr->aStat[iCol+1].nOcc++;
176441 pCsr->aStat[0].nOcc++;
176448 if( fts3auxGrowStatArray(pCsr, iCol+2) ) return SQLITE_NOMEM;
176449 pCsr->aStat[iCol+1].nDoc++;
176455 pCsr->iCol = 0;
176458 pCsr->isEof = 1;
176473 Fts3auxCursor *pCsr = (Fts3auxCursor *)pCursor;
176510 testcase(pCsr->filter.zTerm);
176511 sqlite3Fts3SegReaderFinish(&pCsr->csr);
176512 sqlite3_free((void *)pCsr->filter.zTerm);
176513 sqlite3_free(pCsr->aStat);
176514 memset(&pCsr->csr, 0, ((u8*)&pCsr[1]) - (u8*)&pCsr->csr);
176516 pCsr->filter.flags = FTS3_SEGMENT_REQUIRE_POS|FTS3_SEGMENT_IGNORE_EMPTY;
176517 if( isScan ) pCsr->filter.flags |= FTS3_SEGMENT_SCAN;
176523 pCsr->filter.zTerm = sqlite3_mprintf("%s", zStr);
176524 if( pCsr->filter.zTerm==0 ) return SQLITE_NOMEM;
176525 pCsr->filter.nTerm = (int)strlen(pCsr->filter.zTerm);
176530 pCsr->zStop = sqlite3_mprintf("%s", sqlite3_value_text(apVal[iLe]));
176531 if( pCsr->zStop==0 ) return SQLITE_NOMEM;
176532 pCsr->nStop = (int)strlen(pCsr->zStop);
176545 pCsr->iLangid = iLangVal;
176548 pCsr->filter.zTerm, pCsr->filter.nTerm, 0, isScan, &pCsr->csr
176551 rc = sqlite3Fts3SegReaderStart(pFts3, &pCsr->csr, &pCsr->filter);
176562 Fts3auxCursor *pCsr = (Fts3auxCursor *)pCursor;
176563 return pCsr->isEof;
176614 Fts3auxCursor *pCsr = (Fts3auxCursor *)pCursor;
176615 *pRowid = pCsr->iRowid;
176798 sqlite3_tokenizer_cursor *pCsr = 0;
176801 rc = pModule->xOpen(pTokenizer, z, n, &pCsr);
176802 assert( rc==SQLITE_OK || pCsr==0 );
176804 pCsr->pTokenizer = pTokenizer;
176806 rc = pModule->xLanguageid(pCsr, iLangid);
176808 pModule->xClose(pCsr);
176809 pCsr = 0;
176813 *ppCsr = pCsr;
179275 sqlite3_tokenizer_cursor *pCsr = 0;
179327 if( sqlite3Fts3OpenTokenizer(pTokenizer, 0, zInput, nInput, &pCsr) ){
179332 while( SQLITE_OK==p->xNext(pCsr, &zToken, &nToken, &iStart, &iEnd, &iPos) ){
179340 if( SQLITE_OK!=p->xClose(pCsr) ){
179831 sqlite3_tokenizer_cursor *pCsr; /* Cursor to iterate through zInput */
180030 Fts3tokCursor *pCsr;
180033 pCsr = (Fts3tokCursor *)sqlite3_malloc(sizeof(Fts3tokCursor));
180034 if( pCsr==0 ){
180037 memset(pCsr, 0, sizeof(Fts3tokCursor));
180039 *ppCsr = (sqlite3_vtab_cursor *)pCsr;
180047 static void fts3tokResetCursor(Fts3tokCursor *pCsr){
180048 if( pCsr->pCsr ){
180049 Fts3tokTable *pTab = (Fts3tokTable *)(pCsr->base.pVtab);
180050 pTab->pMod->xClose(pCsr->pCsr);
180051 pCsr->pCsr = 0;
180053 sqlite3_free(pCsr->zInput);
180054 pCsr->zInput = 0;
180055 pCsr->zToken = 0;
180056 pCsr->nToken = 0;
180057 pCsr->iStart = 0;
180058 pCsr->iEnd = 0;
180059 pCsr->iPos = 0;
180060 pCsr->iRowid = 0;
180067 Fts3tokCursor *pCsr = (Fts3tokCursor *)pCursor;
180069 fts3tokResetCursor(pCsr);
180070 sqlite3_free(pCsr);
180078 Fts3tokCursor *pCsr = (Fts3tokCursor *)pCursor;
180082 pCsr->iRowid++;
180083 rc = pTab->pMod->xNext(pCsr->pCsr,
180084 &pCsr->zToken, &pCsr->nToken,
180085 &pCsr->iStart, &pCsr->iEnd, &pCsr->iPos
180089 fts3tokResetCursor(pCsr);
180107 Fts3tokCursor *pCsr = (Fts3tokCursor *)pCursor;
180112 fts3tokResetCursor(pCsr);
180116 pCsr->zInput = sqlite3_malloc64(nByte+1);
180117 if( pCsr->zInput==0 ){
180120 if( nByte>0 ) memcpy(pCsr->zInput, zByte, nByte);
180121 pCsr->zInput[nByte] = 0;
180122 rc = pTab->pMod->xOpen(pTab->pTok, pCsr->zInput, nByte, &pCsr->pCsr);
180124 pCsr->pCsr->pTokenizer = pTab->pTok;
180137 Fts3tokCursor *pCsr = (Fts3tokCursor *)pCursor;
180138 return (pCsr->zToken==0);
180149 Fts3tokCursor *pCsr = (Fts3tokCursor *)pCursor;
180154 sqlite3_result_text(pCtx, pCsr->zInput, -1, SQLITE_TRANSIENT);
180157 sqlite3_result_text(pCtx, pCsr->zToken, pCsr->nToken, SQLITE_TRANSIENT);
180160 sqlite3_result_int(pCtx, pCsr->iStart);
180163 sqlite3_result_int(pCtx, pCsr->iEnd);
180167 sqlite3_result_int(pCtx, pCsr->iPos);
180180 Fts3tokCursor *pCsr = (Fts3tokCursor *)pCursor;
180181 *pRowid = (sqlite3_int64)pCsr->iRowid;
181031 sqlite3_tokenizer_cursor *pCsr;
181045 rc = sqlite3Fts3OpenTokenizer(pTokenizer, iLangid, zText, -1, &pCsr);
181052 && SQLITE_OK==(rc = xNext(pCsr, &zToken, &nToken, &iStart, &iEnd, &iPos))
181081 pModule->xClose(pCsr);
181778 Fts3Cursor *pCsr,
181782 Fts3Table *p = (Fts3Table*)pCsr->base.pVtab;
182970 Fts3MultiSegReader *pCsr, /* Cursor object */
182975 int nSeg = pCsr->nSegment;
182983 for(i=0; pCsr->bRestart==0 && i<pCsr->nSegment; i++){
182985 Fts3SegReader *pSeg = pCsr->apSegment[i];
182995 fts3SegReaderSort(pCsr->apSegment, nSeg, nSeg, fts3SegReaderCmp);
183002 Fts3MultiSegReader *pCsr, /* Cursor object */
183005 pCsr->pFilter = pFilter;
183006 return fts3SegReaderStart(p, pCsr, pFilter->zTerm, pFilter->nTerm);
183011 Fts3MultiSegReader *pCsr, /* Cursor object */
183018 int nSegment = pCsr->nSegment;
183023 assert( pCsr->pFilter==0 );
183027 rc = fts3SegReaderStart(p, pCsr, zTerm, nTerm);
183032 Fts3SegReader *pSeg = pCsr->apSegment[i];
183037 pCsr->nAdvance = i;
183040 for(i=0; i<pCsr->nAdvance; i++){
183041 rc = fts3SegReaderFirstDocid(p, pCsr->apSegment[i]);
183044 fts3SegReaderSort(pCsr->apSegment, i, i, xCmp);
183047 pCsr->iColFilter = iCol;
183064 SQLITE_PRIVATE int sqlite3Fts3MsrIncrRestart(Fts3MultiSegReader *pCsr){
183067 assert( pCsr->zTerm==0 );
183068 assert( pCsr->nTerm==0 );
183069 assert( pCsr->aDoclist==0 );
183070 assert( pCsr->nDoclist==0 );
183072 pCsr->nAdvance = 0;
183073 pCsr->bRestart = 1;
183074 for(i=0; i<pCsr->nSegment; i++){
183075 pCsr->apSegment[i]->pOffsetList = 0;
183076 pCsr->apSegment[i]->nOffsetList = 0;
183077 pCsr->apSegment[i]->iDocid = 0;
183083 static int fts3GrowSegReaderBuffer(Fts3MultiSegReader *pCsr, int nReq){
183084 if( nReq>pCsr->nBuffer ){
183086 pCsr->nBuffer = nReq*2;
183087 aNew = sqlite3_realloc(pCsr->aBuffer, pCsr->nBuffer);
183091 pCsr->aBuffer = aNew;
183099 Fts3MultiSegReader *pCsr /* Cursor object */
183103 int isIgnoreEmpty = (pCsr->pFilter->flags & FTS3_SEGMENT_IGNORE_EMPTY);
183104 int isRequirePos = (pCsr->pFilter->flags & FTS3_SEGMENT_REQUIRE_POS);
183105 int isColFilter = (pCsr->pFilter->flags & FTS3_SEGMENT_COLUMN_FILTER);
183106 int isPrefix = (pCsr->pFilter->flags & FTS3_SEGMENT_PREFIX);
183107 int isScan = (pCsr->pFilter->flags & FTS3_SEGMENT_SCAN);
183108 int isFirst = (pCsr->pFilter->flags & FTS3_SEGMENT_FIRST);
183110 Fts3SegReader **apSegment = pCsr->apSegment;
183111 int nSegment = pCsr->nSegment;
183112 Fts3SegFilter *pFilter = pCsr->pFilter;
183117 if( pCsr->nSegment==0 ) return SQLITE_OK;
183123 /* Advance the first pCsr->nAdvance entries in the apSegment[] array
183126 for(i=0; i<pCsr->nAdvance; i++){
183135 fts3SegReaderSort(apSegment, nSegment, pCsr->nAdvance, fts3SegReaderCmp);
183136 pCsr->nAdvance = 0;
183142 pCsr->nTerm = apSegment[0]->nTerm;
183143 pCsr->zTerm = apSegment[0]->zTerm;
183153 if( pCsr->nTerm<pFilter->nTerm
183154 || (!isPrefix && pCsr->nTerm>pFilter->nTerm)
183155 || memcmp(pCsr->zTerm, pFilter->zTerm, pFilter->nTerm)
183164 && apSegment[nMerge]->nTerm==pCsr->nTerm
183165 && 0==memcmp(pCsr->zTerm, apSegment[nMerge]->zTerm, pCsr->nTerm)
183176 pCsr->nDoclist = apSegment[0]->nDoclist;
183178 rc = fts3MsrBufferData(pCsr, apSegment[0]->aDoclist, pCsr->nDoclist);
183179 pCsr->aDoclist = pCsr->aBuffer;
183181 pCsr->aDoclist = apSegment[0]->aDoclist;
183231 rc = fts3GrowSegReaderBuffer(pCsr, nByte+nDoclist);
183235 char *a = &pCsr->aBuffer[nDoclist];
183244 nDoclist += sqlite3Fts3PutVarint(&pCsr->aBuffer[nDoclist], iDelta);
183247 memcpy(&pCsr->aBuffer[nDoclist], pList, nList);
183249 pCsr->aBuffer[nDoclist++] = '\0';
183257 rc = fts3GrowSegReaderBuffer(pCsr, nDoclist+FTS3_NODE_PADDING);
183259 memset(&pCsr->aBuffer[nDoclist], 0, FTS3_NODE_PADDING);
183260 pCsr->aDoclist = pCsr->aBuffer;
183261 pCsr->nDoclist = nDoclist;
183265 pCsr->nAdvance = nMerge;
183273 Fts3MultiSegReader *pCsr /* Cursor object */
183275 if( pCsr ){
183277 for(i=0; i<pCsr->nSegment; i++){
183278 sqlite3Fts3SegReaderFree(pCsr->apSegment[i]);
183280 sqlite3_free(pCsr->apSegment);
183281 sqlite3_free(pCsr->aBuffer);
183283 pCsr->nSegment = 0;
183284 pCsr->apSegment = 0;
183285 pCsr->aBuffer = 0;
183855 Fts3MultiSegReader *pCsr /* Cursor object to populate */
183859 sqlite3_int64 nByte; /* Bytes allocated at pCsr->apSegment[] */
183862 memset(pCsr, 0, sizeof(*pCsr));
183864 pCsr->apSegment = (Fts3SegReader **)sqlite3_malloc64(nByte);
183866 if( pCsr->apSegment==0 ){
183869 memset(pCsr->apSegment, 0, nByte);
183876 assert( pCsr->nSegment==0 );
183884 &pCsr->apSegment[i]
183886 pCsr->nSegment++;
184218 ** Append the current term and doclist pointed to by cursor pCsr to the
184226 Fts3MultiSegReader *pCsr /* Cursor containing term and doclist */
184228 const char *zTerm = pCsr->zTerm;
184229 int nTerm = pCsr->nTerm;
184230 const char *aDoclist = pCsr->aDoclist;
184231 int nDoclist = pCsr->nDoclist;
184655 Fts3MultiSegReader *pCsr, /* Cursor that data will be read from */
184668 sqlite3_bind_int64(pLeafEst, 2, pCsr->nSegment);
184962 Fts3MultiSegReader *pCsr, /* Chomp all segments opened by this cursor */
184969 for(i=pCsr->nSegment-1; i>=0 && rc==SQLITE_OK; i--){
184974 ** somewhere in the pCsr->apSegment[] array. */
184975 for(j=0; ALWAYS(j<pCsr->nSegment); j++){
184976 pSeg = pCsr->apSegment[j];
184979 assert( j<pCsr->nSegment && pSeg->iIdx==i );
184999 if( rc==SQLITE_OK && nRem!=pCsr->nSegment ){
185124 Fts3MultiSegReader *pCsr; /* Cursor used to read input data */
185125 Fts3SegFilter *pFilter; /* Filter used with cursor pCsr */
185133 const int nAlloc = sizeof(*pCsr) + sizeof(*pFilter) + sizeof(*pWriter);
185137 pCsr = (Fts3MultiSegReader *)&pFilter[1];
185225 rc = fts3IncrmergeCsr(p, iAbsLevel, nSeg, pCsr);
185227 if( SQLITE_OK==rc && pCsr->nSegment==nSeg
185228 && SQLITE_OK==(rc = sqlite3Fts3SegReaderStart(p, pCsr, pFilter))
185231 rc = sqlite3Fts3SegReaderStep(p, pCsr);
185235 sqlite3Fts3SegReaderFinish(pCsr);
185239 const char *zKey = pCsr->zTerm;
185240 int nKey = pCsr->nTerm;
185243 rc = fts3IncrmergeWriter(p, iAbsLevel, iIdx, pCsr, pWriter);
185250 rc = fts3IncrmergeAppend(p, pWriter, pCsr);
185251 if( rc==SQLITE_OK ) rc = sqlite3Fts3SegReaderStep(p, pCsr);
185259 rc = fts3IncrmergeChomp(p, iAbsLevel, pCsr, &nSeg);
185276 sqlite3Fts3SegReaderFinish(pCsr);
185442 char *pCsr = csr.aDoclist;
185443 char *pEnd = &pCsr[csr.nDoclist];
185449 pCsr += sqlite3Fts3GetVarint(pCsr, &iDocid);
185450 while( pCsr<pEnd ){
185452 pCsr += sqlite3Fts3GetVarintU(pCsr, &iVal);
185453 if( pCsr<pEnd ){
185458 pCsr += sqlite3Fts3GetVarint(pCsr, &iCol);
185460 pCsr += sqlite3Fts3GetVarintU(pCsr, &iVal);
185670 SQLITE_PRIVATE void sqlite3Fts3FreeDeferredDoclists(Fts3Cursor *pCsr){
185672 for(pDef=pCsr->pDeferred; pDef; pDef=pDef->pNext){
185679 ** Free all entries in the pCsr->pDeffered list. Entries are added to
185682 SQLITE_PRIVATE void sqlite3Fts3FreeDeferredTokens(Fts3Cursor *pCsr){
185685 for(pDef=pCsr->pDeferred; pDef; pDef=pNext){
185690 pCsr->pDeferred = 0;
185694 ** Generate deferred-doclists for all tokens in the pCsr->pDeferred list
185695 ** based on the row that pCsr currently points to.
185701 SQLITE_PRIVATE int sqlite3Fts3CacheDeferredDoclists(Fts3Cursor *pCsr){
185703 if( pCsr->pDeferred ){
185705 sqlite3_int64 iDocid; /* Docid of the row pCsr points to */
185708 Fts3Table *p = (Fts3Table *)pCsr->base.pVtab;
185712 assert( pCsr->isRequireSeek==0 );
185713 iDocid = sqlite3_column_int64(pCsr->pStmt, 0);
185717 const char *zText = (const char *)sqlite3_column_text(pCsr->pStmt, i+1);
185720 rc = sqlite3Fts3OpenTokenizer(pT, pCsr->iLangid, zText, -1, &pTC);
185728 for(pDef=pCsr->pDeferred; pDef && rc==SQLITE_OK; pDef=pDef->pNext){
185744 for(pDef=pCsr->pDeferred; pDef && rc==SQLITE_OK; pDef=pDef->pNext){
185782 ** Add an entry for token pToken to the pCsr->pDeferred list.
185785 Fts3Cursor *pCsr, /* Fts3 table cursor */
185796 pDeferred->pNext = pCsr->pDeferred;
185798 pCsr->pDeferred = pDeferred;
186070 Fts3Cursor *pCsr; /* FTS3 Cursor */
186084 Fts3Cursor *pCsr; /* Cursor snippet is being generated from */
186333 ** pCsr.
186342 Fts3Cursor *pCsr, /* Fts3 cursor for current query */
186348 sCtx.pCsr = pCsr;
186349 rc = fts3ExprIterate(pCsr->pExpr, fts3ExprLoadDoclistsCb, (void *)&sCtx);
186456 char *pCsr = pPhrase->pTail;
186476 if( 0==(*pCsr & 0x0FE) ) break;
186477 fts3GetDeltaPosition(&pCsr, &iCsr);
186496 char *pCsr;
186500 rc = sqlite3Fts3EvalPhrasePoslist(p->pCsr, pExpr, p->iCol, &pCsr);
186501 assert( rc==SQLITE_OK || pCsr==0 );
186502 if( pCsr ){
186504 pPhrase->pList = pCsr;
186505 fts3GetDeltaPosition(&pCsr, &iFirst);
186509 pPhrase->pHead = pCsr;
186510 pPhrase->pTail = pCsr;
186540 Fts3Cursor *pCsr, /* Cursor to create snippet for */
186559 rc = fts3ExprLoadDoclists(pCsr, &nList, 0);
186577 sIter.pCsr = pCsr;
186582 rc = fts3ExprIterate(pCsr->pExpr, fts3SnippetFindPositions, (void*)&sIter);
186738 ** Extract the snippet text for fragment pFragment from cursor pCsr and
186742 Fts3Cursor *pCsr, /* FTS3 Cursor */
186752 Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab;
186765 zDoc = (const char *)sqlite3_column_text(pCsr->pStmt, iCol);
186767 if( sqlite3_column_type(pCsr->pStmt, iCol)!=SQLITE_NULL ){
186772 nDoc = sqlite3_column_bytes(pCsr->pStmt, iCol);
186776 rc = sqlite3Fts3OpenTokenizer(pTab->pTokenizer, pCsr->iLangid, zDoc,nDoc,&pC);
186815 pTab, pCsr->iLangid, nSnippet, &zDoc[iBegin], n, &iPos, &hlmask
186996 char *pCsr;
186997 rc = sqlite3Fts3EvalPhrasePoslist(p->pCursor, pExpr, i, &pCsr);
186998 if( pCsr ){
186999 p->aMatchinfo[iStart+i*3] = fts3ColumnlistCount(&pCsr);
187163 static int fts3MatchinfoLcs(Fts3Cursor *pCsr, MatchInfo *pInfo){
187173 aIter = sqlite3_malloc64(sizeof(LcsIterator) * pCsr->nPhrase);
187175 memset(aIter, 0, sizeof(LcsIterator) * pCsr->nPhrase);
187176 (void)fts3ExprIterate(pCsr->pExpr, fts3MatchinfoLcsCb, (void*)aIter);
187190 rc = sqlite3Fts3EvalPhrasePoslist(pCsr, pIt->pExpr, iCol, &pIt->pRead);
187253 Fts3Cursor *pCsr, /* FTS3 cursor object */
187260 Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab;
187308 rc = sqlite3Fts3SelectDocsize(pTab, pCsr->iPrevId, &pSelectDocsize);
187328 rc = fts3ExprLoadDoclists(pCsr, 0, 0);
187330 rc = fts3MatchinfoLcs(pCsr, pInfo);
187338 rc = fts3ExprLHitGather(pCsr->pExpr, pInfo);
187345 pExpr = pCsr->pExpr;
187346 rc = fts3ExprLoadDoclists(pCsr, 0, 0);
187349 if( pCsr->pDeferred ){
187354 sqlite3Fts3EvalTestDeferred(pCsr, &rc);
187371 ** Populate pCsr->aMatchinfo[] with data for the current row. The
187376 Fts3Cursor *pCsr, /* FTS3 Cursor object */
187380 Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab;
187388 sInfo.pCursor = pCsr;
187394 if( pCsr->pMIBuffer && strcmp(pCsr->pMIBuffer->zMatchinfo, zArg) ){
187395 sqlite3Fts3MIBufferFree(pCsr->pMIBuffer);
187396 pCsr->pMIBuffer = 0;
187404 if( pCsr->pMIBuffer==0 ){
187409 pCsr->nPhrase = fts3ExprPhraseCount(pCsr->pExpr);
187410 sInfo.nPhrase = pCsr->nPhrase;
187424 pCsr->pMIBuffer = fts3MIBufferNew(nMatchinfo, zArg);
187425 if( !pCsr->pMIBuffer ) rc = SQLITE_NOMEM;
187427 pCsr->isMatchinfoNeeded = 1;
187432 xDestroyOut = fts3MIBufferAlloc(pCsr->pMIBuffer, &aOut);
187440 sInfo.nPhrase = pCsr->nPhrase;
187441 rc = fts3MatchinfoValues(pCsr, bGlobal, &sInfo, zArg);
187443 fts3MIBufferSetGlobal(pCsr->pMIBuffer);
187451 int n = pCsr->pMIBuffer->nElem * sizeof(u32);
187461 Fts3Cursor *pCsr, /* Cursor object */
187468 Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab;
187485 if( !pCsr->pExpr ){
187523 rc = fts3BestSnippet(nFToken, pCsr, iRead, mCovered, &mSeen, &sF, &iS);
187546 rc = fts3SnippetText(pCsr, &aSnippet[i],
187572 Fts3Cursor *pCsr;
187591 rc = sqlite3Fts3EvalPhrasePoslist(p->pCsr, pExpr, p->iCol, &pList);
187613 Fts3Cursor *pCsr /* Cursor object */
187615 Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab;
187623 if( !pCsr->pExpr ){
187629 assert( pCsr->isRequireSeek==0 );
187632 rc = fts3ExprLoadDoclists(pCsr, 0, &nToken);
187641 sCtx.iDocid = pCsr->iPrevId;
187642 sCtx.pCsr = pCsr;
187663 (void)fts3ExprIterate(pCsr->pExpr, fts3ExprTermOffsetInit, (void*)&sCtx);
187671 zDoc = (const char *)sqlite3_column_text(pCsr->pStmt, iCol+1);
187672 nDoc = sqlite3_column_bytes(pCsr->pStmt, iCol+1);
187674 if( sqlite3_column_type(pCsr->pStmt, iCol+1)==SQLITE_NULL ){
187682 rc = sqlite3Fts3OpenTokenizer(pTab->pTokenizer, pCsr->iLangid,
187751 Fts3Cursor *pCsr, /* FTS3 table cursor */
187754 Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab;
187763 if( !pCsr->pExpr ){
187768 fts3GetMatchinfo(pContext, pCsr, zFormat);
188053 unicode_cursor *pCsr;
188055 pCsr = (unicode_cursor *)sqlite3_malloc(sizeof(unicode_cursor));
188056 if( pCsr==0 ){
188059 memset(pCsr, 0, sizeof(unicode_cursor));
188061 pCsr->aInput = (const unsigned char *)aInput;
188063 pCsr->nInput = 0;
188064 pCsr->aInput = (const unsigned char*)"";
188066 pCsr->nInput = (int)strlen(aInput);
188068 pCsr->nInput = nInput;
188071 *pp = &pCsr->base;
188081 unicode_cursor *pCsr = (unicode_cursor *) pCursor;
188082 sqlite3_free(pCsr->zToken);
188083 sqlite3_free(pCsr);
188099 unicode_cursor *pCsr = (unicode_cursor *)pC;
188100 unicode_tokenizer *p = ((unicode_tokenizer *)pCsr->base.pTokenizer);
188103 const unsigned char *z = &pCsr->aInput[pCsr->iOff];
188106 const unsigned char *zTerm = &pCsr->aInput[pCsr->nInput];
188118 zOut = pCsr->zToken;
188123 if( (zOut-pCsr->zToken)>=(pCsr->nAlloc-4) ){
188124 char *zNew = sqlite3_realloc64(pCsr->zToken, pCsr->nAlloc+64);
188126 zOut = &zNew[zOut - pCsr->zToken];
188127 pCsr->zToken = zNew;
188128 pCsr->nAlloc += 64;
188146 pCsr->iOff = (int)(z - pCsr->aInput);
188147 *paToken = pCsr->zToken;
188148 *pnToken = (int)(zOut - pCsr->zToken);
188149 *piStart = (int)(zStart - pCsr->aInput);
188150 *piEnd = (int)(zEnd - pCsr->aInput);
188151 *piPos = pCsr->iToken++;
192266 RtreeCursor *pCsr;
192268 pCsr = (RtreeCursor *)sqlite3_malloc64(sizeof(RtreeCursor));
192269 if( pCsr ){
192270 memset(pCsr, 0, sizeof(RtreeCursor));
192271 pCsr->base.pVtab = pVTab;
192275 *ppCursor = (sqlite3_vtab_cursor *)pCsr;
192284 static void resetCursor(RtreeCursor *pCsr){
192285 Rtree *pRtree = (Rtree *)(pCsr->base.pVtab);
192288 if( pCsr->aConstraint ){
192290 for(i=0; i<pCsr->nConstraint; i++){
192291 sqlite3_rtree_query_info *pInfo = pCsr->aConstraint[i].pInfo;
192297 sqlite3_free(pCsr->aConstraint);
192298 pCsr->aConstraint = 0;
192300 for(ii=0; ii<RTREE_CACHE_SZ; ii++) nodeRelease(pRtree, pCsr->aNode[ii]);
192301 sqlite3_free(pCsr->aPoint);
192302 pStmt = pCsr->pReadAux;
192303 memset(pCsr, 0, sizeof(RtreeCursor));
192304 pCsr->base.pVtab = (sqlite3_vtab*)pRtree;
192305 pCsr->pReadAux = pStmt;
192314 RtreeCursor *pCsr = (RtreeCursor *)cur;
192316 resetCursor(pCsr);
192317 sqlite3_finalize(pCsr->pReadAux);
192318 sqlite3_free(pCsr);
192331 RtreeCursor *pCsr = (RtreeCursor *)cur;
192332 return pCsr->atEOF;
192871 RtreeCursor *pCsr = (RtreeCursor *)pVtabCursor;
192875 RTREE_QUEUE_TRACE(pCsr, "POP-Nx:");
192876 if( pCsr->bAuxValid ){
192877 pCsr->bAuxValid = 0;
192878 sqlite3_reset(pCsr->pReadAux);
192880 rtreeSearchPointPop(pCsr);
192881 rc = rtreeStepToLeaf(pCsr);
192889 RtreeCursor *pCsr = (RtreeCursor *)pVtabCursor;
192890 RtreeSearchPoint *p = rtreeSearchPointFirst(pCsr);
192892 RtreeNode *pNode = rtreeNodeOfFirstSearchPoint(pCsr, &rc);
192894 *pRowid = nodeGetRowid(RTREE_OF_CURSOR(pCsr), pNode, p->iCell);
192904 RtreeCursor *pCsr = (RtreeCursor *)cur;
192905 RtreeSearchPoint *p = rtreeSearchPointFirst(pCsr);
192908 RtreeNode *pNode = rtreeNodeOfFirstSearchPoint(pCsr, &rc);
192926 if( !pCsr->bAuxValid ){
192927 if( pCsr->pReadAux==0 ){
192929 &pCsr->pReadAux, 0);
192932 sqlite3_bind_int64(pCsr->pReadAux, 1,
192934 rc = sqlite3_step(pCsr->pReadAux);
192936 pCsr->bAuxValid = 1;
192938 sqlite3_reset(pCsr->pReadAux);
192944 sqlite3_column_value(pCsr->pReadAux, i - pRtree->nDim2 + 1));
193018 RtreeCursor *pCsr = (RtreeCursor *)pVtabCursor;
193027 resetCursor(pCsr);
193029 pCsr->iStrategy = idxNum;
193046 p = rtreeSearchPointNew(pCsr, RTREE_ZERO, 0);
193047 assert( p!=0 ); /* Always returns pCsr->sPoint */
193048 pCsr->aNode[0] = pLeaf;
193053 RTREE_QUEUE_TRACE(pCsr, "PUSH-F1:");
193055 pCsr->atEOF = 1;
193063 pCsr->aConstraint = sqlite3_malloc64(sizeof(RtreeConstraint)*argc);
193064 pCsr->nConstraint = argc;
193065 if( !pCsr->aConstraint ){
193068 memset(pCsr->aConstraint, 0, sizeof(RtreeConstraint)*argc);
193069 memset(pCsr->anQueue, 0, sizeof(u32)*(pRtree->iDepth + 1));
193073 RtreeConstraint *p = &pCsr->aConstraint[ii];
193087 p->pInfo->anQueue = pCsr->anQueue;
193110 pNew = rtreeSearchPointNew(pCsr, RTREE_ZERO, (u8)(pRtree->iDepth+1));
193115 assert( pCsr->bPoint==1 );
193116 pCsr->aNode[0] = pRoot;
193118 RTREE_QUEUE_TRACE(pCsr, "PUSH-Fm:");
193119 rc = rtreeStepToLeaf(pCsr);
196912 RtreeCursor *pCsr = (RtreeCursor *)pVtabCursor;
196920 resetCursor(pCsr);
196922 pCsr->iStrategy = idxNum;
196931 p = rtreeSearchPointNew(pCsr, RTREE_ZERO, 0);
196932 assert( p!=0 ); /* Always returns pCsr->sPoint */
196933 pCsr->aNode[0] = pLeaf;
196938 RTREE_QUEUE_TRACE(pCsr, "PUSH-F1:");
196940 pCsr->atEOF = 1;
196955 pCsr->aConstraint = p = sqlite3_malloc(sizeof(RtreeConstraint)*4);
196956 pCsr->nConstraint = 4;
196960 memset(pCsr->aConstraint, 0, sizeof(RtreeConstraint)*4);
196961 memset(pCsr->anQueue, 0, sizeof(u32)*(pRtree->iDepth + 1));
197001 pNew = rtreeSearchPointNew(pCsr, RTREE_ZERO, (u8)(pRtree->iDepth+1));
197009 assert( pCsr->bPoint==1 );
197010 pCsr->aNode[0] = pRoot;
197012 RTREE_QUEUE_TRACE(pCsr, "PUSH-Fm:");
197013 rc = rtreeStepToLeaf(pCsr);
197090 RtreeCursor *pCsr = (RtreeCursor *)cur;
197091 RtreeSearchPoint *p = rtreeSearchPointFirst(pCsr);
197093 RtreeNode *pNode = rtreeNodeOfFirstSearchPoint(pCsr, &rc);
197099 if( !pCsr->bAuxValid ){
197100 if( pCsr->pReadAux==0 ){
197102 &pCsr->pReadAux, 0);
197105 sqlite3_bind_int64(pCsr->pReadAux, 1,
197107 rc = sqlite3_step(pCsr->pReadAux);
197109 pCsr->bAuxValid = 1;
197111 sqlite3_reset(pCsr->pReadAux);
197116 sqlite3_result_value(ctx, sqlite3_column_value(pCsr->pReadAux, i+2));
198216 IcuCursor *pCsr;
198235 pCsr = (IcuCursor *)sqlite3_malloc64(
198240 if( !pCsr ){
198243 memset(pCsr, 0, sizeof(IcuCursor));
198244 pCsr->aChar = (UChar *)&pCsr[1];
198245 pCsr->aOffset = (int *)&pCsr->aChar[(nChar+3)&~3];
198247 pCsr->aOffset[iOut] = iInput;
198252 U16_APPEND(pCsr->aChar, iOut, nChar, c, isError);
198254 sqlite3_free(pCsr);
198257 pCsr->aOffset[iOut] = iInput;
198266 pCsr->pIter = ubrk_open(UBRK_WORD, p->zLocale, pCsr->aChar, iOut, &status);
198268 sqlite3_free(pCsr);
198271 pCsr->nChar = iOut;
198273 ubrk_first(pCsr->pIter);
198274 *ppCursor = (sqlite3_tokenizer_cursor *)pCsr;
198282 IcuCursor *pCsr = (IcuCursor *)pCursor;
198283 ubrk_close(pCsr->pIter);
198284 sqlite3_free(pCsr->zBuffer);
198285 sqlite3_free(pCsr);
198300 IcuCursor *pCsr = (IcuCursor *)pCursor;
198309 iStart = ubrk_current(pCsr->pIter);
198310 iEnd = ubrk_next(pCsr->pIter);
198317 U16_NEXT(pCsr->aChar, iWhite, pCsr->nChar, c);
198330 char *zNew = sqlite3_realloc(pCsr->zBuffer, nByte);
198334 pCsr->zBuffer = zNew;
198335 pCsr->nBuffer = nByte;
198339 pCsr->zBuffer, pCsr->nBuffer, &nByte, /* Output vars */
198340 &pCsr->aChar[iStart], iEnd-iStart, /* Input vars */
198343 } while( nByte>pCsr->nBuffer );
198345 *ppToken = pCsr->zBuffer;
198347 *piStartOffset = pCsr->aOffset[iStart];
198348 *piEndOffset = pCsr->aOffset[iEnd];
198349 *piPosition = pCsr->iToken++;
202954 char *pCsr = (char*)&p[1];
202957 p->zTarget = pCsr;
202959 pCsr += nTarget+1;
202961 p->zRbu = pCsr;
202963 pCsr += nRbu+1;
204579 StatCursor *pCsr;
204581 pCsr = (StatCursor *)sqlite3_malloc64(sizeof(StatCursor));
204582 if( pCsr==0 ){
204585 memset(pCsr, 0, sizeof(StatCursor));
204586 pCsr->base.pVtab = pVTab;
204587 pCsr->iDb = pTab->iDb;
204590 *ppCursor = (sqlite3_vtab_cursor *)pCsr;
204613 static void statResetCsr(StatCursor *pCsr){
204615 sqlite3_reset(pCsr->pStmt);
204616 for(i=0; i<ArraySize(pCsr->aPage); i++){
204617 statClearPage(&pCsr->aPage[i]);
204619 pCsr->iPage = 0;
204620 sqlite3_free(pCsr->zPath);
204621 pCsr->zPath = 0;
204622 pCsr->isEof = 0;
204626 static void statResetCounts(StatCursor *pCsr){
204627 pCsr->nCell = 0;
204628 pCsr->nMxPayload = 0;
204629 pCsr->nUnused = 0;
204630 pCsr->nPayload = 0;
204631 pCsr->szPage = 0;
204632 pCsr->nPage = 0;
204639 StatCursor *pCsr = (StatCursor *)pCursor;
204640 statResetCsr(pCsr);
204641 sqlite3_finalize(pCsr->pStmt);
204642 sqlite3_free(pCsr);
204788 ** Populate the pCsr->iOffset and pCsr->szPage member variables. Based on
204789 ** the current value of pCsr->iPageno.
204791 static void statSizeAndOffset(StatCursor *pCsr){
204792 StatTable *pTab = (StatTable *)((sqlite3_vtab_cursor *)pCsr)->pVtab;
204802 x[0] = pCsr->iPageno;
204804 pCsr->iOffset = x[0];
204805 pCsr->szPage += x[1];
204808 pCsr->szPage += sqlite3BtreeGetPageSize(pBt);
204809 pCsr->iOffset = (i64)pCsr->szPage * (pCsr->iPageno - 1);
204815 ** entry will be the next page, but in aggregated mode (pCsr->isAgg!=0),
204822 StatCursor *pCsr = (StatCursor *)pCursor;
204824 Btree *pBt = pTab->db->aDb[pCsr->iDb].pBt;
204827 sqlite3_free(pCsr->zPath);
204828 pCsr->zPath = 0;
204831 if( pCsr->aPage[0].pPg==0 ){
204833 statResetCounts(pCsr);
204834 rc = sqlite3_step(pCsr->pStmt);
204837 u32 iRoot = (u32)sqlite3_column_int64(pCsr->pStmt, 1);
204840 pCsr->isEof = 1;
204841 return sqlite3_reset(pCsr->pStmt);
204843 rc = sqlite3PagerGet(pPager, iRoot, &pCsr->aPage[0].pPg, 0);
204844 pCsr->aPage[0].iPgno = iRoot;
204845 pCsr->aPage[0].iCell = 0;
204846 if( !pCsr->isAgg ){
204847 pCsr->aPage[0].zPath = z = sqlite3_mprintf("/");
204850 pCsr->iPage = 0;
204851 pCsr->nPage = 1;
204853 pCsr->isEof = 1;
204854 return sqlite3_reset(pCsr->pStmt);
204858 StatPage *p = &pCsr->aPage[pCsr->iPage];
204859 if( !pCsr->isAgg ) statResetCounts(pCsr);
204868 pCsr->nPage++;
204869 statSizeAndOffset(pCsr);
204871 pCsr->nPayload += nUsable - 4;
204873 pCsr->nPayload += pCell->nLastOvfl;
204874 pCsr->nUnused += nUsable - 4 - pCell->nLastOvfl;
204878 if( !pCsr->isAgg ){
204879 pCsr->zName = (char *)sqlite3_column_text(pCsr->pStmt, 0);
204880 pCsr->iPageno = pCell->aOvfl[iOvfl];
204881 pCsr->zPagetype = "overflow";
204882 pCsr->zPath = z = sqlite3_mprintf(
204894 if( pCsr->iPage>0 ){
204895 pCsr->iPage--;
204896 }else if( pCsr->isAgg ){
204903 pCsr->iPage++;
204904 if( pCsr->iPage>=ArraySize(pCsr->aPage) ){
204905 statResetCsr(pCsr);
204908 assert( p==&pCsr->aPage[pCsr->iPage-1] );
204916 pCsr->nPage++;
204918 if( !pCsr->isAgg ){
204931 StatPage *p = &pCsr->aPage[pCsr->iPage];
204932 pCsr->zName = (char *)sqlite3_column_text(pCsr->pStmt, 0);
204933 pCsr->iPageno = p->iPgno;
204937 statSizeAndOffset(pCsr);
204942 pCsr->zPagetype = "internal";
204946 pCsr->zPagetype = "leaf";
204949 pCsr->zPagetype = "corrupted";
204952 pCsr->nCell += p->nCell;
204953 pCsr->nUnused += p->nUnused;
204954 if( p->nMxPayload>pCsr->nMxPayload ) pCsr->nMxPayload = p->nMxPayload;
204955 if( !pCsr->isAgg ){
204956 pCsr->zPath = z = sqlite3_mprintf("%s", p->zPath);
204963 pCsr->nPayload += nPayload;
204968 if( pCsr->isAgg ) goto statNextRestart;
204976 StatCursor *pCsr = (StatCursor *)pCursor;
204977 return pCsr->isEof;
204989 StatCursor *pCsr = (StatCursor *)pCursor;
204997 statResetCsr(pCsr);
204998 sqlite3_finalize(pCsr->pStmt);
204999 pCsr->pStmt = 0;
205003 pCsr->iDb = sqlite3FindDbName(pTab->db, zDbase);
205004 if( pCsr->iDb<0 ){
205005 pCsr->iDb = 0;
205006 pCsr->isEof = 1;
205010 pCsr->iDb = pTab->iDb;
205018 pCsr->isAgg = sqlite3_value_double(argv[iArg++])!=0.0;
205020 pCsr->isAgg = 0;
205029 pTab->db->aDb[pCsr->iDb].zDbSName);
205040 rc = sqlite3_prepare_v2(pTab->db, zSql, -1, &pCsr->pStmt, 0);
205055 StatCursor *pCsr = (StatCursor *)pCursor;
205058 sqlite3_result_text(ctx, pCsr->zName, -1, SQLITE_TRANSIENT);
205061 if( !pCsr->isAgg ){
205062 sqlite3_result_text(ctx, pCsr->zPath, -1, SQLITE_TRANSIENT);
205066 if( pCsr->isAgg ){
205067 sqlite3_result_int64(ctx, pCsr->nPage);
205069 sqlite3_result_int64(ctx, pCsr->iPageno);
205073 if( !pCsr->isAgg ){
205074 sqlite3_result_text(ctx, pCsr->zPagetype, -1, SQLITE_STATIC);
205078 sqlite3_result_int(ctx, pCsr->nCell);
205081 sqlite3_result_int(ctx, pCsr->nPayload);
205084 sqlite3_result_int(ctx, pCsr->nUnused);
205087 sqlite3_result_int(ctx, pCsr->nMxPayload);
205090 if( !pCsr->isAgg ){
205091 sqlite3_result_int64(ctx, pCsr->iOffset);
205095 sqlite3_result_int(ctx, pCsr->szPage);
205099 int iDb = pCsr->iDb;
205104 sqlite3_result_int(ctx, pCsr->isAgg);
205112 StatCursor *pCsr = (StatCursor *)pCursor;
205113 *pRowid = pCsr->iPageno;
205320 DbpageCursor *pCsr;
205322 pCsr = (DbpageCursor *)sqlite3_malloc64(sizeof(DbpageCursor));
205323 if( pCsr==0 ){
205326 memset(pCsr, 0, sizeof(DbpageCursor));
205327 pCsr->base.pVtab = pVTab;
205328 pCsr->pgno = -1;
205331 *ppCursor = (sqlite3_vtab_cursor *)pCsr;
205339 DbpageCursor *pCsr = (DbpageCursor *)pCursor;
205340 if( pCsr->pPage1 ) sqlite3PagerUnrefPageOne(pCsr->pPage1);
205341 sqlite3_free(pCsr);
205350 DbpageCursor *pCsr = (DbpageCursor *)pCursor;
205351 pCsr->pgno++;
205356 DbpageCursor *pCsr = (DbpageCursor *)pCursor;
205357 return pCsr->pgno > pCsr->mxPgno;
205375 DbpageCursor *pCsr = (DbpageCursor *)pCursor;
205382 pCsr->pgno = 1;
205383 pCsr->mxPgno = 0;
205389 pCsr->iDb = sqlite3FindDbName(db, zSchema);
205390 if( pCsr->iDb<0 ) return SQLITE_OK;
205392 pCsr->iDb = 0;
205394 pBt = db->aDb[pCsr->iDb].pBt;
205396 pCsr->pPager = sqlite3BtreePager(pBt);
205397 pCsr->szPage = sqlite3BtreeGetPageSize(pBt);
205398 pCsr->mxPgno = sqlite3BtreeLastPage(pBt);
205401 pCsr->pgno = sqlite3_value_int(argv[idxNum>>1]);
205402 if( pCsr->pgno<1 || pCsr->pgno>pCsr->mxPgno ){
205403 pCsr->pgno = 1;
205404 pCsr->mxPgno = 0;
205406 pCsr->mxPgno = pCsr->pgno;
205409 assert( pCsr->pgno==1 );
205411 if( pCsr->pPage1 ) sqlite3PagerUnrefPageOne(pCsr->pPage1);
205412 rc = sqlite3PagerGet(pCsr->pPager, 1, &pCsr->pPage1, 0);
205421 DbpageCursor *pCsr = (DbpageCursor *)pCursor;
205425 sqlite3_result_int(ctx, pCsr->pgno);
205430 rc = sqlite3PagerGet(pCsr->pPager, pCsr->pgno, (DbPage**)&pDbPage, 0);
205432 sqlite3_result_blob(ctx, sqlite3PagerGetData(pDbPage), pCsr->szPage,
205440 sqlite3_result_text(ctx, db->aDb[pCsr->iDb].zDbSName, -1, SQLITE_STATIC);
205448 DbpageCursor *pCsr = (DbpageCursor *)pCursor;
205449 *pRowid = pCsr->pgno;
207672 u8 *pCsr = p->aRecord; /* Used to iterate through old.* values */
207679 int eType = *pCsr;
207692 sqlite3_int64 iVal = sessionGetI64(&pCsr[1]);
207707 int nHdr = 1 + sessionVarintGet(&pCsr[1], &n);
207712 && (n==0 || 0==memcmp(&pCsr[nHdr], sqlite3_column_blob(pStmt, i), n))
207727 sessionAppendBlob(pBuf, pCsr, nAdvance, &rc);
207741 pCsr += nAdvance;
211016 u8 *pCsr = aRec;
211017 sessionSkipRecord(&pCsr, pIter->nCol);
211021 pCsr, nRec-(pCsr-aRec),
226601 Fts5Cursor *pCsr; /* First in list of all open cursors */
226685 Fts5Cursor *pNext; /* Next cursor in Fts5Cursor.pCsr list */
226751 #define CsrFlagSet(pCsr, flag) ((pCsr)->csrflags |= (flag))
226752 #define CsrFlagClear(pCsr, flag) ((pCsr)->csrflags &= ~(flag))
226753 #define CsrFlagTest(pCsr, flag) ((pCsr)->csrflags & (flag))
227199 Fts5Cursor *pCsr;
227200 for(pCsr=pTab->pGlobal->pCsr; pCsr; pCsr=pCsr->pNext){
227201 if( pCsr->base.pVtab==(sqlite3_vtab*)pTab ) return SQLITE_OK;
227212 Fts5Cursor *pCsr = 0; /* New cursor object */
227219 pCsr = (Fts5Cursor*)sqlite3_malloc64(nByte);
227220 if( pCsr ){
227222 memset(pCsr, 0, (size_t)nByte);
227223 pCsr->aColumnSize = (int*)&pCsr[1];
227224 pCsr->pNext = pGlobal->pCsr;
227225 pGlobal->pCsr = pCsr;
227226 pCsr->iCsrId = ++pGlobal->iNextId;
227231 *ppCsr = (sqlite3_vtab_cursor*)pCsr;
227235 static int fts5StmtType(Fts5Cursor *pCsr){
227236 if( pCsr->ePlan==FTS5_PLAN_SCAN ){
227237 return (pCsr->bDesc) ? FTS5_STMT_SCAN_DESC : FTS5_STMT_SCAN_ASC;
227247 static void fts5CsrNewrow(Fts5Cursor *pCsr){
227248 CsrFlagSet(pCsr,
227256 static void fts5FreeCursorComponents(Fts5Cursor *pCsr){
227257 Fts5FullTable *pTab = (Fts5FullTable*)(pCsr->base.pVtab);
227261 sqlite3_free(pCsr->aInstIter);
227262 sqlite3_free(pCsr->aInst);
227263 if( pCsr->pStmt ){
227264 int eStmt = fts5StmtType(pCsr);
227265 sqlite3Fts5StorageStmtRelease(pTab->pStorage, eStmt, pCsr->pStmt);
227267 if( pCsr->pSorter ){
227268 Fts5Sorter *pSorter = pCsr->pSorter;
227273 if( pCsr->ePlan!=FTS5_PLAN_SOURCE ){
227274 sqlite3Fts5ExprFree(pCsr->pExpr);
227277 for(pData=pCsr->pAuxdata; pData; pData=pNext){
227283 sqlite3_finalize(pCsr->pRankArgStmt);
227284 sqlite3_free(pCsr->apRankArg);
227286 if( CsrFlagTest(pCsr, FTS5CSR_FREE_ZRANK) ){
227287 sqlite3_free(pCsr->zRank);
227288 sqlite3_free(pCsr->zRankArgs);
227292 memset(&pCsr->ePlan, 0, sizeof(Fts5Cursor) - ((u8*)&pCsr->ePlan - (u8*)pCsr));
227303 Fts5Cursor *pCsr = (Fts5Cursor*)pCursor;
227306 fts5FreeCursorComponents(pCsr);
227307 /* Remove the cursor from the Fts5Global.pCsr list */
227308 for(pp=&pTab->pGlobal->pCsr; (*pp)!=pCsr; pp=&(*pp)->pNext);
227309 *pp = pCsr->pNext;
227311 sqlite3_free(pCsr);
227316 static int fts5SorterNext(Fts5Cursor *pCsr){
227317 Fts5Sorter *pSorter = pCsr->pSorter;
227323 CsrFlagSet(pCsr, FTS5CSR_EOF);
227348 fts5CsrNewrow(pCsr);
227360 Fts5Cursor *pCsr;
227361 for(pCsr=pTab->pGlobal->pCsr; pCsr; pCsr=pCsr->pNext){
227362 if( pCsr->ePlan==FTS5_PLAN_MATCH
227363 && pCsr->base.pVtab==(sqlite3_vtab*)pTab
227365 CsrFlagSet(pCsr, FTS5CSR_REQUIRE_RESEEK);
227382 static int fts5CursorReseek(Fts5Cursor *pCsr, int *pbSkip){
227385 if( CsrFlagTest(pCsr, FTS5CSR_REQUIRE_RESEEK) ){
227386 Fts5FullTable *pTab = (Fts5FullTable*)(pCsr->base.pVtab);
227387 int bDesc = pCsr->bDesc;
227388 i64 iRowid = sqlite3Fts5ExprRowid(pCsr->pExpr);
227390 rc = sqlite3Fts5ExprFirst(pCsr->pExpr, pTab->p.pIndex, iRowid, bDesc);
227391 if( rc==SQLITE_OK && iRowid!=sqlite3Fts5ExprRowid(pCsr->pExpr) ){
227395 CsrFlagClear(pCsr, FTS5CSR_REQUIRE_RESEEK);
227396 fts5CsrNewrow(pCsr);
227397 if( sqlite3Fts5ExprEof(pCsr->pExpr) ){
227398 CsrFlagSet(pCsr, FTS5CSR_EOF);
227415 Fts5Cursor *pCsr = (Fts5Cursor*)pCursor;
227418 assert( (pCsr->ePlan<3)==
227419 (pCsr->ePlan==FTS5_PLAN_MATCH || pCsr->ePlan==FTS5_PLAN_SOURCE)
227421 assert( !CsrFlagTest(pCsr, FTS5CSR_EOF) );
227423 if( pCsr->ePlan<3 ){
227425 if( (rc = fts5CursorReseek(pCsr, &bSkip)) || bSkip ) return rc;
227426 rc = sqlite3Fts5ExprNext(pCsr->pExpr, pCsr->iLastRowid);
227427 CsrFlagSet(pCsr, sqlite3Fts5ExprEof(pCsr->pExpr));
227428 fts5CsrNewrow(pCsr);
227430 switch( pCsr->ePlan ){
227432 CsrFlagSet(pCsr, FTS5CSR_EOF);
227438 rc = fts5SorterNext(pCsr);
227445 rc = sqlite3_step(pCsr->pStmt);
227448 CsrFlagSet(pCsr, FTS5CSR_EOF);
227449 rc = sqlite3_reset(pCsr->pStmt);
227498 Fts5Cursor *pCsr,
227506 const char *zRank = pCsr->zRank;
227507 const char *zRankArgs = pCsr->zRankArgs;
227509 nPhrase = sqlite3Fts5ExprPhraseCount(pCsr->pExpr);
227531 pCsr->pSorter = pSorter;
227534 pTab->pSortCsr = pCsr;
227535 rc = fts5SorterNext(pCsr);
227542 pCsr->pSorter = 0;
227548 static int fts5CursorFirst(Fts5FullTable *pTab, Fts5Cursor *pCsr, int bDesc){
227550 Fts5Expr *pExpr = pCsr->pExpr;
227551 rc = sqlite3Fts5ExprFirst(pExpr, pTab->p.pIndex, pCsr->iFirstRowid, bDesc);
227553 CsrFlagSet(pCsr, FTS5CSR_EOF);
227555 fts5CsrNewrow(pCsr);
227567 Fts5Cursor *pCsr,
227578 pCsr->ePlan = FTS5_PLAN_SPECIAL;
227581 pCsr->iSpecial = sqlite3Fts5IndexReads(pTab->p.pIndex);
227584 pCsr->iSpecial = pCsr->iCsrId;
227612 static int fts5FindRankFunction(Fts5Cursor *pCsr){
227613 Fts5FullTable *pTab = (Fts5FullTable*)(pCsr->base.pVtab);
227617 const char *zRank = pCsr->zRank;
227618 const char *zRankArgs = pCsr->zRankArgs;
227627 assert( rc==SQLITE_OK || pCsr->pRankArgStmt==0 );
227631 pCsr->nRankArg = sqlite3_column_count(pStmt);
227632 nByte = sizeof(sqlite3_value*)*pCsr->nRankArg;
227633 pCsr->apRankArg = (sqlite3_value**)sqlite3Fts5MallocZero(&rc, nByte);
227636 for(i=0; i<pCsr->nRankArg; i++){
227637 pCsr->apRankArg[i] = sqlite3_column_value(pStmt, i);
227640 pCsr->pRankArgStmt = pStmt;
227658 pCsr->pRank = pAux;
227665 Fts5Cursor *pCsr,
227680 pCsr->zRank = zRank;
227681 pCsr->zRankArgs = zRankArgs;
227682 CsrFlagSet(pCsr, FTS5CSR_FREE_ZRANK);
227684 pCsr->base.pVtab->zErrMsg = sqlite3_mprintf(
227690 pCsr->zRank = (char*)pConfig->zRank;
227691 pCsr->zRankArgs = (char*)pConfig->zRankArgs;
227693 pCsr->zRank = (char*)FTS5_DEFAULT_RANK;
227694 pCsr->zRankArgs = 0;
227730 Fts5Cursor *pCsr = (Fts5Cursor*)pCursor;
227751 if( pCsr->ePlan ){
227752 fts5FreeCursorComponents(pCsr);
227753 memset(&pCsr->ePlan, 0, sizeof(Fts5Cursor) - ((u8*)&pCsr->ePlan-(u8*)pCsr));
227756 assert( pCsr->pStmt==0 );
227757 assert( pCsr->pExpr==0 );
227758 assert( pCsr->csrflags==0 );
227759 assert( pCsr->pRank==0 );
227760 assert( pCsr->zRank==0 );
227761 assert( pCsr->zRankArgs==0 );
227786 rc = fts5SpecialMatch(pTab, pCsr, &zText[1]);
227792 rc = sqlite3Fts5ExprAnd(&pCsr->pExpr, pExpr);
227813 rc = sqlite3Fts5ExprAnd(&pCsr->pExpr, pExpr);
227831 pCsr->bDesc = bDesc = ((idxNum & FTS5_BI_ORDER_DESC) ? 1 : 0);
227841 pCsr->iFirstRowid = fts5GetRowidLimit(pRowidLe, LARGEST_INT64);
227842 pCsr->iLastRowid = fts5GetRowidLimit(pRowidGe, SMALLEST_INT64);
227844 pCsr->iLastRowid = fts5GetRowidLimit(pRowidLe, LARGEST_INT64);
227845 pCsr->iFirstRowid = fts5GetRowidLimit(pRowidGe, SMALLEST_INT64);
227857 assert( pCsr->iLastRowid==LARGEST_INT64 );
227858 assert( pCsr->iFirstRowid==SMALLEST_INT64 );
227860 pCsr->iLastRowid = pTab->pSortCsr->iFirstRowid;
227861 pCsr->iFirstRowid = pTab->pSortCsr->iLastRowid;
227863 pCsr->iLastRowid = pTab->pSortCsr->iLastRowid;
227864 pCsr->iFirstRowid = pTab->pSortCsr->iFirstRowid;
227866 pCsr->ePlan = FTS5_PLAN_SOURCE;
227867 pCsr->pExpr = pTab->pSortCsr->pExpr;
227868 rc = fts5CursorFirst(pTab, pCsr, bDesc);
227869 }else if( pCsr->pExpr ){
227870 rc = fts5CursorParseRank(pConfig, pCsr, pRank);
227873 pCsr->ePlan = FTS5_PLAN_SORTED_MATCH;
227874 rc = fts5CursorFirstSorted(pTab, pCsr, bDesc);
227876 pCsr->ePlan = FTS5_PLAN_MATCH;
227877 rc = fts5CursorFirst(pTab, pCsr, bDesc);
227888 pCsr->ePlan = (pRowidEq ? FTS5_PLAN_ROWID : FTS5_PLAN_SCAN);
227890 pTab->pStorage, fts5StmtType(pCsr), &pCsr->pStmt, &pTab->p.base.zErrMsg
227893 if( pCsr->ePlan==FTS5_PLAN_ROWID ){
227894 sqlite3_bind_value(pCsr->pStmt, 1, pRowidEq);
227896 sqlite3_bind_int64(pCsr->pStmt, 1, pCsr->iFirstRowid);
227897 sqlite3_bind_int64(pCsr->pStmt, 2, pCsr->iLastRowid);
227914 Fts5Cursor *pCsr = (Fts5Cursor*)pCursor;
227915 return (CsrFlagTest(pCsr, FTS5CSR_EOF) ? 1 : 0);
227921 static i64 fts5CursorRowid(Fts5Cursor *pCsr){
227922 assert( pCsr->ePlan==FTS5_PLAN_MATCH
227923 || pCsr->ePlan==FTS5_PLAN_SORTED_MATCH
227924 || pCsr->ePlan==FTS5_PLAN_SOURCE
227926 if( pCsr->pSorter ){
227927 return pCsr->pSorter->iRowid;
227929 return sqlite3Fts5ExprRowid(pCsr->pExpr);
227940 Fts5Cursor *pCsr = (Fts5Cursor*)pCursor;
227941 int ePlan = pCsr->ePlan;
227943 assert( CsrFlagTest(pCsr, FTS5CSR_EOF)==0 );
227952 *pRowid = fts5CursorRowid(pCsr);
227956 *pRowid = sqlite3_column_int64(pCsr->pStmt, 0);
227970 static int fts5SeekCursor(Fts5Cursor *pCsr, int bErrormsg){
227974 if( pCsr->pStmt==0 ){
227975 Fts5FullTable *pTab = (Fts5FullTable*)(pCsr->base.pVtab);
227976 int eStmt = fts5StmtType(pCsr);
227978 pTab->pStorage, eStmt, &pCsr->pStmt, (bErrormsg?&pTab->p.base.zErrMsg:0)
227981 assert( CsrFlagTest(pCsr, FTS5CSR_REQUIRE_CONTENT) );
227984 if( rc==SQLITE_OK && CsrFlagTest(pCsr, FTS5CSR_REQUIRE_CONTENT) ){
227985 Fts5Table *pTab = (Fts5Table*)(pCsr->base.pVtab);
227986 assert( pCsr->pExpr );
227987 sqlite3_reset(pCsr->pStmt);
227988 sqlite3_bind_int64(pCsr->pStmt, 1, fts5CursorRowid(pCsr));
227990 rc = sqlite3_step(pCsr->pStmt);
227994 CsrFlagClear(pCsr, FTS5CSR_REQUIRE_CONTENT);
227996 rc = sqlite3_reset(pCsr->pStmt);
228303 Fts5Cursor *pCsr = (Fts5Cursor*)pCtx;
228304 return pCsr->pAux->pUserData;
228308 Fts5Cursor *pCsr = (Fts5Cursor*)pCtx;
228309 return ((Fts5Table*)(pCsr->base.pVtab))->pConfig->nCol;
228317 Fts5Cursor *pCsr = (Fts5Cursor*)pCtx;
228318 Fts5FullTable *pTab = (Fts5FullTable*)(pCsr->base.pVtab);
228323 Fts5Cursor *pCsr = (Fts5Cursor*)pCtx;
228324 Fts5FullTable *pTab = (Fts5FullTable*)(pCsr->base.pVtab);
228334 Fts5Cursor *pCsr = (Fts5Cursor*)pCtx;
228335 Fts5Table *pTab = (Fts5Table*)(pCsr->base.pVtab);
228342 Fts5Cursor *pCsr = (Fts5Cursor*)pCtx;
228343 return sqlite3Fts5ExprPhraseCount(pCsr->pExpr);
228347 Fts5Cursor *pCsr = (Fts5Cursor*)pCtx;
228348 return sqlite3Fts5ExprPhraseSize(pCsr->pExpr, iPhrase);
228358 Fts5Cursor *pCsr = (Fts5Cursor*)pCtx;
228359 if( fts5IsContentless((Fts5FullTable*)(pCsr->base.pVtab))
228360 || pCsr->ePlan==FTS5_PLAN_SPECIAL
228365 rc = fts5SeekCursor(pCsr, 0);
228367 *pz = (const char*)sqlite3_column_text(pCsr->pStmt, iCol+1);
228368 *pn = sqlite3_column_bytes(pCsr->pStmt, iCol+1);
228375 Fts5Cursor *pCsr,
228380 Fts5Config *pConfig = ((Fts5Table*)(pCsr->base.pVtab))->pConfig;
228382 int bLive = (pCsr->pSorter==0);
228384 if( CsrFlagTest(pCsr, FTS5CSR_REQUIRE_POSLIST) ){
228389 aPopulator = sqlite3Fts5ExprClearPoslists(pCsr->pExpr, bLive);
228393 rc = fts5ApiColumnText((Fts5Context*)pCsr, i, &z, &n);
228396 pConfig, pCsr->pExpr, aPopulator, i, z, n
228402 if( pCsr->pSorter ){
228403 sqlite3Fts5ExprCheckPoslists(pCsr->pExpr, pCsr->pSorter->iRowid);
228406 CsrFlagClear(pCsr, FTS5CSR_REQUIRE_POSLIST);
228409 if( pCsr->pSorter && pConfig->eDetail==FTS5_DETAIL_FULL ){
228410 Fts5Sorter *pSorter = pCsr->pSorter;
228415 *pn = sqlite3Fts5ExprPoslist(pCsr->pExpr, iPhrase, pa);
228426 static int fts5CacheInstArray(Fts5Cursor *pCsr){
228430 int nCol = ((Fts5Table*)pCsr->base.pVtab)->pConfig->nCol;
228432 nIter = sqlite3Fts5ExprPhraseCount(pCsr->pExpr);
228433 if( pCsr->aInstIter==0 ){
228435 pCsr->aInstIter = (Fts5PoslistReader*)sqlite3Fts5MallocZero(&rc, nByte);
228437 aIter = pCsr->aInstIter;
228447 rc = fts5CsrPoslist(pCsr, i, &a, &n);
228467 if( nInst>=pCsr->nInstAlloc ){
228468 pCsr->nInstAlloc = pCsr->nInstAlloc ? pCsr->nInstAlloc*2 : 32;
228470 pCsr->aInst, pCsr->nInstAlloc*sizeof(int)*3
228473 pCsr->aInst = aInst;
228480 aInst = &pCsr->aInst[3 * (nInst-1)];
228492 pCsr->nInstCount = nInst;
228493 CsrFlagClear(pCsr, FTS5CSR_REQUIRE_INST);
228499 Fts5Cursor *pCsr = (Fts5Cursor*)pCtx;
228501 if( CsrFlagTest(pCsr, FTS5CSR_REQUIRE_INST)==0
228502 || SQLITE_OK==(rc = fts5CacheInstArray(pCsr)) ){
228503 *pnInst = pCsr->nInstCount;
228515 Fts5Cursor *pCsr = (Fts5Cursor*)pCtx;
228517 if( CsrFlagTest(pCsr, FTS5CSR_REQUIRE_INST)==0
228518 || SQLITE_OK==(rc = fts5CacheInstArray(pCsr))
228520 if( iIdx<0 || iIdx>=pCsr->nInstCount ){
228523 }else if( fts5IsOffsetless((Fts5Table*)pCsr->base.pVtab) ){
228524 *piPhrase = pCsr->aInst[iIdx*3];
228525 *piCol = pCsr->aInst[iIdx*3 + 2];
228529 *piPhrase = pCsr->aInst[iIdx*3];
228530 *piCol = pCsr->aInst[iIdx*3 + 1];
228531 *piOff = pCsr->aInst[iIdx*3 + 2];
228559 Fts5Cursor *pCsr = (Fts5Cursor*)pCtx;
228560 Fts5FullTable *pTab = (Fts5FullTable*)(pCsr->base.pVtab);
228564 if( CsrFlagTest(pCsr, FTS5CSR_REQUIRE_DOCSIZE) ){
228566 i64 iRowid = fts5CursorRowid(pCsr);
228567 rc = sqlite3Fts5StorageDocsize(pTab->pStorage, iRowid, pCsr->aColumnSize);
228572 pCsr->aColumnSize[i] = -1;
228580 void *p = (void*)(&pCsr->aColumnSize[i]);
228581 pCsr->aColumnSize[i] = 0;
228591 CsrFlagClear(pCsr, FTS5CSR_REQUIRE_DOCSIZE);
228597 *pnToken += pCsr->aColumnSize[i];
228600 *pnToken = pCsr->aColumnSize[iCol];
228616 Fts5Cursor *pCsr = (Fts5Cursor*)pCtx;
228621 for(pData=pCsr->pAuxdata; pData; pData=pData->pNext){
228622 if( pData->pAux==pCsr->pAux ) break;
228636 pData->pAux = pCsr->pAux;
228637 pData->pNext = pCsr->pAuxdata;
228638 pCsr->pAuxdata = pData;
228647 Fts5Cursor *pCsr = (Fts5Cursor*)pCtx;
228651 for(pData=pCsr->pAuxdata; pData; pData=pData->pNext){
228652 if( pData->pAux==pCsr->pAux ) break;
228694 Fts5Cursor *pCsr = (Fts5Cursor*)pCtx;
228696 int rc = fts5CsrPoslist(pCsr, iPhrase, &pIter->a, &n);
228712 Fts5Cursor *pCsr = (Fts5Cursor*)pCtx;
228713 Fts5Config *pConfig = ((Fts5Table*)(pCsr->base.pVtab))->pConfig;
228744 Fts5Cursor *pCsr = (Fts5Cursor*)pCtx;
228745 Fts5Config *pConfig = ((Fts5Table*)(pCsr->base.pVtab))->pConfig;
228748 Fts5Sorter *pSorter = pCsr->pSorter;
228755 rc = sqlite3Fts5ExprPhraseCollist(pCsr->pExpr, iPhrase, &pIter->a, &n);
228765 rc = fts5CsrPoslist(pCsr, iPhrase, &pIter->a, &n);
228819 Fts5Cursor *pCsr = (Fts5Cursor*)pCtx;
228820 Fts5FullTable *pTab = (Fts5FullTable*)(pCsr->base.pVtab);
228824 rc = fts5OpenMethod(pCsr->base.pVtab, (sqlite3_vtab_cursor**)&pNew);
228830 rc = sqlite3Fts5ExprClonePhrase(pCsr->pExpr, iPhrase, &pNew->pExpr);
228852 Fts5Cursor *pCsr,
228857 assert( pCsr->pAux==0 );
228858 pCsr->pAux = pAux;
228859 pAux->xFunc(&sFts5Api, (Fts5Context*)pCsr, context, argc, argv);
228860 pCsr->pAux = 0;
228864 Fts5Cursor *pCsr;
228865 for(pCsr=pGlobal->pCsr; pCsr; pCsr=pCsr->pNext){
228866 if( pCsr->iCsrId==iCsrId ) break;
228868 return pCsr;
228878 Fts5Cursor *pCsr;
228885 pCsr = fts5CursorFromCsrid(pAux->pGlobal, iCsrId);
228886 if( pCsr==0 || pCsr->ePlan==0 ){
228891 fts5ApiInvoke(pAux, pCsr, context, argc-1, &argv[1]);
228904 Fts5Cursor *pCsr;
228905 pCsr = fts5CursorFromCsrid(pGlobal, iCsrId);
228906 if( pCsr ){
228907 return (Fts5Table*)pCsr->base.pVtab;
228914 ** cursor pCsr via sqlite3_result_blob(). A position-list blob contains
228916 ** cursor pCsr.
228927 static int fts5PoslistBlob(sqlite3_context *pCtx, Fts5Cursor *pCsr){
228930 int nPhrase = sqlite3Fts5ExprPhraseCount(pCsr->pExpr);
228934 switch( ((Fts5Table*)(pCsr->base.pVtab))->pConfig->eDetail ){
228940 int nByte = sqlite3Fts5ExprPoslist(pCsr->pExpr, i, &dummy);
228948 nPoslist = sqlite3Fts5ExprPoslist(pCsr->pExpr, i, &pPoslist);
228959 rc = sqlite3Fts5ExprPhraseCollist(pCsr->pExpr, i, &dummy, &nByte);
228967 rc = sqlite3Fts5ExprPhraseCollist(pCsr->pExpr, i, &pPoslist, &nPoslist);
228991 Fts5Cursor *pCsr = (Fts5Cursor*)pCursor;
228994 assert( CsrFlagTest(pCsr, FTS5CSR_EOF)==0 );
228996 if( pCsr->ePlan==FTS5_PLAN_SPECIAL ){
228998 sqlite3_result_int64(pCtx, pCsr->iSpecial);
229007 sqlite3_result_int64(pCtx, pCsr->iCsrId);
229011 if( pCsr->ePlan==FTS5_PLAN_SOURCE ){
229012 fts5PoslistBlob(pCtx, pCsr);
229014 pCsr->ePlan==FTS5_PLAN_MATCH
229015 || pCsr->ePlan==FTS5_PLAN_SORTED_MATCH
229017 if( pCsr->pRank || SQLITE_OK==(rc = fts5FindRankFunction(pCsr)) ){
229018 fts5ApiInvoke(pCsr->pRank, pCsr, pCtx, pCsr->nRankArg, pCsr->apRankArg);
229023 rc = fts5SeekCursor(pCsr, 1);
229025 sqlite3_result_value(pCtx, sqlite3_column_value(pCsr->pStmt, iCol+1));
233473 Fts5VocabCursor *pCsr = 0;
233519 pCsr = (Fts5VocabCursor*)sqlite3Fts5MallocZero(&rc, nByte);
233522 if( pCsr ){
233523 pCsr->pFts5 = pFts5;
233524 pCsr->pStmt = pStmt;
233525 pCsr->aCnt = (i64*)&pCsr[1];
233526 pCsr->aDoc = &pCsr->aCnt[pFts5->pConfig->nCol];
233531 *ppCsr = (sqlite3_vtab_cursor*)pCsr;
233535 static void fts5VocabResetCursor(Fts5VocabCursor *pCsr){
233536 pCsr->rowid = 0;
233537 sqlite3Fts5IterClose(pCsr->pIter);
233538 pCsr->pIter = 0;
233539 sqlite3_free(pCsr->zLeTerm);
233540 pCsr->nLeTerm = -1;
233541 pCsr->zLeTerm = 0;
233542 pCsr->bEof = 0;
233550 Fts5VocabCursor *pCsr = (Fts5VocabCursor*)pCursor;
233551 fts5VocabResetCursor(pCsr);
233552 sqlite3Fts5BufferFree(&pCsr->term);
233553 sqlite3_finalize(pCsr->pStmt);
233554 sqlite3_free(pCsr);
233558 static int fts5VocabInstanceNewTerm(Fts5VocabCursor *pCsr){
233561 if( sqlite3Fts5IterEof(pCsr->pIter) ){
233562 pCsr->bEof = 1;
233566 zTerm = sqlite3Fts5IterTerm(pCsr->pIter, &nTerm);
233567 if( pCsr->nLeTerm>=0 ){
233568 int nCmp = MIN(nTerm, pCsr->nLeTerm);
233569 int bCmp = memcmp(pCsr->zLeTerm, zTerm, nCmp);
233570 if( bCmp<0 || (bCmp==0 && pCsr->nLeTerm<nTerm) ){
233571 pCsr->bEof = 1;
233575 sqlite3Fts5BufferSet(&rc, &pCsr->term, nTerm, (const u8*)zTerm);
233580 static int fts5VocabInstanceNext(Fts5VocabCursor *pCsr){
233581 int eDetail = pCsr->pFts5->pConfig->eDetail;
233583 Fts5IndexIter *pIter = pCsr->pIter;
233584 i64 *pp = &pCsr->iInstPos;
233585 int *po = &pCsr->iInstOff;
233588 assert( pCsr->bEof==0 );
233592 pCsr->iInstPos = 0;
233593 pCsr->iInstOff = 0;
233595 rc = sqlite3Fts5IterNextScan(pCsr->pIter);
233597 rc = fts5VocabInstanceNewTerm(pCsr);
233598 if( pCsr->bEof || eDetail==FTS5_DETAIL_NONE ) break;
233601 pCsr->bEof = 1;
233613 Fts5VocabCursor *pCsr = (Fts5VocabCursor*)pCursor;
233616 int nCol = pCsr->pFts5->pConfig->nCol;
233618 pCsr->rowid++;
233621 return fts5VocabInstanceNext(pCsr);
233625 for(pCsr->iCol++; pCsr->iCol<nCol; pCsr->iCol++){
233626 if( pCsr->aDoc[pCsr->iCol] ) break;
233630 if( pTab->eType!=FTS5_VOCAB_COL || pCsr->iCol>=nCol ){
233631 if( sqlite3Fts5IterEof(pCsr->pIter) ){
233632 pCsr->bEof = 1;
233637 zTerm = sqlite3Fts5IterTerm(pCsr->pIter, &nTerm);
233639 if( pCsr->nLeTerm>=0 ){
233640 int nCmp = MIN(nTerm, pCsr->nLeTerm);
233641 int bCmp = memcmp(pCsr->zLeTerm, zTerm, nCmp);
233642 if( bCmp<0 || (bCmp==0 && pCsr->nLeTerm<nTerm) ){
233643 pCsr->bEof = 1;
233648 sqlite3Fts5BufferSet(&rc, &pCsr->term, nTerm, (const u8*)zTerm);
233649 memset(pCsr->aCnt, 0, nCol * sizeof(i64));
233650 memset(pCsr->aDoc, 0, nCol * sizeof(i64));
233651 pCsr->iCol = 0;
233655 int eDetail = pCsr->pFts5->pConfig->eDetail;
233660 pPos = pCsr->pIter->pData;
233661 nPos = pCsr->pIter->nData;
233667 pCsr->aCnt[0]++;
233670 pCsr->aDoc[0]++;
233683 pCsr->aDoc[ii]++;
233686 pCsr->aCnt[ii]++;
233695 pCsr->aDoc[iPos]++;
233699 pCsr->aDoc[0]++;
233709 rc = sqlite3Fts5IterNextScan(pCsr->pIter);
233714 zTerm = sqlite3Fts5IterTerm(pCsr->pIter, &nTerm);
233715 if( nTerm!=pCsr->term.n
233716 || (nTerm>0 && memcmp(zTerm, pCsr->term.p, nTerm))
233720 if( sqlite3Fts5IterEof(pCsr->pIter) ) break;
233726 if( rc==SQLITE_OK && pCsr->bEof==0 && pTab->eType==FTS5_VOCAB_COL ){
233727 for(/* noop */; pCsr->iCol<nCol && pCsr->aDoc[pCsr->iCol]==0; pCsr->iCol++);
233728 if( pCsr->iCol==nCol ){
233746 Fts5VocabCursor *pCsr = (Fts5VocabCursor*)pCursor;
233761 fts5VocabResetCursor(pCsr);
233778 pCsr->nLeTerm = sqlite3_value_bytes(pLe);
233779 pCsr->zLeTerm = sqlite3_malloc(pCsr->nLeTerm+1);
233780 if( pCsr->zLeTerm==0 ){
233783 memcpy(pCsr->zLeTerm, zCopy, pCsr->nLeTerm+1);
233789 Fts5Index *pIndex = pCsr->pFts5->pIndex;
233790 rc = sqlite3Fts5IndexQuery(pIndex, zTerm, nTerm, f, 0, &pCsr->pIter);
233793 rc = fts5VocabInstanceNewTerm(pCsr);
233795 if( rc==SQLITE_OK && !pCsr->bEof
233797 || pCsr->pFts5->pConfig->eDetail!=FTS5_DETAIL_NONE)
233810 Fts5VocabCursor *pCsr = (Fts5VocabCursor*)pCursor;
233811 return pCsr->bEof;
233819 Fts5VocabCursor *pCsr = (Fts5VocabCursor*)pCursor;
233820 int eDetail = pCsr->pFts5->pConfig->eDetail;
233826 pCtx, (const char*)pCsr->term.p, pCsr->term.n, SQLITE_TRANSIENT
233832 const char *z = pCsr->pFts5->pConfig->azCol[pCsr->iCol];
233836 iVal = pCsr->aDoc[pCsr->iCol];
233838 iVal = pCsr->aCnt[pCsr->iCol];
233843 iVal = pCsr->aDoc[0];
233845 iVal = pCsr->aCnt[0];
233851 sqlite3_result_int64(pCtx, pCsr->pIter->iRowid);
233856 ii = FTS5_POS2COLUMN(pCsr->iInstPos);
233858 ii = (int)pCsr->iInstPos;
233860 if( ii>=0 && ii<pCsr->pFts5->pConfig->nCol ){
233861 const char *z = pCsr->pFts5->pConfig->azCol[ii];
233869 int ii = FTS5_POS2OFFSET(pCsr->iInstPos);
233890 Fts5VocabCursor *pCsr = (Fts5VocabCursor*)pCursor;
233891 *pRowid = pCsr->rowid;