Lines Matching defs:pExpr
16193 ** then the value of the node is the value in Mem[pExpr.iTable]. Any
16509 Expr *pExpr; /* Used when p4type is P4_EXPR */
17097 SQLITE_PRIVATE int sqlite3CursorRangeHintExprCheck(Walker *pWalker, Expr *pExpr);
18838 ** AggInfo.pGroupBy and AggInfo.aFunc.pExpr point to fields within the
19173 Expr *pExpr; /* The parse tree for this expression */
19228 Expr *pExpr; /* Expr to implement a USING variable -- NOT USED */
19239 #define EU4_EXPR 2 /* Uses IdList.a.u4.pExpr -- NOT CURRENTLY USED */
19747 Expr *pExpr; /* The expression contained in the index */
19750 int iIdxCol; /* The index column that contains value of pExpr */
19752 u8 aff; /* Affinity of the pExpr expression */
20437 ** attached to Select.pWin. The Window.pFunc and Window.pExpr
21233 SQLITE_PRIVATE char sqlite3CompareAffinity(const Expr *pExpr, char aff2);
21234 SQLITE_PRIVATE int sqlite3IndexAffinityOk(const Expr *pExpr, char idx_affinity);
21236 SQLITE_PRIVATE char sqlite3ExprAffinity(const Expr *pExpr);
21237 SQLITE_PRIVATE int sqlite3ExprDataType(const Expr *pExpr);
21267 SQLITE_PRIVATE CollSeq *sqlite3ExprCollSeq(Parse *pParse, const Expr *pExpr);
21268 SQLITE_PRIVATE CollSeq *sqlite3ExprNNCollSeq(Parse *pParse, const Expr *pExpr);
21748 SQLITE_PRIVATE int sqlite3ExprVectorSize(const Expr *pExpr);
21749 SQLITE_PRIVATE int sqlite3ExprIsVector(const Expr *pExpr);
31964 Expr *pExpr = va_arg(ap,Expr*);
31965 if( ALWAYS(pExpr) && ALWAYS(!ExprHasProperty(pExpr,EP_IntValue)) ){
31966 sqlite3_str_appendall(pAccum, (const char*)pExpr->u.zToken);
31967 sqlite3RecordErrorOffsetOfExpr(pAccum->db, pExpr);
32066 ** If pExpr has a byte offset for the start of a token, record that as
32069 SQLITE_PRIVATE void sqlite3RecordErrorOffsetOfExpr(sqlite3 *db, const Expr *pExpr){
32070 while( pExpr
32071 && (ExprHasProperty(pExpr,EP_OuterON|EP_InnerON) || pExpr->w.iOfst<=0)
32073 pExpr = pExpr->pLeft;
32075 if( pExpr==0 ) return;
32076 db->errByteOffset = pExpr->w.iOfst;
32962 Expr *pExpr, /* Value for PRECEDING or FOLLOWING */
32978 sqlite3TreeViewExpr(pView, pExpr, 0);
32984 sqlite3TreeViewExpr(pView, pExpr, 0);
33076 SQLITE_PRIVATE void sqlite3TreeViewExpr(TreeView *pView, const Expr *pExpr, u8 moreToFollow){
33081 if( pExpr==0 ){
33086 if( pExpr->flags || pExpr->affExpr || pExpr->vvaFlags || pExpr->pAggInfo ){
33090 pExpr->flags, pExpr->affExpr ? pExpr->affExpr : 'n');
33091 if( ExprHasProperty(pExpr, EP_OuterON) ){
33092 sqlite3_str_appendf(&x, " outer.iJoin=%d", pExpr->w.iJoin);
33094 if( ExprHasProperty(pExpr, EP_InnerON) ){
33095 sqlite3_str_appendf(&x, " inner.iJoin=%d", pExpr->w.iJoin);
33097 if( ExprHasProperty(pExpr, EP_FromDDL) ){
33100 if( ExprHasVVAProperty(pExpr, EP_Immutable) ){
33103 if( pExpr->pAggInfo!=0 ){
33104 sqlite3_str_appendf(&x, " agg-column[%d]", pExpr->iAgg);
33110 switch( pExpr->op ){
33113 pExpr->iTable, pExpr->iColumn, zFlgs);
33117 if( pExpr->iTable<0 ){
33120 if( pExpr->op2 ){
33121 sqlite3_snprintf(sizeof(zOp2),zOp2," op2=0x%02x",pExpr->op2);
33126 pExpr->iColumn, zFlgs, zOp2);
33128 assert( ExprUseYTab(pExpr) );
33130 pExpr->iTable, pExpr->iColumn,
33131 pExpr->y.pTab, zFlgs);
33133 if( ExprHasProperty(pExpr, EP_FixedCol) ){
33134 sqlite3TreeViewExpr(pView, pExpr->pLeft, 0);
33139 if( pExpr->flags & EP_IntValue ){
33140 sqlite3TreeViewLine(pView, "%d", pExpr->u.iValue);
33142 sqlite3TreeViewLine(pView, "%s", pExpr->u.zToken);
33148 assert( !ExprHasProperty(pExpr, EP_IntValue) );
33149 sqlite3TreeViewLine(pView,"%s", pExpr->u.zToken);
33154 assert( !ExprHasProperty(pExpr, EP_IntValue) );
33155 sqlite3TreeViewLine(pView,"%Q", pExpr->u.zToken);
33164 sqlite3ExprTruthValue(pExpr) ? "TRUE" : "FALSE", zFlgs);
33169 assert( !ExprHasProperty(pExpr, EP_IntValue) );
33170 sqlite3TreeViewLine(pView,"%s", pExpr->u.zToken);
33175 assert( !ExprHasProperty(pExpr, EP_IntValue) );
33177 pExpr->u.zToken, pExpr->iColumn);
33181 sqlite3TreeViewLine(pView,"REGISTER(%d)", pExpr->iTable);
33185 assert( !ExprHasProperty(pExpr, EP_IntValue) );
33186 sqlite3TreeViewLine(pView,"ID \"%w\"", pExpr->u.zToken);
33192 assert( !ExprHasProperty(pExpr, EP_IntValue) );
33193 sqlite3TreeViewLine(pView,"CAST %Q", pExpr->u.zToken);
33194 sqlite3TreeViewExpr(pView, pExpr->pLeft, 0);
33233 assert( pExpr->op2==TK_IS || pExpr->op2==TK_ISNOT );
33234 assert( pExpr->pRight );
33235 assert( sqlite3ExprSkipCollateAndLikely(pExpr->pRight)->op
33237 x = (pExpr->op2==TK_ISNOT)*2 + sqlite3ExprTruthValue(pExpr->pRight);
33243 assert( !ExprHasProperty(pExpr, EP_IntValue) );
33244 sqlite3TreeViewLine(pView, "SPAN %Q", pExpr->u.zToken);
33245 sqlite3TreeViewExpr(pView, pExpr->pLeft, 0);
33255 assert( !ExprHasProperty(pExpr, EP_IntValue) );
33257 !ExprHasProperty(pExpr, EP_Collate) ? "SOFT-" : "",
33258 pExpr->u.zToken, zFlgs);
33259 sqlite3TreeViewExpr(pView, pExpr->pLeft, 0);
33267 if( ExprHasProperty(pExpr, EP_TokenOnly) ){
33271 assert( ExprUseXList(pExpr) );
33272 pFarg = pExpr->x.pList;
33274 pWin = IsWindowFunc(pExpr) ? pExpr->y.pWin : 0;
33279 assert( !ExprHasProperty(pExpr, EP_IntValue) );
33280 if( pExpr->op==TK_AGG_FUNCTION ){
33282 pExpr->op2, pExpr->u.zToken, zFlgs,
33283 pExpr->pAggInfo ? pExpr->pAggInfo->selId : 0,
33284 pExpr->iAgg, pExpr->pAggInfo);
33285 }else if( pExpr->op2!=0 ){
33288 sqlite3_snprintf(sizeof(zBuf),zBuf,"0x%02x",pExpr->op2);
33290 if( pExpr->op2==NC_IsCheck ) zOp2 = "NC_IsCheck";
33291 if( pExpr->op2==NC_IdxExpr ) zOp2 = "NC_IdxExpr";
33292 if( pExpr->op2==NC_PartIdx ) zOp2 = "NC_PartIdx";
33293 if( pExpr->op2==NC_GenCol ) zOp2 = "NC_GenCol";
33295 pExpr->u.zToken, zFlgs, zOp2);
33297 sqlite3TreeViewLine(pView, "FUNCTION %Q%s", pExpr->u.zToken, zFlgs);
33300 sqlite3TreeViewExprList(pView, pFarg, pWin!=0 || pExpr->pLeft, 0);
33301 if( pExpr->pLeft ){
33302 Expr *pOB = pExpr->pLeft;
33316 sqlite3TreeViewExprList(pView, pExpr->x.pList, 0, "ORDERBY");
33321 assert( ExprUseXSelect(pExpr) );
33322 sqlite3TreeViewLine(pView, "EXISTS-expr flags=0x%x", pExpr->flags);
33323 sqlite3TreeViewSelect(pView, pExpr->x.pSelect, 0);
33327 assert( ExprUseXSelect(pExpr) );
33328 sqlite3TreeViewLine(pView, "subquery-expr flags=0x%x", pExpr->flags);
33329 sqlite3TreeViewSelect(pView, pExpr->x.pSelect, 0);
33335 sqlite3_str_appendf(pStr, "IN flags=0x%x", pExpr->flags);
33336 if( pExpr->iTable ) sqlite3_str_appendf(pStr, " iTable=%d",pExpr->iTable);
33337 if( ExprHasProperty(pExpr, EP_Subrtn) ){
33339 pExpr->y.sub.regReturn, pExpr->y.sub.iAddr);
33344 sqlite3TreeViewExpr(pView, pExpr->pLeft, 1);
33345 if( ExprUseXSelect(pExpr) ){
33346 sqlite3TreeViewSelect(pView, pExpr->x.pSelect, 0);
33348 sqlite3TreeViewExprList(pView, pExpr->x.pList, 0, 0);
33361 ** X is stored in pExpr->pLeft.
33362 ** Y is stored in pExpr->pList->a[0].pExpr.
33363 ** Z is stored in pExpr->pList->a[1].pExpr.
33367 pX = pExpr->pLeft;
33368 assert( ExprUseXList(pExpr) );
33369 assert( pExpr->x.pList->nExpr==2 );
33370 pY = pExpr->x.pList->a[0].pExpr;
33371 pZ = pExpr->x.pList->a[1].pExpr;
33387 pExpr->iTable ? "NEW" : "OLD", pExpr->iColumn);
33392 sqlite3TreeViewExpr(pView, pExpr->pLeft, 1);
33393 assert( ExprUseXList(pExpr) );
33394 sqlite3TreeViewExprList(pView, pExpr->x.pList, 0, 0);
33400 switch( pExpr->affExpr ){
33406 assert( !ExprHasProperty(pExpr, EP_IntValue) );
33407 sqlite3TreeViewLine(pView, "RAISE %s(%Q)", zType, pExpr->u.zToken);
33413 pExpr->iTable, pExpr->iColumn, zFlgs);
33414 sqlite3TreeViewExpr(pView, pExpr->pRight, 0);
33419 assert( ExprUseXList(pExpr) );
33420 sqlite3TreeViewBareExprList(pView, pExpr->x.pList, z);
33426 pExpr->iColumn, pExpr->iTable-1,
33427 pExpr->pRight==pExpr->pLeft ? " (SELECT-owner)" : "");
33428 assert( ExprUseXSelect(pExpr->pLeft) );
33429 sqlite3TreeViewSelect(pView, pExpr->pLeft->x.pSelect, 0);
33433 sqlite3TreeViewLine(pView, "IF-NULL-ROW %d", pExpr->iTable);
33434 sqlite3TreeViewExpr(pView, pExpr->pLeft, 0);
33440 tmp = *pExpr;
33441 tmp.op = pExpr->op2;
33446 if( pExpr->iColumn<=0 ){
33450 pExpr->iColumn-1);
33455 sqlite3TreeViewLine(pView, "op=%d", pExpr->op);
33461 sqlite3TreeViewExpr(pView, pExpr->pLeft, 1);
33462 sqlite3TreeViewExpr(pView, pExpr->pRight, 0);
33465 sqlite3TreeViewExpr(pView, pExpr->pLeft, 0);
33515 sqlite3TreeViewExpr(pView, pList->a[i].pExpr, moreToFollow);
33559 if( pList->a[i].u4.pExpr==0 ){
33560 fprintf(stdout, "%s (pExpr=NULL)\n", zName);
33564 sqlite3TreeViewExpr(pView, pList->a[i].u4.pExpr, 0);
71543 Expr *pExpr;
71548 pExpr = va_arg(ap, Expr*);
71551 assert( pExpr!=0 );
71553 sqlite3WalkExpr(&w, pExpr);
84319 rc = sqlite3ValueFromExpr(db, pList->a[i].pExpr, enc, aff, &apVal[i]);
84379 const Expr *pExpr, /* The expression to evaluate */
84392 assert( pExpr!=0 );
84393 while( (op = pExpr->op)==TK_UPLUS || op==TK_SPAN ) pExpr = pExpr->pLeft;
84394 if( op==TK_REGISTER ) op = pExpr->op2;
84400 assert( (pExpr->flags & EP_TokenOnly)==0 || pCtx==0 );
84404 assert( !ExprHasProperty(pExpr, EP_IntValue) );
84405 aff = sqlite3AffinityType(pExpr->u.zToken,0);
84406 rc = valueFromExpr(db, pExpr->pLeft, enc, aff, ppVal, pCtx);
84426 Expr *pLeft = pExpr->pLeft;
84431 pExpr = pLeft;
84432 op = pExpr->op;
84442 if( ExprHasProperty(pExpr, EP_IntValue) ){
84443 sqlite3VdbeMemSetInt64(pVal, (i64)pExpr->u.iValue*negInt);
84446 if( op==TK_INTEGER && 0==sqlite3DecOrHexToI64(pExpr->u.zToken, &iVal) ){
84449 zVal = sqlite3MPrintf(db, "%s%s", zNeg, pExpr->u.zToken);
84479 if( SQLITE_OK==valueFromExpr(db,pExpr->pLeft,enc,affinity,&pVal,pCtx)
84505 assert( !ExprHasProperty(pExpr, EP_IntValue) );
84506 assert( pExpr->u.zToken[0]=='x' || pExpr->u.zToken[0]=='X' );
84507 assert( pExpr->u.zToken[1]=='\'' );
84510 zVal = &pExpr->u.zToken[2];
84519 rc = valueFromFunction(db, pExpr, enc, affinity, &pVal, pCtx);
84523 assert( !ExprHasProperty(pExpr, EP_IntValue) );
84527 pVal->u.i = pExpr->u.zToken[4]==0;
84551 ** Create a new sqlite3_value object, containing the value of pExpr.
84562 const Expr *pExpr, /* The expression to evaluate */
84567 return pExpr ? valueFromExpr(db, pExpr, enc, affinity, ppVal, 0) : 0;
84572 ** Attempt to extract a value from pExpr and use it to construct *ppVal.
84580 ** * (pExpr==0). In this case the value is assumed to be an SQL NULL,
84591 Expr *pExpr, /* The expression to extract a value from */
84601 pExpr = sqlite3ExprSkipCollate(pExpr);
84603 assert( pExpr==0 || pExpr->op!=TK_REGISTER || pExpr->op2!=TK_VARIABLE );
84604 if( !pExpr ){
84609 }else if( pExpr->op==TK_VARIABLE && (db->flags & SQLITE_EnableQPSG)==0 ){
84611 int iBindVar = pExpr->iColumn;
84622 rc = valueFromExpr(db, pExpr, ENC(db), affinity, &pVal, pAlloc);
84639 ** * (pExpr==0). In this case the value is assumed to be an SQL NULL,
84646 ** Or, if pExpr is a TK_VECTOR, one field is populated for each of the
84661 ** error if a value cannot be extracted from pExpr. If an error does
84668 Expr *pExpr, /* The expression to extract a value from */
84676 if( pExpr==0 || pExpr->op!=TK_SELECT ){
84686 Expr *pElem = (pExpr ? sqlite3VectorFieldSubexpr(pExpr, i) : 0);
84700 ** Attempt to extract a value from expression pExpr using the methods
84711 Expr *pExpr, /* The expression to extract a value from */
84715 return stat4ValueFromExpr(pParse, pExpr, affinity, 0, ppVal);
86653 ** Translate the P4.pExpr value for an OP_CursorHint opcode into text
86656 static void displayP4Expr(StrAccum *p, Expr *pExpr){
86658 switch( pExpr->op ){
86660 assert( !ExprHasProperty(pExpr, EP_IntValue) );
86661 sqlite3_str_appendf(p, "%Q", pExpr->u.zToken);
86664 sqlite3_str_appendf(p, "%d", pExpr->u.iValue);
86670 sqlite3_str_appendf(p, "r[%d]", pExpr->iTable);
86674 if( pExpr->iColumn<0 ){
86677 sqlite3_str_appendf(p, "c%d", (int)pExpr->iColumn);
86715 displayP4Expr(p, pExpr->pLeft);
86716 if( pExpr->pRight ){
86718 displayP4Expr(p, pExpr->pRight);
86756 displayP4Expr(&x, pOp->p4.pExpr);
90246 SQLITE_PRIVATE int sqlite3CursorRangeHintExprCheck(Walker *pWalker, Expr *pExpr){
90247 if( pExpr->op==TK_REGISTER ){
90248 assert( (pWalker->u.aMem[pExpr->iTable].flags & MEM_Undefined)==0 );
102046 pOp->p4.pExpr, aMem);
106526 SQLITE_PRIVATE SQLITE_NOINLINE int sqlite3WalkExprNN(Walker *pWalker, Expr *pExpr){
106528 testcase( ExprHasProperty(pExpr, EP_TokenOnly) );
106529 testcase( ExprHasProperty(pExpr, EP_Reduced) );
106531 rc = pWalker->xExprCallback(pWalker, pExpr);
106533 if( !ExprHasProperty(pExpr,(EP_TokenOnly|EP_Leaf)) ){
106534 assert( pExpr->x.pList==0 || pExpr->pRight==0 );
106535 if( pExpr->pLeft && sqlite3WalkExprNN(pWalker, pExpr->pLeft) ){
106538 if( pExpr->pRight ){
106539 assert( !ExprHasProperty(pExpr, EP_WinFunc) );
106540 pExpr = pExpr->pRight;
106542 }else if( ExprUseXSelect(pExpr) ){
106543 assert( !ExprHasProperty(pExpr, EP_WinFunc) );
106544 if( sqlite3WalkSelect(pWalker, pExpr->x.pSelect) ) return WRC_Abort;
106546 if( pExpr->x.pList ){
106547 if( sqlite3WalkExprList(pWalker, pExpr->x.pList) ) return WRC_Abort;
106550 if( ExprHasProperty(pExpr, EP_WinFunc) ){
106551 if( walkWindowList(pWalker, pExpr->y.pWin, 1) ) return WRC_Abort;
106560 SQLITE_PRIVATE int sqlite3WalkExpr(Walker *pWalker, Expr *pExpr){
106561 return pExpr ? sqlite3WalkExprNN(pWalker,pExpr) : WRC_Continue;
106573 if( sqlite3WalkExpr(pWalker, pItem->pExpr) ) return WRC_Abort;
106749 ** Walk the expression tree pExpr and increase the aggregate function
106754 ** incrAggFunctionDepth(pExpr,n) is the main routine. incrAggDepth(..)
106759 static int incrAggDepth(Walker *pWalker, Expr *pExpr){
106760 if( pExpr->op==TK_AGG_FUNCTION ) pExpr->op2 += pWalker->u.n;
106763 static void incrAggFunctionDepth(Expr *pExpr, int N){
106769 sqlite3WalkExpr(&w, pExpr);
106774 ** Turn the pExpr expression into an alias for the iCol-th column of the
106796 Expr *pExpr, /* Transform this into an alias to the result set */
106804 pOrig = pEList->a[iCol].pExpr;
106806 assert( !ExprHasProperty(pExpr, EP_Reduced|EP_TokenOnly) );
106807 if( pExpr->pAggInfo ) return;
106816 if( pExpr->op==TK_COLLATE ){
106817 assert( !ExprHasProperty(pExpr, EP_IntValue) );
106818 pDup = sqlite3ExprAddCollateString(pParse, pDup, pExpr->u.zToken);
106821 memcpy(pDup, pExpr, sizeof(Expr));
106822 memcpy(pExpr, &temp, sizeof(Expr));
106823 if( ExprHasProperty(pExpr, EP_WinFunc) ){
106824 if( ALWAYS(pExpr->y.pWin!=0) ){
106825 pExpr->y.pWin->pOwner = pExpr;
106903 SQLITE_PRIVATE Bitmask sqlite3ExprColUsed(Expr *pExpr){
106907 n = pExpr->iColumn;
106908 assert( ExprUseYTab(pExpr) );
106909 pExTab = pExpr->y.pTab;
106977 ** that name in the set of source tables in pSrcList and make the pExpr
106979 ** are made to pExpr:
106981 ** pExpr->iDb Set the index in db->aDb[] of the database X
106983 ** pExpr->iTable Set to the cursor number for the table obtained
106985 ** pExpr->y.pTab Points to the Table structure of X.Y (even if
106987 ** pExpr->iColumn Set to the column number within the table.
106988 ** pExpr->op Set to TK_COLUMN.
106989 ** pExpr->pLeft Any expression this points to is deleted
106990 ** pExpr->pRight Any expression this points to is deleted.
107008 Expr *pExpr /* Make this EXPR node point to the selected column */
107019 int eNewExprOp = TK_COLUMN; /* New value for pExpr->op on success */
107028 assert( !ExprHasProperty(pExpr, EP_TokenOnly|EP_Reduced) );
107031 pExpr->iTable = -1;
107032 ExprSetVVAProperty(pExpr, EP_NoReduce);
107116 extendFJMatch(pParse, &pFJMatch, pMatch, pExpr->iColumn);
107128 pExpr->iColumn = j;
107151 assert( ExprUseYTab(pExpr) );
107153 sqlite3RenameTokenRemap(pParse, 0, (void*)&pExpr->y.pTab);
107182 extendFJMatch(pParse, &pFJMatch, pMatch, pExpr->iColumn);
107188 pExpr->iColumn = j==pTab->iPKey ? -1 : (i16)j;
107230 pExpr->iTable = pMatch->iCursor;
107231 assert( ExprUseYTab(pExpr) );
107232 pExpr->y.pTab = pMatch->pTab;
107234 ExprSetProperty(pExpr, EP_CanBeNull);
107236 pSchema = pExpr->y.pTab->pSchema;
107258 pExpr->iTable = op!=TK_DELETE;
107262 pExpr->iTable = 1;
107265 pExpr->iTable = 0;
107275 pExpr->iTable = EXCLUDED_TABLE_NUMBER;
107303 if( pExpr->iTable==EXCLUDED_TABLE_NUMBER ){
107305 assert( ExprUseYTab(pExpr) );
107307 pExpr->iColumn = iCol;
107308 pExpr->y.pTab = pTab;
107311 pExpr->iTable = pNC->uNC.pUpsert->regData +
107318 assert( ExprUseYTab(pExpr) );
107319 pExpr->y.pTab = pTab;
107322 pExpr->op2 = TK_COLUMN;
107323 pExpr->iColumn = iCol;
107324 pExpr->iTable = pNC->uNC.iBaseReg + (pTab->nCol+1)*pExpr->iTable +
107327 pExpr->iColumn = (i16)iCol;
107331 pExpr->affExpr = SQLITE_AFF_INTEGER;
107332 }else if( pExpr->iTable==0 ){
107365 if( pMatch->fg.isNestedFrom==0 ) pExpr->iColumn = -1;
107366 pExpr->affExpr = SQLITE_AFF_INTEGER;
107376 ** In cases like this, replace pExpr with a copy of the expression that
107399 assert( pExpr->pLeft==0 && pExpr->pRight==0 );
107400 assert( ExprUseXList(pExpr)==0 || pExpr->x.pList==0 );
107401 assert( ExprUseXSelect(pExpr)==0 || pExpr->x.pSelect==0 );
107402 pOrig = pEList->a[j].pExpr;
107417 resolveAlias(pParse, pEList, j, pExpr, nSubquery);
107422 sqlite3RenameTokenRemap(pParse, 0, (void*)pExpr);
107443 ** pExpr.
107449 assert( pExpr->op==TK_ID );
107450 if( ExprHasProperty(pExpr,EP_DblQuoted)
107472 pExpr->op = TK_STRING;
107473 memset(&pExpr->y, 0, sizeof(pExpr->y));
107476 if( sqlite3ExprIdToTrueFalse(pExpr) ){
107489 assert( !ExprHasProperty(pExpr, EP_xIsSelect|EP_IntValue) );
107494 if( ExprHasProperty(pExpr,EP_Leaf) ){
107495 ExprClearProperty(pExpr,EP_Leaf);
107497 sqlite3ExprDelete(db, pExpr->pLeft);
107498 pExpr->pLeft = 0;
107499 sqlite3ExprDelete(db, pExpr->pRight);
107500 pExpr->pRight = 0;
107502 extendFJMatch(pParse, &pFJMatch, pMatch, pExpr->iColumn);
107503 pExpr->op = TK_FUNCTION;
107504 pExpr->u.zToken = "coalesce";
107505 pExpr->x.pList = pFJMatch;
107525 sqlite3RecordErrorOffsetOfExpr(pParse->db, pExpr);
107532 /* Remove all substructure from pExpr */
107533 if( !ExprHasProperty(pExpr,(EP_TokenOnly|EP_Leaf)) ){
107534 sqlite3ExprDelete(db, pExpr->pLeft);
107535 pExpr->pLeft = 0;
107536 sqlite3ExprDelete(db, pExpr->pRight);
107537 pExpr->pRight = 0;
107538 ExprSetProperty(pExpr, EP_Leaf);
107556 if( pExpr->iColumn>=0 ){
107557 pMatch->colUsed |= sqlite3ExprColUsed(pExpr);
107563 pExpr->op = eNewExprOp;
107569 && (pExpr->op==TK_COLUMN || pExpr->op==TK_TRIGGER)
107571 sqlite3AuthRead(pParse, pExpr, pSchema, pNC->pSrcList);
107629 ** Expr *pExpr // Invalidate this expression on error
107640 Expr *pExpr, /* Invalidate this expression on error */
107652 if( pExpr ) pExpr->op = TK_NULL;
107685 static int resolveExprStep(Walker *pWalker, Expr *pExpr){
107703 switch( pExpr->op ){
107715 pExpr->op = TK_COLUMN;
107716 assert( ExprUseYTab(pExpr) );
107717 pExpr->y.pTab = pItem->pTab;
107718 pExpr->iTable = pItem->iCursor;
107719 pExpr->iColumn--;
107720 pExpr->affExpr = SQLITE_AFF_INTEGER;
107759 sqlite3WalkExpr(pWalker, pExpr->pLeft);
107761 if( sqlite3ExprCanBeNull(pExpr->pLeft) ){
107771 testcase( ExprHasProperty(pExpr, EP_OuterON) );
107772 assert( !ExprHasProperty(pExpr, EP_IntValue) );
107777 pExpr->op==TK_NOTNULL
107779 sqlite3ShowExpr(pExpr);
107782 pExpr->u.iValue = (pExpr->op==TK_NOTNULL);
107783 pExpr->flags |= EP_IntValue;
107784 pExpr->op = TK_INTEGER;
107788 sqlite3ExprDelete(pParse->db, pExpr->pLeft);
107789 pExpr->pLeft = 0;
107807 if( pExpr->op==TK_ID ){
107810 assert( !ExprHasProperty(pExpr, EP_IntValue) );
107811 pRight = pExpr;
107813 Expr *pLeft = pExpr->pLeft;
107817 NC_IdxExpr|NC_GenCol, 0, pExpr);
107818 pRight = pExpr->pRight;
107830 assert( ExprUseYTab(pExpr) );
107832 sqlite3RenameTokenRemap(pParse, (void*)pExpr, (void*)pRight);
107833 sqlite3RenameTokenRemap(pParse, (void*)&pExpr->y.pTab, (void*)pLeft);
107836 return lookupName(pParse, zDb, zTable, pRight, pNC, pExpr);
107842 ExprList *pList = pExpr->x.pList; /* The argument list */
107852 Window *pWin = (IsWindowFunc(pExpr) ? pExpr->y.pWin : 0);
107854 assert( !ExprHasProperty(pExpr, EP_xIsSelect|EP_IntValue) );
107855 assert( pExpr->pLeft==0 || pExpr->pLeft->op==TK_ORDER );
107856 zId = pExpr->u.zToken;
107868 ExprSetProperty(pExpr, EP_Unlikely);
107870 pExpr->iTable = exprProbability(pList->a[1].pExpr);
107871 if( pExpr->iTable<0 ){
107874 "constant between 0.0 and 1.0", pExpr);
107887 pExpr->iTable = pDef->zName[0]=='u' ? 8388608 : 125829120;
107896 pExpr);
107899 pExpr->op = TK_NULL;
107909 ExprSetProperty(pExpr,EP_ConstFunc);
107919 NC_IdxExpr|NC_PartIdx|NC_GenCol, 0, pExpr);
107922 pExpr->op2 = pNC->ncFlags & NC_SelfRef;
107923 if( pNC->ncFlags & NC_FromDDL ) ExprSetProperty(pExpr, EP_FromDDL);
107939 sqlite3ExprFunctionUsable(pParse, pExpr, pDef);
107951 "%#T() may not be used as a window function", pExpr
107965 sqlite3ErrorMsg(pParse, "misuse of %s function %#T()",zType,pExpr);
107971 sqlite3ErrorMsg(pParse,"misuse of aggregate function %#T()",pExpr);
107981 sqlite3ErrorMsg(pParse, "no such function: %#T", pExpr);
107985 pExpr);
107989 else if( is_agg==0 && ExprHasProperty(pExpr, EP_WinFunc) ){
107992 pExpr
107997 else if( is_agg==0 && pExpr->pLeft ){
107998 sqlite3ExprOrderByAggregateError(pParse, pExpr);
108012 else if( ExprHasProperty(pExpr, EP_WinFunc) || pExpr->pLeft ){
108017 if( pExpr->pLeft ){
108018 assert( pExpr->pLeft->op==TK_ORDER );
108019 assert( ExprUseXList(pExpr->pLeft) );
108020 sqlite3WalkExprList(pWalker, pExpr->pLeft->x.pList);
108025 assert( pWin==0 || (ExprUseYWin(pExpr) && pWin==pExpr->y.pWin) );
108039 pExpr->op = TK_AGG_FUNCTION;
108040 pExpr->op2 = 0;
108042 if( ExprHasProperty(pExpr, EP_WinFunc) ){
108043 sqlite3WalkExpr(pWalker, pExpr->y.pWin->pFilter);
108048 && sqlite3ReferencesSrcList(pParse, pExpr, pNC2->pSrcList)==0
108050 pExpr->op2 += (1 + pNC2->nNestedSelect);
108055 pExpr->op2 += pNC2->nNestedSelect;
108067 /* FIX ME: Compute pExpr->affinity based on the expected return
108074 case TK_EXISTS: testcase( pExpr->op==TK_EXISTS );
108077 testcase( pExpr->op==TK_IN );
108078 if( ExprUseXSelect(pExpr) ){
108084 assert( pExpr->x.pSelect );
108086 notValidImpl(pParse, pNC, "subqueries", pExpr, pExpr);
108088 sqlite3WalkSelect(pWalker, pExpr->x.pSelect);
108092 ExprSetProperty(pExpr, EP_VarSelect);
108093 pExpr->x.pSelect->selFlags |= SF_Correlated;
108105 NC_IsCheck|NC_PartIdx|NC_IdxExpr|NC_GenCol, pExpr, pExpr);
108110 Expr *pRight = sqlite3ExprSkipCollateAndLikely(pExpr->pRight);
108111 assert( !ExprHasProperty(pExpr, EP_Reduced) );
108118 pExpr->op2 = pExpr->op;
108119 pExpr->op = TK_TRUTH;
108134 assert( pExpr->pLeft!=0 );
108135 nLeft = sqlite3ExprVectorSize(pExpr->pLeft);
108136 if( pExpr->op==TK_BETWEEN ){
108137 assert( ExprUseXList(pExpr) );
108138 nRight = sqlite3ExprVectorSize(pExpr->x.pList->a[0].pExpr);
108140 nRight = sqlite3ExprVectorSize(pExpr->x.pList->a[1].pExpr);
108143 assert( pExpr->pRight!=0 );
108144 nRight = sqlite3ExprVectorSize(pExpr->pRight);
108147 testcase( pExpr->op==TK_EQ );
108148 testcase( pExpr->op==TK_NE );
108149 testcase( pExpr->op==TK_LT );
108150 testcase( pExpr->op==TK_LE );
108151 testcase( pExpr->op==TK_GT );
108152 testcase( pExpr->op==TK_GE );
108153 testcase( pExpr->op==TK_IS );
108154 testcase( pExpr->op==TK_ISNOT );
108155 testcase( pExpr->op==TK_BETWEEN );
108157 sqlite3RecordErrorOffsetOfExpr(pParse->db, pExpr);
108255 if( sqlite3ExprCompare(0, pEList->a[i].pExpr, pE, -1)<2 ){
108329 pE = sqlite3ExprSkipCollateAndLikely(pItem->pExpr);
108369 if( pItem->pExpr==pE ){
108370 pItem->pExpr = pNew;
108372 Expr *pParent = pItem->pExpr;
108432 resolveAlias(pParse, pEList, pItem->u.x.iOrderByCol-1, pItem->pExpr,0);
108442 static int resolveRemoveWindowsCb(Walker *pWalker, Expr *pExpr){
108444 if( ExprHasProperty(pExpr, EP_WinFunc) ){
108445 Window *pWin = pExpr->y.pWin;
108452 ** Remove any Window objects owned by the expression pExpr from the
108455 static void windowRemoveExprFromSelect(Select *pSelect, Expr *pExpr){
108461 sqlite3WalkExpr(&sWalker, pExpr);
108502 Expr *pE = pItem->pExpr;
108534 if( sqlite3ExprCompare(0, pE, pSelect->pEList->a[j].pExpr, -1)==0 ){
108763 if( ExprHasProperty(pItem->pExpr, EP_Agg) ){
108844 Expr *pExpr /* The expression to be analyzed. */
108849 if( pExpr==0 ) return SQLITE_OK;
108858 w.pParse->nHeight += pExpr->nHeight;
108863 assert( pExpr!=0 );
108864 sqlite3WalkExprNN(&w, pExpr);
108866 w.pParse->nHeight -= pExpr->nHeight;
108872 ExprSetProperty(pExpr, pNC->ncFlags & (NC_HasAgg|NC_HasWin) );
108901 Expr *pExpr = pList->a[i].pExpr;
108902 if( pExpr==0 ) continue;
108904 w.pParse->nHeight += pExpr->nHeight;
108909 sqlite3WalkExprNN(&w, pExpr);
108911 w.pParse->nHeight -= pExpr->nHeight;
108918 ExprSetProperty(pExpr, pNC->ncFlags & (NC_HasAgg|NC_HasWin) );
108979 Expr *pExpr, /* Expression to resolve. May be NULL. */
109005 if( (rc = sqlite3ResolveExprNames(&sNC, pExpr))!=SQLITE_OK ) return rc;
109041 ** Return the 'affinity' of the expression pExpr if any.
109043 ** If pExpr is a column, a reference to a column via an 'AS' alias,
109056 SQLITE_PRIVATE char sqlite3ExprAffinity(const Expr *pExpr){
109058 op = pExpr->op;
109060 if( op==TK_COLUMN || (op==TK_AGG_COLUMN && pExpr->y.pTab!=0) ){
109061 assert( ExprUseYTab(pExpr) );
109062 assert( pExpr->y.pTab!=0 );
109063 return sqlite3TableColumnAffinity(pExpr->y.pTab, pExpr->iColumn);
109066 assert( ExprUseXSelect(pExpr) );
109067 assert( pExpr->x.pSelect!=0 );
109068 assert( pExpr->x.pSelect->pEList!=0 );
109069 assert( pExpr->x.pSelect->pEList->a[0].pExpr!=0 );
109070 return sqlite3ExprAffinity(pExpr->x.pSelect->pEList->a[0].pExpr);
109074 assert( !ExprHasProperty(pExpr, EP_IntValue) );
109075 return sqlite3AffinityType(pExpr->u.zToken, 0);
109079 assert( pExpr->pLeft!=0 && ExprUseXSelect(pExpr->pLeft) );
109080 assert( pExpr->iColumn < pExpr->iTable );
109081 assert( pExpr->iColumn >= 0 );
109082 assert( pExpr->iTable==pExpr->pLeft->x.pSelect->pEList->nExpr );
109084 pExpr->pLeft->x.pSelect->pEList->a[pExpr->iColumn].pExpr
109088 assert( ExprUseXList(pExpr) );
109089 return sqlite3ExprAffinity(pExpr->x.pList->a[0].pExpr);
109091 if( ExprHasProperty(pExpr, EP_Skip|EP_IfNullRow) ){
109092 assert( pExpr->op==TK_COLLATE
109093 || pExpr->op==TK_IF_NULL_ROW
109094 || (pExpr->op==TK_REGISTER && pExpr->op2==TK_IF_NULL_ROW) );
109095 pExpr = pExpr->pLeft;
109096 op = pExpr->op;
109099 if( op!=TK_REGISTER || (op = pExpr->op2)==TK_REGISTER ) break;
109101 return pExpr->affExpr;
109114 SQLITE_PRIVATE int sqlite3ExprDataType(const Expr *pExpr){
109115 while( pExpr ){
109116 switch( pExpr->op ){
109120 pExpr = pExpr->pLeft;
109124 pExpr = 0;
109147 int aff = sqlite3ExprAffinity(pExpr);
109155 ExprList *pList = pExpr->x.pList;
109156 assert( ExprUseXList(pExpr) && pList!=0 );
109159 res |= sqlite3ExprDataType(pList->a[ii].pExpr);
109162 res |= sqlite3ExprDataType(pList->a[pList->nExpr-1].pExpr);
109170 } /* End of while(pExpr) */
109175 ** Set the collating sequence for expression pExpr to be the collating
109180 ** and the pExpr parameter is returned unchanged.
109184 Expr *pExpr, /* Add the "COLLATE" clause to this expression */
109191 pNew->pLeft = pExpr;
109193 pExpr = pNew;
109196 return pExpr;
109200 Expr *pExpr, /* Add the "COLLATE" clause to this expression */
109206 return sqlite3ExprAddCollateToken(pParse, pExpr, &s, 0);
109212 SQLITE_PRIVATE Expr *sqlite3ExprSkipCollate(Expr *pExpr){
109213 while( pExpr && ExprHasProperty(pExpr, EP_Skip) ){
109214 assert( pExpr->op==TK_COLLATE );
109215 pExpr = pExpr->pLeft;
109217 return pExpr;
109225 SQLITE_PRIVATE Expr *sqlite3ExprSkipCollateAndLikely(Expr *pExpr){
109226 while( pExpr && ExprHasProperty(pExpr, EP_Skip|EP_Unlikely) ){
109227 if( ExprHasProperty(pExpr, EP_Unlikely) ){
109228 assert( ExprUseXList(pExpr) );
109229 assert( pExpr->x.pList->nExpr>0 );
109230 assert( pExpr->op==TK_FUNCTION );
109231 pExpr = pExpr->x.pList->a[0].pExpr;
109232 }else if( pExpr->op==TK_COLLATE ){
109233 pExpr = pExpr->pLeft;
109238 return pExpr;
109242 ** Return the collation sequence for the expression pExpr. If
109248 ** default collation if pExpr has no defined collation.
109255 SQLITE_PRIVATE CollSeq *sqlite3ExprCollSeq(Parse *pParse, const Expr *pExpr){
109258 const Expr *p = pExpr;
109280 p = p->x.pList->a[0].pExpr;
109298 if( ExprHasProperty(p->x.pList->a[i].pExpr, EP_Collate) ){
109299 pNext = p->x.pList->a[i].pExpr;
109317 ** Return the collation sequence for the expression pExpr. If
109326 SQLITE_PRIVATE CollSeq *sqlite3ExprNNCollSeq(Parse *pParse, const Expr *pExpr){
109327 CollSeq *p = sqlite3ExprCollSeq(pParse, pExpr);
109343 ** pExpr is an operand of a comparison operator. aff2 is the
109347 SQLITE_PRIVATE char sqlite3CompareAffinity(const Expr *pExpr, char aff2){
109348 char aff1 = sqlite3ExprAffinity(pExpr);
109366 ** pExpr is a comparison operator. Return the type affinity that should
109369 static char comparisonAffinity(const Expr *pExpr){
109371 assert( pExpr->op==TK_EQ || pExpr->op==TK_IN || pExpr->op==TK_LT ||
109372 pExpr->op==TK_GT || pExpr->op==TK_GE || pExpr->op==TK_LE ||
109373 pExpr->op==TK_NE || pExpr->op==TK_IS || pExpr->op==TK_ISNOT );
109374 assert( pExpr->pLeft );
109375 aff = sqlite3ExprAffinity(pExpr->pLeft);
109376 if( pExpr->pRight ){
109377 aff = sqlite3CompareAffinity(pExpr->pRight, aff);
109378 }else if( ExprUseXSelect(pExpr) ){
109379 aff = sqlite3CompareAffinity(pExpr->x.pSelect->pEList->a[0].pExpr, aff);
109387 ** pExpr is a comparison expression, eg. '=', '<', IN(...) etc.
109390 ** the comparison in pExpr.
109392 SQLITE_PRIVATE int sqlite3IndexAffinityOk(const Expr *pExpr, char idx_affinity){
109393 char aff = comparisonAffinity(pExpr);
109496 ** Return true if expression pExpr is a vector, or false otherwise.
109504 SQLITE_PRIVATE int sqlite3ExprIsVector(const Expr *pExpr){
109505 return sqlite3ExprVectorSize(pExpr)>1;
109514 SQLITE_PRIVATE int sqlite3ExprVectorSize(const Expr *pExpr){
109515 u8 op = pExpr->op;
109516 if( op==TK_REGISTER ) op = pExpr->op2;
109518 assert( ExprUseXList(pExpr) );
109519 return pExpr->x.pList->nExpr;
109521 assert( ExprUseXSelect(pExpr) );
109522 return pExpr->x.pSelect->pEList->nExpr;
109549 return pVector->x.pSelect->pEList->a[i].pExpr;
109552 return pVector->x.pList->a[i].pExpr;
109615 ppVector = &pVector->x.pList->a[iField].pExpr;
109629 ** If expression pExpr is of type TK_SELECT, generate code to evaluate
109634 ** If pExpr is not a TK_SELECT expression, return 0.
109636 static int exprCodeSubselect(Parse *pParse, Expr *pExpr){
109639 if( pExpr->op==TK_SELECT ){
109640 reg = sqlite3CodeSubselect(pParse, pExpr);
109680 *ppExpr = pVector->x.pSelect->pEList->a[iField].pExpr;
109685 *ppExpr = pVector->x.pList->a[iField].pExpr;
109692 ** Expression pExpr is a comparison between two vector values. Compute
109698 ** if pExpr->op==TK_IS: op==TK_EQ and p5==SQLITE_NULLEQ
109699 ** if pExpr->op==TK_ISNOT: op==TK_NE and p5==SQLITE_NULLEQ
109700 ** otherwise: op==pExpr->op and p5==0
109704 Expr *pExpr, /* The comparison operation */
109710 Expr *pLeft = pExpr->pLeft;
109711 Expr *pRight = pExpr->pRight;
109719 int isCommuted = ExprHasProperty(pExpr,EP_Commuted);
109721 assert( !ExprHasVVAProperty(pExpr,EP_Immutable) );
109727 assert( pExpr->op==TK_EQ || pExpr->op==TK_NE
109728 || pExpr->op==TK_IS || pExpr->op==TK_ISNOT
109729 || pExpr->op==TK_LT || pExpr->op==TK_GT
109730 || pExpr->op==TK_LE || pExpr->op==TK_GE
109732 assert( pExpr->op==op || (pExpr->op==TK_IS && op==TK_EQ)
109733 || (pExpr->op==TK_ISNOT && op==TK_NE) );
109734 assert( p5==0 || pExpr->op!=op );
109735 assert( p5==SQLITE_NULLEQ || pExpr->op==op );
109829 heightOfExpr(p->a[i].pExpr, pnHeight);
109909 SQLITE_PRIVATE void sqlite3ExprSetErrorOffset(Expr *pExpr, int iOfst){
109910 if( pExpr==0 ) return;
109911 if( NEVER(ExprUseWJoin(pExpr)) ) return;
109912 pExpr->w.iOfst = iOfst;
110064 ** Add pSelect to the Expr.x.pSelect field. Or, if pExpr is NULL (due
110067 SQLITE_PRIVATE void sqlite3PExprAddSelect(Parse *pParse, Expr *pExpr, Select *pSelect){
110068 if( pExpr ){
110069 pExpr->x.pSelect = pSelect;
110070 ExprSetProperty(pExpr, EP_xIsSelect|EP_Subquery);
110071 sqlite3ExprSetHeightAndFlags(pParse, pExpr);
110103 Expr *pExpr = pEList->a[ii].pExpr;
110105 if( pExpr->op==TK_VECTOR ){
110106 assert( ExprUseXList(pExpr) );
110107 nExprElem = pExpr->x.pList->nExpr;
110117 assert( ExprUseXList(pExpr) );
110118 pSel = sqlite3SelectNew(pParse, pExpr->x.pList, 0, 0, 0, 0, 0, SF_Values,0);
110119 pExpr->x.pList = 0;
110213 ** pExpr pOrderBy
110220 Expr *pExpr, /* The function call to which ORDER BY is to be added */
110229 if( pExpr==0 ){
110234 assert( pExpr->op==TK_FUNCTION );
110235 assert( pExpr->pLeft==0 );
110236 assert( ExprUseXList(pExpr) );
110237 if( pExpr->x.pList==0 || NEVER(pExpr->x.pList->nExpr==0) ){
110242 if( IsWindowFunc(pExpr) ){
110243 sqlite3ExprOrderByAggregateError(pParse, pExpr);
110255 pExpr->pLeft = pOB;
110272 const Expr *pExpr, /* The function invocation */
110277 if( ExprHasProperty(pExpr, EP_FromDDL) ){
110288 sqlite3ErrorMsg(pParse, "unsafe use of %#T()", pExpr);
110309 SQLITE_PRIVATE void sqlite3ExprAssignVarNumber(Parse *pParse, Expr *pExpr, u32 n){
110314 if( pExpr==0 ) return;
110315 assert( !ExprHasProperty(pExpr, EP_IntValue|EP_Reduced|EP_TokenOnly) );
110316 z = pExpr->u.zToken;
110344 sqlite3RecordErrorOffsetOfExpr(pParse->db, pExpr);
110369 pExpr->iColumn = x;
110372 sqlite3RecordErrorOffsetOfExpr(pParse->db, pExpr);
110451 ** Arrange to cause pExpr to be deleted when the pParse is deleted.
110455 ** The pExpr might be deleted immediately on an OOM error.
110460 SQLITE_PRIVATE int sqlite3ExprDeferredDelete(Parse *pParse, Expr *pExpr){
110461 return 0==sqlite3ParserAddCleanup(pParse, sqlite3ExprDeleteGeneric, pExpr);
110776 static int gatherSelectWindowsCallback(Walker *pWalker, Expr *pExpr){
110777 if( pExpr->op==TK_FUNCTION && ExprHasProperty(pExpr, EP_WinFunc) ){
110779 Window *pWin = pExpr->y.pWin;
110781 assert( IsWindowFunc(pExpr) );
110839 Expr *pOldExpr = pOldItem->pExpr;
110841 pItem->pExpr = sqlite3ExprDup(db, pOldExpr, flags);
110844 && (pNewExpr = pItem->pExpr)!=0
111013 Expr *pExpr /* Expression to be appended. Might be NULL */
111020 sqlite3ExprDelete(db, pExpr);
111027 pItem->pExpr = pExpr;
111033 Expr *pExpr /* Expression to be appended. Might be NULL */
111042 sqlite3ExprDelete(db, pExpr);
111049 pItem->pExpr = pExpr;
111055 Expr *pExpr /* Expression to be appended. Might be NULL */
111059 return sqlite3ExprListAppendNew(pParse->db,pExpr);
111062 return sqlite3ExprListAppendGrow(pParse->db,pList,pExpr);
111066 pItem->pExpr = pExpr;
111071 ** pColumns and pExpr form a vector assignment which is part of the SET
111085 Expr *pExpr /* Vector expression to be appended. Might be NULL */
111094 if( pExpr==0 ) goto vector_append_error;
111101 if( pExpr->op!=TK_SELECT && pColumns->nId!=(n=sqlite3ExprVectorSize(pExpr)) ){
111108 Expr *pSubExpr = sqlite3ExprForVectorField(pParse, pExpr, i, pColumns->nId);
111119 if( !db->mallocFailed && pExpr->op==TK_SELECT && ALWAYS(pList!=0) ){
111120 Expr *pFirst = pList->a[iFirst].pExpr;
111126 pFirst->pRight = pExpr;
111127 pExpr = 0;
111135 sqlite3ExprUnmapAndDelete(pParse, pExpr);
111260 sqlite3ExprDelete(db, pItem->pExpr);
111282 Expr *pExpr = pList->a[i].pExpr;
111283 assert( pExpr!=0 );
111284 m |= pExpr->flags;
111322 SQLITE_PRIVATE int sqlite3ExprIdToTrueFalse(Expr *pExpr){
111324 assert( pExpr->op==TK_ID || pExpr->op==TK_STRING );
111325 if( !ExprHasProperty(pExpr, EP_Quoted|EP_IntValue)
111326 && (v = sqlite3IsTrueOrFalse(pExpr->u.zToken))!=0
111328 pExpr->op = TK_TRUEFALSE;
111329 ExprSetProperty(pExpr, v);
111339 SQLITE_PRIVATE int sqlite3ExprTruthValue(const Expr *pExpr){
111340 pExpr = sqlite3ExprSkipCollateAndLikely((Expr*)pExpr);
111341 assert( pExpr->op==TK_TRUEFALSE );
111342 assert( !ExprHasProperty(pExpr, EP_IntValue) );
111343 assert( sqlite3StrICmp(pExpr->u.zToken,"true")==0
111344 || sqlite3StrICmp(pExpr->u.zToken,"false")==0 );
111345 return pExpr->u.zToken[4]==0;
111349 ** If pExpr is an AND or OR expression, try to simplify it by eliminating
111361 SQLITE_PRIVATE Expr *sqlite3ExprSimplifiedAndOr(Expr *pExpr){
111362 assert( pExpr!=0 );
111363 if( pExpr->op==TK_AND || pExpr->op==TK_OR ){
111364 Expr *pRight = sqlite3ExprSimplifiedAndOr(pExpr->pRight);
111365 Expr *pLeft = sqlite3ExprSimplifiedAndOr(pExpr->pLeft);
111367 pExpr = pExpr->op==TK_AND ? pRight : pLeft;
111369 pExpr = pExpr->op==TK_AND ? pLeft : pRight;
111372 return pExpr;
111376 ** pExpr is a TK_FUNCTION node. Try to determine whether or not the
111385 ** This routine sets pWalker->eCode to 0 if pExpr is not a constant.
111386 ** It makes no changes to pWalker->eCode if pExpr is constant. In
111393 Expr *pExpr
111400 assert( pExpr->op==TK_FUNCTION );
111401 if( ExprHasProperty(pExpr, EP_TokenOnly)
111402 || (pList = pExpr->x.pList)==0
111411 pDef = sqlite3FindFunction(db, pExpr->u.zToken, n, ENC(db), 0);
111415 || ExprHasProperty(pExpr, EP_WinFunc)
111450 static int exprNodeIsConstant(Walker *pWalker, Expr *pExpr){
111456 if( pWalker->eCode==2 && ExprHasProperty(pExpr, EP_OuterON) ){
111461 switch( pExpr->op ){
111466 if( (pWalker->eCode>=4 || ExprHasProperty(pExpr,EP_ConstFunc))
111467 && !ExprHasProperty(pExpr, EP_WinFunc)
111469 if( pWalker->eCode==5 ) ExprSetProperty(pExpr, EP_FromDDL);
111472 return exprNodeIsConstantFunction(pWalker, pExpr);
111480 if( sqlite3ExprIdToTrueFalse(pExpr) ){
111487 testcase( pExpr->op==TK_ID );
111488 testcase( pExpr->op==TK_COLUMN );
111489 testcase( pExpr->op==TK_AGG_FUNCTION );
111490 testcase( pExpr->op==TK_AGG_COLUMN );
111491 if( ExprHasProperty(pExpr, EP_FixedCol) && pWalker->eCode!=2 ){
111494 if( pWalker->eCode==3 && pExpr->iTable==pWalker->u.iCur ){
111502 testcase( pExpr->op==TK_REGISTER );
111503 testcase( pExpr->op==TK_IF_NULL_ROW );
111504 testcase( pExpr->op==TK_DOT );
111505 testcase( pExpr->op==TK_RAISE );
111513 pExpr->op = TK_NULL;
111522 testcase( pExpr->op==TK_SELECT ); /* sqlite3SelectWalkFail() disallows */
111523 testcase( pExpr->op==TK_EXISTS ); /* sqlite3SelectWalkFail() disallows */
111619 ** Check pExpr to see if it is an constraint on the single data source
111620 ** pSrc = &pSrcList->a[iSrc]. In other words, check to see if pExpr
111622 ** sources anywhere else in the query. Return true (non-zero) if pExpr
111631 ** (1) pExpr cannot refer to any table other than pSrc->iCursor.
111633 ** (2a) pExpr cannot use subqueries unless the bAllowSubq parameter is
111636 ** (2b) pExpr cannot use non-deterministic functions.
111642 ** (4a) pExpr must come from an ON clause..
111646 ** operand of a RIGHT JOIN, then pExpr must be from the WHERE
111651 ** (6a) pExpr does not originate in an ON or USING clause, or
111653 ** (6b) The ON or USING clause from which pExpr is derived is
111656 ** Without this restriction, accepting pExpr as a single-table
111663 Expr *pExpr, /* The constraint */
111673 if( !ExprHasProperty(pExpr, EP_OuterON) ) return 0; /* rule (4a) */
111674 if( pExpr->w.iJoin!=pSrc->iCursor ) return 0; /* rule (4b) */
111676 if( ExprHasProperty(pExpr, EP_OuterON) ) return 0; /* rule (5) */
111678 if( ExprHasProperty(pExpr, EP_OuterON|EP_InnerON) /* (6a) */
111683 if( pExpr->w.iJoin==pSrcList->a[jj].iCursor ){
111692 return sqlite3ExprIsTableConstant(pExpr, pSrc->iCursor, bAllowSubq);
111699 static int exprNodeIsConstantOrGroupBy(Walker *pWalker, Expr *pExpr){
111703 /* Check if pExpr is identical to any GROUP BY term. If so, consider
111706 Expr *p = pGroupBy->a[i].pExpr;
111707 if( sqlite3ExprCompare(0, pExpr, p, -1)<2 ){
111715 /* Check if pExpr is a sub-select. If so, consider it variable. */
111716 if( ExprUseXSelect(pExpr) ){
111721 return exprNodeIsConstant(pWalker, pExpr);
111993 Expr *pRes = pEList->a[i].pExpr;
112148 if( sqlite3ExprCanBeNull(pEList->a[i].pExpr) ) break;
112166 assert( p->pEList->a[0].pExpr!=0 ); /* Because of isCandidateForInOpt(p) */
112177 if( nExpr==1 && pEList->a[0].pExpr->iColumn<0 ){
112198 int iCol = pEList->a[i].pExpr->iColumn;
112241 Expr *pRhs = pEList->a[i].pExpr;
112339 ** Argument pExpr is an (?, ?...) IN(...) expression. This
112346 static char *exprINAffinity(Parse *pParse, const Expr *pExpr){
112347 Expr *pLeft = pExpr->pLeft;
112349 Select *pSelect = ExprUseXSelect(pExpr) ? pExpr->x.pSelect : 0;
112352 assert( pExpr->op==TK_IN );
112360 zRet[i] = sqlite3CompareAffinity(pSelect->pEList->a[i].pExpr, a);
112387 ** Expression pExpr is a vector that has been used in a context where
112388 ** it is not permitted. If pExpr is a sub-select vector, this routine
112397 SQLITE_PRIVATE void sqlite3VectorErrorMsg(Parse *pParse, Expr *pExpr){
112399 if( ExprUseXSelect(pExpr) ){
112400 sqlite3SubselectError(pParse, pExpr->x.pSelect->pEList->nExpr, 1);
112417 ** The pExpr parameter is the IN operator. The cursor number for the
112419 ** table is computed, the cursor number is also stored in pExpr->iTable,
112433 Expr *pExpr, /* The IN operator */
112456 if( !ExprHasProperty(pExpr, EP_VarSelect) && pParse->iSelfTab==0 ){
112461 if( ExprHasProperty(pExpr, EP_Subrtn) ){
112463 if( ExprUseXSelect(pExpr) ){
112465 pExpr->x.pSelect->selId));
112467 assert( ExprUseYSub(pExpr) );
112468 sqlite3VdbeAddOp2(v, OP_Gosub, pExpr->y.sub.regReturn,
112469 pExpr->y.sub.iAddr);
112470 assert( iTab!=pExpr->iTable );
112471 sqlite3VdbeAddOp2(v, OP_OpenDup, iTab, pExpr->iTable);
112477 assert( !ExprUseYWin(pExpr) );
112478 ExprSetProperty(pExpr, EP_Subrtn);
112479 assert( !ExprHasProperty(pExpr, EP_TokenOnly|EP_Reduced) );
112480 pExpr->y.sub.regReturn = ++pParse->nMem;
112481 pExpr->y.sub.iAddr =
112482 sqlite3VdbeAddOp2(v, OP_BeginSubrtn, 0, pExpr->y.sub.regReturn) + 1;
112488 pLeft = pExpr->pLeft;
112494 pExpr->iTable = iTab;
112495 addr = sqlite3VdbeAddOp2(v, OP_OpenEphemeral, pExpr->iTable, nVal);
112497 if( ExprUseXSelect(pExpr) ){
112498 VdbeComment((v, "Result of SELECT %u", pExpr->x.pSelect->selId));
112505 if( ExprUseXSelect(pExpr) ){
112511 Select *pSelect = pExpr->x.pSelect;
112525 dest.zAffSdst = exprINAffinity(pParse, pExpr);
112544 pParse, p, pEList->a[i].pExpr
112548 }else if( ALWAYS(pExpr->x.pList!=0) ){
112558 ExprList *pList = pExpr->x.pList;
112569 pKeyInfo->aColl[0] = sqlite3ExprCollSeq(pParse, pExpr->pLeft);
112576 Expr *pE2 = pItem->pExpr;
112586 ExprClearProperty(pExpr, EP_Subrtn);
112605 assert( ExprUseYSub(pExpr) );
112606 assert( sqlite3VdbeGetOp(v,pExpr->y.sub.iAddr-1)->opcode==OP_BeginSubrtn
112608 sqlite3VdbeAddOp3(v, OP_Return, pExpr->y.sub.regReturn,
112609 pExpr->y.sub.iAddr, 1);
112623 ** The pExpr parameter is the SELECT or EXISTS operator to be coded.
112631 SQLITE_PRIVATE int sqlite3CodeSubselect(Parse *pParse, Expr *pExpr){
112645 testcase( pExpr->op==TK_EXISTS );
112646 testcase( pExpr->op==TK_SELECT );
112647 assert( pExpr->op==TK_EXISTS || pExpr->op==TK_SELECT );
112648 assert( ExprUseXSelect(pExpr) );
112649 pSel = pExpr->x.pSelect;
112653 if( ExprHasProperty(pExpr, EP_Subrtn) ){
112655 assert( ExprUseYSub(pExpr) );
112656 sqlite3VdbeAddOp2(v, OP_Gosub, pExpr->y.sub.regReturn,
112657 pExpr->y.sub.iAddr);
112658 return pExpr->iTable;
112662 assert( !ExprUseYWin(pExpr) );
112663 assert( !ExprHasProperty(pExpr, EP_Reduced|EP_TokenOnly) );
112664 ExprSetProperty(pExpr, EP_Subrtn);
112665 pExpr->y.sub.regReturn = ++pParse->nMem;
112666 pExpr->y.sub.iAddr =
112667 sqlite3VdbeAddOp2(v, OP_BeginSubrtn, 0, pExpr->y.sub.regReturn) + 1;
112679 if( !ExprHasProperty(pExpr, EP_VarSelect) ){
112696 nReg = pExpr->op==TK_SELECT ? pSel->pEList->nExpr : 1;
112699 if( pExpr->op==TK_SELECT ){
112729 pExpr->op2 = pExpr->op;
112730 pExpr->op = TK_ERROR;
112733 pExpr->iTable = rReg = dest.iSDParm;
112734 ExprSetVVAProperty(pExpr, EP_NoReduce);
112741 assert( ExprUseYSub(pExpr) );
112742 assert( sqlite3VdbeGetOp(v,pExpr->y.sub.iAddr-1)->opcode==OP_BeginSubrtn
112744 sqlite3VdbeAddOp3(v, OP_Return, pExpr->y.sub.regReturn,
112745 pExpr->y.sub.iAddr, 1);
112802 Expr *pExpr, /* The IN expression */
112825 assert( !ExprHasVVAProperty(pExpr,EP_Immutable) );
112826 pLeft = pExpr->pLeft;
112827 if( sqlite3ExprCheckIN(pParse, pExpr) ) return;
112828 zAff = exprINAffinity(pParse, pExpr);
112829 nVector = sqlite3ExprVectorSize(pExpr->pLeft);
112842 eType = sqlite3FindInIndex(pParse, pExpr,
112901 assert( ExprUseXList(pExpr) );
112902 pList = pExpr->x.pList;
112903 pColl = sqlite3ExprCollSeq(pParse, pExpr->pLeft);
112909 r2 = sqlite3ExprCodeTemp(pParse, pList->a[ii].pExpr, ®ToFree);
112910 if( regCkNull && sqlite3ExprCanBeNull(pList->a[ii].pExpr) ){
112952 Expr *p = sqlite3VectorFieldSubexpr(pExpr->pLeft, i);
113076 static void codeInteger(Parse *pParse, Expr *pExpr, int negFlag, int iMem){
113078 if( pExpr->flags & EP_IntValue ){
113079 int i = pExpr->u.iValue;
113086 const char *z = pExpr->u.zToken;
113091 sqlite3ErrorMsg(pParse, "oversized integer: %s%#T", negFlag?"-":"",pExpr);
113096 negFlag?"-":"",pExpr);
113126 sqlite3ExprCodeCopy(pParse, pIdx->aColExpr->a[iIdxCol].pExpr, regOut);
113257 static void exprToRegister(Expr *pExpr, int iReg){
113258 Expr *p = sqlite3ExprSkipCollateAndLikely(pExpr);
113295 sqlite3ExprCodeFactorable(pParse, p->x.pList->a[i].pExpr, i+iResult);
113337 sqlite3ExprCode(pParse, pFarg->a[0].pExpr, target);
113341 sqlite3ExprCode(pParse, pFarg->a[i].pExpr, target);
113356 Expr *pArg = pFarg->a[0].pExpr;
113370 target = sqlite3ExprCodeTarget(pParse, pFarg->a[0].pExpr, target);
113383 sqlite3ExprCompare(0,pFarg->a[0].pExpr, pFarg->a[1].pExpr,-1),
113392 sqlite3ExprImpliesExpr(pParse,pFarg->a[0].pExpr, pFarg->a[1].pExpr,-1),
113401 pA1 = pFarg->a[1].pExpr;
113404 sqlite3ExprImpliesNonNullRow(pFarg->a[0].pExpr,pA1->iTable,1),
113421 aff = sqlite3ExprAffinity(pFarg->a[0].pExpr);
113434 ** Check to see if pExpr is one of the indexed expressions on pParse->pIdxEpr.
113436 ** return the register into which the value has been read. If pExpr is
113441 Expr *pExpr, /* The expression to potentially bypass */
113454 if( sqlite3ExprCompare(0, pExpr, p->pExpr, iDataCur)!=0 ) continue;
113456 exprAff = sqlite3ExprAffinity(pExpr);
113479 sqlite3ExprCode(pParse, pExpr, target);
113493 ** Expresion pExpr is guaranteed to be a TK_COLUMN or equivalent. This
113502 static int exprPartidxExprLookup(Parse *pParse, Expr *pExpr, int iTarget){
113505 if( pExpr->iColumn==p->iIdxCol && pExpr->iTable==p->iDataCur ){
113513 ret = sqlite3ExprCodeTarget(pParse, p->pExpr, iTarget);
113538 SQLITE_PRIVATE int sqlite3ExprCodeTarget(Parse *pParse, Expr *pExpr, int target){
113552 if( pExpr==0 ){
113555 && !ExprHasProperty(pExpr, EP_Leaf)
113556 && (r1 = sqlite3IndexedExprLookup(pParse, pExpr, target))>=0
113560 assert( !ExprHasVVAProperty(pExpr,EP_Immutable) );
113561 op = pExpr->op;
113566 AggInfo *pAggInfo = pExpr->pAggInfo;
113569 assert( pExpr->iAgg>=0 );
113570 if( pExpr->iAgg>=pAggInfo->nColumn ){
113582 pCol = &pAggInfo->aCol[pExpr->iAgg];
113584 return AggInfoColumnReg(pAggInfo, pExpr->iAgg);
113601 }else if( pExpr->y.pTab==0 ){
113604 sqlite3VdbeAddOp3(v, OP_Column, pExpr->iTable, pExpr->iColumn, target);
113611 int iTab = pExpr->iTable;
113613 if( ExprHasProperty(pExpr, EP_FixedCol) ){
113615 ** constraints, and that constant is coded by the pExpr->pLeft
113621 iReg = sqlite3ExprCodeTarget(pParse, pExpr->pLeft,target);
113622 assert( ExprUseYTab(pExpr) );
113623 assert( pExpr->y.pTab!=0 );
113624 aff = sqlite3TableColumnAffinity(pExpr->y.pTab, pExpr->iColumn);
113645 int iCol = pExpr->iColumn;
113646 assert( ExprUseYTab(pExpr) );
113647 pTab = pExpr->y.pTab;
113686 && 0!=(r1 = exprPartidxExprLookup(pParse, pExpr, target))
113690 assert( ExprUseYTab(pExpr) );
113691 assert( pExpr->y.pTab!=0 );
113692 iReg = sqlite3ExprCodeGetColumn(pParse, pExpr->y.pTab,
113693 pExpr->iColumn, iTab, target,
113694 pExpr->op2);
113698 codeInteger(pParse, pExpr, 0, target);
113702 sqlite3VdbeAddOp2(v, OP_Integer, sqlite3ExprTruthValue(pExpr), target);
113707 assert( !ExprHasProperty(pExpr, EP_IntValue) );
113708 codeReal(v, pExpr->u.zToken, 0, target);
113713 assert( !ExprHasProperty(pExpr, EP_IntValue) );
113714 sqlite3VdbeLoadString(v, target, pExpr->u.zToken);
113731 assert( !ExprHasProperty(pExpr, EP_IntValue) );
113732 assert( pExpr->u.zToken[0]=='x' || pExpr->u.zToken[0]=='X' );
113733 assert( pExpr->u.zToken[1]=='\'' );
113734 z = &pExpr->u.zToken[2];
113743 assert( !ExprHasProperty(pExpr, EP_IntValue) );
113744 assert( pExpr->u.zToken!=0 );
113745 assert( pExpr->u.zToken[0]!=0 );
113746 sqlite3VdbeAddOp2(v, OP_Variable, pExpr->iColumn, target);
113750 return pExpr->iTable;
113755 sqlite3ExprCode(pParse, pExpr->pLeft, target);
113757 assert( !ExprHasProperty(pExpr, EP_IntValue) );
113759 sqlite3AffinityType(pExpr->u.zToken, 0));
113774 Expr *pLeft = pExpr->pLeft;
113776 codeVectorCompare(pParse, pExpr, target, op, p5);
113779 r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, ®Free2);
113781 codeCompare(pParse, pLeft, pExpr->pRight, op, r1, r2,
113783 ExprHasProperty(pExpr,EP_Commuted));
113823 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1);
113824 r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, ®Free2);
113831 Expr *pLeft = pExpr->pLeft;
113838 assert( !ExprHasProperty(pExpr, EP_IntValue) );
113848 r2 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free2);
113858 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1);
113866 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1);
113868 isTrue = sqlite3ExprTruthValue(pExpr->pRight);
113869 bNormal = pExpr->op2==TK_IS;
113881 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1);
113891 AggInfo *pInfo = pExpr->pAggInfo;
113893 || NEVER(pExpr->iAgg<0)
113894 || NEVER(pExpr->iAgg>=pInfo->nFunc)
113896 assert( !ExprHasProperty(pExpr, EP_IntValue) );
113897 sqlite3ErrorMsg(pParse, "misuse of aggregate: %#T()", pExpr);
113899 return AggInfoFuncReg(pInfo, pExpr->iAgg);
113915 if( ExprHasProperty(pExpr, EP_WinFunc) ){
113916 return pExpr->y.pWin->regResult;
113921 && sqlite3ExprIsConstantNotJoin(pParse,pExpr)
113925 return sqlite3ExprCodeRunJustOnce(pParse, pExpr, -1);
113927 assert( !ExprHasProperty(pExpr, EP_TokenOnly) );
113928 assert( ExprUseXList(pExpr) );
113929 pFarg = pExpr->x.pList;
113931 assert( !ExprHasProperty(pExpr, EP_IntValue) );
113932 zId = pExpr->u.zToken;
113940 sqlite3ErrorMsg(pParse, "unknown function: %#T()", pExpr);
113949 sqlite3ExprFunctionUsable(pParse, pExpr, pDef);
113953 if( i<32 && sqlite3ExprIsConstant(pParse, pFarg->a[i].pExpr) ){
113958 pColl = sqlite3ExprCollSeq(pParse, pFarg->a[i].pExpr);
113977 assert( pFarg->a[0].pExpr!=0 );
113978 exprOp = pFarg->a[0].pExpr->op;
113987 pFarg->a[0].pExpr->op2 = pDef->funcFlags & OPFLAG_BYTELENARG;
114008 if( nFarg>=2 && ExprHasProperty(pExpr, EP_InfixFunc) ){
114009 pDef = sqlite3VtabOverloadFunction(db, pDef, nFarg, pFarg->a[1].pExpr);
114011 pDef = sqlite3VtabOverloadFunction(db, pDef, nFarg, pFarg->a[0].pExpr);
114019 pDef, pExpr->op2);
114038 && ALWAYS( ExprUseXSelect(pExpr) )
114039 && (nCol = pExpr->x.pSelect->pEList->nExpr)!=1
114043 return sqlite3CodeSubselect(pParse, pExpr);
114049 Expr *pLeft = pExpr->pLeft;
114056 if( pExpr->iTable!=n ){
114058 pExpr->iTable, n);
114060 return pLeft->iTable + pExpr->iColumn;
114066 sqlite3ExprCodeIN(pParse, pExpr, destIfFalse, destIfNull);
114083 ** X is stored in pExpr->pLeft.
114084 ** Y is stored in pExpr->pList->a[0].pExpr.
114085 ** Z is stored in pExpr->pList->a[1].pExpr.
114088 exprCodeBetween(pParse, pExpr, target, 0, 0);
114092 if( !ExprHasProperty(pExpr, EP_Collate) ){
114099 assert( pExpr->pLeft );
114100 sqlite3ExprCode(pParse, pExpr->pLeft, target);
114104 pExpr = pExpr->pLeft;
114110 pExpr = pExpr->pLeft;
114144 assert( ExprUseYTab(pExpr) );
114145 pTab = pExpr->y.pTab;
114146 iCol = pExpr->iColumn;
114147 p1 = pExpr->iTable * (pTab->nCol+1) + 1
114150 assert( pExpr->iTable==0 || pExpr->iTable==1 );
114157 (pExpr->iTable ? "new" : "old"),
114158 (pExpr->iColumn<0 ? "rowid" : pExpr->y.pTab->aCol[iCol].zCnName)
114188 AggInfo *pAggInfo = pExpr->pAggInfo;
114190 assert( pExpr->iAgg>=0 && pExpr->iAgg<pAggInfo->nColumn );
114192 inReg = AggInfoColumnReg(pAggInfo, pExpr->iAgg);
114195 if( pExpr->pAggInfo->useSortingIdx ){
114197 pAggInfo->aCol[pExpr->iAgg].iSorterColumn,
114203 addrINR = sqlite3VdbeAddOp3(v, OP_IfNullRow, pExpr->iTable, 0, target);
114212 sqlite3ExprCode(pParse, pExpr->pLeft, target);
114230 ** X (if it exists) is in pExpr->pLeft.
114231 ** Y is in the last element of pExpr->x.pList if pExpr->x.pList->nExpr is
114234 ** Ei is in pExpr->pList->a[i*2] and Ri is pExpr->pList->a[i*2+1].
114253 assert( ExprUseXList(pExpr) && pExpr->x.pList!=0 );
114254 assert(pExpr->x.pList->nExpr > 0);
114255 pEList = pExpr->x.pList;
114259 if( (pX = pExpr->pLeft)!=0 ){
114281 opCompare.pRight = aListelem[i].pExpr;
114283 pTest = aListelem[i].pExpr;
114288 testcase( aListelem[i+1].pExpr->op==TK_COLUMN );
114289 sqlite3ExprCode(pParse, aListelem[i+1].pExpr, target);
114294 sqlite3ExprCode(pParse, pEList->a[nExpr-1].pExpr, target);
114305 assert( pExpr->affExpr==OE_Rollback
114306 || pExpr->affExpr==OE_Abort
114307 || pExpr->affExpr==OE_Fail
114308 || pExpr->affExpr==OE_Ignore
114315 if( pExpr->affExpr==OE_Abort ){
114318 assert( !ExprHasProperty(pExpr, EP_IntValue) );
114319 if( pExpr->affExpr==OE_Ignore ){
114321 v, OP_Halt, SQLITE_OK, OE_Ignore, 0, pExpr->u.zToken,0);
114326 pExpr->affExpr, pExpr->u.zToken, 0, 0);
114339 ** Generate code that will evaluate expression pExpr just one time
114357 Expr *pExpr, /* The expression to code when the VDBE initializes */
114369 && sqlite3ExprCompare(0,pItem->pExpr,pExpr,-1)==0
114375 pExpr = sqlite3ExprDup(pParse->db, pExpr, 0);
114376 if( pExpr!=0 && ExprHasProperty(pExpr, EP_HasFunc) ){
114384 sqlite3ExprCode(pParse, pExpr, regDest);
114387 sqlite3ExprDelete(pParse->db, pExpr);
114390 p = sqlite3ExprListAppend(pParse, p, pExpr);
114411 ** If pExpr is a constant, then this routine might generate this
114415 SQLITE_PRIVATE int sqlite3ExprCodeTemp(Parse *pParse, Expr *pExpr, int *pReg){
114417 pExpr = sqlite3ExprSkipCollateAndLikely(pExpr);
114419 && ALWAYS(pExpr!=0)
114420 && pExpr->op!=TK_REGISTER
114421 && sqlite3ExprIsConstantNotJoin(pParse, pExpr)
114424 r2 = sqlite3ExprCodeRunJustOnce(pParse, pExpr, -1);
114427 r2 = sqlite3ExprCodeTarget(pParse, pExpr, r1);
114439 ** Generate code that will evaluate expression pExpr and store the
114443 SQLITE_PRIVATE void sqlite3ExprCode(Parse *pParse, Expr *pExpr, int target){
114446 assert( pExpr==0 || !ExprHasVVAProperty(pExpr,EP_Immutable) );
114450 inReg = sqlite3ExprCodeTarget(pParse, pExpr, target);
114453 Expr *pX = sqlite3ExprSkipCollateAndLikely(pExpr);
114454 testcase( pX!=pExpr );
114467 ** Make a transient copy of expression pExpr and then code it using
114471 SQLITE_PRIVATE void sqlite3ExprCodeCopy(Parse *pParse, Expr *pExpr, int target){
114473 pExpr = sqlite3ExprDup(db, pExpr, 0);
114474 if( !db->mallocFailed ) sqlite3ExprCode(pParse, pExpr, target);
114475 sqlite3ExprDelete(db, pExpr);
114479 ** Generate code that will evaluate expression pExpr and store the
114484 SQLITE_PRIVATE void sqlite3ExprCodeFactorable(Parse *pParse, Expr *pExpr, int target){
114485 if( pParse->okConstFactor && sqlite3ExprIsConstantNotJoin(pParse,pExpr) ){
114486 sqlite3ExprCodeRunJustOnce(pParse, pExpr, target);
114488 sqlite3ExprCodeCopy(pParse, pExpr, target);
114529 Expr *pExpr = pItem->pExpr;
114544 && sqlite3ExprIsConstantNotJoin(pParse,pExpr)
114546 sqlite3ExprCodeRunJustOnce(pParse, pExpr, target+i);
114548 int inReg = sqlite3ExprCodeTarget(pParse, pExpr, target+i);
114589 Expr *pExpr, /* The BETWEEN expression */
114605 assert( ExprUseXList(pExpr) );
114606 pDel = sqlite3ExprDup(db, pExpr->pLeft, 0);
114613 compLeft.pRight = pExpr->x.pList->a[0].pExpr;
114616 compRight.pRight = pExpr->x.pList->a[1].pExpr;
114659 SQLITE_PRIVATE void sqlite3ExprIfTrue(Parse *pParse, Expr *pExpr, int dest, int jumpIfNull){
114668 if( NEVER(pExpr==0) ) return; /* No way this can happen */
114669 assert( !ExprHasVVAProperty(pExpr, EP_Immutable) );
114670 op = pExpr->op;
114674 Expr *pAlt = sqlite3ExprSimplifiedAndOr(pExpr);
114675 if( pAlt!=pExpr ){
114680 sqlite3ExprIfFalse(pParse, pExpr->pLeft, d2,
114682 sqlite3ExprIfTrue(pParse, pExpr->pRight, dest, jumpIfNull);
114686 sqlite3ExprIfTrue(pParse, pExpr->pLeft, dest, jumpIfNull);
114687 sqlite3ExprIfTrue(pParse, pExpr->pRight, dest, jumpIfNull);
114693 sqlite3ExprIfFalse(pParse, pExpr->pLeft, dest, jumpIfNull);
114700 isNot = pExpr->op2==TK_ISNOT;
114701 isTrue = sqlite3ExprTruthValue(pExpr->pRight);
114705 sqlite3ExprIfTrue(pParse, pExpr->pLeft, dest,
114708 sqlite3ExprIfFalse(pParse, pExpr->pLeft, dest,
114726 if( sqlite3ExprIsVector(pExpr->pLeft) ) goto default_expr;
114728 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1);
114729 r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, ®Free2);
114730 codeCompare(pParse, pExpr->pLeft, pExpr->pRight, op,
114731 r1, r2, dest, jumpIfNull, ExprHasProperty(pExpr,EP_Commuted));
114750 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1);
114760 exprCodeBetween(pParse, pExpr, dest, sqlite3ExprIfTrue, jumpIfNull);
114767 sqlite3ExprCodeIN(pParse, pExpr, destIfFalse, destIfNull);
114775 if( ExprAlwaysTrue(pExpr) ){
114777 }else if( ExprAlwaysFalse(pExpr) ){
114780 r1 = sqlite3ExprCodeTemp(pParse, pExpr, ®Free1);
114802 SQLITE_PRIVATE void sqlite3ExprIfFalse(Parse *pParse, Expr *pExpr, int dest, int jumpIfNull){
114811 if( pExpr==0 ) return;
114812 assert( !ExprHasVVAProperty(pExpr,EP_Immutable) );
114814 /* The value of pExpr->op and op are related as follows:
114816 ** pExpr->op op
114827 ** For other values of pExpr->op, op is undefined and unused.
114832 op = ((pExpr->op+(TK_ISNULL&1))^1)-(TK_ISNULL&1);
114836 assert( pExpr->op!=TK_ISNULL || op==OP_NotNull );
114837 assert( pExpr->op!=TK_NOTNULL || op==OP_IsNull );
114838 assert( pExpr->op!=TK_NE || op==OP_Eq );
114839 assert( pExpr->op!=TK_EQ || op==OP_Ne );
114840 assert( pExpr->op!=TK_LT || op==OP_Ge );
114841 assert( pExpr->op!=TK_LE || op==OP_Gt );
114842 assert( pExpr->op!=TK_GT || op==OP_Le );
114843 assert( pExpr->op!=TK_GE || op==OP_Lt );
114845 switch( pExpr->op ){
114848 Expr *pAlt = sqlite3ExprSimplifiedAndOr(pExpr);
114849 if( pAlt!=pExpr ){
114851 }else if( pExpr->op==TK_AND ){
114853 sqlite3ExprIfFalse(pParse, pExpr->pLeft, dest, jumpIfNull);
114854 sqlite3ExprIfFalse(pParse, pExpr->pRight, dest, jumpIfNull);
114858 sqlite3ExprIfTrue(pParse, pExpr->pLeft, d2,
114860 sqlite3ExprIfFalse(pParse, pExpr->pRight, dest, jumpIfNull);
114867 sqlite3ExprIfTrue(pParse, pExpr->pLeft, dest, jumpIfNull);
114874 isNot = pExpr->op2==TK_ISNOT;
114875 isTrue = sqlite3ExprTruthValue(pExpr->pRight);
114880 sqlite3ExprIfFalse(pParse, pExpr->pLeft, dest,
114885 sqlite3ExprIfTrue(pParse, pExpr->pLeft, dest,
114892 testcase( pExpr->op==TK_IS );
114893 testcase( pExpr->op==TK_ISNOT );
114894 op = (pExpr->op==TK_IS) ? TK_NE : TK_EQ;
114903 if( sqlite3ExprIsVector(pExpr->pLeft) ) goto default_expr;
114905 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1);
114906 r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, ®Free2);
114907 codeCompare(pParse, pExpr->pLeft, pExpr->pRight, op,
114908 r1, r2, dest, jumpIfNull,ExprHasProperty(pExpr,EP_Commuted));
114925 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1);
114935 exprCodeBetween(pParse, pExpr, dest, sqlite3ExprIfFalse, jumpIfNull);
114941 sqlite3ExprCodeIN(pParse, pExpr, dest, dest);
114944 sqlite3ExprCodeIN(pParse, pExpr, dest, destIfNull);
114952 if( ExprAlwaysFalse(pExpr) ){
114954 }else if( ExprAlwaysTrue(pExpr) ){
114957 r1 = sqlite3ExprCodeTemp(pParse, pExpr, ®Free1);
114971 ** Like sqlite3ExprIfFalse() except that a copy is made of pExpr before
114973 ** ensures that the original pExpr is unchanged.
114975 SQLITE_PRIVATE void sqlite3ExprIfFalseDup(Parse *pParse, Expr *pExpr, int dest,int jumpIfNull){
114977 Expr *pCopy = sqlite3ExprDup(db, pExpr, 0);
114985 ** Expression pVar is guaranteed to be an SQL variable. pExpr may be any
114988 ** If pExpr is a simple SQL value - an integer, real, string, blob
114992 ** Additionally, if pExpr is a simple SQL value and the value is the
114994 ** Otherwise, if the values are not the same or if pExpr is not a simple
115000 const Expr *pExpr
115006 sqlite3ValueFromExpr(pParse->db, pExpr, SQLITE_UTF8, SQLITE_AFF_BLOB, &pR);
115162 Expr *pExprA = pA->a[i].pExpr;
115163 Expr *pExprB = pB->a[i].pExpr;
115212 if( exprImpliesNotNull(pParse, pList->a[0].pExpr, pNN, iTab, 1)
115213 || exprImpliesNotNull(pParse, pList->a[1].pExpr, pNN, iTab, 1)
115334 static int impliesNotNullRow(Walker *pWalker, Expr *pExpr){
115335 testcase( pExpr->op==TK_AGG_COLUMN );
115336 testcase( pExpr->op==TK_AGG_FUNCTION );
115337 if( ExprHasProperty(pExpr, EP_OuterON) ) return WRC_Prune;
115338 if( ExprHasProperty(pExpr, EP_InnerON) && pWalker->mWFlags ){
115346 switch( pExpr->op ){
115355 testcase( pExpr->op==TK_ISNOT );
115356 testcase( pExpr->op==TK_ISNULL );
115357 testcase( pExpr->op==TK_NOTNULL );
115358 testcase( pExpr->op==TK_IS );
115359 testcase( pExpr->op==TK_VECTOR );
115360 testcase( pExpr->op==TK_FUNCTION );
115361 testcase( pExpr->op==TK_TRUTH );
115362 testcase( pExpr->op==TK_CASE );
115366 if( pWalker->u.iCur==pExpr->iTable ){
115381 testcase( pExpr->op==TK_OR );
115382 testcase( pExpr->op==TK_AND );
115383 bothImplyNotNullRow(pWalker, pExpr->pLeft, pExpr->pRight);
115391 if( ExprUseXList(pExpr) && ALWAYS(pExpr->x.pList->nExpr>0) ){
115392 sqlite3WalkExpr(pWalker, pExpr->pLeft);
115399 assert( ExprUseXList(pExpr) );
115400 assert( pExpr->x.pList->nExpr==2 );
115401 sqlite3WalkExpr(pWalker, pExpr->pLeft);
115402 bothImplyNotNullRow(pWalker, pExpr->x.pList->a[0].pExpr,
115403 pExpr->x.pList->a[1].pExpr);
115415 Expr *pLeft = pExpr->pLeft;
115416 Expr *pRight = pExpr->pRight;
115417 testcase( pExpr->op==TK_EQ );
115418 testcase( pExpr->op==TK_NE );
115419 testcase( pExpr->op==TK_LT );
115420 testcase( pExpr->op==TK_LE );
115421 testcase( pExpr->op==TK_GT );
115422 testcase( pExpr->op==TK_GE );
115504 static int exprIdxCover(Walker *pWalker, Expr *pExpr){
115505 if( pExpr->op==TK_COLUMN
115506 && pExpr->iTable==pWalker->u.pIdxCover->iCur
115507 && sqlite3TableColumnToIndex(pWalker->u.pIdxCover->pIdx, pExpr->iColumn)<0
115517 ** the expression pExpr. Return true if the index does cover the
115518 ** expression and false if the pExpr expression references table columns
115526 Expr *pExpr, /* The index to be tested */
115537 sqlite3WalkExpr(&w, pExpr);
115555 ** When entering a new subquery on the pExpr argument, add all FROM clause
115597 static int exprRefToSrcList(Walker *pWalker, Expr *pExpr){
115598 if( pExpr->op==TK_COLUMN
115599 || pExpr->op==TK_AGG_COLUMN
115606 if( pExpr->iTable==pSrc->a[i].iCursor ){
115611 for(i=0; i<p->nExclude && p->aiExclude[i]!=pExpr->iTable; i++){}
115620 ** Check to see if pExpr references any tables in pSrcList.
115623 ** 1 pExpr does references a table in pSrcList.
115625 ** 0 pExpr references some table that is not defined in either
115626 ** pSrcList or in subqueries of pExpr itself.
115628 ** -1 pExpr only references no tables at all, or it only
115629 ** references tables defined in subqueries of pExpr itself.
115631 ** As currently used, pExpr is always an aggregate function call. That
115634 SQLITE_PRIVATE int sqlite3ReferencesSrcList(Parse *pParse, Expr *pExpr, SrcList *pSrcList){
115646 assert( pExpr->op==TK_AGG_FUNCTION );
115647 assert( ExprUseXList(pExpr) );
115648 sqlite3WalkExprList(&w, pExpr->x.pList);
115649 if( pExpr->pLeft ){
115650 assert( pExpr->pLeft->op==TK_ORDER );
115651 assert( ExprUseXList(pExpr->pLeft) );
115652 assert( pExpr->pLeft->x.pList!=0 );
115653 sqlite3WalkExprList(&w, pExpr->pLeft->x.pList);
115656 if( ExprHasProperty(pExpr, EP_WinFunc) ){
115657 sqlite3WalkExpr(&w, pExpr->y.pWin->pFilter);
115675 ** it does, make a copy. This is done because the pExpr argument is
115681 static int agginfoPersistExprCb(Walker *pWalker, Expr *pExpr){
115682 if( ALWAYS(!ExprHasProperty(pExpr, EP_TokenOnly|EP_Reduced))
115683 && pExpr->pAggInfo!=0
115685 AggInfo *pAggInfo = pExpr->pAggInfo;
115686 int iAgg = pExpr->iAgg;
115690 if( pExpr->op!=TK_AGG_FUNCTION ){
115692 && pAggInfo->aCol[iAgg].pCExpr==pExpr
115694 pExpr = sqlite3ExprDup(db, pExpr, 0);
115695 if( pExpr && !sqlite3ExprDeferredDelete(pParse, pExpr) ){
115696 pAggInfo->aCol[iAgg].pCExpr = pExpr;
115700 assert( pExpr->op==TK_AGG_FUNCTION );
115702 && pAggInfo->aFunc[iAgg].pFExpr==pExpr
115704 pExpr = sqlite3ExprDup(db, pExpr, 0);
115705 if( pExpr && !sqlite3ExprDeferredDelete(pParse, pExpr) ){
115706 pAggInfo->aFunc[iAgg].pFExpr = pExpr;
115767 Expr *pExpr /* Expr describing the column to find or insert */
115775 if( pCol->pCExpr==pExpr ) return;
115776 if( pCol->iTable==pExpr->iTable
115777 && pCol->iColumn==pExpr->iColumn
115778 && pExpr->op!=TK_IF_NULL_ROW
115790 assert( ExprUseYTab(pExpr) );
115791 pCol->pTab = pExpr->y.pTab;
115792 pCol->iTable = pExpr->iTable;
115793 pCol->iColumn = pExpr->iColumn;
115795 pCol->pCExpr = pExpr;
115796 if( pAggInfo->pGroupBy && pExpr->op!=TK_IF_NULL_ROW ){
115802 Expr *pE = pTerm->pExpr;
115804 && pE->iTable==pExpr->iTable
115805 && pE->iColumn==pExpr->iColumn
115816 ExprSetVVAProperty(pExpr, EP_NoReduce);
115817 assert( pExpr->pAggInfo==0 || pExpr->pAggInfo==pAggInfo );
115818 pExpr->pAggInfo = pAggInfo;
115819 if( pExpr->op==TK_COLUMN ){
115820 pExpr->op = TK_AGG_COLUMN;
115822 pExpr->iAgg = (i16)k;
115830 static int analyzeAggregate(Walker *pWalker, Expr *pExpr){
115839 switch( pExpr->op ){
115849 if( sqlite3ExprCompare(0, pExpr, pIEpr->pExpr, iDataCur)==0 ) break;
115852 if( NEVER(!ExprUseYTab(pExpr)) ) break;
115857 if( NEVER(pExpr->pAggInfo!=0) ) break; /* Resolved by outer context */
115860 /* If we reach this point, it means that expression pExpr can be
115872 pAggInfo->aCol[tmp.iAgg].pCExpr = pExpr;
115873 pExpr->pAggInfo = pAggInfo;
115874 pExpr->iAgg = tmp.iAgg;
115880 testcase( pExpr->op==TK_AGG_COLUMN );
115881 testcase( pExpr->op==TK_COLUMN );
115882 testcase( pExpr->op==TK_IF_NULL_ROW );
115888 assert( !ExprHasProperty(pExpr, EP_TokenOnly|EP_Reduced) );
115889 if( pExpr->iTable==pItem->iCursor ){
115890 findOrCreateAggInfoColumn(pParse, pAggInfo, pExpr);
115892 } /* endif pExpr->iTable==pItem->iCursor */
115899 && pWalker->walkerDepth==pExpr->op2
115900 && pExpr->pAggInfo==0
115902 /* Check to see if pExpr is a duplicate of another aggregate
115907 if( NEVER(pItem->pFExpr==pExpr) ) break;
115908 if( sqlite3ExprCompare(0, pItem->pFExpr, pExpr, -1)==0 ){
115913 /* pExpr is original. Make a new entry in pAggInfo->aFunc[]
115919 assert( !ExprHasProperty(pExpr, EP_xIsSelect) );
115921 pItem->pFExpr = pExpr;
115922 assert( ExprUseUToken(pExpr) );
115923 nArg = pExpr->x.pList ? pExpr->x.pList->nExpr : 0;
115925 pExpr->u.zToken, nArg, enc, 0);
115927 if( pExpr->pLeft
115934 assert( pExpr->pLeft->op==TK_ORDER );
115935 assert( ExprUseXList(pExpr->pLeft) );
115937 pOBList = pExpr->pLeft->x.pList;
115942 && sqlite3ExprCompare(0,pOBList->a[0].pExpr,
115943 pExpr->x.pList->a[0].pExpr,0)==0
115946 pItem->bOBUnique = ExprHasProperty(pExpr, EP_Distinct);
115955 if( ExprHasProperty(pExpr, EP_Distinct) && !pItem->bOBUnique ){
115962 /* Make pExpr point to the appropriate pAggInfo->aFunc[] entry
115964 assert( !ExprHasProperty(pExpr, EP_TokenOnly|EP_Reduced) );
115965 ExprSetVVAProperty(pExpr, EP_NoReduce);
115966 pExpr->iAgg = (i16)i;
115967 pExpr->pAggInfo = pAggInfo;
115978 ** Analyze the pExpr expression looking for aggregate functions and
115986 SQLITE_PRIVATE void sqlite3ExprAnalyzeAggregates(NameContext *pNC, Expr *pExpr){
115995 sqlite3WalkExpr(&w, pExpr);
116009 sqlite3ExprAnalyzeAggregates(pNC, pItem->pExpr);
116957 static int renameUnmapExprCb(Walker *pWalker, Expr *pExpr){
116959 sqlite3RenameTokenRemap(pParse, 0, (const void*)pExpr);
116960 if( ExprUseYTab(pExpr) ){
116961 sqlite3RenameTokenRemap(pParse, 0, (const void*)&pExpr->y.pTab);
117053 ** Remove all nodes that are part of expression pExpr from the rename list.
117055 SQLITE_PRIVATE void sqlite3RenameExprUnmap(Parse *pParse, Expr *pExpr){
117063 sqlite3WalkExpr(&sWalker, pExpr);
117156 static int renameColumnExprCb(Walker *pWalker, Expr *pExpr){
117158 if( pExpr->op==TK_TRIGGER
117159 && pExpr->iColumn==p->iCol
117162 renameTokenFind(pWalker->pParse, p, (void*)pExpr);
117163 }else if( pExpr->op==TK_COLUMN
117164 && pExpr->iColumn==p->iCol
117165 && ALWAYS(ExprUseYTab(pExpr))
117166 && p->pTab==pExpr->y.pTab
117168 renameTokenFind(pWalker->pParse, p, (void*)pExpr);
117720 Expr *pExpr = sqlite3ColumnExpr(sParse.pNewTable,
117722 sqlite3WalkExpr(&sWalker, pExpr);
117799 static int renameTableExprCb(Walker *pWalker, Expr *pExpr){
117801 if( pExpr->op==TK_COLUMN
117802 && ALWAYS(ExprUseYTab(pExpr))
117803 && p->pTab==pExpr->y.pTab
117805 renameTokenFind(pWalker->pParse, p, (void*)&pExpr->y.pTab);
118009 static int renameQuotefixExprCb(Walker *pWalker, Expr *pExpr){
118010 if( pExpr->op==TK_STRING && (pExpr->flags & EP_DblQuoted) ){
118011 renameTokenFind(pWalker->pParse, pWalker->u.pRename, (const void*)pExpr);
120505 ** This only applies to the root node of pExpr, so the statement:
120511 static int resolveAttachExpr(NameContext *pName, Expr *pExpr)
120514 if( pExpr ){
120515 if( pExpr->op!=TK_ID ){
120516 rc = sqlite3ResolveExprNames(pName, pExpr);
120518 pExpr->op = TK_STRING;
120931 static int fixExprCb(Walker *p, Expr *pExpr){
120933 if( !pFix->bTemp ) ExprSetProperty(pExpr, EP_FromDDL);
120934 if( pExpr->op==TK_VARIABLE ){
120936 pExpr->op = TK_NULL;
121055 Expr *pExpr /* The expression to be fixed to one database */
121057 return sqlite3WalkExpr(&pFix->w, pExpr);
121196 ** If SQLITE_IGNORE is returned and pExpr is not NULL, then pExpr is changed
121197 ** to an SQL NULL expression. Otherwise, if pExpr is NULL, then SQLITE_IGNORE
121228 ** The pExpr should be a TK_COLUMN expression. The table referred to
121238 Expr *pExpr, /* The expression to check authorization on */
121240 SrcList *pTabList /* All table that pExpr might refer to */
121248 assert( pExpr->op==TK_COLUMN || pExpr->op==TK_TRIGGER );
121258 if( pExpr->op==TK_TRIGGER ){
121263 if( pExpr->iTable==pTabList->a[iSrc].iCursor ){
121269 iCol = pExpr->iColumn;
121283 pExpr->op = TK_NULL;
121623 sqlite3ExprCode(pParse, pEL->a[i].pExpr, pEL->a[i].u.iConstExprReg);
122066 Expr *pExpr /* The new default expression */
122076 pTab->u.tab.pDfltList = sqlite3ExprListAppend(pParse, pList, pExpr);
122078 sqlite3ExprDelete(pParse->db, pList->a[pCol->iDflt-1].pExpr);
122079 pList->a[pCol->iDflt-1].pExpr = pExpr;
122093 return pTab->u.tab.pDfltList->a[pCol->iDflt-1].pExpr;
123098 Expr *pExpr, /* The parsed expression of the default value */
123109 if( !sqlite3ExprIsConstantOrFunction(pExpr, isInit) ){
123119 /* A copy of pExpr is used instead of the original, as pExpr contains
123126 x.pLeft = pExpr;
123134 sqlite3RenameExprUnmap(pParse, pExpr);
123136 sqlite3ExprDelete(db, pExpr);
123222 Expr *pCExpr = sqlite3ExprSkipCollate(pList->a[i].pExpr);
123245 Expr *pCExpr = sqlite3ExprSkipCollate(pList->a[0].pExpr);
123340 SQLITE_PRIVATE void sqlite3AddGenerated(Parse *pParse, Expr *pExpr, Token *pType){
123372 if( ALWAYS(pExpr) && pExpr->op==TK_ID ){
123377 pExpr = sqlite3PExpr(pParse, TK_UPLUS, pExpr, 0);
123379 if( pExpr && pExpr->op!=TK_RAISE ) pExpr->affExpr = pCol->affinity;
123380 sqlite3ColumnSetExpr(pParse, pTab, pCol, pExpr);
123381 pExpr = 0;
123388 sqlite3ExprDelete(pParse->db, pExpr);
123393 sqlite3ExprDelete(pParse->db, pExpr);
123756 sqlite3RenameTokenRemap(pParse, pList->a[0].pExpr, &pTab->iPKey);
123952 static int markImmutableExprStep(Walker *pWalker, Expr *pExpr){
123954 ExprSetVVAProperty(pExpr, EP_Immutable);
125503 Expr *pExpr = pList->a[i].pExpr;
125504 assert( pExpr!=0 );
125505 if( pExpr->op==TK_COLLATE ){
125506 assert( !ExprHasProperty(pExpr, EP_IntValue) );
125507 nExtra += (1 + sqlite3Strlen30(pExpr->u.zToken));
125567 sqlite3StringToId(pListItem->pExpr);
125568 sqlite3ResolveSelfReference(pParse, pTab, NC_IdxExpr, pListItem->pExpr, 0);
125570 pCExpr = sqlite3ExprSkipCollate(pListItem->pExpr);
125602 if( pListItem->pExpr->op==TK_COLLATE ){
125604 assert( !ExprHasProperty(pListItem->pExpr, EP_IntValue) );
125605 zColl = pListItem->pExpr->u.zToken;
130909 ** pExpr points to an expression which implements a function. If
130925 SQLITE_PRIVATE int sqlite3IsLikeFunction(sqlite3 *db, Expr *pExpr, int *pIsNocase, char *aWc){
130928 assert( pExpr!=0 );
130929 assert( pExpr->op==TK_FUNCTION );
130930 assert( ExprUseXList(pExpr) );
130931 if( !pExpr->x.pList ){
130934 nExpr = pExpr->x.pList->nExpr;
130935 assert( !ExprHasProperty(pExpr, EP_IntValue) );
130936 pDef = sqlite3FindFunction(db, pExpr->u.zToken, nExpr, SQLITE_UTF8, 0);
130956 Expr *pEscape = pExpr->x.pList->a[2].pExpr;
131885 Expr *pExpr;
131890 pExpr = sqlite3Expr(db, TK_REGISTER, 0);
131891 if( pExpr ){
131894 pExpr->iTable = regBase + sqlite3TableColumnToStorage(pTab,iCol) + 1;
131895 pExpr->affExpr = pCol->affinity;
131898 pExpr = sqlite3ExprAddCollateString(pParse, pExpr, zColl);
131900 pExpr->iTable = regBase;
131901 pExpr->affExpr = SQLITE_AFF_INTEGER;
131904 return pExpr;
131917 Expr *pExpr = sqlite3Expr(db, TK_COLUMN, 0);
131918 if( pExpr ){
131919 assert( ExprUseYTab(pExpr) );
131920 pExpr->y.pTab = pTab;
131921 pExpr->iTable = iCursor;
131922 pExpr->iColumn = iCol;
131924 return pExpr;
132995 aff = sqlite3ExprAffinity(pIdx->aColExpr->a[n].pExpr);
133159 static int exprColumnFlagUnion(Walker *pWalker, Expr *pExpr){
133160 if( pExpr->op==TK_COLUMN && pExpr->iColumn>=0 ){
133161 assert( pExpr->iColumn < pWalker->u.pTab->nCol );
133162 pWalker->eCode |= pWalker->u.pTab->aCol[pExpr->iColumn].colFlags;
133493 if( 0==sqlite3ExprIsConstant(pParse, pRow->a[ii].pExpr) ) return 0;
133506 Expr *pExpr = pRow->a[ii].pExpr;
133507 assert( pExpr->op!=TK_RAISE );
133508 assert( pExpr->affExpr==0 );
133509 if( 0!=sqlite3ExprAffinity(pExpr) ) return 0;
134306 Expr *pX = pList->a[k].pExpr;
134337 sqlite3ExprCode(pParse, pList->a[ipkColumn].pExpr, regCols);
134389 Expr *pIpk = pList->a[ipkColumn].pExpr;
134394 sqlite3ExprCode(pParse, pList->a[ipkColumn].pExpr, regRowid);
134562 static int checkConstraintExprNode(Walker *pWalker, Expr *pExpr){
134563 if( pExpr->op==TK_COLUMN ){
134564 assert( pExpr->iColumn>=0 || pExpr->iColumn==-1 );
134565 if( pExpr->iColumn>=0 ){
134566 if( pWalker->u.aiCol[pExpr->iColumn]>=0 ){
134577 ** pExpr is a CHECK constraint on a row that is being UPDATE-ed. The
134581 ** Return true if CHECK constraint pExpr uses any of the
134586 ** 2018-09-15: pExpr might also be an expression for an index-on-expressions.
134592 Expr *pExpr, /* The expression to be checked */
134601 sqlite3WalkExpr(&w, pExpr);
134944 Expr *pExpr = pCheck->a[i].pExpr;
134946 && !sqlite3ExprReferencesUpdatedColumn(pExpr, aiChng, pkChng)
134958 pCopy = sqlite3ExprDup(db, pExpr, 0);
135306 sqlite3ExprCodeCopy(pParse, pIdx->aColExpr->a[i].pExpr, regIdx+i);
135840 if( sqlite3ExprCompare(0, pSrc->aColExpr->a[i].pExpr,
135841 pDest->aColExpr->a[i].pExpr, -1)!=0 ){
135956 assert( pEList->a[0].pExpr );
135957 if( pEList->a[0].pExpr->op!=TK_ASTERISK ){
140753 sqlite3ExprIfFalse(pParse, pCheck->a[k].pExpr, addrCkFault, 0);
140755 sqlite3ExprIfTrue(pParse, pCheck->a[0].pExpr, addrCkOk,
143317 sqlite3SetJoinExpr(p->x.pList->a[i].pExpr, iTable, joinFlag);
143355 unsetJoinExpr(p->x.pList->a[i].pExpr, iTable, nullable);
143813 CollSeq *pColl = sqlite3ExprCollSeq(pParse, pEList->a[i].pExpr);
143937 Expr *pExpr = pItem->pExpr;
143939 if( pExpr->op==TK_COLUMN
143940 && pExpr->iColumn>=0
143941 && ALWAYS( ExprUseYTab(pExpr) )
143942 && (pTab = pExpr->y.pTab)!=0
143944 && (pTab->aCol[pExpr->iColumn].colFlags & COLFLAG_SORTERREF)!=0
143948 if( pSort->aDefer[j].iCsr==pExpr->iTable ) break;
143964 pNew->iTable = pExpr->iTable;
143966 pNew->y.pTab = pExpr->y.pTab;
143971 pSort->aDefer[nDefer].pTab = pExpr->y.pTab;
143972 pSort->aDefer[nDefer].iCsr = pExpr->iTable;
144480 pInfo->aColl[i-iStart] = sqlite3ExprNNCollSeq(pParse, pItem->pExpr);
144677 sqlite3ExprCode(pParse, aOutEx[i].pExpr, regRow+i);
144760 ** expression pExpr. The string may be treated as static by the caller.
144787 Expr *pExpr
144789 Expr *pExpr,
144803 assert( pExpr!=0 );
144805 switch( pExpr->op ){
144813 int iCol = pExpr->iColumn; /* Index of column in pTab */
144816 for(j=0;j<pTabList->nSrc && pTabList->a[j].iCursor!=pExpr->iTable;j++);
144846 assert( pTab && ExprUseYTab(pExpr) && pExpr->y.pTab==pTab );
144860 Expr *p = pS->pEList->a[iCol].pExpr;
144904 assert( ExprUseXSelect(pExpr) );
144905 pS = pExpr->x.pSelect;
144906 p = pS->pEList->a[0].pExpr;
144944 Expr *p = pEList->a[i].pExpr;
145024 Expr *p = pEList->a[i].pExpr;
145122 Expr *pColExpr = sqlite3ExprSkipCollateAndLikely(pX->pExpr);
145232 p = a[i].pExpr;
145236 m |= sqlite3ExprDataType(pS2->pEList->a[i].pExpr);
145238 pCol->affinity = sqlite3ExprAffinity(pS2->pEList->a[i].pExpr);
145245 m |= sqlite3ExprDataType(pS2->pEList->a[i].pExpr);
145434 pRet = sqlite3ExprCollSeq(pParse, p->pEList->a[iCol].pExpr);
145457 Expr *pTerm = pItem->pExpr;
145465 pOrderBy->a[i].pExpr =
146722 ** Scan through the expression pExpr. Replace every reference to
146731 ** changes to pExpr so that it refers directly to the source table
146736 Expr *pExpr /* Expr in which substitution occurs */
146738 if( pExpr==0 ) return 0;
146739 if( ExprHasProperty(pExpr, EP_OuterON|EP_InnerON)
146740 && pExpr->w.iJoin==pSubst->iTable
146742 testcase( ExprHasProperty(pExpr, EP_InnerON) );
146743 pExpr->w.iJoin = pSubst->iNewTable;
146745 if( pExpr->op==TK_COLUMN
146746 && pExpr->iTable==pSubst->iTable
146747 && !ExprHasProperty(pExpr, EP_FixedCol)
146750 if( pExpr->iColumn<0 ){
146751 pExpr->op = TK_NULL;
146759 iColumn = pExpr->iColumn;
146762 assert( pExpr->pRight==0 );
146763 pCopy = pSubst->pEList->a[iColumn].pExpr;
146783 return pExpr;
146788 if( ExprHasProperty(pExpr,EP_OuterON|EP_InnerON) ){
146789 sqlite3SetJoinExpr(pNew, pExpr->w.iJoin,
146790 pExpr->flags & (EP_OuterON|EP_InnerON));
146792 sqlite3ExprDelete(db, pExpr);
146793 pExpr = pNew;
146794 if( pExpr->op==TK_TRUEFALSE ){
146795 pExpr->u.iValue = sqlite3ExprTruthValue(pExpr);
146796 pExpr->op = TK_INTEGER;
146797 ExprSetProperty(pExpr, EP_IntValue);
146803 CollSeq *pNat = sqlite3ExprCollSeq(pSubst->pParse, pExpr);
146805 pSubst->pCList->a[iColumn].pExpr
146807 if( pNat!=pColl || (pExpr->op!=TK_COLUMN && pExpr->op!=TK_COLLATE) ){
146808 pExpr = sqlite3ExprAddCollateString(pSubst->pParse, pExpr,
146813 ExprClearProperty(pExpr, EP_Collate);
146817 if( pExpr->op==TK_IF_NULL_ROW && pExpr->iTable==pSubst->iTable ){
146818 pExpr->iTable = pSubst->iNewTable;
146820 pExpr->pLeft = substExpr(pSubst, pExpr->pLeft);
146821 pExpr->pRight = substExpr(pSubst, pExpr->pRight);
146822 if( ExprUseXSelect(pExpr) ){
146823 substSelect(pSubst, pExpr->x.pSelect, 1);
146825 substExprList(pSubst, pExpr->x.pList);
146828 if( ExprHasProperty(pExpr, EP_WinFunc) ){
146829 Window *pWin = pExpr->y.pWin;
146836 return pExpr;
146845 pList->a[i].pExpr = substExpr(pSubst, pList->a[i].pExpr);
146883 static int recomputeColumnsUsedExpr(Walker *pWalker, Expr *pExpr){
146885 if( pExpr->op!=TK_COLUMN ) return WRC_Continue;
146887 if( pItem->iCursor!=pExpr->iTable ) return WRC_Continue;
146888 if( pExpr->iColumn<0 ) return WRC_Continue;
146889 pItem->colUsed |= sqlite3ExprColUsed(pExpr);
146959 static int renumberCursorsCb(Walker *pWalker, Expr *pExpr){
146960 int op = pExpr->op;
146962 renumberCursorDoMapping(pWalker, &pExpr->iTable);
146964 if( ExprHasProperty(pExpr, EP_OuterON) ){
146965 renumberCursorDoMapping(pWalker, &pExpr->w.iJoin);
147030 assert( pList->a[ii].pExpr!=0 );
147031 aff = sqlite3ExprAffinity(pList->a[ii].pExpr);
147035 assert( pSub1->pEList->a[ii].pExpr!=0 );
147036 if( sqlite3ExprAffinity(pSub1->pEList->a[ii].pExpr)!=aff ){
147672 Expr *pExpr /* Overall expression: COLUMN=VALUE or VALUE=COLUMN */
147680 if( !sqlite3IsBinary(sqlite3ExprCompareCollSeq(pConst->pParse,pExpr)) ){
147711 ** Find all terms of COLUMN=VALUE or VALUE=COLUMN in pExpr where VALUE
147716 static void findConstInWhere(WhereConst *pConst, Expr *pExpr){
147718 if( NEVER(pExpr==0) ) return;
147719 if( ExprHasProperty(pExpr, pConst->mExcludeOn) ){
147720 testcase( ExprHasProperty(pExpr, EP_OuterON) );
147721 testcase( ExprHasProperty(pExpr, EP_InnerON) );
147724 if( pExpr->op==TK_AND ){
147725 findConstInWhere(pConst, pExpr->pRight);
147726 findConstInWhere(pConst, pExpr->pLeft);
147729 if( pExpr->op!=TK_EQ ) return;
147730 pRight = pExpr->pRight;
147731 pLeft = pExpr->pLeft;
147735 constInsert(pConst,pRight,pLeft,pExpr);
147738 constInsert(pConst,pLeft,pRight,pExpr);
147745 ** Argument pExpr is a candidate expression to be replaced by a value. If
147746 ** pExpr is equivalent to one of the columns named in pWalker->u.pConst,
147748 ** if argument bIgnoreAffBlob is non-zero and the affinity of pExpr
147753 Expr *pExpr,
147758 if( pExpr->op!=TK_COLUMN ) return WRC_Continue;
147759 if( ExprHasProperty(pExpr, EP_FixedCol|pConst->mExcludeOn) ){
147760 testcase( ExprHasProperty(pExpr, EP_FixedCol) );
147761 testcase( ExprHasProperty(pExpr, EP_OuterON) );
147762 testcase( ExprHasProperty(pExpr, EP_InnerON) );
147767 if( pColumn==pExpr ) continue;
147768 if( pColumn->iTable!=pExpr->iTable ) continue;
147769 if( pColumn->iColumn!=pExpr->iColumn ) continue;
147775 ExprClearProperty(pExpr, EP_Leaf);
147776 ExprSetProperty(pExpr, EP_FixedCol);
147777 assert( pExpr->pLeft==0 );
147778 pExpr->pLeft = sqlite3ExprDup(pConst->pParse->db, pConst->apExpr[i*2+1], 0);
147786 ** This is a Walker expression callback. pExpr is a node from the WHERE
147787 ** clause of a SELECT statement. This function examines pExpr to see if
147789 ** be made to pExpr or its immediate children.
147793 ** + pExpr is a column with an affinity other than BLOB that matches
147796 ** + pExpr is a binary comparison operator (=, <=, >=, <, >) that
147801 static int propagateConstantExprRewrite(Walker *pWalker, Expr *pExpr){
147808 if( (pExpr->op>=TK_EQ && pExpr->op<=TK_GE)
147809 || pExpr->op==TK_IS
147811 propagateConstantExprRewriteOne(pConst, pExpr->pLeft, 0);
147813 if( sqlite3ExprAffinity(pExpr->pLeft)!=SQLITE_AFF_TEXT ){
147814 propagateConstantExprRewriteOne(pConst, pExpr->pRight, 0);
147818 return propagateConstantExprRewriteOne(pConst, pExpr, pConst->bHasAffBlob);
147918 ** push WHERE clause expression pExpr down to FROM clause sub-query
147934 static int pushDownWindowCheck(Parse *pParse, Select *pSubq, Expr *pExpr){
147938 return sqlite3ExprIsConstantOrGroupBy(pParse, pExpr, pSubq->pWin->pPartition);
148093 CollSeq *pColl = sqlite3ExprCollSeq(pParse, pList->a[ii].pExpr);
148264 Expr *pY = pX->pEList->a[j].pExpr;
148315 if( sqlite3ExprCanBeNull(pEList->a[0].pExpr) ){
148349 Expr *pExpr;
148366 pExpr = p->pEList->a[0].pExpr;
148367 assert( pExpr!=0 );
148368 if( pExpr->op!=TK_AGG_FUNCTION ) return 0;
148369 if( pExpr->pAggInfo!=pAggInfo ) return 0;
148371 assert( pAggInfo->aFunc[0].pFExpr==pExpr );
148372 testcase( ExprHasProperty(pExpr, EP_Distinct) );
148373 testcase( ExprHasProperty(pExpr, EP_WinFunc) );
148374 if( ExprHasProperty(pExpr, EP_Distinct|EP_WinFunc) ) return 0;
148452 if( a[i].pExpr->flags & EP_Collate ) break;
148866 Expr *pE, *pRight, *pExpr;
149000 pE = pEList->a[k].pExpr;
149020 pE = a[k].pExpr;
149029 pNew = sqlite3ExprListAppend(pParse, pNew, a[k].pExpr);
149035 a[k].pExpr = 0;
149168 pExpr = sqlite3PExpr(pParse, TK_DOT, pLeft, pRight);
149174 pExpr = sqlite3PExpr(pParse, TK_DOT, pLeft, pExpr);
149177 pExpr = pRight;
149179 sqlite3ExprSetErrorOffset(pExpr, iErrOfst);
149180 pNew = sqlite3ExprListAppend(pParse, pNew, pExpr);
149422 Expr *pExpr = pAggInfo->aFunc[i].pFExpr;
149423 assert( pExpr->op==TK_FUNCTION || pExpr->op==TK_AGG_FUNCTION );
149424 assert( ExprUseXList(pExpr) );
149425 sqlite3ExprAnalyzeAggList(pNC, pExpr->x.pList);
149426 if( pExpr->pLeft ){
149427 assert( pExpr->pLeft->op==TK_ORDER );
149428 assert( ExprUseXList(pExpr->pLeft) );
149429 sqlite3ExprAnalyzeAggList(pNC, pExpr->pLeft->x.pList);
149432 assert( !IsWindowFunc(pExpr) );
149433 if( ExprHasProperty(pExpr, EP_WinFunc) ){
149434 sqlite3ExprAnalyzeAggregates(pNC, pExpr->y.pWin->pFilter);
149477 sqlite3TreeViewExpr(0, pIEpr->pExpr, 0);
149490 static int aggregateIdxEprRefToColCallback(Walker *pWalker, Expr *pExpr){
149494 if( pExpr->pAggInfo==0 ) return WRC_Continue;
149495 if( pExpr->op==TK_AGG_COLUMN ) return WRC_Continue;
149496 if( pExpr->op==TK_AGG_FUNCTION ) return WRC_Continue;
149497 if( pExpr->op==TK_IF_NULL_ROW ) return WRC_Continue;
149498 pAggInfo = pExpr->pAggInfo;
149499 if( NEVER(pExpr->iAgg>=pAggInfo->nColumn) ) return WRC_Continue;
149500 assert( pExpr->iAgg>=0 );
149501 pCol = &pAggInfo->aCol[pExpr->iAgg];
149502 pExpr->op = TK_AGG_COLUMN;
149503 pExpr->iTable = pCol->iTable;
149504 pExpr->iColumn = pCol->iColumn;
149505 ExprClearProperty(pExpr, EP_Skip|EP_Collate|EP_Unlikely);
149510 ** Convert every pAggInfo->aFunc[].pExpr such that any node within
149821 pColl = sqlite3ExprCollSeq(pParse, pItem->pExpr);
149889 static int havingToWhereExprCb(Walker *pWalker, Expr *pExpr){
149890 if( pExpr->op!=TK_AND ){
149893 ** SELECT is analyzed for aggregates. So if pExpr->pAggInfo is set
149899 if( sqlite3ExprIsConstantOrGroupBy(pWalker->pParse, pExpr, pS->pGroupBy)
149900 && ExprAlwaysFalse(pExpr)==0
149901 && pExpr->pAggInfo==0
149907 SWAP(Expr, *pNew, *pExpr);
150021 Expr *pExpr;
150030 pExpr = p->pEList->a[0].pExpr;
150031 if( pExpr->op!=TK_AGG_FUNCTION ) return 0; /* Result is an aggregate */
150032 assert( ExprUseUToken(pExpr) );
150033 if( sqlite3_stricmp(pExpr->u.zToken,"count") ) return 0; /* Is count() */
150034 assert( ExprUseXList(pExpr) );
150035 if( pExpr->x.pList!=0 ) return 0; /* Must be count(*) */
150037 if( ExprHasProperty(pExpr, EP_WinFunc) ) return 0;/* Not a window function */
150054 pCount = pExpr;
150055 pExpr = 0;
150073 if( pExpr==0 ){
150074 pExpr = pTerm;
150076 pExpr = sqlite3PExpr(pParse, TK_PLUS, pTerm, pExpr);
150080 p->pEList->a[0].pExpr = pExpr;
150792 sqlite3ExprDelete(db, pEList->a[ii].pExpr);
150797 if( pEList->a[ii].fg.bUsed==0 ) pEList->a[ii].pExpr->op = TK_NULL;
151044 Expr *pExpr = pAggInfo->aFunc[0].pFExpr->x.pList->a[0].pExpr;
151045 pExpr = sqlite3ExprDup(db, pExpr, 0);
151047 pDistinct = sqlite3ExprListAppend(pParse, pDistinct, pExpr);
151213 sqlite3ExprCode(pParse, pGroupBy->a[j].pExpr, iBMem+j);
151486 Expr *pExpr = pAggInfo->aCol[i].pCExpr;
151487 if( pExpr==0 ) continue;
151488 assert( pExpr->pAggInfo==pAggInfo );
151489 assert( pExpr->iAgg==i );
151492 Expr *pExpr = pAggInfo->aFunc[i].pFExpr;
151493 assert( pExpr!=0 );
151494 assert( pExpr->pAggInfo==pAggInfo );
151495 assert( pExpr->iAgg==i );
152604 ** Return true if the pExpr term from the RETURNING clause argument
152638 Expr *pOldExpr = pList->a[i].pExpr;
152670 static int sqlite3ReturningSubqueryVarSelect(Walker *NotUsed, Expr *pExpr){
152672 if( ExprUseXSelect(pExpr)
152673 && (pExpr->x.pSelect->selFlags & SF_Correlated)!=0
152675 testcase( ExprHasProperty(pExpr, EP_VarSelect) );
152676 ExprSetProperty(pExpr, EP_VarSelect);
152799 Expr *pCol = pNew->a[i].pExpr;
153383 assert( pIdx->aColExpr->a[iCol].pExpr!=0 );
153384 return sqlite3ExprReferencesUpdatedColumn(pIdx->aColExpr->a[iCol].pExpr,
153534 sqlite3ExprDup(db, pChanges->a[i].pExpr, 0)
153744 if( nChangeFrom==0 && sqlite3ResolveExprNames(&sNC, pChanges->a[i].pExpr) ){
153753 pRowidExpr = pChanges->a[i].pExpr;
153776 pRowidExpr = pChanges->a[i].pExpr;
154233 sqlite3ExprCode(pParse, pChanges->a[j].pExpr, k);
154525 pRow = sqlite3ExprDup(db, pChanges->a[aXRef[iPk]].pExpr, 0);
154535 sqlite3ExprDup(db, pChanges->a[aXRef[i]].pExpr, 0)
154561 sqlite3ExprCode(pParse, pChanges->a[aXRef[i]].pExpr, regArg+2+i);
154775 && (pTerm = pTarget->a[0].pExpr)->op==TK_COLUMN
154809 Expr *pExpr;
154815 pExpr = pIdx->aColExpr->a[ii].pExpr;
154816 if( pExpr->op!=TK_COLLATE ){
154817 sCol[0].pLeft = pExpr;
154818 pExpr = &sCol[0];
154823 pExpr = &sCol[0];
154826 if( sqlite3ExprCompare(0,pTarget->a[jj].pExpr,pExpr,iCursor)<2 ){
156530 ** second parameter (pExpr) is the first argument to this function.
156531 ** If pExpr is a column in a virtual table, then let the virtual
156545 Expr *pExpr /* First argument to the function */
156556 if( NEVER(pExpr==0) ) return pDef;
156557 if( pExpr->op!=TK_COLUMN ) return pDef;
156558 assert( ExprUseYTab(pExpr) );
156559 pTab = pExpr->y.pTab;
157037 ** categories, then eOperator==0. The WhereTerm.pExpr field is still set
157058 Expr *pExpr; /* Pointer to the subexpression that is this term */
157075 Bitmask prereqRight; /* Bitmask of tables used by pExpr->pRight */
157076 Bitmask prereqAll; /* Bitmask of tables referenced by pExpr */
157082 #define TERM_DYNAMIC 0x0001 /* Need to call sqlite3ExprDelete(db, pExpr) */
157093 #define TERM_IS 0x0800 /* Term.pExpr is an IS operator */
157094 #define TERM_VARSELECT 0x1000 /* Term.pExpr contains a correlated sub-query */
157787 && (pLevel->iLeftJoin==0 || ExprHasProperty(pTerm->pExpr, EP_OuterON))
157930 if( pLoop->aLTerm[i]->pExpr==pX ){
157934 if( pOrigRhs->a[iField].pExpr==0 ) continue; /* Duplicate PK column */
157935 pRhs = sqlite3ExprListAppend(pParse, pRhs, pOrigRhs->a[iField].pExpr);
157936 pOrigRhs->a[iField].pExpr = 0;
157938 assert( pOrigLhs->a[iField].pExpr!=0 );
157939 pLhs = sqlite3ExprListAppend(pParse,pLhs,pOrigLhs->a[iField].pExpr);
157940 pOrigLhs->a[iField].pExpr = 0;
157954 Expr *p = pLhs->a[0].pExpr;
157955 pLhs->a[0].pExpr = 0;
158008 Expr *pX = pTerm->pExpr;
158041 if( pLoop->aLTerm[i] && pLoop->aLTerm[i]->pExpr==pX ){
158048 if( pLoop->aLTerm[i]->pExpr==pX ) nEq++;
158055 Expr *pExpr = pTerm->pExpr;
158056 if( pExpr->iTable==0 || !ExprHasProperty(pExpr, EP_Subrtn) ){
158062 pExpr->iTable = iTab;
158070 pX = pExpr;
158101 if( pLoop->aLTerm[i]->pExpr==pX ){
158280 if( pTerm->pExpr->flags & EP_xIsSelect ){
158288 Expr *pRight = pTerm->pExpr->pRight;
158364 static int codeCursorHintCheckExpr(Walker *pWalker, Expr *pExpr){
158367 if( pExpr->op==TK_COLUMN
158368 && pExpr->iTable==pHint->iTabCur
158369 && sqlite3TableColumnToIndex(pHint->pIdx, pExpr->iColumn)<0
158377 ** Test whether or not expression pExpr, which was part of a WHERE clause,
158391 static int codeCursorHintIsOrFunction(Walker *pWalker, Expr *pExpr){
158392 if( pExpr->op==TK_IS
158393 || pExpr->op==TK_ISNULL || pExpr->op==TK_ISNOT
158394 || pExpr->op==TK_NOTNULL || pExpr->op==TK_CASE
158397 }else if( pExpr->op==TK_FUNCTION ){
158400 if( 0==sqlite3IsLikeFunction(pWalker->pParse->db, pExpr, &d1, d2) ){
158426 static int codeCursorHintFixExpr(Walker *pWalker, Expr *pExpr){
158430 if( pExpr->op==TK_COLUMN ){
158431 if( pExpr->iTable!=pHint->iTabCur ){
158433 reg = sqlite3ExprCodeTarget(pWalker->pParse, pExpr, reg);
158434 pExpr->op = TK_REGISTER;
158435 pExpr->iTable = reg;
158437 pExpr->iTable = pHint->iIdxCur;
158438 pExpr->iColumn = sqlite3TableColumnToIndex(pHint->pIdx, pExpr->iColumn);
158439 assert( pExpr->iColumn>=0 );
158441 }else if( pExpr->pAggInfo ){
158444 reg = sqlite3ExprCodeTarget(pWalker->pParse, pExpr, reg);
158445 pExpr->op = TK_REGISTER;
158446 pExpr->iTable = reg;
158447 }else if( pExpr->op==TK_TRUEFALSE ){
158466 Expr *pExpr = 0;
158513 Expr *pExpr = pTerm->pExpr;
158514 if( !ExprHasProperty(pExpr, EP_OuterON)
158515 || pExpr->w.iJoin!=pTabItem->iCursor
158519 sqlite3WalkExpr(&sWalker, pTerm->pExpr);
158523 if( ExprHasProperty(pTerm->pExpr, EP_OuterON) ) continue;
158535 if( sqlite3ExprContainsSubquery(pTerm->pExpr) ) continue;
158542 sqlite3WalkExpr(&sWalker, pTerm->pExpr);
158547 pExpr = sqlite3ExprAnd(pParse, pExpr, sqlite3ExprDup(db, pTerm->pExpr, 0));
158549 if( pExpr!=0 ){
158551 if( pParse->nErr==0 ) sqlite3WalkExpr(&sWalker, pExpr);
158554 (const char*)pExpr, P4_EXPR);
158650 sqlite3ExprCode(pParse, pList->a[i].pExpr, iReg+i);
158678 Expr *pExpr;
158680 pExpr = pTerm->pExpr;
158681 if( sqlite3ExprCompare(0, pExpr, pTruth, iTabCur)==0 ){
158723 assert( pTerm->pExpr!=0 );
158890 sqlite3CodeRhsOfIN(pParse, pTerm->pExpr, iTab);
158897 Expr *pRight = pTerm->pExpr->pRight;
158962 Expr *pLeft = pTerm->pExpr->pLeft;
158968 pCompare->pLeft = pLeft->x.pList->a[iFld-1].pExpr;
159006 assert( pTerm->pExpr!=0 );
159064 pX = pStart->pExpr;
159098 pX = pEnd->pExpr;
159305 Expr *pRight = pRangeStart->pExpr->pRight;
159406 Expr *pRight = pRangeEnd->pExpr->pRight;
159685 Expr *pExpr = pWC->a[iTerm].pExpr;
159694 if( ExprHasProperty(pExpr, EP_Subquery) ) continue; /* tag-20220303a */
159695 pExpr = sqlite3ExprDup(db, pExpr, 0);
159696 pAndExpr = sqlite3ExprAnd(pParse, pAndExpr, pExpr);
159717 Expr *pOrExpr = pOrTerm->pExpr; /* Current OR clause term */
159933 pE = pTerm->pExpr;
160010 pE = pTerm->pExpr;
160025 && ExprUseXSelect(pAlt->pExpr)
160026 && (pAlt->pExpr->x.pSelect->pEList->nExpr>1)
160034 sEAlt = *pAlt->pExpr;
160121 assert( pTerm->pExpr );
160122 sqlite3ExprIfFalse(pParse, pTerm->pExpr, addrCont, SQLITE_JUMPIFNULL);
160193 if( ExprHasProperty(pTerm->pExpr, EP_OuterON|EP_InnerON) ) continue;
160195 sqlite3ExprDup(pParse->db, pTerm->pExpr, 0));
160326 pTerm->pExpr = sqlite3ExprSkipCollateAndLikely(p);
160352 static u16 exprCommute(Parse *pParse, Expr *pExpr){
160353 if( pExpr->pLeft->op==TK_VECTOR
160354 || pExpr->pRight->op==TK_VECTOR
160355 || sqlite3BinaryCompareCollSeq(pParse, pExpr->pLeft, pExpr->pRight) !=
160356 sqlite3BinaryCompareCollSeq(pParse, pExpr->pRight, pExpr->pLeft)
160358 pExpr->flags ^= EP_Commuted;
160360 SWAP(Expr*,pExpr->pRight,pExpr->pLeft);
160361 if( pExpr->op>=TK_GT ){
160366 assert( pExpr->op>=TK_GT && pExpr->op<=TK_GE );
160367 pExpr->op = ((pExpr->op-TK_GT)^2)+TK_GT;
160415 Expr *pExpr, /* Test this expression */
160431 if( !sqlite3IsLikeFunction(db, pExpr, pnoCase, (char*)wc) ){
160437 assert( ExprUseXList(pExpr) );
160438 pList = pExpr->x.pList;
160439 pLeft = pList->a[1].pExpr;
160441 pRight = sqlite3ExprSkipCollate(pList->a[0].pExpr);
160567 ** Check to see if the pExpr expression is a form that needs to be passed
160594 Expr *pExpr, /* Test this expression */
160599 if( pExpr->op==TK_FUNCTION ){
160613 assert( ExprUseXList(pExpr) );
160614 pList = pExpr->x.pList;
160626 pCol = pList->a[1].pExpr;
160630 assert( !ExprHasProperty(pExpr, EP_IntValue) );
160631 if( sqlite3StrICmp(pExpr->u.zToken, aOp[i].zOp)==0 ){
160633 *ppRight = pList->a[0].pExpr;
160650 pCol = pList->a[0].pExpr;
160661 assert( !ExprHasProperty(pExpr, EP_IntValue) );
160664 i = pMod->xFindFunction(pVtab,2, pExpr->u.zToken, &xNotUsed, &pNotUsed);
160667 *ppRight = pList->a[1].pExpr;
160673 }else if( pExpr->op==TK_NE || pExpr->op==TK_ISNOT || pExpr->op==TK_NOTNULL ){
160675 Expr *pLeft = pExpr->pLeft;
160676 Expr *pRight = pExpr->pRight;
160689 if( pExpr->op==TK_NE ) *peOp2 = SQLITE_INDEX_CONSTRAINT_NE;
160690 if( pExpr->op==TK_ISNOT ) *peOp2 = SQLITE_INDEX_CONSTRAINT_ISNOT;
160691 if( pExpr->op==TK_NOTNULL ) *peOp2 = SQLITE_INDEX_CONSTRAINT_ISNOTNULL;
160770 assert( pOne->pExpr->pLeft!=0 && pOne->pExpr->pRight!=0 );
160771 assert( pTwo->pExpr->pLeft!=0 && pTwo->pExpr->pRight!=0 );
160772 if( sqlite3ExprCompare(0,pOne->pExpr->pLeft, pTwo->pExpr->pLeft, -1) ) return;
160773 if( sqlite3ExprCompare(0,pOne->pExpr->pRight, pTwo->pExpr->pRight,-1) )return;
160784 pNew = sqlite3ExprDup(db, pOne->pExpr, 0);
160889 Expr *pExpr = pTerm->pExpr; /* The expression of the term */
160903 assert( pExpr->op==TK_OR );
160910 sqlite3WhereSplit(pOrWc, pExpr, TK_OR);
160938 sqlite3WhereSplit(pAndWC, pOrTerm->pExpr, TK_AND);
160943 assert( pAndTerm->pExpr );
160944 if( allowedOp(pAndTerm->pExpr->op)
161056 pLeft = pOrTerm->pExpr->pLeft;
161078 && sqlite3ExprCompare(pParse, pOrTerm->pExpr->pLeft, pLeft, -1)
161087 affRight = sqlite3ExprAffinity(pOrTerm->pExpr->pRight);
161088 affLeft = sqlite3ExprAffinity(pOrTerm->pExpr->pLeft);
161114 pDup = sqlite3ExprDup(db, pOrTerm->pExpr->pRight, 0);
161116 pLeft = pOrTerm->pExpr->pLeft;
161123 transferJoinMarkings(pNew, pExpr);
161140 ** We already know that pExpr is a binary operator where both operands are
161141 ** column references. This routine checks to see if pExpr is an equivalence
161154 static int termIsEquivalence(Parse *pParse, Expr *pExpr){
161158 if( pExpr->op!=TK_EQ && pExpr->op!=TK_IS ) return 0;
161159 if( ExprHasProperty(pExpr, EP_OuterON) ) return 0;
161160 aff1 = sqlite3ExprAffinity(pExpr->pLeft);
161161 aff2 = sqlite3ExprAffinity(pExpr->pRight);
161167 pColl = sqlite3ExprCompareCollSeq(pParse, pExpr);
161169 return sqlite3ExprCollSeqMatch(pParse, pExpr->pLeft, pExpr->pRight);
161204 ** Expression pExpr is one operand of a comparison operator that might
161205 ** be useful for indexing. This routine checks to see if pExpr appears
161206 ** in any index. Return TRUE (1) if pExpr is an indexed term and return
161212 ** If pExpr is a TK_COLUMN column reference, then this routine always returns
161219 Expr *pExpr, /* An operand of a comparison operator */
161232 if( sqlite3ExprCompareSkip(pExpr,pIdx->aColExpr->a[i].pExpr,iCur)==0
161233 && !sqlite3ExprIsConstant(0,pIdx->aColExpr->a[i].pExpr)
161247 Expr *pExpr, /* An operand of a comparison operator */
161258 if( pExpr->op==TK_VECTOR && (op>=TK_GT && ALWAYS(op<=TK_GE)) ){
161259 assert( ExprUseXList(pExpr) );
161260 pExpr = pExpr->x.pList->a[0].pExpr;
161263 if( pExpr->op==TK_COLUMN ){
161264 aiCurCol[0] = pExpr->iTable;
161265 aiCurCol[1] = pExpr->iColumn;
161273 return exprMightBeIndexed2(pFrom,aiCurCol,pExpr,i);
161283 ** "pExpr" field filled in. The job of this routine is to analyze the
161294 ** and the new term is marked with TERM_DYNAMIC (because it's pExpr
161307 Expr *pExpr; /* The expression to be analyzed */
161308 Bitmask prereqLeft; /* Prerequisites of the pExpr->pLeft */
161309 Bitmask prereqAll; /* Prerequisites of pExpr */
161314 int op; /* Top-level operator. pExpr->op */
161326 pExpr = pTerm->pExpr;
161327 assert( pExpr!=0 ); /* Because malloc() has not failed */
161328 assert( pExpr->op!=TK_AS && pExpr->op!=TK_COLLATE );
161330 prereqLeft = sqlite3WhereExprUsage(pMaskSet, pExpr->pLeft);
161331 op = pExpr->op;
161333 assert( pExpr->pRight==0 );
161334 if( sqlite3ExprCheckIN(pParse, pExpr) ) return;
161335 if( ExprUseXSelect(pExpr) ){
161336 pTerm->prereqRight = exprSelectUsage(pMaskSet, pExpr->x.pSelect);
161338 pTerm->prereqRight = sqlite3WhereExprListUsage(pMaskSet, pExpr->x.pList);
161342 pTerm->prereqRight = sqlite3WhereExprUsage(pMaskSet, pExpr->pRight);
161343 if( pExpr->pLeft==0
161344 || ExprHasProperty(pExpr, EP_xIsSelect|EP_IfNullRow)
161345 || pExpr->x.pList!=0
161347 prereqAll = sqlite3WhereExprUsageNN(pMaskSet, pExpr);
161355 if( prereqAll!=sqlite3WhereExprUsageNN(pMaskSet, pExpr) ){
161357 sqlite3TreeViewExpr(0,pExpr,0);
161362 if( ExprHasProperty(pExpr, EP_OuterON|EP_InnerON) ){
161363 Bitmask x = sqlite3WhereGetMask(pMaskSet, pExpr->w.iJoin);
161364 if( ExprHasProperty(pExpr, EP_OuterON) ){
161383 ExprClearProperty(pExpr, EP_InnerON);
161392 Expr *pLeft = sqlite3ExprSkipCollate(pExpr->pLeft);
161393 Expr *pRight = sqlite3ExprSkipCollate(pExpr->pRight);
161400 pLeft = pLeft->x.pList->a[pTerm->u.x.iField-1].pExpr;
161420 pDup = sqlite3ExprDup(db, pExpr, 0);
161438 pDup = pExpr;
161451 && !ExprHasProperty(pExpr,EP_OuterON)
161454 assert( !ExprHasProperty(pExpr, EP_IntValue) );
161455 pExpr->op = TK_TRUEFALSE; /* See tag-20230504-1 */
161456 pExpr->u.zToken = "false";
161457 ExprSetProperty(pExpr, EP_IsFalse);
161479 else if( pExpr->op==TK_BETWEEN && pWC->op==TK_AND ){
161483 assert( ExprUseXList(pExpr) );
161484 pList = pExpr->x.pList;
161491 sqlite3ExprDup(db, pExpr->pLeft, 0),
161492 sqlite3ExprDup(db, pList->a[i].pExpr, 0));
161493 transferJoinMarkings(pNewExpr, pExpr);
161507 else if( pExpr->op==TK_OR ){
161519 else if( pExpr->op==TK_NOTNULL ){
161520 if( pExpr->pLeft->op==TK_COLUMN
161521 && pExpr->pLeft->iColumn>=0
161522 && !ExprHasProperty(pExpr, EP_OuterON)
161525 Expr *pLeft = pExpr->pLeft;
161564 else if( pExpr->op==TK_FUNCTION
161566 && isLikeOrGlob(pParse, pExpr, &pStr1, &isComplete, &noCase)
161577 assert( ExprUseXList(pExpr) );
161578 pLeft = pExpr->x.pList->a[1].pExpr;
161619 transferJoinMarkings(pNewExpr1, pExpr);
161626 transferJoinMarkings(pNewExpr2, pExpr);
161649 if( (pExpr->op==TK_EQ || pExpr->op==TK_IS)
161650 && (nLeft = sqlite3ExprVectorSize(pExpr->pLeft))>1
161651 && sqlite3ExprVectorSize(pExpr->pRight)==nLeft
161652 && ( (pExpr->pLeft->flags & EP_xIsSelect)==0
161653 || (pExpr->pRight->flags & EP_xIsSelect)==0)
161660 Expr *pLeft = sqlite3ExprForVectorField(pParse, pExpr->pLeft, i, nLeft);
161661 Expr *pRight = sqlite3ExprForVectorField(pParse, pExpr->pRight, i, nLeft);
161663 pNew = sqlite3PExpr(pParse, pExpr->op, pLeft, pRight);
161664 transferJoinMarkings(pNew, pExpr);
161675 ** used by each such virtual term is pExpr (the full vector IN(...)
161682 else if( pExpr->op==TK_IN
161684 && pExpr->pLeft->op==TK_VECTOR
161685 && ALWAYS( ExprUseXSelect(pExpr) )
161686 && (pExpr->x.pSelect->pPrior==0 || (pExpr->x.pSelect->selFlags & SF_Values))
161688 && pExpr->x.pSelect->pWin==0
161693 for(i=0; i<sqlite3ExprVectorSize(pExpr->pLeft); i++){
161695 idxNew = whereClauseInsert(pWC, pExpr, TERM_VIRTUAL|TERM_SLICE);
161714 int res = isAuxiliaryVtabOperator(db, pExpr, &eOp2, &pLeft, &pRight);
161726 if( ExprHasProperty(pExpr, EP_OuterON) && pNewExpr ){
161728 pNewExpr->w.iJoin = pExpr->w.iJoin;
161771 ** The original WHERE clause in pExpr is unaltered. All this routine
161772 ** does is make slot[] entries point to substructure within pExpr.
161778 SQLITE_PRIVATE void sqlite3WhereSplit(WhereClause *pWC, Expr *pExpr, u8 op){
161779 Expr *pE2 = sqlite3ExprSkipCollateAndLikely(pExpr);
161781 assert( pE2!=0 || pExpr==0 );
161784 whereClauseInsert(pWC, pExpr, 0);
161805 Expr *pExpr, /* Expression that defines the limit/offset */
161814 if( sqlite3ExprIsInteger(pExpr, &iVal) && iVal>=0 ){
161888 Expr *pExpr = pOrderBy->a[ii].pExpr;
161889 if( pExpr->op!=TK_COLUMN ) return;
161890 if( pExpr->iTable!=iCsr ) return;
161945 sqlite3ExprDelete(db, a->pExpr);
162037 mask |= sqlite3WhereExprUsage(pMaskSet, pList->a[i].pExpr);
162101 sqlite3ExprDup(pParse->db, pArgs->a[j].pExpr, 0), 0);
162436 Expr *pX = pTerm->pExpr;
162445 inexpr.pLeft = pX->pLeft->x.pList->a[iField].pExpr;
162447 inexpr.pRight = pX->x.pSelect->pEList->a[iField].pExpr;
162484 || sqlite3ExprCompareSkip(pTerm->pExpr->pLeft,
162486 && (pScan->iEquiv<=1 || !ExprHasProperty(pTerm->pExpr, EP_OuterON))
162490 && (pX = whereRightSubexprIsColumn(pTerm->pExpr))!=0
162510 pX = pTerm->pExpr;
162530 && (pX = pTerm->pExpr->pRight, ALWAYS(pX!=0))
162624 pScan->pIdxExpr = pIdx->aColExpr->a[j].pExpr;
162706 Expr *p = sqlite3ExprSkipCollateAndLikely(pList->a[i].pExpr);
162712 CollSeq *pColl = sqlite3ExprNNCollSeq(pParse, pList->a[i].pExpr);
162771 Expr *p = sqlite3ExprSkipCollateAndLikely(pDistinct->a[i].pExpr);
162945 testcase( ExprHasProperty(pTerm->pExpr, EP_OuterON) )
162946 testcase( ExprHasProperty(pTerm->pExpr, EP_InnerON) );
162947 if( !ExprHasProperty(pTerm->pExpr, EP_OuterON|EP_InnerON)
162948 || pTerm->pExpr->w.iJoin != pSrc->iCursor
162953 && ExprHasProperty(pTerm->pExpr, EP_InnerON)
162986 if( !sqlite3IndexAffinityOk(pTerm->pExpr, aff) ) return 0;
162987 testcase( pTerm->pExpr->op==TK_IS );
163101 Expr *pExpr = pTerm->pExpr;
163106 && sqlite3ExprIsSingleTableConstraint(pExpr, pTabList, pLevel->iFrom, 0)
163109 sqlite3ExprDup(pParse->db, pExpr, 0));
163180 Expr *pX = pTerm->pExpr;
163373 Expr *pExpr = pTerm->pExpr;
163375 && sqlite3ExprIsSingleTableConstraint(pExpr, pTabList, iSrc, 0)
163377 sqlite3ExprIfFalse(pParse, pTerm->pExpr, addrCont, SQLITE_JUMPIFNULL);
163497 Expr *pExpr = pOrderBy->a[i].pExpr;
163501 if( sqlite3ExprIsConstant(0, pExpr) ){
163509 if( pExpr->op==TK_COLUMN && pExpr->iTable==pSrc->iCursor ){
163510 assert( pExpr->iColumn>=XN_ROWID && pExpr->iColumn<pTab->nCol );
163516 if( pExpr->op==TK_COLLATE
163517 && (pE2 = pExpr->pLeft)->op==TK_COLUMN
163521 assert( !ExprHasProperty(pExpr, EP_IntValue) );
163522 assert( pExpr->u.zToken!=0 );
163524 pExpr->iColumn = pE2->iColumn;
163528 if( sqlite3_stricmp(pExpr->u.zToken, zColl)==0 ) continue;
163598 && sqlite3ExprIsVector(pTerm->pExpr->pRight)
163612 Expr *pExpr = pOrderBy->a[i].pExpr;
163613 if( sqlite3ExprIsConstant(0, pExpr) ) continue;
163614 assert( pExpr->op==TK_COLUMN
163615 || (pExpr->op==TK_COLLATE && pExpr->pLeft->op==TK_COLUMN
163616 && pExpr->iColumn==pExpr->pLeft->iColumn) );
163617 pIdxOrderBy[j].iColumn = pExpr->iColumn;
163987 rc = sqlite3Stat4ValueFromExpr(pParse, pLower->pExpr->pRight, aff, &p1);
163991 rc = sqlite3Stat4ValueFromExpr(pParse, pUpper->pExpr->pRight, aff, &p2);
164152 int n; /* Values extracted from pExpr */
164153 Expr *pExpr = pLower->pExpr->pRight;
164154 rc = sqlite3Stat4ProbeSetValue(pParse, p, &pRec, pExpr, nBtm, nEq, &n);
164158 if( sqlite3ExprVectorSize(pExpr)>n ) mask = (WO_LE|WO_LT);
164169 int n; /* Values extracted from pExpr */
164170 Expr *pExpr = pUpper->pExpr->pRight;
164171 rc = sqlite3Stat4ProbeSetValue(pParse, p, &pRec, pExpr, nTop, nEq, &n);
164175 if( sqlite3ExprVectorSize(pExpr)>n ) mask = (WO_LE|WO_LT);
164247 ** for that index. When pExpr==NULL that means the constraint is
164262 Expr *pExpr, /* Expression for VALUE in the x=VALUE constraint */
164291 rc = sqlite3Stat4ProbeSetValue(pParse, p, &pRec, pExpr, 1, nEq-1, &bOk);
164340 rc = whereEqualScanEst(pParse, pBuilder, pList->a[i].pExpr, &nEst);
164369 if( ExprHasProperty(pTerm->pExpr, EP_OuterON) ) zType[2] = 'L';
164397 sqlite3TreeViewExpr(0, pTerm->pExpr, 0);
164990 Expr *pRight = pTerm->pExpr->pRight;
164992 testcase( pTerm->pExpr->op==TK_IS );
165035 int nCmp = sqlite3ExprVectorSize(pTerm->pExpr->pLeft);
165047 assert( ExprUseXList(pTerm->pExpr->pLeft) );
165048 pLhs = pTerm->pExpr->pLeft->x.pList->a[i].pExpr;
165049 pRhs = pTerm->pExpr->pRight;
165051 pRhs = pRhs->x.pSelect->pEList->a[i].pExpr;
165053 pRhs = pRhs->x.pList->a[i].pExpr;
165218 Expr *pExpr = pTerm->pExpr;
165219 if( ExprUseXSelect(pExpr) ){
165230 if( pNew->aLTerm[i] && pNew->aLTerm[i]->pExpr==pExpr ) nIn = 0;
165232 }else if( ALWAYS(pExpr->x.pList && pExpr->x.pList->nExpr) ){
165234 nIn = sqlite3LogEst(pExpr->x.pList->nExpr);
165361 && ((eOp & WO_IN)==0 || ExprUseXList(pTerm->pExpr))
165364 Expr *pExpr = pTerm->pExpr;
165369 rc = whereEqualScanEst(pParse, pBuilder, pExpr->pRight, &nOut);
165371 rc = whereInScanEst(pParse, pBuilder, pExpr->x.pList, &nOut);
165545 Expr *pExpr = sqlite3ExprSkipCollateAndLikely(pOB->a[ii].pExpr);
165546 if( NEVER(pExpr==0) ) continue;
165547 if( (pExpr->op==TK_COLUMN || pExpr->op==TK_AGG_COLUMN)
165548 && pExpr->iTable==iCursor
165550 if( pExpr->iColumn<0 ) return 1;
165552 if( pExpr->iColumn==pIndex->aiColumn[jj] ) return 1;
165557 if( sqlite3ExprCompareSkip(pExpr,aColExpr->a[jj].pExpr,iCursor)==0 ){
165587 Expr *pExpr;
165588 pExpr = pTerm->pExpr;
165589 if( (!ExprHasProperty(pExpr, EP_OuterON) || pExpr->w.iJoin==iTab)
165590 && ((jointype & JT_OUTER)==0 || ExprHasProperty(pExpr, EP_OuterON))
165591 && sqlite3ExprImpliesExpr(pParse, pExpr, pWhere, iTab)
165602 ** expressions in the index match the pExpr expression.
165605 const Expr *pExpr,
165612 && sqlite3ExprCompare(0, pExpr, pIdx->aColExpr->a[i].pExpr, iTabCur)==0
165646 ** matches pExpr, then prune the search.
165648 static int whereIsCoveringIndexWalkCallback(Walker *pWalk, Expr *pExpr){
165657 if( (pExpr->op==TK_COLUMN || pExpr->op==TK_AGG_COLUMN) ){
165658 /* if( pExpr->iColumn<(BMS-1) && pIdx->bHasExpr==0 ) return WRC_Continue;*/
165659 if( pExpr->iTable!=pCk->iTabCur ) return WRC_Continue;
165664 if( aiColumn[i]==pExpr->iColumn ) return WRC_Continue;
165669 && exprIsCoveredByIndex(pExpr, pIdx, pWalk->u.pCovIdxCk->iTabCur) ){
165752 sqlite3ExprDelete(db, p->pExpr);
165816 p->pExpr = sqlite3ExprDup(db, pRight, 0);
166120 if( !sqlite3ExprCoveredByIndex(pTerm->pExpr, iCur, pProbe) ){
166420 Expr *pX = pHidden->pWC->a[iTerm].pExpr;
166468 pH->pParse->db, pTerm->pExpr->pRight, ENC(pH->pParse->db),
166994 pOBExpr = sqlite3ExprSkipCollateAndLikely(pOrderBy->a[i].pExpr);
167012 CollSeq *pColl1 = sqlite3ExprNNCollSeq(pParse, pOrderBy->a[i].pExpr);
167013 CollSeq *pColl2 = sqlite3ExprCompareCollSeq(pParse, pTerm->pExpr);
167018 testcase( pTerm->pExpr->op==TK_IS );
167083 Expr *pX = pLoop->aLTerm[j]->pExpr;
167085 if( pLoop->aLTerm[i]->pExpr==pX ){
167127 pOBExpr = sqlite3ExprSkipCollateAndLikely(pOrderBy->a[i].pExpr);
167137 Expr *pIxExpr = pIndex->aColExpr->a[j].pExpr;
167143 pColl = sqlite3ExprNNCollSeq(pWInfo->pParse, pOrderBy->a[i].pExpr);
167202 p = pOrderBy->a[i].pExpr;
167908 static int exprNodeIsDeterministic(Walker *pWalker, Expr *pExpr){
167909 if( pExpr->op==TK_FUNCTION && ExprHasProperty(pExpr, EP_ConstFunc)==0 ){
168031 if( !ExprHasProperty(pTerm->pExpr, EP_OuterON)
168032 || pTerm->pExpr->w.iJoin!=pItem->iCursor
168038 && ExprHasProperty(pTerm->pExpr, EP_InnerON)
168039 && pTerm->pExpr->w.iJoin==pItem->iCursor
168132 static int exprNodeCanReturnSubtype(Walker *pWalker, Expr *pExpr){
168136 if( pExpr->op!=TK_FUNCTION ){
168139 assert( ExprUseXList(pExpr) );
168141 n = pExpr->x.pList ? pExpr->x.pList->nExpr : 0;
168142 pDef = sqlite3FindFunction(db, pExpr->u.zToken, n, ENC(db), 0);
168151 ** Return TRUE if expression pExpr is able to return a subtype.
168158 static int sqlite3ExprCanReturnSubtype(Parse *pParse, Expr *pExpr){
168163 sqlite3WalkExpr(&w, pExpr);
168190 Expr *pExpr;
168193 pExpr = pIdx->aColExpr->a[i].pExpr;
168195 pExpr = sqlite3ColumnExpr(pTab, &pTab->aCol[j]);
168199 if( sqlite3ExprIsConstant(0,pExpr) ) continue;
168200 if( pExpr->op==TK_FUNCTION && sqlite3ExprCanReturnSubtype(pParse,pExpr) ){
168212 if( sqlite3WhereTrace & 0x5000 ) sqlite3ShowExpr(pExpr);
168215 p->pExpr = sqlite3ExprDup(pParse->db, pExpr, 0);
168544 pX = pT->pExpr;
169253 if( sqlite3WhereTrace & 0x5000 ) sqlite3ShowExpr(p->pExpr);
170095 static int selectWindowRewriteExprCb(Walker *pWalker, Expr *pExpr){
170107 if( pExpr->op!=TK_COLUMN ){
170113 if( pExpr->iTable==p->pSrc->a[i].iCursor ) break;
170119 switch( pExpr->op ){
170122 if( !ExprHasProperty(pExpr, EP_WinFunc) ){
170127 if( pExpr->y.pWin==pWin ){
170128 assert( pWin->pOwner==pExpr );
170143 if( 0==sqlite3ExprCompare(0, p->pSub->a[i].pExpr, pExpr, -1) ){
170150 Expr *pDup = sqlite3ExprDup(pParse->db, pExpr, 0);
170155 int f = pExpr->flags & EP_Collate;
170156 assert( ExprHasProperty(pExpr, EP_Static)==0 );
170157 ExprSetProperty(pExpr, EP_Static);
170158 sqlite3ExprDelete(pParse->db, pExpr);
170159 ExprClearProperty(pExpr, EP_Static);
170160 memset(pExpr, 0, sizeof(Expr));
170162 pExpr->op = TK_COLUMN;
170163 pExpr->iColumn = (iCol<0 ? p->pSub->nExpr-1: iCol);
170164 pExpr->iTable = p->pWin->iEphCsr;
170165 pExpr->y.pTab = p->pTab;
170166 pExpr->flags = f;
170250 Expr *pDup = sqlite3ExprDup(db, pAppend->a[i].pExpr, 0);
170280 static int sqlite3WindowExtraAggFuncDepth(Walker *pWalker, Expr *pExpr){
170281 if( pExpr->op==TK_AGG_FUNCTION
170282 && pExpr->op2>=pWalker->walkerDepth
170284 pExpr->op2++;
170289 static int disallowAggregatesInOrderByCb(Walker *pWalker, Expr *pExpr){
170290 if( pExpr->op==TK_AGG_FUNCTION && pExpr->pAggInfo==0 ){
170291 assert( !ExprHasProperty(pExpr, EP_IntValue) );
170293 "misuse of aggregate: %s()", pExpr->u.zToken);
170513 static Expr *sqlite3WindowOffsetExpr(Parse *pParse, Expr *pExpr){
170514 if( 0==sqlite3ExprIsConstant(0,pExpr) ){
170515 if( IN_RENAME_OBJECT ) sqlite3RenameExprUnmap(pParse, pExpr);
170516 sqlite3ExprDelete(pParse->db, pExpr);
170517 pExpr = sqlite3ExprAlloc(pParse->db, TK_NULL, 0, 0);
170519 return pExpr;
171090 pColl = sqlite3ExprNNCollSeq(pParse, pWin->pOwner->x.pList->a[0].pExpr);
171554 pColl = sqlite3ExprNNCollSeq(pParse, pOrderBy->a[0].pExpr);
171774 ** pExpr evaluates to a value that, when cast to an integer, is greater
171780 static int windowExprGtZero(Parse *pParse, Expr *pExpr){
171784 sqlite3ValueFromExpr(db, pExpr, db->enc, SQLITE_AFF_NUMERIC, &pVal);
172526 struct FrameBound { int eType; Expr *pExpr; };
174943 sqlite3ExprDelete(pParse->db, (yypminor->yy509).pExpr);
176943 yymsp[-4].minor.yy454->flags |= pList->a[0].pExpr->flags & EP_Propagate;
177079 Expr *pRHS = yymsp[-1].minor.yy14->a[0].pExpr;
177081 yymsp[-1].minor.yy14->a[0].pExpr = 0;
177495 yylhsminor.yy211 = sqlite3WindowAlloc(pParse, yymsp[-2].minor.yy144, yymsp[-1].minor.yy509.eType, yymsp[-1].minor.yy509.pExpr, TK_CURRENT, 0, yymsp[0].minor.yy462);
177501 yylhsminor.yy211 = sqlite3WindowAlloc(pParse, yymsp[-5].minor.yy144, yymsp[-3].minor.yy509.eType, yymsp[-3].minor.yy509.pExpr, yymsp[-1].minor.yy509.eType, yymsp[-1].minor.yy509.pExpr, yymsp[0].minor.yy462);
177513 {yylhsminor.yy509.eType = yymsp[-1].major; yylhsminor.yy509.pExpr = 0;}
177517 {yylhsminor.yy509.eType = yymsp[0].major; yylhsminor.yy509.pExpr = yymsp[-1].minor.yy454;}
186116 Fts3Expr *pExpr; /* Parsed MATCH query string */
187937 sqlite3Fts3ExprFree(pCsr->pExpr);
189514 p->azColumn, p->bFts4, p->nColumn, iCol, zQuery, -1, &pCsr->pExpr,
189626 if( pCsr->pExpr ){
190357 ** by pExpr.
190372 Fts3Expr *pExpr, /* Allocate readers for this expression */
190377 if( pExpr && SQLITE_OK==*pRc ){
190378 if( pExpr->eType==FTSQUERY_PHRASE ){
190380 int nToken = pExpr->pPhrase->nToken;
190383 Fts3PhraseToken *pToken = &pExpr->pPhrase->aToken[i];
190392 assert( pExpr->pPhrase->iDoclistToken==0 );
190393 pExpr->pPhrase->iDoclistToken = -1;
190395 *pnOr += (pExpr->eType==FTSQUERY_OR);
190396 fts3EvalAllocateReaders(pCsr, pExpr->pLeft, pnToken, pnOr, pRc);
190397 fts3EvalAllocateReaders(pCsr, pExpr->pRight, pnToken, pnOr, pRc);
191037 Fts3Expr *pExpr, /* Expression to initialize phrases in */
191040 if( pExpr && SQLITE_OK==*pRc ){
191041 if( pExpr->eType==FTSQUERY_PHRASE ){
191042 int nToken = pExpr->pPhrase->nToken;
191046 if( pExpr->pPhrase->aToken[i].pDeferred==0 ) break;
191048 pExpr->bDeferred = (i==nToken);
191050 *pRc = fts3EvalPhraseStart(pCsr, 1, pExpr->pPhrase);
191052 fts3EvalStartReaders(pCsr, pExpr->pLeft, pRc);
191053 fts3EvalStartReaders(pCsr, pExpr->pRight, pRc);
191054 pExpr->bDeferred = (pExpr->pLeft->bDeferred && pExpr->pRight->bDeferred);
191091 Fts3Expr *pExpr, /* Expression to consider */
191097 if( pExpr->eType==FTSQUERY_PHRASE ){
191098 Fts3Phrase *pPhrase = pExpr->pPhrase;
191109 }else if( pExpr->eType!=FTSQUERY_NOT ){
191110 assert( pExpr->eType==FTSQUERY_OR
191111 || pExpr->eType==FTSQUERY_AND
191112 || pExpr->eType==FTSQUERY_NEAR
191114 assert( pExpr->pLeft && pExpr->pRight );
191115 if( pExpr->eType==FTSQUERY_OR ){
191116 pRoot = pExpr->pLeft;
191120 fts3EvalTokenCosts(pCsr, pRoot, pExpr->pLeft, ppTC, ppOr, pRc);
191121 if( pExpr->eType==FTSQUERY_OR ){
191122 pRoot = pExpr->pRight;
191126 fts3EvalTokenCosts(pCsr, pRoot, pExpr->pRight, ppTC, ppOr, pRc);
191326 ** the full-text query currently stored in pCsr->pExpr. To iterate through
191343 fts3EvalAllocateReaders(pCsr, pCsr->pExpr, &nToken, &nOr, &rc);
191362 fts3EvalTokenCosts(pCsr, 0, pCsr->pExpr, &pTC, &ppOr, &rc);
191378 fts3EvalStartReaders(pCsr, pCsr->pExpr, &rc);
191459 ** successful, the following variables in pExpr are set:
191494 Fts3Expr *pExpr, /* Expr. to advance to next matching row */
191497 if( *pRc==SQLITE_OK && pExpr->bEof==0 ){
191499 pExpr->bStart = 1;
191501 switch( pExpr->eType ){
191504 Fts3Expr *pLeft = pExpr->pLeft;
191505 Fts3Expr *pRight = pExpr->pRight;
191512 pExpr->iDocid = pRight->iDocid;
191513 pExpr->bEof = pRight->bEof;
191518 pExpr->iDocid = pLeft->iDocid;
191519 pExpr->bEof = pLeft->bEof;
191533 pExpr->iDocid = pLeft->iDocid;
191534 pExpr->bEof = (pLeft->bEof || pRight->bEof);
191535 if( pExpr->eType==FTSQUERY_NEAR && pExpr->bEof ){
191558 Fts3Expr *pLeft = pExpr->pLeft;
191559 Fts3Expr *pRight = pExpr->pRight;
191574 pExpr->bEof = (pLeft->bEof && pRight->bEof);
191577 pExpr->iDocid = pLeft->iDocid;
191579 pExpr->iDocid = pRight->iDocid;
191586 Fts3Expr *pLeft = pExpr->pLeft;
191587 Fts3Expr *pRight = pExpr->pRight;
191603 pExpr->iDocid = pLeft->iDocid;
191604 pExpr->bEof = pLeft->bEof;
191609 Fts3Phrase *pPhrase = pExpr->pPhrase;
191611 *pRc = fts3EvalPhraseNext(pCsr, pPhrase, &pExpr->bEof);
191612 pExpr->iDocid = pPhrase->doclist.iDocid;
191620 ** If *pRc is not SQLITE_OK, or if pExpr is not the root node of a NEAR
191634 static int fts3EvalNearTest(Fts3Expr *pExpr, int *pRc){
191637 /* The following block runs if pExpr is the root of a NEAR query.
191658 && pExpr->eType==FTSQUERY_NEAR
191659 && (pExpr->pParent==0 || pExpr->pParent->eType!=FTSQUERY_NEAR)
191666 for(p=pExpr; p->pLeft; p=p->pLeft){
191685 aPoslist = pExpr->pRight->pPhrase->doclist.pList;
191686 nToken = pExpr->pRight->pPhrase->nToken;
191687 for(p=pExpr->pLeft; p && res; p=p->pLeft){
191718 Fts3Expr *pExpr, /* Expr to test. May or may not be root. */
191723 switch( pExpr->eType ){
191727 fts3EvalTestExpr(pCsr, pExpr->pLeft, pRc)
191728 && fts3EvalTestExpr(pCsr, pExpr->pRight, pRc)
191729 && fts3EvalNearTest(pExpr, pRc)
191748 && pExpr->eType==FTSQUERY_NEAR
191749 && (pExpr->pParent==0 || pExpr->pParent->eType!=FTSQUERY_NEAR)
191752 for(p=pExpr; p->pPhrase==0; p=p->pLeft){
191765 int bHit1 = fts3EvalTestExpr(pCsr, pExpr->pLeft, pRc);
191766 int bHit2 = fts3EvalTestExpr(pCsr, pExpr->pRight, pRc);
191773 fts3EvalTestExpr(pCsr, pExpr->pLeft, pRc)
191774 && !fts3EvalTestExpr(pCsr, pExpr->pRight, pRc)
191780 if( pCsr->pDeferred && (pExpr->bDeferred || (
191781 pExpr->iDocid==pCsr->iPrevId && pExpr->pPhrase->doclist.pList
191783 Fts3Phrase *pPhrase = pExpr->pPhrase;
191784 if( pExpr->bDeferred ){
191789 pExpr->iDocid = pCsr->iPrevId;
191794 pExpr->bEof==0 && pExpr->iDocid==pCsr->iPrevId
191795 && pExpr->pPhrase->doclist.nList>0
191846 bMiss = (0==fts3EvalTestExpr(pCsr, pCsr->pExpr, &rc));
191857 ** Fts3Cursor.pExpr.
191861 Fts3Expr *pExpr = pCsr->pExpr;
191863 if( pExpr==0 ){
191871 fts3EvalNextRow(pCsr, pExpr, &rc);
191872 pCsr->isEof = pExpr->bEof;
191875 pCsr->iPrevId = pExpr->iDocid;
191892 ** Restart interation for expression pExpr so that the next call to
191902 Fts3Expr *pExpr,
191905 if( pExpr && *pRc==SQLITE_OK ){
191906 Fts3Phrase *pPhrase = pExpr->pPhrase;
191926 pExpr->iDocid = 0;
191927 pExpr->bEof = 0;
191928 pExpr->bStart = 0;
191930 fts3EvalRestart(pCsr, pExpr->pLeft, pRc);
191931 fts3EvalRestart(pCsr, pExpr->pRight, pRc);
191937 ** expression rooted at pExpr, the cursor iterates through all rows matched
191938 ** by pExpr, calling this function for each row. This function increments
191943 static void fts3EvalUpdateCounts(Fts3Expr *pExpr, int nCol){
191944 if( pExpr ){
191945 Fts3Phrase *pPhrase = pExpr->pPhrase;
191961 pExpr->aMI[iCol*3 + 1] += iCnt;
191962 pExpr->aMI[iCol*3 + 2] += (iCnt>0);
191969 fts3EvalUpdateCounts(pExpr->pLeft, nCol);
191970 fts3EvalUpdateCounts(pExpr->pRight, nCol);
191979 static int fts3AllocateMSI(Fts3Expr *pExpr, int iPhrase, void *pCtx){
191982 if( pExpr->aMI==0 ){
191983 pExpr->aMI = (u32 *)sqlite3_malloc64(pTab->nColumn * 3 * sizeof(u32));
191984 if( pExpr->aMI==0 ) return SQLITE_NOMEM;
191986 memset(pExpr->aMI, 0, pTab->nColumn * 3 * sizeof(u32));
191991 ** Expression pExpr must be of type FTSQUERY_PHRASE.
191994 ** populates the Fts3Expr.aMI[] array for expression pExpr. If pExpr is part
192003 Fts3Expr *pExpr /* FTSQUERY_PHRASE expression */
192007 assert( pExpr->eType==FTSQUERY_PHRASE );
192008 if( pExpr->aMI==0 ){
192017 pRoot = pExpr;
192110 Fts3Expr *pExpr, /* Phrase expression */
192117 if( pExpr->bDeferred && pExpr->pParent->eType!=FTSQUERY_NEAR ){
192124 rc = fts3EvalGatherStats(pCsr, pExpr);
192126 assert( pExpr->aMI );
192128 aiOut[iCol*3 + 1] = pExpr->aMI[iCol*3 + 1];
192129 aiOut[iCol*3 + 2] = pExpr->aMI[iCol*3 + 2];
192138 ** The expression pExpr passed as the second argument to this function
192158 Fts3Expr *pExpr, /* Phrase to return doclist for */
192162 Fts3Phrase *pPhrase = pExpr->pPhrase;
192176 iDocid = pExpr->iDocid;
192178 if( iDocid!=pCsr->iPrevId || pExpr->bEof ){
192183 Fts3Expr *p; /* Used to iterate from pExpr to root */
192184 Fts3Expr *pNear; /* Most senior NEAR ancestor (or pExpr) */
192193 pNear = pExpr;
192194 for(p=pExpr->pParent; p; p=p->pParent){
194024 static char *exprToString(Fts3Expr *pExpr, char *zBuf){
194025 if( pExpr==0 ){
194028 switch( pExpr->eType ){
194030 Fts3Phrase *pPhrase = pExpr->pPhrase;
194044 zBuf = sqlite3_mprintf("%zNEAR/%d ", zBuf, pExpr->nNear);
194058 if( zBuf ) zBuf = exprToString(pExpr->pLeft, zBuf);
194061 if( zBuf ) zBuf = exprToString(pExpr->pRight, zBuf);
194094 Fts3Expr *pExpr;
194134 pTokenizer, 0, azCol, 0, nCol, nCol, zExpr, nExpr, &pExpr, &zDummy
194136 assert( rc==SQLITE_OK || pExpr==0 );
194140 pTokenizer, 0, azCol, 0, nCol, nCol, zExpr, nExpr, &pExpr
194145 sqlite3Fts3ExprFree(pExpr);
194147 }else if( rc==SQLITE_NOMEM || !(zBuf = exprToString(pExpr, 0)) ){
194154 sqlite3Fts3ExprFree(pExpr);
202558 Fts3Expr *pExpr, /* Expression to iterate phrases of */
202564 int eType = pExpr->eType; /* Type of expression node pExpr */
202567 assert( pExpr->pLeft && pExpr->pRight );
202568 rc = fts3ExprIterate2(pExpr->pLeft, piPhrase, x, pCtx);
202570 rc = fts3ExprIterate2(pExpr->pRight, piPhrase, x, pCtx);
202573 rc = x(pExpr, *piPhrase, pCtx);
202590 Fts3Expr *pExpr, /* Expression to iterate phrases of */
202595 return fts3ExprIterate2(pExpr, &iPhrase, x, pCtx);
202603 static int fts3ExprLoadDoclistsCb(Fts3Expr *pExpr, int iPhrase, void *ctx){
202605 Fts3Phrase *pPhrase = pExpr->pPhrase;
202634 rc = sqlite3Fts3ExprIterate(pCsr->pExpr,fts3ExprLoadDoclistsCb,(void*)&sCtx);
202640 static int fts3ExprPhraseCountCb(Fts3Expr *pExpr, int iPhrase, void *ctx){
202642 pExpr->iPhrase = iPhrase;
202645 static int fts3ExprPhraseCount(Fts3Expr *pExpr){
202647 (void)sqlite3Fts3ExprIterate(pExpr, fts3ExprPhraseCountCb, (void *)&nPhrase);
202779 static int fts3SnippetFindPositions(Fts3Expr *pExpr, int iPhrase, void *ctx){
202785 pPhrase->nToken = pExpr->pPhrase->nToken;
202786 rc = sqlite3Fts3EvalPhrasePoslist(p->pCsr, pExpr, p->iCol, &pCsr);
202868 pCsr->pExpr, fts3SnippetFindPositions, (void*)&sIter
203175 Fts3Expr *pExpr, /* Phrase expression node */
203180 Fts3Phrase *pPhrase = pExpr->pPhrase;
203186 iStart = pExpr->iPhrase * p->nCol;
203188 iStart = pExpr->iPhrase * ((p->nCol + 31) / 32);
203213 Fts3Expr *pExpr,
203217 assert( (pExpr->pLeft==0)==(pExpr->pRight==0) );
203218 if( pExpr->bEof==0 && pExpr->iDocid==p->pCursor->iPrevId ){
203219 if( pExpr->pLeft ){
203220 rc = fts3ExprLHitGather(pExpr->pLeft, p);
203221 if( rc==SQLITE_OK ) rc = fts3ExprLHitGather(pExpr->pRight, p);
203223 rc = fts3ExprLHits(pExpr, p);
203250 ** If the phrase pExpr consists entirely of deferred tokens, then all X and
203257 Fts3Expr *pExpr, /* Phrase expression node */
203263 p->pCursor, pExpr, &p->aMatchinfo[3*iPhrase*p->nCol]
203273 Fts3Expr *pExpr, /* Phrase expression node */
203284 rc = sqlite3Fts3EvalPhrasePoslist(p->pCursor, pExpr, i, &pCsr);
203395 Fts3Expr *pExpr; /* Pointer to phrase expression */
203408 Fts3Expr *pExpr, /* Phrase expression node */
203413 aIter[iPhrase].pExpr = pExpr;
203464 (void)sqlite3Fts3ExprIterate(pCsr->pExpr, fts3MatchinfoLcsCb, (void*)aIter);
203468 nToken -= pIter->pExpr->pPhrase->nToken;
203478 rc = sqlite3Fts3EvalPhrasePoslist(pCsr, pIt->pExpr, iCol, &pIt->pRead);
203626 rc = fts3ExprLHitGather(pCsr->pExpr, pInfo);
203631 Fts3Expr *pExpr;
203633 pExpr = pCsr->pExpr;
203641 rc = sqlite3Fts3ExprIterate(pExpr, fts3ExprGlobalHitsCb,(void*)pInfo);
203645 (void)sqlite3Fts3ExprIterate(pExpr, fts3ExprLocalHitsCb,(void*)pInfo);
203697 pCsr->nPhrase = fts3ExprPhraseCount(pCsr->pExpr);
203773 if( !pCsr->pExpr ){
203870 static int fts3ExprTermOffsetInit(Fts3Expr *pExpr, int iPhrase, void *ctx){
203879 rc = sqlite3Fts3EvalPhrasePoslist(p->pCsr, pExpr, p->iCol, &pList);
203880 nTerm = pExpr->pPhrase->nToken;
203911 if( !pCsr->pExpr ){
203951 pCsr->pExpr, fts3ExprTermOffsetInit, (void*)&sCtx
204053 if( !pCsr->pExpr ){
216879 URegularExpression *pExpr = (URegularExpression *)p;
216880 uregex_close(pExpr);
216904 URegularExpression *pExpr;
216917 pExpr = sqlite3_get_auxdata(p, 0);
216918 if( !pExpr ){
216923 pExpr = uregex_open(zPattern, -1, 0, 0, &status);
216926 sqlite3_set_auxdata(p, 0, pExpr, icuRegexpDelete);
216927 pExpr = sqlite3_get_auxdata(p, 0);
216929 if( !pExpr ){
216936 uregex_setText(pExpr, zString, -1, &status);
216943 res = uregex_matches(pExpr, 0, &status);
216954 uregex_setText(pExpr, 0, 0, &status);
232801 ** for(rc = sqlite3Fts5ExprFirst(pExpr, pIdx, bDesc);
232802 ** rc==SQLITE_OK && 0==sqlite3Fts5ExprEof(pExpr);
232803 ** rc = sqlite3Fts5ExprNext(pExpr)
232806 ** i64 iRowid = sqlite3Fts5ExprRowid(pExpr);
236812 Fts5ExprNode *pExpr; /* Result of a successful parse */
236955 assert_expr_depth_ok(sParse.rc, sParse.pExpr);
236959 if( iCol<pConfig->nCol && sParse.pExpr && sParse.rc==SQLITE_OK ){
236965 sqlite3Fts5ParseSetColset(&sParse, sParse.pExpr, pColset);
236974 sqlite3Fts5ParseNodeFree(sParse.pExpr);
236976 if( !sParse.pExpr ){
236983 pNew->pRoot = sParse.pExpr;
236993 sqlite3Fts5ParseNodeFree(sParse.pExpr);
237562 Fts5Expr *pExpr, /* Expression that pNear is a part of */
237568 if( pExpr->pConfig->eDetail!=FTS5_DETAIL_FULL ){
237620 Fts5Expr *pExpr,
237646 pExpr->pIndex, p->pTerm, p->nQueryTerm,
237648 (pExpr->bDesc ? FTS5INDEX_QUERY_DESC : 0),
237672 ** If pExpr is an ASC iterator, this function returns a value with the
237682 Fts5Expr *pExpr,
237686 assert( pExpr->bDesc==0 || pExpr->bDesc==1 );
237687 if( pExpr->bDesc==0 ){
237736 Fts5Expr *pExpr,
237742 return fts5RowidCmp(pExpr, p1->iRowid, p2->iRowid);
237757 Fts5Expr *pExpr, /* Expression pPhrase belongs to */
237766 const int bDesc = pExpr->bDesc;
237813 pNode->bNomatch = ((0==fts5ExprNearTest(&rc, pExpr, pNode)) && rc==SQLITE_OK);
237827 Fts5Expr *pExpr, /* Expression pPhrase belongs to */
237841 i64 iRowid = fts5ExprSynonymRowid(pTerm, pExpr->bDesc, 0);
237849 || (bFromValid && ii!=iFrom && (ii>iFrom)==pExpr->bDesc)
237884 rc = fts5ExprNodeTest_STRING(pExpr, pNode);
237892 Fts5Expr *pExpr, /* Expression that pNear is a part of */
237908 if( pExpr->pConfig->eDetail==FTS5_DETAIL_FULL ){
237920 Fts5Expr *pExpr,
237935 rc = fts5ExprNodeTest_TERM(pExpr, pNode);
237944 Fts5Expr *pExpr, /* Expression of which pNode is a part */
237952 int cmp = fts5NodeCompare(pExpr, pNext, pChild);
237963 Fts5Expr *pExpr,
237973 assert( p1->bEof || fts5RowidCmp(pExpr, p1->iRowid, iLast)>=0 );
237976 || (bFromValid && fts5RowidCmp(pExpr, p1->iRowid, iFrom)<0)
237978 int rc = fts5ExprNodeNext(pExpr, p1, bFromValid, iFrom);
237987 fts5ExprNodeTest_OR(pExpr, pNode);
237995 Fts5Expr *pExpr, /* Expression pPhrase belongs to */
238009 int cmp = fts5RowidCmp(pExpr, iLast, pChild->iRowid);
238012 rc = fts5ExprNodeNext(pExpr, pChild, 1, iLast);
238023 assert( pChild->bEof || fts5RowidCmp(pExpr, iLast, pChild->iRowid)<=0 );
238039 if( pAnd->bNomatch && pAnd!=pExpr->pRoot ){
238047 Fts5Expr *pExpr,
238052 int rc = fts5ExprNodeNext(pExpr, pNode->apChild[0], bFromValid, iFrom);
238054 rc = fts5ExprNodeTest_AND(pExpr, pNode);
238062 Fts5Expr *pExpr, /* Expression pPhrase belongs to */
238071 int cmp = fts5NodeCompare(pExpr, p1, p2);
238073 rc = fts5ExprNodeNext(pExpr, p2, 1, p1->iRowid);
238074 cmp = fts5NodeCompare(pExpr, p1, p2);
238078 rc = fts5ExprNodeNext(pExpr, p1, 0, 0);
238090 Fts5Expr *pExpr,
238095 int rc = fts5ExprNodeNext(pExpr, pNode->apChild[0], bFromValid, iFrom);
238097 rc = fts5ExprNodeTest_NOT(pExpr, pNode);
238111 Fts5Expr *pExpr, /* Expression of which pNode is a part */
238119 rc = fts5ExprNodeTest_STRING(pExpr, pNode);
238124 rc = fts5ExprNodeTest_TERM(pExpr, pNode);
238129 rc = fts5ExprNodeTest_AND(pExpr, pNode);
238134 fts5ExprNodeTest_OR(pExpr, pNode);
238139 rc = fts5ExprNodeTest_NOT(pExpr, pNode);
238149 ** Set node pNode, which is part of expression pExpr, to point to the first
238155 static int fts5ExprNodeFirst(Fts5Expr *pExpr, Fts5ExprNode *pNode){
238162 rc = fts5ExprNearInitAll(pExpr, pNode);
238170 rc = fts5ExprNodeFirst(pExpr, pNode->apChild[i]);
238193 rc = fts5ExprNodeTest(pExpr, pNode);
238480 assert( pParse->pExpr==0 );
238481 pParse->pExpr = p;
238559 Fts5Expr *pExpr,
238564 Fts5ExprPhrase *pOrig = 0; /* The phrase extracted from pExpr */
238567 if( iPhrase<0 || iPhrase>=pExpr->nPhrase ){
238570 pOrig = pExpr->apExprPhrase[iPhrase];
238602 sCtx.pConfig = pExpr->pConfig;
238624 pNew->pIndex = pExpr->pIndex;
238625 pNew->pConfig = pExpr->pConfig;
238884 ** Apply colset pColset to expression node pExpr and all of its descendents.
238888 Fts5ExprNode *pExpr,
238897 fts5ParseSetColset(pParse, pExpr, pColset, &pFree);
239223 ** Compose a tcl-readable representation of expression pExpr. Return a
239231 Fts5ExprNode *pExpr
239234 if( pExpr->eType==FTS5_STRING || pExpr->eType==FTS5_TERM ){
239235 Fts5ExprNearset *pNear = pExpr->pNear;
239282 }else if( pExpr->eType==0 ){
239287 switch( pExpr->eType ){
239291 assert( pExpr->eType==FTS5_OR );
239297 for(i=0; zRet && i<pExpr->nChild; i++){
239298 char *z = fts5ExprPrintTcl(pConfig, zNearsetCmd, pExpr->apChild[i]);
239311 static char *fts5ExprPrint(Fts5Config *pConfig, Fts5ExprNode *pExpr){
239313 if( pExpr->eType==0 ){
239316 if( pExpr->eType==FTS5_STRING || pExpr->eType==FTS5_TERM ){
239317 Fts5ExprNearset *pNear = pExpr->pNear;
239369 switch( pExpr->eType ){
239373 assert( pExpr->eType==FTS5_OR );
239378 for(i=0; i<pExpr->nChild; i++){
239379 char *z = fts5ExprPrint(pConfig, pExpr->apChild[i]);
239384 int e = pExpr->apChild[i]->eType;
239412 Fts5Expr *pExpr = 0;
239455 rc = sqlite3Fts5ExprNew(pConfig, 0, pConfig->nCol, zExpr, &pExpr, &zErr);
239459 if( pExpr->pRoot->xNext==0 ){
239462 zText = fts5ExprPrintTcl(pConfig, zNearsetCmd, pExpr->pRoot);
239464 zText = fts5ExprPrint(pConfig, pExpr->pRoot);
239484 sqlite3Fts5ExprFree(pExpr);
239586 ** Return the number of phrases in expression pExpr.
239588 static int sqlite3Fts5ExprPhraseCount(Fts5Expr *pExpr){
239589 return (pExpr ? pExpr->nPhrase : 0);
239593 ** Return the number of terms in the iPhrase'th phrase in pExpr.
239595 static int sqlite3Fts5ExprPhraseSize(Fts5Expr *pExpr, int iPhrase){
239596 if( iPhrase<0 || iPhrase>=pExpr->nPhrase ) return 0;
239597 return pExpr->apExprPhrase[iPhrase]->nTerm;
239604 static int sqlite3Fts5ExprPoslist(Fts5Expr *pExpr, int iPhrase, const u8 **pa){
239606 Fts5ExprPhrase *pPhrase = pExpr->apExprPhrase[iPhrase];
239608 if( pNode->bEof==0 && pNode->iRowid==pExpr->pRoot->iRowid ){
239633 static Fts5PoslistPopulator *sqlite3Fts5ExprClearPoslists(Fts5Expr *pExpr, int bLive){
239635 pRet = sqlite3_malloc64(sizeof(Fts5PoslistPopulator)*pExpr->nPhrase);
239638 memset(pRet, 0, sizeof(Fts5PoslistPopulator)*pExpr->nPhrase);
239639 for(i=0; i<pExpr->nPhrase; i++){
239640 Fts5Buffer *pBuf = &pExpr->apExprPhrase[i]->poslist;
239641 Fts5ExprNode *pNode = pExpr->apExprPhrase[i]->pNode;
239642 assert( pExpr->apExprPhrase[i]->nTerm<=1 );
239644 (pBuf->n==0 || pNode->iRowid!=pExpr->pRoot->iRowid || pNode->bEof)
239656 Fts5Expr *pExpr;
239693 Fts5Expr *pExpr = p->pExpr;
239696 i64 iRowid = pExpr->pRoot->iRowid;
239701 if( pExpr->pConfig->bTokendata ){
239705 for(i=0; i<pExpr->nPhrase; i++){
239708 for(pT=&pExpr->apExprPhrase[i]->aTerm[0]; pT; pT=pT->pSynonym){
239713 &pExpr->apExprPhrase[i]->poslist, &p->aPopulator[i].writer, p->iOff
239715 if( rc==SQLITE_OK && pExpr->pConfig->bTokendata && !pT->bPrefix ){
239732 Fts5Expr *pExpr,
239739 sCtx.pExpr = pExpr;
239743 for(i=0; i<pExpr->nPhrase; i++){
239744 Fts5ExprNode *pNode = pExpr->apExprPhrase[i]->pNode;
239815 static void sqlite3Fts5ExprCheckPoslists(Fts5Expr *pExpr, i64 iRowid){
239816 fts5ExprCheckPoslists(pExpr->pRoot, iRowid);
239823 Fts5Expr *pExpr,
239828 Fts5ExprPhrase *pPhrase = pExpr->apExprPhrase[iPhrase];
239832 assert( iPhrase>=0 && iPhrase<pExpr->nPhrase );
239833 assert( pExpr->pConfig->eDetail==FTS5_DETAIL_COLUMNS );
239836 && pNode->iRowid==pExpr->pRoot->iRowid
239861 Fts5Expr *pExpr,
239869 if( iPhrase<0 || iPhrase>=pExpr->nPhrase ){
239872 pPhrase = pExpr->apExprPhrase[iPhrase];
239886 Fts5Expr *pExpr,
239899 if( iPhrase<0 || iPhrase>=pExpr->nPhrase ){
239902 pPhrase = pExpr->apExprPhrase[iPhrase];
239908 if( pExpr->pConfig->bTokendata ){
239924 static void sqlite3Fts5ExprClearTokens(Fts5Expr *pExpr){
239926 for(ii=0; ii<pExpr->nPhrase; ii++){
239928 for(pT=&pExpr->apExprPhrase[ii]->aTerm[0]; pT; pT=pT->pSynonym){
249775 Fts5Expr *pExpr; /* Expression for MATCH queries */
250364 sqlite3Fts5ExprFree(pCsr->pExpr);
250478 i64 iRowid = sqlite3Fts5ExprRowid(pCsr->pExpr);
250480 rc = sqlite3Fts5ExprFirst(pCsr->pExpr, pTab->p.pIndex, iRowid, bDesc);
250481 if( rc==SQLITE_OK && iRowid!=sqlite3Fts5ExprRowid(pCsr->pExpr) ){
250487 if( sqlite3Fts5ExprEof(pCsr->pExpr) ){
250520 sqlite3Fts5ExprClearTokens(pCsr->pExpr);
250526 rc = sqlite3Fts5ExprNext(pCsr->pExpr, pCsr->iLastRowid);
250527 CsrFlagSet(pCsr, sqlite3Fts5ExprEof(pCsr->pExpr));
250609 nPhrase = sqlite3Fts5ExprPhraseCount(pCsr->pExpr);
250650 Fts5Expr *pExpr = pCsr->pExpr;
250651 rc = sqlite3Fts5ExprFirst(pExpr, pTab->p.pIndex, pCsr->iFirstRowid, bDesc);
250652 if( sqlite3Fts5ExprEof(pExpr) ){
250842 Fts5Expr *pExpr = 0;
250857 assert( pCsr->pExpr==0 );
250890 rc = sqlite3Fts5ExprNew(pConfig, 0, iCol, zText, &pExpr, pzErr);
250892 rc = sqlite3Fts5ExprAnd(&pCsr->pExpr, pExpr);
250893 pExpr = 0;
250910 rc = sqlite3Fts5ExprPattern(pConfig, bGlob, iCol, zText, &pExpr);
250913 rc = sqlite3Fts5ExprAnd(&pCsr->pExpr, pExpr);
250914 pExpr = 0;
250970 pCsr->pExpr = pTab->pSortCsr->pExpr;
250972 }else if( pCsr->pExpr ){
251009 sqlite3Fts5ExprFree(pExpr);
251034 return sqlite3Fts5ExprRowid(pCsr->pExpr);
251091 assert( pCsr->pExpr );
251496 return sqlite3Fts5ExprPhraseCount(pCsr->pExpr);
251501 return sqlite3Fts5ExprPhraseSize(pCsr->pExpr, iPhrase);
251540 if( iPhrase<0 || iPhrase>=sqlite3Fts5ExprPhraseCount(pCsr->pExpr) ){
251546 aPopulator = sqlite3Fts5ExprClearPoslists(pCsr->pExpr, bLive);
251553 pConfig, pCsr->pExpr, aPopulator, i, z, n
251560 sqlite3Fts5ExprCheckPoslists(pCsr->pExpr, pCsr->pSorter->iRowid);
251573 *pn = sqlite3Fts5ExprPoslist(pCsr->pExpr, iPhrase, pa);
251595 nIter = sqlite3Fts5ExprPhraseCount(pCsr->pExpr);
251914 rc = sqlite3Fts5ExprPhraseCollist(pCsr->pExpr, iPhrase, &pIter->a, &n);
251952 return sqlite3Fts5ExprQueryToken(pCsr->pExpr, iPhrase, iToken, ppOut, pnOut);
251977 pCsr->pExpr, iRowid, iPhrase, iCol, iOff, iToken, ppOut, pnOut
252034 rc = sqlite3Fts5ExprClonePhrase(pCsr->pExpr, iPhrase, &pNew->pExpr);
252134 int nPhrase = sqlite3Fts5ExprPhraseCount(pCsr->pExpr);
252144 int nByte = sqlite3Fts5ExprPoslist(pCsr->pExpr, i, &dummy);
252152 nPoslist = sqlite3Fts5ExprPoslist(pCsr->pExpr, i, &pPoslist);
252163 rc = sqlite3Fts5ExprPhraseCollist(pCsr->pExpr, i, &dummy, &nByte);
252171 rc = sqlite3Fts5ExprPhraseCollist(pCsr->pExpr, i, &pPoslist, &nPoslist);