){          int iDb;          int iMem = pParse->nMem++;          int iAddr;          char *pKey;            pKey = (char *)sqlite3IndexKeyinfo(pParse, pIdx);          iDb = sqlite3SchemaToIndex(db, pIdx->pSchema);          sqlite3VdbeUsesBtree(v, iDb);          sqlite3VdbeAddOp(v, OP_MemLoad, iMem, 0);          iAddr = sqlite3VdbeAddOp(v, OP_If, 0, iMem);          sqlite3VdbeAddOp(v, OP_MemInt, 1, iMem);            sqlite3VdbeAddOp(v, OP_Integer, iDb, 0);          VdbeComment((v, "# %s", pIdx->zName));          sqlite3VdbeOp3(v,OP_OpenRead,iTab,pIdx->tnum,pKey,P3_KEYINFO_HANDOFF);          eType = IN_INDEX_INDEX;          sqlite3VdbeAddOp(v, OP_SetNumColumns, iTab, pIdx->nColumn);          sqlite3VdbeJumpHere(v, iAddr);        }      }    }  }  if( eType==0 ){    sqlite3CodeSubselect(pParse, pX);    eType = IN_INDEX_EPH;  }else{    pX->iTable = iTab;  }  return eType;}#endif/*** Generate code for scalar subqueries used as an expression** and IN operators.  Examples:****     (SELECT a FROM b)          -- subquery**     EXISTS (SELECT a FROM b)   -- EXISTS subquery**     x IN (4,5,11)              -- IN operator with list on right-hand side**     x IN (SELECT a FROM b)     -- IN operator with subquery on the right**** The pExpr parameter describes the expression that contains the IN** operator or subquery.*/#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 || pParse->db->mallocFailed );    sqlite3VdbeAddOp(v, OP_MemInt, 1, mem);  }  switch( pExpr->op ){    case TK_IN: {      char affinity;      KeyInfo keyInfo;      int addr;        /* Address of OP_OpenEphemeral 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_OpenEphemeral, 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 );        if( sqlite3Select(pParse, pExpr->pSelect, SRT_Set, iParm, 0, 0, 0, 0) ){          return;        }        pEList = pExpr->pSelect->pEList;        if( pEList && pEList->nExpr>0 ){           keyInfo.aColl[0] = sqlite3BinaryCompareCollSeq(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_NONE;        }        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) ){            sqlite3VdbeChangeToNoop(v, testAddr-1, 3);            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.      */      static const Token one = { (u8*)"1", 0, 1 };      Select *pSel;      int iMem;      int sop;      pExpr->iColumn = iMem = pParse->nMem++;      pSel = pExpr->pSelect;      if( pExpr->op==TK_SELECT ){        sop = SRT_Mem;        sqlite3VdbeAddOp(v, OP_MemNull, iMem, 0);        VdbeComment((v, "# Init subquery result"));      }else{        sop = SRT_Exists;        sqlite3VdbeAddOp(v, OP_MemInt, 0, iMem);        VdbeComment((v, "# Init EXISTS result"));      }      sqlite3ExprDelete(pSel->pLimit);      pSel->pLimit = sqlite3PExpr(pParse, TK_INTEGER, 0, 0, &one);      if( sqlite3Select(pParse, pSel, sop, iMem, 0, 0, 0, 0) ){        return;      }      break;    }  }  if( testAddr ){    sqlite3VdbeJumpHere(v, testAddr);  }  return;}#endif /* SQLITE_OMIT_SUBQUERY *//*** Duplicate an 8-byte value*/static char *dup8bytes(Vdbe *v, const char *in){  char *out = sqlite3DbMallocRaw(sqlite3VdbeDb(v), 8);  if( out ){    memcpy(out, in, 8);  }  return out;}/*** Generate an instruction that will put the floating point** value described by z[0..n-1] on the stack.**** The z[] string will probably not be zero-terminated.  But the ** z[n] character is guaranteed to be something that does not look** like the continuation of the number.*/static void codeReal(Vdbe *v, const char *z, int n, int negateFlag){  assert( z || v==0 || sqlite3VdbeDb(v)->mallocFailed );  if( z ){    double value;    char *zV;    assert( !isdigit(z[n]) );    sqlite3AtoF(z, &value);    if( negateFlag ) value = -value;    zV = dup8bytes(v, (char*)&value);    sqlite3VdbeOp3(v, OP_Real, 0, 0, zV, P3_REAL);  }}/*** Generate an instruction that will put the integer describe by** text z[0..n-1] on the stack.**** The z[] string will probably not be zero-terminated.  But the ** z[n] character is guaranteed to be something that does not look** like the continuation of the number.*/static void codeInteger(Vdbe *v, const char *z, int n, int negateFlag){  assert( z || v==0 || sqlite3VdbeDb(v)->mallocFailed );  if( z ){    int i;    assert( !isdigit(z[n]) );    if( sqlite3GetInt32(z, &i) ){      if( negateFlag ) i = -i;      sqlite3VdbeAddOp(v, OP_Integer, i, 0);    }else if( sqlite3FitsIn64Bits(z, negateFlag) ){      i64 value;      char *zV;      sqlite3Atoi64(z, &value);      if( negateFlag ) value = -value;      zV = dup8bytes(v, (char*)&value);      sqlite3VdbeOp3(v, OP_Int64, 0, 0, zV, P3_INT64);    }else{      codeReal(v, z, n, negateFlag);    }  }}/*** Generate code that will extract the iColumn-th column from** table pTab and push that column value on the stack.  There** is an open cursor to pTab in iTable.  If iColumn<0 then** code is generated that extracts the rowid.*/void sqlite3ExprCodeGetColumn(Vdbe *v, Table *pTab, int iColumn, int iTable){  if( iColumn<0 ){    int op = (pTab && IsVirtual(pTab)) ? OP_VRowid : OP_Rowid;    sqlite3VdbeAddOp(v, op, iTable, 0);  }else if( pTab==0 ){    sqlite3VdbeAddOp(v, OP_Column, iTable, iColumn);  }else{    int op = IsVirtual(pTab) ? OP_VColumn : OP_Column;    sqlite3VdbeAddOp(v, op, iTable, iColumn);    sqlite3ColumnDefault(v, pTab, iColumn);#ifndef SQLITE_OMIT_FLOATING_POINT    if( pTab->aCol[iColumn].affinity==SQLITE_AFF_REAL ){      sqlite3VdbeAddOp(v, OP_RealAffinity, 0, 0);    }#endif  }}/*** 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;  int stackChng = 1;    /* Amount of change to stack depth */  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->iTable<0 ){        /* This only happens when coding check constraints */        assert( pParse->ckOffset>0 );        sqlite3VdbeAddOp(v, OP_Dup, pParse->ckOffset-pExpr->iColumn-1, 1);      }else{        sqlite3ExprCodeGetColumn(v, pExpr->pTab, pExpr->iColumn, pExpr->iTable);      }      break;    }    case TK_INTEGER: {      codeInteger(v, (char*)pExpr->token.z, pExpr->token.n, 0);      break;    }    case TK_FLOAT: {      codeReal(v, (char*)pExpr->token.z, pExpr->token.n, 0);      break;    }    case TK_STRING: {      sqlite3DequoteExpr(pParse->db, pExpr);      sqlite3VdbeOp3(v,OP_String8, 0, 0, (char*)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 = (char*)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, (char*)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, to_op;      sqlite3ExprCode(pParse, pExpr->pLeft);      aff = sqlite3AffinityType(&pExpr->token);      to_op = aff - SQLITE_AFF_TEXT + OP_ToText;      assert( to_op==OP_ToText    || aff!=SQLITE_AFF_TEXT    );      assert( to_op==OP_ToBlob    || aff!=SQLITE_AFF_NONE    );      assert( to_op==OP_ToNumeric || aff!=SQLITE_AFF_NUMERIC );      assert( to_op==OP_ToInt     || aff!=SQLITE_AFF_INTEGER );      assert( to_op==OP_ToReal    || aff!=SQLITE_AFF_REAL    );      sqlite3VdbeAddOp(v, to_op, 0, 0);      stackChng = 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);      stackChng = -1;      break;