Lines Matching refs:pExpr
15084 Expr *pExpr; /* Used when p4type is P4_EXPR */ member
17916 Expr *pExpr; /* The parse tree for this expression */ member
19764 SQLITE_PRIVATE char sqlite3CompareAffinity(const Expr *pExpr, char aff2);
19765 SQLITE_PRIVATE int sqlite3IndexAffinityOk(const Expr *pExpr, char idx_affinity);
19767 SQLITE_PRIVATE char sqlite3ExprAffinity(const Expr *pExpr);
19792 SQLITE_PRIVATE CollSeq *sqlite3ExprCollSeq(Parse *pParse, const Expr *pExpr);
19793 SQLITE_PRIVATE CollSeq *sqlite3ExprNNCollSeq(Parse *pParse, const Expr *pExpr);
20259 SQLITE_PRIVATE int sqlite3ExprVectorSize(const Expr *pExpr);
20260 SQLITE_PRIVATE int sqlite3ExprIsVector(const Expr *pExpr);
30537 Expr *pExpr, /* Value for PRECEDING or FOLLOWING */
30553 sqlite3TreeViewExpr(pView, pExpr, 0);
30559 sqlite3TreeViewExpr(pView, pExpr, 0);
30648 SQLITE_PRIVATE void sqlite3TreeViewExpr(TreeView *pView, const Expr *pExpr, u8 moreToFollow){
30653 if( pExpr==0 ){
30658 if( pExpr->flags || pExpr->affExpr || pExpr->vvaFlags ){
30662 pExpr->flags, pExpr->affExpr ? pExpr->affExpr : 'n');
30663 if( ExprHasProperty(pExpr, EP_FromJoin) ){
30664 sqlite3_str_appendf(&x, " iRJT=%d", pExpr->iRightJoinTable);
30666 if( ExprHasProperty(pExpr, EP_FromDDL) ){
30669 if( ExprHasVVAProperty(pExpr, EP_Immutable) ){
30676 switch( pExpr->op ){
30679 pExpr->iTable, pExpr->iColumn, zFlgs);
30683 if( pExpr->iTable<0 ){
30686 if( pExpr->op2 ){
30687 sqlite3_snprintf(sizeof(zOp2),zOp2," op2=0x%02x",pExpr->op2);
30692 pExpr->iColumn, zFlgs, zOp2);
30694 assert( ExprUseYTab(pExpr) );
30696 pExpr->iTable, pExpr->iColumn,
30697 pExpr->y.pTab, zFlgs);
30699 if( ExprHasProperty(pExpr, EP_FixedCol) ){
30700 sqlite3TreeViewExpr(pView, pExpr->pLeft, 0);
30705 if( pExpr->flags & EP_IntValue ){
30706 sqlite3TreeViewLine(pView, "%d", pExpr->u.iValue);
30708 sqlite3TreeViewLine(pView, "%s", pExpr->u.zToken);
30714 assert( !ExprHasProperty(pExpr, EP_IntValue) );
30715 sqlite3TreeViewLine(pView,"%s", pExpr->u.zToken);
30720 assert( !ExprHasProperty(pExpr, EP_IntValue) );
30721 sqlite3TreeViewLine(pView,"%Q", pExpr->u.zToken);
30730 sqlite3ExprTruthValue(pExpr) ? "TRUE" : "FALSE", zFlgs);
30735 assert( !ExprHasProperty(pExpr, EP_IntValue) );
30736 sqlite3TreeViewLine(pView,"%s", pExpr->u.zToken);
30741 assert( !ExprHasProperty(pExpr, EP_IntValue) );
30743 pExpr->u.zToken, pExpr->iColumn);
30747 sqlite3TreeViewLine(pView,"REGISTER(%d)", pExpr->iTable);
30751 assert( !ExprHasProperty(pExpr, EP_IntValue) );
30752 sqlite3TreeViewLine(pView,"ID \"%w\"", pExpr->u.zToken);
30758 assert( !ExprHasProperty(pExpr, EP_IntValue) );
30759 sqlite3TreeViewLine(pView,"CAST %Q", pExpr->u.zToken);
30760 sqlite3TreeViewExpr(pView, pExpr->pLeft, 0);
30799 assert( pExpr->op2==TK_IS || pExpr->op2==TK_ISNOT );
30800 assert( pExpr->pRight );
30801 assert( sqlite3ExprSkipCollate(pExpr->pRight)->op==TK_TRUEFALSE );
30802 x = (pExpr->op2==TK_ISNOT)*2 + sqlite3ExprTruthValue(pExpr->pRight);
30808 assert( !ExprHasProperty(pExpr, EP_IntValue) );
30809 sqlite3TreeViewLine(pView, "SPAN %Q", pExpr->u.zToken);
30810 sqlite3TreeViewExpr(pView, pExpr->pLeft, 0);
30820 assert( !ExprHasProperty(pExpr, EP_IntValue) );
30822 !ExprHasProperty(pExpr, EP_Collate) ? "SOFT-" : "",
30823 pExpr->u.zToken, zFlgs);
30824 sqlite3TreeViewExpr(pView, pExpr->pLeft, 0);
30832 if( ExprHasProperty(pExpr, EP_TokenOnly) ){
30836 assert( ExprUseXList(pExpr) );
30837 pFarg = pExpr->x.pList;
30839 pWin = ExprHasProperty(pExpr, EP_WinFunc) ? pExpr->y.pWin : 0;
30844 assert( !ExprHasProperty(pExpr, EP_IntValue) );
30845 if( pExpr->op==TK_AGG_FUNCTION ){
30847 pExpr->op2, pExpr->u.zToken, zFlgs,
30848 pExpr->pAggInfo ? pExpr->pAggInfo->selId : 0,
30849 pExpr->iAgg, pExpr->pAggInfo);
30850 }else if( pExpr->op2!=0 ){
30853 sqlite3_snprintf(sizeof(zBuf),zBuf,"0x%02x",pExpr->op2);
30855 if( pExpr->op2==NC_IsCheck ) zOp2 = "NC_IsCheck";
30856 if( pExpr->op2==NC_IdxExpr ) zOp2 = "NC_IdxExpr";
30857 if( pExpr->op2==NC_PartIdx ) zOp2 = "NC_PartIdx";
30858 if( pExpr->op2==NC_GenCol ) zOp2 = "NC_GenCol";
30860 pExpr->u.zToken, zFlgs, zOp2);
30862 sqlite3TreeViewLine(pView, "FUNCTION %Q%s", pExpr->u.zToken, zFlgs);
30876 assert( ExprUseXSelect(pExpr) );
30877 sqlite3TreeViewLine(pView, "EXISTS-expr flags=0x%x", pExpr->flags);
30878 sqlite3TreeViewSelect(pView, pExpr->x.pSelect, 0);
30882 assert( ExprUseXSelect(pExpr) );
30883 sqlite3TreeViewLine(pView, "subquery-expr flags=0x%x", pExpr->flags);
30884 sqlite3TreeViewSelect(pView, pExpr->x.pSelect, 0);
30888 sqlite3TreeViewLine(pView, "IN flags=0x%x", pExpr->flags);
30889 sqlite3TreeViewExpr(pView, pExpr->pLeft, 1);
30890 if( ExprUseXSelect(pExpr) ){
30891 sqlite3TreeViewSelect(pView, pExpr->x.pSelect, 0);
30893 sqlite3TreeViewExprList(pView, pExpr->x.pList, 0, 0);
30912 pX = pExpr->pLeft;
30913 assert( ExprUseXList(pExpr) );
30914 assert( pExpr->x.pList->nExpr==2 );
30915 pY = pExpr->x.pList->a[0].pExpr;
30916 pZ = pExpr->x.pList->a[1].pExpr;
30932 pExpr->iTable ? "NEW" : "OLD", pExpr->iColumn);
30937 sqlite3TreeViewExpr(pView, pExpr->pLeft, 1);
30938 assert( ExprUseXList(pExpr) );
30939 sqlite3TreeViewExprList(pView, pExpr->x.pList, 0, 0);
30945 switch( pExpr->affExpr ){
30951 assert( !ExprHasProperty(pExpr, EP_IntValue) );
30952 sqlite3TreeViewLine(pView, "RAISE %s(%Q)", zType, pExpr->u.zToken);
30958 pExpr->iTable, pExpr->iColumn, zFlgs);
30959 sqlite3TreeViewExpr(pView, pExpr->pRight, 0);
30964 assert( ExprUseXList(pExpr) );
30965 sqlite3TreeViewBareExprList(pView, pExpr->x.pList, z);
30971 pExpr->iColumn, pExpr->iTable-1,
30972 pExpr->pRight==pExpr->pLeft ? " (SELECT-owner)" : "");
30973 assert( ExprUseXSelect(pExpr->pLeft) );
30974 sqlite3TreeViewSelect(pView, pExpr->pLeft->x.pSelect, 0);
30978 sqlite3TreeViewLine(pView, "IF-NULL-ROW %d", pExpr->iTable);
30979 sqlite3TreeViewExpr(pView, pExpr->pLeft, 0);
30985 tmp = *pExpr;
30986 tmp.op = pExpr->op2;
30991 if( pExpr->iColumn<=0 ){
30995 pExpr->iColumn-1);
31000 sqlite3TreeViewLine(pView, "op=%d", pExpr->op);
31006 sqlite3TreeViewExpr(pView, pExpr->pLeft, 1);
31007 sqlite3TreeViewExpr(pView, pExpr->pRight, 0);
31010 sqlite3TreeViewExpr(pView, pExpr->pLeft, 0);
31048 sqlite3TreeViewExpr(pView, pList->a[i].pExpr, moreToFollow);
78685 rc = sqlite3ValueFromExpr(db, pList->a[i].pExpr, enc, aff, &apVal[i]);
78745 const Expr *pExpr, /* The expression to evaluate */
78758 assert( pExpr!=0 );
78759 while( (op = pExpr->op)==TK_UPLUS || op==TK_SPAN ) pExpr = pExpr->pLeft;
78761 if( op==TK_REGISTER ) op = pExpr->op2;
78763 if( NEVER(op==TK_REGISTER) ) op = pExpr->op2;
78770 assert( (pExpr->flags & EP_TokenOnly)==0 || pCtx==0 );
78774 assert( !ExprHasProperty(pExpr, EP_IntValue) );
78775 aff = sqlite3AffinityType(pExpr->u.zToken,0);
78776 rc = valueFromExpr(db, pExpr->pLeft, enc, aff, ppVal, pCtx);
78789 && (pExpr->pLeft->op==TK_INTEGER || pExpr->pLeft->op==TK_FLOAT) ){
78790 pExpr = pExpr->pLeft;
78791 op = pExpr->op;
78799 if( ExprHasProperty(pExpr, EP_IntValue) ){
78800 sqlite3VdbeMemSetInt64(pVal, (i64)pExpr->u.iValue*negInt);
78802 zVal = sqlite3MPrintf(db, "%s%s", zNeg, pExpr->u.zToken);
78822 if( SQLITE_OK==valueFromExpr(db,pExpr->pLeft,enc,affinity,&pVal,pCtx)
78848 assert( !ExprHasProperty(pExpr, EP_IntValue) );
78849 assert( pExpr->u.zToken[0]=='x' || pExpr->u.zToken[0]=='X' );
78850 assert( pExpr->u.zToken[1]=='\'' );
78853 zVal = &pExpr->u.zToken[2];
78862 rc = valueFromFunction(db, pExpr, enc, affinity, &pVal, pCtx);
78866 assert( !ExprHasProperty(pExpr, EP_IntValue) );
78870 pVal->u.i = pExpr->u.zToken[4]==0;
78904 const Expr *pExpr, /* The expression to evaluate */
78909 return pExpr ? valueFromExpr(db, pExpr, enc, affinity, ppVal, 0) : 0;
78933 Expr *pExpr, /* The expression to extract a value from */
78943 pExpr = sqlite3ExprSkipCollate(pExpr);
78945 assert( pExpr==0 || pExpr->op!=TK_REGISTER || pExpr->op2!=TK_VARIABLE );
78946 if( !pExpr ){
78951 }else if( pExpr->op==TK_VARIABLE && (db->flags & SQLITE_EnableQPSG)==0 ){
78953 int iBindVar = pExpr->iColumn;
78964 rc = valueFromExpr(db, pExpr, ENC(db), affinity, &pVal, pAlloc);
79010 Expr *pExpr, /* The expression to extract a value from */
79018 if( pExpr==0 || pExpr->op!=TK_SELECT ){
79028 Expr *pElem = (pExpr ? sqlite3VectorFieldSubexpr(pExpr, i) : 0);
79053 Expr *pExpr, /* The expression to extract a value from */
79057 return stat4ValueFromExpr(pParse, pExpr, affinity, 0, ppVal);
80735 static void displayP4Expr(StrAccum *p, Expr *pExpr){
80737 switch( pExpr->op ){
80739 assert( !ExprHasProperty(pExpr, EP_IntValue) );
80740 sqlite3_str_appendf(p, "%Q", pExpr->u.zToken);
80743 sqlite3_str_appendf(p, "%d", pExpr->u.iValue);
80749 sqlite3_str_appendf(p, "r[%d]", pExpr->iTable);
80753 if( pExpr->iColumn<0 ){
80756 sqlite3_str_appendf(p, "c%d", (int)pExpr->iColumn);
80794 displayP4Expr(p, pExpr->pLeft);
80795 if( pExpr->pRight ){
80797 displayP4Expr(p, pExpr->pRight);
80835 displayP4Expr(&x, pOp->p4.pExpr);
94954 pOp->p4.pExpr, aMem);
99391 static SQLITE_NOINLINE int walkExpr(Walker *pWalker, Expr *pExpr){
99393 testcase( ExprHasProperty(pExpr, EP_TokenOnly) );
99394 testcase( ExprHasProperty(pExpr, EP_Reduced) );
99396 rc = pWalker->xExprCallback(pWalker, pExpr);
99398 if( !ExprHasProperty(pExpr,(EP_TokenOnly|EP_Leaf)) ){
99399 assert( pExpr->x.pList==0 || pExpr->pRight==0 );
99400 if( pExpr->pLeft && walkExpr(pWalker, pExpr->pLeft) ) return WRC_Abort;
99401 if( pExpr->pRight ){
99402 assert( !ExprHasProperty(pExpr, EP_WinFunc) );
99403 pExpr = pExpr->pRight;
99405 }else if( ExprUseXSelect(pExpr) ){
99406 assert( !ExprHasProperty(pExpr, EP_WinFunc) );
99407 if( sqlite3WalkSelect(pWalker, pExpr->x.pSelect) ) return WRC_Abort;
99409 if( pExpr->x.pList ){
99410 if( sqlite3WalkExprList(pWalker, pExpr->x.pList) ) return WRC_Abort;
99413 if( ExprHasProperty(pExpr, EP_WinFunc) ){
99414 if( walkWindowList(pWalker, pExpr->y.pWin, 1) ) return WRC_Abort;
99423 SQLITE_PRIVATE int sqlite3WalkExpr(Walker *pWalker, Expr *pExpr){
99424 return pExpr ? walkExpr(pWalker,pExpr) : WRC_Continue;
99436 if( sqlite3WalkExpr(pWalker, pItem->pExpr) ) return WRC_Abort;
99622 static int incrAggDepth(Walker *pWalker, Expr *pExpr){
99623 if( pExpr->op==TK_AGG_FUNCTION ) pExpr->op2 += pWalker->u.n;
99626 static void incrAggFunctionDepth(Expr *pExpr, int N){
99632 sqlite3WalkExpr(&w, pExpr);
99659 Expr *pExpr, /* Transform this into an alias to the result set */
99667 pOrig = pEList->a[iCol].pExpr;
99676 if( pExpr->op==TK_COLLATE ){
99677 assert( !ExprHasProperty(pExpr, EP_IntValue) );
99678 pDup = sqlite3ExprAddCollateString(pParse, pDup, pExpr->u.zToken);
99688 ExprSetProperty(pExpr, EP_Static);
99689 sqlite3ExprDelete(db, pExpr);
99690 memcpy(pExpr, pDup, sizeof(*pExpr));
99691 if( !ExprHasProperty(pExpr, EP_IntValue) && pExpr->u.zToken!=0 ){
99692 assert( (pExpr->flags & (EP_Reduced|EP_TokenOnly))==0 );
99693 pExpr->u.zToken = sqlite3DbStrDup(db, pExpr->u.zToken);
99694 pExpr->flags |= EP_MemToken;
99696 if( ExprHasProperty(pExpr, EP_WinFunc) ){
99697 if( ALWAYS(pExpr->y.pWin!=0) ){
99698 pExpr->y.pWin->pOwner = pExpr;
99776 SQLITE_PRIVATE Bitmask sqlite3ExprColUsed(Expr *pExpr){
99780 n = pExpr->iColumn;
99781 assert( ExprUseYTab(pExpr) );
99782 pExTab = pExpr->y.pTab;
99831 Expr *pExpr /* Make this EXPR node point to the selected column */
99848 assert( !ExprHasProperty(pExpr, EP_TokenOnly|EP_Reduced) );
99851 pExpr->iTable = -1;
99852 ExprSetVVAProperty(pExpr, EP_NoReduce);
99904 pExpr->iColumn = j;
99919 assert( ExprUseYTab(pExpr) );
99921 sqlite3RenameTokenRemap(pParse, 0, (void*)&pExpr->y.pTab);
99940 pExpr->iColumn = j==pTab->iPKey ? -1 : (i16)j;
99950 pExpr->iTable = pMatch->iCursor;
99951 assert( ExprUseYTab(pExpr) );
99952 pExpr->y.pTab = pMatch->pTab;
99956 ExprSetProperty(pExpr, EP_CanBeNull);
99958 pSchema = pExpr->y.pTab->pSchema;
99978 pExpr->iTable = op!=TK_DELETE;
99982 pExpr->iTable = 1;
99985 pExpr->iTable = 0;
99995 pExpr->iTable = EXCLUDED_TABLE_NUMBER;
100023 if( pExpr->iTable==EXCLUDED_TABLE_NUMBER ){
100025 assert( ExprUseYTab(pExpr) );
100027 pExpr->iColumn = iCol;
100028 pExpr->y.pTab = pTab;
100031 pExpr->iTable = pNC->uNC.pUpsert->regData +
100038 assert( ExprUseYTab(pExpr) );
100039 pExpr->y.pTab = pTab;
100042 pExpr->iTable = pNC->uNC.iBaseReg + (pTab->nCol+1)*pExpr->iTable +
100045 pExpr->iColumn = (i16)iCol;
100049 pExpr->affExpr = SQLITE_AFF_INTEGER;
100050 }else if( pExpr->iTable==0 ){
100078 pExpr->iColumn = -1;
100079 pExpr->affExpr = SQLITE_AFF_INTEGER;
100112 assert( pExpr->pLeft==0 && pExpr->pRight==0 );
100113 assert( ExprUseXList(pExpr)==0 || pExpr->x.pList==0 );
100114 assert( ExprUseXSelect(pExpr)==0 || pExpr->x.pSelect==0 );
100115 pOrig = pEList->a[j].pExpr;
100130 resolveAlias(pParse, pEList, j, pExpr, nSubquery);
100135 sqlite3RenameTokenRemap(pParse, 0, (void*)pExpr);
100162 assert( pExpr->op==TK_ID );
100163 if( ExprHasProperty(pExpr,EP_DblQuoted)
100185 pExpr->op = TK_STRING;
100186 memset(&pExpr->y, 0, sizeof(pExpr->y));
100189 if( sqlite3ExprIdToTrueFalse(pExpr) ){
100226 if( pExpr->iColumn>=0 && pMatch!=0 ){
100227 pMatch->colUsed |= sqlite3ExprColUsed(pExpr);
100232 if( !ExprHasProperty(pExpr,(EP_TokenOnly|EP_Leaf)) ){
100233 sqlite3ExprDelete(db, pExpr->pLeft);
100234 pExpr->pLeft = 0;
100235 sqlite3ExprDelete(db, pExpr->pRight);
100236 pExpr->pRight = 0;
100238 pExpr->op = eNewExprOp;
100239 ExprSetProperty(pExpr, EP_Leaf);
100245 && (pExpr->op==TK_COLUMN || pExpr->op==TK_TRIGGER)
100247 sqlite3AuthRead(pParse, pExpr, pSchema, pNC->pSrcList);
100316 Expr *pExpr /* Invalidate this expression on error */
100327 if( pExpr ) pExpr->op = TK_NULL;
100359 static int resolveExprStep(Walker *pWalker, Expr *pExpr){
100377 switch( pExpr->op ){
100389 pExpr->op = TK_COLUMN;
100390 assert( ExprUseYTab(pExpr) );
100391 pExpr->y.pTab = pItem->pTab;
100392 pExpr->iTable = pItem->iCursor;
100393 pExpr->iColumn--;
100394 pExpr->affExpr = SQLITE_AFF_INTEGER;
100420 sqlite3WalkExpr(pWalker, pExpr->pLeft);
100421 if( 0==sqlite3ExprCanBeNull(pExpr->pLeft) && !IN_RENAME_OBJECT ){
100422 testcase( ExprHasProperty(pExpr, EP_FromJoin) );
100423 assert( !ExprHasProperty(pExpr, EP_IntValue) );
100424 if( pExpr->op==TK_NOTNULL ){
100425 pExpr->u.zToken = "true";
100426 ExprSetProperty(pExpr, EP_IsTrue);
100428 pExpr->u.zToken = "false";
100429 ExprSetProperty(pExpr, EP_IsFalse);
100431 pExpr->op = TK_TRUEFALSE;
100435 sqlite3ExprDelete(pParse->db, pExpr->pLeft);
100436 pExpr->pLeft = 0;
100456 if( pExpr->op==TK_ID ){
100459 assert( !ExprHasProperty(pExpr, EP_IntValue) );
100460 zColumn = pExpr->u.zToken;
100462 Expr *pLeft = pExpr->pLeft;
100467 pRight = pExpr->pRight;
100480 assert( ExprUseYTab(pExpr) );
100482 sqlite3RenameTokenRemap(pParse, (void*)pExpr, (void*)pRight);
100483 sqlite3RenameTokenRemap(pParse, (void*)&pExpr->y.pTab, (void*)pLeft);
100486 return lookupName(pParse, zDb, zTable, zColumn, pNC, pExpr);
100492 ExprList *pList = pExpr->x.pList; /* The argument list */
100503 Window *pWin = (IsWindowFunc(pExpr) ? pExpr->y.pWin : 0);
100505 assert( !ExprHasProperty(pExpr, EP_xIsSelect|EP_IntValue) );
100506 zId = pExpr->u.zToken;
100519 ExprSetProperty(pExpr, EP_Unlikely);
100521 pExpr->iTable = exprProbability(pList->a[1].pExpr);
100522 if( pExpr->iTable<0 ){
100538 pExpr->iTable = pDef->zName[0]=='u' ? 8388608 : 125829120;
100550 pExpr->op = TK_NULL;
100560 ExprSetProperty(pExpr,EP_ConstFunc);
100573 pExpr->op2 = pNC->ncFlags & NC_SelfRef;
100574 if( pNC->ncFlags & NC_FromDDL ) ExprSetProperty(pExpr, EP_FromDDL);
100590 sqlite3ExprFunctionUsable(pParse, pExpr, pDef);
100640 else if( is_agg==0 && ExprHasProperty(pExpr, EP_WinFunc) ){
100660 else if( ExprHasProperty(pExpr, EP_WinFunc) ){
100669 assert( pWin==0 || (ExprUseYWin(pExpr) && pWin==pExpr->y.pWin) );
100683 pExpr->op = TK_AGG_FUNCTION;
100684 pExpr->op2 = 0;
100686 if( ExprHasProperty(pExpr, EP_WinFunc) ){
100687 sqlite3WalkExpr(pWalker, pExpr->y.pWin->pFilter);
100692 && sqlite3ReferencesSrcList(pParse, pExpr, pNC2->pSrcList)==0
100694 pExpr->op2++;
100717 case TK_EXISTS: testcase( pExpr->op==TK_EXISTS );
100720 testcase( pExpr->op==TK_IN );
100721 if( ExprUseXSelect(pExpr) ){
100728 notValidImpl(pParse, pNC, "subqueries", pExpr);
100730 sqlite3WalkSelect(pWalker, pExpr->x.pSelect);
100734 ExprSetProperty(pExpr, EP_VarSelect);
100746 NC_IsCheck|NC_PartIdx|NC_IdxExpr|NC_GenCol, pExpr);
100751 Expr *pRight = sqlite3ExprSkipCollateAndLikely(pExpr->pRight);
100752 assert( !ExprHasProperty(pExpr, EP_Reduced) );
100759 pExpr->op2 = pExpr->op;
100760 pExpr->op = TK_TRUTH;
100775 assert( pExpr->pLeft!=0 );
100776 nLeft = sqlite3ExprVectorSize(pExpr->pLeft);
100777 if( pExpr->op==TK_BETWEEN ){
100778 assert( ExprUseXList(pExpr) );
100779 nRight = sqlite3ExprVectorSize(pExpr->x.pList->a[0].pExpr);
100781 nRight = sqlite3ExprVectorSize(pExpr->x.pList->a[1].pExpr);
100784 assert( pExpr->pRight!=0 );
100785 nRight = sqlite3ExprVectorSize(pExpr->pRight);
100788 testcase( pExpr->op==TK_EQ );
100789 testcase( pExpr->op==TK_NE );
100790 testcase( pExpr->op==TK_LT );
100791 testcase( pExpr->op==TK_LE );
100792 testcase( pExpr->op==TK_GT );
100793 testcase( pExpr->op==TK_GE );
100794 testcase( pExpr->op==TK_IS );
100795 testcase( pExpr->op==TK_ISNOT );
100796 testcase( pExpr->op==TK_BETWEEN );
100894 if( sqlite3ExprCompare(0, pEList->a[i].pExpr, pE, -1)<2 ){
100966 pE = sqlite3ExprSkipCollateAndLikely(pItem->pExpr);
101006 if( pItem->pExpr==pE ){
101007 pItem->pExpr = pNew;
101009 Expr *pParent = pItem->pExpr;
101069 resolveAlias(pParse, pEList, pItem->u.x.iOrderByCol-1, pItem->pExpr,0);
101079 static int resolveRemoveWindowsCb(Walker *pWalker, Expr *pExpr){
101081 if( ExprHasProperty(pExpr, EP_WinFunc) ){
101082 Window *pWin = pExpr->y.pWin;
101092 static void windowRemoveExprFromSelect(Select *pSelect, Expr *pExpr){
101098 sqlite3WalkExpr(&sWalker, pExpr);
101139 Expr *pE = pItem->pExpr;
101171 if( sqlite3ExprCompare(0, pE, pSelect->pEList->a[j].pExpr, -1)==0 ){
101394 if( ExprHasProperty(pItem->pExpr, EP_Agg) ){
101475 Expr *pExpr /* The expression to be analyzed. */
101480 if( pExpr==0 ) return SQLITE_OK;
101489 w.pParse->nHeight += pExpr->nHeight;
101494 sqlite3WalkExpr(&w, pExpr);
101496 w.pParse->nHeight -= pExpr->nHeight;
101502 ExprSetProperty(pExpr, pNC->ncFlags & (NC_HasAgg|NC_HasWin) );
101528 Expr *pExpr = pList->a[i].pExpr;
101529 if( pExpr==0 ) continue;
101531 w.pParse->nHeight += pExpr->nHeight;
101536 sqlite3WalkExpr(&w, pExpr);
101538 w.pParse->nHeight -= pExpr->nHeight;
101545 ExprSetProperty(pExpr, pNC->ncFlags & (NC_HasAgg|NC_HasWin) );
101606 Expr *pExpr, /* Expression to resolve. May be NULL. */
101632 if( (rc = sqlite3ResolveExprNames(&sNC, pExpr))!=SQLITE_OK ) return rc;
101683 SQLITE_PRIVATE char sqlite3ExprAffinity(const Expr *pExpr){
101685 while( ExprHasProperty(pExpr, EP_Skip|EP_IfNullRow) ){
101686 assert( pExpr->op==TK_COLLATE
101687 || pExpr->op==TK_IF_NULL_ROW
101688 || (pExpr->op==TK_REGISTER && pExpr->op2==TK_IF_NULL_ROW) );
101689 pExpr = pExpr->pLeft;
101690 assert( pExpr!=0 );
101692 op = pExpr->op;
101693 if( op==TK_REGISTER ) op = pExpr->op2;
101695 assert( ExprUseYTab(pExpr) );
101696 if( pExpr->y.pTab ){
101697 return sqlite3TableColumnAffinity(pExpr->y.pTab, pExpr->iColumn);
101701 assert( ExprUseXSelect(pExpr) );
101702 assert( pExpr->x.pSelect!=0 );
101703 assert( pExpr->x.pSelect->pEList!=0 );
101704 assert( pExpr->x.pSelect->pEList->a[0].pExpr!=0 );
101705 return sqlite3ExprAffinity(pExpr->x.pSelect->pEList->a[0].pExpr);
101709 assert( !ExprHasProperty(pExpr, EP_IntValue) );
101710 return sqlite3AffinityType(pExpr->u.zToken, 0);
101714 assert( pExpr->pLeft!=0 && ExprUseXSelect(pExpr->pLeft) );
101715 assert( pExpr->iColumn < pExpr->iTable );
101716 assert( pExpr->iTable==pExpr->pLeft->x.pSelect->pEList->nExpr );
101718 pExpr->pLeft->x.pSelect->pEList->a[pExpr->iColumn].pExpr
101722 assert( ExprUseXList(pExpr) );
101723 return sqlite3ExprAffinity(pExpr->x.pList->a[0].pExpr);
101725 return pExpr->affExpr;
101738 Expr *pExpr, /* Add the "COLLATE" clause to this expression */
101745 pNew->pLeft = pExpr;
101747 pExpr = pNew;
101750 return pExpr;
101754 Expr *pExpr, /* Add the "COLLATE" clause to this expression */
101760 return sqlite3ExprAddCollateToken(pParse, pExpr, &s, 0);
101766 SQLITE_PRIVATE Expr *sqlite3ExprSkipCollate(Expr *pExpr){
101767 while( pExpr && ExprHasProperty(pExpr, EP_Skip) ){
101768 assert( pExpr->op==TK_COLLATE );
101769 pExpr = pExpr->pLeft;
101771 return pExpr;
101779 SQLITE_PRIVATE Expr *sqlite3ExprSkipCollateAndLikely(Expr *pExpr){
101780 while( pExpr && ExprHasProperty(pExpr, EP_Skip|EP_Unlikely) ){
101781 if( ExprHasProperty(pExpr, EP_Unlikely) ){
101782 assert( ExprUseXList(pExpr) );
101783 assert( pExpr->x.pList->nExpr>0 );
101784 assert( pExpr->op==TK_FUNCTION );
101785 pExpr = pExpr->x.pList->a[0].pExpr;
101787 assert( pExpr->op==TK_COLLATE );
101788 pExpr = pExpr->pLeft;
101791 return pExpr;
101808 SQLITE_PRIVATE CollSeq *sqlite3ExprCollSeq(Parse *pParse, const Expr *pExpr){
101811 const Expr *p = pExpr;
101834 p = p->x.pList->a[0].pExpr;
101853 if( ExprHasProperty(p->x.pList->a[i].pExpr, EP_Collate) ){
101854 pNext = p->x.pList->a[i].pExpr;
101881 SQLITE_PRIVATE CollSeq *sqlite3ExprNNCollSeq(Parse *pParse, const Expr *pExpr){
101882 CollSeq *p = sqlite3ExprCollSeq(pParse, pExpr);
101902 SQLITE_PRIVATE char sqlite3CompareAffinity(const Expr *pExpr, char aff2){
101903 char aff1 = sqlite3ExprAffinity(pExpr);
101924 static char comparisonAffinity(const Expr *pExpr){
101926 assert( pExpr->op==TK_EQ || pExpr->op==TK_IN || pExpr->op==TK_LT ||
101927 pExpr->op==TK_GT || pExpr->op==TK_GE || pExpr->op==TK_LE ||
101928 pExpr->op==TK_NE || pExpr->op==TK_IS || pExpr->op==TK_ISNOT );
101929 assert( pExpr->pLeft );
101930 aff = sqlite3ExprAffinity(pExpr->pLeft);
101931 if( pExpr->pRight ){
101932 aff = sqlite3CompareAffinity(pExpr->pRight, aff);
101933 }else if( ExprUseXSelect(pExpr) ){
101934 aff = sqlite3CompareAffinity(pExpr->x.pSelect->pEList->a[0].pExpr, aff);
101947 SQLITE_PRIVATE int sqlite3IndexAffinityOk(const Expr *pExpr, char idx_affinity){
101948 char aff = comparisonAffinity(pExpr);
102059 SQLITE_PRIVATE int sqlite3ExprIsVector(const Expr *pExpr){
102060 return sqlite3ExprVectorSize(pExpr)>1;
102069 SQLITE_PRIVATE int sqlite3ExprVectorSize(const Expr *pExpr){
102070 u8 op = pExpr->op;
102071 if( op==TK_REGISTER ) op = pExpr->op2;
102073 assert( ExprUseXList(pExpr) );
102074 return pExpr->x.pList->nExpr;
102076 assert( ExprUseXSelect(pExpr) );
102077 return pExpr->x.pSelect->pEList->nExpr;
102104 return pVector->x.pSelect->pEList->a[i].pExpr;
102107 return pVector->x.pList->a[i].pExpr;
102169 ppVector = &pVector->x.pList->a[iField].pExpr;
102190 static int exprCodeSubselect(Parse *pParse, Expr *pExpr){
102193 if( pExpr->op==TK_SELECT ){
102194 reg = sqlite3CodeSubselect(pParse, pExpr);
102234 *ppExpr = pVector->x.pSelect->pEList->a[iField].pExpr;
102239 *ppExpr = pVector->x.pList->a[iField].pExpr;
102258 Expr *pExpr, /* The comparison operation */
102264 Expr *pLeft = pExpr->pLeft;
102265 Expr *pRight = pExpr->pRight;
102273 int isCommuted = ExprHasProperty(pExpr,EP_Commuted);
102275 assert( !ExprHasVVAProperty(pExpr,EP_Immutable) );
102281 assert( pExpr->op==TK_EQ || pExpr->op==TK_NE
102282 || pExpr->op==TK_IS || pExpr->op==TK_ISNOT
102283 || pExpr->op==TK_LT || pExpr->op==TK_GT
102284 || pExpr->op==TK_LE || pExpr->op==TK_GE
102286 assert( pExpr->op==op || (pExpr->op==TK_IS && op==TK_EQ)
102287 || (pExpr->op==TK_ISNOT && op==TK_NE) );
102288 assert( p5==0 || pExpr->op!=op );
102289 assert( p5==SQLITE_NULLEQ || pExpr->op==op );
102383 heightOfExpr(p->a[i].pExpr, pnHeight);
102599 SQLITE_PRIVATE void sqlite3PExprAddSelect(Parse *pParse, Expr *pExpr, Select *pSelect){
102600 if( pExpr ){
102601 pExpr->x.pSelect = pSelect;
102602 ExprSetProperty(pExpr, EP_xIsSelect|EP_Subquery);
102603 sqlite3ExprSetHeightAndFlags(pParse, pExpr);
102635 Expr *pExpr = pEList->a[ii].pExpr;
102637 if( pExpr->op==TK_VECTOR ){
102638 assert( ExprUseXList(pExpr) );
102639 nExprElem = pExpr->x.pList->nExpr;
102649 assert( ExprUseXList(pExpr) );
102650 pSel = sqlite3SelectNew(pParse, pExpr->x.pList, 0, 0, 0, 0, 0, SF_Values,0);
102651 pExpr->x.pList = 0;
102738 const Expr *pExpr, /* The function invocation */
102743 if( ExprHasProperty(pExpr, EP_FromDDL) ){
102775 SQLITE_PRIVATE void sqlite3ExprAssignVarNumber(Parse *pParse, Expr *pExpr, u32 n){
102780 if( pExpr==0 ) return;
102781 assert( !ExprHasProperty(pExpr, EP_IntValue|EP_Reduced|EP_TokenOnly) );
102782 z = pExpr->u.zToken;
102834 pExpr->iColumn = x;
102899 SQLITE_PRIVATE void sqlite3ExprDeferredDelete(Parse *pParse, Expr *pExpr){
102901 sqlite3ExprListAppend(pParse, pParse->pConstExpr, pExpr);
103170 static int gatherSelectWindowsCallback(Walker *pWalker, Expr *pExpr){
103171 if( pExpr->op==TK_FUNCTION && ExprHasProperty(pExpr, EP_WinFunc) ){
103173 Window *pWin = pExpr->y.pWin;
103175 assert( IsWindowFunc(pExpr) );
103233 Expr *pOldExpr = pOldItem->pExpr;
103235 pItem->pExpr = sqlite3ExprDup(db, pOldExpr, flags);
103238 && (pNewExpr = pItem->pExpr)!=0
103414 Expr *pExpr /* Expression to be appended. Might be NULL */
103421 sqlite3ExprDelete(db, pExpr);
103428 pItem->pExpr = pExpr;
103434 Expr *pExpr /* Expression to be appended. Might be NULL */
103443 sqlite3ExprDelete(db, pExpr);
103450 pItem->pExpr = pExpr;
103456 Expr *pExpr /* Expression to be appended. Might be NULL */
103460 return sqlite3ExprListAppendNew(pParse->db,pExpr);
103463 return sqlite3ExprListAppendGrow(pParse->db,pList,pExpr);
103467 pItem->pExpr = pExpr;
103486 Expr *pExpr /* Vector expression to be appended. Might be NULL */
103495 if( pExpr==0 ) goto vector_append_error;
103502 if( pExpr->op!=TK_SELECT && pColumns->nId!=(n=sqlite3ExprVectorSize(pExpr)) ){
103509 Expr *pSubExpr = sqlite3ExprForVectorField(pParse, pExpr, i, pColumns->nId);
103520 if( !db->mallocFailed && pExpr->op==TK_SELECT && ALWAYS(pList!=0) ){
103521 Expr *pFirst = pList->a[iFirst].pExpr;
103527 pFirst->pRight = pExpr;
103528 pExpr = 0;
103536 sqlite3ExprUnmapAndDelete(pParse, pExpr);
103660 sqlite3ExprDelete(db, pItem->pExpr);
103679 Expr *pExpr = pList->a[i].pExpr;
103680 assert( pExpr!=0 );
103681 m |= pExpr->flags;
103719 SQLITE_PRIVATE int sqlite3ExprIdToTrueFalse(Expr *pExpr){
103721 assert( pExpr->op==TK_ID || pExpr->op==TK_STRING );
103722 if( !ExprHasProperty(pExpr, EP_Quoted|EP_IntValue)
103723 && (v = sqlite3IsTrueOrFalse(pExpr->u.zToken))!=0
103725 pExpr->op = TK_TRUEFALSE;
103726 ExprSetProperty(pExpr, v);
103736 SQLITE_PRIVATE int sqlite3ExprTruthValue(const Expr *pExpr){
103737 pExpr = sqlite3ExprSkipCollate((Expr*)pExpr);
103738 assert( pExpr->op==TK_TRUEFALSE );
103739 assert( !ExprHasProperty(pExpr, EP_IntValue) );
103740 assert( sqlite3StrICmp(pExpr->u.zToken,"true")==0
103741 || sqlite3StrICmp(pExpr->u.zToken,"false")==0 );
103742 return pExpr->u.zToken[4]==0;
103758 SQLITE_PRIVATE Expr *sqlite3ExprSimplifiedAndOr(Expr *pExpr){
103759 assert( pExpr!=0 );
103760 if( pExpr->op==TK_AND || pExpr->op==TK_OR ){
103761 Expr *pRight = sqlite3ExprSimplifiedAndOr(pExpr->pRight);
103762 Expr *pLeft = sqlite3ExprSimplifiedAndOr(pExpr->pLeft);
103764 pExpr = pExpr->op==TK_AND ? pRight : pLeft;
103766 pExpr = pExpr->op==TK_AND ? pLeft : pRight;
103769 return pExpr;
103799 static int exprNodeIsConstant(Walker *pWalker, Expr *pExpr){
103804 if( pWalker->eCode==2 && ExprHasProperty(pExpr, EP_FromJoin) ){
103809 switch( pExpr->op ){
103814 if( (pWalker->eCode>=4 || ExprHasProperty(pExpr,EP_ConstFunc))
103815 && !ExprHasProperty(pExpr, EP_WinFunc)
103817 if( pWalker->eCode==5 ) ExprSetProperty(pExpr, EP_FromDDL);
103826 if( sqlite3ExprIdToTrueFalse(pExpr) ){
103833 testcase( pExpr->op==TK_ID );
103834 testcase( pExpr->op==TK_COLUMN );
103835 testcase( pExpr->op==TK_AGG_FUNCTION );
103836 testcase( pExpr->op==TK_AGG_COLUMN );
103837 if( ExprHasProperty(pExpr, EP_FixedCol) && pWalker->eCode!=2 ){
103840 if( pWalker->eCode==3 && pExpr->iTable==pWalker->u.iCur ){
103847 testcase( pExpr->op==TK_REGISTER );
103848 testcase( pExpr->op==TK_IF_NULL_ROW );
103849 testcase( pExpr->op==TK_DOT );
103857 pExpr->op = TK_NULL;
103866 testcase( pExpr->op==TK_SELECT ); /* sqlite3SelectWalkFail() disallows */
103867 testcase( pExpr->op==TK_EXISTS ); /* sqlite3SelectWalkFail() disallows */
103927 static int exprNodeIsConstantOrGroupBy(Walker *pWalker, Expr *pExpr){
103934 Expr *p = pGroupBy->a[i].pExpr;
103935 if( sqlite3ExprCompare(0, pExpr, p, -1)<2 ){
103944 if( ExprUseXSelect(pExpr) ){
103949 return exprNodeIsConstant(pWalker, pExpr);
104196 Expr *pRes = pEList->a[i].pExpr;
104347 if( sqlite3ExprCanBeNull(pEList->a[i].pExpr) ) break;
104365 assert( p->pEList->a[0].pExpr!=0 ); /* Because of isCandidateForInOpt(p) */
104376 if( nExpr==1 && pEList->a[0].pExpr->iColumn<0 ){
104397 int iCol = pEList->a[i].pExpr->iColumn;
104440 Expr *pRhs = pEList->a[i].pExpr;
104545 static char *exprINAffinity(Parse *pParse, const Expr *pExpr){
104546 Expr *pLeft = pExpr->pLeft;
104548 Select *pSelect = ExprUseXSelect(pExpr) ? pExpr->x.pSelect : 0;
104551 assert( pExpr->op==TK_IN );
104559 zRet[i] = sqlite3CompareAffinity(pSelect->pEList->a[i].pExpr, a);
104596 SQLITE_PRIVATE void sqlite3VectorErrorMsg(Parse *pParse, Expr *pExpr){
104598 if( ExprUseXSelect(pExpr) ){
104599 sqlite3SubselectError(pParse, pExpr->x.pSelect->pEList->nExpr, 1);
104632 Expr *pExpr, /* The IN operator */
104655 if( !ExprHasProperty(pExpr, EP_VarSelect) && pParse->iSelfTab==0 ){
104660 if( ExprHasProperty(pExpr, EP_Subrtn) ){
104662 if( ExprUseXSelect(pExpr) ){
104664 pExpr->x.pSelect->selId));
104666 assert( ExprUseYSub(pExpr) );
104667 sqlite3VdbeAddOp2(v, OP_Gosub, pExpr->y.sub.regReturn,
104668 pExpr->y.sub.iAddr);
104669 sqlite3VdbeAddOp2(v, OP_OpenDup, iTab, pExpr->iTable);
104675 assert( !ExprUseYWin(pExpr) );
104676 ExprSetProperty(pExpr, EP_Subrtn);
104677 assert( !ExprHasProperty(pExpr, EP_TokenOnly|EP_Reduced) );
104678 pExpr->y.sub.regReturn = ++pParse->nMem;
104679 pExpr->y.sub.iAddr =
104680 sqlite3VdbeAddOp2(v, OP_Integer, 0, pExpr->y.sub.regReturn) + 1;
104687 pLeft = pExpr->pLeft;
104693 pExpr->iTable = iTab;
104694 addr = sqlite3VdbeAddOp2(v, OP_OpenEphemeral, pExpr->iTable, nVal);
104696 if( ExprUseXSelect(pExpr) ){
104697 VdbeComment((v, "Result of SELECT %u", pExpr->x.pSelect->selId));
104704 if( ExprUseXSelect(pExpr) ){
104710 Select *pSelect = pExpr->x.pSelect;
104724 dest.zAffSdst = exprINAffinity(pParse, pExpr);
104743 pParse, p, pEList->a[i].pExpr
104747 }else if( ALWAYS(pExpr->x.pList!=0) ){
104757 ExprList *pList = pExpr->x.pList;
104768 pKeyInfo->aColl[0] = sqlite3ExprCollSeq(pParse, pExpr->pLeft);
104775 Expr *pE2 = pItem->pExpr;
104784 ExprClearProperty(pExpr, EP_Subrtn);
104802 assert( ExprUseYSub(pExpr) );
104803 sqlite3VdbeAddOp1(v, OP_Return, pExpr->y.sub.regReturn);
104804 sqlite3VdbeChangeP1(v, pExpr->y.sub.iAddr-1, sqlite3VdbeCurrentAddr(v)-1);
104825 SQLITE_PRIVATE int sqlite3CodeSubselect(Parse *pParse, Expr *pExpr){
104836 testcase( pExpr->op==TK_EXISTS );
104837 testcase( pExpr->op==TK_SELECT );
104838 assert( pExpr->op==TK_EXISTS || pExpr->op==TK_SELECT );
104839 assert( ExprUseXSelect(pExpr) );
104840 pSel = pExpr->x.pSelect;
104844 if( ExprHasProperty(pExpr, EP_Subrtn) ){
104846 assert( ExprUseYSub(pExpr) );
104847 sqlite3VdbeAddOp2(v, OP_Gosub, pExpr->y.sub.regReturn,
104848 pExpr->y.sub.iAddr);
104849 return pExpr->iTable;
104853 assert( !ExprUseYWin(pExpr) );
104854 assert( !ExprHasProperty(pExpr, EP_Reduced|EP_TokenOnly) );
104855 ExprSetProperty(pExpr, EP_Subrtn);
104856 pExpr->y.sub.regReturn = ++pParse->nMem;
104857 pExpr->y.sub.iAddr =
104858 sqlite3VdbeAddOp2(v, OP_Integer, 0, pExpr->y.sub.regReturn) + 1;
104872 if( !ExprHasProperty(pExpr, EP_VarSelect) ){
104888 nReg = pExpr->op==TK_SELECT ? pSel->pEList->nExpr : 1;
104891 if( pExpr->op==TK_SELECT ){
104922 pExpr->op2 = pExpr->op;
104923 pExpr->op = TK_ERROR;
104927 pExpr->iTable = rReg = dest.iSDParm;
104928 ExprSetVVAProperty(pExpr, EP_NoReduce);
104934 assert( ExprUseYSub(pExpr) );
104935 sqlite3VdbeAddOp1(v, OP_Return, pExpr->y.sub.regReturn);
104936 sqlite3VdbeChangeP1(v, pExpr->y.sub.iAddr-1, sqlite3VdbeCurrentAddr(v)-1);
104992 Expr *pExpr, /* The IN expression */
105015 assert( !ExprHasVVAProperty(pExpr,EP_Immutable) );
105016 pLeft = pExpr->pLeft;
105017 if( sqlite3ExprCheckIN(pParse, pExpr) ) return;
105018 zAff = exprINAffinity(pParse, pExpr);
105019 nVector = sqlite3ExprVectorSize(pExpr->pLeft);
105032 eType = sqlite3FindInIndex(pParse, pExpr,
105091 assert( ExprUseXList(pExpr) );
105092 pList = pExpr->x.pList;
105093 pColl = sqlite3ExprCollSeq(pParse, pExpr->pLeft);
105099 r2 = sqlite3ExprCodeTemp(pParse, pList->a[ii].pExpr, ®ToFree);
105100 if( regCkNull && sqlite3ExprCanBeNull(pList->a[ii].pExpr) ){
105143 Expr *p = sqlite3VectorFieldSubexpr(pExpr->pLeft, i);
105267 static void codeInteger(Parse *pParse, Expr *pExpr, int negFlag, int iMem){
105269 if( pExpr->flags & EP_IntValue ){
105270 int i = pExpr->u.iValue;
105277 const char *z = pExpr->u.zToken;
105316 sqlite3ExprCodeCopy(pParse, pIdx->aColExpr->a[iIdxCol].pExpr, regOut);
105443 static void exprToRegister(Expr *pExpr, int iReg){
105444 Expr *p = sqlite3ExprSkipCollateAndLikely(pExpr);
105481 sqlite3ExprCodeFactorable(pParse, p->x.pList->a[i].pExpr, i+iResult);
105523 sqlite3ExprCode(pParse, pFarg->a[0].pExpr, target);
105527 sqlite3ExprCode(pParse, pFarg->a[i].pExpr, target);
105546 target = sqlite3ExprCodeTarget(pParse, pFarg->a[0].pExpr, target);
105559 sqlite3ExprCompare(0,pFarg->a[0].pExpr, pFarg->a[1].pExpr,-1),
105568 sqlite3ExprImpliesExpr(pParse,pFarg->a[0].pExpr, pFarg->a[1].pExpr,-1),
105577 pA1 = pFarg->a[1].pExpr;
105580 sqlite3ExprImpliesNonNullRow(pFarg->a[0].pExpr,pA1->iTable),
105596 aff = sqlite3ExprAffinity(pFarg->a[0].pExpr);
105618 SQLITE_PRIVATE int sqlite3ExprCodeTarget(Parse *pParse, Expr *pExpr, int target){
105632 if( pExpr==0 ){
105635 assert( !ExprHasVVAProperty(pExpr,EP_Immutable) );
105636 op = pExpr->op;
105640 AggInfo *pAggInfo = pExpr->pAggInfo;
105643 assert( pExpr->iAgg>=0 && pExpr->iAgg<pAggInfo->nColumn );
105644 pCol = &pAggInfo->aCol[pExpr->iAgg];
105667 int iTab = pExpr->iTable;
105669 if( ExprHasProperty(pExpr, EP_FixedCol) ){
105677 iReg = sqlite3ExprCodeTarget(pParse, pExpr->pLeft,target);
105678 assert( ExprUseYTab(pExpr) );
105679 if( pExpr->y.pTab ){
105680 aff = sqlite3TableColumnAffinity(pExpr->y.pTab, pExpr->iColumn);
105682 aff = pExpr->affExpr;
105704 int iCol = pExpr->iColumn;
105705 assert( ExprUseYTab(pExpr) );
105706 pTab = pExpr->y.pTab;
105744 assert( ExprUseYTab(pExpr) );
105745 iReg = sqlite3ExprCodeGetColumn(pParse, pExpr->y.pTab,
105746 pExpr->iColumn, iTab, target,
105747 pExpr->op2);
105748 if( pExpr->y.pTab==0 && pExpr->affExpr==SQLITE_AFF_REAL ){
105754 codeInteger(pParse, pExpr, 0, target);
105758 sqlite3VdbeAddOp2(v, OP_Integer, sqlite3ExprTruthValue(pExpr), target);
105763 assert( !ExprHasProperty(pExpr, EP_IntValue) );
105764 codeReal(v, pExpr->u.zToken, 0, target);
105769 assert( !ExprHasProperty(pExpr, EP_IntValue) );
105770 sqlite3VdbeLoadString(v, target, pExpr->u.zToken);
105787 assert( !ExprHasProperty(pExpr, EP_IntValue) );
105788 assert( pExpr->u.zToken[0]=='x' || pExpr->u.zToken[0]=='X' );
105789 assert( pExpr->u.zToken[1]=='\'' );
105790 z = &pExpr->u.zToken[2];
105799 assert( !ExprHasProperty(pExpr, EP_IntValue) );
105800 assert( pExpr->u.zToken!=0 );
105801 assert( pExpr->u.zToken[0]!=0 );
105802 sqlite3VdbeAddOp2(v, OP_Variable, pExpr->iColumn, target);
105803 if( pExpr->u.zToken[1]!=0 ){
105804 const char *z = sqlite3VListNumToName(pParse->pVList, pExpr->iColumn);
105805 assert( pExpr->u.zToken[0]=='?' || (z && !strcmp(pExpr->u.zToken, z)) );
105812 return pExpr->iTable;
105817 inReg = sqlite3ExprCodeTarget(pParse, pExpr->pLeft, target);
105822 assert( !ExprHasProperty(pExpr, EP_IntValue) );
105824 sqlite3AffinityType(pExpr->u.zToken, 0));
105839 Expr *pLeft = pExpr->pLeft;
105841 codeVectorCompare(pParse, pExpr, target, op, p5);
105844 r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, ®Free2);
105846 codeCompare(pParse, pLeft, pExpr->pRight, op, r1, r2,
105848 ExprHasProperty(pExpr,EP_Commuted));
105888 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1);
105889 r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, ®Free2);
105896 Expr *pLeft = pExpr->pLeft;
105903 assert( !ExprHasProperty(pExpr, EP_IntValue) );
105913 r2 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free2);
105923 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1);
105931 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1);
105933 isTrue = sqlite3ExprTruthValue(pExpr->pRight);
105934 bNormal = pExpr->op2==TK_IS;
105946 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1);
105956 AggInfo *pInfo = pExpr->pAggInfo;
105958 || NEVER(pExpr->iAgg<0)
105959 || NEVER(pExpr->iAgg>=pInfo->nFunc)
105961 assert( !ExprHasProperty(pExpr, EP_IntValue) );
105962 sqlite3ErrorMsg(pParse, "misuse of aggregate: %s()", pExpr->u.zToken);
105964 return pInfo->aFunc[pExpr->iAgg].iMem;
105980 if( ExprHasProperty(pExpr, EP_WinFunc) ){
105981 return pExpr->y.pWin->regResult;
105985 if( ConstFactorOk(pParse) && sqlite3ExprIsConstantNotJoin(pExpr) ){
105988 return sqlite3ExprCodeRunJustOnce(pParse, pExpr, -1);
105990 assert( !ExprHasProperty(pExpr, EP_TokenOnly) );
105991 assert( ExprUseXList(pExpr) );
105992 pFarg = pExpr->x.pList;
105994 assert( !ExprHasProperty(pExpr, EP_IntValue) );
105995 zId = pExpr->u.zToken;
106012 sqlite3ExprFunctionUsable(pParse, pExpr, pDef);
106016 if( i<32 && sqlite3ExprIsConstant(pFarg->a[i].pExpr) ){
106021 pColl = sqlite3ExprCollSeq(pParse, pFarg->a[i].pExpr);
106040 assert( pFarg->a[0].pExpr!=0 );
106041 exprOp = pFarg->a[0].pExpr->op;
106046 pFarg->a[0].pExpr->op2 =
106069 if( nFarg>=2 && ExprHasProperty(pExpr, EP_InfixFunc) ){
106070 pDef = sqlite3VtabOverloadFunction(db, pDef, nFarg, pFarg->a[1].pExpr);
106072 pDef = sqlite3VtabOverloadFunction(db, pDef, nFarg, pFarg->a[0].pExpr);
106081 Expr *pArg = pFarg->a[0].pExpr;
106091 pDef, pExpr->op2);
106111 && ALWAYS( ExprUseXSelect(pExpr) )
106112 && (nCol = pExpr->x.pSelect->pEList->nExpr)!=1
106116 return sqlite3CodeSubselect(pParse, pExpr);
106122 if( pExpr->pLeft->iTable==0 ){
106123 pExpr->pLeft->iTable = sqlite3CodeSubselect(pParse, pExpr->pLeft);
106125 assert( pExpr->pLeft->op==TK_SELECT || pExpr->pLeft->op==TK_ERROR );
106126 n = sqlite3ExprVectorSize(pExpr->pLeft);
106127 if( pExpr->iTable!=n ){
106129 pExpr->iTable, n);
106131 return pExpr->pLeft->iTable + pExpr->iColumn;
106137 sqlite3ExprCodeIN(pParse, pExpr, destIfFalse, destIfNull);
106159 exprCodeBetween(pParse, pExpr, target, 0, 0);
106165 pExpr = pExpr->pLeft;
106199 assert( ExprUseYTab(pExpr) );
106200 pTab = pExpr->y.pTab;
106201 iCol = pExpr->iColumn;
106202 p1 = pExpr->iTable * (pTab->nCol+1) + 1
106205 assert( pExpr->iTable==0 || pExpr->iTable==1 );
106212 (pExpr->iTable ? "new" : "old"),
106213 (pExpr->iColumn<0 ? "rowid" : pExpr->y.pTab->aCol[iCol].zCnName)
106243 addrINR = sqlite3VdbeAddOp1(v, OP_IfNullRow, pExpr->iTable);
106249 inReg = sqlite3ExprCodeTarget(pParse, pExpr->pLeft, target);
106290 assert( ExprUseXList(pExpr) && pExpr->x.pList!=0 );
106291 assert(pExpr->x.pList->nExpr > 0);
106292 pEList = pExpr->x.pList;
106296 if( (pX = pExpr->pLeft)!=0 ){
106318 opCompare.pRight = aListelem[i].pExpr;
106320 pTest = aListelem[i].pExpr;
106325 testcase( aListelem[i+1].pExpr->op==TK_COLUMN );
106326 sqlite3ExprCode(pParse, aListelem[i+1].pExpr, target);
106331 sqlite3ExprCode(pParse, pEList->a[nExpr-1].pExpr, target);
106342 assert( pExpr->affExpr==OE_Rollback
106343 || pExpr->affExpr==OE_Abort
106344 || pExpr->affExpr==OE_Fail
106345 || pExpr->affExpr==OE_Ignore
106352 if( pExpr->affExpr==OE_Abort ){
106355 assert( !ExprHasProperty(pExpr, EP_IntValue) );
106356 if( pExpr->affExpr==OE_Ignore ){
106358 v, OP_Halt, SQLITE_OK, OE_Ignore, 0, pExpr->u.zToken,0);
106363 pExpr->affExpr, pExpr->u.zToken, 0, 0);
106394 Expr *pExpr, /* The expression to code when the VDBE initializes */
106404 if( pItem->reusable && sqlite3ExprCompare(0,pItem->pExpr,pExpr,-1)==0 ){
106409 pExpr = sqlite3ExprDup(pParse->db, pExpr, 0);
106410 if( pExpr!=0 && ExprHasProperty(pExpr, EP_HasFunc) ){
106418 sqlite3ExprCode(pParse, pExpr, regDest);
106421 sqlite3ExprDelete(pParse->db, pExpr);
106424 p = sqlite3ExprListAppend(pParse, p, pExpr);
106449 SQLITE_PRIVATE int sqlite3ExprCodeTemp(Parse *pParse, Expr *pExpr, int *pReg){
106451 pExpr = sqlite3ExprSkipCollateAndLikely(pExpr);
106453 && ALWAYS(pExpr!=0)
106454 && pExpr->op!=TK_REGISTER
106455 && sqlite3ExprIsConstantNotJoin(pExpr)
106458 r2 = sqlite3ExprCodeRunJustOnce(pParse, pExpr, -1);
106461 r2 = sqlite3ExprCodeTarget(pParse, pExpr, r1);
106477 SQLITE_PRIVATE void sqlite3ExprCode(Parse *pParse, Expr *pExpr, int target){
106480 assert( pExpr==0 || !ExprHasVVAProperty(pExpr,EP_Immutable) );
106484 inReg = sqlite3ExprCodeTarget(pParse, pExpr, target);
106487 if( ALWAYS(pExpr) && ExprHasProperty(pExpr,EP_Subquery) ){
106501 SQLITE_PRIVATE void sqlite3ExprCodeCopy(Parse *pParse, Expr *pExpr, int target){
106503 pExpr = sqlite3ExprDup(db, pExpr, 0);
106504 if( !db->mallocFailed ) sqlite3ExprCode(pParse, pExpr, target);
106505 sqlite3ExprDelete(db, pExpr);
106514 SQLITE_PRIVATE void sqlite3ExprCodeFactorable(Parse *pParse, Expr *pExpr, int target){
106515 if( pParse->okConstFactor && sqlite3ExprIsConstantNotJoin(pExpr) ){
106516 sqlite3ExprCodeRunJustOnce(pParse, pExpr, target);
106518 sqlite3ExprCodeCopy(pParse, pExpr, target);
106559 Expr *pExpr = pItem->pExpr;
106574 && sqlite3ExprIsConstantNotJoin(pExpr)
106576 sqlite3ExprCodeRunJustOnce(pParse, pExpr, target+i);
106578 int inReg = sqlite3ExprCodeTarget(pParse, pExpr, target+i);
106619 Expr *pExpr, /* The BETWEEN expression */
106635 assert( ExprUseXList(pExpr) );
106636 pDel = sqlite3ExprDup(db, pExpr->pLeft, 0);
106643 compLeft.pRight = pExpr->x.pList->a[0].pExpr;
106646 compRight.pRight = pExpr->x.pList->a[1].pExpr;
106689 SQLITE_PRIVATE void sqlite3ExprIfTrue(Parse *pParse, Expr *pExpr, int dest, int jumpIfNull){
106698 if( NEVER(pExpr==0) ) return; /* No way this can happen */
106699 assert( !ExprHasVVAProperty(pExpr, EP_Immutable) );
106700 op = pExpr->op;
106704 Expr *pAlt = sqlite3ExprSimplifiedAndOr(pExpr);
106705 if( pAlt!=pExpr ){
106710 sqlite3ExprIfFalse(pParse, pExpr->pLeft, d2,
106712 sqlite3ExprIfTrue(pParse, pExpr->pRight, dest, jumpIfNull);
106716 sqlite3ExprIfTrue(pParse, pExpr->pLeft, dest, jumpIfNull);
106717 sqlite3ExprIfTrue(pParse, pExpr->pRight, dest, jumpIfNull);
106723 sqlite3ExprIfFalse(pParse, pExpr->pLeft, dest, jumpIfNull);
106730 isNot = pExpr->op2==TK_ISNOT;
106731 isTrue = sqlite3ExprTruthValue(pExpr->pRight);
106735 sqlite3ExprIfTrue(pParse, pExpr->pLeft, dest,
106738 sqlite3ExprIfFalse(pParse, pExpr->pLeft, dest,
106756 if( sqlite3ExprIsVector(pExpr->pLeft) ) goto default_expr;
106758 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1);
106759 r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, ®Free2);
106760 codeCompare(pParse, pExpr->pLeft, pExpr->pRight, op,
106761 r1, r2, dest, jumpIfNull, ExprHasProperty(pExpr,EP_Commuted));
106780 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1);
106789 exprCodeBetween(pParse, pExpr, dest, sqlite3ExprIfTrue, jumpIfNull);
106796 sqlite3ExprCodeIN(pParse, pExpr, destIfFalse, destIfNull);
106804 if( ExprAlwaysTrue(pExpr) ){
106806 }else if( ExprAlwaysFalse(pExpr) ){
106809 r1 = sqlite3ExprCodeTemp(pParse, pExpr, ®Free1);
106831 SQLITE_PRIVATE void sqlite3ExprIfFalse(Parse *pParse, Expr *pExpr, int dest, int jumpIfNull){
106840 if( pExpr==0 ) return;
106841 assert( !ExprHasVVAProperty(pExpr,EP_Immutable) );
106861 op = ((pExpr->op+(TK_ISNULL&1))^1)-(TK_ISNULL&1);
106865 assert( pExpr->op!=TK_ISNULL || op==OP_NotNull );
106866 assert( pExpr->op!=TK_NOTNULL || op==OP_IsNull );
106867 assert( pExpr->op!=TK_NE || op==OP_Eq );
106868 assert( pExpr->op!=TK_EQ || op==OP_Ne );
106869 assert( pExpr->op!=TK_LT || op==OP_Ge );
106870 assert( pExpr->op!=TK_LE || op==OP_Gt );
106871 assert( pExpr->op!=TK_GT || op==OP_Le );
106872 assert( pExpr->op!=TK_GE || op==OP_Lt );
106874 switch( pExpr->op ){
106877 Expr *pAlt = sqlite3ExprSimplifiedAndOr(pExpr);
106878 if( pAlt!=pExpr ){
106880 }else if( pExpr->op==TK_AND ){
106882 sqlite3ExprIfFalse(pParse, pExpr->pLeft, dest, jumpIfNull);
106883 sqlite3ExprIfFalse(pParse, pExpr->pRight, dest, jumpIfNull);
106887 sqlite3ExprIfTrue(pParse, pExpr->pLeft, d2,
106889 sqlite3ExprIfFalse(pParse, pExpr->pRight, dest, jumpIfNull);
106896 sqlite3ExprIfTrue(pParse, pExpr->pLeft, dest, jumpIfNull);
106903 isNot = pExpr->op2==TK_ISNOT;
106904 isTrue = sqlite3ExprTruthValue(pExpr->pRight);
106909 sqlite3ExprIfFalse(pParse, pExpr->pLeft, dest,
106914 sqlite3ExprIfTrue(pParse, pExpr->pLeft, dest,
106921 testcase( pExpr->op==TK_IS );
106922 testcase( pExpr->op==TK_ISNOT );
106923 op = (pExpr->op==TK_IS) ? TK_NE : TK_EQ;
106932 if( sqlite3ExprIsVector(pExpr->pLeft) ) goto default_expr;
106934 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1);
106935 r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, ®Free2);
106936 codeCompare(pParse, pExpr->pLeft, pExpr->pRight, op,
106937 r1, r2, dest, jumpIfNull,ExprHasProperty(pExpr,EP_Commuted));
106954 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1);
106963 exprCodeBetween(pParse, pExpr, dest, sqlite3ExprIfFalse, jumpIfNull);
106969 sqlite3ExprCodeIN(pParse, pExpr, dest, dest);
106972 sqlite3ExprCodeIN(pParse, pExpr, dest, destIfNull);
106980 if( ExprAlwaysFalse(pExpr) ){
106982 }else if( ExprAlwaysTrue(pExpr) ){
106985 r1 = sqlite3ExprCodeTemp(pParse, pExpr, ®Free1);
107003 SQLITE_PRIVATE void sqlite3ExprIfFalseDup(Parse *pParse, Expr *pExpr, int dest,int jumpIfNull){
107005 Expr *pCopy = sqlite3ExprDup(db, pExpr, 0);
107028 const Expr *pExpr
107034 sqlite3ValueFromExpr(pParse->db, pExpr, SQLITE_UTF8, SQLITE_AFF_BLOB, &pR);
107184 Expr *pExprA = pA->a[i].pExpr;
107185 Expr *pExprB = pB->a[i].pExpr;
107234 if( exprImpliesNotNull(pParse, pList->a[0].pExpr, pNN, iTab, 1)
107235 || exprImpliesNotNull(pParse, pList->a[1].pExpr, pNN, iTab, 1)
107338 static int impliesNotNullRow(Walker *pWalker, Expr *pExpr){
107339 testcase( pExpr->op==TK_AGG_COLUMN );
107340 testcase( pExpr->op==TK_AGG_FUNCTION );
107341 if( ExprHasProperty(pExpr, EP_FromJoin) ) return WRC_Prune;
107342 switch( pExpr->op ){
107353 testcase( pExpr->op==TK_ISNOT );
107354 testcase( pExpr->op==TK_ISNULL );
107355 testcase( pExpr->op==TK_NOTNULL );
107356 testcase( pExpr->op==TK_IS );
107357 testcase( pExpr->op==TK_OR );
107358 testcase( pExpr->op==TK_VECTOR );
107359 testcase( pExpr->op==TK_CASE );
107360 testcase( pExpr->op==TK_IN );
107361 testcase( pExpr->op==TK_FUNCTION );
107362 testcase( pExpr->op==TK_TRUTH );
107365 if( pWalker->u.iCur==pExpr->iTable ){
107373 sqlite3WalkExpr(pWalker, pExpr->pLeft);
107376 sqlite3WalkExpr(pWalker, pExpr->pRight);
107382 if( sqlite3WalkExpr(pWalker, pExpr->pLeft)==WRC_Abort ){
107397 Expr *pLeft = pExpr->pLeft;
107398 Expr *pRight = pExpr->pRight;
107399 testcase( pExpr->op==TK_EQ );
107400 testcase( pExpr->op==TK_NE );
107401 testcase( pExpr->op==TK_LT );
107402 testcase( pExpr->op==TK_LE );
107403 testcase( pExpr->op==TK_GT );
107404 testcase( pExpr->op==TK_GE );
107485 static int exprIdxCover(Walker *pWalker, Expr *pExpr){
107486 if( pExpr->op==TK_COLUMN
107487 && pExpr->iTable==pWalker->u.pIdxCover->iCur
107488 && sqlite3TableColumnToIndex(pWalker->u.pIdxCover->pIdx, pExpr->iColumn)<0
107507 Expr *pExpr, /* The index to be tested */
107518 sqlite3WalkExpr(&w, pExpr);
107578 static int exprRefToSrcList(Walker *pWalker, Expr *pExpr){
107579 if( pExpr->op==TK_COLUMN
107580 || pExpr->op==TK_AGG_COLUMN
107587 if( pExpr->iTable==pSrc->a[i].iCursor ){
107592 for(i=0; i<p->nExclude && p->aiExclude[i]!=pExpr->iTable; i++){}
107615 SQLITE_PRIVATE int sqlite3ReferencesSrcList(Parse *pParse, Expr *pExpr, SrcList *pSrcList){
107626 assert( pExpr->op==TK_AGG_FUNCTION );
107627 assert( ExprUseXList(pExpr) );
107628 sqlite3WalkExprList(&w, pExpr->x.pList);
107630 if( ExprHasProperty(pExpr, EP_WinFunc) ){
107631 sqlite3WalkExpr(&w, pExpr->y.pWin->pFilter);
107657 static int agginfoPersistExprCb(Walker *pWalker, Expr *pExpr){
107658 if( ALWAYS(!ExprHasProperty(pExpr, EP_TokenOnly|EP_Reduced))
107659 && pExpr->pAggInfo!=0
107661 AggInfo *pAggInfo = pExpr->pAggInfo;
107662 int iAgg = pExpr->iAgg;
107665 assert( pExpr->op==TK_AGG_COLUMN || pExpr->op==TK_AGG_FUNCTION );
107666 if( pExpr->op==TK_AGG_COLUMN ){
107668 if( pAggInfo->aCol[iAgg].pCExpr==pExpr ){
107669 pExpr = sqlite3ExprDup(db, pExpr, 0);
107670 if( pExpr ){
107671 pAggInfo->aCol[iAgg].pCExpr = pExpr;
107672 sqlite3ExprDeferredDelete(pParse, pExpr);
107677 if( pAggInfo->aFunc[iAgg].pFExpr==pExpr ){
107678 pExpr = sqlite3ExprDup(db, pExpr, 0);
107679 if( pExpr ){
107680 pAggInfo->aFunc[iAgg].pFExpr = pExpr;
107681 sqlite3ExprDeferredDelete(pParse, pExpr);
107737 static int analyzeAggregate(Walker *pWalker, Expr *pExpr){
107745 switch( pExpr->op ){
107748 testcase( pExpr->op==TK_AGG_COLUMN );
107749 testcase( pExpr->op==TK_COLUMN );
107756 assert( !ExprHasProperty(pExpr, EP_TokenOnly|EP_Reduced) );
107757 if( pExpr->iTable==pItem->iCursor ){
107767 if( pCol->iTable==pExpr->iTable &&
107768 pCol->iColumn==pExpr->iColumn ){
107776 assert( ExprUseYTab(pExpr) );
107777 pCol->pTab = pExpr->y.pTab;
107778 pCol->iTable = pExpr->iTable;
107779 pCol->iColumn = pExpr->iColumn;
107782 pCol->pCExpr = pExpr;
107789 Expr *pE = pTerm->pExpr;
107790 if( pE->op==TK_COLUMN && pE->iTable==pExpr->iTable &&
107791 pE->iColumn==pExpr->iColumn ){
107806 ExprSetVVAProperty(pExpr, EP_NoReduce);
107807 pExpr->pAggInfo = pAggInfo;
107808 pExpr->op = TK_AGG_COLUMN;
107809 pExpr->iAgg = (i16)k;
107818 && pWalker->walkerDepth==pExpr->op2
107825 if( pItem->pFExpr==pExpr ) break;
107826 if( sqlite3ExprCompare(0, pItem->pFExpr, pExpr, -1)==0 ){
107836 assert( !ExprHasProperty(pExpr, EP_xIsSelect) );
107838 pItem->pFExpr = pExpr;
107840 assert( ExprUseUToken(pExpr) );
107842 pExpr->u.zToken,
107843 pExpr->x.pList ? pExpr->x.pList->nExpr : 0, enc, 0);
107844 if( pExpr->flags & EP_Distinct ){
107853 assert( !ExprHasProperty(pExpr, EP_TokenOnly|EP_Reduced) );
107854 ExprSetVVAProperty(pExpr, EP_NoReduce);
107855 pExpr->iAgg = (i16)i;
107856 pExpr->pAggInfo = pAggInfo;
107875 SQLITE_PRIVATE void sqlite3ExprAnalyzeAggregates(NameContext *pNC, Expr *pExpr){
107884 sqlite3WalkExpr(&w, pExpr);
107898 sqlite3ExprAnalyzeAggregates(pNC, pItem->pExpr);
108797 static int renameUnmapExprCb(Walker *pWalker, Expr *pExpr){
108799 sqlite3RenameTokenRemap(pParse, 0, (const void*)pExpr);
108800 if( ExprUseYTab(pExpr) ){
108801 sqlite3RenameTokenRemap(pParse, 0, (const void*)&pExpr->y.pTab);
108893 SQLITE_PRIVATE void sqlite3RenameExprUnmap(Parse *pParse, Expr *pExpr){
108901 sqlite3WalkExpr(&sWalker, pExpr);
108994 static int renameColumnExprCb(Walker *pWalker, Expr *pExpr){
108996 if( pExpr->op==TK_TRIGGER
108997 && pExpr->iColumn==p->iCol
109000 renameTokenFind(pWalker->pParse, p, (void*)pExpr);
109001 }else if( pExpr->op==TK_COLUMN
109002 && pExpr->iColumn==p->iCol
109003 && ALWAYS(ExprUseYTab(pExpr))
109004 && p->pTab==pExpr->y.pTab
109006 renameTokenFind(pWalker->pParse, p, (void*)pExpr);
109530 Expr *pExpr = sqlite3ColumnExpr(sParse.pNewTable,
109532 sqlite3WalkExpr(&sWalker, pExpr);
109607 static int renameTableExprCb(Walker *pWalker, Expr *pExpr){
109609 if( pExpr->op==TK_COLUMN
109610 && ALWAYS(ExprUseYTab(pExpr))
109611 && p->pTab==pExpr->y.pTab
109613 renameTokenFind(pWalker->pParse, p, (void*)&pExpr->y.pTab);
109806 static int renameQuotefixExprCb(Walker *pWalker, Expr *pExpr){
109807 if( pExpr->op==TK_STRING && (pExpr->flags & EP_DblQuoted) ){
109808 renameTokenFind(pWalker->pParse, pWalker->u.pRename, (const void*)pExpr);
112195 static int resolveAttachExpr(NameContext *pName, Expr *pExpr)
112198 if( pExpr ){
112199 if( pExpr->op!=TK_ID ){
112200 rc = sqlite3ResolveExprNames(pName, pExpr);
112202 pExpr->op = TK_STRING;
112600 static int fixExprCb(Walker *p, Expr *pExpr){
112602 if( !pFix->bTemp ) ExprSetProperty(pExpr, EP_FromDDL);
112603 if( pExpr->op==TK_VARIABLE ){
112605 pExpr->op = TK_NULL;
112720 Expr *pExpr /* The expression to be fixed to one database */
112722 return sqlite3WalkExpr(&pFix->w, pExpr);
112903 Expr *pExpr, /* The expression to check authorization on */
112913 assert( pExpr->op==TK_COLUMN || pExpr->op==TK_TRIGGER );
112923 if( pExpr->op==TK_TRIGGER ){
112928 if( pExpr->iTable==pTabList->a[iSrc].iCursor ){
112934 iCol = pExpr->iColumn;
112948 pExpr->op = TK_NULL;
113293 sqlite3ExprCode(pParse, pEL->a[i].pExpr, iReg);
113739 Expr *pExpr /* The new default expression */
113749 pTab->u.tab.pDfltList = sqlite3ExprListAppend(pParse, pList, pExpr);
113751 sqlite3ExprDelete(pParse->db, pList->a[pCol->iDflt-1].pExpr);
113752 pList->a[pCol->iDflt-1].pExpr = pExpr;
113766 return pTab->u.tab.pDfltList->a[pCol->iDflt-1].pExpr;
114767 Expr *pExpr, /* The parsed expression of the default value */
114778 if( !sqlite3ExprIsConstantOrFunction(pExpr, isInit) ){
114795 x.pLeft = pExpr;
114803 sqlite3RenameExprUnmap(pParse, pExpr);
114805 sqlite3ExprDelete(db, pExpr);
114891 Expr *pCExpr = sqlite3ExprSkipCollate(pList->a[i].pExpr);
114914 Expr *pCExpr = sqlite3ExprSkipCollate(pList->a[0].pExpr);
115009 SQLITE_PRIVATE void sqlite3AddGenerated(Parse *pParse, Expr *pExpr, Token *pType){
115041 sqlite3ColumnSetExpr(pParse, pTab, pCol, pExpr);
115042 pExpr = 0;
115049 sqlite3ExprDelete(pParse->db, pExpr);
115054 sqlite3ExprDelete(pParse->db, pExpr);
115413 sqlite3RenameTokenRemap(pParse, pList->a[0].pExpr, &pTab->iPKey);
115608 static int markImmutableExprStep(Walker *pWalker, Expr *pExpr){
115609 ExprSetVVAProperty(pExpr, EP_Immutable);
117134 Expr *pExpr = pList->a[i].pExpr;
117135 assert( pExpr!=0 );
117136 if( pExpr->op==TK_COLLATE ){
117137 assert( !ExprHasProperty(pExpr, EP_IntValue) );
117138 nExtra += (1 + sqlite3Strlen30(pExpr->u.zToken));
117198 sqlite3StringToId(pListItem->pExpr);
117199 sqlite3ResolveSelfReference(pParse, pTab, NC_IdxExpr, pListItem->pExpr, 0);
117201 pCExpr = sqlite3ExprSkipCollate(pListItem->pExpr);
117231 if( pListItem->pExpr->op==TK_COLLATE ){
117233 assert( !ExprHasProperty(pListItem->pExpr, EP_IntValue) );
117234 zColl = pListItem->pExpr->u.zToken;
122116 SQLITE_PRIVATE int sqlite3IsLikeFunction(sqlite3 *db, Expr *pExpr, int *pIsNocase, char *aWc){
122119 assert( pExpr!=0 );
122120 assert( pExpr->op==TK_FUNCTION );
122121 assert( ExprUseXList(pExpr) );
122122 if( !pExpr->x.pList ){
122125 nExpr = pExpr->x.pList->nExpr;
122126 assert( !ExprHasProperty(pExpr, EP_IntValue) );
122127 pDef = sqlite3FindFunction(db, pExpr->u.zToken, nExpr, SQLITE_UTF8, 0);
122147 Expr *pEscape = pExpr->x.pList->a[2].pExpr;
123021 Expr *pExpr;
123026 pExpr = sqlite3Expr(db, TK_REGISTER, 0);
123027 if( pExpr ){
123030 pExpr->iTable = regBase + sqlite3TableColumnToStorage(pTab,iCol) + 1;
123031 pExpr->affExpr = pCol->affinity;
123034 pExpr = sqlite3ExprAddCollateString(pParse, pExpr, zColl);
123036 pExpr->iTable = regBase;
123037 pExpr->affExpr = SQLITE_AFF_INTEGER;
123040 return pExpr;
123053 Expr *pExpr = sqlite3Expr(db, TK_COLUMN, 0);
123054 if( pExpr ){
123055 assert( ExprUseYTab(pExpr) );
123056 pExpr->y.pTab = pTab;
123057 pExpr->iTable = iCursor;
123058 pExpr->iColumn = iCol;
123060 return pExpr;
124120 aff = sqlite3ExprAffinity(pIdx->aColExpr->a[n].pExpr);
124270 static int exprColumnFlagUnion(Walker *pWalker, Expr *pExpr){
124271 if( pExpr->op==TK_COLUMN && pExpr->iColumn>=0 ){
124272 assert( pExpr->iColumn < pWalker->u.pTab->nCol );
124273 pWalker->eCode |= pWalker->u.pTab->aCol[pExpr->iColumn].colFlags;
125193 sqlite3ExprCode(pParse, pList->a[k].pExpr, iRegStore);
125219 sqlite3ExprCode(pParse, pList->a[ipkColumn].pExpr, regCols);
125271 Expr *pIpk = pList->a[ipkColumn].pExpr;
125276 sqlite3ExprCode(pParse, pList->a[ipkColumn].pExpr, regRowid);
125444 static int checkConstraintExprNode(Walker *pWalker, Expr *pExpr){
125445 if( pExpr->op==TK_COLUMN ){
125446 assert( pExpr->iColumn>=0 || pExpr->iColumn==-1 );
125447 if( pExpr->iColumn>=0 ){
125448 if( pWalker->u.aiCol[pExpr->iColumn]>=0 ){
125474 Expr *pExpr, /* The expression to be checked */
125483 sqlite3WalkExpr(&w, pExpr);
125825 Expr *pExpr = pCheck->a[i].pExpr;
125827 && !sqlite3ExprReferencesUpdatedColumn(pExpr, aiChng, pkChng)
125839 pCopy = sqlite3ExprDup(db, pExpr, 0);
126187 sqlite3ExprCodeCopy(pParse, pIdx->aColExpr->a[i].pExpr, regIdx+i);
126719 if( sqlite3ExprCompare(0, pSrc->aColExpr->a[i].pExpr,
126720 pDest->aColExpr->a[i].pExpr, -1)!=0 ){
126840 assert( pEList->a[0].pExpr );
126841 if( pEList->a[0].pExpr->op!=TK_ASTERISK ){
131330 sqlite3ExprIfFalse(pParse, pCheck->a[k].pExpr, addrCkFault, 0);
131332 sqlite3ExprIfTrue(pParse, pCheck->a[0].pExpr, addrCkOk,
133655 sqlite3SetJoinExpr(p->x.pList->a[i].pExpr, iTable);
133684 unsetJoinExpr(p->x.pList->a[i].pExpr, iTable);
134075 CollSeq *pColl = sqlite3ExprCollSeq(pParse, pEList->a[i].pExpr);
134199 Expr *pExpr = pItem->pExpr;
134201 if( pExpr->op==TK_COLUMN
134202 && pExpr->iColumn>=0
134203 && ALWAYS( ExprUseYTab(pExpr) )
134204 && (pTab = pExpr->y.pTab)!=0
134206 && (pTab->aCol[pExpr->iColumn].colFlags & COLFLAG_SORTERREF)!=0
134210 if( pSort->aDefer[j].iCsr==pExpr->iTable ) break;
134226 pNew->iTable = pExpr->iTable;
134228 pNew->y.pTab = pExpr->y.pTab;
134233 pSort->aDefer[nDefer].pTab = pExpr->y.pTab;
134234 pSort->aDefer[nDefer].iCsr = pExpr->iTable;
134731 pInfo->aColl[i-iStart] = sqlite3ExprNNCollSeq(pParse, pItem->pExpr);
134906 sqlite3ExprCode(pParse, aOutEx[i].pExpr, regRow+i);
135017 Expr *pExpr
135019 Expr *pExpr,
135033 assert( pExpr!=0 );
135035 switch( pExpr->op ){
135043 int iCol = pExpr->iColumn; /* Index of column in pTab */
135046 for(j=0;j<pTabList->nSrc && pTabList->a[j].iCursor!=pExpr->iTable;j++);
135076 assert( pTab && ExprUseYTab(pExpr) && pExpr->y.pTab==pTab );
135094 Expr *p = pS->pEList->a[iCol].pExpr;
135138 assert( ExprUseXSelect(pExpr) );
135139 pS = pExpr->x.pSelect;
135140 p = pS->pEList->a[0].pExpr;
135178 Expr *p = pEList->a[i].pExpr;
135265 Expr *p = pEList->a[i].pExpr;
135361 Expr *pColExpr = sqlite3ExprSkipCollateAndLikely(pEList->a[i].pExpr);
135457 p = a[i].pExpr;
135625 pRet = sqlite3ExprCollSeq(pParse, p->pEList->a[iCol].pExpr);
135648 Expr *pTerm = pItem->pExpr;
135656 pOrderBy->a[i].pExpr =
136887 Expr *pExpr /* Expr in which substitution occurs */
136889 if( pExpr==0 ) return 0;
136890 if( ExprHasProperty(pExpr, EP_FromJoin)
136891 && pExpr->iRightJoinTable==pSubst->iTable
136893 pExpr->iRightJoinTable = pSubst->iNewTable;
136895 if( pExpr->op==TK_COLUMN
136896 && pExpr->iTable==pSubst->iTable
136897 && !ExprHasProperty(pExpr, EP_FixedCol)
136900 if( pExpr->iColumn<0 ){
136901 pExpr->op = TK_NULL;
136906 Expr *pCopy = pSubst->pEList->a[pExpr->iColumn].pExpr;
136908 assert( pSubst->pEList!=0 && pExpr->iColumn<pSubst->pEList->nExpr );
136909 assert( pExpr->pRight==0 );
136926 return pExpr;
136931 if( ExprHasProperty(pExpr,EP_FromJoin) ){
136932 sqlite3SetJoinExpr(pNew, pExpr->iRightJoinTable);
136934 sqlite3ExprDelete(db, pExpr);
136935 pExpr = pNew;
136939 if( pExpr->op!=TK_COLUMN && pExpr->op!=TK_COLLATE ){
136940 CollSeq *pColl = sqlite3ExprCollSeq(pSubst->pParse, pExpr);
136941 pExpr = sqlite3ExprAddCollateString(pSubst->pParse, pExpr,
136945 ExprClearProperty(pExpr, EP_Collate);
136949 if( pExpr->op==TK_IF_NULL_ROW && pExpr->iTable==pSubst->iTable ){
136950 pExpr->iTable = pSubst->iNewTable;
136952 pExpr->pLeft = substExpr(pSubst, pExpr->pLeft);
136953 pExpr->pRight = substExpr(pSubst, pExpr->pRight);
136954 if( ExprUseXSelect(pExpr) ){
136955 substSelect(pSubst, pExpr->x.pSelect, 1);
136957 substExprList(pSubst, pExpr->x.pList);
136960 if( ExprHasProperty(pExpr, EP_WinFunc) ){
136961 Window *pWin = pExpr->y.pWin;
136968 return pExpr;
136977 pList->a[i].pExpr = substExpr(pSubst, pList->a[i].pExpr);
137015 static int recomputeColumnsUsedExpr(Walker *pWalker, Expr *pExpr){
137017 if( pExpr->op!=TK_COLUMN ) return WRC_Continue;
137019 if( pItem->iCursor!=pExpr->iTable ) return WRC_Continue;
137020 if( pExpr->iColumn<0 ) return WRC_Continue;
137021 pItem->colUsed |= sqlite3ExprColUsed(pExpr);
137091 static int renumberCursorsCb(Walker *pWalker, Expr *pExpr){
137092 int op = pExpr->op;
137094 renumberCursorDoMapping(pWalker, &pExpr->iTable);
137096 if( ExprHasProperty(pExpr, EP_FromJoin) ){
137097 renumberCursorDoMapping(pWalker, &pExpr->iRightJoinTable);
137737 Expr *pExpr /* Overall expression: COLUMN=VALUE or VALUE=COLUMN */
137745 if( !sqlite3IsBinary(sqlite3ExprCompareCollSeq(pConst->pParse,pExpr)) ){
137781 static void findConstInWhere(WhereConst *pConst, Expr *pExpr){
137783 if( NEVER(pExpr==0) ) return;
137784 if( ExprHasProperty(pExpr, EP_FromJoin) ) return;
137785 if( pExpr->op==TK_AND ){
137786 findConstInWhere(pConst, pExpr->pRight);
137787 findConstInWhere(pConst, pExpr->pLeft);
137790 if( pExpr->op!=TK_EQ ) return;
137791 pRight = pExpr->pRight;
137792 pLeft = pExpr->pLeft;
137796 constInsert(pConst,pRight,pLeft,pExpr);
137799 constInsert(pConst,pLeft,pRight,pExpr);
137814 Expr *pExpr,
137819 if( pExpr->op!=TK_COLUMN ) return WRC_Continue;
137820 if( ExprHasProperty(pExpr, EP_FixedCol|EP_FromJoin) ){
137821 testcase( ExprHasProperty(pExpr, EP_FixedCol) );
137822 testcase( ExprHasProperty(pExpr, EP_FromJoin) );
137827 if( pColumn==pExpr ) continue;
137828 if( pColumn->iTable!=pExpr->iTable ) continue;
137829 if( pColumn->iColumn!=pExpr->iColumn ) continue;
137835 ExprClearProperty(pExpr, EP_Leaf);
137836 ExprSetProperty(pExpr, EP_FixedCol);
137837 assert( pExpr->pLeft==0 );
137838 pExpr->pLeft = sqlite3ExprDup(pConst->pParse->db, pConst->apExpr[i*2+1], 0);
137861 static int propagateConstantExprRewrite(Walker *pWalker, Expr *pExpr){
137868 if( (pExpr->op>=TK_EQ && pExpr->op<=TK_GE)
137869 || pExpr->op==TK_IS
137871 propagateConstantExprRewriteOne(pConst, pExpr->pLeft, 0);
137873 if( sqlite3ExprAffinity(pExpr->pLeft)!=SQLITE_AFF_TEXT ){
137874 propagateConstantExprRewriteOne(pConst, pExpr->pRight, 0);
137878 return propagateConstantExprRewriteOne(pConst, pExpr, pConst->bHasAffBlob);
137983 static int pushDownWindowCheck(Parse *pParse, Select *pSubq, Expr *pExpr){
137987 return sqlite3ExprIsConstantOrGroupBy(pParse, pExpr, pSubq->pWin->pPartition);
138186 if( sqlite3ExprCanBeNull(pEList->a[0].pExpr) ){
138220 Expr *pExpr;
138236 pExpr = p->pEList->a[0].pExpr;
138237 assert( pExpr!=0 );
138238 if( pExpr->op!=TK_AGG_FUNCTION ) return 0;
138239 if( pExpr->pAggInfo!=pAggInfo ) return 0;
138241 assert( pAggInfo->aFunc[0].pFExpr==pExpr );
138242 testcase( ExprHasProperty(pExpr, EP_Distinct) );
138243 testcase( ExprHasProperty(pExpr, EP_WinFunc) );
138244 if( ExprHasProperty(pExpr, EP_Distinct|EP_WinFunc) ) return 0;
138322 if( a[i].pExpr->flags & EP_Collate ) break;
138714 Expr *pE, *pRight, *pExpr;
138847 pE = pEList->a[k].pExpr;
138867 pE = a[k].pExpr;
138876 pNew = sqlite3ExprListAppend(pParse, pNew, a[k].pExpr);
138882 a[k].pExpr = 0;
138955 pExpr = sqlite3PExpr(pParse, TK_DOT, pLeft, pRight);
138958 pExpr = sqlite3PExpr(pParse, TK_DOT, pLeft, pExpr);
138965 pExpr = pRight;
138967 pNew = sqlite3ExprListAppend(pParse, pNew, pExpr);
139277 pColl = sqlite3ExprCollSeq(pParse, pItem->pExpr);
139343 static int havingToWhereExprCb(Walker *pWalker, Expr *pExpr){
139344 if( pExpr->op!=TK_AND ){
139353 if( sqlite3ExprIsConstantOrGroupBy(pWalker->pParse, pExpr, pS->pGroupBy)
139354 && ExprAlwaysFalse(pExpr)==0
139355 && pExpr->pAggInfo==0
139361 SWAP(Expr, *pNew, *pExpr);
139470 Expr *pExpr;
139477 pExpr = p->pEList->a[0].pExpr;
139478 if( pExpr->op!=TK_AGG_FUNCTION ) return 0; /* Result is an aggregate */
139479 assert( ExprUseUToken(pExpr) );
139480 if( sqlite3_stricmp(pExpr->u.zToken,"count") ) return 0; /* Is count() */
139481 assert( ExprUseXList(pExpr) );
139482 if( pExpr->x.pList!=0 ) return 0; /* Must be count(*) */
139498 pCount = pExpr;
139499 pExpr = 0;
139517 if( pExpr==0 ){
139518 pExpr = pTerm;
139520 pExpr = sqlite3PExpr(pParse, TK_PLUS, pTerm, pExpr);
139524 p->pEList->a[0].pExpr = pExpr;
140295 Expr *pExpr = pAggInfo->aFunc[i].pFExpr;
140296 assert( ExprUseXList(pExpr) );
140298 sqlite3ExprAnalyzeAggList(&sNC, pExpr->x.pList);
140300 assert( !IsWindowFunc(pExpr) );
140301 if( ExprHasProperty(pExpr, EP_WinFunc) ){
140302 sqlite3ExprAnalyzeAggregates(&sNC, pExpr->y.pWin->pFilter);
140355 Expr *pExpr = pAggInfo->aFunc[0].pFExpr->x.pList->a[0].pExpr;
140356 pExpr = sqlite3ExprDup(db, pExpr, 0);
140358 pDistinct = sqlite3ExprListAppend(pParse, pDistinct, pExpr);
140493 sqlite3ExprCode(pParse, pGroupBy->a[j].pExpr, iBMem+j);
140758 Expr *pExpr = pAggInfo->aCol[i].pCExpr;
140759 assert( pExpr!=0 );
140760 assert( pExpr->pAggInfo==pAggInfo );
140761 assert( pExpr->iAgg==i );
140764 Expr *pExpr = pAggInfo->aFunc[i].pFExpr;
140765 assert( pExpr!=0 );
140766 assert( pExpr->pAggInfo==pAggInfo );
140767 assert( pExpr->iAgg==i );
141857 Expr *pOldExpr = pList->a[i].pExpr;
141941 Expr *pCol = pNew->a[i].pExpr;
142516 assert( pIdx->aColExpr->a[iCol].pExpr!=0 );
142517 return sqlite3ExprReferencesUpdatedColumn(pIdx->aColExpr->a[iCol].pExpr,
142667 sqlite3ExprDup(db, pChanges->a[i].pExpr, 0)
142866 if( nChangeFrom==0 && sqlite3ResolveExprNames(&sNC, pChanges->a[i].pExpr) ){
142875 pRowidExpr = pChanges->a[i].pExpr;
142898 pRowidExpr = pChanges->a[i].pExpr;
143340 sqlite3ExprCode(pParse, pChanges->a[j].pExpr, k);
143632 pRow = sqlite3ExprDup(db, pChanges->a[aXRef[iPk]].pExpr, 0);
143642 sqlite3ExprDup(db, pChanges->a[aXRef[i]].pExpr, 0)
143664 sqlite3ExprCode(pParse, pChanges->a[aXRef[i]].pExpr, regArg+2+i);
143877 && (pTerm = pTarget->a[0].pExpr)->op==TK_COLUMN
143911 Expr *pExpr;
143916 pExpr = pIdx->aColExpr->a[ii].pExpr;
143917 if( pExpr->op!=TK_COLLATE ){
143918 sCol[0].pLeft = pExpr;
143919 pExpr = &sCol[0];
143924 pExpr = &sCol[0];
143927 if( sqlite3ExprCompare(pParse,pTarget->a[jj].pExpr,pExpr,iCursor)<2 ){
145601 Expr *pExpr /* First argument to the function */
145612 if( NEVER(pExpr==0) ) return pDef;
145613 if( pExpr->op!=TK_COLUMN ) return pDef;
145614 assert( ExprUseYTab(pExpr) );
145615 pTab = pExpr->y.pTab;
146084 Expr *pExpr; /* Pointer to the subexpression that is this term */
146282 Expr *pExpr; /* The Expr node that was transformed */
146724 && (pLevel->iLeftJoin==0 || ExprHasProperty(pTerm->pExpr, EP_FromJoin))
146864 if( pLoop->aLTerm[i]->pExpr==pX ){
146868 if( pOrigRhs->a[iField].pExpr==0 ) continue; /* Duplicate PK column */
146869 pRhs = sqlite3ExprListAppend(pParse, pRhs, pOrigRhs->a[iField].pExpr);
146870 pOrigRhs->a[iField].pExpr = 0;
146871 assert( pOrigLhs->a[iField].pExpr!=0 );
146872 pLhs = sqlite3ExprListAppend(pParse, pLhs, pOrigLhs->a[iField].pExpr);
146873 pOrigLhs->a[iField].pExpr = 0;
146884 Expr *p = pLhs->a[0].pExpr;
146885 pLhs->a[0].pExpr = 0;
146938 Expr *pX = pTerm->pExpr;
146971 if( pLoop->aLTerm[i] && pLoop->aLTerm[i]->pExpr==pX ){
146978 if( pLoop->aLTerm[i]->pExpr==pX ) nEq++;
146991 pTerm->pExpr->iTable = iTab;
146994 pX = pTerm->pExpr;
147024 if( pLoop->aLTerm[i]->pExpr==pX ){
147202 if( pTerm->pExpr->flags & EP_xIsSelect ){
147210 Expr *pRight = pTerm->pExpr->pRight;
147285 static int codeCursorHintCheckExpr(Walker *pWalker, Expr *pExpr){
147288 if( pExpr->op==TK_COLUMN
147289 && pExpr->iTable==pHint->iTabCur
147290 && sqlite3TableColumnToIndex(pHint->pIdx, pExpr->iColumn)<0
147312 static int codeCursorHintIsOrFunction(Walker *pWalker, Expr *pExpr){
147313 if( pExpr->op==TK_IS
147314 || pExpr->op==TK_ISNULL || pExpr->op==TK_ISNOT
147315 || pExpr->op==TK_NOTNULL || pExpr->op==TK_CASE
147318 }else if( pExpr->op==TK_FUNCTION ){
147321 if( 0==sqlite3IsLikeFunction(pWalker->pParse->db, pExpr, &d1, d2) ){
147347 static int codeCursorHintFixExpr(Walker *pWalker, Expr *pExpr){
147350 if( pExpr->op==TK_COLUMN ){
147351 if( pExpr->iTable!=pHint->iTabCur ){
147353 sqlite3ExprCode(pWalker->pParse, pExpr, reg);
147354 pExpr->op = TK_REGISTER;
147355 pExpr->iTable = reg;
147357 pExpr->iTable = pHint->iIdxCur;
147358 pExpr->iColumn = sqlite3TableColumnToIndex(pHint->pIdx, pExpr->iColumn);
147359 assert( pExpr->iColumn>=0 );
147361 }else if( pExpr->op==TK_AGG_FUNCTION ){
147386 Expr *pExpr = 0;
147433 Expr *pExpr = pTerm->pExpr;
147434 if( !ExprHasProperty(pExpr, EP_FromJoin)
147435 || pExpr->iRightJoinTable!=pTabItem->iCursor
147439 sqlite3WalkExpr(&sWalker, pTerm->pExpr);
147443 if( ExprHasProperty(pTerm->pExpr, EP_FromJoin) ) continue;
147455 if( sqlite3ExprContainsSubquery(pTerm->pExpr) ) continue;
147462 sqlite3WalkExpr(&sWalker, pTerm->pExpr);
147467 pExpr = sqlite3ExprAnd(pParse, pExpr, sqlite3ExprDup(db, pTerm->pExpr, 0));
147469 if( pExpr!=0 ){
147471 sqlite3WalkExpr(&sWalker, pExpr);
147474 (const char*)pExpr, P4_EXPR);
147562 sqlite3ExprCode(pParse, pList->a[i].pExpr, iReg+i);
147588 static void preserveExpr(IdxExprTrans *pTrans, Expr *pExpr){
147594 pNew->pExpr = pExpr;
147595 memcpy(&pNew->orig, pExpr, sizeof(*pExpr));
147604 static int whereIndexExprTransNode(Walker *p, Expr *pExpr){
147606 if( sqlite3ExprCompare(0, pExpr, pX->pIdxExpr, pX->iTabCur)==0 ){
147607 preserveExpr(pX, pExpr);
147608 pExpr->affExpr = sqlite3ExprAffinity(pExpr);
147609 pExpr->op = TK_COLUMN;
147610 pExpr->iTable = pX->iIdxCur;
147611 pExpr->iColumn = pX->iIdxCol;
147612 testcase( ExprHasProperty(pExpr, EP_Skip) );
147613 testcase( ExprHasProperty(pExpr, EP_Unlikely) );
147614 ExprClearProperty(pExpr, EP_Skip|EP_Unlikely|EP_WinFunc|EP_Subrtn);
147615 pExpr->y.pTab = 0;
147626 static int whereIndexExprTransColumn(Walker *p, Expr *pExpr){
147627 if( pExpr->op==TK_COLUMN ){
147629 if( pExpr->iTable==pX->iTabCur && pExpr->iColumn==pX->iTabCol ){
147630 assert( ExprUseYTab(pExpr) && pExpr->y.pTab!=0 );
147631 preserveExpr(pX, pExpr);
147632 pExpr->affExpr = sqlite3TableColumnAffinity(pExpr->y.pTab,pExpr->iColumn);
147633 pExpr->iTable = pX->iIdxCur;
147634 pExpr->iColumn = pX->iIdxCol;
147635 pExpr->y.pTab = 0;
147678 assert( aColExpr!=0 && aColExpr->a[iIdxCol].pExpr!=0 );
147679 x.pIdxExpr = aColExpr->a[iIdxCol].pExpr;
147727 Expr *pExpr;
147729 pExpr = pTerm->pExpr;
147730 if( sqlite3ExprCompare(0, pExpr, pTruth, iTabCur)==0 ){
147850 Expr *pRight = pTerm->pExpr->pRight;
147879 && sqlite3ExprVectorSize(pTerm->pExpr->pLeft)==1
147905 pCompare->pLeft = pTerm->pExpr->pLeft;
147940 assert( pTerm->pExpr!=0 );
147990 pX = pStart->pExpr;
148024 pX = pEnd->pExpr;
148231 Expr *pRight = pRangeStart->pExpr->pRight;
148321 Expr *pRight = pRangeEnd->pExpr->pRight;
148614 Expr *pExpr = pWC->a[iTerm].pExpr;
148621 pExpr = sqlite3ExprDup(db, pExpr, 0);
148622 pAndExpr = sqlite3ExprAnd(pParse, pAndExpr, pExpr);
148643 Expr *pOrExpr = pOrTerm->pExpr; /* Current OR clause term */
148845 pE = pTerm->pExpr;
148910 pE = pTerm->pExpr;
148925 && ExprUseXSelect(pAlt->pExpr)
148926 && (pAlt->pExpr->x.pSelect->pEList->nExpr>1)
148934 sEAlt = *pAlt->pExpr;
148955 assert( pTerm->pExpr );
148956 sqlite3ExprIfFalse(pParse, pTerm->pExpr, addrCont, SQLITE_JUMPIFNULL);
149063 pTerm->pExpr = sqlite3ExprSkipCollateAndLikely(p);
149089 static u16 exprCommute(Parse *pParse, Expr *pExpr){
149090 if( pExpr->pLeft->op==TK_VECTOR
149091 || pExpr->pRight->op==TK_VECTOR
149092 || sqlite3BinaryCompareCollSeq(pParse, pExpr->pLeft, pExpr->pRight) !=
149093 sqlite3BinaryCompareCollSeq(pParse, pExpr->pRight, pExpr->pLeft)
149095 pExpr->flags ^= EP_Commuted;
149097 SWAP(Expr*,pExpr->pRight,pExpr->pLeft);
149098 if( pExpr->op>=TK_GT ){
149103 assert( pExpr->op>=TK_GT && pExpr->op<=TK_GE );
149104 pExpr->op = ((pExpr->op-TK_GT)^2)+TK_GT;
149152 Expr *pExpr, /* Test this expression */
149168 if( !sqlite3IsLikeFunction(db, pExpr, pnoCase, (char*)wc) ){
149174 assert( ExprUseXList(pExpr) );
149175 pList = pExpr->x.pList;
149176 pLeft = pList->a[1].pExpr;
149178 pRight = sqlite3ExprSkipCollate(pList->a[0].pExpr);
149331 Expr *pExpr, /* Test this expression */
149336 if( pExpr->op==TK_FUNCTION ){
149350 assert( ExprUseXList(pExpr) );
149351 pList = pExpr->x.pList;
149363 pCol = pList->a[1].pExpr;
149368 assert( !ExprHasProperty(pExpr, EP_IntValue) );
149369 if( sqlite3StrICmp(pExpr->u.zToken, aOp[i].zOp)==0 ){
149371 *ppRight = pList->a[0].pExpr;
149388 pCol = pList->a[0].pExpr;
149399 assert( !ExprHasProperty(pExpr, EP_IntValue) );
149402 i = pMod->xFindFunction(pVtab,2, pExpr->u.zToken, &xNotUsed, &pNotUsed);
149405 *ppRight = pList->a[1].pExpr;
149411 }else if( pExpr->op==TK_NE || pExpr->op==TK_ISNOT || pExpr->op==TK_NOTNULL ){
149413 Expr *pLeft = pExpr->pLeft;
149414 Expr *pRight = pExpr->pRight;
149428 if( pExpr->op==TK_NE ) *peOp2 = SQLITE_INDEX_CONSTRAINT_NE;
149429 if( pExpr->op==TK_ISNOT ) *peOp2 = SQLITE_INDEX_CONSTRAINT_ISNOT;
149430 if( pExpr->op==TK_NOTNULL ) *peOp2 = SQLITE_INDEX_CONSTRAINT_ISNOTNULL;
149509 assert( pOne->pExpr->pLeft!=0 && pOne->pExpr->pRight!=0 );
149510 assert( pTwo->pExpr->pLeft!=0 && pTwo->pExpr->pRight!=0 );
149511 if( sqlite3ExprCompare(0,pOne->pExpr->pLeft, pTwo->pExpr->pLeft, -1) ) return;
149512 if( sqlite3ExprCompare(0,pOne->pExpr->pRight, pTwo->pExpr->pRight,-1) )return;
149523 pNew = sqlite3ExprDup(db, pOne->pExpr, 0);
149628 Expr *pExpr = pTerm->pExpr; /* The expression of the term */
149642 assert( pExpr->op==TK_OR );
149649 sqlite3WhereSplit(pOrWc, pExpr, TK_OR);
149677 sqlite3WhereSplit(pAndWC, pOrTerm->pExpr, TK_AND);
149682 assert( pAndTerm->pExpr );
149683 if( allowedOp(pAndTerm->pExpr->op)
149795 pLeft = pOrTerm->pExpr->pLeft;
149817 && sqlite3ExprCompare(pParse, pOrTerm->pExpr->pLeft, pLeft, -1)
149826 affRight = sqlite3ExprAffinity(pOrTerm->pExpr->pRight);
149827 affLeft = sqlite3ExprAffinity(pOrTerm->pExpr->pLeft);
149853 pDup = sqlite3ExprDup(db, pOrTerm->pExpr->pRight, 0);
149855 pLeft = pOrTerm->pExpr->pLeft;
149862 transferJoinMarkings(pNew, pExpr);
149893 static int termIsEquivalence(Parse *pParse, Expr *pExpr){
149897 if( pExpr->op!=TK_EQ && pExpr->op!=TK_IS ) return 0;
149898 if( ExprHasProperty(pExpr, EP_FromJoin) ) return 0;
149899 aff1 = sqlite3ExprAffinity(pExpr->pLeft);
149900 aff2 = sqlite3ExprAffinity(pExpr->pRight);
149906 pColl = sqlite3ExprCompareCollSeq(pParse, pExpr);
149908 return sqlite3ExprCollSeqMatch(pParse, pExpr->pLeft, pExpr->pRight);
149957 Expr *pExpr /* An operand of a comparison operator */
149968 if( sqlite3ExprCompareSkip(pExpr, pIdx->aColExpr->a[i].pExpr, iCur)==0 ){
149981 Expr *pExpr, /* An operand of a comparison operator */
149990 if( pExpr->op==TK_VECTOR && (op>=TK_GT && ALWAYS(op<=TK_GE)) ){
149991 assert( ExprUseXList(pExpr) );
149992 pExpr = pExpr->x.pList->a[0].pExpr;
149996 if( pExpr->op==TK_COLUMN ){
149997 aiCurCol[0] = pExpr->iTable;
149998 aiCurCol[1] = pExpr->iColumn;
150003 return exprMightBeIndexed2(pFrom,mPrereq,aiCurCol,pExpr);
150033 Expr *pExpr; /* The expression to be analyzed */
150051 pExpr = pTerm->pExpr;
150052 assert( pExpr->op!=TK_AS && pExpr->op!=TK_COLLATE );
150053 prereqLeft = sqlite3WhereExprUsage(pMaskSet, pExpr->pLeft);
150054 op = pExpr->op;
150056 assert( pExpr->pRight==0 );
150057 if( sqlite3ExprCheckIN(pParse, pExpr) ) return;
150058 if( ExprUseXSelect(pExpr) ){
150059 pTerm->prereqRight = exprSelectUsage(pMaskSet, pExpr->x.pSelect);
150061 pTerm->prereqRight = sqlite3WhereExprListUsage(pMaskSet, pExpr->x.pList);
150066 pTerm->prereqRight = sqlite3WhereExprUsage(pMaskSet, pExpr->pRight);
150069 prereqAll = sqlite3WhereExprUsageNN(pMaskSet, pExpr);
150071 if( ExprHasProperty(pExpr, EP_FromJoin) ){
150072 Bitmask x = sqlite3WhereGetMask(pMaskSet, pExpr->iRightJoinTable);
150087 Expr *pLeft = sqlite3ExprSkipCollate(pExpr->pLeft);
150088 Expr *pRight = sqlite3ExprSkipCollate(pExpr->pRight);
150095 pLeft = pLeft->x.pList->a[pTerm->u.x.iField-1].pExpr;
150115 pDup = sqlite3ExprDup(db, pExpr, 0);
150133 pDup = pExpr;
150146 && !ExprHasProperty(pExpr,EP_FromJoin)
150149 assert( !ExprHasProperty(pExpr, EP_IntValue) );
150150 pExpr->op = TK_TRUEFALSE;
150151 pExpr->u.zToken = "false";
150152 ExprSetProperty(pExpr, EP_IsFalse);
150174 else if( pExpr->op==TK_BETWEEN && pWC->op==TK_AND ){
150178 assert( ExprUseXList(pExpr) );
150179 pList = pExpr->x.pList;
150186 sqlite3ExprDup(db, pExpr->pLeft, 0),
150187 sqlite3ExprDup(db, pList->a[i].pExpr, 0));
150188 transferJoinMarkings(pNewExpr, pExpr);
150202 else if( pExpr->op==TK_OR ){
150214 else if( pExpr->op==TK_NOTNULL ){
150215 if( pExpr->pLeft->op==TK_COLUMN
150216 && pExpr->pLeft->iColumn>=0
150217 && !ExprHasProperty(pExpr, EP_FromJoin)
150220 Expr *pLeft = pExpr->pLeft;
150259 else if( pExpr->op==TK_FUNCTION
150261 && isLikeOrGlob(pParse, pExpr, &pStr1, &isComplete, &noCase)
150272 assert( ExprUseXList(pExpr) );
150273 pLeft = pExpr->x.pList->a[1].pExpr;
150314 transferJoinMarkings(pNewExpr1, pExpr);
150322 transferJoinMarkings(pNewExpr2, pExpr);
150341 if( (pExpr->op==TK_EQ || pExpr->op==TK_IS)
150342 && (nLeft = sqlite3ExprVectorSize(pExpr->pLeft))>1
150343 && sqlite3ExprVectorSize(pExpr->pRight)==nLeft
150344 && ( (pExpr->pLeft->flags & EP_xIsSelect)==0
150345 || (pExpr->pRight->flags & EP_xIsSelect)==0)
150352 Expr *pLeft = sqlite3ExprForVectorField(pParse, pExpr->pLeft, i, nLeft);
150353 Expr *pRight = sqlite3ExprForVectorField(pParse, pExpr->pRight, i, nLeft);
150355 pNew = sqlite3PExpr(pParse, pExpr->op, pLeft, pRight);
150356 transferJoinMarkings(pNew, pExpr);
150374 else if( pExpr->op==TK_IN
150376 && pExpr->pLeft->op==TK_VECTOR
150377 && ALWAYS( ExprUseXSelect(pExpr) )
150378 && pExpr->x.pSelect->pPrior==0
150380 && pExpr->x.pSelect->pWin==0
150385 for(i=0; i<sqlite3ExprVectorSize(pExpr->pLeft); i++){
150387 idxNew = whereClauseInsert(pWC, pExpr, TERM_VIRTUAL);
150406 int res = isAuxiliaryVtabOperator(db, pExpr, &eOp2, &pLeft, &pRight);
150418 if( ExprHasProperty(pExpr, EP_FromJoin) && pNewExpr ){
150420 pNewExpr->iRightJoinTable = pExpr->iRightJoinTable;
150470 SQLITE_PRIVATE void sqlite3WhereSplit(WhereClause *pWC, Expr *pExpr, u8 op){
150471 Expr *pE2 = sqlite3ExprSkipCollateAndLikely(pExpr);
150473 assert( pE2!=0 || pExpr==0 );
150476 whereClauseInsert(pWC, pExpr, 0);
150509 sqlite3ExprDelete(db, a->pExpr);
150565 mask |= sqlite3WhereExprUsage(pMaskSet, pList->a[i].pExpr);
150627 sqlite3ExprDup(pParse->db, pArgs->a[j].pExpr, 0), 0);
150933 || sqlite3ExprCompareSkip(pTerm->pExpr->pLeft,
150935 && (pScan->iEquiv<=1 || !ExprHasProperty(pTerm->pExpr, EP_FromJoin))
150939 && (pX = whereRightSubexprIsColumn(pTerm->pExpr))!=0
150959 pX = pTerm->pExpr;
150971 && (pX = pTerm->pExpr->pRight, ALWAYS(pX!=0))
151060 pScan->pIdxExpr = pIdx->aColExpr->a[j].pExpr;
151147 Expr *p = sqlite3ExprSkipCollateAndLikely(pList->a[i].pExpr);
151153 CollSeq *pColl = sqlite3ExprNNCollSeq(pParse, pList->a[i].pExpr);
151212 Expr *p = sqlite3ExprSkipCollateAndLikely(pDistinct->a[i].pExpr);
151360 && !ExprHasProperty(pTerm->pExpr, EP_FromJoin)
151372 if( !sqlite3IndexAffinityOk(pTerm->pExpr, aff) ) return 0;
151373 testcase( pTerm->pExpr->op==TK_IS );
151430 Expr *pExpr = pTerm->pExpr;
151431 assert( !ExprHasProperty(pExpr, EP_FromJoin) /* prereq always non-zero */
151432 || pExpr->iRightJoinTable!=pSrc->iCursor /* for the right-hand */
151436 && !ExprHasProperty(pExpr, EP_FromJoin)
151437 && sqlite3ExprIsTableConstant(pExpr, pSrc->iCursor) ){
151439 sqlite3ExprDup(pParse->db, pExpr, 0));
151506 Expr *pX = pTerm->pExpr;
151642 Expr *pExpr = pOrderBy->a[i].pExpr;
151643 if( pExpr->op!=TK_COLUMN || pExpr->iTable!=pSrc->iCursor ) break;
151686 && !ExprHasProperty(pTerm->pExpr, EP_FromJoin)
151717 && sqlite3ExprIsVector(pTerm->pExpr->pRight)
151730 Expr *pExpr = pOrderBy->a[i].pExpr;
151731 pIdxOrderBy[i].iColumn = pExpr->iColumn;
152070 rc = sqlite3Stat4ValueFromExpr(pParse, pLower->pExpr->pRight, aff, &p1);
152074 rc = sqlite3Stat4ValueFromExpr(pParse, pUpper->pExpr->pRight, aff, &p2);
152236 Expr *pExpr = pLower->pExpr->pRight;
152237 rc = sqlite3Stat4ProbeSetValue(pParse, p, &pRec, pExpr, nBtm, nEq, &n);
152241 if( sqlite3ExprVectorSize(pExpr)>n ) mask = (WO_LE|WO_LT);
152253 Expr *pExpr = pUpper->pExpr->pRight;
152254 rc = sqlite3Stat4ProbeSetValue(pParse, p, &pRec, pExpr, nTop, nEq, &n);
152258 if( sqlite3ExprVectorSize(pExpr)>n ) mask = (WO_LE|WO_LT);
152344 Expr *pExpr, /* Expression for VALUE in the x=VALUE constraint */
152373 rc = sqlite3Stat4ProbeSetValue(pParse, p, &pRec, pExpr, 1, nEq-1, &bOk);
152422 rc = whereEqualScanEst(pParse, pBuilder, pList->a[i].pExpr, &nEst);
152451 if( ExprHasProperty(pTerm->pExpr, EP_FromJoin) ) zType[2] = 'L';
152479 sqlite3TreeViewExpr(0, pTerm->pExpr, 0);
152657 memcpy(p->pExpr, &p->orig, sizeof(p->orig));
153019 Expr *pRight = pTerm->pExpr->pRight;
153021 testcase( pTerm->pExpr->op==TK_IS );
153062 int nCmp = sqlite3ExprVectorSize(pTerm->pExpr->pLeft);
153074 assert( ExprUseXList(pTerm->pExpr->pLeft) );
153075 pLhs = pTerm->pExpr->pLeft->x.pList->a[i].pExpr;
153076 pRhs = pTerm->pExpr->pRight;
153078 pRhs = pRhs->x.pSelect->pEList->a[i].pExpr;
153080 pRhs = pRhs->x.pList->a[i].pExpr;
153211 && !ExprHasProperty(pTerm->pExpr, EP_FromJoin)
153237 Expr *pExpr = pTerm->pExpr;
153238 if( ExprUseXSelect(pExpr) ){
153249 if( pNew->aLTerm[i] && pNew->aLTerm[i]->pExpr==pExpr ) nIn = 0;
153251 }else if( ALWAYS(pExpr->x.pList && pExpr->x.pList->nExpr) ){
153253 nIn = sqlite3LogEst(pExpr->x.pList->nExpr);
153379 && ((eOp & WO_IN)==0 || ExprUseXList(pTerm->pExpr))
153382 Expr *pExpr = pTerm->pExpr;
153387 rc = whereEqualScanEst(pParse, pBuilder, pExpr->pRight, &nOut);
153389 rc = whereInScanEst(pParse, pBuilder, pExpr->x.pList, &nOut);
153541 Expr *pExpr = sqlite3ExprSkipCollateAndLikely(pOB->a[ii].pExpr);
153542 if( NEVER(pExpr==0) ) continue;
153543 if( pExpr->op==TK_COLUMN && pExpr->iTable==iCursor ){
153544 if( pExpr->iColumn<0 ) return 1;
153546 if( pExpr->iColumn==pIndex->aiColumn[jj] ) return 1;
153551 if( sqlite3ExprCompareSkip(pExpr,aColExpr->a[jj].pExpr,iCursor)==0 ){
153578 Expr *pExpr;
153579 pExpr = pTerm->pExpr;
153580 if( (!ExprHasProperty(pExpr, EP_FromJoin) || pExpr->iRightJoinTable==iTab)
153581 && (isLeft==0 || ExprHasProperty(pExpr, EP_FromJoin))
153582 && sqlite3ExprImpliesExpr(pParse, pExpr, pWhere, iTab)
153839 if( !sqlite3ExprCoveredByIndex(pTerm->pExpr, iCur, pProbe) ){
154068 Expr *pX = pHidden->pWC->a[iTerm].pExpr;
154524 pOBExpr = sqlite3ExprSkipCollateAndLikely(pOrderBy->a[i].pExpr);
154542 CollSeq *pColl1 = sqlite3ExprNNCollSeq(pParse, pOrderBy->a[i].pExpr);
154543 CollSeq *pColl2 = sqlite3ExprCompareCollSeq(pParse, pTerm->pExpr);
154548 testcase( pTerm->pExpr->op==TK_IS );
154613 Expr *pX = pLoop->aLTerm[j]->pExpr;
154615 if( pLoop->aLTerm[i]->pExpr==pX ){
154657 pOBExpr = sqlite3ExprSkipCollateAndLikely(pOrderBy->a[i].pExpr);
154667 Expr *pIdxExpr = pIndex->aColExpr->a[j].pExpr;
154673 pColl = sqlite3ExprNNCollSeq(pWInfo->pParse, pOrderBy->a[i].pExpr);
154730 p = pOrderBy->a[i].pExpr;
155333 static int exprNodeIsDeterministic(Walker *pWalker, Expr *pExpr){
155334 if( pExpr->op==TK_FUNCTION && ExprHasProperty(pExpr, EP_ConstFunc)==0 ){
155634 if( pT->prereqAll==0 && (nTabList==0 || exprIsDeterministic(pT->pExpr)) ){
155635 sqlite3ExprIfFalse(pParse, pT->pExpr, pWInfo->iBreak, SQLITE_JUMPIFNULL);
155797 if( !ExprHasProperty(pTerm->pExpr, EP_FromJoin)
155798 || pTerm->pExpr->iRightJoinTable!=pItem->iCursor
157105 static int selectWindowRewriteExprCb(Walker *pWalker, Expr *pExpr){
157117 if( pExpr->op!=TK_COLUMN ){
157123 if( pExpr->iTable==p->pSrc->a[i].iCursor ) break;
157129 switch( pExpr->op ){
157132 if( !ExprHasProperty(pExpr, EP_WinFunc) ){
157137 if( pExpr->y.pWin==pWin ){
157138 assert( pWin->pOwner==pExpr );
157152 if( 0==sqlite3ExprCompare(0, p->pSub->a[i].pExpr, pExpr, -1) ){
157159 Expr *pDup = sqlite3ExprDup(pParse->db, pExpr, 0);
157164 int f = pExpr->flags & EP_Collate;
157165 assert( ExprHasProperty(pExpr, EP_Static)==0 );
157166 ExprSetProperty(pExpr, EP_Static);
157167 sqlite3ExprDelete(pParse->db, pExpr);
157168 ExprClearProperty(pExpr, EP_Static);
157169 memset(pExpr, 0, sizeof(Expr));
157171 pExpr->op = TK_COLUMN;
157172 pExpr->iColumn = (iCol<0 ? p->pSub->nExpr-1: iCol);
157173 pExpr->iTable = p->pWin->iEphCsr;
157174 pExpr->y.pTab = p->pTab;
157175 pExpr->flags = f;
157259 Expr *pDup = sqlite3ExprDup(db, pAppend->a[i].pExpr, 0);
157290 static int sqlite3WindowExtraAggFuncDepth(Walker *pWalker, Expr *pExpr){
157291 if( pExpr->op==TK_AGG_FUNCTION
157292 && pExpr->op2>=pWalker->walkerDepth
157294 pExpr->op2++;
157299 static int disallowAggregatesInOrderByCb(Walker *pWalker, Expr *pExpr){
157300 if( pExpr->op==TK_AGG_FUNCTION && pExpr->pAggInfo==0 ){
157301 assert( !ExprHasProperty(pExpr, EP_IntValue) );
157303 "misuse of aggregate: %s()", pExpr->u.zToken);
157522 static Expr *sqlite3WindowOffsetExpr(Parse *pParse, Expr *pExpr){
157523 if( 0==sqlite3ExprIsConstant(pExpr) ){
157524 if( IN_RENAME_OBJECT ) sqlite3RenameExprUnmap(pParse, pExpr);
157525 sqlite3ExprDelete(pParse->db, pExpr);
157526 pExpr = sqlite3ExprAlloc(pParse->db, TK_NULL, 0, 0);
157528 return pExpr;
158098 pColl = sqlite3ExprNNCollSeq(pParse, pWin->pOwner->x.pList->a[0].pExpr);
158563 pColl = sqlite3ExprNNCollSeq(pParse, pOrderBy->a[0].pExpr);
158789 static int windowExprGtZero(Parse *pParse, Expr *pExpr){
158793 sqlite3ValueFromExpr(db, pExpr, db->enc, SQLITE_AFF_NUMERIC, &pVal);
159538 struct FrameBound { int eType; Expr *pExpr; };
161890 sqlite3ExprDelete(pParse->db, (yypminor->yy81).pExpr);
163832 yymsp[-4].minor.yy626->flags |= pList->a[0].pExpr->flags & EP_Propagate;
163938 Expr *pRHS = yymsp[-1].minor.yy562->a[0].pExpr;
163940 yymsp[-1].minor.yy562->a[0].pExpr = 0;
164360 …e, yymsp[-2].minor.yy64, yymsp[-1].minor.yy81.eType, yymsp[-1].minor.yy81.pExpr, TK_CURRENT, 0, yy…
164366 …sp[-3].minor.yy81.eType, yymsp[-3].minor.yy81.pExpr, yymsp[-1].minor.yy81.eType, yymsp[-1].minor.y…
164378 {yylhsminor.yy81.eType = yymsp[-1].major; yylhsminor.yy81.pExpr = 0;}
164382 {yylhsminor.yy81.eType = yymsp[0].major; yylhsminor.yy81.pExpr = yymsp[-1].minor.yy626;}
172610 Fts3Expr *pExpr; /* Parsed MATCH query string */
174420 sqlite3Fts3ExprFree(pCsr->pExpr);
175997 p->azColumn, p->bFts4, p->nColumn, iCol, zQuery, -1, &pCsr->pExpr,
176109 if( pCsr->pExpr ){
176792 Fts3Expr *pExpr, /* Allocate readers for this expression */
176797 if( pExpr && SQLITE_OK==*pRc ){
176798 if( pExpr->eType==FTSQUERY_PHRASE ){
176800 int nToken = pExpr->pPhrase->nToken;
176803 Fts3PhraseToken *pToken = &pExpr->pPhrase->aToken[i];
176812 assert( pExpr->pPhrase->iDoclistToken==0 );
176813 pExpr->pPhrase->iDoclistToken = -1;
176815 *pnOr += (pExpr->eType==FTSQUERY_OR);
176816 fts3EvalAllocateReaders(pCsr, pExpr->pLeft, pnToken, pnOr, pRc);
176817 fts3EvalAllocateReaders(pCsr, pExpr->pRight, pnToken, pnOr, pRc);
177454 Fts3Expr *pExpr, /* Expression to initialize phrases in */
177457 if( pExpr && SQLITE_OK==*pRc ){
177458 if( pExpr->eType==FTSQUERY_PHRASE ){
177459 int nToken = pExpr->pPhrase->nToken;
177463 if( pExpr->pPhrase->aToken[i].pDeferred==0 ) break;
177465 pExpr->bDeferred = (i==nToken);
177467 *pRc = fts3EvalPhraseStart(pCsr, 1, pExpr->pPhrase);
177469 fts3EvalStartReaders(pCsr, pExpr->pLeft, pRc);
177470 fts3EvalStartReaders(pCsr, pExpr->pRight, pRc);
177471 pExpr->bDeferred = (pExpr->pLeft->bDeferred && pExpr->pRight->bDeferred);
177508 Fts3Expr *pExpr, /* Expression to consider */
177514 if( pExpr->eType==FTSQUERY_PHRASE ){
177515 Fts3Phrase *pPhrase = pExpr->pPhrase;
177526 }else if( pExpr->eType!=FTSQUERY_NOT ){
177527 assert( pExpr->eType==FTSQUERY_OR
177528 || pExpr->eType==FTSQUERY_AND
177529 || pExpr->eType==FTSQUERY_NEAR
177531 assert( pExpr->pLeft && pExpr->pRight );
177532 if( pExpr->eType==FTSQUERY_OR ){
177533 pRoot = pExpr->pLeft;
177537 fts3EvalTokenCosts(pCsr, pRoot, pExpr->pLeft, ppTC, ppOr, pRc);
177538 if( pExpr->eType==FTSQUERY_OR ){
177539 pRoot = pExpr->pRight;
177543 fts3EvalTokenCosts(pCsr, pRoot, pExpr->pRight, ppTC, ppOr, pRc);
177760 fts3EvalAllocateReaders(pCsr, pCsr->pExpr, &nToken, &nOr, &rc);
177779 fts3EvalTokenCosts(pCsr, 0, pCsr->pExpr, &pTC, &ppOr, &rc);
177795 fts3EvalStartReaders(pCsr, pCsr->pExpr, &rc);
177911 Fts3Expr *pExpr, /* Expr. to advance to next matching row */
177916 assert( pExpr->bEof==0 );
177917 pExpr->bStart = 1;
177919 switch( pExpr->eType ){
177922 Fts3Expr *pLeft = pExpr->pLeft;
177923 Fts3Expr *pRight = pExpr->pRight;
177930 pExpr->iDocid = pRight->iDocid;
177931 pExpr->bEof = pRight->bEof;
177936 pExpr->iDocid = pLeft->iDocid;
177937 pExpr->bEof = pLeft->bEof;
177951 pExpr->iDocid = pLeft->iDocid;
177952 pExpr->bEof = (pLeft->bEof || pRight->bEof);
177953 if( pExpr->eType==FTSQUERY_NEAR && pExpr->bEof ){
177976 Fts3Expr *pLeft = pExpr->pLeft;
177977 Fts3Expr *pRight = pExpr->pRight;
177992 pExpr->bEof = (pLeft->bEof && pRight->bEof);
177995 pExpr->iDocid = pLeft->iDocid;
177997 pExpr->iDocid = pRight->iDocid;
178004 Fts3Expr *pLeft = pExpr->pLeft;
178005 Fts3Expr *pRight = pExpr->pRight;
178021 pExpr->iDocid = pLeft->iDocid;
178022 pExpr->bEof = pLeft->bEof;
178027 Fts3Phrase *pPhrase = pExpr->pPhrase;
178029 *pRc = fts3EvalPhraseNext(pCsr, pPhrase, &pExpr->bEof);
178030 pExpr->iDocid = pPhrase->doclist.iDocid;
178052 static int fts3EvalNearTest(Fts3Expr *pExpr, int *pRc){
178076 && pExpr->eType==FTSQUERY_NEAR
178077 && (pExpr->pParent==0 || pExpr->pParent->eType!=FTSQUERY_NEAR)
178084 for(p=pExpr; p->pLeft; p=p->pLeft){
178103 aPoslist = pExpr->pRight->pPhrase->doclist.pList;
178104 nToken = pExpr->pRight->pPhrase->nToken;
178105 for(p=pExpr->pLeft; p && res; p=p->pLeft){
178136 Fts3Expr *pExpr, /* Expr to test. May or may not be root. */
178141 switch( pExpr->eType ){
178145 fts3EvalTestExpr(pCsr, pExpr->pLeft, pRc)
178146 && fts3EvalTestExpr(pCsr, pExpr->pRight, pRc)
178147 && fts3EvalNearTest(pExpr, pRc)
178166 && pExpr->eType==FTSQUERY_NEAR
178167 && (pExpr->pParent==0 || pExpr->pParent->eType!=FTSQUERY_NEAR)
178170 for(p=pExpr; p->pPhrase==0; p=p->pLeft){
178183 int bHit1 = fts3EvalTestExpr(pCsr, pExpr->pLeft, pRc);
178184 int bHit2 = fts3EvalTestExpr(pCsr, pExpr->pRight, pRc);
178191 fts3EvalTestExpr(pCsr, pExpr->pLeft, pRc)
178192 && !fts3EvalTestExpr(pCsr, pExpr->pRight, pRc)
178199 && (pExpr->iDocid==pCsr->iPrevId || pExpr->bDeferred)
178201 Fts3Phrase *pPhrase = pExpr->pPhrase;
178202 assert( pExpr->bDeferred || pPhrase->doclist.bFreeList==0 );
178203 if( pExpr->bDeferred ){
178208 pExpr->iDocid = pCsr->iPrevId;
178213 pExpr->bEof==0 && pExpr->iDocid==pCsr->iPrevId
178214 && pExpr->pPhrase->doclist.nList>0
178265 bMiss = (0==fts3EvalTestExpr(pCsr, pCsr->pExpr, &rc));
178280 Fts3Expr *pExpr = pCsr->pExpr;
178282 if( pExpr==0 ){
178290 fts3EvalNextRow(pCsr, pExpr, &rc);
178291 pCsr->isEof = pExpr->bEof;
178294 pCsr->iPrevId = pExpr->iDocid;
178321 Fts3Expr *pExpr,
178324 if( pExpr && *pRc==SQLITE_OK ){
178325 Fts3Phrase *pPhrase = pExpr->pPhrase;
178345 pExpr->iDocid = 0;
178346 pExpr->bEof = 0;
178347 pExpr->bStart = 0;
178349 fts3EvalRestart(pCsr, pExpr->pLeft, pRc);
178350 fts3EvalRestart(pCsr, pExpr->pRight, pRc);
178362 static void fts3EvalUpdateCounts(Fts3Expr *pExpr, int nCol){
178363 if( pExpr ){
178364 Fts3Phrase *pPhrase = pExpr->pPhrase;
178380 pExpr->aMI[iCol*3 + 1] += iCnt;
178381 pExpr->aMI[iCol*3 + 2] += (iCnt>0);
178388 fts3EvalUpdateCounts(pExpr->pLeft, nCol);
178389 fts3EvalUpdateCounts(pExpr->pRight, nCol);
178406 Fts3Expr *pExpr /* FTSQUERY_PHRASE expression */
178410 assert( pExpr->eType==FTSQUERY_PHRASE );
178411 if( pExpr->aMI==0 ){
178421 pRoot = pExpr;
178518 Fts3Expr *pExpr, /* Phrase expression */
178525 if( pExpr->bDeferred && pExpr->pParent->eType!=FTSQUERY_NEAR ){
178532 rc = fts3EvalGatherStats(pCsr, pExpr);
178534 assert( pExpr->aMI );
178536 aiOut[iCol*3 + 1] = pExpr->aMI[iCol*3 + 1];
178537 aiOut[iCol*3 + 2] = pExpr->aMI[iCol*3 + 2];
178566 Fts3Expr *pExpr, /* Phrase to return doclist for */
178570 Fts3Phrase *pPhrase = pExpr->pPhrase;
178584 iDocid = pExpr->iDocid;
178586 if( iDocid!=pCsr->iPrevId || pExpr->bEof ){
178600 pNear = pExpr;
178601 for(p=pExpr->pParent; p; p=p->pParent){
180425 static char *exprToString(Fts3Expr *pExpr, char *zBuf){
180426 if( pExpr==0 ){
180429 switch( pExpr->eType ){
180431 Fts3Phrase *pPhrase = pExpr->pPhrase;
180445 zBuf = sqlite3_mprintf("%zNEAR/%d ", zBuf, pExpr->nNear);
180459 if( zBuf ) zBuf = exprToString(pExpr->pLeft, zBuf);
180462 if( zBuf ) zBuf = exprToString(pExpr->pRight, zBuf);
180495 Fts3Expr *pExpr;
180535 pTokenizer, 0, azCol, 0, nCol, nCol, zExpr, nExpr, &pExpr, &zDummy
180537 assert( rc==SQLITE_OK || pExpr==0 );
180541 pTokenizer, 0, azCol, 0, nCol, nCol, zExpr, nExpr, &pExpr
180546 sqlite3Fts3ExprFree(pExpr);
180548 }else if( rc==SQLITE_NOMEM || !(zBuf = exprToString(pExpr, 0)) ){
180555 sqlite3Fts3ExprFree(pExpr);
188931 Fts3Expr *pExpr, /* Expression to iterate phrases of */
188937 int eType = pExpr->eType; /* Type of expression node pExpr */
188940 assert( pExpr->pLeft && pExpr->pRight );
188941 rc = fts3ExprIterate2(pExpr->pLeft, piPhrase, x, pCtx);
188943 rc = fts3ExprIterate2(pExpr->pRight, piPhrase, x, pCtx);
188946 rc = x(pExpr, *piPhrase, pCtx);
188963 Fts3Expr *pExpr, /* Expression to iterate phrases of */
188968 return fts3ExprIterate2(pExpr, &iPhrase, x, pCtx);
188977 static int fts3ExprLoadDoclistsCb(Fts3Expr *pExpr, int iPhrase, void *ctx){
188979 Fts3Phrase *pPhrase = pExpr->pPhrase;
189008 rc = fts3ExprIterate(pCsr->pExpr, fts3ExprLoadDoclistsCb, (void *)&sCtx);
189014 static int fts3ExprPhraseCountCb(Fts3Expr *pExpr, int iPhrase, void *ctx){
189016 pExpr->iPhrase = iPhrase;
189019 static int fts3ExprPhraseCount(Fts3Expr *pExpr){
189021 (void)fts3ExprIterate(pExpr, fts3ExprPhraseCountCb, (void *)&nPhrase);
189152 static int fts3SnippetFindPositions(Fts3Expr *pExpr, int iPhrase, void *ctx){
189158 pPhrase->nToken = pExpr->pPhrase->nToken;
189159 rc = sqlite3Fts3EvalPhrasePoslist(p->pCsr, pExpr, p->iCol, &pCsr);
189240 rc = fts3ExprIterate(pCsr->pExpr, fts3SnippetFindPositions, (void*)&sIter);
189546 Fts3Expr *pExpr, /* Phrase expression node */
189551 Fts3Phrase *pPhrase = pExpr->pPhrase;
189557 iStart = pExpr->iPhrase * p->nCol;
189559 iStart = pExpr->iPhrase * ((p->nCol + 31) / 32);
189584 Fts3Expr *pExpr,
189588 assert( (pExpr->pLeft==0)==(pExpr->pRight==0) );
189589 if( pExpr->bEof==0 && pExpr->iDocid==p->pCursor->iPrevId ){
189590 if( pExpr->pLeft ){
189591 rc = fts3ExprLHitGather(pExpr->pLeft, p);
189592 if( rc==SQLITE_OK ) rc = fts3ExprLHitGather(pExpr->pRight, p);
189594 rc = fts3ExprLHits(pExpr, p);
189628 Fts3Expr *pExpr, /* Phrase expression node */
189634 p->pCursor, pExpr, &p->aMatchinfo[3*iPhrase*p->nCol]
189644 Fts3Expr *pExpr, /* Phrase expression node */
189655 rc = sqlite3Fts3EvalPhrasePoslist(p->pCursor, pExpr, i, &pCsr);
189766 Fts3Expr *pExpr; /* Pointer to phrase expression */
189779 Fts3Expr *pExpr, /* Phrase expression node */
189784 aIter[iPhrase].pExpr = pExpr;
189835 (void)fts3ExprIterate(pCsr->pExpr, fts3MatchinfoLcsCb, (void*)aIter);
189839 nToken -= pIter->pExpr->pPhrase->nToken;
189849 rc = sqlite3Fts3EvalPhrasePoslist(pCsr, pIt->pExpr, iCol, &pIt->pRead);
189997 rc = fts3ExprLHitGather(pCsr->pExpr, pInfo);
190002 Fts3Expr *pExpr;
190004 pExpr = pCsr->pExpr;
190012 rc = fts3ExprIterate(pExpr, fts3ExprGlobalHitsCb,(void*)pInfo);
190016 (void)fts3ExprIterate(pExpr, fts3ExprLocalHitsCb,(void*)pInfo);
190068 pCsr->nPhrase = fts3ExprPhraseCount(pCsr->pExpr);
190144 if( !pCsr->pExpr ){
190241 static int fts3ExprTermOffsetInit(Fts3Expr *pExpr, int iPhrase, void *ctx){
190250 rc = sqlite3Fts3EvalPhrasePoslist(p->pCsr, pExpr, p->iCol, &pList);
190251 nTerm = pExpr->pPhrase->nToken;
190282 if( !pCsr->pExpr ){
190321 rc = fts3ExprIterate(pCsr->pExpr, fts3ExprTermOffsetInit, (void*)&sCtx);
190422 if( !pCsr->pExpr ){
200605 URegularExpression *pExpr = (URegularExpression *)p;
200606 uregex_close(pExpr);
200630 URegularExpression *pExpr;
200643 pExpr = sqlite3_get_auxdata(p, 0);
200644 if( !pExpr ){
200649 pExpr = uregex_open(zPattern, -1, 0, 0, &status);
200652 sqlite3_set_auxdata(p, 0, pExpr, icuRegexpDelete);
200654 assert(!pExpr);
200661 uregex_setText(pExpr, zString, -1, &status);
200668 res = uregex_matches(pExpr, 0, &status);
200679 uregex_setText(pExpr, 0, 0, &status);
219420 Fts5ExprNode *pExpr; /* Result of a successful parse */
219540 if( iCol<pConfig->nCol && sParse.pExpr && sParse.rc==SQLITE_OK ){
219546 sqlite3Fts5ParseSetColset(&sParse, sParse.pExpr, pColset);
219555 sqlite3Fts5ParseNodeFree(sParse.pExpr);
219557 if( !sParse.pExpr ){
219564 pNew->pRoot = sParse.pExpr;
219574 sqlite3Fts5ParseNodeFree(sParse.pExpr);
220125 Fts5Expr *pExpr, /* Expression that pNear is a part of */
220131 if( pExpr->pConfig->eDetail!=FTS5_DETAIL_FULL ){
220183 Fts5Expr *pExpr,
220209 pExpr->pIndex, p->zTerm, (int)strlen(p->zTerm),
220211 (pExpr->bDesc ? FTS5INDEX_QUERY_DESC : 0),
220245 Fts5Expr *pExpr,
220249 assert( pExpr->bDesc==0 || pExpr->bDesc==1 );
220250 if( pExpr->bDesc==0 ){
220299 Fts5Expr *pExpr,
220305 return fts5RowidCmp(pExpr, p1->iRowid, p2->iRowid);
220320 Fts5Expr *pExpr, /* Expression pPhrase belongs to */
220329 const int bDesc = pExpr->bDesc;
220376 pNode->bNomatch = ((0==fts5ExprNearTest(&rc, pExpr, pNode)) && rc==SQLITE_OK);
220390 Fts5Expr *pExpr, /* Expression pPhrase belongs to */
220404 i64 iRowid = fts5ExprSynonymRowid(pTerm, pExpr->bDesc, 0);
220412 || (bFromValid && ii!=iFrom && (ii>iFrom)==pExpr->bDesc)
220447 rc = fts5ExprNodeTest_STRING(pExpr, pNode);
220455 Fts5Expr *pExpr, /* Expression that pNear is a part of */
220471 if( pExpr->pConfig->eDetail==FTS5_DETAIL_FULL ){
220483 Fts5Expr *pExpr,
220498 rc = fts5ExprNodeTest_TERM(pExpr, pNode);
220507 Fts5Expr *pExpr, /* Expression of which pNode is a part */
220515 int cmp = fts5NodeCompare(pExpr, pNext, pChild);
220526 Fts5Expr *pExpr,
220536 assert( p1->bEof || fts5RowidCmp(pExpr, p1->iRowid, iLast)>=0 );
220539 || (bFromValid && fts5RowidCmp(pExpr, p1->iRowid, iFrom)<0)
220541 int rc = fts5ExprNodeNext(pExpr, p1, bFromValid, iFrom);
220550 fts5ExprNodeTest_OR(pExpr, pNode);
220558 Fts5Expr *pExpr, /* Expression pPhrase belongs to */
220572 int cmp = fts5RowidCmp(pExpr, iLast, pChild->iRowid);
220575 rc = fts5ExprNodeNext(pExpr, pChild, 1, iLast);
220586 assert( pChild->bEof || fts5RowidCmp(pExpr, iLast, pChild->iRowid)<=0 );
220602 if( pAnd->bNomatch && pAnd!=pExpr->pRoot ){
220610 Fts5Expr *pExpr,
220615 int rc = fts5ExprNodeNext(pExpr, pNode->apChild[0], bFromValid, iFrom);
220617 rc = fts5ExprNodeTest_AND(pExpr, pNode);
220625 Fts5Expr *pExpr, /* Expression pPhrase belongs to */
220634 int cmp = fts5NodeCompare(pExpr, p1, p2);
220636 rc = fts5ExprNodeNext(pExpr, p2, 1, p1->iRowid);
220637 cmp = fts5NodeCompare(pExpr, p1, p2);
220641 rc = fts5ExprNodeNext(pExpr, p1, 0, 0);
220653 Fts5Expr *pExpr,
220658 int rc = fts5ExprNodeNext(pExpr, pNode->apChild[0], bFromValid, iFrom);
220660 rc = fts5ExprNodeTest_NOT(pExpr, pNode);
220674 Fts5Expr *pExpr, /* Expression of which pNode is a part */
220682 rc = fts5ExprNodeTest_STRING(pExpr, pNode);
220687 rc = fts5ExprNodeTest_TERM(pExpr, pNode);
220692 rc = fts5ExprNodeTest_AND(pExpr, pNode);
220697 fts5ExprNodeTest_OR(pExpr, pNode);
220702 rc = fts5ExprNodeTest_NOT(pExpr, pNode);
220718 static int fts5ExprNodeFirst(Fts5Expr *pExpr, Fts5ExprNode *pNode){
220725 rc = fts5ExprNearInitAll(pExpr, pNode);
220733 rc = fts5ExprNodeFirst(pExpr, pNode->apChild[i]);
220756 rc = fts5ExprNodeTest(pExpr, pNode);
221031 assert( pParse->pExpr==0 );
221032 pParse->pExpr = p;
221109 Fts5Expr *pExpr,
221118 pOrig = pExpr->apExprPhrase[iPhrase];
221170 pNew->pIndex = pExpr->pIndex;
221171 pNew->pConfig = pExpr->pConfig;
221434 Fts5ExprNode *pExpr,
221443 fts5ParseSetColset(pParse, pExpr, pColset, &pFree);
221760 Fts5ExprNode *pExpr
221763 if( pExpr->eType==FTS5_STRING || pExpr->eType==FTS5_TERM ){
221764 Fts5ExprNearset *pNear = pExpr->pNear;
221812 switch( pExpr->eType ){
221816 assert( pExpr->eType==FTS5_OR );
221822 for(i=0; zRet && i<pExpr->nChild; i++){
221823 char *z = fts5ExprPrintTcl(pConfig, zNearsetCmd, pExpr->apChild[i]);
221836 static char *fts5ExprPrint(Fts5Config *pConfig, Fts5ExprNode *pExpr){
221838 if( pExpr->eType==0 ){
221841 if( pExpr->eType==FTS5_STRING || pExpr->eType==FTS5_TERM ){
221842 Fts5ExprNearset *pNear = pExpr->pNear;
221894 switch( pExpr->eType ){
221898 assert( pExpr->eType==FTS5_OR );
221903 for(i=0; i<pExpr->nChild; i++){
221904 char *z = fts5ExprPrint(pConfig, pExpr->apChild[i]);
221909 int e = pExpr->apChild[i]->eType;
221937 Fts5Expr *pExpr = 0;
221980 rc = sqlite3Fts5ExprNew(pConfig, 0, pConfig->nCol, zExpr, &pExpr, &zErr);
221984 if( pExpr->pRoot->xNext==0 ){
221987 zText = fts5ExprPrintTcl(pConfig, zNearsetCmd, pExpr->pRoot);
221989 zText = fts5ExprPrint(pConfig, pExpr->pRoot);
222009 sqlite3Fts5ExprFree(pExpr);
222113 static int sqlite3Fts5ExprPhraseCount(Fts5Expr *pExpr){
222114 return (pExpr ? pExpr->nPhrase : 0);
222120 static int sqlite3Fts5ExprPhraseSize(Fts5Expr *pExpr, int iPhrase){
222121 if( iPhrase<0 || iPhrase>=pExpr->nPhrase ) return 0;
222122 return pExpr->apExprPhrase[iPhrase]->nTerm;
222129 static int sqlite3Fts5ExprPoslist(Fts5Expr *pExpr, int iPhrase, const u8 **pa){
222131 Fts5ExprPhrase *pPhrase = pExpr->apExprPhrase[iPhrase];
222133 if( pNode->bEof==0 && pNode->iRowid==pExpr->pRoot->iRowid ){
222158 static Fts5PoslistPopulator *sqlite3Fts5ExprClearPoslists(Fts5Expr *pExpr, int bLive){
222160 pRet = sqlite3_malloc64(sizeof(Fts5PoslistPopulator)*pExpr->nPhrase);
222163 memset(pRet, 0, sizeof(Fts5PoslistPopulator)*pExpr->nPhrase);
222164 for(i=0; i<pExpr->nPhrase; i++){
222165 Fts5Buffer *pBuf = &pExpr->apExprPhrase[i]->poslist;
222166 Fts5ExprNode *pNode = pExpr->apExprPhrase[i]->pNode;
222167 assert( pExpr->apExprPhrase[i]->nTerm<=1 );
222169 (pBuf->n==0 || pNode->iRowid!=pExpr->pRoot->iRowid || pNode->bEof)
222181 Fts5Expr *pExpr;
222207 Fts5Expr *pExpr = p->pExpr;
222214 for(i=0; i<pExpr->nPhrase; i++){
222217 for(pTerm=&pExpr->apExprPhrase[i]->aTerm[0]; pTerm; pTerm=pTerm->pSynonym){
222223 &pExpr->apExprPhrase[i]->poslist, &p->aPopulator[i].writer, p->iOff
222235 Fts5Expr *pExpr,
222242 sCtx.pExpr = pExpr;
222246 for(i=0; i<pExpr->nPhrase; i++){
222247 Fts5ExprNode *pNode = pExpr->apExprPhrase[i]->pNode;
222318 static void sqlite3Fts5ExprCheckPoslists(Fts5Expr *pExpr, i64 iRowid){
222319 fts5ExprCheckPoslists(pExpr->pRoot, iRowid);
222326 Fts5Expr *pExpr,
222331 Fts5ExprPhrase *pPhrase = pExpr->apExprPhrase[iPhrase];
222335 assert( iPhrase>=0 && iPhrase<pExpr->nPhrase );
222336 assert( pExpr->pConfig->eDetail==FTS5_DETAIL_COLUMNS );
222339 && pNode->iRowid==pExpr->pRoot->iRowid
229919 Fts5Expr *pExpr; /* Expression for MATCH queries */
230498 sqlite3Fts5ExprFree(pCsr->pExpr);
230612 i64 iRowid = sqlite3Fts5ExprRowid(pCsr->pExpr);
230614 rc = sqlite3Fts5ExprFirst(pCsr->pExpr, pTab->p.pIndex, iRowid, bDesc);
230615 if( rc==SQLITE_OK && iRowid!=sqlite3Fts5ExprRowid(pCsr->pExpr) ){
230621 if( sqlite3Fts5ExprEof(pCsr->pExpr) ){
230650 rc = sqlite3Fts5ExprNext(pCsr->pExpr, pCsr->iLastRowid);
230651 CsrFlagSet(pCsr, sqlite3Fts5ExprEof(pCsr->pExpr));
230733 nPhrase = sqlite3Fts5ExprPhraseCount(pCsr->pExpr);
230774 Fts5Expr *pExpr = pCsr->pExpr;
230775 rc = sqlite3Fts5ExprFirst(pExpr, pTab->p.pIndex, pCsr->iFirstRowid, bDesc);
230776 if( sqlite3Fts5ExprEof(pExpr) ){
230966 Fts5Expr *pExpr = 0;
230981 assert( pCsr->pExpr==0 );
231014 rc = sqlite3Fts5ExprNew(pConfig, 0, iCol, zText, &pExpr, pzErr);
231016 rc = sqlite3Fts5ExprAnd(&pCsr->pExpr, pExpr);
231017 pExpr = 0;
231034 rc = sqlite3Fts5ExprPattern(pConfig, bGlob, iCol, zText, &pExpr);
231037 rc = sqlite3Fts5ExprAnd(&pCsr->pExpr, pExpr);
231038 pExpr = 0;
231091 pCsr->pExpr = pTab->pSortCsr->pExpr;
231093 }else if( pCsr->pExpr ){
231129 sqlite3Fts5ExprFree(pExpr);
231154 return sqlite3Fts5ExprRowid(pCsr->pExpr);
231211 assert( pCsr->pExpr );
231568 return sqlite3Fts5ExprPhraseCount(pCsr->pExpr);
231573 return sqlite3Fts5ExprPhraseSize(pCsr->pExpr, iPhrase);
231614 aPopulator = sqlite3Fts5ExprClearPoslists(pCsr->pExpr, bLive);
231621 pConfig, pCsr->pExpr, aPopulator, i, z, n
231628 sqlite3Fts5ExprCheckPoslists(pCsr->pExpr, pCsr->pSorter->iRowid);
231640 *pn = sqlite3Fts5ExprPoslist(pCsr->pExpr, iPhrase, pa);
231657 nIter = sqlite3Fts5ExprPhraseCount(pCsr->pExpr);
231982 rc = sqlite3Fts5ExprPhraseCollist(pCsr->pExpr, iPhrase, &pIter->a, &n);
232057 rc = sqlite3Fts5ExprClonePhrase(pCsr->pExpr, iPhrase, &pNew->pExpr);
232157 int nPhrase = sqlite3Fts5ExprPhraseCount(pCsr->pExpr);
232167 int nByte = sqlite3Fts5ExprPoslist(pCsr->pExpr, i, &dummy);
232175 nPoslist = sqlite3Fts5ExprPoslist(pCsr->pExpr, i, &pPoslist);
232186 rc = sqlite3Fts5ExprPhraseCollist(pCsr->pExpr, i, &dummy, &nByte);
232194 rc = sqlite3Fts5ExprPhraseCollist(pCsr->pExpr, i, &pPoslist, &nPoslist);