Lines Matching refs:pTerm
120194 struct ExprList_item *pTerm = pGB->a; local
120196 for(j=0; j<n; j++, pTerm++){
120197 Expr *pE = pTerm->pExpr;
141051 Upsert *pTerm; local
141063 for(i=0, pTerm=pUpsert; pTerm; pTerm=pTerm->pNextUpsert){
141064 if( pTerm->pUpsertTarget==0 ) break;
141065 if( pTerm->pUpsertIdx==0 ) continue; /* Skip ON CONFLICT for the IPK */
141068 while( ALWAYS(pIdx!=0) && pIdx!=pTerm->pUpsertIdx ){
151602 Expr *pTerm = pItem->pExpr; local
151605 if( pTerm->flags & EP_Collate ){
151606 pColl = sqlite3ExprCollSeq(pParse, pTerm);
151611 sqlite3ExprAddCollateString(pParse, pTerm, pColl->zName);
156177 Expr *pTerm; local
156185 pTerm = pPrior ? sqlite3ExprDup(db, pCount, 0) : pCount;
156186 pSub->pEList = sqlite3ExprListAppend(pParse, 0, pTerm);
156187 pTerm = sqlite3PExpr(pParse, TK_SELECT, 0, 0);
156188 sqlite3PExprAddSelect(pParse, pTerm, pSub);
156190 pExpr = pTerm;
156192 pExpr = sqlite3PExpr(pParse, TK_PLUS, pTerm, pExpr);
159066 Expr *pTerm /* A term in the RETURNING clause */ argument
159068 assert( pTerm!=0 );
159069 if( pTerm->op==TK_ASTERISK ) return 1;
159070 if( pTerm->op!=TK_DOT ) return 0;
159071 assert( pTerm->pRight!=0 );
159072 assert( pTerm->pLeft!=0 );
159073 if( pTerm->pRight->op!=TK_ASTERISK ) return 0;
161217 Expr *pTerm; /* One term of the conflict-target clause */ local
161247 && (pTerm = pTarget->a[0].pExpr)->op==TK_COLUMN
161248 && pTerm->iColumn==XN_ROWID
163812 SQLITE_PRIVATE void sqlite3WhereTermPrint(WhereTerm *pTerm, int iTerm);
164357 static void disableTerm(WhereLevel *pLevel, WhereTerm *pTerm){ argument
164359 assert( pTerm!=0 );
164360 while( (pTerm->wtFlags & TERM_CODED)==0
164361 && (pLevel->iLeftJoin==0 || ExprHasProperty(pTerm->pExpr, EP_OuterON))
164362 && (pLevel->notReady & pTerm->prereqAll)==0
164364 if( nLoop && (pTerm->wtFlags & TERM_LIKE)!=0 ){
164365 pTerm->wtFlags |= TERM_LIKECOND;
164367 pTerm->wtFlags |= TERM_CODED;
164372 sqlite3WhereTermPrint(pTerm, (int)(pTerm - (pTerm->pWC->a)));
164375 if( pTerm->iParent<0 ) break;
164376 pTerm = &pTerm->pWC->a[pTerm->iParent];
164377 assert( pTerm!=0 );
164378 pTerm->nChild--;
164379 if( pTerm->nChild!=0 ) break;
164608 WhereTerm *pTerm, /* The term of the WHERE clause to be coded */ argument
164614 Expr *pX = pTerm->pExpr;
164636 disableTerm(pLevel, pTerm);
164678 sqlite3WhereRealloc(pTerm->pWC->pWInfo,
164743 WhereTerm *pTerm, /* The term of the WHERE clause to be coded */ argument
164749 Expr *pX = pTerm->pExpr;
164752 assert( pLevel->pWLoop->aLTerm[iEq]==pTerm );
164763 codeINTerm(pParse, pTerm, pLevel, iEq, bRev, iTarget);
164777 || (pTerm->eOperator & WO_EQUIV)==0
164779 disableTerm(pLevel, pTerm);
164841 WhereTerm *pTerm; /* A single constraint term */ local
164891 pTerm = pLoop->aLTerm[j];
164892 assert( pTerm!=0 );
164895 testcase( (pTerm->wtFlags & TERM_CODED)!=0 );
164896 testcase( pTerm->wtFlags & TERM_VIRTUAL );
164897 r1 = codeEqualityTerm(pParse, pTerm, pLevel, j, bRev, regBase+j);
164906 if( pTerm->eOperator & WO_IN ){
164907 if( pTerm->pExpr->flags & EP_xIsSelect ){
164914 }else if( (pTerm->eOperator & WO_ISNULL)==0 ){
164915 Expr *pRight = pTerm->pExpr->pRight;
164916 if( (pTerm->wtFlags & TERM_IS)==0 && sqlite3ExprCanBeNull(pRight) ){
164956 WhereTerm *pTerm /* The upper or lower bound just coded */ argument
164958 if( pTerm->wtFlags & TERM_LIKEOPT ){
164964 || pTerm->pWC->pWInfo->pParse->db->mallocFailed );
165097 WhereTerm *pTerm; local
165113 pTerm = &pWC->a[i];
165114 if( pTerm->wtFlags & (TERM_VIRTUAL|TERM_CODED) ) continue;
165115 if( pTerm->prereqAll & pLevel->notReady ) continue;
165140 Expr *pExpr = pTerm->pExpr;
165146 sqlite3WalkExpr(&sWalker, pTerm->pExpr);
165150 if( ExprHasProperty(pTerm->pExpr, EP_OuterON) ) continue;
165156 if( pLoop->u.btree.nEq==0 && pTerm!=pEndRange ){
165157 for(j=0; j<pLoop->nLTerm && pLoop->aLTerm[j]!=pTerm; j++){}
165162 if( sqlite3ExprContainsSubquery(pTerm->pExpr) ) continue;
165169 sqlite3WalkExpr(&sWalker, pTerm->pExpr);
165174 pExpr = sqlite3ExprAnd(pParse, pExpr, sqlite3ExprDup(db, pTerm->pExpr, 0));
165299 WhereTerm *pTerm; local
165304 for(i=0, pTerm=pWC->a; i<pWC->nTerm; i++, pTerm++){
165306 if( pTerm->wtFlags & TERM_CODED ) continue;
165307 pExpr = pTerm->pExpr;
165309 pTerm->wtFlags |= TERM_CODED;
165348 WhereTerm *pTerm = pLoop->aLTerm[0]; local
165350 assert( pTerm!=0 );
165351 assert( pTerm->pExpr!=0 );
165352 testcase( pTerm->wtFlags & TERM_VIRTUAL );
165354 regRowid = codeEqualityTerm(pParse, pTerm, pLevel, 0, 0, regRowid);
165418 WhereTerm *pTerm; /* A WHERE clause term */ local
165508 pTerm = pLoop->aLTerm[j];
165509 if( NEVER(pTerm==0) ) continue;
165510 if( pTerm->eOperator & WO_IN ){
165514 sqlite3CodeRhsOfIN(pParse, pTerm->pExpr, iTab, 0);
165517 codeEqualityTerm(pParse, pTerm, pLevel, j, bRev, iTarget);
165521 Expr *pRight = pTerm->pExpr->pRight;
165523 if( pTerm->eMatchOp==SQLITE_INDEX_CONSTRAINT_OFFSET
165526 assert( pTerm->eOperator==WO_AUX );
165553 pTerm = pLoop->aLTerm[j];
165555 disableTerm(pLevel, pTerm);
165558 if( (pTerm->eOperator & WO_IN)!=0
165588 int iFld = pTerm->u.x.iField;
165589 Expr *pLeft = pTerm->pExpr->pLeft;
165631 pTerm = pLoop->aLTerm[0];
165632 assert( pTerm!=0 );
165633 assert( pTerm->pExpr!=0 );
165634 testcase( pTerm->wtFlags & TERM_VIRTUAL );
165636 iRowidReg = codeEqualityTerm(pParse, pTerm, pLevel, 0, bRev, iReleaseReg);
165666 pTerm = pStart;
165668 pEnd = pTerm;
166226 pTerm = pLoop->aLTerm[0];
166227 assert( pTerm!=0 );
166228 assert( pTerm->eOperator & WO_OR );
166229 assert( (pTerm->wtFlags & TERM_ORINFO)!=0 );
166230 pOrWc = &pTerm->u.pOrInfo->wc;
166320 if( &pWC->a[iTerm] == pTerm ) continue;
166502 if( !untestedTerms ) disableTerm(pLevel, pTerm);
166555 for(pTerm=pWC->a, j=pWC->nTerm; j>0; j--, pTerm++){
166558 testcase( pTerm->wtFlags & TERM_VIRTUAL );
166559 testcase( pTerm->wtFlags & TERM_CODED );
166560 if( pTerm->wtFlags & (TERM_VIRTUAL|TERM_CODED) ) continue;
166561 if( (pTerm->prereqAll & pLevel->notReady)!=0 ){
166567 pE = pTerm->pExpr;
166589 if( iLoop<3 && (pTerm->wtFlags & TERM_VARSELECT) ){
166594 if( (pTerm->wtFlags & TERM_LIKECOND)!=0 ){
166614 pWC->nTerm-j, pTerm, iLoop));
166618 sqlite3WhereTermPrint(pTerm, pWC->nTerm-j);
166623 pTerm->wtFlags |= TERM_CODED;
166636 for(pTerm=pWC->a, j=pWC->nBase; j>0; j--, pTerm++){
166639 if( pTerm->wtFlags & (TERM_VIRTUAL|TERM_CODED) ) continue;
166640 if( (pTerm->eOperator & (WO_EQ|WO_IS))==0 ) continue;
166641 if( (pTerm->eOperator & WO_EQUIV)==0 ) continue;
166642 if( pTerm->leftCursor!=iCur ) continue;
166644 pE = pTerm->pExpr;
166648 sqlite3WhereTermPrint(pTerm, pWC->nTerm-j);
166652 assert( (pTerm->prereqRight & pLevel->notReady)!=0 );
166653 assert( (pTerm->eOperator & (WO_OR|WO_AND))==0 );
166654 pAlt = sqlite3WhereFindTerm(pWC, iCur, pTerm->u.x.leftColumn, notReady,
166747 for(pTerm=pWC->a, j=0; j<pWC->nBase; j++, pTerm++){
166748 testcase( pTerm->wtFlags & TERM_VIRTUAL );
166749 testcase( pTerm->wtFlags & TERM_CODED );
166750 if( pTerm->wtFlags & (TERM_VIRTUAL|TERM_CODED) ) continue;
166751 if( (pTerm->prereqAll & pLevel->notReady)!=0 ){
166756 assert( pTerm->pExpr );
166757 sqlite3ExprIfFalse(pParse, pTerm->pExpr, addrCont, SQLITE_JUMPIFNULL);
166758 pTerm->wtFlags |= TERM_CODED;
166829 WhereTerm *pTerm = &pWC->a[k]; local
166830 if( (pTerm->wtFlags & (TERM_VIRTUAL|TERM_SLICE))!=0
166831 && pTerm->eOperator!=WO_ROWVAL
166835 if( pTerm->prereqAll & ~mAll ) continue;
166836 if( ExprHasProperty(pTerm->pExpr, EP_OuterON|EP_InnerON) ) continue;
166838 sqlite3ExprDup(pParse->db, pTerm->pExpr, 0));
166955 WhereTerm *pTerm; local
166972 pTerm = &pWC->a[idx = pWC->nTerm++];
166975 pTerm->truthProb = sqlite3LogEst(p->iTable) - 270;
166977 pTerm->truthProb = 1;
166979 pTerm->pExpr = sqlite3ExprSkipCollateAndLikely(p);
166980 pTerm->wtFlags = wtFlags;
166981 pTerm->pWC = pWC;
166982 pTerm->iParent = -1;
166983 memset(&pTerm->eOperator, 0,
167423 static WhereTerm *whereNthSubterm(WhereTerm *pTerm, int N){ argument
167424 if( pTerm->eOperator!=WO_AND ){
167425 return N==0 ? pTerm : 0;
167427 if( N<pTerm->u.pAndInfo->wc.nTerm ){
167428 return &pTerm->u.pAndInfo->wc.a[N];
167594 WhereTerm *pTerm = &pWC->a[idxTerm]; /* The term to be analyzed */ local
167595 Expr *pExpr = pTerm->pExpr; /* The expression of the term */
167608 assert( (pTerm->wtFlags & (TERM_DYNAMIC|TERM_ORINFO|TERM_ANDINFO))==0 );
167610 pTerm->u.pOrInfo = pOrInfo = sqlite3DbMallocZero(db, sizeof(*pOrInfo));
167612 pTerm->wtFlags |= TERM_ORINFO;
167683 pTerm->eOperator = WO_OR;
167684 pTerm->leftCursor = -1;
168021 WhereTerm *pTerm; /* The term to be analyzed */ local
168040 pTerm = &pWC->a[idxTerm];
168042 pTerm->iTerm = idxTerm;
168045 pExpr = pTerm->pExpr;
168055 pTerm->prereqRight = exprSelectUsage(pMaskSet, pExpr->x.pSelect);
168057 pTerm->prereqRight = sqlite3WhereExprListUsage(pMaskSet, pExpr->x.pList);
168059 prereqAll = prereqLeft | pTerm->prereqRight;
168061 pTerm->prereqRight = sqlite3WhereExprUsage(pMaskSet, pExpr->pRight);
168068 prereqAll = prereqLeft | pTerm->prereqRight;
168071 if( pMaskSet->bVarSelect ) pTerm->wtFlags |= TERM_VARSELECT;
168091 pTerm->prereqAll = prereqAll;
168092 pTerm->leftCursor = -1;
168093 pTerm->iParent = -1;
168094 pTerm->eOperator = 0;
168099 u16 opMask = (pTerm->prereqRight & prereqLeft)==0 ? WO_ALL : WO_EQUIV;
168101 if( pTerm->u.x.iField>0 ){
168105 pLeft = pLeft->x.pList->a[pTerm->u.x.iField-1].pExpr;
168109 pTerm->leftCursor = aiCurCol[0];
168110 assert( (pTerm->eOperator & (WO_OR|WO_AND))==0 );
168111 pTerm->u.x.leftColumn = aiCurCol[1];
168112 pTerm->eOperator = operatorMask(op) & opMask;
168114 if( op==TK_IS ) pTerm->wtFlags |= TERM_IS;
168122 assert( pTerm->u.x.iField==0 );
168123 if( pTerm->leftCursor>=0 ){
168135 pTerm = &pWC->a[idxTerm];
168136 pTerm->wtFlags |= TERM_COPIED;
168139 pTerm->eOperator |= WO_EQUIV;
168144 pNew = pTerm;
168148 assert( (pTerm->eOperator & (WO_OR|WO_AND))==0 );
168163 pTerm->prereqAll = 0;
168164 pTerm->eOperator = 0;
168203 pTerm = &pWC->a[idxTerm];
168216 pTerm = &pWC->a[idxTerm];
168248 pTerm = &pWC->a[idxTerm];
168249 pTerm->wtFlags |= TERM_COPIED;
168250 pNewTerm->prereqAll = pTerm->prereqAll;
168297 pTerm->wtFlags |= TERM_LIKE;
168343 pTerm = &pWC->a[idxTerm];
168380 pTerm = &pWC->a[idxTerm];
168381 pTerm->wtFlags |= TERM_CODED|TERM_VIRTUAL; /* Disable the original */
168382 pTerm->eOperator = WO_ROWVAL;
168395 && pTerm->u.x.iField==0
168403 && pExpr->x.pSelect->pEList->nExpr <= UMXV(pTerm->nChild)
168407 assert( pTerm->nChild==0 );
168454 pTerm = &pWC->a[idxTerm];
168455 pTerm->wtFlags |= TERM_COPIED;
168456 pNewTerm->prereqAll = pTerm->prereqAll;
168466 testcase( pTerm!=&pWC->a[idxTerm] );
168467 pTerm = &pWC->a[idxTerm];
168468 pTerm->prereqRight |= extraRight;
168540 WhereTerm *pTerm; local
168543 pTerm = &pWC->a[idx];
168544 pTerm->leftCursor = iCsr;
168545 pTerm->eOperator = WO_AUX;
168546 pTerm->eMatchOp = eMatchOp;
168805 Expr *pTerm; local
168829 pTerm = sqlite3PExpr(pParse, TK_EQ, pColRef, pRhs);
168838 sqlite3SetJoinExpr(pTerm, pItem->iCursor, joinType);
168839 whereClauseInsert(pWC, pTerm, TERM_DYNAMIC);
169165 WhereTerm *pTerm, argument
169168 Expr *pX = pTerm->pExpr;
169171 assert( pTerm->eOperator & WO_IN );
169174 int iField = pTerm->u.x.iField - 1;
169200 WhereTerm *pTerm; /* The term being tested */ local
169211 for(pTerm=pWC->a+k; k<pWC->nTerm; k++, pTerm++){
169212 assert( (pTerm->eOperator & (WO_OR|WO_AND))==0 || pTerm->leftCursor<0 );
169213 if( pTerm->leftCursor==iCur
169214 && pTerm->u.x.leftColumn==iColumn
169216 || sqlite3ExprCompareSkip(pTerm->pExpr->pLeft,
169218 && (pScan->iEquiv<=1 || !ExprHasProperty(pTerm->pExpr, EP_OuterON))
169220 if( (pTerm->eOperator & WO_EQUIV)!=0
169222 && (pX = whereRightSubexprIsColumn(pTerm->pExpr))!=0
169237 if( (pTerm->eOperator & pScan->opMask)!=0 ){
169239 if( pScan->zCollName && (pTerm->eOperator & WO_ISNULL)==0 ){
169242 pX = pTerm->pExpr;
169244 if( (pTerm->eOperator & WO_IN) ){
169245 zCollName = indexInAffinityOk(pParse, pTerm, pScan->idxaff);
169261 if( (pTerm->eOperator & (WO_EQ|WO_IS))!=0
169262 && (pX = pTerm->pExpr->pRight, ALWAYS(pX!=0))
169267 testcase( pTerm->eOperator & WO_IS );
169276 pScan->aiCur[0], pScan->aiColumn[0], pTerm->iTerm);
169284 return pTerm;
169677 const WhereTerm *pTerm, /* WHERE clause term to check */ argument
169683 testcase( ExprHasProperty(pTerm->pExpr, EP_OuterON) )
169684 testcase( ExprHasProperty(pTerm->pExpr, EP_InnerON) );
169685 if( !ExprHasProperty(pTerm->pExpr, EP_OuterON|EP_InnerON)
169686 || pTerm->pExpr->w.iJoin != pSrc->iCursor
169691 && NEVER(ExprHasProperty(pTerm->pExpr, EP_InnerON))
169746 const WhereTerm *pTerm, /* WHERE clause term to check */ argument
169753 if( pTerm->leftCursor!=pSrc->iCursor ) return 0;
169754 if( (pTerm->eOperator & (WO_EQ|WO_IS))==0 ) return 0;
169757 && !constraintCompatibleWithOuterJoin(pTerm,pSrc)
169761 if( (pTerm->prereqRight & notReady)!=0 ) return 0;
169762 assert( (pTerm->eOperator & (WO_OR|WO_AND))==0 );
169763 leftCol = pTerm->u.x.leftColumn;
169766 if( !sqlite3IndexAffinityOk(pTerm->pExpr, aff) ) return 0;
169767 testcase( pTerm->pExpr->op==TK_IS );
169837 WhereTerm *pTerm; /* A single term of the WHERE clause */ local
169880 for(pTerm=pWC->a; pTerm<pWCEnd; pTerm++){
169881 Expr *pExpr = pTerm->pExpr;
169885 if( (pTerm->wtFlags & TERM_VIRTUAL)==0
169891 if( termCanDriveIndex(pTerm, pSrc, notReady) ){
169894 assert( (pTerm->eOperator & (WO_OR|WO_AND))==0 );
169895 iCol = pTerm->u.x.leftColumn;
169909 pLoop->aLTerm[nKeyCol++] = pTerm;
169966 for(pTerm=pWC->a; pTerm<pWCEnd; pTerm++){
169967 if( termCanDriveIndex(pTerm, pSrc, notReady) ){
169970 assert( (pTerm->eOperator & (WO_OR|WO_AND))==0 );
169971 iCol = pTerm->u.x.leftColumn;
169976 Expr *pX = pTerm->pExpr;
169978 pIdx->aiColumn[n] = pTerm->u.x.leftColumn;
170126 const WhereTerm *pTerm; /* For looping over WHERE clause terms */ local
170181 for(pTerm=pWInfo->sWC.a; pTerm<pWCEnd; pTerm++){
170182 Expr *pExpr = pTerm->pExpr;
170183 if( (pTerm->wtFlags & TERM_VIRTUAL)==0
170186 sqlite3ExprIfFalse(pParse, pTerm->pExpr, addrCont, SQLITE_JUMPIFNULL);
170271 WhereTerm *pTerm; local
170290 for(i=0, pTerm=p->a; i<p->nTerm; i++, pTerm++){
170291 pTerm->wtFlags &= ~TERM_OK;
170292 if( pTerm->leftCursor != pSrc->iCursor ) continue;
170293 if( pTerm->prereqRight & mUnusable ) continue;
170294 assert( IsPowerOfTwo(pTerm->eOperator & ~WO_EQUIV) );
170295 testcase( pTerm->eOperator & WO_IN );
170296 testcase( pTerm->eOperator & WO_ISNULL );
170297 testcase( pTerm->eOperator & WO_IS );
170298 testcase( pTerm->eOperator & WO_ALL );
170299 if( (pTerm->eOperator & ~(WO_EQUIV))==0 ) continue;
170300 if( pTerm->wtFlags & TERM_VNULL ) continue;
170302 assert( (pTerm->eOperator & (WO_OR|WO_AND))==0 );
170303 assert( pTerm->u.x.leftColumn>=XN_ROWID );
170304 assert( pTerm->u.x.leftColumn<pTab->nCol );
170306 && !constraintCompatibleWithOuterJoin(pTerm,pSrc)
170311 pTerm->wtFlags |= TERM_OK;
170409 for(pTerm=p->a; i<nLast; i++, pTerm++){
170411 if( (pTerm->wtFlags & TERM_OK)==0 ) continue;
170412 pIdxCons[j].iColumn = pTerm->u.x.leftColumn;
170414 op = pTerm->eOperator & WO_ALL;
170416 if( (pTerm->wtFlags & TERM_SLICE)==0 ){
170422 pIdxCons[j].op = pTerm->eMatchOp;
170439 assert( pTerm->eOperator&(WO_IN|WO_EQ|WO_LT|WO_LE|WO_GT|WO_GE|WO_AUX) );
170442 && sqlite3ExprIsVector(pTerm->pExpr->pRight)
170760 static LogEst whereRangeAdjust(WhereTerm *pTerm, LogEst nNew){ argument
170762 if( pTerm ){
170763 if( pTerm->truthProb<=0 ){
170764 nRet += pTerm->truthProb;
170765 }else if( (pTerm->wtFlags & TERM_VNULL)==0 ){
171219 SQLITE_PRIVATE void sqlite3WhereTermPrint(WhereTerm *pTerm, int iTerm){ argument
171220 if( pTerm==0 ){
171226 if( pTerm->wtFlags & TERM_VIRTUAL ) zType[0] = 'V';
171227 if( pTerm->eOperator & WO_EQUIV ) zType[1] = 'E';
171228 if( ExprHasProperty(pTerm->pExpr, EP_OuterON) ) zType[2] = 'L';
171229 if( pTerm->wtFlags & TERM_CODED ) zType[3] = 'C';
171230 if( pTerm->eOperator & WO_SINGLE ){
171231 assert( (pTerm->eOperator & (WO_OR|WO_AND))==0 );
171233 pTerm->leftCursor, pTerm->u.x.leftColumn);
171234 }else if( (pTerm->eOperator & WO_OR)!=0 && pTerm->u.pOrInfo!=0 ){
171236 pTerm->u.pOrInfo->indexable);
171238 sqlite3_snprintf(sizeof(zLeft),zLeft,"left=%d", pTerm->leftCursor);
171240 iTerm = pTerm->iTerm = MAX(iTerm,pTerm->iTerm);
171243 iTerm, pTerm, zType, zLeft, pTerm->eOperator, pTerm->wtFlags);
171248 pTerm->truthProb, (u64)pTerm->prereqAll, (u64)pTerm->prereqRight);
171250 if( (pTerm->eOperator & (WO_OR|WO_AND))==0 && pTerm->u.x.iField ){
171251 sqlite3DebugPrintf(" iField=%d", pTerm->u.x.iField);
171253 if( pTerm->iParent>=0 ){
171254 sqlite3DebugPrintf(" iParent=%d", pTerm->iParent);
171257 sqlite3TreeViewExpr(0, pTerm->pExpr, 0);
171260 SQLITE_PRIVATE void sqlite3ShowWhereTerm(WhereTerm *pTerm){ argument
171261 sqlite3WhereTermPrint(pTerm, 0);
171886 WhereTerm *pTerm, *pX; local
171892 for(i=pWC->nBase, pTerm=pWC->a; i>0; i--, pTerm++){
171893 assert( pTerm!=0 );
171894 if( (pTerm->prereqAll & notAllowed)!=0 ) continue;
171895 if( (pTerm->prereqAll & pLoop->maskSelf)==0 ) continue;
171896 if( (pTerm->wtFlags & TERM_VIRTUAL)!=0 ) continue;
171900 if( pX==pTerm ) break;
171901 if( pX->iParent>=0 && (&pWC->a[pX->iParent])==pTerm ) break;
171905 if( pLoop->maskSelf==pTerm->prereqAll ){
171915 if( (pTerm->eOperator & 0x3f)!=0
171922 if( pTerm->truthProb<=0 ){
171925 pLoop->nOut += pTerm->truthProb;
171929 Expr *pOpExpr = pTerm->pExpr;
171931 if( (pTerm->eOperator&(WO_EQ|WO_IS))!=0
171932 && (pTerm->wtFlags & TERM_HIGHTRUTH)==0 /* tag-20200224-1 */
171943 pTerm->wtFlags |= TERM_HEURTRUTH;
171994 WhereTerm *pTerm /* The vector inequality constraint */ argument
171996 int nCmp = sqlite3ExprVectorSize(pTerm->pExpr->pLeft);
172008 assert( ExprUseXList(pTerm->pExpr->pLeft) );
172009 pLhs = pTerm->pExpr->pLeft->x.pList->a[i].pExpr;
172010 pRhs = pTerm->pExpr->pRight;
172034 if( ExprHasProperty(pTerm->pExpr, EP_Commuted) ) SWAP(Expr*, pRhs, pLhs);
172074 WhereTerm *pTerm; /* A WhereTerm under consideration */ local
172123 pTerm = whereScanInit(&scan, pBuilder->pWC, pSrc->iCursor, saved_nEq,
172128 for(; rc==SQLITE_OK && pTerm!=0; pTerm = whereScanNext(&scan)){
172129 u16 eOp = pTerm->eOperator; /* Shorthand for pTerm->eOperator */
172136 if( (eOp==WO_ISNULL || (pTerm->wtFlags&TERM_VNULL)!=0)
172141 if( pTerm->prereqRight & pNew->maskSelf ) continue;
172145 if( pTerm->wtFlags & TERM_LIKEOPT && pTerm->eOperator==WO_LT ) continue;
172148 && !constraintCompatibleWithOuterJoin(pTerm,pSrc)
172167 pNew->aLTerm[pNew->nLTerm++] = pTerm;
172168 pNew->prereq = (saved_prereq | pTerm->prereqRight) & ~pNew->maskSelf;
172177 Expr *pExpr = pTerm->pExpr;
172192 if( pNew->aLTerm[i]->u.x.iField == pTerm->u.x.iField ){
172275 pParse, pSrc->iCursor, pProbe, saved_nEq, pTerm
172282 pBtm = pTerm;
172284 if( pTerm->wtFlags & TERM_LIKEOPT ){
172287 pTop = &pTerm[1];
172288 assert( (pTop-(pTerm->pWC->a))<pTerm->pWC->nTerm );
172302 pTop = pTerm;
172323 if( pTerm->truthProb<=0 && pProbe->aiColumn[saved_nEq]>=0 ){
172326 pNew->nOut += pTerm->truthProb;
172334 && ((eOp & WO_IN)==0 || ExprUseXList(pTerm->pExpr))
172337 Expr *pExpr = pTerm->pExpr;
172360 sqlite3WhereTermPrint(pTerm, 999);
172363 pTerm->wtFlags |= TERM_HIGHTRUTH;
172364 if( pTerm->wtFlags & TERM_HEURTRUTH ){
172551 WhereTerm *pTerm; local
172560 for(i=0, pTerm=pWC->a; i<pWC->nTerm; i++, pTerm++){
172562 pExpr = pTerm->pExpr;
172567 && (pTerm->wtFlags & TERM_VNULL)==0
172921 WhereTerm *pTerm; local
172924 for(pTerm=pWC->a; rc==SQLITE_OK && pTerm<pWCEnd; pTerm++){
172925 if( pTerm->prereqRight & pNew->maskSelf ) continue;
172926 if( termCanDriveIndex(pTerm, pSrc, 0) ){
172931 pNew->aLTerm[0] = pTerm;
172956 pNew->prereq = mPrereq | pTerm->prereqRight;
173106 WhereTerm *pTerm = &pWC2->a[ii]; local
173107 if( !sqlite3ExprCoveredByIndex(pTerm->pExpr, iCur, pProbe) ){
173112 if( pTerm->truthProb<=0 ){
173113 nLookup += pTerm->truthProb;
173116 if( pTerm->eOperator & (WO_EQ|WO_IS) ) nLookup -= 19;
173161 static int isLimitTerm(WhereTerm *pTerm){ argument
173162 assert( pTerm->eOperator==WO_AUX || pTerm->eMatchOp==0 );
173163 return pTerm->eMatchOp>=SQLITE_INDEX_CONSTRAINT_LIMIT
173164 && pTerm->eMatchOp<=SQLITE_INDEX_CONSTRAINT_OFFSET;
173232 WhereTerm *pTerm = termFromWhereClause(pWC, pIdxCons->iTermOffset); local
173234 if( (pTerm->prereqRight & mUsable)==pTerm->prereqRight
173235 && (pTerm->eOperator & mExclude)==0
173236 && (pbRetryLimit || !isLimitTerm(pTerm))
173276 WhereTerm *pTerm; local
173280 || (pTerm = termFromWhereClause(pWC, j))==0
173291 pNew->prereq |= pTerm->prereqRight;
173293 pNew->aLTerm[iTerm] = pTerm;
173304 if( pTerm->eMatchOp==SQLITE_INDEX_CONSTRAINT_OFFSET ){
173310 }else if( (pTerm->eOperator & WO_IN)!=0 ){
173323 assert( pbRetryLimit || !isLimitTerm(pTerm) );
173324 assert( !isLimitTerm(pTerm) || i>=nConstraint-2 );
173325 assert( !isLimitTerm(pTerm) || i==nConstraint-1 || isLimitTerm(pTerm+1) );
173327 if( isLimitTerm(pTerm) && (*pbIn || !allConstraintsUsed(pUsage, i)) ){
173450 WhereTerm *pTerm = termFromWhereClause( local
173454 pH->pParse->db, pTerm->pExpr->pRight, ENC(pH->pParse->db),
173663 WhereTerm *pTerm, *pWCEnd; local
173681 for(pTerm=pWC->a; pTerm<pWCEnd && rc==SQLITE_OK; pTerm++){
173682 if( (pTerm->eOperator & WO_OR)!=0
173683 && (pTerm->u.pOrInfo->indexable & pNew->maskSelf)!=0
173685 WhereClause * const pOrWC = &pTerm->u.pOrInfo->wc;
173694 WHERETRACE(0x400, ("Begin processing OR-clause %p\n", pTerm));
173712 (int)(pOrTerm-pOrWC->a), pTerm, sSubBuild.pWC->nTerm));
173750 pNew->aLTerm[0] = pTerm;
173773 WHERETRACE(0x400, ("End processing OR-clause %p\n", pTerm));
173840 WhereTerm *pTerm; local
173842 for(i=pWC->nBase, pTerm=pWC->a; i>0; i--, pTerm++){
173843 if( (pNew->maskSelf & pTerm->prereqAll)!=0 ){
173844 mPrereq |= (pTerm->prereqAll & (pNew->maskSelf-1));
174015 WhereTerm *pTerm; /* A single term of the WHERE clause */ local
174092 pTerm = sqlite3WhereFindTerm(&pWInfo->sWC, iCur, pOBExpr->iColumn,
174094 if( pTerm==0 ) continue;
174095 if( pTerm->eOperator==WO_IN ){
174101 for(j=0; j<pLoop->nLTerm && pTerm!=pLoop->aLTerm[j]; j++){}
174104 if( (pTerm->eOperator&(WO_EQ|WO_IS))!=0 && pOBExpr->iColumn>=0 ){
174107 CollSeq *pColl2 = sqlite3ExprCompareCollSeq(pParse, pTerm->pExpr);
174112 testcase( pTerm->pExpr->op==TK_IS );
175199 WhereTerm *pTerm; local
175223 pTerm = whereScanInit(&scan, pWC, iCur, -1, WO_EQ|WO_IS, 0);
175224 while( pTerm && pTerm->prereqRight ) pTerm = whereScanNext(&scan);
175225 if( pTerm ){
175226 testcase( pTerm->eOperator & WO_IS );
175228 pLoop->aLTerm[0] = pTerm;
175243 pTerm = whereScanInit(&scan, pWC, iCur, j, opMask, pIdx);
175244 while( pTerm && pTerm->prereqRight ) pTerm = whereScanNext(&scan);
175245 if( pTerm==0 ) break;
175246 testcase( pTerm->eOperator & WO_IS );
175247 pLoop->aLTerm[j] = pTerm;
175398 WhereTerm *pTerm, *pEnd; local
175412 for(pTerm=pWInfo->sWC.a; pTerm<pEnd; pTerm++){
175413 if( (pTerm->prereqAll & pLoop->maskSelf)!=0 ){
175414 if( !ExprHasProperty(pTerm->pExpr, EP_OuterON)
175415 || pTerm->pExpr->w.iJoin!=pItem->iCursor
175421 && ExprHasProperty(pTerm->pExpr, EP_InnerON)
175422 && NEVER(pTerm->pExpr->w.iJoin==pItem->iCursor)
175427 if( pTerm<pEnd ) continue;
175433 for(pTerm=pWInfo->sWC.a; pTerm<pEnd; pTerm++){
175434 if( (pTerm->prereqAll & pLoop->maskSelf)!=0 ){
175435 pTerm->wtFlags |= TERM_CODED;
175436 pTerm->prereqAll = 0;
211858 TermOffset *pTerm = 0; /* TermOffset associated with next token */ local
211864 pTerm = pT;
211868 if( !pTerm ){
211873 if( 0==(0xFE&*pTerm->pList) ){
211874 pTerm->pList = 0;
211876 fts3GetDeltaPosition(&pTerm->pList, &pTerm->iPos);
211884 "%d %d %d %d ", iCol, pTerm-sCtx.aTerm, iStart, iEnd-iStart
242547 const char *pTerm,
242789 const char *pTerm, int nTerm, /* Query term */
242796 const char *pTerm, int nTerm /* Query prefix */
245735 char *pTerm; member
245754 const char *pTerm, int nTerm, argument
245769 hash = (hash << 3) ^ hash ^ pTerm[i];
245777 && memcmp(pEntry->pTerm, pTerm, nTerm)==0
245787 pEntry->pTerm = (char*)&pEntry[1];
245790 memcpy(pEntry->pTerm, pTerm, nTerm);
247051 char *pTerm; /* Term data */ member
247437 static i64 fts5ExprSynonymRowid(Fts5ExprTerm *pTerm, int bDesc, int *pbEof){ argument
247442 assert( pTerm );
247443 assert( pTerm->pSynonym );
247445 for(p=pTerm; p; p=p->pSynonym){
247463 Fts5ExprTerm *pTerm, argument
247475 assert( pTerm->pSynonym );
247476 for(p=pTerm; p; p=p->pSynonym){
247570 Fts5ExprTerm *pTerm = &pPhrase->aTerm[i]; local
247574 if( pTerm->pSynonym ){
247576 rc = fts5ExprSynonymList(pTerm, pNode->iRowid, &buf, &a, &n);
247583 a = (u8*)pTerm->pIter->pData;
247584 n = pTerm->pIter->nData;
247809 Fts5ExprTerm *pTerm, /* Term iterator to advance */ argument
247819 for(p=pTerm; rc==SQLITE_OK && p; p=p->pSynonym){
247832 *piLast = fts5ExprSynonymRowid(pTerm, bDesc, &bEof);
247847 Fts5ExprTerm *pTerm; local
247850 for(pTerm=&pPhrase->aTerm[0]; pTerm; pTerm=pTerm->pSynonym){
247851 Fts5IndexIter *pIter = pTerm->pIter;
247913 Fts5ExprTerm *pTerm = &pPhrase->aTerm[j]; local
247917 for(p=pTerm; p; p=p->pSynonym){
247924 pExpr->pIndex, p->pTerm, p->nQueryTerm,
247925 (pTerm->bPrefix ? FTS5INDEX_QUERY_PREFIX : 0) |
248068 Fts5ExprTerm *pTerm = &pPhrase->aTerm[j]; local
248069 if( pTerm->pSynonym ){
248070 i64 iRowid = fts5ExprSynonymRowid(pTerm, bDesc, 0);
248073 if( fts5ExprSynonymAdvanceto(pTerm, bDesc, &iLast, &rc) ){
248110 Fts5ExprTerm *pTerm = &pNode->pNear->apPhrase[0]->aTerm[0]; local
248114 if( pTerm->pSynonym ){
248119 i64 iRowid = fts5ExprSynonymRowid(pTerm, pExpr->bDesc, 0);
248123 for(p=pTerm; p; p=p->pSynonym){
248148 Fts5IndexIter *pIter = pTerm->pIter;
248569 Fts5ExprTerm *pTerm = &pPhrase->aTerm[i]; local
248570 sqlite3_free(pTerm->pTerm);
248571 sqlite3Fts5IterClose(pTerm->pIter);
248572 for(pSyn=pTerm->pSynonym; pSyn; pSyn=pNext){
248699 pSyn->pTerm = ((char*)pSyn) + sizeof(Fts5ExprTerm) + sizeof(Fts5Buffer);
248701 memcpy(pSyn->pTerm, pToken, nToken);
248703 pSyn->nQueryTerm = (int)strlen(pSyn->pTerm);
248709 Fts5ExprTerm *pTerm; local
248727 pTerm = &pPhrase->aTerm[pPhrase->nTerm++];
248728 memset(pTerm, 0, sizeof(Fts5ExprTerm));
248729 pTerm->pTerm = sqlite3Fts5Strndup(&rc, pToken, nToken);
248730 pTerm->nFullTerm = pTerm->nQueryTerm = nToken;
248732 pTerm->nQueryTerm = (int)strlen(pTerm->pTerm);
248891 rc = fts5ParseTokenize((void*)&sCtx,tflags,p->pTerm,p->nFullTerm,0,0);
249281 pTo->pTerm = sqlite3Fts5Strndup(&pParse->rc, p->pTerm, p->nFullTerm);
249468 static char *fts5ExprTermPrint(Fts5ExprTerm *pTerm){ argument
249474 for(p=pTerm; p; p=p->pSynonym){
249475 nByte += pTerm->nQueryTerm * 2 + 3 + 2;
249481 for(p=pTerm; p; p=p->pSynonym){
249482 char *zIn = p->pTerm;
249492 if( pTerm->bPrefix ){
249565 p->nQueryTerm, p->pTerm
250004 && memcmp(pT->pTerm, pToken, pT->nQueryTerm)==0
250134 Fts5ExprTerm *pTerm = &pPhrase->aTerm[0]; local
250135 if( pTerm->pSynonym ){
250136 Fts5Buffer *pBuf = (Fts5Buffer*)&pTerm->pSynonym[1];
250138 pTerm, pNode->iRowid, pBuf, (u8**)ppCollist, pnCollist
250172 *ppOut = pPhrase->aTerm[iToken].pTerm;
250191 Fts5ExprTerm *pTerm = 0; local
250201 pTerm = &pPhrase->aTerm[iToken];
250202 if( pExpr->pConfig->bTokendata || pTerm->bPrefix ){
250204 pTerm->pIter, pTerm->pTerm, pTerm->nQueryTerm,
250208 *ppOut = pTerm->pTerm;
250209 *pnOut = pTerm->nFullTerm;
250676 const char *pTerm, int nTerm, /* Query prefix, if any */ argument
250693 if( pTerm==0
250694 || (pIter->nKey>=nTerm && 0==memcmp(fts5EntryKey(pIter), pTerm, nTerm))
250723 const char *pTerm, int nTerm, /* Query term */ argument
250727 unsigned int iHash = fts5HashKey(pHash->nSlot, (const u8*)pTerm, nTerm);
250733 if( nTerm==p->nKey && memcmp(zKey, pTerm, nTerm)==0 ) break;
250759 const char *pTerm, int nTerm /* Query prefix */ argument
250761 return fts5HashEntrySort(p, pTerm, nTerm, &p->pScan);
253367 const u8 *pTerm, int nTerm /* Term to search for */ argument
253408 if( a[iOff+i]!=pTerm[nMatch+i] ) break;
253418 }else if( i<nNew && a[iOff+i]>pTerm[nMatch] ){
253477 fts5BufferSet(&p->rc, &pIter->term, nKeep, pTerm);
253514 const u8 *pTerm, int nTerm, /* Term to seek to */ argument
253525 assert( pTerm && nTerm );
253534 sqlite3_bind_blob(pIdxSelect, 2, pTerm, nTerm, SQLITE_STATIC);
253552 fts5LeafSeek(p, bGe, pIter, pTerm, nTerm);
253585 || fts5BufferCompareBlob(&pIter->term, pTerm, nTerm)==0 /* 3 */
253586 || (bGe && fts5BufferCompareBlob(&pIter->term, pTerm, nTerm)>0) /* 4 */
253614 const char *pTerm, int nTerm, argument
253626 sqlite3_bind_blob(pSel, 2, pTerm, nTerm, SQLITE_STATIC);
253658 fts5BufferCompareBlob(&pIter->term, (const u8*)pTerm, nTerm)>0
253673 const u8 *pTerm, int nTerm, /* Term to seek to */ argument
253685 if( pTerm==0 || (flags & FTS5INDEX_QUERY_SCAN) ){
253688 p->rc = sqlite3Fts5HashScanInit(p->pHash, (const char*)pTerm, nTerm);
253706 (const char*)pTerm, nTerm, (void**)&pLeaf, &nList
253711 z = pTerm;
254762 const u8 *pTerm, int nTerm, /* Term to seek to (or NULL/0) */ argument
254773 assert( (pTerm==0 && nTerm==0) || iLevel<0 );
254804 fts5SegIterHashInit(p, pTerm, nTerm, flags, pIter);
254810 if( pTerm==0 ){
254813 fts5SegIterSeekInit(p, pTerm, nTerm, flags, pSeg, pIter);
255131 int nTerm, const u8 *pTerm /* First term on new page */ argument
255135 fts5BufferSet(&p->rc, &pWriter->btterm, nTerm, pTerm);
255283 int nTerm, const u8 *pTerm argument
255331 n = 1 + fts5PrefixCompress(nMin, pPage->term.p, pTerm);
255333 fts5WriteBtreeTerm(p, pWriter, n, pTerm);
255338 nPrefix = fts5PrefixCompress(nMin, pPage->term.p, pTerm);
255345 fts5BufferAppendBlob(&p->rc, &pPage->buf, nTerm - nPrefix, &pTerm[nPrefix]);
255348 fts5BufferSet(&p->rc, &pPage->term, nTerm, pTerm);
255659 const u8 *pTerm; local
255661 pTerm = fts5MultiIterTerm(pIter, &nTerm);
255662 if( nTerm!=term.n || fts5Memcmp(pTerm, term.p, nTerm) ){
255666 fts5BufferSet(&p->rc, &term, nTerm, pTerm);
255675 fts5WriteAppendTerm(p, &writer, nTerm, pTerm);
256281 Fts5Data *pTerm = fts5DataRead(p, iId); local
256282 if( pTerm && pTerm->szLeaf==pSeg->iTermLeafOffset ){
256283 u8 *aTermIdx = &pTerm->p[pTerm->szLeaf];
256284 int nTermIdx = pTerm->nn - pTerm->szLeaf;
256297 if( iTermOff>pTerm->szLeaf ){
256300 memmove(&pTerm->p[iTermOff], &pTerm->p[pTerm->szLeaf], nTermIdx);
256301 fts5PutU16(&pTerm->p[2], iTermOff);
256302 fts5DataWrite(p, iId, pTerm->p, iTermOff+nTermIdx);
256308 fts5DataRelease(pTerm);
258064 static void fts5TokendataSetTermIfEof(Fts5Iter *pIter, Fts5Buffer *pTerm){ argument
258066 fts5BufferSet(&pIter->pIndex->rc, &pIter->aSeg[0].term, pTerm->n, pTerm->p);
258540 Fts5Buffer *pTerm = &pT->apIter[ii]->aSeg[0].term; local
258541 if( nToken==pTerm->n-1 && memcmp(pToken, pTerm->p+1, nToken)==0 ) break;
258998 const char *pTerm, argument
259006 for(i=0; i<nTerm; i++) ret += (ret<<3) + pTerm[i];
259794 static void fts5BufferAppendTerm(int *pRc, Fts5Buffer *pBuf, Fts5Buffer *pTerm){ argument
259796 fts5BufferGrow(pRc, pBuf, pTerm->n*2 + 1);
259798 for(ii=0; ii<pTerm->n; ii++){
259799 if( pTerm->p[ii]==0x00 ){
259803 pBuf->p[pBuf->n++] = pTerm->p[ii];