static Mem nullMem;    if( nullMem.flags==0 ){ nullMem.flags = MEM_Null; }    sqlite3Error(pVm->db, SQLITE_RANGE, 0);    return &nullMem;  }  return &pVm->pTos[(1-vals)+i];}/**************************** sqlite3_column_  ********************************* The following routines are used to access elements of the current row** in the result set.*/const void *sqlite3_column_blob(sqlite3_stmt *pStmt, int i){  return sqlite3_value_blob( columnMem(pStmt,i) );}int sqlite3_column_bytes(sqlite3_stmt *pStmt, int i){  return sqlite3_value_bytes( columnMem(pStmt,i) );}int sqlite3_column_bytes16(sqlite3_stmt *pStmt, int i){  return sqlite3_value_bytes16( columnMem(pStmt,i) );}double sqlite3_column_double(sqlite3_stmt *pStmt, int i){  return sqlite3_value_double( columnMem(pStmt,i) );}int sqlite3_column_int(sqlite3_stmt *pStmt, int i){  return sqlite3_value_int( columnMem(pStmt,i) );}sqlite_int64 sqlite3_column_int64(sqlite3_stmt *pStmt, int i){  return sqlite3_value_int64( columnMem(pStmt,i) );}const unsigned char *sqlite3_column_text(sqlite3_stmt *pStmt, int i){  return sqlite3_value_text( columnMem(pStmt,i) );}#if 0sqlite3_value *sqlite3_column_value(sqlite3_stmt *pStmt, int i){  return columnMem(pStmt, i);}#endif#ifndef SQLITE_OMIT_UTF16const void *sqlite3_column_text16(sqlite3_stmt *pStmt, int i){  return sqlite3_value_text16( columnMem(pStmt,i) );}#endif /* SQLITE_OMIT_UTF16 */int sqlite3_column_type(sqlite3_stmt *pStmt, int i){  return sqlite3_value_type( columnMem(pStmt,i) );}/*** Convert the N-th element of pStmt->pColName[] into a string using** xFunc() then return that string.  If N is out of range, return 0.**** There are up to 5 names for each column.  useType determines which** name is returned.  Here are the names:****    0      The column name as it should be displayed for output**    1      The datatype name for the column**    2      The name of the database that the column derives from**    3      The name of the table that the column derives from**    4      The name of the table column that the result column derives from**** If the result is not a simple column reference (if it is an expression** or a constant) then useTypes 2, 3, and 4 return NULL.*/static const void *columnName(  sqlite3_stmt *pStmt,  int N,  const void *(*xFunc)(Mem*),  int useType){  Vdbe *p = (Vdbe *)pStmt;  int n = sqlite3_column_count(pStmt);  if( p==0 || N>=n || N<0 ){    return 0;  }  N += useType*n;  return xFunc(&p->aColName[N]);}/*** Return the name of the Nth column of the result set returned by SQL** statement pStmt.*/const char *sqlite3_column_name(sqlite3_stmt *pStmt, int N){  return columnName(pStmt, N, (const void*(*)(Mem*))sqlite3_value_text, 0);}#ifndef SQLITE_OMIT_UTF16const void *sqlite3_column_name16(sqlite3_stmt *pStmt, int N){  return columnName(pStmt, N, (const void*(*)(Mem*))sqlite3_value_text16, 0);}#endif/*** Return the column declaration type (if applicable) of the 'i'th column** of the result set of SQL statement pStmt.*/const char *sqlite3_column_decltype(sqlite3_stmt *pStmt, int N){  return columnName(pStmt, N, (const void*(*)(Mem*))sqlite3_value_text, 1);}#ifndef SQLITE_OMIT_UTF16const void *sqlite3_column_decltype16(sqlite3_stmt *pStmt, int N){  return columnName(pStmt, N, (const void*(*)(Mem*))sqlite3_value_text16, 1);}#endif /* SQLITE_OMIT_UTF16 */#if !defined(SQLITE_OMIT_ORIGIN_NAMES) && 0/*** Return the name of the database from which a result column derives.** NULL is returned if the result column is an expression or constant or** anything else which is not an unabiguous reference to a database column.*/const char *sqlite3_column_database_name(sqlite3_stmt *pStmt, int N){  return columnName(pStmt, N, (const void*(*)(Mem*))sqlite3_value_text, 2);}#ifndef SQLITE_OMIT_UTF16const void *sqlite3_column_database_name16(sqlite3_stmt *pStmt, int N){  return columnName(pStmt, N, (const void*(*)(Mem*))sqlite3_value_text16, 2);}#endif /* SQLITE_OMIT_UTF16 *//*** Return the name of the table from which a result column derives.** NULL is returned if the result column is an expression or constant or** anything else which is not an unabiguous reference to a database column.*/const char *sqlite3_column_table_name(sqlite3_stmt *pStmt, int N){  return columnName(pStmt, N, (const void*(*)(Mem*))sqlite3_value_text, 3);}#ifndef SQLITE_OMIT_UTF16const void *sqlite3_column_table_name16(sqlite3_stmt *pStmt, int N){  return columnName(pStmt, N, (const void*(*)(Mem*))sqlite3_value_text16, 3);}#endif /* SQLITE_OMIT_UTF16 *//*** Return the name of the table column from which a result column derives.** NULL is returned if the result column is an expression or constant or** anything else which is not an unabiguous reference to a database column.*/const char *sqlite3_column_origin_name(sqlite3_stmt *pStmt, int N){  return columnName(pStmt, N, (const void*(*)(Mem*))sqlite3_value_text, 4);}#ifndef SQLITE_OMIT_UTF16const void *sqlite3_column_origin_name16(sqlite3_stmt *pStmt, int N){  return columnName(pStmt, N, (const void*(*)(Mem*))sqlite3_value_text16, 4);}#endif /* SQLITE_OMIT_UTF16 */#endif /* SQLITE_OMIT_ORIGIN_NAMES *//******************************* sqlite3_bind_  ***************************** ** Routines used to attach values to wildcards in a compiled SQL statement.*//*** Unbind the value bound to variable i in virtual machine p. This is the ** the same as binding a NULL value to the column. If the "i" parameter is** out of range, then SQLITE_RANGE is returned. Othewise SQLITE_OK.**** The error code stored in database p->db is overwritten with the return** value in any case.*/static int vdbeUnbind(Vdbe *p, int i){  Mem *pVar;  if( p==0 || p->magic!=VDBE_MAGIC_RUN || p->pc>=0 ){    if( p ) sqlite3Error(p->db, SQLITE_MISUSE, 0);    return SQLITE_MISUSE;  }  if( i<1 || i>p->nVar ){    sqlite3Error(p->db, SQLITE_RANGE, 0);    return SQLITE_RANGE;  }  i--;  pVar = &p->aVar[i];  sqlite3VdbeMemRelease(pVar);  pVar->flags = MEM_Null;  sqlite3Error(p->db, SQLITE_OK, 0);  return SQLITE_OK;}/*** Bind a text or BLOB value.*/static int bindText(  sqlite3_stmt *pStmt,   int i,   const void *zData,   int nData,   void (*xDel)(void*),  int encoding){  Vdbe *p = (Vdbe *)pStmt;  Mem *pVar;  int rc;  rc = vdbeUnbind(p, i);  if( rc || zData==0 ){    return rc;  }  pVar = &p->aVar[i-1];  rc = sqlite3VdbeMemSetStr(pVar, zData, nData, encoding, xDel);  if( rc ){    return rc;  }  if( rc==SQLITE_OK && encoding!=0 ){    rc = sqlite3VdbeChangeEncoding(pVar, p->db->enc);  }  return rc;}/*** Bind a blob value to an SQL statement variable.*/int sqlite3_bind_blob(  sqlite3_stmt *pStmt,   int i,   const void *zData,   int nData,   void (*xDel)(void*)){  return bindText(pStmt, i, zData, nData, xDel, 0);}int sqlite3_bind_double(sqlite3_stmt *pStmt, int i, double rValue){  int rc;  Vdbe *p = (Vdbe *)pStmt;  rc = vdbeUnbind(p, i);  if( rc==SQLITE_OK ){    sqlite3VdbeMemSetDouble(&p->aVar[i-1], rValue);  }  return rc;}int sqlite3_bind_int(sqlite3_stmt *p, int i, int iValue){  return sqlite3_bind_int64(p, i, (i64)iValue);}int sqlite3_bind_int64(sqlite3_stmt *pStmt, int i, sqlite_int64 iValue){  int rc;  Vdbe *p = (Vdbe *)pStmt;  rc = vdbeUnbind(p, i);  if( rc==SQLITE_OK ){    sqlite3VdbeMemSetInt64(&p->aVar[i-1], iValue);  }  return rc;}int sqlite3_bind_null(sqlite3_stmt* p, int i){  return vdbeUnbind((Vdbe *)p, i);}int sqlite3_bind_text(   sqlite3_stmt *pStmt,   int i,   const char *zData,   int nData,   void (*xDel)(void*)){  return bindText(pStmt, i, zData, nData, xDel, SQLITE_UTF8);}#ifndef SQLITE_OMIT_UTF16int sqlite3_bind_text16(  sqlite3_stmt *pStmt,   int i,   const void *zData,   int nData,   void (*xDel)(void*)){  return bindText(pStmt, i, zData, nData, xDel, SQLITE_UTF16NATIVE);}#endif /* SQLITE_OMIT_UTF16 *//*** Return the number of wildcards that can be potentially bound to.** This routine is added to support DBD::SQLite.  */int sqlite3_bind_parameter_count(sqlite3_stmt *pStmt){  Vdbe *p = (Vdbe*)pStmt;  return p ? p->nVar : 0;}/*** Create a mapping from variable numbers to variable names** in the Vdbe.azVar[] array, if such a mapping does not already** exist.*/static void createVarMap(Vdbe *p){  if( !p->okVar ){    int j;    Op *pOp;    for(j=0, pOp=p->aOp; j<p->nOp; j++, pOp++){      if( pOp->opcode==OP_Variable ){        assert( pOp->p1>0 && pOp->p1<=p->nVar );        p->azVar[pOp->p1-1] = pOp->p3;      }    }    p->okVar = 1;  }}/*** Return the name of a wildcard parameter.  Return NULL if the index** is out of range or if the wildcard is unnamed.**** The result is always UTF-8.*/const char *sqlite3_bind_parameter_name(sqlite3_stmt *pStmt, int i){  Vdbe *p = (Vdbe*)pStmt;  if( p==0 || i<1 || i>p->nVar ){    return 0;  }  createVarMap(p);  return p->azVar[i-1];}/*** Given a wildcard parameter name, return the index of the variable** with that name.  If there is no variable with the given name,** return 0.*/int sqlite3_bind_parameter_index(sqlite3_stmt *pStmt, const char *zName){  Vdbe *p = (Vdbe*)pStmt;  int i;  if( p==0 ){    return 0;  }  createVarMap(p);   if( zName ){    for(i=0; i<p->nVar; i++){      const char *z = p->azVar[i];      if( z && strcmp(z,zName)==0 ){        return i+1;      }    }  }  return 0;}/*** Transfer all bindings from the first statement over to the second.** If the two statements contain a different number of bindings, then** an SQLITE_ERROR is returned.*/int sqlite3_transfer_bindings(sqlite3_stmt *pFromStmt, sqlite3_stmt *pToStmt){  Vdbe *pFrom = (Vdbe*)pFromStmt;  Vdbe *pTo = (Vdbe*)pToStmt;  int i, rc = SQLITE_OK;  if( (pFrom->magic!=VDBE_MAGIC_RUN && pFrom->magic!=VDBE_MAGIC_HALT)    || (pTo->magic!=VDBE_MAGIC_RUN && pTo->magic!=VDBE_MAGIC_HALT) ){    return SQLITE_MISUSE;  }  if( pFrom->nVar!=pTo->nVar ){    return SQLITE_ERROR;  }  for(i=0; rc==SQLITE_OK && i<pFrom->nVar; i++){    rc = sqlite3VdbeMemMove(&pTo->aVar[i], &pFrom->aVar[i]);  }  return rc;}/*** Return the sqlite3* database handle to which the prepared statement given** in the argument belongs.  This is the same database handle that was** the first argument to the sqlite3_prepare() that was used to create** the statement in the first place.*/sqlite3 *sqlite3_db_handle(sqlite3_stmt *pStmt){  return pStmt ? ((Vdbe*)pStmt)->db : 0;}