/*** Call walkExprTree() for every expression in list p.*/static int walkExprList(ExprList *p, int (*xFunc)(void *, Expr*), void *pArg){  int i;  struct ExprList_item *pItem;  if( !p ) return 0;  for(i=p->nExpr, pItem=p->a; i>0; i--, pItem++){    if( walkExprTree(pItem->pExpr, xFunc, pArg) ) return 1;  }  return 0;}/*** Call walkExprTree() for every expression in Select p, not including** expressions that are part of sub-selects in any FROM clause or the LIMIT** or OFFSET expressions..*/static int walkSelectExpr(Select *p, int (*xFunc)(void *, Expr*), void *pArg){  walkExprList(p->pEList, xFunc, pArg);  walkExprTree(p->pWhere, xFunc, pArg);  walkExprList(p->pGroupBy, xFunc, pArg);  walkExprTree(p->pHaving, xFunc, pArg);  walkExprList(p->pOrderBy, xFunc, pArg);  if( p->pPrior ){    walkSelectExpr(p->pPrior, xFunc, pArg);  }  return 0;}/*** This routine is designed as an xFunc for walkExprTree().**** pArg is really a pointer to an integer.  If we can tell by looking** at pExpr that the expression that contains pExpr is not a constant** expression, then set *pArg to 0 and return 2 to abandon the tree walk.** If pExpr does does not disqualify the expression from being a constant** then do nothing.**** After walking the whole tree, if no nodes are found that disqualify** the expression as constant, then we assume the whole expression** is constant.  See sqlite3ExprIsConstant() for additional information.*/static int exprNodeIsConstant(void *pArg, Expr *pExpr){  int *pN = (int*)pArg;  /* If *pArg is 3 then any term of the expression that comes from  ** the ON or USING clauses of a join disqualifies the expression  ** from being considered constant. */  if( (*pN)==3 && ExprHasAnyProperty(pExpr, EP_FromJoin) ){    *pN = 0;    return 2;  }  switch( pExpr->op ){    /* Consider functions to be constant if all their arguments are constant    ** and *pArg==2 */    case TK_FUNCTION:      if( (*pN)==2 ) return 0;      /* Fall through */    case TK_ID:    case TK_COLUMN:    case TK_DOT:    case TK_AGG_FUNCTION:    case TK_AGG_COLUMN:#ifndef SQLITE_OMIT_SUBQUERY    case TK_SELECT:    case TK_EXISTS:#endif      *pN = 0;      return 2;    case TK_IN:      if( pExpr->pSelect ){        *pN = 0;        return 2;      }    default:      return 0;  }}/*** Walk an expression tree.  Return 1 if the expression is constant** and 0 if it involves variables or function calls.**** For the purposes of this function, a double-quoted string (ex: "abc")** is considered a variable but a single-quoted string (ex: 'abc') is** a constant.*/int sqlite3ExprIsConstant(Expr *p){  int isConst = 1;  walkExprTree(p, exprNodeIsConstant, &isConst);  return isConst;}/*** Walk an expression tree.  Return 1 if the expression is constant** that does no originate from the ON or USING clauses of a join.** Return 0 if it involves variables or function calls or terms from** an ON or USING clause.*/int sqlite3ExprIsConstantNotJoin(Expr *p){  int isConst = 3;  walkExprTree(p, exprNodeIsConstant, &isConst);  return isConst!=0;}/*** Walk an expression tree.  Return 1 if the expression is constant** or a function call with constant arguments.  Return and 0 if there** are any variables.**** For the purposes of this function, a double-quoted string (ex: "abc")** is considered a variable but a single-quoted string (ex: 'abc') is** a constant.*/int sqlite3ExprIsConstantOrFunction(Expr *p){  int isConst = 2;  walkExprTree(p, exprNodeIsConstant, &isConst);  return isConst!=0;}/*** If the expression p codes a constant integer that is small enough** to fit in a 32-bit integer, return 1 and put the value of the integer** in *pValue.  If the expression is not an integer or if it is too big** to fit in a signed 32-bit integer, return 0 and leave *pValue unchanged.*/int sqlite3ExprIsInteger(Expr *p, int *pValue){  switch( p->op ){    case TK_INTEGER: {      if( sqlite3GetInt32((char*)p->token.z, pValue) ){        return 1;      }      break;    }    case TK_UPLUS: {      return sqlite3ExprIsInteger(p->pLeft, pValue);    }    case TK_UMINUS: {      int v;      if( sqlite3ExprIsInteger(p->pLeft, &v) ){        *pValue = -v;        return 1;      }      break;    }    default: break;  }  return 0;}/*** Return TRUE if the given string is a row-id column name.*/int sqlite3IsRowid(const char *z){  if( sqlite3StrICmp(z, "_ROWID_")==0 ) return 1;  if( sqlite3StrICmp(z, "ROWID")==0 ) return 1;  if( sqlite3StrICmp(z, "OID")==0 ) return 1;  return 0;}/*** Given the name of a column of the form X.Y.Z or Y.Z or just Z, look up** that name in the set of source tables in pSrcList and make the pExpr ** expression node refer back to that source column.  The following changes** are made to pExpr:****    pExpr->iDb           Set the index in db->aDb[] of the database holding**                         the table.**    pExpr->iTable        Set to the cursor number for the table obtained**                         from pSrcList.**    pExpr->iColumn       Set to the column number within the table.**    pExpr->op            Set to TK_COLUMN.**    pExpr->pLeft         Any expression this points to is deleted**    pExpr->pRight        Any expression this points to is deleted.**** The pDbToken is the name of the database (the "X").  This value may be** NULL meaning that name is of the form Y.Z or Z.  Any available database** can be used.  The pTableToken is the name of the table (the "Y").  This** value can be NULL if pDbToken is also NULL.  If pTableToken is NULL it** means that the form of the name is Z and that columns from any table** can be used.**** If the name cannot be resolved unambiguously, leave an error message** in pParse and return non-zero.  Return zero on success.*/static int lookupName(  Parse *pParse,       /* The parsing context */  Token *pDbToken,     /* Name of the database containing table, or NULL */  Token *pTableToken,  /* Name of table containing column, or NULL */  Token *pColumnToken, /* Name of the column. */  NameContext *pNC,    /* The name context used to resolve the name */  Expr *pExpr          /* Make this EXPR node point to the selected column */){  char *zDb = 0;       /* Name of the database.  The "X" in X.Y.Z */  char *zTab = 0;      /* Name of the table.  The "Y" in X.Y.Z or Y.Z */  char *zCol = 0;      /* Name of the column.  The "Z" */  int i, j;            /* Loop counters */  int cnt = 0;         /* Number of matching column names */  int cntTab = 0;      /* Number of matching table names */  sqlite3 *db = pParse->db;  /* The database */  struct SrcList_item *pItem;       /* Use for looping over pSrcList items */  struct SrcList_item *pMatch = 0;  /* The matching pSrcList item */  NameContext *pTopNC = pNC;        /* First namecontext in the list */  Schema *pSchema = 0;              /* Schema of the expression */  assert( pColumnToken && pColumnToken->z ); /* The Z in X.Y.Z cannot be NULL */  zDb = sqlite3NameFromToken(db, pDbToken);  zTab = sqlite3NameFromToken(db, pTableToken);  zCol = sqlite3NameFromToken(db, pColumnToken);  if( db->mallocFailed ){    goto lookupname_end;  }  pExpr->iTable = -1;  while( pNC && cnt==0 ){    ExprList *pEList;    SrcList *pSrcList = pNC->pSrcList;    if( pSrcList ){      for(i=0, pItem=pSrcList->a; i<pSrcList->nSrc; i++, pItem++){        Table *pTab;        int iDb;        Column *pCol;          pTab = pItem->pTab;        assert( pTab!=0 );        iDb = sqlite3SchemaToIndex(db, pTab->pSchema);        assert( pTab->nCol>0 );        if( zTab ){          if( pItem->zAlias ){            char *zTabName = pItem->zAlias;            if( sqlite3StrICmp(zTabName, zTab)!=0 ) continue;          }else{            char *zTabName = pTab->zName;            if( zTabName==0 || sqlite3StrICmp(zTabName, zTab)!=0 ) continue;            if( zDb!=0 && sqlite3StrICmp(db->aDb[iDb].zName, zDb)!=0 ){              continue;            }          }        }        if( 0==(cntTab++) ){          pExpr->iTable = pItem->iCursor;          pSchema = pTab->pSchema;          pMatch = pItem;        }        for(j=0, pCol=pTab->aCol; j<pTab->nCol; j++, pCol++){          if( sqlite3StrICmp(pCol->zName, zCol)==0 ){            const char *zColl = pTab->aCol[j].zColl;            IdList *pUsing;            cnt++;            pExpr->iTable = pItem->iCursor;            pMatch = pItem;            pSchema = pTab->pSchema;            /* Substitute the rowid (column -1) for the INTEGER PRIMARY KEY */            pExpr->iColumn = j==pTab->iPKey ? -1 : j;            pExpr->affinity = pTab->aCol[j].affinity;            if( (pExpr->flags & EP_ExpCollate)==0 ){              pExpr->pColl = sqlite3FindCollSeq(db, ENC(db), zColl,-1, 0);            }            if( i<pSrcList->nSrc-1 ){              if( pItem[1].jointype & JT_NATURAL ){                /* If this match occurred in the left table of a natural join,                ** then skip the right table to avoid a duplicate match */                pItem++;                i++;              }else if( (pUsing = pItem[1].pUsing)!=0 ){                /* If this match occurs on a column that is in the USING clause                ** of a join, skip the search of the right table of the join                ** to avoid a duplicate match there. */                int k;                for(k=0; k<pUsing->nId; k++){                  if( sqlite3StrICmp(pUsing->a[k].zName, zCol)==0 ){                    pItem++;                    i++;                    break;                  }                }              }            }            break;          }        }      }    }#ifndef SQLITE_OMIT_TRIGGER    /* If we have not already resolved the name, then maybe     ** it is a new.* or old.* trigger argument reference    */    if( zDb==0 && zTab!=0 && cnt==0 && pParse->trigStack!=0 ){      TriggerStack *pTriggerStack = pParse->trigStack;      Table *pTab = 0;      if( pTriggerStack->newIdx != -1 && sqlite3StrICmp("new", zTab) == 0 ){        pExpr->iTable = pTriggerStack->newIdx;        assert( pTriggerStack->pTab );        pTab = pTriggerStack->pTab;      }else if( pTriggerStack->oldIdx != -1 && sqlite3StrICmp("old", zTab)==0 ){        pExpr->iTable = pTriggerStack->oldIdx;        assert( pTriggerStack->pTab );        pTab = pTriggerStack->pTab;      }      if( pTab ){         int iCol;        Column *pCol = pTab->aCol;        pSchema = pTab->pSchema;        cntTab++;        for(iCol=0; iCol < pTab->nCol; iCol++, pCol++) {          if( sqlite3StrICmp(pCol->zName, zCol)==0 ){            const char *zColl = pTab->aCol[iCol].zColl;            cnt++;            pExpr->iColumn = iCol==pTab->iPKey ? -1 : iCol;            pExpr->affinity = pTab->aCol[iCol].affinity;            if( (pExpr->flags & EP_ExpCollate)==0 ){              pExpr->pColl = sqlite3FindCollSeq(db, ENC(db), zColl,-1, 0);            }            pExpr->pTab = pTab;            break;          }        }      }    }#endif /* !defined(SQLITE_OMIT_TRIGGER) */    /*    ** Perhaps the name is a reference to the ROWID    */    if( cnt==0 && cntTab==1 && sqlite3IsRowid(zCol) ){      cnt = 1;      pExpr->iColumn = -1;      pExpr->affinity = SQLITE_AFF_INTEGER;    }    /*    ** If the input is of the form Z (not Y.Z or X.Y.Z) then the name Z    ** might refer to an result-set alias.  This happens, for example, when    ** we are resolving names in the WHERE clause of the following command:    **    **     SELECT a+b AS x FROM table WHERE x<10;    **    ** In cases like this, replace pExpr with a copy of the expression that    ** forms the result set entry ("a+b" in the example) and return immediately.    ** Note that the expression in the result set should have already been    ** resolved by the time the WHERE clause is resolved.    */    if( cnt==0 && (pEList = pNC->pEList)!=0 && zTab==0 ){      for(j=0; j<pEList->nExpr; j++){        char *zAs = pEList->a[j].zName;        if( zAs!=0 && sqlite3StrICmp(zAs, zCol)==0 ){          Expr *pDup, *pOrig;          assert( pExpr->pLeft==0 && pExpr->pRight==0 );          assert( pExpr->pList==0 );          assert( pExpr->pSelect==0 );          pOrig = pEList->a[j].pExpr;          if( !pNC->allowAgg && ExprHasProperty(pOrig, EP_Agg) ){            sqlite3ErrorMsg(pParse, "misuse of aliased aggregate %s", zAs);            sqlite3_free(zCol);            return 2;          }          pDup = sqlite3ExprDup(db, pOrig);          if( pExpr->flags & EP_ExpCollate ){            pDup->pColl = pExpr->pColl;            pDup->flags |= EP_ExpCollate;          }          if( pExpr->span.dyn ) sqlite3_free((char*)pExpr->span.z);          if( pExpr->token.dyn ) sqlite3_free((char*)pExpr->token.z);          memcpy(pExpr, pDup, sizeof(*pExpr));          sqlite3_free(pDup);          cnt = 1;          pMatch = 0;          assert( zTab==0 && zDb==0 );          goto lookupname_end_2;        }      }     }    /* Advance to the next name context.  The loop will exit when either    ** we have a match (cnt>0) or when we run out of name contexts.    */    if( cnt==0 ){      pNC = pNC->pNext;    }  }  /*  ** If X and Y are NULL (in other words if only the column name Z is  ** supplied) and the value of Z is enclosed in double-quotes, then  ** Z is a string literal if it doesn't match any column names.  In that  ** case, we need to return right away and not make any changes to  ** pExpr.  **  ** Because no reference was made to outer contexts, the pNC->nRef  ** fields are not changed in any context.  */  if( cnt==0 && zTab==0 && pColumnToken->z[0]=='"' ){    sqlite3_free(zCol);    return 0;  }  /*  ** cnt==0 means there was not match.  cnt>1 means there were two or  ** more matches.  Either way, we have an error.  */