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"; }*/ }
ECode CStmt::ColumnString( /* [in] */ Int32 col, /* [out] */ String* str) { VALIDATE_NOT_NULL(str); #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 char *data = NULL; if (col < 0 || col >= ncol) { return E_ILLEGAL_ARGUMENT_EXCEPTION; } data = (const char *)sqlite3_column_text((sqlite3_stmt *) v->vm, col); if (data) { nbytes = sqlite3_column_bytes((sqlite3_stmt *) v->vm, col); } else { *str = String(NULL); return E_SQL_EXCEPTION; } *str = String((char *)data); } else { return E_NULL_POINTER_EXCEPTION; } #else return E_SQL_FEATURE_NOT_SUPPORTED_EXCEPTION; #endif return NOERROR; }
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; }
void load_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 void load_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 JSBool js_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 int es_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; }