ref_ptr<statement> connection::get_prepared_statement(std::string const &q) { ref_ptr<statement> st; if(!cache_.active()) { st = prepare_statement(q); return st; } st = cache_.fetch(q); if(!st) st = prepare_statement(q); st->cache(&cache_); return st; }
size_t connection::last_insert_id(){ std::string statement; switch(_handle->type){ case ODBC_Type::MySQL: statement = "SELECT LAST_INSERT_ID()"; break; case ODBC_Type::TSQL: statement = "SELECT SCOPE_IDENTITY"; break; case ODBC_Type::SQLite3: statement = "SELECT last_insert_rowid()"; break; case ODBC_Type::PostgreSQL: statement = "SELECT LASTVAL()"; break; default: throw sqlpp::exception("Can't get last insert id for ODBC_Type "+std::to_string(static_cast<int>(_handle->type))); } auto prepared_statement = prepare_statement(*_handle, statement); execute_statement(prepared_statement->stmt); int64_t ret; bool is_null; bind_result_t result(prepared_statement); if(!result.next_impl()){ std::cerr << "ODBC warning: next_impl failed!" << std::endl; return 0; } result._bind_integral_result(0, &ret, &is_null); if(is_null) { std::cerr << "ODBC warning: NULL returned from " << statement << std::endl; return 0; } return ret; }
size_t connection::insert_impl(const std::string& statement) { auto prepared = prepare_statement(*_handle, statement); execute_statement(*_handle, prepared); return sqlite3_last_insert_rowid(_handle->sqlite); }
bind_result_t connection::select_impl(const std::string& statement) { auto prepared = prepare_statement(*_handle, statement); if(!prepared || !*prepared) { throw sqlpp::exception("ODBC error: Could not store result set"); } execute_statement(prepared->stmt); return bind_result_t(prepared); }
void SQLiteQuery::Reset(const char* query) { copy_query(query); if (stmt) { sqlite3_finalize(stmt); stmt = NULL; } prepare_statement(); }
void connection::commit_transaction() { if (not _transaction_active) { throw sqlpp::exception("Sqlite3 error: Cannot commit a finished or failed transaction"); } _transaction_active = false; auto prepared = prepare_statement(*_handle, "COMMIT"); execute_statement(*_handle, prepared); }
void connection::start_transaction() { if (_transaction_active) { throw sqlpp::exception("Sqlite3 error: Cannot have more than one open transaction per connection"); } auto prepared = prepare_statement(*_handle, "BEGIN"); execute_statement(*_handle, prepared); _transaction_active = true; }
void connection::rollback_transaction(bool report) { if (not _transaction_active) { throw sqlpp::exception("Sqlite3 error: Cannot rollback a finished or failed transaction"); } if (report) { std::cerr << "Sqlite3 warning: Rolling back unfinished transaction" << std::endl; } _transaction_active = false; auto prepared = prepare_statement(*_handle, "ROLLBACK"); execute_statement(*_handle, prepared); }
svn_error_t * svn_sqlite__read_schema_version(int *version, svn_sqlite__db_t *db, apr_pool_t *scratch_pool) { svn_sqlite__stmt_t *stmt; SVN_ERR(prepare_statement(&stmt, db, "PRAGMA user_version;", scratch_pool)); SVN_ERR(svn_sqlite__step_row(stmt)); *version = svn_sqlite__column_int(stmt, 0); return svn_error_trace(svn_sqlite__finalize(stmt)); }
int evaluate(shell_state_t *state, evaluation_queue_t *queue, const cypher_quick_parse_segment_t *segment) { size_t n; const char *s = cypher_quick_parse_segment_get_text(segment, &n); if (n == 0) { return 0; } struct cypher_input_range range = cypher_quick_parse_segment_get_range(segment); if (cypher_quick_parse_segment_is_command(segment)) { // drain queue before running commands int err = finalize(state, queue, queue->depth); if (err) { return err; } return evaluate_command(state, s, n, range.start); } assert(queue->depth <= queue->capacity); if ((queue->depth >= queue->capacity) && finalize(state, queue, 1)) { neo4j_perror(state->err, errno, "unexpected error"); return -1; } assert(queue->depth < queue->capacity); evaluation_continuation_t *continuation = prepare_statement(state, s, n, range.start); if (continuation == NULL) { neo4j_perror(state->err, errno, "unexpected error"); return -1; } unsigned int i = queue->next + queue->depth; if (i >= queue->capacity) { i -= queue->capacity; } queue->continuations[i] = continuation; ++(queue->depth); return 0; }
char * sound_hash(const char *str, int len, enum sound_hash_type type) { sqlite3 *sqldb = get_shared_db(); sqlite3_stmt *hasher; char *utf8, *result = NULL; int ulen; int status; switch (type) { case HASH_SOUNDEX: /* Classic Penn soundex turns a leading ph into f. This makes sense but isn't typical. */ hasher = prepare_statement(sqldb, "VALUES (soundex(CASE WHEN ?1 LIKE 'ph%' THEN " "printf('f%s', substr(?1, 3)) ELSE ?1 END))", "hash.soundex"); break; case HASH_PHONE: hasher = prepare_statement(sqldb, "VALUES (spellfix1_phonehash(?))", "hash.phone"); break; default: return NULL; } utf8 = latin1_to_utf8(str, len, &ulen, "string"); sqlite3_bind_text(hasher, 1, utf8, ulen, free_string); status = sqlite3_step(hasher); if (status == SQLITE_ROW) { result = mush_strdup((const char *) sqlite3_column_text(hasher, 0), "string"); } sqlite3_reset(hasher); return result; }
/* Like svn_sqlite__get_statement but gets an internal statement. All internal statements that use this api are executed with step_done(), so we don't need the fallback reset handling here or in the pool cleanup */ static svn_error_t * get_internal_statement(svn_sqlite__stmt_t **stmt, svn_sqlite__db_t *db, int stmt_idx) { /* The internal statements are stored after the registered statements */ int prep_idx = db->nbr_statements + stmt_idx; SVN_ERR_ASSERT(stmt_idx < STMT_INTERNAL_LAST); if (db->prepared_stmts[prep_idx] == NULL) SVN_ERR(prepare_statement(&db->prepared_stmts[prep_idx], db, internal_statements[stmt_idx], db->state_pool)); *stmt = db->prepared_stmts[prep_idx]; return SVN_NO_ERROR; }
svn_error_t * svn_sqlite__get_statement(svn_sqlite__stmt_t **stmt, svn_sqlite__db_t *db, int stmt_idx) { SVN_ERR_ASSERT(stmt_idx < db->nbr_statements); if (db->prepared_stmts[stmt_idx] == NULL) SVN_ERR(prepare_statement(&db->prepared_stmts[stmt_idx], db, db->statement_strings[stmt_idx], db->state_pool)); *stmt = db->prepared_stmts[stmt_idx]; if ((*stmt)->needs_reset) return svn_error_trace(svn_sqlite__reset(*stmt)); return SVN_NO_ERROR; }
prepared_statement_t connection::prepare_impl(const std::string& statement, size_t no_of_parameters, size_t no_of_columns) { return prepare_statement(*_handle, statement, no_of_parameters, no_of_columns); }
prepared_statement_t connection::prepare_impl(const std::string& statement) { return { std::unique_ptr<detail::prepared_statement_handle_t>(new detail::prepared_statement_handle_t(prepare_statement(*_handle, statement))) }; }
ref_ptr<statement> connection::get_prepared_uncached_statement(std::string const &q) { ref_ptr<statement> st = prepare_statement(q); return st; }
size_t connection::remove_impl(const std::string& statement) { auto prepared = prepare_statement(*_handle, statement); execute_statement(*_handle, prepared); return sqlite3_changes(_handle->sqlite); }
//----------------------------------------------------------------------------------------- // Class: SQLiteQuery // Purpose: Provide an interface for executing prepared queries // SQLiteQuery::SQLiteQuery(SQLite& parent, const char* query) : SQLiteObject(parent), query(NULL), stmt(NULL) { copy_query(query); prepare_statement(); }
bind_result_t connection::select_impl(const std::string& statement) { std::unique_ptr<detail::prepared_statement_handle_t> prepared(new detail::prepared_statement_handle_t(prepare_statement(*_handle, statement))); if (!prepared) { throw sqlpp::exception("Sqlite3 error: Could not store result set"); } return {std::move(prepared)}; }
size_t connection::remove_impl(const std::string& statement) { auto prepared = prepare_statement(*_handle, statement); execute_statement(prepared->stmt); return odbc_affected(prepared->stmt); }
prepared_statement_t connection::prepare_impl(const std::string& statement) { return prepared_statement_t(prepare_statement(*_handle, statement)); }
size_t connection::insert_impl(const std::string& statement) { auto prepared = prepare_statement(*_handle, statement); execute_statement(prepared->stmt); return last_insert_id(); }
/** * Get internal handle for a prepared statement. This function should rarely * be used, and if, with caution! On failures during the interaction with * the handle, you must call 'GNUNET_MYSQL_statements_invalidate'! * * @param sh prepared statement to introspect * @return MySQL statement handle, NULL on error */ MYSQL_STMT * GNUNET_MYSQL_statement_get_stmt (struct GNUNET_MYSQL_StatementHandle *sh) { (void) prepare_statement (sh); return sh->statement; }