自学教程：C++ sqlite3_data_count函数代码示例

ECode CStmt::ColumnBytes(    /* [in] */ Int32 col,    /* [out, callee] */ ArrayOf<unsigned char>** array){    VALIDATE_NOT_NULL(array);#if HAVE_SQLITE3 && HAVE_SQLITE_COMPILE    hvm *v = (hvm *)mHandle;    if (v && v->vm && v->h) {        Int32 ncol = sqlite3_data_count((sqlite3_stmt *) v->vm);        Int32 nbytes = 0;        const unsigned char *data = NULL;        if (col < 0 || col >= ncol) {            *array = NULL;            return E_ILLEGAL_ARGUMENT_EXCEPTION;        }        data = (const unsigned char *)sqlite3_column_blob((sqlite3_stmt *) v->vm, col);        if (data) {            nbytes = sqlite3_column_bytes((sqlite3_stmt *) v->vm, col);        } else {            *array = NULL;            return E_SQL_EXCEPTION;        }        AutoPtr<ArrayOf<unsigned char> > outchar = ArrayOf<unsigned char>::Alloc(nbytes);        outchar->Copy(data,nbytes);        *array = outchar;    } else {        return E_NULL_POINTER_EXCEPTION;    }#else    return E_SQL_FEATURE_NOT_SUPPORTED_EXCEPTION;#endif    return NOERROR;}

static int pdo_sqlite_stmt_get_col(pdo_stmt_t *stmt, int colno, char **ptr, zend_ulong *len, int *caller_frees){	pdo_sqlite_stmt *S = (pdo_sqlite_stmt*)stmt->driver_data;	if (!S->stmt) {		return 0;	}	if(colno >= sqlite3_data_count(S->stmt)) {		/* error invalid column */		pdo_sqlite_error_stmt(stmt);		return 0;	}	switch (sqlite3_column_type(S->stmt, colno)) {		case SQLITE_NULL:			*ptr = NULL;			*len = 0;			return 1;		case SQLITE_BLOB:			*ptr = (char*)sqlite3_column_blob(S->stmt, colno);			*len = sqlite3_column_bytes(S->stmt, colno);			return 1;		default:			*ptr = (char*)sqlite3_column_text(S->stmt, colno);			*len = sqlite3_column_bytes(S->stmt, colno);			return 1;	}}

bool PDOSqliteStatement::getColumnMeta(int64_t colno, Array &ret) {  if (!m_stmt) {    return false;  }  if (colno >= sqlite3_data_count(m_stmt)) {    /* error invalid column */    handleError(__FILE__, __LINE__);    return false;  }  ret = Array::Create();  Array flags = Array::Create();  switch (sqlite3_column_type(m_stmt, colno)) {  case SQLITE_NULL:    ret.set(s_native_type, s_null);    break;  case SQLITE_FLOAT:   ret.set(s_native_type, s_double);  break;  case SQLITE_BLOB:    flags.append(s_blob);  case SQLITE_TEXT:    ret.set(s_native_type, s_string);  break;  case SQLITE_INTEGER: ret.set(s_native_type, s_integer); break;  }  const char *str = sqlite3_column_decltype(m_stmt, colno);  if (str) {    ret.set(s_sqlite_decl_type, String((char *)str, CopyString));  }#ifdef SQLITE_ENABLE_COLUMN_METADATA  str = sqlite3_column_table_name(m_stmt, colno);  if (str) {    ret.set(s_table, String((char *)str, CopyString));  }#endif  ret.set(s_flags, flags);  return true;}

//取得Magic* MagicManager::getById(int id){    std::string sql = "SELECT * FROM " + getTableName() + " WHERE id = ?";    const char *pzTest;    sqlite3_prepare_v2(_db, sql.c_str(), strlen(sql.c_str()), &_stmt, &pzTest);        sqlite3_bind_int(_stmt, 1, id);    sqlite3_step(_stmt);        auto magic = Magic::getInstance();        if(sqlite3_data_count(_stmt)){        magic->setId(sqlite3_column_int(_stmt, 0));        magic->setRank(sqlite3_column_int(_stmt, 1));        magic->setName((char*)sqlite3_column_text(_stmt, 2));        magic->setParamAttack(sqlite3_column_int(_stmt, 3));        magic->setParamCure(sqlite3_column_int(_stmt, 4));        magic->setParamStan(sqlite3_column_int(_stmt, 5));    }        sqlite3_reset(_stmt);    sqlite3_clear_bindings(_stmt);    sqlite3_finalize(_stmt);        return magic;}

static int pdo_sqlite_stmt_execute(pdo_stmt_t *stmt){	pdo_sqlite_stmt *S = (pdo_sqlite_stmt*)stmt->driver_data;	if (stmt->executed && !S->done) {		sqlite3_reset(S->stmt);	}	S->done = 0;	switch (sqlite3_step(S->stmt)) {		case SQLITE_ROW:			S->pre_fetched = 1;			stmt->column_count = sqlite3_data_count(S->stmt);			return 1;		case SQLITE_DONE:			stmt->column_count = sqlite3_column_count(S->stmt);			stmt->row_count = sqlite3_changes(S->H->db);			sqlite3_reset(S->stmt);			S->done = 1;			return 1;		case SQLITE_ERROR:			sqlite3_reset(S->stmt);		case SQLITE_MISUSE:		case SQLITE_BUSY:		default:			pdo_sqlite_error_stmt(stmt);			return 0;	}}

bool PDOSqliteStatement::executer() {  if (executed && !m_done) {    sqlite3_reset(m_stmt);  }  m_done = 0;  switch (sqlite3_step(m_stmt)) {  case SQLITE_ROW:    m_pre_fetched = 1;    column_count = sqlite3_data_count(m_stmt);    return true;  case SQLITE_DONE:    column_count = sqlite3_column_count(m_stmt);    row_count = sqlite3_changes(m_db);    sqlite3_reset(m_stmt);    m_done = 1;    return true;  case SQLITE_ERROR:    sqlite3_reset(m_stmt);  case SQLITE_MISUSE:  case SQLITE_BUSY:  default:    handleError(__FILE__, __LINE__);    return false;  }}

int osux_database_exec_prepared_query(osux_database *db, osux_list *query_result){    int ret = sqlite3_step(db->prepared_query);    while (ret != SQLITE_DONE) {        if (ret != SQLITE_ROW) {            osux_debug("%s/n", sqlite3_errmsg(get_handle(db)));            sqlite3_reset(db->prepared_query);            sqlite3_clear_bindings(db->prepared_query);            return -OSUX_ERR_DATABASE;        }        osux_hashtable *dict = osux_hashtable_new(0);        int col_count = sqlite3_data_count(db->prepared_query);        for (int i = 0; i < col_count; ++i) {            char const *col_text;            col_text = (char const*) sqlite3_column_text(db->prepared_query, i);            if (col_text != NULL) {                char const *col_name = sqlite3_column_name(db->prepared_query, i);                osux_hashtable_insert(dict, col_name, g_strdup(col_text));            }        }        osux_list_append(query_result, dict);        ret = sqlite3_step(db->prepared_query);    }    sqlite3_reset(db->prepared_query);    sqlite3_clear_bindings(db->prepared_query);    return 0;}

int SQLiteStatement::columnCount(){    ASSERT(m_isPrepared);    if (!m_statement)        return 0;    return sqlite3_data_count(m_statement);}

int sqlite3_data_count_idr(void* db){		DBinfo* dbi =(DBinfo*) db;	int rc = sqlite3_data_count(dbi->ppStmt);		return rc;}

void SqliteCursor::drv_getNextRecord(){    int res = sqlite3_step(d->prepared_st_handle);    if (res == SQLITE_ROW) {        m_fetchResult = FetchOK;        m_fieldCount = sqlite3_data_count(d->prepared_st_handle);//#else //for SQLITE3 data fetching is delayed. Now we even do not take field count information//      // -- just set a flag that we've a data not fetched but available        m_fieldsToStoreInRecord = m_fieldCount;    }    else {        if (res == SQLITE_DONE) {            m_fetchResult = FetchEnd;        } else {            m_result.setServerErrorCode(res);            m_fetchResult = FetchError;        }    }    //debug    /*      if ((int)m_result == (int)FetchOK && d->curr_coldata) {        for (int i=0;i<m_fieldCount;i++) {          sqliteDebug()<<"col."<< i<<": "<< d->curr_colname[i]<<" "<< d->curr_colname[m_fieldCount+i]          << " = " << (d->curr_coldata[i] ? QString::fromLocal8Bit(d->curr_coldata[i]) : "(NULL)");        }    //  sqliteDebug() << m_fieldCount << "col(s) fetched";      }*/}

bool PDOSqliteStatement::getColumn(int colno, Variant &value) {  if (!m_stmt) {    return false;  }  if (colno >= sqlite3_data_count(m_stmt)) {    /* error invalid column */    handleError(__FILE__, __LINE__);    return false;  }  char *ptr; int len;  switch (sqlite3_column_type(m_stmt, colno)) {  case SQLITE_NULL:    ptr = NULL;    len = 0;    break;  case SQLITE_BLOB:    ptr = (char*)sqlite3_column_blob(m_stmt, colno);    len = sqlite3_column_bytes(m_stmt, colno);    break;  case SQLITE3_TEXT:    ptr = (char*)sqlite3_column_text(m_stmt, colno);    len = sqlite3_column_bytes(m_stmt, colno);    break;  default:    ptr = (char*)sqlite3_column_text(m_stmt, colno);    len = sqlite3_column_bytes(m_stmt, colno);    break;  }  value = String(ptr, len, CopyString);  return true;}

Variant c_SQLite3::t_querysingle(CStrRef sql, bool entire_row /* = false */) {  INSTANCE_METHOD_INJECTION_BUILTIN(SQLite3, SQLite3::querysingle);  validate();  if (!sql.empty()) {    Variant stmt = t_prepare(sql);    if (!same(stmt, false)) {      sqlite3_stmt *pstmt =        stmt.toObject().getTyped<c_SQLite3Stmt>()->m_raw_stmt;      switch (sqlite3_step(pstmt)) {      case SQLITE_ROW: /* Valid Row */        if (entire_row) {          Array ret = Array::Create();          for (int i = 0; i < sqlite3_data_count(pstmt); i++) {            ret.set(String((char*)sqlite3_column_name(pstmt, i), CopyString),                    get_column_value(pstmt, i));          }          return ret;        }        return get_column_value(pstmt, 0);      case SQLITE_DONE: /* Valid but no results */        if (entire_row) {          return Array::Create();        } else {          return null;        }      default:        raise_warning("Unable to execute statement: %s",                      sqlite3_errmsg(m_raw_db));      }    }  }  return false;}

voidload_statement(sqlite3_stmt *stmt, Row_t *row, Table_t *table){	guint32 i, max;	if (table->header.list.count <= 0) /* Lazy header loading */		load_table_header(stmt, table);	if (!row->fields) /* Lazy memory allocation */		row->fields = calloc(1, sizeof(struct RowFieldSequence));	for (i=0,max=sqlite3_data_count(stmt); i<max ;i++) {		struct RowField *rf = calloc(1, sizeof(*rf));		asn_uint32_to_INTEGER(&(rf->pos), i);		rf->value.present = RowFieldValue_PR_n;		switch (sqlite3_column_type(stmt, i)) {			case SQLITE_NULL:				rf->value.present = RowFieldValue_PR_n;				break;			case SQLITE_INTEGER:				do {					gint64 i64 = sqlite3_column_int64(stmt, i);					asn_int64_to_INTEGER(&(rf->value.choice.i), i64);					rf->value.present = RowFieldValue_PR_i;				} while (0);				break;			case SQLITE_FLOAT:				do {					gdouble d = sqlite3_column_double(stmt, i);					asn_double2REAL(&(rf->value.choice.f), d);					rf->value.present = RowFieldValue_PR_f;				} while (0);				break;			case SQLITE_TEXT:				do {					const guint8 *t = sqlite3_column_text(stmt, i);					gsize tsize = sqlite3_column_bytes(stmt, i);					OCTET_STRING_fromBuf(&(rf->value.choice.s), (char*)t, tsize);					rf->value.present = RowFieldValue_PR_s;				} while (0);				break;			case SQLITE_BLOB:				do {					const void *b = sqlite3_column_blob(stmt, i);					gsize bsize = sqlite3_column_bytes(stmt, i);					OCTET_STRING_fromBuf(&(rf->value.choice.b), (char*)b, bsize);					rf->value.present = RowFieldValue_PR_b;				} while (0);				break;			default:				rf->value.present = RowFieldValue_PR_n;				break;		}		asn_sequence_add(&(row->fields->list), rf);	}}

/************************************************************************* * *	Function: sql_num_rows * *	Purpose: database specific num_rows. Returns number of rows in *               query * *************************************************************************/static int sql_num_rows(SQLSOCK * sqlsocket, UNUSED SQL_CONFIG *config){	rlm_sql_sqlite_sock *sqlite_sock = sqlsocket->conn;		if (sqlite_sock->pStmt)		return sqlite3_data_count(sqlite_sock->pStmt);		return 0;}

/*** Check to see if column iCol of the given statement is valid.  If** it is, return a pointer to the Mem for the value of that column.** If iCol is not valid, return a pointer to a Mem which has a value** of NULL.*/static Mem *columnMem(sqlite3_stmt *pStmt, int i){  Vdbe *pVm = (Vdbe *)pStmt;  int vals = sqlite3_data_count(pStmt);  if( i>=vals || i<0 ){    static const Mem nullMem = {{0}, 0.0, "", 0, MEM_Null, MEM_Null };    sqlite3Error(pVm->db, SQLITE_RANGE, 0);    return (Mem*)&nullMem;  }  return &pVm->pTos[(1-vals)+i];}

/*** Check to see if column iCol of the given statement is valid.  If** it is, return a pointer to the Mem for the value of that column.** If iCol is not valid, return a pointer to a Mem which has a value** of NULL.*/static Mem *columnMem(sqlite3_stmt *pStmt, int i){  Vdbe *pVm = (Vdbe *)pStmt;  int vals = sqlite3_data_count(pStmt);  if( i>=vals || i<0 ){    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];}

static int pdo_sqlite_stmt_col_meta(pdo_stmt_t *stmt, zend_long colno, zval *return_value){	pdo_sqlite_stmt *S = (pdo_sqlite_stmt*)stmt->driver_data;	const char *str;	zval flags;	if (!S->stmt) {		return FAILURE;	}	if(colno >= sqlite3_data_count(S->stmt)) {		/* error invalid column */		pdo_sqlite_error_stmt(stmt);		return FAILURE;	}	array_init(return_value);	array_init(&flags);	switch (sqlite3_column_type(S->stmt, colno)) {		case SQLITE_NULL:			add_assoc_string(return_value, "native_type", "null");			break;		case SQLITE_FLOAT:			add_assoc_string(return_value, "native_type", "double");			break;		case SQLITE_BLOB:			add_next_index_string(&flags, "blob");		case SQLITE_TEXT:			add_assoc_string(return_value, "native_type", "string");			break;		case SQLITE_INTEGER:			add_assoc_string(return_value, "native_type", "integer");			break;	}	str = sqlite3_column_decltype(S->stmt, colno);	if (str) {		add_assoc_string(return_value, "sqlite:decl_type", (char *)str);	}#ifdef SQLITE_ENABLE_COLUMN_METADATA	str = sqlite3_column_table_name(S->stmt, colno);	if (str) {		add_assoc_string(return_value, "table", (char *)str);	}#endif	add_assoc_zval(return_value, "flags", &flags);	return SUCCESS;}

SWIGEXPORT jint JNICALL Java_com_almworks_sqlite4java__1SQLiteSwiggedJNI_sqlite3_1data_1count(JNIEnv *jenv, jclass jcls, jlong jarg1) {  jint jresult = 0 ;  sqlite3_stmt *arg1 = (sqlite3_stmt *) 0 ;  int result;    (void)jenv;  (void)jcls;  arg1 = *(sqlite3_stmt **)&jarg1;   result = (int)sqlite3_data_count(arg1);  jresult = (jint)result;   return jresult;}

jint JNICALL Java_com_baidu_javalite_PrepareStmt_sqlite3_1data_1count(        JNIEnv *env, jclass cls, jlong handle){  if (handle == 0)  {    throwSqliteException(env, "handle is NULL");    return 0;  }  sqlite3_stmt* stmt = (sqlite3_stmt*) handle;  return sqlite3_data_count(stmt);}

static voidload_table_header(sqlite3_stmt *stmt, Table_t *t){	guint32 i, max;	for (i=0,max=sqlite3_data_count(stmt); i<max ;i++) {		const char *cname = sqlite3_column_name(stmt, i);		struct RowName *rname = calloc(1, sizeof(*rname));		asn_uint32_to_INTEGER(&(rname->pos), i);		OCTET_STRING_fromBuf(&(rname->name), cname, strlen(cname));		asn_sequence_add(&(t->header.list), rname);	}}

static int echoColumn(sqlite3_vtab_cursor *cur, sqlite3_context *ctx, int i){  int iCol = i + 1;  sqlite3_stmt *pStmt = ((echo_cursor *)cur)->pStmt;  if( simulateVtabError((echo_vtab *)(cur->pVtab), "xColumn") ){    return SQLITE_ERROR;  }  if( !pStmt ){    sqlite3_result_null(ctx);  }else{    assert( sqlite3_data_count(pStmt)>iCol );    sqlite3_result_value(ctx, sqlite3_column_value(pStmt, iCol));  }  return SQLITE_OK;}

void DBBrowserDB::getTableRecords( const QString & tablename ){    sqlite3_stmt *vm;    const char *tail;    int ncol;    QStringList r;    // char *errmsg;    int err=0;    // int tabnum = 0;    browseRecs.clear();    idmap.clear();    lastErrorMessage = QString("no error");    QString statement = "SELECT rowid, *  FROM ";    statement.append( GetEncodedQString(tablename) );    statement.append(" ORDER BY rowid; ");//qDebug(statement);    logSQL(statement, kLogMsg_App);    err=sqlite3_prepare(_db,statement,statement.length(),                        &vm, &tail);    if (err == SQLITE_OK) {        int rownum = 0;        while ( sqlite3_step(vm) == SQLITE_ROW ) {            r.clear();            ncol = sqlite3_data_count(vm);            for (int e=0; e<ncol; e++) {                char * strresult = 0;                QString rv;                strresult = (char *) sqlite3_column_text(vm, e);                rv = QString(strresult);                r << GetDecodedQString(rv);                if (e==0) {                    idmap.insert(rv.toInt(),rownum);                    rownum++;                }            }            browseRecs.append(r);        }        sqlite3_finalize(vm);    } else {        lastErrorMessage = QString ("could not get fields");    }}

QStringList SqliteTableModel::getColumns(const QString sQuery){    sqlite3_stmt* stmt;    QByteArray utf8Query = sQuery.toUtf8();    int status = sqlite3_prepare_v2(m_db->_db, utf8Query, utf8Query.size(), &stmt, NULL);    QStringList listColumns;    if(SQLITE_OK == status)    {        status = sqlite3_step(stmt);        int columns = sqlite3_data_count(stmt);        for(int i = 0; i < columns; ++i)            listColumns.append(QString::fromUtf8((const char*)sqlite3_column_name(stmt, i)));    }    sqlite3_finalize(stmt);    return listColumns;}

static JSBooljs_db_step(JSContext *cx, JSObject *obj, uintN argc,           jsval *argv, jsval *rval){    js_db_t *jd = JS_GetPrivate(cx, obj);    if(js_db_check(cx, jd))        return JS_FALSE;    if(jd->jd_stmt == NULL) {        *rval = JSVAL_NULL;    } else if(jd->jd_step_rc == SQLITE_ROW) {        int cols = sqlite3_data_count(jd->jd_stmt);        int i;        JSObject *r = JS_NewObjectWithGivenProto(cx, NULL, NULL, obj);        *rval = OBJECT_TO_JSVAL(r);        if(!JS_EnterLocalRootScope(cx))            return JS_FALSE;        for(i = 0; i < cols; i++) {            const char *cn = sqlite3_column_name(jd->jd_stmt, i);            switch(sqlite3_column_type(jd->jd_stmt, i)) {            case SQLITE_INTEGER:                js_set_prop_int(cx, r, cn, sqlite3_column_int(jd->jd_stmt, i));                break;            case SQLITE_TEXT:                js_set_prop_str(cx, r, cn,                                (const char *)sqlite3_column_text(jd->jd_stmt, i));                break;            case SQLITE_FLOAT:                js_set_prop_dbl(cx, r, cn, sqlite3_column_double(jd->jd_stmt, i));                break;            }        }        JS_LeaveLocalRootScope(cx);        return js_stmt_step(cx, jd, rval);    }    *rval = JSVAL_FALSE;    return JS_TRUE;}

void SqliteTableModel::setQuery(const QString& sQuery, bool dontClearHeaders){    // clear    if(!dontClearHeaders)    {        m_mWhere.clear();        m_headers.clear();    }    if(!m_db->isOpen())        return;    m_sQuery = removeComments(sQuery).trimmed();    // do a count query to get the full row count in a fast manner    m_rowCount = getQueryRowCount();    if(m_rowCount == -1)    {        m_valid = false;        return;    }    // headers    if(!dontClearHeaders)    {        sqlite3_stmt* stmt;        QByteArray utf8Query = sQuery.toUtf8();        int status = sqlite3_prepare_v2(m_db->_db, utf8Query, utf8Query.size(), &stmt, NULL);        if(SQLITE_OK == status)        {            status = sqlite3_step(stmt);            int columns = sqlite3_data_count(stmt);            for(int i = 0; i < columns; ++i)                m_headers.append(QString::fromUtf8((const char*)sqlite3_column_name(stmt, i)));        }        sqlite3_finalize(stmt);    }    // now fetch the first entries    clearCache();    fetchData(0, m_chunkSize);    m_valid = true;    emit layoutChanged();}

/* * mode: 0 = direct, 1 = integer, 2 = alphanumeric */static int l_sqlite3_row_mode(lua_State * L, int mode){  /* Old code / Just a reminder / To be removed:   ** checkargs(L, 1, 2, CHECK_PTR, CHECK_NILTABLE, 0);  */    sqlite3_stmt * stmt	= checkstmt_stmt(L, 1);  int num_columns	= sqlite3_data_count(stmt);	/* Maybe wrong state, so don't use sqlite3_column_count */  int index;    /* XXX Should really be cleaned up... Fixme! */    if (mode == 0)    lua_checkstack(L, num_columns);  else    if (!lua_istable(L, -1))      lua_newtable(L);    for (index=0; index<num_columns; index++)    switch(mode)    {      case 0:	/* direct mode */        push_column(L, stmt, index);        break;            case 1:	/* integer mode */        push_column(L, stmt, index);        lua_rawseti(L, -2, index+1);        break;            case 2:	/* alphanumeric mode */        lua_pushstring(L, sqlite3_column_name(stmt, index));        push_column(L, stmt, index);        lua_rawset(L, -3);        break;            default:        report_error(L, "libluasqlite3: Internal error in sqlite3_row_mode");    }    if (mode)    return 1;  else    return num_columns;}

/*** This procedure runs in the thread to step the virtual machine.*/static void do_step(Thread *p){  int i;  if( p->pStmt==0 ){    p->zErr = p->zStaticErr = "no virtual machine available";    p->rc = SQLITE_ERROR;    return;  }  p->rc = sqlite3_client_step(p->pStmt);  if( p->rc==SQLITE_ROW ){    p->argc = sqlite3_column_count(p->pStmt);    for(i=0; i<sqlite3_data_count(p->pStmt); i++){      p->argv[i] = (char*)sqlite3_column_text(p->pStmt, i);    }    for(i=0; i<p->argc; i++){      p->colv[i] = sqlite3_column_name(p->pStmt, i);    }  }}

static intes_sqlite_step(duk_context *ctx){    es_sqlite_t *es = es_resource_get(ctx, 0, &es_resource_sqlite);    if(es->es_stmt == NULL) {        duk_push_null(ctx);        return 1;    }    const int cols = sqlite3_data_count(es->es_stmt);    duk_push_object(ctx);    for(int i = 0; i < cols; i++) {        int64_t i64;        switch(sqlite3_column_type(es->es_stmt, i)) {        case SQLITE_INTEGER:            i64 = sqlite3_column_int64(es->es_stmt, i);            if(i64 >= INT32_MIN && i64 <= INT32_MAX)                duk_push_int(ctx, i64);            else if(i64 >= 0 && i64 <= UINT32_MAX)                duk_push_uint(ctx, i64);            else                duk_push_number(ctx, i64);            break;        case SQLITE_TEXT:            duk_push_string(ctx, (const char *)sqlite3_column_text(es->es_stmt, i));            break;        case SQLITE_FLOAT:            duk_push_number(ctx, sqlite3_column_double(es->es_stmt, i));            break;        default:            continue;        }        duk_put_prop_string(ctx, -2, sqlite3_column_name(es->es_stmt, i));    }    es_sqlite_stmt_step(ctx, es);    return 1;}

/*** Check to see if column iCol of the given statement is valid.  If** it is, return a pointer to the Mem for the value of that column.** If iCol is not valid, return a pointer to a Mem which has a value** of NULL.*/static Mem *columnMem(sqlite3_stmt *pStmt, int i){  Vdbe *pVm;  int vals;  Mem *pOut;  pVm = (Vdbe *)pStmt;  if( pVm && pVm->pResultSet!=0 && i<pVm->nResColumn && i>=0 ){    sqlite3_mutex_enter(pVm->db->mutex);    vals = sqlite3_data_count(pStmt);    pOut = &pVm->pResultSet[i];  }else{    static const Mem nullMem = {{0}, 0.0, 0, "", 0, MEM_Null, SQLITE_NULL, 0, 0, 0 };    if( pVm->db ){      sqlite3_mutex_enter(pVm->db->mutex);      sqlite3Error(pVm->db, SQLITE_RANGE, 0);    }    pOut = (Mem*)&nullMem;  }  return pOut;}