AaronPo/the-biergarten-app
1
0
Fork 0
mirror of https://github.com/aaronpo97/the-biergarten-app.git synced 2026-10-15 01:54:43 +00:00
Code Issues Packages Projects Releases Wiki Activity

Formatted src/services/sqlite/helpers

Browse Source
This commit is contained in:
Aaron Po
2026-07-19 04:10:33 -04:00
parent 5d48d6757a
commit a238db1d37
2 changed files with 85 additions and 85 deletions
Download Patch File Download Diff File Expand all files Collapse all files

70
tooling/pipeline/src/services/sqlite/helpers/sqlite_connection_helpers.cc
View File

@@ -6,62 +6,62 @@
namespace sqlite_export_service_internal { namespace sqlite_export_service_internal {
void SqliteDatabaseDeleter::operator()(sqlite3* handle) const noexcept { void SqliteDatabaseDeleter::operator()(sqlite3* handle) const noexcept {
if (handle != nullptr) { if (handle != nullptr) {
sqlite3_close(handle); sqlite3_close(handle);
} }
} }
void SqliteStatementDeleter::operator()( void SqliteStatementDeleter::operator()(
sqlite3_stmt* statement) const noexcept { sqlite3_stmt* statement) const noexcept {
if (statement != nullptr) { if (statement != nullptr) {
sqlite3_finalize(statement); sqlite3_finalize(statement);
} }
} }
void ThrowSqliteError(sqlite3* db_handle, std::string_view action) { void ThrowSqliteError(sqlite3* db_handle, std::string_view action) {
const std::string message = const std::string message = db_handle != nullptr ? sqlite3_errmsg(db_handle)
db_handle != nullptr ? sqlite3_errmsg(db_handle) : "unknown SQLite error"; : "unknown SQLite error";
throw std::runtime_error(std::format("{}: {}", action, message)); throw std::runtime_error(std::format("{}: {}", action, message));
} }
SqliteDatabaseHandle OpenDatabase(const std::filesystem::path& path) { SqliteDatabaseHandle OpenDatabase(const std::filesystem::path& path) {
sqlite3* raw_handle = nullptr; sqlite3* raw_handle = nullptr;
const int result = sqlite3_open(path.string().c_str(), &raw_handle); const int result = sqlite3_open(path.string().c_str(), &raw_handle);
SqliteDatabaseHandle handle(raw_handle); SqliteDatabaseHandle handle(raw_handle);
if (result != SQLITE_OK) { if (result != SQLITE_OK) {
const std::string message = raw_handle != nullptr const std::string message = raw_handle != nullptr
? sqlite3_errmsg(raw_handle) ? sqlite3_errmsg(raw_handle)
: "unknown SQLite error"; : "unknown SQLite error";
throw std::runtime_error("Failed to open SQLite export database: " + throw std::runtime_error("Failed to open SQLite export database: " +
message); message);
} }
return handle; return handle;
} }
void ExecSql(const SqliteDatabaseHandle& db_handle, std::string_view sql, void ExecSql(const SqliteDatabaseHandle& db_handle, std::string_view sql,
const char* action) { const char* action) {
char* error_message = nullptr; char* error_message = nullptr;
const std::string sql_text(sql); const std::string sql_text(sql);
const int result = sqlite3_exec(db_handle.get(), sql_text.c_str(), nullptr, const int result = sqlite3_exec(db_handle.get(), sql_text.c_str(), nullptr,
nullptr, &error_message); nullptr, &error_message);
if (result != SQLITE_OK) { if (result != SQLITE_OK) {
const std::string message = error_message != nullptr const std::string message = error_message != nullptr
? error_message ? error_message
: sqlite3_errmsg(db_handle.get()); : sqlite3_errmsg(db_handle.get());
sqlite3_free(error_message); sqlite3_free(error_message);
throw std::runtime_error(std::format("{}: {}", action, message)); throw std::runtime_error(std::format("{}: {}", action, message));
} }
} }
void RollbackTransactionNoThrow( void RollbackTransactionNoThrow(
const SqliteDatabaseHandle& db_handle) noexcept { const SqliteDatabaseHandle& db_handle) noexcept {
if (!db_handle) { if (!db_handle) {
return; return;
} }
sqlite3_exec(db_handle.get(), "ROLLBACK;", nullptr, nullptr, nullptr); sqlite3_exec(db_handle.get(), "ROLLBACK;", nullptr, nullptr, nullptr);
} }
} // namespace sqlite_export_service_internal } // namespace sqlite_export_service_internal

100
tooling/pipeline/src/services/sqlite/helpers/sqlite_statement_helpers.cc
View File

@@ -13,87 +13,87 @@ namespace sqlite_export_service_internal {
SqliteStatementHandle PrepareStatement(const SqliteDatabaseHandle& db_handle, SqliteStatementHandle PrepareStatement(const SqliteDatabaseHandle& db_handle,
std::string_view sql, std::string_view sql,
const char* action) { const char* action) {
sqlite3_stmt* raw_statement = nullptr; sqlite3_stmt* raw_statement = nullptr;
const std::string sql_text(sql); const std::string sql_text(sql);
const int result = sqlite3_prepare_v2(db_handle.get(), sql_text.c_str(), -1, const int result = sqlite3_prepare_v2(db_handle.get(), sql_text.c_str(), -1,
&raw_statement, nullptr); &raw_statement, nullptr);
SqliteStatementHandle statement(raw_statement); SqliteStatementHandle statement(raw_statement);
if (result != SQLITE_OK) { if (result != SQLITE_OK) {
ThrowSqliteError(db_handle.get(), action); ThrowSqliteError(db_handle.get(), action);
} }
return statement; return statement;
} }
void ResetStatement(SqliteStatementHandle& statement) { void ResetStatement(SqliteStatementHandle& statement) {
if (statement != nullptr) { if (statement != nullptr) {
sqlite3_reset(statement.get()); sqlite3_reset(statement.get());
sqlite3_clear_bindings(statement.get()); sqlite3_clear_bindings(statement.get());
} }
} }
void Bind(const SqliteStatementHandle& statement, void Bind(const SqliteStatementHandle& statement,
const BoundParam<std::string_view>& param) { const BoundParam<std::string_view>& param) {
const auto byte_count = param.value.size(); const auto byte_count = param.value.size();
if (byte_count > static_cast<std::size_t>(std::numeric_limits<int>::max())) { if (byte_count > static_cast<std::size_t>(std::numeric_limits<int>::max())) {
ThrowSqliteError(sqlite3_db_handle(statement.get()), param.action); ThrowSqliteError(sqlite3_db_handle(statement.get()), param.action);
} }
auto delete_char_array = [](void* data) noexcept { auto delete_char_array = [](void* data) noexcept {
// NOLINT(cppcoreguidelines-owning-memory) // NOLINT(cppcoreguidelines-owning-memory)
delete[] static_cast<char*>(data); delete[] static_cast<char*>(data);
}; };
// NOLINT(cppcoreguidelines-avoid-c-arrays, modernize-avoid-c-arrays) // NOLINT(cppcoreguidelines-avoid-c-arrays, modernize-avoid-c-arrays)
auto buffer = std::make_unique<char[]>(byte_count + 1); auto buffer = std::make_unique<char[]>(byte_count + 1);
std::memcpy(buffer.get(), param.value.data(), byte_count); std::memcpy(buffer.get(), param.value.data(), byte_count);
buffer[byte_count] = '\0'; buffer[byte_count] = '\0';
char* raw_buffer = buffer.release(); char* raw_buffer = buffer.release();
if (sqlite3_bind_text(statement.get(), param.index, raw_buffer, if (sqlite3_bind_text(statement.get(), param.index, raw_buffer,
static_cast<int>(byte_count), static_cast<int>(byte_count),
delete_char_array) != SQLITE_OK) { delete_char_array) != SQLITE_OK) {
delete_char_array(raw_buffer); delete_char_array(raw_buffer);
ThrowSqliteError(sqlite3_db_handle(statement.get()), param.action); ThrowSqliteError(sqlite3_db_handle(statement.get()), param.action);
} }
} }
void Bind(const SqliteStatementHandle& statement, void Bind(const SqliteStatementHandle& statement,
const BoundParam<double>& param) { const BoundParam<double>& param) {
if (sqlite3_bind_double(statement.get(), param.index, param.value) != if (sqlite3_bind_double(statement.get(), param.index, param.value) !=
SQLITE_OK) { SQLITE_OK) {
ThrowSqliteError(sqlite3_db_handle(statement.get()), param.action); ThrowSqliteError(sqlite3_db_handle(statement.get()), param.action);
} }
} }
void Bind(const SqliteStatementHandle& statement, void Bind(const SqliteStatementHandle& statement,
const BoundParam<sqlite3_int64>& param) { const BoundParam<sqlite3_int64>& param) {
if (sqlite3_bind_int64(statement.get(), param.index, param.value) != if (sqlite3_bind_int64(statement.get(), param.index, param.value) !=
SQLITE_OK) { SQLITE_OK) {
ThrowSqliteError(sqlite3_db_handle(statement.get()), param.action); ThrowSqliteError(sqlite3_db_handle(statement.get()), param.action);
} }
} }
void StepStatement(const SqliteDatabaseHandle& db_handle, void StepStatement(const SqliteDatabaseHandle& db_handle,
const SqliteStatementHandle& statement, const SqliteStatementHandle& statement,
std::string_view action) { std::string_view action) {
if (sqlite3_step(statement.get()) != SQLITE_DONE) { if (sqlite3_step(statement.get()) != SQLITE_DONE) {
ThrowSqliteError(db_handle.get(), action); ThrowSqliteError(db_handle.get(), action);
} }
} }
sqlite3_int64 LastInsertRowId(const SqliteDatabaseHandle& db_handle) { sqlite3_int64 LastInsertRowId(const SqliteDatabaseHandle& db_handle) {
return sqlite3_last_insert_rowid(db_handle.get()); return sqlite3_last_insert_rowid(db_handle.get());
} }
std::string SerializeVector(const std::vector<std::string>& str_vec) { std::string SerializeVector(const std::vector<std::string>& str_vec) {
boost::json::array array; boost::json::array array;
array.reserve(str_vec.size()); array.reserve(str_vec.size());
for (const auto& s : str_vec) { for (const auto& s : str_vec) {
array.emplace_back(s); array.emplace_back(s);
} }
return boost::json::serialize(array); return boost::json::serialize(array);
} }
} // namespace sqlite_export_service_internal } // namespace sqlite_export_service_internal