8#include <botan/sqlite3.h>
10#include <botan/assert.h>
11#include <botan/mem_ops.h>
12#include <botan/internal/fmt.h>
13#include <botan/internal/int_utils.h>
21 const int open_flags =
22 sqlite_open_flags.value_or(SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE | SQLITE_OPEN_FULLMUTEX);
23 sqlite3* db =
nullptr;
24 const int rc = ::sqlite3_open_v2(std::string(db_filename).c_str(), &db, open_flags,
nullptr);
26 if(rc != 0) [[unlikely]] {
27 const std::string err_msg = (db !=
nullptr) ? ::sqlite3_errmsg(db) :
"unknown error";
28 ::sqlite3_close_v2(db);
32 m_db = std::shared_ptr<sqlite3>(db, [](sqlite3* p)
noexcept { ::sqlite3_close_v2(p); });
38 return std::make_shared<Sqlite3_Statement>(m_db, base_sql);
42 std::string_view table, std::initializer_list<std::string_view> columns)
const {
43 BOTAN_ARG_CHECK(columns.size() > 0,
"upsert requires at least one column");
45 std::string sql =
"INSERT OR REPLACE INTO ";
49 for(
const auto& col : columns) {
57 for(
size_t i = 1; i <= columns.size(); ++i) {
73 return stmt->get_size_t(0);
75 throw SQL_DB_Error(
fmt(
"Querying size of table '{}' failed", table_name));
83 std::string sql =
"CREATE TABLE ";
85 sql +=
"IF NOT EXISTS ";
90 for(
const auto& col : schema.
columns()) {
107 if(col.is_primary_key()) {
108 sql +=
" PRIMARY KEY";
110 if(col.is_unique()) {
113 if(col.is_not_null()) {
120 char* errmsg =
nullptr;
121 const int rc = ::sqlite3_exec(m_db.get(), sql.c_str(),
nullptr,
nullptr, &errmsg);
123 if(rc != SQLITE_OK) {
124 const std::string err_msg = (errmsg !=
nullptr) ? errmsg :
"unknown error";
125 ::sqlite3_free(errmsg);
126 throw SQL_DB_Error(
"sqlite3_exec for create_table failed - " + err_msg, rc);
131 const auto result = ::sqlite3_changes64(m_db.get());
133 return static_cast<size_t>(result);
143 return ::sqlite3_db_mutex(m_db.get()) !=
nullptr;
146Sqlite3_Database::Sqlite3_Statement::Sqlite3_Statement(std::shared_ptr<sqlite3> db, std::string_view base_sql) :
147 m_db(std::move(db)), m_stmt{} {
149 ::sqlite3_prepare_v2(m_db.get(), base_sql.data(),
static_cast<int>(base_sql.size()), &m_stmt,
nullptr);
151 if(rc != SQLITE_OK) {
152 throw SQL_DB_Error(
fmt(
"sqlite3_prepare failed on '{}' with err {}", base_sql, rc), rc);
156void Sqlite3_Database::Sqlite3_Statement::bind(
int column, std::string_view val) {
157 if(val.data() ==
nullptr) {
161 const int rc = ::sqlite3_bind_text64(m_stmt, column, val.data(), val.size(), SQLITE_TRANSIENT, SQLITE_UTF8);
162 if(rc != SQLITE_OK) {
163 throw SQL_DB_Error(
"sqlite3_bind_text failed", rc);
167void Sqlite3_Database::Sqlite3_Statement::bind(
int column,
size_t val) {
168 const int rc = ::sqlite3_bind_int64(m_stmt, column, val);
169 if(rc != SQLITE_OK) {
174void Sqlite3_Database::Sqlite3_Statement::bind(
int column, std::chrono::system_clock::time_point time) {
175 const uint64_t timeval = std::chrono::duration_cast<std::chrono::seconds>(time.time_since_epoch()).count();
176 bind(column,
static_cast<size_t>(timeval));
179void Sqlite3_Database::Sqlite3_Statement::bind(
int column,
const std::vector<uint8_t>& val) {
180 bind(column, val.data(), val.size());
183void Sqlite3_Database::Sqlite3_Statement::bind(
int column,
const uint8_t* p,
size_t len) {
188 const int rc = ::sqlite3_bind_blob64(m_stmt, column, p, len, SQLITE_TRANSIENT);
189 if(rc != SQLITE_OK) {
194void Sqlite3_Database::Sqlite3_Statement::bind_null(
int column) {
195 const int rc = ::sqlite3_bind_null(m_stmt, column);
196 if(rc != SQLITE_OK) {
201std::span<const uint8_t> Sqlite3_Database::Sqlite3_Statement::get_blob(
int column) {
202 const auto column_type = ::sqlite3_column_type(m_stmt, column);
203 if(column_type == SQLITE_NULL) {
207 BOTAN_ASSERT(column_type == SQLITE_BLOB,
"Return value is a blob");
209 const void* session_blob = ::sqlite3_column_blob(m_stmt, column);
210 const int session_blob_size = ::sqlite3_column_bytes(m_stmt, column);
212 BOTAN_ASSERT(session_blob_size >= 0,
"Blob size is non-negative");
214 return {
static_cast<const uint8_t*
>(session_blob),
static_cast<size_t>(session_blob_size)};
217std::optional<std::string> Sqlite3_Database::Sqlite3_Statement::get_str(
int column) {
218 const auto column_type = ::sqlite3_column_type(m_stmt, column);
219 if(column_type == SQLITE_NULL) {
223 BOTAN_ASSERT(column_type == SQLITE_TEXT,
"Return value is text");
225 const unsigned char* str = ::sqlite3_column_text(m_stmt, column);
226 const int len = ::sqlite3_column_bytes(m_stmt, column);
232size_t Sqlite3_Database::Sqlite3_Statement::get_size_t(
int column) {
233 BOTAN_ASSERT(::sqlite3_column_type(m_stmt, column) == SQLITE_INTEGER,
"Return count is an integer");
248 const int rc = ::sqlite3_step(m_stmt);
249 if(rc == SQLITE_ROW) {
252 if(rc == SQLITE_DONE) {
255 throw SQL_DB_Error(
fmt(
"sqlite3_step failed - {}", ::sqlite3_errmsg(::sqlite3_db_handle(m_stmt))), rc);
258Sqlite3_Database::Sqlite3_Statement::~Sqlite3_Statement() {
259 ::sqlite3_finalize(m_stmt);
#define BOTAN_ASSERT_NOMSG(expr)
#define BOTAN_ARG_CHECK(expr, msg)
#define BOTAN_ASSERT(expr, assertion_made)
bool is_if_not_exists() const
const std::string & name() const
const std::vector< Column > & columns() const
virtual bool is_valid_table_name(std::string_view table) const
std::shared_ptr< Statement > upsert(std::string_view table, std::initializer_list< std::string_view > columns) const override
~Sqlite3_Database() override
std::shared_ptr< Statement > new_statement(std::string_view sql) const override
size_t rows_changed_by_last_statement() override
bool is_threadsafe() const override
BOTAN_FUTURE_EXPLICIT Sqlite3_Database(std::string_view file, std::optional< int > sqlite_open_flags=std::nullopt)
size_t row_count(std::string_view table_name) override
void create_table(const Table_Schema &schema) override
std::string fmt(std::string_view format, const T &... args)
constexpr RT checked_cast_to(AT i)
const char * cast_uint8_ptr_to_char(const uint8_t *b)