Lines Matching refs:pTerm
105282 struct ExprList_item *pTerm = pGB->a;
105284 for(j=0; j<n; j++, pTerm++){
105285 Expr *pE = pTerm->pExpr;
131103 Expr *pTerm = pItem->pExpr;
131106 if( pTerm->flags & EP_Collate ){
131107 pColl = sqlite3ExprCollSeq(pParse, pTerm);
131112 sqlite3ExprAddCollateString(pParse, pTerm, pColl->zName);
134530 Expr *pTerm;
134538 pTerm = pPrior ? sqlite3ExprDup(db, pCount, 0) : pCount;
134539 pSub->pEList = sqlite3ExprListAppend(pParse, 0, pTerm);
134540 pTerm = sqlite3PExpr(pParse, TK_SELECT, 0, 0);
134541 sqlite3PExprAddSelect(pParse, pTerm, pSub);
134543 pExpr = pTerm;
134545 pExpr = sqlite3PExpr(pParse, TK_PLUS, pTerm, pExpr);
138209 Expr *pTerm; /* One term of the conflict-target clause */
138236 && (pTerm = pTarget->a[0].pExpr)->op==TK_COLUMN
138237 && pTerm->iColumn==XN_ROWID
140639 SQLITE_PRIVATE void sqlite3WhereTermPrint(WhereTerm *pTerm, int iTerm);
141030 static void disableTerm(WhereLevel *pLevel, WhereTerm *pTerm){
141032 assert( pTerm!=0 );
141033 while( (pTerm->wtFlags & TERM_CODED)==0
141034 && (pLevel->iLeftJoin==0 || ExprHasProperty(pTerm->pExpr, EP_FromJoin))
141035 && (pLevel->notReady & pTerm->prereqAll)==0
141037 if( nLoop && (pTerm->wtFlags & TERM_LIKE)!=0 ){
141038 pTerm->wtFlags |= TERM_LIKECOND;
141040 pTerm->wtFlags |= TERM_CODED;
141042 if( pTerm->iParent<0 ) break;
141043 pTerm = &pTerm->pWC->a[pTerm->iParent];
141044 assert( pTerm!=0 );
141045 pTerm->nChild--;
141046 if( pTerm->nChild!=0 ) break;
141229 WhereTerm *pTerm, /* The term of the WHERE clause to be coded */
141235 Expr *pX = pTerm->pExpr;
141239 assert( pLevel->pWLoop->aLTerm[iEq]==pTerm );
141269 disableTerm(pLevel, pTerm);
141288 pTerm->pExpr->iTable = iTab;
141291 pX = pTerm->pExpr;
141349 disableTerm(pLevel, pTerm);
141409 WhereTerm *pTerm; /* A single constraint term */
141457 pTerm = pLoop->aLTerm[j];
141458 assert( pTerm!=0 );
141461 testcase( (pTerm->wtFlags & TERM_CODED)!=0 );
141462 testcase( pTerm->wtFlags & TERM_VIRTUAL );
141463 r1 = codeEqualityTerm(pParse, pTerm, pLevel, j, bRev, regBase+j);
141472 if( pTerm->eOperator & WO_IN ){
141473 if( pTerm->pExpr->flags & EP_xIsSelect ){
141480 }else if( (pTerm->eOperator & WO_ISNULL)==0 ){
141481 Expr *pRight = pTerm->pExpr->pRight;
141482 if( (pTerm->wtFlags & TERM_IS)==0 && sqlite3ExprCanBeNull(pRight) ){
141521 WhereTerm *pTerm /* The upper or lower bound just coded */
141523 if( pTerm->wtFlags & TERM_LIKEOPT ){
141529 || pTerm->pWC->pWInfo->pParse->db->mallocFailed );
141661 WhereTerm *pTerm;
141677 pTerm = &pWC->a[i];
141678 if( pTerm->wtFlags & (TERM_VIRTUAL|TERM_CODED) ) continue;
141679 if( pTerm->prereqAll & pLevel->notReady ) continue;
141704 Expr *pExpr = pTerm->pExpr;
141710 sqlite3WalkExpr(&sWalker, pTerm->pExpr);
141714 if( ExprHasProperty(pTerm->pExpr, EP_FromJoin) ) continue;
141720 if( pLoop->u.btree.nEq==0 && pTerm!=pEndRange ){
141721 for(j=0; j<pLoop->nLTerm && pLoop->aLTerm[j]!=pTerm; j++){}
141726 if( sqlite3ExprContainsSubquery(pTerm->pExpr) ) continue;
141733 sqlite3WalkExpr(&sWalker, pTerm->pExpr);
141738 pExpr = sqlite3ExprAnd(pParse, pExpr, sqlite3ExprDup(db, pTerm->pExpr, 0));
141989 WhereTerm *pTerm;
141994 for(i=0, pTerm=pWC->a; i<pWC->nTerm; i++, pTerm++){
141996 if( pTerm->wtFlags & TERM_CODED ) continue;
141997 pExpr = pTerm->pExpr;
141999 pTerm->wtFlags |= TERM_CODED;
142022 WhereTerm *pTerm; /* A WHERE clause term */
142112 pTerm = pLoop->aLTerm[j];
142113 if( NEVER(pTerm==0) ) continue;
142114 if( pTerm->eOperator & WO_IN ){
142115 codeEqualityTerm(pParse, pTerm, pLevel, j, bRev, iTarget);
142118 Expr *pRight = pTerm->pExpr->pRight;
142134 pTerm = pLoop->aLTerm[j];
142135 if( (pTerm->eOperator & WO_IN)!=0 ) iIn--;
142137 disableTerm(pLevel, pTerm);
142138 }else if( (pTerm->eOperator & WO_IN)!=0
142139 && sqlite3ExprVectorSize(pTerm->pExpr->pLeft)==1
142165 pCompare->pLeft = pTerm->pExpr->pLeft;
142198 pTerm = pLoop->aLTerm[0];
142199 assert( pTerm!=0 );
142200 assert( pTerm->pExpr!=0 );
142201 testcase( pTerm->wtFlags & TERM_VIRTUAL );
142203 iRowidReg = codeEqualityTerm(pParse, pTerm, pLevel, 0, bRev, iReleaseReg);
142209 if( (pTerm->prereqAll & pLevel->notReady)==0 ){
142210 pTerm->wtFlags |= TERM_CODED;
142228 pTerm = pStart;
142230 pEnd = pTerm;
142787 pTerm = pLoop->aLTerm[0];
142788 assert( pTerm!=0 );
142789 assert( pTerm->eOperator & WO_OR );
142790 assert( (pTerm->wtFlags & TERM_ORINFO)!=0 );
142791 pOrWc = &pTerm->u.pOrInfo->wc;
142861 if( &pWC->a[iTerm] == pTerm ) continue;
143020 if( !untestedTerms ) disableTerm(pLevel, pTerm);
143067 for(pTerm=pWC->a, j=pWC->nTerm; j>0; j--, pTerm++){
143070 testcase( pTerm->wtFlags & TERM_VIRTUAL );
143071 testcase( pTerm->wtFlags & TERM_CODED );
143072 if( pTerm->wtFlags & (TERM_VIRTUAL|TERM_CODED) ) continue;
143073 if( (pTerm->prereqAll & pLevel->notReady)!=0 ){
143079 pE = pTerm->pExpr;
143089 if( iLoop<3 && (pTerm->wtFlags & TERM_VARSELECT) ){
143094 if( (pTerm->wtFlags & TERM_LIKECOND)!=0 ){
143114 pWC->nTerm-j, pTerm, iLoop));
143118 sqlite3WhereTermPrint(pTerm, pWC->nTerm-j);
143123 pTerm->wtFlags |= TERM_CODED;
143136 for(pTerm=pWC->a, j=pWC->nTerm; j>0; j--, pTerm++){
143139 if( pTerm->wtFlags & (TERM_VIRTUAL|TERM_CODED) ) continue;
143140 if( (pTerm->eOperator & (WO_EQ|WO_IS))==0 ) continue;
143141 if( (pTerm->eOperator & WO_EQUIV)==0 ) continue;
143142 if( pTerm->leftCursor!=iCur ) continue;
143144 pE = pTerm->pExpr;
143148 sqlite3WhereTermPrint(pTerm, pWC->nTerm-j);
143152 assert( (pTerm->prereqRight & pLevel->notReady)!=0 );
143153 pAlt = sqlite3WhereFindTerm(pWC, iCur, pTerm->u.leftColumn, notReady,
143179 for(pTerm=pWC->a, j=0; j<pWC->nTerm; j++, pTerm++){
143180 testcase( pTerm->wtFlags & TERM_VIRTUAL );
143181 testcase( pTerm->wtFlags & TERM_CODED );
143182 if( pTerm->wtFlags & (TERM_VIRTUAL|TERM_CODED) ) continue;
143183 if( (pTerm->prereqAll & pLevel->notReady)!=0 ){
143187 assert( pTerm->pExpr );
143188 sqlite3ExprIfFalse(pParse, pTerm->pExpr, addrCont, SQLITE_JUMPIFNULL);
143189 pTerm->wtFlags |= TERM_CODED;
143269 WhereTerm *pTerm;
143289 pTerm = &pWC->a[idx = pWC->nTerm++];
143291 pTerm->truthProb = sqlite3LogEst(p->iTable) - 270;
143293 pTerm->truthProb = 1;
143295 pTerm->pExpr = sqlite3ExprSkipCollateAndLikely(p);
143296 pTerm->wtFlags = wtFlags;
143297 pTerm->pWC = pWC;
143298 pTerm->iParent = -1;
143299 memset(&pTerm->eOperator, 0,
143680 static WhereTerm *whereNthSubterm(WhereTerm *pTerm, int N){
143681 if( pTerm->eOperator!=WO_AND ){
143682 return N==0 ? pTerm : 0;
143684 if( N<pTerm->u.pAndInfo->wc.nTerm ){
143685 return &pTerm->u.pAndInfo->wc.a[N];
143844 WhereTerm *pTerm = &pWC->a[idxTerm]; /* The term to be analyzed */
143845 Expr *pExpr = pTerm->pExpr; /* The expression of the term */
143858 assert( (pTerm->wtFlags & (TERM_DYNAMIC|TERM_ORINFO|TERM_ANDINFO))==0 );
143860 pTerm->u.pOrInfo = pOrInfo = sqlite3DbMallocZero(db, sizeof(*pOrInfo));
143862 pTerm->wtFlags |= TERM_ORINFO;
143933 pTerm->eOperator = WO_OR;
143936 pTerm->eOperator = WO_OR;
144242 WhereTerm *pTerm; /* The term to be analyzed */
144260 pTerm = &pWC->a[idxTerm];
144262 pExpr = pTerm->pExpr;
144270 pTerm->prereqRight = exprSelectUsage(pMaskSet, pExpr->x.pSelect);
144272 pTerm->prereqRight = sqlite3WhereExprListUsage(pMaskSet, pExpr->x.pList);
144275 pTerm->prereqRight = 0;
144277 pTerm->prereqRight = sqlite3WhereExprUsage(pMaskSet, pExpr->pRight);
144281 if( pMaskSet->bVarSelect ) pTerm->wtFlags |= TERM_VARSELECT;
144292 pTerm->prereqAll = prereqAll;
144293 pTerm->leftCursor = -1;
144294 pTerm->iParent = -1;
144295 pTerm->eOperator = 0;
144300 u16 opMask = (pTerm->prereqRight & prereqLeft)==0 ? WO_ALL : WO_EQUIV;
144302 if( pTerm->iField>0 ){
144305 pLeft = pLeft->x.pList->a[pTerm->iField-1].pExpr;
144309 pTerm->leftCursor = aiCurCol[0];
144310 pTerm->u.leftColumn = aiCurCol[1];
144311 pTerm->eOperator = operatorMask(op) & opMask;
144313 if( op==TK_IS ) pTerm->wtFlags |= TERM_IS;
144315 && exprMightBeIndexed(pSrc, pTerm->prereqRight, aiCurCol, pRight, op)
144320 assert( pTerm->iField==0 );
144321 if( pTerm->leftCursor>=0 ){
144333 pTerm = &pWC->a[idxTerm];
144334 pTerm->wtFlags |= TERM_COPIED;
144337 pTerm->eOperator |= WO_EQUIV;
144342 pNew = pTerm;
144386 pTerm = &pWC->a[idxTerm];
144399 pTerm = &pWC->a[idxTerm];
144439 pTerm->wtFlags |= TERM_LIKE;
144479 pTerm = &pWC->a[idxTerm];
144524 pTerm = &pWC->a[idxTerm];
144525 pTerm->wtFlags |= TERM_COPIED;
144526 pNewTerm->prereqAll = pTerm->prereqAll;
144559 pTerm = &pWC->a[idxTerm];
144560 pTerm->wtFlags |= TERM_CODED|TERM_VIRTUAL; /* Disable the original */
144561 pTerm->eOperator = 0;
144573 if( pWC->op==TK_AND && pExpr->op==TK_IN && pTerm->iField==0
144622 pTerm = &pWC->a[idxTerm];
144623 pTerm->wtFlags |= TERM_COPIED;
144624 pNewTerm->prereqAll = pTerm->prereqAll;
144632 testcase( pTerm!=&pWC->a[idxTerm] );
144633 pTerm = &pWC->a[idxTerm];
144634 pTerm->prereqRight |= extraRight;
144793 Expr *pTerm;
144814 pTerm = sqlite3PExpr(pParse, TK_EQ, pColRef, pRhs);
144816 sqlite3SetJoinExpr(pTerm, pItem->iCursor);
144818 whereClauseInsert(pWC, pTerm, TERM_DYNAMIC);
145067 WhereTerm *pTerm; /* The term being tested */
145077 for(pTerm=pWC->a+k; k<pWC->nTerm; k++, pTerm++){
145078 if( pTerm->leftCursor==iCur
145079 && pTerm->u.leftColumn==iColumn
145081 || sqlite3ExprCompareSkip(pTerm->pExpr->pLeft,
145083 && (pScan->iEquiv<=1 || !ExprHasProperty(pTerm->pExpr, EP_FromJoin))
145085 if( (pTerm->eOperator & WO_EQUIV)!=0
145087 && (pX = sqlite3ExprSkipCollateAndLikely(pTerm->pExpr->pRight))->op
145103 if( (pTerm->eOperator & pScan->opMask)!=0 ){
145105 if( pScan->zCollName && (pTerm->eOperator & WO_ISNULL)==0 ){
145108 pX = pTerm->pExpr;
145119 if( (pTerm->eOperator & (WO_EQ|WO_IS))!=0
145120 && (pX = pTerm->pExpr->pRight)->op==TK_COLUMN
145124 testcase( pTerm->eOperator & WO_IS );
145129 return pTerm;
145484 WhereTerm *pTerm, /* WHERE clause term to check */
145489 if( pTerm->leftCursor!=pSrc->iCursor ) return 0;
145490 if( (pTerm->eOperator & (WO_EQ|WO_IS))==0 ) return 0;
145492 && !ExprHasProperty(pTerm->pExpr, EP_FromJoin)
145493 && (pTerm->eOperator & WO_IS)
145500 if( (pTerm->prereqRight & notReady)!=0 ) return 0;
145501 if( pTerm->u.leftColumn<0 ) return 0;
145502 aff = pSrc->pTab->aCol[pTerm->u.leftColumn].affinity;
145503 if( !sqlite3IndexAffinityOk(pTerm->pExpr, aff) ) return 0;
145504 testcase( pTerm->pExpr->op==TK_IS );
145524 WhereTerm *pTerm; /* A single term of the WHERE clause */
145560 for(pTerm=pWC->a; pTerm<pWCEnd; pTerm++){
145561 Expr *pExpr = pTerm->pExpr;
145566 && (pTerm->wtFlags & TERM_VIRTUAL)==0
145572 if( termCanDriveIndex(pTerm, pSrc, notReady) ){
145573 int iCol = pTerm->u.leftColumn;
145587 pLoop->aLTerm[nKeyCol++] = pTerm;
145624 for(pTerm=pWC->a; pTerm<pWCEnd; pTerm++){
145625 if( termCanDriveIndex(pTerm, pSrc, notReady) ){
145626 int iCol = pTerm->u.leftColumn;
145631 Expr *pX = pTerm->pExpr;
145633 pIdx->aiColumn[n] = pTerm->u.leftColumn;
145737 WhereTerm *pTerm;
145744 for(i=nTerm=0, pTerm=pWC->a; i<pWC->nTerm; i++, pTerm++){
145745 if( pTerm->leftCursor != pSrc->iCursor ) continue;
145746 if( pTerm->prereqRight & mUnusable ) continue;
145747 assert( IsPowerOfTwo(pTerm->eOperator & ~WO_EQUIV) );
145748 testcase( pTerm->eOperator & WO_IN );
145749 testcase( pTerm->eOperator & WO_ISNULL );
145750 testcase( pTerm->eOperator & WO_IS );
145751 testcase( pTerm->eOperator & WO_ALL );
145752 if( (pTerm->eOperator & ~(WO_EQUIV))==0 ) continue;
145753 if( pTerm->wtFlags & TERM_VNULL ) continue;
145754 assert( pTerm->u.leftColumn>=(-1) );
145794 for(i=j=0, pTerm=pWC->a; i<pWC->nTerm; i++, pTerm++){
145796 if( pTerm->leftCursor != pSrc->iCursor ) continue;
145797 if( pTerm->prereqRight & mUnusable ) continue;
145798 assert( IsPowerOfTwo(pTerm->eOperator & ~WO_EQUIV) );
145799 testcase( pTerm->eOperator & WO_IN );
145800 testcase( pTerm->eOperator & WO_IS );
145801 testcase( pTerm->eOperator & WO_ISNULL );
145802 testcase( pTerm->eOperator & WO_ALL );
145803 if( (pTerm->eOperator & ~(WO_EQUIV))==0 ) continue;
145804 if( pTerm->wtFlags & TERM_VNULL ) continue;
145810 && !ExprHasProperty(pTerm->pExpr, EP_FromJoin)
145814 assert( pTerm->u.leftColumn>=(-1) );
145815 pIdxCons[j].iColumn = pTerm->u.leftColumn;
145817 op = pTerm->eOperator & WO_ALL;
145820 pIdxCons[j].op = pTerm->eMatchOp;
145837 assert( pTerm->eOperator&(WO_IN|WO_EQ|WO_LT|WO_LE|WO_GT|WO_GE|WO_AUX) );
145840 && sqlite3ExprIsVector(pTerm->pExpr->pRight)
146107 static LogEst whereRangeAdjust(WhereTerm *pTerm, LogEst nNew){
146109 if( pTerm ){
146110 if( pTerm->truthProb<=0 ){
146111 nRet += pTerm->truthProb;
146112 }else if( (pTerm->wtFlags & TERM_VNULL)==0 ){
146565 SQLITE_PRIVATE void sqlite3WhereTermPrint(WhereTerm *pTerm, int iTerm){
146566 if( pTerm==0 ){
146572 if( pTerm->wtFlags & TERM_VIRTUAL ) zType[0] = 'V';
146573 if( pTerm->eOperator & WO_EQUIV ) zType[1] = 'E';
146574 if( ExprHasProperty(pTerm->pExpr, EP_FromJoin) ) zType[2] = 'L';
146575 if( pTerm->wtFlags & TERM_CODED ) zType[3] = 'C';
146576 if( pTerm->eOperator & WO_SINGLE ){
146578 pTerm->leftCursor, pTerm->u.leftColumn);
146579 }else if( (pTerm->eOperator & WO_OR)!=0 && pTerm->u.pOrInfo!=0 ){
146581 pTerm->u.pOrInfo->indexable);
146583 sqlite3_snprintf(sizeof(zLeft),zLeft,"left=%d", pTerm->leftCursor);
146587 iTerm, pTerm, zType, zLeft, pTerm->eOperator, pTerm->wtFlags);
146592 pTerm->truthProb, (u64)pTerm->prereqAll, (u64)pTerm->prereqRight);
146594 if( pTerm->iField ){
146595 sqlite3DebugPrintf(" iField=%d", pTerm->iField);
146597 if( pTerm->iParent>=0 ){
146598 sqlite3DebugPrintf(" iParent=%d", pTerm->iParent);
146601 sqlite3TreeViewExpr(0, pTerm->pExpr, 0);
147098 WhereTerm *pTerm, *pX;
147104 for(i=pWC->nTerm, pTerm=pWC->a; i>0; i--, pTerm++){
147105 assert( pTerm!=0 );
147106 if( (pTerm->wtFlags & TERM_VIRTUAL)!=0 ) break;
147107 if( (pTerm->prereqAll & pLoop->maskSelf)==0 ) continue;
147108 if( (pTerm->prereqAll & notAllowed)!=0 ) continue;
147112 if( pX==pTerm ) break;
147113 if( pX->iParent>=0 && (&pWC->a[pX->iParent])==pTerm ) break;
147116 if( pTerm->truthProb<=0 ){
147119 pLoop->nOut += pTerm->truthProb;
147124 if( (pTerm->eOperator&(WO_EQ|WO_IS))!=0
147125 && (pTerm->wtFlags & TERM_HIGHTRUTH)==0 /* tag-20200224-1 */
147127 Expr *pRight = pTerm->pExpr->pRight;
147129 testcase( pTerm->pExpr->op==TK_IS );
147136 pTerm->wtFlags |= TERM_HEURTRUTH;
147168 WhereTerm *pTerm /* The vector inequality constraint */
147170 int nCmp = sqlite3ExprVectorSize(pTerm->pExpr->pLeft);
147180 Expr *pLhs = pTerm->pExpr->pLeft->x.pList->a[i].pExpr;
147181 Expr *pRhs = pTerm->pExpr->pRight;
147244 WhereTerm *pTerm; /* A WhereTerm under consideration */
147286 pTerm = whereScanInit(&scan, pBuilder->pWC, pSrc->iCursor, saved_nEq,
147291 for(; rc==SQLITE_OK && pTerm!=0; pTerm = whereScanNext(&scan)){
147292 u16 eOp = pTerm->eOperator; /* Shorthand for pTerm->eOperator */
147299 if( (eOp==WO_ISNULL || (pTerm->wtFlags&TERM_VNULL)!=0)
147304 if( pTerm->prereqRight & pNew->maskSelf ) continue;
147308 if( pTerm->wtFlags & TERM_LIKEOPT && pTerm->eOperator==WO_LT ) continue;
147314 && !ExprHasProperty(pTerm->pExpr, EP_FromJoin)
147330 pNew->aLTerm[pNew->nLTerm++] = pTerm;
147331 pNew->prereq = (saved_prereq | pTerm->prereqRight) & ~pNew->maskSelf;
147340 Expr *pExpr = pTerm->pExpr;
147416 pParse, pSrc->iCursor, pProbe, saved_nEq, pTerm
147418 pBtm = pTerm;
147420 if( pTerm->wtFlags & TERM_LIKEOPT ){
147423 pTop = &pTerm[1];
147424 assert( (pTop-(pTerm->pWC->a))<pTerm->pWC->nTerm );
147438 pParse, pSrc->iCursor, pProbe, saved_nEq, pTerm
147440 pTop = pTerm;
147460 if( pTerm->truthProb<=0 && pProbe->aiColumn[saved_nEq]>=0 ){
147463 pNew->nOut += pTerm->truthProb;
147471 && ((eOp & WO_IN)==0 || !ExprHasProperty(pTerm->pExpr, EP_xIsSelect))
147474 Expr *pExpr = pTerm->pExpr;
147497 sqlite3WhereTermPrint(pTerm, 999);
147500 pTerm->wtFlags |= TERM_HIGHTRUTH;
147501 if( pTerm->wtFlags & TERM_HEURTRUTH ){
147659 WhereTerm *pTerm;
147666 for(i=0, pTerm=pWC->a; i<pWC->nTerm; i++, pTerm++){
147668 pExpr = pTerm->pExpr;
147788 WhereTerm *pTerm;
147790 for(pTerm=pWC->a; rc==SQLITE_OK && pTerm<pWCEnd; pTerm++){
147791 if( pTerm->prereqRight & pNew->maskSelf ) continue;
147792 if( termCanDriveIndex(pTerm, pSrc, 0) ){
147797 pNew->aLTerm[0] = pTerm;
147821 pNew->prereq = mPrereq | pTerm->prereqRight;
147908 WhereTerm *pTerm = &pWC2->a[ii];
147909 if( !sqlite3ExprCoveredByIndex(pTerm->pExpr, iCur, pProbe) ){
147914 if( pTerm->truthProb<=0 ){
147915 nLookup += pTerm->truthProb;
147918 if( pTerm->eOperator & (WO_EQ|WO_IS) ) nLookup -= 19;
148000 WhereTerm *pTerm = &pWC->a[pIdxCons->iTermOffset];
148002 if( (pTerm->prereqRight & mUsable)==pTerm->prereqRight
148003 && (pTerm->eOperator & mExclude)==0
148042 WhereTerm *pTerm;
148057 pTerm = &pWC->a[j];
148058 pNew->prereq |= pTerm->prereqRight;
148060 pNew->aLTerm[iTerm] = pTerm;
148072 if( (pTerm->eOperator & WO_IN)!=0 ){
148303 WhereTerm *pTerm, *pWCEnd;
148318 for(pTerm=pWC->a; pTerm<pWCEnd && rc==SQLITE_OK; pTerm++){
148319 if( (pTerm->eOperator & WO_OR)!=0
148320 && (pTerm->u.pOrInfo->indexable & pNew->maskSelf)!=0
148322 WhereClause * const pOrWC = &pTerm->u.pOrInfo->wc;
148332 WHERETRACE(0x200, ("Begin processing OR-clause %p\n", pTerm));
148349 (int)(pOrTerm-pOrWC->a), pTerm, sSubBuild.pWC->nTerm));
148387 pNew->aLTerm[0] = pTerm;
148410 WHERETRACE(0x200, ("End processing OR-clause %p\n", pTerm));
148521 WhereTerm *pTerm; /* A single term of the WHERE clause */
148593 pTerm = sqlite3WhereFindTerm(&pWInfo->sWC, iCur, pOBExpr->iColumn,
148595 if( pTerm==0 ) continue;
148596 if( pTerm->eOperator==WO_IN ){
148601 for(j=0; j<pLoop->nLTerm && pTerm!=pLoop->aLTerm[j]; j++){}
148604 if( (pTerm->eOperator&(WO_EQ|WO_IS))!=0 && pOBExpr->iColumn>=0 ){
148607 CollSeq *pColl2 = sqlite3ExprCompareCollSeq(pParse, pTerm->pExpr);
148612 testcase( pTerm->pExpr->op==TK_IS );
149288 WhereTerm *pTerm;
149307 pTerm = sqlite3WhereFindTerm(pWC, iCur, -1, 0, WO_EQ|WO_IS, 0);
149308 if( pTerm ){
149309 testcase( pTerm->eOperator & WO_IS );
149311 pLoop->aLTerm[0] = pTerm;
149326 pTerm = sqlite3WhereFindTerm(pWC, iCur, j, 0, opMask, pIdx);
149327 if( pTerm==0 ) break;
149328 testcase( pTerm->eOperator & WO_IS );
149329 pLoop->aLTerm[j] = pTerm;
149815 WhereTerm *pTerm, *pEnd;
149827 for(pTerm=sWLB.pWC->a; pTerm<pEnd; pTerm++){
149828 if( (pTerm->prereqAll & pLoop->maskSelf)!=0 ){
149829 if( !ExprHasProperty(pTerm->pExpr, EP_FromJoin)
149830 || pTerm->pExpr->iRightJoinTable!=pItem->iCursor
149836 if( pTerm<pEnd ) continue;
149839 for(pTerm=sWLB.pWC->a; pTerm<pEnd; pTerm++){
149840 if( (pTerm->prereqAll & pLoop->maskSelf)!=0 ){
149841 pTerm->wtFlags |= TERM_CODED;
183688 TermOffset *pTerm = 0; /* TermOffset associated with next token */
183694 pTerm = pT;
183698 if( !pTerm ){
183703 if( 0==(0xFE&*pTerm->pList) ){
183704 pTerm->pList = 0;
183706 fts3GetDeltaPosition(&pTerm->pList, &pTerm->iPos);
183714 "%d %d %d %d ", iCol, pTerm-sCtx.aTerm, iStart, iEnd-iStart
207988 const char *pTerm,
208200 const char *pTerm, int nTerm, /* Query term */
208207 const char *pTerm, int nTerm /* Query prefix */
210957 char *pTerm;
210976 const char *pTerm, int nTerm,
210991 hash = (hash << 3) ^ hash ^ pTerm[i];
210999 && memcmp(pEntry->pTerm, pTerm, nTerm)==0
211009 pEntry->pTerm = (char*)&pEntry[1];
211012 memcpy(pEntry->pTerm, pTerm, nTerm);
212351 static i64 fts5ExprSynonymRowid(Fts5ExprTerm *pTerm, int bDesc, int *pbEof){
212356 assert( pTerm->pSynonym );
212358 for(p=pTerm; p; p=p->pSynonym){
212376 Fts5ExprTerm *pTerm,
212388 assert( pTerm->pSynonym );
212389 for(p=pTerm; p; p=p->pSynonym){
212483 Fts5ExprTerm *pTerm = &pPhrase->aTerm[i];
212487 if( pTerm->pSynonym ){
212489 rc = fts5ExprSynonymList(pTerm, pNode->iRowid, &buf, &a, &n);
212496 a = (u8*)pTerm->pIter->pData;
212497 n = pTerm->pIter->nData;
212722 Fts5ExprTerm *pTerm, /* Term iterator to advance */
212732 for(p=pTerm; rc==SQLITE_OK && p; p=p->pSynonym){
212745 *piLast = fts5ExprSynonymRowid(pTerm, bDesc, &bEof);
212760 Fts5ExprTerm *pTerm;
212763 for(pTerm=&pPhrase->aTerm[0]; pTerm; pTerm=pTerm->pSynonym){
212764 Fts5IndexIter *pIter = pTerm->pIter;
212826 Fts5ExprTerm *pTerm = &pPhrase->aTerm[j];
212830 for(p=pTerm; p; p=p->pSynonym){
212838 (pTerm->bPrefix ? FTS5INDEX_QUERY_PREFIX : 0) |
212981 Fts5ExprTerm *pTerm = &pPhrase->aTerm[j];
212982 if( pTerm->pSynonym ){
212983 i64 iRowid = fts5ExprSynonymRowid(pTerm, bDesc, 0);
212986 if( fts5ExprSynonymAdvanceto(pTerm, bDesc, &iLast, &rc) ){
213023 Fts5ExprTerm *pTerm = &pNode->pNear->apPhrase[0]->aTerm[0];
213027 if( pTerm->pSynonym ){
213032 i64 iRowid = fts5ExprSynonymRowid(pTerm, pExpr->bDesc, 0);
213036 for(p=pTerm; p; p=p->pSynonym){
213061 Fts5IndexIter *pIter = pTerm->pIter;
213473 Fts5ExprTerm *pTerm = &pPhrase->aTerm[i];
213474 sqlite3_free(pTerm->zTerm);
213475 sqlite3Fts5IterClose(pTerm->pIter);
213476 for(pSyn=pTerm->pSynonym; pSyn; pSyn=pNext){
213608 Fts5ExprTerm *pTerm;
213626 pTerm = &pPhrase->aTerm[pPhrase->nTerm++];
213627 memset(pTerm, 0, sizeof(Fts5ExprTerm));
213628 pTerm->zTerm = sqlite3Fts5Strndup(&rc, pToken, nToken);
214260 static char *fts5ExprTermPrint(Fts5ExprTerm *pTerm){
214266 for(p=pTerm; p; p=p->pSynonym){
214267 nByte += (int)strlen(pTerm->zTerm) * 2 + 3 + 2;
214273 for(p=pTerm; p; p=p->pSynonym){
214283 if( pTerm->bPrefix ){
214747 Fts5ExprTerm *pTerm;
214749 for(pTerm=&pExpr->apExprPhrase[i]->aTerm[0]; pTerm; pTerm=pTerm->pSynonym){
214750 int nTerm = (int)strlen(pTerm->zTerm);
214751 if( (nTerm==nToken || (nTerm<nToken && pTerm->bPrefix))
214752 && memcmp(pTerm->zTerm, pToken, nTerm)==0
214874 Fts5ExprTerm *pTerm = &pPhrase->aTerm[0];
214875 if( pTerm->pSynonym ){
214876 Fts5Buffer *pBuf = (Fts5Buffer*)&pTerm->pSynonym[1];
214878 pTerm, pNode->iRowid, pBuf, (u8**)ppCollist, pnCollist
215333 const char *pTerm, int nTerm, /* Query prefix, if any */
215350 if( pTerm==0
215351 || (pIter->nKey+1>=nTerm && 0==memcmp(fts5EntryKey(pIter), pTerm, nTerm))
215381 const char *pTerm, int nTerm, /* Query term */
215385 unsigned int iHash = fts5HashKey(pHash->nSlot, (const u8*)pTerm, nTerm);
215392 if( nTerm==p->nKey+1 && memcmp(zKey, pTerm, nTerm)==0 ) break;
215418 const char *pTerm, int nTerm /* Query prefix */
215420 return fts5HashEntrySort(p, pTerm, nTerm, &p->pScan);
217677 const u8 *pTerm, int nTerm /* Term to search for */
217715 if( a[iOff+i]!=pTerm[nMatch+i] ) break;
217725 }else if( i<nNew && a[iOff+i]>pTerm[nMatch] ){
217784 fts5BufferSet(&p->rc, &pIter->term, nKeep, pTerm);
217821 const u8 *pTerm, int nTerm, /* Term to seek to */
217832 assert( pTerm && nTerm );
217841 sqlite3_bind_blob(pIdxSelect, 2, pTerm, nTerm, SQLITE_STATIC);
217859 fts5LeafSeek(p, bGe, pIter, pTerm, nTerm);
217889 || fts5BufferCompareBlob(&pIter->term, pTerm, nTerm)==0 /* 3 */
217890 || (bGe && fts5BufferCompareBlob(&pIter->term, pTerm, nTerm)>0) /* 4 */
217904 const u8 *pTerm, int nTerm, /* Term to seek to */
217916 if( pTerm==0 || (flags & FTS5INDEX_QUERY_SCAN) ){
217919 p->rc = sqlite3Fts5HashScanInit(p->pHash, (const char*)pTerm, nTerm);
217930 (const char*)pTerm, nTerm, (void**)&pLeaf, &nList
217935 z = pTerm;
218836 const u8 *pTerm, int nTerm, /* Term to seek to (or NULL/0) */
218847 assert( (pTerm==0 && nTerm==0) || iLevel<0 );
218875 fts5SegIterHashInit(p, pTerm, nTerm, flags, pIter);
218881 if( pTerm==0 ){
218884 fts5SegIterSeekInit(p, pTerm, nTerm, flags, pSeg, pIter);
219212 int nTerm, const u8 *pTerm /* First term on new page */
219216 fts5BufferSet(&p->rc, &pWriter->btterm, nTerm, pTerm);
219364 int nTerm, const u8 *pTerm
219412 n = 1 + fts5PrefixCompress(nMin, pPage->term.p, pTerm);
219414 fts5WriteBtreeTerm(p, pWriter, n, pTerm);
219419 nPrefix = fts5PrefixCompress(nMin, pPage->term.p, pTerm);
219426 fts5BufferAppendBlob(&p->rc, &pPage->buf, nTerm - nPrefix, &pTerm[nPrefix]);
219429 fts5BufferSet(&p->rc, &pPage->term, nTerm, pTerm);
219732 const u8 *pTerm;
219734 pTerm = fts5MultiIterTerm(pIter, &nTerm);
219735 if( nTerm!=term.n || fts5Memcmp(pTerm, term.p, nTerm) ){
219739 fts5BufferSet(&p->rc, &term, nTerm, pTerm);
219748 fts5WriteAppendTerm(p, &writer, nTerm, pTerm);
220577 const u8 *pTerm = pSeg->term.p;
220580 assert_nc( memcmp(pToken, pTerm, MIN(nToken, nTerm))<=0 );
220582 if( nTerm<nToken || memcmp(pToken, pTerm, nToken) ) break;
221085 const char *pTerm,
221093 for(i=0; i<nTerm; i++) ret += (ret<<3) + pTerm[i];