Lines Matching refs:pExpr
9004 ** AggInfo.pGroupBy and AggInfo.aFunc.pExpr point to fields within the
9022 Expr *pExpr; /* The original expression */
9030 Expr *pExpr; /* Expression encoding the function */
9236 Expr *pExpr; /* The list of expressions */
9252 Expr *pExpr; /* The expression parse tree */
10359 SQLITE_PRIVATE char sqlite3CompareAffinity(Expr *pExpr, char aff2);
10360 SQLITE_PRIVATE int sqlite3IndexAffinityOk(Expr *pExpr, char idx_affinity);
10361 SQLITE_PRIVATE char sqlite3ExprAffinity(Expr *pExpr);
10370 SQLITE_PRIVATE CollSeq *sqlite3ExprCollSeq(Parse *pParse, Expr *pExpr);
47302 ** Create a new sqlite3_value object, containing the value of pExpr.
47313 Expr *pExpr, /* The expression to evaluate */
47322 if( !pExpr ){
47326 op = pExpr->op;
47328 op = pExpr->op2; /* This only happens with SQLITE_ENABLE_STAT2 */
47334 if( ExprHasProperty(pExpr, EP_IntValue) ){
47335 sqlite3VdbeMemSetInt64(pVal, (i64)pExpr->u.iValue);
47337 zVal = sqlite3DbStrDup(db, pExpr->u.zToken);
47351 if( SQLITE_OK==sqlite3ValueFromExpr(db,pExpr->pLeft,enc,affinity,&pVal) ){
47360 assert( pExpr->u.zToken[0]=='x' || pExpr->u.zToken[0]=='X' );
47361 assert( pExpr->u.zToken[1]=='\'' );
47364 zVal = &pExpr->u.zToken[2];
59213 SQLITE_PRIVATE int sqlite3WalkExpr(Walker *pWalker, Expr *pExpr){
59215 if( pExpr==0 ) return WRC_Continue;
59216 testcase( ExprHasProperty(pExpr, EP_TokenOnly) );
59217 testcase( ExprHasProperty(pExpr, EP_Reduced) );
59218 rc = pWalker->xExprCallback(pWalker, pExpr);
59220 && !ExprHasAnyProperty(pExpr,EP_TokenOnly) ){
59221 if( sqlite3WalkExpr(pWalker, pExpr->pLeft) ) return WRC_Abort;
59222 if( sqlite3WalkExpr(pWalker, pExpr->pRight) ) return WRC_Abort;
59223 if( ExprHasProperty(pExpr, EP_xIsSelect) ){
59224 if( sqlite3WalkSelect(pWalker, pExpr->x.pSelect) ) return WRC_Abort;
59226 if( sqlite3WalkExprList(pWalker, pExpr->x.pList) ) return WRC_Abort;
59241 if( sqlite3WalkExpr(pWalker, pItem->pExpr) ) return WRC_Abort;
59332 ** Turn the pExpr expression into an alias for the iCol-th column of the
59362 Expr *pExpr, /* Transform this into an alias to the result set */
59370 pOrig = pEList->a[iCol].pExpr;
59396 if( pExpr->flags & EP_ExpCollate ){
59397 pDup->pColl = pExpr->pColl;
59405 ExprSetProperty(pExpr, EP_Static);
59406 sqlite3ExprDelete(db, pExpr);
59407 memcpy(pExpr, pDup, sizeof(*pExpr));
59413 ** that name in the set of source tables in pSrcList and make the pExpr
59415 ** are made to pExpr:
59417 ** pExpr->iDb Set the index in db->aDb[] of the database X
59419 ** pExpr->iTable Set to the cursor number for the table obtained
59421 ** pExpr->pTab Points to the Table structure of X.Y (even if
59423 ** pExpr->iColumn Set to the column number within the table.
59424 ** pExpr->op Set to TK_COLUMN.
59425 ** pExpr->pLeft Any expression this points to is deleted
59426 ** pExpr->pRight Any expression this points to is deleted.
59444 Expr *pExpr /* Make this EXPR node point to the selected column */
59458 assert( ~ExprHasAnyProperty(pExpr, EP_TokenOnly|EP_Reduced) );
59461 pExpr->iTable = -1;
59462 pExpr->pTab = 0;
59463 ExprSetIrreducible(pExpr);
59495 pExpr->iTable = pItem->iCursor;
59496 pExpr->pTab = pTab;
59504 pExpr->iTable = pItem->iCursor;
59505 pExpr->pTab = pTab;
59509 pExpr->iColumn = j==pTab->iPKey ? -1 : (i16)j;
59545 pExpr->iTable = 1;
59548 pExpr->iTable = 0;
59571 pExpr->affinity = SQLITE_AFF_INTEGER;
59572 }else if( pExpr->iTable==0 ){
59581 pExpr->iColumn = (i16)iCol;
59582 pExpr->pTab = pTab;
59594 pExpr->iColumn = -1; /* IMP: R-44911-55124 */
59595 pExpr->affinity = SQLITE_AFF_INTEGER;
59605 ** In cases like this, replace pExpr with a copy of the expression that
59615 assert( pExpr->pLeft==0 && pExpr->pRight==0 );
59616 assert( pExpr->x.pList==0 );
59617 assert( pExpr->x.pSelect==0 );
59618 pOrig = pEList->a[j].pExpr;
59623 resolveAlias(pParse, pEList, j, pExpr, "");
59645 ** pExpr.
59650 if( cnt==0 && zTab==0 && ExprHasProperty(pExpr,EP_DblQuoted) ){
59651 pExpr->op = TK_STRING;
59652 pExpr->pTab = 0;
59679 if( pExpr->iColumn>=0 && pMatch!=0 ){
59680 int n = pExpr->iColumn;
59685 assert( pMatch->iCursor==pExpr->iTable );
59691 sqlite3ExprDelete(db, pExpr->pLeft);
59692 pExpr->pLeft = 0;
59693 sqlite3ExprDelete(db, pExpr->pRight);
59694 pExpr->pRight = 0;
59695 pExpr->op = (isTrigger ? TK_TRIGGER : TK_COLUMN);
59699 sqlite3AuthRead(pParse, pExpr, pSchema, pNC->pSrcList);
59746 static int resolveExprStep(Walker *pWalker, Expr *pExpr){
59755 if( ExprHasAnyProperty(pExpr, EP_Resolved) ) return WRC_Prune;
59756 ExprSetProperty(pExpr, EP_Resolved);
59766 switch( pExpr->op ){
59778 pExpr->op = TK_COLUMN;
59779 pExpr->pTab = pItem->pTab;
59780 pExpr->iTable = pItem->iCursor;
59781 pExpr->iColumn = -1;
59782 pExpr->affinity = SQLITE_AFF_INTEGER;
59790 return lookupName(pParse, 0, 0, pExpr->u.zToken, pNC, pExpr);
59803 pRight = pExpr->pRight;
59806 zTable = pExpr->pLeft->u.zToken;
59810 zDb = pExpr->pLeft->u.zToken;
59814 return lookupName(pParse, zDb, zTable, zColumn, pNC, pExpr);
59821 ExprList *pList = pExpr->x.pList; /* The argument list */
59832 testcase( pExpr->op==TK_CONST_FUNC );
59833 assert( !ExprHasProperty(pExpr, EP_xIsSelect) );
59834 zId = pExpr->u.zToken;
59856 pExpr->op = TK_NULL;
59874 pExpr->op = TK_AGG_FUNCTION;
59880 /* FIX ME: Compute pExpr->affinity based on the expected return
59887 case TK_EXISTS: testcase( pExpr->op==TK_EXISTS );
59890 testcase( pExpr->op==TK_IN );
59891 if( ExprHasProperty(pExpr, EP_xIsSelect) ){
59898 sqlite3WalkSelect(pWalker, pExpr->x.pSelect);
59901 ExprSetProperty(pExpr, EP_VarSelect);
60004 if( sqlite3ExprCompare(pEList->a[i].pExpr, pE) ){
60078 pE = pItem->pExpr;
60099 pItem->pExpr = pE = sqlite3Expr(db, TK_INTEGER, 0);
60158 resolveAlias(pParse, pEList, pItem->iCol-1, pItem->pExpr, zType);
60198 Expr *pE = pItem->pExpr;
60295 Expr *pX = pEList->a[i].pExpr;
60375 if( ExprHasProperty(pItem->pExpr, EP_Agg) ){
60449 Expr *pExpr /* The expression to be analyzed. */
60454 if( pExpr==0 ) return 0;
60458 if( sqlite3ExprCheckHeight(pParse, pExpr->nHeight+pNC->pParse->nHeight) ){
60461 pParse->nHeight += pExpr->nHeight;
60470 sqlite3WalkExpr(&w, pExpr);
60472 pNC->pParse->nHeight -= pExpr->nHeight;
60475 ExprSetProperty(pExpr, EP_Error);
60478 ExprSetProperty(pExpr, EP_Agg);
60482 return ExprHasProperty(pExpr, EP_Error);
60531 ** Return the 'affinity' of the expression pExpr if any.
60533 ** If pExpr is a column, a reference to a column via an 'AS' alias,
60546 SQLITE_PRIVATE char sqlite3ExprAffinity(Expr *pExpr){
60547 int op = pExpr->op;
60549 assert( pExpr->flags&EP_xIsSelect );
60550 return sqlite3ExprAffinity(pExpr->x.pSelect->pEList->a[0].pExpr);
60554 assert( !ExprHasProperty(pExpr, EP_IntValue) );
60555 return sqlite3AffinityType(pExpr->u.zToken);
60559 && pExpr->pTab!=0
60561 /* op==TK_REGISTER && pExpr->pTab!=0 happens when pExpr was originally
60563 int j = pExpr->iColumn;
60565 assert( pExpr->pTab && j<pExpr->pTab->nCol );
60566 return pExpr->pTab->aCol[j].affinity;
60568 return pExpr->affinity;
60572 ** Set the collating sequence for expression pExpr to be the collating
60578 SQLITE_PRIVATE Expr *sqlite3ExprSetColl(Parse *pParse, Expr *pExpr, Token *pCollName){
60583 if( pExpr && zColl ){
60586 pExpr->pColl = pColl;
60587 pExpr->flags |= EP_ExpCollate;
60591 return pExpr;
60595 ** Return the default collation sequence for the expression pExpr. If
60598 SQLITE_PRIVATE CollSeq *sqlite3ExprCollSeq(Parse *pParse, Expr *pExpr){
60600 Expr *p = pExpr;
60609 /* op==TK_REGISTER && p->pTab!=0 happens when pExpr was originally
60617 pExpr->pColl = pColl;
60633 ** pExpr is an operand of a comparison operator. aff2 is the
60637 SQLITE_PRIVATE char sqlite3CompareAffinity(Expr *pExpr, char aff2){
60638 char aff1 = sqlite3ExprAffinity(pExpr);
60661 ** pExpr is a comparison operator. Return the type affinity that should
60664 static char comparisonAffinity(Expr *pExpr){
60666 assert( pExpr->op==TK_EQ || pExpr->op==TK_IN || pExpr->op==TK_LT ||
60667 pExpr->op==TK_GT || pExpr->op==TK_GE || pExpr->op==TK_LE ||
60668 pExpr->op==TK_NE || pExpr->op==TK_IS || pExpr->op==TK_ISNOT );
60669 assert( pExpr->pLeft );
60670 aff = sqlite3ExprAffinity(pExpr->pLeft);
60671 if( pExpr->pRight ){
60672 aff = sqlite3CompareAffinity(pExpr->pRight, aff);
60673 }else if( ExprHasProperty(pExpr, EP_xIsSelect) ){
60674 aff = sqlite3CompareAffinity(pExpr->x.pSelect->pEList->a[0].pExpr, aff);
60682 ** pExpr is a comparison expression, eg. '=', '<', IN(...) etc.
60685 ** the comparison in pExpr.
60687 SQLITE_PRIVATE int sqlite3IndexAffinityOk(Expr *pExpr, char idx_affinity){
60688 char aff = comparisonAffinity(pExpr);
60809 heightOfExpr(p->a[i].pExpr, pnHeight);
61051 SQLITE_PRIVATE void sqlite3ExprAssignVarNumber(Parse *pParse, Expr *pExpr){
61055 if( pExpr==0 ) return;
61056 assert( !ExprHasAnyProperty(pExpr, EP_IntValue|EP_Reduced|EP_TokenOnly) );
61057 z = pExpr->u.zToken;
61063 pExpr->iColumn = (ynVar)(++pParse->nVar);
61068 pExpr->iColumn = (ynVar)i;
61092 pExpr->iColumn = pE->iColumn;
61097 pExpr->iColumn = (ynVar)(++pParse->nVar);
61109 pParse->apVarExpr[pParse->nVarExpr++] = pExpr;
61369 Expr *pOldExpr = pOldItem->pExpr;
61370 pItem->pExpr = sqlite3ExprDup(db, pOldExpr, flags);
61485 Expr *pExpr /* Expression to be appended. Might be NULL */
61509 pItem->pExpr = pExpr;
61515 sqlite3ExprDelete(db, pExpr);
61563 assert( db->mallocFailed || pItem->pExpr==pSpan->pExpr );
61597 sqlite3ExprDelete(db, pItem->pExpr);
61618 static int exprNodeIsConstant(Walker *pWalker, Expr *pExpr){
61623 pExpr, EP_FromJoin) ){
61628 switch( pExpr->op ){
61638 testcase( pExpr->op==TK_ID );
61639 testcase( pExpr->op==TK_COLUMN );
61640 testcase( pExpr->op==TK_AGG_FUNCTION );
61641 testcase( pExpr->op==TK_AGG_COLUMN );
61645 testcase( pExpr->op==TK_SELECT ); /* selectNodeIsConstant will disallow */
61646 testcase( pExpr->op==TK_EXISTS ); /* selectNodeIsConstant will disallow */
61774 ** was computed by pExpr. If we can look at pExpr at compile-time and
61780 const Expr *pExpr, /* Only generate OP_IsNull if this expr can be NULL */
61784 if( sqlite3ExprCanBeNull(pExpr) ){
61877 if( pEList->a[0].pExpr->op!=TK_COLUMN ) return 0; /* Result is a column */
61952 Expr *pExpr = p->pEList->a[0].pExpr; /* Expression <column> */
61953 int iCol = pExpr->iColumn; /* Index of column <column> */
61985 CollSeq *pReq = sqlite3BinaryCompareCollSeq(pParse, pX->pLeft, pExpr);
62049 ** The pExpr parameter describes the expression that contains the IN
62052 ** If parameter isRowid is non-zero, then expression pExpr is guaranteed
62076 Expr *pExpr, /* The IN, SELECT, or EXISTS operator */
62096 if( !ExprHasAnyProperty(pExpr, EP_VarSelect) && !pParse->pTriggerTab ){
62103 switch( pExpr->op ){
62108 Expr *pLeft = pExpr->pLeft;
62129 pExpr->iTable = pParse->nTab++;
62130 addr = sqlite3VdbeAddOp2(v, OP_OpenEphemeral, pExpr->iTable, !isRowid);
62134 if( ExprHasProperty(pExpr, EP_xIsSelect) ){
62144 sqlite3SelectDestInit(&dest, SRT_Set, pExpr->iTable);
62146 assert( (pExpr->iTable&0x0000FFFF)==pExpr->iTable );
62147 if( sqlite3Select(pParse, pExpr->x.pSelect, &dest) ){
62150 pEList = pExpr->x.pSelect->pEList;
62152 keyInfo.aColl[0] = sqlite3BinaryCompareCollSeq(pParse, pExpr->pLeft,
62153 pEList->a[0].pExpr);
62155 }else if( pExpr->x.pList!=0 ){
62164 ExprList *pList = pExpr->x.pList;
62171 keyInfo.aColl[0] = sqlite3ExprCollSeq(pParse, pExpr->pLeft);
62178 Expr *pE2 = pItem->pExpr;
62193 sqlite3VdbeAddOp3(v, OP_InsertInt, pExpr->iTable, r2, iValToIns);
62199 sqlite3VdbeAddOp3(v, OP_Insert, pExpr->iTable, r2, r3);
62203 sqlite3VdbeAddOp2(v, OP_IdxInsert, pExpr->iTable, r2);
62229 testcase( pExpr->op==TK_EXISTS );
62230 testcase( pExpr->op==TK_SELECT );
62231 assert( pExpr->op==TK_EXISTS || pExpr->op==TK_SELECT );
62233 assert( ExprHasProperty(pExpr, EP_xIsSelect) );
62234 pSel = pExpr->x.pSelect;
62236 if( pExpr->op==TK_SELECT ){
62251 ExprSetIrreducible(pExpr);
62285 Expr *pExpr, /* The IN expression */
62296 ** pExpr->iTable will contains the values that make up the RHS.
62301 eType = sqlite3FindInIndex(pParse, pExpr, &rRhsHasNull);
62307 affinity = comparisonAffinity(pExpr);
62313 sqlite3ExprCode(pParse, pExpr->pLeft, r1);
62321 sqlite3VdbeAddOp3(v, OP_NotExists, pExpr->iTable, destIfFalse, r1);
62341 sqlite3VdbeAddOp4Int(v, OP_NotFound, pExpr->iTable, destIfFalse, r1, 1);
62354 j1 = sqlite3VdbeAddOp4Int(v, OP_Found, pExpr->iTable, 0, r1, 1);
62363 j3 = sqlite3VdbeAddOp4Int(v, OP_Found, pExpr->iTable, 0, rRhsHasNull, 1);
62427 static void codeInteger(Vdbe *v, Expr *pExpr, int negFlag, int iMem){
62428 if( pExpr->flags & EP_IntValue ){
62429 int i = pExpr->u.iValue;
62433 const char *z = pExpr->u.zToken;
62726 ** target. The first time this is called, pExpr is evaluated to compute
62741 static int codeAlias(Parse *pParse, int iAlias, Expr *pExpr, int target){
62758 iReg = sqlite3ExprCodeTarget(pParse, pExpr, target);
62761 sqlite3ExprCode(pParse, pExpr, iReg);
62768 return sqlite3ExprCodeTarget(pParse, pExpr, target);
62783 SQLITE_PRIVATE int sqlite3ExprCodeTarget(Parse *pParse, Expr *pExpr, int target){
62798 if( pExpr==0 ){
62801 op = pExpr->op;
62805 AggInfo *pAggInfo = pExpr->pAggInfo;
62806 struct AggInfo_col *pCol = &pAggInfo->aCol[pExpr->iAgg];
62819 if( pExpr->iTable<0 ){
62822 inReg = pExpr->iColumn + pParse->ckBase;
62824 inReg = sqlite3ExprCodeGetColumn(pParse, pExpr->pTab,
62825 pExpr->iColumn, pExpr->iTable, target);
62830 codeInteger(v, pExpr, 0, target);
62834 assert( !ExprHasProperty(pExpr, EP_IntValue) );
62835 codeReal(v, pExpr->u.zToken, 0, target);
62839 assert( !ExprHasProperty(pExpr, EP_IntValue) );
62840 sqlite3VdbeAddOp4(v, OP_String8, 0, target, 0, pExpr->u.zToken, 0);
62852 assert( !ExprHasProperty(pExpr, EP_IntValue) );
62853 assert( pExpr->u.zToken[0]=='x' || pExpr->u.zToken[0]=='X' );
62854 assert( pExpr->u.zToken[1]=='\'' );
62855 z = &pExpr->u.zToken[2];
62865 assert( !ExprHasProperty(pExpr, EP_IntValue) );
62866 assert( pExpr->u.zToken!=0 );
62867 assert( pExpr->u.zToken[0]!=0 );
62868 if( pExpr->u.zToken[1]==0
62870 && pOp->p1+pOp->p3==pExpr->iColumn
62881 sqlite3VdbeAddOp3(v, OP_Variable, pExpr->iColumn, target, 1);
62882 if( pExpr->u.zToken[1]!=0 ){
62883 sqlite3VdbeChangeP4(v, -1, pExpr->u.zToken, 0);
62889 inReg = pExpr->iTable;
62893 inReg = codeAlias(pParse, pExpr->iTable, pExpr->pLeft, target);
62900 inReg = sqlite3ExprCodeTarget(pParse, pExpr->pLeft, target);
62901 assert( !ExprHasProperty(pExpr, EP_IntValue) );
62902 aff = sqlite3AffinityType(pExpr->u.zToken);
62942 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1);
62943 r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, ®Free2);
62944 codeCompare(pParse, pExpr->pLeft, pExpr->pRight, op,
62954 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1);
62955 r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, ®Free2);
62957 codeCompare(pParse, pExpr->pLeft, pExpr->pRight, op,
62997 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1);
62998 r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, ®Free2);
63005 Expr *pLeft = pExpr->pLeft;
63008 assert( !ExprHasProperty(pExpr, EP_IntValue) );
63015 r2 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free2);
63028 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1);
63042 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1);
63050 AggInfo *pInfo = pExpr->pAggInfo;
63052 assert( !ExprHasProperty(pExpr, EP_IntValue) );
63053 sqlite3ErrorMsg(pParse, "misuse of aggregate: %s()", pExpr->u.zToken);
63055 inReg = pInfo->aFunc[pExpr->iAgg].iMem;
63071 assert( !ExprHasProperty(pExpr, EP_xIsSelect) );
63074 if( ExprHasAnyProperty(pExpr, EP_TokenOnly) ){
63077 pFarg = pExpr->x.pList;
63080 assert( !ExprHasProperty(pExpr, EP_IntValue) );
63081 zId = pExpr->u.zToken;
63096 sqlite3ExprCode(pParse, pFarg->a[0].pExpr, target);
63101 sqlite3ExprCode(pParse, pFarg->a[i].pExpr, target);
63130 if( nFarg>=2 && (pExpr->flags & EP_InfixFunc) ){
63131 pDef = sqlite3VtabOverloadFunction(db, pDef, nFarg, pFarg->a[1].pExpr);
63133 pDef = sqlite3VtabOverloadFunction(db, pDef, nFarg, pFarg->a[0].pExpr);
63137 if( i<32 && sqlite3ExprIsConstant(pFarg->a[i].pExpr) ){
63141 pColl = sqlite3ExprCollSeq(pParse, pFarg->a[i].pExpr);
63161 inReg = sqlite3CodeSubselect(pParse, pExpr, 0, 0);
63168 sqlite3ExprCodeIN(pParse, pExpr, destIfFalse, destIfNull);
63185 ** X is stored in pExpr->pLeft.
63186 ** Y is stored in pExpr->pList->a[0].pExpr.
63187 ** Z is stored in pExpr->pList->a[1].pExpr.
63190 Expr *pLeft = pExpr->pLeft;
63191 struct ExprList_item *pLItem = pExpr->x.pList->a;
63192 Expr *pRight = pLItem->pExpr;
63203 pRight = pLItem->pExpr;
63214 inReg = sqlite3ExprCodeTarget(pParse, pExpr->pLeft, target);
63244 Table *pTab = pExpr->pTab;
63245 int p1 = pExpr->iTable * (pTab->nCol+1) + 1 + pExpr->iColumn;
63247 assert( pExpr->iTable==0 || pExpr->iTable==1 );
63248 assert( pExpr->iColumn>=-1 && pExpr->iColumn<pTab->nCol );
63249 assert( pTab->iPKey<0 || pExpr->iColumn!=pTab->iPKey );
63254 (pExpr->iTable ? "new" : "old"),
63255 (pExpr->iColumn<0 ? "rowid" : pExpr->pTab->aCol[pExpr->iColumn].zName),
63261 if( pExpr->iColumn>=0
63262 && pTab->aCol[pExpr->iColumn].affinity==SQLITE_AFF_REAL
63281 ** X (if it exists) is in pExpr->pLeft.
63282 ** Y is in pExpr->pRight. The Y is also optional. If there is no
63285 ** Ei is in pExpr->pList->a[i*2] and Ri is pExpr->pList->a[i*2+1].
63304 assert( !ExprHasProperty(pExpr, EP_xIsSelect) && pExpr->x.pList );
63305 assert((pExpr->x.pList->nExpr % 2) == 0);
63306 assert(pExpr->x.pList->nExpr > 0);
63307 pEList = pExpr->x.pList;
63311 if( (pX = pExpr->pLeft)!=0 ){
63326 opCompare.pRight = aListelem[i].pExpr;
63328 pTest = aListelem[i].pExpr;
63333 testcase( aListelem[i+1].pExpr->op==TK_COLUMN );
63334 testcase( aListelem[i+1].pExpr->op==TK_REGISTER );
63335 sqlite3ExprCode(pParse, aListelem[i+1].pExpr, target);
63340 if( pExpr->pRight ){
63342 sqlite3ExprCode(pParse, pExpr->pRight, target);
63354 assert( pExpr->affinity==OE_Rollback
63355 || pExpr->affinity==OE_Abort
63356 || pExpr->affinity==OE_Fail
63357 || pExpr->affinity==OE_Ignore
63364 if( pExpr->affinity==OE_Abort ){
63367 assert( !ExprHasProperty(pExpr, EP_IntValue) );
63368 if( pExpr->affinity==OE_Ignore ){
63370 v, OP_Halt, SQLITE_OK, OE_Ignore, 0, pExpr->u.zToken,0);
63372 sqlite3HaltConstraint(pParse, pExpr->affinity, pExpr->u.zToken, 0);
63393 SQLITE_PRIVATE int sqlite3ExprCodeTemp(Parse *pParse, Expr *pExpr, int *pReg){
63395 int r2 = sqlite3ExprCodeTarget(pParse, pExpr, r1);
63406 ** Generate code that will evaluate expression pExpr and store the
63410 SQLITE_PRIVATE int sqlite3ExprCode(Parse *pParse, Expr *pExpr, int target){
63414 inReg = sqlite3ExprCodeTarget(pParse, pExpr, target);
63434 SQLITE_PRIVATE int sqlite3ExprCodeAndCache(Parse *pParse, Expr *pExpr, int target){
63437 inReg = sqlite3ExprCode(pParse, pExpr, target);
63445 if( ALWAYS(pExpr->op!=TK_REGISTER) ){
63449 pExpr->iTable = iMem;
63450 pExpr->op2 = pExpr->op;
63451 pExpr->op = TK_REGISTER;
63457 ** Return TRUE if pExpr is an constant expression that is appropriate
63516 ** If pExpr is a constant expression that is appropriate for
63521 static int evalConstExpr(Walker *pWalker, Expr *pExpr){
63523 switch( pExpr->op ){
63535 ExprList *pList = pExpr->x.pList;
63536 assert( !ExprHasProperty(pExpr, EP_xIsSelect) );
63541 if( ALWAYS(pItem->pExpr) ) pItem->pExpr->flags |= EP_FixedDest;
63547 if( isAppropriateForFactoring(pExpr) ){
63550 r2 = sqlite3ExprCodeTarget(pParse, pExpr, r1);
63552 pExpr->op2 = pExpr->op;
63553 pExpr->op = TK_REGISTER;
63554 pExpr->iTable = r2;
63561 ** Preevaluate constant subexpressions within pExpr and store the
63562 ** results in registers. Modify pExpr so that the constant subexpresions
63565 SQLITE_PRIVATE void sqlite3ExprCodeConstants(Parse *pParse, Expr *pExpr){
63570 sqlite3WalkExpr(&w, pExpr);
63593 int iReg = codeAlias(pParse, pItem->iAlias, pItem->pExpr, target+i);
63599 sqlite3ExprCode(pParse, pItem->pExpr, target+i);
63622 Expr *pExpr, /* The BETWEEN expression */
63633 assert( !ExprHasProperty(pExpr, EP_xIsSelect) );
63634 exprX = *pExpr->pLeft;
63640 compLeft.pRight = pExpr->x.pList->a[0].pExpr;
63643 compRight.pRight = pExpr->x.pList->a[1].pExpr;
63678 SQLITE_PRIVATE void sqlite3ExprIfTrue(Parse *pParse, Expr *pExpr, int dest, int jumpIfNull){
63687 if( NEVER(pExpr==0) ) return; /* No way this can happen */
63688 op = pExpr->op;
63694 sqlite3ExprIfFalse(pParse, pExpr->pLeft, d2,jumpIfNull^SQLITE_JUMPIFNULL);
63695 sqlite3ExprIfTrue(pParse, pExpr->pRight, dest, jumpIfNull);
63702 sqlite3ExprIfTrue(pParse, pExpr->pLeft, dest, jumpIfNull);
63703 sqlite3ExprIfTrue(pParse, pExpr->pRight, dest, jumpIfNull);
63708 sqlite3ExprIfFalse(pParse, pExpr->pLeft, dest, jumpIfNull);
63730 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1);
63731 r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, ®Free2);
63732 codeCompare(pParse, pExpr->pLeft, pExpr->pRight, op,
63742 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1);
63743 r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, ®Free2);
63745 codeCompare(pParse, pExpr->pLeft, pExpr->pRight, op,
63757 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1);
63764 exprCodeBetween(pParse, pExpr, dest, 1, jumpIfNull);
63770 sqlite3ExprCodeIN(pParse, pExpr, destIfFalse, destIfNull);
63776 r1 = sqlite3ExprCodeTemp(pParse, pExpr, ®Free1);
63796 SQLITE_PRIVATE void sqlite3ExprIfFalse(Parse *pParse, Expr *pExpr, int dest, int jumpIfNull){
63805 if( pExpr==0 ) return;
63807 /* The value of pExpr->op and op are related as follows:
63809 ** pExpr->op op
63820 ** For other values of pExpr->op, op is undefined and unused.
63825 op = ((pExpr->op+(TK_ISNULL&1))^1)-(TK_ISNULL&1);
63829 assert( pExpr->op!=TK_ISNULL || op==OP_NotNull );
63830 assert( pExpr->op!=TK_NOTNULL || op==OP_IsNull );
63831 assert( pExpr->op!=TK_NE || op==OP_Eq );
63832 assert( pExpr->op!=TK_EQ || op==OP_Ne );
63833 assert( pExpr->op!=TK_LT || op==OP_Ge );
63834 assert( pExpr->op!=TK_LE || op==OP_Gt );
63835 assert( pExpr->op!=TK_GT || op==OP_Le );
63836 assert( pExpr->op!=TK_GE || op==OP_Lt );
63838 switch( pExpr->op ){
63841 sqlite3ExprIfFalse(pParse, pExpr->pLeft, dest, jumpIfNull);
63842 sqlite3ExprIfFalse(pParse, pExpr->pRight, dest, jumpIfNull);
63849 sqlite3ExprIfTrue(pParse, pExpr->pLeft, d2, jumpIfNull^SQLITE_JUMPIFNULL);
63850 sqlite3ExprIfFalse(pParse, pExpr->pRight, dest, jumpIfNull);
63857 sqlite3ExprIfTrue(pParse, pExpr->pLeft, dest, jumpIfNull);
63873 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1);
63874 r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, ®Free2);
63875 codeCompare(pParse, pExpr->pLeft, pExpr->pRight, op,
63883 testcase( pExpr->op==TK_IS );
63884 testcase( pExpr->op==TK_ISNOT );
63885 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1);
63886 r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, ®Free2);
63887 op = (pExpr->op==TK_IS) ? TK_NE : TK_EQ;
63888 codeCompare(pParse, pExpr->pLeft, pExpr->pRight, op,
63898 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1);
63905 exprCodeBetween(pParse, pExpr, dest, 0, jumpIfNull);
63910 sqlite3ExprCodeIN(pParse, pExpr, dest, dest);
63913 sqlite3ExprCodeIN(pParse, pExpr, dest, destIfNull);
63919 r1 = sqlite3ExprCodeTemp(pParse, pExpr, ®Free1);
63962 Expr *pExprA = pA->x.pList->a[i].pExpr;
63963 Expr *pExprB = pB->x.pList->a[i].pExpr;
64026 static int analyzeAggregate(Walker *pWalker, Expr *pExpr){
64033 switch( pExpr->op ){
64036 testcase( pExpr->op==TK_AGG_COLUMN );
64037 testcase( pExpr->op==TK_COLUMN );
64044 assert( !ExprHasAnyProperty(pExpr, EP_TokenOnly|EP_Reduced) );
64045 if( pExpr->iTable==pItem->iCursor ){
64046 /* If we reach this point, it means that pExpr refers to a table
64055 if( pCol->iTable==pExpr->iTable &&
64056 pCol->iColumn==pExpr->iColumn ){
64064 pCol->pTab = pExpr->pTab;
64065 pCol->iTable = pExpr->iTable;
64066 pCol->iColumn = pExpr->iColumn;
64069 pCol->pExpr = pExpr;
64076 Expr *pE = pTerm->pExpr;
64077 if( pE->op==TK_COLUMN && pE->iTable==pExpr->iTable &&
64078 pE->iColumn==pExpr->iColumn ){
64088 /* There is now an entry for pExpr in pAggInfo->aCol[] (either
64090 ** Convert the pExpr to be a TK_AGG_COLUMN referring to that
64093 ExprSetIrreducible(pExpr);
64094 pExpr->pAggInfo = pAggInfo;
64095 pExpr->op = TK_AGG_COLUMN;
64096 pExpr->iAgg = (i16)k;
64098 } /* endif pExpr->iTable==pItem->iCursor */
64107 /* Check to see if pExpr is a duplicate of another aggregate
64112 if( sqlite3ExprCompare(pItem->pExpr, pExpr) ){
64117 /* pExpr is original. Make a new entry in pAggInfo->aFunc[]
64122 assert( !ExprHasProperty(pExpr, EP_xIsSelect) );
64124 pItem->pExpr = pExpr;
64126 assert( !ExprHasProperty(pExpr, EP_IntValue) );
64128 pExpr->u.zToken, sqlite3Strlen30(pExpr->u.zToken),
64129 pExpr->x.pList ? pExpr->x.pList->nExpr : 0, enc, 0);
64130 if( pExpr->flags & EP_Distinct ){
64137 /* Make pExpr point to the appropriate pAggInfo->aFunc[] entry
64139 assert( !ExprHasAnyProperty(pExpr, EP_TokenOnly|EP_Reduced) );
64140 ExprSetIrreducible(pExpr);
64141 pExpr->iAgg = (i16)i;
64142 pExpr->pAggInfo = pAggInfo;
64169 SQLITE_PRIVATE void sqlite3ExprAnalyzeAggregates(NameContext *pNC, Expr *pExpr){
64175 sqlite3WalkExpr(&w, pExpr);
64189 sqlite3ExprAnalyzeAggregates(pNC, pItem->pExpr);
65722 ** This only applies to the root node of pExpr, so the statement:
65728 static int resolveAttachExpr(NameContext *pName, Expr *pExpr)
65731 if( pExpr ){
65732 if( pExpr->op!=TK_ID ){
65733 rc = sqlite3ResolveExprNames(pName, pExpr);
65734 if( rc==SQLITE_OK && !sqlite3ExprIsConstant(pExpr) ){
65735 sqlite3ErrorMsg(pName->pParse, "invalid name: \"%s\"", pExpr->u.zToken);
65739 pExpr->op = TK_STRING;
66179 Expr *pExpr /* The expression to be fixed to one database */
66181 while( pExpr ){
66182 if( ExprHasAnyProperty(pExpr, EP_TokenOnly) ) break;
66183 if( ExprHasProperty(pExpr, EP_xIsSelect) ){
66184 if( sqlite3FixSelect(pFix, pExpr->x.pSelect) ) return 1;
66186 if( sqlite3FixExprList(pFix, pExpr->x.pList) ) return 1;
66188 if( sqlite3FixExpr(pFix, pExpr->pRight) ){
66191 pExpr = pExpr->pLeft;
66203 if( sqlite3FixExpr(pFix, pItem->pExpr) ){
66329 ** If SQLITE_IGNORE is returned and pExpr is not NULL, then pExpr is changed
66330 ** to an SQL NULL expression. Otherwise, if pExpr is NULL, then SQLITE_IGNORE
66358 ** The pExpr should be a TK_COLUMN expression. The table referred to
66368 Expr *pExpr, /* The expression to check authorization on */
66370 SrcList *pTabList /* All table that pExpr might refer to */
66387 assert( pExpr->op==TK_COLUMN || pExpr->op==TK_TRIGGER );
66388 if( pExpr->op==TK_TRIGGER ){
66393 if( pExpr->iTable==pTabList->a[iSrc].iCursor ){
66399 iCol = pExpr->iColumn;
66413 pExpr->op = TK_NULL;
67569 if( !sqlite3ExprIsConstantOrFunction(pSpan->pExpr) ){
67573 /* A copy of pExpr is used instead of the original, as pExpr contains
67578 pCol->pDflt = sqlite3ExprDup(db, pSpan->pExpr, EXPRDUP_REDUCE);
67584 sqlite3ExprDelete(db, pSpan->pExpr);
69029 Expr *pExpr = pList->a[i].pExpr;
69030 if( pExpr ){
69031 CollSeq *pColl = pExpr->pColl;
69103 /* Justification of the ALWAYS(pListItem->pExpr->pColl): Because of
69105 ** if pListItem->pExpr is not null then either pListItem->pExpr->pColl
69108 if( pListItem->pExpr && ALWAYS(pListItem->pExpr->pColl) ){
69110 zColl = pListItem->pExpr->pColl->zName;
72675 ** pExpr points to an expression which implements a function. If
72681 SQLITE_PRIVATE int sqlite3IsLikeFunction(sqlite3 *db, Expr *pExpr, int *pIsNocase, char *aWc){
72683 if( pExpr->op!=TK_FUNCTION
72684 || !pExpr->x.pList
72685 || pExpr->x.pList->nExpr!=2
72689 assert( !ExprHasProperty(pExpr, EP_xIsSelect) );
72690 pDef = sqlite3FindFunction(db, pExpr->u.zToken,
72691 sqlite3Strlen30(pExpr->u.zToken),
74670 if( sqlite3ResolveExprNames(&sNC, pList->a[i].pExpr) ){
74822 sqlite3ExprCode(pParse, pList->a[keyColumn].pExpr, regCols);
74851 sqlite3ExprCodeAndCache(pParse, pList->a[j].pExpr, regCols+i+1);
74889 sqlite3ExprCode(pParse, pList->a[keyColumn].pExpr, regRowid);
74956 sqlite3ExprCode(pParse, pList->a[j].pExpr, iRegStore);
75660 assert( pEList->a[0].pExpr );
75661 if( pEList->a[0].pExpr->op!=TK_ALL ){
79889 p->affinity = sqlite3CompareAffinity(pEList->a[0].pExpr, pDest->affinity);
80005 pColl = sqlite3ExprCollSeq(pParse, pItem->pExpr);
80120 ** expression pExpr. The string may be treated as static by the caller.
80138 Expr *pExpr,
80148 if( NEVER(pExpr==0) || pNC->pSrcList==0 ) return 0;
80150 switch( pExpr->op ){
80159 int iCol = pExpr->iColumn; /* Index of column in pTab */
80160 testcase( pExpr->op==TK_AGG_COLUMN );
80161 testcase( pExpr->op==TK_COLUMN );
80164 for(j=0;j<pTabList->nSrc && pTabList->a[j].iCursor!=pExpr->iTable;j++);
80194 assert( pTab && pExpr->pTab==pTab );
80206 Expr *p = pS->pEList->a[iCol].pExpr;
80239 Select *pS = pExpr->x.pSelect;
80240 Expr *p = pS->pEList->a[0].pExpr;
80241 assert( ExprHasProperty(pExpr, EP_xIsSelect) );
80276 Expr *p = pEList->a[i].pExpr;
80328 p = pEList->a[i].pExpr;
80417 p = pEList->a[i].pExpr;
80509 p = a[i].pExpr;
80659 pRet = sqlite3ExprCollSeq(pParse, p->pEList->a[iCol].pExpr);
81114 sqlite3CompareAffinity(p->pEList->a[0].pExpr, pDest->affinity);
81377 Expr *pTerm = pOrderBy->a[i].pExpr;
81622 ** Scan through the expression pExpr. Replace every reference to
81631 ** changes to pExpr so that it refers directly to the source table
81636 Expr *pExpr, /* Expr in which substitution occurs */
81640 if( pExpr==0 ) return 0;
81641 if( pExpr->op==TK_COLUMN && pExpr->iTable==iTable ){
81642 if( pExpr->iColumn<0 ){
81643 pExpr->op = TK_NULL;
81646 assert( pEList!=0 && pExpr->iColumn<pEList->nExpr );
81647 assert( pExpr->pLeft==0 && pExpr->pRight==0 );
81648 pNew = sqlite3ExprDup(db, pEList->a[pExpr->iColumn].pExpr, 0);
81649 if( pNew && pExpr->pColl ){
81650 pNew->pColl = pExpr->pColl;
81652 sqlite3ExprDelete(db, pExpr);
81653 pExpr = pNew;
81656 pExpr->pLeft = substExpr(db, pExpr->pLeft, iTable, pEList);
81657 pExpr->pRight = substExpr(db, pExpr->pRight, iTable, pEList);
81658 if( ExprHasProperty(pExpr, EP_xIsSelect) ){
81659 substSelect(db, pExpr->x.pSelect, iTable, pEList);
81661 substExprList(db, pExpr->x.pList, iTable, pEList);
81664 return pExpr;
81675 pList->a[i].pExpr = substExpr(db, pList->a[i].pExpr, iTable, pEList);
82192 Expr *pExpr;
82196 pExpr = pEList->a[0].pExpr;
82197 if( pExpr->op!=TK_AGG_FUNCTION ) return 0;
82198 if( NEVER(ExprHasProperty(pExpr, EP_xIsSelect)) ) return 0;
82199 pEList = pExpr->x.pList;
82201 if( pEList->a[0].pExpr->op!=TK_AGG_COLUMN ) return WHERE_ORDERBY_NORMAL;
82202 assert( !ExprHasProperty(pExpr, EP_IntValue) );
82203 if( sqlite3StrICmp(pExpr->u.zToken,"min")==0 ){
82205 }else if( sqlite3StrICmp(pExpr->u.zToken,"max")==0 ){
82224 Expr *pExpr;
82234 pExpr = p->pEList->a[0].pExpr;
82235 assert( pTab && !pTab->pSelect && pExpr );
82238 if( pExpr->op!=TK_AGG_FUNCTION ) return 0;
82240 if( pExpr->flags&EP_Distinct ) return 0;
82387 Expr *pE = pEList->a[k].pExpr;
82406 Expr *pE = a[k].pExpr;
82411 pNew = sqlite3ExprListAppend(pParse, pNew, a[k].pExpr);
82418 a[k].pExpr = 0;
82443 Expr *pExpr, *pRight;
82478 pExpr = sqlite3PExpr(pParse, TK_DOT, pLeft, pRight, 0);
82484 pExpr = pRight;
82486 pNew = sqlite3ExprListAppend(pParse, pNew, pExpr);
82655 Expr *pE = pFunc->pExpr;
82679 ExprList *pList = pF->pExpr->x.pList;
82680 assert( !ExprHasProperty(pF->pExpr, EP_xIsSelect) );
82702 ExprList *pList = pF->pExpr->x.pList;
82703 assert( !ExprHasProperty(pF->pExpr, EP_xIsSelect) );
82723 pColl = sqlite3ExprCollSeq(pParse, pItem->pExpr);
82741 sqlite3ExprCode(pParse, pC->pExpr, pC->iMem);
83065 assert( !ExprHasProperty(sAggInfo.aFunc[i].pExpr, EP_xIsSelect) );
83066 sqlite3ExprAnalyzeAggList(&sNC, sAggInfo.aFunc[i].pExpr->x.pList);
83191 sqlite3ExprCode(pParse, pGroupBy->a[j].pExpr, iBMem+j);
83360 assert( !ExprHasProperty(p->pEList->a[0].pExpr, EP_xIsSelect) );
83361 pMinMax = sqlite3ExprListDup(db, p->pEList->a[0].pExpr->x.pList,0);
83365 pMinMax->a[0].pExpr->op = TK_COLUMN;
83465 sqlite3PrintExpr(pList->a[i].pExpr);
85012 if( sqlite3ResolveExprNames(&sNC, pChanges->a[i].pExpr) ){
85019 pRowidExpr = pChanges->a[i].pExpr;
85028 pRowidExpr = pChanges->a[i].pExpr;
85248 sqlite3ExprCode(pParse, pChanges->a[j].pExpr, regNew+i);
85423 Expr *pExpr; /* Temporary expression */
85443 pExpr = sqlite3ExprDup(db, pChanges->a[aXRef[i]].pExpr, 0);
85445 pExpr = sqlite3Expr(db, TK_ID, pTab->aCol[i].zName);
85447 pEList = sqlite3ExprListAppend(pParse, pEList, pExpr);
86656 ** second parameter (pExpr) is the first argument to this function.
86657 ** If pExpr is a column in a virtual table, then let the virtual
86671 Expr *pExpr /* First argument to the function */
86685 if( NEVER(pExpr==0) ) return pDef;
86686 if( pExpr->op!=TK_COLUMN ) return pDef;
86687 pTab = pExpr->pTab;
86826 ** categories, then eOperator==0. The WhereTerm.pExpr field is still set
86848 Expr *pExpr; /* Pointer to the subexpression that is this term */
86860 Bitmask prereqRight; /* Bitmask of tables used by pExpr->pRight */
86861 Bitmask prereqAll; /* Bitmask of tables referenced by pExpr */
86867 #define TERM_DYNAMIC 0x01 /* Need to call sqlite3ExprDelete(db, pExpr) */
87047 sqlite3ExprDelete(db, a->pExpr);
87100 pTerm->pExpr = p;
87117 ** The original WHERE clause in pExpr is unaltered. All this routine
87118 ** does is make slot[] entries point to substructure within pExpr.
87124 static void whereSplit(WhereClause *pWC, Expr *pExpr, int op){
87126 if( pExpr==0 ) return;
87127 if( pExpr->op!=op ){
87128 whereClauseInsert(pWC, pExpr, 0);
87130 whereSplit(pWC, pExpr->pLeft, op);
87131 whereSplit(pWC, pExpr->pRight, op);
87205 mask |= exprTableUsage(pMaskSet, pList->a[i].pExpr);
87253 static void exprCommute(Parse *pParse, Expr *pExpr){
87254 u16 expRight = (pExpr->pRight->flags & EP_ExpCollate);
87255 u16 expLeft = (pExpr->pLeft->flags & EP_ExpCollate);
87256 assert( allowedOp(pExpr->op) && pExpr->op!=TK_IN );
87257 pExpr->pRight->pColl = sqlite3ExprCollSeq(pParse, pExpr->pRight);
87258 pExpr->pLeft->pColl = sqlite3ExprCollSeq(pParse, pExpr->pLeft);
87259 SWAP(CollSeq*,pExpr->pRight->pColl,pExpr->pLeft->pColl);
87260 pExpr->pRight->flags = (pExpr->pRight->flags & ~EP_ExpCollate) | expLeft;
87261 pExpr->pLeft->flags = (pExpr->pLeft->flags & ~EP_ExpCollate) | expRight;
87262 SWAP(Expr*,pExpr->pRight,pExpr->pLeft);
87263 if( pExpr->op>=TK_GT ){
87268 assert( pExpr->op>=TK_GT && pExpr->op<=TK_GE );
87269 pExpr->op = ((pExpr->op-TK_GT)^2)+TK_GT;
87322 Expr *pX = pTerm->pExpr;
87379 Expr *pExpr, /* Test this expression */
87395 if( !sqlite3IsLikeFunction(db, pExpr, pnoCase, wc) ){
87401 pList = pExpr->x.pList;
87402 pLeft = pList->a[1].pExpr;
87423 pRight = pList->a[0].pExpr;
87486 Expr *pExpr /* Test this expression */
87490 if( pExpr->op!=TK_FUNCTION ){
87493 if( sqlite3StrICmp(pExpr->u.zToken,"match")!=0 ){
87496 pList = pExpr->x.pList;
87500 if( pList->a[1].pExpr->op != TK_COLUMN ){
87601 Expr *pExpr = pTerm->pExpr; /* The expression of the term */
87616 assert( pExpr->op==TK_OR );
87622 whereSplit(pOrWc, pExpr, TK_OR);
87649 whereSplit(pAndWC, pOrTerm->pExpr, TK_AND);
87654 assert( pAndTerm->pExpr );
87655 if( allowedOp(pAndTerm->pExpr->op) ){
87771 affRight = sqlite3ExprAffinity(pOrTerm->pExpr->pRight);
87772 affLeft = sqlite3ExprAffinity(pOrTerm->pExpr->pLeft);
87797 pDup = sqlite3ExprDup(db, pOrTerm->pExpr->pRight, 0);
87799 pLeft = pOrTerm->pExpr->pLeft;
87806 transferJoinMarkings(pNew, pExpr);
87827 ** "pExpr" field filled in. The job of this routine is to analyze the
87838 ** and the new term is marked with TERM_DYNAMIC (because it's pExpr
87850 Expr *pExpr; /* The expression to be analyzed */
87851 Bitmask prereqLeft; /* Prerequesites of the pExpr->pLeft */
87852 Bitmask prereqAll; /* Prerequesites of pExpr */
87857 int op; /* Top-level operator. pExpr->op */
87866 pExpr = pTerm->pExpr;
87867 prereqLeft = exprTableUsage(pMaskSet, pExpr->pLeft);
87868 op = pExpr->op;
87870 assert( pExpr->pRight==0 );
87871 if( ExprHasProperty(pExpr, EP_xIsSelect) ){
87872 pTerm->prereqRight = exprSelectTableUsage(pMaskSet, pExpr->x.pSelect);
87874 pTerm->prereqRight = exprListTableUsage(pMaskSet, pExpr->x.pList);
87879 pTerm->prereqRight = exprTableUsage(pMaskSet, pExpr->pRight);
87881 prereqAll = exprTableUsage(pMaskSet, pExpr);
87882 if( ExprHasProperty(pExpr, EP_FromJoin) ){
87883 Bitmask x = getMask(pMaskSet, pExpr->iRightJoinTable);
87893 Expr *pLeft = pExpr->pLeft;
87894 Expr *pRight = pExpr->pRight;
87905 pDup = sqlite3ExprDup(db, pExpr, 0);
87918 pDup = pExpr;
87947 else if( pExpr->op==TK_BETWEEN && pWC->op==TK_AND ){
87948 ExprList *pList = pExpr->x.pList;
87957 sqlite3ExprDup(db, pExpr->pLeft, 0),
87958 sqlite3ExprDup(db, pList->a[i].pExpr, 0), 0);
87973 else if( pExpr->op==TK_OR ){
87992 && isLikeOrGlob(pParse, pExpr, &pStr1, &isComplete, &noCase)
88001 pLeft = pExpr->x.pList->a[1].pExpr;
88044 if( isMatchOfColumn(pExpr) ){
88050 pRight = pExpr->x.pList->a[0].pExpr;
88051 pLeft = pExpr->x.pList->a[1].pExpr;
88092 if( (exprTableUsage(pMaskSet, pList->a[iFirst++].pExpr)&allowed)!=0 ){
88152 Expr *pExpr; /* The expression of the ORDER BY pTerm */
88153 CollSeq *pColl; /* The collating sequence of pExpr */
88159 pExpr = pTerm->pExpr;
88160 if( pExpr->op!=TK_COLUMN || pExpr->iTable!=base ){
88165 pColl = sqlite3ExprCollSeq(pParse, pExpr);
88181 if( pExpr->iColumn!=iColumn || sqlite3StrICmp(pColl->zName, zColl) ){
88432 Expr *pExpr = pOrderBy->a[i].pExpr;
88433 if( pExpr->op!=TK_COLUMN || pExpr->iTable!=pSrc->iCursor ) break;
88488 Expr *pExpr = pOrderBy->a[i].pExpr;
88489 pIdxOrderBy[i].iColumn = pExpr->iColumn;
88782 ** If expression pExpr represents a literal value, set *pp to point to
88788 ** If the current parse is a recompile (sqlite3Reprepare()) and pExpr
88800 Expr *pExpr,
88806 assert( pExpr->op!=TK_VARIABLE );
88807 if( pExpr->op==TK_REGISTER && pExpr->op2==TK_VARIABLE ){
88808 int iVar = pExpr->iColumn;
88813 return sqlite3ValueFromExpr(pParse->db, pExpr, SQLITE_UTF8, aff, pp);
88879 Expr *pExpr = pLower->pExpr->pRight;
88880 rc = valueFromExpr(pParse, pExpr, aff, &pLowerVal);
88883 Expr *pExpr = pUpper->pExpr->pRight;
88884 rc = valueFromExpr(pParse, pExpr, aff, &pUpperVal);
89113 Expr *pExpr = pTerm->pExpr;
89115 if( ExprHasProperty(pExpr, EP_xIsSelect) ){
89118 }else if( pExpr->x.pList ){
89119 nInMul *= pExpr->x.pList->nExpr + 1;
89333 && (pLevel->iLeftJoin==0 || ExprHasProperty(pTerm->pExpr, EP_FromJoin))
89402 Expr *pX = pTerm->pExpr;
89543 Expr *pRight = pTerm->pExpr->pRight;
89637 sqlite3ExprCode(pParse, pWC->a[iTerm].pExpr->pRight, iReg+j+1);
89671 assert( pTerm->pExpr!=0 );
89714 pX = pStart->pExpr;
89728 pX = pEnd->pExpr;
89832 /* assert( pOrderBy->a[0].pExpr->iColumn==pIdx->aiColumn[nEq] ); */
89877 Expr *pRight = pRangeStart->pExpr->pRight;
89914 Expr *pRight = pRangeEnd->pExpr->pRight;
90084 pSubWInfo = sqlite3WhereBegin(pParse, pOrTab, pOrTerm->pExpr, 0,
90149 pE = pTerm->pExpr;
90175 assert( pTerm->pExpr );
90176 sqlite3ExprIfFalse(pParse, pTerm->pExpr, addrCont, SQLITE_JUMPIFNULL);
90941 pOut->pExpr = sqlite3PExpr(pParse, op, 0, 0, pValue);
90956 pOut->pExpr = sqlite3PExpr(pParse, op, pLeft->pExpr, pRight->pExpr, 0);
90970 pOut->pExpr = sqlite3PExpr(pParse, op, pOperand->pExpr, 0, 0);
90995 pOut->pExpr = sqlite3PExpr(pParse, op, pOperand->pExpr, 0, 0);
92261 sqlite3ExprDelete(pParse->db, (yypminor->yy346).pExpr);
93102 v.pExpr = sqlite3PExpr(pParse, TK_UMINUS, yymsp[0].minor.yy346.pExpr, 0, 0);
93125 {sqlite3AddCheckConstraint(pParse,yymsp[-1].minor.yy346.pExpr);}
93186 {sqlite3AddCheckConstraint(pParse,yymsp[-2].minor.yy346.pExpr);}
93266 yygotominor.yy14 = sqlite3ExprListAppend(pParse, yymsp[-2].minor.yy14, yymsp[-1].minor.yy346.pExpr);
93354 {yygotominor.yy132 = yymsp[0].minor.yy346.pExpr;}
93402 {yygotominor.yy476.pLimit = yymsp[0].minor.yy346.pExpr; yygotominor.yy476.pOffset = 0;}
93405 {yygotominor.yy476.pLimit = yymsp[-2].minor.yy346.pExpr; yygotominor.yy476.pOffset = yymsp[0].minor.yy346.pExpr;}
93408 {yygotominor.yy476.pOffset = yymsp[-2].minor.yy346.pExpr; yygotominor.yy476.pLimit = yymsp[0].minor.yy346.pExpr;}
93425 yygotominor.yy14 = sqlite3ExprListAppend(pParse, yymsp[-4].minor.yy14, yymsp[0].minor.yy346.pExpr);
93431 yygotominor.yy14 = sqlite3ExprListAppend(pParse, 0, yymsp[0].minor.yy346.pExpr);
93452 {yygotominor.yy14 = sqlite3ExprListAppend(pParse,yymsp[-2].minor.yy14,yymsp[0].minor.yy346.pExpr);}
93456 {yygotominor.yy14 = sqlite3ExprListAppend(pParse,0,yymsp[0].minor.yy346.pExpr);}
93469 {yygotominor.yy346.pExpr = yymsp[-1].minor.yy346.pExpr; spanSet(&yygotominor.yy346,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy0);}
93484 yygotominor.yy346.pExpr = sqlite3PExpr(pParse, TK_DOT, temp1, temp2, 0);
93494 yygotominor.yy346.pExpr = sqlite3PExpr(pParse, TK_DOT, temp1, temp4, 0);
93505 yygotominor.yy346.pExpr = 0;
93507 yygotominor.yy346.pExpr = sqlite3PExpr(pParse, TK_REGISTER, 0, 0, &yymsp[0].minor.yy0);
93508 if( yygotominor.yy346.pExpr ) sqlite3GetInt32(&yymsp[0].minor.yy0.z[1], &yygotominor.yy346.pExpr->iTable);
93516 sqlite3ExprAssignVarNumber(pParse, yygotominor.yy346.pExpr);
93522 yygotominor.yy346.pExpr = sqlite3ExprSetColl(pParse, yymsp[-2].minor.yy346.pExpr, &yymsp[0].minor.yy0);
93529 yygotominor.yy346.pExpr = sqlite3PExpr(pParse, TK_CAST, yymsp[-3].minor.yy346.pExpr, 0, &yymsp[-1].minor.yy0);
93538 yygotominor.yy346.pExpr = sqlite3ExprFunction(pParse, yymsp[-1].minor.yy14, &yymsp[-4].minor.yy0);
93540 if( yymsp[-2].minor.yy328 && yygotominor.yy346.pExpr ){
93541 yygotominor.yy346.pExpr->flags |= EP_Distinct;
93547 yygotominor.yy346.pExpr = sqlite3ExprFunction(pParse, 0, &yymsp[-3].minor.yy0);
93555 yygotominor.yy346.pExpr = sqlite3ExprFunction(pParse, 0,&yymsp[0].minor.yy0);
93556 if( yygotominor.yy346.pExpr ){
93557 yygotominor.yy346.pExpr->op = TK_CONST_FUNC;
93586 pList = sqlite3ExprListAppend(pParse,0, yymsp[-1].minor.yy346.pExpr);
93587 pExpr);
93588 if( yymsp[0].minor.yy346.pExpr ){
93589 pList = sqlite3ExprListAppend(pParse,pList, yymsp[0].minor.yy346.pExpr);
93591 yygotominor.yy346.pExpr = sqlite3ExprFunction(pParse, pList, &yymsp[-2].minor.yy96.eOperator);
93592 if( yymsp[-2].minor.yy96.not ) yygotominor.yy346.pExpr = sqlite3PExpr(pParse, TK_NOT, yygotominor.yy346.pExpr, 0, 0);
93595 if( yygotominor.yy346.pExpr ) yygotominor.yy346.pExpr->flags |= EP_InfixFunc;
93607 binaryToUnaryIfNull(pParse, yymsp[0].minor.yy346.pExpr, yygotominor.yy346.pExpr, TK_ISNULL);
93613 binaryToUnaryIfNull(pParse, yymsp[0].minor.yy346.pExpr, yygotominor.yy346.pExpr, TK_NOTNULL);
93628 ExprList *pList = sqlite3ExprListAppend(pParse,0, yymsp[-2].minor.yy346.pExpr);
93629 pList = sqlite3ExprListAppend(pParse,pList, yymsp[0].minor.yy346.pExpr);
93630 yygotominor.yy346.pExpr = sqlite3PExpr(pParse, TK_BETWEEN, yymsp[-4].minor.yy346.pExpr, 0, 0);
93631 if( yygotominor.yy346.pExpr ){
93632 yygotominor.yy346.pExpr->x.pList = pList;
93636 if( yymsp[-3].minor.yy328 ) yygotominor.yy346.pExpr = sqlite3PExpr(pParse, TK_NOT, yygotominor.yy346.pExpr, 0, 0);
93643 yygotominor.yy346.pExpr = sqlite3PExpr(pParse, TK_IN, yymsp[-4].minor.yy346.pExpr, 0, 0);
93644 if( yygotominor.yy346.pExpr ){
93645 yygotominor.yy346.pExpr->x.pList = yymsp[-1].minor.yy14;
93646 sqlite3ExprSetHeight(pParse, yygotominor.yy346.pExpr);
93650 if( yymsp[-3].minor.yy328 ) yygotominor.yy346.pExpr = sqlite3PExpr(pParse, TK_NOT, yygotominor.yy346.pExpr, 0, 0);
93657 yygotominor.yy346.pExpr = sqlite3PExpr(pParse, TK_SELECT, 0, 0, 0);
93658 if( yygotominor.yy346.pExpr ){
93659 yygotominor.yy346.pExpr->x.pSelect = yymsp[-1].minor.yy3;
93660 ExprSetProperty(yygotominor.yy346.pExpr, EP_xIsSelect);
93661 sqlite3ExprSetHeight(pParse, yygotominor.yy346.pExpr);
93671 yygotominor.yy346.pExpr = sqlite3PExpr(pParse, TK_IN, yymsp[-4].minor.yy346.pExpr, 0, 0);
93672 if( yygotominor.yy346.pExpr ){
93673 yygotominor.yy346.pExpr->x.pSelect = yymsp[-1].minor.yy3;
93674 ExprSetProperty(yygotominor.yy346.pExpr, EP_xIsSelect);
93675 sqlite3ExprSetHeight(pParse, yygotominor.yy346.pExpr);
93679 if( yymsp[-3].minor.yy328 ) yygotominor.yy346.pExpr = sqlite3PExpr(pParse, TK_NOT, yygotominor.yy346.pExpr, 0, 0);
93687 yygotominor.yy346.pExpr = sqlite3PExpr(pParse, TK_IN, yymsp[-3].minor.yy346.pExpr, 0, 0);
93688 if( yygotominor.yy346.pExpr ){
93689 yygotominor.yy346.pExpr->x.pSelect = sqlite3SelectNew(pParse, 0,pSrc,0,0,0,0,0,0,0);
93690 ExprSetProperty(yygotominor.yy346.pExpr, EP_xIsSelect);
93691 sqlite3ExprSetHeight(pParse, yygotominor.yy346.pExpr);
93695 if( yymsp[-2].minor.yy328 ) yygotominor.yy346.pExpr = sqlite3PExpr(pParse, TK_NOT, yygotominor.yy346.pExpr, 0, 0);
93702 Expr *p = yygotominor.yy346.pExpr = sqlite3PExpr(pParse, TK_EXISTS, 0, 0, 0);
93716 yygotominor.yy346.pExpr = sqlite3PExpr(pParse, TK_CASE, yymsp[-3].minor.yy132, yymsp[-1].minor.yy132, 0);
93717 if( yygotominor.yy346.pExpr ){
93718 yygotominor.yy346.pExpr->x.pList = yymsp[-2].minor.yy14;
93719 sqlite3ExprSetHeight(pParse, yygotominor.yy346.pExpr);
93729 yygotominor.yy14 = sqlite3ExprListAppend(pParse,yymsp[-4].minor.yy14, yymsp[-2].minor.yy346.pExpr);
93730 yygotominor.yy14 = sqlite3ExprListAppend(pParse,yygotominor.yy14, yymsp[0].minor.yy346.pExpr);
93735 yygotominor.yy14 = sqlite3ExprListAppend(pParse,0, yymsp[-2].minor.yy346.pExpr);
93736 yygotominor.yy14 = sqlite3ExprListAppend(pParse,yygotominor.yy14, yymsp[0].minor.yy346.pExpr);
93841 { yygotominor.yy132 = yymsp[0].minor.yy346.pExpr; }
93897 yygotominor.yy346.pExpr = sqlite3PExpr(pParse, TK_RAISE, 0, 0, 0);
93898 if( yygotominor.yy346.pExpr ){
93899 yygotominor.yy346.pExpr->affinity = OE_Ignore;
93907 yygotominor.yy346.pExpr = sqlite3PExpr(pParse, TK_RAISE, 0, 0, &yymsp[-1].minor.yy0);
93908 if( yygotominor.yy346.pExpr ) {
93909 yygotominor.yy346.pExpr->affinity = (char)yymsp[-3].minor.yy328;
93928 sqlite3Attach(pParse, yymsp[-3].minor.yy346.pExpr, yymsp[-1].minor.yy346.pExpr, yymsp[0].minor.yy132);
93933 sqlite3Detach(pParse, yymsp[0].minor.yy346.pExpr);
98858 Fts3Expr *pExpr; /* Parsed MATCH query string */
99534 sqlite3Fts3ExprFree(pCsr->pExpr);
100449 ** Evaluate the full-text expression pExpr against fts3 table pTab. Store
100454 Fts3Expr *pExpr, /* Parsed fts3 expression */
100465 if( pExpr ){
100466 assert( pExpr->eType==FTSQUERY_PHRASE
100467 || pExpr->eType==FTSQUERY_NEAR
100470 if( pExpr->eType==FTSQUERY_PHRASE ){
100471 rc = fts3PhraseSelect(p, pExpr->pPhrase,
100472 isReqPos || (pExpr->pParent && pExpr->pParent->eType==FTSQUERY_NEAR),
100481 if( 0==(rc = evalFts3Expr(p, pExpr->pRight, &aRight, &nRight, isReqPos))
100482 && 0==(rc = evalFts3Expr(p, pExpr->pLeft, &aLeft, &nLeft, isReqPos))
100484 assert( pExpr->eType==FTSQUERY_NEAR || pExpr->eType==FTSQUERY_OR
100485 || pExpr->eType==FTSQUERY_AND || pExpr->eType==FTSQUERY_NOT
100487 switch( pExpr->eType ){
100496 if( pExpr->pParent && pExpr->pParent->eType==FTSQUERY_NEAR ){
100499 pLeft = pExpr->pLeft;
100503 pRight = pExpr->pRight;
100507 nParam1 = pExpr->nNear+1;
100539 fts3DoclistMerge(pExpr->eType, 0, 0, aLeft, pnOut,
100601 sqlite3Fts3ExprFree(pCsr->pExpr);
100630 iCol, zQuery, -1, &pCsr->pExpr
100634 rc = evalFts3Expr(p, pCsr->pExpr, &pCsr->aDoclist, &pCsr->nDoclist, 0);
100757 ** Load the doclist associated with expression pExpr to pExpr->aDoclist.
100762 SQLITE_PRIVATE int sqlite3Fts3ExprLoadDoclist(Fts3Table *pTab, Fts3Expr *pExpr){
100763 return evalFts3Expr(pTab, pExpr, &pExpr->aDoclist, &pExpr->nDoclist, 1);
100769 ** stored in pExpr->aDoclist.
100772 Fts3Expr *pExpr, /* Access this expressions doclist */
100776 assert( pExpr->isLoaded );
100777 if( pExpr->aDoclist ){
100778 char *pEnd = &pExpr->aDoclist[pExpr->nDoclist];
100779 char *pCsr = pExpr->pCurrent;
100783 if( pExpr->iCurrent<iDocid ){
100785 fts3GetDeltaVarint(&pCsr, &pExpr->iCurrent);
100786 pExpr->pCurrent = pCsr;
100788 if( pExpr->iCurrent==iDocid ){
101984 ** writes a text representation of the query expression pExpr into the
101988 static void exprToString(Fts3Expr *pExpr, char *zBuf){
101989 switch( pExpr->eType ){
101991 Fts3Phrase *pPhrase = pExpr->pPhrase;
102002 zBuf += sprintf(zBuf, "NEAR/%d ", pExpr->nNear);
102016 exprToString(pExpr->pLeft, zBuf);
102021 exprToString(pExpr->pRight, zBuf);
102053 Fts3Expr *pExpr;
102094 pTokenizer, azCol, nCol, nCol, zExpr, nExpr, &pExpr
102101 exprToString(pExpr, zBuf);
102103 sqlite3Fts3ExprFree(pExpr);
106416 ** Return TRUE if the expression node pExpr is located beneath the
106471 Fts3Expr *pIter = pCur->pExpr;
106529 ** pExpr. This function increments *piLeft by the total number of tokens
106530 ** in the expression tree headed by pExpr.
106535 Fts3Expr *pExpr, /* The search expression */
106537 int *piLeft /* Index of left-most token in pExpr */
106539 if( pExpr ){
106540 if( trimSnippetOffsets(pExpr->pLeft, pSnippet, piLeft) ){
106544 switch( pExpr->eType ){
106546 *piLeft += pExpr->pPhrase->nToken;
106561 Fts3Expr *pLeft = pExpr->pLeft;
106562 Fts3Expr *pRight = pExpr->pRight;
106564 int nNear = pExpr->nNear;
106630 if( trimSnippetOffsets(pExpr->pRight, pSnippet, piLeft) ){
106652 if( pCsr->pExpr==0 ){
106686 while( trimSnippetOffsets(pCsr->pExpr, pSnippet, &iTerm) ){
106957 Fts3Expr *pExpr, /* Expression to iterate phrases of */
106962 int eType = pExpr->eType;
106966 assert( pExpr->pLeft && pExpr->pRight );
106967 rc = fts3ExprIterate(pExpr->pLeft, x, pCtx);
106969 rc = fts3ExprIterate(pExpr->pRight, x, pCtx);
106972 rc = x(pExpr, pCtx);
106983 static int fts3ExprLoadDoclistsCb(Fts3Expr *pExpr, void *ctx){
106987 if( pExpr->isLoaded==0 ){
106988 rc = sqlite3Fts3ExprLoadDoclist(p->pTab, pExpr);
106989 pExpr->isLoaded = 1;
106990 if( rc==SQLITE_OK && pExpr->aDoclist ){
106991 pExpr->pCurrent = pExpr->aDoclist;
106992 pExpr->pCurrent += sqlite3Fts3GetVarint(pExpr->pCurrent,&pExpr->iCurrent);
107002 rc = fts3ExprIterate(pCsr->pExpr, fts3ExprLoadDoclistsCb, (void *)&sCtx);
107066 static int fts3SnippetFindPositions(Fts3Expr *pExpr, void *ctx){
107071 p->anToken[iPhrase] = pExpr->pPhrase->nToken;
107072 pCsr = sqlite3Fts3FindPositions(pExpr, p->pCsr->iPrevId, p->iCol);
107178 (void)fts3ExprIterate(pCsr->pExpr, fts3SnippetFindPositions, (void *)&sCtx);
107409 Fts3Expr *pExpr, /* Phrase expression node */
107417 assert( pExpr->isLoaded );
107420 pCsr = pExpr->aDoclist;
107421 pEnd = &pExpr->aDoclist[pExpr->nDoclist];
107432 Fts3Expr *pExpr, /* Phrase expression node */
107438 if( pExpr->aDoclist ){
107443 pCsr = sqlite3Fts3FindPositions(pExpr, p->pCursor->iPrevId, -1);
107481 (void)fts3ExprIterate(pCsr->pExpr, fts3ExprGlobalMatchinfoCb, (void *)&g);
107493 (void)fts3ExprIterate(pCsr->pExpr, fts3ExprLocalMatchinfoCb, (void *)&g);
110624 URegularExpression *pExpr = (URegularExpression *)p;
110625 uregex_close(pExpr);
110649 URegularExpression *pExpr;
110660 pExpr = sqlite3_get_auxdata(p, 0);
110661 if( !pExpr ){
110666 pExpr = uregex_open(zPattern, -1, 0, 0, &status);
110669 sqlite3_set_auxdata(p, 0, pExpr, icuRegexpDelete);
110671 assert(!pExpr);
110678 uregex_setText(pExpr, zString, -1, &status);
110685 res = uregex_matches(pExpr, 0, &status);
110696 uregex_setText(pExpr, 0, 0, &status);
