int WfipsData::LoadFwas() { //assert( poScenario->m_VDispLogic.size() > 0 ); sqlite3_stmt *stmt; int rc, n, i; void *pGeom; /* Clear our lookup */ FwaIndexMap.clear(); poScenario->m_VFWA.clear(); if( pszAnalysisAreaWkt ) { n = CompileGeometry( pszAnalysisAreaWkt, &pGeom ); if( n > 0 ) { rc = sqlite3_prepare_v2( db, "SELECT * FROM fwa JOIN reload ON " "fwa.name=reload.fwa_name JOIN " "walk_in ON " "reload.fwa_name=walk_in.fwa_name " "WHERE ST_Intersects(@geom, geometry) " "AND name NOT LIKE '%unassigned%' " "AND substr(fwa.name, 0, 3) NOT IN " "('EA','SA','AK') " "AND fwa.ROWID IN " "(SELECT pkid FROM " "idx_fwa_geometry WHERE " "xmin <= MbrMaxX(@geom) AND " "xmax >= MbrMinX(@geom) AND " "ymin <= MbrMaxY(@geom) AND " "ymax >= MbrMinY(@geom))", -1, &stmt, NULL ); rc = sqlite3_bind_blob( stmt, sqlite3_bind_parameter_index( stmt, "@geom" ), pGeom, n, sqlite3_free ); } else { return SQLITE_ERROR; } } else { rc = sqlite3_prepare_v2( db, "SELECT * FROM fwa JOIN reload ON " "fwa.name=reload.fwa_name JOIN " "walk_in ON " "reload.fwa_name=walk_in.fwa_name " "WHERE fwa.name NOT LIKE '%unassigned%' " "AND substr(fwa.name, 0, 3) NOT IN " "('EA','SA','AK')", -1, &stmt, NULL ); } const char *pszName, *pszFpu; int nWalkIn, nPumpRoll, nHead, nTail, nPara; double dfAttDist; int bWaterDrops, bExcluded; double dfDiscSize, dfEslSize, dfEslTime, dfAirGrnd; int nFirstDelay; const char *pszLogic; int anReload[5]; int anWalkIn[6]; int iFwa = 0; std::map<std::string, int>::iterator it; while( sqlite3_step( stmt ) == SQLITE_ROW ) { pszName = (const char *)sqlite3_column_text( stmt, 1 ); assert( pszName ); pszFpu = (const char *)sqlite3_column_text( stmt, 2 ); assert( pszFpu ); // FMG 3 nWalkIn = sqlite3_column_int( stmt, 4 ); assert( nWalkIn >= 0 || nWalkIn <= 100 ); nPumpRoll = sqlite3_column_int( stmt, 5 ); assert( nPumpRoll >= 0 || nPumpRoll <= 100 ); nHead = sqlite3_column_int( stmt, 6 ); assert( nHead >= 0 || nHead <= 100 ); nTail = sqlite3_column_int( stmt, 7 ); assert( nTail >= 0 || nTail <= 100 ); nPara = sqlite3_column_int( stmt, 8 ); assert( nPara >= 0 || nPara <= 100 ); assert( nPara + nTail + nHead < 101 ); dfAttDist = sqlite3_column_double( stmt, 9 ); assert( dfAttDist >= 0.0 ); bWaterDrops = sqlite3_column_int( stmt, 10 ); assert( bWaterDrops == 0 || bWaterDrops == 1 ); bExcluded = sqlite3_column_int( stmt, 11 ); assert( bExcluded == 0 || bExcluded == 1 ); dfDiscSize = sqlite3_column_double( stmt, 12 ); assert( dfDiscSize >= 0 ); dfEslTime = sqlite3_column_double( stmt, 13 ); assert( dfEslTime >= 0 ); dfEslSize = sqlite3_column_double( stmt, 14 ); assert( dfEslSize >= 0 ); dfAirGrnd = sqlite3_column_double( stmt, 15 ); assert( dfAirGrnd >= 0 ); nFirstDelay = sqlite3_column_int( stmt, 16 ); assert( nFirstDelay >= 0 ); pszLogic = (const char *)sqlite3_column_text( stmt, 17 ); assert( pszLogic ); memset( anReload, 0, sizeof( int ) * 5 ); for( i = 0; i < 5; i++ ) { anReload[i] = sqlite3_column_int( stmt, 18+i ); assert( anReload[i] >= 0 ); } memset( anWalkIn, 0, sizeof( int ) * 6 ); for( i = 0; i < 6; i++ ) { anWalkIn[i] = sqlite3_column_int( stmt, 18+5+i ); assert( anWalkIn[i] >= 0 ); } /* ** We use defaults now for some delays: From FPA: ** ** Post Escape Delay 20 minutes for all but smokejumpers, smokejumpers ** 120 minutes. ** Post Unused Delay 10 minutes for all. ** Post Used Delay 30 minutes for all but boats and smokejumpers, boats ** and smokejumpers 120 minutes. ** ** Columns: ** tracked,boat,crew,engine,helitack,smkjmp **/ int anPostEscape[6] = {20,20, 20,20,20,120}; int anPostUnused[6] = {10,10, 10,10,10,10}; int anPostUsed[6] = {30,120,30,30,30,120}; /* Fixed, no assert */ /* ** These values have also been defaulted. */ std::string aoRos[10]; double adfRosCoeff[10]; double adfDiurn[24]; for( i = 0; i < 10; i++ ) { aoRos[i] = std::string( "NA" ); adfRosCoeff[i] = 1.0; } /* Fixed, no assert */ for( i = 0; i < 24; i++ ) { adfDiurn[i] = 1.; } /* Fixed, no assert */ /* ** The value of this is up for discussion... */ it = DispLogIndexMap.find( pszLogic ); if( it == DispLogIndexMap.end() ) { i = 0; printf("Failed to load logic: %s for fwa: %s\n", pszLogic, pszName); } else { i = it->second; } poScenario->m_VFWA.push_back( CFWA( std::string( pszName ), std::string( "" ), nWalkIn, nPumpRoll, nHead, nTail, nPara, dfAttDist, bWaterDrops, bExcluded, dfDiscSize, dfEslTime, dfEslSize, dfAirGrnd, anWalkIn, anPostUsed, anPostUnused, anPostEscape, anReload, nFirstDelay, adfDiurn, aoRos, adfRosCoeff, iFwa, poScenario->m_VDispLogic[i], std::string( pszFpu ) ) ); FwaIndexMap.insert( std::pair<std::string, int>( std::string( pszName ), iFwa ) ); iFwa++; } assert( FwaIndexMap.size() == poScenario->m_VFWA.size() ); sqlite3_finalize( stmt ); return 0; }
void Database::writePlayerData(const PlayerData& playerData) { // Prepare statement. std::string statementString("UPDATE `players` SET worldId=:worldId, positionX=:positionX, positionY=:positionY, hp=:hp, maxhp=:maxhp, strength=:strength, agility=:agility, resistance=:resistance, xp=:xp, level=:level WHERE id=:dbid"); sqlite3_stmt* statement; m_lastError = sqlite3_prepare(m_db, statementString.c_str(), statementString.size(), &statement, nullptr); if(m_lastError != SQLITE_OK) return; // Bind parameters. int parameterIndex = sqlite3_bind_parameter_index(statement, ":dbid"); sqlite3_bind_int(statement, parameterIndex, playerData.dbid); parameterIndex = sqlite3_bind_parameter_index(statement, ":worldId"); sqlite3_bind_int(statement, parameterIndex, playerData.worldId); parameterIndex = sqlite3_bind_parameter_index(statement, ":positionX"); sqlite3_bind_double(statement, parameterIndex, playerData.positionX); parameterIndex = sqlite3_bind_parameter_index(statement, ":positionY"); sqlite3_bind_double(statement, parameterIndex, playerData.positionY); parameterIndex = sqlite3_bind_parameter_index(statement, ":hp"); sqlite3_bind_double(statement, parameterIndex, playerData.hp); parameterIndex = sqlite3_bind_parameter_index(statement, ":maxhp"); sqlite3_bind_double(statement, parameterIndex, playerData.maxhp); parameterIndex = sqlite3_bind_parameter_index(statement, ":strength"); sqlite3_bind_double(statement, parameterIndex, playerData.strength); parameterIndex = sqlite3_bind_parameter_index(statement, ":agility"); sqlite3_bind_double(statement, parameterIndex, playerData.agility); parameterIndex = sqlite3_bind_parameter_index(statement, ":resistance"); sqlite3_bind_double(statement, parameterIndex, playerData.resistance); parameterIndex = sqlite3_bind_parameter_index(statement, ":xp"); sqlite3_bind_double(statement, parameterIndex, playerData.xp); parameterIndex = sqlite3_bind_parameter_index(statement, ":level"); sqlite3_bind_double(statement, parameterIndex, playerData.level); // Execute. while(true) { int status = sqlite3_step(statement); if(status == SQLITE_BUSY) continue; break; } // Free. sqlite3_finalize(statement); }
// Bind a text value to a parameter "?NNN", ":VVV", "@VVV" or "$VVV" in the SQL prepared statement void Statement::bindNoCopy(const char* apName, const char* apValue) { const int index = sqlite3_bind_parameter_index(mStmtPtr, apName); const int ret = sqlite3_bind_text(mStmtPtr, index, apValue, -1, SQLITE_STATIC); check(ret); }
// Bind a binary blob value to a parameter "?NNN", ":VVV", "@VVV" or "$VVV" in the SQL prepared statement void Statement::bind(const char* apName, const void* apValue, const int aSize) { const int index = sqlite3_bind_parameter_index(mStmtPtr, apName); const int ret = sqlite3_bind_blob(mStmtPtr, index, apValue, aSize, SQLITE_TRANSIENT); check(ret); }
/* call-seq: stmt.bind_param(key, value) * * Binds value to the named (or positional) placeholder. If +param+ is a * Fixnum, it is treated as an index for a positional placeholder. * Otherwise it is used as the name of the placeholder to bind to. * * See also #bind_params. */ static VALUE bind_param(VALUE self, VALUE key, VALUE value) { sqlite3StmtRubyPtr ctx; int status; int index; Data_Get_Struct(self, sqlite3StmtRuby, ctx); REQUIRE_OPEN_STMT(ctx); switch(TYPE(key)) { case T_SYMBOL: key = rb_funcall(key, rb_intern("to_s"), 0); case T_STRING: if(RSTRING_PTR(key)[0] != ':') key = rb_str_plus(rb_str_new2(":"), key); index = sqlite3_bind_parameter_index(ctx->st, StringValuePtr(key)); break; default: index = (int)NUM2INT(key); } if(index == 0) rb_raise(rb_path2class("SQLite3::Exception"), "no such bind parameter"); switch(TYPE(value)) { case T_STRING: if(CLASS_OF(value) == cSqlite3Blob #ifdef HAVE_RUBY_ENCODING_H || rb_enc_get_index(value) == rb_ascii8bit_encindex() #endif ) { status = sqlite3_bind_blob( ctx->st, index, (const char *)StringValuePtr(value), (int)RSTRING_LEN(value), SQLITE_TRANSIENT ); } else { #ifdef HAVE_RUBY_ENCODING_H if(!UTF8_P(value)) { VALUE db = rb_iv_get(self, "@connection"); VALUE encoding = rb_funcall(db, rb_intern("encoding"), 0); rb_encoding * enc = rb_to_encoding(encoding); value = rb_str_export_to_enc(value, enc); } #endif status = sqlite3_bind_text( ctx->st, index, (const char *)StringValuePtr(value), (int)RSTRING_LEN(value), SQLITE_TRANSIENT ); } break; case T_BIGNUM: #if SIZEOF_LONG < 8 if (RBIGNUM_LEN(value) * SIZEOF_BDIGITS <= 8) { status = sqlite3_bind_int64(ctx->st, index, (sqlite3_int64)NUM2LL(value)); break; } #endif case T_FLOAT: status = sqlite3_bind_double(ctx->st, index, NUM2DBL(value)); break; case T_FIXNUM: status = sqlite3_bind_int64(ctx->st, index, (sqlite3_int64)FIX2LONG(value)); break; case T_NIL: status = sqlite3_bind_null(ctx->st, index); break; default: rb_raise(rb_eRuntimeError, "can't prepare %s", rb_class2name(CLASS_OF(value))); break; } CHECK(sqlite3_db_handle(ctx->st), status); return self; }
/* --------------------------------------------------------------- */ void R_sqlbind( const int func ) { int col, i; double d; char type; if (!sqldb) Lerror(ERR_DATABASE,1); if (!sqlstmt) Lerror(ERR_DATABASE,0); if (ARGN==0) { Licpy(ARGR, sqlite3_bind_parameter_count(sqlstmt)); return; } if (ARGN!=3) Lerror(ERR_INCORRECT_CALL,0); if (Ldatatype(ARG1,'N')) col = Lrdint(ARG1); else { LASCIIZ(*ARG1); col = sqlite3_bind_parameter_index(sqlstmt, LSTR(*ARG1)); } get_pad(2, type); switch (type) { case 'b': case 'B': /* blob */ Licpy(ARGR, sqlite3_bind_blob(sqlstmt, col, LSTR(*ARG3), LLEN(*ARG3), SQLITE_TRANSIENT)); break; case 'i': case 'I': /* integer */ get_i(3, i); Licpy(ARGR, sqlite3_bind_int(sqlstmt, col, i)); break; case 'd': case 'D': /* double */ case 'f': case 'F': L2REAL(ARG3); Licpy(ARGR, sqlite3_bind_double(sqlstmt, col, LREAL(*ARG3))); break; case 's': case 'S': /* double */ case 't': case 'T': L2STR(ARG3); Licpy(ARGR, sqlite3_bind_text(sqlstmt, col, LSTR(*ARG3), LLEN(*ARG3), SQLITE_TRANSIENT)); break; case 'n': case 'N': /* null */ Licpy(ARGR, sqlite3_bind_null(sqlstmt, col)); break; case 'z': case 'Z': /* zero blob */ get_i(3, i); Licpy(ARGR, sqlite3_bind_zeroblob(sqlstmt, col, i)); break; default: Lerror(ERR_INCORRECT_CALL,0); } } /* R_sqlbind */
DLL_FUNCTION(int32_t) BU_SQLite_Bind_Parameter_Index(sqlite3_stmt* pStmt, const char* zName) { #pragma comment(linker, "/EXPORT:BU_SQLite_Bind_Parameter_Index=_BU_SQLite_Bind_Parameter_Index@8") return sqlite3_bind_parameter_index(pStmt, zName); }
void SQLiteStatement::bind(string param, const void* value, int len, SQLiteStatement::ValueManagement valmgmt) const { int idx = sqlite3_bind_parameter_index(this->_stmt, param.c_str()); this->bind(idx, value, len, valmgmt); }
void makedb(int compress) { ssize_t nchars; char *line = 0; size_t len = 0; sqlite3 *db = NULL; sqlite3_stmt *stmt = NULL; char *query; int rc = 0; int i = 0; int idx = 0; char *errmsg = NULL; FILE *file = fopen("./sample.txt", "r"); if (file == NULL) err(EXIT_FAILURE, "fopen failed"); remove(DBPATH); db = init_db(); if (compress) query = "CREATE VIRTUAL TABLE fts USING FTS4(data, i, tokenize=porter, " "compress=zip, uncompress=unzip)"; else query = "CREATE VIRTUAL TABLE fts USING FTS4(data, i, tokenize=porter)"; rc = sqlite3_prepare_v2(db, query, -1, &stmt, NULL); if (rc != SQLITE_OK) { warnx("sqlite3_prepare failed while creating db"); sqlite3_close(db); fclose(file); sqlite3_free(query); exit(EXIT_FAILURE); } sqlite3_step(stmt); sqlite3_finalize(stmt); sqlite3_exec(db, "BEGIN", NULL, NULL, &errmsg); if (errmsg) { warnx("%s", errmsg); fclose(file); sqlite3_close(db); free(errmsg); exit(EXIT_FAILURE); } while ((nchars = getline(&line, &len, file)) != -1) { query = "INSERT INTO fts VALUES(:line, :i)"; rc = sqlite3_prepare_v2(db, query, -1, &stmt, NULL); if (rc != SQLITE_OK) { warnx("sqlite3_prepare failed while inserting data"); warnx("%s", sqlite3_errmsg(db)); sqlite3_close(db); fclose(file); exit(EXIT_FAILURE); } idx = sqlite3_bind_parameter_index(stmt, ":line"); rc = sqlite3_bind_text(stmt, idx, line, -1, NULL); if (rc != SQLITE_OK) { warnx("%s", sqlite3_errmsg(db)); sqlite3_finalize(stmt); sqlite3_close(db); fclose(file); exit(EXIT_FAILURE); } idx = sqlite3_bind_parameter_index(stmt, ":i"); rc = sqlite3_bind_int(stmt, idx, i); if (rc != SQLITE_OK) { warnx("%s", sqlite3_errmsg(db)); sqlite3_finalize(stmt); sqlite3_close(db); fclose(file); exit(EXIT_FAILURE); } sqlite3_step(stmt); sqlite3_finalize(stmt); } sqlite3_exec(db, "END", NULL, NULL, &errmsg); if (errmsg) { warnx("%s", errmsg); free(errmsg); } fclose(file); sqlite3_close(db); }
bool PDOSqliteStatement::paramHook(PDOBoundParam *param, PDOParamEvent event_type) { switch (event_type) { case PDO_PARAM_EVT_EXEC_PRE: if (executed && !m_done) { sqlite3_reset(m_stmt); m_done = 1; } if (param->is_param) { if (param->paramno == -1) { param->paramno = sqlite3_bind_parameter_index(m_stmt, param->name.c_str()) - 1; } switch (PDO_PARAM_TYPE(param->param_type)) { case PDO_PARAM_STMT: return false; case PDO_PARAM_NULL: if (sqlite3_bind_null(m_stmt, param->paramno + 1) == SQLITE_OK) { return true; } handleError(__FILE__, __LINE__); return false; case PDO_PARAM_INT: case PDO_PARAM_BOOL: if (param->parameter.isNull()) { if (sqlite3_bind_null(m_stmt, param->paramno + 1) == SQLITE_OK) { return true; } } else { if (SQLITE_OK == sqlite3_bind_int(m_stmt, param->paramno + 1, param->parameter.toInt64())) { return true; } } handleError(__FILE__, __LINE__); return false; case PDO_PARAM_LOB: if (param->parameter.isResource()) { Variant buf = f_stream_get_contents(param->parameter); if (!same(buf, false)) { param->parameter = buf; } else { pdo_raise_impl_error(dbh, this, "HY105", "Expected a stream resource"); return false; } } else if (param->parameter.isNull()) { if (sqlite3_bind_null(m_stmt, param->paramno + 1) == SQLITE_OK) { return true; } handleError(__FILE__, __LINE__); return false; } { String sparam = param->parameter.toString(); if (SQLITE_OK == sqlite3_bind_blob(m_stmt, param->paramno + 1, sparam.data(), sparam.size(), SQLITE_STATIC)) { return true; } } handleError(__FILE__, __LINE__); return false; case PDO_PARAM_STR: default: if (param->parameter.isNull()) { if (sqlite3_bind_null(m_stmt, param->paramno + 1) == SQLITE_OK) { return true; } } else { String sparam = param->parameter.toString(); if (SQLITE_OK == sqlite3_bind_text(m_stmt, param->paramno + 1, sparam.data(), sparam.size(), SQLITE_STATIC)) { return true; } } handleError(__FILE__, __LINE__); return false; } } break; default:; } return true; }
bool exec(const std::string& sql, const bindings_type& bindings, rows_type* rows) { boost::mutex::scoped_lock lock(guard_); auto it = stmt_ptr_map_.find(sql); sqlite3_stmt* stmt; if(it == stmt_ptr_map_.end()) { sqlite3_stmt* new_stmt; int ret = sqlite3_prepare_v2(db_ptr_.get(), sql.c_str(), sql.size(), &new_stmt, NULL); if(new_stmt == NULL ) { std::cerr << "Failed to execute statement: " << sql << std::endl; return false; } if(ret != SQLITE_OK) { std::cerr << "Failed to execute statement: " << sql << ", " << ret << std::endl; sqlite3_finalize(new_stmt); return false; } stmt_ptr_map_[sql] = boost::shared_ptr<sqlite3_stmt>(new_stmt, statement_finalise()); stmt = new_stmt; } else { stmt = it->second.get(); // Reset the prepared statement, which is more efficient than re-creating // as preparing a statement is expensive. sqlite3_reset(stmt); sqlite3_clear_bindings(stmt); } #ifdef BOOST_NO_CXX11_RANGE_BASED_FOR BOOST_FOREACH(auto bit, bindings) { #else for(auto bit : bindings) { #endif int ndx = 0; if(bit.first.type() == json_spirit::int_type) { ndx = bit.first.get_int(); } else if(bit.first.type() == json_spirit::str_type) { ndx = sqlite3_bind_parameter_index(stmt, bit.first.get_str().c_str()); } else { ASSERT_LOG(false, "parameter for binding index must be int or string: " << bit.first.type()); } ASSERT_LOG(ndx != 0, "Bad index value: 0"); switch(bit.second.type()) { case json_spirit::obj_type: { json_spirit::mObject& obj = bit.second.get_obj(); std::string s = json_spirit::write(obj); sqlite3_bind_blob(stmt, ndx, static_cast<const void*>(s.c_str()), s.size(), SQLITE_TRANSIENT); break; } case json_spirit::array_type: { json_spirit::mArray& ary = bit.second.get_array(); std::string s = json_spirit::write(ary); sqlite3_bind_blob(stmt, ndx, static_cast<const void*>(s.c_str()), s.size(), SQLITE_TRANSIENT); break; } case json_spirit::str_type: { std::string s = bit.second.get_str(); sqlite3_bind_text(stmt, ndx, s.c_str(), s.size(), SQLITE_TRANSIENT); break; } case json_spirit::bool_type: { sqlite3_bind_int(stmt, ndx, bit.second.get_bool()); break; } case json_spirit::int_type: { sqlite3_bind_int(stmt, ndx, bit.second.get_int()); break; } case json_spirit::real_type: { sqlite3_bind_double(stmt, ndx, bit.second.get_real()); break; } case json_spirit::null_type: { sqlite3_bind_null(stmt, ndx); break; } } } std::vector<json_spirit::mValue> ret_rows; // Step through the statement bool stepping = true; while(stepping) { int ret = sqlite3_step(stmt); if(ret == SQLITE_ROW) { int col_count = sqlite3_column_count(stmt); for(int n = 0; n != col_count; ++n) { int type = sqlite3_column_type(stmt, n); switch(type) { case SQLITE_INTEGER: { int val = sqlite3_column_int(stmt, n); ret_rows.push_back(json_spirit::mValue(val)); break; } case SQLITE_FLOAT: { double val = sqlite3_column_double(stmt, n); ret_rows.push_back(json_spirit::mValue(val)); break; } case SQLITE_BLOB: { const char* blob = reinterpret_cast<const char *>(sqlite3_column_blob(stmt, n)); int len = sqlite3_column_bytes(stmt, n); json_spirit::mValue value; json_spirit::read(std::string(blob, blob + len), value); ret_rows.push_back(value); break; } case SQLITE_NULL: { ret_rows.push_back(json_spirit::mValue()); break; } case SQLITE_TEXT: { const uint8_t* us = sqlite3_column_text(stmt, n); int len = sqlite3_column_bytes(stmt, n); std::string s(us, us + len); ret_rows.push_back(json_spirit::mValue(s)); break; } } } } else if(ret == SQLITE_DONE) { stepping = false; } else { std::cerr << "Error stepping through statement: " << sql << ", " << ret << " : " << sqlite3_errmsg(db_ptr_.get()) << std::endl; return false; } } ASSERT_LOG(rows != NULL || ret_rows.empty() != false, "There was data to return but no place to put it."); rows->swap(ret_rows); return true; } private:
int Query::BindingIndex(std::string name) { return sqlite3_bind_parameter_index(statement, name.c_str()); }
int Statement::index(const char* arg_name) { int i = sqlite3_bind_parameter_index(stmt, arg_name); if(i <= 0) throw ValueError("The key '%s' is invalid (doesn't match with any argument.", arg_name); return i; }
static int bind_parameters( sqlite3_drv_t *drv, char *buffer, int buffer_size, int *p_index, sqlite3_stmt *statement, int *p_type, int *p_size) { // decoding parameters int i, cur_list_size = -1, param_index = 1, param_indices_are_explicit = 0, result = 0; long param_index_long; char param_name[MAXATOMLEN + 1]; // parameter names shouldn't be longer than 256! char *acc_string; result = ei_decode_list_header(buffer, p_index, &cur_list_size); if (result) { // probably all parameters are integers between 0 and 255 // and the list was encoded as string (see ei documentation) ei_get_type(buffer, p_index, p_type, p_size); if (*p_type != ERL_STRING_EXT) { return output_error(drv, SQLITE_ERROR, "error while binding parameters"); } acc_string = driver_alloc(sizeof(char*) * (*p_size + 1)); ei_decode_string(buffer, p_index, acc_string); for (param_index = 1; param_index <= *p_size; param_index++) { sqlite3_bind_int(statement, param_index, (int) acc_string[param_index - 1]); } driver_free(acc_string); return 0; } for (i = 0; i < cur_list_size; i++) { if (*p_index >= buffer_size) { return output_error(drv, SQLITE_ERROR, "error while binding parameters"); } ei_get_type(buffer, p_index, p_type, p_size); if (*p_type == ERL_SMALL_TUPLE_EXT) { int old_index = *p_index; // param with name or explicit index param_indices_are_explicit = 1; if (*p_size != 2) { return output_error(drv, SQLITE_MISUSE, "tuple should contain index or name, and value"); } ei_decode_tuple_header(buffer, p_index, p_size); ei_get_type(buffer, p_index, p_type, p_size); // first element of tuple is int (index), atom, or string (name) switch (*p_type) { case ERL_SMALL_INTEGER_EXT: case ERL_INTEGER_EXT: ei_decode_long(buffer, p_index, ¶m_index_long); param_index = param_index_long; break; case ERL_ATOM_EXT: ei_decode_atom(buffer, p_index, param_name); // insert zero terminator param_name[*p_size] = '\0'; if (strncmp(param_name, "blob", 5) == 0) { // this isn't really a parameter name! *p_index = old_index; param_indices_are_explicit = 0; goto IMPLICIT_INDEX; // yuck } else { param_index = sqlite3_bind_parameter_index(statement, param_name); } break; case ERL_STRING_EXT: if (*p_size >= MAXATOMLEN) { return output_error(drv, SQLITE_TOOBIG, "parameter name too long"); } ei_decode_string(buffer, p_index, param_name); // insert zero terminator param_name[*p_size] = '\0'; param_index = sqlite3_bind_parameter_index(statement, param_name); break; default: return output_error( drv, SQLITE_MISMATCH, "parameter index must be given as integer, atom, or string"); } result = decode_and_bind_param( drv, buffer, p_index, statement, param_index, p_type, p_size); if (result != SQLITE_OK) { return result; // error has already been output } } else { IMPLICIT_INDEX: if (param_indices_are_explicit) { return output_error( drv, SQLITE_MISUSE, "parameters without indices shouldn't follow indexed or named parameters"); } result = decode_and_bind_param( drv, buffer, p_index, statement, param_index, p_type, p_size); if (result != SQLITE_OK) { return result; // error has already been output } ++param_index; } } return result; }
int WfipsData::LoadDispatchLocations() { sqlite3_stmt *stmt, *astmt, *estmt; int rc, n, i; void *pGeom = NULL; int nFwaCount; poScenario->m_VDispLoc.clear(); if( pszAnalysisAreaWkt ) { n = CompileGeometry( pszAnalysisAreaWkt, &pGeom ); if( n > 0 ) { rc = sqlite3_prepare_v2( db, "SELECT disploc.name,fpu_code," "callback,X(disploc.geometry)," "Y(disploc.geometry) FROM " "disploc JOIN assoc ON " "name=disploc_name " "WHERE fwa_name NOT LIKE '%unassign%' " "AND substr(fwa_name, 0, 3) NOT IN " "('EA','SA','AK') " "AND fwa_name IN " "(SELECT name FROM fwa WHERE " "ST_Intersects(@geom, fwa.geometry) AND " "fwa.ROWID IN(SELECT pkid FROM " "idx_fwa_geometry WHERE " "xmin <= MbrMaxX(@geom) AND " "xmax >= MbrMinX(@geom) AND " "ymin <= MbrMaxY(@geom) AND " "ymax >= MbrMinY(@geom))) GROUP BY " "disploc.name", -1, &stmt, NULL ); rc = sqlite3_bind_blob( stmt, sqlite3_bind_parameter_index( stmt, "@geom" ), pGeom, n, sqlite3_free ); } else { return SQLITE_ERROR; } } else { rc = sqlite3_prepare_v2( db, "SELECT name,fpu_code,callback," "X(geometry), Y(geometry) FROM disploc " "JOIN assoc ON name=disploc_name WHERE " "fwa_name NOT LIKE '%unassign%' " "AND substr(fwa_name, 0, 3) NOT IN " "('EA','SA','AK') " "GROUP BY disploc.name", -1, &stmt, NULL ); } rc = sqlite3_prepare_v2( db, "SELECT fwa_name, distance FROM assoc WHERE " "disploc_name=?", -1, &astmt, NULL ); rc = sqlite3_prepare_v2( db, "SELECT COUNT(*) FROM resource WHERE disploc=?", -1, &estmt, NULL ); nFwaCount = poScenario->m_VFWA.size(); const char *pszName, *pszFpu; const char *pszFwa; int nCallBack; double dfX, dfY; double dfDist; std::map<std::string, int>::iterator it; while( sqlite3_step( stmt ) == SQLITE_ROW ) { pszName = (const char*)sqlite3_column_text( stmt, 0 ); assert( pszName ); rc = sqlite3_bind_text( estmt, 1, pszName, -1, NULL ); if( sqlite3_step( estmt ) != SQLITE_ROW || sqlite3_column_int( estmt, 0 ) < 1 ) { sqlite3_reset( estmt ); continue; } pszFpu = (const char*)sqlite3_column_text( stmt, 1 ); assert( pszFpu ); nCallBack = sqlite3_column_int( stmt, 2 ); assert( nCallBack >= 0 ); dfX = sqlite3_column_double( stmt, 3 ); assert( dfX > -180 && dfX < 360 ); dfY = sqlite3_column_double( stmt, 4 ); assert( dfY > -180 && dfY < 360 ); CDispLoc oDispLoc( std::string( pszName ), nCallBack, std::string( pszFpu ), dfY, dfX ); rc = sqlite3_bind_text( astmt, 1, pszName, -1, NULL ); while( sqlite3_step( astmt ) == SQLITE_ROW ) { pszFwa = (const char*)sqlite3_column_text( astmt, 0 ); assert( pszFwa ); dfDist = sqlite3_column_double( astmt, 1 ); assert( dfDist >= 0 ); it = FwaIndexMap.find( std::string( pszFwa ) ); if( it != FwaIndexMap.end() ) { i = it->second; poScenario->m_VFWA[i].AddAssociation( std::string( pszName ), dfDist ); oDispLoc.AddAssocFWA( &(poScenario->m_VFWA[i]) ); } } sqlite3_reset( astmt ); sqlite3_reset( estmt ); poScenario->m_VDispLoc.push_back( oDispLoc ); } sqlite3_finalize( stmt ); sqlite3_finalize( astmt ); sqlite3_finalize( estmt ); poScenario->CreateRescTypeVectors("C:/wfips/data/"); return 0; }
// Bind a string value to a parameter "?NNN", ":VVV", "@VVV" or "$VVV" in the SQL prepared statement void Statement::bind(const char* apName, const std::string& aValue) { int index = sqlite3_bind_parameter_index(mStmtPtr, apName); int ret = sqlite3_bind_text(mStmtPtr, index, aValue.c_str(), static_cast<int>(aValue.size()), SQLITE_TRANSIENT); check(ret); }
int WfipsData::LoadDispatchLogic() { sqlite3_stmt *stmt; sqlite3_stmt *rstmt; int rc, i, j, n, iLogic; void *pGeom; /* Clear our lookup */ DispLogIndexMap.clear(); poScenario->m_VDispLogic.clear(); if( pszAnalysisAreaWkt ) { n = CompileGeometry( pszAnalysisAreaWkt, &pGeom ); if( n > 0 ) { rc = sqlite3_prepare_v2( db, "SELECT displog.name,indice,num_lev,bp_1," "bp_2,bp_3,bp_4 FROM fwa JOIN displog " "ON fwa.displogic_name=displog.name " "JOIN brk_point ON " "displog.name=brk_point.name " "WHERE ST_Intersects(@geom, geometry) " "AND fwa.name NOT LIKE '%unassign%' " "AND substr(fwa.name, 0, 3) NOT IN " "('EA','SA','AK') " "AND fwa.ROWID IN " "(SELECT pkid FROM " "idx_fwa_geometry WHERE " "xmin <= MbrMaxX(@geom) AND " "xmax >= MbrMinX(@geom) AND " "ymin <= MbrMaxY(@geom) AND " "ymax >= MbrMinY(@geom)) " "group by displog.name", -1, &stmt, NULL ); rc = sqlite3_bind_blob( stmt, sqlite3_bind_parameter_index( stmt, "@geom" ), pGeom, n, sqlite3_free ); } else { /* Geometry is bad */ return SQLITE_ERROR; } } else { rc = sqlite3_prepare_v2( db, "SELECT displog.name,indice," "num_lev,bp_1,bp_2,bp_3,bp_4 FROM " "fwa JOIN displog ON " "fwa.displogic_name=displog.name " "JOIN brk_point ON " "displog.name=brk_point.name " "WHERE fwa.name NOT LIKE '%unassign%' " "AND substr(fwa.name, 0, 3) NOT IN " "('EA','SA','AK') " "GROUP BY displog.name", -1, &stmt, NULL ); } rc = sqlite3_prepare_v2( db, "SELECT * FROM num_resc WHERE name=?", -1, &rstmt, NULL ); const char *pszName, *pszIndice; int nLevels, anBps[4]; int nBp, anRescCount[13][5]; iLogic = 0; /* Push a default displogic on so we avoid errors */ poScenario->m_VDispLogic.push_back( CDispLogic() ); DispLogIndexMap.insert( std::pair<std::string, int>( poScenario->m_VDispLogic[0].GetLogicID(), iLogic++ ) ); while( sqlite3_step( stmt ) == SQLITE_ROW ) { pszName = (const char*)sqlite3_column_text( stmt, 0 ); assert( pszName ); pszIndice = (const char*)sqlite3_column_text( stmt, 1 ); /* No assert currently, but do we assume BI? */ nLevels = sqlite3_column_int( stmt, 2 ); assert( nLevels >= 3 && nLevels <= 5 ); memset( anBps, 0, sizeof( int ) * 4 ); for( i = 0; i < nLevels - 1; i++ ) { anBps[i] = sqlite3_column_int( stmt, 3 + i ); } sqlite3_bind_text( rstmt, 1, pszName, -1, NULL ); i = 0; memset( anRescCount, 0, sizeof( int ) * 13 * 5 ); while( sqlite3_step( rstmt ) == SQLITE_ROW ) { for( j = 0; j < 13; j++ ) { anRescCount[j][i] = sqlite3_column_int( rstmt, j+2 ); assert( anRescCount[j][i] >= 0 ); assert( i < 5 ); } i++; } poScenario->m_VDispLogic.push_back( CDispLogic( std::string( pszName ), std::string( pszIndice ), nLevels, anBps, anRescCount ) ); DispLogIndexMap.insert( std::pair<std::string, int>( pszName, iLogic++ ) ); sqlite3_reset( rstmt ); } assert( DispLogIndexMap.size() == poScenario->m_VDispLogic.size() ); sqlite3_finalize( stmt ); sqlite3_finalize( rstmt ); return 0; }
// Bind a text value to a parameter "?NNN", ":VVV", "@VVV" or "$VVV" in the SQL prepared statement void Statement::bind(const char* apName, const char* apValue) { int index = sqlite3_bind_parameter_index(mStmtPtr, apName); int ret = sqlite3_bind_text(mStmtPtr, index, apValue, -1, SQLITE_TRANSIENT); check(ret); }
static void _bindConstraints(sqlite3_stmt* statement, const struct mLibraryEntry* constraints) { if (!constraints) { return; } int useIndex, index; if (constraints->crc32) { useIndex = sqlite3_bind_parameter_index(statement, ":useCrc32"); index = sqlite3_bind_parameter_index(statement, ":crc32"); sqlite3_bind_int(statement, useIndex, 1); sqlite3_bind_int(statement, index, constraints->crc32); } if (constraints->filesize) { useIndex = sqlite3_bind_parameter_index(statement, ":useSize"); index = sqlite3_bind_parameter_index(statement, ":size"); sqlite3_bind_int(statement, useIndex, 1); sqlite3_bind_int64(statement, index, constraints->filesize); } if (constraints->filename) { useIndex = sqlite3_bind_parameter_index(statement, ":useFilename"); index = sqlite3_bind_parameter_index(statement, ":path"); sqlite3_bind_int(statement, useIndex, 1); sqlite3_bind_text(statement, index, constraints->filename, -1, SQLITE_TRANSIENT); } if (constraints->base) { useIndex = sqlite3_bind_parameter_index(statement, ":useRoot"); index = sqlite3_bind_parameter_index(statement, ":root"); sqlite3_bind_int(statement, useIndex, 1); sqlite3_bind_text(statement, index, constraints->base, -1, SQLITE_TRANSIENT); } if (constraints->internalCode[0]) { useIndex = sqlite3_bind_parameter_index(statement, ":useInternalCode"); index = sqlite3_bind_parameter_index(statement, ":internalCode"); sqlite3_bind_int(statement, useIndex, 1); sqlite3_bind_text(statement, index, constraints->internalCode, -1, SQLITE_TRANSIENT); } if (constraints->platform != PLATFORM_NONE) { useIndex = sqlite3_bind_parameter_index(statement, ":usePlatform"); index = sqlite3_bind_parameter_index(statement, ":platform"); sqlite3_bind_int(statement, useIndex, 1); sqlite3_bind_int(statement, index, constraints->platform); } }
int Statement::getParameterPos(const char *name) { int pos = sqlite3_bind_parameter_index(impl->stmt, name); if (!pos) throw ParameterUnknown(name); return pos - 1; }
static int pdo_sqlite_stmt_param_hook(pdo_stmt_t *stmt, struct pdo_bound_param_data *param, enum pdo_param_event event_type) { pdo_sqlite_stmt *S = (pdo_sqlite_stmt*)stmt->driver_data; zval *parameter; switch (event_type) { case PDO_PARAM_EVT_EXEC_PRE: if (stmt->executed && !S->done) { sqlite3_reset(S->stmt); S->done = 1; } if (param->is_param) { if (param->paramno == -1) { param->paramno = sqlite3_bind_parameter_index(S->stmt, ZSTR_VAL(param->name)) - 1; } switch (PDO_PARAM_TYPE(param->param_type)) { case PDO_PARAM_STMT: return 0; case PDO_PARAM_NULL: if (sqlite3_bind_null(S->stmt, param->paramno + 1) == SQLITE_OK) { return 1; } pdo_sqlite_error_stmt(stmt); return 0; case PDO_PARAM_INT: case PDO_PARAM_BOOL: if (Z_ISREF(param->parameter)) { parameter = Z_REFVAL(param->parameter); } else { parameter = ¶m->parameter; } if (Z_TYPE_P(parameter) == IS_NULL) { if (sqlite3_bind_null(S->stmt, param->paramno + 1) == SQLITE_OK) { return 1; } } else { convert_to_long(parameter); #if ZEND_LONG_MAX > 2147483647 if (SQLITE_OK == sqlite3_bind_int64(S->stmt, param->paramno + 1, Z_LVAL_P(parameter))) { return 1; } #else if (SQLITE_OK == sqlite3_bind_int(S->stmt, param->paramno + 1, Z_LVAL_P(parameter))) { return 1; } #endif } pdo_sqlite_error_stmt(stmt); return 0; case PDO_PARAM_LOB: if (Z_ISREF(param->parameter)) { parameter = Z_REFVAL(param->parameter); } else { parameter = ¶m->parameter; } if (Z_TYPE_P(parameter) == IS_RESOURCE) { php_stream *stm = NULL; php_stream_from_zval_no_verify(stm, parameter); if (stm) { zend_string *mem = php_stream_copy_to_mem(stm, PHP_STREAM_COPY_ALL, 0); zval_ptr_dtor(parameter); ZVAL_STR(parameter, mem ? mem : ZSTR_EMPTY_ALLOC()); } else { pdo_raise_impl_error(stmt->dbh, stmt, "HY105", "Expected a stream resource"); return 0; } } else if (Z_TYPE_P(parameter) == IS_NULL) { if (sqlite3_bind_null(S->stmt, param->paramno + 1) == SQLITE_OK) { return 1; } pdo_sqlite_error_stmt(stmt); return 0; } else { convert_to_string(parameter); } if (SQLITE_OK == sqlite3_bind_blob(S->stmt, param->paramno + 1, Z_STRVAL_P(parameter), Z_STRLEN_P(parameter), SQLITE_STATIC)) { return 1; } return 0; case PDO_PARAM_STR: default: if (Z_ISREF(param->parameter)) { parameter = Z_REFVAL(param->parameter); } else { parameter = ¶m->parameter; } if (Z_TYPE_P(parameter) == IS_NULL) { if (sqlite3_bind_null(S->stmt, param->paramno + 1) == SQLITE_OK) { return 1; } } else { convert_to_string(parameter); if (SQLITE_OK == sqlite3_bind_text(S->stmt, param->paramno + 1, Z_STRVAL_P(parameter), Z_STRLEN_P(parameter), SQLITE_STATIC)) { return 1; } } pdo_sqlite_error_stmt(stmt); return 0; } } break; default: ; } return 1; }
/** * \brief apply appropriate tile properties to the sqlite statement */ static void _bind_sqlite_params(mapcache_context *ctx, void *vstmt, mapcache_cache_sqlite *cache, mapcache_tile *tile) { sqlite3_stmt *stmt = vstmt; int paramidx; /* tile->x */ paramidx = sqlite3_bind_parameter_index(stmt, ":x"); if (paramidx) sqlite3_bind_int(stmt, paramidx, tile->x); /* tile->y */ paramidx = sqlite3_bind_parameter_index(stmt, ":y"); if (paramidx) sqlite3_bind_int(stmt, paramidx, tile->y); /* tile->y */ paramidx = sqlite3_bind_parameter_index(stmt, ":z"); if (paramidx) sqlite3_bind_int(stmt, paramidx, tile->z); /* eventual dimensions */ paramidx = sqlite3_bind_parameter_index(stmt, ":dim"); if (paramidx) { if (tile->dimensions) { char *dim = mapcache_util_get_tile_dimkey(ctx, tile, NULL, NULL); sqlite3_bind_text(stmt, paramidx, dim, -1, SQLITE_STATIC); } else { sqlite3_bind_text(stmt, paramidx, "", -1, SQLITE_STATIC); } } /* grid */ paramidx = sqlite3_bind_parameter_index(stmt, ":grid"); if (paramidx) sqlite3_bind_text(stmt, paramidx, tile->grid_link->grid->name, -1, SQLITE_STATIC); /* tileset */ paramidx = sqlite3_bind_parameter_index(stmt, ":tileset"); if (paramidx) sqlite3_bind_text(stmt, paramidx, tile->tileset->name, -1, SQLITE_STATIC); /* tile blob data */ paramidx = sqlite3_bind_parameter_index(stmt, ":data"); if (paramidx) { int written = 0; if(cache->detect_blank) { if(!tile->raw_image) { tile->raw_image = mapcache_imageio_decode(ctx, tile->encoded_data); GC_CHECK_ERROR(ctx); } if(mapcache_image_blank_color(tile->raw_image) != MAPCACHE_FALSE) { char *buf = apr_palloc(ctx->pool, 5* sizeof(char)); buf[0] = '#'; memcpy(buf+1,tile->raw_image->data,4); written = 1; sqlite3_bind_blob(stmt, paramidx, buf, 5, SQLITE_STATIC); } } if(!written) { if (!tile->encoded_data) { tile->encoded_data = tile->tileset->format->write(ctx, tile->raw_image, tile->tileset->format); GC_CHECK_ERROR(ctx); } if (tile->encoded_data && tile->encoded_data->size) { sqlite3_bind_blob(stmt, paramidx, tile->encoded_data->buf, tile->encoded_data->size, SQLITE_STATIC); } else { sqlite3_bind_text(stmt, paramidx, "", -1, SQLITE_STATIC); } } } }
// Bind a NULL value to a parameter "?NNN", ":VVV", "@VVV" or "$VVV" in the SQL prepared statement void Statement::bind(const char* apName) { const int index = sqlite3_bind_parameter_index(mStmtPtr, apName); const int ret = sqlite3_bind_null(mStmtPtr, index); check(ret); }
static void _mapcache_cache_mbtiles_delete(mapcache_context *ctx, mapcache_cache *pcache, mapcache_tile *tile) { mapcache_cache_sqlite *cache = (mapcache_cache_sqlite*) pcache; mapcache_pooled_connection *pc; struct sqlite_conn *conn; sqlite3_stmt *stmt1,*stmt2,*stmt3; int ret; const char *tile_id; size_t tile_id_size; pc = mapcache_sqlite_get_conn(ctx,cache,tile,0); if (GC_HAS_ERROR(ctx)) { mapcache_sqlite_release_conn(ctx, pc); return; } conn = SQLITE_CONN(pc); stmt1 = conn->prepared_statements[MBTILES_DEL_TILE_SELECT_STMT_IDX]; stmt2 = conn->prepared_statements[MBTILES_DEL_TILE_STMT1_IDX]; stmt3 = conn->prepared_statements[MBTILES_DEL_TILE_STMT2_IDX]; if(!stmt1) { sqlite3_prepare(conn->handle, "select tile_id from map where tile_col=:x and tile_row=:y and zoom_level=:z",-1,&conn->prepared_statements[MBTILES_DEL_TILE_SELECT_STMT_IDX], NULL); sqlite3_prepare(conn->handle, "delete from map where tile_col=:x and tile_row=:y and zoom_level=:z", -1, &conn->prepared_statements[MBTILES_DEL_TILE_STMT1_IDX], NULL); sqlite3_prepare(conn->handle, "delete from images where tile_id=:foobar", -1, &conn->prepared_statements[MBTILES_DEL_TILE_STMT2_IDX], NULL); stmt1 = conn->prepared_statements[MBTILES_DEL_TILE_SELECT_STMT_IDX]; stmt2 = conn->prepared_statements[MBTILES_DEL_TILE_STMT1_IDX]; stmt3 = conn->prepared_statements[MBTILES_DEL_TILE_STMT2_IDX]; } /* first extract tile_id from the tile we will delete. We need this because we do not know * if the tile is empty or not. * If it is empty, we will not delete the image blob data from the images table */ cache->bind_stmt(ctx, stmt1, cache, tile); do { ret = sqlite3_step(stmt1); if (ret != SQLITE_DONE && ret != SQLITE_ROW && ret != SQLITE_BUSY && ret != SQLITE_LOCKED) { ctx->set_error(ctx, 500, "sqlite backend failed on mbtile del 1: %s", sqlite3_errmsg(conn->handle)); sqlite3_reset(stmt1); mapcache_sqlite_release_conn(ctx, pc); return; } } while (ret == SQLITE_BUSY || ret == SQLITE_LOCKED); if (ret == SQLITE_DONE) { /* tile does not exist, ignore */ sqlite3_reset(stmt1); mapcache_sqlite_release_conn(ctx, pc); return; } else { tile_id = (const char*) sqlite3_column_text(stmt1, 0); tile_id_size = sqlite3_column_bytes(stmt1, 0); } /* delete the tile from the "map" table */ cache->bind_stmt(ctx,stmt2, cache, tile); ret = sqlite3_step(stmt2); if (ret != SQLITE_DONE && ret != SQLITE_ROW) { ctx->set_error(ctx, 500, "sqlite backend failed on mbtile del 2: %s", sqlite3_errmsg(conn->handle)); sqlite3_reset(stmt1); sqlite3_reset(stmt2); mapcache_sqlite_release_conn(ctx, pc); return; } if(tile_id[0] != '#') { /* the tile isn't empty, we must also delete from the images table */ int paramidx = sqlite3_bind_parameter_index(stmt3, ":foobar"); if (paramidx) { sqlite3_bind_text(stmt3, paramidx, tile_id, tile_id_size, SQLITE_STATIC); } ret = sqlite3_step(stmt3); if (ret != SQLITE_DONE && ret != SQLITE_ROW) { ctx->set_error(ctx, 500, "sqlite backend failed on mbtile del 3: %s", sqlite3_errmsg(conn->handle)); sqlite3_reset(stmt1); sqlite3_reset(stmt2); sqlite3_reset(stmt3); mapcache_sqlite_release_conn(ctx, pc); return; } } sqlite3_reset(stmt1); sqlite3_reset(stmt2); sqlite3_reset(stmt3); mapcache_sqlite_release_conn(ctx, pc); }
// Bind an int value to a parameter "?NNN", ":VVV", "@VVV" or "$VVV" in the SQL prepared statement void Statement::bind(const char* apName, const int& aValue) { const int index = sqlite3_bind_parameter_index(mStmtPtr, apName); const int ret = sqlite3_bind_int(mStmtPtr, index, aValue); check(ret); }
PlayerData Database::getPlayerData(const std::string& username) { // Prepare statement. std::string statementString("SELECT * FROM `players` WHERE username=:username"); sqlite3_stmt* statement; m_lastError = sqlite3_prepare(m_db, statementString.c_str(), statementString.size(), &statement, nullptr); if(m_lastError != SQLITE_OK) return PlayerData(); // Bind parameters. int usernameParameterIndex = sqlite3_bind_parameter_index(statement, ":username"); sqlite3_bind_text(statement, usernameParameterIndex, username.c_str(), username.size(), nullptr); // Execute. while(true) { int status = sqlite3_step(statement); if(status == SQLITE_BUSY) continue; break; } PlayerData playerData; playerData.dbid = sqlite3_column_int(statement, 0); const unsigned char* cuc_string_username = sqlite3_column_text(statement, 1); const char* cc_string_username = reinterpret_cast<const char*>(cuc_string_username); try { playerData.username = std::string(cc_string_username); } catch(std::exception& e) { playerData.username = ""; } const unsigned char* cuc_string_hashedPassword = sqlite3_column_text(statement, 2); const char* cc_string_hashedPassword = reinterpret_cast<const char*>(cuc_string_hashedPassword); try { playerData.hashedPassword = std::string(cc_string_hashedPassword); } catch(std::exception& e) { playerData.hashedPassword = ""; } playerData.worldId = sqlite3_column_int(statement, 3); playerData.positionX = sqlite3_column_double(statement, 4); playerData.positionY = sqlite3_column_double(statement, 5); playerData.hp = sqlite3_column_double(statement, 6); playerData.maxhp = sqlite3_column_double(statement, 7); playerData.strength = sqlite3_column_double(statement, 8); playerData.agility = sqlite3_column_double(statement, 9); playerData.resistance = sqlite3_column_double(statement, 10); playerData.xp = sqlite3_column_double(statement, 11); playerData.level = sqlite3_column_double(statement, 12); // Free. sqlite3_finalize(statement); return playerData; }