Lines Matching refs:pExpr
16941 Expr *pExpr; /* Used when p4type is P4_EXPR */ member
17530 SQLITE_PRIVATE int sqlite3CursorRangeHintExprCheck(Walker *pWalker, Expr *pExpr);
19591 Expr *pExpr; /* The parse tree for this expression */ member
20210 Expr *pExpr; /* The expression contained in the index */ member
21470 SQLITE_PRIVATE void sqlite3ExprToRegister(Expr *pExpr, int iReg);
21705 SQLITE_PRIVATE char sqlite3CompareAffinity(const Expr *pExpr, char aff2);
21706 SQLITE_PRIVATE int sqlite3IndexAffinityOk(const Expr *pExpr, char idx_affinity);
21708 SQLITE_PRIVATE char sqlite3ExprAffinity(const Expr *pExpr);
21709 SQLITE_PRIVATE int sqlite3ExprDataType(const Expr *pExpr);
21739 SQLITE_PRIVATE CollSeq *sqlite3ExprCollSeq(Parse *pParse, const Expr *pExpr);
21740 SQLITE_PRIVATE CollSeq *sqlite3ExprNNCollSeq(Parse *pParse, const Expr *pExpr);
22220 SQLITE_PRIVATE int sqlite3ExprVectorSize(const Expr *pExpr);
22221 SQLITE_PRIVATE int sqlite3ExprIsVector(const Expr *pExpr);
32520 Expr *pExpr = va_arg(ap,Expr*); in sqlite3_str_vappendf() local
32521 if( ALWAYS(pExpr) && ALWAYS(!ExprHasProperty(pExpr,EP_IntValue)) ){ in sqlite3_str_vappendf()
32522 sqlite3_str_appendall(pAccum, (const char*)pExpr->u.zToken); in sqlite3_str_vappendf()
32523 sqlite3RecordErrorOffsetOfExpr(pAccum->db, pExpr); in sqlite3_str_vappendf()
32628 SQLITE_PRIVATE void sqlite3RecordErrorOffsetOfExpr(sqlite3 *db, const Expr *pExpr){ in sqlite3RecordErrorOffsetOfExpr() argument
32629 while( pExpr in sqlite3RecordErrorOffsetOfExpr()
32630 && (ExprHasProperty(pExpr,EP_OuterON|EP_InnerON) || pExpr->w.iOfst<=0) in sqlite3RecordErrorOffsetOfExpr()
32632 pExpr = pExpr->pLeft; in sqlite3RecordErrorOffsetOfExpr()
32634 if( pExpr==0 ) return; in sqlite3RecordErrorOffsetOfExpr()
32635 if( ExprHasProperty(pExpr, EP_FromDDL) ) return; in sqlite3RecordErrorOffsetOfExpr()
32636 db->errByteOffset = pExpr->w.iOfst; in sqlite3RecordErrorOffsetOfExpr()
33536 Expr *pExpr, /* Value for PRECEDING or FOLLOWING */ in sqlite3TreeViewBound() argument
33552 sqlite3TreeViewExpr(pView, pExpr, 0); in sqlite3TreeViewBound()
33558 sqlite3TreeViewExpr(pView, pExpr, 0); in sqlite3TreeViewBound()
33650 SQLITE_PRIVATE void sqlite3TreeViewExpr(TreeView *pView, const Expr *pExpr, u8 moreToFollow){ in sqlite3TreeViewExpr() argument
33655 if( pExpr==0 ){ in sqlite3TreeViewExpr()
33660 if( pExpr->flags || pExpr->affExpr || pExpr->vvaFlags || pExpr->pAggInfo ){ in sqlite3TreeViewExpr()
33664 pExpr->flags, pExpr->affExpr ? pExpr->affExpr : 'n'); in sqlite3TreeViewExpr()
33665 if( ExprHasProperty(pExpr, EP_OuterON) ){ in sqlite3TreeViewExpr()
33666 sqlite3_str_appendf(&x, " outer.iJoin=%d", pExpr->w.iJoin); in sqlite3TreeViewExpr()
33668 if( ExprHasProperty(pExpr, EP_InnerON) ){ in sqlite3TreeViewExpr()
33669 sqlite3_str_appendf(&x, " inner.iJoin=%d", pExpr->w.iJoin); in sqlite3TreeViewExpr()
33671 if( ExprHasProperty(pExpr, EP_FromDDL) ){ in sqlite3TreeViewExpr()
33674 if( ExprHasVVAProperty(pExpr, EP_Immutable) ){ in sqlite3TreeViewExpr()
33677 if( pExpr->pAggInfo!=0 ){ in sqlite3TreeViewExpr()
33678 sqlite3_str_appendf(&x, " agg-column[%d]", pExpr->iAgg); in sqlite3TreeViewExpr()
33684 switch( pExpr->op ){ in sqlite3TreeViewExpr()
33687 pExpr->iTable, pExpr->iColumn, zFlgs); in sqlite3TreeViewExpr()
33691 if( pExpr->iTable<0 ){ in sqlite3TreeViewExpr()
33694 if( pExpr->op2 ){ in sqlite3TreeViewExpr()
33695 sqlite3_snprintf(sizeof(zOp2),zOp2," op2=0x%02x",pExpr->op2); in sqlite3TreeViewExpr()
33700 pExpr->iColumn, zFlgs, zOp2); in sqlite3TreeViewExpr()
33702 assert( ExprUseYTab(pExpr) ); in sqlite3TreeViewExpr()
33704 pExpr->iTable, pExpr->iColumn, in sqlite3TreeViewExpr()
33705 pExpr->y.pTab, zFlgs); in sqlite3TreeViewExpr()
33707 if( ExprHasProperty(pExpr, EP_FixedCol) ){ in sqlite3TreeViewExpr()
33708 sqlite3TreeViewExpr(pView, pExpr->pLeft, 0); in sqlite3TreeViewExpr()
33713 if( pExpr->flags & EP_IntValue ){ in sqlite3TreeViewExpr()
33714 sqlite3TreeViewLine(pView, "%d", pExpr->u.iValue); in sqlite3TreeViewExpr()
33716 sqlite3TreeViewLine(pView, "%s", pExpr->u.zToken); in sqlite3TreeViewExpr()
33722 assert( !ExprHasProperty(pExpr, EP_IntValue) ); in sqlite3TreeViewExpr()
33723 sqlite3TreeViewLine(pView,"%s", pExpr->u.zToken); in sqlite3TreeViewExpr()
33728 assert( !ExprHasProperty(pExpr, EP_IntValue) ); in sqlite3TreeViewExpr()
33729 sqlite3TreeViewLine(pView,"%Q", pExpr->u.zToken); in sqlite3TreeViewExpr()
33738 sqlite3ExprTruthValue(pExpr) ? "TRUE" : "FALSE", zFlgs); in sqlite3TreeViewExpr()
33743 assert( !ExprHasProperty(pExpr, EP_IntValue) ); in sqlite3TreeViewExpr()
33744 sqlite3TreeViewLine(pView,"%s", pExpr->u.zToken); in sqlite3TreeViewExpr()
33749 assert( !ExprHasProperty(pExpr, EP_IntValue) ); in sqlite3TreeViewExpr()
33751 pExpr->u.zToken, pExpr->iColumn); in sqlite3TreeViewExpr()
33755 sqlite3TreeViewLine(pView,"REGISTER(%d)", pExpr->iTable); in sqlite3TreeViewExpr()
33759 assert( !ExprHasProperty(pExpr, EP_IntValue) ); in sqlite3TreeViewExpr()
33760 sqlite3TreeViewLine(pView,"ID \"%w\"", pExpr->u.zToken); in sqlite3TreeViewExpr()
33766 assert( !ExprHasProperty(pExpr, EP_IntValue) ); in sqlite3TreeViewExpr()
33767 sqlite3TreeViewLine(pView,"CAST %Q", pExpr->u.zToken); in sqlite3TreeViewExpr()
33768 sqlite3TreeViewExpr(pView, pExpr->pLeft, 0); in sqlite3TreeViewExpr()
33807 assert( pExpr->op2==TK_IS || pExpr->op2==TK_ISNOT ); in sqlite3TreeViewExpr()
33808 assert( pExpr->pRight ); in sqlite3TreeViewExpr()
33809 assert( sqlite3ExprSkipCollateAndLikely(pExpr->pRight)->op in sqlite3TreeViewExpr()
33811 x = (pExpr->op2==TK_ISNOT)*2 + sqlite3ExprTruthValue(pExpr->pRight); in sqlite3TreeViewExpr()
33817 assert( !ExprHasProperty(pExpr, EP_IntValue) ); in sqlite3TreeViewExpr()
33818 sqlite3TreeViewLine(pView, "SPAN %Q", pExpr->u.zToken); in sqlite3TreeViewExpr()
33819 sqlite3TreeViewExpr(pView, pExpr->pLeft, 0); in sqlite3TreeViewExpr()
33829 assert( !ExprHasProperty(pExpr, EP_IntValue) ); in sqlite3TreeViewExpr()
33831 !ExprHasProperty(pExpr, EP_Collate) ? "SOFT-" : "", in sqlite3TreeViewExpr()
33832 pExpr->u.zToken, zFlgs); in sqlite3TreeViewExpr()
33833 sqlite3TreeViewExpr(pView, pExpr->pLeft, 0); in sqlite3TreeViewExpr()
33841 if( ExprHasProperty(pExpr, EP_TokenOnly) ){ in sqlite3TreeViewExpr()
33845 assert( ExprUseXList(pExpr) ); in sqlite3TreeViewExpr()
33846 pFarg = pExpr->x.pList; in sqlite3TreeViewExpr()
33848 pWin = IsWindowFunc(pExpr) ? pExpr->y.pWin : 0; in sqlite3TreeViewExpr()
33853 assert( !ExprHasProperty(pExpr, EP_IntValue) ); in sqlite3TreeViewExpr()
33854 if( pExpr->op==TK_AGG_FUNCTION ){ in sqlite3TreeViewExpr()
33856 pExpr->op2, pExpr->u.zToken, zFlgs, in sqlite3TreeViewExpr()
33857 pExpr->pAggInfo ? pExpr->pAggInfo->selId : 0, in sqlite3TreeViewExpr()
33858 pExpr->iAgg, pExpr->pAggInfo); in sqlite3TreeViewExpr()
33859 }else if( pExpr->op2!=0 ){ in sqlite3TreeViewExpr()
33862 sqlite3_snprintf(sizeof(zBuf),zBuf,"0x%02x",pExpr->op2); in sqlite3TreeViewExpr()
33864 if( pExpr->op2==NC_IsCheck ) zOp2 = "NC_IsCheck"; in sqlite3TreeViewExpr()
33865 if( pExpr->op2==NC_IdxExpr ) zOp2 = "NC_IdxExpr"; in sqlite3TreeViewExpr()
33866 if( pExpr->op2==NC_PartIdx ) zOp2 = "NC_PartIdx"; in sqlite3TreeViewExpr()
33867 if( pExpr->op2==NC_GenCol ) zOp2 = "NC_GenCol"; in sqlite3TreeViewExpr()
33869 pExpr->u.zToken, zFlgs, zOp2); in sqlite3TreeViewExpr()
33871 sqlite3TreeViewLine(pView, "FUNCTION %Q%s", pExpr->u.zToken, zFlgs); in sqlite3TreeViewExpr()
33874 sqlite3TreeViewExprList(pView, pFarg, pWin!=0 || pExpr->pLeft, 0); in sqlite3TreeViewExpr()
33875 if( pExpr->pLeft ){ in sqlite3TreeViewExpr()
33876 Expr *pOB = pExpr->pLeft; in sqlite3TreeViewExpr()
33890 sqlite3TreeViewExprList(pView, pExpr->x.pList, 0, "ORDERBY"); in sqlite3TreeViewExpr()
33895 assert( ExprUseXSelect(pExpr) ); in sqlite3TreeViewExpr()
33896 sqlite3TreeViewLine(pView, "EXISTS-expr flags=0x%x", pExpr->flags); in sqlite3TreeViewExpr()
33897 sqlite3TreeViewSelect(pView, pExpr->x.pSelect, 0); in sqlite3TreeViewExpr()
33901 assert( ExprUseXSelect(pExpr) ); in sqlite3TreeViewExpr()
33902 sqlite3TreeViewLine(pView, "subquery-expr flags=0x%x", pExpr->flags); in sqlite3TreeViewExpr()
33903 sqlite3TreeViewSelect(pView, pExpr->x.pSelect, 0); in sqlite3TreeViewExpr()
33909 sqlite3_str_appendf(pStr, "IN flags=0x%x", pExpr->flags); in sqlite3TreeViewExpr()
33910 if( pExpr->iTable ) sqlite3_str_appendf(pStr, " iTable=%d",pExpr->iTable); in sqlite3TreeViewExpr()
33911 if( ExprHasProperty(pExpr, EP_Subrtn) ){ in sqlite3TreeViewExpr()
33913 pExpr->y.sub.regReturn, pExpr->y.sub.iAddr); in sqlite3TreeViewExpr()
33918 sqlite3TreeViewExpr(pView, pExpr->pLeft, 1); in sqlite3TreeViewExpr()
33919 if( ExprUseXSelect(pExpr) ){ in sqlite3TreeViewExpr()
33920 sqlite3TreeViewSelect(pView, pExpr->x.pSelect, 0); in sqlite3TreeViewExpr()
33922 sqlite3TreeViewExprList(pView, pExpr->x.pList, 0, 0); in sqlite3TreeViewExpr()
33941 pX = pExpr->pLeft; in sqlite3TreeViewExpr()
33942 assert( ExprUseXList(pExpr) ); in sqlite3TreeViewExpr()
33943 assert( pExpr->x.pList->nExpr==2 ); in sqlite3TreeViewExpr()
33944 pY = pExpr->x.pList->a[0].pExpr; in sqlite3TreeViewExpr()
33945 pZ = pExpr->x.pList->a[1].pExpr; in sqlite3TreeViewExpr()
33961 pExpr->iTable ? "NEW" : "OLD", pExpr->iColumn); in sqlite3TreeViewExpr()
33966 sqlite3TreeViewExpr(pView, pExpr->pLeft, 1); in sqlite3TreeViewExpr()
33967 assert( ExprUseXList(pExpr) ); in sqlite3TreeViewExpr()
33968 sqlite3TreeViewExprList(pView, pExpr->x.pList, 0, 0); in sqlite3TreeViewExpr()
33974 switch( pExpr->affExpr ){ in sqlite3TreeViewExpr()
33980 assert( !ExprHasProperty(pExpr, EP_IntValue) ); in sqlite3TreeViewExpr()
33982 sqlite3TreeViewExpr(pView, pExpr->pLeft, 0); in sqlite3TreeViewExpr()
33988 pExpr->iTable, pExpr->iColumn, zFlgs); in sqlite3TreeViewExpr()
33989 sqlite3TreeViewExpr(pView, pExpr->pRight, 0); in sqlite3TreeViewExpr()
33994 assert( ExprUseXList(pExpr) ); in sqlite3TreeViewExpr()
33995 sqlite3TreeViewBareExprList(pView, pExpr->x.pList, z); in sqlite3TreeViewExpr()
34001 pExpr->iColumn, pExpr->iTable-1, in sqlite3TreeViewExpr()
34002 pExpr->pRight==pExpr->pLeft ? " (SELECT-owner)" : ""); in sqlite3TreeViewExpr()
34003 assert( ExprUseXSelect(pExpr->pLeft) ); in sqlite3TreeViewExpr()
34004 sqlite3TreeViewSelect(pView, pExpr->pLeft->x.pSelect, 0); in sqlite3TreeViewExpr()
34008 sqlite3TreeViewLine(pView, "IF-NULL-ROW %d", pExpr->iTable); in sqlite3TreeViewExpr()
34009 sqlite3TreeViewExpr(pView, pExpr->pLeft, 0); in sqlite3TreeViewExpr()
34015 tmp = *pExpr; in sqlite3TreeViewExpr()
34016 tmp.op = pExpr->op2; in sqlite3TreeViewExpr()
34021 if( pExpr->iColumn<=0 ){ in sqlite3TreeViewExpr()
34025 pExpr->iColumn-1); in sqlite3TreeViewExpr()
34030 sqlite3TreeViewLine(pView, "op=%d", pExpr->op); in sqlite3TreeViewExpr()
34036 sqlite3TreeViewExpr(pView, pExpr->pLeft, 1); in sqlite3TreeViewExpr()
34037 sqlite3TreeViewExpr(pView, pExpr->pRight, 0); in sqlite3TreeViewExpr()
34040 sqlite3TreeViewExpr(pView, pExpr->pLeft, 0); in sqlite3TreeViewExpr()
34096 sqlite3TreeViewExpr(pView, pList->a[i].pExpr, moreToFollow); in sqlite3TreeViewBareExprList()
72553 Expr *pExpr; local
72558 pExpr = va_arg(ap, Expr*);
72561 assert( pExpr!=0 );
72563 sqlite3WalkExpr(&w, pExpr);
85376 rc = sqlite3Stat4ValueFromExpr(pCtx->pParse, pList->a[i].pExpr, aff,
85437 const Expr *pExpr, /* The expression to evaluate */
85450 assert( pExpr!=0 );
85451 while( (op = pExpr->op)==TK_UPLUS || op==TK_SPAN ) pExpr = pExpr->pLeft;
85452 if( op==TK_REGISTER ) op = pExpr->op2;
85458 assert( (pExpr->flags & EP_TokenOnly)==0 || pCtx==0 );
85462 assert( !ExprHasProperty(pExpr, EP_IntValue) );
85463 aff = sqlite3AffinityType(pExpr->u.zToken,0);
85464 rc = valueFromExpr(db, pExpr->pLeft, enc, aff, ppVal, pCtx);
85484 Expr *pLeft = pExpr->pLeft;
85489 pExpr = pLeft;
85490 op = pExpr->op;
85500 if( ExprHasProperty(pExpr, EP_IntValue) ){
85501 sqlite3VdbeMemSetInt64(pVal, (i64)pExpr->u.iValue*negInt);
85504 if( op==TK_INTEGER && 0==sqlite3DecOrHexToI64(pExpr->u.zToken, &iVal) ){
85507 zVal = sqlite3MPrintf(db, "%s%s", zNeg, pExpr->u.zToken);
85537 if( SQLITE_OK==valueFromExpr(db,pExpr->pLeft,enc,affinity,&pVal,pCtx)
85563 assert( !ExprHasProperty(pExpr, EP_IntValue) );
85564 assert( pExpr->u.zToken[0]=='x' || pExpr->u.zToken[0]=='X' );
85565 assert( pExpr->u.zToken[1]=='\'' );
85568 zVal = &pExpr->u.zToken[2];
85577 rc = valueFromFunction(db, pExpr, enc, affinity, &pVal, pCtx);
85581 assert( !ExprHasProperty(pExpr, EP_IntValue) );
85585 pVal->u.i = pExpr->u.zToken[4]==0;
85620 const Expr *pExpr, /* The expression to evaluate */
85625 return pExpr ? valueFromExpr(db, pExpr, enc, affinity, ppVal, 0) : 0;
85649 Expr *pExpr, /* The expression to extract a value from */
85659 pExpr = sqlite3ExprSkipCollate(pExpr);
85661 assert( pExpr==0 || pExpr->op!=TK_REGISTER || pExpr->op2!=TK_VARIABLE );
85662 if( !pExpr ){
85667 }else if( pExpr->op==TK_VARIABLE && (db->flags & SQLITE_EnableQPSG)==0 ){
85669 int iBindVar = pExpr->iColumn;
85680 rc = valueFromExpr(db, pExpr, ENC(db), affinity, &pVal, pAlloc);
85726 Expr *pExpr, /* The expression to extract a value from */
85734 if( pExpr==0 || pExpr->op!=TK_SELECT ){
85744 Expr *pElem = (pExpr ? sqlite3VectorFieldSubexpr(pExpr, i) : 0);
85769 Expr *pExpr, /* The expression to extract a value from */
85773 return stat4ValueFromExpr(pParse, pExpr, affinity, 0, ppVal);
87725 static void displayP4Expr(StrAccum *p, Expr *pExpr){
87727 switch( pExpr->op ){
87729 assert( !ExprHasProperty(pExpr, EP_IntValue) );
87730 sqlite3_str_appendf(p, "%Q", pExpr->u.zToken);
87733 sqlite3_str_appendf(p, "%d", pExpr->u.iValue);
87739 sqlite3_str_appendf(p, "r[%d]", pExpr->iTable);
87743 if( pExpr->iColumn<0 ){
87746 sqlite3_str_appendf(p, "c%d", (int)pExpr->iColumn);
87784 displayP4Expr(p, pExpr->pLeft);
87785 if( pExpr->pRight ){
87787 displayP4Expr(p, pExpr->pRight);
87825 displayP4Expr(&x, pOp->p4.pExpr);
91321 SQLITE_PRIVATE int sqlite3CursorRangeHintExprCheck(Walker *pWalker, Expr *pExpr){
91322 if( pExpr->op==TK_REGISTER ){
91323 assert( (pWalker->u.aMem[pExpr->iTable].flags & MEM_Undefined)==0 );
93706 pDflt = p->pTab->u.tab.pDfltList->a[pCol->iDflt-1].pExpr;
103325 pOp->p4.pExpr, aMem);
107834 SQLITE_PRIVATE SQLITE_NOINLINE int sqlite3WalkExprNN(Walker *pWalker, Expr *pExpr){
107836 testcase( ExprHasProperty(pExpr, EP_TokenOnly) );
107837 testcase( ExprHasProperty(pExpr, EP_Reduced) );
107839 rc = pWalker->xExprCallback(pWalker, pExpr);
107841 if( !ExprHasProperty(pExpr,(EP_TokenOnly|EP_Leaf)) ){
107842 assert( pExpr->x.pList==0 || pExpr->pRight==0 );
107843 if( pExpr->pLeft && sqlite3WalkExprNN(pWalker, pExpr->pLeft) ){
107846 if( pExpr->pRight ){
107847 assert( !ExprHasProperty(pExpr, EP_WinFunc) );
107848 pExpr = pExpr->pRight;
107850 }else if( ExprUseXSelect(pExpr) ){
107851 assert( !ExprHasProperty(pExpr, EP_WinFunc) );
107852 if( sqlite3WalkSelect(pWalker, pExpr->x.pSelect) ) return WRC_Abort;
107854 if( pExpr->x.pList ){
107855 if( sqlite3WalkExprList(pWalker, pExpr->x.pList) ) return WRC_Abort;
107858 if( ExprHasProperty(pExpr, EP_WinFunc) ){
107859 if( walkWindowList(pWalker, pExpr->y.pWin, 1) ) return WRC_Abort;
107868 SQLITE_PRIVATE int sqlite3WalkExpr(Walker *pWalker, Expr *pExpr){
107869 return pExpr ? sqlite3WalkExprNN(pWalker,pExpr) : WRC_Continue;
107881 if( sqlite3WalkExpr(pWalker, pItem->pExpr) ) return WRC_Abort;
108069 static int incrAggDepth(Walker *pWalker, Expr *pExpr){
108070 if( pExpr->op==TK_AGG_FUNCTION ) pExpr->op2 += pWalker->u.n;
108073 static void incrAggFunctionDepth(Expr *pExpr, int N){
108079 sqlite3WalkExpr(&w, pExpr);
108106 Expr *pExpr, /* Transform this into an alias to the result set */
108114 pOrig = pEList->a[iCol].pExpr;
108116 assert( !ExprHasProperty(pExpr, EP_Reduced|EP_TokenOnly) );
108117 if( pExpr->pAggInfo ) return;
108126 if( pExpr->op==TK_COLLATE ){
108127 assert( !ExprHasProperty(pExpr, EP_IntValue) );
108128 pDup = sqlite3ExprAddCollateString(pParse, pDup, pExpr->u.zToken);
108131 memcpy(pDup, pExpr, sizeof(Expr));
108132 memcpy(pExpr, &temp, sizeof(Expr));
108133 if( ExprHasProperty(pExpr, EP_WinFunc) ){
108134 if( ALWAYS(pExpr->y.pWin!=0) ){
108135 pExpr->y.pWin->pOwner = pExpr;
108213 SQLITE_PRIVATE Bitmask sqlite3ExprColUsed(Expr *pExpr){
108217 n = pExpr->iColumn;
108218 assert( ExprUseYTab(pExpr) );
108219 pExTab = pExpr->y.pTab;
108318 Expr *pExpr /* Make this EXPR node point to the selected column */
108337 assert( !ExprHasProperty(pExpr, EP_TokenOnly|EP_Reduced) );
108340 pExpr->iTable = -1;
108341 ExprSetVVAProperty(pExpr, EP_NoReduce);
108428 extendFJMatch(pParse, &pFJMatch, pMatch, pExpr->iColumn);
108440 pExpr->iColumn = j;
108463 assert( ExprUseYTab(pExpr) );
108465 sqlite3RenameTokenRemap(pParse, 0, (void*)&pExpr->y.pTab);
108491 extendFJMatch(pParse, &pFJMatch, pMatch, pExpr->iColumn);
108497 pExpr->iColumn = j==pTab->iPKey ? -1 : (i16)j;
108537 pExpr->iTable = pMatch->iCursor;
108538 assert( ExprUseYTab(pExpr) );
108539 pExpr->y.pTab = pMatch->pSTab;
108541 ExprSetProperty(pExpr, EP_CanBeNull);
108543 pSchema = pExpr->y.pTab->pSchema;
108565 pExpr->iTable = op!=TK_DELETE;
108569 pExpr->iTable = 1;
108572 pExpr->iTable = 0;
108582 pExpr->iTable = EXCLUDED_TABLE_NUMBER;
108605 if( pExpr->iTable==EXCLUDED_TABLE_NUMBER ){
108607 assert( ExprUseYTab(pExpr) );
108609 pExpr->iColumn = iCol;
108610 pExpr->y.pTab = pTab;
108613 pExpr->iTable = pNC->uNC.pUpsert->regData +
108620 assert( ExprUseYTab(pExpr) );
108621 pExpr->y.pTab = pTab;
108624 pExpr->op2 = TK_COLUMN;
108625 pExpr->iColumn = iCol;
108626 pExpr->iTable = pNC->uNC.iBaseReg + (pTab->nCol+1)*pExpr->iTable +
108629 pExpr->iColumn = (i16)iCol;
108633 pExpr->affExpr = SQLITE_AFF_INTEGER;
108634 }else if( pExpr->iTable==0 ){
108667 if( pMatch->fg.isNestedFrom==0 ) pExpr->iColumn = -1;
108668 pExpr->affExpr = SQLITE_AFF_INTEGER;
108701 assert( pExpr->pLeft==0 && pExpr->pRight==0 );
108702 assert( ExprUseXList(pExpr)==0 || pExpr->x.pList==0 );
108703 assert( ExprUseXSelect(pExpr)==0 || pExpr->x.pSelect==0 );
108704 pOrig = pEList->a[j].pExpr;
108719 resolveAlias(pParse, pEList, j, pExpr, nSubquery);
108724 sqlite3RenameTokenRemap(pParse, 0, (void*)pExpr);
108751 assert( pExpr->op==TK_ID );
108752 if( ExprHasProperty(pExpr,EP_DblQuoted)
108774 pExpr->op = TK_STRING;
108775 memset(&pExpr->y, 0, sizeof(pExpr->y));
108778 if( sqlite3ExprIdToTrueFalse(pExpr) ){
108791 assert( !ExprHasProperty(pExpr, EP_xIsSelect|EP_IntValue) );
108796 if( ExprHasProperty(pExpr,EP_Leaf) ){
108797 ExprClearProperty(pExpr,EP_Leaf);
108799 sqlite3ExprDelete(db, pExpr->pLeft);
108800 pExpr->pLeft = 0;
108801 sqlite3ExprDelete(db, pExpr->pRight);
108802 pExpr->pRight = 0;
108804 extendFJMatch(pParse, &pFJMatch, pMatch, pExpr->iColumn);
108805 pExpr->op = TK_FUNCTION;
108806 pExpr->u.zToken = "coalesce";
108807 pExpr->x.pList = pFJMatch;
108827 sqlite3RecordErrorOffsetOfExpr(pParse->db, pExpr);
108835 if( !ExprHasProperty(pExpr,(EP_TokenOnly|EP_Leaf)) ){
108836 sqlite3ExprDelete(db, pExpr->pLeft);
108837 pExpr->pLeft = 0;
108838 sqlite3ExprDelete(db, pExpr->pRight);
108839 pExpr->pRight = 0;
108840 ExprSetProperty(pExpr, EP_Leaf);
108858 if( pExpr->iColumn>=0 ){
108859 pMatch->colUsed |= sqlite3ExprColUsed(pExpr);
108865 pExpr->op = eNewExprOp;
108871 && (pExpr->op==TK_COLUMN || pExpr->op==TK_TRIGGER)
108873 sqlite3AuthRead(pParse, pExpr, pSchema, pNC->pSrcList);
108942 Expr *pExpr, /* Invalidate this expression on error */
108954 if( pExpr ) pExpr->op = TK_NULL;
108987 static int resolveExprStep(Walker *pWalker, Expr *pExpr){
109005 switch( pExpr->op ){
109017 pExpr->op = TK_COLUMN;
109018 assert( ExprUseYTab(pExpr) );
109019 pExpr->y.pTab = pItem->pSTab;
109020 pExpr->iTable = pItem->iCursor;
109021 pExpr->iColumn--;
109022 pExpr->affExpr = SQLITE_AFF_INTEGER;
109061 sqlite3WalkExpr(pWalker, pExpr->pLeft);
109063 if( sqlite3ExprCanBeNull(pExpr->pLeft) ){
109073 testcase( ExprHasProperty(pExpr, EP_OuterON) );
109074 assert( !ExprHasProperty(pExpr, EP_IntValue) );
109079 pExpr->op==TK_NOTNULL
109081 sqlite3ShowExpr(pExpr);
109084 pExpr->u.iValue = (pExpr->op==TK_NOTNULL);
109085 pExpr->flags |= EP_IntValue;
109086 pExpr->op = TK_INTEGER;
109090 sqlite3ExprDelete(pParse->db, pExpr->pLeft);
109091 pExpr->pLeft = 0;
109109 if( pExpr->op==TK_ID ){
109112 assert( !ExprHasProperty(pExpr, EP_IntValue) );
109113 pRight = pExpr;
109115 Expr *pLeft = pExpr->pLeft;
109119 NC_IdxExpr|NC_GenCol, 0, pExpr);
109120 pRight = pExpr->pRight;
109132 assert( ExprUseYTab(pExpr) );
109134 sqlite3RenameTokenRemap(pParse, (void*)pExpr, (void*)pRight);
109135 sqlite3RenameTokenRemap(pParse, (void*)&pExpr->y.pTab, (void*)pLeft);
109138 return lookupName(pParse, zDb, zTable, pRight, pNC, pExpr);
109154 Window *pWin = (IsWindowFunc(pExpr) ? pExpr->y.pWin : 0);
109156 assert( !ExprHasProperty(pExpr, EP_xIsSelect|EP_IntValue) );
109157 assert( pExpr->pLeft==0 || pExpr->pLeft->op==TK_ORDER );
109158 pList = pExpr->x.pList;
109160 zId = pExpr->u.zToken;
109172 ExprSetProperty(pExpr, EP_Unlikely);
109174 pExpr->iTable = exprProbability(pList->a[1].pExpr);
109175 if( pExpr->iTable<0 ){
109178 "constant between 0.0 and 1.0", pExpr);
109191 pExpr->iTable = pDef->zName[0]=='u' ? 8388608 : 125829120;
109200 pExpr);
109203 pExpr->op = TK_NULL;
109218 || ExprHasProperty(pExpr, EP_SubtArg)
109222 ExprSetProperty(pList->a[ii].pExpr, EP_SubtArg);
109231 ExprSetProperty(pExpr,EP_ConstFunc);
109241 NC_IdxExpr|NC_PartIdx|NC_GenCol, 0, pExpr);
109244 pExpr->op2 = pNC->ncFlags & NC_SelfRef;
109260 if( pNC->ncFlags & NC_FromDDL ) ExprSetProperty(pExpr, EP_FromDDL);
109261 sqlite3ExprFunctionUsable(pParse, pExpr, pDef);
109273 "%#T() may not be used as a window function", pExpr
109287 sqlite3ErrorMsg(pParse, "misuse of %s function %#T()",zType,pExpr);
109293 sqlite3ErrorMsg(pParse,"misuse of aggregate function %#T()",pExpr);
109303 sqlite3ErrorMsg(pParse, "no such function: %#T", pExpr);
109307 pExpr);
109311 else if( is_agg==0 && ExprHasProperty(pExpr, EP_WinFunc) ){
109314 pExpr
109319 else if( is_agg==0 && pExpr->pLeft ){
109320 sqlite3ExprOrderByAggregateError(pParse, pExpr);
109334 else if( ExprHasProperty(pExpr, EP_WinFunc) || pExpr->pLeft ){
109339 if( pExpr->pLeft ){
109340 assert( pExpr->pLeft->op==TK_ORDER );
109341 assert( ExprUseXList(pExpr->pLeft) );
109342 sqlite3WalkExprList(pWalker, pExpr->pLeft->x.pList);
109347 assert( ExprUseYWin(pExpr) && pWin==pExpr->y.pWin );
109361 pExpr->op = TK_AGG_FUNCTION;
109362 pExpr->op2 = 0;
109364 if( ExprHasProperty(pExpr, EP_WinFunc) ){
109365 sqlite3WalkExpr(pWalker, pExpr->y.pWin->pFilter);
109370 && sqlite3ReferencesSrcList(pParse, pExpr, pNC2->pSrcList)==0
109372 pExpr->op2 += (1 + pNC2->nNestedSelect);
109377 pExpr->op2 += pNC2->nNestedSelect;
109396 case TK_EXISTS: testcase( pExpr->op==TK_EXISTS );
109399 testcase( pExpr->op==TK_IN );
109400 if( ExprUseXSelect(pExpr) ){
109406 assert( pExpr->x.pSelect );
109408 notValidImpl(pParse, pNC, "subqueries", pExpr, pExpr);
109410 sqlite3WalkSelect(pWalker, pExpr->x.pSelect);
109414 ExprSetProperty(pExpr, EP_VarSelect);
109415 pExpr->x.pSelect->selFlags |= SF_Correlated;
109427 NC_IsCheck|NC_PartIdx|NC_IdxExpr|NC_GenCol, pExpr, pExpr);
109432 Expr *pRight = sqlite3ExprSkipCollateAndLikely(pExpr->pRight);
109433 assert( !ExprHasProperty(pExpr, EP_Reduced) );
109440 pExpr->op2 = pExpr->op;
109441 pExpr->op = TK_TRUTH;
109456 assert( pExpr->pLeft!=0 );
109457 nLeft = sqlite3ExprVectorSize(pExpr->pLeft);
109458 if( pExpr->op==TK_BETWEEN ){
109459 assert( ExprUseXList(pExpr) );
109460 nRight = sqlite3ExprVectorSize(pExpr->x.pList->a[0].pExpr);
109462 nRight = sqlite3ExprVectorSize(pExpr->x.pList->a[1].pExpr);
109465 assert( pExpr->pRight!=0 );
109466 nRight = sqlite3ExprVectorSize(pExpr->pRight);
109469 testcase( pExpr->op==TK_EQ );
109470 testcase( pExpr->op==TK_NE );
109471 testcase( pExpr->op==TK_LT );
109472 testcase( pExpr->op==TK_LE );
109473 testcase( pExpr->op==TK_GT );
109474 testcase( pExpr->op==TK_GE );
109475 testcase( pExpr->op==TK_IS );
109476 testcase( pExpr->op==TK_ISNOT );
109477 testcase( pExpr->op==TK_BETWEEN );
109479 sqlite3RecordErrorOffsetOfExpr(pParse->db, pExpr);
109577 if( sqlite3ExprCompare(0, pEList->a[i].pExpr, pE, -1)<2 ){
109651 pE = sqlite3ExprSkipCollateAndLikely(pItem->pExpr);
109691 if( pItem->pExpr==pE ){
109692 pItem->pExpr = pNew;
109694 Expr *pParent = pItem->pExpr;
109754 resolveAlias(pParse, pEList, pItem->u.x.iOrderByCol-1, pItem->pExpr,0);
109764 static int resolveRemoveWindowsCb(Walker *pWalker, Expr *pExpr){
109766 if( ExprHasProperty(pExpr, EP_WinFunc) ){
109767 Window *pWin = pExpr->y.pWin;
109777 static void windowRemoveExprFromSelect(Select *pSelect, Expr *pExpr){
109783 sqlite3WalkExpr(&sWalker, pExpr);
109824 Expr *pE = pItem->pExpr;
109856 if( sqlite3ExprCompare(0, pE, pSelect->pEList->a[j].pExpr, -1)==0 ){
110095 if( ExprHasProperty(pItem->pExpr, EP_Agg) ){
110176 Expr *pExpr /* The expression to be analyzed. */
110181 if( pExpr==0 ) return SQLITE_OK;
110190 w.pParse->nHeight += pExpr->nHeight;
110195 assert( pExpr!=0 );
110196 sqlite3WalkExprNN(&w, pExpr);
110198 w.pParse->nHeight -= pExpr->nHeight;
110204 ExprSetProperty(pExpr, pNC->ncFlags & (NC_HasAgg|NC_HasWin) );
110233 Expr *pExpr = pList->a[i].pExpr;
110234 if( pExpr==0 ) continue;
110236 w.pParse->nHeight += pExpr->nHeight;
110241 sqlite3WalkExprNN(&w, pExpr);
110243 w.pParse->nHeight -= pExpr->nHeight;
110250 ExprSetProperty(pExpr, pNC->ncFlags & (NC_HasAgg|NC_HasWin) );
110311 Expr *pExpr, /* Expression to resolve. May be NULL. */
110339 if( (rc = sqlite3ResolveExprNames(&sNC, pExpr))!=SQLITE_OK ) return rc;
110390 SQLITE_PRIVATE char sqlite3ExprAffinity(const Expr *pExpr){
110392 op = pExpr->op;
110394 if( op==TK_COLUMN || (op==TK_AGG_COLUMN && pExpr->y.pTab!=0) ){
110395 assert( ExprUseYTab(pExpr) );
110396 assert( pExpr->y.pTab!=0 );
110397 return sqlite3TableColumnAffinity(pExpr->y.pTab, pExpr->iColumn);
110400 assert( ExprUseXSelect(pExpr) );
110401 assert( pExpr->x.pSelect!=0 );
110402 assert( pExpr->x.pSelect->pEList!=0 );
110403 assert( pExpr->x.pSelect->pEList->a[0].pExpr!=0 );
110404 return sqlite3ExprAffinity(pExpr->x.pSelect->pEList->a[0].pExpr);
110408 assert( !ExprHasProperty(pExpr, EP_IntValue) );
110409 return sqlite3AffinityType(pExpr->u.zToken, 0);
110413 assert( pExpr->pLeft!=0 && ExprUseXSelect(pExpr->pLeft) );
110414 assert( pExpr->iColumn < pExpr->iTable );
110415 assert( pExpr->iColumn >= 0 );
110416 assert( pExpr->iTable==pExpr->pLeft->x.pSelect->pEList->nExpr );
110418 pExpr->pLeft->x.pSelect->pEList->a[pExpr->iColumn].pExpr
110422 || (op==TK_FUNCTION && pExpr->affExpr==SQLITE_AFF_DEFER)
110424 assert( ExprUseXList(pExpr) );
110425 return sqlite3ExprAffinity(pExpr->x.pList->a[0].pExpr);
110427 if( ExprHasProperty(pExpr, EP_Skip|EP_IfNullRow) ){
110428 assert( pExpr->op==TK_COLLATE
110429 || pExpr->op==TK_IF_NULL_ROW
110430 || (pExpr->op==TK_REGISTER && pExpr->op2==TK_IF_NULL_ROW) );
110431 pExpr = pExpr->pLeft;
110432 op = pExpr->op;
110436 op = pExpr->op2;
110439 return pExpr->affExpr;
110452 SQLITE_PRIVATE int sqlite3ExprDataType(const Expr *pExpr){
110453 while( pExpr ){
110454 switch( pExpr->op ){
110458 pExpr = pExpr->pLeft;
110462 pExpr = 0;
110485 int aff = sqlite3ExprAffinity(pExpr);
110493 ExprList *pList = pExpr->x.pList;
110494 assert( ExprUseXList(pExpr) && pList!=0 );
110497 res |= sqlite3ExprDataType(pList->a[ii].pExpr);
110500 res |= sqlite3ExprDataType(pList->a[pList->nExpr-1].pExpr);
110522 Expr *pExpr, /* Add the "COLLATE" clause to this expression */
110529 pNew->pLeft = pExpr;
110531 pExpr = pNew;
110534 return pExpr;
110538 Expr *pExpr, /* Add the "COLLATE" clause to this expression */
110544 return sqlite3ExprAddCollateToken(pParse, pExpr, &s, 0);
110550 SQLITE_PRIVATE Expr *sqlite3ExprSkipCollate(Expr *pExpr){
110551 while( pExpr && ExprHasProperty(pExpr, EP_Skip) ){
110552 assert( pExpr->op==TK_COLLATE );
110553 pExpr = pExpr->pLeft;
110555 return pExpr;
110563 SQLITE_PRIVATE Expr *sqlite3ExprSkipCollateAndLikely(Expr *pExpr){
110564 while( pExpr && ExprHasProperty(pExpr, EP_Skip|EP_Unlikely) ){
110565 if( ExprHasProperty(pExpr, EP_Unlikely) ){
110566 assert( ExprUseXList(pExpr) );
110567 assert( pExpr->x.pList->nExpr>0 );
110568 assert( pExpr->op==TK_FUNCTION );
110569 pExpr = pExpr->x.pList->a[0].pExpr;
110570 }else if( pExpr->op==TK_COLLATE ){
110571 pExpr = pExpr->pLeft;
110576 return pExpr;
110593 SQLITE_PRIVATE CollSeq *sqlite3ExprCollSeq(Parse *pParse, const Expr *pExpr){
110596 const Expr *p = pExpr;
110620 p = p->x.pList->a[0].pExpr;
110638 if( ExprHasProperty(p->x.pList->a[i].pExpr, EP_Collate) ){
110639 pNext = p->x.pList->a[i].pExpr;
110666 SQLITE_PRIVATE CollSeq *sqlite3ExprNNCollSeq(Parse *pParse, const Expr *pExpr){
110667 CollSeq *p = sqlite3ExprCollSeq(pParse, pExpr);
110687 SQLITE_PRIVATE char sqlite3CompareAffinity(const Expr *pExpr, char aff2){
110688 char aff1 = sqlite3ExprAffinity(pExpr);
110709 static char comparisonAffinity(const Expr *pExpr){
110711 assert( pExpr->op==TK_EQ || pExpr->op==TK_IN || pExpr->op==TK_LT ||
110712 pExpr->op==TK_GT || pExpr->op==TK_GE || pExpr->op==TK_LE ||
110713 pExpr->op==TK_NE || pExpr->op==TK_IS || pExpr->op==TK_ISNOT );
110714 assert( pExpr->pLeft );
110715 aff = sqlite3ExprAffinity(pExpr->pLeft);
110716 if( pExpr->pRight ){
110717 aff = sqlite3CompareAffinity(pExpr->pRight, aff);
110718 }else if( ExprUseXSelect(pExpr) ){
110719 aff = sqlite3CompareAffinity(pExpr->x.pSelect->pEList->a[0].pExpr, aff);
110732 SQLITE_PRIVATE int sqlite3IndexAffinityOk(const Expr *pExpr, char idx_affinity){
110733 char aff = comparisonAffinity(pExpr);
110844 SQLITE_PRIVATE int sqlite3ExprIsVector(const Expr *pExpr){
110845 return sqlite3ExprVectorSize(pExpr)>1;
110854 SQLITE_PRIVATE int sqlite3ExprVectorSize(const Expr *pExpr){
110855 u8 op = pExpr->op;
110856 if( op==TK_REGISTER ) op = pExpr->op2;
110858 assert( ExprUseXList(pExpr) );
110859 return pExpr->x.pList->nExpr;
110861 assert( ExprUseXSelect(pExpr) );
110862 return pExpr->x.pSelect->pEList->nExpr;
110889 return pVector->x.pSelect->pEList->a[i].pExpr;
110892 return pVector->x.pList->a[i].pExpr;
110955 ppVector = &pVector->x.pList->a[iField].pExpr;
110976 static int exprCodeSubselect(Parse *pParse, Expr *pExpr){
110979 if( pExpr->op==TK_SELECT ){
110980 reg = sqlite3CodeSubselect(pParse, pExpr);
111020 *ppExpr = pVector->x.pSelect->pEList->a[iField].pExpr;
111025 *ppExpr = pVector->x.pList->a[iField].pExpr;
111044 Expr *pExpr, /* The comparison operation */
111050 Expr *pLeft = pExpr->pLeft;
111051 Expr *pRight = pExpr->pRight;
111059 int isCommuted = ExprHasProperty(pExpr,EP_Commuted);
111061 assert( !ExprHasVVAProperty(pExpr,EP_Immutable) );
111067 assert( pExpr->op==TK_EQ || pExpr->op==TK_NE
111068 || pExpr->op==TK_IS || pExpr->op==TK_ISNOT
111069 || pExpr->op==TK_LT || pExpr->op==TK_GT
111070 || pExpr->op==TK_LE || pExpr->op==TK_GE
111072 assert( pExpr->op==op || (pExpr->op==TK_IS && op==TK_EQ)
111073 || (pExpr->op==TK_ISNOT && op==TK_NE) );
111074 assert( p5==0 || pExpr->op!=op );
111075 assert( p5==SQLITE_NULLEQ || pExpr->op==op );
111169 heightOfExpr(p->a[i].pExpr, pnHeight);
111249 SQLITE_PRIVATE void sqlite3ExprSetErrorOffset(Expr *pExpr, int iOfst){
111250 if( pExpr==0 ) return;
111251 if( NEVER(ExprUseWJoin(pExpr)) ) return;
111252 pExpr->w.iOfst = iOfst;
111407 SQLITE_PRIVATE void sqlite3PExprAddSelect(Parse *pParse, Expr *pExpr, Select *pSelect){
111408 if( pExpr ){
111409 pExpr->x.pSelect = pSelect;
111410 ExprSetProperty(pExpr, EP_xIsSelect|EP_Subquery);
111411 sqlite3ExprSetHeightAndFlags(pParse, pExpr);
111443 Expr *pExpr = pEList->a[ii].pExpr;
111445 if( pExpr->op==TK_VECTOR ){
111446 assert( ExprUseXList(pExpr) );
111447 nExprElem = pExpr->x.pList->nExpr;
111457 assert( ExprUseXList(pExpr) );
111458 pSel = sqlite3SelectNew(pParse, pExpr->x.pList, 0, 0, 0, 0, 0, SF_Values,0);
111459 pExpr->x.pList = 0;
111560 Expr *pExpr, /* The function call to which ORDER BY is to be added */
111569 if( pExpr==0 ){
111574 assert( pExpr->op==TK_FUNCTION );
111575 assert( pExpr->pLeft==0 );
111576 assert( ExprUseXList(pExpr) );
111577 if( pExpr->x.pList==0 || NEVER(pExpr->x.pList->nExpr==0) ){
111582 if( IsWindowFunc(pExpr) ){
111583 sqlite3ExprOrderByAggregateError(pParse, pExpr);
111595 pExpr->pLeft = pOB;
111612 const Expr *pExpr, /* The function invocation */
111617 if( ExprHasProperty(pExpr, EP_FromDDL) ){
111628 sqlite3ErrorMsg(pParse, "unsafe use of %#T()", pExpr);
111649 SQLITE_PRIVATE void sqlite3ExprAssignVarNumber(Parse *pParse, Expr *pExpr, u32 n){
111654 if( pExpr==0 ) return;
111655 assert( !ExprHasProperty(pExpr, EP_IntValue|EP_Reduced|EP_TokenOnly) );
111656 z = pExpr->u.zToken;
111684 sqlite3RecordErrorOffsetOfExpr(pParse->db, pExpr);
111709 pExpr->iColumn = x;
111712 sqlite3RecordErrorOffsetOfExpr(pParse->db, pExpr);
111800 SQLITE_PRIVATE int sqlite3ExprDeferredDelete(Parse *pParse, Expr *pExpr){
111801 return 0==sqlite3ParserAddCleanup(pParse, sqlite3ExprDeleteGeneric, pExpr);
112116 static int gatherSelectWindowsCallback(Walker *pWalker, Expr *pExpr){
112117 if( pExpr->op==TK_FUNCTION && ExprHasProperty(pExpr, EP_WinFunc) ){
112119 Window *pWin = pExpr->y.pWin;
112121 assert( IsWindowFunc(pExpr) );
112179 Expr *pOldExpr = pOldItem->pExpr;
112181 pItem->pExpr = sqlite3ExprDup(db, pOldExpr, flags);
112184 && (pNewExpr = pItem->pExpr)!=0
112360 Expr *pExpr /* Expression to be appended. Might be NULL */
112367 sqlite3ExprDelete(db, pExpr);
112374 pItem->pExpr = pExpr;
112380 Expr *pExpr /* Expression to be appended. Might be NULL */
112388 sqlite3ExprDelete(db, pExpr);
112395 pItem->pExpr = pExpr;
112401 Expr *pExpr /* Expression to be appended. Might be NULL */
112405 return sqlite3ExprListAppendNew(pParse->db,pExpr);
112408 return sqlite3ExprListAppendGrow(pParse->db,pList,pExpr);
112412 pItem->pExpr = pExpr;
112431 Expr *pExpr /* Vector expression to be appended. Might be NULL */
112440 if( pExpr==0 ) goto vector_append_error;
112447 if( pExpr->op!=TK_SELECT && pColumns->nId!=(n=sqlite3ExprVectorSize(pExpr)) ){
112454 Expr *pSubExpr = sqlite3ExprForVectorField(pParse, pExpr, i, pColumns->nId);
112465 if( !db->mallocFailed && pExpr->op==TK_SELECT && ALWAYS(pList!=0) ){
112466 Expr *pFirst = pList->a[iFirst].pExpr;
112472 pFirst->pRight = pExpr;
112473 pExpr = 0;
112481 sqlite3ExprUnmapAndDelete(pParse, pExpr);
112606 sqlite3ExprDelete(db, pItem->pExpr);
112628 Expr *pExpr = pList->a[i].pExpr;
112629 assert( pExpr!=0 );
112630 m |= pExpr->flags;
112668 SQLITE_PRIVATE int sqlite3ExprIdToTrueFalse(Expr *pExpr){
112670 assert( pExpr->op==TK_ID || pExpr->op==TK_STRING );
112671 if( !ExprHasProperty(pExpr, EP_Quoted|EP_IntValue)
112672 && (v = sqlite3IsTrueOrFalse(pExpr->u.zToken))!=0
112674 pExpr->op = TK_TRUEFALSE;
112675 ExprSetProperty(pExpr, v);
112685 SQLITE_PRIVATE int sqlite3ExprTruthValue(const Expr *pExpr){
112686 pExpr = sqlite3ExprSkipCollateAndLikely((Expr*)pExpr);
112687 assert( pExpr->op==TK_TRUEFALSE );
112688 assert( !ExprHasProperty(pExpr, EP_IntValue) );
112689 assert( sqlite3StrICmp(pExpr->u.zToken,"true")==0
112690 || sqlite3StrICmp(pExpr->u.zToken,"false")==0 );
112691 return pExpr->u.zToken[4]==0;
112707 SQLITE_PRIVATE Expr *sqlite3ExprSimplifiedAndOr(Expr *pExpr){
112708 assert( pExpr!=0 );
112709 if( pExpr->op==TK_AND || pExpr->op==TK_OR ){
112710 Expr *pRight = sqlite3ExprSimplifiedAndOr(pExpr->pRight);
112711 Expr *pLeft = sqlite3ExprSimplifiedAndOr(pExpr->pLeft);
112713 pExpr = pExpr->op==TK_AND ? pRight : pLeft;
112715 pExpr = pExpr->op==TK_AND ? pLeft : pRight;
112718 return pExpr;
112739 Expr *pExpr
112746 assert( pExpr->op==TK_FUNCTION );
112747 if( ExprHasProperty(pExpr, EP_TokenOnly)
112748 || (pList = pExpr->x.pList)==0
112757 pDef = sqlite3FindFunction(db, pExpr->u.zToken, n, ENC(db), 0);
112761 || ExprHasProperty(pExpr, EP_WinFunc)
112796 static int exprNodeIsConstant(Walker *pWalker, Expr *pExpr){
112802 if( pWalker->eCode==2 && ExprHasProperty(pExpr, EP_OuterON) ){
112807 switch( pExpr->op ){
112812 if( (pWalker->eCode>=4 || ExprHasProperty(pExpr,EP_ConstFunc))
112813 && !ExprHasProperty(pExpr, EP_WinFunc)
112815 if( pWalker->eCode==5 ) ExprSetProperty(pExpr, EP_FromDDL);
112818 return exprNodeIsConstantFunction(pWalker, pExpr);
112826 if( sqlite3ExprIdToTrueFalse(pExpr) ){
112833 testcase( pExpr->op==TK_ID );
112834 testcase( pExpr->op==TK_COLUMN );
112835 testcase( pExpr->op==TK_AGG_FUNCTION );
112836 testcase( pExpr->op==TK_AGG_COLUMN );
112837 if( ExprHasProperty(pExpr, EP_FixedCol) && pWalker->eCode!=2 ){
112840 if( pWalker->eCode==3 && pExpr->iTable==pWalker->u.iCur ){
112848 testcase( pExpr->op==TK_REGISTER );
112849 testcase( pExpr->op==TK_IF_NULL_ROW );
112850 testcase( pExpr->op==TK_DOT );
112851 testcase( pExpr->op==TK_RAISE );
112859 pExpr->op = TK_NULL;
112868 testcase( pExpr->op==TK_SELECT ); /* sqlite3SelectWalkFail() disallows */
112869 testcase( pExpr->op==TK_EXISTS ); /* sqlite3SelectWalkFail() disallows */
113009 Expr *pExpr, /* The constraint */
113019 if( !ExprHasProperty(pExpr, EP_OuterON) ) return 0; /* rule (4a) */
113020 if( pExpr->w.iJoin!=pSrc->iCursor ) return 0; /* rule (4b) */
113022 if( ExprHasProperty(pExpr, EP_OuterON) ) return 0; /* rule (5) */
113024 if( ExprHasProperty(pExpr, EP_OuterON|EP_InnerON) /* (6a) */
113029 if( pExpr->w.iJoin==pSrcList->a[jj].iCursor ){
113038 return sqlite3ExprIsTableConstant(pExpr, pSrc->iCursor, bAllowSubq);
113045 static int exprNodeIsConstantOrGroupBy(Walker *pWalker, Expr *pExpr){
113052 Expr *p = pGroupBy->a[i].pExpr;
113053 if( sqlite3ExprCompare(0, pExpr, p, -1)<2 ){
113062 if( ExprUseXSelect(pExpr) ){
113067 return exprNodeIsConstant(pWalker, pExpr);
113357 Expr *pRes = pEList->a[i].pExpr;
113512 if( sqlite3ExprCanBeNull(pEList->a[i].pExpr) ) break;
113530 assert( p->pEList->a[0].pExpr!=0 ); /* Because of isCandidateForInOpt(p) */
113541 if( nExpr==1 && pEList->a[0].pExpr->iColumn<0 ){
113562 int iCol = pEList->a[i].pExpr->iColumn;
113605 Expr *pRhs = pEList->a[i].pExpr;
113711 static char *exprINAffinity(Parse *pParse, const Expr *pExpr){
113712 Expr *pLeft = pExpr->pLeft;
113714 Select *pSelect = ExprUseXSelect(pExpr) ? pExpr->x.pSelect : 0;
113717 assert( pExpr->op==TK_IN );
113725 zRet[i] = sqlite3CompareAffinity(pSelect->pEList->a[i].pExpr, a);
113762 SQLITE_PRIVATE void sqlite3VectorErrorMsg(Parse *pParse, Expr *pExpr){
113764 if( ExprUseXSelect(pExpr) ){
113765 sqlite3SubselectError(pParse, pExpr->x.pSelect->pEList->nExpr, 1);
113781 Expr *pExpr, /* IN operator with RHS that we want to reuse */
113790 assert( pExpr->op==TK_IN );
113791 assert( !ExprUseYSub(pExpr) );
113792 assert( ExprUseXSelect(pExpr) );
113793 assert( pExpr->x.pSelect!=0 );
113794 assert( (pExpr->x.pSelect->selFlags & SF_All)==0 );
113807 pExpr->y.sub.iAddr = pSig->iAddr;
113808 pExpr->y.sub.regReturn = pSig->regReturn;
113809 pExpr->iTable = pSig->iTable;
113810 ExprSetProperty(pExpr, EP_Subrtn);
113842 Expr *pExpr, /* The IN operator */
113866 if( !ExprHasProperty(pExpr, EP_VarSelect) && pParse->iSelfTab==0 ){
113872 assert( !ExprUseXSelect(pExpr) || pExpr->x.pSelect!=0 );
113873 if( ExprUseXSelect(pExpr) && (pExpr->x.pSelect->selFlags & SF_All)==0 ){
113876 pSig->selId = pExpr->x.pSelect->selId;
113877 pSig->zAff = exprINAffinity(pParse, pExpr);
113885 if( ExprHasProperty(pExpr, EP_Subrtn)
113886 || findCompatibleInRhsSubrtn(pParse, pExpr, pSig)
113889 if( ExprUseXSelect(pExpr) ){
113891 pExpr->x.pSelect->selId));
113893 assert( ExprUseYSub(pExpr) );
113894 sqlite3VdbeAddOp2(v, OP_Gosub, pExpr->y.sub.regReturn,
113895 pExpr->y.sub.iAddr);
113896 assert( iTab!=pExpr->iTable );
113897 sqlite3VdbeAddOp2(v, OP_OpenDup, iTab, pExpr->iTable);
113907 assert( !ExprUseYWin(pExpr) );
113908 ExprSetProperty(pExpr, EP_Subrtn);
113909 assert( !ExprHasProperty(pExpr, EP_TokenOnly|EP_Reduced) );
113910 pExpr->y.sub.regReturn = ++pParse->nMem;
113911 pExpr->y.sub.iAddr =
113912 sqlite3VdbeAddOp2(v, OP_BeginSubrtn, 0, pExpr->y.sub.regReturn) + 1;
113915 pSig->iAddr = pExpr->y.sub.iAddr;
113916 pSig->regReturn = pExpr->y.sub.regReturn;
113925 pLeft = pExpr->pLeft;
113931 pExpr->iTable = iTab;
113932 addr = sqlite3VdbeAddOp2(v, OP_OpenEphemeral, pExpr->iTable, nVal);
113934 if( ExprUseXSelect(pExpr) ){
113935 VdbeComment((v, "Result of SELECT %u", pExpr->x.pSelect->selId));
113942 if( ExprUseXSelect(pExpr) ){
113948 Select *pSelect = pExpr->x.pSelect;
113963 dest.zAffSdst = exprINAffinity(pParse, pExpr);
113997 pParse, p, pEList->a[i].pExpr
114001 }else if( ALWAYS(pExpr->x.pList!=0) ){
114011 ExprList *pList = pExpr->x.pList;
114022 pKeyInfo->aColl[0] = sqlite3ExprCollSeq(pParse, pExpr->pLeft);
114029 Expr *pE2 = pItem->pExpr;
114039 ExprClearProperty(pExpr, EP_Subrtn);
114059 assert( ExprUseYSub(pExpr) );
114060 assert( sqlite3VdbeGetOp(v,pExpr->y.sub.iAddr-1)->opcode==OP_BeginSubrtn
114062 sqlite3VdbeAddOp3(v, OP_Return, pExpr->y.sub.regReturn,
114063 pExpr->y.sub.iAddr, 1);
114085 SQLITE_PRIVATE int sqlite3CodeSubselect(Parse *pParse, Expr *pExpr){
114099 testcase( pExpr->op==TK_EXISTS );
114100 testcase( pExpr->op==TK_SELECT );
114101 assert( pExpr->op==TK_EXISTS || pExpr->op==TK_SELECT );
114102 assert( ExprUseXSelect(pExpr) );
114103 pSel = pExpr->x.pSelect;
114107 if( ExprHasProperty(pExpr, EP_Subrtn) ){
114109 assert( ExprUseYSub(pExpr) );
114110 sqlite3VdbeAddOp2(v, OP_Gosub, pExpr->y.sub.regReturn,
114111 pExpr->y.sub.iAddr);
114112 return pExpr->iTable;
114116 assert( !ExprUseYWin(pExpr) );
114117 assert( !ExprHasProperty(pExpr, EP_Reduced|EP_TokenOnly) );
114118 ExprSetProperty(pExpr, EP_Subrtn);
114119 pExpr->y.sub.regReturn = ++pParse->nMem;
114120 pExpr->y.sub.iAddr =
114121 sqlite3VdbeAddOp2(v, OP_BeginSubrtn, 0, pExpr->y.sub.regReturn) + 1;
114133 if( !ExprHasProperty(pExpr, EP_VarSelect) ){
114150 nReg = pExpr->op==TK_SELECT ? pSel->pEList->nExpr : 1;
114153 if( pExpr->op==TK_SELECT ){
114183 pExpr->op2 = pExpr->op;
114184 pExpr->op = TK_ERROR;
114187 pExpr->iTable = rReg = dest.iSDParm;
114188 ExprSetVVAProperty(pExpr, EP_NoReduce);
114195 assert( ExprUseYSub(pExpr) );
114196 assert( sqlite3VdbeGetOp(v,pExpr->y.sub.iAddr-1)->opcode==OP_BeginSubrtn
114198 sqlite3VdbeAddOp3(v, OP_Return, pExpr->y.sub.regReturn,
114199 pExpr->y.sub.iAddr, 1);
114256 Expr *pExpr, /* The IN expression */
114279 assert( !ExprHasVVAProperty(pExpr,EP_Immutable) );
114280 pLeft = pExpr->pLeft;
114281 if( sqlite3ExprCheckIN(pParse, pExpr) ) return;
114282 zAff = exprINAffinity(pParse, pExpr);
114283 nVector = sqlite3ExprVectorSize(pExpr->pLeft);
114294 eType = sqlite3FindInIndex(pParse, pExpr,
114353 assert( ExprUseXList(pExpr) );
114354 pList = pExpr->x.pList;
114355 pColl = sqlite3ExprCollSeq(pParse, pExpr->pLeft);
114361 r2 = sqlite3ExprCodeTemp(pParse, pList->a[ii].pExpr, ®ToFree);
114362 if( regCkNull && sqlite3ExprCanBeNull(pList->a[ii].pExpr) ){
114404 Expr *p = sqlite3VectorFieldSubexpr(pExpr->pLeft, i);
114427 if( ExprHasProperty(pExpr, EP_Subrtn) ){
114428 const VdbeOp *pOp = sqlite3VdbeGetOp(v, pExpr->y.sub.iAddr);
114537 static void codeInteger(Parse *pParse, Expr *pExpr, int negFlag, int iMem){
114539 if( pExpr->flags & EP_IntValue ){
114540 int i = pExpr->u.iValue;
114547 const char *z = pExpr->u.zToken;
114552 sqlite3ErrorMsg(pParse, "oversized integer: %s%#T", negFlag?"-":"",pExpr);
114557 negFlag?"-":"",pExpr);
114587 sqlite3ExprCodeCopy(pParse, pIdx->aColExpr->a[iIdxCol].pExpr, regOut);
114718 SQLITE_PRIVATE void sqlite3ExprToRegister(Expr *pExpr, int iReg){
114719 Expr *p = sqlite3ExprSkipCollateAndLikely(pExpr);
114760 sqlite3ExprCodeFactorable(pParse, p->x.pList->a[i].pExpr, i+iResult);
114802 sqlite3ExprCode(pParse, pFarg->a[0].pExpr, target);
114806 sqlite3ExprCode(pParse, pFarg->a[i].pExpr, target);
114821 Expr *pArg = pFarg->a[0].pExpr;
114835 target = sqlite3ExprCodeTarget(pParse, pFarg->a[0].pExpr, target);
114848 sqlite3ExprCompare(0,pFarg->a[0].pExpr, pFarg->a[1].pExpr,-1),
114857 sqlite3ExprImpliesExpr(pParse,pFarg->a[0].pExpr, pFarg->a[1].pExpr,-1),
114866 pA1 = pFarg->a[1].pExpr;
114869 sqlite3ExprImpliesNonNullRow(pFarg->a[0].pExpr,pA1->iTable,1),
114886 aff = sqlite3ExprAffinity(pFarg->a[0].pExpr);
114915 static int exprNodeCanReturnSubtype(Walker *pWalker, Expr *pExpr){
114919 if( pExpr->op!=TK_FUNCTION ){
114922 assert( ExprUseXList(pExpr) );
114924 n = ALWAYS(pExpr->x.pList) ? pExpr->x.pList->nExpr : 0;
114925 pDef = sqlite3FindFunction(db, pExpr->u.zToken, n, ENC(db), 0);
114941 static int sqlite3ExprCanReturnSubtype(Parse *pParse, Expr *pExpr){
114946 sqlite3WalkExpr(&w, pExpr);
114959 Expr *pExpr, /* The expression to potentially bypass */
114972 if( sqlite3ExprCompare(0, pExpr, p->pExpr, iDataCur)!=0 ) continue;
114974 exprAff = sqlite3ExprAffinity(pExpr);
114988 if( ExprHasProperty(pExpr, EP_SubtArg)
114989 && sqlite3ExprCanReturnSubtype(pParse, pExpr)
115008 sqlite3ExprCode(pParse, pExpr, target);
115031 static int exprPartidxExprLookup(Parse *pParse, Expr *pExpr, int iTarget){
115034 if( pExpr->iColumn==p->iIdxCol && pExpr->iTable==p->iDataCur ){
115042 ret = sqlite3ExprCodeTarget(pParse, p->pExpr, iTarget);
115067 SQLITE_PRIVATE int sqlite3ExprCodeTarget(Parse *pParse, Expr *pExpr, int target){
115081 if( pExpr==0 ){
115084 && !ExprHasProperty(pExpr, EP_Leaf)
115085 && (r1 = sqlite3IndexedExprLookup(pParse, pExpr, target))>=0
115089 assert( !ExprHasVVAProperty(pExpr,EP_Immutable) );
115090 op = pExpr->op;
115095 AggInfo *pAggInfo = pExpr->pAggInfo;
115098 assert( pExpr->iAgg>=0 );
115099 if( pExpr->iAgg>=pAggInfo->nColumn ){
115111 pCol = &pAggInfo->aCol[pExpr->iAgg];
115113 return AggInfoColumnReg(pAggInfo, pExpr->iAgg);
115130 }else if( pExpr->y.pTab==0 ){
115133 sqlite3VdbeAddOp3(v, OP_Column, pExpr->iTable, pExpr->iColumn, target);
115140 int iTab = pExpr->iTable;
115142 if( ExprHasProperty(pExpr, EP_FixedCol) ){
115150 iReg = sqlite3ExprCodeTarget(pParse, pExpr->pLeft,target);
115151 assert( ExprUseYTab(pExpr) );
115152 assert( pExpr->y.pTab!=0 );
115153 aff = sqlite3TableColumnAffinity(pExpr->y.pTab, pExpr->iColumn);
115174 int iCol = pExpr->iColumn;
115175 assert( ExprUseYTab(pExpr) );
115176 pTab = pExpr->y.pTab;
115215 && 0!=(r1 = exprPartidxExprLookup(pParse, pExpr, target))
115219 assert( ExprUseYTab(pExpr) );
115220 assert( pExpr->y.pTab!=0 );
115221 iReg = sqlite3ExprCodeGetColumn(pParse, pExpr->y.pTab,
115222 pExpr->iColumn, iTab, target,
115223 pExpr->op2);
115227 codeInteger(pParse, pExpr, 0, target);
115231 sqlite3VdbeAddOp2(v, OP_Integer, sqlite3ExprTruthValue(pExpr), target);
115236 assert( !ExprHasProperty(pExpr, EP_IntValue) );
115237 codeReal(v, pExpr->u.zToken, 0, target);
115242 assert( !ExprHasProperty(pExpr, EP_IntValue) );
115243 sqlite3VdbeLoadString(v, target, pExpr->u.zToken);
115249 sqlite3VdbeAddOp3(v, OP_Null, 0, target, target + pExpr->y.nReg - 1);
115266 assert( !ExprHasProperty(pExpr, EP_IntValue) );
115267 assert( pExpr->u.zToken[0]=='x' || pExpr->u.zToken[0]=='X' );
115268 assert( pExpr->u.zToken[1]=='\'' );
115269 z = &pExpr->u.zToken[2];
115278 assert( !ExprHasProperty(pExpr, EP_IntValue) );
115279 assert( pExpr->u.zToken!=0 );
115280 assert( pExpr->u.zToken[0]!=0 );
115281 sqlite3VdbeAddOp2(v, OP_Variable, pExpr->iColumn, target);
115285 return pExpr->iTable;
115290 sqlite3ExprCode(pParse, pExpr->pLeft, target);
115292 assert( !ExprHasProperty(pExpr, EP_IntValue) );
115294 sqlite3AffinityType(pExpr->u.zToken, 0));
115309 Expr *pLeft = pExpr->pLeft;
115311 codeVectorCompare(pParse, pExpr, target, op, p5);
115314 r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, ®Free2);
115316 codeCompare(pParse, pLeft, pExpr->pRight, op, r1, r2,
115318 ExprHasProperty(pExpr,EP_Commuted));
115358 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1);
115359 r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, ®Free2);
115366 Expr *pLeft = pExpr->pLeft;
115373 assert( !ExprHasProperty(pExpr, EP_IntValue) );
115383 r2 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free2);
115393 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1);
115401 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1);
115403 isTrue = sqlite3ExprTruthValue(pExpr->pRight);
115404 bNormal = pExpr->op2==TK_IS;
115416 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1);
115426 AggInfo *pInfo = pExpr->pAggInfo;
115428 || NEVER(pExpr->iAgg<0)
115429 || NEVER(pExpr->iAgg>=pInfo->nFunc)
115431 assert( !ExprHasProperty(pExpr, EP_IntValue) );
115432 sqlite3ErrorMsg(pParse, "misuse of aggregate: %#T()", pExpr);
115434 return AggInfoFuncReg(pInfo, pExpr->iAgg);
115450 if( ExprHasProperty(pExpr, EP_WinFunc) ){
115451 return pExpr->y.pWin->regResult;
115456 && sqlite3ExprIsConstantNotJoin(pParse,pExpr)
115460 return sqlite3ExprCodeRunJustOnce(pParse, pExpr, -1);
115462 assert( !ExprHasProperty(pExpr, EP_TokenOnly) );
115463 assert( ExprUseXList(pExpr) );
115464 pFarg = pExpr->x.pList;
115466 assert( !ExprHasProperty(pExpr, EP_IntValue) );
115467 zId = pExpr->u.zToken;
115475 sqlite3ErrorMsg(pParse, "unknown function: %#T()", pExpr);
115484 sqlite3ExprFunctionUsable(pParse, pExpr, pDef);
115488 if( i<32 && sqlite3ExprIsConstant(pParse, pFarg->a[i].pExpr) ){
115493 pColl = sqlite3ExprCollSeq(pParse, pFarg->a[i].pExpr);
115512 assert( pFarg->a[0].pExpr!=0 );
115513 exprOp = pFarg->a[0].pExpr->op;
115522 pFarg->a[0].pExpr->op2 = pDef->funcFlags & OPFLAG_BYTELENARG;
115543 if( nFarg>=2 && ExprHasProperty(pExpr, EP_InfixFunc) ){
115544 pDef = sqlite3VtabOverloadFunction(db, pDef, nFarg, pFarg->a[1].pExpr);
115546 pDef = sqlite3VtabOverloadFunction(db, pDef, nFarg, pFarg->a[0].pExpr);
115554 pDef, pExpr->op2);
115573 && ALWAYS( ExprUseXSelect(pExpr) )
115574 && (nCol = pExpr->x.pSelect->pEList->nExpr)!=1
115578 return sqlite3CodeSubselect(pParse, pExpr);
115584 Expr *pLeft = pExpr->pLeft;
115591 if( pExpr->iTable!=n ){
115593 pExpr->iTable, n);
115595 return pLeft->iTable + pExpr->iColumn;
115601 sqlite3ExprCodeIN(pParse, pExpr, destIfFalse, destIfNull);
115623 exprCodeBetween(pParse, pExpr, target, 0, 0);
115627 if( !ExprHasProperty(pExpr, EP_Collate) ){
115634 assert( pExpr->pLeft );
115635 sqlite3ExprCode(pParse, pExpr->pLeft, target);
115639 pExpr = pExpr->pLeft;
115645 pExpr = pExpr->pLeft;
115679 assert( ExprUseYTab(pExpr) );
115680 pTab = pExpr->y.pTab;
115681 iCol = pExpr->iColumn;
115682 p1 = pExpr->iTable * (pTab->nCol+1) + 1
115685 assert( pExpr->iTable==0 || pExpr->iTable==1 );
115692 (pExpr->iTable ? "new" : "old"),
115693 (pExpr->iColumn<0 ? "rowid" : pExpr->y.pTab->aCol[iCol].zCnName)
115723 AggInfo *pAggInfo = pExpr->pAggInfo;
115725 assert( pExpr->iAgg>=0 && pExpr->iAgg<pAggInfo->nColumn );
115727 inReg = AggInfoColumnReg(pAggInfo, pExpr->iAgg);
115730 if( pExpr->pAggInfo->useSortingIdx ){
115732 pAggInfo->aCol[pExpr->iAgg].iSorterColumn,
115738 addrINR = sqlite3VdbeAddOp3(v, OP_IfNullRow, pExpr->iTable, 0, target);
115747 sqlite3ExprCode(pParse, pExpr->pLeft, target);
115788 assert( ExprUseXList(pExpr) && pExpr->x.pList!=0 );
115789 assert(pExpr->x.pList->nExpr > 0);
115790 pEList = pExpr->x.pList;
115794 if( (pX = pExpr->pLeft)!=0 ){
115816 opCompare.pRight = aListelem[i].pExpr;
115818 pTest = aListelem[i].pExpr;
115823 testcase( aListelem[i+1].pExpr->op==TK_COLUMN );
115824 sqlite3ExprCode(pParse, aListelem[i+1].pExpr, target);
115829 sqlite3ExprCode(pParse, pEList->a[nExpr-1].pExpr, target);
115840 assert( pExpr->affExpr==OE_Rollback
115841 || pExpr->affExpr==OE_Abort
115842 || pExpr->affExpr==OE_Fail
115843 || pExpr->affExpr==OE_Ignore
115850 if( pExpr->affExpr==OE_Abort ){
115853 assert( !ExprHasProperty(pExpr, EP_IntValue) );
115854 if( pExpr->affExpr==OE_Ignore ){
115858 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1);
115861 pExpr->affExpr, r1);
115891 Expr *pExpr, /* The expression to code when the VDBE initializes */
115903 && sqlite3ExprCompare(0,pItem->pExpr,pExpr,-1)==0
115909 pExpr = sqlite3ExprDup(pParse->db, pExpr, 0);
115910 if( pExpr!=0 && ExprHasProperty(pExpr, EP_HasFunc) ){
115918 sqlite3ExprCode(pParse, pExpr, regDest);
115921 sqlite3ExprDelete(pParse->db, pExpr);
115924 p = sqlite3ExprListAppend(pParse, p, pExpr);
115968 SQLITE_PRIVATE int sqlite3ExprCodeTemp(Parse *pParse, Expr *pExpr, int *pReg){
115970 pExpr = sqlite3ExprSkipCollateAndLikely(pExpr);
115972 && ALWAYS(pExpr!=0)
115973 && pExpr->op!=TK_REGISTER
115974 && sqlite3ExprIsConstantNotJoin(pParse, pExpr)
115977 r2 = sqlite3ExprCodeRunJustOnce(pParse, pExpr, -1);
115980 r2 = sqlite3ExprCodeTarget(pParse, pExpr, r1);
115996 SQLITE_PRIVATE void sqlite3ExprCode(Parse *pParse, Expr *pExpr, int target){
115999 assert( pExpr==0 || !ExprHasVVAProperty(pExpr,EP_Immutable) );
116003 inReg = sqlite3ExprCodeTarget(pParse, pExpr, target);
116006 Expr *pX = sqlite3ExprSkipCollateAndLikely(pExpr);
116007 testcase( pX!=pExpr );
116024 SQLITE_PRIVATE void sqlite3ExprCodeCopy(Parse *pParse, Expr *pExpr, int target){
116026 pExpr = sqlite3ExprDup(db, pExpr, 0);
116027 if( !db->mallocFailed ) sqlite3ExprCode(pParse, pExpr, target);
116028 sqlite3ExprDelete(db, pExpr);
116037 SQLITE_PRIVATE void sqlite3ExprCodeFactorable(Parse *pParse, Expr *pExpr, int target){
116038 if( pParse->okConstFactor && sqlite3ExprIsConstantNotJoin(pParse,pExpr) ){
116039 sqlite3ExprCodeRunJustOnce(pParse, pExpr, target);
116041 sqlite3ExprCodeCopy(pParse, pExpr, target);
116082 Expr *pExpr = pItem->pExpr;
116097 && sqlite3ExprIsConstantNotJoin(pParse,pExpr)
116099 sqlite3ExprCodeRunJustOnce(pParse, pExpr, target+i);
116101 int inReg = sqlite3ExprCodeTarget(pParse, pExpr, target+i);
116142 Expr *pExpr, /* The BETWEEN expression */
116158 assert( ExprUseXList(pExpr) );
116159 pDel = sqlite3ExprDup(db, pExpr->pLeft, 0);
116166 compLeft.pRight = pExpr->x.pList->a[0].pExpr;
116169 compRight.pRight = pExpr->x.pList->a[1].pExpr;
116212 SQLITE_PRIVATE void sqlite3ExprIfTrue(Parse *pParse, Expr *pExpr, int dest, int jumpIfNull){
116221 if( NEVER(pExpr==0) ) return; /* No way this can happen */
116222 assert( !ExprHasVVAProperty(pExpr, EP_Immutable) );
116223 op = pExpr->op;
116227 Expr *pAlt = sqlite3ExprSimplifiedAndOr(pExpr);
116228 if( pAlt!=pExpr ){
116233 sqlite3ExprIfFalse(pParse, pExpr->pLeft, d2,
116235 sqlite3ExprIfTrue(pParse, pExpr->pRight, dest, jumpIfNull);
116239 sqlite3ExprIfTrue(pParse, pExpr->pLeft, dest, jumpIfNull);
116240 sqlite3ExprIfTrue(pParse, pExpr->pRight, dest, jumpIfNull);
116246 sqlite3ExprIfFalse(pParse, pExpr->pLeft, dest, jumpIfNull);
116253 isNot = pExpr->op2==TK_ISNOT;
116254 isTrue = sqlite3ExprTruthValue(pExpr->pRight);
116258 sqlite3ExprIfTrue(pParse, pExpr->pLeft, dest,
116261 sqlite3ExprIfFalse(pParse, pExpr->pLeft, dest,
116279 if( sqlite3ExprIsVector(pExpr->pLeft) ) goto default_expr;
116281 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1);
116282 r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, ®Free2);
116283 codeCompare(pParse, pExpr->pLeft, pExpr->pRight, op,
116284 r1, r2, dest, jumpIfNull, ExprHasProperty(pExpr,EP_Commuted));
116303 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1);
116313 exprCodeBetween(pParse, pExpr, dest, sqlite3ExprIfTrue, jumpIfNull);
116320 sqlite3ExprCodeIN(pParse, pExpr, destIfFalse, destIfNull);
116328 if( ExprAlwaysTrue(pExpr) ){
116330 }else if( ExprAlwaysFalse(pExpr) ){
116333 r1 = sqlite3ExprCodeTemp(pParse, pExpr, ®Free1);
116355 SQLITE_PRIVATE void sqlite3ExprIfFalse(Parse *pParse, Expr *pExpr, int dest, int jumpIfNull){
116364 if( pExpr==0 ) return;
116365 assert( !ExprHasVVAProperty(pExpr,EP_Immutable) );
116385 op = ((pExpr->op+(TK_ISNULL&1))^1)-(TK_ISNULL&1);
116389 assert( pExpr->op!=TK_ISNULL || op==OP_NotNull );
116390 assert( pExpr->op!=TK_NOTNULL || op==OP_IsNull );
116391 assert( pExpr->op!=TK_NE || op==OP_Eq );
116392 assert( pExpr->op!=TK_EQ || op==OP_Ne );
116393 assert( pExpr->op!=TK_LT || op==OP_Ge );
116394 assert( pExpr->op!=TK_LE || op==OP_Gt );
116395 assert( pExpr->op!=TK_GT || op==OP_Le );
116396 assert( pExpr->op!=TK_GE || op==OP_Lt );
116398 switch( pExpr->op ){
116401 Expr *pAlt = sqlite3ExprSimplifiedAndOr(pExpr);
116402 if( pAlt!=pExpr ){
116404 }else if( pExpr->op==TK_AND ){
116406 sqlite3ExprIfFalse(pParse, pExpr->pLeft, dest, jumpIfNull);
116407 sqlite3ExprIfFalse(pParse, pExpr->pRight, dest, jumpIfNull);
116411 sqlite3ExprIfTrue(pParse, pExpr->pLeft, d2,
116413 sqlite3ExprIfFalse(pParse, pExpr->pRight, dest, jumpIfNull);
116420 sqlite3ExprIfTrue(pParse, pExpr->pLeft, dest, jumpIfNull);
116427 isNot = pExpr->op2==TK_ISNOT;
116428 isTrue = sqlite3ExprTruthValue(pExpr->pRight);
116433 sqlite3ExprIfFalse(pParse, pExpr->pLeft, dest,
116438 sqlite3ExprIfTrue(pParse, pExpr->pLeft, dest,
116445 testcase( pExpr->op==TK_IS );
116446 testcase( pExpr->op==TK_ISNOT );
116447 op = (pExpr->op==TK_IS) ? TK_NE : TK_EQ;
116456 if( sqlite3ExprIsVector(pExpr->pLeft) ) goto default_expr;
116458 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1);
116459 r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, ®Free2);
116460 codeCompare(pParse, pExpr->pLeft, pExpr->pRight, op,
116461 r1, r2, dest, jumpIfNull,ExprHasProperty(pExpr,EP_Commuted));
116478 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1);
116488 exprCodeBetween(pParse, pExpr, dest, sqlite3ExprIfFalse, jumpIfNull);
116494 sqlite3ExprCodeIN(pParse, pExpr, dest, dest);
116497 sqlite3ExprCodeIN(pParse, pExpr, dest, destIfNull);
116505 if( ExprAlwaysFalse(pExpr) ){
116507 }else if( ExprAlwaysTrue(pExpr) ){
116510 r1 = sqlite3ExprCodeTemp(pParse, pExpr, ®Free1);
116528 SQLITE_PRIVATE void sqlite3ExprIfFalseDup(Parse *pParse, Expr *pExpr, int dest,int jumpIfNull){
116530 Expr *pCopy = sqlite3ExprDup(db, pExpr, 0);
116556 const Expr *pExpr
116562 if( pExpr->op==TK_VARIABLE && pVar->iColumn==pExpr->iColumn ){
116566 sqlite3ValueFromExpr(pParse->db, pExpr, SQLITE_UTF8, SQLITE_AFF_BLOB, &pR);
116719 Expr *pExprA = pA->a[i].pExpr;
116720 Expr *pExprB = pB->a[i].pExpr;
116769 if( exprImpliesNotNull(pParse, pList->a[0].pExpr, pNN, iTab, 1)
116770 || exprImpliesNotNull(pParse, pList->a[1].pExpr, pNN, iTab, 1)
116820 static int sqlite3ExprIsNotTrue(Expr *pExpr){
116822 if( pExpr->op==TK_NULL ) return 1;
116823 if( pExpr->op==TK_TRUEFALSE && sqlite3ExprTruthValue(pExpr)==0 ) return 1;
116825 if( sqlite3ExprIsInteger(pExpr, &v, 0) && v==0 ) return 1;
116839 static int sqlite3ExprIsIIF(sqlite3 *db, const Expr *pExpr){
116841 if( pExpr->op==TK_FUNCTION ){
116842 const char *z = pExpr->u.zToken;
116845 if( pExpr->x.pList==0 ) return 0;
116846 pDef = sqlite3FindFunction(db, z, pExpr->x.pList->nExpr, ENC(db), 0);
116854 }else if( pExpr->op==TK_CASE ){
116855 if( pExpr->pLeft!=0 ) return 0;
116859 pList = pExpr->x.pList;
116862 if( pList->nExpr==3 && sqlite3ExprIsNotTrue(pList->a[2].pExpr) ) return 1;
116914 return sqlite3ExprImpliesExpr(pParse,pE1->x.pList->a[0].pExpr,pE2,iTab);
116946 static int impliesNotNullRow(Walker *pWalker, Expr *pExpr){
116947 testcase( pExpr->op==TK_AGG_COLUMN );
116948 testcase( pExpr->op==TK_AGG_FUNCTION );
116949 if( ExprHasProperty(pExpr, EP_OuterON) ) return WRC_Prune;
116950 if( ExprHasProperty(pExpr, EP_InnerON) && pWalker->mWFlags ){
116958 switch( pExpr->op ){
116967 testcase( pExpr->op==TK_ISNOT );
116968 testcase( pExpr->op==TK_ISNULL );
116969 testcase( pExpr->op==TK_NOTNULL );
116970 testcase( pExpr->op==TK_IS );
116971 testcase( pExpr->op==TK_VECTOR );
116972 testcase( pExpr->op==TK_FUNCTION );
116973 testcase( pExpr->op==TK_TRUTH );
116974 testcase( pExpr->op==TK_CASE );
116978 if( pWalker->u.iCur==pExpr->iTable ){
116993 testcase( pExpr->op==TK_OR );
116994 testcase( pExpr->op==TK_AND );
116995 bothImplyNotNullRow(pWalker, pExpr->pLeft, pExpr->pRight);
117003 if( ExprUseXList(pExpr) && ALWAYS(pExpr->x.pList->nExpr>0) ){
117004 sqlite3WalkExpr(pWalker, pExpr->pLeft);
117011 assert( ExprUseXList(pExpr) );
117012 assert( pExpr->x.pList->nExpr==2 );
117013 sqlite3WalkExpr(pWalker, pExpr->pLeft);
117014 bothImplyNotNullRow(pWalker, pExpr->x.pList->a[0].pExpr,
117015 pExpr->x.pList->a[1].pExpr);
117027 Expr *pLeft = pExpr->pLeft;
117028 Expr *pRight = pExpr->pRight;
117029 testcase( pExpr->op==TK_EQ );
117030 testcase( pExpr->op==TK_NE );
117031 testcase( pExpr->op==TK_LT );
117032 testcase( pExpr->op==TK_LE );
117033 testcase( pExpr->op==TK_GT );
117034 testcase( pExpr->op==TK_GE );
117116 static int exprIdxCover(Walker *pWalker, Expr *pExpr){
117117 if( pExpr->op==TK_COLUMN
117118 && pExpr->iTable==pWalker->u.pIdxCover->iCur
117119 && sqlite3TableColumnToIndex(pWalker->u.pIdxCover->pIdx, pExpr->iColumn)<0
117138 Expr *pExpr, /* The index to be tested */
117149 sqlite3WalkExpr(&w, pExpr);
117209 static int exprRefToSrcList(Walker *pWalker, Expr *pExpr){
117210 if( pExpr->op==TK_COLUMN
117211 || pExpr->op==TK_AGG_COLUMN
117218 if( pExpr->iTable==pSrc->a[i].iCursor ){
117223 for(i=0; i<p->nExclude && p->aiExclude[i]!=pExpr->iTable; i++){}
117246 SQLITE_PRIVATE int sqlite3ReferencesSrcList(Parse *pParse, Expr *pExpr, SrcList *pSrcList){
117258 assert( pExpr->op==TK_AGG_FUNCTION );
117259 assert( ExprUseXList(pExpr) );
117260 sqlite3WalkExprList(&w, pExpr->x.pList);
117261 if( pExpr->pLeft ){
117262 assert( pExpr->pLeft->op==TK_ORDER );
117263 assert( ExprUseXList(pExpr->pLeft) );
117264 assert( pExpr->pLeft->x.pList!=0 );
117265 sqlite3WalkExprList(&w, pExpr->pLeft->x.pList);
117268 if( ExprHasProperty(pExpr, EP_WinFunc) ){
117269 sqlite3WalkExpr(&w, pExpr->y.pWin->pFilter);
117293 static int agginfoPersistExprCb(Walker *pWalker, Expr *pExpr){
117294 if( ALWAYS(!ExprHasProperty(pExpr, EP_TokenOnly|EP_Reduced))
117295 && pExpr->pAggInfo!=0
117297 AggInfo *pAggInfo = pExpr->pAggInfo;
117298 int iAgg = pExpr->iAgg;
117302 if( pExpr->op!=TK_AGG_FUNCTION ){
117304 && pAggInfo->aCol[iAgg].pCExpr==pExpr
117306 pExpr = sqlite3ExprDup(db, pExpr, 0);
117307 if( pExpr && !sqlite3ExprDeferredDelete(pParse, pExpr) ){
117308 pAggInfo->aCol[iAgg].pCExpr = pExpr;
117312 assert( pExpr->op==TK_AGG_FUNCTION );
117314 && pAggInfo->aFunc[iAgg].pFExpr==pExpr
117316 pExpr = sqlite3ExprDup(db, pExpr, 0);
117317 if( pExpr && !sqlite3ExprDeferredDelete(pParse, pExpr) ){
117318 pAggInfo->aFunc[iAgg].pFExpr = pExpr;
117379 Expr *pExpr /* Expr describing the column to find or insert */
117389 if( pCol->pCExpr==pExpr ) return;
117390 if( pCol->iTable==pExpr->iTable
117391 && pCol->iColumn==pExpr->iColumn
117392 && pExpr->op!=TK_IF_NULL_ROW
117408 assert( ExprUseYTab(pExpr) );
117409 pCol->pTab = pExpr->y.pTab;
117410 pCol->iTable = pExpr->iTable;
117411 pCol->iColumn = pExpr->iColumn;
117413 pCol->pCExpr = pExpr;
117414 if( pAggInfo->pGroupBy && pExpr->op!=TK_IF_NULL_ROW ){
117420 Expr *pE = pTerm->pExpr;
117422 && pE->iTable==pExpr->iTable
117423 && pE->iColumn==pExpr->iColumn
117434 ExprSetVVAProperty(pExpr, EP_NoReduce);
117435 assert( pExpr->pAggInfo==0 || pExpr->pAggInfo==pAggInfo );
117436 pExpr->pAggInfo = pAggInfo;
117437 if( pExpr->op==TK_COLUMN ){
117438 pExpr->op = TK_AGG_COLUMN;
117440 assert( k <= SMXV(pExpr->iAgg) );
117441 pExpr->iAgg = (i16)k;
117449 static int analyzeAggregate(Walker *pWalker, Expr *pExpr){
117458 switch( pExpr->op ){
117468 if( sqlite3ExprCompare(0, pExpr, pIEpr->pExpr, iDataCur)==0 ) break;
117471 if( NEVER(!ExprUseYTab(pExpr)) ) break;
117476 if( NEVER(pExpr->pAggInfo!=0) ) break; /* Resolved by outer context */
117491 pAggInfo->aCol[tmp.iAgg].pCExpr = pExpr;
117492 pExpr->pAggInfo = pAggInfo;
117493 pExpr->iAgg = tmp.iAgg;
117499 testcase( pExpr->op==TK_AGG_COLUMN );
117500 testcase( pExpr->op==TK_COLUMN );
117501 testcase( pExpr->op==TK_IF_NULL_ROW );
117507 assert( !ExprHasProperty(pExpr, EP_TokenOnly|EP_Reduced) );
117508 if( pExpr->iTable==pItem->iCursor ){
117509 findOrCreateAggInfoColumn(pParse, pAggInfo, pExpr);
117518 && pWalker->walkerDepth==pExpr->op2
117519 && pExpr->pAggInfo==0
117528 if( NEVER(pItem->pFExpr==pExpr) ) break;
117529 if( sqlite3ExprCompare(0, pItem->pFExpr, pExpr, -1)==0 ){
117544 assert( !ExprHasProperty(pExpr, EP_xIsSelect) );
117546 pItem->pFExpr = pExpr;
117547 assert( ExprUseUToken(pExpr) );
117548 nArg = pExpr->x.pList ? pExpr->x.pList->nExpr : 0;
117550 pExpr->u.zToken, nArg, enc, 0);
117552 if( pExpr->pLeft
117559 assert( pExpr->pLeft->op==TK_ORDER );
117560 assert( ExprUseXList(pExpr->pLeft) );
117562 pOBList = pExpr->pLeft->x.pList;
117567 && sqlite3ExprCompare(0,pOBList->a[0].pExpr,
117568 pExpr->x.pList->a[0].pExpr,0)==0
117571 pItem->bOBUnique = ExprHasProperty(pExpr, EP_Distinct);
117580 if( ExprHasProperty(pExpr, EP_Distinct) && !pItem->bOBUnique ){
117589 assert( !ExprHasProperty(pExpr, EP_TokenOnly|EP_Reduced) );
117590 ExprSetVVAProperty(pExpr, EP_NoReduce);
117591 assert( i <= SMXV(pExpr->iAgg) );
117592 pExpr->iAgg = (i16)i;
117593 pExpr->pAggInfo = pAggInfo;
117612 SQLITE_PRIVATE void sqlite3ExprAnalyzeAggregates(NameContext *pNC, Expr *pExpr){
117621 sqlite3WalkExpr(&w, pExpr);
117635 sqlite3ExprAnalyzeAggregates(pNC, pItem->pExpr);
118581 static int renameUnmapExprCb(Walker *pWalker, Expr *pExpr){
118583 sqlite3RenameTokenRemap(pParse, 0, (const void*)pExpr);
118584 if( ExprUseYTab(pExpr) ){
118585 sqlite3RenameTokenRemap(pParse, 0, (const void*)&pExpr->y.pTab);
118679 SQLITE_PRIVATE void sqlite3RenameExprUnmap(Parse *pParse, Expr *pExpr){
118687 sqlite3WalkExpr(&sWalker, pExpr);
118780 static int renameColumnExprCb(Walker *pWalker, Expr *pExpr){
118782 if( pExpr->op==TK_TRIGGER
118783 && pExpr->iColumn==p->iCol
118786 renameTokenFind(pWalker->pParse, p, (void*)pExpr);
118787 }else if( pExpr->op==TK_COLUMN
118788 && pExpr->iColumn==p->iCol
118789 && ALWAYS(ExprUseYTab(pExpr))
118790 && p->pTab==pExpr->y.pTab
118792 renameTokenFind(pWalker->pParse, p, (void*)pExpr);
119364 Expr *pExpr = sqlite3ColumnExpr(sParse.pNewTable,
119366 sqlite3WalkExpr(&sWalker, pExpr);
119443 static int renameTableExprCb(Walker *pWalker, Expr *pExpr){
119445 if( pExpr->op==TK_COLUMN
119446 && ALWAYS(ExprUseYTab(pExpr))
119447 && p->pTab==pExpr->y.pTab
119449 renameTokenFind(pWalker->pParse, p, (void*)&pExpr->y.pTab);
119653 static int renameQuotefixExprCb(Walker *pWalker, Expr *pExpr){
119654 if( pExpr->op==TK_STRING && (pExpr->flags & EP_DblQuoted) ){
119655 renameTokenFind(pWalker->pParse, pWalker->u.pRename, (const void*)pExpr);
122150 static int resolveAttachExpr(NameContext *pName, Expr *pExpr)
122153 if( pExpr ){
122154 if( pExpr->op!=TK_ID ){
122155 rc = sqlite3ResolveExprNames(pName, pExpr);
122157 pExpr->op = TK_STRING;
122574 static int fixExprCb(Walker *p, Expr *pExpr){
122576 if( !pFix->bTemp ) ExprSetProperty(pExpr, EP_FromDDL);
122577 if( pExpr->op==TK_VARIABLE ){
122579 pExpr->op = TK_NULL;
122699 Expr *pExpr /* The expression to be fixed to one database */
122701 return sqlite3WalkExpr(&pFix->w, pExpr);
122878 Expr *pExpr, /* The expression to check authorization on */
122888 assert( pExpr->op==TK_COLUMN || pExpr->op==TK_TRIGGER );
122898 if( pExpr->op==TK_TRIGGER ){
122903 if( pExpr->iTable==pTabList->a[iSrc].iCursor ){
122909 iCol = pExpr->iColumn;
122923 pExpr->op = TK_NULL;
123251 sqlite3ExprCode(pParse, pEL->a[i].pExpr, pEL->a[i].u.iConstExprReg);
123679 Expr *pExpr /* The new default expression */
123689 pTab->u.tab.pDfltList = sqlite3ExprListAppend(pParse, pList, pExpr);
123691 sqlite3ExprDelete(pParse->db, pList->a[pCol->iDflt-1].pExpr);
123692 pList->a[pCol->iDflt-1].pExpr = pExpr;
123706 return pTab->u.tab.pDfltList->a[pCol->iDflt-1].pExpr;
124720 Expr *pExpr, /* The parsed expression of the default value */
124731 if( !sqlite3ExprIsConstantOrFunction(pExpr, isInit) ){
124748 x.pLeft = pExpr;
124756 sqlite3RenameExprUnmap(pParse, pExpr);
124758 sqlite3ExprDelete(db, pExpr);
124844 Expr *pCExpr = sqlite3ExprSkipCollate(pList->a[i].pExpr);
124863 Expr *pCExpr = sqlite3ExprSkipCollate(pList->a[0].pExpr);
124960 SQLITE_PRIVATE void sqlite3AddGenerated(Parse *pParse, Expr *pExpr, Token *pType){
124992 if( ALWAYS(pExpr) && pExpr->op==TK_ID ){
124997 pExpr = sqlite3PExpr(pParse, TK_UPLUS, pExpr, 0);
124999 if( pExpr && pExpr->op!=TK_RAISE ) pExpr->affExpr = pCol->affinity;
125000 sqlite3ColumnSetExpr(pParse, pTab, pCol, pExpr);
125001 pExpr = 0;
125008 sqlite3ExprDelete(pParse->db, pExpr);
125013 sqlite3ExprDelete(pParse->db, pExpr);
125388 sqlite3RenameTokenRemap(pParse, pList->a[0].pExpr, &pTab->iPKey);
125584 static int markImmutableExprStep(Walker *pWalker, Expr *pExpr){
125586 ExprSetVVAProperty(pExpr, EP_Immutable);
127138 Expr *pExpr = pList->a[i].pExpr;
127139 assert( pExpr!=0 );
127140 if( pExpr->op==TK_COLLATE ){
127141 assert( !ExprHasProperty(pExpr, EP_IntValue) );
127142 nExtra += (1 + sqlite3Strlen30(pExpr->u.zToken));
127202 sqlite3StringToId(pListItem->pExpr);
127203 sqlite3ResolveSelfReference(pParse, pTab, NC_IdxExpr, pListItem->pExpr, 0);
127205 pCExpr = sqlite3ExprSkipCollate(pListItem->pExpr);
127237 if( pListItem->pExpr->op==TK_COLLATE ){
127239 assert( !ExprHasProperty(pListItem->pExpr, EP_IntValue) );
127240 zColl = pListItem->pExpr->u.zToken;
132766 SQLITE_PRIVATE int sqlite3IsLikeFunction(sqlite3 *db, Expr *pExpr, int *pIsNocase, char *aWc){
132769 assert( pExpr!=0 );
132770 assert( pExpr->op==TK_FUNCTION );
132771 assert( ExprUseXList(pExpr) );
132772 if( !pExpr->x.pList ){
132775 nExpr = pExpr->x.pList->nExpr;
132776 assert( !ExprHasProperty(pExpr, EP_IntValue) );
132777 pDef = sqlite3FindFunction(db, pExpr->u.zToken, nExpr, SQLITE_UTF8, 0);
132797 Expr *pEscape = pExpr->x.pList->a[2].pExpr;
133804 Expr *pExpr;
133809 pExpr = sqlite3Expr(db, TK_REGISTER, 0);
133810 if( pExpr ){
133813 pExpr->iTable = regBase + sqlite3TableColumnToStorage(pTab,iCol) + 1;
133814 pExpr->affExpr = pCol->affinity;
133817 pExpr = sqlite3ExprAddCollateString(pParse, pExpr, zColl);
133819 pExpr->iTable = regBase;
133820 pExpr->affExpr = SQLITE_AFF_INTEGER;
133823 return pExpr;
133836 Expr *pExpr = sqlite3Expr(db, TK_COLUMN, 0);
133837 if( pExpr ){
133838 assert( ExprUseYTab(pExpr) );
133839 pExpr->y.pTab = pTab;
133840 pExpr->iTable = iCursor;
133841 pExpr->iColumn = iCol;
133843 return pExpr;
134916 aff = sqlite3ExprAffinity(pIdx->aColExpr->a[n].pExpr);
135080 static int exprColumnFlagUnion(Walker *pWalker, Expr *pExpr){
135081 if( pExpr->op==TK_COLUMN && pExpr->iColumn>=0 ){
135082 assert( pExpr->iColumn < pWalker->u.pTab->nCol );
135083 pWalker->eCode |= pWalker->u.pTab->aCol[pExpr->iColumn].colFlags;
135417 if( 0==sqlite3ExprIsConstant(pParse, pRow->a[ii].pExpr) ) return 0;
135430 Expr *pExpr = pRow->a[ii].pExpr;
135431 assert( pExpr->op!=TK_RAISE );
135432 assert( pExpr->affExpr==0 );
135433 if( 0!=sqlite3ExprAffinity(pExpr) ) return 0;
136241 Expr *pX = pList->a[k].pExpr;
136272 sqlite3ExprCode(pParse, pList->a[ipkColumn].pExpr, regCols);
136324 Expr *pIpk = pList->a[ipkColumn].pExpr;
136329 sqlite3ExprCode(pParse, pList->a[ipkColumn].pExpr, regRowid);
136500 static int checkConstraintExprNode(Walker *pWalker, Expr *pExpr){
136501 if( pExpr->op==TK_COLUMN ){
136502 assert( pExpr->iColumn>=0 || pExpr->iColumn==-1 );
136503 if( pExpr->iColumn>=0 ){
136504 if( pWalker->u.aiCol[pExpr->iColumn]>=0 ){
136530 Expr *pExpr, /* The expression to be checked */
136539 sqlite3WalkExpr(&w, pExpr);
136882 Expr *pExpr = pCheck->a[i].pExpr;
136884 && !sqlite3ExprReferencesUpdatedColumn(pExpr, aiChng, pkChng)
136896 pCopy = sqlite3ExprDup(db, pExpr, 0);
137244 sqlite3ExprCodeCopy(pParse, pIdx->aColExpr->a[i].pExpr, regIdx+i);
137778 if( sqlite3ExprCompare(0, pSrc->aColExpr->a[i].pExpr,
137779 pDest->aColExpr->a[i].pExpr, -1)!=0 ){
137894 assert( pEList->a[0].pExpr );
137895 if( pEList->a[0].pExpr->op!=TK_ASTERISK ){
142696 sqlite3ExprIfFalse(pParse, pCheck->a[k].pExpr, addrCkFault, 0);
142698 sqlite3ExprIfTrue(pParse, pCheck->a[0].pExpr, addrCkOk,
145290 sqlite3SetJoinExpr(p->x.pList->a[i].pExpr, iTable, joinFlag);
145328 unsetJoinExpr(p->x.pList->a[i].pExpr, iTable, nullable);
145794 CollSeq *pColl = sqlite3ExprCollSeq(pParse, pEList->a[i].pExpr);
145918 Expr *pExpr = pItem->pExpr;
145920 if( pExpr->op==TK_COLUMN
145921 && pExpr->iColumn>=0
145922 && ALWAYS( ExprUseYTab(pExpr) )
145923 && (pTab = pExpr->y.pTab)!=0
145925 && (pTab->aCol[pExpr->iColumn].colFlags & COLFLAG_SORTERREF)!=0
145929 if( pSort->aDefer[j].iCsr==pExpr->iTable ) break;
145945 pNew->iTable = pExpr->iTable;
145947 pNew->y.pTab = pExpr->y.pTab;
145952 pSort->aDefer[nDefer].pTab = pExpr->y.pTab;
145953 pSort->aDefer[nDefer].iCsr = pExpr->iTable;
146467 pInfo->aColl[i-iStart] = sqlite3ExprNNCollSeq(pParse, pItem->pExpr);
146664 sqlite3ExprCode(pParse, aOutEx[i].pExpr, regRow+i);
146774 Expr *pExpr
146776 Expr *pExpr,
146790 assert( pExpr!=0 );
146792 switch( pExpr->op ){
146800 int iCol = pExpr->iColumn; /* Index of column in pTab */
146803 for(j=0;j<pTabList->nSrc && pTabList->a[j].iCursor!=pExpr->iTable;j++);
146837 assert( pTab && ExprUseYTab(pExpr) && pExpr->y.pTab==pTab );
146851 Expr *p = pS->pEList->a[iCol].pExpr;
146895 assert( ExprUseXSelect(pExpr) );
146896 pS = pExpr->x.pSelect;
146897 p = pS->pEList->a[0].pExpr;
146935 Expr *p = pEList->a[i].pExpr;
147015 Expr *p = pEList->a[i].pExpr;
147113 Expr *pColExpr = sqlite3ExprSkipCollateAndLikely(pX->pExpr);
147223 p = a[i].pExpr;
147227 m |= sqlite3ExprDataType(pS2->pEList->a[i].pExpr);
147229 pCol->affinity = sqlite3ExprAffinity(pS2->pEList->a[i].pExpr);
147236 m |= sqlite3ExprDataType(pS2->pEList->a[i].pExpr);
147425 pRet = sqlite3ExprCollSeq(pParse, p->pEList->a[iCol].pExpr);
147448 Expr *pTerm = pItem->pExpr;
147456 pOrderBy->a[i].pExpr =
148733 Expr *pExpr /* Expr in which substitution occurs */
148735 if( pExpr==0 ) return 0;
148736 if( ExprHasProperty(pExpr, EP_OuterON|EP_InnerON)
148737 && pExpr->w.iJoin==pSubst->iTable
148739 testcase( ExprHasProperty(pExpr, EP_InnerON) );
148740 pExpr->w.iJoin = pSubst->iNewTable;
148742 if( pExpr->op==TK_COLUMN
148743 && pExpr->iTable==pSubst->iTable
148744 && !ExprHasProperty(pExpr, EP_FixedCol)
148747 if( pExpr->iColumn<0 ){
148748 pExpr->op = TK_NULL;
148756 iColumn = pExpr->iColumn;
148759 assert( pExpr->pRight==0 );
148760 pCopy = pSubst->pEList->a[iColumn].pExpr;
148780 return pExpr;
148796 pSubst->pCList->a[iColumn].pExpr
148805 if( ExprHasProperty(pExpr,EP_OuterON|EP_InnerON) ){
148806 sqlite3SetJoinExpr(pNew, pExpr->w.iJoin,
148807 pExpr->flags & (EP_OuterON|EP_InnerON));
148809 sqlite3ExprDelete(db, pExpr);
148810 pExpr = pNew;
148814 if( pExpr->op==TK_IF_NULL_ROW && pExpr->iTable==pSubst->iTable ){
148815 pExpr->iTable = pSubst->iNewTable;
148817 pExpr->pLeft = substExpr(pSubst, pExpr->pLeft);
148818 pExpr->pRight = substExpr(pSubst, pExpr->pRight);
148819 if( ExprUseXSelect(pExpr) ){
148820 substSelect(pSubst, pExpr->x.pSelect, 1);
148822 substExprList(pSubst, pExpr->x.pList);
148825 if( ExprHasProperty(pExpr, EP_WinFunc) ){
148826 Window *pWin = pExpr->y.pWin;
148833 return pExpr;
148842 pList->a[i].pExpr = substExpr(pSubst, pList->a[i].pExpr);
148882 static int recomputeColumnsUsedExpr(Walker *pWalker, Expr *pExpr){
148884 if( pExpr->op!=TK_COLUMN ) return WRC_Continue;
148886 if( pItem->iCursor!=pExpr->iTable ) return WRC_Continue;
148887 if( pExpr->iColumn<0 ) return WRC_Continue;
148888 pItem->colUsed |= sqlite3ExprColUsed(pExpr);
148960 static int renumberCursorsCb(Walker *pWalker, Expr *pExpr){
148961 int op = pExpr->op;
148963 renumberCursorDoMapping(pWalker, &pExpr->iTable);
148965 if( ExprHasProperty(pExpr, EP_OuterON) ){
148966 renumberCursorDoMapping(pWalker, &pExpr->w.iJoin);
149031 assert( pList->a[ii].pExpr!=0 );
149032 aff = sqlite3ExprAffinity(pList->a[ii].pExpr);
149036 assert( pSub1->pEList->a[ii].pExpr!=0 );
149037 if( sqlite3ExprAffinity(pSub1->pEList->a[ii].pExpr)!=aff ){
149685 Expr *pExpr /* Overall expression: COLUMN=VALUE or VALUE=COLUMN */
149693 if( !sqlite3IsBinary(sqlite3ExprCompareCollSeq(pConst->pParse,pExpr)) ){
149730 static void findConstInWhere(WhereConst *pConst, Expr *pExpr){
149732 if( NEVER(pExpr==0) ) return;
149733 if( ExprHasProperty(pExpr, pConst->mExcludeOn) ){
149734 testcase( ExprHasProperty(pExpr, EP_OuterON) );
149735 testcase( ExprHasProperty(pExpr, EP_InnerON) );
149738 if( pExpr->op==TK_AND ){
149739 findConstInWhere(pConst, pExpr->pRight);
149740 findConstInWhere(pConst, pExpr->pLeft);
149743 if( pExpr->op!=TK_EQ ) return;
149744 pRight = pExpr->pRight;
149745 pLeft = pExpr->pLeft;
149749 constInsert(pConst,pRight,pLeft,pExpr);
149752 constInsert(pConst,pLeft,pRight,pExpr);
149767 Expr *pExpr,
149772 if( pExpr->op!=TK_COLUMN ) return WRC_Continue;
149773 if( ExprHasProperty(pExpr, EP_FixedCol|pConst->mExcludeOn) ){
149774 testcase( ExprHasProperty(pExpr, EP_FixedCol) );
149775 testcase( ExprHasProperty(pExpr, EP_OuterON) );
149776 testcase( ExprHasProperty(pExpr, EP_InnerON) );
149781 if( pColumn==pExpr ) continue;
149782 if( pColumn->iTable!=pExpr->iTable ) continue;
149783 if( pColumn->iColumn!=pExpr->iColumn ) continue;
149790 ExprClearProperty(pExpr, EP_Leaf);
149791 ExprSetProperty(pExpr, EP_FixedCol);
149792 assert( pExpr->pLeft==0 );
149793 pExpr->pLeft = sqlite3ExprDup(pConst->pParse->db, pConst->apExpr[i*2+1], 0);
149816 static int propagateConstantExprRewrite(Walker *pWalker, Expr *pExpr){
149823 if( (pExpr->op>=TK_EQ && pExpr->op<=TK_GE)
149824 || pExpr->op==TK_IS
149826 propagateConstantExprRewriteOne(pConst, pExpr->pLeft, 0);
149828 if( sqlite3ExprAffinity(pExpr->pLeft)!=SQLITE_AFF_TEXT ){
149829 propagateConstantExprRewriteOne(pConst, pExpr->pRight, 0);
149833 return propagateConstantExprRewriteOne(pConst, pExpr, pConst->bHasAffBlob);
149949 static int pushDownWindowCheck(Parse *pParse, Select *pSubq, Expr *pExpr){
149953 return sqlite3ExprIsConstantOrGroupBy(pParse, pExpr, pSubq->pWin->pPartition);
150109 CollSeq *pColl = sqlite3ExprCollSeq(pParse, pList->a[ii].pExpr);
150280 Expr *pY = pX->pEList->a[j].pExpr;
150331 if( sqlite3ExprCanBeNull(pEList->a[0].pExpr) ){
150365 Expr *pExpr;
150382 pExpr = p->pEList->a[0].pExpr;
150383 assert( pExpr!=0 );
150384 if( pExpr->op!=TK_AGG_FUNCTION ) return 0;
150385 if( pExpr->pAggInfo!=pAggInfo ) return 0;
150387 assert( pAggInfo->aFunc[0].pFExpr==pExpr );
150388 testcase( ExprHasProperty(pExpr, EP_Distinct) );
150389 testcase( ExprHasProperty(pExpr, EP_WinFunc) );
150390 if( ExprHasProperty(pExpr, EP_Distinct|EP_WinFunc) ) return 0;
150468 if( a[i].pExpr->flags & EP_Collate ) break;
150895 Expr *pE, *pRight, *pExpr;
151033 pE = pEList->a[k].pExpr;
151053 pE = a[k].pExpr;
151062 pNew = sqlite3ExprListAppend(pParse, pNew, a[k].pExpr);
151068 a[k].pExpr = 0;
151202 pExpr = sqlite3PExpr(pParse, TK_DOT, pLeft, pRight);
151208 pExpr = sqlite3PExpr(pParse, TK_DOT, pLeft, pExpr);
151211 pExpr = pRight;
151213 sqlite3ExprSetErrorOffset(pExpr, iErrOfst);
151214 pNew = sqlite3ExprListAppend(pParse, pNew, pExpr);
151454 Expr *pExpr = pAggInfo->aFunc[i].pFExpr;
151455 assert( pExpr->op==TK_FUNCTION || pExpr->op==TK_AGG_FUNCTION );
151456 assert( ExprUseXList(pExpr) );
151457 sqlite3ExprAnalyzeAggList(pNC, pExpr->x.pList);
151458 if( pExpr->pLeft ){
151459 assert( pExpr->pLeft->op==TK_ORDER );
151460 assert( ExprUseXList(pExpr->pLeft) );
151461 sqlite3ExprAnalyzeAggList(pNC, pExpr->pLeft->x.pList);
151464 assert( !IsWindowFunc(pExpr) );
151465 if( ExprHasProperty(pExpr, EP_WinFunc) ){
151466 sqlite3ExprAnalyzeAggregates(pNC, pExpr->y.pWin->pFilter);
151509 sqlite3TreeViewExpr(0, pIEpr->pExpr, 0);
151522 static int aggregateIdxEprRefToColCallback(Walker *pWalker, Expr *pExpr){
151526 if( pExpr->pAggInfo==0 ) return WRC_Continue;
151527 if( pExpr->op==TK_AGG_COLUMN ) return WRC_Continue;
151528 if( pExpr->op==TK_AGG_FUNCTION ) return WRC_Continue;
151529 if( pExpr->op==TK_IF_NULL_ROW ) return WRC_Continue;
151530 pAggInfo = pExpr->pAggInfo;
151531 if( NEVER(pExpr->iAgg>=pAggInfo->nColumn) ) return WRC_Continue;
151532 assert( pExpr->iAgg>=0 );
151533 pCol = &pAggInfo->aCol[pExpr->iAgg];
151534 pExpr->op = TK_AGG_COLUMN;
151535 pExpr->iTable = pCol->iTable;
151536 pExpr->iColumn = pCol->iColumn;
151537 ExprClearProperty(pExpr, EP_Skip|EP_Collate|EP_Unlikely);
151854 pColl = sqlite3ExprCollSeq(pParse, pItem->pExpr);
151924 static int havingToWhereExprCb(Walker *pWalker, Expr *pExpr){
151925 if( pExpr->op!=TK_AND ){
151934 if( sqlite3ExprIsConstantOrGroupBy(pWalker->pParse, pExpr, pS->pGroupBy)
151935 && ExprAlwaysFalse(pExpr)==0
151936 && pExpr->pAggInfo==0
151942 SWAP(Expr, *pNew, *pExpr);
152060 Expr *pExpr;
152070 pExpr = p->pEList->a[0].pExpr;
152071 if( pExpr->op!=TK_AGG_FUNCTION ) return 0; /* Result is an aggregate */
152072 assert( ExprUseUToken(pExpr) );
152073 if( sqlite3_stricmp(pExpr->u.zToken,"count") ) return 0; /* Is count() */
152074 assert( ExprUseXList(pExpr) );
152075 if( pExpr->x.pList!=0 ) return 0; /* Must be count(*) */
152077 if( ExprHasProperty(pExpr, EP_WinFunc) ) return 0;/* Not a window function */
152099 pCount = pExpr;
152100 pExpr = 0;
152117 if( pExpr==0 ){
152118 pExpr = pTerm;
152120 pExpr = sqlite3PExpr(pParse, TK_PLUS, pTerm, pExpr);
152124 p->pEList->a[0].pExpr = pExpr;
152913 sqlite3ExprDelete(db, pEList->a[ii].pExpr);
152918 if( pEList->a[ii].fg.bUsed==0 ) pEList->a[ii].pExpr->op = TK_NULL;
153171 Expr *pExpr = pAggInfo->aFunc[0].pFExpr->x.pList->a[0].pExpr;
153172 pExpr = sqlite3ExprDup(db, pExpr, 0);
153174 pDistinct = sqlite3ExprListAppend(pParse, pDistinct, pExpr);
153343 sqlite3ExprCode(pParse, pGroupBy->a[j].pExpr, iBMem+j);
153347 Expr *pX = p->pEList->a[iOrderByCol-1].pExpr;
153637 Expr *pExpr = pAggInfo->aCol[i].pCExpr;
153638 if( pExpr==0 ) continue;
153639 assert( pExpr->pAggInfo==pAggInfo );
153640 assert( pExpr->iAgg==i );
153643 Expr *pExpr = pAggInfo->aFunc[i].pFExpr;
153644 assert( pExpr!=0 );
153645 assert( pExpr->pAggInfo==pAggInfo );
153646 assert( pExpr->iAgg==i );
154795 Expr *pOldExpr = pList->a[i].pExpr;
154827 static int sqlite3ReturningSubqueryVarSelect(Walker *NotUsed, Expr *pExpr){
154829 if( ExprUseXSelect(pExpr)
154830 && (pExpr->x.pSelect->selFlags & SF_Correlated)!=0
154832 testcase( ExprHasProperty(pExpr, EP_VarSelect) );
154833 ExprSetProperty(pExpr, EP_VarSelect);
154959 Expr *pCol = pNew->a[i].pExpr;
155545 assert( pIdx->aColExpr->a[iCol].pExpr!=0 );
155546 return sqlite3ExprReferencesUpdatedColumn(pIdx->aColExpr->a[iCol].pExpr,
155696 sqlite3ExprDup(db, pChanges->a[i].pExpr, 0)
155905 if( nChangeFrom==0 && sqlite3ResolveExprNames(&sNC, pChanges->a[i].pExpr) ){
155912 pRowidExpr = pChanges->a[i].pExpr;
155932 pRowidExpr = pChanges->a[i].pExpr;
156389 sqlite3ExprCode(pParse, pChanges->a[j].pExpr, k);
156681 pRow = sqlite3ExprDup(db, pChanges->a[aXRef[iPk]].pExpr, 0);
156691 sqlite3ExprDup(db, pChanges->a[aXRef[i]].pExpr, 0)
156717 sqlite3ExprCode(pParse, pChanges->a[aXRef[i]].pExpr, regArg+2+i);
156931 && (pTerm = pTarget->a[0].pExpr)->op==TK_COLUMN
156965 Expr *pExpr;
156971 pExpr = pIdx->aColExpr->a[ii].pExpr;
156972 if( pExpr->op!=TK_COLLATE ){
156973 sCol[0].pLeft = pExpr;
156974 pExpr = &sCol[0];
156979 pExpr = &sCol[0];
156982 if( sqlite3ExprCompare(0,pTarget->a[jj].pExpr,pExpr,iCursor)<2 ){
158710 Expr *pExpr /* First argument to the function */
158721 if( NEVER(pExpr==0) ) return pDef;
158722 if( pExpr->op!=TK_COLUMN ) return pDef;
158723 assert( ExprUseYTab(pExpr) );
158724 pTab = pExpr->y.pTab;
159229 Expr *pExpr; /* Pointer to the subexpression that is this term */
160022 && (pLevel->iLeftJoin==0 || ExprHasProperty(pTerm->pExpr, EP_OuterON))
160198 if( pLoop->aLTerm[i]->pExpr==pX ){
160202 if( NEVER(pOrigRhs->a[iField].pExpr==0) ){
160205 pRhs = sqlite3ExprListAppend(pParse, pRhs, pOrigRhs->a[iField].pExpr);
160206 pOrigRhs->a[iField].pExpr = 0;
160209 assert( pOrigLhs->a[iField].pExpr!=0 );
160210 pLhs = sqlite3ExprListAppend(pParse,pLhs,pOrigLhs->a[iField].pExpr);
160211 pOrigLhs->a[iField].pExpr = 0;
160226 Expr *p = pLhs->a[0].pExpr;
160227 pLhs->a[0].pExpr = 0;
160275 Expr *pX = pTerm->pExpr;
160296 if( pLoop->aLTerm[i] && pLoop->aLTerm[i]->pExpr==pX ){
160303 if( pLoop->aLTerm[i]->pExpr==pX ) nEq++;
160347 if( pLoop->aLTerm[i]->pExpr==pX ){
160410 Expr *pX = pTerm->pExpr;
160568 if( pTerm->pExpr->flags & EP_xIsSelect ){
160576 Expr *pRight = pTerm->pExpr->pRight;
160652 static int codeCursorHintCheckExpr(Walker *pWalker, Expr *pExpr){
160655 if( pExpr->op==TK_COLUMN
160656 && pExpr->iTable==pHint->iTabCur
160657 && sqlite3TableColumnToIndex(pHint->pIdx, pExpr->iColumn)<0
160679 static int codeCursorHintIsOrFunction(Walker *pWalker, Expr *pExpr){
160680 if( pExpr->op==TK_IS
160681 || pExpr->op==TK_ISNULL || pExpr->op==TK_ISNOT
160682 || pExpr->op==TK_NOTNULL || pExpr->op==TK_CASE
160685 }else if( pExpr->op==TK_FUNCTION ){
160688 if( 0==sqlite3IsLikeFunction(pWalker->pParse->db, pExpr, &d1, d2) ){
160714 static int codeCursorHintFixExpr(Walker *pWalker, Expr *pExpr){
160718 if( pExpr->op==TK_COLUMN ){
160719 if( pExpr->iTable!=pHint->iTabCur ){
160721 reg = sqlite3ExprCodeTarget(pWalker->pParse, pExpr, reg);
160722 pExpr->op = TK_REGISTER;
160723 pExpr->iTable = reg;
160725 pExpr->iTable = pHint->iIdxCur;
160726 pExpr->iColumn = sqlite3TableColumnToIndex(pHint->pIdx, pExpr->iColumn);
160727 assert( pExpr->iColumn>=0 );
160729 }else if( pExpr->pAggInfo ){
160732 reg = sqlite3ExprCodeTarget(pWalker->pParse, pExpr, reg);
160733 pExpr->op = TK_REGISTER;
160734 pExpr->iTable = reg;
160735 }else if( pExpr->op==TK_TRUEFALSE ){
160754 Expr *pExpr = 0;
160801 Expr *pExpr = pTerm->pExpr;
160802 if( !ExprHasProperty(pExpr, EP_OuterON)
160803 || pExpr->w.iJoin!=pTabItem->iCursor
160807 sqlite3WalkExpr(&sWalker, pTerm->pExpr);
160811 if( ExprHasProperty(pTerm->pExpr, EP_OuterON) ) continue;
160823 if( sqlite3ExprContainsSubquery(pTerm->pExpr) ) continue;
160830 sqlite3WalkExpr(&sWalker, pTerm->pExpr);
160835 pExpr = sqlite3ExprAnd(pParse, pExpr, sqlite3ExprDup(db, pTerm->pExpr, 0));
160837 if( pExpr!=0 ){
160839 if( pParse->nErr==0 ) sqlite3WalkExpr(&sWalker, pExpr);
160842 (const char*)pExpr, P4_EXPR);
160938 sqlite3ExprCode(pParse, pList->a[i].pExpr, iReg+i);
160966 Expr *pExpr;
160968 pExpr = pTerm->pExpr;
160969 if( sqlite3ExprCompare(0, pExpr, pTruth, iTabCur)==0 ){
161011 assert( pTerm->pExpr!=0 );
161183 sqlite3CodeRhsOfIN(pParse, pTerm->pExpr, iTab);
161190 Expr *pRight = pTerm->pExpr->pRight;
161258 Expr *pLeft = pTerm->pExpr->pLeft;
161264 pCompare->pLeft = pLeft->x.pList->a[iFld-1].pExpr;
161302 assert( pTerm->pExpr!=0 );
161360 pX = pStart->pExpr;
161394 pX = pEnd->pExpr;
161601 Expr *pRight = pRangeStart->pExpr->pRight;
161702 Expr *pRight = pRangeEnd->pExpr->pRight;
161981 Expr *pExpr = pWC->a[iTerm].pExpr;
161990 if( ExprHasProperty(pExpr, EP_Subquery) ) continue; /* tag-20220303a */
161991 pExpr = sqlite3ExprDup(db, pExpr, 0);
161992 pAndExpr = sqlite3ExprAnd(pParse, pAndExpr, pExpr);
162013 Expr *pOrExpr = pOrTerm->pExpr; /* Current OR clause term */
162229 pE = pTerm->pExpr;
162306 pE = pTerm->pExpr;
162321 && ExprUseXSelect(pAlt->pExpr)
162322 && (pAlt->pExpr->x.pSelect->pEList->nExpr>1)
162330 sEAlt = *pAlt->pExpr;
162417 assert( pTerm->pExpr );
162418 sqlite3ExprIfFalse(pParse, pTerm->pExpr, addrCont, SQLITE_JUMPIFNULL);
162494 if( ExprHasProperty(pTerm->pExpr, EP_OuterON|EP_InnerON) ) continue;
162496 sqlite3ExprDup(pParse->db, pTerm->pExpr, 0));
162628 pTerm->pExpr = sqlite3ExprSkipCollateAndLikely(p);
162659 static u16 exprCommute(Parse *pParse, Expr *pExpr){
162660 if( pExpr->pLeft->op==TK_VECTOR
162661 || pExpr->pRight->op==TK_VECTOR
162662 || sqlite3BinaryCompareCollSeq(pParse, pExpr->pLeft, pExpr->pRight) !=
162663 sqlite3BinaryCompareCollSeq(pParse, pExpr->pRight, pExpr->pLeft)
162665 pExpr->flags ^= EP_Commuted;
162667 SWAP(Expr*,pExpr->pRight,pExpr->pLeft);
162668 if( pExpr->op>=TK_GT ){
162673 assert( pExpr->op>=TK_GT && pExpr->op<=TK_GE );
162674 pExpr->op = ((pExpr->op-TK_GT)^2)+TK_GT;
162723 Expr *pExpr, /* Test this expression */
162739 if( !sqlite3IsLikeFunction(db, pExpr, pnoCase, (char*)wc) ){
162745 assert( ExprUseXList(pExpr) );
162746 pList = pExpr->x.pList;
162747 pLeft = pList->a[1].pExpr;
162749 pRight = sqlite3ExprSkipCollate(pList->a[0].pExpr);
162918 Expr *pExpr, /* Test this expression */
162923 if( pExpr->op==TK_FUNCTION ){
162937 assert( ExprUseXList(pExpr) );
162938 pList = pExpr->x.pList;
162950 pCol = pList->a[1].pExpr;
162954 assert( !ExprHasProperty(pExpr, EP_IntValue) );
162955 if( sqlite3StrICmp(pExpr->u.zToken, aOp[i].zOp)==0 ){
162957 *ppRight = pList->a[0].pExpr;
162974 pCol = pList->a[0].pExpr;
162985 assert( !ExprHasProperty(pExpr, EP_IntValue) );
162988 i = pMod->xFindFunction(pVtab,2, pExpr->u.zToken, &xNotUsed, &pNotUsed);
162991 *ppRight = pList->a[1].pExpr;
162997 }else if( pExpr->op>=TK_EQ ){
163004 }else if( pExpr->op==TK_NE || pExpr->op==TK_ISNOT || pExpr->op==TK_NOTNULL ){
163006 Expr *pLeft = pExpr->pLeft;
163007 Expr *pRight = pExpr->pRight;
163020 if( pExpr->op==TK_NE ) *peOp2 = SQLITE_INDEX_CONSTRAINT_NE;
163021 if( pExpr->op==TK_ISNOT ) *peOp2 = SQLITE_INDEX_CONSTRAINT_ISNOT;
163022 if( pExpr->op==TK_NOTNULL ) *peOp2 = SQLITE_INDEX_CONSTRAINT_ISNOTNULL;
163101 assert( pOne->pExpr->pLeft!=0 && pOne->pExpr->pRight!=0 );
163102 assert( pTwo->pExpr->pLeft!=0 && pTwo->pExpr->pRight!=0 );
163103 if( sqlite3ExprCompare(0,pOne->pExpr->pLeft, pTwo->pExpr->pLeft, -1) ) return;
163104 if( sqlite3ExprCompare(0,pOne->pExpr->pRight, pTwo->pExpr->pRight,-1) )return;
163115 pNew = sqlite3ExprDup(db, pOne->pExpr, 0);
163220 Expr *pExpr = pTerm->pExpr; /* The expression of the term */
163234 assert( pExpr->op==TK_OR );
163241 sqlite3WhereSplit(pOrWc, pExpr, TK_OR);
163269 sqlite3WhereSplit(pAndWC, pOrTerm->pExpr, TK_AND);
163274 assert( pAndTerm->pExpr );
163275 if( allowedOp(pAndTerm->pExpr->op)
163387 pLeft = pOrTerm->pExpr->pLeft;
163409 && sqlite3ExprCompare(pParse, pOrTerm->pExpr->pLeft, pLeft, -1)
163418 affRight = sqlite3ExprAffinity(pOrTerm->pExpr->pRight);
163419 affLeft = sqlite3ExprAffinity(pOrTerm->pExpr->pLeft);
163445 pDup = sqlite3ExprDup(db, pOrTerm->pExpr->pRight, 0);
163447 pLeft = pOrTerm->pExpr->pLeft;
163454 transferJoinMarkings(pNew, pExpr);
163486 static int termIsEquivalence(Parse *pParse, Expr *pExpr, SrcList *pSrc){
163490 if( pExpr->op!=TK_EQ && pExpr->op!=TK_IS ) return 0; /* (2) */
163491 if( ExprHasProperty(pExpr, EP_OuterON) ) return 0; /* (3) */
163493 if( pExpr->op==TK_IS
163499 aff1 = sqlite3ExprAffinity(pExpr->pLeft);
163500 aff2 = sqlite3ExprAffinity(pExpr->pRight);
163506 pColl = sqlite3ExprCompareCollSeq(pParse, pExpr);
163508 && !sqlite3ExprCollSeqMatch(pParse, pExpr->pLeft, pExpr->pRight)
163564 Expr *pExpr, /* An operand of a comparison operator */
163577 if( sqlite3ExprCompareSkip(pExpr,pIdx->aColExpr->a[i].pExpr,iCur)==0
163578 && !sqlite3ExprIsConstant(0,pIdx->aColExpr->a[i].pExpr)
163592 Expr *pExpr, /* An operand of a comparison operator */
163603 if( pExpr->op==TK_VECTOR && (op>=TK_GT && ALWAYS(op<=TK_GE)) ){
163604 assert( ExprUseXList(pExpr) );
163605 pExpr = pExpr->x.pList->a[0].pExpr;
163608 if( pExpr->op==TK_COLUMN ){
163609 aiCurCol[0] = pExpr->iTable;
163610 aiCurCol[1] = pExpr->iColumn;
163618 return exprMightBeIndexed2(pFrom,aiCurCol,pExpr,i);
163652 Expr *pExpr; /* The expression to be analyzed */
163671 pExpr = pTerm->pExpr;
163672 assert( pExpr!=0 ); /* Because malloc() has not failed */
163673 assert( pExpr->op!=TK_AS && pExpr->op!=TK_COLLATE );
163675 prereqLeft = sqlite3WhereExprUsage(pMaskSet, pExpr->pLeft);
163676 op = pExpr->op;
163678 assert( pExpr->pRight==0 );
163679 if( sqlite3ExprCheckIN(pParse, pExpr) ) return;
163680 if( ExprUseXSelect(pExpr) ){
163681 pTerm->prereqRight = exprSelectUsage(pMaskSet, pExpr->x.pSelect);
163683 pTerm->prereqRight = sqlite3WhereExprListUsage(pMaskSet, pExpr->x.pList);
163687 pTerm->prereqRight = sqlite3WhereExprUsage(pMaskSet, pExpr->pRight);
163688 if( pExpr->pLeft==0
163689 || ExprHasProperty(pExpr, EP_xIsSelect|EP_IfNullRow)
163690 || pExpr->x.pList!=0
163692 prereqAll = sqlite3WhereExprUsageNN(pMaskSet, pExpr);
163700 if( prereqAll!=sqlite3WhereExprUsageNN(pMaskSet, pExpr) ){
163702 sqlite3TreeViewExpr(0,pExpr,0);
163707 if( ExprHasProperty(pExpr, EP_OuterON|EP_InnerON) ){
163708 Bitmask x = sqlite3WhereGetMask(pMaskSet, pExpr->w.iJoin);
163709 if( ExprHasProperty(pExpr, EP_OuterON) ){
163728 ExprClearProperty(pExpr, EP_InnerON);
163737 Expr *pLeft = sqlite3ExprSkipCollate(pExpr->pLeft);
163738 Expr *pRight = sqlite3ExprSkipCollate(pExpr->pRight);
163745 pLeft = pLeft->x.pList->a[pTerm->u.x.iField-1].pExpr;
163765 pDup = sqlite3ExprDup(db, pExpr, 0);
163783 pDup = pExpr;
163796 && !ExprHasProperty(pExpr,EP_OuterON)
163799 assert( !ExprHasProperty(pExpr, EP_IntValue) );
163800 pExpr->op = TK_TRUEFALSE; /* See tag-20230504-1 */
163801 pExpr->u.zToken = "false";
163802 ExprSetProperty(pExpr, EP_IsFalse);
163824 else if( pExpr->op==TK_BETWEEN && pWC->op==TK_AND ){
163828 assert( ExprUseXList(pExpr) );
163829 pList = pExpr->x.pList;
163836 sqlite3ExprDup(db, pExpr->pLeft, 0),
163837 sqlite3ExprDup(db, pList->a[i].pExpr, 0));
163838 transferJoinMarkings(pNewExpr, pExpr);
163852 else if( pExpr->op==TK_OR ){
163864 else if( pExpr->op==TK_NOTNULL ){
163865 if( pExpr->pLeft->op==TK_COLUMN
163866 && pExpr->pLeft->iColumn>=0
163867 && !ExprHasProperty(pExpr, EP_OuterON)
163870 Expr *pLeft = pExpr->pLeft;
163909 else if( pExpr->op==TK_FUNCTION
163911 && isLikeOrGlob(pParse, pExpr, &pStr1, &isComplete, &noCase)
163922 assert( ExprUseXList(pExpr) );
163923 pLeft = pExpr->x.pList->a[1].pExpr;
163970 transferJoinMarkings(pNewExpr1, pExpr);
163977 transferJoinMarkings(pNewExpr2, pExpr);
164000 if( (pExpr->op==TK_EQ || pExpr->op==TK_IS)
164001 && (nLeft = sqlite3ExprVectorSize(pExpr->pLeft))>1
164002 && sqlite3ExprVectorSize(pExpr->pRight)==nLeft
164003 && ( (pExpr->pLeft->flags & EP_xIsSelect)==0
164004 || (pExpr->pRight->flags & EP_xIsSelect)==0)
164011 Expr *pLeft = sqlite3ExprForVectorField(pParse, pExpr->pLeft, i, nLeft);
164012 Expr *pRight = sqlite3ExprForVectorField(pParse, pExpr->pRight, i, nLeft);
164014 pNew = sqlite3PExpr(pParse, pExpr->op, pLeft, pRight);
164015 transferJoinMarkings(pNew, pExpr);
164033 else if( pExpr->op==TK_IN
164035 && pExpr->pLeft->op==TK_VECTOR
164036 && ALWAYS( ExprUseXSelect(pExpr) )
164037 && (pExpr->x.pSelect->pPrior==0 || (pExpr->x.pSelect->selFlags & SF_Values))
164039 && pExpr->x.pSelect->pWin==0
164044 for(i=0; i<sqlite3ExprVectorSize(pExpr->pLeft); i++){
164046 idxNew = whereClauseInsert(pWC, pExpr, TERM_VIRTUAL|TERM_SLICE);
164065 int res = isAuxiliaryVtabOperator(db, pExpr, &eOp2, &pLeft, &pRight);
164077 if( ExprHasProperty(pExpr, EP_OuterON) && pNewExpr ){
164079 pNewExpr->w.iJoin = pExpr->w.iJoin;
164129 SQLITE_PRIVATE void sqlite3WhereSplit(WhereClause *pWC, Expr *pExpr, u8 op){
164130 Expr *pE2 = sqlite3ExprSkipCollateAndLikely(pExpr);
164132 assert( pE2!=0 || pExpr==0 );
164135 whereClauseInsert(pWC, pExpr, 0);
164156 Expr *pExpr, /* Expression that defines the limit/offset */
164165 if( sqlite3ExprIsInteger(pExpr, &iVal, pParse) && iVal>=0 ){
164239 Expr *pExpr = pOrderBy->a[ii].pExpr;
164240 if( pExpr->op!=TK_COLUMN ) return;
164241 if( pExpr->iTable!=iCsr ) return;
164296 sqlite3ExprDelete(db, a->pExpr);
164388 mask |= sqlite3WhereExprUsage(pMaskSet, pList->a[i].pExpr);
164452 sqlite3ExprDup(pParse->db, pArgs->a[j].pExpr, 0), 0);
164792 Expr *pX = pTerm->pExpr;
164801 inexpr.pLeft = pX->pLeft->x.pList->a[iField].pExpr;
164803 inexpr.pRight = pX->x.pSelect->pEList->a[iField].pExpr;
164840 || sqlite3ExprCompareSkip(pTerm->pExpr->pLeft,
164842 && (pScan->iEquiv<=1 || !ExprHasProperty(pTerm->pExpr, EP_OuterON))
164846 && (pX = whereRightSubexprIsColumn(pTerm->pExpr))!=0
164866 pX = pTerm->pExpr;
164886 && (pX = pTerm->pExpr->pRight, ALWAYS(pX!=0))
164980 pScan->pIdxExpr = pIdx->aColExpr->a[j].pExpr;
165062 Expr *p = sqlite3ExprSkipCollateAndLikely(pList->a[i].pExpr);
165068 CollSeq *pColl = sqlite3ExprNNCollSeq(pParse, pList->a[i].pExpr);
165127 Expr *p = sqlite3ExprSkipCollateAndLikely(pDistinct->a[i].pExpr);
165307 testcase( ExprHasProperty(pTerm->pExpr, EP_OuterON) )
165308 testcase( ExprHasProperty(pTerm->pExpr, EP_InnerON) );
165309 if( !ExprHasProperty(pTerm->pExpr, EP_OuterON|EP_InnerON)
165310 || pTerm->pExpr->w.iJoin != pSrc->iCursor
165315 && NEVER(ExprHasProperty(pTerm->pExpr, EP_InnerON))
165390 if( !sqlite3IndexAffinityOk(pTerm->pExpr, aff) ) return 0;
165391 testcase( pTerm->pExpr->op==TK_IS );
165505 Expr *pExpr = pTerm->pExpr;
165510 && sqlite3ExprIsSingleTableConstraint(pExpr, pTabList, pLevel->iFrom, 0)
165513 sqlite3ExprDup(pParse->db, pExpr, 0));
165600 Expr *pX = pTerm->pExpr;
165801 Expr *pExpr = pTerm->pExpr;
165803 && sqlite3ExprIsSingleTableConstraint(pExpr, pTabList, iSrc, 0)
165805 sqlite3ExprIfFalse(pParse, pTerm->pExpr, addrCont, SQLITE_JUMPIFNULL);
165942 Expr *pExpr = pOrderBy->a[i].pExpr;
165946 if( sqlite3ExprIsConstant(0, pExpr) ){
165954 if( pExpr->op==TK_COLUMN && pExpr->iTable==pSrc->iCursor ){
165955 assert( pExpr->iColumn>=XN_ROWID && pExpr->iColumn<pTab->nCol );
165961 if( pExpr->op==TK_COLLATE
165962 && (pE2 = pExpr->pLeft)->op==TK_COLUMN
165966 assert( !ExprHasProperty(pExpr, EP_IntValue) );
165967 assert( pExpr->u.zToken!=0 );
165969 pExpr->iColumn = pE2->iColumn;
165973 if( sqlite3_stricmp(pExpr->u.zToken, zColl)==0 ) continue;
166058 && sqlite3ExprIsVector(pTerm->pExpr->pRight)
166073 Expr *pExpr = pOrderBy->a[i].pExpr;
166074 if( sqlite3ExprIsConstant(0, pExpr) ) continue;
166075 assert( pExpr->op==TK_COLUMN
166076 || (pExpr->op==TK_COLLATE && pExpr->pLeft->op==TK_COLUMN
166077 && pExpr->iColumn==pExpr->pLeft->iColumn) );
166078 pIdxOrderBy[j].iColumn = pExpr->iColumn;
166462 rc = sqlite3Stat4ValueFromExpr(pParse, pLower->pExpr->pRight, aff, &p1);
166466 rc = sqlite3Stat4ValueFromExpr(pParse, pUpper->pExpr->pRight, aff, &p2);
166628 Expr *pExpr = pLower->pExpr->pRight;
166629 rc = sqlite3Stat4ProbeSetValue(pParse, p, &pRec, pExpr, nBtm, nEq, &n);
166633 if( sqlite3ExprVectorSize(pExpr)>n ) mask = (WO_LE|WO_LT);
166645 Expr *pExpr = pUpper->pExpr->pRight;
166646 rc = sqlite3Stat4ProbeSetValue(pParse, p, &pRec, pExpr, nTop, nEq, &n);
166650 if( sqlite3ExprVectorSize(pExpr)>n ) mask = (WO_LE|WO_LT);
166737 Expr *pExpr, /* Expression for VALUE in the x=VALUE constraint */
166766 rc = sqlite3Stat4ProbeSetValue(pParse, p, &pRec, pExpr, 1, nEq-1, &bOk);
166815 rc = whereEqualScanEst(pParse, pBuilder, pList->a[i].pExpr, &nEst);
166844 if( ExprHasProperty(pTerm->pExpr, EP_OuterON) ) zType[2] = 'L';
166872 sqlite3TreeViewExpr(0, pTerm->pExpr, 0);
167475 Expr *pRight = pTerm->pExpr->pRight;
167477 testcase( pTerm->pExpr->op==TK_IS );
167520 int nCmp = sqlite3ExprVectorSize(pTerm->pExpr->pLeft);
167532 assert( ExprUseXList(pTerm->pExpr->pLeft) );
167533 pLhs = pTerm->pExpr->pLeft->x.pList->a[i].pExpr;
167534 pRhs = pTerm->pExpr->pRight;
167536 pRhs = pRhs->x.pSelect->pEList->a[i].pExpr;
167538 pRhs = pRhs->x.pList->a[i].pExpr;
167700 Expr *pExpr = pTerm->pExpr;
167701 if( ExprUseXSelect(pExpr) ){
167713 if( pNew->aLTerm[i] && pNew->aLTerm[i]->pExpr==pExpr ){
167728 }else if( ALWAYS(pExpr->x.pList && pExpr->x.pList->nExpr) ){
167730 nIn = sqlite3LogEst(pExpr->x.pList->nExpr);
167857 && ((eOp & WO_IN)==0 || ExprUseXList(pTerm->pExpr))
167860 Expr *pExpr = pTerm->pExpr;
167865 rc = whereEqualScanEst(pParse, pBuilder, pExpr->pRight, &nOut);
167867 rc = whereInScanEst(pParse, pBuilder, pExpr->x.pList, &nOut);
168041 Expr *pExpr = sqlite3ExprSkipCollateAndLikely(pOB->a[ii].pExpr);
168042 if( NEVER(pExpr==0) ) continue;
168043 if( (pExpr->op==TK_COLUMN || pExpr->op==TK_AGG_COLUMN)
168044 && pExpr->iTable==iCursor
168046 if( pExpr->iColumn<0 ) return 1;
168048 if( pExpr->iColumn==pIndex->aiColumn[jj] ) return 1;
168053 if( sqlite3ExprCompareSkip(pExpr,aColExpr->a[jj].pExpr,iCursor)==0 ){
168082 Expr *pExpr;
168083 pExpr = pTerm->pExpr;
168084 if( (!ExprHasProperty(pExpr, EP_OuterON) || pExpr->w.iJoin==iTab)
168085 && ((jointype & JT_OUTER)==0 || ExprHasProperty(pExpr, EP_OuterON))
168086 && sqlite3ExprImpliesExpr(pParse, pExpr, pWhere, iTab)
168087 && !sqlite3ExprImpliesExpr(pParse, pExpr, pWhere, -1)
168101 const Expr *pExpr,
168108 && sqlite3ExprCompare(0, pExpr, pIdx->aColExpr->a[i].pExpr, iTabCur)==0
168144 static int whereIsCoveringIndexWalkCallback(Walker *pWalk, Expr *pExpr){
168153 if( (pExpr->op==TK_COLUMN || pExpr->op==TK_AGG_COLUMN) ){
168155 if( pExpr->iTable!=pCk->iTabCur ) return WRC_Continue;
168160 if( aiColumn[i]==pExpr->iColumn ) return WRC_Continue;
168165 && exprIsCoveredByIndex(pExpr, pIdx, pWalk->u.pCovIdxCk->iTabCur) ){
168248 sqlite3ExprDelete(db, p->pExpr);
168312 p->pExpr = sqlite3ExprDup(db, pRight, 0);
168621 if( !sqlite3ExprCoveredByIndex(pTerm->pExpr, iCur, pProbe) ){
168917 Expr *pX = termFromWhereClause(pHidden->pWC, iTerm)->pExpr;
168967 pH->pParse->db, pTerm->pExpr->pRight, ENC(pH->pParse->db),
169437 pOBExpr = pOrderBy->a[iOB].pExpr;
169580 pOBExpr = sqlite3ExprSkipCollateAndLikely(pOrderBy->a[i].pExpr);
169598 CollSeq *pColl1 = sqlite3ExprNNCollSeq(pParse, pOrderBy->a[i].pExpr);
169599 CollSeq *pColl2 = sqlite3ExprCompareCollSeq(pParse, pTerm->pExpr);
169604 testcase( pTerm->pExpr->op==TK_IS );
169678 Expr *pX = pLoop->aLTerm[j]->pExpr;
169680 if( pLoop->aLTerm[i]->pExpr==pX ){
169722 pOBExpr = sqlite3ExprSkipCollateAndLikely(pOrderBy->a[i].pExpr);
169732 Expr *pIxExpr = pIndex->aColExpr->a[j].pExpr;
169738 pColl = sqlite3ExprNNCollSeq(pWInfo->pParse, pOrderBy->a[i].pExpr);
169797 p = pOrderBy->a[i].pExpr;
170748 static int exprNodeIsDeterministic(Walker *pWalker, Expr *pExpr){
170749 if( pExpr->op==TK_FUNCTION && ExprHasProperty(pExpr, EP_ConstFunc)==0 ){
170872 if( !ExprHasProperty(pTerm->pExpr, EP_OuterON)
170873 || pTerm->pExpr->w.iJoin!=pItem->iCursor
170879 && ExprHasProperty(pTerm->pExpr, EP_InnerON)
170880 && NEVER(pTerm->pExpr->w.iJoin==pItem->iCursor)
170982 Expr *pExpr;
170985 pExpr = pIdx->aColExpr->a[i].pExpr;
170987 pExpr = sqlite3ColumnExpr(pTab, &pTab->aCol[j]);
170991 if( sqlite3ExprIsConstant(0,pExpr) ) continue;
170998 if( sqlite3WhereTrace & 0x5000 ) sqlite3ShowExpr(pExpr);
171001 p->pExpr = sqlite3ExprDup(pParse->db, pExpr, 0);
171327 pX = pT->pExpr;
172046 if( sqlite3WhereTrace & 0x5000 ) sqlite3ShowExpr(p->pExpr);
172902 static int selectWindowRewriteExprCb(Walker *pWalker, Expr *pExpr){
172914 if( pExpr->op!=TK_COLUMN ){
172920 if( pExpr->iTable==p->pSrc->a[i].iCursor ) break;
172926 switch( pExpr->op ){
172929 if( !ExprHasProperty(pExpr, EP_WinFunc) ){
172934 if( pExpr->y.pWin==pWin ){
172935 assert( pWin->pOwner==pExpr );
172950 if( 0==sqlite3ExprCompare(0, p->pSub->a[i].pExpr, pExpr, -1) ){
172957 Expr *pDup = sqlite3ExprDup(pParse->db, pExpr, 0);
172962 int f = pExpr->flags & EP_Collate;
172963 assert( ExprHasProperty(pExpr, EP_Static)==0 );
172964 ExprSetProperty(pExpr, EP_Static);
172965 sqlite3ExprDelete(pParse->db, pExpr);
172966 ExprClearProperty(pExpr, EP_Static);
172967 memset(pExpr, 0, sizeof(Expr));
172969 pExpr->op = TK_COLUMN;
172970 pExpr->iColumn = (iCol<0 ? p->pSub->nExpr-1: iCol);
172971 pExpr->iTable = p->pWin->iEphCsr;
172972 pExpr->y.pTab = p->pTab;
172973 pExpr->flags = f;
173057 Expr *pDup = sqlite3ExprDup(db, pAppend->a[i].pExpr, 0);
173087 static int sqlite3WindowExtraAggFuncDepth(Walker *pWalker, Expr *pExpr){
173088 if( pExpr->op==TK_AGG_FUNCTION
173089 && pExpr->op2>=pWalker->walkerDepth
173091 pExpr->op2++;
173096 static int disallowAggregatesInOrderByCb(Walker *pWalker, Expr *pExpr){
173097 if( pExpr->op==TK_AGG_FUNCTION && pExpr->pAggInfo==0 ){
173098 assert( !ExprHasProperty(pExpr, EP_IntValue) );
173100 "misuse of aggregate: %s()", pExpr->u.zToken);
173319 static Expr *sqlite3WindowOffsetExpr(Parse *pParse, Expr *pExpr){
173320 if( 0==sqlite3ExprIsConstant(0,pExpr) ){
173321 if( IN_RENAME_OBJECT ) sqlite3RenameExprUnmap(pParse, pExpr);
173322 sqlite3ExprDelete(pParse->db, pExpr);
173323 pExpr = sqlite3ExprAlloc(pParse->db, TK_NULL, 0, 0);
173325 return pExpr;
173902 pColl = sqlite3ExprNNCollSeq(pParse, pWin->pOwner->x.pList->a[0].pExpr);
174367 pColl = sqlite3ExprNNCollSeq(pParse, pOrderBy->a[0].pExpr);
174593 static int windowExprGtZero(Parse *pParse, Expr *pExpr){
174597 sqlite3ValueFromExpr(db, pExpr, db->enc, SQLITE_AFF_NUMERIC, &pVal);
175344 struct FrameBound { int eType; Expr *pExpr; };
177788 sqlite3ExprDelete(pParse->db, (yypminor->yy205).pExpr);
179803 yymsp[-4].minor.yy590->flags |= pList->a[0].pExpr->flags & EP_Propagate;
179948 Expr *pRHS = yymsp[-1].minor.yy402->a[0].pExpr;
179950 yymsp[-1].minor.yy402->a[0].pExpr = 0;
180368 …yymsp[-2].minor.yy502, yymsp[-1].minor.yy205.eType, yymsp[-1].minor.yy205.pExpr, TK_CURRENT, 0, yy…
180374 …-3].minor.yy205.eType, yymsp[-3].minor.yy205.pExpr, yymsp[-1].minor.yy205.eType, yymsp[-1].minor.y…
180386 {yylhsminor.yy205.eType = yymsp[-1].major; yylhsminor.yy205.pExpr = 0;}
180390 {yylhsminor.yy205.eType = yymsp[0].major; yylhsminor.yy205.pExpr = yymsp[-1].minor.yy590;}
189042 Fts3Expr *pExpr; /* Parsed MATCH query string */
190862 sqlite3Fts3ExprFree(pCsr->pExpr);
192444 p->azColumn, p->bFts4, p->nColumn, iCol, zQuery, -1, &pCsr->pExpr,
192556 if( pCsr->pExpr ){
193302 Fts3Expr *pExpr, /* Allocate readers for this expression */
193307 if( pExpr && SQLITE_OK==*pRc ){
193308 if( pExpr->eType==FTSQUERY_PHRASE ){
193310 int nToken = pExpr->pPhrase->nToken;
193313 Fts3PhraseToken *pToken = &pExpr->pPhrase->aToken[i];
193322 assert( pExpr->pPhrase->iDoclistToken==0 );
193323 pExpr->pPhrase->iDoclistToken = -1;
193325 *pnOr += (pExpr->eType==FTSQUERY_OR);
193326 fts3EvalAllocateReaders(pCsr, pExpr->pLeft, pnToken, pnOr, pRc);
193327 fts3EvalAllocateReaders(pCsr, pExpr->pRight, pnToken, pnOr, pRc);
193967 Fts3Expr *pExpr, /* Expression to initialize phrases in */
193970 if( pExpr && SQLITE_OK==*pRc ){
193971 if( pExpr->eType==FTSQUERY_PHRASE ){
193972 int nToken = pExpr->pPhrase->nToken;
193976 if( pExpr->pPhrase->aToken[i].pDeferred==0 ) break;
193978 pExpr->bDeferred = (i==nToken);
193980 *pRc = fts3EvalPhraseStart(pCsr, 1, pExpr->pPhrase);
193982 fts3EvalStartReaders(pCsr, pExpr->pLeft, pRc);
193983 fts3EvalStartReaders(pCsr, pExpr->pRight, pRc);
193984 pExpr->bDeferred = (pExpr->pLeft->bDeferred && pExpr->pRight->bDeferred);
194021 Fts3Expr *pExpr, /* Expression to consider */
194027 if( pExpr->eType==FTSQUERY_PHRASE ){
194028 Fts3Phrase *pPhrase = pExpr->pPhrase;
194039 }else if( pExpr->eType!=FTSQUERY_NOT ){
194040 assert( pExpr->eType==FTSQUERY_OR
194041 || pExpr->eType==FTSQUERY_AND
194042 || pExpr->eType==FTSQUERY_NEAR
194044 assert( pExpr->pLeft && pExpr->pRight );
194045 if( pExpr->eType==FTSQUERY_OR ){
194046 pRoot = pExpr->pLeft;
194050 fts3EvalTokenCosts(pCsr, pRoot, pExpr->pLeft, ppTC, ppOr, pRc);
194051 if( pExpr->eType==FTSQUERY_OR ){
194052 pRoot = pExpr->pRight;
194056 fts3EvalTokenCosts(pCsr, pRoot, pExpr->pRight, ppTC, ppOr, pRc);
194273 fts3EvalAllocateReaders(pCsr, pCsr->pExpr, &nToken, &nOr, &rc);
194292 fts3EvalTokenCosts(pCsr, 0, pCsr->pExpr, &pTC, &ppOr, &rc);
194308 fts3EvalStartReaders(pCsr, pCsr->pExpr, &rc);
194424 Fts3Expr *pExpr, /* Expr. to advance to next matching row */
194427 if( *pRc==SQLITE_OK && pExpr->bEof==0 ){
194429 pExpr->bStart = 1;
194431 switch( pExpr->eType ){
194434 Fts3Expr *pLeft = pExpr->pLeft;
194435 Fts3Expr *pRight = pExpr->pRight;
194442 pExpr->iDocid = pRight->iDocid;
194443 pExpr->bEof = pRight->bEof;
194448 pExpr->iDocid = pLeft->iDocid;
194449 pExpr->bEof = pLeft->bEof;
194463 pExpr->iDocid = pLeft->iDocid;
194464 pExpr->bEof = (pLeft->bEof || pRight->bEof);
194465 if( pExpr->eType==FTSQUERY_NEAR && pExpr->bEof ){
194488 Fts3Expr *pLeft = pExpr->pLeft;
194489 Fts3Expr *pRight = pExpr->pRight;
194504 pExpr->bEof = (pLeft->bEof && pRight->bEof);
194507 pExpr->iDocid = pLeft->iDocid;
194509 pExpr->iDocid = pRight->iDocid;
194516 Fts3Expr *pLeft = pExpr->pLeft;
194517 Fts3Expr *pRight = pExpr->pRight;
194533 pExpr->iDocid = pLeft->iDocid;
194534 pExpr->bEof = pLeft->bEof;
194539 Fts3Phrase *pPhrase = pExpr->pPhrase;
194541 *pRc = fts3EvalPhraseNext(pCsr, pPhrase, &pExpr->bEof);
194542 pExpr->iDocid = pPhrase->doclist.iDocid;
194564 static int fts3EvalNearTest(Fts3Expr *pExpr, int *pRc){
194588 && pExpr->eType==FTSQUERY_NEAR
194589 && (pExpr->pParent==0 || pExpr->pParent->eType!=FTSQUERY_NEAR)
194596 for(p=pExpr; p->pLeft; p=p->pLeft){
194615 aPoslist = pExpr->pRight->pPhrase->doclist.pList;
194616 nToken = pExpr->pRight->pPhrase->nToken;
194617 for(p=pExpr->pLeft; p && res; p=p->pLeft){
194648 Fts3Expr *pExpr, /* Expr to test. May or may not be root. */
194653 switch( pExpr->eType ){
194657 fts3EvalTestExpr(pCsr, pExpr->pLeft, pRc)
194658 && fts3EvalTestExpr(pCsr, pExpr->pRight, pRc)
194659 && fts3EvalNearTest(pExpr, pRc)
194678 && pExpr->eType==FTSQUERY_NEAR
194679 && (pExpr->pParent==0 || pExpr->pParent->eType!=FTSQUERY_NEAR)
194682 for(p=pExpr; p->pPhrase==0; p=p->pLeft){
194695 int bHit1 = fts3EvalTestExpr(pCsr, pExpr->pLeft, pRc);
194696 int bHit2 = fts3EvalTestExpr(pCsr, pExpr->pRight, pRc);
194703 fts3EvalTestExpr(pCsr, pExpr->pLeft, pRc)
194704 && !fts3EvalTestExpr(pCsr, pExpr->pRight, pRc)
194710 if( pCsr->pDeferred && (pExpr->bDeferred || (
194711 pExpr->iDocid==pCsr->iPrevId && pExpr->pPhrase->doclist.pList
194713 Fts3Phrase *pPhrase = pExpr->pPhrase;
194714 if( pExpr->bDeferred ){
194719 pExpr->iDocid = pCsr->iPrevId;
194724 pExpr->bEof==0 && pExpr->iDocid==pCsr->iPrevId
194725 && pExpr->pPhrase->doclist.nList>0
194776 bMiss = (0==fts3EvalTestExpr(pCsr, pCsr->pExpr, &rc));
194791 Fts3Expr *pExpr = pCsr->pExpr;
194793 if( pExpr==0 ){
194801 fts3EvalNextRow(pCsr, pExpr, &rc);
194802 pCsr->isEof = pExpr->bEof;
194805 pCsr->iPrevId = pExpr->iDocid;
194832 Fts3Expr *pExpr,
194835 if( pExpr && *pRc==SQLITE_OK ){
194836 Fts3Phrase *pPhrase = pExpr->pPhrase;
194856 pExpr->iDocid = 0;
194857 pExpr->bEof = 0;
194858 pExpr->bStart = 0;
194860 fts3EvalRestart(pCsr, pExpr->pLeft, pRc);
194861 fts3EvalRestart(pCsr, pExpr->pRight, pRc);
194870 SQLITE_PRIVATE int sqlite3Fts3MsrCancel(Fts3Cursor *pCsr, Fts3Expr *pExpr){
194872 if( pExpr->bEof==0 ){
194873 i64 iDocid = pExpr->iDocid;
194874 fts3EvalRestart(pCsr, pExpr, &rc);
194875 while( rc==SQLITE_OK && pExpr->iDocid!=iDocid ){
194876 fts3EvalNextRow(pCsr, pExpr, &rc);
194877 if( pExpr->bEof ) rc = FTS_CORRUPT_VTAB;
194891 static void fts3EvalUpdateCounts(Fts3Expr *pExpr, int nCol){
194892 if( pExpr ){
194893 Fts3Phrase *pPhrase = pExpr->pPhrase;
194909 pExpr->aMI[iCol*3 + 1] += iCnt;
194910 pExpr->aMI[iCol*3 + 2] += (iCnt>0);
194917 fts3EvalUpdateCounts(pExpr->pLeft, nCol);
194918 fts3EvalUpdateCounts(pExpr->pRight, nCol);
194927 static int fts3AllocateMSI(Fts3Expr *pExpr, int iPhrase, void *pCtx){
194930 if( pExpr->aMI==0 ){
194931 pExpr->aMI = (u32 *)sqlite3_malloc64(pTab->nColumn * 3 * sizeof(u32));
194932 if( pExpr->aMI==0 ) return SQLITE_NOMEM;
194934 memset(pExpr->aMI, 0, pTab->nColumn * 3 * sizeof(u32));
194951 Fts3Expr *pExpr /* FTSQUERY_PHRASE expression */
194955 assert( pExpr->eType==FTSQUERY_PHRASE );
194956 if( pExpr->aMI==0 ){
194965 pRoot = pExpr;
195058 Fts3Expr *pExpr, /* Phrase expression */
195065 if( pExpr->bDeferred && pExpr->pParent->eType!=FTSQUERY_NEAR ){
195072 rc = fts3EvalGatherStats(pCsr, pExpr);
195074 assert( pExpr->aMI );
195076 aiOut[iCol*3 + 1] = pExpr->aMI[iCol*3 + 1];
195077 aiOut[iCol*3 + 2] = pExpr->aMI[iCol*3 + 2];
195106 Fts3Expr *pExpr, /* Phrase to return doclist for */
195110 Fts3Phrase *pPhrase = pExpr->pPhrase;
195124 iDocid = pExpr->iDocid;
195126 if( iDocid!=pCsr->iPrevId || pExpr->bEof ){
195141 pNear = pExpr;
195142 for(p=pExpr->pParent; p; p=p->pParent){
196996 static char *exprToString(Fts3Expr *pExpr, char *zBuf){
196997 if( pExpr==0 ){
197000 switch( pExpr->eType ){
197002 Fts3Phrase *pPhrase = pExpr->pPhrase;
197016 zBuf = sqlite3_mprintf("%zNEAR/%d ", zBuf, pExpr->nNear);
197030 if( zBuf ) zBuf = exprToString(pExpr->pLeft, zBuf);
197033 if( zBuf ) zBuf = exprToString(pExpr->pRight, zBuf);
197066 Fts3Expr *pExpr;
197106 pTokenizer, 0, azCol, 0, nCol, nCol, zExpr, nExpr, &pExpr, &zDummy
197108 assert( rc==SQLITE_OK || pExpr==0 );
197112 pTokenizer, 0, azCol, 0, nCol, nCol, zExpr, nExpr, &pExpr
197118 }else if( rc==SQLITE_NOMEM || !(zBuf = exprToString(pExpr, 0)) ){
197125 sqlite3Fts3ExprFree(pExpr);
205529 Fts3Expr *pExpr, /* Expression to iterate phrases of */
205535 int eType = pExpr->eType; /* Type of expression node pExpr */
205538 assert( pExpr->pLeft && pExpr->pRight );
205539 rc = fts3ExprIterate2(pExpr->pLeft, piPhrase, x, pCtx);
205541 rc = fts3ExprIterate2(pExpr->pRight, piPhrase, x, pCtx);
205544 rc = x(pExpr, *piPhrase, pCtx);
205561 Fts3Expr *pExpr, /* Expression to iterate phrases of */
205566 return fts3ExprIterate2(pExpr, &iPhrase, x, pCtx);
205574 static int fts3ExprLoadDoclistsCb(Fts3Expr *pExpr, int iPhrase, void *ctx){
205576 Fts3Phrase *pPhrase = pExpr->pPhrase;
205605 rc = sqlite3Fts3ExprIterate(pCsr->pExpr,fts3ExprLoadDoclistsCb,(void*)&sCtx);
205611 static int fts3ExprPhraseCountCb(Fts3Expr *pExpr, int iPhrase, void *ctx){
205613 pExpr->iPhrase = iPhrase;
205616 static int fts3ExprPhraseCount(Fts3Expr *pExpr){
205618 (void)sqlite3Fts3ExprIterate(pExpr, fts3ExprPhraseCountCb, (void *)&nPhrase);
205751 static int fts3SnippetFindPositions(Fts3Expr *pExpr, int iPhrase, void *ctx){
205757 pPhrase->nToken = pExpr->pPhrase->nToken;
205758 rc = sqlite3Fts3EvalPhrasePoslist(p->pCsr, pExpr, p->iCol, &pCsr);
205840 pCsr->pExpr, fts3SnippetFindPositions, (void*)&sIter
206147 Fts3Expr *pExpr, /* Phrase expression node */
206152 Fts3Phrase *pPhrase = pExpr->pPhrase;
206158 iStart = pExpr->iPhrase * p->nCol;
206160 iStart = pExpr->iPhrase * ((p->nCol + 31) / 32);
206185 Fts3Expr *pExpr,
206189 assert( (pExpr->pLeft==0)==(pExpr->pRight==0) );
206190 if( pExpr->bEof==0 && pExpr->iDocid==p->pCursor->iPrevId ){
206191 if( pExpr->pLeft ){
206192 rc = fts3ExprLHitGather(pExpr->pLeft, p);
206193 if( rc==SQLITE_OK ) rc = fts3ExprLHitGather(pExpr->pRight, p);
206195 rc = fts3ExprLHits(pExpr, p);
206229 Fts3Expr *pExpr, /* Phrase expression node */
206235 p->pCursor, pExpr, &p->aMatchinfo[3*iPhrase*p->nCol]
206245 Fts3Expr *pExpr, /* Phrase expression node */
206256 rc = sqlite3Fts3EvalPhrasePoslist(p->pCursor, pExpr, i, &pCsr);
206367 Fts3Expr *pExpr; /* Pointer to phrase expression */
206380 Fts3Expr *pExpr, /* Phrase expression node */
206385 aIter[iPhrase].pExpr = pExpr;
206436 (void)sqlite3Fts3ExprIterate(pCsr->pExpr, fts3MatchinfoLcsCb, (void*)aIter);
206440 nToken -= pIter->pExpr->pPhrase->nToken;
206450 rc = sqlite3Fts3EvalPhrasePoslist(pCsr, pIt->pExpr, iCol, &pIt->pRead);
206598 rc = fts3ExprLHitGather(pCsr->pExpr, pInfo);
206603 Fts3Expr *pExpr;
206605 pExpr = pCsr->pExpr;
206613 rc = sqlite3Fts3ExprIterate(pExpr, fts3ExprGlobalHitsCb,(void*)pInfo);
206617 (void)sqlite3Fts3ExprIterate(pExpr, fts3ExprLocalHitsCb,(void*)pInfo);
206669 pCsr->nPhrase = fts3ExprPhraseCount(pCsr->pExpr);
206745 if( !pCsr->pExpr ){
206842 static int fts3ExprTermOffsetInit(Fts3Expr *pExpr, int iPhrase, void *ctx){
206851 rc = sqlite3Fts3EvalPhrasePoslist(p->pCsr, pExpr, p->iCol, &pList);
206852 nTerm = pExpr->pPhrase->nToken;
206873 static int fts3ExprRestartIfCb(Fts3Expr *pExpr, int iPhrase, void *ctx){
206877 if( pExpr->pPhrase && pExpr->pPhrase->bIncr ){
206878 rc = sqlite3Fts3MsrCancel(p->pCsr, pExpr);
206879 pExpr->pPhrase->bIncr = 0;
206899 if( !pCsr->pExpr ){
206923 rc = sqlite3Fts3ExprIterate(pCsr->pExpr, fts3ExprRestartIfCb, (void*)&sCtx);
206945 pCsr->pExpr, fts3ExprTermOffsetInit, (void*)&sCtx
207047 if( !pCsr->pExpr ){
220034 URegularExpression *pExpr = (URegularExpression *)p;
220035 uregex_close(pExpr);
220059 URegularExpression *pExpr;
220072 pExpr = sqlite3_get_auxdata(p, 0);
220073 if( !pExpr ){
220078 pExpr = uregex_open(zPattern, -1, 0, 0, &status);
220081 sqlite3_set_auxdata(p, 0, pExpr, icuRegexpDelete);
220082 pExpr = sqlite3_get_auxdata(p, 0);
220084 if( !pExpr ){
220091 uregex_setText(pExpr, zString, -1, &status);
220098 res = uregex_matches(pExpr, 0, &status);
220109 uregex_setText(pExpr, 0, 0, &status);
240542 Fts5ExprNode *pExpr; /* Result of a successful parse */
240685 assert( sParse.pExpr || sParse.rc!=SQLITE_OK );
240686 assert_expr_depth_ok(sParse.rc, sParse.pExpr);
240696 sqlite3Fts5ParseSetColset(&sParse, sParse.pExpr, pColset);
240705 sqlite3Fts5ParseNodeFree(sParse.pExpr);
240707 pNew->pRoot = sParse.pExpr;
240716 sqlite3Fts5ParseNodeFree(sParse.pExpr);
241285 Fts5Expr *pExpr, /* Expression that pNear is a part of */
241291 if( pExpr->pConfig->eDetail!=FTS5_DETAIL_FULL ){
241343 Fts5Expr *pExpr,
241369 pExpr->pIndex, p->pTerm, p->nQueryTerm,
241371 (pExpr->bDesc ? FTS5INDEX_QUERY_DESC : 0),
241405 Fts5Expr *pExpr,
241409 assert( pExpr->bDesc==0 || pExpr->bDesc==1 );
241410 if( pExpr->bDesc==0 ){
241459 Fts5Expr *pExpr,
241465 return fts5RowidCmp(pExpr, p1->iRowid, p2->iRowid);
241480 Fts5Expr *pExpr, /* Expression pPhrase belongs to */
241489 const int bDesc = pExpr->bDesc;
241536 pNode->bNomatch = ((0==fts5ExprNearTest(&rc, pExpr, pNode)) && rc==SQLITE_OK);
241550 Fts5Expr *pExpr, /* Expression pPhrase belongs to */
241564 i64 iRowid = fts5ExprSynonymRowid(pTerm, pExpr->bDesc, 0);
241572 || (bFromValid && ii!=iFrom && (ii>iFrom)==pExpr->bDesc)
241607 rc = fts5ExprNodeTest_STRING(pExpr, pNode);
241615 Fts5Expr *pExpr, /* Expression that pNear is a part of */
241631 if( pExpr->pConfig->eDetail==FTS5_DETAIL_FULL ){
241643 Fts5Expr *pExpr,
241658 rc = fts5ExprNodeTest_TERM(pExpr, pNode);
241667 Fts5Expr *pExpr, /* Expression of which pNode is a part */
241675 int cmp = fts5NodeCompare(pExpr, pNext, pChild);
241686 Fts5Expr *pExpr,
241696 assert( p1->bEof || fts5RowidCmp(pExpr, p1->iRowid, iLast)>=0 );
241699 || (bFromValid && fts5RowidCmp(pExpr, p1->iRowid, iFrom)<0)
241701 int rc = fts5ExprNodeNext(pExpr, p1, bFromValid, iFrom);
241710 fts5ExprNodeTest_OR(pExpr, pNode);
241718 Fts5Expr *pExpr, /* Expression pPhrase belongs to */
241732 int cmp = fts5RowidCmp(pExpr, iLast, pChild->iRowid);
241735 rc = fts5ExprNodeNext(pExpr, pChild, 1, iLast);
241746 assert( pChild->bEof || fts5RowidCmp(pExpr, iLast, pChild->iRowid)<=0 );
241762 if( pAnd->bNomatch && pAnd!=pExpr->pRoot ){
241770 Fts5Expr *pExpr,
241775 int rc = fts5ExprNodeNext(pExpr, pNode->apChild[0], bFromValid, iFrom);
241777 rc = fts5ExprNodeTest_AND(pExpr, pNode);
241785 Fts5Expr *pExpr, /* Expression pPhrase belongs to */
241794 int cmp = fts5NodeCompare(pExpr, p1, p2);
241796 rc = fts5ExprNodeNext(pExpr, p2, 1, p1->iRowid);
241797 cmp = fts5NodeCompare(pExpr, p1, p2);
241801 rc = fts5ExprNodeNext(pExpr, p1, 0, 0);
241813 Fts5Expr *pExpr,
241818 int rc = fts5ExprNodeNext(pExpr, pNode->apChild[0], bFromValid, iFrom);
241820 rc = fts5ExprNodeTest_NOT(pExpr, pNode);
241834 Fts5Expr *pExpr, /* Expression of which pNode is a part */
241842 rc = fts5ExprNodeTest_STRING(pExpr, pNode);
241847 rc = fts5ExprNodeTest_TERM(pExpr, pNode);
241852 rc = fts5ExprNodeTest_AND(pExpr, pNode);
241857 fts5ExprNodeTest_OR(pExpr, pNode);
241862 rc = fts5ExprNodeTest_NOT(pExpr, pNode);
241878 static int fts5ExprNodeFirst(Fts5Expr *pExpr, Fts5ExprNode *pNode){
241885 rc = fts5ExprNearInitAll(pExpr, pNode);
241893 rc = fts5ExprNodeFirst(pExpr, pNode->apChild[i]);
241916 rc = fts5ExprNodeTest(pExpr, pNode);
242200 assert( pParse->pExpr==0 );
242201 pParse->pExpr = p;
242280 Fts5Expr *pExpr,
242288 if( !pExpr || iPhrase<0 || iPhrase>=pExpr->nPhrase ){
242291 pOrig = pExpr->apExprPhrase[iPhrase];
242322 sCtx.pConfig = pExpr->pConfig;
242344 pNew->pIndex = pExpr->pIndex;
242345 pNew->pConfig = pExpr->pConfig;
242609 Fts5ExprNode *pExpr,
242618 fts5ParseSetColset(pParse, pExpr, pColset, &pFree);
242961 Fts5ExprNode *pExpr
242964 if( pExpr->eType==FTS5_STRING || pExpr->eType==FTS5_TERM ){
242965 Fts5ExprNearset *pNear = pExpr->pNear;
243012 }else if( pExpr->eType==0 ){
243017 switch( pExpr->eType ){
243021 assert( pExpr->eType==FTS5_OR );
243027 for(i=0; zRet && i<pExpr->nChild; i++){
243028 char *z = fts5ExprPrintTcl(pConfig, zNearsetCmd, pExpr->apChild[i]);
243041 static char *fts5ExprPrint(Fts5Config *pConfig, Fts5ExprNode *pExpr){
243043 if( pExpr->eType==0 ){
243046 if( pExpr->eType==FTS5_STRING || pExpr->eType==FTS5_TERM ){
243047 Fts5ExprNearset *pNear = pExpr->pNear;
243099 switch( pExpr->eType ){
243103 assert( pExpr->eType==FTS5_OR );
243108 for(i=0; i<pExpr->nChild; i++){
243109 char *z = fts5ExprPrint(pConfig, pExpr->apChild[i]);
243114 int e = pExpr->apChild[i]->eType;
243142 Fts5Expr *pExpr = 0;
243185 rc = sqlite3Fts5ExprNew(pConfig, 0, pConfig->nCol, zExpr, &pExpr, &zErr);
243189 if( pExpr->pRoot->xNext==0 ){
243192 zText = fts5ExprPrintTcl(pConfig, zNearsetCmd, pExpr->pRoot);
243194 zText = fts5ExprPrint(pConfig, pExpr->pRoot);
243214 sqlite3Fts5ExprFree(pExpr);
243318 static int sqlite3Fts5ExprPhraseCount(Fts5Expr *pExpr){
243319 return (pExpr ? pExpr->nPhrase : 0);
243325 static int sqlite3Fts5ExprPhraseSize(Fts5Expr *pExpr, int iPhrase){
243326 if( iPhrase<0 || iPhrase>=pExpr->nPhrase ) return 0;
243327 return pExpr->apExprPhrase[iPhrase]->nTerm;
243334 static int sqlite3Fts5ExprPoslist(Fts5Expr *pExpr, int iPhrase, const u8 **pa){
243336 Fts5ExprPhrase *pPhrase = pExpr->apExprPhrase[iPhrase];
243338 if( pNode->bEof==0 && pNode->iRowid==pExpr->pRoot->iRowid ){
243363 static Fts5PoslistPopulator *sqlite3Fts5ExprClearPoslists(Fts5Expr *pExpr, int bLive){
243365 pRet = sqlite3_malloc64(sizeof(Fts5PoslistPopulator)*pExpr->nPhrase);
243368 memset(pRet, 0, sizeof(Fts5PoslistPopulator)*pExpr->nPhrase);
243369 for(i=0; i<pExpr->nPhrase; i++){
243370 Fts5Buffer *pBuf = &pExpr->apExprPhrase[i]->poslist;
243371 Fts5ExprNode *pNode = pExpr->apExprPhrase[i]->pNode;
243372 assert( pExpr->apExprPhrase[i]->nTerm<=1 );
243374 (pBuf->n==0 || pNode->iRowid!=pExpr->pRoot->iRowid || pNode->bEof)
243386 Fts5Expr *pExpr;
243423 Fts5Expr *pExpr = p->pExpr;
243426 i64 iRowid = pExpr->pRoot->iRowid;
243431 if( pExpr->pConfig->bTokendata ){
243435 for(i=0; i<pExpr->nPhrase; i++){
243438 for(pT=&pExpr->apExprPhrase[i]->aTerm[0]; pT; pT=pT->pSynonym){
243443 &pExpr->apExprPhrase[i]->poslist, &p->aPopulator[i].writer, p->iOff
243445 if( rc==SQLITE_OK && (pExpr->pConfig->bTokendata || pT->bPrefix) ){
243462 Fts5Expr *pExpr,
243469 sCtx.pExpr = pExpr;
243473 for(i=0; i<pExpr->nPhrase; i++){
243474 Fts5ExprNode *pNode = pExpr->apExprPhrase[i]->pNode;
243546 static void sqlite3Fts5ExprCheckPoslists(Fts5Expr *pExpr, i64 iRowid){
243547 fts5ExprCheckPoslists(pExpr->pRoot, iRowid);
243554 Fts5Expr *pExpr,
243559 Fts5ExprPhrase *pPhrase = pExpr->apExprPhrase[iPhrase];
243563 assert( iPhrase>=0 && iPhrase<pExpr->nPhrase );
243564 assert( pExpr->pConfig->eDetail==FTS5_DETAIL_COLUMNS );
243567 && pNode->iRowid==pExpr->pRoot->iRowid
243592 Fts5Expr *pExpr,
243600 if( iPhrase<0 || iPhrase>=pExpr->nPhrase ){
243603 pPhrase = pExpr->apExprPhrase[iPhrase];
243617 Fts5Expr *pExpr,
243630 if( iPhrase<0 || iPhrase>=pExpr->nPhrase ){
243633 pPhrase = pExpr->apExprPhrase[iPhrase];
243638 if( pExpr->pConfig->bTokendata || pTerm->bPrefix ){
243654 static void sqlite3Fts5ExprClearTokens(Fts5Expr *pExpr){
243656 for(ii=0; ii<pExpr->nPhrase; ii++){
243658 for(pT=&pExpr->apExprPhrase[ii]->aTerm[0]; pT; pT=pT->pSynonym){
253939 Fts5Expr *pExpr; /* Expression for MATCH queries */
254537 sqlite3Fts5ExprFree(pCsr->pExpr);
254651 i64 iRowid = sqlite3Fts5ExprRowid(pCsr->pExpr);
254653 rc = sqlite3Fts5ExprFirst(pCsr->pExpr, pTab->p.pIndex, iRowid, bDesc);
254654 if( rc==SQLITE_OK && iRowid!=sqlite3Fts5ExprRowid(pCsr->pExpr) ){
254660 if( sqlite3Fts5ExprEof(pCsr->pExpr) ){
254693 sqlite3Fts5ExprClearTokens(pCsr->pExpr);
254699 rc = sqlite3Fts5ExprNext(pCsr->pExpr, pCsr->iLastRowid);
254700 CsrFlagSet(pCsr, sqlite3Fts5ExprEof(pCsr->pExpr));
254783 nPhrase = sqlite3Fts5ExprPhraseCount(pCsr->pExpr);
254824 Fts5Expr *pExpr = pCsr->pExpr;
254825 rc = sqlite3Fts5ExprFirst(pExpr, pTab->p.pIndex, pCsr->iFirstRowid, bDesc);
254826 if( sqlite3Fts5ExprEof(pExpr) ){
255156 Fts5Expr *pExpr = 0;
255165 assert( pCsr->pExpr==0 );
255207 rc = sqlite3Fts5ExprNew(pConfig, 0, iCol, zText, &pExpr, pzErr);
255209 rc = sqlite3Fts5ExprAnd(&pCsr->pExpr, pExpr);
255210 pExpr = 0;
255233 rc = sqlite3Fts5ExprPattern(pConfig, bGlob, iCol, zText, &pExpr);
255236 rc = sqlite3Fts5ExprAnd(&pCsr->pExpr, pExpr);
255237 pExpr = 0;
255293 pCsr->pExpr = pTab->pSortCsr->pExpr;
255295 }else if( pCsr->pExpr ){
255330 sqlite3Fts5ExprFree(pExpr);
255360 return sqlite3Fts5ExprRowid(pCsr->pExpr);
255408 assert( pCsr->pExpr );
255911 return sqlite3Fts5ExprPhraseCount(pCsr->pExpr);
255916 return sqlite3Fts5ExprPhraseSize(pCsr->pExpr, iPhrase);
256005 if( iPhrase<0 || iPhrase>=sqlite3Fts5ExprPhraseCount(pCsr->pExpr) ){
256018 aPopulator = sqlite3Fts5ExprClearPoslists(pCsr->pExpr, bLive);
256029 pConfig, pCsr->pExpr, aPopulator, i, z, n
256037 sqlite3Fts5ExprCheckPoslists(pCsr->pExpr, pCsr->pSorter->iRowid);
256050 *pn = sqlite3Fts5ExprPoslist(pCsr->pExpr, iPhrase, pa);
256071 nIter = sqlite3Fts5ExprPhraseCount(pCsr->pExpr);
256396 rc = sqlite3Fts5ExprPhraseCollist(pCsr->pExpr, iPhrase, &pIter->a, &n);
256434 return sqlite3Fts5ExprQueryToken(pCsr->pExpr, iPhrase, iToken, ppOut, pnOut);
256459 pCsr->pExpr, iRowid, iPhrase, iCol, iOff, iToken, ppOut, pnOut
256558 rc = sqlite3Fts5ExprClonePhrase(pCsr->pExpr, iPhrase, &pNew->pExpr);
256675 int nPhrase = sqlite3Fts5ExprPhraseCount(pCsr->pExpr);
256685 int nByte = sqlite3Fts5ExprPoslist(pCsr->pExpr, i, &dummy);
256693 nPoslist = sqlite3Fts5ExprPoslist(pCsr->pExpr, i, &pPoslist);
256704 rc = sqlite3Fts5ExprPhraseCollist(pCsr->pExpr, i, &dummy, &nByte);
256712 rc = sqlite3Fts5ExprPhraseCollist(pCsr->pExpr, i, &pPoslist, &nPoslist);