if( p==0 ) return 0;  pNew = sqliteMallocRaw( sizeof(*p) );  if( pNew==0 ) return 0;  memcpy(pNew, p, sizeof(*pNew));  if( p->token.z!=0 ){    pNew->token.z = sqliteStrNDup(p->token.z, p->token.n);    pNew->token.dyn = 1;  }else{    assert( pNew->token.z==0 );  }  pNew->span.z = 0;  pNew->pLeft = sqlite3ExprDup(p->pLeft);  pNew->pRight = sqlite3ExprDup(p->pRight);  pNew->pList = sqlite3ExprListDup(p->pList);  pNew->pSelect = sqlite3SelectDup(p->pSelect);  pNew->pTab = p->pTab;  return pNew;}void sqlite3TokenCopy(Token *pTo, Token *pFrom){  if( pTo->dyn ) sqliteFree((char*)pTo->z);  if( pFrom->z ){    pTo->n = pFrom->n;    pTo->z = sqliteStrNDup(pFrom->z, pFrom->n);    pTo->dyn = 1;  }else{    pTo->z = 0;  }}ExprList *sqlite3ExprListDup(ExprList *p){  ExprList *pNew;  struct ExprList_item *pItem, *pOldItem;  int i;  if( p==0 ) return 0;  pNew = sqliteMalloc( sizeof(*pNew) );  if( pNew==0 ) return 0;  pNew->nExpr = pNew->nAlloc = p->nExpr;  pNew->a = pItem = sqliteMalloc( p->nExpr*sizeof(p->a[0]) );  if( pItem==0 ){    sqliteFree(pNew);    return 0;  }   pOldItem = p->a;  for(i=0; i<p->nExpr; i++, pItem++, pOldItem++){    Expr *pNewExpr, *pOldExpr;    pItem->pExpr = pNewExpr = sqlite3ExprDup(pOldExpr = pOldItem->pExpr);    if( pOldExpr->span.z!=0 && pNewExpr ){      /* Always make a copy of the span for top-level expressions in the      ** expression list.  The logic in SELECT processing that determines      ** the names of columns in the result set needs this information */      sqlite3TokenCopy(&pNewExpr->span, &pOldExpr->span);    }    assert( pNewExpr==0 || pNewExpr->span.z!=0             || pOldExpr->span.z==0 || sqlite3_malloc_failed );    pItem->zName = sqliteStrDup(pOldItem->zName);    pItem->sortOrder = pOldItem->sortOrder;    pItem->isAgg = pOldItem->isAgg;    pItem->done = 0;  }  return pNew;}/*** If cursors, triggers, views and subqueries are all omitted from** the build, then none of the following routines, except for ** sqlite3SelectDup(), can be called. sqlite3SelectDup() is sometimes** called with a NULL argument.*/#if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_TRIGGER) \ || !defined(SQLITE_OMIT_SUBQUERY)SrcList *sqlite3SrcListDup(SrcList *p){  SrcList *pNew;  int i;  int nByte;  if( p==0 ) return 0;  nByte = sizeof(*p) + (p->nSrc>0 ? sizeof(p->a[0]) * (p->nSrc-1) : 0);  pNew = sqliteMallocRaw( nByte );  if( pNew==0 ) return 0;  pNew->nSrc = pNew->nAlloc = p->nSrc;  for(i=0; i<p->nSrc; i++){    struct SrcList_item *pNewItem = &pNew->a[i];    struct SrcList_item *pOldItem = &p->a[i];    Table *pTab;    pNewItem->zDatabase = sqliteStrDup(pOldItem->zDatabase);    pNewItem->zName = sqliteStrDup(pOldItem->zName);    pNewItem->zAlias = sqliteStrDup(pOldItem->zAlias);    pNewItem->jointype = pOldItem->jointype;    pNewItem->iCursor = pOldItem->iCursor;    pTab = pNewItem->pTab = pOldItem->pTab;    if( pTab ){      pTab->nRef++;    }    pNewItem->pSelect = sqlite3SelectDup(pOldItem->pSelect);    pNewItem->pOn = sqlite3ExprDup(pOldItem->pOn);    pNewItem->pUsing = sqlite3IdListDup(pOldItem->pUsing);    pNewItem->colUsed = pOldItem->colUsed;  }  return pNew;}IdList *sqlite3IdListDup(IdList *p){  IdList *pNew;  int i;  if( p==0 ) return 0;  pNew = sqliteMallocRaw( sizeof(*pNew) );  if( pNew==0 ) return 0;  pNew->nId = pNew->nAlloc = p->nId;  pNew->a = sqliteMallocRaw( p->nId*sizeof(p->a[0]) );  if( pNew->a==0 ){    sqliteFree(pNew);    return 0;  }  for(i=0; i<p->nId; i++){    struct IdList_item *pNewItem = &pNew->a[i];    struct IdList_item *pOldItem = &p->a[i];    pNewItem->zName = sqliteStrDup(pOldItem->zName);    pNewItem->idx = pOldItem->idx;  }  return pNew;}Select *sqlite3SelectDup(Select *p){  Select *pNew;  if( p==0 ) return 0;  pNew = sqliteMallocRaw( sizeof(*p) );  if( pNew==0 ) return 0;  pNew->isDistinct = p->isDistinct;  pNew->pEList = sqlite3ExprListDup(p->pEList);  pNew->pSrc = sqlite3SrcListDup(p->pSrc);  pNew->pWhere = sqlite3ExprDup(p->pWhere);  pNew->pGroupBy = sqlite3ExprListDup(p->pGroupBy);  pNew->pHaving = sqlite3ExprDup(p->pHaving);  pNew->pOrderBy = sqlite3ExprListDup(p->pOrderBy);  pNew->op = p->op;  pNew->pPrior = sqlite3SelectDup(p->pPrior);  pNew->pLimit = sqlite3ExprDup(p->pLimit);  pNew->pOffset = sqlite3ExprDup(p->pOffset);  pNew->iLimit = -1;  pNew->iOffset = -1;  pNew->isResolved = p->isResolved;  pNew->isAgg = p->isAgg;  pNew->usesVirt = 0;  pNew->disallowOrderBy = 0;  pNew->pRightmost = 0;  pNew->addrOpenVirt[0] = -1;  pNew->addrOpenVirt[1] = -1;  pNew->addrOpenVirt[2] = -1;  return pNew;}#elseSelect *sqlite3SelectDup(Select *p){  assert( p==0 );  return 0;}#endif/*** Add a new element to the end of an expression list.  If pList is** initially NULL, then create a new expression list.*/ExprList *sqlite3ExprListAppend(ExprList *pList, Expr *pExpr, Token *pName){  if( pList==0 ){    pList = sqliteMalloc( sizeof(ExprList) );    if( pList==0 ){      goto no_mem;    }    assert( pList->nAlloc==0 );  }  if( pList->nAlloc<=pList->nExpr ){    struct ExprList_item *a;    int n = pList->nAlloc*2 + 4;    a = sqliteRealloc(pList->a, n*sizeof(pList->a[0]));    if( a==0 ){      goto no_mem;    }    pList->a = a;    pList->nAlloc = n;  }  assert( pList->a!=0 );  if( pExpr || pName ){    struct ExprList_item *pItem = &pList->a[pList->nExpr++];    memset(pItem, 0, sizeof(*pItem));    pItem->zName = sqlite3NameFromToken(pName);    pItem->pExpr = pExpr;  }  return pList;no_mem:       /* Avoid leaking memory if malloc has failed. */  sqlite3ExprDelete(pExpr);  sqlite3ExprListDelete(pList);  return 0;}/*** Delete an entire expression list.*/void sqlite3ExprListDelete(ExprList *pList){  int i;  struct ExprList_item *pItem;  if( pList==0 ) return;  assert( pList->a!=0 || (pList->nExpr==0 && pList->nAlloc==0) );  assert( pList->nExpr<=pList->nAlloc );  for(pItem=pList->a, i=0; i<pList->nExpr; i++, pItem++){    sqlite3ExprDelete(pItem->pExpr);    sqliteFree(pItem->zName);  }  sqliteFree(pList->a);  sqliteFree(pList);}/*** Walk an expression tree.  Call xFunc for each node visited.**** The return value from xFunc determines whether the tree walk continues.** 0 means continue walking the tree.  1 means do not walk children** of the current node but continue with siblings.  2 means abandon** the tree walk completely.**** The return value from this routine is 1 to abandon the tree walk** and 0 to continue.**** NOTICE:  This routine does *not* descend into subqueries.*/static int walkExprList(ExprList *, int (*)(void *, Expr*), void *);static int walkExprTree(Expr *pExpr, int (*xFunc)(void*,Expr*), void *pArg){  int rc;  if( pExpr==0 ) return 0;  rc = (*xFunc)(pArg, pExpr);  if( rc==0 ){    if( walkExprTree(pExpr->pLeft, xFunc, pArg) ) return 1;    if( walkExprTree(pExpr->pRight, xFunc, pArg) ) return 1;    if( walkExprList(pExpr->pList, xFunc, pArg) ) return 1;  }  return rc>1;}/*** 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);  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){  switch( pExpr->op ){    /* Consider functions to be constant if all their arguments are constant    ** and *pArg==2 */    case TK_FUNCTION:      if( *((int*)pArg)==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      *((int*)pArg) = 0;      return 2;    case TK_IN:      if( pExpr->pSelect ){        *((int*)pArg) = 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** 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(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 */