Lines Matching refs:pExpr
15182 Expr *pExpr; /* Used when p4type is P4_EXPR */ member
17870 Expr *pExpr; /* The original expression */ member
17877 Expr *pExpr; /* Expression encoding the function */ member
18153 Expr *pExpr; /* The parse tree for this expression */ member
19835 SQLITE_PRIVATE char sqlite3CompareAffinity(const Expr *pExpr, char aff2);
19836 SQLITE_PRIVATE int sqlite3IndexAffinityOk(const Expr *pExpr, char idx_affinity);
19838 SQLITE_PRIVATE char sqlite3ExprAffinity(const Expr *pExpr);
19862 SQLITE_PRIVATE CollSeq *sqlite3ExprCollSeq(Parse *pParse, const Expr *pExpr);
19863 SQLITE_PRIVATE CollSeq *sqlite3ExprNNCollSeq(Parse *pParse, const Expr *pExpr);
20303 SQLITE_PRIVATE int sqlite3ExprVectorSize(Expr *pExpr);
20304 SQLITE_PRIVATE int sqlite3ExprIsVector(Expr *pExpr);
29686 Expr *pExpr, /* Value for PRECEDING or FOLLOWING */
29702 sqlite3TreeViewExpr(pView, pExpr, 0);
29708 sqlite3TreeViewExpr(pView, pExpr, 0);
29797 SQLITE_PRIVATE void sqlite3TreeViewExpr(TreeView *pView, const Expr *pExpr, u8 moreToFollow){
29802 if( pExpr==0 ){
29807 if( pExpr->flags || pExpr->affExpr || pExpr->vvaFlags ){
29811 pExpr->flags, pExpr->affExpr ? pExpr->affExpr : 'n');
29812 if( ExprHasProperty(pExpr, EP_FromJoin) ){
29813 sqlite3_str_appendf(&x, " iRJT=%d", pExpr->iRightJoinTable);
29815 if( ExprHasProperty(pExpr, EP_FromDDL) ){
29818 if( ExprHasVVAProperty(pExpr, EP_Immutable) ){
29825 switch( pExpr->op ){
29828 pExpr->iTable, pExpr->iColumn, zFlgs);
29832 if( pExpr->iTable<0 ){
29835 if( pExpr->op2 ){
29836 sqlite3_snprintf(sizeof(zOp2),zOp2," op2=0x%02x",pExpr->op2);
29841 pExpr->iColumn, zFlgs, zOp2);
29844 pExpr->iTable, pExpr->iColumn,
29845 pExpr->y.pTab, zFlgs);
29847 if( ExprHasProperty(pExpr, EP_FixedCol) ){
29848 sqlite3TreeViewExpr(pView, pExpr->pLeft, 0);
29853 if( pExpr->flags & EP_IntValue ){
29854 sqlite3TreeViewLine(pView, "%d", pExpr->u.iValue);
29856 sqlite3TreeViewLine(pView, "%s", pExpr->u.zToken);
29862 sqlite3TreeViewLine(pView,"%s", pExpr->u.zToken);
29867 sqlite3TreeViewLine(pView,"%Q", pExpr->u.zToken);
29876 sqlite3ExprTruthValue(pExpr) ? "TRUE" : "FALSE");
29881 sqlite3TreeViewLine(pView,"%s", pExpr->u.zToken);
29887 pExpr->u.zToken, pExpr->iColumn);
29891 sqlite3TreeViewLine(pView,"REGISTER(%d)", pExpr->iTable);
29895 sqlite3TreeViewLine(pView,"ID \"%w\"", pExpr->u.zToken);
29901 sqlite3TreeViewLine(pView,"CAST %Q", pExpr->u.zToken);
29902 sqlite3TreeViewExpr(pView, pExpr->pLeft, 0);
29941 assert( pExpr->op2==TK_IS || pExpr->op2==TK_ISNOT );
29942 assert( pExpr->pRight );
29943 assert( sqlite3ExprSkipCollate(pExpr->pRight)->op==TK_TRUEFALSE );
29944 x = (pExpr->op2==TK_ISNOT)*2 + sqlite3ExprTruthValue(pExpr->pRight);
29950 sqlite3TreeViewLine(pView, "SPAN %Q", pExpr->u.zToken);
29951 sqlite3TreeViewExpr(pView, pExpr->pLeft, 0);
29962 !ExprHasProperty(pExpr, EP_Collate) ? "SOFT-" : "",
29963 pExpr->u.zToken, zFlgs);
29964 sqlite3TreeViewExpr(pView, pExpr->pLeft, 0);
29972 if( ExprHasProperty(pExpr, EP_TokenOnly) ){
29976 pFarg = pExpr->x.pList;
29978 pWin = ExprHasProperty(pExpr, EP_WinFunc) ? pExpr->y.pWin : 0;
29983 if( pExpr->op==TK_AGG_FUNCTION ){
29985 pExpr->op2, pExpr->u.zToken, zFlgs,
29986 pExpr->iAgg, pExpr->pAggInfo);
29987 }else if( pExpr->op2!=0 ){
29990 sqlite3_snprintf(sizeof(zBuf),zBuf,"0x%02x",pExpr->op2);
29992 if( pExpr->op2==NC_IsCheck ) zOp2 = "NC_IsCheck";
29993 if( pExpr->op2==NC_IdxExpr ) zOp2 = "NC_IdxExpr";
29994 if( pExpr->op2==NC_PartIdx ) zOp2 = "NC_PartIdx";
29995 if( pExpr->op2==NC_GenCol ) zOp2 = "NC_GenCol";
29997 pExpr->u.zToken, zFlgs, zOp2);
29999 sqlite3TreeViewLine(pView, "FUNCTION %Q%s", pExpr->u.zToken, zFlgs);
30013 sqlite3TreeViewLine(pView, "EXISTS-expr flags=0x%x", pExpr->flags);
30014 sqlite3TreeViewSelect(pView, pExpr->x.pSelect, 0);
30018 sqlite3TreeViewLine(pView, "SELECT-expr flags=0x%x", pExpr->flags);
30019 sqlite3TreeViewSelect(pView, pExpr->x.pSelect, 0);
30023 sqlite3TreeViewLine(pView, "IN flags=0x%x", pExpr->flags);
30024 sqlite3TreeViewExpr(pView, pExpr->pLeft, 1);
30025 if( ExprHasProperty(pExpr, EP_xIsSelect) ){
30026 sqlite3TreeViewSelect(pView, pExpr->x.pSelect, 0);
30028 sqlite3TreeViewExprList(pView, pExpr->x.pList, 0, 0);
30046 Expr *pX = pExpr->pLeft;
30047 Expr *pY = pExpr->x.pList->a[0].pExpr;
30048 Expr *pZ = pExpr->x.pList->a[1].pExpr;
30064 pExpr->iTable ? "NEW" : "OLD", pExpr->iColumn);
30069 sqlite3TreeViewExpr(pView, pExpr->pLeft, 1);
30070 sqlite3TreeViewExprList(pView, pExpr->x.pList, 0, 0);
30076 switch( pExpr->affExpr ){
30082 sqlite3TreeViewLine(pView, "RAISE %s(%Q)", zType, pExpr->u.zToken);
30088 pExpr->iTable, pExpr->iColumn, zFlgs);
30089 sqlite3TreeViewExpr(pView, pExpr->pRight, 0);
30094 sqlite3TreeViewBareExprList(pView, pExpr->x.pList, z);
30099 sqlite3TreeViewLine(pView, "SELECT-COLUMN %d", pExpr->iColumn);
30100 sqlite3TreeViewSelect(pView, pExpr->pLeft->x.pSelect, 0);
30104 sqlite3TreeViewLine(pView, "IF-NULL-ROW %d", pExpr->iTable);
30105 sqlite3TreeViewExpr(pView, pExpr->pLeft, 0);
30109 sqlite3TreeViewLine(pView, "op=%d", pExpr->op);
30115 sqlite3TreeViewExpr(pView, pExpr->pLeft, 1);
30116 sqlite3TreeViewExpr(pView, pExpr->pRight, 0);
30119 sqlite3TreeViewExpr(pView, pExpr->pLeft, 0);
30157 sqlite3TreeViewExpr(pView, pList->a[i].pExpr, moreToFollow);
77048 rc = sqlite3ValueFromExpr(db, pList->a[i].pExpr, enc, aff, &apVal[i]);
77108 Expr *pExpr, /* The expression to evaluate */
77121 assert( pExpr!=0 );
77122 while( (op = pExpr->op)==TK_UPLUS || op==TK_SPAN ) pExpr = pExpr->pLeft;
77124 if( op==TK_REGISTER ) op = pExpr->op2;
77126 if( NEVER(op==TK_REGISTER) ) op = pExpr->op2;
77133 assert( (pExpr->flags & EP_TokenOnly)==0 || pCtx==0 );
77136 u8 aff = sqlite3AffinityType(pExpr->u.zToken,0);
77137 rc = valueFromExpr(db, pExpr->pLeft, enc, aff, ppVal, pCtx);
77150 && (pExpr->pLeft->op==TK_INTEGER || pExpr->pLeft->op==TK_FLOAT) ){
77151 pExpr = pExpr->pLeft;
77152 op = pExpr->op;
77160 if( ExprHasProperty(pExpr, EP_IntValue) ){
77161 sqlite3VdbeMemSetInt64(pVal, (i64)pExpr->u.iValue*negInt);
77163 zVal = sqlite3MPrintf(db, "%s%s", zNeg, pExpr->u.zToken);
77183 if( SQLITE_OK==valueFromExpr(db,pExpr->pLeft,enc,affinity,&pVal,pCtx)
77209 assert( pExpr->u.zToken[0]=='x' || pExpr->u.zToken[0]=='X' );
77210 assert( pExpr->u.zToken[1]=='\'' );
77213 zVal = &pExpr->u.zToken[2];
77222 rc = valueFromFunction(db, pExpr, enc, affinity, &pVal, pCtx);
77229 pVal->u.i = pExpr->u.zToken[4]==0;
77263 Expr *pExpr, /* The expression to evaluate */
77268 return pExpr ? valueFromExpr(db, pExpr, enc, affinity, ppVal, 0) : 0;
77292 Expr *pExpr, /* The expression to extract a value from */
77302 pExpr = sqlite3ExprSkipCollate(pExpr);
77304 assert( pExpr==0 || pExpr->op!=TK_REGISTER || pExpr->op2!=TK_VARIABLE );
77305 if( !pExpr ){
77310 }else if( pExpr->op==TK_VARIABLE && (db->flags & SQLITE_EnableQPSG)==0 ){
77312 int iBindVar = pExpr->iColumn;
77323 rc = valueFromExpr(db, pExpr, ENC(db), affinity, &pVal, pAlloc);
77369 Expr *pExpr, /* The expression to extract a value from */
77377 if( pExpr==0 || pExpr->op!=TK_SELECT ){
77387 Expr *pElem = (pExpr ? sqlite3VectorFieldSubexpr(pExpr, i) : 0);
77412 Expr *pExpr, /* The expression to extract a value from */
77416 return stat4ValueFromExpr(pParse, pExpr, affinity, 0, ppVal);
79093 static void displayP4Expr(StrAccum *p, Expr *pExpr){
79095 switch( pExpr->op ){
79097 sqlite3_str_appendf(p, "%Q", pExpr->u.zToken);
79100 sqlite3_str_appendf(p, "%d", pExpr->u.iValue);
79106 sqlite3_str_appendf(p, "r[%d]", pExpr->iTable);
79110 if( pExpr->iColumn<0 ){
79113 sqlite3_str_appendf(p, "c%d", (int)pExpr->iColumn);
79151 displayP4Expr(p, pExpr->pLeft);
79152 if( pExpr->pRight ){
79154 displayP4Expr(p, pExpr->pRight);
79192 displayP4Expr(&x, pOp->p4.pExpr);
92942 pOp->p4.pExpr, aMem);
97347 static SQLITE_NOINLINE int walkExpr(Walker *pWalker, Expr *pExpr){
97349 testcase( ExprHasProperty(pExpr, EP_TokenOnly) );
97350 testcase( ExprHasProperty(pExpr, EP_Reduced) );
97352 rc = pWalker->xExprCallback(pWalker, pExpr);
97354 if( !ExprHasProperty(pExpr,(EP_TokenOnly|EP_Leaf)) ){
97355 assert( pExpr->x.pList==0 || pExpr->pRight==0 );
97356 if( pExpr->pLeft && walkExpr(pWalker, pExpr->pLeft) ) return WRC_Abort;
97357 if( pExpr->pRight ){
97358 assert( !ExprHasProperty(pExpr, EP_WinFunc) );
97359 pExpr = pExpr->pRight;
97361 }else if( ExprHasProperty(pExpr, EP_xIsSelect) ){
97362 assert( !ExprHasProperty(pExpr, EP_WinFunc) );
97363 if( sqlite3WalkSelect(pWalker, pExpr->x.pSelect) ) return WRC_Abort;
97365 if( pExpr->x.pList ){
97366 if( sqlite3WalkExprList(pWalker, pExpr->x.pList) ) return WRC_Abort;
97369 if( ExprHasProperty(pExpr, EP_WinFunc) ){
97370 if( walkWindowList(pWalker, pExpr->y.pWin) ) return WRC_Abort;
97379 SQLITE_PRIVATE int sqlite3WalkExpr(Walker *pWalker, Expr *pExpr){
97380 return pExpr ? walkExpr(pWalker,pExpr) : WRC_Continue;
97392 if( sqlite3WalkExpr(pWalker, pItem->pExpr) ) return WRC_Abort;
97558 static int incrAggDepth(Walker *pWalker, Expr *pExpr){
97559 if( pExpr->op==TK_AGG_FUNCTION ) pExpr->op2 += pWalker->u.n;
97562 static void incrAggFunctionDepth(Expr *pExpr, int N){
97568 sqlite3WalkExpr(&w, pExpr);
97595 Expr *pExpr, /* Transform this into an alias to the result set */
97604 pOrig = pEList->a[iCol].pExpr;
97610 if( pExpr->op==TK_COLLATE ){
97611 pDup = sqlite3ExprAddCollateString(pParse, pDup, pExpr->u.zToken);
97621 ExprSetProperty(pExpr, EP_Static);
97622 sqlite3ExprDelete(db, pExpr);
97623 memcpy(pExpr, pDup, sizeof(*pExpr));
97624 if( !ExprHasProperty(pExpr, EP_IntValue) && pExpr->u.zToken!=0 ){
97625 assert( (pExpr->flags & (EP_Reduced|EP_TokenOnly))==0 );
97626 pExpr->u.zToken = sqlite3DbStrDup(db, pExpr->u.zToken);
97627 pExpr->flags |= EP_MemToken;
97629 if( ExprHasProperty(pExpr, EP_WinFunc) ){
97630 if( pExpr->y.pWin!=0 ){
97631 pExpr->y.pWin->pOwner = pExpr;
97638 ExprSetProperty(pExpr, EP_Alias);
97712 SQLITE_PRIVATE Bitmask sqlite3ExprColUsed(Expr *pExpr){
97716 n = pExpr->iColumn;
97717 pExTab = pExpr->y.pTab;
97766 Expr *pExpr /* Make this EXPR node point to the selected column */
97783 assert( !ExprHasProperty(pExpr, EP_TokenOnly|EP_Reduced) );
97786 pExpr->iTable = -1;
97787 ExprSetVVAProperty(pExpr, EP_NoReduce);
97839 pExpr->iColumn = j;
97855 sqlite3RenameTokenRemap(pParse, 0, (void*)&pExpr->y.pTab);
97875 pExpr->iColumn = j==pTab->iPKey ? -1 : (i16)j;
97881 pExpr->iTable = pMatch->iCursor;
97882 pExpr->y.pTab = pMatch->pTab;
97886 ExprSetProperty(pExpr, EP_CanBeNull);
97888 pSchema = pExpr->y.pTab->pSchema;
97904 pExpr->iTable = 1;
97907 pExpr->iTable = 0;
97917 pExpr->iTable = 2;
97942 if( pExpr->iTable==2 ){
97945 pExpr->iColumn = iCol;
97946 pExpr->y.pTab = pTab;
97949 pExpr->iTable = pNC->uNC.pUpsert->regData + iCol;
97951 ExprSetProperty(pExpr, EP_Alias);
97958 pExpr->affExpr = SQLITE_AFF_INTEGER;
97959 }else if( pExpr->iTable==0 ){
97968 pExpr->y.pTab = pTab;
97969 pExpr->iColumn = (i16)iCol;
97989 pExpr->iColumn = -1;
97990 pExpr->affExpr = SQLITE_AFF_INTEGER;
98023 assert( pExpr->pLeft==0 && pExpr->pRight==0 );
98024 assert( pExpr->x.pList==0 );
98025 assert( pExpr->x.pSelect==0 );
98026 pOrig = pEList->a[j].pExpr;
98041 resolveAlias(pParse, pEList, j, pExpr, "", nSubquery);
98046 sqlite3RenameTokenRemap(pParse, 0, (void*)pExpr);
98073 assert( pExpr->op==TK_ID );
98074 if( ExprHasProperty(pExpr,EP_DblQuoted)
98096 pExpr->op = TK_STRING;
98097 pExpr->y.pTab = 0;
98100 if( sqlite3ExprIdToTrueFalse(pExpr) ){
98137 if( pExpr->iColumn>=0 && pMatch!=0 ){
98138 pMatch->colUsed |= sqlite3ExprColUsed(pExpr);
98143 sqlite3ExprDelete(db, pExpr->pLeft);
98144 pExpr->pLeft = 0;
98145 sqlite3ExprDelete(db, pExpr->pRight);
98146 pExpr->pRight = 0;
98147 pExpr->op = eNewExprOp;
98148 ExprSetProperty(pExpr, EP_Leaf);
98152 if( !ExprHasProperty(pExpr, EP_Alias) ){
98153 sqlite3AuthRead(pParse, pExpr, pSchema, pNC->pSrcList);
98219 Expr *pExpr /* Invalidate this expression on error */
98230 if( pExpr ) pExpr->op = TK_NULL;
98261 static int resolveExprStep(Walker *pWalker, Expr *pExpr){
98279 switch( pExpr->op ){
98292 pExpr->op = TK_COLUMN;
98293 pExpr->y.pTab = pItem->pTab;
98294 pExpr->iTable = pItem->iCursor;
98295 pExpr->iColumn = -1;
98296 pExpr->affExpr = SQLITE_AFF_INTEGER;
98317 if( pExpr->op==TK_ID ){
98320 zColumn = pExpr->u.zToken;
98322 Expr *pLeft = pExpr->pLeft;
98327 pRight = pExpr->pRight;
98339 sqlite3RenameTokenRemap(pParse, (void*)pExpr, (void*)pRight);
98340 sqlite3RenameTokenRemap(pParse, (void*)&pExpr->y.pTab, (void*)pLeft);
98343 return lookupName(pParse, zDb, zTable, zColumn, pNC, pExpr);
98349 ExprList *pList = pExpr->x.pList; /* The argument list */
98360 Window *pWin = (IsWindowFunc(pExpr) ? pExpr->y.pWin : 0);
98362 assert( !ExprHasProperty(pExpr, EP_xIsSelect) );
98363 zId = pExpr->u.zToken;
98376 ExprSetProperty(pExpr, EP_Unlikely);
98378 pExpr->iTable = exprProbability(pList->a[1].pExpr);
98379 if( pExpr->iTable<0 ){
98395 pExpr->iTable = pDef->zName[0]=='u' ? 8388608 : 125829120;
98407 pExpr->op = TK_NULL;
98417 ExprSetProperty(pExpr,EP_ConstFunc);
98430 pExpr->op2 = pNC->ncFlags & NC_SelfRef;
98431 if( pNC->ncFlags & NC_FromDDL ) ExprSetProperty(pExpr, EP_FromDDL);
98447 sqlite3ExprFunctionUsable(pParse, pExpr, pDef);
98497 else if( is_agg==0 && ExprHasProperty(pExpr, EP_WinFunc) ){
98517 else if( ExprHasProperty(pExpr, EP_WinFunc) ){
98526 assert( pWin==pExpr->y.pWin );
98539 pExpr->op = TK_AGG_FUNCTION;
98540 pExpr->op2 = 0;
98542 if( ExprHasProperty(pExpr, EP_WinFunc) ){
98543 sqlite3WalkExpr(pWalker, pExpr->y.pWin->pFilter);
98546 while( pNC2 && !sqlite3FunctionUsesThisSrc(pExpr, pNC2->pSrcList) ){
98547 pExpr->op2++;
98567 case TK_EXISTS: testcase( pExpr->op==TK_EXISTS );
98570 testcase( pExpr->op==TK_IN );
98571 if( ExprHasProperty(pExpr, EP_xIsSelect) ){
98578 NC_IsCheck|NC_PartIdx|NC_IdxExpr|NC_GenCol, pExpr);
98579 sqlite3WalkSelect(pWalker, pExpr->x.pSelect);
98582 ExprSetProperty(pExpr, EP_VarSelect);
98594 NC_IsCheck|NC_PartIdx|NC_IdxExpr|NC_GenCol, pExpr);
98599 Expr *pRight = sqlite3ExprSkipCollateAndLikely(pExpr->pRight);
98600 assert( !ExprHasProperty(pExpr, EP_Reduced) );
98607 pExpr->op2 = pExpr->op;
98608 pExpr->op = TK_TRUTH;
98623 assert( pExpr->pLeft!=0 );
98624 nLeft = sqlite3ExprVectorSize(pExpr->pLeft);
98625 if( pExpr->op==TK_BETWEEN ){
98626 nRight = sqlite3ExprVectorSize(pExpr->x.pList->a[0].pExpr);
98628 nRight = sqlite3ExprVectorSize(pExpr->x.pList->a[1].pExpr);
98631 assert( pExpr->pRight!=0 );
98632 nRight = sqlite3ExprVectorSize(pExpr->pRight);
98635 testcase( pExpr->op==TK_EQ );
98636 testcase( pExpr->op==TK_NE );
98637 testcase( pExpr->op==TK_LT );
98638 testcase( pExpr->op==TK_LE );
98639 testcase( pExpr->op==TK_GT );
98640 testcase( pExpr->op==TK_GE );
98641 testcase( pExpr->op==TK_IS );
98642 testcase( pExpr->op==TK_ISNOT );
98643 testcase( pExpr->op==TK_BETWEEN );
98739 if( sqlite3ExprCompare(0, pEList->a[i].pExpr, pE, -1)<2 ){
98811 pE = sqlite3ExprSkipCollateAndLikely(pItem->pExpr);
98855 if( pItem->pExpr==pE ){
98856 pItem->pExpr = pNew;
98858 Expr *pParent = pItem->pExpr;
98918 resolveAlias(pParse, pEList, pItem->u.x.iOrderByCol-1, pItem->pExpr,
98929 static int resolveRemoveWindowsCb(Walker *pWalker, Expr *pExpr){
98931 if( ExprHasProperty(pExpr, EP_WinFunc) ){
98932 Window *pWin = pExpr->y.pWin;
98942 static void windowRemoveExprFromSelect(Select *pSelect, Expr *pExpr){
98948 sqlite3WalkExpr(&sWalker, pExpr);
98989 Expr *pE = pItem->pExpr;
99020 if( sqlite3ExprCompare(0, pE, pSelect->pEList->a[j].pExpr, -1)==0 ){
99228 if( ExprHasProperty(pItem->pExpr, EP_Agg) ){
99322 Expr *pExpr /* The expression to be analyzed. */
99327 if( pExpr==0 ) return SQLITE_OK;
99336 w.pParse->nHeight += pExpr->nHeight;
99341 sqlite3WalkExpr(&w, pExpr);
99343 w.pParse->nHeight -= pExpr->nHeight;
99349 ExprSetProperty(pExpr, pNC->ncFlags & (NC_HasAgg|NC_HasWin) );
99375 Expr *pExpr = pList->a[i].pExpr;
99376 if( pExpr==0 ) continue;
99378 w.pParse->nHeight += pExpr->nHeight;
99383 sqlite3WalkExpr(&w, pExpr);
99385 w.pParse->nHeight -= pExpr->nHeight;
99392 ExprSetProperty(pExpr, pNC->ncFlags & (NC_HasAgg|NC_HasWin) );
99452 Expr *pExpr, /* Expression to resolve. May be NULL. */
99478 if( (rc = sqlite3ResolveExprNames(&sNC, pExpr))!=SQLITE_OK ) return rc;
99529 SQLITE_PRIVATE char sqlite3ExprAffinity(const Expr *pExpr){
99531 while( ExprHasProperty(pExpr, EP_Skip) ){
99532 assert( pExpr->op==TK_COLLATE || pExpr->op==TK_IF_NULL_ROW );
99533 pExpr = pExpr->pLeft;
99534 assert( pExpr!=0 );
99536 op = pExpr->op;
99538 assert( pExpr->flags&EP_xIsSelect );
99539 return sqlite3ExprAffinity(pExpr->x.pSelect->pEList->a[0].pExpr);
99541 if( op==TK_REGISTER ) op = pExpr->op2;
99544 assert( !ExprHasProperty(pExpr, EP_IntValue) );
99545 return sqlite3AffinityType(pExpr->u.zToken, 0);
99548 if( (op==TK_AGG_COLUMN || op==TK_COLUMN) && pExpr->y.pTab ){
99549 return sqlite3TableColumnAffinity(pExpr->y.pTab, pExpr->iColumn);
99552 assert( pExpr->pLeft->flags&EP_xIsSelect );
99554 pExpr->pLeft->x.pSelect->pEList->a[pExpr->iColumn].pExpr
99558 return sqlite3ExprAffinity(pExpr->x.pList->a[0].pExpr);
99560 return pExpr->affExpr;
99573 Expr *pExpr, /* Add the "COLLATE" clause to this expression */
99580 pNew->pLeft = pExpr;
99582 pExpr = pNew;
99585 return pExpr;
99587 SQLITE_PRIVATE Expr *sqlite3ExprAddCollateString(Parse *pParse, Expr *pExpr, const char *zC){
99591 return sqlite3ExprAddCollateToken(pParse, pExpr, &s, 0);
99597 SQLITE_PRIVATE Expr *sqlite3ExprSkipCollate(Expr *pExpr){
99598 while( pExpr && ExprHasProperty(pExpr, EP_Skip) ){
99599 assert( pExpr->op==TK_COLLATE || pExpr->op==TK_IF_NULL_ROW );
99600 pExpr = pExpr->pLeft;
99602 return pExpr;
99610 SQLITE_PRIVATE Expr *sqlite3ExprSkipCollateAndLikely(Expr *pExpr){
99611 while( pExpr && ExprHasProperty(pExpr, EP_Skip|EP_Unlikely) ){
99612 if( ExprHasProperty(pExpr, EP_Unlikely) ){
99613 assert( !ExprHasProperty(pExpr, EP_xIsSelect) );
99614 assert( pExpr->x.pList->nExpr>0 );
99615 assert( pExpr->op==TK_FUNCTION );
99616 pExpr = pExpr->x.pList->a[0].pExpr;
99618 assert( pExpr->op==TK_COLLATE || pExpr->op==TK_IF_NULL_ROW );
99619 pExpr = pExpr->pLeft;
99622 return pExpr;
99639 SQLITE_PRIVATE CollSeq *sqlite3ExprCollSeq(Parse *pParse, const Expr *pExpr){
99642 const Expr *p = pExpr;
99663 p = p->x.pList->a[0].pExpr;
99683 if( ExprHasProperty(p->x.pList->a[i].pExpr, EP_Collate) ){
99684 pNext = p->x.pList->a[i].pExpr;
99711 SQLITE_PRIVATE CollSeq *sqlite3ExprNNCollSeq(Parse *pParse, const Expr *pExpr){
99712 CollSeq *p = sqlite3ExprCollSeq(pParse, pExpr);
99732 SQLITE_PRIVATE char sqlite3CompareAffinity(const Expr *pExpr, char aff2){
99733 char aff1 = sqlite3ExprAffinity(pExpr);
99754 static char comparisonAffinity(const Expr *pExpr){
99756 assert( pExpr->op==TK_EQ || pExpr->op==TK_IN || pExpr->op==TK_LT ||
99757 pExpr->op==TK_GT || pExpr->op==TK_GE || pExpr->op==TK_LE ||
99758 pExpr->op==TK_NE || pExpr->op==TK_IS || pExpr->op==TK_ISNOT );
99759 assert( pExpr->pLeft );
99760 aff = sqlite3ExprAffinity(pExpr->pLeft);
99761 if( pExpr->pRight ){
99762 aff = sqlite3CompareAffinity(pExpr->pRight, aff);
99763 }else if( ExprHasProperty(pExpr, EP_xIsSelect) ){
99764 aff = sqlite3CompareAffinity(pExpr->x.pSelect->pEList->a[0].pExpr, aff);
99777 SQLITE_PRIVATE int sqlite3IndexAffinityOk(const Expr *pExpr, char idx_affinity){
99778 char aff = comparisonAffinity(pExpr);
99889 SQLITE_PRIVATE int sqlite3ExprIsVector(Expr *pExpr){
99890 return sqlite3ExprVectorSize(pExpr)>1;
99899 SQLITE_PRIVATE int sqlite3ExprVectorSize(Expr *pExpr){
99900 u8 op = pExpr->op;
99901 if( op==TK_REGISTER ) op = pExpr->op2;
99903 return pExpr->x.pList->nExpr;
99905 return pExpr->x.pSelect->pEList->nExpr;
99931 return pVector->x.pSelect->pEList->a[i].pExpr;
99933 return pVector->x.pList->a[i].pExpr;
99991 if( pVector->op==TK_VECTOR ) pVector = pVector->x.pList->a[iField].pExpr;
100006 static int exprCodeSubselect(Parse *pParse, Expr *pExpr){
100009 if( pExpr->op==TK_SELECT ){
100010 reg = sqlite3CodeSubselect(pParse, pExpr);
100049 *ppExpr = pVector->x.pSelect->pEList->a[iField].pExpr;
100052 *ppExpr = pVector->x.pList->a[iField].pExpr;
100069 Expr *pExpr, /* The comparison operation */
100075 Expr *pLeft = pExpr->pLeft;
100076 Expr *pRight = pExpr->pRight;
100083 int isCommuted = ExprHasProperty(pExpr,EP_Commuted);
100085 assert( !ExprHasVVAProperty(pExpr,EP_Immutable) );
100091 assert( pExpr->op==TK_EQ || pExpr->op==TK_NE
100092 || pExpr->op==TK_IS || pExpr->op==TK_ISNOT
100093 || pExpr->op==TK_LT || pExpr->op==TK_GT
100094 || pExpr->op==TK_LE || pExpr->op==TK_GE
100096 assert( pExpr->op==op || (pExpr->op==TK_IS && op==TK_EQ)
100097 || (pExpr->op==TK_ISNOT && op==TK_NE) );
100098 assert( p5==0 || pExpr->op!=op );
100099 assert( p5==SQLITE_NULLEQ || pExpr->op==op );
100184 heightOfExpr(p->a[i].pExpr, pnHeight);
100399 SQLITE_PRIVATE void sqlite3PExprAddSelect(Parse *pParse, Expr *pExpr, Select *pSelect){
100400 if( pExpr ){
100401 pExpr->x.pSelect = pSelect;
100402 ExprSetProperty(pExpr, EP_xIsSelect|EP_Subquery);
100403 sqlite3ExprSetHeightAndFlags(pParse, pExpr);
100478 Expr *pExpr, /* The function invocation */
100483 if( ExprHasProperty(pExpr, EP_FromDDL) ){
100515 SQLITE_PRIVATE void sqlite3ExprAssignVarNumber(Parse *pParse, Expr *pExpr, u32 n){
100520 if( pExpr==0 ) return;
100521 assert( !ExprHasProperty(pExpr, EP_IntValue|EP_Reduced|EP_TokenOnly) );
100522 z = pExpr->u.zToken;
100574 pExpr->iColumn = x;
100891 static int gatherSelectWindowsCallback(Walker *pWalker, Expr *pExpr){
100892 if( pExpr->op==TK_FUNCTION && ExprHasProperty(pExpr, EP_WinFunc) ){
100894 Window *pWin = pExpr->y.pWin;
100896 assert( IsWindowFunc(pExpr) );
100951 Expr *pOldExpr = pOldItem->pExpr;
100953 pItem->pExpr = sqlite3ExprDup(db, pOldExpr, flags);
100956 && (pNewExpr = pItem->pExpr)!=0
100964 assert( pItem[-1].pExpr!=0 );
100965 assert( pNewExpr->iColumn==pItem[-1].pExpr->iColumn+1 );
100966 assert( pPriorSelectCol==pItem[-1].pExpr->pLeft );
101120 Expr *pExpr /* Expression to be appended. Might be NULL */
101141 assert( offsetof(struct ExprList_item,zEName)==sizeof(pItem->pExpr) );
101142 assert( offsetof(struct ExprList_item,pExpr)==0 );
101144 pItem->pExpr = pExpr;
101149 sqlite3ExprDelete(db, pExpr);
101169 Expr *pExpr /* Vector expression to be appended. Might be NULL */
101178 if( pExpr==0 ) goto vector_append_error;
101185 if( pExpr->op!=TK_SELECT && pColumns->nId!=(n=sqlite3ExprVectorSize(pExpr)) ){
101192 Expr *pSubExpr = sqlite3ExprForVectorField(pParse, pExpr, i);
101205 if( !db->mallocFailed && pExpr->op==TK_SELECT && ALWAYS(pList!=0) ){
101206 Expr *pFirst = pList->a[iFirst].pExpr;
101212 pFirst->pRight = pExpr;
101213 pExpr = 0;
101221 sqlite3ExprUnmapAndDelete(pParse, pExpr);
101345 sqlite3ExprDelete(db, pItem->pExpr);
101364 Expr *pExpr = pList->a[i].pExpr;
101365 assert( pExpr!=0 );
101366 m |= pExpr->flags;
101404 SQLITE_PRIVATE int sqlite3ExprIdToTrueFalse(Expr *pExpr){
101406 assert( pExpr->op==TK_ID || pExpr->op==TK_STRING );
101407 if( !ExprHasProperty(pExpr, EP_Quoted)
101408 && (v = sqlite3IsTrueOrFalse(pExpr->u.zToken))!=0
101410 pExpr->op = TK_TRUEFALSE;
101411 ExprSetProperty(pExpr, v);
101421 SQLITE_PRIVATE int sqlite3ExprTruthValue(const Expr *pExpr){
101422 pExpr = sqlite3ExprSkipCollate((Expr*)pExpr);
101423 assert( pExpr->op==TK_TRUEFALSE );
101424 assert( sqlite3StrICmp(pExpr->u.zToken,"true")==0
101425 || sqlite3StrICmp(pExpr->u.zToken,"false")==0 );
101426 return pExpr->u.zToken[4]==0;
101442 SQLITE_PRIVATE Expr *sqlite3ExprSimplifiedAndOr(Expr *pExpr){
101443 assert( pExpr!=0 );
101444 if( pExpr->op==TK_AND || pExpr->op==TK_OR ){
101445 Expr *pRight = sqlite3ExprSimplifiedAndOr(pExpr->pRight);
101446 Expr *pLeft = sqlite3ExprSimplifiedAndOr(pExpr->pLeft);
101448 pExpr = pExpr->op==TK_AND ? pRight : pLeft;
101450 pExpr = pExpr->op==TK_AND ? pLeft : pRight;
101453 return pExpr;
101483 static int exprNodeIsConstant(Walker *pWalker, Expr *pExpr){
101488 if( pWalker->eCode==2 && ExprHasProperty(pExpr, EP_FromJoin) ){
101493 switch( pExpr->op ){
101498 if( (pWalker->eCode>=4 || ExprHasProperty(pExpr,EP_ConstFunc))
101499 && !ExprHasProperty(pExpr, EP_WinFunc)
101501 if( pWalker->eCode==5 ) ExprSetProperty(pExpr, EP_FromDDL);
101510 if( sqlite3ExprIdToTrueFalse(pExpr) ){
101517 testcase( pExpr->op==TK_ID );
101518 testcase( pExpr->op==TK_COLUMN );
101519 testcase( pExpr->op==TK_AGG_FUNCTION );
101520 testcase( pExpr->op==TK_AGG_COLUMN );
101521 if( ExprHasProperty(pExpr, EP_FixedCol) && pWalker->eCode!=2 ){
101524 if( pWalker->eCode==3 && pExpr->iTable==pWalker->u.iCur ){
101530 testcase( pExpr->op==TK_REGISTER );
101531 testcase( pExpr->op==TK_IF_NULL_ROW );
101539 pExpr->op = TK_NULL;
101548 testcase( pExpr->op==TK_SELECT ); /* sqlite3SelectWalkFail() disallows */
101549 testcase( pExpr->op==TK_EXISTS ); /* sqlite3SelectWalkFail() disallows */
101609 static int exprNodeIsConstantOrGroupBy(Walker *pWalker, Expr *pExpr){
101616 Expr *p = pGroupBy->a[i].pExpr;
101617 if( sqlite3ExprCompare(0, pExpr, p, -1)<2 ){
101626 if( ExprHasProperty(pExpr, EP_xIsSelect) ){
101631 return exprNodeIsConstant(pWalker, pExpr);
101875 Expr *pRes = pEList->a[i].pExpr;
102026 if( sqlite3ExprCanBeNull(pEList->a[i].pExpr) ) break;
102044 assert( p->pEList->a[0].pExpr!=0 ); /* Because of isCandidateForInOpt(p) */
102054 if( nExpr==1 && pEList->a[0].pExpr->iColumn<0 ){
102075 int iCol = pEList->a[i].pExpr->iColumn;
102118 Expr *pRhs = pEList->a[i].pExpr;
102222 static char *exprINAffinity(Parse *pParse, Expr *pExpr){
102223 Expr *pLeft = pExpr->pLeft;
102225 Select *pSelect = (pExpr->flags & EP_xIsSelect) ? pExpr->x.pSelect : 0;
102228 assert( pExpr->op==TK_IN );
102236 zRet[i] = sqlite3CompareAffinity(pSelect->pEList->a[i].pExpr, a);
102273 SQLITE_PRIVATE void sqlite3VectorErrorMsg(Parse *pParse, Expr *pExpr){
102275 if( pExpr->flags & EP_xIsSelect ){
102276 sqlite3SubselectError(pParse, pExpr->x.pSelect->pEList->nExpr, 1);
102309 Expr *pExpr, /* The IN operator */
102332 if( !ExprHasProperty(pExpr, EP_VarSelect) && pParse->iSelfTab==0 ){
102337 if( ExprHasProperty(pExpr, EP_Subrtn) ){
102339 if( ExprHasProperty(pExpr, EP_xIsSelect) ){
102341 pExpr->x.pSelect->selId));
102343 sqlite3VdbeAddOp2(v, OP_Gosub, pExpr->y.sub.regReturn,
102344 pExpr->y.sub.iAddr);
102345 sqlite3VdbeAddOp2(v, OP_OpenDup, iTab, pExpr->iTable);
102351 ExprSetProperty(pExpr, EP_Subrtn);
102352 assert( !ExprHasProperty(pExpr, EP_TokenOnly|EP_Reduced) );
102353 pExpr->y.sub.regReturn = ++pParse->nMem;
102354 pExpr->y.sub.iAddr =
102355 sqlite3VdbeAddOp2(v, OP_Integer, 0, pExpr->y.sub.regReturn) + 1;
102362 pLeft = pExpr->pLeft;
102368 pExpr->iTable = iTab;
102369 addr = sqlite3VdbeAddOp2(v, OP_OpenEphemeral, pExpr->iTable, nVal);
102371 if( ExprHasProperty(pExpr, EP_xIsSelect) ){
102372 VdbeComment((v, "Result of SELECT %u", pExpr->x.pSelect->selId));
102379 if( ExprHasProperty(pExpr, EP_xIsSelect) ){
102385 Select *pSelect = pExpr->x.pSelect;
102397 dest.zAffSdst = exprINAffinity(pParse, pExpr);
102414 pParse, p, pEList->a[i].pExpr
102418 }else if( ALWAYS(pExpr->x.pList!=0) ){
102428 ExprList *pList = pExpr->x.pList;
102439 pKeyInfo->aColl[0] = sqlite3ExprCollSeq(pParse, pExpr->pLeft);
102446 Expr *pE2 = pItem->pExpr;
102455 ExprClearProperty(pExpr, EP_Subrtn);
102473 sqlite3VdbeAddOp1(v, OP_Return, pExpr->y.sub.regReturn);
102474 sqlite3VdbeChangeP1(v, pExpr->y.sub.iAddr-1, sqlite3VdbeCurrentAddr(v)-1);
102495 SQLITE_PRIVATE int sqlite3CodeSubselect(Parse *pParse, Expr *pExpr){
102505 testcase( pExpr->op==TK_EXISTS );
102506 testcase( pExpr->op==TK_SELECT );
102507 assert( pExpr->op==TK_EXISTS || pExpr->op==TK_SELECT );
102508 assert( ExprHasProperty(pExpr, EP_xIsSelect) );
102509 pSel = pExpr->x.pSelect;
102521 if( !ExprHasProperty(pExpr, EP_VarSelect) ){
102524 if( ExprHasProperty(pExpr, EP_Subrtn) ){
102526 sqlite3VdbeAddOp2(v, OP_Gosub, pExpr->y.sub.regReturn,
102527 pExpr->y.sub.iAddr);
102528 return pExpr->iTable;
102532 ExprSetProperty(pExpr, EP_Subrtn);
102533 pExpr->y.sub.regReturn = ++pParse->nMem;
102534 pExpr->y.sub.iAddr =
102535 sqlite3VdbeAddOp2(v, OP_Integer, 0, pExpr->y.sub.regReturn) + 1;
102553 nReg = pExpr->op==TK_SELECT ? pSel->pEList->nExpr : 1;
102556 if( pExpr->op==TK_SELECT ){
102588 pExpr->iTable = rReg = dest.iSDParm;
102589 ExprSetVVAProperty(pExpr, EP_NoReduce);
102594 sqlite3VdbeAddOp1(v, OP_Return, pExpr->y.sub.regReturn);
102595 sqlite3VdbeChangeP1(v, pExpr->y.sub.iAddr-1, sqlite3VdbeCurrentAddr(v)-1);
102653 Expr *pExpr, /* The IN expression */
102676 assert( !ExprHasVVAProperty(pExpr,EP_Immutable) );
102677 pLeft = pExpr->pLeft;
102678 if( sqlite3ExprCheckIN(pParse, pExpr) ) return;
102679 zAff = exprINAffinity(pParse, pExpr);
102680 nVector = sqlite3ExprVectorSize(pExpr->pLeft);
102693 eType = sqlite3FindInIndex(pParse, pExpr,
102746 ExprList *pList = pExpr->x.pList;
102747 CollSeq *pColl = sqlite3ExprCollSeq(pParse, pExpr->pLeft);
102752 assert( !ExprHasProperty(pExpr, EP_xIsSelect) );
102758 r2 = sqlite3ExprCodeTemp(pParse, pList->a[ii].pExpr, ®ToFree);
102759 if( regCkNull && sqlite3ExprCanBeNull(pList->a[ii].pExpr) ){
102802 Expr *p = sqlite3VectorFieldSubexpr(pExpr->pLeft, i);
102925 static void codeInteger(Parse *pParse, Expr *pExpr, int negFlag, int iMem){
102927 if( pExpr->flags & EP_IntValue ){
102928 int i = pExpr->u.iValue;
102935 const char *z = pExpr->u.zToken;
102974 sqlite3ExprCodeCopy(pParse, pIdx->aColExpr->a[iIdxCol].pExpr, regOut);
103099 static void exprToRegister(Expr *pExpr, int iReg){
103100 Expr *p = sqlite3ExprSkipCollateAndLikely(pExpr);
103135 sqlite3ExprCodeFactorable(pParse, p->x.pList->a[i].pExpr, i+iResult);
103177 sqlite3ExprCode(pParse, pFarg->a[0].pExpr, target);
103181 sqlite3ExprCode(pParse, pFarg->a[i].pExpr, target);
103200 target = sqlite3ExprCodeTarget(pParse, pFarg->a[0].pExpr, target);
103212 sqlite3ExprCompare(0,pFarg->a[0].pExpr, pFarg->a[1].pExpr,-1),
103221 sqlite3ExprImpliesExpr(pParse,pFarg->a[0].pExpr, pFarg->a[1].pExpr,-1),
103230 pA1 = pFarg->a[1].pExpr;
103233 sqlite3ExprImpliesNonNullRow(pFarg->a[0].pExpr,pA1->iTable),
103250 aff = sqlite3ExprAffinity(pFarg->a[0].pExpr);
103272 SQLITE_PRIVATE int sqlite3ExprCodeTarget(Parse *pParse, Expr *pExpr, int target){
103289 if( pExpr==0 ){
103292 assert( !ExprHasVVAProperty(pExpr,EP_Immutable) );
103293 op = pExpr->op;
103297 AggInfo *pAggInfo = pExpr->pAggInfo;
103300 assert( pExpr->iAgg>=0 && pExpr->iAgg<pAggInfo->nColumn );
103301 pCol = &pAggInfo->aCol[pExpr->iAgg];
103322 int iTab = pExpr->iTable;
103324 if( ExprHasProperty(pExpr, EP_FixedCol) ){
103332 iReg = sqlite3ExprCodeTarget(pParse, pExpr->pLeft,target);
103333 if( pExpr->y.pTab ){
103334 aff = sqlite3TableColumnAffinity(pExpr->y.pTab, pExpr->iColumn);
103336 aff = pExpr->affExpr;
103356 Table *pTab = pExpr->y.pTab;
103358 int iCol = pExpr->iColumn;
103396 iReg = sqlite3ExprCodeGetColumn(pParse, pExpr->y.pTab,
103397 pExpr->iColumn, iTab, target,
103398 pExpr->op2);
103399 if( pExpr->y.pTab==0 && pExpr->affExpr==SQLITE_AFF_REAL ){
103405 codeInteger(pParse, pExpr, 0, target);
103409 sqlite3VdbeAddOp2(v, OP_Integer, sqlite3ExprTruthValue(pExpr), target);
103414 assert( !ExprHasProperty(pExpr, EP_IntValue) );
103415 codeReal(v, pExpr->u.zToken, 0, target);
103420 assert( !ExprHasProperty(pExpr, EP_IntValue) );
103421 sqlite3VdbeLoadString(v, target, pExpr->u.zToken);
103438 assert( !ExprHasProperty(pExpr, EP_IntValue) );
103439 assert( pExpr->u.zToken[0]=='x' || pExpr->u.zToken[0]=='X' );
103440 assert( pExpr->u.zToken[1]=='\'' );
103441 z = &pExpr->u.zToken[2];
103450 assert( !ExprHasProperty(pExpr, EP_IntValue) );
103451 assert( pExpr->u.zToken!=0 );
103452 assert( pExpr->u.zToken[0]!=0 );
103453 sqlite3VdbeAddOp2(v, OP_Variable, pExpr->iColumn, target);
103454 if( pExpr->u.zToken[1]!=0 ){
103455 const char *z = sqlite3VListNumToName(pParse->pVList, pExpr->iColumn);
103456 assert( pExpr->u.zToken[0]=='?' || (z && !strcmp(pExpr->u.zToken, z)) );
103463 return pExpr->iTable;
103468 inReg = sqlite3ExprCodeTarget(pParse, pExpr->pLeft, target);
103474 sqlite3AffinityType(pExpr->u.zToken, 0));
103489 Expr *pLeft = pExpr->pLeft;
103491 codeVectorCompare(pParse, pExpr, target, op, p5);
103494 r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, ®Free2);
103495 codeCompare(pParse, pLeft, pExpr->pRight, op,
103497 ExprHasProperty(pExpr,EP_Commuted));
103532 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1);
103533 r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, ®Free2);
103540 Expr *pLeft = pExpr->pLeft;
103547 assert( !ExprHasProperty(pExpr, EP_IntValue) );
103557 r2 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free2);
103567 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1);
103575 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1);
103577 isTrue = sqlite3ExprTruthValue(pExpr->pRight);
103578 bNormal = pExpr->op2==TK_IS;
103590 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1);
103600 AggInfo *pInfo = pExpr->pAggInfo;
103602 || NEVER(pExpr->iAgg<0)
103603 || NEVER(pExpr->iAgg>=pInfo->nFunc)
103605 assert( !ExprHasProperty(pExpr, EP_IntValue) );
103606 sqlite3ErrorMsg(pParse, "misuse of aggregate: %s()", pExpr->u.zToken);
103608 return pInfo->aFunc[pExpr->iAgg].iMem;
103624 if( ExprHasProperty(pExpr, EP_WinFunc) ){
103625 return pExpr->y.pWin->regResult;
103629 if( ConstFactorOk(pParse) && sqlite3ExprIsConstantNotJoin(pExpr) ){
103632 return sqlite3ExprCodeRunJustOnce(pParse, pExpr, -1);
103634 assert( !ExprHasProperty(pExpr, EP_xIsSelect) );
103635 assert( !ExprHasProperty(pExpr, EP_TokenOnly) );
103636 pFarg = pExpr->x.pList;
103638 assert( !ExprHasProperty(pExpr, EP_IntValue) );
103639 zId = pExpr->u.zToken;
103656 sqlite3ExprFunctionUsable(pParse, pExpr, pDef);
103660 if( i<32 && sqlite3ExprIsConstant(pFarg->a[i].pExpr) ){
103665 pColl = sqlite3ExprCollSeq(pParse, pFarg->a[i].pExpr);
103684 assert( pFarg->a[0].pExpr!=0 );
103685 exprOp = pFarg->a[0].pExpr->op;
103690 pFarg->a[0].pExpr->op2 =
103713 if( nFarg>=2 && ExprHasProperty(pExpr, EP_InfixFunc) ){
103714 pDef = sqlite3VtabOverloadFunction(db, pDef, nFarg, pFarg->a[1].pExpr);
103716 pDef = sqlite3VtabOverloadFunction(db, pDef, nFarg, pFarg->a[0].pExpr);
103725 Expr *pArg = pFarg->a[0].pExpr;
103735 pDef, pExpr->op2);
103752 if( op==TK_SELECT && (nCol = pExpr->x.pSelect->pEList->nExpr)!=1 ){
103755 return sqlite3CodeSubselect(pParse, pExpr);
103761 if( pExpr->pLeft->iTable==0 ){
103762 pExpr->pLeft->iTable = sqlite3CodeSubselect(pParse, pExpr->pLeft);
103764 assert( pExpr->iTable==0 || pExpr->pLeft->op==TK_SELECT );
103765 if( pExpr->iTable!=0
103766 && pExpr->iTable!=(n = sqlite3ExprVectorSize(pExpr->pLeft))
103769 pExpr->iTable, n);
103771 return pExpr->pLeft->iTable + pExpr->iColumn;
103777 sqlite3ExprCodeIN(pParse, pExpr, destIfFalse, destIfNull);
103799 exprCodeBetween(pParse, pExpr, target, 0, 0);
103805 pExpr = pExpr->pLeft;
103835 Table *pTab = pExpr->y.pTab;
103836 int iCol = pExpr->iColumn;
103837 int p1 = pExpr->iTable * (pTab->nCol+1) + 1
103840 assert( pExpr->iTable==0 || pExpr->iTable==1 );
103847 (pExpr->iTable ? "new" : "old"),
103848 (pExpr->iColumn<0 ? "rowid" : pExpr->y.pTab->aCol[iCol].zName)
103878 addrINR = sqlite3VdbeAddOp1(v, OP_IfNullRow, pExpr->iTable);
103884 inReg = sqlite3ExprCodeTarget(pParse, pExpr->pLeft, target);
103925 assert( !ExprHasProperty(pExpr, EP_xIsSelect) && pExpr->x.pList );
103926 assert(pExpr->x.pList->nExpr > 0);
103927 pEList = pExpr->x.pList;
103931 if( (pX = pExpr->pLeft)!=0 ){
103953 opCompare.pRight = aListelem[i].pExpr;
103955 pTest = aListelem[i].pExpr;
103960 testcase( aListelem[i+1].pExpr->op==TK_COLUMN );
103961 sqlite3ExprCode(pParse, aListelem[i+1].pExpr, target);
103966 sqlite3ExprCode(pParse, pEList->a[nExpr-1].pExpr, target);
103977 assert( pExpr->affExpr==OE_Rollback
103978 || pExpr->affExpr==OE_Abort
103979 || pExpr->affExpr==OE_Fail
103980 || pExpr->affExpr==OE_Ignore
103987 if( pExpr->affExpr==OE_Abort ){
103990 assert( !ExprHasProperty(pExpr, EP_IntValue) );
103991 if( pExpr->affExpr==OE_Ignore ){
103993 v, OP_Halt, SQLITE_OK, OE_Ignore, 0, pExpr->u.zToken,0);
103998 pExpr->affExpr, pExpr->u.zToken, 0, 0);
104029 Expr *pExpr, /* The expression to code when the VDBE initializes */
104039 if( pItem->reusable && sqlite3ExprCompare(0,pItem->pExpr,pExpr,-1)==0 ){
104044 pExpr = sqlite3ExprDup(pParse->db, pExpr, 0);
104045 if( pExpr!=0 && ExprHasProperty(pExpr, EP_HasFunc) ){
104053 sqlite3ExprCode(pParse, pExpr, regDest);
104056 sqlite3ExprDelete(pParse->db, pExpr);
104059 p = sqlite3ExprListAppend(pParse, p, pExpr);
104084 SQLITE_PRIVATE int sqlite3ExprCodeTemp(Parse *pParse, Expr *pExpr, int *pReg){
104086 pExpr = sqlite3ExprSkipCollateAndLikely(pExpr);
104088 && pExpr->op!=TK_REGISTER
104089 && sqlite3ExprIsConstantNotJoin(pExpr)
104092 r2 = sqlite3ExprCodeRunJustOnce(pParse, pExpr, -1);
104095 r2 = sqlite3ExprCodeTarget(pParse, pExpr, r1);
104111 SQLITE_PRIVATE void sqlite3ExprCode(Parse *pParse, Expr *pExpr, int target){
104114 assert( pExpr==0 || !ExprHasVVAProperty(pExpr,EP_Immutable) );
104116 inReg = sqlite3ExprCodeTarget(pParse, pExpr, target);
104120 if( ExprHasProperty(pExpr,EP_Subquery) ){
104134 SQLITE_PRIVATE void sqlite3ExprCodeCopy(Parse *pParse, Expr *pExpr, int target){
104136 pExpr = sqlite3ExprDup(db, pExpr, 0);
104137 if( !db->mallocFailed ) sqlite3ExprCode(pParse, pExpr, target);
104138 sqlite3ExprDelete(db, pExpr);
104147 SQLITE_PRIVATE void sqlite3ExprCodeFactorable(Parse *pParse, Expr *pExpr, int target){
104148 if( pParse->okConstFactor && sqlite3ExprIsConstantNotJoin(pExpr) ){
104149 sqlite3ExprCodeRunJustOnce(pParse, pExpr, target);
104151 sqlite3ExprCodeCopy(pParse, pExpr, target);
104192 Expr *pExpr = pItem->pExpr;
104207 && sqlite3ExprIsConstantNotJoin(pExpr)
104209 sqlite3ExprCodeRunJustOnce(pParse, pExpr, target+i);
104211 int inReg = sqlite3ExprCodeTarget(pParse, pExpr, target+i);
104252 Expr *pExpr, /* The BETWEEN expression */
104268 assert( !ExprHasProperty(pExpr, EP_xIsSelect) );
104269 pDel = sqlite3ExprDup(db, pExpr->pLeft, 0);
104276 compLeft.pRight = pExpr->x.pList->a[0].pExpr;
104279 compRight.pRight = pExpr->x.pList->a[1].pExpr;
104322 SQLITE_PRIVATE void sqlite3ExprIfTrue(Parse *pParse, Expr *pExpr, int dest, int jumpIfNull){
104331 if( NEVER(pExpr==0) ) return; /* No way this can happen */
104332 assert( !ExprHasVVAProperty(pExpr, EP_Immutable) );
104333 op = pExpr->op;
104337 Expr *pAlt = sqlite3ExprSimplifiedAndOr(pExpr);
104338 if( pAlt!=pExpr ){
104343 sqlite3ExprIfFalse(pParse, pExpr->pLeft, d2,
104345 sqlite3ExprIfTrue(pParse, pExpr->pRight, dest, jumpIfNull);
104349 sqlite3ExprIfTrue(pParse, pExpr->pLeft, dest, jumpIfNull);
104350 sqlite3ExprIfTrue(pParse, pExpr->pRight, dest, jumpIfNull);
104356 sqlite3ExprIfFalse(pParse, pExpr->pLeft, dest, jumpIfNull);
104363 isNot = pExpr->op2==TK_ISNOT;
104364 isTrue = sqlite3ExprTruthValue(pExpr->pRight);
104368 sqlite3ExprIfTrue(pParse, pExpr->pLeft, dest,
104371 sqlite3ExprIfFalse(pParse, pExpr->pLeft, dest,
104389 if( sqlite3ExprIsVector(pExpr->pLeft) ) goto default_expr;
104391 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1);
104392 r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, ®Free2);
104393 codeCompare(pParse, pExpr->pLeft, pExpr->pRight, op,
104394 r1, r2, dest, jumpIfNull, ExprHasProperty(pExpr,EP_Commuted));
104413 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1);
104422 exprCodeBetween(pParse, pExpr, dest, sqlite3ExprIfTrue, jumpIfNull);
104429 sqlite3ExprCodeIN(pParse, pExpr, destIfFalse, destIfNull);
104437 if( ExprAlwaysTrue(pExpr) ){
104439 }else if( ExprAlwaysFalse(pExpr) ){
104442 r1 = sqlite3ExprCodeTemp(pParse, pExpr, ®Free1);
104464 SQLITE_PRIVATE void sqlite3ExprIfFalse(Parse *pParse, Expr *pExpr, int dest, int jumpIfNull){
104473 if( pExpr==0 ) return;
104474 assert( !ExprHasVVAProperty(pExpr,EP_Immutable) );
104494 op = ((pExpr->op+(TK_ISNULL&1))^1)-(TK_ISNULL&1);
104498 assert( pExpr->op!=TK_ISNULL || op==OP_NotNull );
104499 assert( pExpr->op!=TK_NOTNULL || op==OP_IsNull );
104500 assert( pExpr->op!=TK_NE || op==OP_Eq );
104501 assert( pExpr->op!=TK_EQ || op==OP_Ne );
104502 assert( pExpr->op!=TK_LT || op==OP_Ge );
104503 assert( pExpr->op!=TK_LE || op==OP_Gt );
104504 assert( pExpr->op!=TK_GT || op==OP_Le );
104505 assert( pExpr->op!=TK_GE || op==OP_Lt );
104507 switch( pExpr->op ){
104510 Expr *pAlt = sqlite3ExprSimplifiedAndOr(pExpr);
104511 if( pAlt!=pExpr ){
104513 }else if( pExpr->op==TK_AND ){
104515 sqlite3ExprIfFalse(pParse, pExpr->pLeft, dest, jumpIfNull);
104516 sqlite3ExprIfFalse(pParse, pExpr->pRight, dest, jumpIfNull);
104520 sqlite3ExprIfTrue(pParse, pExpr->pLeft, d2,
104522 sqlite3ExprIfFalse(pParse, pExpr->pRight, dest, jumpIfNull);
104529 sqlite3ExprIfTrue(pParse, pExpr->pLeft, dest, jumpIfNull);
104536 isNot = pExpr->op2==TK_ISNOT;
104537 isTrue = sqlite3ExprTruthValue(pExpr->pRight);
104542 sqlite3ExprIfFalse(pParse, pExpr->pLeft, dest,
104547 sqlite3ExprIfTrue(pParse, pExpr->pLeft, dest,
104554 testcase( pExpr->op==TK_IS );
104555 testcase( pExpr->op==TK_ISNOT );
104556 op = (pExpr->op==TK_IS) ? TK_NE : TK_EQ;
104565 if( sqlite3ExprIsVector(pExpr->pLeft) ) goto default_expr;
104567 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1);
104568 r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, ®Free2);
104569 codeCompare(pParse, pExpr->pLeft, pExpr->pRight, op,
104570 r1, r2, dest, jumpIfNull,ExprHasProperty(pExpr,EP_Commuted));
104587 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1);
104596 exprCodeBetween(pParse, pExpr, dest, sqlite3ExprIfFalse, jumpIfNull);
104602 sqlite3ExprCodeIN(pParse, pExpr, dest, dest);
104605 sqlite3ExprCodeIN(pParse, pExpr, dest, destIfNull);
104613 if( ExprAlwaysFalse(pExpr) ){
104615 }else if( ExprAlwaysTrue(pExpr) ){
104618 r1 = sqlite3ExprCodeTemp(pParse, pExpr, ®Free1);
104636 SQLITE_PRIVATE void sqlite3ExprIfFalseDup(Parse *pParse, Expr *pExpr, int dest,int jumpIfNull){
104638 Expr *pCopy = sqlite3ExprDup(db, pExpr, 0);
104658 static int exprCompareVariable(Parse *pParse, Expr *pVar, Expr *pExpr){
104663 sqlite3ValueFromExpr(pParse->db, pExpr, SQLITE_UTF8, SQLITE_AFF_BLOB, &pR);
104801 Expr *pExprA = pA->a[i].pExpr;
104802 Expr *pExprB = pB->a[i].pExpr;
104850 if( exprImpliesNotNull(pParse, pList->a[0].pExpr, pNN, iTab, 1)
104851 || exprImpliesNotNull(pParse, pList->a[1].pExpr, pNN, iTab, 1)
104949 static int impliesNotNullRow(Walker *pWalker, Expr *pExpr){
104950 testcase( pExpr->op==TK_AGG_COLUMN );
104951 testcase( pExpr->op==TK_AGG_FUNCTION );
104952 if( ExprHasProperty(pExpr, EP_FromJoin) ) return WRC_Prune;
104953 switch( pExpr->op ){
104964 testcase( pExpr->op==TK_ISNOT );
104965 testcase( pExpr->op==TK_ISNULL );
104966 testcase( pExpr->op==TK_NOTNULL );
104967 testcase( pExpr->op==TK_IS );
104968 testcase( pExpr->op==TK_OR );
104969 testcase( pExpr->op==TK_VECTOR );
104970 testcase( pExpr->op==TK_CASE );
104971 testcase( pExpr->op==TK_IN );
104972 testcase( pExpr->op==TK_FUNCTION );
104973 testcase( pExpr->op==TK_TRUTH );
104976 if( pWalker->u.iCur==pExpr->iTable ){
104984 sqlite3WalkExpr(pWalker, pExpr->pLeft);
104987 sqlite3WalkExpr(pWalker, pExpr->pRight);
104993 if( sqlite3WalkExpr(pWalker, pExpr->pLeft)==WRC_Abort ){
105008 Expr *pLeft = pExpr->pLeft;
105009 Expr *pRight = pExpr->pRight;
105010 testcase( pExpr->op==TK_EQ );
105011 testcase( pExpr->op==TK_NE );
105012 testcase( pExpr->op==TK_LT );
105013 testcase( pExpr->op==TK_LE );
105014 testcase( pExpr->op==TK_GT );
105015 testcase( pExpr->op==TK_GE );
105091 static int exprIdxCover(Walker *pWalker, Expr *pExpr){
105092 if( pExpr->op==TK_COLUMN
105093 && pExpr->iTable==pWalker->u.pIdxCover->iCur
105094 && sqlite3TableColumnToIndex(pWalker->u.pIdxCover->pIdx, pExpr->iColumn)<0
105113 Expr *pExpr, /* The index to be tested */
105124 sqlite3WalkExpr(&w, pExpr);
105144 static int exprSrcCount(Walker *pWalker, Expr *pExpr){
105151 if( pExpr->op==TK_COLUMN || pExpr->op==TK_AGG_COLUMN ){
105157 if( pExpr->iTable==pSrc->a[i].iCursor ) break;
105161 }else if( nSrc==0 || pExpr->iTable<pSrc->a[0].iCursor ){
105177 SQLITE_PRIVATE int sqlite3FunctionUsesThisSrc(Expr *pExpr, SrcList *pSrcList){
105180 assert( pExpr->op==TK_AGG_FUNCTION );
105188 sqlite3WalkExprList(&w, pExpr->x.pList);
105190 if( ExprHasProperty(pExpr, EP_WinFunc) ){
105191 sqlite3WalkExpr(&w, pExpr->y.pWin->pFilter);
105234 static int analyzeAggregate(Walker *pWalker, Expr *pExpr){
105242 switch( pExpr->op ){
105245 testcase( pExpr->op==TK_AGG_COLUMN );
105246 testcase( pExpr->op==TK_COLUMN );
105253 assert( !ExprHasProperty(pExpr, EP_TokenOnly|EP_Reduced) );
105254 if( pExpr->iTable==pItem->iCursor ){
105264 if( pCol->iTable==pExpr->iTable &&
105265 pCol->iColumn==pExpr->iColumn ){
105273 pCol->pTab = pExpr->y.pTab;
105274 pCol->iTable = pExpr->iTable;
105275 pCol->iColumn = pExpr->iColumn;
105278 pCol->pExpr = pExpr;
105285 Expr *pE = pTerm->pExpr;
105286 if( pE->op==TK_COLUMN && pE->iTable==pExpr->iTable &&
105287 pE->iColumn==pExpr->iColumn ){
105302 ExprSetVVAProperty(pExpr, EP_NoReduce);
105303 pExpr->pAggInfo = pAggInfo;
105304 pExpr->op = TK_AGG_COLUMN;
105305 pExpr->iAgg = (i16)k;
105314 && pWalker->walkerDepth==pExpr->op2
105321 if( sqlite3ExprCompare(0, pItem->pExpr, pExpr, -1)==0 ){
105331 assert( !ExprHasProperty(pExpr, EP_xIsSelect) );
105333 pItem->pExpr = pExpr;
105335 assert( !ExprHasProperty(pExpr, EP_IntValue) );
105337 pExpr->u.zToken,
105338 pExpr->x.pList ? pExpr->x.pList->nExpr : 0, enc, 0);
105339 if( pExpr->flags & EP_Distinct ){
105348 assert( !ExprHasProperty(pExpr, EP_TokenOnly|EP_Reduced) );
105349 ExprSetVVAProperty(pExpr, EP_NoReduce);
105350 pExpr->iAgg = (i16)i;
105351 pExpr->pAggInfo = pAggInfo;
105370 SQLITE_PRIVATE void sqlite3ExprAnalyzeAggregates(NameContext *pNC, Expr *pExpr){
105379 sqlite3WalkExpr(&w, pExpr);
105393 sqlite3ExprAnalyzeAggregates(pNC, pItem->pExpr);
106238 static int renameUnmapExprCb(Walker *pWalker, Expr *pExpr){
106240 sqlite3RenameTokenRemap(pParse, 0, (void*)pExpr);
106311 SQLITE_PRIVATE void sqlite3RenameExprUnmap(Parse *pParse, Expr *pExpr){
106319 sqlite3WalkExpr(&sWalker, pExpr);
106396 static int renameColumnExprCb(Walker *pWalker, Expr *pExpr){
106398 if( pExpr->op==TK_TRIGGER
106399 && pExpr->iColumn==p->iCol
106402 renameTokenFind(pWalker->pParse, p, (void*)pExpr);
106403 }else if( pExpr->op==TK_COLUMN
106404 && pExpr->iColumn==p->iCol
106405 && p->pTab==pExpr->y.pTab
106407 renameTokenFind(pWalker->pParse, p, (void*)pExpr);
106955 static int renameTableExprCb(Walker *pWalker, Expr *pExpr){
106957 if( pExpr->op==TK_COLUMN && p->pTab==pExpr->y.pTab ){
106958 renameTokenFind(pWalker->pParse, p, (void*)&pExpr->y.pTab);
109186 static int resolveAttachExpr(NameContext *pName, Expr *pExpr)
109189 if( pExpr ){
109190 if( pExpr->op!=TK_ID ){
109191 rc = sqlite3ResolveExprNames(pName, pExpr);
109193 pExpr->op = TK_STRING;
109697 Expr *pExpr /* The expression to be fixed to one database */
109699 while( pExpr ){
109700 if( !pFix->bTemp ) ExprSetProperty(pExpr, EP_FromDDL);
109701 if( pExpr->op==TK_VARIABLE ){
109703 pExpr->op = TK_NULL;
109709 if( ExprHasProperty(pExpr, EP_TokenOnly|EP_Leaf) ) break;
109710 if( ExprHasProperty(pExpr, EP_xIsSelect) ){
109711 if( sqlite3FixSelect(pFix, pExpr->x.pSelect) ) return 1;
109713 if( sqlite3FixExprList(pFix, pExpr->x.pList) ) return 1;
109715 if( sqlite3FixExpr(pFix, pExpr->pRight) ){
109718 pExpr = pExpr->pLeft;
109730 if( sqlite3FixExpr(pFix, pItem->pExpr) ){
109914 Expr *pExpr, /* The expression to check authorization on */
109925 assert( pExpr->op==TK_COLUMN || pExpr->op==TK_TRIGGER );
109935 if( pExpr->op==TK_TRIGGER ){
109940 if( pExpr->iTable==pTabList->a[iSrc].iCursor ){
109946 iCol = pExpr->iColumn;
109960 pExpr->op = TK_NULL;
110263 sqlite3ExprCode(pParse, pEL->a[i].pExpr, pEL->a[i].u.iConstExprReg);
111465 Expr *pExpr, /* The parsed expression of the default value */
111476 if( !sqlite3ExprIsConstantOrFunction(pExpr, isInit) ){
111494 x.pLeft = pExpr;
111501 sqlite3RenameExprUnmap(pParse, pExpr);
111503 sqlite3ExprDelete(db, pExpr);
111589 Expr *pCExpr = sqlite3ExprSkipCollate(pList->a[i].pExpr);
111610 Expr *pCExpr = sqlite3ExprSkipCollate(pList->a[0].pExpr);
111698 SQLITE_PRIVATE void sqlite3AddGenerated(Parse *pParse, Expr *pExpr, Token *pType){
111730 pCol->pDflt = pExpr;
111731 pExpr = 0;
111738 sqlite3ExprDelete(pParse->db, pExpr);
111743 sqlite3ExprDelete(pParse->db, pExpr);
112094 sqlite3RenameTokenRemap(pParse, pList->a[0].pExpr, &pTab->iPKey);
112251 static int markImmutableExprStep(Walker *pWalker, Expr *pExpr){
112252 ExprSetVVAProperty(pExpr, EP_Immutable);
113717 Expr *pExpr = pList->a[i].pExpr;
113718 assert( pExpr!=0 );
113719 if( pExpr->op==TK_COLLATE ){
113720 nExtra += (1 + sqlite3Strlen30(pExpr->u.zToken));
113780 sqlite3StringToId(pListItem->pExpr);
113781 sqlite3ResolveSelfReference(pParse, pTab, NC_IdxExpr, pListItem->pExpr, 0);
113783 pCExpr = sqlite3ExprSkipCollate(pListItem->pExpr);
113813 if( pListItem->pExpr->op==TK_COLLATE ){
113815 zColl = pListItem->pExpr->u.zToken;
118512 SQLITE_PRIVATE int sqlite3IsLikeFunction(sqlite3 *db, Expr *pExpr, int *pIsNocase, char *aWc){
118515 if( pExpr->op!=TK_FUNCTION || !pExpr->x.pList ){
118518 assert( !ExprHasProperty(pExpr, EP_xIsSelect) );
118519 nExpr = pExpr->x.pList->nExpr;
118520 pDef = sqlite3FindFunction(db, pExpr->u.zToken, nExpr, SQLITE_UTF8, 0);
118540 Expr *pEscape = pExpr->x.pList->a[2].pExpr;
119175 Expr *pExpr;
119180 pExpr = sqlite3Expr(db, TK_REGISTER, 0);
119181 if( pExpr ){
119184 pExpr->iTable = regBase + sqlite3TableColumnToStorage(pTab,iCol) + 1;
119185 pExpr->affExpr = pCol->affinity;
119188 pExpr = sqlite3ExprAddCollateString(pParse, pExpr, zColl);
119190 pExpr->iTable = regBase;
119191 pExpr->affExpr = SQLITE_AFF_INTEGER;
119194 return pExpr;
119207 Expr *pExpr = sqlite3Expr(db, TK_COLUMN, 0);
119208 if( pExpr ){
119209 pExpr->y.pTab = pTab;
119210 pExpr->iTable = iCursor;
119211 pExpr->iColumn = iCol;
119213 return pExpr;
120248 aff = sqlite3ExprAffinity(pIdx->aColExpr->a[n].pExpr);
120356 static int exprColumnFlagUnion(Walker *pWalker, Expr *pExpr){
120357 if( pExpr->op==TK_COLUMN && pExpr->iColumn>=0 ){
120358 assert( pExpr->iColumn < pWalker->u.pTab->nCol );
120359 pWalker->eCode |= pWalker->u.pTab->aCol[pExpr->iColumn].colFlags;
121252 sqlite3ExprCode(pParse, pList->a[k].pExpr, iRegStore);
121278 sqlite3ExprCode(pParse, pList->a[ipkColumn].pExpr, regCols);
121335 Expr *pIpk = pList->a[ipkColumn].pExpr;
121340 sqlite3ExprCode(pParse, pList->a[ipkColumn].pExpr, regRowid);
121499 static int checkConstraintExprNode(Walker *pWalker, Expr *pExpr){
121500 if( pExpr->op==TK_COLUMN ){
121501 assert( pExpr->iColumn>=0 || pExpr->iColumn==-1 );
121502 if( pExpr->iColumn>=0 ){
121503 if( pWalker->u.aiCol[pExpr->iColumn]>=0 ){
121529 Expr *pExpr, /* The expression to be checked */
121538 sqlite3WalkExpr(&w, pExpr);
121814 Expr *pExpr = pCheck->a[i].pExpr;
121816 && !sqlite3ExprReferencesUpdatedColumn(pExpr, aiChng, pkChng)
121828 pCopy = sqlite3ExprDup(db, pExpr, 0);
122118 sqlite3ExprCodeCopy(pParse, pIdx->aColExpr->a[i].pExpr, regIdx+i);
122626 if( sqlite3ExprCompare(0, pSrc->aColExpr->a[i].pExpr,
122627 pDest->aColExpr->a[i].pExpr, -1)!=0 ){
122747 assert( pEList->a[0].pExpr );
122748 if( pEList->a[0].pExpr->op!=TK_ASTERISK ){
127009 sqlite3ExprIfFalse(pParse, pCheck->a[k].pExpr, addrCkFault, 0);
127011 sqlite3ExprIfTrue(pParse, pCheck->a[0].pExpr, addrCkOk,
129253 sqlite3SetJoinExpr(p->x.pList->a[i].pExpr, iTable);
129276 unsetJoinExpr(p->x.pList->a[i].pExpr, iTable);
129664 Expr *pExpr = pItem->pExpr;
129665 Table *pTab = pExpr->y.pTab;
129666 if( pExpr->op==TK_COLUMN && pExpr->iColumn>=0 && pTab && !IsVirtual(pTab)
129667 && (pTab->aCol[pExpr->iColumn].colFlags & COLFLAG_SORTERREF)
129671 if( pSort->aDefer[j].iCsr==pExpr->iTable ) break;
129687 pNew->iTable = pExpr->iTable;
129688 pNew->y.pTab = pExpr->y.pTab;
129693 pSort->aDefer[nDefer].pTab = pExpr->y.pTab;
129694 pSort->aDefer[nDefer].iCsr = pExpr->iTable;
129896 CollSeq *pColl = sqlite3ExprCollSeq(pParse, p->pEList->a[i].pExpr);
130213 pInfo->aColl[i-iStart] = sqlite3ExprNNCollSeq(pParse, pItem->pExpr);
130388 sqlite3ExprCode(pParse, aOutEx[i].pExpr, regRow+i);
130488 Expr *pExpr
130490 Expr *pExpr,
130504 assert( pExpr!=0 );
130506 switch( pExpr->op ){
130514 int iCol = pExpr->iColumn; /* Index of column in pTab */
130517 for(j=0;j<pTabList->nSrc && pTabList->a[j].iCursor!=pExpr->iTable;j++);
130547 assert( pTab && pExpr->y.pTab==pTab );
130559 Expr *p = pS->pEList->a[iCol].pExpr;
130601 Select *pS = pExpr->x.pSelect;
130602 Expr *p = pS->pEList->a[0].pExpr;
130603 assert( ExprHasProperty(pExpr, EP_xIsSelect) );
130641 Expr *p = pEList->a[i].pExpr;
130728 Expr *p = pEList->a[i].pExpr;
130822 Expr *pColExpr = sqlite3ExprSkipCollateAndLikely(pEList->a[i].pExpr);
130916 p = a[i].pExpr;
131080 pRet = sqlite3ExprCollSeq(pParse, p->pEList->a[iCol].pExpr);
131103 Expr *pTerm = pItem->pExpr;
131111 pOrderBy->a[i].pExpr =
132308 Expr *pExpr /* Expr in which substitution occurs */
132310 if( pExpr==0 ) return 0;
132311 if( ExprHasProperty(pExpr, EP_FromJoin)
132312 && pExpr->iRightJoinTable==pSubst->iTable
132314 pExpr->iRightJoinTable = pSubst->iNewTable;
132316 if( pExpr->op==TK_COLUMN
132317 && pExpr->iTable==pSubst->iTable
132318 && !ExprHasProperty(pExpr, EP_FixedCol)
132320 if( pExpr->iColumn<0 ){
132321 pExpr->op = TK_NULL;
132324 Expr *pCopy = pSubst->pEList->a[pExpr->iColumn].pExpr;
132326 assert( pSubst->pEList!=0 && pExpr->iColumn<pSubst->pEList->nExpr );
132327 assert( pExpr->pRight==0 );
132345 if( pNew && ExprHasProperty(pExpr,EP_FromJoin) ){
132346 pNew->iRightJoinTable = pExpr->iRightJoinTable;
132349 sqlite3ExprDelete(db, pExpr);
132350 pExpr = pNew;
132354 if( pExpr ){
132355 if( pExpr->op!=TK_COLUMN && pExpr->op!=TK_COLLATE ){
132356 CollSeq *pColl = sqlite3ExprCollSeq(pSubst->pParse, pExpr);
132357 pExpr = sqlite3ExprAddCollateString(pSubst->pParse, pExpr,
132361 ExprClearProperty(pExpr, EP_Collate);
132366 if( pExpr->op==TK_IF_NULL_ROW && pExpr->iTable==pSubst->iTable ){
132367 pExpr->iTable = pSubst->iNewTable;
132369 pExpr->pLeft = substExpr(pSubst, pExpr->pLeft);
132370 pExpr->pRight = substExpr(pSubst, pExpr->pRight);
132371 if( ExprHasProperty(pExpr, EP_xIsSelect) ){
132372 substSelect(pSubst, pExpr->x.pSelect, 1);
132374 substExprList(pSubst, pExpr->x.pList);
132377 if( ExprHasProperty(pExpr, EP_WinFunc) ){
132378 Window *pWin = pExpr->y.pWin;
132385 return pExpr;
132394 pList->a[i].pExpr = substExpr(pSubst, pList->a[i].pExpr);
132432 static int recomputeColumnsUsedExpr(Walker *pWalker, Expr *pExpr){
132434 if( pExpr->op!=TK_COLUMN ) return WRC_Continue;
132436 if( pItem->iCursor!=pExpr->iTable ) return WRC_Continue;
132437 if( pExpr->iColumn<0 ) return WRC_Continue;
132438 pItem->colUsed |= sqlite3ExprColUsed(pExpr);
133042 Expr *pExpr /* Overall expression: COLUMN=VALUE or VALUE=COLUMN */
133050 if( !sqlite3IsBinary(sqlite3ExprCompareCollSeq(pConst->pParse,pExpr)) ){
133083 static void findConstInWhere(WhereConst *pConst, Expr *pExpr){
133085 if( pExpr==0 ) return;
133086 if( ExprHasProperty(pExpr, EP_FromJoin) ) return;
133087 if( pExpr->op==TK_AND ){
133088 findConstInWhere(pConst, pExpr->pRight);
133089 findConstInWhere(pConst, pExpr->pLeft);
133092 if( pExpr->op!=TK_EQ ) return;
133093 pRight = pExpr->pRight;
133094 pLeft = pExpr->pLeft;
133098 constInsert(pConst,pRight,pLeft,pExpr);
133101 constInsert(pConst,pLeft,pRight,pExpr);
133111 static int propagateConstantExprRewrite(Walker *pWalker, Expr *pExpr){
133114 if( pExpr->op!=TK_COLUMN ) return WRC_Continue;
133115 if( ExprHasProperty(pExpr, EP_FixedCol|EP_FromJoin) ){
133116 testcase( ExprHasProperty(pExpr, EP_FixedCol) );
133117 testcase( ExprHasProperty(pExpr, EP_FromJoin) );
133123 if( pColumn==pExpr ) continue;
133124 if( pColumn->iTable!=pExpr->iTable ) continue;
133125 if( pColumn->iColumn!=pExpr->iColumn ) continue;
133128 ExprClearProperty(pExpr, EP_Leaf);
133129 ExprSetProperty(pExpr, EP_FixedCol);
133130 assert( pExpr->pLeft==0 );
133131 pExpr->pLeft = sqlite3ExprDup(pConst->pParse->db, pConst->apExpr[i*2+1], 0);
133358 if( sqlite3ExprCanBeNull(pEList->a[0].pExpr) ){
133386 Expr *pExpr;
133396 pExpr = p->pEList->a[0].pExpr;
133397 assert( pTab && !pTab->pSelect && pExpr );
133400 if( pExpr->op!=TK_AGG_FUNCTION ) return 0;
133403 if( ExprHasProperty(pExpr, EP_Distinct|EP_WinFunc) ) return 0;
133470 if( a[i].pExpr->flags & EP_Collate ) break;
133788 Expr *pE, *pRight, *pExpr;
133905 pE = pEList->a[k].pExpr;
133925 pE = a[k].pExpr;
133934 pNew = sqlite3ExprListAppend(pParse, pNew, a[k].pExpr);
133940 a[k].pExpr = 0;
134013 pExpr = sqlite3PExpr(pParse, TK_DOT, pLeft, pRight);
134016 pExpr = sqlite3PExpr(pParse, TK_DOT, pLeft, pExpr);
134023 pExpr = pRight;
134025 pNew = sqlite3ExprListAppend(pParse, pNew, pExpr);
134226 Expr *pE = pFunc->pExpr;
134250 ExprList *pList = pF->pExpr->x.pList;
134251 assert( !ExprHasProperty(pF->pExpr, EP_xIsSelect) );
134280 ExprList *pList = pF->pExpr->x.pList;
134281 assert( !ExprHasProperty(pF->pExpr, EP_xIsSelect) );
134282 assert( !IsWindowFunc(pF->pExpr) );
134283 if( ExprHasProperty(pF->pExpr, EP_WinFunc) ){
134284 Expr *pFilter = pF->pExpr->y.pWin->pFilter;
134323 pColl = sqlite3ExprCollSeq(pParse, pItem->pExpr);
134346 sqlite3ExprCode(pParse, pC->pExpr, pC->iMem);
134389 static int havingToWhereExprCb(Walker *pWalker, Expr *pExpr){
134390 if( pExpr->op!=TK_AND ){
134392 if( sqlite3ExprIsConstantOrGroupBy(pWalker->pParse, pExpr, pS->pGroupBy) ){
134397 SWAP(Expr, *pNew, *pExpr);
134497 Expr *pExpr;
134504 pExpr = p->pEList->a[0].pExpr;
134505 if( pExpr->op!=TK_AGG_FUNCTION ) return 0; /* Result is an aggregate */
134506 if( sqlite3_stricmp(pExpr->u.zToken,"count") ) return 0; /* Is count() */
134507 if( pExpr->x.pList!=0 ) return 0; /* Must be count(*) */
134523 pCount = pExpr;
134524 pExpr = 0;
134542 if( pExpr==0 ){
134543 pExpr = pTerm;
134545 pExpr = sqlite3PExpr(pParse, TK_PLUS, pTerm, pExpr);
134549 p->pEList->a[0].pExpr = pExpr;
135216 minMaxFlag = minMaxQuery(db, sAggInfo.aFunc[0].pExpr, &pMinMaxOrderBy);
135221 Expr *pExpr = sAggInfo.aFunc[i].pExpr;
135222 assert( !ExprHasProperty(pExpr, EP_xIsSelect) );
135224 sqlite3ExprAnalyzeAggList(&sNC, pExpr->x.pList);
135226 assert( !IsWindowFunc(pExpr) );
135227 if( ExprHasProperty(pExpr, EP_WinFunc) ){
135228 sqlite3ExprAnalyzeAggregates(&sNC, pExpr->y.pWin->pFilter);
135243 sqlite3TreeViewExpr(0, sAggInfo.aCol[ii].pExpr, 0);
135248 sqlite3TreeViewExpr(0, sAggInfo.aFunc[ii].pExpr, 0);
135392 sqlite3ExprCode(pParse, pGroupBy->a[j].pExpr, iBMem+j);
135552 if( ExprHasProperty(sAggInfo.aFunc[i].pExpr, EP_WinFunc) ) continue;
137150 assert( pIdx->aColExpr->a[iCol].pExpr!=0 );
137151 return sqlite3ExprReferencesUpdatedColumn(pIdx->aColExpr->a[iCol].pExpr,
137349 if( sqlite3ResolveExprNames(&sNC, pChanges->a[i].pExpr) ){
137356 pRowidExpr = pChanges->a[i].pExpr;
137378 pRowidExpr = pChanges->a[i].pExpr;
137755 sqlite3ExprCode(pParse, pChanges->a[j].pExpr, k);
138040 sqlite3ExprCode(pParse, pChanges->a[aXRef[i]].pExpr, regArg+2+i);
138236 && (pTerm = pTarget->a[0].pExpr)->op==TK_COLUMN
138270 Expr *pExpr;
138275 pExpr = pIdx->aColExpr->a[ii].pExpr;
138276 if( pExpr->op!=TK_COLLATE ){
138277 sCol[0].pLeft = pExpr;
138278 pExpr = &sCol[0];
138283 pExpr = &sCol[0];
138286 if( sqlite3ExprCompare(pParse, pTarget->a[jj].pExpr, pExpr,iCursor)<2 ){
139894 Expr *pExpr /* First argument to the function */
139905 if( NEVER(pExpr==0) ) return pDef;
139906 if( pExpr->op!=TK_COLUMN ) return pDef;
139907 pTab = pExpr->y.pTab;
140387 Expr *pExpr; /* Pointer to the subexpression that is this term */
140587 Expr *pExpr; /* The Expr node that was transformed */
141034 && (pLevel->iLeftJoin==0 || ExprHasProperty(pTerm->pExpr, EP_FromJoin))
141163 if( pLoop->aLTerm[i]->pExpr==pX ){
141165 if( pOrigRhs->a[iField].pExpr==0 ) continue; /* Duplicate PK column */
141166 pRhs = sqlite3ExprListAppend(pParse, pRhs, pOrigRhs->a[iField].pExpr);
141167 pOrigRhs->a[iField].pExpr = 0;
141168 assert( pOrigLhs->a[iField].pExpr!=0 );
141169 pLhs = sqlite3ExprListAppend(pParse, pLhs, pOrigLhs->a[iField].pExpr);
141170 pOrigLhs->a[iField].pExpr = 0;
141181 Expr *p = pLhs->a[0].pExpr;
141182 pLhs->a[0].pExpr = 0;
141235 Expr *pX = pTerm->pExpr;
141268 if( pLoop->aLTerm[i] && pLoop->aLTerm[i]->pExpr==pX ){
141275 if( pLoop->aLTerm[i]->pExpr==pX ) nEq++;
141288 pTerm->pExpr->iTable = iTab;
141291 pX = pTerm->pExpr;
141318 if( pLoop->aLTerm[i]->pExpr==pX ){
141473 if( pTerm->pExpr->flags & EP_xIsSelect ){
141481 Expr *pRight = pTerm->pExpr->pRight;
141556 static int codeCursorHintCheckExpr(Walker *pWalker, Expr *pExpr){
141559 if( pExpr->op==TK_COLUMN
141560 && pExpr->iTable==pHint->iTabCur
141561 && sqlite3TableColumnToIndex(pHint->pIdx, pExpr->iColumn)<0
141583 static int codeCursorHintIsOrFunction(Walker *pWalker, Expr *pExpr){
141584 if( pExpr->op==TK_IS
141585 || pExpr->op==TK_ISNULL || pExpr->op==TK_ISNOT
141586 || pExpr->op==TK_NOTNULL || pExpr->op==TK_CASE
141589 }else if( pExpr->op==TK_FUNCTION ){
141592 if( 0==sqlite3IsLikeFunction(pWalker->pParse->db, pExpr, &d1, d2) ){
141618 static int codeCursorHintFixExpr(Walker *pWalker, Expr *pExpr){
141621 if( pExpr->op==TK_COLUMN ){
141622 if( pExpr->iTable!=pHint->iTabCur ){
141624 sqlite3ExprCode(pWalker->pParse, pExpr, reg);
141625 pExpr->op = TK_REGISTER;
141626 pExpr->iTable = reg;
141628 pExpr->iTable = pHint->iIdxCur;
141629 pExpr->iColumn = sqlite3TableColumnToIndex(pHint->pIdx, pExpr->iColumn);
141630 assert( pExpr->iColumn>=0 );
141632 }else if( pExpr->op==TK_AGG_FUNCTION ){
141657 Expr *pExpr = 0;
141704 Expr *pExpr = pTerm->pExpr;
141705 if( !ExprHasProperty(pExpr, EP_FromJoin)
141706 || pExpr->iRightJoinTable!=pTabItem->iCursor
141710 sqlite3WalkExpr(&sWalker, pTerm->pExpr);
141714 if( ExprHasProperty(pTerm->pExpr, EP_FromJoin) ) continue;
141726 if( sqlite3ExprContainsSubquery(pTerm->pExpr) ) continue;
141733 sqlite3WalkExpr(&sWalker, pTerm->pExpr);
141738 pExpr = sqlite3ExprAnd(pParse, pExpr, sqlite3ExprDup(db, pTerm->pExpr, 0));
141740 if( pExpr!=0 ){
141742 sqlite3WalkExpr(&sWalker, pExpr);
141745 (const char*)pExpr, P4_EXPR);
141831 sqlite3ExprCode(pParse, pList->a[i].pExpr, iReg+i);
141857 static void preserveExpr(IdxExprTrans *pTrans, Expr *pExpr){
141863 pNew->pExpr = pExpr;
141864 memcpy(&pNew->orig, pExpr, sizeof(*pExpr));
141873 static int whereIndexExprTransNode(Walker *p, Expr *pExpr){
141875 if( sqlite3ExprCompare(0, pExpr, pX->pIdxExpr, pX->iTabCur)==0 ){
141876 preserveExpr(pX, pExpr);
141877 pExpr->affExpr = sqlite3ExprAffinity(pExpr);
141878 pExpr->op = TK_COLUMN;
141879 pExpr->iTable = pX->iIdxCur;
141880 pExpr->iColumn = pX->iIdxCol;
141881 pExpr->y.pTab = 0;
141882 testcase( ExprHasProperty(pExpr, EP_Skip) );
141883 testcase( ExprHasProperty(pExpr, EP_Unlikely) );
141884 ExprClearProperty(pExpr, EP_Skip|EP_Unlikely);
141895 static int whereIndexExprTransColumn(Walker *p, Expr *pExpr){
141896 if( pExpr->op==TK_COLUMN ){
141898 if( pExpr->iTable==pX->iTabCur && pExpr->iColumn==pX->iTabCol ){
141899 assert( pExpr->y.pTab!=0 );
141900 preserveExpr(pX, pExpr);
141901 pExpr->affExpr = sqlite3TableColumnAffinity(pExpr->y.pTab,pExpr->iColumn);
141902 pExpr->iTable = pX->iIdxCur;
141903 pExpr->iColumn = pX->iIdxCol;
141904 pExpr->y.pTab = 0;
141947 assert( aColExpr->a[iIdxCol].pExpr!=0 );
141948 x.pIdxExpr = aColExpr->a[iIdxCol].pExpr;
141995 Expr *pExpr;
141997 pExpr = pTerm->pExpr;
141998 if( sqlite3ExprCompare(0, pExpr, pTruth, iTabCur)==0 ){
142118 Expr *pRight = pTerm->pExpr->pRight;
142139 && sqlite3ExprVectorSize(pTerm->pExpr->pLeft)==1
142165 pCompare->pLeft = pTerm->pExpr->pLeft;
142200 assert( pTerm->pExpr!=0 );
142253 pX = pStart->pExpr;
142287 pX = pEnd->pExpr;
142489 Expr *pRight = pRangeStart->pExpr->pRight;
142567 Expr *pRight = pRangeEnd->pExpr->pRight;
142860 Expr *pExpr = pWC->a[iTerm].pExpr;
142867 pExpr = sqlite3ExprDup(db, pExpr, 0);
142868 pAndExpr = sqlite3ExprAnd(pParse, pAndExpr, pExpr);
142890 Expr *pOrExpr = pOrTerm->pExpr; /* Current OR clause term */
143079 pE = pTerm->pExpr;
143144 pE = pTerm->pExpr;
143158 && (pAlt->pExpr->flags & EP_xIsSelect)
143159 && (pAlt->pExpr->x.pSelect->pEList->nExpr>1)
143167 sEAlt = *pAlt->pExpr;
143187 assert( pTerm->pExpr );
143188 sqlite3ExprIfFalse(pParse, pTerm->pExpr, addrCont, SQLITE_JUMPIFNULL);
143295 pTerm->pExpr = sqlite3ExprSkipCollateAndLikely(p);
143321 static u16 exprCommute(Parse *pParse, Expr *pExpr){
143322 if( pExpr->pLeft->op==TK_VECTOR
143323 || pExpr->pRight->op==TK_VECTOR
143324 || sqlite3BinaryCompareCollSeq(pParse, pExpr->pLeft, pExpr->pRight) !=
143325 sqlite3BinaryCompareCollSeq(pParse, pExpr->pRight, pExpr->pLeft)
143327 pExpr->flags ^= EP_Commuted;
143329 SWAP(Expr*,pExpr->pRight,pExpr->pLeft);
143330 if( pExpr->op>=TK_GT ){
143335 assert( pExpr->op>=TK_GT && pExpr->op<=TK_GE );
143336 pExpr->op = ((pExpr->op-TK_GT)^2)+TK_GT;
143384 Expr *pExpr, /* Test this expression */
143400 if( !sqlite3IsLikeFunction(db, pExpr, pnoCase, (char*)wc) ){
143406 pList = pExpr->x.pList;
143407 pLeft = pList->a[1].pExpr;
143409 pRight = sqlite3ExprSkipCollate(pList->a[0].pExpr);
143556 Expr *pExpr, /* Test this expression */
143561 if( pExpr->op==TK_FUNCTION ){
143575 pList = pExpr->x.pList;
143587 pCol = pList->a[1].pExpr;
143591 if( sqlite3StrICmp(pExpr->u.zToken, aOp[i].zOp)==0 ){
143593 *ppRight = pList->a[0].pExpr;
143610 pCol = pList->a[0].pExpr;
143622 i = pMod->xFindFunction(pVtab,2, pExpr->u.zToken, &xNotUsed, &pNotUsed);
143625 *ppRight = pList->a[1].pExpr;
143631 }else if( pExpr->op==TK_NE || pExpr->op==TK_ISNOT || pExpr->op==TK_NOTNULL ){
143633 Expr *pLeft = pExpr->pLeft;
143634 Expr *pRight = pExpr->pRight;
143646 if( pExpr->op==TK_NE ) *peOp2 = SQLITE_INDEX_CONSTRAINT_NE;
143647 if( pExpr->op==TK_ISNOT ) *peOp2 = SQLITE_INDEX_CONSTRAINT_ISNOT;
143648 if( pExpr->op==TK_NOTNULL ) *peOp2 = SQLITE_INDEX_CONSTRAINT_ISNOTNULL;
143726 assert( pOne->pExpr->pLeft!=0 && pOne->pExpr->pRight!=0 );
143727 assert( pTwo->pExpr->pLeft!=0 && pTwo->pExpr->pRight!=0 );
143728 if( sqlite3ExprCompare(0,pOne->pExpr->pLeft, pTwo->pExpr->pLeft, -1) ) return;
143729 if( sqlite3ExprCompare(0,pOne->pExpr->pRight, pTwo->pExpr->pRight,-1) )return;
143740 pNew = sqlite3ExprDup(db, pOne->pExpr, 0);
143845 Expr *pExpr = pTerm->pExpr; /* The expression of the term */
143859 assert( pExpr->op==TK_OR );
143866 sqlite3WhereSplit(pOrWc, pExpr, TK_OR);
143893 sqlite3WhereSplit(pAndWC, pOrTerm->pExpr, TK_AND);
143898 assert( pAndTerm->pExpr );
143899 if( allowedOp(pAndTerm->pExpr->op)
144011 pLeft = pOrTerm->pExpr->pLeft;
144032 && sqlite3ExprCompare(pParse, pOrTerm->pExpr->pLeft, pLeft, -1)
144041 affRight = sqlite3ExprAffinity(pOrTerm->pExpr->pRight);
144042 affLeft = sqlite3ExprAffinity(pOrTerm->pExpr->pLeft);
144067 pDup = sqlite3ExprDup(db, pOrTerm->pExpr->pRight, 0);
144069 pLeft = pOrTerm->pExpr->pLeft;
144076 transferJoinMarkings(pNew, pExpr);
144107 static int termIsEquivalence(Parse *pParse, Expr *pExpr){
144111 if( pExpr->op!=TK_EQ && pExpr->op!=TK_IS ) return 0;
144112 if( ExprHasProperty(pExpr, EP_FromJoin) ) return 0;
144113 aff1 = sqlite3ExprAffinity(pExpr->pLeft);
144114 aff2 = sqlite3ExprAffinity(pExpr->pRight);
144120 pColl = sqlite3ExprCompareCollSeq(pParse, pExpr);
144122 return sqlite3ExprCollSeqMatch(pParse, pExpr->pLeft, pExpr->pRight);
144171 Expr *pExpr /* An operand of a comparison operator */
144182 if( sqlite3ExprCompareSkip(pExpr, pIdx->aColExpr->a[i].pExpr, iCur)==0 ){
144195 Expr *pExpr, /* An operand of a comparison operator */
144204 if( pExpr->op==TK_VECTOR && (op>=TK_GT && ALWAYS(op<=TK_GE)) ){
144205 pExpr = pExpr->x.pList->a[0].pExpr;
144208 if( pExpr->op==TK_COLUMN ){
144209 aiCurCol[0] = pExpr->iTable;
144210 aiCurCol[1] = pExpr->iColumn;
144215 return exprMightBeIndexed2(pFrom,mPrereq,aiCurCol,pExpr);
144244 Expr *pExpr; /* The expression to be analyzed */
144262 pExpr = pTerm->pExpr;
144263 assert( pExpr->op!=TK_AS && pExpr->op!=TK_COLLATE );
144264 prereqLeft = sqlite3WhereExprUsage(pMaskSet, pExpr->pLeft);
144265 op = pExpr->op;
144267 assert( pExpr->pRight==0 );
144268 if( sqlite3ExprCheckIN(pParse, pExpr) ) return;
144269 if( ExprHasProperty(pExpr, EP_xIsSelect) ){
144270 pTerm->prereqRight = exprSelectUsage(pMaskSet, pExpr->x.pSelect);
144272 pTerm->prereqRight = sqlite3WhereExprListUsage(pMaskSet, pExpr->x.pList);
144277 pTerm->prereqRight = sqlite3WhereExprUsage(pMaskSet, pExpr->pRight);
144280 prereqAll = sqlite3WhereExprUsageNN(pMaskSet, pExpr);
144282 if( ExprHasProperty(pExpr, EP_FromJoin) ){
144283 Bitmask x = sqlite3WhereGetMask(pMaskSet, pExpr->iRightJoinTable);
144298 Expr *pLeft = sqlite3ExprSkipCollate(pExpr->pLeft);
144299 Expr *pRight = sqlite3ExprSkipCollate(pExpr->pRight);
144305 pLeft = pLeft->x.pList->a[pTerm->iField-1].pExpr;
144323 pDup = sqlite3ExprDup(db, pExpr, 0);
144341 pDup = pExpr;
144370 else if( pExpr->op==TK_BETWEEN && pWC->op==TK_AND ){
144371 ExprList *pList = pExpr->x.pList;
144380 sqlite3ExprDup(db, pExpr->pLeft, 0),
144381 sqlite3ExprDup(db, pList->a[i].pExpr, 0));
144382 transferJoinMarkings(pNewExpr, pExpr);
144396 else if( pExpr->op==TK_OR ){
144418 && isLikeOrGlob(pParse, pExpr, &pStr1, &isComplete, &noCase)
144429 pLeft = pExpr->x.pList->a[1].pExpr;
144467 transferJoinMarkings(pNewExpr1, pExpr);
144475 transferJoinMarkings(pNewExpr2, pExpr);
144499 int res = isAuxiliaryVtabOperator(db, pExpr, &eOp2, &pLeft, &pRight);
144511 if( ExprHasProperty(pExpr, EP_FromJoin) && pNewExpr ){
144513 pNewExpr->iRightJoinTable = pExpr->iRightJoinTable;
144541 && (pExpr->op==TK_EQ || pExpr->op==TK_IS)
144542 && (nLeft = sqlite3ExprVectorSize(pExpr->pLeft))>1
144543 && sqlite3ExprVectorSize(pExpr->pRight)==nLeft
144544 && ( (pExpr->pLeft->flags & EP_xIsSelect)==0
144545 || (pExpr->pRight->flags & EP_xIsSelect)==0)
144551 Expr *pLeft = sqlite3ExprForVectorField(pParse, pExpr->pLeft, i);
144552 Expr *pRight = sqlite3ExprForVectorField(pParse, pExpr->pRight, i);
144554 pNew = sqlite3PExpr(pParse, pExpr->op, pLeft, pRight);
144555 transferJoinMarkings(pNew, pExpr);
144573 if( pWC->op==TK_AND && pExpr->op==TK_IN && pTerm->iField==0
144574 && pExpr->pLeft->op==TK_VECTOR
144575 && pExpr->x.pSelect->pPrior==0
144577 && pExpr->x.pSelect->pWin==0
144581 for(i=0; i<sqlite3ExprVectorSize(pExpr->pLeft); i++){
144583 idxNew = whereClauseInsert(pWC, pExpr, TERM_VIRTUAL);
144598 if( pExpr->op==TK_NOTNULL
144599 && pExpr->pLeft->op==TK_COLUMN
144600 && pExpr->pLeft->iColumn>=0
144601 && !ExprHasProperty(pExpr, EP_FromJoin)
144605 Expr *pLeft = pExpr->pLeft;
144659 SQLITE_PRIVATE void sqlite3WhereSplit(WhereClause *pWC, Expr *pExpr, u8 op){
144660 Expr *pE2 = sqlite3ExprSkipCollateAndLikely(pExpr);
144664 whereClauseInsert(pWC, pExpr, 0);
144697 sqlite3ExprDelete(db, a->pExpr);
144752 mask |= sqlite3WhereExprUsage(pMaskSet, pList->a[i].pExpr);
144813 sqlite3ExprDup(pParse->db, pArgs->a[j].pExpr, 0), 0);
145081 || sqlite3ExprCompareSkip(pTerm->pExpr->pLeft,
145083 && (pScan->iEquiv<=1 || !ExprHasProperty(pTerm->pExpr, EP_FromJoin))
145087 && (pX = sqlite3ExprSkipCollateAndLikely(pTerm->pExpr->pRight))->op
145108 pX = pTerm->pExpr;
145120 && (pX = pTerm->pExpr->pRight)->op==TK_COLUMN
145196 pScan->pIdxExpr = pIdx->aColExpr->a[j].pExpr;
145283 Expr *p = sqlite3ExprSkipCollateAndLikely(pList->a[i].pExpr);
145288 CollSeq *pColl = sqlite3ExprNNCollSeq(pParse, pList->a[i].pExpr);
145347 Expr *p = sqlite3ExprSkipCollateAndLikely(pDistinct->a[i].pExpr);
145492 && !ExprHasProperty(pTerm->pExpr, EP_FromJoin)
145503 if( !sqlite3IndexAffinityOk(pTerm->pExpr, aff) ) return 0;
145504 testcase( pTerm->pExpr->op==TK_IS );
145561 Expr *pExpr = pTerm->pExpr;
145562 assert( !ExprHasProperty(pExpr, EP_FromJoin) /* prereq always non-zero */
145563 || pExpr->iRightJoinTable!=pSrc->iCursor /* for the right-hand */
145567 && !ExprHasProperty(pExpr, EP_FromJoin)
145568 && sqlite3ExprIsTableConstant(pExpr, pSrc->iCursor) ){
145570 sqlite3ExprDup(pParse->db, pExpr, 0));
145631 Expr *pX = pTerm->pExpr;
145766 Expr *pExpr = pOrderBy->a[i].pExpr;
145767 if( pExpr->op!=TK_COLUMN || pExpr->iTable!=pSrc->iCursor ) break;
145810 && !ExprHasProperty(pTerm->pExpr, EP_FromJoin)
145840 && sqlite3ExprIsVector(pTerm->pExpr->pRight)
145853 Expr *pExpr = pOrderBy->a[i].pExpr;
145854 pIdxOrderBy[i].iColumn = pExpr->iColumn;
146193 rc = sqlite3Stat4ValueFromExpr(pParse, pLower->pExpr->pRight, aff, &p1);
146197 rc = sqlite3Stat4ValueFromExpr(pParse, pUpper->pExpr->pRight, aff, &p2);
146359 Expr *pExpr = pLower->pExpr->pRight;
146360 rc = sqlite3Stat4ProbeSetValue(pParse, p, &pRec, pExpr, nBtm, nEq, &n);
146364 if( sqlite3ExprVectorSize(pExpr)>n ) mask = (WO_LE|WO_LT);
146376 Expr *pExpr = pUpper->pExpr->pRight;
146377 rc = sqlite3Stat4ProbeSetValue(pParse, p, &pRec, pExpr, nTop, nEq, &n);
146381 if( sqlite3ExprVectorSize(pExpr)>n ) mask = (WO_LE|WO_LT);
146467 Expr *pExpr, /* Expression for VALUE in the x=VALUE constraint */
146496 rc = sqlite3Stat4ProbeSetValue(pParse, p, &pRec, pExpr, 1, nEq-1, &bOk);
146545 rc = whereEqualScanEst(pParse, pBuilder, pList->a[i].pExpr, &nEst);
146574 if( ExprHasProperty(pTerm->pExpr, EP_FromJoin) ) zType[2] = 'L';
146601 sqlite3TreeViewExpr(0, pTerm->pExpr, 0);
147127 Expr *pRight = pTerm->pExpr->pRight;
147129 testcase( pTerm->pExpr->op==TK_IS );
147170 int nCmp = sqlite3ExprVectorSize(pTerm->pExpr->pLeft);
147180 Expr *pLhs = pTerm->pExpr->pLeft->x.pList->a[i].pExpr;
147181 Expr *pRhs = pTerm->pExpr->pRight;
147183 pRhs = pRhs->x.pSelect->pEList->a[i].pExpr;
147185 pRhs = pRhs->x.pList->a[i].pExpr;
147314 && !ExprHasProperty(pTerm->pExpr, EP_FromJoin)
147340 Expr *pExpr = pTerm->pExpr;
147341 if( ExprHasProperty(pExpr, EP_xIsSelect) ){
147352 if( pNew->aLTerm[i] && pNew->aLTerm[i]->pExpr==pExpr ) nIn = 0;
147354 }else if( ALWAYS(pExpr->x.pList && pExpr->x.pList->nExpr) ){
147356 nIn = sqlite3LogEst(pExpr->x.pList->nExpr);
147471 && ((eOp & WO_IN)==0 || !ExprHasProperty(pTerm->pExpr, EP_xIsSelect))
147474 Expr *pExpr = pTerm->pExpr;
147479 rc = whereEqualScanEst(pParse, pBuilder, pExpr->pRight, &nOut);
147481 rc = whereInScanEst(pParse, pBuilder, pExpr->x.pList, &nOut);
147631 Expr *pExpr = sqlite3ExprSkipCollateAndLikely(pOB->a[ii].pExpr);
147632 if( pExpr->op==TK_COLUMN && pExpr->iTable==iCursor ){
147633 if( pExpr->iColumn<0 ) return 1;
147635 if( pExpr->iColumn==pIndex->aiColumn[jj] ) return 1;
147640 if( sqlite3ExprCompareSkip(pExpr,aColExpr->a[jj].pExpr,iCursor)==0 ){
147667 Expr *pExpr;
147668 pExpr = pTerm->pExpr;
147669 if( (!ExprHasProperty(pExpr, EP_FromJoin) || pExpr->iRightJoinTable==iTab)
147670 && (isLeft==0 || ExprHasProperty(pExpr, EP_FromJoin))
147671 && sqlite3ExprImpliesExpr(pParse, pExpr, pWhere, iTab)
147909 if( !sqlite3ExprCoveredByIndex(pTerm->pExpr, iCur, pProbe) ){
148138 Expr *pX = pHidden->pWC->a[iTerm].pExpr;
148590 pOBExpr = sqlite3ExprSkipCollateAndLikely(pOrderBy->a[i].pExpr);
148606 CollSeq *pColl1 = sqlite3ExprNNCollSeq(pParse, pOrderBy->a[i].pExpr);
148607 CollSeq *pColl2 = sqlite3ExprCompareCollSeq(pParse, pTerm->pExpr);
148612 testcase( pTerm->pExpr->op==TK_IS );
148673 Expr *pX = pLoop->aLTerm[j]->pExpr;
148675 if( pLoop->aLTerm[i]->pExpr==pX ){
148713 pOBExpr = sqlite3ExprSkipCollateAndLikely(pOrderBy->a[i].pExpr);
148722 Expr *pIdxExpr = pIndex->aColExpr->a[j].pExpr;
148728 pColl = sqlite3ExprNNCollSeq(pWInfo->pParse, pOrderBy->a[i].pExpr);
148785 p = pOrderBy->a[i].pExpr;
149366 static int exprNodeIsDeterministic(Walker *pWalker, Expr *pExpr){
149367 if( pExpr->op==TK_FUNCTION && ExprHasProperty(pExpr, EP_ConstFunc)==0 ){
149667 if( pT->prereqAll==0 && (nTabList==0 || exprIsDeterministic(pT->pExpr)) ){
149668 sqlite3ExprIfFalse(pParse, pT->pExpr, pWInfo->iBreak, SQLITE_JUMPIFNULL);
149829 if( !ExprHasProperty(pTerm->pExpr, EP_FromJoin)
149830 || pTerm->pExpr->iRightJoinTable!=pItem->iCursor
150351 memcpy(p->pExpr, &p->orig, sizeof(p->orig));
151111 static int selectWindowRewriteExprCb(Walker *pWalker, Expr *pExpr){
151123 if( pExpr->op!=TK_COLUMN ){
151129 if( pExpr->iTable==p->pSrc->a[i].iCursor ) break;
151135 switch( pExpr->op ){
151138 if( !ExprHasProperty(pExpr, EP_WinFunc) ){
151143 if( pExpr->y.pWin==pWin ){
151144 assert( pWin->pOwner==pExpr );
151157 if( 0==sqlite3ExprCompare(0, p->pSub->a[i].pExpr, pExpr, -1) ){
151164 Expr *pDup = sqlite3ExprDup(pParse->db, pExpr, 0);
151169 assert( ExprHasProperty(pExpr, EP_Static)==0 );
151170 ExprSetProperty(pExpr, EP_Static);
151171 sqlite3ExprDelete(pParse->db, pExpr);
151172 ExprClearProperty(pExpr, EP_Static);
151173 memset(pExpr, 0, sizeof(Expr));
151175 pExpr->op = TK_COLUMN;
151176 pExpr->iColumn = (iCol<0 ? p->pSub->nExpr-1: iCol);
151177 pExpr->iTable = p->pWin->iEphCsr;
151178 pExpr->y.pTab = p->pTab;
151261 Expr *pDup = sqlite3ExprDup(pParse->db, pAppend->a[i].pExpr, 0);
151290 static int sqlite3WindowExtraAggFuncDepth(Walker *pWalker, Expr *pExpr){
151291 if( pExpr->op==TK_AGG_FUNCTION
151292 && pExpr->op2>=pWalker->walkerDepth
151294 pExpr->op2++;
151494 static Expr *sqlite3WindowOffsetExpr(Parse *pParse, Expr *pExpr){
151495 if( 0==sqlite3ExprIsConstant(pExpr) ){
151496 if( IN_RENAME_OBJECT ) sqlite3RenameExprUnmap(pParse, pExpr);
151497 sqlite3ExprDelete(pParse->db, pExpr);
151498 pExpr = sqlite3ExprAlloc(pParse->db, TK_NULL, 0, 0);
151500 return pExpr;
152051 pColl = sqlite3ExprNNCollSeq(pParse, pWin->pOwner->x.pList->a[0].pExpr);
152725 static int windowExprGtZero(Parse *pParse, Expr *pExpr){
152729 sqlite3ValueFromExpr(db, pExpr, db->enc, SQLITE_AFF_NUMERIC, &pVal);
153479 struct FrameBound { int eType; Expr *pExpr; };
155550 sqlite3ExprDelete(pParse->db, (yypminor->yy77).pExpr);
157491 yymsp[-4].minor.yy202->flags |= pList->a[0].pExpr->flags & EP_Propagate;
157596 … if( yymsp[-1].minor.yy242->nExpr==1 && sqlite3ExprIsConstant(yymsp[-1].minor.yy242->a[0].pExpr) ){
157597 Expr *pRHS = yymsp[-1].minor.yy242->a[0].pExpr;
157598 yymsp[-1].minor.yy242->a[0].pExpr = 0;
157992 …, yymsp[-2].minor.yy192, yymsp[-1].minor.yy77.eType, yymsp[-1].minor.yy77.pExpr, TK_CURRENT, 0, yy…
157998 …sp[-3].minor.yy77.eType, yymsp[-3].minor.yy77.pExpr, yymsp[-1].minor.yy77.eType, yymsp[-1].minor.y…
158010 {yylhsminor.yy77.eType = yymsp[-1].major; yylhsminor.yy77.pExpr = 0;}
158014 {yylhsminor.yy77.eType = yymsp[0].major; yylhsminor.yy77.pExpr = yymsp[-1].minor.yy202;}
166006 Fts3Expr *pExpr; /* Parsed MATCH query string */
167820 sqlite3Fts3ExprFree(pCsr->pExpr);
169394 p->azColumn, p->bFts4, p->nColumn, iCol, zQuery, -1, &pCsr->pExpr,
169506 if( pCsr->pExpr ){
170179 Fts3Expr *pExpr, /* Allocate readers for this expression */
170184 if( pExpr && SQLITE_OK==*pRc ){
170185 if( pExpr->eType==FTSQUERY_PHRASE ){
170187 int nToken = pExpr->pPhrase->nToken;
170190 Fts3PhraseToken *pToken = &pExpr->pPhrase->aToken[i];
170199 assert( pExpr->pPhrase->iDoclistToken==0 );
170200 pExpr->pPhrase->iDoclistToken = -1;
170202 *pnOr += (pExpr->eType==FTSQUERY_OR);
170203 fts3EvalAllocateReaders(pCsr, pExpr->pLeft, pnToken, pnOr, pRc);
170204 fts3EvalAllocateReaders(pCsr, pExpr->pRight, pnToken, pnOr, pRc);
170841 Fts3Expr *pExpr, /* Expression to initialize phrases in */
170844 if( pExpr && SQLITE_OK==*pRc ){
170845 if( pExpr->eType==FTSQUERY_PHRASE ){
170846 int nToken = pExpr->pPhrase->nToken;
170850 if( pExpr->pPhrase->aToken[i].pDeferred==0 ) break;
170852 pExpr->bDeferred = (i==nToken);
170854 *pRc = fts3EvalPhraseStart(pCsr, 1, pExpr->pPhrase);
170856 fts3EvalStartReaders(pCsr, pExpr->pLeft, pRc);
170857 fts3EvalStartReaders(pCsr, pExpr->pRight, pRc);
170858 pExpr->bDeferred = (pExpr->pLeft->bDeferred && pExpr->pRight->bDeferred);
170895 Fts3Expr *pExpr, /* Expression to consider */
170901 if( pExpr->eType==FTSQUERY_PHRASE ){
170902 Fts3Phrase *pPhrase = pExpr->pPhrase;
170913 }else if( pExpr->eType!=FTSQUERY_NOT ){
170914 assert( pExpr->eType==FTSQUERY_OR
170915 || pExpr->eType==FTSQUERY_AND
170916 || pExpr->eType==FTSQUERY_NEAR
170918 assert( pExpr->pLeft && pExpr->pRight );
170919 if( pExpr->eType==FTSQUERY_OR ){
170920 pRoot = pExpr->pLeft;
170924 fts3EvalTokenCosts(pCsr, pRoot, pExpr->pLeft, ppTC, ppOr, pRc);
170925 if( pExpr->eType==FTSQUERY_OR ){
170926 pRoot = pExpr->pRight;
170930 fts3EvalTokenCosts(pCsr, pRoot, pExpr->pRight, ppTC, ppOr, pRc);
171147 fts3EvalAllocateReaders(pCsr, pCsr->pExpr, &nToken, &nOr, &rc);
171167 fts3EvalTokenCosts(pCsr, 0, pCsr->pExpr, &pTC, &ppOr, &rc);
171183 fts3EvalStartReaders(pCsr, pCsr->pExpr, &rc);
171297 Fts3Expr *pExpr, /* Expr. to advance to next matching row */
171302 assert( pExpr->bEof==0 );
171303 pExpr->bStart = 1;
171305 switch( pExpr->eType ){
171308 Fts3Expr *pLeft = pExpr->pLeft;
171309 Fts3Expr *pRight = pExpr->pRight;
171316 pExpr->iDocid = pRight->iDocid;
171317 pExpr->bEof = pRight->bEof;
171322 pExpr->iDocid = pLeft->iDocid;
171323 pExpr->bEof = pLeft->bEof;
171337 pExpr->iDocid = pLeft->iDocid;
171338 pExpr->bEof = (pLeft->bEof || pRight->bEof);
171339 if( pExpr->eType==FTSQUERY_NEAR && pExpr->bEof ){
171362 Fts3Expr *pLeft = pExpr->pLeft;
171363 Fts3Expr *pRight = pExpr->pRight;
171378 pExpr->bEof = (pLeft->bEof && pRight->bEof);
171381 pExpr->iDocid = pLeft->iDocid;
171383 pExpr->iDocid = pRight->iDocid;
171390 Fts3Expr *pLeft = pExpr->pLeft;
171391 Fts3Expr *pRight = pExpr->pRight;
171407 pExpr->iDocid = pLeft->iDocid;
171408 pExpr->bEof = pLeft->bEof;
171413 Fts3Phrase *pPhrase = pExpr->pPhrase;
171415 *pRc = fts3EvalPhraseNext(pCsr, pPhrase, &pExpr->bEof);
171416 pExpr->iDocid = pPhrase->doclist.iDocid;
171438 static int fts3EvalNearTest(Fts3Expr *pExpr, int *pRc){
171462 && pExpr->eType==FTSQUERY_NEAR
171463 && (pExpr->pParent==0 || pExpr->pParent->eType!=FTSQUERY_NEAR)
171470 for(p=pExpr; p->pLeft; p=p->pLeft){
171489 aPoslist = pExpr->pRight->pPhrase->doclist.pList;
171490 nToken = pExpr->pRight->pPhrase->nToken;
171491 for(p=pExpr->pLeft; p && res; p=p->pLeft){
171522 Fts3Expr *pExpr, /* Expr to test. May or may not be root. */
171527 switch( pExpr->eType ){
171531 fts3EvalTestExpr(pCsr, pExpr->pLeft, pRc)
171532 && fts3EvalTestExpr(pCsr, pExpr->pRight, pRc)
171533 && fts3EvalNearTest(pExpr, pRc)
171552 && pExpr->eType==FTSQUERY_NEAR
171553 && (pExpr->pParent==0 || pExpr->pParent->eType!=FTSQUERY_NEAR)
171556 for(p=pExpr; p->pPhrase==0; p=p->pLeft){
171569 int bHit1 = fts3EvalTestExpr(pCsr, pExpr->pLeft, pRc);
171570 int bHit2 = fts3EvalTestExpr(pCsr, pExpr->pRight, pRc);
171577 fts3EvalTestExpr(pCsr, pExpr->pLeft, pRc)
171578 && !fts3EvalTestExpr(pCsr, pExpr->pRight, pRc)
171585 && (pExpr->iDocid==pCsr->iPrevId || pExpr->bDeferred)
171587 Fts3Phrase *pPhrase = pExpr->pPhrase;
171588 assert( pExpr->bDeferred || pPhrase->doclist.bFreeList==0 );
171589 if( pExpr->bDeferred ){
171594 pExpr->iDocid = pCsr->iPrevId;
171598 bHit = (pExpr->bEof==0 && pExpr->iDocid==pCsr->iPrevId);
171648 bMiss = (0==fts3EvalTestExpr(pCsr, pCsr->pExpr, &rc));
171663 Fts3Expr *pExpr = pCsr->pExpr;
171665 if( pExpr==0 ){
171673 fts3EvalNextRow(pCsr, pExpr, &rc);
171674 pCsr->isEof = pExpr->bEof;
171677 pCsr->iPrevId = pExpr->iDocid;
171704 Fts3Expr *pExpr,
171707 if( pExpr && *pRc==SQLITE_OK ){
171708 Fts3Phrase *pPhrase = pExpr->pPhrase;
171728 pExpr->iDocid = 0;
171729 pExpr->bEof = 0;
171730 pExpr->bStart = 0;
171732 fts3EvalRestart(pCsr, pExpr->pLeft, pRc);
171733 fts3EvalRestart(pCsr, pExpr->pRight, pRc);
171745 static void fts3EvalUpdateCounts(Fts3Expr *pExpr, int nCol){
171746 if( pExpr ){
171747 Fts3Phrase *pPhrase = pExpr->pPhrase;
171763 pExpr->aMI[iCol*3 + 1] += iCnt;
171764 pExpr->aMI[iCol*3 + 2] += (iCnt>0);
171771 fts3EvalUpdateCounts(pExpr->pLeft, nCol);
171772 fts3EvalUpdateCounts(pExpr->pRight, nCol);
171789 Fts3Expr *pExpr /* FTSQUERY_PHRASE expression */
171793 assert( pExpr->eType==FTSQUERY_PHRASE );
171794 if( pExpr->aMI==0 ){
171804 pRoot = pExpr;
171900 Fts3Expr *pExpr, /* Phrase expression */
171907 if( pExpr->bDeferred && pExpr->pParent->eType!=FTSQUERY_NEAR ){
171914 rc = fts3EvalGatherStats(pCsr, pExpr);
171916 assert( pExpr->aMI );
171918 aiOut[iCol*3 + 1] = pExpr->aMI[iCol*3 + 1];
171919 aiOut[iCol*3 + 2] = pExpr->aMI[iCol*3 + 2];
171948 Fts3Expr *pExpr, /* Phrase to return doclist for */
171952 Fts3Phrase *pPhrase = pExpr->pPhrase;
171966 iDocid = pExpr->iDocid;
171968 if( iDocid!=pCsr->iPrevId || pExpr->bEof ){
171982 pNear = pExpr;
171983 for(p=pExpr->pParent; p; p=p->pParent){
173794 static char *exprToString(Fts3Expr *pExpr, char *zBuf){
173795 if( pExpr==0 ){
173798 switch( pExpr->eType ){
173800 Fts3Phrase *pPhrase = pExpr->pPhrase;
173814 zBuf = sqlite3_mprintf("%zNEAR/%d ", zBuf, pExpr->nNear);
173828 if( zBuf ) zBuf = exprToString(pExpr->pLeft, zBuf);
173831 if( zBuf ) zBuf = exprToString(pExpr->pRight, zBuf);
173864 Fts3Expr *pExpr;
173904 pTokenizer, 0, azCol, 0, nCol, nCol, zExpr, nExpr, &pExpr, &zDummy
173906 assert( rc==SQLITE_OK || pExpr==0 );
173910 pTokenizer, 0, azCol, 0, nCol, nCol, zExpr, nExpr, &pExpr
173915 sqlite3Fts3ExprFree(pExpr);
173917 }else if( rc==SQLITE_NOMEM || !(zBuf = exprToString(pExpr, 0)) ){
173924 sqlite3Fts3ExprFree(pExpr);
182269 Fts3Expr *pExpr, /* Expression to iterate phrases of */
182275 int eType = pExpr->eType; /* Type of expression node pExpr */
182278 assert( pExpr->pLeft && pExpr->pRight );
182279 rc = fts3ExprIterate2(pExpr->pLeft, piPhrase, x, pCtx);
182281 rc = fts3ExprIterate2(pExpr->pRight, piPhrase, x, pCtx);
182284 rc = x(pExpr, *piPhrase, pCtx);
182301 Fts3Expr *pExpr, /* Expression to iterate phrases of */
182306 return fts3ExprIterate2(pExpr, &iPhrase, x, pCtx);
182315 static int fts3ExprLoadDoclistsCb(Fts3Expr *pExpr, int iPhrase, void *ctx){
182317 Fts3Phrase *pPhrase = pExpr->pPhrase;
182346 rc = fts3ExprIterate(pCsr->pExpr, fts3ExprLoadDoclistsCb, (void *)&sCtx);
182352 static int fts3ExprPhraseCountCb(Fts3Expr *pExpr, int iPhrase, void *ctx){
182354 pExpr->iPhrase = iPhrase;
182357 static int fts3ExprPhraseCount(Fts3Expr *pExpr){
182359 (void)fts3ExprIterate(pExpr, fts3ExprPhraseCountCb, (void *)&nPhrase);
182490 static int fts3SnippetFindPositions(Fts3Expr *pExpr, int iPhrase, void *ctx){
182496 pPhrase->nToken = pExpr->pPhrase->nToken;
182497 rc = sqlite3Fts3EvalPhrasePoslist(p->pCsr, pExpr, p->iCol, &pCsr);
182579 rc = fts3ExprIterate(pCsr->pExpr, fts3SnippetFindPositions, (void*)&sIter);
182885 Fts3Expr *pExpr, /* Phrase expression node */
182890 Fts3Phrase *pPhrase = pExpr->pPhrase;
182896 iStart = pExpr->iPhrase * p->nCol;
182898 iStart = pExpr->iPhrase * ((p->nCol + 31) / 32);
182923 Fts3Expr *pExpr,
182927 assert( (pExpr->pLeft==0)==(pExpr->pRight==0) );
182928 if( pExpr->bEof==0 && pExpr->iDocid==p->pCursor->iPrevId ){
182929 if( pExpr->pLeft ){
182930 rc = fts3ExprLHitGather(pExpr->pLeft, p);
182931 if( rc==SQLITE_OK ) rc = fts3ExprLHitGather(pExpr->pRight, p);
182933 rc = fts3ExprLHits(pExpr, p);
182967 Fts3Expr *pExpr, /* Phrase expression node */
182973 p->pCursor, pExpr, &p->aMatchinfo[3*iPhrase*p->nCol]
182983 Fts3Expr *pExpr, /* Phrase expression node */
182994 rc = sqlite3Fts3EvalPhrasePoslist(p->pCursor, pExpr, i, &pCsr);
183105 Fts3Expr *pExpr; /* Pointer to phrase expression */
183118 Fts3Expr *pExpr, /* Phrase expression node */
183123 aIter[iPhrase].pExpr = pExpr;
183173 (void)fts3ExprIterate(pCsr->pExpr, fts3MatchinfoLcsCb, (void*)aIter);
183177 nToken -= pIter->pExpr->pPhrase->nToken;
183187 rc = sqlite3Fts3EvalPhrasePoslist(pCsr, pIt->pExpr, iCol, &pIt->pRead);
183335 rc = fts3ExprLHitGather(pCsr->pExpr, pInfo);
183340 Fts3Expr *pExpr;
183342 pExpr = pCsr->pExpr;
183350 rc = fts3ExprIterate(pExpr, fts3ExprGlobalHitsCb,(void*)pInfo);
183354 (void)fts3ExprIterate(pExpr, fts3ExprLocalHitsCb,(void*)pInfo);
183406 pCsr->nPhrase = fts3ExprPhraseCount(pCsr->pExpr);
183482 if( !pCsr->pExpr ){
183579 static int fts3ExprTermOffsetInit(Fts3Expr *pExpr, int iPhrase, void *ctx){
183588 rc = sqlite3Fts3EvalPhrasePoslist(p->pCsr, pExpr, p->iCol, &pList);
183589 nTerm = pExpr->pPhrase->nToken;
183620 if( !pCsr->pExpr ){
183660 (void)fts3ExprIterate(pCsr->pExpr, fts3ExprTermOffsetInit, (void*)&sCtx);
183760 if( !pCsr->pExpr ){
193783 URegularExpression *pExpr = (URegularExpression *)p;
193784 uregex_close(pExpr);
193808 URegularExpression *pExpr;
193821 pExpr = sqlite3_get_auxdata(p, 0);
193822 if( !pExpr ){
193827 pExpr = uregex_open(zPattern, -1, 0, 0, &status);
193830 sqlite3_set_auxdata(p, 0, pExpr, icuRegexpDelete);
193832 assert(!pExpr);
193839 uregex_setText(pExpr, zString, -1, &status);
193846 res = uregex_matches(pExpr, 0, &status);
193857 uregex_setText(pExpr, 0, 0, &status);
212129 Fts5ExprNode *pExpr; /* Result of a successful parse */
212245 if( iCol<pConfig->nCol && sParse.pExpr && sParse.rc==SQLITE_OK ){
212251 sqlite3Fts5ParseSetColset(&sParse, sParse.pExpr, pColset);
212260 sqlite3Fts5ParseNodeFree(sParse.pExpr);
212262 if( !sParse.pExpr ){
212269 pNew->pRoot = sParse.pExpr;
212278 sqlite3Fts5ParseNodeFree(sParse.pExpr);
212753 Fts5Expr *pExpr, /* Expression that pNear is a part of */
212759 if( pExpr->pConfig->eDetail!=FTS5_DETAIL_FULL ){
212811 Fts5Expr *pExpr,
212837 pExpr->pIndex, p->zTerm, (int)strlen(p->zTerm),
212839 (pExpr->bDesc ? FTS5INDEX_QUERY_DESC : 0),
212873 Fts5Expr *pExpr,
212877 assert( pExpr->bDesc==0 || pExpr->bDesc==1 );
212878 if( pExpr->bDesc==0 ){
212927 Fts5Expr *pExpr,
212933 return fts5RowidCmp(pExpr, p1->iRowid, p2->iRowid);
212948 Fts5Expr *pExpr, /* Expression pPhrase belongs to */
212957 const int bDesc = pExpr->bDesc;
213004 pNode->bNomatch = ((0==fts5ExprNearTest(&rc, pExpr, pNode)) && rc==SQLITE_OK);
213018 Fts5Expr *pExpr, /* Expression pPhrase belongs to */
213032 i64 iRowid = fts5ExprSynonymRowid(pTerm, pExpr->bDesc, 0);
213040 || (bFromValid && ii!=iFrom && (ii>iFrom)==pExpr->bDesc)
213075 rc = fts5ExprNodeTest_STRING(pExpr, pNode);
213083 Fts5Expr *pExpr, /* Expression that pNear is a part of */
213099 if( pExpr->pConfig->eDetail==FTS5_DETAIL_FULL ){
213111 Fts5Expr *pExpr,
213126 rc = fts5ExprNodeTest_TERM(pExpr, pNode);
213135 Fts5Expr *pExpr, /* Expression of which pNode is a part */
213143 int cmp = fts5NodeCompare(pExpr, pNext, pChild);
213154 Fts5Expr *pExpr,
213164 assert( p1->bEof || fts5RowidCmp(pExpr, p1->iRowid, iLast)>=0 );
213167 || (bFromValid && fts5RowidCmp(pExpr, p1->iRowid, iFrom)<0)
213169 int rc = fts5ExprNodeNext(pExpr, p1, bFromValid, iFrom);
213178 fts5ExprNodeTest_OR(pExpr, pNode);
213186 Fts5Expr *pExpr, /* Expression pPhrase belongs to */
213200 int cmp = fts5RowidCmp(pExpr, iLast, pChild->iRowid);
213203 rc = fts5ExprNodeNext(pExpr, pChild, 1, iLast);
213214 assert( pChild->bEof || fts5RowidCmp(pExpr, iLast, pChild->iRowid)<=0 );
213230 if( pAnd->bNomatch && pAnd!=pExpr->pRoot ){
213238 Fts5Expr *pExpr,
213243 int rc = fts5ExprNodeNext(pExpr, pNode->apChild[0], bFromValid, iFrom);
213245 rc = fts5ExprNodeTest_AND(pExpr, pNode);
213253 Fts5Expr *pExpr, /* Expression pPhrase belongs to */
213262 int cmp = fts5NodeCompare(pExpr, p1, p2);
213264 rc = fts5ExprNodeNext(pExpr, p2, 1, p1->iRowid);
213265 cmp = fts5NodeCompare(pExpr, p1, p2);
213269 rc = fts5ExprNodeNext(pExpr, p1, 0, 0);
213281 Fts5Expr *pExpr,
213286 int rc = fts5ExprNodeNext(pExpr, pNode->apChild[0], bFromValid, iFrom);
213288 rc = fts5ExprNodeTest_NOT(pExpr, pNode);
213302 Fts5Expr *pExpr, /* Expression of which pNode is a part */
213310 rc = fts5ExprNodeTest_STRING(pExpr, pNode);
213315 rc = fts5ExprNodeTest_TERM(pExpr, pNode);
213320 rc = fts5ExprNodeTest_AND(pExpr, pNode);
213325 fts5ExprNodeTest_OR(pExpr, pNode);
213330 rc = fts5ExprNodeTest_NOT(pExpr, pNode);
213346 static int fts5ExprNodeFirst(Fts5Expr *pExpr, Fts5ExprNode *pNode){
213353 rc = fts5ExprNearInitAll(pExpr, pNode);
213361 rc = fts5ExprNodeFirst(pExpr, pNode->apChild[i]);
213384 rc = fts5ExprNodeTest(pExpr, pNode);
213659 assert( pParse->pExpr==0 );
213660 pParse->pExpr = p;
213730 Fts5Expr *pExpr,
213739 pOrig = pExpr->apExprPhrase[iPhrase];
213791 pNew->pIndex = pExpr->pIndex;
213792 pNew->pConfig = pExpr->pConfig;
214055 Fts5ExprNode *pExpr,
214065 fts5ParseSetColset(pParse, pExpr, pColset, &pFree);
214316 Fts5ExprNode *pExpr
214319 if( pExpr->eType==FTS5_STRING || pExpr->eType==FTS5_TERM ){
214320 Fts5ExprNearset *pNear = pExpr->pNear;
214368 switch( pExpr->eType ){
214372 assert( pExpr->eType==FTS5_OR );
214378 for(i=0; zRet && i<pExpr->nChild; i++){
214379 char *z = fts5ExprPrintTcl(pConfig, zNearsetCmd, pExpr->apChild[i]);
214392 static char *fts5ExprPrint(Fts5Config *pConfig, Fts5ExprNode *pExpr){
214394 if( pExpr->eType==0 ){
214397 if( pExpr->eType==FTS5_STRING || pExpr->eType==FTS5_TERM ){
214398 Fts5ExprNearset *pNear = pExpr->pNear;
214441 switch( pExpr->eType ){
214445 assert( pExpr->eType==FTS5_OR );
214450 for(i=0; i<pExpr->nChild; i++){
214451 char *z = fts5ExprPrint(pConfig, pExpr->apChild[i]);
214456 int e = pExpr->apChild[i]->eType;
214484 Fts5Expr *pExpr = 0;
214527 rc = sqlite3Fts5ExprNew(pConfig, pConfig->nCol, zExpr, &pExpr, &zErr);
214531 if( pExpr->pRoot->xNext==0 ){
214534 zText = fts5ExprPrintTcl(pConfig, zNearsetCmd, pExpr->pRoot);
214536 zText = fts5ExprPrint(pConfig, pExpr->pRoot);
214556 sqlite3Fts5ExprFree(pExpr);
214654 static int sqlite3Fts5ExprPhraseCount(Fts5Expr *pExpr){
214655 return (pExpr ? pExpr->nPhrase : 0);
214661 static int sqlite3Fts5ExprPhraseSize(Fts5Expr *pExpr, int iPhrase){
214662 if( iPhrase<0 || iPhrase>=pExpr->nPhrase ) return 0;
214663 return pExpr->apExprPhrase[iPhrase]->nTerm;
214670 static int sqlite3Fts5ExprPoslist(Fts5Expr *pExpr, int iPhrase, const u8 **pa){
214672 Fts5ExprPhrase *pPhrase = pExpr->apExprPhrase[iPhrase];
214674 if( pNode->bEof==0 && pNode->iRowid==pExpr->pRoot->iRowid ){
214690 static Fts5PoslistPopulator *sqlite3Fts5ExprClearPoslists(Fts5Expr *pExpr, int bLive){
214692 pRet = sqlite3_malloc64(sizeof(Fts5PoslistPopulator)*pExpr->nPhrase);
214695 memset(pRet, 0, sizeof(Fts5PoslistPopulator)*pExpr->nPhrase);
214696 for(i=0; i<pExpr->nPhrase; i++){
214697 Fts5Buffer *pBuf = &pExpr->apExprPhrase[i]->poslist;
214698 Fts5ExprNode *pNode = pExpr->apExprPhrase[i]->pNode;
214699 assert( pExpr->apExprPhrase[i]->nTerm==1 );
214701 (pBuf->n==0 || pNode->iRowid!=pExpr->pRoot->iRowid || pNode->bEof)
214713 Fts5Expr *pExpr;
214739 Fts5Expr *pExpr = p->pExpr;
214746 for(i=0; i<pExpr->nPhrase; i++){
214749 for(pTerm=&pExpr->apExprPhrase[i]->aTerm[0]; pTerm; pTerm=pTerm->pSynonym){
214755 &pExpr->apExprPhrase[i]->poslist, &p->aPopulator[i].writer, p->iOff
214767 Fts5Expr *pExpr,
214774 sCtx.pExpr = pExpr;
214778 for(i=0; i<pExpr->nPhrase; i++){
214779 Fts5ExprNode *pNode = pExpr->apExprPhrase[i]->pNode;
214850 static void sqlite3Fts5ExprCheckPoslists(Fts5Expr *pExpr, i64 iRowid){
214851 fts5ExprCheckPoslists(pExpr->pRoot, iRowid);
214858 Fts5Expr *pExpr,
214863 Fts5ExprPhrase *pPhrase = pExpr->apExprPhrase[iPhrase];
214867 assert( iPhrase>=0 && iPhrase<pExpr->nPhrase );
214868 assert( pExpr->pConfig->eDetail==FTS5_DETAIL_COLUMNS );
214871 && pNode->iRowid==pExpr->pRoot->iRowid
222259 Fts5Expr *pExpr; /* Expression for MATCH queries */
222815 sqlite3Fts5ExprFree(pCsr->pExpr);
222929 i64 iRowid = sqlite3Fts5ExprRowid(pCsr->pExpr);
222931 rc = sqlite3Fts5ExprFirst(pCsr->pExpr, pTab->p.pIndex, iRowid, bDesc);
222932 if( rc==SQLITE_OK && iRowid!=sqlite3Fts5ExprRowid(pCsr->pExpr) ){
222938 if( sqlite3Fts5ExprEof(pCsr->pExpr) ){
222967 rc = sqlite3Fts5ExprNext(pCsr->pExpr, pCsr->iLastRowid);
222968 CsrFlagSet(pCsr, sqlite3Fts5ExprEof(pCsr->pExpr));
223050 nPhrase = sqlite3Fts5ExprPhraseCount(pCsr->pExpr);
223091 Fts5Expr *pExpr = pCsr->pExpr;
223092 rc = sqlite3Fts5ExprFirst(pExpr, pTab->p.pIndex, pCsr->iFirstRowid, bDesc);
223093 if( sqlite3Fts5ExprEof(pExpr) ){
223283 Fts5Expr *pExpr = 0;
223298 assert( pCsr->pExpr==0 );
223336 rc = sqlite3Fts5ExprNew(pConfig, iCol, zText, &pExpr, pzErr);
223338 rc = sqlite3Fts5ExprAnd(&pCsr->pExpr, pExpr);
223339 pExpr = 0;
223394 pCsr->pExpr = pTab->pSortCsr->pExpr;
223396 }else if( pCsr->pExpr ){
223431 sqlite3Fts5ExprFree(pExpr);
223456 return sqlite3Fts5ExprRowid(pCsr->pExpr);
223513 assert( pCsr->pExpr );
223869 return sqlite3Fts5ExprPhraseCount(pCsr->pExpr);
223874 return sqlite3Fts5ExprPhraseSize(pCsr->pExpr, iPhrase);
223915 aPopulator = sqlite3Fts5ExprClearPoslists(pCsr->pExpr, bLive);
223922 pConfig, pCsr->pExpr, aPopulator, i, z, n
223929 sqlite3Fts5ExprCheckPoslists(pCsr->pExpr, pCsr->pSorter->iRowid);
223941 *pn = sqlite3Fts5ExprPoslist(pCsr->pExpr, iPhrase, pa);
223958 nIter = sqlite3Fts5ExprPhraseCount(pCsr->pExpr);
224280 rc = sqlite3Fts5ExprPhraseCollist(pCsr->pExpr, iPhrase, &pIter->a, &n);
224353 rc = sqlite3Fts5ExprClonePhrase(pCsr->pExpr, iPhrase, &pNew->pExpr);
224453 int nPhrase = sqlite3Fts5ExprPhraseCount(pCsr->pExpr);
224463 int nByte = sqlite3Fts5ExprPoslist(pCsr->pExpr, i, &dummy);
224471 nPoslist = sqlite3Fts5ExprPoslist(pCsr->pExpr, i, &pPoslist);
224482 rc = sqlite3Fts5ExprPhraseCollist(pCsr->pExpr, i, &dummy, &nByte);
224490 rc = sqlite3Fts5ExprPhraseCollist(pCsr->pExpr, i, &pPoslist, &nPoslist);