Lines Matching refs:pExpr
17575 Expr *pExpr; /* Used when p4type is P4_EXPR */ member
18173 SQLITE_PRIVATE int sqlite3CursorRangeHintExprCheck(Walker *pWalker, Expr *pExpr);
20252 Expr *pExpr; /* The parse tree for this expression */ member
20852 Expr *pExpr; /* The expression contained in the index */ member
22137 SQLITE_PRIVATE void sqlite3ExprToRegister(Expr *pExpr, int iReg);
22375 SQLITE_PRIVATE char sqlite3CompareAffinity(const Expr *pExpr, char aff2);
22376 SQLITE_PRIVATE int sqlite3IndexAffinityOk(const Expr *pExpr, char idx_affinity);
22378 SQLITE_PRIVATE char sqlite3ExprAffinity(const Expr *pExpr);
22379 SQLITE_PRIVATE int sqlite3ExprDataType(const Expr *pExpr);
22409 SQLITE_PRIVATE CollSeq *sqlite3ExprCollSeq(Parse *pParse, const Expr *pExpr);
22410 SQLITE_PRIVATE CollSeq *sqlite3ExprNNCollSeq(Parse *pParse, const Expr *pExpr);
22480 Expr *pExpr /* The parsed CHECK expression */
22902 SQLITE_PRIVATE int sqlite3ExprVectorSize(const Expr *pExpr);
22903 SQLITE_PRIVATE int sqlite3ExprIsVector(const Expr *pExpr);
33360 Expr *pExpr = va_arg(ap,Expr*); in sqlite3_str_vappendf() local
33361 if( ALWAYS(pExpr) && ALWAYS(!ExprHasProperty(pExpr,EP_IntValue)) ){ in sqlite3_str_vappendf()
33362 sqlite3_str_appendall(pAccum, (const char*)pExpr->u.zToken); in sqlite3_str_vappendf()
33363 sqlite3RecordErrorOffsetOfExpr(pAccum->db, pExpr); in sqlite3_str_vappendf()
33468 SQLITE_PRIVATE void sqlite3RecordErrorOffsetOfExpr(sqlite3 *db, const Expr *pExpr){ in sqlite3RecordErrorOffsetOfExpr() argument
33469 while( pExpr in sqlite3RecordErrorOffsetOfExpr()
33470 && (ExprHasProperty(pExpr,EP_OuterON|EP_InnerON) || pExpr->w.iOfst<=0) in sqlite3RecordErrorOffsetOfExpr()
33472 pExpr = pExpr->pLeft; in sqlite3RecordErrorOffsetOfExpr()
33474 if( pExpr==0 ) return; in sqlite3RecordErrorOffsetOfExpr()
33475 if( ExprHasProperty(pExpr, EP_FromDDL) ) return; in sqlite3RecordErrorOffsetOfExpr()
33476 db->errByteOffset = pExpr->w.iOfst; in sqlite3RecordErrorOffsetOfExpr()
34406 Expr *pExpr, /* Value for PRECEDING or FOLLOWING */ in sqlite3TreeViewBound() argument
34422 sqlite3TreeViewExpr(pView, pExpr, 0); in sqlite3TreeViewBound()
34428 sqlite3TreeViewExpr(pView, pExpr, 0); in sqlite3TreeViewBound()
34520 SQLITE_PRIVATE void sqlite3TreeViewExpr(TreeView *pView, const Expr *pExpr, u8 moreToFollow){ in sqlite3TreeViewExpr() argument
34525 if( pExpr==0 ){ in sqlite3TreeViewExpr()
34530 if( pExpr->flags || pExpr->affExpr || pExpr->vvaFlags || pExpr->pAggInfo ){ in sqlite3TreeViewExpr()
34534 pExpr->flags, pExpr->affExpr ? pExpr->affExpr : 'n'); in sqlite3TreeViewExpr()
34535 if( ExprHasProperty(pExpr, EP_OuterON) ){ in sqlite3TreeViewExpr()
34536 sqlite3_str_appendf(&x, " outer.iJoin=%d", pExpr->w.iJoin); in sqlite3TreeViewExpr()
34538 if( ExprHasProperty(pExpr, EP_InnerON) ){ in sqlite3TreeViewExpr()
34539 sqlite3_str_appendf(&x, " inner.iJoin=%d", pExpr->w.iJoin); in sqlite3TreeViewExpr()
34541 if( ExprHasProperty(pExpr, EP_FromDDL) ){ in sqlite3TreeViewExpr()
34544 if( ExprHasVVAProperty(pExpr, EP_Immutable) ){ in sqlite3TreeViewExpr()
34547 if( pExpr->pAggInfo!=0 ){ in sqlite3TreeViewExpr()
34548 sqlite3_str_appendf(&x, " agg-column[%d]", pExpr->iAgg); in sqlite3TreeViewExpr()
34554 switch( pExpr->op ){ in sqlite3TreeViewExpr()
34557 pExpr->iTable, pExpr->iColumn, zFlgs); in sqlite3TreeViewExpr()
34561 if( pExpr->iTable<0 ){ in sqlite3TreeViewExpr()
34564 if( pExpr->op2 ){ in sqlite3TreeViewExpr()
34565 sqlite3_snprintf(sizeof(zOp2),zOp2," op2=0x%02x",pExpr->op2); in sqlite3TreeViewExpr()
34570 pExpr->iColumn, zFlgs, zOp2); in sqlite3TreeViewExpr()
34572 assert( ExprUseYTab(pExpr) ); in sqlite3TreeViewExpr()
34574 pExpr->iTable, pExpr->iColumn, in sqlite3TreeViewExpr()
34575 pExpr->y.pTab, zFlgs); in sqlite3TreeViewExpr()
34577 if( ExprHasProperty(pExpr, EP_FixedCol) ){ in sqlite3TreeViewExpr()
34578 sqlite3TreeViewExpr(pView, pExpr->pLeft, 0); in sqlite3TreeViewExpr()
34583 if( pExpr->flags & EP_IntValue ){ in sqlite3TreeViewExpr()
34584 sqlite3TreeViewLine(pView, "%d", pExpr->u.iValue); in sqlite3TreeViewExpr()
34586 sqlite3TreeViewLine(pView, "%s", pExpr->u.zToken); in sqlite3TreeViewExpr()
34592 assert( !ExprHasProperty(pExpr, EP_IntValue) ); in sqlite3TreeViewExpr()
34593 sqlite3TreeViewLine(pView,"%s", pExpr->u.zToken); in sqlite3TreeViewExpr()
34598 assert( !ExprHasProperty(pExpr, EP_IntValue) ); in sqlite3TreeViewExpr()
34599 sqlite3TreeViewLine(pView,"%Q", pExpr->u.zToken); in sqlite3TreeViewExpr()
34608 sqlite3ExprTruthValue(pExpr) ? "TRUE" : "FALSE", zFlgs); in sqlite3TreeViewExpr()
34613 assert( !ExprHasProperty(pExpr, EP_IntValue) ); in sqlite3TreeViewExpr()
34614 sqlite3TreeViewLine(pView,"%s", pExpr->u.zToken); in sqlite3TreeViewExpr()
34619 assert( !ExprHasProperty(pExpr, EP_IntValue) ); in sqlite3TreeViewExpr()
34621 pExpr->u.zToken, pExpr->iColumn); in sqlite3TreeViewExpr()
34625 sqlite3TreeViewLine(pView,"REGISTER(%d)", pExpr->iTable); in sqlite3TreeViewExpr()
34629 assert( !ExprHasProperty(pExpr, EP_IntValue) ); in sqlite3TreeViewExpr()
34630 sqlite3TreeViewLine(pView,"ID \"%w\"", pExpr->u.zToken); in sqlite3TreeViewExpr()
34636 assert( !ExprHasProperty(pExpr, EP_IntValue) ); in sqlite3TreeViewExpr()
34637 sqlite3TreeViewLine(pView,"CAST %Q", pExpr->u.zToken); in sqlite3TreeViewExpr()
34638 sqlite3TreeViewExpr(pView, pExpr->pLeft, 0); in sqlite3TreeViewExpr()
34677 assert( pExpr->op2==TK_IS || pExpr->op2==TK_ISNOT ); in sqlite3TreeViewExpr()
34678 assert( pExpr->pRight ); in sqlite3TreeViewExpr()
34679 assert( sqlite3ExprSkipCollateAndLikely(pExpr->pRight)->op in sqlite3TreeViewExpr()
34681 x = (pExpr->op2==TK_ISNOT)*2 + sqlite3ExprTruthValue(pExpr->pRight); in sqlite3TreeViewExpr()
34687 assert( !ExprHasProperty(pExpr, EP_IntValue) ); in sqlite3TreeViewExpr()
34688 sqlite3TreeViewLine(pView, "SPAN %Q", pExpr->u.zToken); in sqlite3TreeViewExpr()
34689 sqlite3TreeViewExpr(pView, pExpr->pLeft, 0); in sqlite3TreeViewExpr()
34699 assert( !ExprHasProperty(pExpr, EP_IntValue) ); in sqlite3TreeViewExpr()
34701 !ExprHasProperty(pExpr, EP_Collate) ? "SOFT-" : "", in sqlite3TreeViewExpr()
34702 pExpr->u.zToken, zFlgs); in sqlite3TreeViewExpr()
34703 sqlite3TreeViewExpr(pView, pExpr->pLeft, 0); in sqlite3TreeViewExpr()
34711 if( ExprHasProperty(pExpr, EP_TokenOnly) ){ in sqlite3TreeViewExpr()
34715 assert( ExprUseXList(pExpr) ); in sqlite3TreeViewExpr()
34716 pFarg = pExpr->x.pList; in sqlite3TreeViewExpr()
34718 pWin = IsWindowFunc(pExpr) ? pExpr->y.pWin : 0; in sqlite3TreeViewExpr()
34723 assert( !ExprHasProperty(pExpr, EP_IntValue) ); in sqlite3TreeViewExpr()
34724 if( pExpr->op==TK_AGG_FUNCTION ){ in sqlite3TreeViewExpr()
34726 pExpr->op2, pExpr->u.zToken, zFlgs, in sqlite3TreeViewExpr()
34727 pExpr->pAggInfo ? pExpr->pAggInfo->selId : 0, in sqlite3TreeViewExpr()
34728 pExpr->iAgg, pExpr->pAggInfo); in sqlite3TreeViewExpr()
34729 }else if( pExpr->op2!=0 ){ in sqlite3TreeViewExpr()
34732 sqlite3_snprintf(sizeof(zBuf),zBuf,"0x%02x",pExpr->op2); in sqlite3TreeViewExpr()
34734 if( pExpr->op2==NC_IsCheck ) zOp2 = "NC_IsCheck"; in sqlite3TreeViewExpr()
34735 if( pExpr->op2==NC_IdxExpr ) zOp2 = "NC_IdxExpr"; in sqlite3TreeViewExpr()
34736 if( pExpr->op2==NC_PartIdx ) zOp2 = "NC_PartIdx"; in sqlite3TreeViewExpr()
34737 if( pExpr->op2==NC_GenCol ) zOp2 = "NC_GenCol"; in sqlite3TreeViewExpr()
34739 pExpr->u.zToken, zFlgs, zOp2); in sqlite3TreeViewExpr()
34741 sqlite3TreeViewLine(pView, "FUNCTION %Q%s", pExpr->u.zToken, zFlgs); in sqlite3TreeViewExpr()
34744 sqlite3TreeViewExprList(pView, pFarg, pWin!=0 || pExpr->pLeft, 0); in sqlite3TreeViewExpr()
34745 if( pExpr->pLeft ){ in sqlite3TreeViewExpr()
34746 Expr *pOB = pExpr->pLeft; in sqlite3TreeViewExpr()
34760 sqlite3TreeViewExprList(pView, pExpr->x.pList, 0, "ORDERBY"); in sqlite3TreeViewExpr()
34765 assert( ExprUseXSelect(pExpr) ); in sqlite3TreeViewExpr()
34766 sqlite3TreeViewLine(pView, "EXISTS-expr flags=0x%x", pExpr->flags); in sqlite3TreeViewExpr()
34767 sqlite3TreeViewSelect(pView, pExpr->x.pSelect, 0); in sqlite3TreeViewExpr()
34771 assert( ExprUseXSelect(pExpr) ); in sqlite3TreeViewExpr()
34772 sqlite3TreeViewLine(pView, "subquery-expr flags=0x%x", pExpr->flags); in sqlite3TreeViewExpr()
34773 sqlite3TreeViewSelect(pView, pExpr->x.pSelect, 0); in sqlite3TreeViewExpr()
34779 sqlite3_str_appendf(pStr, "IN flags=0x%x", pExpr->flags); in sqlite3TreeViewExpr()
34780 if( pExpr->iTable ) sqlite3_str_appendf(pStr, " iTable=%d",pExpr->iTable); in sqlite3TreeViewExpr()
34781 if( ExprHasProperty(pExpr, EP_Subrtn) ){ in sqlite3TreeViewExpr()
34783 pExpr->y.sub.regReturn, pExpr->y.sub.iAddr); in sqlite3TreeViewExpr()
34788 sqlite3TreeViewExpr(pView, pExpr->pLeft, 1); in sqlite3TreeViewExpr()
34789 if( ExprUseXSelect(pExpr) ){ in sqlite3TreeViewExpr()
34790 sqlite3TreeViewSelect(pView, pExpr->x.pSelect, 0); in sqlite3TreeViewExpr()
34792 sqlite3TreeViewExprList(pView, pExpr->x.pList, 0, 0); in sqlite3TreeViewExpr()
34811 pX = pExpr->pLeft; in sqlite3TreeViewExpr()
34812 assert( ExprUseXList(pExpr) ); in sqlite3TreeViewExpr()
34813 assert( pExpr->x.pList->nExpr==2 ); in sqlite3TreeViewExpr()
34814 pY = pExpr->x.pList->a[0].pExpr; in sqlite3TreeViewExpr()
34815 pZ = pExpr->x.pList->a[1].pExpr; in sqlite3TreeViewExpr()
34831 pExpr->iTable ? "NEW" : "OLD", pExpr->iColumn); in sqlite3TreeViewExpr()
34836 sqlite3TreeViewExpr(pView, pExpr->pLeft, 1); in sqlite3TreeViewExpr()
34837 assert( ExprUseXList(pExpr) ); in sqlite3TreeViewExpr()
34838 sqlite3TreeViewExprList(pView, pExpr->x.pList, 0, 0); in sqlite3TreeViewExpr()
34844 switch( pExpr->affExpr ){ in sqlite3TreeViewExpr()
34850 assert( !ExprHasProperty(pExpr, EP_IntValue) ); in sqlite3TreeViewExpr()
34852 sqlite3TreeViewExpr(pView, pExpr->pLeft, 0); in sqlite3TreeViewExpr()
34858 pExpr->iTable, pExpr->iColumn, zFlgs); in sqlite3TreeViewExpr()
34859 sqlite3TreeViewExpr(pView, pExpr->pRight, 0); in sqlite3TreeViewExpr()
34864 assert( ExprUseXList(pExpr) ); in sqlite3TreeViewExpr()
34865 sqlite3TreeViewBareExprList(pView, pExpr->x.pList, z); in sqlite3TreeViewExpr()
34871 pExpr->iColumn, pExpr->iTable-1, in sqlite3TreeViewExpr()
34872 pExpr->pRight==pExpr->pLeft ? " (SELECT-owner)" : ""); in sqlite3TreeViewExpr()
34873 assert( ExprUseXSelect(pExpr->pLeft) ); in sqlite3TreeViewExpr()
34874 sqlite3TreeViewSelect(pView, pExpr->pLeft->x.pSelect, 0); in sqlite3TreeViewExpr()
34878 sqlite3TreeViewLine(pView, "IF-NULL-ROW %d", pExpr->iTable); in sqlite3TreeViewExpr()
34879 sqlite3TreeViewExpr(pView, pExpr->pLeft, 0); in sqlite3TreeViewExpr()
34885 tmp = *pExpr; in sqlite3TreeViewExpr()
34886 tmp.op = pExpr->op2; in sqlite3TreeViewExpr()
34891 if( pExpr->iColumn<=0 ){ in sqlite3TreeViewExpr()
34895 pExpr->iColumn-1); in sqlite3TreeViewExpr()
34900 sqlite3TreeViewLine(pView, "op=%d", pExpr->op); in sqlite3TreeViewExpr()
34906 sqlite3TreeViewExpr(pView, pExpr->pLeft, 1); in sqlite3TreeViewExpr()
34907 sqlite3TreeViewExpr(pView, pExpr->pRight, 0); in sqlite3TreeViewExpr()
34910 sqlite3TreeViewExpr(pView, pExpr->pLeft, 0); in sqlite3TreeViewExpr()
34966 sqlite3TreeViewExpr(pView, pList->a[i].pExpr, moreToFollow); in sqlite3TreeViewBareExprList()
74225 Expr *pExpr; local
74230 pExpr = va_arg(ap, Expr*);
74233 assert( pExpr!=0 );
74235 sqlite3WalkExpr(&w, pExpr);
87350 rc = sqlite3Stat4ValueFromExpr(pCtx->pParse, pList->a[i].pExpr, aff,
87411 const Expr *pExpr, /* The expression to evaluate */ argument
87424 assert( pExpr!=0 );
87425 while( (op = pExpr->op)==TK_UPLUS || op==TK_SPAN ) pExpr = pExpr->pLeft;
87426 if( op==TK_REGISTER ) op = pExpr->op2;
87432 assert( (pExpr->flags & EP_TokenOnly)==0 || pCtx==0 );
87436 assert( !ExprHasProperty(pExpr, EP_IntValue) );
87437 aff = sqlite3AffinityType(pExpr->u.zToken,0);
87438 rc = valueFromExpr(db, pExpr->pLeft, enc, aff, ppVal, pCtx);
87458 Expr *pLeft = pExpr->pLeft;
87463 pExpr = pLeft;
87464 op = pExpr->op;
87474 if( ExprHasProperty(pExpr, EP_IntValue) ){
87475 sqlite3VdbeMemSetInt64(pVal, (i64)pExpr->u.iValue*negInt);
87478 if( op==TK_INTEGER && 0==sqlite3DecOrHexToI64(pExpr->u.zToken, &iVal) ){
87481 zVal = sqlite3MPrintf(db, "%s%s", zNeg, pExpr->u.zToken);
87511 if( SQLITE_OK==valueFromExpr(db,pExpr->pLeft,enc,affinity,&pVal,pCtx)
87537 assert( !ExprHasProperty(pExpr, EP_IntValue) );
87538 assert( pExpr->u.zToken[0]=='x' || pExpr->u.zToken[0]=='X' );
87539 assert( pExpr->u.zToken[1]=='\'' );
87542 zVal = &pExpr->u.zToken[2];
87551 rc = valueFromFunction(db, pExpr, enc, affinity, &pVal, pCtx);
87555 assert( !ExprHasProperty(pExpr, EP_IntValue) );
87559 pVal->u.i = pExpr->u.zToken[4]==0;
87594 const Expr *pExpr, /* The expression to evaluate */ argument
87599 return pExpr ? valueFromExpr(db, pExpr, enc, affinity, ppVal, 0) : 0;
87623 Expr *pExpr, /* The expression to extract a value from */ argument
87633 pExpr = sqlite3ExprSkipCollate(pExpr);
87635 assert( pExpr==0 || pExpr->op!=TK_REGISTER || pExpr->op2!=TK_VARIABLE );
87636 if( !pExpr ){
87641 }else if( pExpr->op==TK_VARIABLE && (db->flags & SQLITE_EnableQPSG)==0 ){
87643 int iBindVar = pExpr->iColumn;
87654 rc = valueFromExpr(db, pExpr, ENC(db), affinity, &pVal, pAlloc);
87700 Expr *pExpr, /* The expression to extract a value from */ argument
87708 if( pExpr==0 || pExpr->op!=TK_SELECT ){
87718 Expr *pElem = (pExpr ? sqlite3VectorFieldSubexpr(pExpr, i) : 0);
87743 Expr *pExpr, /* The expression to extract a value from */ argument
87747 return stat4ValueFromExpr(pParse, pExpr, affinity, 0, ppVal);
89704 static void displayP4Expr(StrAccum *p, Expr *pExpr){ argument
89706 switch( pExpr->op ){
89708 assert( !ExprHasProperty(pExpr, EP_IntValue) );
89709 sqlite3_str_appendf(p, "%Q", pExpr->u.zToken);
89712 sqlite3_str_appendf(p, "%d", pExpr->u.iValue);
89718 sqlite3_str_appendf(p, "r[%d]", pExpr->iTable);
89722 if( pExpr->iColumn<0 ){
89725 sqlite3_str_appendf(p, "c%d", (int)pExpr->iColumn);
89763 displayP4Expr(p, pExpr->pLeft);
89764 if( pExpr->pRight ){
89766 displayP4Expr(p, pExpr->pRight);
89804 displayP4Expr(&x, pOp->p4.pExpr);
93533 SQLITE_PRIVATE int sqlite3CursorRangeHintExprCheck(Walker *pWalker, Expr *pExpr){ argument
93534 if( pExpr->op==TK_REGISTER ){
93535 assert( (pWalker->u.aMem[pExpr->iTable].flags & MEM_Undefined)==0 );
95971 pDflt = p->pTab->u.tab.pDfltList->a[pCol->iDflt-1].pExpr;
105740 pOp->p4.pExpr, aMem);
110283 SQLITE_PRIVATE SQLITE_NOINLINE int sqlite3WalkExprNN(Walker *pWalker, Expr *pExpr){ argument
110285 testcase( ExprHasProperty(pExpr, EP_TokenOnly) );
110286 testcase( ExprHasProperty(pExpr, EP_Reduced) );
110288 rc = pWalker->xExprCallback(pWalker, pExpr);
110290 if( !ExprHasProperty(pExpr,(EP_TokenOnly|EP_Leaf)) ){
110291 assert( pExpr->x.pList==0 || pExpr->pRight==0 );
110292 if( pExpr->pLeft && sqlite3WalkExprNN(pWalker, pExpr->pLeft) ){
110295 if( pExpr->pRight ){
110296 assert( !ExprHasProperty(pExpr, EP_WinFunc) );
110297 pExpr = pExpr->pRight;
110299 }else if( ExprUseXSelect(pExpr) ){
110300 assert( !ExprHasProperty(pExpr, EP_WinFunc) );
110301 if( sqlite3WalkSelect(pWalker, pExpr->x.pSelect) ) return WRC_Abort;
110303 if( pExpr->x.pList ){
110304 if( sqlite3WalkExprList(pWalker, pExpr->x.pList) ) return WRC_Abort;
110307 if( ExprHasProperty(pExpr, EP_WinFunc) ){
110308 if( walkWindowList(pWalker, pExpr->y.pWin, 1) ) return WRC_Abort;
110317 SQLITE_PRIVATE int sqlite3WalkExpr(Walker *pWalker, Expr *pExpr){ argument
110318 return pExpr ? sqlite3WalkExprNN(pWalker,pExpr) : WRC_Continue;
110330 if( sqlite3WalkExpr(pWalker, pItem->pExpr) ) return WRC_Abort;
110518 static int incrAggDepth(Walker *pWalker, Expr *pExpr){ argument
110519 if( pExpr->op==TK_AGG_FUNCTION ) pExpr->op2 += pWalker->u.n;
110522 static void incrAggFunctionDepth(Expr *pExpr, int N){ argument
110528 sqlite3WalkExpr(&w, pExpr);
110555 Expr *pExpr, /* Transform this into an alias to the result set */ argument
110563 pOrig = pEList->a[iCol].pExpr;
110565 assert( !ExprHasProperty(pExpr, EP_Reduced|EP_TokenOnly) );
110566 if( pExpr->pAggInfo ) return;
110575 if( pExpr->op==TK_COLLATE ){
110576 assert( !ExprHasProperty(pExpr, EP_IntValue) );
110577 pDup = sqlite3ExprAddCollateString(pParse, pDup, pExpr->u.zToken);
110580 memcpy(pDup, pExpr, sizeof(Expr));
110581 memcpy(pExpr, &temp, sizeof(Expr));
110582 if( ExprHasProperty(pExpr, EP_WinFunc) ){
110583 if( ALWAYS(pExpr->y.pWin!=0) ){
110584 pExpr->y.pWin->pOwner = pExpr;
110662 SQLITE_PRIVATE Bitmask sqlite3ExprColUsed(Expr *pExpr){ argument
110666 n = pExpr->iColumn;
110667 assert( ExprUseYTab(pExpr) );
110668 pExTab = pExpr->y.pTab;
110767 Expr *pExpr /* Make this EXPR node point to the selected column */ argument
110786 assert( !ExprHasProperty(pExpr, EP_TokenOnly|EP_Reduced) );
110789 pExpr->iTable = -1;
110790 ExprSetVVAProperty(pExpr, EP_NoReduce);
110880 extendFJMatch(pParse, &pFJMatch, pMatch, pExpr->iColumn);
110892 pExpr->iColumn = j;
110915 assert( ExprUseYTab(pExpr) );
110917 sqlite3RenameTokenRemap(pParse, 0, (void*)&pExpr->y.pTab);
110943 extendFJMatch(pParse, &pFJMatch, pMatch, pExpr->iColumn);
110949 pExpr->iColumn = j==pTab->iPKey ? -1 : (i16)j;
110989 pExpr->iTable = pMatch->iCursor;
110990 assert( ExprUseYTab(pExpr) );
110991 pExpr->y.pTab = pMatch->pSTab;
110993 ExprSetProperty(pExpr, EP_CanBeNull);
110995 pSchema = pExpr->y.pTab->pSchema;
111017 pExpr->iTable = op!=TK_DELETE;
111021 pExpr->iTable = 1;
111024 pExpr->iTable = 0;
111034 pExpr->iTable = EXCLUDED_TABLE_NUMBER;
111057 if( pExpr->iTable==EXCLUDED_TABLE_NUMBER ){
111059 assert( ExprUseYTab(pExpr) );
111061 pExpr->iColumn = iCol;
111062 pExpr->y.pTab = pTab;
111065 pExpr->iTable = pNC->uNC.pUpsert->regData +
111072 assert( ExprUseYTab(pExpr) );
111073 pExpr->y.pTab = pTab;
111076 pExpr->op2 = TK_COLUMN;
111077 pExpr->iColumn = iCol;
111078 pExpr->iTable = pNC->uNC.iBaseReg + (pTab->nCol+1)*pExpr->iTable +
111081 pExpr->iColumn = (i16)iCol;
111085 pExpr->affExpr = SQLITE_AFF_INTEGER;
111086 }else if( pExpr->iTable==0 ){
111119 if( pMatch->fg.isNestedFrom==0 ) pExpr->iColumn = -1;
111120 pExpr->affExpr = SQLITE_AFF_INTEGER;
111153 assert( pExpr->pLeft==0 && pExpr->pRight==0 );
111154 assert( ExprUseXList(pExpr)==0 || pExpr->x.pList==0 );
111155 assert( ExprUseXSelect(pExpr)==0 || pExpr->x.pSelect==0 );
111156 pOrig = pEList->a[j].pExpr;
111171 resolveAlias(pParse, pEList, j, pExpr, nSubquery);
111176 sqlite3RenameTokenRemap(pParse, 0, (void*)pExpr);
111203 assert( pExpr->op==TK_ID );
111204 if( ExprHasProperty(pExpr,EP_DblQuoted)
111226 pExpr->op = TK_STRING;
111227 memset(&pExpr->y, 0, sizeof(pExpr->y));
111230 if( sqlite3ExprIdToTrueFalse(pExpr) ){
111243 assert( !ExprHasProperty(pExpr, EP_xIsSelect|EP_IntValue) );
111248 if( ExprHasProperty(pExpr,EP_Leaf) ){
111249 ExprClearProperty(pExpr,EP_Leaf);
111251 sqlite3ExprDelete(db, pExpr->pLeft);
111252 pExpr->pLeft = 0;
111253 sqlite3ExprDelete(db, pExpr->pRight);
111254 pExpr->pRight = 0;
111256 extendFJMatch(pParse, &pFJMatch, pMatch, pExpr->iColumn);
111257 pExpr->op = TK_FUNCTION;
111258 pExpr->u.zToken = "coalesce";
111259 pExpr->x.pList = pFJMatch;
111260 pExpr->affExpr = SQLITE_AFF_DEFER;
111280 sqlite3RecordErrorOffsetOfExpr(pParse->db, pExpr);
111288 if( !ExprHasProperty(pExpr,(EP_TokenOnly|EP_Leaf)) ){
111289 sqlite3ExprDelete(db, pExpr->pLeft);
111290 pExpr->pLeft = 0;
111291 sqlite3ExprDelete(db, pExpr->pRight);
111292 pExpr->pRight = 0;
111293 ExprSetProperty(pExpr, EP_Leaf);
111311 if( pExpr->iColumn>=0 ){
111312 pMatch->colUsed |= sqlite3ExprColUsed(pExpr);
111318 pExpr->op = eNewExprOp;
111324 && (pExpr->op==TK_COLUMN || pExpr->op==TK_TRIGGER)
111326 sqlite3AuthRead(pParse, pExpr, pSchema, pNC->pSrcList);
111395 Expr *pExpr, /* Invalidate this expression on error */ argument
111407 if( pExpr ) pExpr->op = TK_NULL;
111439 Expr *pExpr = pList->a[ii].pExpr; local
111440 ExprSetProperty(pExpr, EP_SubtArg);
111441 if( pExpr->op==TK_SELECT ){
111442 assert( ExprUseXSelect(pExpr) );
111443 assert( pExpr->x.pSelect!=0 );
111444 resolveSetExprSubtypeArg(pExpr->x.pSelect->pEList);
111460 static int resolveExprStep(Walker *pWalker, Expr *pExpr){ argument
111478 switch( pExpr->op ){
111490 pExpr->op = TK_COLUMN;
111491 assert( ExprUseYTab(pExpr) );
111492 pExpr->y.pTab = pItem->pSTab;
111493 pExpr->iTable = pItem->iCursor;
111494 pExpr->iColumn--;
111495 pExpr->affExpr = SQLITE_AFF_INTEGER;
111534 sqlite3WalkExpr(pWalker, pExpr->pLeft);
111536 if( sqlite3ExprCanBeNull(pExpr->pLeft) ){
111546 testcase( ExprHasProperty(pExpr, EP_OuterON) );
111547 assert( !ExprHasProperty(pExpr, EP_IntValue) );
111552 pExpr->op==TK_NOTNULL
111554 sqlite3ShowExpr(pExpr);
111557 pExpr->u.iValue = (pExpr->op==TK_NOTNULL);
111558 pExpr->flags |= EP_IntValue;
111559 pExpr->op = TK_INTEGER;
111563 sqlite3ExprDelete(pParse->db, pExpr->pLeft);
111564 pExpr->pLeft = 0;
111582 if( pExpr->op==TK_ID ){
111585 assert( !ExprHasProperty(pExpr, EP_IntValue) );
111586 pRight = pExpr;
111588 Expr *pLeft = pExpr->pLeft;
111592 NC_IdxExpr|NC_GenCol, 0, pExpr);
111593 pRight = pExpr->pRight;
111605 assert( ExprUseYTab(pExpr) );
111607 sqlite3RenameTokenRemap(pParse, (void*)pExpr, (void*)pRight);
111608 sqlite3RenameTokenRemap(pParse, (void*)&pExpr->y.pTab, (void*)pLeft);
111611 return lookupName(pParse, zDb, zTable, pRight, pNC, pExpr);
111627 Window *pWin = (IsWindowFunc(pExpr) ? pExpr->y.pWin : 0);
111629 assert( !ExprHasProperty(pExpr, EP_xIsSelect|EP_IntValue) );
111630 assert( pExpr->pLeft==0 || pExpr->pLeft->op==TK_ORDER );
111631 pList = pExpr->x.pList;
111633 zId = pExpr->u.zToken;
111645 ExprSetProperty(pExpr, EP_Unlikely);
111647 pExpr->iTable = exprProbability(pList->a[1].pExpr);
111648 if( pExpr->iTable<0 ){
111651 "constant between 0.0 and 1.0", pExpr);
111664 pExpr->iTable = pDef->zName[0]=='u' ? 8388608 : 125829120;
111673 pExpr);
111676 pExpr->op = TK_NULL;
111691 || ExprHasProperty(pExpr, EP_SubtArg)
111701 ExprSetProperty(pExpr,EP_ConstFunc);
111711 NC_IdxExpr|NC_PartIdx|NC_GenCol, 0, pExpr);
111714 pExpr->op2 = pNC->ncFlags & NC_SelfRef;
111730 if( pNC->ncFlags & NC_FromDDL ) ExprSetProperty(pExpr, EP_FromDDL);
111731 sqlite3ExprFunctionUsable(pParse, pExpr, pDef);
111743 "%#T() may not be used as a window function", pExpr
111757 sqlite3ErrorMsg(pParse, "misuse of %s function %#T()",zType,pExpr);
111763 sqlite3ErrorMsg(pParse,"misuse of aggregate function %#T()",pExpr);
111773 sqlite3ErrorMsg(pParse, "no such function: %#T", pExpr);
111777 pExpr);
111781 else if( is_agg==0 && ExprHasProperty(pExpr, EP_WinFunc) ){
111784 pExpr
111789 else if( is_agg==0 && pExpr->pLeft ){
111790 sqlite3ExprOrderByAggregateError(pParse, pExpr);
111804 else if( ExprHasProperty(pExpr, EP_WinFunc) || pExpr->pLeft ){
111809 if( pExpr->pLeft ){
111810 assert( pExpr->pLeft->op==TK_ORDER );
111811 assert( ExprUseXList(pExpr->pLeft) );
111812 sqlite3WalkExprList(pWalker, pExpr->pLeft->x.pList);
111817 assert( ExprUseYWin(pExpr) && pWin==pExpr->y.pWin );
111831 pExpr->op = TK_AGG_FUNCTION;
111832 pExpr->op2 = 0;
111834 if( ExprHasProperty(pExpr, EP_WinFunc) ){
111835 sqlite3WalkExpr(pWalker, pExpr->y.pWin->pFilter);
111840 && sqlite3ReferencesSrcList(pParse, pExpr, pNC2->pSrcList)==0
111842 pExpr->op2 += (1 + pNC2->nNestedSelect);
111847 pExpr->op2 += pNC2->nNestedSelect;
111869 testcase( pExpr->op==TK_IN );
111870 testcase( pExpr->op==TK_EXISTS );
111871 testcase( pExpr->op==TK_SELECT );
111872 if( ExprUseXSelect(pExpr) ){
111878 assert( pExpr->x.pSelect );
111879 if( pExpr->op==TK_EXISTS ) pParse->bHasExists = 1;
111881 notValidImpl(pParse, pNC, "subqueries", pExpr, pExpr);
111883 sqlite3WalkSelect(pWalker, pExpr->x.pSelect);
111887 ExprSetProperty(pExpr, EP_VarSelect);
111888 pExpr->x.pSelect->selFlags |= SF_Correlated;
111900 NC_IsCheck|NC_PartIdx|NC_IdxExpr|NC_GenCol, pExpr, pExpr);
111905 Expr *pRight = sqlite3ExprSkipCollateAndLikely(pExpr->pRight);
111906 assert( !ExprHasProperty(pExpr, EP_Reduced) );
111913 pExpr->op2 = pExpr->op;
111914 pExpr->op = TK_TRUTH;
111929 assert( pExpr->pLeft!=0 );
111930 nLeft = sqlite3ExprVectorSize(pExpr->pLeft);
111931 if( pExpr->op==TK_BETWEEN ){
111932 assert( ExprUseXList(pExpr) );
111933 nRight = sqlite3ExprVectorSize(pExpr->x.pList->a[0].pExpr);
111935 nRight = sqlite3ExprVectorSize(pExpr->x.pList->a[1].pExpr);
111938 assert( pExpr->pRight!=0 );
111939 nRight = sqlite3ExprVectorSize(pExpr->pRight);
111942 testcase( pExpr->op==TK_EQ );
111943 testcase( pExpr->op==TK_NE );
111944 testcase( pExpr->op==TK_LT );
111945 testcase( pExpr->op==TK_LE );
111946 testcase( pExpr->op==TK_GT );
111947 testcase( pExpr->op==TK_GE );
111948 testcase( pExpr->op==TK_IS );
111949 testcase( pExpr->op==TK_ISNOT );
111950 testcase( pExpr->op==TK_BETWEEN );
111952 sqlite3RecordErrorOffsetOfExpr(pParse->db, pExpr);
112050 if( sqlite3ExprCompare(0, pEList->a[i].pExpr, pE, -1)<2 ){
112124 pE = sqlite3ExprSkipCollateAndLikely(pItem->pExpr);
112162 if( pItem->pExpr==pE ){
112163 pItem->pExpr = pNew;
112165 Expr *pParent = pItem->pExpr;
112225 resolveAlias(pParse, pEList, pItem->u.x.iOrderByCol-1, pItem->pExpr,0);
112235 static int resolveRemoveWindowsCb(Walker *pWalker, Expr *pExpr){ argument
112237 if( ExprHasProperty(pExpr, EP_WinFunc) ){
112238 Window *pWin = pExpr->y.pWin;
112248 static void windowRemoveExprFromSelect(Select *pSelect, Expr *pExpr){ argument
112254 sqlite3WalkExpr(&sWalker, pExpr);
112295 Expr *pE = pItem->pExpr;
112327 if( sqlite3ExprCompare(0, pE, pSelect->pEList->a[j].pExpr, -1)==0 ){
112562 if( ExprHasProperty(pItem->pExpr, EP_Agg) ){
112651 Expr *pExpr /* The expression to be analyzed. */ argument
112656 if( pExpr==0 ) return SQLITE_OK;
112665 w.pParse->nHeight += pExpr->nHeight;
112670 assert( pExpr!=0 );
112671 sqlite3WalkExprNN(&w, pExpr);
112673 w.pParse->nHeight -= pExpr->nHeight;
112679 ExprSetProperty(pExpr, pNC->ncFlags & (NC_HasAgg|NC_HasWin) );
112708 Expr *pExpr = pList->a[i].pExpr; local
112709 if( pExpr==0 ) continue;
112711 w.pParse->nHeight += pExpr->nHeight;
112716 sqlite3WalkExprNN(&w, pExpr);
112718 w.pParse->nHeight -= pExpr->nHeight;
112725 ExprSetProperty(pExpr, pNC->ncFlags & (NC_HasAgg|NC_HasWin) );
112786 Expr *pExpr, /* Expression to resolve. May be NULL. */ argument
112817 if( (rc = sqlite3ResolveExprNames(&sNC, pExpr))!=SQLITE_OK ) return rc;
112868 SQLITE_PRIVATE char sqlite3ExprAffinity(const Expr *pExpr){ argument
112870 op = pExpr->op;
112872 if( op==TK_COLUMN || (op==TK_AGG_COLUMN && pExpr->y.pTab!=0) ){
112873 assert( ExprUseYTab(pExpr) );
112874 assert( pExpr->y.pTab!=0 );
112875 return sqlite3TableColumnAffinity(pExpr->y.pTab, pExpr->iColumn);
112878 assert( ExprUseXSelect(pExpr) );
112879 assert( pExpr->x.pSelect!=0 );
112880 assert( pExpr->x.pSelect->pEList!=0 );
112881 assert( pExpr->x.pSelect->pEList->a[0].pExpr!=0 );
112882 return sqlite3ExprAffinity(pExpr->x.pSelect->pEList->a[0].pExpr);
112886 assert( !ExprHasProperty(pExpr, EP_IntValue) );
112887 return sqlite3AffinityType(pExpr->u.zToken, 0);
112891 assert( pExpr->pLeft!=0 && ExprUseXSelect(pExpr->pLeft) );
112892 assert( pExpr->iColumn < pExpr->iTable );
112893 assert( pExpr->iColumn >= 0 );
112894 assert( pExpr->iTable==pExpr->pLeft->x.pSelect->pEList->nExpr );
112896 pExpr->pLeft->x.pSelect->pEList->a[pExpr->iColumn].pExpr
112900 || (op==TK_FUNCTION && pExpr->affExpr==SQLITE_AFF_DEFER)
112902 assert( ExprUseXList(pExpr) );
112903 return sqlite3ExprAffinity(pExpr->x.pList->a[0].pExpr);
112905 if( ExprHasProperty(pExpr, EP_Skip|EP_IfNullRow) ){
112906 assert( pExpr->op==TK_COLLATE
112907 || pExpr->op==TK_IF_NULL_ROW
112908 || (pExpr->op==TK_REGISTER && pExpr->op2==TK_IF_NULL_ROW) );
112909 pExpr = pExpr->pLeft;
112910 op = pExpr->op;
112914 op = pExpr->op2;
112917 return pExpr->affExpr;
112930 SQLITE_PRIVATE int sqlite3ExprDataType(const Expr *pExpr){ argument
112931 while( pExpr ){
112932 switch( pExpr->op ){
112936 pExpr = pExpr->pLeft;
112940 pExpr = 0;
112963 int aff = sqlite3ExprAffinity(pExpr);
112971 ExprList *pList = pExpr->x.pList;
112972 assert( ExprUseXList(pExpr) && pList!=0 );
112975 res |= sqlite3ExprDataType(pList->a[ii].pExpr);
112978 res |= sqlite3ExprDataType(pList->a[pList->nExpr-1].pExpr);
113000 Expr *pExpr, /* Add the "COLLATE" clause to this expression */ argument
113007 pNew->pLeft = pExpr;
113009 pExpr = pNew;
113012 return pExpr;
113016 Expr *pExpr, /* Add the "COLLATE" clause to this expression */ argument
113022 return sqlite3ExprAddCollateToken(pParse, pExpr, &s, 0);
113028 SQLITE_PRIVATE Expr *sqlite3ExprSkipCollate(Expr *pExpr){ argument
113029 while( pExpr && ExprHasProperty(pExpr, EP_Skip) ){
113030 assert( pExpr->op==TK_COLLATE );
113031 pExpr = pExpr->pLeft;
113033 return pExpr;
113041 SQLITE_PRIVATE Expr *sqlite3ExprSkipCollateAndLikely(Expr *pExpr){ argument
113042 while( pExpr && ExprHasProperty(pExpr, EP_Skip|EP_Unlikely) ){
113043 if( ExprHasProperty(pExpr, EP_Unlikely) ){
113044 assert( ExprUseXList(pExpr) );
113045 assert( pExpr->x.pList->nExpr>0 );
113046 assert( pExpr->op==TK_FUNCTION );
113047 pExpr = pExpr->x.pList->a[0].pExpr;
113048 }else if( pExpr->op==TK_COLLATE ){
113049 pExpr = pExpr->pLeft;
113054 return pExpr;
113071 SQLITE_PRIVATE CollSeq *sqlite3ExprCollSeq(Parse *pParse, const Expr *pExpr){ argument
113074 const Expr *p = pExpr;
113098 p = p->x.pList->a[0].pExpr;
113116 if( ExprHasProperty(p->x.pList->a[i].pExpr, EP_Collate) ){
113117 pNext = p->x.pList->a[i].pExpr;
113144 SQLITE_PRIVATE CollSeq *sqlite3ExprNNCollSeq(Parse *pParse, const Expr *pExpr){ argument
113145 CollSeq *p = sqlite3ExprCollSeq(pParse, pExpr);
113165 SQLITE_PRIVATE char sqlite3CompareAffinity(const Expr *pExpr, char aff2){ argument
113166 char aff1 = sqlite3ExprAffinity(pExpr);
113187 static char comparisonAffinity(const Expr *pExpr){ argument
113189 assert( pExpr->op==TK_EQ || pExpr->op==TK_IN || pExpr->op==TK_LT ||
113190 pExpr->op==TK_GT || pExpr->op==TK_GE || pExpr->op==TK_LE ||
113191 pExpr->op==TK_NE || pExpr->op==TK_IS || pExpr->op==TK_ISNOT );
113192 assert( pExpr->pLeft );
113193 aff = sqlite3ExprAffinity(pExpr->pLeft);
113194 if( pExpr->pRight ){
113195 aff = sqlite3CompareAffinity(pExpr->pRight, aff);
113196 }else if( ExprUseXSelect(pExpr) ){
113197 aff = sqlite3CompareAffinity(pExpr->x.pSelect->pEList->a[0].pExpr, aff);
113210 SQLITE_PRIVATE int sqlite3IndexAffinityOk(const Expr *pExpr, char idx_affinity){ argument
113211 char aff = comparisonAffinity(pExpr);
113322 SQLITE_PRIVATE int sqlite3ExprIsVector(const Expr *pExpr){ argument
113323 return sqlite3ExprVectorSize(pExpr)>1;
113332 SQLITE_PRIVATE int sqlite3ExprVectorSize(const Expr *pExpr){ argument
113333 u8 op = pExpr->op;
113334 if( op==TK_REGISTER ) op = pExpr->op2;
113336 assert( ExprUseXList(pExpr) );
113337 return pExpr->x.pList->nExpr;
113339 assert( ExprUseXSelect(pExpr) );
113340 return pExpr->x.pSelect->pEList->nExpr;
113367 return pVector->x.pSelect->pEList->a[i].pExpr;
113370 return pVector->x.pList->a[i].pExpr;
113433 ppVector = &pVector->x.pList->a[iField].pExpr;
113454 static int exprCodeSubselect(Parse *pParse, Expr *pExpr){ argument
113457 if( pExpr->op==TK_SELECT ){
113458 reg = sqlite3CodeSubselect(pParse, pExpr);
113498 *ppExpr = pVector->x.pSelect->pEList->a[iField].pExpr;
113503 *ppExpr = pVector->x.pList->a[iField].pExpr;
113522 Expr *pExpr, /* The comparison operation */ argument
113528 Expr *pLeft = pExpr->pLeft;
113529 Expr *pRight = pExpr->pRight;
113537 int isCommuted = ExprHasProperty(pExpr,EP_Commuted);
113539 assert( !ExprHasVVAProperty(pExpr,EP_Immutable) );
113545 assert( pExpr->op==TK_EQ || pExpr->op==TK_NE
113546 || pExpr->op==TK_IS || pExpr->op==TK_ISNOT
113547 || pExpr->op==TK_LT || pExpr->op==TK_GT
113548 || pExpr->op==TK_LE || pExpr->op==TK_GE
113550 assert( pExpr->op==op || (pExpr->op==TK_IS && op==TK_EQ)
113551 || (pExpr->op==TK_ISNOT && op==TK_NE) );
113552 assert( p5==0 || pExpr->op!=op );
113553 assert( p5==SQLITE_NULLEQ || pExpr->op==op );
113647 heightOfExpr(p->a[i].pExpr, pnHeight);
113727 SQLITE_PRIVATE void sqlite3ExprSetErrorOffset(Expr *pExpr, int iOfst){ argument
113728 if( pExpr==0 ) return;
113729 if( NEVER(ExprUseWJoin(pExpr)) ) return;
113730 pExpr->w.iOfst = iOfst;
113891 SQLITE_PRIVATE void sqlite3PExprAddSelect(Parse *pParse, Expr *pExpr, Select *pSelect){ argument
113892 if( pExpr ){
113893 pExpr->x.pSelect = pSelect;
113894 ExprSetProperty(pExpr, EP_xIsSelect|EP_Subquery);
113895 sqlite3ExprSetHeightAndFlags(pParse, pExpr);
113927 Expr *pExpr = pEList->a[ii].pExpr; local
113929 if( pExpr->op==TK_VECTOR ){
113930 assert( ExprUseXList(pExpr) );
113931 nExprElem = pExpr->x.pList->nExpr;
113941 assert( ExprUseXList(pExpr) );
113942 pSel = sqlite3SelectNew(pParse, pExpr->x.pList, 0, 0, 0, 0, 0, SF_Values,0);
113943 pExpr->x.pList = 0;
114044 Expr *pExpr, /* The function call to which ORDER BY is to be added */ argument
114053 if( pExpr==0 ){
114058 assert( pExpr->op==TK_FUNCTION );
114059 assert( pExpr->pLeft==0 );
114060 assert( ExprUseXList(pExpr) );
114061 if( pExpr->x.pList==0 || NEVER(pExpr->x.pList->nExpr==0) ){
114066 if( IsWindowFunc(pExpr) ){
114067 sqlite3ExprOrderByAggregateError(pParse, pExpr);
114084 pExpr->pLeft = pOB;
114101 const Expr *pExpr, /* The function invocation */ argument
114106 if( ExprHasProperty(pExpr, EP_FromDDL)
114119 sqlite3ErrorMsg(pParse, "unsafe use of %#T()", pExpr);
114140 SQLITE_PRIVATE void sqlite3ExprAssignVarNumber(Parse *pParse, Expr *pExpr, u32 n){ argument
114145 if( pExpr==0 ) return;
114146 assert( !ExprHasProperty(pExpr, EP_IntValue|EP_Reduced|EP_TokenOnly) );
114147 z = pExpr->u.zToken;
114175 sqlite3RecordErrorOffsetOfExpr(pParse->db, pExpr);
114200 pExpr->iColumn = x;
114203 sqlite3RecordErrorOffsetOfExpr(pParse->db, pExpr);
114291 SQLITE_PRIVATE int sqlite3ExprDeferredDelete(Parse *pParse, Expr *pExpr){ argument
114292 return 0==sqlite3ParserAddCleanup(pParse, sqlite3ExprDeleteGeneric, pExpr);
114607 static int gatherSelectWindowsCallback(Walker *pWalker, Expr *pExpr){ argument
114608 if( pExpr->op==TK_FUNCTION && ExprHasProperty(pExpr, EP_WinFunc) ){
114610 Window *pWin = pExpr->y.pWin;
114612 assert( IsWindowFunc(pExpr) );
114670 Expr *pOldExpr = pOldItem->pExpr;
114672 pItem->pExpr = sqlite3ExprDup(db, pOldExpr, flags);
114675 && (pNewExpr = pItem->pExpr)!=0
114849 Expr *pExpr /* Expression to be appended. Might be NULL */ argument
114856 sqlite3ExprDelete(db, pExpr);
114863 pItem->pExpr = pExpr;
114869 Expr *pExpr /* Expression to be appended. Might be NULL */ argument
114877 sqlite3ExprDelete(db, pExpr);
114884 pItem->pExpr = pExpr;
114890 Expr *pExpr /* Expression to be appended. Might be NULL */ argument
114894 return sqlite3ExprListAppendNew(pParse->db,pExpr);
114897 return sqlite3ExprListAppendGrow(pParse->db,pList,pExpr);
114901 pItem->pExpr = pExpr;
114920 Expr *pExpr /* Vector expression to be appended. Might be NULL */ argument
114929 if( pExpr==0 ) goto vector_append_error;
114936 if( pExpr->op!=TK_SELECT && pColumns->nId!=(n=sqlite3ExprVectorSize(pExpr)) ){
114943 Expr *pSubExpr = sqlite3ExprForVectorField(pParse, pExpr, i, pColumns->nId);
114954 if( !db->mallocFailed && pExpr->op==TK_SELECT && ALWAYS(pList!=0) ){
114955 Expr *pFirst = pList->a[iFirst].pExpr;
114961 pFirst->pRight = pExpr;
114962 pExpr = 0;
114970 sqlite3ExprUnmapAndDelete(pParse, pExpr);
115095 sqlite3ExprDelete(db, pItem->pExpr);
115117 Expr *pExpr = pList->a[i].pExpr; local
115118 assert( pExpr!=0 );
115119 m |= pExpr->flags;
115157 SQLITE_PRIVATE int sqlite3ExprIdToTrueFalse(Expr *pExpr){ argument
115159 assert( pExpr->op==TK_ID || pExpr->op==TK_STRING );
115160 if( !ExprHasProperty(pExpr, EP_Quoted|EP_IntValue)
115161 && (v = sqlite3IsTrueOrFalse(pExpr->u.zToken))!=0
115163 pExpr->op = TK_TRUEFALSE;
115164 ExprSetProperty(pExpr, v);
115174 SQLITE_PRIVATE int sqlite3ExprTruthValue(const Expr *pExpr){ argument
115175 pExpr = sqlite3ExprSkipCollateAndLikely((Expr*)pExpr);
115176 assert( pExpr->op==TK_TRUEFALSE );
115177 assert( !ExprHasProperty(pExpr, EP_IntValue) );
115178 assert( sqlite3StrICmp(pExpr->u.zToken,"true")==0
115179 || sqlite3StrICmp(pExpr->u.zToken,"false")==0 );
115180 return pExpr->u.zToken[4]==0;
115196 SQLITE_PRIVATE Expr *sqlite3ExprSimplifiedAndOr(Expr *pExpr){ argument
115197 assert( pExpr!=0 );
115198 if( pExpr->op==TK_AND || pExpr->op==TK_OR ){
115199 Expr *pRight = sqlite3ExprSimplifiedAndOr(pExpr->pRight);
115200 Expr *pLeft = sqlite3ExprSimplifiedAndOr(pExpr->pLeft);
115202 pExpr = pExpr->op==TK_AND ? pRight : pLeft;
115204 pExpr = pExpr->op==TK_AND ? pLeft : pRight;
115207 return pExpr;
115218 static int exprEvalRhsFirst(Expr *pExpr){ argument
115219 if( ExprHasProperty(pExpr->pLeft, EP_Subquery)
115220 && !ExprHasProperty(pExpr->pRight, EP_Subquery)
115242 Expr *pExpr, /* The comparison expression */ argument
115259 if( exprEvalRhsFirst(pExpr) && sqlite3ExprCanBeNull(pExpr->pRight) ){
115260 r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, pFree2);
115268 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, pFree1);
115275 if( ExprHasProperty(pExpr->pRight, EP_Subquery)
115276 && sqlite3ExprCanBeNull(pExpr->pLeft)
115282 r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, pFree2);
115307 Expr *pExpr argument
115314 assert( pExpr->op==TK_FUNCTION );
115315 if( ExprHasProperty(pExpr, EP_TokenOnly)
115316 || (pList = pExpr->x.pList)==0
115325 pDef = sqlite3FindFunction(db, pExpr->u.zToken, n, ENC(db), 0);
115329 || ExprHasProperty(pExpr, EP_WinFunc)
115364 static int exprNodeIsConstant(Walker *pWalker, Expr *pExpr){ argument
115370 if( pWalker->eCode==2 && ExprHasProperty(pExpr, EP_OuterON) ){
115375 switch( pExpr->op ){
115380 if( (pWalker->eCode>=4 || ExprHasProperty(pExpr,EP_ConstFunc))
115381 && !ExprHasProperty(pExpr, EP_WinFunc)
115383 if( pWalker->eCode==5 ) ExprSetProperty(pExpr, EP_FromDDL);
115386 return exprNodeIsConstantFunction(pWalker, pExpr);
115394 if( sqlite3ExprIdToTrueFalse(pExpr) ){
115401 testcase( pExpr->op==TK_ID );
115402 testcase( pExpr->op==TK_COLUMN );
115403 testcase( pExpr->op==TK_AGG_FUNCTION );
115404 testcase( pExpr->op==TK_AGG_COLUMN );
115405 if( ExprHasProperty(pExpr, EP_FixedCol) && pWalker->eCode!=2 ){
115408 if( pWalker->eCode==3 && pExpr->iTable==pWalker->u.iCur ){
115416 testcase( pExpr->op==TK_REGISTER );
115417 testcase( pExpr->op==TK_IF_NULL_ROW );
115418 testcase( pExpr->op==TK_DOT );
115419 testcase( pExpr->op==TK_RAISE );
115427 pExpr->op = TK_NULL;
115436 testcase( pExpr->op==TK_SELECT ); /* sqlite3SelectWalkFail() disallows */
115437 testcase( pExpr->op==TK_EXISTS ); /* sqlite3SelectWalkFail() disallows */
115577 Expr *pExpr, /* The constraint */ argument
115587 if( !ExprHasProperty(pExpr, EP_OuterON) ) return 0; /* rule (4a) */
115588 if( pExpr->w.iJoin!=pSrc->iCursor ) return 0; /* rule (4b) */
115590 if( ExprHasProperty(pExpr, EP_OuterON) ) return 0; /* rule (5) */
115592 if( ExprHasProperty(pExpr, EP_OuterON|EP_InnerON) /* (6a) */
115597 if( pExpr->w.iJoin==pSrcList->a[jj].iCursor ){
115606 return sqlite3ExprIsTableConstant(pExpr, pSrc->iCursor, bAllowSubq);
115613 static int exprNodeIsConstantOrGroupBy(Walker *pWalker, Expr *pExpr){ argument
115620 Expr *p = pGroupBy->a[i].pExpr;
115621 if( sqlite3ExprCompare(0, pExpr, p, -1)<2 ){
115630 if( ExprUseXSelect(pExpr) ){
115635 return exprNodeIsConstant(pWalker, pExpr);
115925 Expr *pRes = pEList->a[i].pExpr;
116080 if( sqlite3ExprCanBeNull(pEList->a[i].pExpr) ) break;
116098 assert( p->pEList->a[0].pExpr!=0 ); /* Because of isCandidateForInOpt(p) */
116109 if( nExpr==1 && pEList->a[0].pExpr->iColumn<0 ){
116130 int iCol = pEList->a[i].pExpr->iColumn;
116173 Expr *pRhs = pEList->a[i].pExpr;
116286 static char *exprINAffinity(Parse *pParse, const Expr *pExpr){ argument
116287 Expr *pLeft = pExpr->pLeft;
116289 Select *pSelect = ExprUseXSelect(pExpr) ? pExpr->x.pSelect : 0;
116292 assert( pExpr->op==TK_IN );
116300 zRet[i] = sqlite3CompareAffinity(pSelect->pEList->a[i].pExpr, a);
116337 SQLITE_PRIVATE void sqlite3VectorErrorMsg(Parse *pParse, Expr *pExpr){ argument
116339 if( ExprUseXSelect(pExpr) ){
116340 sqlite3SubselectError(pParse, pExpr->x.pSelect->pEList->nExpr, 1);
116356 Expr *pExpr, /* IN operator with RHS that we want to reuse */ argument
116365 assert( pExpr->op==TK_IN );
116366 assert( !ExprUseYSub(pExpr) );
116367 assert( ExprUseXSelect(pExpr) );
116368 assert( pExpr->x.pSelect!=0 );
116369 assert( (pExpr->x.pSelect->selFlags & SF_All)==0 );
116382 pExpr->y.sub.iAddr = pSig->iAddr;
116383 pExpr->y.sub.regReturn = pSig->regReturn;
116384 pExpr->iTable = pSig->iTable;
116385 ExprSetProperty(pExpr, EP_Subrtn);
116417 Expr *pExpr, /* The IN operator */ argument
116442 if( !ExprHasProperty(pExpr, EP_VarSelect) && pParse->iSelfTab==0 ){
116448 assert( !ExprUseXSelect(pExpr) || pExpr->x.pSelect!=0 );
116449 if( ExprUseXSelect(pExpr) && (pExpr->x.pSelect->selFlags & SF_All)==0 ){
116452 pSig->selId = pExpr->x.pSelect->selId;
116453 pSig->zAff = exprINAffinity(pParse, pExpr);
116461 if( ExprHasProperty(pExpr, EP_Subrtn)
116462 || findCompatibleInRhsSubrtn(pParse, pExpr, pSig)
116465 if( ExprUseXSelect(pExpr) ){
116467 pExpr->x.pSelect->selId));
116469 assert( ExprUseYSub(pExpr) );
116470 sqlite3VdbeAddOp2(v, OP_Gosub, pExpr->y.sub.regReturn,
116471 pExpr->y.sub.iAddr);
116472 assert( iTab!=pExpr->iTable );
116473 sqlite3VdbeAddOp2(v, OP_OpenDup, iTab, pExpr->iTable);
116483 assert( !ExprUseYWin(pExpr) );
116484 ExprSetProperty(pExpr, EP_Subrtn);
116485 assert( !ExprHasProperty(pExpr, EP_TokenOnly|EP_Reduced) );
116486 pExpr->y.sub.regReturn = ++pParse->nMem;
116487 pExpr->y.sub.iAddr =
116488 sqlite3VdbeAddOp2(v, OP_BeginSubrtn, 0, pExpr->y.sub.regReturn) + 1;
116491 pSig->iAddr = pExpr->y.sub.iAddr;
116492 pSig->regReturn = pExpr->y.sub.regReturn;
116501 pLeft = pExpr->pLeft;
116507 pExpr->iTable = iTab;
116508 addr = sqlite3VdbeAddOp2(v, OP_OpenEphemeral, pExpr->iTable, nVal);
116510 if( ExprUseXSelect(pExpr) ){
116511 VdbeComment((v, "Result of SELECT %u", pExpr->x.pSelect->selId));
116518 if( ExprUseXSelect(pExpr) ){
116524 Select *pSelect = pExpr->x.pSelect;
116539 dest.zAffSdst = exprINAffinity(pParse, pExpr);
116576 pParse, p, pEList->a[i].pExpr
116580 }else if( ALWAYS(pExpr->x.pList!=0) ){
116590 ExprList *pList = pExpr->x.pList;
116601 pKeyInfo->aColl[0] = sqlite3ExprCollSeq(pParse, pExpr->pLeft);
116608 Expr *pE2 = pItem->pExpr;
116618 ExprClearProperty(pExpr, EP_Subrtn);
116638 assert( ExprUseYSub(pExpr) );
116639 assert( sqlite3VdbeGetOp(v,pExpr->y.sub.iAddr-1)->opcode==OP_BeginSubrtn
116641 sqlite3VdbeAddOp3(v, OP_Return, pExpr->y.sub.regReturn,
116642 pExpr->y.sub.iAddr, 1);
116664 SQLITE_PRIVATE int sqlite3CodeSubselect(Parse *pParse, Expr *pExpr){ argument
116678 testcase( pExpr->op==TK_EXISTS );
116679 testcase( pExpr->op==TK_SELECT );
116680 assert( pExpr->op==TK_EXISTS || pExpr->op==TK_SELECT );
116681 assert( ExprUseXSelect(pExpr) );
116682 pSel = pExpr->x.pSelect;
116686 if( ExprHasProperty(pExpr, EP_Subrtn) ){
116688 assert( ExprUseYSub(pExpr) );
116689 sqlite3VdbeAddOp2(v, OP_Gosub, pExpr->y.sub.regReturn,
116690 pExpr->y.sub.iAddr);
116691 return pExpr->iTable;
116695 assert( !ExprUseYWin(pExpr) );
116696 assert( !ExprHasProperty(pExpr, EP_Reduced|EP_TokenOnly) );
116697 ExprSetProperty(pExpr, EP_Subrtn);
116698 pExpr->y.sub.regReturn = ++pParse->nMem;
116699 pExpr->y.sub.iAddr =
116700 sqlite3VdbeAddOp2(v, OP_BeginSubrtn, 0, pExpr->y.sub.regReturn) + 1;
116712 if( !ExprHasProperty(pExpr, EP_VarSelect) ){
116729 nReg = pExpr->op==TK_SELECT ? pSel->pEList->nExpr : 1;
116732 if( pExpr->op==TK_SELECT ){
116781 pExpr->op2 = pExpr->op;
116782 pExpr->op = TK_ERROR;
116785 pExpr->iTable = rReg = dest.iSDParm;
116786 ExprSetVVAProperty(pExpr, EP_NoReduce);
116793 assert( ExprUseYSub(pExpr) );
116794 assert( sqlite3VdbeGetOp(v,pExpr->y.sub.iAddr-1)->opcode==OP_BeginSubrtn
116796 sqlite3VdbeAddOp3(v, OP_Return, pExpr->y.sub.regReturn,
116797 pExpr->y.sub.iAddr, 1);
116854 Expr *pExpr, /* The IN expression */ argument
116876 assert( !ExprHasVVAProperty(pExpr,EP_Immutable) );
116877 pLeft = pExpr->pLeft;
116878 if( sqlite3ExprCheckIN(pParse, pExpr) ) return;
116879 zAff = exprINAffinity(pParse, pExpr);
116880 nVector = sqlite3ExprVectorSize(pExpr->pLeft);
116891 eType = sqlite3FindInIndex(pParse, pExpr,
116940 assert( ExprUseXList(pExpr) );
116941 pList = pExpr->x.pList;
116942 pColl = sqlite3ExprCollSeq(pParse, pExpr->pLeft);
116948 r2 = sqlite3ExprCodeTemp(pParse, pList->a[ii].pExpr, ®ToFree);
116949 if( regCkNull && sqlite3ExprCanBeNull(pList->a[ii].pExpr) ){
117011 Expr *p = sqlite3VectorFieldSubexpr(pExpr->pLeft, i);
117034 if( ExprHasProperty(pExpr, EP_Subrtn) ){
117035 const VdbeOp *pOp = sqlite3VdbeGetOp(v, pExpr->y.sub.iAddr);
117088 if( ExprUseXSelect(pExpr) ){
117089 Expr *pRhs = pExpr->x.pSelect->pEList->a[i].pExpr;
117153 static void codeInteger(Parse *pParse, Expr *pExpr, int negFlag, int iMem){ argument
117155 if( pExpr->flags & EP_IntValue ){
117156 int i = pExpr->u.iValue;
117163 const char *z = pExpr->u.zToken;
117168 sqlite3ErrorMsg(pParse, "oversized integer: %s%#T", negFlag?"-":"",pExpr);
117173 negFlag?"-":"",pExpr);
117203 sqlite3ExprCodeCopy(pParse, pIdx->aColExpr->a[iIdxCol].pExpr, regOut);
117339 SQLITE_PRIVATE void sqlite3ExprToRegister(Expr *pExpr, int iReg){ argument
117340 Expr *p = sqlite3ExprSkipCollateAndLikely(pExpr);
117381 sqlite3ExprCodeFactorable(pParse, p->x.pList->a[i].pExpr, i+iResult);
117423 sqlite3ExprCode(pParse, pFarg->a[0].pExpr, target);
117427 sqlite3ExprCode(pParse, pFarg->a[i].pExpr, target);
117442 Expr *pArg = pFarg->a[0].pExpr;
117456 target = sqlite3ExprCodeTarget(pParse, pFarg->a[0].pExpr, target);
117469 sqlite3ExprCompare(0,pFarg->a[0].pExpr, pFarg->a[1].pExpr,-1),
117478 sqlite3ExprImpliesExpr(pParse,pFarg->a[0].pExpr, pFarg->a[1].pExpr,-1),
117487 pA1 = pFarg->a[1].pExpr;
117490 sqlite3ExprImpliesNonNullRow(pFarg->a[0].pExpr,pA1->iTable,1),
117507 aff = sqlite3ExprAffinity(pFarg->a[0].pExpr);
117542 static int exprNodeCanReturnSubtype(Walker *pWalker, Expr *pExpr){ argument
117546 if( pExpr->op==TK_CASE || pExpr->op==TK_UPLUS
117547 || pExpr->op==TK_COLLATE || pExpr->op==TK_CAST
117551 if( pExpr->op!=TK_FUNCTION ){
117554 assert( ExprUseXList(pExpr) );
117556 n = ALWAYS(pExpr->x.pList) ? pExpr->x.pList->nExpr : 0;
117557 pDef = sqlite3FindFunction(db, pExpr->u.zToken, n, ENC(db), 0);
117573 static int sqlite3ExprCanReturnSubtype(Parse *pParse, Expr *pExpr){ argument
117578 sqlite3WalkExpr(&w, pExpr);
117591 Expr *pExpr, /* The expression to potentially bypass */ argument
117604 if( sqlite3ExprCompare(0, pExpr, p->pExpr, iDataCur)!=0 ) continue;
117606 exprAff = sqlite3ExprAffinity(pExpr);
117620 if( ExprHasProperty(pExpr, EP_SubtArg)
117621 && sqlite3ExprCanReturnSubtype(pParse, pExpr)
117640 sqlite3ExprCode(pParse, pExpr, target);
117663 static int exprPartidxExprLookup(Parse *pParse, Expr *pExpr, int iTarget){ argument
117666 if( pExpr->iColumn==p->iIdxCol && pExpr->iTable==p->iDataCur ){
117674 ret = sqlite3ExprCodeTarget(pParse, p->pExpr, iTarget);
117699 Expr *pExpr, /* AND or OR expression to be coded */ argument
117711 assert( pExpr!=0 );
117712 op = pExpr->op;
117718 pAlt = sqlite3ExprSimplifiedAndOr(pExpr);
117719 if( pAlt!=pExpr ){
117725 if( exprEvalRhsFirst(pExpr) ){
117728 r2 = regSS = sqlite3ExprCodeTarget(pParse, pExpr->pRight, target);
117732 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, pTmpReg);
117735 r1 = sqlite3ExprCodeTarget(pParse, pExpr->pLeft, target);
117736 if( ExprHasProperty(pExpr->pRight, EP_Subquery) ){
117747 r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, pTmpReg);
117773 SQLITE_PRIVATE int sqlite3ExprCodeTarget(Parse *pParse, Expr *pExpr, int target){ argument
117787 if( pExpr==0 ){
117790 && !ExprHasProperty(pExpr, EP_Leaf)
117791 && (r1 = sqlite3IndexedExprLookup(pParse, pExpr, target))>=0
117795 assert( !ExprHasVVAProperty(pExpr,EP_Immutable) );
117796 op = pExpr->op;
117801 AggInfo *pAggInfo = pExpr->pAggInfo;
117804 assert( pExpr->iAgg>=0 );
117805 if( pExpr->iAgg>=pAggInfo->nColumn ){
117817 pCol = &pAggInfo->aCol[pExpr->iAgg];
117819 return AggInfoColumnReg(pAggInfo, pExpr->iAgg);
117836 }else if( pExpr->y.pTab==0 ){
117839 sqlite3VdbeAddOp3(v, OP_Column, pExpr->iTable, pExpr->iColumn, target);
117846 int iTab = pExpr->iTable;
117848 if( ExprHasProperty(pExpr, EP_FixedCol) ){
117856 iReg = sqlite3ExprCodeTarget(pParse, pExpr->pLeft,target);
117857 assert( ExprUseYTab(pExpr) );
117858 assert( pExpr->y.pTab!=0 );
117859 aff = sqlite3TableColumnAffinity(pExpr->y.pTab, pExpr->iColumn);
117880 int iCol = pExpr->iColumn;
117881 assert( ExprUseYTab(pExpr) );
117882 pTab = pExpr->y.pTab;
117921 && 0!=(r1 = exprPartidxExprLookup(pParse, pExpr, target))
117925 assert( ExprUseYTab(pExpr) );
117926 assert( pExpr->y.pTab!=0 );
117927 iReg = sqlite3ExprCodeGetColumn(pParse, pExpr->y.pTab,
117928 pExpr->iColumn, iTab, target,
117929 pExpr->op2);
117933 codeInteger(pParse, pExpr, 0, target);
117937 sqlite3VdbeAddOp2(v, OP_Integer, sqlite3ExprTruthValue(pExpr), target);
117942 assert( !ExprHasProperty(pExpr, EP_IntValue) );
117943 codeReal(v, pExpr->u.zToken, 0, target);
117948 assert( !ExprHasProperty(pExpr, EP_IntValue) );
117949 sqlite3VdbeLoadString(v, target, pExpr->u.zToken);
117955 sqlite3VdbeAddOp3(v, OP_Null, 0, target, target + pExpr->y.nReg - 1);
117972 assert( !ExprHasProperty(pExpr, EP_IntValue) );
117973 assert( pExpr->u.zToken[0]=='x' || pExpr->u.zToken[0]=='X' );
117974 assert( pExpr->u.zToken[1]=='\'' );
117975 z = &pExpr->u.zToken[2];
117984 assert( !ExprHasProperty(pExpr, EP_IntValue) );
117985 assert( pExpr->u.zToken!=0 );
117986 assert( pExpr->u.zToken[0]!=0 );
117987 sqlite3VdbeAddOp2(v, OP_Variable, pExpr->iColumn, target);
117991 return pExpr->iTable;
117996 sqlite3ExprCode(pParse, pExpr->pLeft, target);
117998 assert( !ExprHasProperty(pExpr, EP_IntValue) );
118000 sqlite3AffinityType(pExpr->u.zToken, 0));
118015 Expr *pLeft = pExpr->pLeft;
118018 codeVectorCompare(pParse, pExpr, target, op, p5);
118020 if( ExprHasProperty(pExpr, EP_Subquery) && p5!=SQLITE_NULLEQ ){
118021 addrIsNull = exprComputeOperands(pParse, pExpr,
118024 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1);
118025 r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, ®Free2);
118028 codeCompare(pParse, pLeft, pExpr->pRight, op, r1, r2,
118030 ExprHasProperty(pExpr,EP_Commuted));
118054 inReg = exprCodeTargetAndOr(pParse, pExpr, target, ®Free1);
118077 if( ExprHasProperty(pExpr, EP_Subquery) ){
118078 addrIsNull = exprComputeOperands(pParse, pExpr,
118081 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1);
118082 r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, ®Free2);
118097 Expr *pLeft = pExpr->pLeft;
118104 assert( !ExprHasProperty(pExpr, EP_IntValue) );
118114 r2 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free2);
118124 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1);
118132 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1);
118134 isTrue = sqlite3ExprTruthValue(pExpr->pRight);
118135 bNormal = pExpr->op2==TK_IS;
118147 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1);
118157 AggInfo *pInfo = pExpr->pAggInfo;
118159 || NEVER(pExpr->iAgg<0)
118160 || NEVER(pExpr->iAgg>=pInfo->nFunc)
118162 assert( !ExprHasProperty(pExpr, EP_IntValue) );
118163 sqlite3ErrorMsg(pParse, "misuse of aggregate: %#T()", pExpr);
118165 return AggInfoFuncReg(pInfo, pExpr->iAgg);
118181 if( ExprHasProperty(pExpr, EP_WinFunc) ){
118182 return pExpr->y.pWin->regResult;
118187 && sqlite3ExprIsConstantNotJoin(pParse,pExpr)
118191 return sqlite3ExprCodeRunJustOnce(pParse, pExpr, -1);
118193 assert( !ExprHasProperty(pExpr, EP_TokenOnly) );
118194 assert( ExprUseXList(pExpr) );
118195 pFarg = pExpr->x.pList;
118197 assert( !ExprHasProperty(pExpr, EP_IntValue) );
118198 zId = pExpr->u.zToken;
118206 sqlite3ErrorMsg(pParse, "unknown function: %#T()", pExpr);
118215 sqlite3ExprFunctionUsable(pParse, pExpr, pDef);
118219 if( i<32 && sqlite3ExprIsConstant(pParse, pFarg->a[i].pExpr) ){
118224 pColl = sqlite3ExprCollSeq(pParse, pFarg->a[i].pExpr);
118243 assert( pFarg->a[0].pExpr!=0 );
118244 exprOp = pFarg->a[0].pExpr->op;
118253 pFarg->a[0].pExpr->op2 = pDef->funcFlags & OPFLAG_BYTELENARG;
118274 if( nFarg>=2 && ExprHasProperty(pExpr, EP_InfixFunc) ){
118275 pDef = sqlite3VtabOverloadFunction(db, pDef, nFarg, pFarg->a[1].pExpr);
118277 pDef = sqlite3VtabOverloadFunction(db, pDef, nFarg, pFarg->a[0].pExpr);
118285 pDef, pExpr->op2);
118304 && ALWAYS( ExprUseXSelect(pExpr) )
118305 && (nCol = pExpr->x.pSelect->pEList->nExpr)!=1
118309 return sqlite3CodeSubselect(pParse, pExpr);
118315 Expr *pLeft = pExpr->pLeft;
118322 if( pExpr->iTable!=n ){
118324 pExpr->iTable, n);
118326 return pLeft->iTable + pExpr->iColumn;
118332 sqlite3ExprCodeIN(pParse, pExpr, destIfFalse, destIfNull);
118354 exprCodeBetween(pParse, pExpr, target, 0, 0);
118358 if( !ExprHasProperty(pExpr, EP_Collate) ){
118365 assert( pExpr->pLeft );
118366 sqlite3ExprCode(pParse, pExpr->pLeft, target);
118370 pExpr = pExpr->pLeft;
118376 pExpr = pExpr->pLeft;
118410 assert( ExprUseYTab(pExpr) );
118411 pTab = pExpr->y.pTab;
118412 iCol = pExpr->iColumn;
118413 p1 = pExpr->iTable * (pTab->nCol+1) + 1
118416 assert( pExpr->iTable==0 || pExpr->iTable==1 );
118423 (pExpr->iTable ? "new" : "old"),
118424 (pExpr->iColumn<0 ? "rowid" : pExpr->y.pTab->aCol[iCol].zCnName)
118454 AggInfo *pAggInfo = pExpr->pAggInfo;
118456 assert( pExpr->iAgg>=0 && pExpr->iAgg<pAggInfo->nColumn );
118458 inReg = AggInfoColumnReg(pAggInfo, pExpr->iAgg);
118461 if( pExpr->pAggInfo->useSortingIdx ){
118463 pAggInfo->aCol[pExpr->iAgg].iSorterColumn,
118469 addrINR = sqlite3VdbeAddOp3(v, OP_IfNullRow, pExpr->iTable, 0, target);
118478 sqlite3ExprCode(pParse, pExpr->pLeft, target);
118519 assert( ExprUseXList(pExpr) && pExpr->x.pList!=0 );
118520 assert(pExpr->x.pList->nExpr > 0);
118521 pEList = pExpr->x.pList;
118525 if( (pX = pExpr->pLeft)!=0 ){
118547 opCompare.pRight = aListelem[i].pExpr;
118549 pTest = aListelem[i].pExpr;
118554 testcase( aListelem[i+1].pExpr->op==TK_COLUMN );
118555 sqlite3ExprCode(pParse, aListelem[i+1].pExpr, target);
118560 sqlite3ExprCode(pParse, pEList->a[nExpr-1].pExpr, target);
118571 assert( pExpr->affExpr==OE_Rollback
118572 || pExpr->affExpr==OE_Abort
118573 || pExpr->affExpr==OE_Fail
118574 || pExpr->affExpr==OE_Ignore
118581 if( pExpr->affExpr==OE_Abort ){
118584 assert( !ExprHasProperty(pExpr, EP_IntValue) );
118585 if( pExpr->affExpr==OE_Ignore ){
118589 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1);
118592 pExpr->affExpr, r1);
118622 Expr *pExpr, /* The expression to code when the VDBE initializes */ argument
118634 && sqlite3ExprCompare(0,pItem->pExpr,pExpr,-1)==0
118640 pExpr = sqlite3ExprDup(pParse->db, pExpr, 0);
118641 if( pExpr!=0 && ExprHasProperty(pExpr, EP_HasFunc) ){
118649 sqlite3ExprCode(pParse, pExpr, regDest);
118652 sqlite3ExprDelete(pParse->db, pExpr);
118655 p = sqlite3ExprListAppend(pParse, p, pExpr);
118699 SQLITE_PRIVATE int sqlite3ExprCodeTemp(Parse *pParse, Expr *pExpr, int *pReg){ argument
118701 pExpr = sqlite3ExprSkipCollateAndLikely(pExpr);
118703 && ALWAYS(pExpr!=0)
118704 && pExpr->op!=TK_REGISTER
118705 && sqlite3ExprIsConstantNotJoin(pParse, pExpr)
118708 r2 = sqlite3ExprCodeRunJustOnce(pParse, pExpr, -1);
118711 r2 = sqlite3ExprCodeTarget(pParse, pExpr, r1);
118727 SQLITE_PRIVATE void sqlite3ExprCode(Parse *pParse, Expr *pExpr, int target){ argument
118730 assert( pExpr==0 || !ExprHasVVAProperty(pExpr,EP_Immutable) );
118734 inReg = sqlite3ExprCodeTarget(pParse, pExpr, target);
118737 Expr *pX = sqlite3ExprSkipCollateAndLikely(pExpr);
118738 testcase( pX!=pExpr );
118755 SQLITE_PRIVATE void sqlite3ExprCodeCopy(Parse *pParse, Expr *pExpr, int target){ argument
118757 pExpr = sqlite3ExprDup(db, pExpr, 0);
118758 if( !db->mallocFailed ) sqlite3ExprCode(pParse, pExpr, target);
118759 sqlite3ExprDelete(db, pExpr);
118768 SQLITE_PRIVATE void sqlite3ExprCodeFactorable(Parse *pParse, Expr *pExpr, int target){ argument
118769 if( pParse->okConstFactor && sqlite3ExprIsConstantNotJoin(pParse,pExpr) ){
118770 sqlite3ExprCodeRunJustOnce(pParse, pExpr, target);
118772 sqlite3ExprCodeCopy(pParse, pExpr, target);
118813 Expr *pExpr = pItem->pExpr; local
118828 && sqlite3ExprIsConstantNotJoin(pParse,pExpr)
118830 sqlite3ExprCodeRunJustOnce(pParse, pExpr, target+i);
118832 int inReg = sqlite3ExprCodeTarget(pParse, pExpr, target+i);
118873 Expr *pExpr, /* The BETWEEN expression */ argument
118889 assert( ExprUseXList(pExpr) );
118890 pDel = sqlite3ExprDup(db, pExpr->pLeft, 0);
118897 compLeft.pRight = pExpr->x.pList->a[0].pExpr;
118900 compRight.pRight = pExpr->x.pList->a[1].pExpr;
118943 SQLITE_PRIVATE void sqlite3ExprIfTrue(Parse *pParse, Expr *pExpr, int dest, int jumpIfNull){ argument
118952 if( NEVER(pExpr==0) ) return; /* No way this can happen */
118953 assert( !ExprHasVVAProperty(pExpr, EP_Immutable) );
118954 op = pExpr->op;
118958 Expr *pAlt = sqlite3ExprSimplifiedAndOr(pExpr);
118959 if( pAlt!=pExpr ){
118963 if( exprEvalRhsFirst(pExpr) ){
118964 pFirst = pExpr->pRight;
118965 pSecond = pExpr->pLeft;
118967 pFirst = pExpr->pLeft;
118968 pSecond = pExpr->pRight;
118987 sqlite3ExprIfFalse(pParse, pExpr->pLeft, dest, jumpIfNull);
118994 isNot = pExpr->op2==TK_ISNOT;
118995 isTrue = sqlite3ExprTruthValue(pExpr->pRight);
118999 sqlite3ExprIfTrue(pParse, pExpr->pLeft, dest,
119002 sqlite3ExprIfFalse(pParse, pExpr->pLeft, dest,
119021 if( sqlite3ExprIsVector(pExpr->pLeft) ) goto default_expr;
119022 if( ExprHasProperty(pExpr, EP_Subquery) && jumpIfNull!=SQLITE_NULLEQ ){
119023 addrIsNull = exprComputeOperands(pParse, pExpr,
119026 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1);
119027 r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, ®Free2);
119030 codeCompare(pParse, pExpr->pLeft, pExpr->pRight, op,
119031 r1, r2, dest, jumpIfNull, ExprHasProperty(pExpr,EP_Commuted));
119057 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1);
119067 exprCodeBetween(pParse, pExpr, dest, sqlite3ExprIfTrue, jumpIfNull);
119074 sqlite3ExprCodeIN(pParse, pExpr, destIfFalse, destIfNull);
119082 if( ExprAlwaysTrue(pExpr) ){
119084 }else if( ExprAlwaysFalse(pExpr) ){
119087 r1 = sqlite3ExprCodeTemp(pParse, pExpr, ®Free1);
119109 SQLITE_PRIVATE void sqlite3ExprIfFalse(Parse *pParse, Expr *pExpr, int dest, int jumpIfNull){ argument
119118 if( pExpr==0 ) return;
119119 assert( !ExprHasVVAProperty(pExpr,EP_Immutable) );
119139 op = ((pExpr->op+(TK_ISNULL&1))^1)-(TK_ISNULL&1);
119143 assert( pExpr->op!=TK_ISNULL || op==OP_NotNull );
119144 assert( pExpr->op!=TK_NOTNULL || op==OP_IsNull );
119145 assert( pExpr->op!=TK_NE || op==OP_Eq );
119146 assert( pExpr->op!=TK_EQ || op==OP_Ne );
119147 assert( pExpr->op!=TK_LT || op==OP_Ge );
119148 assert( pExpr->op!=TK_LE || op==OP_Gt );
119149 assert( pExpr->op!=TK_GT || op==OP_Le );
119150 assert( pExpr->op!=TK_GE || op==OP_Lt );
119152 switch( pExpr->op ){
119155 Expr *pAlt = sqlite3ExprSimplifiedAndOr(pExpr);
119156 if( pAlt!=pExpr ){
119160 if( exprEvalRhsFirst(pExpr) ){
119161 pFirst = pExpr->pRight;
119162 pSecond = pExpr->pLeft;
119164 pFirst = pExpr->pLeft;
119165 pSecond = pExpr->pRight;
119167 if( pExpr->op==TK_AND ){
119184 sqlite3ExprIfTrue(pParse, pExpr->pLeft, dest, jumpIfNull);
119191 isNot = pExpr->op2==TK_ISNOT;
119192 isTrue = sqlite3ExprTruthValue(pExpr->pRight);
119197 sqlite3ExprIfFalse(pParse, pExpr->pLeft, dest,
119202 sqlite3ExprIfTrue(pParse, pExpr->pLeft, dest,
119209 testcase( pExpr->op==TK_IS );
119210 testcase( pExpr->op==TK_ISNOT );
119211 op = (pExpr->op==TK_IS) ? TK_NE : TK_EQ;
119221 if( sqlite3ExprIsVector(pExpr->pLeft) ) goto default_expr;
119222 if( ExprHasProperty(pExpr, EP_Subquery) && jumpIfNull!=SQLITE_NULLEQ ){
119223 addrIsNull = exprComputeOperands(pParse, pExpr,
119226 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1);
119227 r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, ®Free2);
119230 codeCompare(pParse, pExpr->pLeft, pExpr->pRight, op,
119231 r1, r2, dest, jumpIfNull,ExprHasProperty(pExpr,EP_Commuted));
119255 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1);
119265 exprCodeBetween(pParse, pExpr, dest, sqlite3ExprIfFalse, jumpIfNull);
119271 sqlite3ExprCodeIN(pParse, pExpr, dest, dest);
119274 sqlite3ExprCodeIN(pParse, pExpr, dest, destIfNull);
119282 if( ExprAlwaysFalse(pExpr) ){
119284 }else if( ExprAlwaysTrue(pExpr) ){
119287 r1 = sqlite3ExprCodeTemp(pParse, pExpr, ®Free1);
119305 SQLITE_PRIVATE void sqlite3ExprIfFalseDup(Parse *pParse, Expr *pExpr, int dest,int jumpIfNull){ argument
119307 Expr *pCopy = sqlite3ExprDup(db, pExpr, 0);
119333 const Expr *pExpr argument
119339 if( pExpr->op==TK_VARIABLE && pVar->iColumn==pExpr->iColumn ){
119343 sqlite3ValueFromExpr(pParse->db, pExpr, SQLITE_UTF8, SQLITE_AFF_BLOB, &pR);
119496 Expr *pExprA = pA->a[i].pExpr;
119497 Expr *pExprB = pB->a[i].pExpr;
119546 if( exprImpliesNotNull(pParse, pList->a[0].pExpr, pNN, iTab, 1)
119547 || exprImpliesNotNull(pParse, pList->a[1].pExpr, pNN, iTab, 1)
119597 static int sqlite3ExprIsNotTrue(Expr *pExpr){ argument
119599 if( pExpr->op==TK_NULL ) return 1;
119600 if( pExpr->op==TK_TRUEFALSE && sqlite3ExprTruthValue(pExpr)==0 ) return 1;
119602 if( sqlite3ExprIsInteger(pExpr, &v, 0) && v==0 ) return 1;
119616 static int sqlite3ExprIsIIF(sqlite3 *db, const Expr *pExpr){ argument
119618 if( pExpr->op==TK_FUNCTION ){
119619 const char *z = pExpr->u.zToken;
119622 if( pExpr->x.pList==0 ) return 0;
119623 pDef = sqlite3FindFunction(db, z, pExpr->x.pList->nExpr, ENC(db), 0);
119631 }else if( pExpr->op==TK_CASE ){
119632 if( pExpr->pLeft!=0 ) return 0;
119636 pList = pExpr->x.pList;
119639 if( pList->nExpr==3 && sqlite3ExprIsNotTrue(pList->a[2].pExpr) ) return 1;
119691 return sqlite3ExprImpliesExpr(pParse,pE1->x.pList->a[0].pExpr,pE2,iTab);
119723 static int impliesNotNullRow(Walker *pWalker, Expr *pExpr){ argument
119724 testcase( pExpr->op==TK_AGG_COLUMN );
119725 testcase( pExpr->op==TK_AGG_FUNCTION );
119726 if( ExprHasProperty(pExpr, EP_OuterON) ) return WRC_Prune;
119727 if( ExprHasProperty(pExpr, EP_InnerON) && pWalker->mWFlags ){
119735 switch( pExpr->op ){
119744 testcase( pExpr->op==TK_ISNOT );
119745 testcase( pExpr->op==TK_ISNULL );
119746 testcase( pExpr->op==TK_NOTNULL );
119747 testcase( pExpr->op==TK_IS );
119748 testcase( pExpr->op==TK_VECTOR );
119749 testcase( pExpr->op==TK_FUNCTION );
119750 testcase( pExpr->op==TK_TRUTH );
119751 testcase( pExpr->op==TK_CASE );
119755 if( pWalker->u.iCur==pExpr->iTable ){
119770 testcase( pExpr->op==TK_OR );
119771 testcase( pExpr->op==TK_AND );
119772 bothImplyNotNullRow(pWalker, pExpr->pLeft, pExpr->pRight);
119780 if( ExprUseXList(pExpr) && ALWAYS(pExpr->x.pList->nExpr>0) ){
119781 sqlite3WalkExpr(pWalker, pExpr->pLeft);
119788 assert( ExprUseXList(pExpr) );
119789 assert( pExpr->x.pList->nExpr==2 );
119790 sqlite3WalkExpr(pWalker, pExpr->pLeft);
119791 bothImplyNotNullRow(pWalker, pExpr->x.pList->a[0].pExpr,
119792 pExpr->x.pList->a[1].pExpr);
119804 Expr *pLeft = pExpr->pLeft;
119805 Expr *pRight = pExpr->pRight;
119806 testcase( pExpr->op==TK_EQ );
119807 testcase( pExpr->op==TK_NE );
119808 testcase( pExpr->op==TK_LT );
119809 testcase( pExpr->op==TK_LE );
119810 testcase( pExpr->op==TK_GT );
119811 testcase( pExpr->op==TK_GE );
119893 static int exprIdxCover(Walker *pWalker, Expr *pExpr){ argument
119894 if( pExpr->op==TK_COLUMN
119895 && pExpr->iTable==pWalker->u.pIdxCover->iCur
119896 && sqlite3TableColumnToIndex(pWalker->u.pIdxCover->pIdx, pExpr->iColumn)<0
119915 Expr *pExpr, /* The index to be tested */ argument
119926 sqlite3WalkExpr(&w, pExpr);
119986 static int exprRefToSrcList(Walker *pWalker, Expr *pExpr){ argument
119987 if( pExpr->op==TK_COLUMN
119988 || pExpr->op==TK_AGG_COLUMN
119995 if( pExpr->iTable==pSrc->a[i].iCursor ){
120000 for(i=0; i<p->nExclude && p->aiExclude[i]!=pExpr->iTable; i++){}
120023 SQLITE_PRIVATE int sqlite3ReferencesSrcList(Parse *pParse, Expr *pExpr, SrcList *pSrcList){ argument
120035 assert( pExpr->op==TK_AGG_FUNCTION );
120036 assert( ExprUseXList(pExpr) );
120037 sqlite3WalkExprList(&w, pExpr->x.pList);
120038 if( pExpr->pLeft ){
120039 assert( pExpr->pLeft->op==TK_ORDER );
120040 assert( ExprUseXList(pExpr->pLeft) );
120041 assert( pExpr->pLeft->x.pList!=0 );
120042 sqlite3WalkExprList(&w, pExpr->pLeft->x.pList);
120045 if( ExprHasProperty(pExpr, EP_WinFunc) ){
120046 sqlite3WalkExpr(&w, pExpr->y.pWin->pFilter);
120070 static int agginfoPersistExprCb(Walker *pWalker, Expr *pExpr){ argument
120071 if( ALWAYS(!ExprHasProperty(pExpr, EP_TokenOnly|EP_Reduced))
120072 && pExpr->pAggInfo!=0
120074 AggInfo *pAggInfo = pExpr->pAggInfo;
120075 int iAgg = pExpr->iAgg;
120079 if( pExpr->op!=TK_AGG_FUNCTION ){
120081 && pAggInfo->aCol[iAgg].pCExpr==pExpr
120083 pExpr = sqlite3ExprDup(db, pExpr, 0);
120084 if( pExpr && !sqlite3ExprDeferredDelete(pParse, pExpr) ){
120085 pAggInfo->aCol[iAgg].pCExpr = pExpr;
120089 assert( pExpr->op==TK_AGG_FUNCTION );
120091 && pAggInfo->aFunc[iAgg].pFExpr==pExpr
120093 pExpr = sqlite3ExprDup(db, pExpr, 0);
120094 if( pExpr && !sqlite3ExprDeferredDelete(pParse, pExpr) ){
120095 pAggInfo->aFunc[iAgg].pFExpr = pExpr;
120156 Expr *pExpr /* Expr describing the column to find or insert */ argument
120166 if( pCol->pCExpr==pExpr ) return;
120167 if( pCol->iTable==pExpr->iTable
120168 && pCol->iColumn==pExpr->iColumn
120169 && pExpr->op!=TK_IF_NULL_ROW
120185 assert( ExprUseYTab(pExpr) );
120186 pCol->pTab = pExpr->y.pTab;
120187 pCol->iTable = pExpr->iTable;
120188 pCol->iColumn = pExpr->iColumn;
120190 pCol->pCExpr = pExpr;
120191 if( pAggInfo->pGroupBy && pExpr->op!=TK_IF_NULL_ROW ){
120197 Expr *pE = pTerm->pExpr;
120199 && pE->iTable==pExpr->iTable
120200 && pE->iColumn==pExpr->iColumn
120211 ExprSetVVAProperty(pExpr, EP_NoReduce);
120212 assert( pExpr->pAggInfo==0 || pExpr->pAggInfo==pAggInfo );
120213 pExpr->pAggInfo = pAggInfo;
120214 if( pExpr->op==TK_COLUMN ){
120215 pExpr->op = TK_AGG_COLUMN;
120217 assert( k <= SMXV(pExpr->iAgg) );
120218 pExpr->iAgg = (i16)k;
120226 static int analyzeAggregate(Walker *pWalker, Expr *pExpr){ argument
120235 switch( pExpr->op ){
120245 if( sqlite3ExprCompare(0, pExpr, pIEpr->pExpr, iDataCur)==0 ) break;
120248 if( NEVER(!ExprUseYTab(pExpr)) ) break;
120256 if( NEVER(pExpr->pAggInfo!=0) ) break; /* Resolved by outer context */
120271 pAggInfo->aCol[tmp.iAgg].pCExpr = pExpr;
120272 pExpr->pAggInfo = pAggInfo;
120273 pExpr->iAgg = tmp.iAgg;
120279 testcase( pExpr->op==TK_AGG_COLUMN );
120280 testcase( pExpr->op==TK_COLUMN );
120281 testcase( pExpr->op==TK_IF_NULL_ROW );
120287 assert( !ExprHasProperty(pExpr, EP_TokenOnly|EP_Reduced) );
120288 if( pExpr->iTable==pItem->iCursor ){
120289 findOrCreateAggInfoColumn(pParse, pAggInfo, pExpr);
120298 && pWalker->walkerDepth==pExpr->op2
120299 && pExpr->pAggInfo==0
120308 if( NEVER(pItem->pFExpr==pExpr) ) break;
120309 if( sqlite3ExprCompare(0, pItem->pFExpr, pExpr, -1)==0 ){
120324 assert( !ExprHasProperty(pExpr, EP_xIsSelect) );
120326 pItem->pFExpr = pExpr;
120327 assert( ExprUseUToken(pExpr) );
120328 nArg = pExpr->x.pList ? pExpr->x.pList->nExpr : 0;
120330 pExpr->u.zToken, nArg, enc, 0);
120332 if( pExpr->pLeft
120339 assert( pExpr->pLeft->op==TK_ORDER );
120340 assert( ExprUseXList(pExpr->pLeft) );
120342 pOBList = pExpr->pLeft->x.pList;
120347 && sqlite3ExprCompare(0,pOBList->a[0].pExpr,
120348 pExpr->x.pList->a[0].pExpr,0)==0
120351 pItem->bOBUnique = ExprHasProperty(pExpr, EP_Distinct);
120360 if( ExprHasProperty(pExpr, EP_Distinct) && !pItem->bOBUnique ){
120369 assert( !ExprHasProperty(pExpr, EP_TokenOnly|EP_Reduced) );
120370 ExprSetVVAProperty(pExpr, EP_NoReduce);
120371 assert( i <= SMXV(pExpr->iAgg) );
120372 pExpr->iAgg = (i16)i;
120373 pExpr->pAggInfo = pAggInfo;
120392 SQLITE_PRIVATE void sqlite3ExprAnalyzeAggregates(NameContext *pNC, Expr *pExpr){ argument
120401 sqlite3WalkExpr(&w, pExpr);
120415 sqlite3ExprAnalyzeAggregates(pNC, pItem->pExpr);
121364 static int renameUnmapExprCb(Walker *pWalker, Expr *pExpr){ argument
121366 sqlite3RenameTokenRemap(pParse, 0, (const void*)pExpr);
121367 if( ExprUseYTab(pExpr) ){
121368 sqlite3RenameTokenRemap(pParse, 0, (const void*)&pExpr->y.pTab);
121462 SQLITE_PRIVATE void sqlite3RenameExprUnmap(Parse *pParse, Expr *pExpr){ argument
121470 sqlite3WalkExpr(&sWalker, pExpr);
121563 static int renameColumnExprCb(Walker *pWalker, Expr *pExpr){ argument
121565 if( pExpr->op==TK_TRIGGER
121566 && pExpr->iColumn==p->iCol
121569 renameTokenFind(pWalker->pParse, p, (void*)pExpr);
121570 }else if( pExpr->op==TK_COLUMN
121571 && pExpr->iColumn==p->iCol
121572 && ALWAYS(ExprUseYTab(pExpr))
121573 && p->pTab==pExpr->y.pTab
121575 renameTokenFind(pWalker->pParse, p, (void*)pExpr);
122166 Expr *pExpr = sqlite3ColumnExpr(sParse.pNewTable, local
122168 sqlite3WalkExpr(&sWalker, pExpr);
122244 static int renameTableExprCb(Walker *pWalker, Expr *pExpr){ argument
122246 if( pExpr->op==TK_COLUMN
122247 && ALWAYS(ExprUseYTab(pExpr))
122248 && p->pTab==pExpr->y.pTab
122250 renameTokenFind(pWalker->pParse, p, (void*)&pExpr->y.pTab);
122451 static int renameQuotefixExprCb(Walker *pWalker, Expr *pExpr){ argument
122452 if( pExpr->op==TK_STRING && (pExpr->flags & EP_DblQuoted) ){
122453 renameTokenFind(pWalker->pParse, pWalker->u.pRename, (const void*)pExpr);
123540 Expr *pExpr /* The parsed CHECK expression */ argument
123553 sqlite3ExprDelete(pParse->db, pExpr);
123560 rc = sqlite3ResolveSelfReference(pParse, pTab, NC_IsCheck, pExpr, 0);
123561 sqlite3ExprDelete(pParse->db, pExpr);
125671 static int resolveAttachExpr(NameContext *pName, Expr *pExpr) argument
125674 if( pExpr ){
125675 if( pExpr->op!=TK_ID ){
125676 rc = sqlite3ResolveExprNames(pName, pExpr);
125678 pExpr->op = TK_STRING;
126104 static int fixExprCb(Walker *p, Expr *pExpr){ argument
126106 if( !pFix->bTemp ) ExprSetProperty(pExpr, EP_FromDDL);
126107 if( pExpr->op==TK_VARIABLE ){
126109 pExpr->op = TK_NULL;
126229 Expr *pExpr /* The expression to be fixed to one database */ argument
126231 return sqlite3WalkExpr(&pFix->w, pExpr);
126408 Expr *pExpr, /* The expression to check authorization on */ argument
126418 assert( pExpr->op==TK_COLUMN || pExpr->op==TK_TRIGGER );
126428 if( pExpr->op==TK_TRIGGER ){
126433 if( pExpr->iTable==pTabList->a[iSrc].iCursor ){
126439 iCol = pExpr->iColumn;
126453 pExpr->op = TK_NULL;
126781 sqlite3ExprCode(pParse, pEL->a[i].pExpr, pEL->a[i].u.iConstExprReg);
127220 Expr *pExpr /* The new default expression */ argument
127230 pTab->u.tab.pDfltList = sqlite3ExprListAppend(pParse, pList, pExpr);
127232 sqlite3ExprDelete(pParse->db, pList->a[pCol->iDflt-1].pExpr);
127233 pList->a[pCol->iDflt-1].pExpr = pExpr;
127247 return pTab->u.tab.pDfltList->a[pCol->iDflt-1].pExpr;
128264 Expr *pExpr, /* The parsed expression of the default value */ argument
128275 if( !sqlite3ExprIsConstantOrFunction(pExpr, isInit) ){
128292 x.pLeft = pExpr;
128300 sqlite3RenameExprUnmap(pParse, pExpr);
128302 sqlite3ExprDelete(db, pExpr);
128388 Expr *pCExpr = sqlite3ExprSkipCollate(pList->a[i].pExpr);
128407 Expr *pCExpr = sqlite3ExprSkipCollate(pList->a[0].pExpr);
128504 SQLITE_PRIVATE void sqlite3AddGenerated(Parse *pParse, Expr *pExpr, Token *pType){ argument
128536 if( ALWAYS(pExpr) && pExpr->op==TK_ID ){
128541 pExpr = sqlite3PExpr(pParse, TK_UPLUS, pExpr, 0);
128543 if( pExpr && pExpr->op!=TK_RAISE ) pExpr->affExpr = pCol->affinity;
128544 sqlite3ColumnSetExpr(pParse, pTab, pCol, pExpr);
128545 pExpr = 0;
128552 sqlite3ExprDelete(pParse->db, pExpr);
128557 sqlite3ExprDelete(pParse->db, pExpr);
128932 sqlite3RenameTokenRemap(pParse, pList->a[0].pExpr, &pTab->iPKey);
129130 static int markImmutableExprStep(Walker *pWalker, Expr *pExpr){ argument
129132 ExprSetVVAProperty(pExpr, EP_Immutable);
130686 Expr *pExpr = pList->a[i].pExpr; local
130687 assert( pExpr!=0 );
130688 if( pExpr->op==TK_COLLATE ){
130689 assert( !ExprHasProperty(pExpr, EP_IntValue) );
130690 nExtra += (1 + sqlite3Strlen30(pExpr->u.zToken));
130750 sqlite3StringToId(pListItem->pExpr);
130751 sqlite3ResolveSelfReference(pParse, pTab, NC_IdxExpr, pListItem->pExpr, 0);
130753 pCExpr = sqlite3ExprSkipCollate(pListItem->pExpr);
130785 if( pListItem->pExpr->op==TK_COLLATE ){
130787 assert( !ExprHasProperty(pListItem->pExpr, EP_IntValue) );
130788 zColl = pListItem->pExpr->u.zToken;
136329 SQLITE_PRIVATE int sqlite3IsLikeFunction(sqlite3 *db, Expr *pExpr, int *pIsNocase, char *aWc){ argument
136332 assert( pExpr!=0 );
136333 assert( pExpr->op==TK_FUNCTION );
136334 assert( ExprUseXList(pExpr) );
136335 if( !pExpr->x.pList ){
136338 nExpr = pExpr->x.pList->nExpr;
136339 assert( !ExprHasProperty(pExpr, EP_IntValue) );
136340 pDef = sqlite3FindFunction(db, pExpr->u.zToken, nExpr, SQLITE_UTF8, 0);
136360 Expr *pEscape = pExpr->x.pList->a[2].pExpr;
137880 Expr *pExpr; local
137885 pExpr = sqlite3Expr(db, TK_REGISTER, 0);
137886 if( pExpr ){
137889 pExpr->iTable = regBase + sqlite3TableColumnToStorage(pTab,iCol) + 1;
137890 pExpr->affExpr = pCol->affinity;
137893 pExpr = sqlite3ExprAddCollateString(pParse, pExpr, zColl);
137895 pExpr->iTable = regBase;
137896 pExpr->affExpr = SQLITE_AFF_INTEGER;
137899 return pExpr;
137912 Expr *pExpr = sqlite3Expr(db, TK_COLUMN, 0); local
137913 if( pExpr ){
137914 assert( ExprUseYTab(pExpr) );
137915 pExpr->y.pTab = pTab;
137916 pExpr->iTable = iCursor;
137917 pExpr->iColumn = iCol;
137919 return pExpr;
138996 aff = sqlite3ExprAffinity(pIdx->aColExpr->a[n].pExpr);
139163 static int exprColumnFlagUnion(Walker *pWalker, Expr *pExpr){ argument
139164 if( pExpr->op==TK_COLUMN && pExpr->iColumn>=0 ){
139165 assert( pExpr->iColumn < pWalker->u.pTab->nCol );
139166 pWalker->eCode |= pWalker->u.pTab->aCol[pExpr->iColumn].colFlags;
139500 if( 0==sqlite3ExprIsConstant(pParse, pRow->a[ii].pExpr) ) return 0;
139513 Expr *pExpr = pRow->a[ii].pExpr; local
139514 assert( pExpr->op!=TK_RAISE );
139515 assert( pExpr->affExpr==0 );
139516 if( 0!=sqlite3ExprAffinity(pExpr) ) return 0;
140324 Expr *pX = pList->a[k].pExpr;
140355 sqlite3ExprCode(pParse, pList->a[ipkColumn].pExpr, regCols);
140407 Expr *pIpk = pList->a[ipkColumn].pExpr;
140412 sqlite3ExprCode(pParse, pList->a[ipkColumn].pExpr, regRowid);
140583 static int checkConstraintExprNode(Walker *pWalker, Expr *pExpr){ argument
140584 if( pExpr->op==TK_COLUMN ){
140585 assert( pExpr->iColumn>=0 || pExpr->iColumn==-1 );
140586 if( pExpr->iColumn>=0 ){
140587 if( pWalker->u.aiCol[pExpr->iColumn]>=0 ){
140613 Expr *pExpr, /* The expression to be checked */ argument
140622 sqlite3WalkExpr(&w, pExpr);
140965 Expr *pExpr = pCheck->a[i].pExpr; local
140967 && !sqlite3ExprReferencesUpdatedColumn(pExpr, aiChng, pkChng)
140979 pCopy = sqlite3ExprDup(db, pExpr, 0);
141327 sqlite3ExprCodeCopy(pParse, pIdx->aColExpr->a[i].pExpr, regIdx+i);
141861 if( sqlite3ExprCompare(0, pSrc->aColExpr->a[i].pExpr,
141862 pDest->aColExpr->a[i].pExpr, -1)!=0 ){
141977 assert( pEList->a[0].pExpr );
141978 if( pEList->a[0].pExpr->op!=TK_ASTERISK ){
146833 sqlite3ExprIfFalse(pParse, pCheck->a[k].pExpr, addrCkFault, 0);
146835 sqlite3ExprIfTrue(pParse, pCheck->a[0].pExpr, addrCkOk,
149441 sqlite3SetJoinExpr(p->x.pList->a[i].pExpr, iTable, joinFlag);
149479 unsetJoinExpr(p->x.pList->a[i].pExpr, iTable, nullable);
149950 CollSeq *pColl = sqlite3ExprCollSeq(pParse, pEList->a[i].pExpr);
150074 Expr *pExpr = pItem->pExpr; local
150076 if( pExpr->op==TK_COLUMN
150077 && pExpr->iColumn>=0
150078 && ALWAYS( ExprUseYTab(pExpr) )
150079 && (pTab = pExpr->y.pTab)!=0
150081 && (pTab->aCol[pExpr->iColumn].colFlags & COLFLAG_SORTERREF)!=0
150085 if( pSort->aDefer[j].iCsr==pExpr->iTable ) break;
150101 pNew->iTable = pExpr->iTable;
150103 pNew->y.pTab = pExpr->y.pTab;
150108 pSort->aDefer[nDefer].pTab = pExpr->y.pTab;
150109 pSort->aDefer[nDefer].iCsr = pExpr->iTable;
150608 pInfo->aColl[i-iStart] = sqlite3ExprNNCollSeq(pParse, pItem->pExpr);
150805 sqlite3ExprCode(pParse, aOutEx[i].pExpr, regRow+i);
150915 Expr *pExpr argument
150917 Expr *pExpr,
150931 assert( pExpr!=0 );
150933 switch( pExpr->op ){
150941 int iCol = pExpr->iColumn; /* Index of column in pTab */
150944 for(j=0;j<pTabList->nSrc && pTabList->a[j].iCursor!=pExpr->iTable;j++);
150978 assert( pTab && ExprUseYTab(pExpr) && pExpr->y.pTab==pTab );
150992 Expr *p = pS->pEList->a[iCol].pExpr;
151036 assert( ExprUseXSelect(pExpr) );
151037 pS = pExpr->x.pSelect;
151038 p = pS->pEList->a[0].pExpr;
151076 Expr *p = pEList->a[i].pExpr;
151160 Expr *p = pEList->a[i].pExpr;
151258 Expr *pColExpr = sqlite3ExprSkipCollateAndLikely(pX->pExpr);
151368 p = a[i].pExpr;
151372 m |= sqlite3ExprDataType(pS2->pEList->a[i].pExpr);
151374 pCol->affinity = sqlite3ExprAffinity(pS2->pEList->a[i].pExpr);
151381 m |= sqlite3ExprDataType(pS2->pEList->a[i].pExpr);
151579 pRet = sqlite3ExprCollSeq(pParse, p->pEList->a[iCol].pExpr);
151602 Expr *pTerm = pItem->pExpr;
151610 pOrderBy->a[i].pExpr =
152792 Expr *pExpr /* Expr in which substitution occurs */ argument
152794 if( pExpr==0 ) return 0;
152795 if( ExprHasProperty(pExpr, EP_OuterON|EP_InnerON)
152796 && pExpr->w.iJoin==pSubst->iTable
152798 testcase( ExprHasProperty(pExpr, EP_InnerON) );
152799 pExpr->w.iJoin = pSubst->iNewTable;
152801 if( pExpr->op==TK_COLUMN
152802 && pExpr->iTable==pSubst->iTable
152803 && !ExprHasProperty(pExpr, EP_FixedCol)
152806 if( pExpr->iColumn<0 ){
152807 pExpr->op = TK_NULL;
152815 iColumn = pExpr->iColumn;
152818 assert( pExpr->pRight==0 );
152819 pCopy = pSubst->pEList->a[iColumn].pExpr;
152839 return pExpr;
152855 pSubst->pCList->a[iColumn].pExpr
152864 if( ExprHasProperty(pExpr,EP_OuterON|EP_InnerON) ){
152865 sqlite3SetJoinExpr(pNew, pExpr->w.iJoin,
152866 pExpr->flags & (EP_OuterON|EP_InnerON));
152868 sqlite3ExprDelete(db, pExpr);
152869 pExpr = pNew;
152873 if( pExpr->op==TK_IF_NULL_ROW && pExpr->iTable==pSubst->iTable ){
152874 pExpr->iTable = pSubst->iNewTable;
152876 if( pExpr->op==TK_AGG_FUNCTION && pExpr->op2>=pSubst->nSelDepth ){
152877 pExpr->op2--;
152879 pExpr->pLeft = substExpr(pSubst, pExpr->pLeft);
152880 pExpr->pRight = substExpr(pSubst, pExpr->pRight);
152881 if( ExprUseXSelect(pExpr) ){
152882 substSelect(pSubst, pExpr->x.pSelect, 1);
152884 substExprList(pSubst, pExpr->x.pList);
152887 if( ExprHasProperty(pExpr, EP_WinFunc) ){
152888 Window *pWin = pExpr->y.pWin;
152895 return pExpr;
152904 pList->a[i].pExpr = substExpr(pSubst, pList->a[i].pExpr);
152946 static int recomputeColumnsUsedExpr(Walker *pWalker, Expr *pExpr){ argument
152948 if( pExpr->op!=TK_COLUMN ) return WRC_Continue;
152950 if( pItem->iCursor!=pExpr->iTable ) return WRC_Continue;
152951 if( pExpr->iColumn<0 ) return WRC_Continue;
152952 pItem->colUsed |= sqlite3ExprColUsed(pExpr);
153024 static int renumberCursorsCb(Walker *pWalker, Expr *pExpr){ argument
153025 int op = pExpr->op;
153027 renumberCursorDoMapping(pWalker, &pExpr->iTable);
153029 if( ExprHasProperty(pExpr, EP_OuterON) ){
153030 renumberCursorDoMapping(pWalker, &pExpr->w.iJoin);
153095 assert( pList->a[ii].pExpr!=0 );
153096 aff = sqlite3ExprAffinity(pList->a[ii].pExpr);
153100 assert( pSub1->pEList->a[ii].pExpr!=0 );
153101 if( sqlite3ExprAffinity(pSub1->pEList->a[ii].pExpr)!=aff ){
153745 Expr *pExpr /* Overall expression: COLUMN=VALUE or VALUE=COLUMN */ argument
153753 if( !sqlite3IsBinary(sqlite3ExprCompareCollSeq(pConst->pParse,pExpr)) ){
153790 static void findConstInWhere(WhereConst *pConst, Expr *pExpr){ argument
153792 if( NEVER(pExpr==0) ) return;
153793 if( ExprHasProperty(pExpr, pConst->mExcludeOn) ){
153794 testcase( ExprHasProperty(pExpr, EP_OuterON) );
153795 testcase( ExprHasProperty(pExpr, EP_InnerON) );
153798 if( pExpr->op==TK_AND ){
153799 findConstInWhere(pConst, pExpr->pRight);
153800 findConstInWhere(pConst, pExpr->pLeft);
153803 if( pExpr->op!=TK_EQ ) return;
153804 pRight = pExpr->pRight;
153805 pLeft = pExpr->pLeft;
153809 constInsert(pConst,pRight,pLeft,pExpr);
153812 constInsert(pConst,pLeft,pRight,pExpr);
153827 Expr *pExpr, argument
153832 if( pExpr->op!=TK_COLUMN ) return WRC_Continue;
153833 if( ExprHasProperty(pExpr, EP_FixedCol|pConst->mExcludeOn) ){
153834 testcase( ExprHasProperty(pExpr, EP_FixedCol) );
153835 testcase( ExprHasProperty(pExpr, EP_OuterON) );
153836 testcase( ExprHasProperty(pExpr, EP_InnerON) );
153841 if( pColumn==pExpr ) continue;
153842 if( pColumn->iTable!=pExpr->iTable ) continue;
153843 if( pColumn->iColumn!=pExpr->iColumn ) continue;
153850 ExprClearProperty(pExpr, EP_Leaf);
153851 ExprSetProperty(pExpr, EP_FixedCol);
153852 assert( pExpr->pLeft==0 );
153853 pExpr->pLeft = sqlite3ExprDup(pConst->pParse->db, pConst->apExpr[i*2+1], 0);
153876 static int propagateConstantExprRewrite(Walker *pWalker, Expr *pExpr){ argument
153883 if( (pExpr->op>=TK_EQ && pExpr->op<=TK_GE)
153884 || pExpr->op==TK_IS
153886 propagateConstantExprRewriteOne(pConst, pExpr->pLeft, 0);
153888 if( sqlite3ExprAffinity(pExpr->pLeft)!=SQLITE_AFF_TEXT ){
153889 propagateConstantExprRewriteOne(pConst, pExpr->pRight, 0);
153893 return propagateConstantExprRewriteOne(pConst, pExpr, pConst->bHasAffBlob);
154009 static int pushDownWindowCheck(Parse *pParse, Select *pSubq, Expr *pExpr){ argument
154013 return sqlite3ExprIsConstantOrGroupBy(pParse, pExpr, pSubq->pWin->pPartition);
154169 CollSeq *pColl = sqlite3ExprCollSeq(pParse, pList->a[ii].pExpr);
154351 Expr *pY = pX->pEList->a[j].pExpr;
154402 if( sqlite3ExprCanBeNull(pEList->a[0].pExpr) ){
154436 Expr *pExpr; local
154453 pExpr = p->pEList->a[0].pExpr;
154454 assert( pExpr!=0 );
154455 if( pExpr->op!=TK_AGG_FUNCTION ) return 0;
154456 if( pExpr->pAggInfo!=pAggInfo ) return 0;
154458 assert( pAggInfo->aFunc[0].pFExpr==pExpr );
154459 testcase( ExprHasProperty(pExpr, EP_Distinct) );
154460 testcase( ExprHasProperty(pExpr, EP_WinFunc) );
154461 if( ExprHasProperty(pExpr, EP_Distinct|EP_WinFunc) ) return 0;
154539 if( a[i].pExpr->flags & EP_Collate ) break;
154966 Expr *pE, *pRight, *pExpr; local
155104 pE = pEList->a[k].pExpr;
155124 pE = a[k].pExpr;
155133 pNew = sqlite3ExprListAppend(pParse, pNew, a[k].pExpr);
155139 a[k].pExpr = 0;
155273 pExpr = sqlite3PExpr(pParse, TK_DOT, pLeft, pRight);
155279 pExpr = sqlite3PExpr(pParse, TK_DOT, pLeft, pExpr);
155282 pExpr = pRight;
155284 sqlite3ExprSetErrorOffset(pExpr, iErrOfst);
155285 pNew = sqlite3ExprListAppend(pParse, pNew, pExpr);
155525 Expr *pExpr = pAggInfo->aFunc[i].pFExpr; local
155526 assert( pExpr->op==TK_FUNCTION || pExpr->op==TK_AGG_FUNCTION );
155527 assert( ExprUseXList(pExpr) );
155528 sqlite3ExprAnalyzeAggList(pNC, pExpr->x.pList);
155529 if( pExpr->pLeft ){
155530 assert( pExpr->pLeft->op==TK_ORDER );
155531 assert( ExprUseXList(pExpr->pLeft) );
155532 sqlite3ExprAnalyzeAggList(pNC, pExpr->pLeft->x.pList);
155535 assert( !IsWindowFunc(pExpr) );
155536 if( ExprHasProperty(pExpr, EP_WinFunc) ){
155537 sqlite3ExprAnalyzeAggregates(pNC, pExpr->y.pWin->pFilter);
155580 sqlite3TreeViewExpr(0, pIEpr->pExpr, 0);
155593 static int aggregateIdxEprRefToColCallback(Walker *pWalker, Expr *pExpr){ argument
155597 if( pExpr->pAggInfo==0 ) return WRC_Continue;
155598 if( pExpr->op==TK_AGG_COLUMN ) return WRC_Continue;
155599 if( pExpr->op==TK_AGG_FUNCTION ) return WRC_Continue;
155600 if( pExpr->op==TK_IF_NULL_ROW ) return WRC_Continue;
155601 pAggInfo = pExpr->pAggInfo;
155602 if( NEVER(pExpr->iAgg>=pAggInfo->nColumn) ) return WRC_Continue;
155603 assert( pExpr->iAgg>=0 );
155604 pCol = &pAggInfo->aCol[pExpr->iAgg];
155605 pExpr->op = TK_AGG_COLUMN;
155606 pExpr->iTable = pCol->iTable;
155607 pExpr->iColumn = pCol->iColumn;
155608 ExprClearProperty(pExpr, EP_Skip|EP_Collate|EP_Unlikely);
155926 pColl = sqlite3ExprCollSeq(pParse, pItem->pExpr);
155996 static int havingToWhereExprCb(Walker *pWalker, Expr *pExpr){ argument
155997 if( pExpr->op!=TK_AND ){
156006 if( sqlite3ExprIsConstantOrGroupBy(pWalker->pParse, pExpr, pS->pGroupBy)
156007 && ExprAlwaysFalse(pExpr)==0
156008 && pExpr->pAggInfo==0
156014 SWAP(Expr, *pNew, *pExpr);
156132 Expr *pExpr; local
156142 pExpr = p->pEList->a[0].pExpr;
156143 if( pExpr->op!=TK_AGG_FUNCTION ) return 0; /* Result is an aggregate */
156144 assert( ExprUseUToken(pExpr) );
156145 if( sqlite3_stricmp(pExpr->u.zToken,"count") ) return 0; /* Is count() */
156146 assert( ExprUseXList(pExpr) );
156147 if( pExpr->x.pList!=0 ) return 0; /* Must be count(*) */
156149 if( ExprHasProperty(pExpr, EP_WinFunc) ) return 0;/* Not a window function */
156171 pCount = pExpr;
156172 pExpr = 0;
156189 if( pExpr==0 ){
156190 pExpr = pTerm;
156192 pExpr = sqlite3PExpr(pParse, TK_PLUS, pTerm, pExpr);
156196 p->pEList->a[0].pExpr = pExpr;
156402 static int selectCheckOnClausesExpr(Walker *pWalker, Expr *pExpr){ argument
156413 if( (ExprHasProperty(pExpr, EP_OuterON))
156414 || (ExprHasProperty(pExpr, EP_InnerON) && hasRightJoin(pCtx->pSrc))
156421 assert( pCtx->iJoin==0 || pCtx->iJoin==pExpr->w.iJoin );
156423 pCtx->iJoin = pExpr->w.iJoin;
156424 sqlite3WalkExprNN(pWalker, pExpr);
156430 if( pExpr->op==TK_COLUMN ){
156438 int iTab = pExpr->iTable;
157234 sqlite3ExprDelete(db, pEList->a[ii].pExpr);
157239 if( pEList->a[ii].fg.bUsed==0 ) pEList->a[ii].pExpr->op = TK_NULL;
157481 Expr *pExpr = pAggInfo->aFunc[0].pFExpr->x.pList->a[0].pExpr; local
157482 pExpr = sqlite3ExprDup(db, pExpr, 0);
157484 pDistinct = sqlite3ExprListAppend(pParse, pDistinct, pExpr);
157653 sqlite3ExprCode(pParse, pGroupBy->a[j].pExpr, iBMem+j);
157657 Expr *pX = p->pEList->a[iOrderByCol-1].pExpr;
157947 Expr *pExpr = pAggInfo->aCol[i].pCExpr; local
157948 if( pExpr==0 ) continue;
157949 assert( pExpr->pAggInfo==pAggInfo );
157950 assert( pExpr->iAgg==i );
157953 Expr *pExpr = pAggInfo->aFunc[i].pFExpr; local
157954 assert( pExpr!=0 );
157955 assert( pExpr->pAggInfo==pAggInfo );
157956 assert( pExpr->iAgg==i );
159094 Expr *pOldExpr = pList->a[i].pExpr;
159126 static int sqlite3ReturningSubqueryVarSelect(Walker *NotUsed, Expr *pExpr){ argument
159128 if( ExprUseXSelect(pExpr)
159129 && (pExpr->x.pSelect->selFlags & SF_Correlated)!=0
159131 testcase( ExprHasProperty(pExpr, EP_VarSelect) );
159132 ExprSetProperty(pExpr, EP_VarSelect);
159261 Expr *pCol = pNew->a[i].pExpr;
159861 assert( pIdx->aColExpr->a[iCol].pExpr!=0 );
159862 return sqlite3ExprReferencesUpdatedColumn(pIdx->aColExpr->a[iCol].pExpr,
160012 sqlite3ExprDup(db, pChanges->a[i].pExpr, 0)
160221 if( nChangeFrom==0 && sqlite3ResolveExprNames(&sNC, pChanges->a[i].pExpr) ){
160228 pRowidExpr = pChanges->a[i].pExpr;
160248 pRowidExpr = pChanges->a[i].pExpr;
160705 sqlite3ExprCode(pParse, pChanges->a[j].pExpr, k);
160997 pRow = sqlite3ExprDup(db, pChanges->a[aXRef[iPk]].pExpr, 0);
161007 sqlite3ExprDup(db, pChanges->a[aXRef[i]].pExpr, 0)
161033 sqlite3ExprCode(pParse, pChanges->a[aXRef[i]].pExpr, regArg+2+i);
161247 && (pTerm = pTarget->a[0].pExpr)->op==TK_COLUMN
161281 Expr *pExpr; local
161287 pExpr = pIdx->aColExpr->a[ii].pExpr;
161288 if( pExpr->op!=TK_COLLATE ){
161289 sCol[0].pLeft = pExpr;
161290 pExpr = &sCol[0];
161295 pExpr = &sCol[0];
161298 if( sqlite3ExprCompare(0,pTarget->a[jj].pExpr,pExpr,iCursor)<2 ){
163040 Expr *pExpr /* First argument to the function */ argument
163051 if( NEVER(pExpr==0) ) return pDef;
163052 if( pExpr->op!=TK_COLUMN ) return pDef;
163053 assert( ExprUseYTab(pExpr) );
163054 pTab = pExpr->y.pTab;
163563 Expr *pExpr; /* Pointer to the subexpression that is this term */ member
164361 && (pLevel->iLeftJoin==0 || ExprHasProperty(pTerm->pExpr, EP_OuterON))
164537 if( pLoop->aLTerm[i]->pExpr==pX ){
164541 if( NEVER(pOrigRhs->a[iField].pExpr==0) ){
164544 pRhs = sqlite3ExprListAppend(pParse, pRhs, pOrigRhs->a[iField].pExpr);
164545 pOrigRhs->a[iField].pExpr = 0;
164548 assert( pOrigLhs->a[iField].pExpr!=0 );
164549 pLhs = sqlite3ExprListAppend(pParse,pLhs,pOrigLhs->a[iField].pExpr);
164550 pOrigLhs->a[iField].pExpr = 0;
164565 Expr *p = pLhs->a[0].pExpr;
164566 pLhs->a[0].pExpr = 0;
164614 Expr *pX = pTerm->pExpr;
164635 if( pLoop->aLTerm[i] && pLoop->aLTerm[i]->pExpr==pX ){
164642 if( pLoop->aLTerm[i]->pExpr==pX ) nEq++;
164686 if( pLoop->aLTerm[i]->pExpr==pX ){
164749 Expr *pX = pTerm->pExpr;
164907 if( pTerm->pExpr->flags & EP_xIsSelect ){
164915 Expr *pRight = pTerm->pExpr->pRight;
164991 static int codeCursorHintCheckExpr(Walker *pWalker, Expr *pExpr){ argument
164994 if( pExpr->op==TK_COLUMN
164995 && pExpr->iTable==pHint->iTabCur
164996 && sqlite3TableColumnToIndex(pHint->pIdx, pExpr->iColumn)<0
165018 static int codeCursorHintIsOrFunction(Walker *pWalker, Expr *pExpr){ argument
165019 if( pExpr->op==TK_IS
165020 || pExpr->op==TK_ISNULL || pExpr->op==TK_ISNOT
165021 || pExpr->op==TK_NOTNULL || pExpr->op==TK_CASE
165024 }else if( pExpr->op==TK_FUNCTION ){
165027 if( 0==sqlite3IsLikeFunction(pWalker->pParse->db, pExpr, &d1, d2) ){
165053 static int codeCursorHintFixExpr(Walker *pWalker, Expr *pExpr){ argument
165057 if( pExpr->op==TK_COLUMN ){
165058 if( pExpr->iTable!=pHint->iTabCur ){
165060 reg = sqlite3ExprCodeTarget(pWalker->pParse, pExpr, reg);
165061 pExpr->op = TK_REGISTER;
165062 pExpr->iTable = reg;
165064 pExpr->iTable = pHint->iIdxCur;
165065 pExpr->iColumn = sqlite3TableColumnToIndex(pHint->pIdx, pExpr->iColumn);
165066 assert( pExpr->iColumn>=0 );
165068 }else if( pExpr->pAggInfo ){
165071 reg = sqlite3ExprCodeTarget(pWalker->pParse, pExpr, reg);
165072 pExpr->op = TK_REGISTER;
165073 pExpr->iTable = reg;
165074 }else if( pExpr->op==TK_TRUEFALSE ){
165093 Expr *pExpr = 0; local
165140 Expr *pExpr = pTerm->pExpr; local
165141 if( !ExprHasProperty(pExpr, EP_OuterON)
165142 || pExpr->w.iJoin!=pTabItem->iCursor
165146 sqlite3WalkExpr(&sWalker, pTerm->pExpr);
165150 if( ExprHasProperty(pTerm->pExpr, EP_OuterON) ) continue;
165162 if( sqlite3ExprContainsSubquery(pTerm->pExpr) ) continue;
165169 sqlite3WalkExpr(&sWalker, pTerm->pExpr);
165174 pExpr = sqlite3ExprAnd(pParse, pExpr, sqlite3ExprDup(db, pTerm->pExpr, 0));
165176 if( pExpr!=0 ){
165178 if( pParse->nErr==0 ) sqlite3WalkExpr(&sWalker, pExpr);
165181 (const char*)pExpr, P4_EXPR);
165277 sqlite3ExprCode(pParse, pList->a[i].pExpr, iReg+i);
165305 Expr *pExpr; local
165307 pExpr = pTerm->pExpr;
165308 if( sqlite3ExprCompare(0, pExpr, pTruth, iTabCur)==0 ){
165351 assert( pTerm->pExpr!=0 );
165514 sqlite3CodeRhsOfIN(pParse, pTerm->pExpr, iTab, 0);
165521 Expr *pRight = pTerm->pExpr->pRight;
165589 Expr *pLeft = pTerm->pExpr->pLeft;
165595 pCompare->pLeft = pLeft->x.pList->a[iFld-1].pExpr;
165633 assert( pTerm->pExpr!=0 );
165691 pX = pStart->pExpr;
165725 pX = pEnd->pExpr;
165932 Expr *pRight = pRangeStart->pExpr->pRight;
166033 Expr *pRight = pRangeEnd->pExpr->pRight;
166319 Expr *pExpr = pWC->a[iTerm].pExpr; local
166328 if( ExprHasProperty(pExpr, EP_Subquery) ) continue; /* tag-20220303a */
166329 pExpr = sqlite3ExprDup(db, pExpr, 0);
166330 pAndExpr = sqlite3ExprAnd(pParse, pAndExpr, pExpr);
166351 Expr *pOrExpr = pOrTerm->pExpr; /* Current OR clause term */
166567 pE = pTerm->pExpr;
166644 pE = pTerm->pExpr;
166658 if( ExprHasProperty(pAlt->pExpr, EP_Collate) ) continue;
166660 && ExprUseXSelect(pAlt->pExpr)
166661 && (pAlt->pExpr->x.pSelect->pEList->nExpr>1)
166669 sEAlt = *pAlt->pExpr;
166756 assert( pTerm->pExpr );
166757 sqlite3ExprIfFalse(pParse, pTerm->pExpr, addrCont, SQLITE_JUMPIFNULL);
166836 if( ExprHasProperty(pTerm->pExpr, EP_OuterON|EP_InnerON) ) continue;
166838 sqlite3ExprDup(pParse->db, pTerm->pExpr, 0));
166979 pTerm->pExpr = sqlite3ExprSkipCollateAndLikely(p);
167010 static u16 exprCommute(Parse *pParse, Expr *pExpr){ argument
167011 if( pExpr->pLeft->op==TK_VECTOR
167012 || pExpr->pRight->op==TK_VECTOR
167013 || sqlite3BinaryCompareCollSeq(pParse, pExpr->pLeft, pExpr->pRight) !=
167014 sqlite3BinaryCompareCollSeq(pParse, pExpr->pRight, pExpr->pLeft)
167016 pExpr->flags ^= EP_Commuted;
167018 SWAP(Expr*,pExpr->pRight,pExpr->pLeft);
167019 if( pExpr->op>=TK_GT ){
167024 assert( pExpr->op>=TK_GT && pExpr->op<=TK_GE );
167025 pExpr->op = ((pExpr->op-TK_GT)^2)+TK_GT;
167074 Expr *pExpr, /* Test this expression */ argument
167090 if( !sqlite3IsLikeFunction(db, pExpr, pnoCase, (char*)wc) ){
167096 assert( ExprUseXList(pExpr) );
167097 pList = pExpr->x.pList;
167098 pLeft = pList->a[1].pExpr;
167100 pRight = sqlite3ExprSkipCollate(pList->a[0].pExpr);
167247 SQLITE_PRIVATE int sqlite3ExprIsLikeOperator(const Expr *pExpr){ argument
167258 assert( pExpr->op==TK_FUNCTION );
167259 assert( !ExprHasProperty(pExpr, EP_IntValue) );
167261 if( sqlite3StrICmp(pExpr->u.zToken, aOp[i].zOp)==0 ){
167298 Expr *pExpr, /* Test this expression */ argument
167303 if( pExpr->op==TK_FUNCTION ){
167308 assert( ExprUseXList(pExpr) );
167309 pList = pExpr->x.pList;
167321 pCol = pList->a[1].pExpr;
167323 if( ExprIsVtab(pCol) && (i = sqlite3ExprIsLikeOperator(pExpr))!=0 ){
167325 *ppRight = pList->a[0].pExpr;
167340 pCol = pList->a[0].pExpr;
167351 assert( !ExprHasProperty(pExpr, EP_IntValue) );
167354 i = pMod->xFindFunction(pVtab,2, pExpr->u.zToken, &xNotUsed, &pNotUsed);
167357 *ppRight = pList->a[1].pExpr;
167363 }else if( pExpr->op>=TK_EQ ){
167370 }else if( pExpr->op==TK_NE || pExpr->op==TK_ISNOT || pExpr->op==TK_NOTNULL ){
167372 Expr *pLeft = pExpr->pLeft;
167373 Expr *pRight = pExpr->pRight;
167386 if( pExpr->op==TK_NE ) *peOp2 = SQLITE_INDEX_CONSTRAINT_NE;
167387 if( pExpr->op==TK_ISNOT ) *peOp2 = SQLITE_INDEX_CONSTRAINT_ISNOT;
167388 if( pExpr->op==TK_NOTNULL ) *peOp2 = SQLITE_INDEX_CONSTRAINT_ISNOTNULL;
167471 pA = pOne->pExpr;
167472 pB = pTwo->pExpr;
167595 Expr *pExpr = pTerm->pExpr; /* The expression of the term */ local
167609 assert( pExpr->op==TK_OR );
167616 sqlite3WhereSplit(pOrWc, pExpr, TK_OR);
167644 sqlite3WhereSplit(pAndWC, pOrTerm->pExpr, TK_AND);
167649 assert( pAndTerm->pExpr );
167650 if( allowedOp(pAndTerm->pExpr->op)
167762 pLeft = pOrTerm->pExpr->pLeft;
167784 && sqlite3ExprCompare(pParse, pOrTerm->pExpr->pLeft, pLeft, -1)
167793 affRight = sqlite3ExprAffinity(pOrTerm->pExpr->pRight);
167794 affLeft = sqlite3ExprAffinity(pOrTerm->pExpr->pLeft);
167820 pDup = sqlite3ExprDup(db, pOrTerm->pExpr->pRight, 0);
167822 pLeft = pOrTerm->pExpr->pLeft;
167829 transferJoinMarkings(pNew, pExpr);
167861 static int termIsEquivalence(Parse *pParse, Expr *pExpr, SrcList *pSrc){ argument
167864 if( pExpr->op!=TK_EQ && pExpr->op!=TK_IS ) return 0; /* (2) */
167865 if( ExprHasProperty(pExpr, EP_OuterON|EP_Collate) ) return 0; /* (3) */
167867 if( pExpr->op==TK_IS
167873 aff1 = sqlite3ExprAffinity(pExpr->pLeft);
167874 aff2 = sqlite3ExprAffinity(pExpr->pRight);
167880 if( !sqlite3ExprCollSeqMatch(pParse, pExpr->pLeft, pExpr->pRight) ){
167935 Expr *pExpr, /* An operand of a comparison operator */ argument
167948 if( sqlite3ExprCompareSkip(pExpr,pIdx->aColExpr->a[i].pExpr,iCur)==0
167949 && !sqlite3ExprIsConstant(0,pIdx->aColExpr->a[i].pExpr)
167963 Expr *pExpr, /* An operand of a comparison operator */ argument
167974 if( pExpr->op==TK_VECTOR && (op>=TK_GT && ALWAYS(op<=TK_GE)) ){
167975 assert( ExprUseXList(pExpr) );
167976 pExpr = pExpr->x.pList->a[0].pExpr;
167979 if( pExpr->op==TK_COLUMN ){
167980 aiCurCol[0] = pExpr->iTable;
167981 aiCurCol[1] = pExpr->iColumn;
167989 return exprMightBeIndexed2(pFrom,aiCurCol,pExpr,i);
168023 Expr *pExpr; /* The expression to be analyzed */ local
168045 pExpr = pTerm->pExpr;
168046 assert( pExpr!=0 ); /* Because malloc() has not failed */
168047 assert( pExpr->op!=TK_AS && pExpr->op!=TK_COLLATE );
168049 prereqLeft = sqlite3WhereExprUsage(pMaskSet, pExpr->pLeft);
168050 op = pExpr->op;
168052 assert( pExpr->pRight==0 );
168053 if( sqlite3ExprCheckIN(pParse, pExpr) ) return;
168054 if( ExprUseXSelect(pExpr) ){
168055 pTerm->prereqRight = exprSelectUsage(pMaskSet, pExpr->x.pSelect);
168057 pTerm->prereqRight = sqlite3WhereExprListUsage(pMaskSet, pExpr->x.pList);
168061 pTerm->prereqRight = sqlite3WhereExprUsage(pMaskSet, pExpr->pRight);
168062 if( pExpr->pLeft==0
168063 || ExprHasProperty(pExpr, EP_xIsSelect|EP_IfNullRow)
168064 || pExpr->x.pList!=0
168066 prereqAll = sqlite3WhereExprUsageNN(pMaskSet, pExpr);
168074 if( prereqAll!=sqlite3WhereExprUsageNN(pMaskSet, pExpr) ){
168076 sqlite3TreeViewExpr(0,pExpr,0);
168081 if( ExprHasProperty(pExpr, EP_OuterON|EP_InnerON) ){
168082 Bitmask x = sqlite3WhereGetMask(pMaskSet, pExpr->w.iJoin);
168083 if( ExprHasProperty(pExpr, EP_OuterON) ){
168088 ExprClearProperty(pExpr, EP_InnerON);
168097 Expr *pLeft = sqlite3ExprSkipCollate(pExpr->pLeft);
168098 Expr *pRight = sqlite3ExprSkipCollate(pExpr->pRight);
168105 pLeft = pLeft->x.pList->a[pTerm->u.x.iField-1].pExpr;
168125 pDup = sqlite3ExprDup(db, pExpr, 0);
168143 pDup = pExpr;
168156 && !ExprHasProperty(pExpr,EP_OuterON)
168159 assert( !ExprHasProperty(pExpr, EP_IntValue) );
168160 pExpr->op = TK_TRUEFALSE; /* See tag-20230504-1 */
168161 pExpr->u.zToken = "false";
168162 ExprSetProperty(pExpr, EP_IsFalse);
168184 else if( pExpr->op==TK_BETWEEN && pWC->op==TK_AND ){
168188 assert( ExprUseXList(pExpr) );
168189 pList = pExpr->x.pList;
168197 sqlite3ExprDup(db, pExpr->pLeft, 0),
168198 sqlite3ExprDup(db, pList->a[i].pExpr, 0));
168199 transferJoinMarkings(pNewExpr, pExpr);
168213 else if( pExpr->op==TK_OR && !ExprHasProperty(pExpr, EP_Collate) ){
168225 else if( pExpr->op==TK_NOTNULL ){
168226 if( pExpr->pLeft->op==TK_COLUMN
168227 && pExpr->pLeft->iColumn>=0
168228 && !ExprHasProperty(pExpr, EP_OuterON)
168231 Expr *pLeft = pExpr->pLeft;
168270 else if( pExpr->op==TK_FUNCTION
168272 && isLikeOrGlob(pParse, pExpr, &pStr1, &isComplete, &noCase)
168283 assert( ExprUseXList(pExpr) );
168284 pLeft = pExpr->x.pList->a[1].pExpr;
168331 transferJoinMarkings(pNewExpr1, pExpr);
168338 transferJoinMarkings(pNewExpr2, pExpr);
168361 if( (pExpr->op==TK_EQ || pExpr->op==TK_IS)
168362 && (nLeft = sqlite3ExprVectorSize(pExpr->pLeft))>1
168363 && sqlite3ExprVectorSize(pExpr->pRight)==nLeft
168364 && ( (pExpr->pLeft->flags & EP_xIsSelect)==0
168365 || (pExpr->pRight->flags & EP_xIsSelect)==0)
168372 Expr *pLeft = sqlite3ExprForVectorField(pParse, pExpr->pLeft, i, nLeft);
168373 Expr *pRight = sqlite3ExprForVectorField(pParse, pExpr->pRight, i, nLeft);
168375 pNew = sqlite3PExpr(pParse, pExpr->op, pLeft, pRight);
168376 transferJoinMarkings(pNew, pExpr);
168394 else if( pExpr->op==TK_IN
168396 && pExpr->pLeft->op==TK_VECTOR
168397 && ALWAYS( ExprUseXSelect(pExpr) )
168398 && (pExpr->x.pSelect->pPrior==0 || (pExpr->x.pSelect->selFlags & SF_Values))
168400 && pExpr->x.pSelect->pWin==0
168403 && pExpr->x.pSelect->pEList->nExpr <= UMXV(pTerm->nChild)
168408 for(i=0; i<sqlite3ExprVectorSize(pExpr->pLeft); i++){
168410 idxNew = whereClauseInsert(pWC, pExpr, TERM_VIRTUAL|TERM_SLICE);
168429 int res = isAuxiliaryVtabOperator(db, pExpr, &eOp2, &pLeft, &pRight);
168441 if( ExprHasProperty(pExpr, EP_OuterON) && pNewExpr ){
168443 pNewExpr->w.iJoin = pExpr->w.iJoin;
168493 SQLITE_PRIVATE void sqlite3WhereSplit(WhereClause *pWC, Expr *pExpr, u8 op){ argument
168494 Expr *pE2 = sqlite3ExprSkipCollateAndLikely(pExpr);
168496 assert( pE2!=0 || pExpr==0 );
168499 whereClauseInsert(pWC, pExpr, 0);
168520 Expr *pExpr, /* Expression that defines the limit/offset */ argument
168529 if( sqlite3ExprIsInteger(pExpr, &iVal, pParse) && iVal>=0 ){
168615 Expr *pExpr = pOrderBy->a[ii].pExpr; local
168616 if( pExpr->op!=TK_COLUMN ) return;
168617 if( pExpr->iTable!=iCsr ) return;
168672 sqlite3ExprDelete(db, a->pExpr);
168764 mask |= sqlite3WhereExprUsage(pMaskSet, pList->a[i].pExpr);
168828 sqlite3ExprDup(pParse->db, pArgs->a[j].pExpr, 0), 0);
169168 Expr *pX = pTerm->pExpr;
169177 inexpr.pLeft = pX->pLeft->x.pList->a[iField].pExpr;
169179 inexpr.pRight = pX->x.pSelect->pEList->a[iField].pExpr;
169216 || sqlite3ExprCompareSkip(pTerm->pExpr->pLeft,
169218 && (pScan->iEquiv<=1 || !ExprHasProperty(pTerm->pExpr, EP_OuterON))
169222 && (pX = whereRightSubexprIsColumn(pTerm->pExpr))!=0
169242 pX = pTerm->pExpr;
169262 && (pX = pTerm->pExpr->pRight, ALWAYS(pX!=0))
169356 pScan->pIdxExpr = pIdx->aColExpr->a[j].pExpr;
169438 Expr *p = sqlite3ExprSkipCollateAndLikely(pList->a[i].pExpr);
169444 CollSeq *pColl = sqlite3ExprNNCollSeq(pParse, pList->a[i].pExpr);
169503 Expr *p = sqlite3ExprSkipCollateAndLikely(pDistinct->a[i].pExpr);
169683 testcase( ExprHasProperty(pTerm->pExpr, EP_OuterON) )
169684 testcase( ExprHasProperty(pTerm->pExpr, EP_InnerON) );
169685 if( !ExprHasProperty(pTerm->pExpr, EP_OuterON|EP_InnerON)
169686 || pTerm->pExpr->w.iJoin != pSrc->iCursor
169691 && NEVER(ExprHasProperty(pTerm->pExpr, EP_InnerON))
169766 if( !sqlite3IndexAffinityOk(pTerm->pExpr, aff) ) return 0;
169767 testcase( pTerm->pExpr->op==TK_IS );
169881 Expr *pExpr = pTerm->pExpr; local
169886 && sqlite3ExprIsSingleTableConstraint(pExpr, pTabList, pLevel->iFrom, 0)
169889 sqlite3ExprDup(pParse->db, pExpr, 0));
169976 Expr *pX = pTerm->pExpr;
170182 Expr *pExpr = pTerm->pExpr; local
170184 && sqlite3ExprIsSingleTableConstraint(pExpr, pTabList, iSrc, 0)
170186 sqlite3ExprIfFalse(pParse, pTerm->pExpr, addrCont, SQLITE_JUMPIFNULL);
170323 Expr *pExpr = pOrderBy->a[i].pExpr; local
170327 if( sqlite3ExprIsConstant(0, pExpr) ){
170335 if( pExpr->op==TK_COLUMN && pExpr->iTable==pSrc->iCursor ){
170336 assert( pExpr->iColumn>=XN_ROWID && pExpr->iColumn<pTab->nCol );
170342 if( pExpr->op==TK_COLLATE
170343 && (pE2 = pExpr->pLeft)->op==TK_COLUMN
170347 assert( !ExprHasProperty(pExpr, EP_IntValue) );
170348 assert( pExpr->u.zToken!=0 );
170350 pExpr->iColumn = pE2->iColumn;
170354 if( sqlite3_stricmp(pExpr->u.zToken, zColl)==0 ) continue;
170442 && sqlite3ExprIsVector(pTerm->pExpr->pRight)
170457 Expr *pExpr = pOrderBy->a[i].pExpr; local
170458 if( sqlite3ExprIsConstant(0, pExpr) ) continue;
170459 assert( pExpr->op==TK_COLUMN
170460 || (pExpr->op==TK_COLLATE && pExpr->pLeft->op==TK_COLUMN
170461 && pExpr->iColumn==pExpr->pLeft->iColumn) );
170462 pIdxOrderBy[j].iColumn = pExpr->iColumn;
170846 rc = sqlite3Stat4ValueFromExpr(pParse, pLower->pExpr->pRight, aff, &p1);
170850 rc = sqlite3Stat4ValueFromExpr(pParse, pUpper->pExpr->pRight, aff, &p2);
171012 Expr *pExpr = pLower->pExpr->pRight; local
171013 rc = sqlite3Stat4ProbeSetValue(pParse, p, &pRec, pExpr, nBtm, nEq, &n);
171017 if( sqlite3ExprVectorSize(pExpr)>n ) mask = (WO_LE|WO_LT);
171029 Expr *pExpr = pUpper->pExpr->pRight; local
171030 rc = sqlite3Stat4ProbeSetValue(pParse, p, &pRec, pExpr, nTop, nEq, &n);
171034 if( sqlite3ExprVectorSize(pExpr)>n ) mask = (WO_LE|WO_LT);
171121 Expr *pExpr, /* Expression for VALUE in the x=VALUE constraint */ argument
171150 rc = sqlite3Stat4ProbeSetValue(pParse, p, &pRec, pExpr, 1, nEq-1, &bOk);
171199 rc = whereEqualScanEst(pParse, pBuilder, pList->a[i].pExpr, &nEst);
171228 if( ExprHasProperty(pTerm->pExpr, EP_OuterON) ) zType[2] = 'L';
171257 sqlite3TreeViewExpr(0, pTerm->pExpr, 0);
171795 static int exprNodePatternLengthEst(Walker *pWalker, Expr *pExpr){ argument
171796 if( pExpr->op==TK_STRING ){
171798 u8 *z = (u8*)pExpr->u.zToken; /* The pattern */
171929 Expr *pOpExpr = pTerm->pExpr;
171956 Expr *pRHS = pOpExpr->x.pList->a[0].pExpr;
171996 int nCmp = sqlite3ExprVectorSize(pTerm->pExpr->pLeft);
172008 assert( ExprUseXList(pTerm->pExpr->pLeft) );
172009 pLhs = pTerm->pExpr->pLeft->x.pList->a[i].pExpr;
172010 pRhs = pTerm->pExpr->pRight;
172012 pRhs = pRhs->x.pSelect->pEList->a[i].pExpr;
172014 pRhs = pRhs->x.pList->a[i].pExpr;
172034 if( ExprHasProperty(pTerm->pExpr, EP_Commuted) ) SWAP(Expr*, pRhs, pLhs);
172177 Expr *pExpr = pTerm->pExpr; local
172178 if( ExprUseXSelect(pExpr) ){
172190 if( pNew->aLTerm[i] && pNew->aLTerm[i]->pExpr==pExpr ){
172205 }else if( ALWAYS(pExpr->x.pList && pExpr->x.pList->nExpr) ){
172207 nIn = sqlite3LogEst(pExpr->x.pList->nExpr);
172334 && ((eOp & WO_IN)==0 || ExprUseXList(pTerm->pExpr))
172337 Expr *pExpr = pTerm->pExpr; local
172342 rc = whereEqualScanEst(pParse, pBuilder, pExpr->pRight, &nOut);
172344 rc = whereInScanEst(pParse, pBuilder, pExpr->x.pList, &nOut);
172520 Expr *pExpr = sqlite3ExprSkipCollateAndLikely(pOB->a[ii].pExpr); local
172521 if( NEVER(pExpr==0) ) continue;
172522 if( (pExpr->op==TK_COLUMN || pExpr->op==TK_AGG_COLUMN)
172523 && pExpr->iTable==iCursor
172525 if( pExpr->iColumn<0 ) return 1;
172527 if( pExpr->iColumn==pIndex->aiColumn[jj] ) return 1;
172532 if( sqlite3ExprCompareSkip(pExpr,aColExpr->a[jj].pExpr,iCursor)==0 ){
172561 Expr *pExpr; local
172562 pExpr = pTerm->pExpr;
172563 if( (!ExprHasProperty(pExpr, EP_OuterON) || pExpr->w.iJoin==iTab)
172564 && ((jointype & JT_OUTER)==0 || ExprHasProperty(pExpr, EP_OuterON))
172565 && sqlite3ExprImpliesExpr(pParse, pExpr, pWhere, iTab)
172566 && !sqlite3ExprImpliesExpr(pParse, pExpr, pWhere, -1)
172580 const Expr *pExpr, argument
172587 && sqlite3ExprCompare(0, pExpr, pIdx->aColExpr->a[i].pExpr, iTabCur)==0
172623 static int whereIsCoveringIndexWalkCallback(Walker *pWalk, Expr *pExpr){ argument
172632 if( (pExpr->op==TK_COLUMN || pExpr->op==TK_AGG_COLUMN) ){
172634 if( pExpr->iTable!=pCk->iTabCur ) return WRC_Continue;
172639 if( aiColumn[i]==pExpr->iColumn ) return WRC_Continue;
172644 && exprIsCoveredByIndex(pExpr, pIdx, pWalk->u.pCovIdxCk->iTabCur) ){
172727 sqlite3ExprDelete(db, p->pExpr);
172791 p->pExpr = sqlite3ExprDup(db, pRight, 0);
173107 if( !sqlite3ExprCoveredByIndex(pTerm->pExpr, iCur, pProbe) ){
173404 Expr *pX = termFromWhereClause(pHidden->pWC, iTerm)->pExpr;
173454 pH->pParse->db, pTerm->pExpr->pRight, ENC(pH->pParse->db),
173943 pOBExpr = pOrderBy->a[iOB].pExpr;
174088 pOBExpr = sqlite3ExprSkipCollateAndLikely(pOrderBy->a[i].pExpr);
174106 CollSeq *pColl1 = sqlite3ExprNNCollSeq(pParse, pOrderBy->a[i].pExpr);
174107 CollSeq *pColl2 = sqlite3ExprCompareCollSeq(pParse, pTerm->pExpr);
174112 testcase( pTerm->pExpr->op==TK_IS );
174186 Expr *pX = pLoop->aLTerm[j]->pExpr;
174188 if( pLoop->aLTerm[i]->pExpr==pX ){
174230 pOBExpr = sqlite3ExprSkipCollateAndLikely(pOrderBy->a[i].pExpr);
174240 Expr *pIxExpr = pIndex->aColExpr->a[j].pExpr;
174246 pColl = sqlite3ExprNNCollSeq(pWInfo->pParse, pOrderBy->a[i].pExpr);
174305 p = pOrderBy->a[i].pExpr;
175290 static int exprNodeIsDeterministic(Walker *pWalker, Expr *pExpr){ argument
175291 if( pExpr->op==TK_FUNCTION && ExprHasProperty(pExpr, EP_ConstFunc)==0 ){
175414 if( !ExprHasProperty(pTerm->pExpr, EP_OuterON)
175415 || pTerm->pExpr->w.iJoin!=pItem->iCursor
175421 && ExprHasProperty(pTerm->pExpr, EP_InnerON)
175422 && NEVER(pTerm->pExpr->w.iJoin==pItem->iCursor)
175525 Expr *pExpr; local
175528 pExpr = pIdx->aColExpr->a[i].pExpr;
175530 pExpr = sqlite3ColumnExpr(pTab, &pTab->aCol[j]);
175534 if( sqlite3ExprIsConstant(0,pExpr) ) continue;
175541 if( sqlite3WhereTrace & 0x5000 ) sqlite3ShowExpr(pExpr);
175544 p->pExpr = sqlite3ExprDup(pParse->db, pExpr, 0);
175870 pX = pT->pExpr;
176624 if( sqlite3WhereTrace & 0x5000 ) sqlite3ShowExpr(p->pExpr);
177480 static int selectWindowRewriteExprCb(Walker *pWalker, Expr *pExpr){ argument
177492 if( pExpr->op!=TK_COLUMN ){
177498 if( pExpr->iTable==p->pSrc->a[i].iCursor ) break;
177504 switch( pExpr->op ){
177507 if( !ExprHasProperty(pExpr, EP_WinFunc) ){
177512 if( pExpr->y.pWin==pWin ){
177513 assert( pWin->pOwner==pExpr );
177528 if( 0==sqlite3ExprCompare(0, p->pSub->a[i].pExpr, pExpr, -1) ){
177535 Expr *pDup = sqlite3ExprDup(pParse->db, pExpr, 0);
177540 int f = pExpr->flags & EP_Collate;
177541 assert( ExprHasProperty(pExpr, EP_Static)==0 );
177542 ExprSetProperty(pExpr, EP_Static);
177543 sqlite3ExprDelete(pParse->db, pExpr);
177544 ExprClearProperty(pExpr, EP_Static);
177545 memset(pExpr, 0, sizeof(Expr));
177547 pExpr->op = TK_COLUMN;
177548 pExpr->iColumn = (iCol<0 ? p->pSub->nExpr-1: iCol);
177549 pExpr->iTable = p->pWin->iEphCsr;
177550 pExpr->y.pTab = p->pTab;
177551 pExpr->flags = f;
177635 Expr *pDup = sqlite3ExprDup(db, pAppend->a[i].pExpr, 0);
177665 static int sqlite3WindowExtraAggFuncDepth(Walker *pWalker, Expr *pExpr){ argument
177666 if( pExpr->op==TK_AGG_FUNCTION
177667 && pExpr->op2>=pWalker->walkerDepth
177669 pExpr->op2++;
177674 static int disallowAggregatesInOrderByCb(Walker *pWalker, Expr *pExpr){ argument
177675 if( pExpr->op==TK_AGG_FUNCTION && pExpr->pAggInfo==0 ){
177676 assert( !ExprHasProperty(pExpr, EP_IntValue) );
177678 "misuse of aggregate: %s()", pExpr->u.zToken);
177895 static Expr *sqlite3WindowOffsetExpr(Parse *pParse, Expr *pExpr){ argument
177896 if( 0==sqlite3ExprIsConstant(0,pExpr) ){
177897 if( IN_RENAME_OBJECT ) sqlite3RenameExprUnmap(pParse, pExpr);
177898 sqlite3ExprDelete(pParse->db, pExpr);
177899 pExpr = sqlite3ExprAlloc(pParse->db, TK_NULL, 0, 0);
177901 return pExpr;
178478 pColl = sqlite3ExprNNCollSeq(pParse, pWin->pOwner->x.pList->a[0].pExpr);
178943 pColl = sqlite3ExprNNCollSeq(pParse, pOrderBy->a[0].pExpr);
179169 static int windowExprGtZero(Parse *pParse, Expr *pExpr){ argument
179173 sqlite3ValueFromExpr(db, pExpr, db->enc, SQLITE_AFF_NUMERIC, &pVal);
179926 struct FrameBound { int eType; Expr *pExpr; }; member
182473 sqlite3ExprDelete(pParse->db, (yypminor->yy509).pExpr);
184512 assert( pList->a[i].pExpr!=0 );
184513 yymsp[-4].minor.yy454->flags |= pList->a[i].pExpr->flags & EP_Propagate;
184655 Expr *pRHS = yymsp[-1].minor.yy14->a[0].pExpr;
184657 yymsp[-1].minor.yy14->a[0].pExpr = 0;
185092 …yymsp[-2].minor.yy144, yymsp[-1].minor.yy509.eType, yymsp[-1].minor.yy509.pExpr, TK_CURRENT, 0, yy…
185098 …-3].minor.yy509.eType, yymsp[-3].minor.yy509.pExpr, yymsp[-1].minor.yy509.eType, yymsp[-1].minor.y…
185110 {yylhsminor.yy509.eType = yymsp[-1].major; yylhsminor.yy509.pExpr = 0;}
185114 {yylhsminor.yy509.eType = yymsp[0].major; yylhsminor.yy509.pExpr = yymsp[-1].minor.yy454;}
193880 Fts3Expr *pExpr; /* Parsed MATCH query string */ member
195715 sqlite3Fts3ExprFree(pCsr->pExpr);
197304 p->azColumn, p->bFts4, p->nColumn, iCol, zQuery, -1, &pCsr->pExpr,
197414 if( pCsr->pExpr ){
198161 Fts3Expr *pExpr, /* Allocate readers for this expression */ argument
198166 if( pExpr && SQLITE_OK==*pRc ){
198167 if( pExpr->eType==FTSQUERY_PHRASE ){
198169 int nToken = pExpr->pPhrase->nToken;
198172 Fts3PhraseToken *pToken = &pExpr->pPhrase->aToken[i];
198181 assert( pExpr->pPhrase->iDoclistToken==0 );
198182 pExpr->pPhrase->iDoclistToken = -1;
198184 *pnOr += (pExpr->eType==FTSQUERY_OR);
198185 fts3EvalAllocateReaders(pCsr, pExpr->pLeft, pnToken, pnOr, pRc);
198186 fts3EvalAllocateReaders(pCsr, pExpr->pRight, pnToken, pnOr, pRc);
198827 Fts3Expr *pExpr, /* Expression to initialize phrases in */ argument
198830 if( pExpr && SQLITE_OK==*pRc ){
198831 if( pExpr->eType==FTSQUERY_PHRASE ){
198832 int nToken = pExpr->pPhrase->nToken;
198836 if( pExpr->pPhrase->aToken[i].pDeferred==0 ) break;
198838 pExpr->bDeferred = (i==nToken);
198840 *pRc = fts3EvalPhraseStart(pCsr, 1, pExpr->pPhrase);
198842 fts3EvalStartReaders(pCsr, pExpr->pLeft, pRc);
198843 fts3EvalStartReaders(pCsr, pExpr->pRight, pRc);
198844 pExpr->bDeferred = (pExpr->pLeft->bDeferred && pExpr->pRight->bDeferred);
198881 Fts3Expr *pExpr, /* Expression to consider */ argument
198887 if( pExpr->eType==FTSQUERY_PHRASE ){
198888 Fts3Phrase *pPhrase = pExpr->pPhrase;
198899 }else if( pExpr->eType!=FTSQUERY_NOT ){
198900 assert( pExpr->eType==FTSQUERY_OR
198901 || pExpr->eType==FTSQUERY_AND
198902 || pExpr->eType==FTSQUERY_NEAR
198904 assert( pExpr->pLeft && pExpr->pRight );
198905 if( pExpr->eType==FTSQUERY_OR ){
198906 pRoot = pExpr->pLeft;
198910 fts3EvalTokenCosts(pCsr, pRoot, pExpr->pLeft, ppTC, ppOr, pRc);
198911 if( pExpr->eType==FTSQUERY_OR ){
198912 pRoot = pExpr->pRight;
198916 fts3EvalTokenCosts(pCsr, pRoot, pExpr->pRight, ppTC, ppOr, pRc);
199133 fts3EvalAllocateReaders(pCsr, pCsr->pExpr, &nToken, &nOr, &rc);
199152 fts3EvalTokenCosts(pCsr, 0, pCsr->pExpr, &pTC, &ppOr, &rc);
199168 fts3EvalStartReaders(pCsr, pCsr->pExpr, &rc);
199284 Fts3Expr *pExpr, /* Expr. to advance to next matching row */ argument
199287 if( *pRc==SQLITE_OK && pExpr->bEof==0 ){
199289 pExpr->bStart = 1;
199291 switch( pExpr->eType ){
199294 Fts3Expr *pLeft = pExpr->pLeft;
199295 Fts3Expr *pRight = pExpr->pRight;
199302 pExpr->iDocid = pRight->iDocid;
199303 pExpr->bEof = pRight->bEof;
199308 pExpr->iDocid = pLeft->iDocid;
199309 pExpr->bEof = pLeft->bEof;
199323 pExpr->iDocid = pLeft->iDocid;
199324 pExpr->bEof = (pLeft->bEof || pRight->bEof);
199325 if( pExpr->eType==FTSQUERY_NEAR && pExpr->bEof ){
199348 Fts3Expr *pLeft = pExpr->pLeft;
199349 Fts3Expr *pRight = pExpr->pRight;
199364 pExpr->bEof = (pLeft->bEof && pRight->bEof);
199367 pExpr->iDocid = pLeft->iDocid;
199369 pExpr->iDocid = pRight->iDocid;
199376 Fts3Expr *pLeft = pExpr->pLeft;
199377 Fts3Expr *pRight = pExpr->pRight;
199393 pExpr->iDocid = pLeft->iDocid;
199394 pExpr->bEof = pLeft->bEof;
199399 Fts3Phrase *pPhrase = pExpr->pPhrase;
199401 *pRc = fts3EvalPhraseNext(pCsr, pPhrase, &pExpr->bEof);
199402 pExpr->iDocid = pPhrase->doclist.iDocid;
199424 static int fts3EvalNearTest(Fts3Expr *pExpr, int *pRc){ argument
199448 && pExpr->eType==FTSQUERY_NEAR
199449 && (pExpr->pParent==0 || pExpr->pParent->eType!=FTSQUERY_NEAR)
199456 for(p=pExpr; p->pLeft; p=p->pLeft){
199475 aPoslist = pExpr->pRight->pPhrase->doclist.pList;
199476 nToken = pExpr->pRight->pPhrase->nToken;
199477 for(p=pExpr->pLeft; p && res; p=p->pLeft){
199508 Fts3Expr *pExpr, /* Expr to test. May or may not be root. */ argument
199513 switch( pExpr->eType ){
199517 fts3EvalTestExpr(pCsr, pExpr->pLeft, pRc)
199518 && fts3EvalTestExpr(pCsr, pExpr->pRight, pRc)
199519 && fts3EvalNearTest(pExpr, pRc)
199538 && pExpr->eType==FTSQUERY_NEAR
199539 && (pExpr->pParent==0 || pExpr->pParent->eType!=FTSQUERY_NEAR)
199542 for(p=pExpr; p->pPhrase==0; p=p->pLeft){
199555 int bHit1 = fts3EvalTestExpr(pCsr, pExpr->pLeft, pRc);
199556 int bHit2 = fts3EvalTestExpr(pCsr, pExpr->pRight, pRc);
199563 fts3EvalTestExpr(pCsr, pExpr->pLeft, pRc)
199564 && !fts3EvalTestExpr(pCsr, pExpr->pRight, pRc)
199570 if( pCsr->pDeferred && (pExpr->bDeferred || (
199571 pExpr->iDocid==pCsr->iPrevId && pExpr->pPhrase->doclist.pList
199573 Fts3Phrase *pPhrase = pExpr->pPhrase;
199574 if( pExpr->bDeferred ){
199579 pExpr->iDocid = pCsr->iPrevId;
199584 pExpr->bEof==0 && pExpr->iDocid==pCsr->iPrevId
199585 && pExpr->pPhrase->doclist.nList>0
199636 bMiss = (0==fts3EvalTestExpr(pCsr, pCsr->pExpr, &rc));
199651 Fts3Expr *pExpr = pCsr->pExpr; local
199653 if( pExpr==0 ){
199661 fts3EvalNextRow(pCsr, pExpr, &rc);
199662 pCsr->isEof = pExpr->bEof;
199665 pCsr->iPrevId = pExpr->iDocid;
199692 Fts3Expr *pExpr, argument
199695 if( pExpr && *pRc==SQLITE_OK ){
199696 Fts3Phrase *pPhrase = pExpr->pPhrase;
199716 pExpr->iDocid = 0;
199717 pExpr->bEof = 0;
199718 pExpr->bStart = 0;
199720 fts3EvalRestart(pCsr, pExpr->pLeft, pRc);
199721 fts3EvalRestart(pCsr, pExpr->pRight, pRc);
199730 SQLITE_PRIVATE int sqlite3Fts3MsrCancel(Fts3Cursor *pCsr, Fts3Expr *pExpr){ argument
199732 if( pExpr->bEof==0 ){
199733 i64 iDocid = pExpr->iDocid;
199734 fts3EvalRestart(pCsr, pExpr, &rc);
199735 while( rc==SQLITE_OK && pExpr->iDocid!=iDocid ){
199736 fts3EvalNextRow(pCsr, pExpr, &rc);
199737 if( pExpr->bEof ) rc = FTS_CORRUPT_VTAB;
199751 static void fts3EvalUpdateCounts(Fts3Expr *pExpr, int nCol){ argument
199752 if( pExpr ){
199753 Fts3Phrase *pPhrase = pExpr->pPhrase;
199769 pExpr->aMI[iCol*3 + 1] += iCnt;
199770 pExpr->aMI[iCol*3 + 2] += (iCnt>0);
199777 fts3EvalUpdateCounts(pExpr->pLeft, nCol);
199778 fts3EvalUpdateCounts(pExpr->pRight, nCol);
199787 static int fts3AllocateMSI(Fts3Expr *pExpr, int iPhrase, void *pCtx){ argument
199790 if( pExpr->aMI==0 ){
199791 pExpr->aMI = (u32 *)sqlite3_malloc64(pTab->nColumn * 3 * sizeof(u32));
199792 if( pExpr->aMI==0 ) return SQLITE_NOMEM;
199794 memset(pExpr->aMI, 0, pTab->nColumn * 3 * sizeof(u32));
199811 Fts3Expr *pExpr /* FTSQUERY_PHRASE expression */ argument
199815 assert( pExpr->eType==FTSQUERY_PHRASE );
199816 if( pExpr->aMI==0 ){
199825 pRoot = pExpr;
199918 Fts3Expr *pExpr, /* Phrase expression */ argument
199925 if( pExpr->bDeferred && pExpr->pParent->eType!=FTSQUERY_NEAR ){
199932 rc = fts3EvalGatherStats(pCsr, pExpr);
199934 assert( pExpr->aMI );
199936 aiOut[iCol*3 + 1] = pExpr->aMI[iCol*3 + 1];
199937 aiOut[iCol*3 + 2] = pExpr->aMI[iCol*3 + 2];
199966 Fts3Expr *pExpr, /* Phrase to return doclist for */ argument
199970 Fts3Phrase *pPhrase = pExpr->pPhrase;
199984 iDocid = pExpr->iDocid;
199986 if( iDocid!=pCsr->iPrevId || pExpr->bEof ){
200001 pNear = pExpr;
200002 for(p=pExpr->pParent; p; p=p->pParent){
201857 static char *exprToString(Fts3Expr *pExpr, char *zBuf){ argument
201858 if( pExpr==0 ){
201861 switch( pExpr->eType ){
201863 Fts3Phrase *pPhrase = pExpr->pPhrase;
201877 zBuf = sqlite3_mprintf("%zNEAR/%d ", zBuf, pExpr->nNear);
201891 if( zBuf ) zBuf = exprToString(pExpr->pLeft, zBuf);
201894 if( zBuf ) zBuf = exprToString(pExpr->pRight, zBuf);
201927 Fts3Expr *pExpr; local
201967 pTokenizer, 0, azCol, 0, nCol, nCol, zExpr, nExpr, &pExpr, &zDummy
201969 assert( rc==SQLITE_OK || pExpr==0 );
201973 pTokenizer, 0, azCol, 0, nCol, nCol, zExpr, nExpr, &pExpr
201979 }else if( rc==SQLITE_NOMEM || !(zBuf = exprToString(pExpr, 0)) ){
201986 sqlite3Fts3ExprFree(pExpr);
210412 Fts3Expr *pExpr, /* Expression to iterate phrases of */ argument
210418 int eType = pExpr->eType; /* Type of expression node pExpr */
210421 assert( pExpr->pLeft && pExpr->pRight );
210422 rc = fts3ExprIterate2(pExpr->pLeft, piPhrase, x, pCtx);
210424 rc = fts3ExprIterate2(pExpr->pRight, piPhrase, x, pCtx);
210427 rc = x(pExpr, *piPhrase, pCtx);
210444 Fts3Expr *pExpr, /* Expression to iterate phrases of */ argument
210449 return fts3ExprIterate2(pExpr, &iPhrase, x, pCtx);
210457 static int fts3ExprLoadDoclistsCb(Fts3Expr *pExpr, int iPhrase, void *ctx){ argument
210459 Fts3Phrase *pPhrase = pExpr->pPhrase;
210488 rc = sqlite3Fts3ExprIterate(pCsr->pExpr,fts3ExprLoadDoclistsCb,(void*)&sCtx);
210494 static int fts3ExprPhraseCountCb(Fts3Expr *pExpr, int iPhrase, void *ctx){ argument
210496 pExpr->iPhrase = iPhrase;
210499 static int fts3ExprPhraseCount(Fts3Expr *pExpr){ argument
210501 (void)sqlite3Fts3ExprIterate(pExpr, fts3ExprPhraseCountCb, (void *)&nPhrase);
210634 static int fts3SnippetFindPositions(Fts3Expr *pExpr, int iPhrase, void *ctx){ argument
210640 pPhrase->nToken = pExpr->pPhrase->nToken;
210641 rc = sqlite3Fts3EvalPhrasePoslist(p->pCsr, pExpr, p->iCol, &pCsr);
210723 pCsr->pExpr, fts3SnippetFindPositions, (void*)&sIter
211030 Fts3Expr *pExpr, /* Phrase expression node */ argument
211035 Fts3Phrase *pPhrase = pExpr->pPhrase;
211041 iStart = pExpr->iPhrase * p->nCol;
211043 iStart = pExpr->iPhrase * ((p->nCol + 31) / 32);
211068 Fts3Expr *pExpr, argument
211072 assert( (pExpr->pLeft==0)==(pExpr->pRight==0) );
211073 if( pExpr->bEof==0 && pExpr->iDocid==p->pCursor->iPrevId ){
211074 if( pExpr->pLeft ){
211075 rc = fts3ExprLHitGather(pExpr->pLeft, p);
211076 if( rc==SQLITE_OK ) rc = fts3ExprLHitGather(pExpr->pRight, p);
211078 rc = fts3ExprLHits(pExpr, p);
211112 Fts3Expr *pExpr, /* Phrase expression node */ argument
211118 p->pCursor, pExpr, &p->aMatchinfo[3*iPhrase*p->nCol]
211128 Fts3Expr *pExpr, /* Phrase expression node */ argument
211139 rc = sqlite3Fts3EvalPhrasePoslist(p->pCursor, pExpr, i, &pCsr);
211250 Fts3Expr *pExpr; /* Pointer to phrase expression */ member
211263 Fts3Expr *pExpr, /* Phrase expression node */ argument
211268 aIter[iPhrase].pExpr = pExpr;
211319 (void)sqlite3Fts3ExprIterate(pCsr->pExpr, fts3MatchinfoLcsCb, (void*)aIter);
211323 nToken -= pIter->pExpr->pPhrase->nToken;
211333 rc = sqlite3Fts3EvalPhrasePoslist(pCsr, pIt->pExpr, iCol, &pIt->pRead);
211481 rc = fts3ExprLHitGather(pCsr->pExpr, pInfo);
211486 Fts3Expr *pExpr; local
211488 pExpr = pCsr->pExpr;
211496 rc = sqlite3Fts3ExprIterate(pExpr, fts3ExprGlobalHitsCb,(void*)pInfo);
211500 (void)sqlite3Fts3ExprIterate(pExpr, fts3ExprLocalHitsCb,(void*)pInfo);
211552 pCsr->nPhrase = fts3ExprPhraseCount(pCsr->pExpr);
211628 if( !pCsr->pExpr ){
211725 static int fts3ExprTermOffsetInit(Fts3Expr *pExpr, int iPhrase, void *ctx){ argument
211734 rc = sqlite3Fts3EvalPhrasePoslist(p->pCsr, pExpr, p->iCol, &pList);
211735 nTerm = pExpr->pPhrase->nToken;
211756 static int fts3ExprRestartIfCb(Fts3Expr *pExpr, int iPhrase, void *ctx){ argument
211760 if( pExpr->pPhrase && pExpr->pPhrase->bIncr ){
211761 rc = sqlite3Fts3MsrCancel(p->pCsr, pExpr);
211762 pExpr->pPhrase->bIncr = 0;
211782 if( !pCsr->pExpr ){
211806 rc = sqlite3Fts3ExprIterate(pCsr->pExpr, fts3ExprRestartIfCb, (void*)&sCtx);
211828 pCsr->pExpr, fts3ExprTermOffsetInit, (void*)&sCtx
211930 if( !pCsr->pExpr ){
225063 URegularExpression *pExpr = (URegularExpression *)p; local
225064 uregex_close(pExpr);
225088 URegularExpression *pExpr; local
225101 pExpr = sqlite3_get_auxdata(p, 0);
225102 if( !pExpr ){
225107 pExpr = uregex_open(zPattern, -1, 0, 0, &status);
225110 sqlite3_set_auxdata(p, 0, pExpr, icuRegexpDelete);
225111 pExpr = sqlite3_get_auxdata(p, 0);
225113 if( !pExpr ){
225120 uregex_setText(pExpr, zString, -1, &status);
225127 res = uregex_matches(pExpr, 0, &status);
225138 uregex_setText(pExpr, 0, 0, &status);
247097 Fts5ExprNode *pExpr; /* Result of a successful parse */ member
247240 assert( sParse.pExpr || sParse.rc!=SQLITE_OK );
247241 assert_expr_depth_ok(sParse.rc, sParse.pExpr);
247251 sqlite3Fts5ParseSetColset(&sParse, sParse.pExpr, pColset);
247260 sqlite3Fts5ParseNodeFree(sParse.pExpr);
247262 pNew->pRoot = sParse.pExpr;
247271 sqlite3Fts5ParseNodeFree(sParse.pExpr);
247840 Fts5Expr *pExpr, /* Expression that pNear is a part of */ argument
247846 if( pExpr->pConfig->eDetail!=FTS5_DETAIL_FULL ){
247898 Fts5Expr *pExpr, argument
247924 pExpr->pIndex, p->pTerm, p->nQueryTerm,
247926 (pExpr->bDesc ? FTS5INDEX_QUERY_DESC : 0),
247960 Fts5Expr *pExpr, argument
247964 assert( pExpr->bDesc==0 || pExpr->bDesc==1 );
247965 if( pExpr->bDesc==0 ){
248014 Fts5Expr *pExpr, argument
248020 return fts5RowidCmp(pExpr, p1->iRowid, p2->iRowid);
248035 Fts5Expr *pExpr, /* Expression pPhrase belongs to */ argument
248044 const int bDesc = pExpr->bDesc;
248091 pNode->bNomatch = ((0==fts5ExprNearTest(&rc, pExpr, pNode)) && rc==SQLITE_OK);
248105 Fts5Expr *pExpr, /* Expression pPhrase belongs to */ argument
248119 i64 iRowid = fts5ExprSynonymRowid(pTerm, pExpr->bDesc, 0);
248127 || (bFromValid && ii!=iFrom && (ii>iFrom)==pExpr->bDesc)
248162 rc = fts5ExprNodeTest_STRING(pExpr, pNode);
248170 Fts5Expr *pExpr, /* Expression that pNear is a part of */ argument
248186 if( pExpr->pConfig->eDetail==FTS5_DETAIL_FULL ){
248198 Fts5Expr *pExpr, argument
248213 rc = fts5ExprNodeTest_TERM(pExpr, pNode);
248222 Fts5Expr *pExpr, /* Expression of which pNode is a part */ argument
248230 int cmp = fts5NodeCompare(pExpr, pNext, pChild);
248241 Fts5Expr *pExpr, argument
248251 assert( p1->bEof || fts5RowidCmp(pExpr, p1->iRowid, iLast)>=0 );
248254 || (bFromValid && fts5RowidCmp(pExpr, p1->iRowid, iFrom)<0)
248256 int rc = fts5ExprNodeNext(pExpr, p1, bFromValid, iFrom);
248265 fts5ExprNodeTest_OR(pExpr, pNode);
248273 Fts5Expr *pExpr, /* Expression pPhrase belongs to */ argument
248287 int cmp = fts5RowidCmp(pExpr, iLast, pChild->iRowid);
248290 rc = fts5ExprNodeNext(pExpr, pChild, 1, iLast);
248301 assert( pChild->bEof || fts5RowidCmp(pExpr, iLast, pChild->iRowid)<=0 );
248317 if( pAnd->bNomatch && pAnd!=pExpr->pRoot ){
248325 Fts5Expr *pExpr, argument
248330 int rc = fts5ExprNodeNext(pExpr, pNode->apChild[0], bFromValid, iFrom);
248332 rc = fts5ExprNodeTest_AND(pExpr, pNode);
248340 Fts5Expr *pExpr, /* Expression pPhrase belongs to */ argument
248349 int cmp = fts5NodeCompare(pExpr, p1, p2);
248351 rc = fts5ExprNodeNext(pExpr, p2, 1, p1->iRowid);
248352 cmp = fts5NodeCompare(pExpr, p1, p2);
248356 rc = fts5ExprNodeNext(pExpr, p1, 0, 0);
248368 Fts5Expr *pExpr, argument
248373 int rc = fts5ExprNodeNext(pExpr, pNode->apChild[0], bFromValid, iFrom);
248375 rc = fts5ExprNodeTest_NOT(pExpr, pNode);
248389 Fts5Expr *pExpr, /* Expression of which pNode is a part */ argument
248397 rc = fts5ExprNodeTest_STRING(pExpr, pNode);
248402 rc = fts5ExprNodeTest_TERM(pExpr, pNode);
248407 rc = fts5ExprNodeTest_AND(pExpr, pNode);
248412 fts5ExprNodeTest_OR(pExpr, pNode);
248417 rc = fts5ExprNodeTest_NOT(pExpr, pNode);
248433 static int fts5ExprNodeFirst(Fts5Expr *pExpr, Fts5ExprNode *pNode){ argument
248440 rc = fts5ExprNearInitAll(pExpr, pNode);
248448 rc = fts5ExprNodeFirst(pExpr, pNode->apChild[i]);
248471 rc = fts5ExprNodeTest(pExpr, pNode);
248764 assert( pParse->pExpr==0 );
248765 pParse->pExpr = p;
248844 Fts5Expr *pExpr, argument
248852 if( !pExpr || iPhrase<0 || iPhrase>=pExpr->nPhrase ){
248855 pOrig = pExpr->apExprPhrase[iPhrase];
248886 sCtx.pConfig = pExpr->pConfig;
248908 pNew->pIndex = pExpr->pIndex;
248909 pNew->pConfig = pExpr->pConfig;
249173 Fts5ExprNode *pExpr, argument
249182 fts5ParseSetColset(pParse, pExpr, pColset, &pFree);
249525 Fts5ExprNode *pExpr argument
249528 if( pExpr->eType==FTS5_STRING || pExpr->eType==FTS5_TERM ){
249529 Fts5ExprNearset *pNear = pExpr->pNear;
249576 }else if( pExpr->eType==0 ){
249581 switch( pExpr->eType ){
249585 assert( pExpr->eType==FTS5_OR );
249591 for(i=0; zRet && i<pExpr->nChild; i++){
249592 char *z = fts5ExprPrintTcl(pConfig, zNearsetCmd, pExpr->apChild[i]);
249605 static char *fts5ExprPrint(Fts5Config *pConfig, Fts5ExprNode *pExpr){ argument
249607 if( pExpr->eType==0 ){
249610 if( pExpr->eType==FTS5_STRING || pExpr->eType==FTS5_TERM ){
249611 Fts5ExprNearset *pNear = pExpr->pNear;
249663 switch( pExpr->eType ){
249667 assert( pExpr->eType==FTS5_OR );
249672 for(i=0; i<pExpr->nChild; i++){
249673 char *z = fts5ExprPrint(pConfig, pExpr->apChild[i]);
249678 int e = pExpr->apChild[i]->eType;
249706 Fts5Expr *pExpr = 0; local
249749 rc = sqlite3Fts5ExprNew(pConfig, 0, pConfig->nCol, zExpr, &pExpr, &zErr);
249753 if( pExpr->pRoot->xNext==0 ){
249756 zText = fts5ExprPrintTcl(pConfig, zNearsetCmd, pExpr->pRoot);
249758 zText = fts5ExprPrint(pConfig, pExpr->pRoot);
249778 sqlite3Fts5ExprFree(pExpr);
249882 static int sqlite3Fts5ExprPhraseCount(Fts5Expr *pExpr){ argument
249883 return (pExpr ? pExpr->nPhrase : 0);
249889 static int sqlite3Fts5ExprPhraseSize(Fts5Expr *pExpr, int iPhrase){ argument
249890 if( iPhrase<0 || iPhrase>=pExpr->nPhrase ) return 0;
249891 return pExpr->apExprPhrase[iPhrase]->nTerm;
249898 static int sqlite3Fts5ExprPoslist(Fts5Expr *pExpr, int iPhrase, const u8 **pa){ argument
249900 Fts5ExprPhrase *pPhrase = pExpr->apExprPhrase[iPhrase];
249902 if( pNode->bEof==0 && pNode->iRowid==pExpr->pRoot->iRowid ){
249927 static Fts5PoslistPopulator *sqlite3Fts5ExprClearPoslists(Fts5Expr *pExpr, int bLive){ argument
249929 pRet = sqlite3_malloc64(sizeof(Fts5PoslistPopulator)*pExpr->nPhrase);
249932 memset(pRet, 0, sizeof(Fts5PoslistPopulator)*pExpr->nPhrase);
249933 for(i=0; i<pExpr->nPhrase; i++){
249934 Fts5Buffer *pBuf = &pExpr->apExprPhrase[i]->poslist;
249935 Fts5ExprNode *pNode = pExpr->apExprPhrase[i]->pNode;
249936 assert( pExpr->apExprPhrase[i]->nTerm<=1 );
249938 (pBuf->n==0 || pNode->iRowid!=pExpr->pRoot->iRowid || pNode->bEof)
249950 Fts5Expr *pExpr; member
249987 Fts5Expr *pExpr = p->pExpr; local
249990 i64 iRowid = pExpr->pRoot->iRowid;
249995 if( pExpr->pConfig->bTokendata ){
249999 for(i=0; i<pExpr->nPhrase; i++){
250002 for(pT=&pExpr->apExprPhrase[i]->aTerm[0]; pT; pT=pT->pSynonym){
250007 &pExpr->apExprPhrase[i]->poslist, &p->aPopulator[i].writer, p->iOff
250009 if( rc==SQLITE_OK && (pExpr->pConfig->bTokendata || pT->bPrefix) ){
250026 Fts5Expr *pExpr, argument
250033 sCtx.pExpr = pExpr;
250037 for(i=0; i<pExpr->nPhrase; i++){
250038 Fts5ExprNode *pNode = pExpr->apExprPhrase[i]->pNode;
250110 static void sqlite3Fts5ExprCheckPoslists(Fts5Expr *pExpr, i64 iRowid){ argument
250111 fts5ExprCheckPoslists(pExpr->pRoot, iRowid);
250118 Fts5Expr *pExpr, argument
250123 Fts5ExprPhrase *pPhrase = pExpr->apExprPhrase[iPhrase];
250127 assert( iPhrase>=0 && iPhrase<pExpr->nPhrase );
250128 assert( pExpr->pConfig->eDetail==FTS5_DETAIL_COLUMNS );
250131 && pNode->iRowid==pExpr->pRoot->iRowid
250156 Fts5Expr *pExpr, argument
250164 if( iPhrase<0 || iPhrase>=pExpr->nPhrase ){
250167 pPhrase = pExpr->apExprPhrase[iPhrase];
250181 Fts5Expr *pExpr, argument
250194 if( iPhrase<0 || iPhrase>=pExpr->nPhrase ){
250197 pPhrase = pExpr->apExprPhrase[iPhrase];
250202 if( pExpr->pConfig->bTokendata || pTerm->bPrefix ){
250218 static void sqlite3Fts5ExprClearTokens(Fts5Expr *pExpr){ argument
250220 for(ii=0; ii<pExpr->nPhrase; ii++){
250222 for(pT=&pExpr->apExprPhrase[ii]->aTerm[0]; pT; pT=pT->pSynonym){
260592 Fts5Expr *pExpr; /* Expression for MATCH queries */ member
261231 sqlite3Fts5ExprFree(pCsr->pExpr);
261345 i64 iRowid = sqlite3Fts5ExprRowid(pCsr->pExpr);
261348 pCsr->pExpr, pTab->p.pIndex, iRowid, pCsr->iLastRowid, bDesc
261350 if( rc==SQLITE_OK && iRowid!=sqlite3Fts5ExprRowid(pCsr->pExpr) ){
261356 if( sqlite3Fts5ExprEof(pCsr->pExpr) ){
261389 sqlite3Fts5ExprClearTokens(pCsr->pExpr);
261395 rc = sqlite3Fts5ExprNext(pCsr->pExpr, pCsr->iLastRowid);
261396 CsrFlagSet(pCsr, sqlite3Fts5ExprEof(pCsr->pExpr));
261479 nPhrase = sqlite3Fts5ExprPhraseCount(pCsr->pExpr);
261520 Fts5Expr *pExpr = pCsr->pExpr; local
261522 pExpr, pTab->p.pIndex, pCsr->iFirstRowid, pCsr->iLastRowid, bDesc
261524 if( sqlite3Fts5ExprEof(pExpr) ){
261854 Fts5Expr *pExpr = 0; local
261863 assert( pCsr->pExpr==0 );
261905 rc = sqlite3Fts5ExprNew(pConfig, 0, iCol, zText, &pExpr, pzErr);
261907 rc = sqlite3Fts5ExprAnd(&pCsr->pExpr, pExpr);
261908 pExpr = 0;
261931 rc = sqlite3Fts5ExprPattern(pConfig, bGlob, iCol, zText, &pExpr);
261934 rc = sqlite3Fts5ExprAnd(&pCsr->pExpr, pExpr);
261935 pExpr = 0;
261991 pCsr->pExpr = pTab->pSortCsr->pExpr;
261993 }else if( pCsr->pExpr ){
262028 sqlite3Fts5ExprFree(pExpr);
262058 return sqlite3Fts5ExprRowid(pCsr->pExpr);
262106 assert( pCsr->pExpr );
262610 return sqlite3Fts5ExprPhraseCount(pCsr->pExpr);
262615 return sqlite3Fts5ExprPhraseSize(pCsr->pExpr, iPhrase);
262704 if( iPhrase<0 || iPhrase>=sqlite3Fts5ExprPhraseCount(pCsr->pExpr) ){
262717 aPopulator = sqlite3Fts5ExprClearPoslists(pCsr->pExpr, bLive);
262728 pConfig, pCsr->pExpr, aPopulator, i, z, n
262736 sqlite3Fts5ExprCheckPoslists(pCsr->pExpr, pCsr->pSorter->iRowid);
262749 *pn = sqlite3Fts5ExprPoslist(pCsr->pExpr, iPhrase, pa);
262770 nIter = sqlite3Fts5ExprPhraseCount(pCsr->pExpr);
263095 rc = sqlite3Fts5ExprPhraseCollist(pCsr->pExpr, iPhrase, &pIter->a, &n);
263133 return sqlite3Fts5ExprQueryToken(pCsr->pExpr, iPhrase, iToken, ppOut, pnOut);
263158 pCsr->pExpr, iRowid, iPhrase, iCol, iOff, iToken, ppOut, pnOut
263257 rc = sqlite3Fts5ExprClonePhrase(pCsr->pExpr, iPhrase, &pNew->pExpr);
263374 int nPhrase = sqlite3Fts5ExprPhraseCount(pCsr->pExpr);
263384 int nByte = sqlite3Fts5ExprPoslist(pCsr->pExpr, i, &dummy);
263392 nPoslist = sqlite3Fts5ExprPoslist(pCsr->pExpr, i, &pPoslist);
263403 rc = sqlite3Fts5ExprPhraseCollist(pCsr->pExpr, i, &dummy, &nByte);
263411 rc = sqlite3Fts5ExprPhraseCollist(pCsr->pExpr, i, &pPoslist, &nPoslist);