Lines Matching refs:pExpr
10175 ** AggInfo.pGroupBy and AggInfo.aFunc.pExpr point to fields within the
10194 Expr *pExpr; /* The original expression */
10202 Expr *pExpr; /* Expression encoding the function */
10408 Expr *pExpr; /* The list of expressions */
10424 Expr *pExpr; /* The expression parse tree */
11579 SQLITE_PRIVATE char sqlite3CompareAffinity(Expr *pExpr, char aff2);
11580 SQLITE_PRIVATE int sqlite3IndexAffinityOk(Expr *pExpr, char idx_affinity);
11581 SQLITE_PRIVATE char sqlite3ExprAffinity(Expr *pExpr);
11591 SQLITE_PRIVATE CollSeq *sqlite3ExprCollSeq(Parse *pParse, Expr *pExpr);
58152 ** Create a new sqlite3_value object, containing the value of pExpr.
58163 Expr *pExpr, /* The expression to evaluate */
58174 if( !pExpr ){
58178 op = pExpr->op;
58185 if( op==TK_REGISTER ) op = pExpr->op2;
58187 if( NEVER(op==TK_REGISTER) ) op = pExpr->op2;
58194 && (pExpr->pLeft->op==TK_INTEGER || pExpr->pLeft->op==TK_FLOAT) ){
58195 pExpr = pExpr->pLeft;
58196 op = pExpr->op;
58204 if( ExprHasProperty(pExpr, EP_IntValue) ){
58205 sqlite3VdbeMemSetInt64(pVal, (i64)pExpr->u.iValue*negInt);
58207 zVal = sqlite3MPrintf(db, "%s%s", zNeg, pExpr->u.zToken);
58223 if( SQLITE_OK==sqlite3ValueFromExpr(db,pExpr->pLeft,enc,affinity,&pVal) ){
58242 assert( pExpr->u.zToken[0]=='x' || pExpr->u.zToken[0]=='X' );
58243 assert( pExpr->u.zToken[1]=='\'' );
58246 zVal = &pExpr->u.zToken[2];
71701 SQLITE_PRIVATE int sqlite3WalkExpr(Walker *pWalker, Expr *pExpr){
71703 if( pExpr==0 ) return WRC_Continue;
71704 testcase( ExprHasProperty(pExpr, EP_TokenOnly) );
71705 testcase( ExprHasProperty(pExpr, EP_Reduced) );
71706 rc = pWalker->xExprCallback(pWalker, pExpr);
71708 && !ExprHasAnyProperty(pExpr,EP_TokenOnly) ){
71709 if( sqlite3WalkExpr(pWalker, pExpr->pLeft) ) return WRC_Abort;
71710 if( sqlite3WalkExpr(pWalker, pExpr->pRight) ) return WRC_Abort;
71711 if( ExprHasProperty(pExpr, EP_xIsSelect) ){
71712 if( sqlite3WalkSelect(pWalker, pExpr->x.pSelect) ) return WRC_Abort;
71714 if( sqlite3WalkExprList(pWalker, pExpr->x.pList) ) return WRC_Abort;
71729 if( sqlite3WalkExpr(pWalker, pItem->pExpr) ) return WRC_Abort;
71822 ** Turn the pExpr expression into an alias for the iCol-th column of the
71852 Expr *pExpr, /* Transform this into an alias to the result set */
71860 pOrig = pEList->a[iCol].pExpr;
71886 if( pExpr->flags & EP_ExpCollate ){
71887 pDup->pColl = pExpr->pColl;
71895 ExprSetProperty(pExpr, EP_Static);
71896 sqlite3ExprDelete(db, pExpr);
71897 memcpy(pExpr, pDup, sizeof(*pExpr));
71903 ** that name in the set of source tables in pSrcList and make the pExpr
71905 ** are made to pExpr:
71907 ** pExpr->iDb Set the index in db->aDb[] of the database X
71909 ** pExpr->iTable Set to the cursor number for the table obtained
71911 ** pExpr->pTab Points to the Table structure of X.Y (even if
71913 ** pExpr->iColumn Set to the column number within the table.
71914 ** pExpr->op Set to TK_COLUMN.
71915 ** pExpr->pLeft Any expression this points to is deleted
71916 ** pExpr->pRight Any expression this points to is deleted.
71934 Expr *pExpr /* Make this EXPR node point to the selected column */
71948 assert( ~ExprHasAnyProperty(pExpr, EP_TokenOnly|EP_Reduced) );
71951 pExpr->iTable = -1;
71952 pExpr->pTab = 0;
71953 ExprSetIrreducible(pExpr);
71985 pExpr->iTable = pItem->iCursor;
71986 pExpr->pTab = pTab;
71994 pExpr->iTable = pItem->iCursor;
71995 pExpr->pTab = pTab;
71999 pExpr->iColumn = j==pTab->iPKey ? -1 : (i16)j;
72035 pExpr->iTable = 1;
72038 pExpr->iTable = 0;
72061 pExpr->affinity = SQLITE_AFF_INTEGER;
72062 }else if( pExpr->iTable==0 ){
72071 pExpr->iColumn = (i16)iCol;
72072 pExpr->pTab = pTab;
72084 pExpr->iColumn = -1; /* IMP: R-44911-55124 */
72085 pExpr->affinity = SQLITE_AFF_INTEGER;
72095 ** In cases like this, replace pExpr with a copy of the expression that
72105 assert( pExpr->pLeft==0 && pExpr->pRight==0 );
72106 assert( pExpr->x.pList==0 );
72107 assert( pExpr->x.pSelect==0 );
72108 pOrig = pEList->a[j].pExpr;
72113 resolveAlias(pParse, pEList, j, pExpr, "");
72135 ** pExpr.
72140 if( cnt==0 && zTab==0 && ExprHasProperty(pExpr,EP_DblQuoted) ){
72141 pExpr->op = TK_STRING;
72142 pExpr->pTab = 0;
72170 if( pExpr->iColumn>=0 && pMatch!=0 ){
72171 int n = pExpr->iColumn;
72176 assert( pMatch->iCursor==pExpr->iTable );
72182 sqlite3ExprDelete(db, pExpr->pLeft);
72183 pExpr->pLeft = 0;
72184 sqlite3ExprDelete(db, pExpr->pRight);
72185 pExpr->pRight = 0;
72186 pExpr->op = (isTrigger ? TK_TRIGGER : TK_COLUMN);
72190 sqlite3AuthRead(pParse, pExpr, pSchema, pNC->pSrcList);
72239 static int resolveExprStep(Walker *pWalker, Expr *pExpr){
72248 if( ExprHasAnyProperty(pExpr, EP_Resolved) ) return WRC_Prune;
72249 ExprSetProperty(pExpr, EP_Resolved);
72259 switch( pExpr->op ){
72271 pExpr->op = TK_COLUMN;
72272 pExpr->pTab = pItem->pTab;
72273 pExpr->iTable = pItem->iCursor;
72274 pExpr->iColumn = -1;
72275 pExpr->affinity = SQLITE_AFF_INTEGER;
72283 return lookupName(pParse, 0, 0, pExpr->u.zToken, pNC, pExpr);
72296 pRight = pExpr->pRight;
72299 zTable = pExpr->pLeft->u.zToken;
72303 zDb = pExpr->pLeft->u.zToken;
72307 return lookupName(pParse, zDb, zTable, zColumn, pNC, pExpr);
72314 ExprList *pList = pExpr->x.pList; /* The argument list */
72325 testcase( pExpr->op==TK_CONST_FUNC );
72326 assert( !ExprHasProperty(pExpr, EP_xIsSelect) );
72327 zId = pExpr->u.zToken;
72349 pExpr->op = TK_NULL;
72367 pExpr->op = TK_AGG_FUNCTION;
72373 /* FIX ME: Compute pExpr->affinity based on the expected return
72380 case TK_EXISTS: testcase( pExpr->op==TK_EXISTS );
72383 testcase( pExpr->op==TK_IN );
72384 if( ExprHasProperty(pExpr, EP_xIsSelect) ){
72391 sqlite3WalkSelect(pWalker, pExpr->x.pSelect);
72394 ExprSetProperty(pExpr, EP_VarSelect);
72497 if( sqlite3ExprCompare(pEList->a[i].pExpr, pE)<2 ){
72571 pE = pItem->pExpr;
72592 pItem->pExpr = pE = sqlite3Expr(db, TK_INTEGER, 0);
72651 resolveAlias(pParse, pEList, pItem->iCol-1, pItem->pExpr, zType);
72691 Expr *pE = pItem->pExpr;
72788 Expr *pX = pEList->a[i].pExpr;
72882 if( ExprHasProperty(pItem->pExpr, EP_Agg) ){
72956 Expr *pExpr /* The expression to be analyzed. */
72961 if( pExpr==0 ) return 0;
72965 if( sqlite3ExprCheckHeight(pParse, pExpr->nHeight+pNC->pParse->nHeight) ){
72968 pParse->nHeight += pExpr->nHeight;
72977 sqlite3WalkExpr(&w, pExpr);
72979 pNC->pParse->nHeight -= pExpr->nHeight;
72982 ExprSetProperty(pExpr, EP_Error);
72985 ExprSetProperty(pExpr, EP_Agg);
72989 return ExprHasProperty(pExpr, EP_Error);
73038 ** Return the 'affinity' of the expression pExpr if any.
73040 ** If pExpr is a column, a reference to a column via an 'AS' alias,
73053 SQLITE_PRIVATE char sqlite3ExprAffinity(Expr *pExpr){
73054 int op = pExpr->op;
73056 assert( pExpr->flags&EP_xIsSelect );
73057 return sqlite3ExprAffinity(pExpr->x.pSelect->pEList->a[0].pExpr);
73061 assert( !ExprHasProperty(pExpr, EP_IntValue) );
73062 return sqlite3AffinityType(pExpr->u.zToken);
73066 && pExpr->pTab!=0
73068 /* op==TK_REGISTER && pExpr->pTab!=0 happens when pExpr was originally
73070 int j = pExpr->iColumn;
73072 assert( pExpr->pTab && j<pExpr->pTab->nCol );
73073 return pExpr->pTab->aCol[j].affinity;
73075 return pExpr->affinity;
73082 SQLITE_PRIVATE Expr *sqlite3ExprSetColl(Expr *pExpr, CollSeq *pColl){
73083 if( pExpr && pColl ){
73084 pExpr->pColl = pColl;
73085 pExpr->flags |= EP_ExpCollate;
73087 return pExpr;
73091 ** Set the collating sequence for expression pExpr to be the collating
73097 SQLITE_PRIVATE Expr *sqlite3ExprSetCollByToken(Parse *pParse, Expr *pExpr, Token *pCollName){
73103 sqlite3ExprSetColl(pExpr, pColl);
73105 return pExpr;
73109 ** Return the default collation sequence for the expression pExpr. If
73112 SQLITE_PRIVATE CollSeq *sqlite3ExprCollSeq(Parse *pParse, Expr *pExpr){
73114 Expr *p = pExpr;
73123 /* op==TK_REGISTER && p->pTab!=0 happens when pExpr was originally
73131 pExpr->pColl = pColl;
73147 ** pExpr is an operand of a comparison operator. aff2 is the
73151 SQLITE_PRIVATE char sqlite3CompareAffinity(Expr *pExpr, char aff2){
73152 char aff1 = sqlite3ExprAffinity(pExpr);
73175 ** pExpr is a comparison operator. Return the type affinity that should
73178 static char comparisonAffinity(Expr *pExpr){
73180 assert( pExpr->op==TK_EQ || pExpr->op==TK_IN || pExpr->op==TK_LT ||
73181 pExpr->op==TK_GT || pExpr->op==TK_GE || pExpr->op==TK_LE ||
73182 pExpr->op==TK_NE || pExpr->op==TK_IS || pExpr->op==TK_ISNOT );
73183 assert( pExpr->pLeft );
73184 aff = sqlite3ExprAffinity(pExpr->pLeft);
73185 if( pExpr->pRight ){
73186 aff = sqlite3CompareAffinity(pExpr->pRight, aff);
73187 }else if( ExprHasProperty(pExpr, EP_xIsSelect) ){
73188 aff = sqlite3CompareAffinity(pExpr->x.pSelect->pEList->a[0].pExpr, aff);
73196 ** pExpr is a comparison expression, eg. '=', '<', IN(...) etc.
73199 ** the comparison in pExpr.
73201 SQLITE_PRIVATE int sqlite3IndexAffinityOk(Expr *pExpr, char idx_affinity){
73202 char aff = comparisonAffinity(pExpr);
73319 heightOfExpr(p->a[i].pExpr, pnHeight);
73565 SQLITE_PRIVATE void sqlite3ExprAssignVarNumber(Parse *pParse, Expr *pExpr){
73569 if( pExpr==0 ) return;
73570 assert( !ExprHasAnyProperty(pExpr, EP_IntValue|EP_Reduced|EP_TokenOnly) );
73571 z = pExpr->u.zToken;
73577 pExpr->iColumn = (ynVar)(++pParse->nVar);
73586 pExpr->iColumn = x = (ynVar)i;
73607 pExpr->iColumn = x = (ynVar)i+1;
73611 if( x==0 ) x = pExpr->iColumn = (ynVar)(++pParse->nVar);
73886 Expr *pOldExpr = pOldItem->pExpr;
73887 pItem->pExpr = sqlite3ExprDup(db, pOldExpr, flags);
74004 Expr *pExpr /* Expression to be appended. Might be NULL */
74028 pItem->pExpr = pExpr;
74034 sqlite3ExprDelete(db, pExpr);
74082 assert( db->mallocFailed || pItem->pExpr==pSpan->pExpr );
74116 sqlite3ExprDelete(db, pItem->pExpr);
74137 static int exprNodeIsConstant(Walker *pWalker, Expr *pExpr){
74142 if( pWalker->u.i==3 && ExprHasAnyProperty(pExpr, EP_FromJoin) ){
74147 switch( pExpr->op ){
74157 testcase( pExpr->op==TK_ID );
74158 testcase( pExpr->op==TK_COLUMN );
74159 testcase( pExpr->op==TK_AGG_FUNCTION );
74160 testcase( pExpr->op==TK_AGG_COLUMN );
74164 testcase( pExpr->op==TK_SELECT ); /* selectNodeIsConstant will disallow */
74165 testcase( pExpr->op==TK_EXISTS ); /* selectNodeIsConstant will disallow */
74287 ** was computed by pExpr. If we can look at pExpr at compile-time and
74293 const Expr *pExpr, /* Only generate OP_IsNull if this expr can be NULL */
74297 if( sqlite3ExprCanBeNull(pExpr) ){
74390 if( pEList->a[0].pExpr->op!=TK_COLUMN ) return 0; /* Result is a column */
74465 Expr *pExpr = p->pEList->a[0].pExpr; /* Expression <column> */
74466 int iCol = pExpr->iColumn; /* Index of column <column> */
74497 CollSeq *pReq = sqlite3BinaryCompareCollSeq(pParse, pX->pLeft, pExpr);
74566 ** The pExpr parameter describes the expression that contains the IN
74569 ** If parameter isRowid is non-zero, then expression pExpr is guaranteed
74593 Expr *pExpr, /* The IN, SELECT, or EXISTS operator */
74613 if( !ExprHasAnyProperty(pExpr, EP_VarSelect) && !pParse->pTriggerTab ){
74622 pExpr->op==TK_IN?"LIST":"SCALAR", pParse->iNextSelectId
74628 switch( pExpr->op ){
74633 Expr *pLeft = pExpr->pLeft; /* the LHS of the IN operator */
74654 pExpr->iTable = pParse->nTab++;
74655 addr = sqlite3VdbeAddOp2(v, OP_OpenEphemeral, pExpr->iTable, !isRowid);
74660 if( ExprHasProperty(pExpr, EP_xIsSelect) ){
74670 sqlite3SelectDestInit(&dest, SRT_Set, pExpr->iTable);
74672 assert( (pExpr->iTable&0x0000FFFF)==pExpr->iTable );
74673 pExpr->x.pSelect->iLimit = 0;
74674 if( sqlite3Select(pParse, pExpr->x.pSelect, &dest) ){
74677 pEList = pExpr->x.pSelect->pEList;
74679 keyInfo.aColl[0] = sqlite3BinaryCompareCollSeq(pParse, pExpr->pLeft,
74680 pEList->a[0].pExpr);
74682 }else if( ALWAYS(pExpr->x.pList!=0) ){
74691 ExprList *pList = pExpr->x.pList;
74698 keyInfo.aColl[0] = sqlite3ExprCollSeq(pParse, pExpr->pLeft);
74705 Expr *pE2 = pItem->pExpr;
74720 sqlite3VdbeAddOp3(v, OP_InsertInt, pExpr->iTable, r2, iValToIns);
74726 sqlite3VdbeAddOp3(v, OP_Insert, pExpr->iTable, r2, r3);
74730 sqlite3VdbeAddOp2(v, OP_IdxInsert, pExpr->iTable, r2);
74755 testcase( pExpr->op==TK_EXISTS );
74756 testcase( pExpr->op==TK_SELECT );
74757 assert( pExpr->op==TK_EXISTS || pExpr->op==TK_SELECT );
74759 assert( ExprHasProperty(pExpr, EP_xIsSelect) );
74760 pSel = pExpr->x.pSelect;
74762 if( pExpr->op==TK_SELECT ){
74779 ExprSetIrreducible(pExpr);
74813 Expr *pExpr, /* The IN expression */
74824 ** pExpr->iTable will contains the values that make up the RHS.
74829 eType = sqlite3FindInIndex(pParse, pExpr, &rRhsHasNull);
74835 affinity = comparisonAffinity(pExpr);
74841 sqlite3ExprCode(pParse, pExpr->pLeft, r1);
74852 sqlite3VdbeAddOp2(v, OP_Rewind, pExpr->iTable, destIfFalse);
74861 sqlite3VdbeAddOp3(v, OP_NotExists, pExpr->iTable, destIfFalse, r1);
74881 sqlite3VdbeAddOp4Int(v, OP_NotFound, pExpr->iTable, destIfFalse, r1, 1);
74894 j1 = sqlite3VdbeAddOp4Int(v, OP_Found, pExpr->iTable, 0, r1, 1);
74903 j3 = sqlite3VdbeAddOp4Int(v, OP_Found, pExpr->iTable, 0, rRhsHasNull, 1);
74967 static void codeInteger(Parse *pParse, Expr *pExpr, int negFlag, int iMem){
74969 if( pExpr->flags & EP_IntValue ){
74970 int i = pExpr->u.iValue;
74977 const char *z = pExpr->u.zToken;
75278 SQLITE_PRIVATE int sqlite3ExprCodeTarget(Parse *pParse, Expr *pExpr, int target){
75293 if( pExpr==0 ){
75296 op = pExpr->op;
75300 AggInfo *pAggInfo = pExpr->pAggInfo;
75301 struct AggInfo_col *pCol = &pAggInfo->aCol[pExpr->iAgg];
75314 if( pExpr->iTable<0 ){
75317 inReg = pExpr->iColumn + pParse->ckBase;
75319 inReg = sqlite3ExprCodeGetColumn(pParse, pExpr->pTab,
75320 pExpr->iColumn, pExpr->iTable, target);
75325 codeInteger(pParse, pExpr, 0, target);
75330 assert( !ExprHasProperty(pExpr, EP_IntValue) );
75331 codeReal(v, pExpr->u.zToken, 0, target);
75336 assert( !ExprHasProperty(pExpr, EP_IntValue) );
75337 sqlite3VdbeAddOp4(v, OP_String8, 0, target, 0, pExpr->u.zToken, 0);
75349 assert( !ExprHasProperty(pExpr, EP_IntValue) );
75350 assert( pExpr->u.zToken[0]=='x' || pExpr->u.zToken[0]=='X' );
75351 assert( pExpr->u.zToken[1]=='\'' );
75352 z = &pExpr->u.zToken[2];
75361 assert( !ExprHasProperty(pExpr, EP_IntValue) );
75362 assert( pExpr->u.zToken!=0 );
75363 assert( pExpr->u.zToken[0]!=0 );
75364 sqlite3VdbeAddOp2(v, OP_Variable, pExpr->iColumn, target);
75365 if( pExpr->u.zToken[1]!=0 ){
75366 assert( pExpr->u.zToken[0]=='?'
75367 || strcmp(pExpr->u.zToken, pParse->azVar[pExpr->iColumn-1])==0 );
75368 sqlite3VdbeChangeP4(v, -1, pParse->azVar[pExpr->iColumn-1], P4_STATIC);
75373 inReg = pExpr->iTable;
75377 inReg = sqlite3ExprCodeTarget(pParse, pExpr->pLeft, target);
75384 inReg = sqlite3ExprCodeTarget(pParse, pExpr->pLeft, target);
75385 assert( !ExprHasProperty(pExpr, EP_IntValue) );
75386 aff = sqlite3AffinityType(pExpr->u.zToken);
75426 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1);
75427 r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, ®Free2);
75428 codeCompare(pParse, pExpr->pLeft, pExpr->pRight, op,
75438 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1);
75439 r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, ®Free2);
75441 codeCompare(pParse, pExpr->pLeft, pExpr->pRight, op,
75481 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1);
75482 r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, ®Free2);
75489 Expr *pLeft = pExpr->pLeft;
75495 assert( !ExprHasProperty(pExpr, EP_IntValue) );
75501 r2 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free2);
75514 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1);
75528 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1);
75536 AggInfo *pInfo = pExpr->pAggInfo;
75538 assert( !ExprHasProperty(pExpr, EP_IntValue) );
75539 sqlite3ErrorMsg(pParse, "misuse of aggregate: %s()", pExpr->u.zToken);
75541 inReg = pInfo->aFunc[pExpr->iAgg].iMem;
75557 assert( !ExprHasProperty(pExpr, EP_xIsSelect) );
75560 if( ExprHasAnyProperty(pExpr, EP_TokenOnly) ){
75563 pFarg = pExpr->x.pList;
75566 assert( !ExprHasProperty(pExpr, EP_IntValue) );
75567 zId = pExpr->u.zToken;
75582 sqlite3ExprCode(pParse, pFarg->a[0].pExpr, target);
75587 sqlite3ExprCode(pParse, pFarg->a[i].pExpr, target);
75616 if( nFarg>=2 && (pExpr->flags & EP_InfixFunc) ){
75617 pDef = sqlite3VtabOverloadFunction(db, pDef, nFarg, pFarg->a[1].pExpr);
75619 pDef = sqlite3VtabOverloadFunction(db, pDef, nFarg, pFarg->a[0].pExpr);
75623 if( i<32 && sqlite3ExprIsConstant(pFarg->a[i].pExpr) ){
75627 pColl = sqlite3ExprCollSeq(pParse, pFarg->a[i].pExpr);
75647 inReg = sqlite3CodeSubselect(pParse, pExpr, 0, 0);
75654 sqlite3ExprCodeIN(pParse, pExpr, destIfFalse, destIfNull);
75671 ** X is stored in pExpr->pLeft.
75672 ** Y is stored in pExpr->pList->a[0].pExpr.
75673 ** Z is stored in pExpr->pList->a[1].pExpr.
75676 Expr *pLeft = pExpr->pLeft;
75677 struct ExprList_item *pLItem = pExpr->x.pList->a;
75678 Expr *pRight = pLItem->pExpr;
75689 pRight = pLItem->pExpr;
75700 inReg = sqlite3ExprCodeTarget(pParse, pExpr->pLeft, target);
75730 Table *pTab = pExpr->pTab;
75731 int p1 = pExpr->iTable * (pTab->nCol+1) + 1 + pExpr->iColumn;
75733 assert( pExpr->iTable==0 || pExpr->iTable==1 );
75734 assert( pExpr->iColumn>=-1 && pExpr->iColumn<pTab->nCol );
75735 assert( pTab->iPKey<0 || pExpr->iColumn!=pTab->iPKey );
75740 (pExpr->iTable ? "new" : "old"),
75741 (pExpr->iColumn<0 ? "rowid" : pExpr->pTab->aCol[pExpr->iColumn].zName),
75748 if( pExpr->iColumn>=0
75749 && pTab->aCol[pExpr->iColumn].affinity==SQLITE_AFF_REAL
75769 ** X (if it exists) is in pExpr->pLeft.
75770 ** Y is in pExpr->pRight. The Y is also optional. If there is no
75773 ** Ei is in pExpr->pList->a[i*2] and Ri is pExpr->pList->a[i*2+1].
75792 assert( !ExprHasProperty(pExpr, EP_xIsSelect) && pExpr->x.pList );
75793 assert((pExpr->x.pList->nExpr % 2) == 0);
75794 assert(pExpr->x.pList->nExpr > 0);
75795 pEList = pExpr->x.pList;
75799 if( (pX = pExpr->pLeft)!=0 ){
75819 opCompare.pRight = aListelem[i].pExpr;
75821 pTest = aListelem[i].pExpr;
75826 testcase( aListelem[i+1].pExpr->op==TK_COLUMN );
75827 testcase( aListelem[i+1].pExpr->op==TK_REGISTER );
75828 sqlite3ExprCode(pParse, aListelem[i+1].pExpr, target);
75833 if( pExpr->pRight ){
75835 sqlite3ExprCode(pParse, pExpr->pRight, target);
75847 assert( pExpr->affinity==OE_Rollback
75848 || pExpr->affinity==OE_Abort
75849 || pExpr->affinity==OE_Fail
75850 || pExpr->affinity==OE_Ignore
75857 if( pExpr->affinity==OE_Abort ){
75860 assert( !ExprHasProperty(pExpr, EP_IntValue) );
75861 if( pExpr->affinity==OE_Ignore ){
75863 v, OP_Halt, SQLITE_OK, OE_Ignore, 0, pExpr->u.zToken,0);
75865 sqlite3HaltConstraint(pParse, pExpr->affinity, pExpr->u.zToken, 0);
75886 SQLITE_PRIVATE int sqlite3ExprCodeTemp(Parse *pParse, Expr *pExpr, int *pReg){
75888 int r2 = sqlite3ExprCodeTarget(pParse, pExpr, r1);
75899 ** Generate code that will evaluate expression pExpr and store the
75903 SQLITE_PRIVATE int sqlite3ExprCode(Parse *pParse, Expr *pExpr, int target){
75907 if( pExpr && pExpr->op==TK_REGISTER ){
75908 sqlite3VdbeAddOp2(pParse->pVdbe, OP_Copy, pExpr->iTable, target);
75910 inReg = sqlite3ExprCodeTarget(pParse, pExpr, target);
75931 SQLITE_PRIVATE int sqlite3ExprCodeAndCache(Parse *pParse, Expr *pExpr, int target){
75934 inReg = sqlite3ExprCode(pParse, pExpr, target);
75942 if( ALWAYS(pExpr->op!=TK_REGISTER) ){
75946 pExpr->iTable = iMem;
75947 pExpr->op2 = pExpr->op;
75948 pExpr->op = TK_REGISTER;
75954 ** Return TRUE if pExpr is an constant expression that is appropriate
76013 ** If pExpr is a constant expression that is appropriate for
76018 static int evalConstExpr(Walker *pWalker, Expr *pExpr){
76020 switch( pExpr->op ){
76032 ExprList *pList = pExpr->x.pList;
76033 assert( !ExprHasProperty(pExpr, EP_xIsSelect) );
76038 if( ALWAYS(pItem->pExpr) ) pItem->pExpr->flags |= EP_FixedDest;
76044 if( isAppropriateForFactoring(pExpr) ){
76047 r2 = sqlite3ExprCodeTarget(pParse, pExpr, r1);
76049 pExpr->op2 = pExpr->op;
76050 pExpr->op = TK_REGISTER;
76051 pExpr->iTable = r2;
76058 ** Preevaluate constant subexpressions within pExpr and store the
76059 ** results in registers. Modify pExpr so that the constant subexpresions
76073 SQLITE_PRIVATE void sqlite3ExprCodeConstants(Parse *pParse, Expr *pExpr){
76080 sqlite3WalkExpr(&w, pExpr);
76103 Expr *pExpr = pItem->pExpr;
76104 int inReg = sqlite3ExprCodeTarget(pParse, pExpr, target+i);
76127 Expr *pExpr, /* The BETWEEN expression */
76138 assert( !ExprHasProperty(pExpr, EP_xIsSelect) );
76139 exprX = *pExpr->pLeft;
76145 compLeft.pRight = pExpr->x.pList->a[0].pExpr;
76148 compRight.pRight = pExpr->x.pList->a[1].pExpr;
76183 SQLITE_PRIVATE void sqlite3ExprIfTrue(Parse *pParse, Expr *pExpr, int dest, int jumpIfNull){
76192 if( NEVER(pExpr==0) ) return; /* No way this can happen */
76193 op = pExpr->op;
76199 sqlite3ExprIfFalse(pParse, pExpr->pLeft, d2,jumpIfNull^SQLITE_JUMPIFNULL);
76200 sqlite3ExprIfTrue(pParse, pExpr->pRight, dest, jumpIfNull);
76207 sqlite3ExprIfTrue(pParse, pExpr->pLeft, dest, jumpIfNull);
76208 sqlite3ExprIfTrue(pParse, pExpr->pRight, dest, jumpIfNull);
76213 sqlite3ExprIfFalse(pParse, pExpr->pLeft, dest, jumpIfNull);
76235 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1);
76236 r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, ®Free2);
76237 codeCompare(pParse, pExpr->pLeft, pExpr->pRight, op,
76247 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1);
76248 r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, ®Free2);
76250 codeCompare(pParse, pExpr->pLeft, pExpr->pRight, op,
76262 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1);
76269 exprCodeBetween(pParse, pExpr, dest, 1, jumpIfNull);
76276 sqlite3ExprCodeIN(pParse, pExpr, destIfFalse, destIfNull);
76283 r1 = sqlite3ExprCodeTemp(pParse, pExpr, ®Free1);
76303 SQLITE_PRIVATE void sqlite3ExprIfFalse(Parse *pParse, Expr *pExpr, int dest, int jumpIfNull){
76312 if( pExpr==0 ) return;
76314 /* The value of pExpr->op and op are related as follows:
76316 ** pExpr->op op
76327 ** For other values of pExpr->op, op is undefined and unused.
76332 op = ((pExpr->op+(TK_ISNULL&1))^1)-(TK_ISNULL&1);
76336 assert( pExpr->op!=TK_ISNULL || op==OP_NotNull );
76337 assert( pExpr->op!=TK_NOTNULL || op==OP_IsNull );
76338 assert( pExpr->op!=TK_NE || op==OP_Eq );
76339 assert( pExpr->op!=TK_EQ || op==OP_Ne );
76340 assert( pExpr->op!=TK_LT || op==OP_Ge );
76341 assert( pExpr->op!=TK_LE || op==OP_Gt );
76342 assert( pExpr->op!=TK_GT || op==OP_Le );
76343 assert( pExpr->op!=TK_GE || op==OP_Lt );
76345 switch( pExpr->op ){
76348 sqlite3ExprIfFalse(pParse, pExpr->pLeft, dest, jumpIfNull);
76349 sqlite3ExprIfFalse(pParse, pExpr->pRight, dest, jumpIfNull);
76356 sqlite3ExprIfTrue(pParse, pExpr->pLeft, d2, jumpIfNull^SQLITE_JUMPIFNULL);
76357 sqlite3ExprIfFalse(pParse, pExpr->pRight, dest, jumpIfNull);
76364 sqlite3ExprIfTrue(pParse, pExpr->pLeft, dest, jumpIfNull);
76380 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1);
76381 r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, ®Free2);
76382 codeCompare(pParse, pExpr->pLeft, pExpr->pRight, op,
76390 testcase( pExpr->op==TK_IS );
76391 testcase( pExpr->op==TK_ISNOT );
76392 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1);
76393 r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, ®Free2);
76394 op = (pExpr->op==TK_IS) ? TK_NE : TK_EQ;
76395 codeCompare(pParse, pExpr->pLeft, pExpr->pRight, op,
76405 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1);
76412 exprCodeBetween(pParse, pExpr, dest, 0, jumpIfNull);
76418 sqlite3ExprCodeIN(pParse, pExpr, dest, dest);
76421 sqlite3ExprCodeIN(pParse, pExpr, dest, destIfNull);
76428 r1 = sqlite3ExprCodeTemp(pParse, pExpr, ®Free1);
76503 Expr *pExprA = pA->a[i].pExpr;
76504 Expr *pExprB = pB->a[i].pExpr;
76552 static int analyzeAggregate(Walker *pWalker, Expr *pExpr){
76559 switch( pExpr->op ){
76562 testcase( pExpr->op==TK_AGG_COLUMN );
76563 testcase( pExpr->op==TK_COLUMN );
76570 assert( !ExprHasAnyProperty(pExpr, EP_TokenOnly|EP_Reduced) );
76571 if( pExpr->iTable==pItem->iCursor ){
76572 /* If we reach this point, it means that pExpr refers to a table
76581 if( pCol->iTable==pExpr->iTable &&
76582 pCol->iColumn==pExpr->iColumn ){
76590 pCol->pTab = pExpr->pTab;
76591 pCol->iTable = pExpr->iTable;
76592 pCol->iColumn = pExpr->iColumn;
76595 pCol->pExpr = pExpr;
76602 Expr *pE = pTerm->pExpr;
76603 if( pE->op==TK_COLUMN && pE->iTable==pExpr->iTable &&
76604 pE->iColumn==pExpr->iColumn ){
76614 /* There is now an entry for pExpr in pAggInfo->aCol[] (either
76616 ** Convert the pExpr to be a TK_AGG_COLUMN referring to that
76619 ExprSetIrreducible(pExpr);
76620 pExpr->pAggInfo = pAggInfo;
76621 pExpr->op = TK_AGG_COLUMN;
76622 pExpr->iAgg = (i16)k;
76624 } /* endif pExpr->iTable==pItem->iCursor */
76633 /* Check to see if pExpr is a duplicate of another aggregate
76638 if( sqlite3ExprCompare(pItem->pExpr, pExpr)==0 ){
76643 /* pExpr is original. Make a new entry in pAggInfo->aFunc[]
76648 assert( !ExprHasProperty(pExpr, EP_xIsSelect) );
76650 pItem->pExpr = pExpr;
76652 assert( !ExprHasProperty(pExpr, EP_IntValue) );
76654 pExpr->u.zToken, sqlite3Strlen30(pExpr->u.zToken),
76655 pExpr->x.pList ? pExpr->x.pList->nExpr : 0, enc, 0);
76656 if( pExpr->flags & EP_Distinct ){
76663 /* Make pExpr point to the appropriate pAggInfo->aFunc[] entry
76665 assert( !ExprHasAnyProperty(pExpr, EP_TokenOnly|EP_Reduced) );
76666 ExprSetIrreducible(pExpr);
76667 pExpr->iAgg = (i16)i;
76668 pExpr->pAggInfo = pAggInfo;
76695 SQLITE_PRIVATE void sqlite3ExprAnalyzeAggregates(NameContext *pNC, Expr *pExpr){
76701 sqlite3WalkExpr(&w, pExpr);
76715 sqlite3ExprAnalyzeAggregates(pNC, pItem->pExpr);
78355 ** This only applies to the root node of pExpr, so the statement:
78361 static int resolveAttachExpr(NameContext *pName, Expr *pExpr)
78364 if( pExpr ){
78365 if( pExpr->op!=TK_ID ){
78366 rc = sqlite3ResolveExprNames(pName, pExpr);
78367 if( rc==SQLITE_OK && !sqlite3ExprIsConstant(pExpr) ){
78368 sqlite3ErrorMsg(pName->pParse, "invalid name: \"%s\"", pExpr->u.zToken);
78372 pExpr->op = TK_STRING;
78832 Expr *pExpr /* The expression to be fixed to one database */
78834 while( pExpr ){
78835 if( ExprHasAnyProperty(pExpr, EP_TokenOnly) ) break;
78836 if( ExprHasProperty(pExpr, EP_xIsSelect) ){
78837 if( sqlite3FixSelect(pFix, pExpr->x.pSelect) ) return 1;
78839 if( sqlite3FixExprList(pFix, pExpr->x.pList) ) return 1;
78841 if( sqlite3FixExpr(pFix, pExpr->pRight) ){
78844 pExpr = pExpr->pLeft;
78856 if( sqlite3FixExpr(pFix, pItem->pExpr) ){
78982 ** If SQLITE_IGNORE is returned and pExpr is not NULL, then pExpr is changed
78983 ** to an SQL NULL expression. Otherwise, if pExpr is NULL, then SQLITE_IGNORE
79011 ** The pExpr should be a TK_COLUMN expression. The table referred to
79021 Expr *pExpr, /* The expression to check authorization on */
79023 SrcList *pTabList /* All table that pExpr might refer to */
79040 assert( pExpr->op==TK_COLUMN || pExpr->op==TK_TRIGGER );
79041 if( pExpr->op==TK_TRIGGER ){
79046 if( pExpr->iTable==pTabList->a[iSrc].iCursor ){
79052 iCol = pExpr->iColumn;
79066 pExpr->op = TK_NULL;
80235 if( !sqlite3ExprIsConstantOrFunction(pSpan->pExpr) ){
80239 /* A copy of pExpr is used instead of the original, as pExpr contains
80244 pCol->pDflt = sqlite3ExprDup(db, pSpan->pExpr, EXPRDUP_REDUCE);
80250 sqlite3ExprDelete(db, pSpan->pExpr);
81760 Expr *pExpr = pList->a[i].pExpr;
81761 if( pExpr ){
81762 CollSeq *pColl = pExpr->pColl;
81836 /* Justification of the ALWAYS(pListItem->pExpr->pColl): Because of
81838 ** if pListItem->pExpr is not null then either pListItem->pExpr->pColl
81841 if( pListItem->pExpr && ALWAYS(pListItem->pExpr->pColl) ){
81843 zColl = pListItem->pExpr->pColl->zName;
85524 ** pExpr points to an expression which implements a function. If
85530 SQLITE_PRIVATE int sqlite3IsLikeFunction(sqlite3 *db, Expr *pExpr, int *pIsNocase, char *aWc){
85532 if( pExpr->op!=TK_FUNCTION
85533 || !pExpr->x.pList
85534 || pExpr->x.pList->nExpr!=2
85538 assert( !ExprHasProperty(pExpr, EP_xIsSelect) );
85539 pDef = sqlite3FindFunction(db, pExpr->u.zToken,
85540 sqlite3Strlen30(pExpr->u.zToken),
87555 if( sqlite3ResolveExprNames(&sNC, pList->a[i].pExpr) ){
87706 sqlite3ExprCode(pParse, pList->a[keyColumn].pExpr, regCols);
87735 sqlite3ExprCodeAndCache(pParse, pList->a[j].pExpr, regCols+i+1);
87773 sqlite3ExprCode(pParse, pList->a[keyColumn].pExpr, regRowid);
87840 sqlite3ExprCode(pParse, pList->a[j].pExpr, iRegStore);
88560 assert( pEList->a[0].pExpr );
88561 if( pEList->a[0].pExpr->op!=TK_ALL ){
93002 p->affinity = sqlite3CompareAffinity(pEList->a[0].pExpr, pDest->affinity);
93118 pColl = sqlite3ExprCollSeq(pParse, pItem->pExpr);
93330 ** expression pExpr. The string may be treated as static by the caller.
93348 Expr *pExpr,
93358 if( NEVER(pExpr==0) || pNC->pSrcList==0 ) return 0;
93360 switch( pExpr->op ){
93369 int iCol = pExpr->iColumn; /* Index of column in pTab */
93370 testcase( pExpr->op==TK_AGG_COLUMN );
93371 testcase( pExpr->op==TK_COLUMN );
93374 for(j=0;j<pTabList->nSrc && pTabList->a[j].iCursor!=pExpr->iTable;j++);
93404 assert( pTab && pExpr->pTab==pTab );
93416 Expr *p = pS->pEList->a[iCol].pExpr;
93449 Select *pS = pExpr->x.pSelect;
93450 Expr *p = pS->pEList->a[0].pExpr;
93451 assert( ExprHasProperty(pExpr, EP_xIsSelect) );
93486 Expr *p = pEList->a[i].pExpr;
93538 p = pEList->a[i].pExpr;
93611 p = pEList->a[i].pExpr;
93703 p = a[i].pExpr;
93855 pRet = sqlite3ExprCollSeq(pParse, p->pEList->a[iCol].pExpr);
94333 sqlite3CompareAffinity(p->pEList->a[0].pExpr, pDest->affinity);
94600 Expr *pTerm = pOrderBy->a[i].pExpr;
94849 ** Scan through the expression pExpr. Replace every reference to
94858 ** changes to pExpr so that it refers directly to the source table
94863 Expr *pExpr, /* Expr in which substitution occurs */
94867 if( pExpr==0 ) return 0;
94868 if( pExpr->op==TK_COLUMN && pExpr->iTable==iTable ){
94869 if( pExpr->iColumn<0 ){
94870 pExpr->op = TK_NULL;
94873 assert( pEList!=0 && pExpr->iColumn<pEList->nExpr );
94874 assert( pExpr->pLeft==0 && pExpr->pRight==0 );
94875 pNew = sqlite3ExprDup(db, pEList->a[pExpr->iColumn].pExpr, 0);
94876 if( pNew && pExpr->pColl ){
94877 pNew->pColl = pExpr->pColl;
94879 sqlite3ExprDelete(db, pExpr);
94880 pExpr = pNew;
94883 pExpr->pLeft = substExpr(db, pExpr->pLeft, iTable, pEList);
94884 pExpr->pRight = substExpr(db, pExpr->pRight, iTable, pEList);
94885 if( ExprHasProperty(pExpr, EP_xIsSelect) ){
94886 substSelect(db, pExpr->x.pSelect, iTable, pEList);
94888 substExprList(db, pExpr->x.pList, iTable, pEList);
94891 return pExpr;
94902 pList->a[i].pExpr = substExpr(db, pList->a[i].pExpr, iTable, pEList);
95426 Expr *pExpr;
95430 pExpr = pEList->a[0].pExpr;
95431 if( pExpr->op!=TK_AGG_FUNCTION ) return 0;
95432 if( NEVER(ExprHasProperty(pExpr, EP_xIsSelect)) ) return 0;
95433 pEList = pExpr->x.pList;
95435 if( pEList->a[0].pExpr->op!=TK_AGG_COLUMN ) return WHERE_ORDERBY_NORMAL;
95436 assert( !ExprHasProperty(pExpr, EP_IntValue) );
95437 if( sqlite3StrICmp(pExpr->u.zToken,"min")==0 ){
95439 }else if( sqlite3StrICmp(pExpr->u.zToken,"max")==0 ){
95458 Expr *pExpr;
95468 pExpr = p->pEList->a[0].pExpr;
95469 assert( pTab && !pTab->pSelect && pExpr );
95472 if( pExpr->op!=TK_AGG_FUNCTION ) return 0;
95474 if( pExpr->flags&EP_Distinct ) return 0;
95622 Expr *pE = pEList->a[k].pExpr;
95641 Expr *pE = a[k].pExpr;
95646 pNew = sqlite3ExprListAppend(pParse, pNew, a[k].pExpr);
95653 a[k].pExpr = 0;
95678 Expr *pExpr, *pRight;
95713 pExpr = sqlite3PExpr(pParse, TK_DOT, pLeft, pRight, 0);
95719 pExpr = pRight;
95721 pNew = sqlite3ExprListAppend(pParse, pNew, pExpr);
95891 Expr *pE = pFunc->pExpr;
95915 ExprList *pList = pF->pExpr->x.pList;
95916 assert( !ExprHasProperty(pF->pExpr, EP_xIsSelect) );
95938 ExprList *pList = pF->pExpr->x.pList;
95939 assert( !ExprHasProperty(pF->pExpr, EP_xIsSelect) );
95959 pColl = sqlite3ExprCollSeq(pParse, pItem->pExpr);
95989 sqlite3ExprCode(pParse, pC->pExpr, pC->iMem);
96379 CollSeq *pColl = sqlite3ExprCollSeq(pParse, pEList->a[iExpr].pExpr);
96454 assert( !ExprHasProperty(sAggInfo.aFunc[i].pExpr, EP_xIsSelect) );
96455 sqlite3ExprAnalyzeAggList(&sNC, sAggInfo.aFunc[i].pExpr->x.pList);
96590 sqlite3ExprCode(pParse, pGroupBy->a[j].pExpr, iBMem+j);
96762 assert( !ExprHasProperty(p->pEList->a[0].pExpr, EP_xIsSelect) );
96763 pMinMax = sqlite3ExprListDup(db, p->pEList->a[0].pExpr->x.pList,0);
96767 pMinMax->a[0].pExpr->op = TK_COLUMN;
96873 sqlite3PrintExpr(pList->a[i].pExpr);
98455 if( sqlite3ResolveExprNames(&sNC, pChanges->a[i].pExpr) ){
98462 pRowidExpr = pChanges->a[i].pExpr;
98471 pRowidExpr = pChanges->a[i].pExpr;
98692 sqlite3ExprCode(pParse, pChanges->a[j].pExpr, regNew+i);
98868 Expr *pExpr; /* Temporary expression */
98888 pExpr = sqlite3ExprDup(db, pChanges->a[aXRef[i]].pExpr, 0);
98890 pExpr = sqlite3Expr(db, TK_ID, pTab->aCol[i].zName);
98892 pEList = sqlite3ExprListAppend(pParse, pEList, pExpr);
100196 ** second parameter (pExpr) is the first argument to this function.
100197 ** If pExpr is a column in a virtual table, then let the virtual
100211 Expr *pExpr /* First argument to the function */
100225 if( NEVER(pExpr==0) ) return pDef;
100226 if( pExpr->op!=TK_COLUMN ) return pDef;
100227 pTab = pExpr->pTab;
100418 ** categories, then eOperator==0. The WhereTerm.pExpr field is still set
100440 Expr *pExpr; /* Pointer to the subexpression that is this term */
100452 Bitmask prereqRight; /* Bitmask of tables used by pExpr->pRight */
100453 Bitmask prereqAll; /* Bitmask of tables referenced by pExpr */
100459 #define TERM_DYNAMIC 0x01 /* Need to call sqlite3ExprDelete(db, pExpr) */
100648 sqlite3ExprDelete(db, a->pExpr);
100702 pTerm->pExpr = p;
100719 ** The original WHERE clause in pExpr is unaltered. All this routine
100720 ** does is make slot[] entries point to substructure within pExpr.
100726 static void whereSplit(WhereClause *pWC, Expr *pExpr, int op){
100728 if( pExpr==0 ) return;
100729 if( pExpr->op!=op ){
100730 whereClauseInsert(pWC, pExpr, 0);
100732 whereSplit(pWC, pExpr->pLeft, op);
100733 whereSplit(pWC, pExpr->pRight, op);
100807 mask |= exprTableUsage(pMaskSet, pList->a[i].pExpr);
100870 static void exprCommute(Parse *pParse, Expr *pExpr){
100871 u16 expRight = (pExpr->pRight->flags & EP_ExpCollate);
100872 u16 expLeft = (pExpr->pLeft->flags & EP_ExpCollate);
100873 assert( allowedOp(pExpr->op) && pExpr->op!=TK_IN );
100874 pExpr->pRight->pColl = sqlite3ExprCollSeq(pParse, pExpr->pRight);
100875 pExpr->pLeft->pColl = sqlite3ExprCollSeq(pParse, pExpr->pLeft);
100876 SWAP(CollSeq*,pExpr->pRight->pColl,pExpr->pLeft->pColl);
100877 pExpr->pRight->flags = (pExpr->pRight->flags & ~EP_ExpCollate) | expLeft;
100878 pExpr->pLeft->flags = (pExpr->pLeft->flags & ~EP_ExpCollate) | expRight;
100879 SWAP(Expr*,pExpr->pRight,pExpr->pLeft);
100880 if( pExpr->op>=TK_GT ){
100885 assert( pExpr->op>=TK_GT && pExpr->op<=TK_GE );
100886 pExpr->op = ((pExpr->op-TK_GT)^2)+TK_GT;
100939 Expr *pX = pTerm->pExpr;
100996 Expr *pExpr, /* Test this expression */
101011 if( !sqlite3IsLikeFunction(db, pExpr, pnoCase, wc) ){
101017 pList = pExpr->x.pList;
101018 pLeft = pList->a[1].pExpr;
101026 pRight = pList->a[0].pExpr;
101090 Expr *pExpr /* Test this expression */
101094 if( pExpr->op!=TK_FUNCTION ){
101097 if( sqlite3StrICmp(pExpr->u.zToken,"match")!=0 ){
101100 pList = pExpr->x.pList;
101104 if( pList->a[1].pExpr->op != TK_COLUMN ){
101205 Expr *pExpr = pTerm->pExpr; /* The expression of the term */
101220 assert( pExpr->op==TK_OR );
101226 whereSplit(pOrWc, pExpr, TK_OR);
101253 whereSplit(pAndWC, pOrTerm->pExpr, TK_AND);
101258 assert( pAndTerm->pExpr );
101259 if( allowedOp(pAndTerm->pExpr->op) ){
101375 affRight = sqlite3ExprAffinity(pOrTerm->pExpr->pRight);
101376 affLeft = sqlite3ExprAffinity(pOrTerm->pExpr->pLeft);
101403 pDup = sqlite3ExprDup(db, pOrTerm->pExpr->pRight, 0);
101405 pLeft = pOrTerm->pExpr->pLeft;
101412 transferJoinMarkings(pNew, pExpr);
101433 ** "pExpr" field filled in. The job of this routine is to analyze the
101444 ** and the new term is marked with TERM_DYNAMIC (because it's pExpr
101456 Expr *pExpr; /* The expression to be analyzed */
101457 Bitmask prereqLeft; /* Prerequesites of the pExpr->pLeft */
101458 Bitmask prereqAll; /* Prerequesites of pExpr */
101463 int op; /* Top-level operator. pExpr->op */
101472 pExpr = pTerm->pExpr;
101473 prereqLeft = exprTableUsage(pMaskSet, pExpr->pLeft);
101474 op = pExpr->op;
101476 assert( pExpr->pRight==0 );
101477 if( ExprHasProperty(pExpr, EP_xIsSelect) ){
101478 pTerm->prereqRight = exprSelectTableUsage(pMaskSet, pExpr->x.pSelect);
101480 pTerm->prereqRight = exprListTableUsage(pMaskSet, pExpr->x.pList);
101485 pTerm->prereqRight = exprTableUsage(pMaskSet, pExpr->pRight);
101487 prereqAll = exprTableUsage(pMaskSet, pExpr);
101488 if( ExprHasProperty(pExpr, EP_FromJoin) ){
101489 Bitmask x = getMask(pMaskSet, pExpr->iRightJoinTable);
101499 Expr *pLeft = pExpr->pLeft;
101500 Expr *pRight = pExpr->pRight;
101511 pDup = sqlite3ExprDup(db, pExpr, 0);
101524 pDup = pExpr;
101554 else if( pExpr->op==TK_BETWEEN && pWC->op==TK_AND ){
101555 ExprList *pList = pExpr->x.pList;
101564 sqlite3ExprDup(db, pExpr->pLeft, 0),
101565 sqlite3ExprDup(db, pList->a[i].pExpr, 0), 0);
101580 else if( pExpr->op==TK_OR ){
101599 && isLikeOrGlob(pParse, pExpr, &pStr1, &isComplete, &noCase)
101609 pLeft = pExpr->x.pList->a[1].pExpr;
101658 if( isMatchOfColumn(pExpr) ){
101664 pRight = pExpr->x.pList->a[0].pExpr;
101665 pLeft = pExpr->x.pList->a[1].pExpr;
101699 if( pExpr->op==TK_NOTNULL
101700 && pExpr->pLeft->op==TK_COLUMN
101701 && pExpr->pLeft->iColumn>=0
101704 Expr *pLeft = pExpr->pLeft;
101747 if( (exprTableUsage(pMaskSet, pList->a[iFirst++].pExpr)&allowed)!=0 ){
101775 Expr *p = pList->a[i].pExpr;
101826 Expr *p = pDistinct->a[i].pExpr;
101830 Expr *pX = pTerm->pExpr;
101878 Expr *p = pDistinct->a[i].pExpr;
101967 Expr *pExpr; /* The expression of the ORDER BY pTerm */
101968 CollSeq *pColl; /* The collating sequence of pExpr */
101974 pExpr = pTerm->pExpr;
101975 if( pExpr->op!=TK_COLUMN || pExpr->iTable!=base ){
101980 pColl = sqlite3ExprCollSeq(pParse, pExpr);
101996 if( pExpr->iColumn!=iColumn || sqlite3StrICmp(pColl->zName, zColl) ){
102234 if( !sqlite3IndexAffinityOk(pTerm->pExpr, aff) ) return 0;
102414 Expr *pX = pTerm->pExpr;
102508 Expr *pExpr = pOrderBy->a[i].pExpr;
102509 if( pExpr->op!=TK_COLUMN || pExpr->iTable!=pSrc->iCursor ) break;
102565 Expr *pExpr = pOrderBy->a[i].pExpr;
102566 pIdxOrderBy[i].iColumn = pExpr->iColumn;
102889 ** If expression pExpr represents a literal value, set *pp to point to
102895 ** If the current parse is a recompile (sqlite3Reprepare()) and pExpr
102907 Expr *pExpr,
102911 if( pExpr->op==TK_VARIABLE
102912 || (pExpr->op==TK_REGISTER && pExpr->op2==TK_VARIABLE)
102914 int iVar = pExpr->iColumn;
102919 return sqlite3ValueFromExpr(pParse->db, pExpr, SQLITE_UTF8, aff, pp);
102987 Expr *pExpr = pLower->pExpr->pRight;
102988 rc = valueFromExpr(pParse, pExpr, aff, &pLowerVal);
102993 Expr *pExpr = pUpper->pExpr->pRight;
102994 rc = valueFromExpr(pParse, pExpr, aff, &pUpperVal);
103048 ** for that index. When pExpr==NULL that means the constraint is
103063 Expr *pExpr, /* Expression for VALUE in the x=VALUE constraint */
103074 if( pExpr ){
103075 rc = valueFromExpr(pParse, pExpr, aff, &pRhs);
103141 rc = valueFromExpr(pParse, pList->a[i].pExpr, aff, &pVal);
103370 Expr *pExpr = pTerm->pExpr;
103372 if( ExprHasProperty(pExpr, EP_xIsSelect) ){
103376 }else if( ALWAYS(pExpr->x.pList && pExpr->x.pList->nExpr) ){
103378 nInMul *= pExpr->x.pList->nExpr;
103478 whereEqualScanEst(pParse, pProbe, pFirstTerm->pExpr->pRight, &nRow);
103480 whereInScanEst(pParse, pProbe, pFirstTerm->pExpr->x.pList, &nRow);
103732 && (pLevel->iLeftJoin==0 || ExprHasProperty(pTerm->pExpr, EP_FromJoin))
103801 Expr *pX = pTerm->pExpr;
103945 Expr *pRight = pTerm->pExpr->pRight;
104194 sqlite3ExprCode(pParse, pWC->a[iTerm].pExpr->pRight, iReg+j+1);
104228 assert( pTerm->pExpr!=0 );
104273 pX = pStart->pExpr;
104287 pX = pEnd->pExpr;
104397 /* assert( pOrderBy->a[0].pExpr->iColumn==pIdx->aiColumn[nEq] ); */
104443 Expr *pRight = pRangeStart->pExpr->pRight;
104483 Expr *pRight = pRangeEnd->pExpr->pRight;
104661 pSubWInfo = sqlite3WhereBegin(pParse, pOrTab, pOrTerm->pExpr, 0, 0,
104732 pE = pTerm->pExpr;
104757 assert( pTerm->pExpr );
104758 sqlite3ExprIfFalse(pParse, pTerm->pExpr, addrCont, SQLITE_JUMPIFNULL);
105614 pOut->pExpr = sqlite3PExpr(pParse, op, 0, 0, pValue);
105629 pOut->pExpr = sqlite3PExpr(pParse, op, pLeft->pExpr, pRight->pExpr, 0);
105643 pOut->pExpr = sqlite3PExpr(pParse, op, pOperand->pExpr, 0, 0);
105668 pOut->pExpr = sqlite3PExpr(pParse, op, pOperand->pExpr, 0, 0);
106933 sqlite3ExprDelete(pParse->db, (yypminor->yy118).pExpr);
107773 v.pExpr = sqlite3PExpr(pParse, TK_UMINUS, yymsp[0].minor.yy118.pExpr, 0, 0);
107796 {sqlite3AddCheckConstraint(pParse,yymsp[-1].minor.yy118.pExpr);}
107857 {sqlite3AddCheckConstraint(pParse,yymsp[-2].minor.yy118.pExpr);}
107937 yygotominor.yy322 = sqlite3ExprListAppend(pParse, yymsp[-2].minor.yy322, yymsp[-1].minor.yy118.pExpr);
108025 {yygotominor.yy314 = yymsp[0].minor.yy118.pExpr;}
108073 {yygotominor.yy292.pLimit = yymsp[0].minor.yy118.pExpr; yygotominor.yy292.pOffset = 0;}
108076 {yygotominor.yy292.pLimit = yymsp[-2].minor.yy118.pExpr; yygotominor.yy292.pOffset = yymsp[0].minor.yy118.pExpr;}
108079 {yygotominor.yy292.pOffset = yymsp[-2].minor.yy118.pExpr; yygotominor.yy292.pLimit = yymsp[0].minor.yy118.pExpr;}
108096 yygotominor.yy322 = sqlite3ExprListAppend(pParse, yymsp[-4].minor.yy322, yymsp[0].minor.yy118.pExpr);
108102 yygotominor.yy322 = sqlite3ExprListAppend(pParse, 0, yymsp[0].minor.yy118.pExpr);
108123 {yygotominor.yy322 = sqlite3ExprListAppend(pParse,yymsp[-2].minor.yy322,yymsp[0].minor.yy118.pExpr);}
108127 {yygotominor.yy322 = sqlite3ExprListAppend(pParse,0,yymsp[0].minor.yy118.pExpr);}
108139 {yygotominor.yy118.pExpr = yymsp[-1].minor.yy118.pExpr; spanSet(&yygotominor.yy118,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy0);}
108154 yygotominor.yy118.pExpr = sqlite3PExpr(pParse, TK_DOT, temp1, temp2, 0);
108164 yygotominor.yy118.pExpr = sqlite3PExpr(pParse, TK_DOT, temp1, temp4, 0);
108175 yygotominor.yy118.pExpr = 0;
108177 yygotominor.yy118.pExpr = sqlite3PExpr(pParse, TK_REGISTER, 0, 0, &yymsp[0].minor.yy0);
108178 if( yygotominor.yy118.pExpr ) sqlite3GetInt32(&yymsp[0].minor.yy0.z[1], &yygotominor.yy118.pExpr->iTable);
108186 sqlite3ExprAssignVarNumber(pParse, yygotominor.yy118.pExpr);
108192 yygotominor.yy118.pExpr = sqlite3ExprSetCollByToken(pParse, yymsp[-2].minor.yy118.pExpr, &yymsp[0].minor.yy0);
108199 yygotominor.yy118.pExpr = sqlite3PExpr(pParse, TK_CAST, yymsp[-3].minor.yy118.pExpr, 0, &yymsp[-1].minor.yy0);
108208 yygotominor.yy118.pExpr = sqlite3ExprFunction(pParse, yymsp[-1].minor.yy322, &yymsp[-4].minor.yy0);
108210 if( yymsp[-2].minor.yy4 && yygotominor.yy118.pExpr ){
108211 yygotominor.yy118.pExpr->flags |= EP_Distinct;
108217 yygotominor.yy118.pExpr = sqlite3ExprFunction(pParse, 0, &yymsp[-3].minor.yy0);
108225 yygotominor.yy118.pExpr = sqlite3ExprFunction(pParse, 0,&yymsp[0].minor.yy0);
108226 if( yygotominor.yy118.pExpr ){
108227 yygotominor.yy118.pExpr->op = TK_CONST_FUNC;
108253 pList = sqlite3ExprListAppend(pParse,0, yymsp[0].minor.yy118.pExpr);
108254 pList = sqlite3ExprListAppend(pParse,pList, yymsp[-2].minor.yy118.pExpr);
108255 yygotominor.yy118.pExpr = sqlite3ExprFunction(pParse, pList, &yymsp[-1].minor.yy342.eOperator);
108256 if( yymsp[-1].minor.yy342.not ) yygotominor.yy118.pExpr = sqlite3PExpr(pParse, TK_NOT, yygotominor.yy118.pExpr, 0, 0);
108259 if( yygotominor.yy118.pExpr ) yygotominor.yy118.pExpr->flags |= EP_InfixFunc;
108265 pList = sqlite3ExprListAppend(pParse,0, yymsp[-2].minor.yy118.pExpr);
108266 pList = sqlite3ExprListAppend(pParse,pList, yymsp[-4].minor.yy118.pExpr);
108267 pList = sqlite3ExprListAppend(pParse,pList, yymsp[0].minor.yy118.pExpr);
108268 yygotominor.yy118.pExpr = sqlite3ExprFunction(pParse, pList, &yymsp[-3].minor.yy342.eOperator);
108269 if( yymsp[-3].minor.yy342.not ) yygotominor.yy118.pExpr = sqlite3PExpr(pParse, TK_NOT, yygotominor.yy118.pExpr, 0, 0);
108272 if( yygotominor.yy118.pExpr ) yygotominor.yy118.pExpr->flags |= EP_InfixFunc;
108284 binaryToUnaryIfNull(pParse, yymsp[0].minor.yy118.pExpr, yygotominor.yy118.pExpr, TK_ISNULL);
108290 binaryToUnaryIfNull(pParse, yymsp[0].minor.yy118.pExpr, yygotominor.yy118.pExpr, TK_NOTNULL);
108305 ExprList *pList = sqlite3ExprListAppend(pParse,0, yymsp[-2].minor.yy118.pExpr);
108306 pList = sqlite3ExprListAppend(pParse,pList, yymsp[0].minor.yy118.pExpr);
108307 yygotominor.yy118.pExpr = sqlite3PExpr(pParse, TK_BETWEEN, yymsp[-4].minor.yy118.pExpr, 0, 0);
108308 if( yygotominor.yy118.pExpr ){
108309 yygotominor.yy118.pExpr->x.pList = pList;
108313 if( yymsp[-3].minor.yy4 ) yygotominor.yy118.pExpr = sqlite3PExpr(pParse, TK_NOT, yygotominor.yy118.pExpr, 0, 0);
108329 yygotominor.yy118.pExpr = sqlite3PExpr(pParse, TK_INTEGER, 0, 0, &sqlite3IntTokens[yymsp[-3].minor.yy4]);
108330 sqlite3ExprDelete(pParse->db, yymsp[-4].minor.yy118.pExpr);
108332 yygotominor.yy118.pExpr = sqlite3PExpr(pParse, TK_IN, yymsp[-4].minor.yy118.pExpr, 0, 0);
108333 if( yygotominor.yy118.pExpr ){
108334 yygotominor.yy118.pExpr->x.pList = yymsp[-1].minor.yy322;
108335 sqlite3ExprSetHeight(pParse, yygotominor.yy118.pExpr);
108339 if( yymsp[-3].minor.yy4 ) yygotominor.yy118.pExpr = sqlite3PExpr(pParse, TK_NOT, yygotominor.yy118.pExpr, 0, 0);
108347 yygotominor.yy118.pExpr = sqlite3PExpr(pParse, TK_SELECT, 0, 0, 0);
108348 if( yygotominor.yy118.pExpr ){
108349 yygotominor.yy118.pExpr->x.pSelect = yymsp[-1].minor.yy387;
108350 ExprSetProperty(yygotominor.yy118.pExpr, EP_xIsSelect);
108351 sqlite3ExprSetHeight(pParse, yygotominor.yy118.pExpr);
108361 yygotominor.yy118.pExpr = sqlite3PExpr(pParse, TK_IN, yymsp[-4].minor.yy118.pExpr, 0, 0);
108362 if( yygotominor.yy118.pExpr ){
108363 yygotominor.yy118.pExpr->x.pSelect = yymsp[-1].minor.yy387;
108364 ExprSetProperty(yygotominor.yy118.pExpr, EP_xIsSelect);
108365 sqlite3ExprSetHeight(pParse, yygotominor.yy118.pExpr);
108369 if( yymsp[-3].minor.yy4 ) yygotominor.yy118.pExpr = sqlite3PExpr(pParse, TK_NOT, yygotominor.yy118.pExpr, 0, 0);
108377 yygotominor.yy118.pExpr = sqlite3PExpr(pParse, TK_IN, yymsp[-3].minor.yy118.pExpr, 0, 0);
108378 if( yygotominor.yy118.pExpr ){
108379 yygotominor.yy118.pExpr->x.pSelect = sqlite3SelectNew(pParse, 0,pSrc,0,0,0,0,0,0,0);
108380 ExprSetProperty(yygotominor.yy118.pExpr, EP_xIsSelect);
108381 sqlite3ExprSetHeight(pParse, yygotominor.yy118.pExpr);
108385 if( yymsp[-2].minor.yy4 ) yygotominor.yy118.pExpr = sqlite3PExpr(pParse, TK_NOT, yygotominor.yy118.pExpr, 0, 0);
108392 Expr *p = yygotominor.yy118.pExpr = sqlite3PExpr(pParse, TK_EXISTS, 0, 0, 0);
108406 yygotominor.yy118.pExpr = sqlite3PExpr(pParse, TK_CASE, yymsp[-3].minor.yy314, yymsp[-1].minor.yy314, 0);
108407 if( yygotominor.yy118.pExpr ){
108408 yygotominor.yy118.pExpr->x.pList = yymsp[-2].minor.yy322;
108409 sqlite3ExprSetHeight(pParse, yygotominor.yy118.pExpr);
108419 yygotominor.yy322 = sqlite3ExprListAppend(pParse,yymsp[-4].minor.yy322, yymsp[-2].minor.yy118.pExpr);
108420 yygotominor.yy322 = sqlite3ExprListAppend(pParse,yygotominor.yy322, yymsp[0].minor.yy118.pExpr);
108425 yygotominor.yy322 = sqlite3ExprListAppend(pParse,0, yymsp[-2].minor.yy118.pExpr);
108426 yygotominor.yy322 = sqlite3ExprListAppend(pParse,yygotominor.yy322, yymsp[0].minor.yy118.pExpr);
108531 { yygotominor.yy314 = yymsp[0].minor.yy118.pExpr; }
108587 yygotominor.yy118.pExpr = sqlite3PExpr(pParse, TK_RAISE, 0, 0, 0);
108588 if( yygotominor.yy118.pExpr ){
108589 yygotominor.yy118.pExpr->affinity = OE_Ignore;
108597 yygotominor.yy118.pExpr = sqlite3PExpr(pParse, TK_RAISE, 0, 0, &yymsp[-1].minor.yy0);
108598 if( yygotominor.yy118.pExpr ) {
108599 yygotominor.yy118.pExpr->affinity = (char)yymsp[-3].minor.yy4;
108618 sqlite3Attach(pParse, yymsp[-3].minor.yy118.pExpr, yymsp[-1].minor.yy118.pExpr, yymsp[0].minor.yy314);
108623 sqlite3Detach(pParse, yymsp[0].minor.yy118.pExpr);
114247 Fts3Expr *pExpr; /* Parsed MATCH query string */
115531 sqlite3Fts3ExprFree(pCsr->pExpr);
116887 sqlite3Fts3ExprFree(pCsr->pExpr);
116906 iCol, zQuery, -1, &pCsr->pExpr
117510 ** by pExpr.
117525 Fts3Expr *pExpr, /* Allocate readers for this expression */
117530 if( pExpr && SQLITE_OK==*pRc ){
117531 if( pExpr->eType==FTSQUERY_PHRASE ){
117533 int nToken = pExpr->pPhrase->nToken;
117536 Fts3PhraseToken *pToken = &pExpr->pPhrase->aToken[i];
117545 assert( pExpr->pPhrase->iDoclistToken==0 );
117546 pExpr->pPhrase->iDoclistToken = -1;
117548 *pnOr += (pExpr->eType==FTSQUERY_OR);
117549 fts3EvalAllocateReaders(pCsr, pExpr->pLeft, pnToken, pnOr, pRc);
117550 fts3EvalAllocateReaders(pCsr, pExpr->pRight, pnToken, pnOr, pRc);
117947 Fts3Expr *pExpr, /* Expression to initialize phrases in */
117951 if( pExpr && SQLITE_OK==*pRc ){
117952 if( pExpr->eType==FTSQUERY_PHRASE ){
117954 int nToken = pExpr->pPhrase->nToken;
117956 if( pExpr->pPhrase->aToken[i].pDeferred==0 ) break;
117958 pExpr->bDeferred = (i==nToken);
117959 *pRc = fts3EvalPhraseStart(pCsr, bOptOk, pExpr->pPhrase);
117961 fts3EvalStartReaders(pCsr, pExpr->pLeft, bOptOk, pRc);
117962 fts3EvalStartReaders(pCsr, pExpr->pRight, bOptOk, pRc);
117963 pExpr->bDeferred = (pExpr->pLeft->bDeferred && pExpr->pRight->bDeferred);
118000 Fts3Expr *pExpr, /* Expression to consider */
118005 if( *pRc==SQLITE_OK && pExpr ){
118006 if( pExpr->eType==FTSQUERY_PHRASE ){
118007 Fts3Phrase *pPhrase = pExpr->pPhrase;
118018 }else if( pExpr->eType!=FTSQUERY_NOT ){
118019 if( pExpr->eType==FTSQUERY_OR ){
118020 pRoot = pExpr->pLeft;
118024 fts3EvalTokenCosts(pCsr, pRoot, pExpr->pLeft, ppTC, ppOr, pRc);
118025 if( pExpr->eType==FTSQUERY_OR ){
118026 pRoot = pExpr->pRight;
118030 fts3EvalTokenCosts(pCsr, pRoot, pExpr->pRight, ppTC, ppOr, pRc);
118213 ** the full-text query currently stored in pCsr->pExpr. To iterate through
118230 fts3EvalAllocateReaders(pCsr, pCsr->pExpr, &nToken, &nOr, &rc);
118249 fts3EvalTokenCosts(pCsr, 0, pCsr->pExpr, &pTC, &ppOr, &rc);
118264 fts3EvalStartReaders(pCsr, pCsr->pExpr, 1, &rc);
118343 ** successful, the following variables in pExpr are set:
118378 Fts3Expr *pExpr, /* Expr. to advance to next matching row */
118383 assert( pExpr->bEof==0 );
118384 pExpr->bStart = 1;
118386 switch( pExpr->eType ){
118389 Fts3Expr *pLeft = pExpr->pLeft;
118390 Fts3Expr *pRight = pExpr->pRight;
118397 pExpr->iDocid = pRight->iDocid;
118398 pExpr->bEof = pRight->bEof;
118403 pExpr->iDocid = pLeft->iDocid;
118404 pExpr->bEof = pLeft->bEof;
118418 pExpr->iDocid = pLeft->iDocid;
118419 pExpr->bEof = (pLeft->bEof || pRight->bEof);
118425 Fts3Expr *pLeft = pExpr->pLeft;
118426 Fts3Expr *pRight = pExpr->pRight;
118441 pExpr->bEof = (pLeft->bEof && pRight->bEof);
118444 pExpr->iDocid = pLeft->iDocid;
118446 pExpr->iDocid = pRight->iDocid;
118453 Fts3Expr *pLeft = pExpr->pLeft;
118454 Fts3Expr *pRight = pExpr->pRight;
118470 pExpr->iDocid = pLeft->iDocid;
118471 pExpr->bEof = pLeft->bEof;
118476 Fts3Phrase *pPhrase = pExpr->pPhrase;
118478 *pRc = fts3EvalPhraseNext(pCsr, pPhrase, &pExpr->bEof);
118479 pExpr->iDocid = pPhrase->doclist.iDocid;
118487 ** If *pRc is not SQLITE_OK, or if pExpr is not the root node of a NEAR
118501 static int fts3EvalNearTest(Fts3Expr *pExpr, int *pRc){
118504 /* The following block runs if pExpr is the root of a NEAR query.
118525 && pExpr->eType==FTSQUERY_NEAR
118526 && pExpr->bEof==0
118527 && (pExpr->pParent==0 || pExpr->pParent->eType!=FTSQUERY_NEAR)
118534 for(p=pExpr; p->pLeft; p=p->pLeft){
118552 aPoslist = pExpr->pRight->pPhrase->doclist.pList;
118553 nToken = pExpr->pRight->pPhrase->nToken;
118554 for(p=pExpr->pLeft; p && res; p=p->pLeft){
118582 Fts3Expr *pExpr, /* Expr to test. May or may not be root. */
118587 switch( pExpr->eType ){
118591 fts3EvalTestExpr(pCsr, pExpr->pLeft, pRc)
118592 && fts3EvalTestExpr(pCsr, pExpr->pRight, pRc)
118593 && fts3EvalNearTest(pExpr, pRc)
118612 && pExpr->eType==FTSQUERY_NEAR
118613 && (pExpr->pParent==0 || pExpr->pParent->eType!=FTSQUERY_NEAR)
118616 for(p=pExpr; p->pPhrase==0; p=p->pLeft){
118629 int bHit1 = fts3EvalTestExpr(pCsr, pExpr->pLeft, pRc);
118630 int bHit2 = fts3EvalTestExpr(pCsr, pExpr->pRight, pRc);
118637 fts3EvalTestExpr(pCsr, pExpr->pLeft, pRc)
118638 && !fts3EvalTestExpr(pCsr, pExpr->pRight, pRc)
118644 && (pExpr->iDocid==pCsr->iPrevId || pExpr->bDeferred)
118646 Fts3Phrase *pPhrase = pExpr->pPhrase;
118647 assert( pExpr->bDeferred || pPhrase->doclist.bFreeList==0 );
118648 if( pExpr->bDeferred ){
118653 pExpr->iDocid = pCsr->iPrevId;
118655 bHit = (pExpr->bEof==0 && pExpr->iDocid==pCsr->iPrevId);
118705 bMiss = (0==fts3EvalTestExpr(pCsr, pCsr->pExpr, &rc));
118716 ** Fts3Cursor.pExpr.
118720 Fts3Expr *pExpr = pCsr->pExpr;
118722 if( pExpr==0 ){
118730 fts3EvalNextRow(pCsr, pExpr, &rc);
118731 pCsr->isEof = pExpr->bEof;
118734 pCsr->iPrevId = pExpr->iDocid;
118741 ** Restart interation for expression pExpr so that the next call to
118751 Fts3Expr *pExpr,
118754 if( pExpr && *pRc==SQLITE_OK ){
118755 Fts3Phrase *pPhrase = pExpr->pPhrase;
118770 pExpr->iDocid = 0;
118771 pExpr->bEof = 0;
118772 pExpr->bStart = 0;
118774 fts3EvalRestart(pCsr, pExpr->pLeft, pRc);
118775 fts3EvalRestart(pCsr, pExpr->pRight, pRc);
118781 ** expression rooted at pExpr, the cursor iterates through all rows matched
118782 ** by pExpr, calling this function for each row. This function increments
118787 static void fts3EvalUpdateCounts(Fts3Expr *pExpr){
118788 if( pExpr ){
118789 Fts3Phrase *pPhrase = pExpr->pPhrase;
118806 pExpr->aMI[iCol*3 + 1] += iCnt;
118807 pExpr->aMI[iCol*3 + 2] += (iCnt>0);
118814 fts3EvalUpdateCounts(pExpr->pLeft);
118815 fts3EvalUpdateCounts(pExpr->pRight);
118820 ** Expression pExpr must be of type FTSQUERY_PHRASE.
118823 ** populates the Fts3Expr.aMI[] array for expression pExpr. If pExpr is part
118832 Fts3Expr *pExpr /* FTSQUERY_PHRASE expression */
118836 assert( pExpr->eType==FTSQUERY_PHRASE );
118837 if( pExpr->aMI==0 ){
118847 pRoot = pExpr;
118944 Fts3Expr *pExpr, /* Phrase expression */
118951 if( pExpr->bDeferred && pExpr->pParent->eType!=FTSQUERY_NEAR ){
118958 rc = fts3EvalGatherStats(pCsr, pExpr);
118960 assert( pExpr->aMI );
118962 aiOut[iCol*3 + 1] = pExpr->aMI[iCol*3 + 1];
118963 aiOut[iCol*3 + 2] = pExpr->aMI[iCol*3 + 2];
118972 ** The expression pExpr passed as the second argument to this function
118992 Fts3Expr *pExpr, /* Phrase to return doclist for */
118995 Fts3Phrase *pPhrase = pExpr->pPhrase;
119002 || pExpr->bEof
119003 || pExpr->iDocid!=pCsr->iPrevId
120362 static char *exprToString(Fts3Expr *pExpr, char *zBuf){
120363 switch( pExpr->eType ){
120365 Fts3Phrase *pPhrase = pExpr->pPhrase;
120379 zBuf = sqlite3_mprintf("%zNEAR/%d ", zBuf, pExpr->nNear);
120393 if( zBuf ) zBuf = exprToString(pExpr->pLeft, zBuf);
120396 if( zBuf ) zBuf = exprToString(pExpr->pRight, zBuf);
120429 Fts3Expr *pExpr;
120471 pTokenizer, azCol, nCol, nCol, zExpr, nExpr, &pExpr
120475 }else if( rc==SQLITE_NOMEM || !(zBuf = exprToString(pExpr, 0)) ){
120482 sqlite3Fts3ExprFree(pExpr);
125668 Fts3Expr *pExpr, /* Expression to iterate phrases of */
125674 int eType = pExpr->eType; /* Type of expression node pExpr */
125677 assert( pExpr->pLeft && pExpr->pRight );
125678 rc = fts3ExprIterate2(pExpr->pLeft, piPhrase, x, pCtx);
125680 rc = fts3ExprIterate2(pExpr->pRight, piPhrase, x, pCtx);
125683 rc = x(pExpr, *piPhrase, pCtx);
125700 Fts3Expr *pExpr, /* Expression to iterate phrases of */
125705 return fts3ExprIterate2(pExpr, &iPhrase, x, pCtx);
125713 static int fts3ExprLoadDoclistsCb(Fts3Expr *pExpr, int iPhrase, void *ctx){
125715 Fts3Phrase *pPhrase = pExpr->pPhrase;
125744 rc = fts3ExprIterate(pCsr->pExpr, fts3ExprLoadDoclistsCb, (void *)&sCtx);
125750 static int fts3ExprPhraseCountCb(Fts3Expr *pExpr, int iPhrase, void *ctx){
125752 UNUSED_PARAMETER(pExpr);
125756 static int fts3ExprPhraseCount(Fts3Expr *pExpr){
125758 (void)fts3ExprIterate(pExpr, fts3ExprPhraseCountCb, (void *)&nPhrase);
125888 static int fts3SnippetFindPositions(Fts3Expr *pExpr, int iPhrase, void *ctx){
125893 pPhrase->nToken = pExpr->pPhrase->nToken;
125895 pCsr = sqlite3Fts3EvalPhrasePoslist(p->pCsr, pExpr, p->iCol);
125970 (void)fts3ExprIterate(pCsr->pExpr, fts3SnippetFindPositions, (void *)&sIter);
126273 ** If the phrase pExpr consists entirely of deferred tokens, then all X and
126280 Fts3Expr *pExpr, /* Phrase expression node */
126286 p->pCursor, pExpr, &p->aMatchinfo[3*iPhrase*p->nCol]
126296 Fts3Expr *pExpr, /* Phrase expression node */
126306 pCsr = sqlite3Fts3EvalPhrasePoslist(p->pCursor, pExpr, i);
126395 Fts3Expr *pExpr; /* Pointer to phrase expression */
126408 Fts3Expr *pExpr, /* Phrase expression node */
126413 aIter[iPhrase].pExpr = pExpr;
126462 (void)fts3ExprIterate(pCsr->pExpr, fts3MatchinfoLcsCb, (void*)aIter);
126466 nToken -= pIter->pExpr->pPhrase->nToken;
126476 pIt->pRead = sqlite3Fts3EvalPhrasePoslist(pCsr, pIt->pExpr, iCol);
126605 Fts3Expr *pExpr;
126607 pExpr = pCsr->pExpr;
126615 rc = fts3ExprIterate(pExpr, fts3ExprGlobalHitsCb,(void*)pInfo);
126618 (void)fts3ExprIterate(pExpr, fts3ExprLocalHitsCb,(void*)pInfo);
126669 pCsr->nPhrase = fts3ExprPhraseCount(pCsr->pExpr);
126729 if( !pCsr->pExpr ){
126822 static int fts3ExprTermOffsetInit(Fts3Expr *pExpr, int iPhrase, void *ctx){
126830 pList = sqlite3Fts3EvalPhrasePoslist(p->pCsr, pExpr, p->iCol);
126831 nTerm = pExpr->pPhrase->nToken;
126864 if( !pCsr->pExpr ){
126902 (void)fts3ExprIterate(pCsr->pExpr, fts3ExprTermOffsetInit, (void *)&sCtx);
127011 if( !pCsr->pExpr ){
130531 URegularExpression *pExpr = (URegularExpression *)p;
130532 uregex_close(pExpr);
130556 URegularExpression *pExpr;
130569 pExpr = sqlite3_get_auxdata(p, 0);
130570 if( !pExpr ){
130575 pExpr = uregex_open(zPattern, -1, 0, 0, &status);
130578 sqlite3_set_auxdata(p, 0, pExpr, icuRegexpDelete);
130580 assert(!pExpr);
130587 uregex_setText(pExpr, zString, -1, &status);
130594 res = uregex_matches(pExpr, 0, &status);
130605 uregex_setText(pExpr, 0, 0, &status);