void sqlite3_db::open() { if (db_ != NULL) return; if (sqlite3_open(filename_.c_str(), &db_) != SQLITE_OK) throw database_exception(last_error()); }
statement::resultset_type statement::results() { if (sess_ == nullptr) { throw database_exception("sqlite statement results invalid database"); } return resultset_type(make_shared<resultset>(sess_, stmt_)); }
bool session::execute(const string &sql) { if (db_ == nullptr) { throw database_exception("database is not open"); } return !mysql_real_query(db_.get(), sql.c_str(), sql.length()); }
std::shared_ptr<resultset_impl> session::query(const string &sql) { sqlite3_stmt *stmt; if (db_ == nullptr) { throw database_exception("session::execute database not open"); } if (sqlite3_prepare_v2(db_.get(), sql.c_str(), -1, &stmt, nullptr) != SQLITE_OK) { throw database_exception(last_error()); } if (cache_level() == cache::ResultSet) { return make_shared<cached_resultset>(shared_from_this(), shared_ptr<sqlite3_stmt>(stmt, helper::stmt_delete())); } else { return make_shared<resultset>(shared_from_this(), shared_ptr<sqlite3_stmt>(stmt, helper::stmt_delete())); } }
void statement::prepare(const string &sql) { if (!sess_ || !sess_->db_) { throw database_exception("database not open"); } if (is_valid()) { log::warn("sql statement prepare not valid"); return; } sqlite3_stmt *temp; if (sqlite3_prepare_v2(sess_->db_.get(), sql.c_str(), -1, &temp, NULL) != SQLITE_OK) { throw database_exception(sess_->last_error()); } stmt_ = shared_ptr<sqlite3_stmt>(temp, helper::stmt_delete()); }
void statement::reset() { if (!is_valid()) { log::warn("sqlite statement reset invalid"); return; } if (sqlite3_reset(stmt_.get()) != SQLITE_OK) { throw database_exception(sess_->last_error()); } }
std::shared_ptr<session> sqldb::create_session(const uri &uri) { auto factory = instance()->factories_[uri.protocol]; if (factory == nullptr) { throw database_exception("unknown database " + uri.value); } return std::make_shared<session>(factory->create(uri)); }
std::shared_ptr<resultset_impl> session::query(const string &sql) { MYSQL_RES *res = nullptr; if (db_ == nullptr) { throw database_exception("database is not open"); } if (mysql_real_query(db_.get(), sql.c_str(), sql.length())) { throw database_exception(last_error()); } res = mysql_store_result(db_.get()); if (res == nullptr && mysql_field_count(db_.get()) != 0) { throw database_exception(last_error()); } return make_shared<resultset>(shared_from_this(), shared_ptr<MYSQL_RES>(res, helper::res_delete())); }
resultset sqlite3_db::execute(const string &sql) { sqlite3_stmt *stmt; if (sqlite3_prepare_v2(db_, sql.c_str(), -1, &stmt, NULL) != SQLITE_OK) throw database_exception(last_error()); resultset set(make_shared<sqlite3_resultset>(this, stmt)); set.next(); return set; }
void connection::open(std::string const & db, sqlite::open_mode open_mode){ boost::system::error_code ec; bool exists = boost::filesystem::exists(db, ec); exists = exists && !ec; switch(open_mode) { case sqlite::open_mode::open_readonly: if (!exists) { throw database_exception( "Read-only database '" + db + "' does not exist" ); } open(db, true); // read-only return; // we already opened it! case sqlite::open_mode::open_existing: if(!exists) { throw database_exception( "Database '" + db + "' does not exist" ); } break; case sqlite::open_mode::always_create: if(exists) { boost::filesystem::remove(db, ec); if(ec) { throw database_system_error( "Failed to remove existing database '" + db + "'", ec.value() ); } } // fall-through case sqlite::open_mode::open_or_create: // Default behaviour break; default: break; }; open(db); }
void session::open(int flags) { if (db_ != nullptr) { return; } sqlite3 *conn = nullptr; if (sqlite3_open_v2(connection_info().path.c_str(), &conn, flags, nullptr) != SQLITE_OK) { throw database_exception(last_error()); } db_ = shared_ptr<sqlite3>(conn, helper::close_db()); }
column sqlite3_row::column(const string &name) const { assert(!name.empty()); for (size_t i = 0; i < size_; i++) { const char *col_name = sqlite3_column_name(stmt_, i); if (name == col_name) { return column(i); } } throw database_exception("unknown column '" + name + "'"); }
bool session::execute(const string &sql) { sqlite3_stmt *stmt; if (db_ == nullptr) { throw database_exception("session::execute database not open"); } if (sqlite3_prepare_v2(db_.get(), sql.c_str(), -1, &stmt, nullptr) != SQLITE_OK) { return false; } int res = sqlite3_step(stmt); sqlite3_finalize(stmt); return res == SQLITE_OK || res == SQLITE_ROW || res == SQLITE_DONE; }
int modify_query::execute() { if (!is_valid()) { throw database_exception("Invalid modify query"); } prepare(to_sql()); bool success = stmt_->result(); if (success) { numChanges_ = stmt_->last_number_of_changes(); } else { numChanges_ = 0; } reset(); return numChanges_; }
void mysql_stmt_resultset::get_results() { if (stmt_ == NULL || bindings_ != NULL || status_ != -1) return; if ((status_ = mysql_stmt_execute(stmt_))) { throw database_exception(last_stmt_error(stmt_)); } metadata_ = mysql_stmt_result_metadata(stmt_); if (metadata_ == NULL) throw database_exception("No result data found."); columnCount_ = mysql_num_fields(metadata_); bindings_ = (MYSQL_BIND *) calloc(columnCount_, sizeof(MYSQL_BIND)); auto fields = mysql_fetch_fields(metadata_); for (auto i = 0; i < columnCount_; i++) { switch (fields[i].type) { case MYSQL_TYPE_INT24: bindings_[i].buffer_type = MYSQL_TYPE_LONGLONG; break; case MYSQL_TYPE_DECIMAL: case MYSQL_TYPE_NEWDECIMAL: bindings_[i].buffer_type = MYSQL_TYPE_DOUBLE; break; case MYSQL_TYPE_BIT: bindings_[i].buffer_type = MYSQL_TYPE_TINY; break; case MYSQL_TYPE_YEAR: break; case MYSQL_TYPE_VAR_STRING: bindings_[i].buffer_type = MYSQL_TYPE_STRING; break; case MYSQL_TYPE_SET: case MYSQL_TYPE_ENUM: case MYSQL_TYPE_GEOMETRY: break; default: bindings_[i].buffer_type = fields[i].type; break; } bindings_[i].is_null = (my_bool *) calloc(1, sizeof(my_bool)); bindings_[i].is_unsigned = 0; bindings_[i].error = 0; bindings_[i].buffer_length = fields[i].length; bindings_[i].length = (size_t *) calloc(1, sizeof(size_t)); bindings_[i].buffer = calloc(1, fields[i].length); } if (mysql_stmt_bind_result(stmt_, bindings_) != 0) { throw database_exception(last_stmt_error(stmt_)); } }
void connection::access_check(){ if(!handle) throw database_exception("Database is not open."); }
void sqlite3_statement::reset() { if (sqlite3_reset(stmt_) != SQLITE_OK) throw database_exception(db_->last_error()); }
/*! * @param schema the schema to operate on * @param columnName the name of the id column in the schema */ record::record(const std::shared_ptr<schema_type> &schema) : schema_(schema) { if (schema_ == nullptr) { throw database_exception("no schema for record"); } }
statement::statement(const std::shared_ptr<sqlite::session> &sess) : sess_(sess), stmt_(nullptr), bound_(0) { if (sess_ == NULL) { throw database_exception("no database provided to sqlite3 statement"); } }
row::row(const shared_ptr<row_impl> &impl) : impl_(impl) { if (impl_ == nullptr) { throw database_exception("No implementation provided for row"); } }
boost::int64_t connection::get_last_insert_rowid(){ if(!handle) throw database_exception("Database is not open."); return static_cast<boost::int64_t>( sqlite3_last_insert_rowid(handle)); }