Lines Matching refs:pExpr
16462 Expr *pExpr; /* Used when p4type is P4_EXPR */ member
17047 SQLITE_PRIVATE int sqlite3CursorRangeHintExprCheck(Walker *pWalker, Expr *pExpr);
19111 Expr *pExpr; /* The parse tree for this expression */ member
19166 Expr *pExpr; /* Expr to implement a USING variable -- NOT USED */ member
19678 Expr *pExpr; /* The expression contained in the index */ member
21153 SQLITE_PRIVATE char sqlite3CompareAffinity(const Expr *pExpr, char aff2);
21154 SQLITE_PRIVATE int sqlite3IndexAffinityOk(const Expr *pExpr, char idx_affinity);
21156 SQLITE_PRIVATE char sqlite3ExprAffinity(const Expr *pExpr);
21157 SQLITE_PRIVATE int sqlite3ExprDataType(const Expr *pExpr);
21185 SQLITE_PRIVATE CollSeq *sqlite3ExprCollSeq(Parse *pParse, const Expr *pExpr);
21186 SQLITE_PRIVATE CollSeq *sqlite3ExprNNCollSeq(Parse *pParse, const Expr *pExpr);
21666 SQLITE_PRIVATE int sqlite3ExprVectorSize(const Expr *pExpr);
21667 SQLITE_PRIVATE int sqlite3ExprIsVector(const Expr *pExpr);
31663 Expr *pExpr = va_arg(ap,Expr*); in sqlite3_str_vappendf() local
31664 if( ALWAYS(pExpr) && ALWAYS(!ExprHasProperty(pExpr,EP_IntValue)) ){ in sqlite3_str_vappendf()
31665 sqlite3_str_appendall(pAccum, (const char*)pExpr->u.zToken); in sqlite3_str_vappendf()
31666 sqlite3RecordErrorOffsetOfExpr(pAccum->db, pExpr); in sqlite3_str_vappendf()
31764 SQLITE_PRIVATE void sqlite3RecordErrorOffsetOfExpr(sqlite3 *db, const Expr *pExpr){ in sqlite3RecordErrorOffsetOfExpr() argument
31765 while( pExpr in sqlite3RecordErrorOffsetOfExpr()
31766 && (ExprHasProperty(pExpr,EP_OuterON|EP_InnerON) || pExpr->w.iOfst<=0) in sqlite3RecordErrorOffsetOfExpr()
31768 pExpr = pExpr->pLeft; in sqlite3RecordErrorOffsetOfExpr()
31770 if( pExpr==0 ) return; in sqlite3RecordErrorOffsetOfExpr()
31771 db->errByteOffset = pExpr->w.iOfst; in sqlite3RecordErrorOffsetOfExpr()
32653 Expr *pExpr, /* Value for PRECEDING or FOLLOWING */ in sqlite3TreeViewBound() argument
32669 sqlite3TreeViewExpr(pView, pExpr, 0); in sqlite3TreeViewBound()
32675 sqlite3TreeViewExpr(pView, pExpr, 0); in sqlite3TreeViewBound()
32767 SQLITE_PRIVATE void sqlite3TreeViewExpr(TreeView *pView, const Expr *pExpr, u8 moreToFollow){ in sqlite3TreeViewExpr() argument
32772 if( pExpr==0 ){ in sqlite3TreeViewExpr()
32777 if( pExpr->flags || pExpr->affExpr || pExpr->vvaFlags || pExpr->pAggInfo ){ in sqlite3TreeViewExpr()
32781 pExpr->flags, pExpr->affExpr ? pExpr->affExpr : 'n'); in sqlite3TreeViewExpr()
32782 if( ExprHasProperty(pExpr, EP_OuterON) ){ in sqlite3TreeViewExpr()
32783 sqlite3_str_appendf(&x, " outer.iJoin=%d", pExpr->w.iJoin); in sqlite3TreeViewExpr()
32785 if( ExprHasProperty(pExpr, EP_InnerON) ){ in sqlite3TreeViewExpr()
32786 sqlite3_str_appendf(&x, " inner.iJoin=%d", pExpr->w.iJoin); in sqlite3TreeViewExpr()
32788 if( ExprHasProperty(pExpr, EP_FromDDL) ){ in sqlite3TreeViewExpr()
32791 if( ExprHasVVAProperty(pExpr, EP_Immutable) ){ in sqlite3TreeViewExpr()
32794 if( pExpr->pAggInfo!=0 ){ in sqlite3TreeViewExpr()
32795 sqlite3_str_appendf(&x, " agg-column[%d]", pExpr->iAgg); in sqlite3TreeViewExpr()
32801 switch( pExpr->op ){ in sqlite3TreeViewExpr()
32804 pExpr->iTable, pExpr->iColumn, zFlgs); in sqlite3TreeViewExpr()
32808 if( pExpr->iTable<0 ){ in sqlite3TreeViewExpr()
32811 if( pExpr->op2 ){ in sqlite3TreeViewExpr()
32812 sqlite3_snprintf(sizeof(zOp2),zOp2," op2=0x%02x",pExpr->op2); in sqlite3TreeViewExpr()
32817 pExpr->iColumn, zFlgs, zOp2); in sqlite3TreeViewExpr()
32819 assert( ExprUseYTab(pExpr) ); in sqlite3TreeViewExpr()
32821 pExpr->iTable, pExpr->iColumn, in sqlite3TreeViewExpr()
32822 pExpr->y.pTab, zFlgs); in sqlite3TreeViewExpr()
32824 if( ExprHasProperty(pExpr, EP_FixedCol) ){ in sqlite3TreeViewExpr()
32825 sqlite3TreeViewExpr(pView, pExpr->pLeft, 0); in sqlite3TreeViewExpr()
32830 if( pExpr->flags & EP_IntValue ){ in sqlite3TreeViewExpr()
32831 sqlite3TreeViewLine(pView, "%d", pExpr->u.iValue); in sqlite3TreeViewExpr()
32833 sqlite3TreeViewLine(pView, "%s", pExpr->u.zToken); in sqlite3TreeViewExpr()
32839 assert( !ExprHasProperty(pExpr, EP_IntValue) ); in sqlite3TreeViewExpr()
32840 sqlite3TreeViewLine(pView,"%s", pExpr->u.zToken); in sqlite3TreeViewExpr()
32845 assert( !ExprHasProperty(pExpr, EP_IntValue) ); in sqlite3TreeViewExpr()
32846 sqlite3TreeViewLine(pView,"%Q", pExpr->u.zToken); in sqlite3TreeViewExpr()
32855 sqlite3ExprTruthValue(pExpr) ? "TRUE" : "FALSE", zFlgs); in sqlite3TreeViewExpr()
32860 assert( !ExprHasProperty(pExpr, EP_IntValue) ); in sqlite3TreeViewExpr()
32861 sqlite3TreeViewLine(pView,"%s", pExpr->u.zToken); in sqlite3TreeViewExpr()
32866 assert( !ExprHasProperty(pExpr, EP_IntValue) ); in sqlite3TreeViewExpr()
32868 pExpr->u.zToken, pExpr->iColumn); in sqlite3TreeViewExpr()
32872 sqlite3TreeViewLine(pView,"REGISTER(%d)", pExpr->iTable); in sqlite3TreeViewExpr()
32876 assert( !ExprHasProperty(pExpr, EP_IntValue) ); in sqlite3TreeViewExpr()
32877 sqlite3TreeViewLine(pView,"ID \"%w\"", pExpr->u.zToken); in sqlite3TreeViewExpr()
32883 assert( !ExprHasProperty(pExpr, EP_IntValue) ); in sqlite3TreeViewExpr()
32884 sqlite3TreeViewLine(pView,"CAST %Q", pExpr->u.zToken); in sqlite3TreeViewExpr()
32885 sqlite3TreeViewExpr(pView, pExpr->pLeft, 0); in sqlite3TreeViewExpr()
32924 assert( pExpr->op2==TK_IS || pExpr->op2==TK_ISNOT ); in sqlite3TreeViewExpr()
32925 assert( pExpr->pRight ); in sqlite3TreeViewExpr()
32926 assert( sqlite3ExprSkipCollateAndLikely(pExpr->pRight)->op in sqlite3TreeViewExpr()
32928 x = (pExpr->op2==TK_ISNOT)*2 + sqlite3ExprTruthValue(pExpr->pRight); in sqlite3TreeViewExpr()
32934 assert( !ExprHasProperty(pExpr, EP_IntValue) ); in sqlite3TreeViewExpr()
32935 sqlite3TreeViewLine(pView, "SPAN %Q", pExpr->u.zToken); in sqlite3TreeViewExpr()
32936 sqlite3TreeViewExpr(pView, pExpr->pLeft, 0); in sqlite3TreeViewExpr()
32946 assert( !ExprHasProperty(pExpr, EP_IntValue) ); in sqlite3TreeViewExpr()
32948 !ExprHasProperty(pExpr, EP_Collate) ? "SOFT-" : "", in sqlite3TreeViewExpr()
32949 pExpr->u.zToken, zFlgs); in sqlite3TreeViewExpr()
32950 sqlite3TreeViewExpr(pView, pExpr->pLeft, 0); in sqlite3TreeViewExpr()
32958 if( ExprHasProperty(pExpr, EP_TokenOnly) ){ in sqlite3TreeViewExpr()
32962 assert( ExprUseXList(pExpr) ); in sqlite3TreeViewExpr()
32963 pFarg = pExpr->x.pList; in sqlite3TreeViewExpr()
32965 pWin = IsWindowFunc(pExpr) ? pExpr->y.pWin : 0; in sqlite3TreeViewExpr()
32970 assert( !ExprHasProperty(pExpr, EP_IntValue) ); in sqlite3TreeViewExpr()
32971 if( pExpr->op==TK_AGG_FUNCTION ){ in sqlite3TreeViewExpr()
32973 pExpr->op2, pExpr->u.zToken, zFlgs, in sqlite3TreeViewExpr()
32974 pExpr->pAggInfo ? pExpr->pAggInfo->selId : 0, in sqlite3TreeViewExpr()
32975 pExpr->iAgg, pExpr->pAggInfo); in sqlite3TreeViewExpr()
32976 }else if( pExpr->op2!=0 ){ in sqlite3TreeViewExpr()
32979 sqlite3_snprintf(sizeof(zBuf),zBuf,"0x%02x",pExpr->op2); in sqlite3TreeViewExpr()
32981 if( pExpr->op2==NC_IsCheck ) zOp2 = "NC_IsCheck"; in sqlite3TreeViewExpr()
32982 if( pExpr->op2==NC_IdxExpr ) zOp2 = "NC_IdxExpr"; in sqlite3TreeViewExpr()
32983 if( pExpr->op2==NC_PartIdx ) zOp2 = "NC_PartIdx"; in sqlite3TreeViewExpr()
32984 if( pExpr->op2==NC_GenCol ) zOp2 = "NC_GenCol"; in sqlite3TreeViewExpr()
32986 pExpr->u.zToken, zFlgs, zOp2); in sqlite3TreeViewExpr()
32988 sqlite3TreeViewLine(pView, "FUNCTION %Q%s", pExpr->u.zToken, zFlgs); in sqlite3TreeViewExpr()
32991 sqlite3TreeViewExprList(pView, pFarg, pWin!=0 || pExpr->pLeft, 0); in sqlite3TreeViewExpr()
32992 if( pExpr->pLeft ){ in sqlite3TreeViewExpr()
32993 Expr *pOB = pExpr->pLeft; in sqlite3TreeViewExpr()
33007 sqlite3TreeViewExprList(pView, pExpr->x.pList, 0, "ORDERBY"); in sqlite3TreeViewExpr()
33012 assert( ExprUseXSelect(pExpr) ); in sqlite3TreeViewExpr()
33013 sqlite3TreeViewLine(pView, "EXISTS-expr flags=0x%x", pExpr->flags); in sqlite3TreeViewExpr()
33014 sqlite3TreeViewSelect(pView, pExpr->x.pSelect, 0); in sqlite3TreeViewExpr()
33018 assert( ExprUseXSelect(pExpr) ); in sqlite3TreeViewExpr()
33019 sqlite3TreeViewLine(pView, "subquery-expr flags=0x%x", pExpr->flags); in sqlite3TreeViewExpr()
33020 sqlite3TreeViewSelect(pView, pExpr->x.pSelect, 0); in sqlite3TreeViewExpr()
33026 sqlite3_str_appendf(pStr, "IN flags=0x%x", pExpr->flags); in sqlite3TreeViewExpr()
33027 if( pExpr->iTable ) sqlite3_str_appendf(pStr, " iTable=%d",pExpr->iTable); in sqlite3TreeViewExpr()
33028 if( ExprHasProperty(pExpr, EP_Subrtn) ){ in sqlite3TreeViewExpr()
33030 pExpr->y.sub.regReturn, pExpr->y.sub.iAddr); in sqlite3TreeViewExpr()
33035 sqlite3TreeViewExpr(pView, pExpr->pLeft, 1); in sqlite3TreeViewExpr()
33036 if( ExprUseXSelect(pExpr) ){ in sqlite3TreeViewExpr()
33037 sqlite3TreeViewSelect(pView, pExpr->x.pSelect, 0); in sqlite3TreeViewExpr()
33039 sqlite3TreeViewExprList(pView, pExpr->x.pList, 0, 0); in sqlite3TreeViewExpr()
33058 pX = pExpr->pLeft; in sqlite3TreeViewExpr()
33059 assert( ExprUseXList(pExpr) ); in sqlite3TreeViewExpr()
33060 assert( pExpr->x.pList->nExpr==2 ); in sqlite3TreeViewExpr()
33061 pY = pExpr->x.pList->a[0].pExpr; in sqlite3TreeViewExpr()
33062 pZ = pExpr->x.pList->a[1].pExpr; in sqlite3TreeViewExpr()
33078 pExpr->iTable ? "NEW" : "OLD", pExpr->iColumn); in sqlite3TreeViewExpr()
33083 sqlite3TreeViewExpr(pView, pExpr->pLeft, 1); in sqlite3TreeViewExpr()
33084 assert( ExprUseXList(pExpr) ); in sqlite3TreeViewExpr()
33085 sqlite3TreeViewExprList(pView, pExpr->x.pList, 0, 0); in sqlite3TreeViewExpr()
33091 switch( pExpr->affExpr ){ in sqlite3TreeViewExpr()
33097 assert( !ExprHasProperty(pExpr, EP_IntValue) ); in sqlite3TreeViewExpr()
33098 sqlite3TreeViewLine(pView, "RAISE %s(%Q)", zType, pExpr->u.zToken); in sqlite3TreeViewExpr()
33104 pExpr->iTable, pExpr->iColumn, zFlgs); in sqlite3TreeViewExpr()
33105 sqlite3TreeViewExpr(pView, pExpr->pRight, 0); in sqlite3TreeViewExpr()
33110 assert( ExprUseXList(pExpr) ); in sqlite3TreeViewExpr()
33111 sqlite3TreeViewBareExprList(pView, pExpr->x.pList, z); in sqlite3TreeViewExpr()
33117 pExpr->iColumn, pExpr->iTable-1, in sqlite3TreeViewExpr()
33118 pExpr->pRight==pExpr->pLeft ? " (SELECT-owner)" : ""); in sqlite3TreeViewExpr()
33119 assert( ExprUseXSelect(pExpr->pLeft) ); in sqlite3TreeViewExpr()
33120 sqlite3TreeViewSelect(pView, pExpr->pLeft->x.pSelect, 0); in sqlite3TreeViewExpr()
33124 sqlite3TreeViewLine(pView, "IF-NULL-ROW %d", pExpr->iTable); in sqlite3TreeViewExpr()
33125 sqlite3TreeViewExpr(pView, pExpr->pLeft, 0); in sqlite3TreeViewExpr()
33131 tmp = *pExpr; in sqlite3TreeViewExpr()
33132 tmp.op = pExpr->op2; in sqlite3TreeViewExpr()
33137 if( pExpr->iColumn<=0 ){ in sqlite3TreeViewExpr()
33141 pExpr->iColumn-1); in sqlite3TreeViewExpr()
33146 sqlite3TreeViewLine(pView, "op=%d", pExpr->op); in sqlite3TreeViewExpr()
33152 sqlite3TreeViewExpr(pView, pExpr->pLeft, 1); in sqlite3TreeViewExpr()
33153 sqlite3TreeViewExpr(pView, pExpr->pRight, 0); in sqlite3TreeViewExpr()
33156 sqlite3TreeViewExpr(pView, pExpr->pLeft, 0); in sqlite3TreeViewExpr()
33206 sqlite3TreeViewExpr(pView, pList->a[i].pExpr, moreToFollow); in sqlite3TreeViewBareExprList()
33250 if( pList->a[i].u4.pExpr==0 ){ in sqlite3TreeViewBareIdList()
33255 sqlite3TreeViewExpr(pView, pList->a[i].u4.pExpr, 0); in sqlite3TreeViewBareIdList()
71135 Expr *pExpr;
71140 pExpr = va_arg(ap, Expr*);
71143 assert( pExpr!=0 );
71145 sqlite3WalkExpr(&w, pExpr);
83872 rc = sqlite3ValueFromExpr(db, pList->a[i].pExpr, enc, aff, &apVal[i]);
83932 const Expr *pExpr, /* The expression to evaluate */
83945 assert( pExpr!=0 );
83946 while( (op = pExpr->op)==TK_UPLUS || op==TK_SPAN ) pExpr = pExpr->pLeft;
83947 if( op==TK_REGISTER ) op = pExpr->op2;
83953 assert( (pExpr->flags & EP_TokenOnly)==0 || pCtx==0 );
83957 assert( !ExprHasProperty(pExpr, EP_IntValue) );
83958 aff = sqlite3AffinityType(pExpr->u.zToken,0);
83959 rc = valueFromExpr(db, pExpr->pLeft, enc, aff, ppVal, pCtx);
83979 && (pExpr->pLeft->op==TK_INTEGER || pExpr->pLeft->op==TK_FLOAT) ){
83980 pExpr = pExpr->pLeft;
83981 op = pExpr->op;
83989 if( ExprHasProperty(pExpr, EP_IntValue) ){
83990 sqlite3VdbeMemSetInt64(pVal, (i64)pExpr->u.iValue*negInt);
83992 zVal = sqlite3MPrintf(db, "%s%s", zNeg, pExpr->u.zToken);
84012 if( SQLITE_OK==valueFromExpr(db,pExpr->pLeft,enc,affinity,&pVal,pCtx)
84038 assert( !ExprHasProperty(pExpr, EP_IntValue) );
84039 assert( pExpr->u.zToken[0]=='x' || pExpr->u.zToken[0]=='X' );
84040 assert( pExpr->u.zToken[1]=='\'' );
84043 zVal = &pExpr->u.zToken[2];
84052 rc = valueFromFunction(db, pExpr, enc, affinity, &pVal, pCtx);
84056 assert( !ExprHasProperty(pExpr, EP_IntValue) );
84060 pVal->u.i = pExpr->u.zToken[4]==0;
84095 const Expr *pExpr, /* The expression to evaluate */
84100 return pExpr ? valueFromExpr(db, pExpr, enc, affinity, ppVal, 0) : 0;
84124 Expr *pExpr, /* The expression to extract a value from */
84134 pExpr = sqlite3ExprSkipCollate(pExpr);
84136 assert( pExpr==0 || pExpr->op!=TK_REGISTER || pExpr->op2!=TK_VARIABLE );
84137 if( !pExpr ){
84142 }else if( pExpr->op==TK_VARIABLE && (db->flags & SQLITE_EnableQPSG)==0 ){
84144 int iBindVar = pExpr->iColumn;
84155 rc = valueFromExpr(db, pExpr, ENC(db), affinity, &pVal, pAlloc);
84201 Expr *pExpr, /* The expression to extract a value from */
84209 if( pExpr==0 || pExpr->op!=TK_SELECT ){
84219 Expr *pElem = (pExpr ? sqlite3VectorFieldSubexpr(pExpr, i) : 0);
84244 Expr *pExpr, /* The expression to extract a value from */
84248 return stat4ValueFromExpr(pParse, pExpr, affinity, 0, ppVal);
86180 static void displayP4Expr(StrAccum *p, Expr *pExpr){
86182 switch( pExpr->op ){
86184 assert( !ExprHasProperty(pExpr, EP_IntValue) );
86185 sqlite3_str_appendf(p, "%Q", pExpr->u.zToken);
86188 sqlite3_str_appendf(p, "%d", pExpr->u.iValue);
86194 sqlite3_str_appendf(p, "r[%d]", pExpr->iTable);
86198 if( pExpr->iColumn<0 ){
86201 sqlite3_str_appendf(p, "c%d", (int)pExpr->iColumn);
86239 displayP4Expr(p, pExpr->pLeft);
86240 if( pExpr->pRight ){
86242 displayP4Expr(p, pExpr->pRight);
86280 displayP4Expr(&x, pOp->p4.pExpr);
89742 SQLITE_PRIVATE int sqlite3CursorRangeHintExprCheck(Walker *pWalker, Expr *pExpr){
89743 if( pExpr->op==TK_REGISTER ){
89744 assert( (pWalker->u.aMem[pExpr->iTable].flags & MEM_Undefined)==0 );
101506 pOp->p4.pExpr, aMem);
105986 SQLITE_PRIVATE SQLITE_NOINLINE int sqlite3WalkExprNN(Walker *pWalker, Expr *pExpr){
105988 testcase( ExprHasProperty(pExpr, EP_TokenOnly) );
105989 testcase( ExprHasProperty(pExpr, EP_Reduced) );
105991 rc = pWalker->xExprCallback(pWalker, pExpr);
105993 if( !ExprHasProperty(pExpr,(EP_TokenOnly|EP_Leaf)) ){
105994 assert( pExpr->x.pList==0 || pExpr->pRight==0 );
105995 if( pExpr->pLeft && sqlite3WalkExprNN(pWalker, pExpr->pLeft) ){
105998 if( pExpr->pRight ){
105999 assert( !ExprHasProperty(pExpr, EP_WinFunc) );
106000 pExpr = pExpr->pRight;
106002 }else if( ExprUseXSelect(pExpr) ){
106003 assert( !ExprHasProperty(pExpr, EP_WinFunc) );
106004 if( sqlite3WalkSelect(pWalker, pExpr->x.pSelect) ) return WRC_Abort;
106006 if( pExpr->x.pList ){
106007 if( sqlite3WalkExprList(pWalker, pExpr->x.pList) ) return WRC_Abort;
106010 if( ExprHasProperty(pExpr, EP_WinFunc) ){
106011 if( walkWindowList(pWalker, pExpr->y.pWin, 1) ) return WRC_Abort;
106020 SQLITE_PRIVATE int sqlite3WalkExpr(Walker *pWalker, Expr *pExpr){
106021 return pExpr ? sqlite3WalkExprNN(pWalker,pExpr) : WRC_Continue;
106033 if( sqlite3WalkExpr(pWalker, pItem->pExpr) ) return WRC_Abort;
106219 static int incrAggDepth(Walker *pWalker, Expr *pExpr){
106220 if( pExpr->op==TK_AGG_FUNCTION ) pExpr->op2 += pWalker->u.n;
106223 static void incrAggFunctionDepth(Expr *pExpr, int N){
106229 sqlite3WalkExpr(&w, pExpr);
106256 Expr *pExpr, /* Transform this into an alias to the result set */
106264 pOrig = pEList->a[iCol].pExpr;
106274 if( pExpr->op==TK_COLLATE ){
106275 assert( !ExprHasProperty(pExpr, EP_IntValue) );
106276 pDup = sqlite3ExprAddCollateString(pParse, pDup, pExpr->u.zToken);
106279 memcpy(pDup, pExpr, sizeof(Expr));
106280 memcpy(pExpr, &temp, sizeof(Expr));
106281 if( ExprHasProperty(pExpr, EP_WinFunc) ){
106282 if( ALWAYS(pExpr->y.pWin!=0) ){
106283 pExpr->y.pWin->pOwner = pExpr;
106361 SQLITE_PRIVATE Bitmask sqlite3ExprColUsed(Expr *pExpr){
106365 n = pExpr->iColumn;
106366 assert( ExprUseYTab(pExpr) );
106367 pExTab = pExpr->y.pTab;
106466 Expr *pExpr /* Make this EXPR node point to the selected column */
106485 assert( !ExprHasProperty(pExpr, EP_TokenOnly|EP_Reduced) );
106488 pExpr->iTable = -1;
106489 ExprSetVVAProperty(pExpr, EP_NoReduce);
106573 extendFJMatch(pParse, &pFJMatch, pMatch, pExpr->iColumn);
106585 pExpr->iColumn = j;
106608 assert( ExprUseYTab(pExpr) );
106610 sqlite3RenameTokenRemap(pParse, 0, (void*)&pExpr->y.pTab);
106639 extendFJMatch(pParse, &pFJMatch, pMatch, pExpr->iColumn);
106645 pExpr->iColumn = j==pTab->iPKey ? -1 : (i16)j;
106658 pExpr->iTable = pMatch->iCursor;
106659 assert( ExprUseYTab(pExpr) );
106660 pExpr->y.pTab = pMatch->pTab;
106662 ExprSetProperty(pExpr, EP_CanBeNull);
106664 pSchema = pExpr->y.pTab->pSchema;
106685 pExpr->iTable = op!=TK_DELETE;
106689 pExpr->iTable = 1;
106692 pExpr->iTable = 0;
106702 pExpr->iTable = EXCLUDED_TABLE_NUMBER;
106730 if( pExpr->iTable==EXCLUDED_TABLE_NUMBER ){
106732 assert( ExprUseYTab(pExpr) );
106734 pExpr->iColumn = iCol;
106735 pExpr->y.pTab = pTab;
106738 pExpr->iTable = pNC->uNC.pUpsert->regData +
106745 assert( ExprUseYTab(pExpr) );
106746 pExpr->y.pTab = pTab;
106749 pExpr->op2 = TK_COLUMN;
106750 pExpr->iColumn = iCol;
106751 pExpr->iTable = pNC->uNC.iBaseReg + (pTab->nCol+1)*pExpr->iTable +
106754 pExpr->iColumn = (i16)iCol;
106758 pExpr->affExpr = SQLITE_AFF_INTEGER;
106759 }else if( pExpr->iTable==0 ){
106787 if( pMatch->fg.isNestedFrom==0 ) pExpr->iColumn = -1;
106788 pExpr->affExpr = SQLITE_AFF_INTEGER;
106821 assert( pExpr->pLeft==0 && pExpr->pRight==0 );
106822 assert( ExprUseXList(pExpr)==0 || pExpr->x.pList==0 );
106823 assert( ExprUseXSelect(pExpr)==0 || pExpr->x.pSelect==0 );
106824 pOrig = pEList->a[j].pExpr;
106839 resolveAlias(pParse, pEList, j, pExpr, nSubquery);
106844 sqlite3RenameTokenRemap(pParse, 0, (void*)pExpr);
106871 assert( pExpr->op==TK_ID );
106872 if( ExprHasProperty(pExpr,EP_DblQuoted)
106894 pExpr->op = TK_STRING;
106895 memset(&pExpr->y, 0, sizeof(pExpr->y));
106898 if( sqlite3ExprIdToTrueFalse(pExpr) ){
106911 assert( !ExprHasProperty(pExpr, EP_xIsSelect|EP_IntValue) );
106916 if( ExprHasProperty(pExpr,EP_Leaf) ){
106917 ExprClearProperty(pExpr,EP_Leaf);
106919 sqlite3ExprDelete(db, pExpr->pLeft);
106920 pExpr->pLeft = 0;
106921 sqlite3ExprDelete(db, pExpr->pRight);
106922 pExpr->pRight = 0;
106924 extendFJMatch(pParse, &pFJMatch, pMatch, pExpr->iColumn);
106925 pExpr->op = TK_FUNCTION;
106926 pExpr->u.zToken = "coalesce";
106927 pExpr->x.pList = pFJMatch;
106943 sqlite3RecordErrorOffsetOfExpr(pParse->db, pExpr);
106951 if( !ExprHasProperty(pExpr,(EP_TokenOnly|EP_Leaf)) ){
106952 sqlite3ExprDelete(db, pExpr->pLeft);
106953 pExpr->pLeft = 0;
106954 sqlite3ExprDelete(db, pExpr->pRight);
106955 pExpr->pRight = 0;
106956 ExprSetProperty(pExpr, EP_Leaf);
106973 if( pExpr->iColumn>=0 && cnt==1 && pMatch!=0 ){
106974 pMatch->colUsed |= sqlite3ExprColUsed(pExpr);
106977 pExpr->op = eNewExprOp;
106983 && (pExpr->op==TK_COLUMN || pExpr->op==TK_TRIGGER)
106985 sqlite3AuthRead(pParse, pExpr, pSchema, pNC->pSrcList);
107054 Expr *pExpr, /* Invalidate this expression on error */
107066 if( pExpr ) pExpr->op = TK_NULL;
107099 static int resolveExprStep(Walker *pWalker, Expr *pExpr){
107117 switch( pExpr->op ){
107129 pExpr->op = TK_COLUMN;
107130 assert( ExprUseYTab(pExpr) );
107131 pExpr->y.pTab = pItem->pTab;
107132 pExpr->iTable = pItem->iCursor;
107133 pExpr->iColumn--;
107134 pExpr->affExpr = SQLITE_AFF_INTEGER;
107160 sqlite3WalkExpr(pWalker, pExpr->pLeft);
107161 if( 0==sqlite3ExprCanBeNull(pExpr->pLeft) && !IN_RENAME_OBJECT ){
107162 testcase( ExprHasProperty(pExpr, EP_OuterON) );
107163 assert( !ExprHasProperty(pExpr, EP_IntValue) );
107164 pExpr->u.iValue = (pExpr->op==TK_NOTNULL);
107165 pExpr->flags |= EP_IntValue;
107166 pExpr->op = TK_INTEGER;
107171 sqlite3ExprDelete(pParse->db, pExpr->pLeft);
107172 pExpr->pLeft = 0;
107192 if( pExpr->op==TK_ID ){
107195 assert( !ExprHasProperty(pExpr, EP_IntValue) );
107196 zColumn = pExpr->u.zToken;
107198 Expr *pLeft = pExpr->pLeft;
107202 NC_IdxExpr|NC_GenCol, 0, pExpr);
107203 pRight = pExpr->pRight;
107216 assert( ExprUseYTab(pExpr) );
107218 sqlite3RenameTokenRemap(pParse, (void*)pExpr, (void*)pRight);
107219 sqlite3RenameTokenRemap(pParse, (void*)&pExpr->y.pTab, (void*)pLeft);
107222 return lookupName(pParse, zDb, zTable, zColumn, pNC, pExpr);
107228 ExprList *pList = pExpr->x.pList; /* The argument list */
107238 Window *pWin = (IsWindowFunc(pExpr) ? pExpr->y.pWin : 0);
107240 assert( !ExprHasProperty(pExpr, EP_xIsSelect|EP_IntValue) );
107241 assert( pExpr->pLeft==0 || pExpr->pLeft->op==TK_ORDER );
107242 zId = pExpr->u.zToken;
107254 ExprSetProperty(pExpr, EP_Unlikely);
107256 pExpr->iTable = exprProbability(pList->a[1].pExpr);
107257 if( pExpr->iTable<0 ){
107260 "constant between 0.0 and 1.0", pExpr);
107273 pExpr->iTable = pDef->zName[0]=='u' ? 8388608 : 125829120;
107282 pExpr);
107285 pExpr->op = TK_NULL;
107295 ExprSetProperty(pExpr,EP_ConstFunc);
107305 NC_IdxExpr|NC_PartIdx|NC_GenCol, 0, pExpr);
107308 pExpr->op2 = pNC->ncFlags & NC_SelfRef;
107309 if( pNC->ncFlags & NC_FromDDL ) ExprSetProperty(pExpr, EP_FromDDL);
107325 sqlite3ExprFunctionUsable(pParse, pExpr, pDef);
107337 "%#T() may not be used as a window function", pExpr
107351 sqlite3ErrorMsg(pParse, "misuse of %s function %#T()",zType,pExpr);
107357 sqlite3ErrorMsg(pParse,"misuse of aggregate function %#T()",pExpr);
107367 sqlite3ErrorMsg(pParse, "no such function: %#T", pExpr);
107371 pExpr);
107375 else if( is_agg==0 && ExprHasProperty(pExpr, EP_WinFunc) ){
107378 pExpr
107383 else if( is_agg==0 && pExpr->pLeft ){
107384 sqlite3ExprOrderByAggregateError(pParse, pExpr);
107399 else if( ExprHasProperty(pExpr, EP_WinFunc) ){
107405 if( pExpr->pLeft ){
107406 assert( pExpr->pLeft->op==TK_ORDER );
107407 assert( ExprUseXList(pExpr->pLeft) );
107408 sqlite3WalkExprList(pWalker, pExpr->pLeft->x.pList);
107413 assert( pWin==0 || (ExprUseYWin(pExpr) && pWin==pExpr->y.pWin) );
107427 pExpr->op = TK_AGG_FUNCTION;
107428 pExpr->op2 = 0;
107430 if( ExprHasProperty(pExpr, EP_WinFunc) ){
107431 sqlite3WalkExpr(pWalker, pExpr->y.pWin->pFilter);
107436 && sqlite3ReferencesSrcList(pParse, pExpr, pNC2->pSrcList)==0
107438 pExpr->op2 += (1 + pNC2->nNestedSelect);
107443 pExpr->op2 += pNC2->nNestedSelect;
107462 case TK_EXISTS: testcase( pExpr->op==TK_EXISTS );
107465 testcase( pExpr->op==TK_IN );
107466 if( ExprUseXSelect(pExpr) ){
107473 notValidImpl(pParse, pNC, "subqueries", pExpr, pExpr);
107475 sqlite3WalkSelect(pWalker, pExpr->x.pSelect);
107479 ExprSetProperty(pExpr, EP_VarSelect);
107491 NC_IsCheck|NC_PartIdx|NC_IdxExpr|NC_GenCol, pExpr, pExpr);
107496 Expr *pRight = sqlite3ExprSkipCollateAndLikely(pExpr->pRight);
107497 assert( !ExprHasProperty(pExpr, EP_Reduced) );
107504 pExpr->op2 = pExpr->op;
107505 pExpr->op = TK_TRUTH;
107520 assert( pExpr->pLeft!=0 );
107521 nLeft = sqlite3ExprVectorSize(pExpr->pLeft);
107522 if( pExpr->op==TK_BETWEEN ){
107523 assert( ExprUseXList(pExpr) );
107524 nRight = sqlite3ExprVectorSize(pExpr->x.pList->a[0].pExpr);
107526 nRight = sqlite3ExprVectorSize(pExpr->x.pList->a[1].pExpr);
107529 assert( pExpr->pRight!=0 );
107530 nRight = sqlite3ExprVectorSize(pExpr->pRight);
107533 testcase( pExpr->op==TK_EQ );
107534 testcase( pExpr->op==TK_NE );
107535 testcase( pExpr->op==TK_LT );
107536 testcase( pExpr->op==TK_LE );
107537 testcase( pExpr->op==TK_GT );
107538 testcase( pExpr->op==TK_GE );
107539 testcase( pExpr->op==TK_IS );
107540 testcase( pExpr->op==TK_ISNOT );
107541 testcase( pExpr->op==TK_BETWEEN );
107543 sqlite3RecordErrorOffsetOfExpr(pParse->db, pExpr);
107641 if( sqlite3ExprCompare(0, pEList->a[i].pExpr, pE, -1)<2 ){
107715 pE = sqlite3ExprSkipCollateAndLikely(pItem->pExpr);
107755 if( pItem->pExpr==pE ){
107756 pItem->pExpr = pNew;
107758 Expr *pParent = pItem->pExpr;
107818 resolveAlias(pParse, pEList, pItem->u.x.iOrderByCol-1, pItem->pExpr,0);
107828 static int resolveRemoveWindowsCb(Walker *pWalker, Expr *pExpr){
107830 if( ExprHasProperty(pExpr, EP_WinFunc) ){
107831 Window *pWin = pExpr->y.pWin;
107841 static void windowRemoveExprFromSelect(Select *pSelect, Expr *pExpr){
107847 sqlite3WalkExpr(&sWalker, pExpr);
107888 Expr *pE = pItem->pExpr;
107920 if( sqlite3ExprCompare(0, pE, pSelect->pEList->a[j].pExpr, -1)==0 ){
108146 if( ExprHasProperty(pItem->pExpr, EP_Agg) ){
108227 Expr *pExpr /* The expression to be analyzed. */
108232 if( pExpr==0 ) return SQLITE_OK;
108241 w.pParse->nHeight += pExpr->nHeight;
108246 assert( pExpr!=0 );
108247 sqlite3WalkExprNN(&w, pExpr);
108249 w.pParse->nHeight -= pExpr->nHeight;
108255 ExprSetProperty(pExpr, pNC->ncFlags & (NC_HasAgg|NC_HasWin) );
108281 Expr *pExpr = pList->a[i].pExpr;
108282 if( pExpr==0 ) continue;
108284 w.pParse->nHeight += pExpr->nHeight;
108289 sqlite3WalkExprNN(&w, pExpr);
108291 w.pParse->nHeight -= pExpr->nHeight;
108298 ExprSetProperty(pExpr, pNC->ncFlags & (NC_HasAgg|NC_HasWin) );
108359 Expr *pExpr, /* Expression to resolve. May be NULL. */
108385 if( (rc = sqlite3ResolveExprNames(&sNC, pExpr))!=SQLITE_OK ) return rc;
108436 SQLITE_PRIVATE char sqlite3ExprAffinity(const Expr *pExpr){
108438 op = pExpr->op;
108440 if( op==TK_COLUMN || (op==TK_AGG_COLUMN && pExpr->y.pTab!=0) ){
108441 assert( ExprUseYTab(pExpr) );
108442 assert( pExpr->y.pTab!=0 );
108443 return sqlite3TableColumnAffinity(pExpr->y.pTab, pExpr->iColumn);
108446 assert( ExprUseXSelect(pExpr) );
108447 assert( pExpr->x.pSelect!=0 );
108448 assert( pExpr->x.pSelect->pEList!=0 );
108449 assert( pExpr->x.pSelect->pEList->a[0].pExpr!=0 );
108450 return sqlite3ExprAffinity(pExpr->x.pSelect->pEList->a[0].pExpr);
108454 assert( !ExprHasProperty(pExpr, EP_IntValue) );
108455 return sqlite3AffinityType(pExpr->u.zToken, 0);
108459 assert( pExpr->pLeft!=0 && ExprUseXSelect(pExpr->pLeft) );
108460 assert( pExpr->iColumn < pExpr->iTable );
108461 assert( pExpr->iColumn >= 0 );
108462 assert( pExpr->iTable==pExpr->pLeft->x.pSelect->pEList->nExpr );
108464 pExpr->pLeft->x.pSelect->pEList->a[pExpr->iColumn].pExpr
108468 assert( ExprUseXList(pExpr) );
108469 return sqlite3ExprAffinity(pExpr->x.pList->a[0].pExpr);
108471 if( ExprHasProperty(pExpr, EP_Skip|EP_IfNullRow) ){
108472 assert( pExpr->op==TK_COLLATE
108473 || pExpr->op==TK_IF_NULL_ROW
108474 || (pExpr->op==TK_REGISTER && pExpr->op2==TK_IF_NULL_ROW) );
108475 pExpr = pExpr->pLeft;
108476 op = pExpr->op;
108479 if( op!=TK_REGISTER || (op = pExpr->op2)==TK_REGISTER ) break;
108481 return pExpr->affExpr;
108494 SQLITE_PRIVATE int sqlite3ExprDataType(const Expr *pExpr){
108495 while( pExpr ){
108496 switch( pExpr->op ){
108500 pExpr = pExpr->pLeft;
108504 pExpr = 0;
108527 int aff = sqlite3ExprAffinity(pExpr);
108535 ExprList *pList = pExpr->x.pList;
108536 assert( ExprUseXList(pExpr) && pList!=0 );
108539 res |= sqlite3ExprDataType(pList->a[ii].pExpr);
108542 res |= sqlite3ExprDataType(pList->a[pList->nExpr-1].pExpr);
108564 Expr *pExpr, /* Add the "COLLATE" clause to this expression */
108571 pNew->pLeft = pExpr;
108573 pExpr = pNew;
108576 return pExpr;
108580 Expr *pExpr, /* Add the "COLLATE" clause to this expression */
108586 return sqlite3ExprAddCollateToken(pParse, pExpr, &s, 0);
108592 SQLITE_PRIVATE Expr *sqlite3ExprSkipCollate(Expr *pExpr){
108593 while( pExpr && ExprHasProperty(pExpr, EP_Skip) ){
108594 assert( pExpr->op==TK_COLLATE );
108595 pExpr = pExpr->pLeft;
108597 return pExpr;
108605 SQLITE_PRIVATE Expr *sqlite3ExprSkipCollateAndLikely(Expr *pExpr){
108606 while( pExpr && ExprHasProperty(pExpr, EP_Skip|EP_Unlikely) ){
108607 if( ExprHasProperty(pExpr, EP_Unlikely) ){
108608 assert( ExprUseXList(pExpr) );
108609 assert( pExpr->x.pList->nExpr>0 );
108610 assert( pExpr->op==TK_FUNCTION );
108611 pExpr = pExpr->x.pList->a[0].pExpr;
108613 assert( pExpr->op==TK_COLLATE );
108614 pExpr = pExpr->pLeft;
108617 return pExpr;
108634 SQLITE_PRIVATE CollSeq *sqlite3ExprCollSeq(Parse *pParse, const Expr *pExpr){
108637 const Expr *p = pExpr;
108659 p = p->x.pList->a[0].pExpr;
108677 if( ExprHasProperty(p->x.pList->a[i].pExpr, EP_Collate) ){
108678 pNext = p->x.pList->a[i].pExpr;
108705 SQLITE_PRIVATE CollSeq *sqlite3ExprNNCollSeq(Parse *pParse, const Expr *pExpr){
108706 CollSeq *p = sqlite3ExprCollSeq(pParse, pExpr);
108726 SQLITE_PRIVATE char sqlite3CompareAffinity(const Expr *pExpr, char aff2){
108727 char aff1 = sqlite3ExprAffinity(pExpr);
108748 static char comparisonAffinity(const Expr *pExpr){
108750 assert( pExpr->op==TK_EQ || pExpr->op==TK_IN || pExpr->op==TK_LT ||
108751 pExpr->op==TK_GT || pExpr->op==TK_GE || pExpr->op==TK_LE ||
108752 pExpr->op==TK_NE || pExpr->op==TK_IS || pExpr->op==TK_ISNOT );
108753 assert( pExpr->pLeft );
108754 aff = sqlite3ExprAffinity(pExpr->pLeft);
108755 if( pExpr->pRight ){
108756 aff = sqlite3CompareAffinity(pExpr->pRight, aff);
108757 }else if( ExprUseXSelect(pExpr) ){
108758 aff = sqlite3CompareAffinity(pExpr->x.pSelect->pEList->a[0].pExpr, aff);
108771 SQLITE_PRIVATE int sqlite3IndexAffinityOk(const Expr *pExpr, char idx_affinity){
108772 char aff = comparisonAffinity(pExpr);
108883 SQLITE_PRIVATE int sqlite3ExprIsVector(const Expr *pExpr){
108884 return sqlite3ExprVectorSize(pExpr)>1;
108893 SQLITE_PRIVATE int sqlite3ExprVectorSize(const Expr *pExpr){
108894 u8 op = pExpr->op;
108895 if( op==TK_REGISTER ) op = pExpr->op2;
108897 assert( ExprUseXList(pExpr) );
108898 return pExpr->x.pList->nExpr;
108900 assert( ExprUseXSelect(pExpr) );
108901 return pExpr->x.pSelect->pEList->nExpr;
108928 return pVector->x.pSelect->pEList->a[i].pExpr;
108931 return pVector->x.pList->a[i].pExpr;
108994 ppVector = &pVector->x.pList->a[iField].pExpr;
109015 static int exprCodeSubselect(Parse *pParse, Expr *pExpr){
109018 if( pExpr->op==TK_SELECT ){
109019 reg = sqlite3CodeSubselect(pParse, pExpr);
109059 *ppExpr = pVector->x.pSelect->pEList->a[iField].pExpr;
109064 *ppExpr = pVector->x.pList->a[iField].pExpr;
109083 Expr *pExpr, /* The comparison operation */
109089 Expr *pLeft = pExpr->pLeft;
109090 Expr *pRight = pExpr->pRight;
109098 int isCommuted = ExprHasProperty(pExpr,EP_Commuted);
109100 assert( !ExprHasVVAProperty(pExpr,EP_Immutable) );
109106 assert( pExpr->op==TK_EQ || pExpr->op==TK_NE
109107 || pExpr->op==TK_IS || pExpr->op==TK_ISNOT
109108 || pExpr->op==TK_LT || pExpr->op==TK_GT
109109 || pExpr->op==TK_LE || pExpr->op==TK_GE
109111 assert( pExpr->op==op || (pExpr->op==TK_IS && op==TK_EQ)
109112 || (pExpr->op==TK_ISNOT && op==TK_NE) );
109113 assert( p5==0 || pExpr->op!=op );
109114 assert( p5==SQLITE_NULLEQ || pExpr->op==op );
109208 heightOfExpr(p->a[i].pExpr, pnHeight);
109288 SQLITE_PRIVATE void sqlite3ExprSetErrorOffset(Expr *pExpr, int iOfst){
109289 if( pExpr==0 ) return;
109290 if( NEVER(ExprUseWJoin(pExpr)) ) return;
109291 pExpr->w.iOfst = iOfst;
109445 SQLITE_PRIVATE void sqlite3PExprAddSelect(Parse *pParse, Expr *pExpr, Select *pSelect){
109446 if( pExpr ){
109447 pExpr->x.pSelect = pSelect;
109448 ExprSetProperty(pExpr, EP_xIsSelect|EP_Subquery);
109449 sqlite3ExprSetHeightAndFlags(pParse, pExpr);
109481 Expr *pExpr = pEList->a[ii].pExpr;
109483 if( pExpr->op==TK_VECTOR ){
109484 assert( ExprUseXList(pExpr) );
109485 nExprElem = pExpr->x.pList->nExpr;
109495 assert( ExprUseXList(pExpr) );
109496 pSel = sqlite3SelectNew(pParse, pExpr->x.pList, 0, 0, 0, 0, 0, SF_Values,0);
109497 pExpr->x.pList = 0;
109598 Expr *pExpr, /* The function call to which ORDER BY is to be added */
109607 if( pExpr==0 ){
109612 assert( pExpr->op==TK_FUNCTION );
109613 assert( pExpr->pLeft==0 );
109614 assert( ExprUseXList(pExpr) );
109615 if( pExpr->x.pList==0 || NEVER(pExpr->x.pList->nExpr==0) ){
109620 if( IsWindowFunc(pExpr) ){
109621 sqlite3ExprOrderByAggregateError(pParse, pExpr);
109633 pExpr->pLeft = pOB;
109650 const Expr *pExpr, /* The function invocation */
109655 if( ExprHasProperty(pExpr, EP_FromDDL) ){
109666 sqlite3ErrorMsg(pParse, "unsafe use of %#T()", pExpr);
109687 SQLITE_PRIVATE void sqlite3ExprAssignVarNumber(Parse *pParse, Expr *pExpr, u32 n){
109692 if( pExpr==0 ) return;
109693 assert( !ExprHasProperty(pExpr, EP_IntValue|EP_Reduced|EP_TokenOnly) );
109694 z = pExpr->u.zToken;
109722 sqlite3RecordErrorOffsetOfExpr(pParse->db, pExpr);
109747 pExpr->iColumn = x;
109750 sqlite3RecordErrorOffsetOfExpr(pParse->db, pExpr);
109825 SQLITE_PRIVATE void sqlite3ExprDeferredDelete(Parse *pParse, Expr *pExpr){
109826 sqlite3ParserAddCleanup(pParse, sqlite3ExprDeleteGeneric, pExpr);
110141 static int gatherSelectWindowsCallback(Walker *pWalker, Expr *pExpr){
110142 if( pExpr->op==TK_FUNCTION && ExprHasProperty(pExpr, EP_WinFunc) ){
110144 Window *pWin = pExpr->y.pWin;
110146 assert( IsWindowFunc(pExpr) );
110204 Expr *pOldExpr = pOldItem->pExpr;
110206 pItem->pExpr = sqlite3ExprDup(db, pOldExpr, flags);
110209 && (pNewExpr = pItem->pExpr)!=0
110376 Expr *pExpr /* Expression to be appended. Might be NULL */
110383 sqlite3ExprDelete(db, pExpr);
110390 pItem->pExpr = pExpr;
110396 Expr *pExpr /* Expression to be appended. Might be NULL */
110405 sqlite3ExprDelete(db, pExpr);
110412 pItem->pExpr = pExpr;
110418 Expr *pExpr /* Expression to be appended. Might be NULL */
110422 return sqlite3ExprListAppendNew(pParse->db,pExpr);
110425 return sqlite3ExprListAppendGrow(pParse->db,pList,pExpr);
110429 pItem->pExpr = pExpr;
110448 Expr *pExpr /* Vector expression to be appended. Might be NULL */
110457 if( pExpr==0 ) goto vector_append_error;
110464 if( pExpr->op!=TK_SELECT && pColumns->nId!=(n=sqlite3ExprVectorSize(pExpr)) ){
110471 Expr *pSubExpr = sqlite3ExprForVectorField(pParse, pExpr, i, pColumns->nId);
110482 if( !db->mallocFailed && pExpr->op==TK_SELECT && ALWAYS(pList!=0) ){
110483 Expr *pFirst = pList->a[iFirst].pExpr;
110489 pFirst->pRight = pExpr;
110490 pExpr = 0;
110498 sqlite3ExprUnmapAndDelete(pParse, pExpr);
110623 sqlite3ExprDelete(db, pItem->pExpr);
110645 Expr *pExpr = pList->a[i].pExpr;
110646 assert( pExpr!=0 );
110647 m |= pExpr->flags;
110685 SQLITE_PRIVATE int sqlite3ExprIdToTrueFalse(Expr *pExpr){
110687 assert( pExpr->op==TK_ID || pExpr->op==TK_STRING );
110688 if( !ExprHasProperty(pExpr, EP_Quoted|EP_IntValue)
110689 && (v = sqlite3IsTrueOrFalse(pExpr->u.zToken))!=0
110691 pExpr->op = TK_TRUEFALSE;
110692 ExprSetProperty(pExpr, v);
110702 SQLITE_PRIVATE int sqlite3ExprTruthValue(const Expr *pExpr){
110703 pExpr = sqlite3ExprSkipCollateAndLikely((Expr*)pExpr);
110704 assert( pExpr->op==TK_TRUEFALSE );
110705 assert( !ExprHasProperty(pExpr, EP_IntValue) );
110706 assert( sqlite3StrICmp(pExpr->u.zToken,"true")==0
110707 || sqlite3StrICmp(pExpr->u.zToken,"false")==0 );
110708 return pExpr->u.zToken[4]==0;
110724 SQLITE_PRIVATE Expr *sqlite3ExprSimplifiedAndOr(Expr *pExpr){
110725 assert( pExpr!=0 );
110726 if( pExpr->op==TK_AND || pExpr->op==TK_OR ){
110727 Expr *pRight = sqlite3ExprSimplifiedAndOr(pExpr->pRight);
110728 Expr *pLeft = sqlite3ExprSimplifiedAndOr(pExpr->pLeft);
110730 pExpr = pExpr->op==TK_AND ? pRight : pLeft;
110732 pExpr = pExpr->op==TK_AND ? pLeft : pRight;
110735 return pExpr;
110765 static int exprNodeIsConstant(Walker *pWalker, Expr *pExpr){
110770 if( pWalker->eCode==2 && ExprHasProperty(pExpr, EP_OuterON) ){
110775 switch( pExpr->op ){
110780 if( (pWalker->eCode>=4 || ExprHasProperty(pExpr,EP_ConstFunc))
110781 && !ExprHasProperty(pExpr, EP_WinFunc)
110783 if( pWalker->eCode==5 ) ExprSetProperty(pExpr, EP_FromDDL);
110792 if( sqlite3ExprIdToTrueFalse(pExpr) ){
110799 testcase( pExpr->op==TK_ID );
110800 testcase( pExpr->op==TK_COLUMN );
110801 testcase( pExpr->op==TK_AGG_FUNCTION );
110802 testcase( pExpr->op==TK_AGG_COLUMN );
110803 if( ExprHasProperty(pExpr, EP_FixedCol) && pWalker->eCode!=2 ){
110806 if( pWalker->eCode==3 && pExpr->iTable==pWalker->u.iCur ){
110813 testcase( pExpr->op==TK_REGISTER );
110814 testcase( pExpr->op==TK_IF_NULL_ROW );
110815 testcase( pExpr->op==TK_DOT );
110823 pExpr->op = TK_NULL;
110832 testcase( pExpr->op==TK_SELECT ); /* sqlite3SelectWalkFail() disallows */
110833 testcase( pExpr->op==TK_EXISTS ); /* sqlite3SelectWalkFail() disallows */
110931 Expr *pExpr, /* The constraint */
110940 if( !ExprHasProperty(pExpr, EP_OuterON) ) return 0; /* rule (4a) */
110941 if( pExpr->w.iJoin!=pSrc->iCursor ) return 0; /* rule (4b) */
110943 if( ExprHasProperty(pExpr, EP_OuterON) ) return 0; /* rule (5) */
110945 if( ExprHasProperty(pExpr, EP_OuterON|EP_InnerON) /* (6a) */
110950 if( pExpr->w.iJoin==pSrcList->a[jj].iCursor ){
110958 return sqlite3ExprIsTableConstant(pExpr, pSrc->iCursor); /* rules (1), (2) */
110965 static int exprNodeIsConstantOrGroupBy(Walker *pWalker, Expr *pExpr){
110972 Expr *p = pGroupBy->a[i].pExpr;
110973 if( sqlite3ExprCompare(0, pExpr, p, -1)<2 ){
110982 if( ExprUseXSelect(pExpr) ){
110987 return exprNodeIsConstant(pWalker, pExpr);
111256 Expr *pRes = pEList->a[i].pExpr;
111411 if( sqlite3ExprCanBeNull(pEList->a[i].pExpr) ) break;
111429 assert( p->pEList->a[0].pExpr!=0 ); /* Because of isCandidateForInOpt(p) */
111440 if( nExpr==1 && pEList->a[0].pExpr->iColumn<0 ){
111461 int iCol = pEList->a[i].pExpr->iColumn;
111504 Expr *pRhs = pEList->a[i].pExpr;
111609 static char *exprINAffinity(Parse *pParse, const Expr *pExpr){
111610 Expr *pLeft = pExpr->pLeft;
111612 Select *pSelect = ExprUseXSelect(pExpr) ? pExpr->x.pSelect : 0;
111615 assert( pExpr->op==TK_IN );
111623 zRet[i] = sqlite3CompareAffinity(pSelect->pEList->a[i].pExpr, a);
111660 SQLITE_PRIVATE void sqlite3VectorErrorMsg(Parse *pParse, Expr *pExpr){
111662 if( ExprUseXSelect(pExpr) ){
111663 sqlite3SubselectError(pParse, pExpr->x.pSelect->pEList->nExpr, 1);
111696 Expr *pExpr, /* The IN operator */
111719 if( !ExprHasProperty(pExpr, EP_VarSelect) && pParse->iSelfTab==0 ){
111724 if( ExprHasProperty(pExpr, EP_Subrtn) ){
111726 if( ExprUseXSelect(pExpr) ){
111728 pExpr->x.pSelect->selId));
111730 assert( ExprUseYSub(pExpr) );
111731 sqlite3VdbeAddOp2(v, OP_Gosub, pExpr->y.sub.regReturn,
111732 pExpr->y.sub.iAddr);
111733 assert( iTab!=pExpr->iTable );
111734 sqlite3VdbeAddOp2(v, OP_OpenDup, iTab, pExpr->iTable);
111740 assert( !ExprUseYWin(pExpr) );
111741 ExprSetProperty(pExpr, EP_Subrtn);
111742 assert( !ExprHasProperty(pExpr, EP_TokenOnly|EP_Reduced) );
111743 pExpr->y.sub.regReturn = ++pParse->nMem;
111744 pExpr->y.sub.iAddr =
111745 sqlite3VdbeAddOp2(v, OP_BeginSubrtn, 0, pExpr->y.sub.regReturn) + 1;
111751 pLeft = pExpr->pLeft;
111757 pExpr->iTable = iTab;
111758 addr = sqlite3VdbeAddOp2(v, OP_OpenEphemeral, pExpr->iTable, nVal);
111760 if( ExprUseXSelect(pExpr) ){
111761 VdbeComment((v, "Result of SELECT %u", pExpr->x.pSelect->selId));
111768 if( ExprUseXSelect(pExpr) ){
111774 Select *pSelect = pExpr->x.pSelect;
111788 dest.zAffSdst = exprINAffinity(pParse, pExpr);
111807 pParse, p, pEList->a[i].pExpr
111811 }else if( ALWAYS(pExpr->x.pList!=0) ){
111821 ExprList *pList = pExpr->x.pList;
111832 pKeyInfo->aColl[0] = sqlite3ExprCollSeq(pParse, pExpr->pLeft);
111839 Expr *pE2 = pItem->pExpr;
111849 ExprClearProperty(pExpr, EP_Subrtn);
111868 assert( ExprUseYSub(pExpr) );
111869 assert( sqlite3VdbeGetOp(v,pExpr->y.sub.iAddr-1)->opcode==OP_BeginSubrtn
111871 sqlite3VdbeAddOp3(v, OP_Return, pExpr->y.sub.regReturn,
111872 pExpr->y.sub.iAddr, 1);
111894 SQLITE_PRIVATE int sqlite3CodeSubselect(Parse *pParse, Expr *pExpr){
111908 testcase( pExpr->op==TK_EXISTS );
111909 testcase( pExpr->op==TK_SELECT );
111910 assert( pExpr->op==TK_EXISTS || pExpr->op==TK_SELECT );
111911 assert( ExprUseXSelect(pExpr) );
111912 pSel = pExpr->x.pSelect;
111916 if( ExprHasProperty(pExpr, EP_Subrtn) ){
111918 assert( ExprUseYSub(pExpr) );
111919 sqlite3VdbeAddOp2(v, OP_Gosub, pExpr->y.sub.regReturn,
111920 pExpr->y.sub.iAddr);
111921 return pExpr->iTable;
111925 assert( !ExprUseYWin(pExpr) );
111926 assert( !ExprHasProperty(pExpr, EP_Reduced|EP_TokenOnly) );
111927 ExprSetProperty(pExpr, EP_Subrtn);
111928 pExpr->y.sub.regReturn = ++pParse->nMem;
111929 pExpr->y.sub.iAddr =
111930 sqlite3VdbeAddOp2(v, OP_BeginSubrtn, 0, pExpr->y.sub.regReturn) + 1;
111942 if( !ExprHasProperty(pExpr, EP_VarSelect) ){
111959 nReg = pExpr->op==TK_SELECT ? pSel->pEList->nExpr : 1;
111962 if( pExpr->op==TK_SELECT ){
111992 pExpr->op2 = pExpr->op;
111993 pExpr->op = TK_ERROR;
111996 pExpr->iTable = rReg = dest.iSDParm;
111997 ExprSetVVAProperty(pExpr, EP_NoReduce);
112004 assert( ExprUseYSub(pExpr) );
112005 assert( sqlite3VdbeGetOp(v,pExpr->y.sub.iAddr-1)->opcode==OP_BeginSubrtn
112007 sqlite3VdbeAddOp3(v, OP_Return, pExpr->y.sub.regReturn,
112008 pExpr->y.sub.iAddr, 1);
112065 Expr *pExpr, /* The IN expression */
112088 assert( !ExprHasVVAProperty(pExpr,EP_Immutable) );
112089 pLeft = pExpr->pLeft;
112090 if( sqlite3ExprCheckIN(pParse, pExpr) ) return;
112091 zAff = exprINAffinity(pParse, pExpr);
112092 nVector = sqlite3ExprVectorSize(pExpr->pLeft);
112105 eType = sqlite3FindInIndex(pParse, pExpr,
112164 assert( ExprUseXList(pExpr) );
112165 pList = pExpr->x.pList;
112166 pColl = sqlite3ExprCollSeq(pParse, pExpr->pLeft);
112172 r2 = sqlite3ExprCodeTemp(pParse, pList->a[ii].pExpr, ®ToFree);
112173 if( regCkNull && sqlite3ExprCanBeNull(pList->a[ii].pExpr) ){
112215 Expr *p = sqlite3VectorFieldSubexpr(pExpr->pLeft, i);
112339 static void codeInteger(Parse *pParse, Expr *pExpr, int negFlag, int iMem){
112341 if( pExpr->flags & EP_IntValue ){
112342 int i = pExpr->u.iValue;
112349 const char *z = pExpr->u.zToken;
112354 sqlite3ErrorMsg(pParse, "oversized integer: %s%#T", negFlag?"-":"",pExpr);
112359 negFlag?"-":"",pExpr);
112389 sqlite3ExprCodeCopy(pParse, pIdx->aColExpr->a[iIdxCol].pExpr, regOut);
112520 static void exprToRegister(Expr *pExpr, int iReg){
112521 Expr *p = sqlite3ExprSkipCollateAndLikely(pExpr);
112558 sqlite3ExprCodeFactorable(pParse, p->x.pList->a[i].pExpr, i+iResult);
112600 sqlite3ExprCode(pParse, pFarg->a[0].pExpr, target);
112604 sqlite3ExprCode(pParse, pFarg->a[i].pExpr, target);
112619 Expr *pArg = pFarg->a[0].pExpr;
112633 target = sqlite3ExprCodeTarget(pParse, pFarg->a[0].pExpr, target);
112646 sqlite3ExprCompare(0,pFarg->a[0].pExpr, pFarg->a[1].pExpr,-1),
112655 sqlite3ExprImpliesExpr(pParse,pFarg->a[0].pExpr, pFarg->a[1].pExpr,-1),
112664 pA1 = pFarg->a[1].pExpr;
112667 sqlite3ExprImpliesNonNullRow(pFarg->a[0].pExpr,pA1->iTable,1),
112684 aff = sqlite3ExprAffinity(pFarg->a[0].pExpr);
112704 Expr *pExpr, /* The expression to potentially bypass */
112717 if( sqlite3ExprCompare(0, pExpr, p->pExpr, iDataCur)!=0 ) continue;
112719 exprAff = sqlite3ExprAffinity(pExpr);
112742 sqlite3ExprCode(pParse, pExpr, target);
112765 static int exprPartidxExprLookup(Parse *pParse, Expr *pExpr, int iTarget){
112768 if( pExpr->iColumn==p->iIdxCol && pExpr->iTable==p->iDataCur ){
112776 ret = sqlite3ExprCodeTarget(pParse, p->pExpr, iTarget);
112801 SQLITE_PRIVATE int sqlite3ExprCodeTarget(Parse *pParse, Expr *pExpr, int target){
112815 if( pExpr==0 ){
112818 && !ExprHasProperty(pExpr, EP_Leaf)
112819 && (r1 = sqlite3IndexedExprLookup(pParse, pExpr, target))>=0
112823 assert( !ExprHasVVAProperty(pExpr,EP_Immutable) );
112824 op = pExpr->op;
112829 AggInfo *pAggInfo = pExpr->pAggInfo;
112832 assert( pExpr->iAgg>=0 );
112833 if( pExpr->iAgg>=pAggInfo->nColumn ){
112845 pCol = &pAggInfo->aCol[pExpr->iAgg];
112847 return AggInfoColumnReg(pAggInfo, pExpr->iAgg);
112864 }else if( pExpr->y.pTab==0 ){
112867 sqlite3VdbeAddOp3(v, OP_Column, pExpr->iTable, pExpr->iColumn, target);
112874 int iTab = pExpr->iTable;
112876 if( ExprHasProperty(pExpr, EP_FixedCol) ){
112884 iReg = sqlite3ExprCodeTarget(pParse, pExpr->pLeft,target);
112885 assert( ExprUseYTab(pExpr) );
112886 assert( pExpr->y.pTab!=0 );
112887 aff = sqlite3TableColumnAffinity(pExpr->y.pTab, pExpr->iColumn);
112908 int iCol = pExpr->iColumn;
112909 assert( ExprUseYTab(pExpr) );
112910 pTab = pExpr->y.pTab;
112949 && 0!=(r1 = exprPartidxExprLookup(pParse, pExpr, target))
112953 assert( ExprUseYTab(pExpr) );
112954 assert( pExpr->y.pTab!=0 );
112955 iReg = sqlite3ExprCodeGetColumn(pParse, pExpr->y.pTab,
112956 pExpr->iColumn, iTab, target,
112957 pExpr->op2);
112961 codeInteger(pParse, pExpr, 0, target);
112965 sqlite3VdbeAddOp2(v, OP_Integer, sqlite3ExprTruthValue(pExpr), target);
112970 assert( !ExprHasProperty(pExpr, EP_IntValue) );
112971 codeReal(v, pExpr->u.zToken, 0, target);
112976 assert( !ExprHasProperty(pExpr, EP_IntValue) );
112977 sqlite3VdbeLoadString(v, target, pExpr->u.zToken);
112994 assert( !ExprHasProperty(pExpr, EP_IntValue) );
112995 assert( pExpr->u.zToken[0]=='x' || pExpr->u.zToken[0]=='X' );
112996 assert( pExpr->u.zToken[1]=='\'' );
112997 z = &pExpr->u.zToken[2];
113006 assert( !ExprHasProperty(pExpr, EP_IntValue) );
113007 assert( pExpr->u.zToken!=0 );
113008 assert( pExpr->u.zToken[0]!=0 );
113009 sqlite3VdbeAddOp2(v, OP_Variable, pExpr->iColumn, target);
113010 if( pExpr->u.zToken[1]!=0 ){
113011 const char *z = sqlite3VListNumToName(pParse->pVList, pExpr->iColumn);
113012 assert( pExpr->u.zToken[0]=='?' || (z && !strcmp(pExpr->u.zToken, z)) );
113019 return pExpr->iTable;
113024 sqlite3ExprCode(pParse, pExpr->pLeft, target);
113026 assert( !ExprHasProperty(pExpr, EP_IntValue) );
113028 sqlite3AffinityType(pExpr->u.zToken, 0));
113043 Expr *pLeft = pExpr->pLeft;
113045 codeVectorCompare(pParse, pExpr, target, op, p5);
113048 r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, ®Free2);
113050 codeCompare(pParse, pLeft, pExpr->pRight, op, r1, r2,
113052 ExprHasProperty(pExpr,EP_Commuted));
113092 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1);
113093 r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, ®Free2);
113100 Expr *pLeft = pExpr->pLeft;
113107 assert( !ExprHasProperty(pExpr, EP_IntValue) );
113117 r2 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free2);
113127 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1);
113135 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1);
113137 isTrue = sqlite3ExprTruthValue(pExpr->pRight);
113138 bNormal = pExpr->op2==TK_IS;
113150 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1);
113160 AggInfo *pInfo = pExpr->pAggInfo;
113162 || NEVER(pExpr->iAgg<0)
113163 || NEVER(pExpr->iAgg>=pInfo->nFunc)
113165 assert( !ExprHasProperty(pExpr, EP_IntValue) );
113166 sqlite3ErrorMsg(pParse, "misuse of aggregate: %#T()", pExpr);
113168 return AggInfoFuncReg(pInfo, pExpr->iAgg);
113184 if( ExprHasProperty(pExpr, EP_WinFunc) ){
113185 return pExpr->y.pWin->regResult;
113189 if( ConstFactorOk(pParse) && sqlite3ExprIsConstantNotJoin(pExpr) ){
113192 return sqlite3ExprCodeRunJustOnce(pParse, pExpr, -1);
113194 assert( !ExprHasProperty(pExpr, EP_TokenOnly) );
113195 assert( ExprUseXList(pExpr) );
113196 pFarg = pExpr->x.pList;
113198 assert( !ExprHasProperty(pExpr, EP_IntValue) );
113199 zId = pExpr->u.zToken;
113207 sqlite3ErrorMsg(pParse, "unknown function: %#T()", pExpr);
113216 sqlite3ExprFunctionUsable(pParse, pExpr, pDef);
113220 if( i<32 && sqlite3ExprIsConstant(pFarg->a[i].pExpr) ){
113225 pColl = sqlite3ExprCollSeq(pParse, pFarg->a[i].pExpr);
113244 assert( pFarg->a[0].pExpr!=0 );
113245 exprOp = pFarg->a[0].pExpr->op;
113254 pFarg->a[0].pExpr->op2 = pDef->funcFlags & OPFLAG_BYTELENARG;
113275 if( nFarg>=2 && ExprHasProperty(pExpr, EP_InfixFunc) ){
113276 pDef = sqlite3VtabOverloadFunction(db, pDef, nFarg, pFarg->a[1].pExpr);
113278 pDef = sqlite3VtabOverloadFunction(db, pDef, nFarg, pFarg->a[0].pExpr);
113286 pDef, pExpr->op2);
113305 && ALWAYS( ExprUseXSelect(pExpr) )
113306 && (nCol = pExpr->x.pSelect->pEList->nExpr)!=1
113310 return sqlite3CodeSubselect(pParse, pExpr);
113316 Expr *pLeft = pExpr->pLeft;
113323 if( pExpr->iTable!=n ){
113325 pExpr->iTable, n);
113327 return pLeft->iTable + pExpr->iColumn;
113333 sqlite3ExprCodeIN(pParse, pExpr, destIfFalse, destIfNull);
113355 exprCodeBetween(pParse, pExpr, target, 0, 0);
113359 if( !ExprHasProperty(pExpr, EP_Collate) ){
113365 assert( pExpr->pLeft );
113366 sqlite3ExprCode(pParse, pExpr->pLeft, target);
113370 pExpr = pExpr->pLeft;
113376 pExpr = pExpr->pLeft;
113410 assert( ExprUseYTab(pExpr) );
113411 pTab = pExpr->y.pTab;
113412 iCol = pExpr->iColumn;
113413 p1 = pExpr->iTable * (pTab->nCol+1) + 1
113416 assert( pExpr->iTable==0 || pExpr->iTable==1 );
113423 (pExpr->iTable ? "new" : "old"),
113424 (pExpr->iColumn<0 ? "rowid" : pExpr->y.pTab->aCol[iCol].zCnName)
113454 AggInfo *pAggInfo = pExpr->pAggInfo;
113456 assert( pExpr->iAgg>=0 && pExpr->iAgg<pAggInfo->nColumn );
113458 inReg = AggInfoColumnReg(pAggInfo, pExpr->iAgg);
113461 if( pExpr->pAggInfo->useSortingIdx ){
113463 pAggInfo->aCol[pExpr->iAgg].iSorterColumn,
113469 addrINR = sqlite3VdbeAddOp3(v, OP_IfNullRow, pExpr->iTable, 0, target);
113478 sqlite3ExprCode(pParse, pExpr->pLeft, target);
113519 assert( ExprUseXList(pExpr) && pExpr->x.pList!=0 );
113520 assert(pExpr->x.pList->nExpr > 0);
113521 pEList = pExpr->x.pList;
113525 if( (pX = pExpr->pLeft)!=0 ){
113547 opCompare.pRight = aListelem[i].pExpr;
113549 pTest = aListelem[i].pExpr;
113554 testcase( aListelem[i+1].pExpr->op==TK_COLUMN );
113555 sqlite3ExprCode(pParse, aListelem[i+1].pExpr, target);
113560 sqlite3ExprCode(pParse, pEList->a[nExpr-1].pExpr, target);
113571 assert( pExpr->affExpr==OE_Rollback
113572 || pExpr->affExpr==OE_Abort
113573 || pExpr->affExpr==OE_Fail
113574 || pExpr->affExpr==OE_Ignore
113581 if( pExpr->affExpr==OE_Abort ){
113584 assert( !ExprHasProperty(pExpr, EP_IntValue) );
113585 if( pExpr->affExpr==OE_Ignore ){
113587 v, OP_Halt, SQLITE_OK, OE_Ignore, 0, pExpr->u.zToken,0);
113592 pExpr->affExpr, pExpr->u.zToken, 0, 0);
113623 Expr *pExpr, /* The expression to code when the VDBE initializes */
113635 && sqlite3ExprCompare(0,pItem->pExpr,pExpr,-1)==0
113641 pExpr = sqlite3ExprDup(pParse->db, pExpr, 0);
113642 if( pExpr!=0 && ExprHasProperty(pExpr, EP_HasFunc) ){
113650 sqlite3ExprCode(pParse, pExpr, regDest);
113653 sqlite3ExprDelete(pParse->db, pExpr);
113656 p = sqlite3ExprListAppend(pParse, p, pExpr);
113681 SQLITE_PRIVATE int sqlite3ExprCodeTemp(Parse *pParse, Expr *pExpr, int *pReg){
113683 pExpr = sqlite3ExprSkipCollateAndLikely(pExpr);
113685 && ALWAYS(pExpr!=0)
113686 && pExpr->op!=TK_REGISTER
113687 && sqlite3ExprIsConstantNotJoin(pExpr)
113690 r2 = sqlite3ExprCodeRunJustOnce(pParse, pExpr, -1);
113693 r2 = sqlite3ExprCodeTarget(pParse, pExpr, r1);
113709 SQLITE_PRIVATE void sqlite3ExprCode(Parse *pParse, Expr *pExpr, int target){
113712 assert( pExpr==0 || !ExprHasVVAProperty(pExpr,EP_Immutable) );
113716 inReg = sqlite3ExprCodeTarget(pParse, pExpr, target);
113719 Expr *pX = sqlite3ExprSkipCollateAndLikely(pExpr);
113720 testcase( pX!=pExpr );
113737 SQLITE_PRIVATE void sqlite3ExprCodeCopy(Parse *pParse, Expr *pExpr, int target){
113739 pExpr = sqlite3ExprDup(db, pExpr, 0);
113740 if( !db->mallocFailed ) sqlite3ExprCode(pParse, pExpr, target);
113741 sqlite3ExprDelete(db, pExpr);
113750 SQLITE_PRIVATE void sqlite3ExprCodeFactorable(Parse *pParse, Expr *pExpr, int target){
113751 if( pParse->okConstFactor && sqlite3ExprIsConstantNotJoin(pExpr) ){
113752 sqlite3ExprCodeRunJustOnce(pParse, pExpr, target);
113754 sqlite3ExprCodeCopy(pParse, pExpr, target);
113795 Expr *pExpr = pItem->pExpr;
113810 && sqlite3ExprIsConstantNotJoin(pExpr)
113812 sqlite3ExprCodeRunJustOnce(pParse, pExpr, target+i);
113814 int inReg = sqlite3ExprCodeTarget(pParse, pExpr, target+i);
113855 Expr *pExpr, /* The BETWEEN expression */
113871 assert( ExprUseXList(pExpr) );
113872 pDel = sqlite3ExprDup(db, pExpr->pLeft, 0);
113879 compLeft.pRight = pExpr->x.pList->a[0].pExpr;
113882 compRight.pRight = pExpr->x.pList->a[1].pExpr;
113925 SQLITE_PRIVATE void sqlite3ExprIfTrue(Parse *pParse, Expr *pExpr, int dest, int jumpIfNull){
113934 if( NEVER(pExpr==0) ) return; /* No way this can happen */
113935 assert( !ExprHasVVAProperty(pExpr, EP_Immutable) );
113936 op = pExpr->op;
113940 Expr *pAlt = sqlite3ExprSimplifiedAndOr(pExpr);
113941 if( pAlt!=pExpr ){
113946 sqlite3ExprIfFalse(pParse, pExpr->pLeft, d2,
113948 sqlite3ExprIfTrue(pParse, pExpr->pRight, dest, jumpIfNull);
113952 sqlite3ExprIfTrue(pParse, pExpr->pLeft, dest, jumpIfNull);
113953 sqlite3ExprIfTrue(pParse, pExpr->pRight, dest, jumpIfNull);
113959 sqlite3ExprIfFalse(pParse, pExpr->pLeft, dest, jumpIfNull);
113966 isNot = pExpr->op2==TK_ISNOT;
113967 isTrue = sqlite3ExprTruthValue(pExpr->pRight);
113971 sqlite3ExprIfTrue(pParse, pExpr->pLeft, dest,
113974 sqlite3ExprIfFalse(pParse, pExpr->pLeft, dest,
113992 if( sqlite3ExprIsVector(pExpr->pLeft) ) goto default_expr;
113994 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1);
113995 r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, ®Free2);
113996 codeCompare(pParse, pExpr->pLeft, pExpr->pRight, op,
113997 r1, r2, dest, jumpIfNull, ExprHasProperty(pExpr,EP_Commuted));
114016 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1);
114026 exprCodeBetween(pParse, pExpr, dest, sqlite3ExprIfTrue, jumpIfNull);
114033 sqlite3ExprCodeIN(pParse, pExpr, destIfFalse, destIfNull);
114041 if( ExprAlwaysTrue(pExpr) ){
114043 }else if( ExprAlwaysFalse(pExpr) ){
114046 r1 = sqlite3ExprCodeTemp(pParse, pExpr, ®Free1);
114068 SQLITE_PRIVATE void sqlite3ExprIfFalse(Parse *pParse, Expr *pExpr, int dest, int jumpIfNull){
114077 if( pExpr==0 ) return;
114078 assert( !ExprHasVVAProperty(pExpr,EP_Immutable) );
114098 op = ((pExpr->op+(TK_ISNULL&1))^1)-(TK_ISNULL&1);
114102 assert( pExpr->op!=TK_ISNULL || op==OP_NotNull );
114103 assert( pExpr->op!=TK_NOTNULL || op==OP_IsNull );
114104 assert( pExpr->op!=TK_NE || op==OP_Eq );
114105 assert( pExpr->op!=TK_EQ || op==OP_Ne );
114106 assert( pExpr->op!=TK_LT || op==OP_Ge );
114107 assert( pExpr->op!=TK_LE || op==OP_Gt );
114108 assert( pExpr->op!=TK_GT || op==OP_Le );
114109 assert( pExpr->op!=TK_GE || op==OP_Lt );
114111 switch( pExpr->op ){
114114 Expr *pAlt = sqlite3ExprSimplifiedAndOr(pExpr);
114115 if( pAlt!=pExpr ){
114117 }else if( pExpr->op==TK_AND ){
114119 sqlite3ExprIfFalse(pParse, pExpr->pLeft, dest, jumpIfNull);
114120 sqlite3ExprIfFalse(pParse, pExpr->pRight, dest, jumpIfNull);
114124 sqlite3ExprIfTrue(pParse, pExpr->pLeft, d2,
114126 sqlite3ExprIfFalse(pParse, pExpr->pRight, dest, jumpIfNull);
114133 sqlite3ExprIfTrue(pParse, pExpr->pLeft, dest, jumpIfNull);
114140 isNot = pExpr->op2==TK_ISNOT;
114141 isTrue = sqlite3ExprTruthValue(pExpr->pRight);
114146 sqlite3ExprIfFalse(pParse, pExpr->pLeft, dest,
114151 sqlite3ExprIfTrue(pParse, pExpr->pLeft, dest,
114158 testcase( pExpr->op==TK_IS );
114159 testcase( pExpr->op==TK_ISNOT );
114160 op = (pExpr->op==TK_IS) ? TK_NE : TK_EQ;
114169 if( sqlite3ExprIsVector(pExpr->pLeft) ) goto default_expr;
114171 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1);
114172 r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, ®Free2);
114173 codeCompare(pParse, pExpr->pLeft, pExpr->pRight, op,
114174 r1, r2, dest, jumpIfNull,ExprHasProperty(pExpr,EP_Commuted));
114191 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1);
114201 exprCodeBetween(pParse, pExpr, dest, sqlite3ExprIfFalse, jumpIfNull);
114207 sqlite3ExprCodeIN(pParse, pExpr, dest, dest);
114210 sqlite3ExprCodeIN(pParse, pExpr, dest, destIfNull);
114218 if( ExprAlwaysFalse(pExpr) ){
114220 }else if( ExprAlwaysTrue(pExpr) ){
114223 r1 = sqlite3ExprCodeTemp(pParse, pExpr, ®Free1);
114241 SQLITE_PRIVATE void sqlite3ExprIfFalseDup(Parse *pParse, Expr *pExpr, int dest,int jumpIfNull){
114243 Expr *pCopy = sqlite3ExprDup(db, pExpr, 0);
114266 const Expr *pExpr
114272 sqlite3ValueFromExpr(pParse->db, pExpr, SQLITE_UTF8, SQLITE_AFF_BLOB, &pR);
114428 Expr *pExprA = pA->a[i].pExpr;
114429 Expr *pExprB = pB->a[i].pExpr;
114478 if( exprImpliesNotNull(pParse, pList->a[0].pExpr, pNN, iTab, 1)
114479 || exprImpliesNotNull(pParse, pList->a[1].pExpr, pNN, iTab, 1)
114600 static int impliesNotNullRow(Walker *pWalker, Expr *pExpr){
114601 testcase( pExpr->op==TK_AGG_COLUMN );
114602 testcase( pExpr->op==TK_AGG_FUNCTION );
114603 if( ExprHasProperty(pExpr, EP_OuterON) ) return WRC_Prune;
114604 if( ExprHasProperty(pExpr, EP_InnerON) && pWalker->mWFlags ){
114612 switch( pExpr->op ){
114621 testcase( pExpr->op==TK_ISNOT );
114622 testcase( pExpr->op==TK_ISNULL );
114623 testcase( pExpr->op==TK_NOTNULL );
114624 testcase( pExpr->op==TK_IS );
114625 testcase( pExpr->op==TK_VECTOR );
114626 testcase( pExpr->op==TK_FUNCTION );
114627 testcase( pExpr->op==TK_TRUTH );
114628 testcase( pExpr->op==TK_CASE );
114632 if( pWalker->u.iCur==pExpr->iTable ){
114647 testcase( pExpr->op==TK_OR );
114648 testcase( pExpr->op==TK_AND );
114649 bothImplyNotNullRow(pWalker, pExpr->pLeft, pExpr->pRight);
114657 if( ExprUseXList(pExpr) && ALWAYS(pExpr->x.pList->nExpr>0) ){
114658 sqlite3WalkExpr(pWalker, pExpr->pLeft);
114665 assert( ExprUseXList(pExpr) );
114666 assert( pExpr->x.pList->nExpr==2 );
114667 sqlite3WalkExpr(pWalker, pExpr->pLeft);
114668 bothImplyNotNullRow(pWalker, pExpr->x.pList->a[0].pExpr,
114669 pExpr->x.pList->a[1].pExpr);
114681 Expr *pLeft = pExpr->pLeft;
114682 Expr *pRight = pExpr->pRight;
114683 testcase( pExpr->op==TK_EQ );
114684 testcase( pExpr->op==TK_NE );
114685 testcase( pExpr->op==TK_LT );
114686 testcase( pExpr->op==TK_LE );
114687 testcase( pExpr->op==TK_GT );
114688 testcase( pExpr->op==TK_GE );
114770 static int exprIdxCover(Walker *pWalker, Expr *pExpr){
114771 if( pExpr->op==TK_COLUMN
114772 && pExpr->iTable==pWalker->u.pIdxCover->iCur
114773 && sqlite3TableColumnToIndex(pWalker->u.pIdxCover->pIdx, pExpr->iColumn)<0
114792 Expr *pExpr, /* The index to be tested */
114803 sqlite3WalkExpr(&w, pExpr);
114863 static int exprRefToSrcList(Walker *pWalker, Expr *pExpr){
114864 if( pExpr->op==TK_COLUMN
114865 || pExpr->op==TK_AGG_COLUMN
114872 if( pExpr->iTable==pSrc->a[i].iCursor ){
114877 for(i=0; i<p->nExclude && p->aiExclude[i]!=pExpr->iTable; i++){}
114900 SQLITE_PRIVATE int sqlite3ReferencesSrcList(Parse *pParse, Expr *pExpr, SrcList *pSrcList){
114912 assert( pExpr->op==TK_AGG_FUNCTION );
114913 assert( ExprUseXList(pExpr) );
114914 sqlite3WalkExprList(&w, pExpr->x.pList);
114915 if( pExpr->pLeft ){
114916 assert( pExpr->pLeft->op==TK_ORDER );
114917 assert( ExprUseXList(pExpr->pLeft) );
114918 assert( pExpr->pLeft->x.pList!=0 );
114919 sqlite3WalkExprList(&w, pExpr->pLeft->x.pList);
114922 if( ExprHasProperty(pExpr, EP_WinFunc) ){
114923 sqlite3WalkExpr(&w, pExpr->y.pWin->pFilter);
114947 static int agginfoPersistExprCb(Walker *pWalker, Expr *pExpr){
114948 if( ALWAYS(!ExprHasProperty(pExpr, EP_TokenOnly|EP_Reduced))
114949 && pExpr->pAggInfo!=0
114951 AggInfo *pAggInfo = pExpr->pAggInfo;
114952 int iAgg = pExpr->iAgg;
114956 if( pExpr->op!=TK_AGG_FUNCTION ){
114958 && pAggInfo->aCol[iAgg].pCExpr==pExpr
114960 pExpr = sqlite3ExprDup(db, pExpr, 0);
114961 if( pExpr ){
114962 pAggInfo->aCol[iAgg].pCExpr = pExpr;
114963 sqlite3ExprDeferredDelete(pParse, pExpr);
114967 assert( pExpr->op==TK_AGG_FUNCTION );
114969 && pAggInfo->aFunc[iAgg].pFExpr==pExpr
114971 pExpr = sqlite3ExprDup(db, pExpr, 0);
114972 if( pExpr ){
114973 pAggInfo->aFunc[iAgg].pFExpr = pExpr;
114974 sqlite3ExprDeferredDelete(pParse, pExpr);
115035 Expr *pExpr /* Expr describing the column to find or insert */
115043 if( pCol->pCExpr==pExpr ) return;
115044 if( pCol->iTable==pExpr->iTable
115045 && pCol->iColumn==pExpr->iColumn
115046 && pExpr->op!=TK_IF_NULL_ROW
115058 assert( ExprUseYTab(pExpr) );
115059 pCol->pTab = pExpr->y.pTab;
115060 pCol->iTable = pExpr->iTable;
115061 pCol->iColumn = pExpr->iColumn;
115063 pCol->pCExpr = pExpr;
115064 if( pAggInfo->pGroupBy && pExpr->op!=TK_IF_NULL_ROW ){
115070 Expr *pE = pTerm->pExpr;
115072 && pE->iTable==pExpr->iTable
115073 && pE->iColumn==pExpr->iColumn
115084 ExprSetVVAProperty(pExpr, EP_NoReduce);
115085 assert( pExpr->pAggInfo==0 || pExpr->pAggInfo==pAggInfo );
115086 pExpr->pAggInfo = pAggInfo;
115087 if( pExpr->op==TK_COLUMN ){
115088 pExpr->op = TK_AGG_COLUMN;
115090 pExpr->iAgg = (i16)k;
115098 static int analyzeAggregate(Walker *pWalker, Expr *pExpr){
115107 switch( pExpr->op ){
115117 if( sqlite3ExprCompare(0, pExpr, pIEpr->pExpr, iDataCur)==0 ) break;
115120 if( NEVER(!ExprUseYTab(pExpr)) ) break;
115125 if( NEVER(pExpr->pAggInfo!=0) ) break; /* Resolved by outer context */
115140 pAggInfo->aCol[tmp.iAgg].pCExpr = pExpr;
115141 pExpr->pAggInfo = pAggInfo;
115142 pExpr->iAgg = tmp.iAgg;
115148 testcase( pExpr->op==TK_AGG_COLUMN );
115149 testcase( pExpr->op==TK_COLUMN );
115150 testcase( pExpr->op==TK_IF_NULL_ROW );
115156 assert( !ExprHasProperty(pExpr, EP_TokenOnly|EP_Reduced) );
115157 if( pExpr->iTable==pItem->iCursor ){
115158 findOrCreateAggInfoColumn(pParse, pAggInfo, pExpr);
115167 && pWalker->walkerDepth==pExpr->op2
115168 && pExpr->pAggInfo==0
115175 if( NEVER(pItem->pFExpr==pExpr) ) break;
115176 if( sqlite3ExprCompare(0, pItem->pFExpr, pExpr, -1)==0 ){
115187 assert( !ExprHasProperty(pExpr, EP_xIsSelect) );
115189 pItem->pFExpr = pExpr;
115190 assert( ExprUseUToken(pExpr) );
115191 nArg = pExpr->x.pList ? pExpr->x.pList->nExpr : 0;
115193 pExpr->u.zToken, nArg, enc, 0);
115195 if( pExpr->pLeft
115202 assert( pExpr->pLeft->op==TK_ORDER );
115203 assert( ExprUseXList(pExpr->pLeft) );
115205 pOBList = pExpr->pLeft->x.pList;
115210 && sqlite3ExprCompare(0,pOBList->a[0].pExpr,
115211 pExpr->x.pList->a[0].pExpr,0)==0
115214 pItem->bOBUnique = ExprHasProperty(pExpr, EP_Distinct);
115223 if( ExprHasProperty(pExpr, EP_Distinct) && !pItem->bOBUnique ){
115232 assert( !ExprHasProperty(pExpr, EP_TokenOnly|EP_Reduced) );
115233 ExprSetVVAProperty(pExpr, EP_NoReduce);
115234 pExpr->iAgg = (i16)i;
115235 pExpr->pAggInfo = pAggInfo;
115254 SQLITE_PRIVATE void sqlite3ExprAnalyzeAggregates(NameContext *pNC, Expr *pExpr){
115263 sqlite3WalkExpr(&w, pExpr);
115277 sqlite3ExprAnalyzeAggregates(pNC, pItem->pExpr);
116225 static int renameUnmapExprCb(Walker *pWalker, Expr *pExpr){
116227 sqlite3RenameTokenRemap(pParse, 0, (const void*)pExpr);
116228 if( ExprUseYTab(pExpr) ){
116229 sqlite3RenameTokenRemap(pParse, 0, (const void*)&pExpr->y.pTab);
116323 SQLITE_PRIVATE void sqlite3RenameExprUnmap(Parse *pParse, Expr *pExpr){
116331 sqlite3WalkExpr(&sWalker, pExpr);
116424 static int renameColumnExprCb(Walker *pWalker, Expr *pExpr){
116426 if( pExpr->op==TK_TRIGGER
116427 && pExpr->iColumn==p->iCol
116430 renameTokenFind(pWalker->pParse, p, (void*)pExpr);
116431 }else if( pExpr->op==TK_COLUMN
116432 && pExpr->iColumn==p->iCol
116433 && ALWAYS(ExprUseYTab(pExpr))
116434 && p->pTab==pExpr->y.pTab
116436 renameTokenFind(pWalker->pParse, p, (void*)pExpr);
116988 Expr *pExpr = sqlite3ColumnExpr(sParse.pNewTable,
116990 sqlite3WalkExpr(&sWalker, pExpr);
117067 static int renameTableExprCb(Walker *pWalker, Expr *pExpr){
117069 if( pExpr->op==TK_COLUMN
117070 && ALWAYS(ExprUseYTab(pExpr))
117071 && p->pTab==pExpr->y.pTab
117073 renameTokenFind(pWalker->pParse, p, (void*)&pExpr->y.pTab);
117277 static int renameQuotefixExprCb(Walker *pWalker, Expr *pExpr){
117278 if( pExpr->op==TK_STRING && (pExpr->flags & EP_DblQuoted) ){
117279 renameTokenFind(pWalker->pParse, pWalker->u.pRename, (const void*)pExpr);
119761 static int resolveAttachExpr(NameContext *pName, Expr *pExpr)
119764 if( pExpr ){
119765 if( pExpr->op!=TK_ID ){
119766 rc = sqlite3ResolveExprNames(pName, pExpr);
119768 pExpr->op = TK_STRING;
120181 static int fixExprCb(Walker *p, Expr *pExpr){
120183 if( !pFix->bTemp ) ExprSetProperty(pExpr, EP_FromDDL);
120184 if( pExpr->op==TK_VARIABLE ){
120186 pExpr->op = TK_NULL;
120305 Expr *pExpr /* The expression to be fixed to one database */
120307 return sqlite3WalkExpr(&pFix->w, pExpr);
120488 Expr *pExpr, /* The expression to check authorization on */
120498 assert( pExpr->op==TK_COLUMN || pExpr->op==TK_TRIGGER );
120508 if( pExpr->op==TK_TRIGGER ){
120513 if( pExpr->iTable==pTabList->a[iSrc].iCursor ){
120519 iCol = pExpr->iColumn;
120533 pExpr->op = TK_NULL;
120873 sqlite3ExprCode(pParse, pEL->a[i].pExpr, pEL->a[i].u.iConstExprReg);
121316 Expr *pExpr /* The new default expression */
121326 pTab->u.tab.pDfltList = sqlite3ExprListAppend(pParse, pList, pExpr);
121328 sqlite3ExprDelete(pParse->db, pList->a[pCol->iDflt-1].pExpr);
121329 pList->a[pCol->iDflt-1].pExpr = pExpr;
121343 return pTab->u.tab.pDfltList->a[pCol->iDflt-1].pExpr;
122348 Expr *pExpr, /* The parsed expression of the default value */
122359 if( !sqlite3ExprIsConstantOrFunction(pExpr, isInit) ){
122376 x.pLeft = pExpr;
122384 sqlite3RenameExprUnmap(pParse, pExpr);
122386 sqlite3ExprDelete(db, pExpr);
122472 Expr *pCExpr = sqlite3ExprSkipCollate(pList->a[i].pExpr);
122495 Expr *pCExpr = sqlite3ExprSkipCollate(pList->a[0].pExpr);
122590 SQLITE_PRIVATE void sqlite3AddGenerated(Parse *pParse, Expr *pExpr, Token *pType){
122622 if( ALWAYS(pExpr) && pExpr->op==TK_ID ){
122627 pExpr = sqlite3PExpr(pParse, TK_UPLUS, pExpr, 0);
122629 if( pExpr && pExpr->op!=TK_RAISE ) pExpr->affExpr = pCol->affinity;
122630 sqlite3ColumnSetExpr(pParse, pTab, pCol, pExpr);
122631 pExpr = 0;
122638 sqlite3ExprDelete(pParse->db, pExpr);
122643 sqlite3ExprDelete(pParse->db, pExpr);
123006 sqlite3RenameTokenRemap(pParse, pList->a[0].pExpr, &pTab->iPKey);
123202 static int markImmutableExprStep(Walker *pWalker, Expr *pExpr){
123204 ExprSetVVAProperty(pExpr, EP_Immutable);
124752 Expr *pExpr = pList->a[i].pExpr;
124753 assert( pExpr!=0 );
124754 if( pExpr->op==TK_COLLATE ){
124755 assert( !ExprHasProperty(pExpr, EP_IntValue) );
124756 nExtra += (1 + sqlite3Strlen30(pExpr->u.zToken));
124816 sqlite3StringToId(pListItem->pExpr);
124817 sqlite3ResolveSelfReference(pParse, pTab, NC_IdxExpr, pListItem->pExpr, 0);
124819 pCExpr = sqlite3ExprSkipCollate(pListItem->pExpr);
124851 if( pListItem->pExpr->op==TK_COLLATE ){
124853 assert( !ExprHasProperty(pListItem->pExpr, EP_IntValue) );
124854 zColl = pListItem->pExpr->u.zToken;
130172 SQLITE_PRIVATE int sqlite3IsLikeFunction(sqlite3 *db, Expr *pExpr, int *pIsNocase, char *aWc){
130175 assert( pExpr!=0 );
130176 assert( pExpr->op==TK_FUNCTION );
130177 assert( ExprUseXList(pExpr) );
130178 if( !pExpr->x.pList ){
130181 nExpr = pExpr->x.pList->nExpr;
130182 assert( !ExprHasProperty(pExpr, EP_IntValue) );
130183 pDef = sqlite3FindFunction(db, pExpr->u.zToken, nExpr, SQLITE_UTF8, 0);
130203 Expr *pEscape = pExpr->x.pList->a[2].pExpr;
131132 Expr *pExpr;
131137 pExpr = sqlite3Expr(db, TK_REGISTER, 0);
131138 if( pExpr ){
131141 pExpr->iTable = regBase + sqlite3TableColumnToStorage(pTab,iCol) + 1;
131142 pExpr->affExpr = pCol->affinity;
131145 pExpr = sqlite3ExprAddCollateString(pParse, pExpr, zColl);
131147 pExpr->iTable = regBase;
131148 pExpr->affExpr = SQLITE_AFF_INTEGER;
131151 return pExpr;
131164 Expr *pExpr = sqlite3Expr(db, TK_COLUMN, 0);
131165 if( pExpr ){
131166 assert( ExprUseYTab(pExpr) );
131167 pExpr->y.pTab = pTab;
131168 pExpr->iTable = iCursor;
131169 pExpr->iColumn = iCol;
131171 return pExpr;
132242 aff = sqlite3ExprAffinity(pIdx->aColExpr->a[n].pExpr);
132406 static int exprColumnFlagUnion(Walker *pWalker, Expr *pExpr){
132407 if( pExpr->op==TK_COLUMN && pExpr->iColumn>=0 ){
132408 assert( pExpr->iColumn < pWalker->u.pTab->nCol );
132409 pWalker->eCode |= pWalker->u.pTab->aCol[pExpr->iColumn].colFlags;
133348 Expr *pX = pList->a[k].pExpr;
133379 sqlite3ExprCode(pParse, pList->a[ipkColumn].pExpr, regCols);
133431 Expr *pIpk = pList->a[ipkColumn].pExpr;
133436 sqlite3ExprCode(pParse, pList->a[ipkColumn].pExpr, regRowid);
133604 static int checkConstraintExprNode(Walker *pWalker, Expr *pExpr){
133605 if( pExpr->op==TK_COLUMN ){
133606 assert( pExpr->iColumn>=0 || pExpr->iColumn==-1 );
133607 if( pExpr->iColumn>=0 ){
133608 if( pWalker->u.aiCol[pExpr->iColumn]>=0 ){
133634 Expr *pExpr, /* The expression to be checked */
133643 sqlite3WalkExpr(&w, pExpr);
133986 Expr *pExpr = pCheck->a[i].pExpr;
133988 && !sqlite3ExprReferencesUpdatedColumn(pExpr, aiChng, pkChng)
134000 pCopy = sqlite3ExprDup(db, pExpr, 0);
134348 sqlite3ExprCodeCopy(pParse, pIdx->aColExpr->a[i].pExpr, regIdx+i);
134882 if( sqlite3ExprCompare(0, pSrc->aColExpr->a[i].pExpr,
134883 pDest->aColExpr->a[i].pExpr, -1)!=0 ){
134998 assert( pEList->a[0].pExpr );
134999 if( pEList->a[0].pExpr->op!=TK_ASTERISK ){
139759 sqlite3ExprIfFalse(pParse, pCheck->a[k].pExpr, addrCkFault, 0);
139761 sqlite3ExprIfTrue(pParse, pCheck->a[0].pExpr, addrCkOk,
142210 sqlite3SetJoinExpr(p->x.pList->a[i].pExpr, iTable, joinFlag);
142248 unsetJoinExpr(p->x.pList->a[i].pExpr, iTable, nullable);
142706 CollSeq *pColl = sqlite3ExprCollSeq(pParse, pEList->a[i].pExpr);
142830 Expr *pExpr = pItem->pExpr;
142832 if( pExpr->op==TK_COLUMN
142833 && pExpr->iColumn>=0
142834 && ALWAYS( ExprUseYTab(pExpr) )
142835 && (pTab = pExpr->y.pTab)!=0
142837 && (pTab->aCol[pExpr->iColumn].colFlags & COLFLAG_SORTERREF)!=0
142841 if( pSort->aDefer[j].iCsr==pExpr->iTable ) break;
142857 pNew->iTable = pExpr->iTable;
142859 pNew->y.pTab = pExpr->y.pTab;
142864 pSort->aDefer[nDefer].pTab = pExpr->y.pTab;
142865 pSort->aDefer[nDefer].iCsr = pExpr->iTable;
143373 pInfo->aColl[i-iStart] = sqlite3ExprNNCollSeq(pParse, pItem->pExpr);
143564 sqlite3ExprCode(pParse, aOutEx[i].pExpr, regRow+i);
143674 Expr *pExpr
143676 Expr *pExpr,
143690 assert( pExpr!=0 );
143692 switch( pExpr->op ){
143700 int iCol = pExpr->iColumn; /* Index of column in pTab */
143703 for(j=0;j<pTabList->nSrc && pTabList->a[j].iCursor!=pExpr->iTable;j++);
143733 assert( pTab && ExprUseYTab(pExpr) && pExpr->y.pTab==pTab );
143751 Expr *p = pS->pEList->a[iCol].pExpr;
143795 assert( ExprUseXSelect(pExpr) );
143796 pS = pExpr->x.pSelect;
143797 p = pS->pEList->a[0].pExpr;
143835 Expr *p = pEList->a[i].pExpr;
143915 Expr *p = pEList->a[i].pExpr;
144013 Expr *pColExpr = sqlite3ExprSkipCollateAndLikely(pX->pExpr);
144122 p = a[i].pExpr;
144132 m |= sqlite3ExprDataType(pS2->pEList->a[i].pExpr);
144321 pRet = sqlite3ExprCollSeq(pParse, p->pEList->a[iCol].pExpr);
144344 Expr *pTerm = pItem->pExpr;
144352 pOrderBy->a[i].pExpr =
145623 Expr *pExpr /* Expr in which substitution occurs */
145625 if( pExpr==0 ) return 0;
145626 if( ExprHasProperty(pExpr, EP_OuterON|EP_InnerON)
145627 && pExpr->w.iJoin==pSubst->iTable
145629 testcase( ExprHasProperty(pExpr, EP_InnerON) );
145630 pExpr->w.iJoin = pSubst->iNewTable;
145632 if( pExpr->op==TK_COLUMN
145633 && pExpr->iTable==pSubst->iTable
145634 && !ExprHasProperty(pExpr, EP_FixedCol)
145637 if( pExpr->iColumn<0 ){
145638 pExpr->op = TK_NULL;
145646 iColumn = pExpr->iColumn;
145649 assert( pExpr->pRight==0 );
145650 pCopy = pSubst->pEList->a[iColumn].pExpr;
145670 return pExpr;
145675 if( ExprHasProperty(pExpr,EP_OuterON|EP_InnerON) ){
145676 sqlite3SetJoinExpr(pNew, pExpr->w.iJoin,
145677 pExpr->flags & (EP_OuterON|EP_InnerON));
145679 sqlite3ExprDelete(db, pExpr);
145680 pExpr = pNew;
145681 if( pExpr->op==TK_TRUEFALSE ){
145682 pExpr->u.iValue = sqlite3ExprTruthValue(pExpr);
145683 pExpr->op = TK_INTEGER;
145684 ExprSetProperty(pExpr, EP_IntValue);
145690 CollSeq *pNat = sqlite3ExprCollSeq(pSubst->pParse, pExpr);
145692 pSubst->pCList->a[iColumn].pExpr
145694 if( pNat!=pColl || (pExpr->op!=TK_COLUMN && pExpr->op!=TK_COLLATE) ){
145695 pExpr = sqlite3ExprAddCollateString(pSubst->pParse, pExpr,
145700 ExprClearProperty(pExpr, EP_Collate);
145704 if( pExpr->op==TK_IF_NULL_ROW && pExpr->iTable==pSubst->iTable ){
145705 pExpr->iTable = pSubst->iNewTable;
145707 pExpr->pLeft = substExpr(pSubst, pExpr->pLeft);
145708 pExpr->pRight = substExpr(pSubst, pExpr->pRight);
145709 if( ExprUseXSelect(pExpr) ){
145710 substSelect(pSubst, pExpr->x.pSelect, 1);
145712 substExprList(pSubst, pExpr->x.pList);
145715 if( ExprHasProperty(pExpr, EP_WinFunc) ){
145716 Window *pWin = pExpr->y.pWin;
145723 return pExpr;
145732 pList->a[i].pExpr = substExpr(pSubst, pList->a[i].pExpr);
145770 static int recomputeColumnsUsedExpr(Walker *pWalker, Expr *pExpr){
145772 if( pExpr->op!=TK_COLUMN ) return WRC_Continue;
145774 if( pItem->iCursor!=pExpr->iTable ) return WRC_Continue;
145775 if( pExpr->iColumn<0 ) return WRC_Continue;
145776 pItem->colUsed |= sqlite3ExprColUsed(pExpr);
145846 static int renumberCursorsCb(Walker *pWalker, Expr *pExpr){
145847 int op = pExpr->op;
145849 renumberCursorDoMapping(pWalker, &pExpr->iTable);
145851 if( ExprHasProperty(pExpr, EP_OuterON) ){
145852 renumberCursorDoMapping(pWalker, &pExpr->w.iJoin);
145917 assert( pList->a[ii].pExpr!=0 );
145918 aff = sqlite3ExprAffinity(pList->a[ii].pExpr);
145922 assert( pSub1->pEList->a[ii].pExpr!=0 );
145923 if( sqlite3ExprAffinity(pSub1->pEList->a[ii].pExpr)!=aff ){
146559 Expr *pExpr /* Overall expression: COLUMN=VALUE or VALUE=COLUMN */
146567 if( !sqlite3IsBinary(sqlite3ExprCompareCollSeq(pConst->pParse,pExpr)) ){
146603 static void findConstInWhere(WhereConst *pConst, Expr *pExpr){
146605 if( NEVER(pExpr==0) ) return;
146606 if( ExprHasProperty(pExpr, pConst->mExcludeOn) ){
146607 testcase( ExprHasProperty(pExpr, EP_OuterON) );
146608 testcase( ExprHasProperty(pExpr, EP_InnerON) );
146611 if( pExpr->op==TK_AND ){
146612 findConstInWhere(pConst, pExpr->pRight);
146613 findConstInWhere(pConst, pExpr->pLeft);
146616 if( pExpr->op!=TK_EQ ) return;
146617 pRight = pExpr->pRight;
146618 pLeft = pExpr->pLeft;
146622 constInsert(pConst,pRight,pLeft,pExpr);
146625 constInsert(pConst,pLeft,pRight,pExpr);
146640 Expr *pExpr,
146645 if( pExpr->op!=TK_COLUMN ) return WRC_Continue;
146646 if( ExprHasProperty(pExpr, EP_FixedCol|pConst->mExcludeOn) ){
146647 testcase( ExprHasProperty(pExpr, EP_FixedCol) );
146648 testcase( ExprHasProperty(pExpr, EP_OuterON) );
146649 testcase( ExprHasProperty(pExpr, EP_InnerON) );
146654 if( pColumn==pExpr ) continue;
146655 if( pColumn->iTable!=pExpr->iTable ) continue;
146656 if( pColumn->iColumn!=pExpr->iColumn ) continue;
146662 ExprClearProperty(pExpr, EP_Leaf);
146663 ExprSetProperty(pExpr, EP_FixedCol);
146664 assert( pExpr->pLeft==0 );
146665 pExpr->pLeft = sqlite3ExprDup(pConst->pParse->db, pConst->apExpr[i*2+1], 0);
146688 static int propagateConstantExprRewrite(Walker *pWalker, Expr *pExpr){
146695 if( (pExpr->op>=TK_EQ && pExpr->op<=TK_GE)
146696 || pExpr->op==TK_IS
146698 propagateConstantExprRewriteOne(pConst, pExpr->pLeft, 0);
146700 if( sqlite3ExprAffinity(pExpr->pLeft)!=SQLITE_AFF_TEXT ){
146701 propagateConstantExprRewriteOne(pConst, pExpr->pRight, 0);
146705 return propagateConstantExprRewriteOne(pConst, pExpr, pConst->bHasAffBlob);
146821 static int pushDownWindowCheck(Parse *pParse, Select *pSubq, Expr *pExpr){
146825 return sqlite3ExprIsConstantOrGroupBy(pParse, pExpr, pSubq->pWin->pPartition);
146964 CollSeq *pColl = sqlite3ExprCollSeq(pParse, pList->a[ii].pExpr);
147123 Expr *pY = pX->pEList->a[j].pExpr;
147174 if( sqlite3ExprCanBeNull(pEList->a[0].pExpr) ){
147208 Expr *pExpr;
147225 pExpr = p->pEList->a[0].pExpr;
147226 assert( pExpr!=0 );
147227 if( pExpr->op!=TK_AGG_FUNCTION ) return 0;
147228 if( pExpr->pAggInfo!=pAggInfo ) return 0;
147230 assert( pAggInfo->aFunc[0].pFExpr==pExpr );
147231 testcase( ExprHasProperty(pExpr, EP_Distinct) );
147232 testcase( ExprHasProperty(pExpr, EP_WinFunc) );
147233 if( ExprHasProperty(pExpr, EP_Distinct|EP_WinFunc) ) return 0;
147311 if( a[i].pExpr->flags & EP_Collate ) break;
147723 Expr *pE, *pRight, *pExpr;
147857 pE = pEList->a[k].pExpr;
147877 pE = a[k].pExpr;
147886 pNew = sqlite3ExprListAppend(pParse, pNew, a[k].pExpr);
147892 a[k].pExpr = 0;
148024 pExpr = sqlite3PExpr(pParse, TK_DOT, pLeft, pRight);
148030 pExpr = sqlite3PExpr(pParse, TK_DOT, pLeft, pExpr);
148033 pExpr = pRight;
148035 sqlite3ExprSetErrorOffset(pExpr, iErrOfst);
148036 pNew = sqlite3ExprListAppend(pParse, pNew, pExpr);
148276 Expr *pExpr = pAggInfo->aFunc[i].pFExpr;
148277 assert( pExpr->op==TK_FUNCTION || pExpr->op==TK_AGG_FUNCTION );
148278 assert( ExprUseXList(pExpr) );
148279 sqlite3ExprAnalyzeAggList(pNC, pExpr->x.pList);
148280 if( pExpr->pLeft ){
148281 assert( pExpr->pLeft->op==TK_ORDER );
148282 assert( ExprUseXList(pExpr->pLeft) );
148283 sqlite3ExprAnalyzeAggList(pNC, pExpr->pLeft->x.pList);
148286 assert( !IsWindowFunc(pExpr) );
148287 if( ExprHasProperty(pExpr, EP_WinFunc) ){
148288 sqlite3ExprAnalyzeAggregates(pNC, pExpr->y.pWin->pFilter);
148331 sqlite3TreeViewExpr(0, pIEpr->pExpr, 0);
148344 static int aggregateIdxEprRefToColCallback(Walker *pWalker, Expr *pExpr){
148348 if( pExpr->pAggInfo==0 ) return WRC_Continue;
148349 if( pExpr->op==TK_AGG_COLUMN ) return WRC_Continue;
148350 if( pExpr->op==TK_AGG_FUNCTION ) return WRC_Continue;
148351 if( pExpr->op==TK_IF_NULL_ROW ) return WRC_Continue;
148352 pAggInfo = pExpr->pAggInfo;
148353 if( NEVER(pExpr->iAgg>=pAggInfo->nColumn) ) return WRC_Continue;
148354 assert( pExpr->iAgg>=0 );
148355 pCol = &pAggInfo->aCol[pExpr->iAgg];
148356 pExpr->op = TK_AGG_COLUMN;
148357 pExpr->iTable = pCol->iTable;
148358 pExpr->iColumn = pCol->iColumn;
148359 ExprClearProperty(pExpr, EP_Skip|EP_Collate|EP_Unlikely);
148675 pColl = sqlite3ExprCollSeq(pParse, pItem->pExpr);
148743 static int havingToWhereExprCb(Walker *pWalker, Expr *pExpr){
148744 if( pExpr->op!=TK_AND ){
148753 if( sqlite3ExprIsConstantOrGroupBy(pWalker->pParse, pExpr, pS->pGroupBy)
148754 && ExprAlwaysFalse(pExpr)==0
148755 && pExpr->pAggInfo==0
148761 SWAP(Expr, *pNew, *pExpr);
148875 Expr *pExpr;
148884 pExpr = p->pEList->a[0].pExpr;
148885 if( pExpr->op!=TK_AGG_FUNCTION ) return 0; /* Result is an aggregate */
148886 assert( ExprUseUToken(pExpr) );
148887 if( sqlite3_stricmp(pExpr->u.zToken,"count") ) return 0; /* Is count() */
148888 assert( ExprUseXList(pExpr) );
148889 if( pExpr->x.pList!=0 ) return 0; /* Must be count(*) */
148891 if( ExprHasProperty(pExpr, EP_WinFunc) ) return 0;/* Not a window function */
148908 pCount = pExpr;
148909 pExpr = 0;
148927 if( pExpr==0 ){
148928 pExpr = pTerm;
148930 pExpr = sqlite3PExpr(pParse, TK_PLUS, pTerm, pExpr);
148934 p->pEList->a[0].pExpr = pExpr;
149646 sqlite3ExprDelete(db, pEList->a[ii].pExpr);
149651 if( pEList->a[ii].fg.bUsed==0 ) pEList->a[ii].pExpr->op = TK_NULL;
149898 Expr *pExpr = pAggInfo->aFunc[0].pFExpr->x.pList->a[0].pExpr;
149899 pExpr = sqlite3ExprDup(db, pExpr, 0);
149901 pDistinct = sqlite3ExprListAppend(pParse, pDistinct, pExpr);
150067 sqlite3ExprCode(pParse, pGroupBy->a[j].pExpr, iBMem+j);
150334 Expr *pExpr = pAggInfo->aCol[i].pCExpr;
150335 if( pExpr==0 ) continue;
150336 assert( pExpr->pAggInfo==pAggInfo );
150337 assert( pExpr->iAgg==i );
150340 Expr *pExpr = pAggInfo->aFunc[i].pFExpr;
150341 assert( pExpr!=0 );
150342 assert( pExpr->pAggInfo==pAggInfo );
150343 assert( pExpr->iAgg==i );
151486 Expr *pOldExpr = pList->a[i].pExpr;
151579 Expr *pCol = pNew->a[i].pExpr;
152163 assert( pIdx->aColExpr->a[iCol].pExpr!=0 );
152164 return sqlite3ExprReferencesUpdatedColumn(pIdx->aColExpr->a[iCol].pExpr,
152314 sqlite3ExprDup(db, pChanges->a[i].pExpr, 0)
152524 if( nChangeFrom==0 && sqlite3ResolveExprNames(&sNC, pChanges->a[i].pExpr) ){
152533 pRowidExpr = pChanges->a[i].pExpr;
152556 pRowidExpr = pChanges->a[i].pExpr;
153010 sqlite3ExprCode(pParse, pChanges->a[j].pExpr, k);
153302 pRow = sqlite3ExprDup(db, pChanges->a[aXRef[iPk]].pExpr, 0);
153312 sqlite3ExprDup(db, pChanges->a[aXRef[i]].pExpr, 0)
153338 sqlite3ExprCode(pParse, pChanges->a[aXRef[i]].pExpr, regArg+2+i);
153551 && (pTerm = pTarget->a[0].pExpr)->op==TK_COLUMN
153585 Expr *pExpr;
153591 pExpr = pIdx->aColExpr->a[ii].pExpr;
153592 if( pExpr->op!=TK_COLLATE ){
153593 sCol[0].pLeft = pExpr;
153594 pExpr = &sCol[0];
153599 pExpr = &sCol[0];
153602 if( sqlite3ExprCompare(0,pTarget->a[jj].pExpr,pExpr,iCursor)<2 ){
155289 Expr *pExpr /* First argument to the function */
155300 if( NEVER(pExpr==0) ) return pDef;
155301 if( pExpr->op!=TK_COLUMN ) return pDef;
155302 assert( ExprUseYTab(pExpr) );
155303 pTab = pExpr->y.pTab;
155802 Expr *pExpr; /* Pointer to the subexpression that is this term */
156531 && (pLevel->iLeftJoin==0 || ExprHasProperty(pTerm->pExpr, EP_OuterON))
156674 if( pLoop->aLTerm[i]->pExpr==pX ){
156678 if( pOrigRhs->a[iField].pExpr==0 ) continue; /* Duplicate PK column */
156679 pRhs = sqlite3ExprListAppend(pParse, pRhs, pOrigRhs->a[iField].pExpr);
156680 pOrigRhs->a[iField].pExpr = 0;
156682 assert( pOrigLhs->a[iField].pExpr!=0 );
156683 pLhs = sqlite3ExprListAppend(pParse,pLhs,pOrigLhs->a[iField].pExpr);
156684 pOrigLhs->a[iField].pExpr = 0;
156698 Expr *p = pLhs->a[0].pExpr;
156699 pLhs->a[0].pExpr = 0;
156752 Expr *pX = pTerm->pExpr;
156785 if( pLoop->aLTerm[i] && pLoop->aLTerm[i]->pExpr==pX ){
156792 if( pLoop->aLTerm[i]->pExpr==pX ) nEq++;
156799 Expr *pExpr = pTerm->pExpr;
156800 if( pExpr->iTable==0 || !ExprHasProperty(pExpr, EP_Subrtn) ){
156806 pExpr->iTable = iTab;
156814 pX = pExpr;
156845 if( pLoop->aLTerm[i]->pExpr==pX ){
157024 if( pTerm->pExpr->flags & EP_xIsSelect ){
157032 Expr *pRight = pTerm->pExpr->pRight;
157108 static int codeCursorHintCheckExpr(Walker *pWalker, Expr *pExpr){
157111 if( pExpr->op==TK_COLUMN
157112 && pExpr->iTable==pHint->iTabCur
157113 && sqlite3TableColumnToIndex(pHint->pIdx, pExpr->iColumn)<0
157135 static int codeCursorHintIsOrFunction(Walker *pWalker, Expr *pExpr){
157136 if( pExpr->op==TK_IS
157137 || pExpr->op==TK_ISNULL || pExpr->op==TK_ISNOT
157138 || pExpr->op==TK_NOTNULL || pExpr->op==TK_CASE
157141 }else if( pExpr->op==TK_FUNCTION ){
157144 if( 0==sqlite3IsLikeFunction(pWalker->pParse->db, pExpr, &d1, d2) ){
157170 static int codeCursorHintFixExpr(Walker *pWalker, Expr *pExpr){
157174 if( pExpr->op==TK_COLUMN ){
157175 if( pExpr->iTable!=pHint->iTabCur ){
157177 reg = sqlite3ExprCodeTarget(pWalker->pParse, pExpr, reg);
157178 pExpr->op = TK_REGISTER;
157179 pExpr->iTable = reg;
157181 pExpr->iTable = pHint->iIdxCur;
157182 pExpr->iColumn = sqlite3TableColumnToIndex(pHint->pIdx, pExpr->iColumn);
157183 assert( pExpr->iColumn>=0 );
157185 }else if( pExpr->pAggInfo ){
157188 reg = sqlite3ExprCodeTarget(pWalker->pParse, pExpr, reg);
157189 pExpr->op = TK_REGISTER;
157190 pExpr->iTable = reg;
157191 }else if( pExpr->op==TK_TRUEFALSE ){
157210 Expr *pExpr = 0;
157257 Expr *pExpr = pTerm->pExpr;
157258 if( !ExprHasProperty(pExpr, EP_OuterON)
157259 || pExpr->w.iJoin!=pTabItem->iCursor
157263 sqlite3WalkExpr(&sWalker, pTerm->pExpr);
157267 if( ExprHasProperty(pTerm->pExpr, EP_OuterON) ) continue;
157279 if( sqlite3ExprContainsSubquery(pTerm->pExpr) ) continue;
157286 sqlite3WalkExpr(&sWalker, pTerm->pExpr);
157291 pExpr = sqlite3ExprAnd(pParse, pExpr, sqlite3ExprDup(db, pTerm->pExpr, 0));
157293 if( pExpr!=0 ){
157295 if( pParse->nErr==0 ) sqlite3WalkExpr(&sWalker, pExpr);
157298 (const char*)pExpr, P4_EXPR);
157394 sqlite3ExprCode(pParse, pList->a[i].pExpr, iReg+i);
157422 Expr *pExpr;
157424 pExpr = pTerm->pExpr;
157425 if( sqlite3ExprCompare(0, pExpr, pTruth, iTabCur)==0 ){
157467 assert( pTerm->pExpr!=0 );
157613 sqlite3CodeRhsOfIN(pParse, pTerm->pExpr, iTab);
157620 Expr *pRight = pTerm->pExpr->pRight;
157685 Expr *pLeft = pTerm->pExpr->pLeft;
157691 pCompare->pLeft = pLeft->x.pList->a[iFld-1].pExpr;
157729 assert( pTerm->pExpr!=0 );
157787 pX = pStart->pExpr;
157821 pX = pEnd->pExpr;
158028 Expr *pRight = pRangeStart->pExpr->pRight;
158129 Expr *pRight = pRangeEnd->pExpr->pRight;
158406 Expr *pExpr = pWC->a[iTerm].pExpr;
158415 if( ExprHasProperty(pExpr, EP_Subquery) ) continue; /* tag-20220303a */
158416 pExpr = sqlite3ExprDup(db, pExpr, 0);
158417 pAndExpr = sqlite3ExprAnd(pParse, pAndExpr, pExpr);
158438 Expr *pOrExpr = pOrTerm->pExpr; /* Current OR clause term */
158648 pE = pTerm->pExpr;
158725 pE = pTerm->pExpr;
158740 && ExprUseXSelect(pAlt->pExpr)
158741 && (pAlt->pExpr->x.pSelect->pEList->nExpr>1)
158749 sEAlt = *pAlt->pExpr;
158836 assert( pTerm->pExpr );
158837 sqlite3ExprIfFalse(pParse, pTerm->pExpr, addrCont, SQLITE_JUMPIFNULL);
158899 if( ExprHasProperty(pTerm->pExpr, EP_OuterON|EP_InnerON) ) continue;
158901 sqlite3ExprDup(pParse->db, pTerm->pExpr, 0));
159032 pTerm->pExpr = sqlite3ExprSkipCollateAndLikely(p);
159058 static u16 exprCommute(Parse *pParse, Expr *pExpr){
159059 if( pExpr->pLeft->op==TK_VECTOR
159060 || pExpr->pRight->op==TK_VECTOR
159061 || sqlite3BinaryCompareCollSeq(pParse, pExpr->pLeft, pExpr->pRight) !=
159062 sqlite3BinaryCompareCollSeq(pParse, pExpr->pRight, pExpr->pLeft)
159064 pExpr->flags ^= EP_Commuted;
159066 SWAP(Expr*,pExpr->pRight,pExpr->pLeft);
159067 if( pExpr->op>=TK_GT ){
159072 assert( pExpr->op>=TK_GT && pExpr->op<=TK_GE );
159073 pExpr->op = ((pExpr->op-TK_GT)^2)+TK_GT;
159121 Expr *pExpr, /* Test this expression */
159137 if( !sqlite3IsLikeFunction(db, pExpr, pnoCase, (char*)wc) ){
159143 assert( ExprUseXList(pExpr) );
159144 pList = pExpr->x.pList;
159145 pLeft = pList->a[1].pExpr;
159147 pRight = sqlite3ExprSkipCollate(pList->a[0].pExpr);
159300 Expr *pExpr, /* Test this expression */
159305 if( pExpr->op==TK_FUNCTION ){
159319 assert( ExprUseXList(pExpr) );
159320 pList = pExpr->x.pList;
159332 pCol = pList->a[1].pExpr;
159336 assert( !ExprHasProperty(pExpr, EP_IntValue) );
159337 if( sqlite3StrICmp(pExpr->u.zToken, aOp[i].zOp)==0 ){
159339 *ppRight = pList->a[0].pExpr;
159356 pCol = pList->a[0].pExpr;
159367 assert( !ExprHasProperty(pExpr, EP_IntValue) );
159370 i = pMod->xFindFunction(pVtab,2, pExpr->u.zToken, &xNotUsed, &pNotUsed);
159373 *ppRight = pList->a[1].pExpr;
159379 }else if( pExpr->op==TK_NE || pExpr->op==TK_ISNOT || pExpr->op==TK_NOTNULL ){
159381 Expr *pLeft = pExpr->pLeft;
159382 Expr *pRight = pExpr->pRight;
159395 if( pExpr->op==TK_NE ) *peOp2 = SQLITE_INDEX_CONSTRAINT_NE;
159396 if( pExpr->op==TK_ISNOT ) *peOp2 = SQLITE_INDEX_CONSTRAINT_ISNOT;
159397 if( pExpr->op==TK_NOTNULL ) *peOp2 = SQLITE_INDEX_CONSTRAINT_ISNOTNULL;
159476 assert( pOne->pExpr->pLeft!=0 && pOne->pExpr->pRight!=0 );
159477 assert( pTwo->pExpr->pLeft!=0 && pTwo->pExpr->pRight!=0 );
159478 if( sqlite3ExprCompare(0,pOne->pExpr->pLeft, pTwo->pExpr->pLeft, -1) ) return;
159479 if( sqlite3ExprCompare(0,pOne->pExpr->pRight, pTwo->pExpr->pRight,-1) )return;
159490 pNew = sqlite3ExprDup(db, pOne->pExpr, 0);
159595 Expr *pExpr = pTerm->pExpr; /* The expression of the term */
159609 assert( pExpr->op==TK_OR );
159616 sqlite3WhereSplit(pOrWc, pExpr, TK_OR);
159644 sqlite3WhereSplit(pAndWC, pOrTerm->pExpr, TK_AND);
159649 assert( pAndTerm->pExpr );
159650 if( allowedOp(pAndTerm->pExpr->op)
159762 pLeft = pOrTerm->pExpr->pLeft;
159784 && sqlite3ExprCompare(pParse, pOrTerm->pExpr->pLeft, pLeft, -1)
159793 affRight = sqlite3ExprAffinity(pOrTerm->pExpr->pRight);
159794 affLeft = sqlite3ExprAffinity(pOrTerm->pExpr->pLeft);
159820 pDup = sqlite3ExprDup(db, pOrTerm->pExpr->pRight, 0);
159822 pLeft = pOrTerm->pExpr->pLeft;
159829 transferJoinMarkings(pNew, pExpr);
159860 static int termIsEquivalence(Parse *pParse, Expr *pExpr){
159864 if( pExpr->op!=TK_EQ && pExpr->op!=TK_IS ) return 0;
159865 if( ExprHasProperty(pExpr, EP_OuterON) ) return 0;
159866 aff1 = sqlite3ExprAffinity(pExpr->pLeft);
159867 aff2 = sqlite3ExprAffinity(pExpr->pRight);
159873 pColl = sqlite3ExprCompareCollSeq(pParse, pExpr);
159875 return sqlite3ExprCollSeqMatch(pParse, pExpr->pLeft, pExpr->pRight);
159925 Expr *pExpr, /* An operand of a comparison operator */
159938 if( sqlite3ExprCompareSkip(pExpr,pIdx->aColExpr->a[i].pExpr,iCur)==0
159939 && pExpr->op!=TK_STRING
159953 Expr *pExpr, /* An operand of a comparison operator */
159964 if( pExpr->op==TK_VECTOR && (op>=TK_GT && ALWAYS(op<=TK_GE)) ){
159965 assert( ExprUseXList(pExpr) );
159966 pExpr = pExpr->x.pList->a[0].pExpr;
159969 if( pExpr->op==TK_COLUMN ){
159970 aiCurCol[0] = pExpr->iTable;
159971 aiCurCol[1] = pExpr->iColumn;
159979 return exprMightBeIndexed2(pFrom,aiCurCol,pExpr,i);
160013 Expr *pExpr; /* The expression to be analyzed */
160032 pExpr = pTerm->pExpr;
160033 assert( pExpr!=0 ); /* Because malloc() has not failed */
160034 assert( pExpr->op!=TK_AS && pExpr->op!=TK_COLLATE );
160036 prereqLeft = sqlite3WhereExprUsage(pMaskSet, pExpr->pLeft);
160037 op = pExpr->op;
160039 assert( pExpr->pRight==0 );
160040 if( sqlite3ExprCheckIN(pParse, pExpr) ) return;
160041 if( ExprUseXSelect(pExpr) ){
160042 pTerm->prereqRight = exprSelectUsage(pMaskSet, pExpr->x.pSelect);
160044 pTerm->prereqRight = sqlite3WhereExprListUsage(pMaskSet, pExpr->x.pList);
160048 pTerm->prereqRight = sqlite3WhereExprUsage(pMaskSet, pExpr->pRight);
160049 if( pExpr->pLeft==0
160050 || ExprHasProperty(pExpr, EP_xIsSelect|EP_IfNullRow)
160051 || pExpr->x.pList!=0
160053 prereqAll = sqlite3WhereExprUsageNN(pMaskSet, pExpr);
160061 if( prereqAll!=sqlite3WhereExprUsageNN(pMaskSet, pExpr) ){
160063 sqlite3TreeViewExpr(0,pExpr,0);
160068 if( ExprHasProperty(pExpr, EP_OuterON|EP_InnerON) ){
160069 Bitmask x = sqlite3WhereGetMask(pMaskSet, pExpr->w.iJoin);
160070 if( ExprHasProperty(pExpr, EP_OuterON) ){
160089 ExprClearProperty(pExpr, EP_InnerON);
160098 Expr *pLeft = sqlite3ExprSkipCollate(pExpr->pLeft);
160099 Expr *pRight = sqlite3ExprSkipCollate(pExpr->pRight);
160106 pLeft = pLeft->x.pList->a[pTerm->u.x.iField-1].pExpr;
160126 pDup = sqlite3ExprDup(db, pExpr, 0);
160144 pDup = pExpr;
160157 && !ExprHasProperty(pExpr,EP_OuterON)
160160 assert( !ExprHasProperty(pExpr, EP_IntValue) );
160161 pExpr->op = TK_TRUEFALSE; /* See tag-20230504-1 */
160162 pExpr->u.zToken = "false";
160163 ExprSetProperty(pExpr, EP_IsFalse);
160185 else if( pExpr->op==TK_BETWEEN && pWC->op==TK_AND ){
160189 assert( ExprUseXList(pExpr) );
160190 pList = pExpr->x.pList;
160197 sqlite3ExprDup(db, pExpr->pLeft, 0),
160198 sqlite3ExprDup(db, pList->a[i].pExpr, 0));
160199 transferJoinMarkings(pNewExpr, pExpr);
160213 else if( pExpr->op==TK_OR ){
160225 else if( pExpr->op==TK_NOTNULL ){
160226 if( pExpr->pLeft->op==TK_COLUMN
160227 && pExpr->pLeft->iColumn>=0
160228 && !ExprHasProperty(pExpr, EP_OuterON)
160231 Expr *pLeft = pExpr->pLeft;
160270 else if( pExpr->op==TK_FUNCTION
160272 && isLikeOrGlob(pParse, pExpr, &pStr1, &isComplete, &noCase)
160283 assert( ExprUseXList(pExpr) );
160284 pLeft = pExpr->x.pList->a[1].pExpr;
160325 transferJoinMarkings(pNewExpr1, pExpr);
160332 transferJoinMarkings(pNewExpr2, pExpr);
160355 if( (pExpr->op==TK_EQ || pExpr->op==TK_IS)
160356 && (nLeft = sqlite3ExprVectorSize(pExpr->pLeft))>1
160357 && sqlite3ExprVectorSize(pExpr->pRight)==nLeft
160358 && ( (pExpr->pLeft->flags & EP_xIsSelect)==0
160359 || (pExpr->pRight->flags & EP_xIsSelect)==0)
160366 Expr *pLeft = sqlite3ExprForVectorField(pParse, pExpr->pLeft, i, nLeft);
160367 Expr *pRight = sqlite3ExprForVectorField(pParse, pExpr->pRight, i, nLeft);
160369 pNew = sqlite3PExpr(pParse, pExpr->op, pLeft, pRight);
160370 transferJoinMarkings(pNew, pExpr);
160388 else if( pExpr->op==TK_IN
160390 && pExpr->pLeft->op==TK_VECTOR
160391 && ALWAYS( ExprUseXSelect(pExpr) )
160392 && (pExpr->x.pSelect->pPrior==0 || (pExpr->x.pSelect->selFlags & SF_Values))
160394 && pExpr->x.pSelect->pWin==0
160399 for(i=0; i<sqlite3ExprVectorSize(pExpr->pLeft); i++){
160401 idxNew = whereClauseInsert(pWC, pExpr, TERM_VIRTUAL|TERM_SLICE);
160420 int res = isAuxiliaryVtabOperator(db, pExpr, &eOp2, &pLeft, &pRight);
160432 if( ExprHasProperty(pExpr, EP_OuterON) && pNewExpr ){
160434 pNewExpr->w.iJoin = pExpr->w.iJoin;
160484 SQLITE_PRIVATE void sqlite3WhereSplit(WhereClause *pWC, Expr *pExpr, u8 op){
160485 Expr *pE2 = sqlite3ExprSkipCollateAndLikely(pExpr);
160487 assert( pE2!=0 || pExpr==0 );
160490 whereClauseInsert(pWC, pExpr, 0);
160511 Expr *pExpr, /* Expression that defines the limit/offset */
160520 if( sqlite3ExprIsInteger(pExpr, &iVal) && iVal>=0 ){
160593 Expr *pExpr = pOrderBy->a[ii].pExpr;
160594 if( pExpr->op!=TK_COLUMN ) return;
160595 if( pExpr->iTable!=iCsr ) return;
160648 sqlite3ExprDelete(db, a->pExpr);
160740 mask |= sqlite3WhereExprUsage(pMaskSet, pList->a[i].pExpr);
160804 sqlite3ExprDup(pParse->db, pArgs->a[j].pExpr, 0), 0);
161151 || sqlite3ExprCompareSkip(pTerm->pExpr->pLeft,
161153 && (pScan->iEquiv<=1 || !ExprHasProperty(pTerm->pExpr, EP_OuterON))
161157 && (pX = whereRightSubexprIsColumn(pTerm->pExpr))!=0
161177 pX = pTerm->pExpr;
161189 && (pX = pTerm->pExpr->pRight, ALWAYS(pX!=0))
161283 pScan->pIdxExpr = pIdx->aColExpr->a[j].pExpr;
161365 Expr *p = sqlite3ExprSkipCollateAndLikely(pList->a[i].pExpr);
161371 CollSeq *pColl = sqlite3ExprNNCollSeq(pParse, pList->a[i].pExpr);
161430 Expr *p = sqlite3ExprSkipCollateAndLikely(pDistinct->a[i].pExpr);
161596 testcase( ExprHasProperty(pTerm->pExpr, EP_OuterON) )
161597 testcase( ExprHasProperty(pTerm->pExpr, EP_InnerON) );
161598 if( !ExprHasProperty(pTerm->pExpr, EP_OuterON|EP_InnerON)
161599 || pTerm->pExpr->w.iJoin != pSrc->iCursor
161604 && ExprHasProperty(pTerm->pExpr, EP_InnerON)
161637 if( !sqlite3IndexAffinityOk(pTerm->pExpr, aff) ) return 0;
161638 testcase( pTerm->pExpr->op==TK_IS );
161752 Expr *pExpr = pTerm->pExpr;
161757 && sqlite3ExprIsSingleTableConstraint(pExpr, pTabList, pLevel->iFrom)
161760 sqlite3ExprDup(pParse->db, pExpr, 0));
161831 Expr *pX = pTerm->pExpr;
162024 Expr *pExpr = pTerm->pExpr;
162026 && sqlite3ExprIsSingleTableConstraint(pExpr, pTabList, iSrc)
162028 sqlite3ExprIfFalse(pParse, pTerm->pExpr, addrCont, SQLITE_JUMPIFNULL);
162148 Expr *pExpr = pOrderBy->a[i].pExpr;
162152 if( sqlite3ExprIsConstant(pExpr) ){
162160 if( pExpr->op==TK_COLUMN && pExpr->iTable==pSrc->iCursor ){
162161 assert( pExpr->iColumn>=XN_ROWID && pExpr->iColumn<pTab->nCol );
162167 if( pExpr->op==TK_COLLATE
162168 && (pE2 = pExpr->pLeft)->op==TK_COLUMN
162172 assert( !ExprHasProperty(pExpr, EP_IntValue) );
162173 assert( pExpr->u.zToken!=0 );
162175 pExpr->iColumn = pE2->iColumn;
162179 if( sqlite3_stricmp(pExpr->u.zToken, zColl)==0 ) continue;
162249 && sqlite3ExprIsVector(pTerm->pExpr->pRight)
162263 Expr *pExpr = pOrderBy->a[i].pExpr;
162264 if( sqlite3ExprIsConstant(pExpr) ) continue;
162265 assert( pExpr->op==TK_COLUMN
162266 || (pExpr->op==TK_COLLATE && pExpr->pLeft->op==TK_COLUMN
162267 && pExpr->iColumn==pExpr->pLeft->iColumn) );
162268 pIdxOrderBy[j].iColumn = pExpr->iColumn;
162638 rc = sqlite3Stat4ValueFromExpr(pParse, pLower->pExpr->pRight, aff, &p1);
162642 rc = sqlite3Stat4ValueFromExpr(pParse, pUpper->pExpr->pRight, aff, &p2);
162804 Expr *pExpr = pLower->pExpr->pRight;
162805 rc = sqlite3Stat4ProbeSetValue(pParse, p, &pRec, pExpr, nBtm, nEq, &n);
162809 if( sqlite3ExprVectorSize(pExpr)>n ) mask = (WO_LE|WO_LT);
162821 Expr *pExpr = pUpper->pExpr->pRight;
162822 rc = sqlite3Stat4ProbeSetValue(pParse, p, &pRec, pExpr, nTop, nEq, &n);
162826 if( sqlite3ExprVectorSize(pExpr)>n ) mask = (WO_LE|WO_LT);
162913 Expr *pExpr, /* Expression for VALUE in the x=VALUE constraint */
162942 rc = sqlite3Stat4ProbeSetValue(pParse, p, &pRec, pExpr, 1, nEq-1, &bOk);
162991 rc = whereEqualScanEst(pParse, pBuilder, pList->a[i].pExpr, &nEst);
163020 if( ExprHasProperty(pTerm->pExpr, EP_OuterON) ) zType[2] = 'L';
163048 sqlite3TreeViewExpr(0, pTerm->pExpr, 0);
163641 Expr *pRight = pTerm->pExpr->pRight;
163643 testcase( pTerm->pExpr->op==TK_IS );
163686 int nCmp = sqlite3ExprVectorSize(pTerm->pExpr->pLeft);
163698 assert( ExprUseXList(pTerm->pExpr->pLeft) );
163699 pLhs = pTerm->pExpr->pLeft->x.pList->a[i].pExpr;
163700 pRhs = pTerm->pExpr->pRight;
163702 pRhs = pRhs->x.pSelect->pEList->a[i].pExpr;
163704 pRhs = pRhs->x.pList->a[i].pExpr;
163867 Expr *pExpr = pTerm->pExpr;
163868 if( ExprUseXSelect(pExpr) ){
163879 if( pNew->aLTerm[i] && pNew->aLTerm[i]->pExpr==pExpr ) nIn = 0;
163881 }else if( ALWAYS(pExpr->x.pList && pExpr->x.pList->nExpr) ){
163883 nIn = sqlite3LogEst(pExpr->x.pList->nExpr);
164010 && ((eOp & WO_IN)==0 || ExprUseXList(pTerm->pExpr))
164013 Expr *pExpr = pTerm->pExpr;
164018 rc = whereEqualScanEst(pParse, pBuilder, pExpr->pRight, &nOut);
164020 rc = whereInScanEst(pParse, pBuilder, pExpr->x.pList, &nOut);
164183 Expr *pExpr = sqlite3ExprSkipCollateAndLikely(pOB->a[ii].pExpr);
164184 if( NEVER(pExpr==0) ) continue;
164185 if( pExpr->op==TK_COLUMN && pExpr->iTable==iCursor ){
164186 if( pExpr->iColumn<0 ) return 1;
164188 if( pExpr->iColumn==pIndex->aiColumn[jj] ) return 1;
164193 if( sqlite3ExprCompareSkip(pExpr,aColExpr->a[jj].pExpr,iCursor)==0 ){
164223 Expr *pExpr;
164224 pExpr = pTerm->pExpr;
164225 if( (!ExprHasProperty(pExpr, EP_OuterON) || pExpr->w.iJoin==iTab)
164226 && ((jointype & JT_OUTER)==0 || ExprHasProperty(pExpr, EP_OuterON))
164227 && sqlite3ExprImpliesExpr(pParse, pExpr, pWhere, iTab)
164241 const Expr *pExpr,
164248 && sqlite3ExprCompare(0, pExpr, pIdx->aColExpr->a[i].pExpr, iTabCur)==0
164284 static int whereIsCoveringIndexWalkCallback(Walker *pWalk, Expr *pExpr){
164293 if( (pExpr->op==TK_COLUMN || pExpr->op==TK_AGG_COLUMN) ){
164295 if( pExpr->iTable!=pCk->iTabCur ) return WRC_Continue;
164300 if( aiColumn[i]==pExpr->iColumn ) return WRC_Continue;
164305 && exprIsCoveredByIndex(pExpr, pIdx, pWalk->u.pCovIdxCk->iTabCur) ){
164388 sqlite3ExprDelete(db, p->pExpr);
164452 p->pExpr = sqlite3ExprDup(db, pRight, 0);
164754 if( !sqlite3ExprCoveredByIndex(pTerm->pExpr, iCur, pProbe) ){
165032 Expr *pX = pHidden->pWC->a[iTerm].pExpr;
165080 pH->pParse->db, pTerm->pExpr->pRight, ENC(pH->pParse->db),
165606 pOBExpr = sqlite3ExprSkipCollateAndLikely(pOrderBy->a[i].pExpr);
165624 CollSeq *pColl1 = sqlite3ExprNNCollSeq(pParse, pOrderBy->a[i].pExpr);
165625 CollSeq *pColl2 = sqlite3ExprCompareCollSeq(pParse, pTerm->pExpr);
165630 testcase( pTerm->pExpr->op==TK_IS );
165695 Expr *pX = pLoop->aLTerm[j]->pExpr;
165697 if( pLoop->aLTerm[i]->pExpr==pX ){
165739 pOBExpr = sqlite3ExprSkipCollateAndLikely(pOrderBy->a[i].pExpr);
165749 Expr *pIxExpr = pIndex->aColExpr->a[j].pExpr;
165755 pColl = sqlite3ExprNNCollSeq(pWInfo->pParse, pOrderBy->a[i].pExpr);
165814 p = pOrderBy->a[i].pExpr;
166445 static int exprNodeIsDeterministic(Walker *pWalker, Expr *pExpr){
166446 if( pExpr->op==TK_FUNCTION && ExprHasProperty(pExpr, EP_ConstFunc)==0 ){
166564 if( !ExprHasProperty(pTerm->pExpr, EP_OuterON)
166565 || pTerm->pExpr->w.iJoin!=pItem->iCursor
166571 && ExprHasProperty(pTerm->pExpr, EP_InnerON)
166572 && pTerm->pExpr->w.iJoin==pItem->iCursor
166671 Expr *pExpr;
166675 pExpr = pIdx->aColExpr->a[i].pExpr;
166681 pExpr = sqlite3ColumnExpr(pTab, &pTab->aCol[j]);
166686 if( sqlite3ExprIsConstant(pExpr) ) continue;
166687 if( pExpr->op==TK_FUNCTION ){
166694 assert( ExprUseXList(pExpr) );
166695 n = pExpr->x.pList ? pExpr->x.pList->nExpr : 0;
166696 pDef = sqlite3FindFunction(db, pExpr->u.zToken, n, ENC(db), 0);
166707 if( sqlite3WhereTrace & 0x5000 ) sqlite3ShowExpr(pExpr);
166710 p->pExpr = sqlite3ExprDup(pParse->db, pExpr, 0);
167034 pX = pT->pExpr;
167753 if( sqlite3WhereTrace & 0x5000 ) sqlite3ShowExpr(p->pExpr);
168601 static int selectWindowRewriteExprCb(Walker *pWalker, Expr *pExpr){
168613 if( pExpr->op!=TK_COLUMN ){
168619 if( pExpr->iTable==p->pSrc->a[i].iCursor ) break;
168625 switch( pExpr->op ){
168628 if( !ExprHasProperty(pExpr, EP_WinFunc) ){
168633 if( pExpr->y.pWin==pWin ){
168634 assert( pWin->pOwner==pExpr );
168649 if( 0==sqlite3ExprCompare(0, p->pSub->a[i].pExpr, pExpr, -1) ){
168656 Expr *pDup = sqlite3ExprDup(pParse->db, pExpr, 0);
168661 int f = pExpr->flags & EP_Collate;
168662 assert( ExprHasProperty(pExpr, EP_Static)==0 );
168663 ExprSetProperty(pExpr, EP_Static);
168664 sqlite3ExprDelete(pParse->db, pExpr);
168665 ExprClearProperty(pExpr, EP_Static);
168666 memset(pExpr, 0, sizeof(Expr));
168668 pExpr->op = TK_COLUMN;
168669 pExpr->iColumn = (iCol<0 ? p->pSub->nExpr-1: iCol);
168670 pExpr->iTable = p->pWin->iEphCsr;
168671 pExpr->y.pTab = p->pTab;
168672 pExpr->flags = f;
168756 Expr *pDup = sqlite3ExprDup(db, pAppend->a[i].pExpr, 0);
168786 static int sqlite3WindowExtraAggFuncDepth(Walker *pWalker, Expr *pExpr){
168787 if( pExpr->op==TK_AGG_FUNCTION
168788 && pExpr->op2>=pWalker->walkerDepth
168790 pExpr->op2++;
168795 static int disallowAggregatesInOrderByCb(Walker *pWalker, Expr *pExpr){
168796 if( pExpr->op==TK_AGG_FUNCTION && pExpr->pAggInfo==0 ){
168797 assert( !ExprHasProperty(pExpr, EP_IntValue) );
168799 "misuse of aggregate: %s()", pExpr->u.zToken);
169019 static Expr *sqlite3WindowOffsetExpr(Parse *pParse, Expr *pExpr){
169020 if( 0==sqlite3ExprIsConstant(pExpr) ){
169021 if( IN_RENAME_OBJECT ) sqlite3RenameExprUnmap(pParse, pExpr);
169022 sqlite3ExprDelete(pParse->db, pExpr);
169023 pExpr = sqlite3ExprAlloc(pParse->db, TK_NULL, 0, 0);
169025 return pExpr;
169596 pColl = sqlite3ExprNNCollSeq(pParse, pWin->pOwner->x.pList->a[0].pExpr);
170060 pColl = sqlite3ExprNNCollSeq(pParse, pOrderBy->a[0].pExpr);
170286 static int windowExprGtZero(Parse *pParse, Expr *pExpr){
170290 sqlite3ValueFromExpr(db, pExpr, db->enc, SQLITE_AFF_NUMERIC, &pVal);
171032 struct FrameBound { int eType; Expr *pExpr; };
173401 sqlite3ExprDelete(pParse->db, (yypminor->yy595).pExpr);
175385 yymsp[-4].minor.yy528->flags |= pList->a[0].pExpr->flags & EP_Propagate;
175512 Expr *pRHS = yymsp[-1].minor.yy322->a[0].pExpr;
175514 yymsp[-1].minor.yy322->a[0].pExpr = 0;
175925 …yymsp[-2].minor.yy394, yymsp[-1].minor.yy595.eType, yymsp[-1].minor.yy595.pExpr, TK_CURRENT, 0, yy…
175931 …-3].minor.yy595.eType, yymsp[-3].minor.yy595.pExpr, yymsp[-1].minor.yy595.eType, yymsp[-1].minor.y…
175943 {yylhsminor.yy595.eType = yymsp[-1].major; yylhsminor.yy595.pExpr = 0;}
175947 {yylhsminor.yy595.eType = yymsp[0].major; yylhsminor.yy595.pExpr = yymsp[-1].minor.yy528;}
184500 Fts3Expr *pExpr; /* Parsed MATCH query string */
186321 sqlite3Fts3ExprFree(pCsr->pExpr);
187898 p->azColumn, p->bFts4, p->nColumn, iCol, zQuery, -1, &pCsr->pExpr,
188010 if( pCsr->pExpr ){
188754 Fts3Expr *pExpr, /* Allocate readers for this expression */
188759 if( pExpr && SQLITE_OK==*pRc ){
188760 if( pExpr->eType==FTSQUERY_PHRASE ){
188762 int nToken = pExpr->pPhrase->nToken;
188765 Fts3PhraseToken *pToken = &pExpr->pPhrase->aToken[i];
188774 assert( pExpr->pPhrase->iDoclistToken==0 );
188775 pExpr->pPhrase->iDoclistToken = -1;
188777 *pnOr += (pExpr->eType==FTSQUERY_OR);
188778 fts3EvalAllocateReaders(pCsr, pExpr->pLeft, pnToken, pnOr, pRc);
188779 fts3EvalAllocateReaders(pCsr, pExpr->pRight, pnToken, pnOr, pRc);
189419 Fts3Expr *pExpr, /* Expression to initialize phrases in */
189422 if( pExpr && SQLITE_OK==*pRc ){
189423 if( pExpr->eType==FTSQUERY_PHRASE ){
189424 int nToken = pExpr->pPhrase->nToken;
189428 if( pExpr->pPhrase->aToken[i].pDeferred==0 ) break;
189430 pExpr->bDeferred = (i==nToken);
189432 *pRc = fts3EvalPhraseStart(pCsr, 1, pExpr->pPhrase);
189434 fts3EvalStartReaders(pCsr, pExpr->pLeft, pRc);
189435 fts3EvalStartReaders(pCsr, pExpr->pRight, pRc);
189436 pExpr->bDeferred = (pExpr->pLeft->bDeferred && pExpr->pRight->bDeferred);
189473 Fts3Expr *pExpr, /* Expression to consider */
189479 if( pExpr->eType==FTSQUERY_PHRASE ){
189480 Fts3Phrase *pPhrase = pExpr->pPhrase;
189491 }else if( pExpr->eType!=FTSQUERY_NOT ){
189492 assert( pExpr->eType==FTSQUERY_OR
189493 || pExpr->eType==FTSQUERY_AND
189494 || pExpr->eType==FTSQUERY_NEAR
189496 assert( pExpr->pLeft && pExpr->pRight );
189497 if( pExpr->eType==FTSQUERY_OR ){
189498 pRoot = pExpr->pLeft;
189502 fts3EvalTokenCosts(pCsr, pRoot, pExpr->pLeft, ppTC, ppOr, pRc);
189503 if( pExpr->eType==FTSQUERY_OR ){
189504 pRoot = pExpr->pRight;
189508 fts3EvalTokenCosts(pCsr, pRoot, pExpr->pRight, ppTC, ppOr, pRc);
189725 fts3EvalAllocateReaders(pCsr, pCsr->pExpr, &nToken, &nOr, &rc);
189744 fts3EvalTokenCosts(pCsr, 0, pCsr->pExpr, &pTC, &ppOr, &rc);
189760 fts3EvalStartReaders(pCsr, pCsr->pExpr, &rc);
189876 Fts3Expr *pExpr, /* Expr. to advance to next matching row */
189879 if( *pRc==SQLITE_OK && pExpr->bEof==0 ){
189881 pExpr->bStart = 1;
189883 switch( pExpr->eType ){
189886 Fts3Expr *pLeft = pExpr->pLeft;
189887 Fts3Expr *pRight = pExpr->pRight;
189894 pExpr->iDocid = pRight->iDocid;
189895 pExpr->bEof = pRight->bEof;
189900 pExpr->iDocid = pLeft->iDocid;
189901 pExpr->bEof = pLeft->bEof;
189915 pExpr->iDocid = pLeft->iDocid;
189916 pExpr->bEof = (pLeft->bEof || pRight->bEof);
189917 if( pExpr->eType==FTSQUERY_NEAR && pExpr->bEof ){
189940 Fts3Expr *pLeft = pExpr->pLeft;
189941 Fts3Expr *pRight = pExpr->pRight;
189956 pExpr->bEof = (pLeft->bEof && pRight->bEof);
189959 pExpr->iDocid = pLeft->iDocid;
189961 pExpr->iDocid = pRight->iDocid;
189968 Fts3Expr *pLeft = pExpr->pLeft;
189969 Fts3Expr *pRight = pExpr->pRight;
189985 pExpr->iDocid = pLeft->iDocid;
189986 pExpr->bEof = pLeft->bEof;
189991 Fts3Phrase *pPhrase = pExpr->pPhrase;
189993 *pRc = fts3EvalPhraseNext(pCsr, pPhrase, &pExpr->bEof);
189994 pExpr->iDocid = pPhrase->doclist.iDocid;
190016 static int fts3EvalNearTest(Fts3Expr *pExpr, int *pRc){
190040 && pExpr->eType==FTSQUERY_NEAR
190041 && (pExpr->pParent==0 || pExpr->pParent->eType!=FTSQUERY_NEAR)
190048 for(p=pExpr; p->pLeft; p=p->pLeft){
190067 aPoslist = pExpr->pRight->pPhrase->doclist.pList;
190068 nToken = pExpr->pRight->pPhrase->nToken;
190069 for(p=pExpr->pLeft; p && res; p=p->pLeft){
190100 Fts3Expr *pExpr, /* Expr to test. May or may not be root. */
190105 switch( pExpr->eType ){
190109 fts3EvalTestExpr(pCsr, pExpr->pLeft, pRc)
190110 && fts3EvalTestExpr(pCsr, pExpr->pRight, pRc)
190111 && fts3EvalNearTest(pExpr, pRc)
190130 && pExpr->eType==FTSQUERY_NEAR
190131 && (pExpr->pParent==0 || pExpr->pParent->eType!=FTSQUERY_NEAR)
190134 for(p=pExpr; p->pPhrase==0; p=p->pLeft){
190147 int bHit1 = fts3EvalTestExpr(pCsr, pExpr->pLeft, pRc);
190148 int bHit2 = fts3EvalTestExpr(pCsr, pExpr->pRight, pRc);
190155 fts3EvalTestExpr(pCsr, pExpr->pLeft, pRc)
190156 && !fts3EvalTestExpr(pCsr, pExpr->pRight, pRc)
190162 if( pCsr->pDeferred && (pExpr->bDeferred || (
190163 pExpr->iDocid==pCsr->iPrevId && pExpr->pPhrase->doclist.pList
190165 Fts3Phrase *pPhrase = pExpr->pPhrase;
190166 if( pExpr->bDeferred ){
190171 pExpr->iDocid = pCsr->iPrevId;
190176 pExpr->bEof==0 && pExpr->iDocid==pCsr->iPrevId
190177 && pExpr->pPhrase->doclist.nList>0
190228 bMiss = (0==fts3EvalTestExpr(pCsr, pCsr->pExpr, &rc));
190243 Fts3Expr *pExpr = pCsr->pExpr;
190245 if( pExpr==0 ){
190253 fts3EvalNextRow(pCsr, pExpr, &rc);
190254 pCsr->isEof = pExpr->bEof;
190257 pCsr->iPrevId = pExpr->iDocid;
190284 Fts3Expr *pExpr,
190287 if( pExpr && *pRc==SQLITE_OK ){
190288 Fts3Phrase *pPhrase = pExpr->pPhrase;
190308 pExpr->iDocid = 0;
190309 pExpr->bEof = 0;
190310 pExpr->bStart = 0;
190312 fts3EvalRestart(pCsr, pExpr->pLeft, pRc);
190313 fts3EvalRestart(pCsr, pExpr->pRight, pRc);
190325 static void fts3EvalUpdateCounts(Fts3Expr *pExpr, int nCol){
190326 if( pExpr ){
190327 Fts3Phrase *pPhrase = pExpr->pPhrase;
190343 pExpr->aMI[iCol*3 + 1] += iCnt;
190344 pExpr->aMI[iCol*3 + 2] += (iCnt>0);
190351 fts3EvalUpdateCounts(pExpr->pLeft, nCol);
190352 fts3EvalUpdateCounts(pExpr->pRight, nCol);
190361 static int fts3AllocateMSI(Fts3Expr *pExpr, int iPhrase, void *pCtx){
190364 if( pExpr->aMI==0 ){
190365 pExpr->aMI = (u32 *)sqlite3_malloc64(pTab->nColumn * 3 * sizeof(u32));
190366 if( pExpr->aMI==0 ) return SQLITE_NOMEM;
190368 memset(pExpr->aMI, 0, pTab->nColumn * 3 * sizeof(u32));
190385 Fts3Expr *pExpr /* FTSQUERY_PHRASE expression */
190389 assert( pExpr->eType==FTSQUERY_PHRASE );
190390 if( pExpr->aMI==0 ){
190399 pRoot = pExpr;
190492 Fts3Expr *pExpr, /* Phrase expression */
190499 if( pExpr->bDeferred && pExpr->pParent->eType!=FTSQUERY_NEAR ){
190506 rc = fts3EvalGatherStats(pCsr, pExpr);
190508 assert( pExpr->aMI );
190510 aiOut[iCol*3 + 1] = pExpr->aMI[iCol*3 + 1];
190511 aiOut[iCol*3 + 2] = pExpr->aMI[iCol*3 + 2];
190540 Fts3Expr *pExpr, /* Phrase to return doclist for */
190544 Fts3Phrase *pPhrase = pExpr->pPhrase;
190558 iDocid = pExpr->iDocid;
190560 if( iDocid!=pCsr->iPrevId || pExpr->bEof ){
190575 pNear = pExpr;
190576 for(p=pExpr->pParent; p; p=p->pParent){
192406 static char *exprToString(Fts3Expr *pExpr, char *zBuf){
192407 if( pExpr==0 ){
192410 switch( pExpr->eType ){
192412 Fts3Phrase *pPhrase = pExpr->pPhrase;
192426 zBuf = sqlite3_mprintf("%zNEAR/%d ", zBuf, pExpr->nNear);
192440 if( zBuf ) zBuf = exprToString(pExpr->pLeft, zBuf);
192443 if( zBuf ) zBuf = exprToString(pExpr->pRight, zBuf);
192476 Fts3Expr *pExpr;
192516 pTokenizer, 0, azCol, 0, nCol, nCol, zExpr, nExpr, &pExpr, &zDummy
192518 assert( rc==SQLITE_OK || pExpr==0 );
192522 pTokenizer, 0, azCol, 0, nCol, nCol, zExpr, nExpr, &pExpr
192527 sqlite3Fts3ExprFree(pExpr);
192529 }else if( rc==SQLITE_NOMEM || !(zBuf = exprToString(pExpr, 0)) ){
192536 sqlite3Fts3ExprFree(pExpr);
200935 Fts3Expr *pExpr, /* Expression to iterate phrases of */
200941 int eType = pExpr->eType; /* Type of expression node pExpr */
200944 assert( pExpr->pLeft && pExpr->pRight );
200945 rc = fts3ExprIterate2(pExpr->pLeft, piPhrase, x, pCtx);
200947 rc = fts3ExprIterate2(pExpr->pRight, piPhrase, x, pCtx);
200950 rc = x(pExpr, *piPhrase, pCtx);
200967 Fts3Expr *pExpr, /* Expression to iterate phrases of */
200972 return fts3ExprIterate2(pExpr, &iPhrase, x, pCtx);
200980 static int fts3ExprLoadDoclistsCb(Fts3Expr *pExpr, int iPhrase, void *ctx){
200982 Fts3Phrase *pPhrase = pExpr->pPhrase;
201011 rc = sqlite3Fts3ExprIterate(pCsr->pExpr,fts3ExprLoadDoclistsCb,(void*)&sCtx);
201017 static int fts3ExprPhraseCountCb(Fts3Expr *pExpr, int iPhrase, void *ctx){
201019 pExpr->iPhrase = iPhrase;
201022 static int fts3ExprPhraseCount(Fts3Expr *pExpr){
201024 (void)sqlite3Fts3ExprIterate(pExpr, fts3ExprPhraseCountCb, (void *)&nPhrase);
201156 static int fts3SnippetFindPositions(Fts3Expr *pExpr, int iPhrase, void *ctx){
201162 pPhrase->nToken = pExpr->pPhrase->nToken;
201163 rc = sqlite3Fts3EvalPhrasePoslist(p->pCsr, pExpr, p->iCol, &pCsr);
201245 pCsr->pExpr, fts3SnippetFindPositions, (void*)&sIter
201552 Fts3Expr *pExpr, /* Phrase expression node */
201557 Fts3Phrase *pPhrase = pExpr->pPhrase;
201563 iStart = pExpr->iPhrase * p->nCol;
201565 iStart = pExpr->iPhrase * ((p->nCol + 31) / 32);
201590 Fts3Expr *pExpr,
201594 assert( (pExpr->pLeft==0)==(pExpr->pRight==0) );
201595 if( pExpr->bEof==0 && pExpr->iDocid==p->pCursor->iPrevId ){
201596 if( pExpr->pLeft ){
201597 rc = fts3ExprLHitGather(pExpr->pLeft, p);
201598 if( rc==SQLITE_OK ) rc = fts3ExprLHitGather(pExpr->pRight, p);
201600 rc = fts3ExprLHits(pExpr, p);
201634 Fts3Expr *pExpr, /* Phrase expression node */
201640 p->pCursor, pExpr, &p->aMatchinfo[3*iPhrase*p->nCol]
201650 Fts3Expr *pExpr, /* Phrase expression node */
201661 rc = sqlite3Fts3EvalPhrasePoslist(p->pCursor, pExpr, i, &pCsr);
201772 Fts3Expr *pExpr; /* Pointer to phrase expression */
201785 Fts3Expr *pExpr, /* Phrase expression node */
201790 aIter[iPhrase].pExpr = pExpr;
201841 (void)sqlite3Fts3ExprIterate(pCsr->pExpr, fts3MatchinfoLcsCb, (void*)aIter);
201845 nToken -= pIter->pExpr->pPhrase->nToken;
201855 rc = sqlite3Fts3EvalPhrasePoslist(pCsr, pIt->pExpr, iCol, &pIt->pRead);
202003 rc = fts3ExprLHitGather(pCsr->pExpr, pInfo);
202008 Fts3Expr *pExpr;
202010 pExpr = pCsr->pExpr;
202018 rc = sqlite3Fts3ExprIterate(pExpr, fts3ExprGlobalHitsCb,(void*)pInfo);
202022 (void)sqlite3Fts3ExprIterate(pExpr, fts3ExprLocalHitsCb,(void*)pInfo);
202074 pCsr->nPhrase = fts3ExprPhraseCount(pCsr->pExpr);
202150 if( !pCsr->pExpr ){
202247 static int fts3ExprTermOffsetInit(Fts3Expr *pExpr, int iPhrase, void *ctx){
202256 rc = sqlite3Fts3EvalPhrasePoslist(p->pCsr, pExpr, p->iCol, &pList);
202257 nTerm = pExpr->pPhrase->nToken;
202288 if( !pCsr->pExpr ){
202328 pCsr->pExpr, fts3ExprTermOffsetInit, (void*)&sCtx
202430 if( !pCsr->pExpr ){
215071 URegularExpression *pExpr = (URegularExpression *)p;
215072 uregex_close(pExpr);
215096 URegularExpression *pExpr;
215109 pExpr = sqlite3_get_auxdata(p, 0);
215110 if( !pExpr ){
215115 pExpr = uregex_open(zPattern, -1, 0, 0, &status);
215118 sqlite3_set_auxdata(p, 0, pExpr, icuRegexpDelete);
215119 pExpr = sqlite3_get_auxdata(p, 0);
215121 if( !pExpr ){
215128 uregex_setText(pExpr, zString, -1, &status);
215135 res = uregex_matches(pExpr, 0, &status);
215146 uregex_setText(pExpr, 0, 0, &status);
234884 Fts5ExprNode *pExpr; /* Result of a successful parse */
235027 assert_expr_depth_ok(sParse.rc, sParse.pExpr);
235031 if( iCol<pConfig->nCol && sParse.pExpr && sParse.rc==SQLITE_OK ){
235037 sqlite3Fts5ParseSetColset(&sParse, sParse.pExpr, pColset);
235046 sqlite3Fts5ParseNodeFree(sParse.pExpr);
235048 if( !sParse.pExpr ){
235055 pNew->pRoot = sParse.pExpr;
235065 sqlite3Fts5ParseNodeFree(sParse.pExpr);
235630 Fts5Expr *pExpr, /* Expression that pNear is a part of */
235636 if( pExpr->pConfig->eDetail!=FTS5_DETAIL_FULL ){
235688 Fts5Expr *pExpr,
235714 pExpr->pIndex, p->pTerm, p->nQueryTerm,
235716 (pExpr->bDesc ? FTS5INDEX_QUERY_DESC : 0),
235750 Fts5Expr *pExpr,
235754 assert( pExpr->bDesc==0 || pExpr->bDesc==1 );
235755 if( pExpr->bDesc==0 ){
235804 Fts5Expr *pExpr,
235810 return fts5RowidCmp(pExpr, p1->iRowid, p2->iRowid);
235825 Fts5Expr *pExpr, /* Expression pPhrase belongs to */
235834 const int bDesc = pExpr->bDesc;
235881 pNode->bNomatch = ((0==fts5ExprNearTest(&rc, pExpr, pNode)) && rc==SQLITE_OK);
235895 Fts5Expr *pExpr, /* Expression pPhrase belongs to */
235909 i64 iRowid = fts5ExprSynonymRowid(pTerm, pExpr->bDesc, 0);
235917 || (bFromValid && ii!=iFrom && (ii>iFrom)==pExpr->bDesc)
235952 rc = fts5ExprNodeTest_STRING(pExpr, pNode);
235960 Fts5Expr *pExpr, /* Expression that pNear is a part of */
235976 if( pExpr->pConfig->eDetail==FTS5_DETAIL_FULL ){
235988 Fts5Expr *pExpr,
236003 rc = fts5ExprNodeTest_TERM(pExpr, pNode);
236012 Fts5Expr *pExpr, /* Expression of which pNode is a part */
236020 int cmp = fts5NodeCompare(pExpr, pNext, pChild);
236031 Fts5Expr *pExpr,
236041 assert( p1->bEof || fts5RowidCmp(pExpr, p1->iRowid, iLast)>=0 );
236044 || (bFromValid && fts5RowidCmp(pExpr, p1->iRowid, iFrom)<0)
236046 int rc = fts5ExprNodeNext(pExpr, p1, bFromValid, iFrom);
236055 fts5ExprNodeTest_OR(pExpr, pNode);
236063 Fts5Expr *pExpr, /* Expression pPhrase belongs to */
236077 int cmp = fts5RowidCmp(pExpr, iLast, pChild->iRowid);
236080 rc = fts5ExprNodeNext(pExpr, pChild, 1, iLast);
236091 assert( pChild->bEof || fts5RowidCmp(pExpr, iLast, pChild->iRowid)<=0 );
236107 if( pAnd->bNomatch && pAnd!=pExpr->pRoot ){
236115 Fts5Expr *pExpr,
236120 int rc = fts5ExprNodeNext(pExpr, pNode->apChild[0], bFromValid, iFrom);
236122 rc = fts5ExprNodeTest_AND(pExpr, pNode);
236130 Fts5Expr *pExpr, /* Expression pPhrase belongs to */
236139 int cmp = fts5NodeCompare(pExpr, p1, p2);
236141 rc = fts5ExprNodeNext(pExpr, p2, 1, p1->iRowid);
236142 cmp = fts5NodeCompare(pExpr, p1, p2);
236146 rc = fts5ExprNodeNext(pExpr, p1, 0, 0);
236158 Fts5Expr *pExpr,
236163 int rc = fts5ExprNodeNext(pExpr, pNode->apChild[0], bFromValid, iFrom);
236165 rc = fts5ExprNodeTest_NOT(pExpr, pNode);
236179 Fts5Expr *pExpr, /* Expression of which pNode is a part */
236187 rc = fts5ExprNodeTest_STRING(pExpr, pNode);
236192 rc = fts5ExprNodeTest_TERM(pExpr, pNode);
236197 rc = fts5ExprNodeTest_AND(pExpr, pNode);
236202 fts5ExprNodeTest_OR(pExpr, pNode);
236207 rc = fts5ExprNodeTest_NOT(pExpr, pNode);
236223 static int fts5ExprNodeFirst(Fts5Expr *pExpr, Fts5ExprNode *pNode){
236230 rc = fts5ExprNearInitAll(pExpr, pNode);
236238 rc = fts5ExprNodeFirst(pExpr, pNode->apChild[i]);
236261 rc = fts5ExprNodeTest(pExpr, pNode);
236548 assert( pParse->pExpr==0 );
236549 pParse->pExpr = p;
236627 Fts5Expr *pExpr,
236635 if( iPhrase<0 || iPhrase>=pExpr->nPhrase ){
236638 pOrig = pExpr->apExprPhrase[iPhrase];
236670 sCtx.pConfig = pExpr->pConfig;
236692 pNew->pIndex = pExpr->pIndex;
236693 pNew->pConfig = pExpr->pConfig;
236956 Fts5ExprNode *pExpr,
236965 fts5ParseSetColset(pParse, pExpr, pColset, &pFree);
237298 Fts5ExprNode *pExpr
237301 if( pExpr->eType==FTS5_STRING || pExpr->eType==FTS5_TERM ){
237302 Fts5ExprNearset *pNear = pExpr->pNear;
237349 }else if( pExpr->eType==0 ){
237354 switch( pExpr->eType ){
237358 assert( pExpr->eType==FTS5_OR );
237364 for(i=0; zRet && i<pExpr->nChild; i++){
237365 char *z = fts5ExprPrintTcl(pConfig, zNearsetCmd, pExpr->apChild[i]);
237378 static char *fts5ExprPrint(Fts5Config *pConfig, Fts5ExprNode *pExpr){
237380 if( pExpr->eType==0 ){
237383 if( pExpr->eType==FTS5_STRING || pExpr->eType==FTS5_TERM ){
237384 Fts5ExprNearset *pNear = pExpr->pNear;
237436 switch( pExpr->eType ){
237440 assert( pExpr->eType==FTS5_OR );
237445 for(i=0; i<pExpr->nChild; i++){
237446 char *z = fts5ExprPrint(pConfig, pExpr->apChild[i]);
237451 int e = pExpr->apChild[i]->eType;
237479 Fts5Expr *pExpr = 0;
237522 rc = sqlite3Fts5ExprNew(pConfig, 0, pConfig->nCol, zExpr, &pExpr, &zErr);
237526 if( pExpr->pRoot->xNext==0 ){
237529 zText = fts5ExprPrintTcl(pConfig, zNearsetCmd, pExpr->pRoot);
237531 zText = fts5ExprPrint(pConfig, pExpr->pRoot);
237551 sqlite3Fts5ExprFree(pExpr);
237655 static int sqlite3Fts5ExprPhraseCount(Fts5Expr *pExpr){
237656 return (pExpr ? pExpr->nPhrase : 0);
237662 static int sqlite3Fts5ExprPhraseSize(Fts5Expr *pExpr, int iPhrase){
237663 if( iPhrase<0 || iPhrase>=pExpr->nPhrase ) return 0;
237664 return pExpr->apExprPhrase[iPhrase]->nTerm;
237671 static int sqlite3Fts5ExprPoslist(Fts5Expr *pExpr, int iPhrase, const u8 **pa){
237673 Fts5ExprPhrase *pPhrase = pExpr->apExprPhrase[iPhrase];
237675 if( pNode->bEof==0 && pNode->iRowid==pExpr->pRoot->iRowid ){
237700 static Fts5PoslistPopulator *sqlite3Fts5ExprClearPoslists(Fts5Expr *pExpr, int bLive){
237702 pRet = sqlite3_malloc64(sizeof(Fts5PoslistPopulator)*pExpr->nPhrase);
237705 memset(pRet, 0, sizeof(Fts5PoslistPopulator)*pExpr->nPhrase);
237706 for(i=0; i<pExpr->nPhrase; i++){
237707 Fts5Buffer *pBuf = &pExpr->apExprPhrase[i]->poslist;
237708 Fts5ExprNode *pNode = pExpr->apExprPhrase[i]->pNode;
237709 assert( pExpr->apExprPhrase[i]->nTerm<=1 );
237711 (pBuf->n==0 || pNode->iRowid!=pExpr->pRoot->iRowid || pNode->bEof)
237723 Fts5Expr *pExpr;
237760 Fts5Expr *pExpr = p->pExpr;
237763 i64 iRowid = pExpr->pRoot->iRowid;
237768 if( pExpr->pConfig->bTokendata ){
237772 for(i=0; i<pExpr->nPhrase; i++){
237775 for(pT=&pExpr->apExprPhrase[i]->aTerm[0]; pT; pT=pT->pSynonym){
237780 &pExpr->apExprPhrase[i]->poslist, &p->aPopulator[i].writer, p->iOff
237782 if( rc==SQLITE_OK && pExpr->pConfig->bTokendata && !pT->bPrefix ){
237799 Fts5Expr *pExpr,
237806 sCtx.pExpr = pExpr;
237810 for(i=0; i<pExpr->nPhrase; i++){
237811 Fts5ExprNode *pNode = pExpr->apExprPhrase[i]->pNode;
237882 static void sqlite3Fts5ExprCheckPoslists(Fts5Expr *pExpr, i64 iRowid){
237883 fts5ExprCheckPoslists(pExpr->pRoot, iRowid);
237890 Fts5Expr *pExpr,
237895 Fts5ExprPhrase *pPhrase = pExpr->apExprPhrase[iPhrase];
237899 assert( iPhrase>=0 && iPhrase<pExpr->nPhrase );
237900 assert( pExpr->pConfig->eDetail==FTS5_DETAIL_COLUMNS );
237903 && pNode->iRowid==pExpr->pRoot->iRowid
237928 Fts5Expr *pExpr,
237936 if( iPhrase<0 || iPhrase>=pExpr->nPhrase ){
237939 pPhrase = pExpr->apExprPhrase[iPhrase];
237953 Fts5Expr *pExpr,
237966 if( iPhrase<0 || iPhrase>=pExpr->nPhrase ){
237969 pPhrase = pExpr->apExprPhrase[iPhrase];
237975 if( pExpr->pConfig->bTokendata ){
237991 static void sqlite3Fts5ExprClearTokens(Fts5Expr *pExpr){
237993 for(ii=0; ii<pExpr->nPhrase; ii++){
237995 for(pT=&pExpr->apExprPhrase[ii]->aTerm[0]; pT; pT=pT->pSynonym){
247839 Fts5Expr *pExpr; /* Expression for MATCH queries */
248428 sqlite3Fts5ExprFree(pCsr->pExpr);
248542 i64 iRowid = sqlite3Fts5ExprRowid(pCsr->pExpr);
248544 rc = sqlite3Fts5ExprFirst(pCsr->pExpr, pTab->p.pIndex, iRowid, bDesc);
248545 if( rc==SQLITE_OK && iRowid!=sqlite3Fts5ExprRowid(pCsr->pExpr) ){
248551 if( sqlite3Fts5ExprEof(pCsr->pExpr) ){
248584 sqlite3Fts5ExprClearTokens(pCsr->pExpr);
248590 rc = sqlite3Fts5ExprNext(pCsr->pExpr, pCsr->iLastRowid);
248591 CsrFlagSet(pCsr, sqlite3Fts5ExprEof(pCsr->pExpr));
248673 nPhrase = sqlite3Fts5ExprPhraseCount(pCsr->pExpr);
248714 Fts5Expr *pExpr = pCsr->pExpr;
248715 rc = sqlite3Fts5ExprFirst(pExpr, pTab->p.pIndex, pCsr->iFirstRowid, bDesc);
248716 if( sqlite3Fts5ExprEof(pExpr) ){
248906 Fts5Expr *pExpr = 0;
248921 assert( pCsr->pExpr==0 );
248954 rc = sqlite3Fts5ExprNew(pConfig, 0, iCol, zText, &pExpr, pzErr);
248956 rc = sqlite3Fts5ExprAnd(&pCsr->pExpr, pExpr);
248957 pExpr = 0;
248974 rc = sqlite3Fts5ExprPattern(pConfig, bGlob, iCol, zText, &pExpr);
248977 rc = sqlite3Fts5ExprAnd(&pCsr->pExpr, pExpr);
248978 pExpr = 0;
249034 pCsr->pExpr = pTab->pSortCsr->pExpr;
249036 }else if( pCsr->pExpr ){
249073 sqlite3Fts5ExprFree(pExpr);
249098 return sqlite3Fts5ExprRowid(pCsr->pExpr);
249155 assert( pCsr->pExpr );
249559 return sqlite3Fts5ExprPhraseCount(pCsr->pExpr);
249564 return sqlite3Fts5ExprPhraseSize(pCsr->pExpr, iPhrase);
249603 if( iPhrase<0 || iPhrase>=sqlite3Fts5ExprPhraseCount(pCsr->pExpr) ){
249609 aPopulator = sqlite3Fts5ExprClearPoslists(pCsr->pExpr, bLive);
249616 pConfig, pCsr->pExpr, aPopulator, i, z, n
249623 sqlite3Fts5ExprCheckPoslists(pCsr->pExpr, pCsr->pSorter->iRowid);
249636 *pn = sqlite3Fts5ExprPoslist(pCsr->pExpr, iPhrase, pa);
249658 nIter = sqlite3Fts5ExprPhraseCount(pCsr->pExpr);
249977 rc = sqlite3Fts5ExprPhraseCollist(pCsr->pExpr, iPhrase, &pIter->a, &n);
250015 return sqlite3Fts5ExprQueryToken(pCsr->pExpr, iPhrase, iToken, ppOut, pnOut);
250040 pCsr->pExpr, iRowid, iPhrase, iCol, iOff, iToken, ppOut, pnOut
250097 rc = sqlite3Fts5ExprClonePhrase(pCsr->pExpr, iPhrase, &pNew->pExpr);
250197 int nPhrase = sqlite3Fts5ExprPhraseCount(pCsr->pExpr);
250207 int nByte = sqlite3Fts5ExprPoslist(pCsr->pExpr, i, &dummy);
250215 nPoslist = sqlite3Fts5ExprPoslist(pCsr->pExpr, i, &pPoslist);
250226 rc = sqlite3Fts5ExprPhraseCollist(pCsr->pExpr, i, &dummy, &nByte);
250234 rc = sqlite3Fts5ExprPhraseCollist(pCsr->pExpr, i, &pPoslist, &nPoslist);