bool Statement::GetInt(unsigned int Column, Nullable<int> &Out) { if (Inner == nullptr) return false; if (sqlite3_column_type(Inner, Column) == SQLITE_NULL) { Out = Nullable<int>(); return true; } Out = Nullable<int>(sqlite3_column_int(Inner, Column)); return true; }
bool Statement::GetString(unsigned int Column, Nullable<std::string> &Out) { if (Inner == nullptr) return false; if (sqlite3_column_type(Inner, Column) == SQLITE_NULL) { Out = Nullable<std::string>(); return true; } Out = Nullable<std::string>(std::string(reinterpret_cast<const char *>(sqlite3_column_text(Inner, Column)))); return true; }
void sqlite_table::retrieve_data(sqlite3_stmt* stmt) { tu_autolock locker(s_sqlite_plugin_mutex); int col_count = sqlite3_column_count(stmt); m_title.resize(col_count); for (int i = 0; i < col_count; i++) { m_title[i] = sqlite3_column_name(stmt, i); } int rc; do { as_object* row = new as_object(get_player()); m_data.push_back(row); for (int i = 0; i < col_count; i++) { as_value val; int col_type = sqlite3_column_type(stmt, i); switch (col_type) { case SQLITE_INTEGER : val.set_int(sqlite3_column_int(stmt, i)); break; case SQLITE_FLOAT : val.set_double(sqlite3_column_double(stmt, i)); break; case SQLITE_BLOB : // FIXME: val.set_string((const char*) sqlite3_column_blob(stmt, i)); break; case SQLITE_NULL : // val.set_null(); val.set_string(""); break; case SQLITE3_TEXT : val.set_string((const char*) sqlite3_column_text(stmt, i)); break; default: assert(0); break; } row->set_member(m_title[i], val); } rc = sqlite3_step(stmt); } while (rc == SQLITE_ROW); }
static krb5_error_code KRB5_CALLCONV scc_get_principal(krb5_context context, krb5_ccache id, krb5_principal *principal) { krb5_scache *s = SCACHE(id); krb5_error_code ret; const char *str; *principal = NULL; ret = make_database(context, s); if (ret) return ret; sqlite3_bind_int(s->scache, 1, s->cid); if (sqlite3_step(s->scache) != SQLITE_ROW) { sqlite3_reset(s->scache); krb5_set_error_message(context, KRB5_CC_END, N_("No principal for cache SCC:%s:%s", ""), s->name, s->file); return KRB5_CC_END; } if (sqlite3_column_type(s->scache, 0) != SQLITE_TEXT) { sqlite3_reset(s->scache); krb5_set_error_message(context, KRB5_CC_END, N_("Principal data of wrong type " "for SCC:%s:%s", ""), s->name, s->file); return KRB5_CC_END; } str = (const char *)sqlite3_column_text(s->scache, 0); if (str == NULL) { sqlite3_reset(s->scache); krb5_set_error_message(context, KRB5_CC_END, N_("Principal not set for SCC:%s:%s", ""), s->name, s->file); return KRB5_CC_END; } ret = krb5_parse_name(context, str, principal); sqlite3_reset(s->scache); return ret; }
bool sqlite_db::step() { if(!_stmt) return false; sqlite3_stmt* stmt=(sqlite3_stmt*)_stmt; int ret=sqlite3_step(stmt); if(ret==SQLITE_DONE) { if(sqlite3_column_count(stmt)) _array_res.push_back(sqlite_res()); // check if the statement will produce resultset, add a blank even if no rows to keep consistent return true; } if(ret!=SQLITE_ROW) { _err_msg=(const wchar_t*)sqlite3_errmsg16((sqlite3*)_handle); return false; } if(ret==SQLITE_ROW) _array_res.push_back(sqlite_res()); sqlite_res& res=*(_array_res.end()-1); int row=0; while(ret==SQLITE_ROW) { res._res.push_back(vector<sqlite_res::VALUE>()); int i; int count=sqlite3_column_count(stmt); for(i=0;i<count;++i) { res._res[row].push_back(sqlite_res::VALUE()); int type=sqlite3_column_type(stmt,i); if(type==SQLITE_NULL) continue; if(type==SQLITE_BLOB) { if(!sqlite3_column_bytes(stmt,i)) continue; vector<char>& blob=res._res[row][i].blob; blob.resize(sqlite3_column_bytes(stmt,i)); memcpy(&blob[0],sqlite3_column_blob(stmt,i),sqlite3_column_bytes(stmt,i)); continue; } res._res[row][i].text=(const wchar_t*)sqlite3_column_text16(stmt,i); } ++row; ret=sqlite3_step(stmt); } return true; }
void genGateKeeperApprovedAppRow(sqlite3_stmt* const stmt, Row& r) { for (int i = 0; i < sqlite3_column_count(stmt); i++) { auto column_name = std::string(sqlite3_column_name(stmt, i)); auto column_type = sqlite3_column_type(stmt, i); if (column_type == SQLITE_TEXT) { auto value = sqlite3_column_text(stmt, i); if (value != nullptr) { r[column_name] = std::string(reinterpret_cast<const char*>(value)); } } else if (column_type == SQLITE_FLOAT) { auto value = sqlite3_column_double(stmt, i); r[column_name] = DOUBLE(value); } } }
void genPkgRow(sqlite3_stmt* stmt, Row& r) { for (int i = 0; i < sqlite3_column_count(stmt); i++) { auto column_name = std::string(sqlite3_column_name(stmt, i)); auto column_type = sqlite3_column_type(stmt, i); if (column_type == SQLITE_TEXT) { auto value = sqlite3_column_text(stmt, i); if (value != nullptr) { r[column_name] = std::string((const char*)value); } } else if (column_type == SQLITE_INTEGER) { auto value = sqlite3_column_int(stmt, i); r[column_name] = INTEGER(value); } } }
ResultSet::FieldType SQLiteResult::fieldType(int field) { if (field>num_fields) throw FieldNotInResultSetException("%d",field); if (!stmt) throw NoResultException(); if (last_res!=SQLITE_ROW) throw NoResultException(); int type=sqlite3_column_type(stmt, field); switch (type) { case SQLITE_INTEGER: return ResultSet::TYPE_INTEGER; case SQLITE_FLOAT: return ResultSet::TYPE_FLOAT; case SQLITE_BLOB: return ResultSet::TYPE_BINARY; case SQLITE_NULL: return ResultSet::TYPE_INTEGER; case SQLITE_TEXT: return ResultSet::TYPE_STRING; } return ResultSet::TYPE_UNKNOWN; }
QVariant QgsSpatiaLiteFeatureIterator::getFeatureAttribute( sqlite3_stmt* stmt, int ic, const QVariant::Type& type ) { if ( sqlite3_column_type( stmt, ic ) == SQLITE_INTEGER ) { // INTEGER value return sqlite3_column_int( stmt, ic ); } if ( sqlite3_column_type( stmt, ic ) == SQLITE_FLOAT ) { // DOUBLE value return sqlite3_column_double( stmt, ic ); } if ( sqlite3_column_type( stmt, ic ) == SQLITE_TEXT ) { // TEXT value const char *txt = ( const char * ) sqlite3_column_text( stmt, ic ); return QString::fromUtf8( txt ); } // assuming NULL return QVariant( type ); }
void QSpatiaLiteResultPrivate::initColumns(bool emptyResultset) { int nCols = sqlite3_column_count(stmt); if (nCols <= 0) return; q->init(nCols); for (int i = 0; i < nCols; ++i) { QString colName = QString::fromUtf16( (const ushort *) sqlite3_column_name16(stmt, i) ).remove(QLatin1Char('"')); // must use typeName for resolving the type to match QSqliteDriver::record QString typeName = QString::fromUtf16( (const ushort *) sqlite3_column_decltype16(stmt, i) ); // sqlite3_column_type is documented to have undefined behavior if the result set is empty int stp = emptyResultset ? -1 : sqlite3_column_type(stmt, i); QVariant::Type fieldType; if (!typeName.isEmpty()) { fieldType = qGetColumnType(typeName); } else { // Get the proper type for the field based on stp value switch (stp) { case SQLITE_INTEGER: fieldType = QVariant::Int; break; case SQLITE_FLOAT: fieldType = QVariant::Double; break; case SQLITE_BLOB: fieldType = QVariant::ByteArray; break; case SQLITE_TEXT: fieldType = QVariant::String; break; case SQLITE_NULL: default: fieldType = QVariant::Invalid; break; } } int dotIdx = colName.lastIndexOf(QLatin1Char('.')); QSqlField fld(colName.mid(dotIdx == -1 ? 0 : dotIdx + 1), fieldType); fld.setSqlType(stp); rInf.append(fld); } }
char *cws_query2json (char *dbfile, char *stmt) { int i; const char *aux; char *json; json_object *root; json_object *array; sqlite3 *db; sqlite3_stmt *pp; sqlite3_open (dbfile, &db); sqlite3_prepare (db, stmt, strlen (stmt), &pp, NULL); array = json_object_new_array (); while (sqlite3_step (pp) == SQLITE_ROW) { int ncol = sqlite3_column_count (pp); json_object *row = json_object_new_object (); for (i = 0; i < ncol; i++) { json_object *col = NULL; switch (sqlite3_column_type (pp, i)) { case SQLITE_FLOAT : col = json_object_new_double (sqlite3_column_double (pp, i)); break; case SQLITE_INTEGER : col = json_object_new_int (sqlite3_column_int (pp, i)); break; case SQLITE_TEXT : col = json_object_new_string ((char *) sqlite3_column_text (pp, i)); break; } json_object_object_add (row, sqlite3_column_name (pp, i), col); } json_object_array_add (array, row); } sqlite3_finalize (pp); sqlite3_close (db); root = json_object_new_object (); json_object_object_add (root, "records", array); aux = json_object_to_json_string (root); json = malloc (sizeof (char) * (strlen (aux) + 1)); strcpy (json, aux); json_object_put (root); return json; }
/* Return the data type of a column */ Statement::Type StatementPrivate::dataType(unsigned int column) const { switch (sqlite3_column_type(stmt_, column)) { case SQLITE_INTEGER: return Statement::Type::Integer; case SQLITE_FLOAT: return Statement::Type::Real; case SQLITE_BLOB: return Statement::Type::Binary; case SQLITE_NULL: return Statement::Type::Null; case SQLITE_TEXT: return Statement::Type::Text; default: return Statement::Type::Null; }; }
const char* wyResultSet::dataForColumnIndex(int columnIdx, size_t* outLen) { // check type if (sqlite3_column_type(m_statement->getStatement(), columnIdx) == SQLITE_NULL || (columnIdx < 0)) { *outLen = 0; return NULL; } // copy data int dataSize = sqlite3_column_bytes(m_statement->getStatement(), columnIdx); char* buf = (char*)wyMalloc(dataSize * sizeof(char)); memcpy(buf, sqlite3_column_blob(m_statement->getStatement(), columnIdx), dataSize); // return buffer *outLen = dataSize; return (const char*)buf; }
query_result run(sqlite3_stmt *stmt) { query_result data(new Result); int rc; do { rc=sqlite3_step(stmt); if (rc==SQLITE_ROW) { data->resize(data->size()+1); rowResult cur=data->back(); int nrows=sqlite3_column_count(stmt); for (int i=0;i<nrows;++i) { LOCK_COUT cout << "[DB] query " << stmt << ": result row " << i+1 << "/" << nrows << endl; UNLOCK_COUT switch (sqlite3_column_type(stmt,i)) { case SQLITE_NULL: cur[i]=dbValue::ptr(new dbValue); break; case SQLITE_INTEGER: cur[i]=dbValue::ptr(new dbValue((s64)sqlite3_column_int(stmt,i))); break; case SQLITE_FLOAT: cur[i]=dbValue::ptr(new dbValue((double)sqlite3_column_double(stmt,i))); break; case SQLITE_TEXT: cur[i]=dbValue::ptr(new dbValue((const char *)sqlite3_column_text(stmt,i))); break; case SQLITE_BLOB: cur[i]=dbValue::ptr( new dbValue( (const char *)sqlite3_column_text(stmt,i), sqlite3_column_bytes(stmt,i) )); break; } } } } while (rc==SQLITE_ROW); if (rc!=SQLITE_DONE) { DBError::busy_aware_throw(rc,sqlite3_errmsg(db)); } LOCK_COUT cout << "[DB] " << stmt << ": " << data->size() << " rows returned." << endl; UNLOCK_COUT return data; }
static int sqlite3_odbx_column_type( odbx_result_t* result, unsigned long pos ) { #ifdef HAVE_SQLITE3_TABLE_COLUMN_METADATA const char *type, *collation; int notnull, primarykey, autoinc; #endif switch( sqlite3_column_type( (sqlite3_stmt*) result->generic, pos ) ) { case SQLITE_INTEGER: return ODBX_TYPE_BIGINT; case SQLITE_FLOAT: return ODBX_TYPE_DOUBLE; case SQLITE_BLOB: return ODBX_TYPE_BLOB; case SQLITE_TEXT: return ODBX_TYPE_CLOB; default: #ifdef HAVE_SQLITE3_TABLE_COLUMN_METADATA if( sqlite3_table_column_metadata( (sqlite3*) result->handle->generic, sqlite3_column_database_name( (sqlite3_stmt*) result->generic, pos ), sqlite3_column_table_name( (sqlite3_stmt*) result->generic, pos ), sqlite3_column_origin_name( (sqlite3_stmt*) result->generic, pos ), &type, &collation, ¬null, &primarykey, &autoinc ) != SQLITE_OK ) { return ODBX_TYPE_UNKNOWN; } if( strstr( type, "DOUBLE" ) != NULL || strcmp( type, "FLOAT" ) == 0 || strcmp( type, "REAL" ) == 0 ) { return ODBX_TYPE_DOUBLE; } else if( strstr( type, "INT" ) != NULL || strcmp( type, "BOOLEAN" ) == 0 ) { return ODBX_TYPE_BIGINT; } else if( strstr( type, "CHAR" ) != NULL || strcmp( type, "CLOB" ) == 0 || strcmp( type, "TEXT" ) == 0 ) { return ODBX_TYPE_CLOB; } else if( strstr( type, "DATE" ) != NULL || strstr( type, "TIME" ) != NULL || strstr( type, "DECIMAL" ) != NULL ) { return ODBX_TYPE_CLOB; } else if( strcmp( type, "BLOB" ) == 0 ) { return ODBX_TYPE_BLOB; } else { return ODBX_TYPE_UNKNOWN; } #else return ODBX_TYPE_UNKNOWN; #endif } }
shared_ptr<DBValue> SQLiteDataReader::makeDBValue(sqlite3_stmt *statement, std::size_t column) { if (column >= (std::size_t) sqlite3_column_count(statement)) { return 0; } const int type = sqlite3_column_type(statement, column); switch (type) { case SQLITE_INTEGER: return new DBIntValue(sqlite3_column_int(statement, column)); case SQLITE_FLOAT: return new DBRealValue(sqlite3_column_double(statement, column)); case SQLITE_TEXT: return new DBTextValue((const char *) sqlite3_column_text(statement, column)); case SQLITE_NULL: return DBValue::create(DBValue::DBNULL); } return 0; }
void Query::ViewRes() { if (!res) { printf("no result stored\n"); return; } printf("result column count = %d\n", sqlite3_column_count(res)); for (int i = 0; i < sqlite3_column_count(res); i++) { printf(" %2d type %d name '%s'", i, sqlite3_column_type(res, i), sqlite3_column_name(res, i)); printf(" / '%s'", (char *)sqlite3_column_text(res, i)); printf(" / %d", sqlite3_column_int(res, i)); printf(" / %f", sqlite3_column_double(res, i)); printf("\n"); } }
static pse_op_error_t sqlite_query_int_value(sqlite3 *db, const char* sql_sentence, int* value) { pse_op_error_t ret = OP_SUCCESS; int rc; sqlite3_stmt *stat = NULL; rc = sqlite3_prepare_v2(db, sql_sentence, -1, &stat, 0); if(SQLITE_OK != rc) { ret = OP_ERROR_SQLITE_INTERNAL; goto exit; } rc = sqlite3_step(stat); if (SQLITE_DONE == rc) { *value = 0; ret = OP_ERROR_SQLITE_NOT_FOUND; goto exit; } if(SQLITE_ROW != rc) { ret = OP_ERROR_SQLITE_INTERNAL; goto exit; } rc = sqlite3_column_type(stat, 0); if(SQLITE_INTEGER != rc) { if(SQLITE_NULL == rc) { ret = OP_ERROR_SQLITE_NOT_FOUND; // SQlite returned a NULL record that indicates "NOT FOUND" } else { ret = OP_ERROR_INVALID_VMC_DB; // this will trigger DB re-initialization } goto exit; } *value = sqlite3_column_int(stat, 0); exit: sqlite3_finalize(stat); return ret; }
/* --------------------------------------------------------------- */ void R_sqlget( const int func ) { int col, bytes; if (ARGN==0) { Licpy(ARGR, sqlite3_column_count(sqlstmt)); return; } if (ARGN>1) Lerror(ERR_INCORRECT_CALL,0); get_i0(1,col); col--; switch (sqlite3_column_type(sqlstmt, col)) { case SQLITE_INTEGER: Licpy(ARGR, sqlite3_column_int(sqlstmt, col)); break; case SQLITE_FLOAT: Lrcpy(ARGR, sqlite3_column_double(sqlstmt, col)); break; case SQLITE_TEXT: Lscpy(ARGR, (char*)sqlite3_column_text(sqlstmt, col)); break; case SQLITE_BLOB: bytes = sqlite3_column_bytes(sqlstmt, col); Lfx(ARGR, bytes); LLEN(*ARGR) = bytes; LTYPE(*ARGR) = LSTRING_TY; MEMCPY(LSTR(*ARGR), sqlite3_column_blob(sqlstmt, col), bytes); break; case SQLITE_NULL: Lfx(ARGR,1); LTYPE(*ARGR) = LSTRING_TY; LLEN(*ARGR) = 1; LSTR(*ARGR)[0] = 0; break; default: Lfx(ARGR,0); LTYPE(*ARGR) = LSTRING_TY; LLEN(*ARGR) = 0; } } /* R_sqlget */
const CommonCardData* ClientDatabase::getCardData(CardId id) { auto found = _cards.find(id); if(found == _cards.end()) // not found: create and return { sqlite3_reset(_getCardStmt); sqliteThrowExcept(sqlite3_bind_int64(_getCardStmt, 1, id)); assert(sqliteThrowExcept(sqlite3_step(_getCardStmt)) == SQLITE_ROW); CommonCardData * cardData; if(sqlite3_column_type(_getCardStmt, 4) == SQLITE_NULL) // Spell { cardData = new ClientSpellData( id, reinterpret_cast<const char *>(sqlite3_column_text(_getCardStmt, 0)), // name sqlite3_column_int(_getCardStmt, 1), // cost reinterpret_cast<const char *>(sqlite3_column_text(_getCardStmt, 2)) // description ); } else // Creature { cardData = new ClientCreatureData( id, reinterpret_cast<const char *>(sqlite3_column_text(_getCardStmt, 0)), // name sqlite3_column_int(_getCardStmt, 1), // cost reinterpret_cast<const char *>(sqlite3_column_text(_getCardStmt, 2)), // description sqlite3_column_int(_getCardStmt, 3), // attack sqlite3_column_int(_getCardStmt, 4), // health sqlite3_column_int(_getCardStmt, 5), // shield sqlite3_column_int(_getCardStmt, 6) // shieldType ); } return _cards.emplace(std::make_pair<>( id, std::unique_ptr<CommonCardData>(cardData) )).first->second.get(); } else // card already created { return found->second.get(); } }
void Experiment::deserialize(sqlite3* db) { sqlite3_stmt *read; db_prepare(db, read, boost::format("select " "name, " "paramset_id, " "response_id, " "train_set, " "test_set, " "time, " "vcs_commit, " "human_note, " "machine_note, " "batch, " "skip, " "flags " "from experiment where id=%d;") % id); db_step(read, SQLITE_ROW); int c = 0; name = string((const char*) sqlite3_column_text(read, c++)); paramset.id = sqlite3_column_int64(read, c++); has_run = (sqlite3_column_type(read, c) != SQLITE_NULL); if (has_run) { response.id = sqlite3_column_int64(read, c++); } else { response.id = -1; c++; } train_set = string((const char*) sqlite3_column_text(read, c++)); test_set = string((const char*) sqlite3_column_text(read, c++)); if (has_run) { time = string((const char*) sqlite3_column_text(read, c++)); vcs_commit = string((const char*) sqlite3_column_text(read, c++)); } else { c += 2; } human_note = string((const char*) sqlite3_column_text(read, c++)); machine_note = string((const char*) sqlite3_column_text(read, c++)); batch = string((const char*) sqlite3_column_text(read, c++)); skip = sqlite3_column_int(read, c++) != 0; flags = sqlite3_column_int(read, c++); sqlite3_finalize(read); paramset.deserialize(db); if (has_run) { response.deserialize(db); } }
LJEntry* journal_store_get_entry(JournalStore *js, int get_itemid) { LJEntry *entry; sqlite3_stmt *stmt = NULL; int ret; time_t timestamp; SQLCHECK(sqlite3_prepare(js->db, "SELECT anum, subject, event, moodid, mood, " /* 0-4 */ "music, pickeyword, preformatted, backdated, " /* 5-9 */ "comments, timestamp, security, taglist " /* 10-13 */ "FROM entry WHERE itemid=?1", -1, &stmt, NULL)); SQLCHECK(sqlite3_bind_int(stmt, 1, get_itemid)); ret = sqlite3_step(stmt); if (ret != SQLITE_ROW) { SQLCHECK(sqlite3_finalize(stmt)); return NULL; } entry = lj_entry_new(); entry->itemid = get_itemid; entry->anum = sqlite3_column_int(stmt, 0); entry->subject = dup_col_or_null(stmt, 1); entry->event = dup_col_or_null(stmt, 2); entry->moodid = sqlite3_column_int(stmt, 3); entry->mood = dup_col_or_null(stmt, 4); entry->music = dup_col_or_null(stmt, 5); entry->pickeyword = dup_col_or_null(stmt, 6); entry->preformatted = sqlite3_column_int(stmt, 7); entry->backdated = sqlite3_column_int(stmt, 8); entry->comments = sqlite3_column_int(stmt, 9); entry->taglist = dup_col_or_null(stmt, 12); timestamp = sqlite3_column_int(stmt, 10); gmtime_r(×tamp, &entry->time); if (sqlite3_column_type(stmt, 11) != SQLITE_NULL) security_from_int(&entry->security, sqlite3_column_int(stmt, 11)); SQLCHECK(sqlite3_finalize(stmt)); return entry; }
mxArray *get_column(sqlite3_stmt *stmt, int index) { int type = sqlite3_column_type(stmt, index); if (type == SQLITE_TEXT) { const char *text = sqlite3_column_text(stmt, index); return mxCreateCharMatrixFromStrings(1, &text); } else if (type == SQLITE_FLOAT) { return mxCreateDoubleScalar(sqlite3_column_double(stmt, index)); } else if (type == SQLITE_INTEGER) { mxArray *a = mxCreateNumericMatrix(1, 1, mxINT64_CLASS, mxREAL); int64_t val = sqlite3_column_int64(stmt, index); memcpy(mxGetData(a), &val, sizeof val); return a; } mexErrMsgIdAndTxt("sqlite3:get_column", "unsupported column type"); return NULL; }
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; }
/** * Fetch the current branch if attached. * Return NULL if detached. * */ void sg_wc_db__branch__get_branch(SG_context * pCtx, sg_wc_db * pDb, char ** ppszBranchName) { sqlite3_stmt * pStmt = NULL; int rc; SG_ERR_CHECK( sg_sqlite__prepare(pCtx, pDb->psql, &pStmt, ("SELECT" " name" // 0 " FROM tbl_branch" " WHERE id = ?")) ); SG_ERR_CHECK( sg_sqlite__bind_int64(pCtx, pStmt, 1, ID_KEY) ); rc = sqlite3_step(pStmt); switch (rc) { case SQLITE_ROW: if (sqlite3_column_type(pStmt, 0) == SQLITE_NULL) *ppszBranchName = NULL; else SG_ERR_CHECK( SG_STRDUP(pCtx, (const char *)sqlite3_column_text(pStmt, 0), ppszBranchName) ); break; case SQLITE_DONE: *ppszBranchName = NULL; break; default: SG_ERR_THROW2( SG_ERR_SQLITE(rc), (pCtx, "sg_wc_db:tbl_branch can't get branch name.") ); } SG_ERR_CHECK( sg_sqlite__nullfinalize(pCtx, &pStmt) ); #if TRACE_WC_DB SG_ERR_IGNORE( SG_console(pCtx, SG_CS_STDERR, "sg_wc_db__branch__get_branch: %s\n", ((*ppszBranchName) ? (*ppszBranchName) : "<detached>")) ); #endif return; fail: SG_ERR_IGNORE( sg_sqlite__nullfinalize(pCtx, &pStmt) ); }
EphySQLiteColumnType ephy_sqlite_statement_get_column_type (EphySQLiteStatement *self, int column) { int column_type = sqlite3_column_type (self->priv->prepared_statement, column); switch (column_type) { case SQLITE_INTEGER: return EPHY_SQLITE_COLUMN_TYPE_INT; case SQLITE_FLOAT: return EPHY_SQLITE_COLUMN_TYPE_FLOAT; case SQLITE_TEXT: return EPHY_SQLITE_COLUMN_TYPE_STRING; case SQLITE_BLOB: return EPHY_SQLITE_COLUMN_TYPE_BLOB; case SQLITE_NULL: default: return EPHY_SQLITE_COLUMN_TYPE_NULL; } }
/* Static */ static gint _highest_logged_session_id() { gchar *cmd = NULL; sqlite3_stmt *stmt = NULL; gint id = 0; cmd = sqlite3_mprintf("select max(id) from sessionslog;"); sqlite3_prepare(ccl->db, cmd, -1, &stmt, NULL); sqlite3_free(cmd); if (sqlite3_step(stmt) == SQLITE_ROW && sqlite3_column_type(stmt, 0) != SQLITE_NULL) id = sqlite3_column_int(stmt, 0); sqlite3_finalize(stmt); return id; }
static int fetch(lua_State* L, int mode) { stmt* s = (stmt*)luaL_checkudata(L, 1, MT_STMT); sqlite3* db = sqlite3_db_handle(s->handle); int ret; while((ret = sqlite3_step(s->handle)) == SQLITE_SCHEMA) {} if(ret == SQLITE_DONE) { lua_pushnil(L); return 1; } else if(ret == SQLITE_ROW) { int i; int col_count = sqlite3_column_count(s->handle); lua_createtable(L, col_count, 0); for(i = 0; i < col_count; i++) { if(mode == 0) { /* fetch, rows */ lua_pushstring(L, sqlite3_column_name(s->handle, i)); } else if(mode == 1) { /* ifetch, irows */ lua_pushinteger(L, i + 1); } switch(sqlite3_column_type(s->handle, i)) { case SQLITE_INTEGER: lua_pushinteger(L, sqlite3_column_int(s->handle, i)); break; case SQLITE_FLOAT: lua_pushnumber(L, sqlite3_column_double(s->handle, i)); break; case SQLITE_TEXT: lua_pushstring(L, (const char*)sqlite3_column_text(s->handle, i)); break; case SQLITE_BLOB: case SQLITE_NULL: lua_pushnil(L); break; } lua_settable(L, -3); } return 1; } return luaL_error(L, "[%d] %s", ret, sqlite3_errmsg(db)); }
gboolean journal_store_scan(JournalStore *js, JournalStoreScanCallback scan_cb, const gpointer scan_data, JournalStoreSummaryCallback cb_func, const gpointer cb_data) { int ret; sqlite3_stmt *stmt = NULL; int matchcount = 0; SQLCHECK(sqlite3_prepare(js->db, "SELECT itemid, timestamp, subject, event, security " "FROM entry ORDER BY itemid ASC", -1, &stmt, NULL)); ret = sqlite3_step(stmt); while (ret == SQLITE_ROW) { int itemid = sqlite3_column_int(stmt, 0); time_t timestamp = sqlite3_column_int(stmt, 1); const char *subject = (char*)sqlite3_column_text(stmt, 2); const char *event = (char*)sqlite3_column_text(stmt, 3); LJSecurity sec = {0}; if (sqlite3_column_type(stmt, 4) != SQLITE_NULL) security_from_int(&sec, sqlite3_column_int(stmt, 4)); if (scan_cb(subject, scan_data) || scan_cb(event, scan_data)) { const char *summary = lj_get_summary(subject, event); cb_func(itemid, timestamp, summary, &sec, cb_data); if (++matchcount == MAX_MATCHES) break; } ret = sqlite3_step(stmt); } if (ret != SQLITE_ROW && ret != SQLITE_DONE) { SQLCHECK(ret); SQLCHECK(sqlite3_finalize(stmt)); return FALSE; } SQLCHECK(sqlite3_finalize(stmt)); return TRUE; }
QgsPolyline QgsOSMDatabase::wayPoints( QgsOSMId id ) const { QgsPolyline points; // bind the way identifier sqlite3_bind_int64( mStmtWayNodePoints, 1, id ); while ( sqlite3_step( mStmtWayNodePoints ) == SQLITE_ROW ) { if ( sqlite3_column_type( mStmtWayNodePoints, 0 ) == SQLITE_NULL ) return QgsPolyline(); // missing some nodes double lon = sqlite3_column_double( mStmtWayNodePoints, 0 ); double lat = sqlite3_column_double( mStmtWayNodePoints, 1 ); points.append( QgsPoint( lon, lat ) ); } sqlite3_reset( mStmtWayNodePoints ); return points; }