if( pExpr==0 ) return 0;  savedHasAgg = pNC->hasAgg;  pNC->hasAgg = 0;  walkExprTree(pExpr, nameResolverStep, pNC);  if( pNC->nErr>0 ){    ExprSetProperty(pExpr, EP_Error);  }  if( pNC->hasAgg ){    ExprSetProperty(pExpr, EP_Agg);  }else if( savedHasAgg ){    pNC->hasAgg = 1;  }  return ExprHasProperty(pExpr, EP_Error);}/*** A pointer instance of this structure is used to pass information** through walkExprTree into codeSubqueryStep().*/typedef struct QueryCoder QueryCoder;struct QueryCoder {  Parse *pParse;       /* The parsing context */  NameContext *pNC;    /* Namespace of first enclosing query */};/*** Generate code for subqueries and IN operators.**** IN operators comes in two forms:****           expr IN (exprlist)** and**           expr IN (SELECT ...)**** The first form is handled by creating a set holding the list** of allowed values.  The second form causes the SELECT to generate ** a temporary table.*/#ifndef SQLITE_OMIT_SUBQUERYvoid sqlite3CodeSubselect(Parse *pParse, Expr *pExpr){  int testAddr = 0;                       /* One-time test address */  Vdbe *v = sqlite3GetVdbe(pParse);  if( v==0 ) return;  /* This code must be run in its entirety every time it is encountered  ** if any of the following is true:  **  **    *  The right-hand side is a correlated subquery  **    *  The right-hand side is an expression list containing variables  **    *  We are inside a trigger  **  ** If all of the above are false, then we can run this code just once  ** save the results, and reuse the same result on subsequent invocations.  */  if( !ExprHasAnyProperty(pExpr, EP_VarSelect) && !pParse->trigStack ){    int mem = pParse->nMem++;    sqlite3VdbeAddOp(v, OP_MemLoad, mem, 0);    testAddr = sqlite3VdbeAddOp(v, OP_If, 0, 0);    assert( testAddr>0 || sqlite3_malloc_failed );    sqlite3VdbeAddOp(v, OP_MemInt, 1, mem);  }  switch( pExpr->op ){    case TK_IN: {      char affinity;      KeyInfo keyInfo;      int addr;        /* Address of OP_OpenVirtual instruction */      affinity = sqlite3ExprAffinity(pExpr->pLeft);      /* Whether this is an 'x IN(SELECT...)' or an 'x IN(<exprlist>)'      ** expression it is handled the same way. A virtual table is       ** filled with single-field index keys representing the results      ** from the SELECT or the <exprlist>.      **      ** If the 'x' expression is a column value, or the SELECT...      ** statement returns a column value, then the affinity of that      ** column is used to build the index keys. If both 'x' and the      ** SELECT... statement are columns, then numeric affinity is used      ** if either column has NUMERIC or INTEGER affinity. If neither      ** 'x' nor the SELECT... statement are columns, then numeric affinity      ** is used.      */      pExpr->iTable = pParse->nTab++;      addr = sqlite3VdbeAddOp(v, OP_OpenVirtual, pExpr->iTable, 0);      memset(&keyInfo, 0, sizeof(keyInfo));      keyInfo.nField = 1;      sqlite3VdbeAddOp(v, OP_SetNumColumns, pExpr->iTable, 1);      if( pExpr->pSelect ){        /* Case 1:     expr IN (SELECT ...)        **        ** Generate code to write the results of the select into the temporary        ** table allocated and opened above.        */        int iParm = pExpr->iTable +  (((int)affinity)<<16);        ExprList *pEList;        assert( (pExpr->iTable&0x0000FFFF)==pExpr->iTable );        sqlite3Select(pParse, pExpr->pSelect, SRT_Set, iParm, 0, 0, 0, 0);        pEList = pExpr->pSelect->pEList;        if( pEList && pEList->nExpr>0 ){           keyInfo.aColl[0] = binaryCompareCollSeq(pParse, pExpr->pLeft,              pEList->a[0].pExpr);        }      }else if( pExpr->pList ){        /* Case 2:     expr IN (exprlist)        **	** For each expression, build an index key from the evaluation and        ** store it in the temporary table. If <expr> is a column, then use        ** that columns affinity when building index keys. If <expr> is not        ** a column, use numeric affinity.        */        int i;        ExprList *pList = pExpr->pList;        struct ExprList_item *pItem;        if( !affinity ){          affinity = SQLITE_AFF_NUMERIC;        }        keyInfo.aColl[0] = pExpr->pLeft->pColl;        /* Loop through each expression in <exprlist>. */        for(i=pList->nExpr, pItem=pList->a; i>0; i--, pItem++){          Expr *pE2 = pItem->pExpr;          /* If the expression is not constant then we will need to          ** disable the test that was generated above that makes sure          ** this code only executes once.  Because for a non-constant          ** expression we need to rerun this code each time.          */          if( testAddr>0 && !sqlite3ExprIsConstant(pE2) ){            VdbeOp *aOp = sqlite3VdbeGetOp(v, testAddr-1);            int i;            for(i=0; i<3; i++){              aOp[i].opcode = OP_Noop;            }            testAddr = 0;          }          /* Evaluate the expression and insert it into the temp table */          sqlite3ExprCode(pParse, pE2);          sqlite3VdbeOp3(v, OP_MakeRecord, 1, 0, &affinity, 1);          sqlite3VdbeAddOp(v, OP_IdxInsert, pExpr->iTable, 0);        }      }      sqlite3VdbeChangeP3(v, addr, (void *)&keyInfo, P3_KEYINFO);      break;    }    case TK_EXISTS:    case TK_SELECT: {      /* This has to be a scalar SELECT.  Generate code to put the      ** value of this select in a memory cell and record the number      ** of the memory cell in iColumn.      */      int sop;      Select *pSel;      pExpr->iColumn = pParse->nMem++;      pSel = pExpr->pSelect;      if( pExpr->op==TK_SELECT ){        sop = SRT_Mem;      }else{        static const Token one = { "1", 0, 1 };        sop = SRT_Exists;        sqlite3ExprListDelete(pSel->pEList);        pSel->pEList = sqlite3ExprListAppend(0,                           sqlite3Expr(TK_INTEGER, 0, 0, &one), 0);      }      sqlite3Select(pParse, pSel, sop, pExpr->iColumn, 0, 0, 0, 0);      break;    }  }  if( testAddr ){    sqlite3VdbeJumpHere(v, testAddr);  }  return;}#endif /* SQLITE_OMIT_SUBQUERY *//*** Generate an instruction that will put the integer describe by** text z[0..n-1] on the stack.*/static void codeInteger(Vdbe *v, const char *z, int n){  int i;  if( sqlite3GetInt32(z, &i) ){    sqlite3VdbeAddOp(v, OP_Integer, i, 0);  }else if( sqlite3FitsIn64Bits(z) ){    sqlite3VdbeOp3(v, OP_Int64, 0, 0, z, n);  }else{    sqlite3VdbeOp3(v, OP_Real, 0, 0, z, n);  }}/*** Generate code into the current Vdbe to evaluate the given** expression and leave the result on the top of stack.**** This code depends on the fact that certain token values (ex: TK_EQ)** are the same as opcode values (ex: OP_Eq) that implement the corresponding** operation.  Special comments in vdbe.c and the mkopcodeh.awk script in** the make process cause these values to align.  Assert()s in the code** below verify that the numbers are aligned correctly.*/void sqlite3ExprCode(Parse *pParse, Expr *pExpr){  Vdbe *v = pParse->pVdbe;  int op;  if( v==0 ) return;  if( pExpr==0 ){    sqlite3VdbeAddOp(v, OP_Null, 0, 0);    return;  }  op = pExpr->op;  switch( op ){    case TK_AGG_COLUMN: {      AggInfo *pAggInfo = pExpr->pAggInfo;      struct AggInfo_col *pCol = &pAggInfo->aCol[pExpr->iAgg];      if( !pAggInfo->directMode ){        sqlite3VdbeAddOp(v, OP_MemLoad, pCol->iMem, 0);        break;      }else if( pAggInfo->useSortingIdx ){        sqlite3VdbeAddOp(v, OP_Column, pAggInfo->sortingIdx,                              pCol->iSorterColumn);        break;      }      /* Otherwise, fall thru into the TK_COLUMN case */    }    case TK_COLUMN: {      if( pExpr->iColumn>=0 ){        sqlite3VdbeAddOp(v, OP_Column, pExpr->iTable, pExpr->iColumn);        sqlite3ColumnDefault(v, pExpr->pTab, pExpr->iColumn);      }else{        sqlite3VdbeAddOp(v, OP_Rowid, pExpr->iTable, 0);      }      break;    }    case TK_INTEGER: {      codeInteger(v, pExpr->token.z, pExpr->token.n);      break;    }    case TK_FLOAT:    case TK_STRING: {      assert( TK_FLOAT==OP_Real );      assert( TK_STRING==OP_String8 );      sqlite3DequoteExpr(pExpr);      sqlite3VdbeOp3(v, op, 0, 0, pExpr->token.z, pExpr->token.n);      break;    }    case TK_NULL: {      sqlite3VdbeAddOp(v, OP_Null, 0, 0);      break;    }#ifndef SQLITE_OMIT_BLOB_LITERAL    case TK_BLOB: {      int n;      const char *z;      assert( TK_BLOB==OP_HexBlob );      n = pExpr->token.n - 3;      z = pExpr->token.z + 2;      assert( n>=0 );      if( n==0 ){        z = "";      }      sqlite3VdbeOp3(v, op, 0, 0, z, n);      break;    }#endif    case TK_VARIABLE: {      sqlite3VdbeAddOp(v, OP_Variable, pExpr->iTable, 0);      if( pExpr->token.n>1 ){        sqlite3VdbeChangeP3(v, -1, pExpr->token.z, pExpr->token.n);      }      break;    }    case TK_REGISTER: {      sqlite3VdbeAddOp(v, OP_MemLoad, pExpr->iTable, 0);      break;    }#ifndef SQLITE_OMIT_CAST    case TK_CAST: {      /* Expressions of the form:   CAST(pLeft AS token) */      int aff, op;      sqlite3ExprCode(pParse, pExpr->pLeft);      aff = sqlite3AffinityType(&pExpr->token);      switch( aff ){        case SQLITE_AFF_INTEGER:   op = OP_ToInt;      break;        case SQLITE_AFF_NUMERIC:   op = OP_ToNumeric;  break;        case SQLITE_AFF_TEXT:      op = OP_ToText;     break;        case SQLITE_AFF_NONE:      op = OP_ToBlob;     break;      }      sqlite3VdbeAddOp(v, op, 0, 0);      break;    }#endif /* SQLITE_OMIT_CAST */    case TK_LT:    case TK_LE:    case TK_GT:    case TK_GE:    case TK_NE:    case TK_EQ: {      assert( TK_LT==OP_Lt );      assert( TK_LE==OP_Le );      assert( TK_GT==OP_Gt );      assert( TK_GE==OP_Ge );      assert( TK_EQ==OP_Eq );      assert( TK_NE==OP_Ne );      sqlite3ExprCode(pParse, pExpr->pLeft);      sqlite3ExprCode(pParse, pExpr->pRight);      codeCompare(pParse, pExpr->pLeft, pExpr->pRight, op, 0, 0);      break;    }    case TK_AND:    case TK_OR:    case TK_PLUS:    case TK_STAR:    case TK_MINUS:    case TK_REM:    case TK_BITAND:    case TK_BITOR:    case TK_SLASH:    case TK_LSHIFT:    case TK_RSHIFT:     case TK_CONCAT: {      assert( TK_AND==OP_And );      assert( TK_OR==OP_Or );      assert( TK_PLUS==OP_Add );      assert( TK_MINUS==OP_Subtract );      assert( TK_REM==OP_Remainder );      assert( TK_BITAND==OP_BitAnd );      assert( TK_BITOR==OP_BitOr );      assert( TK_SLASH==OP_Divide );      assert( TK_LSHIFT==OP_ShiftLeft );      assert( TK_RSHIFT==OP_ShiftRight );      assert( TK_CONCAT==OP_Concat );      sqlite3ExprCode(pParse, pExpr->pLeft);      sqlite3ExprCode(pParse, pExpr->pRight);      sqlite3VdbeAddOp(v, op, 0, 0);      break;    }    case TK_UMINUS: {      Expr *pLeft = pExpr->pLeft;      assert( pLeft );      if( pLeft->op==TK_FLOAT || pLeft->op==TK_INTEGER ){        Token *p = &pLeft->token;        char *z = sqliteMalloc( p->n + 2 );        sprintf(z, "-%.*s", p->n, p->z);        if( pLeft->op==TK_FLOAT ){          sqlite3VdbeOp3(v, OP_Real, 0, 0, z, p->n+1);        }else{          codeInteger(v, z, p->n+1);        }        sqliteFree(z);        break;      }      /* Fall through into TK_NOT */    }    case TK_BITNOT:    case TK_NOT: {      assert( TK_BITNOT==OP_BitNot );      assert( TK_NOT==OP_Not );      sqlite3ExprCode(pParse, pExpr->pLeft);      sqlite3VdbeAddOp(v, op, 0, 0);      break;    }    case TK_ISNULL:    case TK_NOTNULL: {      int dest;      assert( TK_ISNULL==OP_IsNull );      assert( TK_NOTNULL==OP_NotNull );      sqlite3VdbeAddOp(v, OP_Integer, 1, 0);      sqlite3ExprCode(pParse, pExpr->pLeft);      dest = sqlite3VdbeCurrentAddr(v) + 2;      sqlite3VdbeAddOp(v, op, 1, dest);      sqlite3VdbeAddOp(v, OP_AddImm, -1, 0);      break;    }    case TK_AGG_FUNCTION: {      AggInfo *pInfo = pExpr->pAggInfo;      sqlite3VdbeAddOp(v, OP_MemLoad, pInfo->aFunc[pExpr->iAgg].iMem, 0);      break;    }    case TK_CONST_FUNC:    case TK_FUNCTION: {      ExprList *pList = pExpr->pList;      int nExpr = pList ? pList->nExpr : 0;      FuncDef *pDef;      int nId;      const char *zId;      int constMask = 0;      int i;      u8 enc = pParse->db->enc;      CollSeq *pColl = 0;      zId = pExpr->token.z;      nId = pExpr->token.n;      pDef = sqlite3FindFunction(pParse->db, zId, nId, nExpr, enc, 0);      assert( pDef!=0 );      nExpr = sqlite3ExprCodeExprList(pParse, pList);      for(i=0; i<nExpr && i<32; i++){        if( sqlite3ExprIsConstant(pList->a[i].pExpr) ){          constMask |= (1<<i);        }        if( pDef->needCollSeq && !pColl ){          pColl = sqlite3ExprCollSeq(pParse, pList->a[i].pExpr);        }      }      if( pDef->needCollSeq ){        if( !pColl ) pColl = pParse->db->pDfltColl;         sqlite3VdbeOp3(v, OP_CollSeq, 0, 0, (char *)pColl, P3_COLLSEQ);      }