Refactor SQLite Export Service and ProcessRecord Method Signatures (#216)

* Helper cleanup

update bind to use dto for params
consolidate translation units


* Update planned class diagram

tooling/pipeline/src/services/sqlite/build_location_key.cc

@@ -1,28 +0,0 @@
-/**
- * @file services/sqlite/build_location_key.cc
- * @brief SqliteExportService::BuildLocationKey() implementation.
- */
-
-#include <iomanip>
-#include <sstream>
-
-#include "services/sqlite_export_service.h"
-#include "services/sqlite_export_service_helpers.h"
-
-constexpr int kLocationPrecision = 17;
-
-std::string SqliteExportService::BuildLocationKey(const Location& location) {
-  std::ostringstream key_stream;
-  key_stream << location.city << '\n'
-             << location.state_province << '\n'
-             << location.iso3166_2 << '\n'
-             << location.country << '\n'
-             << location.iso3166_1 << '\n'
-             << std::setprecision(kLocationPrecision) << location.latitude
-             << '\n'
-             << std::setprecision(kLocationPrecision) << location.longitude
-             << '\n'
-             << sqlite_export_service_internal::SerializeLocalLanguages(
-                    location.local_languages);
-  return key_stream.str();
-}

tooling/pipeline/src/services/sqlite/finalize.cc

@@ -8,13 +8,15 @@
 #include "services/sqlite_export_service.h"
 #include "services/sqlite_export_service_helpers.h"
 
+
 void SqliteExportService::Finalize() {
   if (db_handle_ == nullptr) {
     return;
   }
 
   try {
-    FinalizeStatements();
+    insert_brewery_stmt_.reset();
+    insert_location_stmt_.reset();
     if (transaction_open_) {
       sqlite_export_service_internal::ExecSql(
           db_handle_, "COMMIT;", "Failed to commit SQLite transaction");
@@ -27,4 +29,4 @@ void SqliteExportService::Finalize() {
     RollbackAndCloseNoThrow();
     throw;
   }
-}
+}

tooling/pipeline/src/services/sqlite/finalize_statements.cc

@@ -1,11 +0,0 @@
-/**
- * @file services/sqlite/finalize_statements.cc
- * @brief SqliteExportService::FinalizeStatements() implementation.
- */
-
-#include "services/sqlite_export_service.h"
-
-void SqliteExportService::FinalizeStatements() noexcept {
-  insert_brewery_stmt_.reset();
-  insert_location_stmt_.reset();
-}

tooling/pipeline/src/services/sqlite/helpers/sqlite_connection_helpers.cpp

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

tooling/pipeline/src/services/sqlite/helpers/sqlite_statement_helpers.cpp

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

tooling/pipeline/src/services/sqlite/initialize.cc

@@ -11,6 +11,42 @@
 #include "services/sqlite_export_service.h"
 #include "services/sqlite_export_service_helpers.h"
 
+
+void SqliteExportService::InitializeSchema() const {
+  sqlite_export_service_internal::ExecSql(
+      db_handle_, sqlite_export_service_internal::kCreateLocationsTableSql,
+      "Failed to create SQLite locations table");
+  sqlite_export_service_internal::ExecSql(
+      db_handle_, sqlite_export_service_internal::kCreateBreweriesTableSql,
+      "Failed to create SQLite breweries table");
+}
+
+void SqliteExportService::PrepareStatements() {
+  insert_location_stmt_ = sqlite_export_service_internal::PrepareStatement(
+      db_handle_, sqlite_export_service_internal::kInsertLocationSql,
+      "Failed to prepare SQLite location insert statement");
+  insert_brewery_stmt_ = sqlite_export_service_internal::PrepareStatement(
+      db_handle_, sqlite_export_service_internal::kInsertBrewerySql,
+      "Failed to prepare SQLite brewery insert statement");
+}
+
+void SqliteExportService::RollbackAndCloseNoThrow() noexcept {
+  if (db_handle_ == nullptr) {
+    return;
+  }
+
+  if (transaction_open_) {
+    sqlite_export_service_internal::RollbackTransactionNoThrow(db_handle_);
+    transaction_open_ = false;
+  }
+
+  insert_brewery_stmt_.reset();
+  insert_location_stmt_.reset();
+  db_handle_.reset();
+  location_cache_.clear();
+}
+
+
 void SqliteExportService::Initialize() {
   if (db_handle_ != nullptr) {
     throw std::runtime_error("SQLite export service is already initialized");

tooling/pipeline/src/services/sqlite/initialize_schema.cc

@@ -1,16 +0,0 @@
-/**
- * @file services/sqlite/initialize_schema.cc
- * @brief SqliteExportService::InitializeSchema() implementation.
- */
-
-#include "services/sqlite_export_service.h"
-#include "services/sqlite_export_service_helpers.h"
-
-void SqliteExportService::InitializeSchema() {
-  sqlite_export_service_internal::ExecSql(
-      db_handle_, sqlite_export_service_internal::kCreateLocationsTableSql,
-      "Failed to create SQLite locations table");
-  sqlite_export_service_internal::ExecSql(
-      db_handle_, sqlite_export_service_internal::kCreateBreweriesTableSql,
-      "Failed to create SQLite breweries table");
-}

tooling/pipeline/src/services/sqlite/prepare_statements.cc

@@ -1,16 +0,0 @@
-/**
- * @file services/sqlite/prepare_statements.cc
- * @brief SqliteExportService::PrepareStatements() implementation.
- */
-
-#include "services/sqlite_export_service.h"
-#include "services/sqlite_export_service_helpers.h"
-
-void SqliteExportService::PrepareStatements() {
-  insert_location_stmt_ = sqlite_export_service_internal::PrepareStatement(
-      db_handle_, sqlite_export_service_internal::kInsertLocationSql,
-      "Failed to prepare SQLite location insert statement");
-  insert_brewery_stmt_ = sqlite_export_service_internal::PrepareStatement(
-      db_handle_, sqlite_export_service_internal::kInsertBrewerySql,
-      "Failed to prepare SQLite brewery insert statement");
-}

tooling/pipeline/src/services/sqlite/process_record.cc

@@ -9,7 +9,25 @@
 #include "services/sqlite_export_service.h"
 #include "services/sqlite_export_service_helpers.h"
 
-void SqliteExportService::ProcessRecord(const GeneratedBrewery& brewery) {
+constexpr int kLocationPrecision = 17;
+
+std::string SqliteExportService::BuildLocationKey(const Location& location) {
+  std::ostringstream key_stream;
+  key_stream << location.city << '\n'
+             << location.state_province << '\n'
+             << location.iso3166_2 << '\n'
+             << location.country << '\n'
+             << location.iso3166_1 << '\n'
+             << std::setprecision(kLocationPrecision) << location.latitude
+             << '\n'
+             << std::setprecision(kLocationPrecision) << location.longitude
+             << '\n'
+             << sqlite_export_service_internal::SerializeVector(
+                    location.local_languages);
+  return key_stream.str();
+}
+
+uint64_t SqliteExportService::ProcessRecord(const GeneratedBrewery& brewery) {
   if (db_handle_ == nullptr || !transaction_open_) {
     throw std::runtime_error("SQLite export service is not initialized");
   }
@@ -22,44 +40,60 @@ void SqliteExportService::ProcessRecord(const GeneratedBrewery& brewery) {
     location_id = cached_location->second;
   } else {
     const std::string local_languages_json =
-        sqlite_export_service_internal::SerializeLocalLanguages(
+        sqlite_export_service_internal::SerializeVector(
             brewery.location.local_languages);
 
-    sqlite_export_service_internal::BindText(
+    sqlite_export_service_internal::Bind(
         insert_location_stmt_,
-        sqlite_export_service_internal::kLocationCityBindIndex,
-        brewery.location.city, "Failed to bind SQLite location city");
-    sqlite_export_service_internal::BindText(
+        sqlite_export_service_internal::BindParam<std::string_view>{
+            .index = sqlite_export_service_internal::kLocationCityBindIndex,
+            .value = brewery.location.city,
+            .action = "Failed to bind SQLite location city"});
+    sqlite_export_service_internal::Bind(
         insert_location_stmt_,
-        sqlite_export_service_internal::kLocationStateProvinceBindIndex,
-        brewery.location.state_province,
-        "Failed to bind SQLite location state/province");
-    sqlite_export_service_internal::BindText(
+        sqlite_export_service_internal::BindParam<std::string_view>{
+            .index =
+                sqlite_export_service_internal::kLocationStateProvinceBindIndex,
+            .value = brewery.location.state_province,
+            .action = "Failed to bind SQLite location state/province"});
+    sqlite_export_service_internal::Bind(
         insert_location_stmt_,
-        sqlite_export_service_internal::kLocationIso31662BindIndex,
-        brewery.location.iso3166_2,
-        "Failed to bind SQLite location ISO 3166-2 code");
-    sqlite_export_service_internal::BindText(
+        sqlite_export_service_internal::BindParam<std::string_view>{
+            .index = sqlite_export_service_internal::kLocationIso31662BindIndex,
+            .value = brewery.location.iso3166_2,
+            .action = "Failed to bind SQLite location ISO 3166-2 code"});
+    sqlite_export_service_internal::Bind(
         insert_location_stmt_,
-        sqlite_export_service_internal::kLocationCountryBindIndex,
-        brewery.location.country, "Failed to bind SQLite location country");
-    sqlite_export_service_internal::BindText(
+        sqlite_export_service_internal::BindParam<std::string_view>{
+            .index = sqlite_export_service_internal::kLocationCountryBindIndex,
+            .value = brewery.location.country,
+            .action = "Failed to bind SQLite location country"});
+    sqlite_export_service_internal::Bind(
         insert_location_stmt_,
-        sqlite_export_service_internal::kLocationIso31661BindIndex,
-        brewery.location.iso3166_1,
-        "Failed to bind SQLite location ISO 3166-1 code");
-    sqlite_export_service_internal::BindText(
+        sqlite_export_service_internal::BindParam<std::string_view>{
+            .index = sqlite_export_service_internal::kLocationIso31661BindIndex,
+            .value = brewery.location.iso3166_1,
+            .action = "Failed to bind SQLite location ISO 3166-1 code"});
+    sqlite_export_service_internal::Bind(
         insert_location_stmt_,
-        sqlite_export_service_internal::kLocationLanguagesBindIndex,
-        local_languages_json, "Failed to bind SQLite location languages");
-    sqlite_export_service_internal::BindDouble(
+        sqlite_export_service_internal::BindParam<std::string_view>{
+            .index =
+                sqlite_export_service_internal::kLocationLanguagesBindIndex,
+            .value = local_languages_json,
+            .action = "Failed to bind SQLite location languages"});
+    sqlite_export_service_internal::Bind(
         insert_location_stmt_,
-        sqlite_export_service_internal::kLocationLatitudeBindIndex,
-        brewery.location.latitude, "Failed to bind SQLite location latitude");
-    sqlite_export_service_internal::BindDouble(
+        sqlite_export_service_internal::BindParam{
+            .index = sqlite_export_service_internal::kLocationLatitudeBindIndex,
+            .value = brewery.location.latitude,
+            .action = "Failed to bind SQLite location latitude"});
+    sqlite_export_service_internal::Bind(
         insert_location_stmt_,
-        sqlite_export_service_internal::kLocationLongitudeBindIndex,
-        brewery.location.longitude, "Failed to bind SQLite location longitude");
+        sqlite_export_service_internal::BindParam{
+            .index =
+                sqlite_export_service_internal::kLocationLongitudeBindIndex,
+            .value = brewery.location.longitude,
+            .action = "Failed to bind SQLite location longitude"});
 
     sqlite_export_service_internal::StepStatement(
         db_handle_, insert_location_stmt_,
@@ -70,31 +104,43 @@ void SqliteExportService::ProcessRecord(const GeneratedBrewery& brewery) {
     sqlite_export_service_internal::ResetStatement(insert_location_stmt_);
   }
 
-  sqlite_export_service_internal::BindInt64(
+  sqlite_export_service_internal::Bind(
       insert_brewery_stmt_,
-      sqlite_export_service_internal::kBreweryLocationIdBindIndex, location_id,
-      "Failed to bind SQLite brewery location id");
-  sqlite_export_service_internal::BindText(
+      sqlite_export_service_internal::BindParam<sqlite3_int64>{
+          .index = sqlite_export_service_internal::kBreweryLocationIdBindIndex,
+          .value = location_id,
+          .action = "Failed to bind SQLite brewery location id"});
+  sqlite_export_service_internal::Bind(
       insert_brewery_stmt_,
-      sqlite_export_service_internal::kBreweryEnglishNameBindIndex,
-      brewery.brewery.name_en, "Failed to bind SQLite brewery English name");
-  sqlite_export_service_internal::BindText(
+      sqlite_export_service_internal::BindParam<std::string_view>{
+          .index = sqlite_export_service_internal::kBreweryEnglishNameBindIndex,
+          .value = brewery.brewery.name_en,
+          .action = "Failed to bind SQLite brewery English name"});
+  sqlite_export_service_internal::Bind(
       insert_brewery_stmt_,
-      sqlite_export_service_internal::kBreweryEnglishDescriptionBindIndex,
-      brewery.brewery.description_en,
-      "Failed to bind SQLite brewery English description");
-  sqlite_export_service_internal::BindText(
+      sqlite_export_service_internal::BindParam<std::string_view>{
+          .index = sqlite_export_service_internal::
+              kBreweryEnglishDescriptionBindIndex,
+          .value = brewery.brewery.description_en,
+          .action = "Failed to bind SQLite brewery English description"});
+  sqlite_export_service_internal::Bind(
       insert_brewery_stmt_,
-      sqlite_export_service_internal::kBreweryLocalNameBindIndex,
-      brewery.brewery.name_local, "Failed to bind SQLite brewery local name");
-  sqlite_export_service_internal::BindText(
+      sqlite_export_service_internal::BindParam<std::string_view>{
+          .index = sqlite_export_service_internal::kBreweryLocalNameBindIndex,
+          .value = brewery.brewery.name_local,
+          .action = "Failed to bind SQLite brewery local name"});
+  sqlite_export_service_internal::Bind(
       insert_brewery_stmt_,
-      sqlite_export_service_internal::kBreweryLocalDescriptionBindIndex,
-      brewery.brewery.description_local,
-      "Failed to bind SQLite brewery local description");
+      sqlite_export_service_internal::BindParam<std::string_view>{
+          .index =
+              sqlite_export_service_internal::kBreweryLocalDescriptionBindIndex,
+          .value = brewery.brewery.description_local,
+          .action = "Failed to bind SQLite brewery local description"});
 
   sqlite_export_service_internal::StepStatement(
       db_handle_, insert_brewery_stmt_, "Failed to insert SQLite brewery row");
 
   sqlite_export_service_internal::ResetStatement(insert_brewery_stmt_);
+
+  return sqlite_export_service_internal::LastInsertRowId(db_handle_);
 }

tooling/pipeline/src/services/sqlite/rollback_and_close_no_throw.cc

@@ -1,21 +0,0 @@
-/**
- * @file services/sqlite/rollback_and_close_no_throw.cc
- * @brief SqliteExportService::RollbackAndCloseNoThrow() implementation.
- */
-
-#include "services/sqlite_export_service.h"
-
-void SqliteExportService::RollbackAndCloseNoThrow() noexcept {
-  if (db_handle_ == nullptr) {
-    return;
-  }
-
-  if (transaction_open_) {
-    sqlite_export_service_internal::RollbackTransactionNoThrow(db_handle_);
-    transaction_open_ = false;
-  }
-
-  FinalizeStatements();
-  db_handle_.reset();
-  location_cache_.clear();
-}