Integrate SQLite export functionality

pipeline/includes/biergarten_data_generator.h

@@ -14,6 +14,7 @@
 #include "data_model/enriched_city.h"
 #include "data_model/generated_brewery.h"
 #include "data_model/location.h"
+#include "services/export_service.h"
 #include "services/enrichment_service.h"
 
 /**
@@ -28,10 +29,12 @@ class BiergartenDataGenerator {
    * @brief Construct a BiergartenDataGenerator with injected dependencies.
    *
    * @param context_service Context provider for sampled locations.
-   * @param generator Brewery and user data generator.
+  * @param generator Brewery and user data generator.
+  * @param exporter Storage backend for generated brewery data.
    */
   BiergartenDataGenerator(std::unique_ptr<IEnrichmentService> context_service,
-                          std::unique_ptr<DataGenerator> generator);
+                  std::unique_ptr<DataGenerator> generator,
+                  std::unique_ptr<IExportService> exporter);
 
   /**
    * @brief Run the data generation pipeline.
@@ -52,6 +55,9 @@ class BiergartenDataGenerator {
   /// @brief Generator dependency selected in the composition root.
   std::unique_ptr<DataGenerator> generator_;
 
+  /// @brief Storage backend for generated brewery records.
+  std::unique_ptr<IExportService> exporter_;
+
   /**
    * @brief Load locations from JSON and sample cities.
    *

pipeline/includes/services/date_time_provider.h

@@ -0,0 +1,68 @@
+#ifndef BIERGARTEN_PIPELINE_INCLUDES_SERVICES_DATE_TIME_PROVIDER_H_
+#define BIERGARTEN_PIPELINE_INCLUDES_SERVICES_DATE_TIME_PROVIDER_H_
+
+/**
+ * @file services/date_time_provider.h
+ * @brief Abstraction for UTC timestamp generation.
+ */
+
+#include <chrono>
+#include <ctime>
+#include <iomanip>
+#include <sstream>
+#include <stdexcept>
+#include <string>
+
+/**
+ * @brief Interface for UTC timestamp providers.
+ */
+class IDateTimeProvider {
+   public:
+
+   /// @brief Virtual destructor for polymorphic cleanup.
+   virtual ~IDateTimeProvider() = default;
+
+
+   IDateTimeProvider() = default;
+  IDateTimeProvider(const IDateTimeProvider&) = delete;
+  IDateTimeProvider& operator=(const IDateTimeProvider&) = delete;
+  IDateTimeProvider(IDateTimeProvider&&) = delete;
+  IDateTimeProvider& operator=(IDateTimeProvider&&) = delete;
+
+  /**
+   * @brief Returns the current UTC timestamp in a file-safe format.
+   *
+   * @return UTC timestamp string.
+   */
+  virtual std::string GetUtcTimestamp() = 0;
+};
+
+/**
+ * @brief Timestamp provider backed by the system clock.
+ */
+class SystemDateTimeProvider final : public IDateTimeProvider {
+ public:
+  std::string GetUtcTimestamp() override {
+    constexpr int kFractionalSecondWidth = 6;
+
+    const auto now = std::chrono::system_clock::now();
+    const auto now_time = std::chrono::system_clock::to_time_t(now);
+    const std::tm* utc_time_ptr = std::gmtime(&now_time);
+    if (utc_time_ptr == nullptr) {
+      throw std::runtime_error("Failed to format UTC timestamp");
+    }
+
+    const auto fractional_seconds =
+        std::chrono::duration_cast<std::chrono::microseconds>(
+            now.time_since_epoch()) %
+        std::chrono::seconds(1);
+
+    std::ostringstream output;
+    output << std::put_time(utc_time_ptr, "%Y-%m-%dT%H-%M-%S");
+    output << '.' << std::setw(kFractionalSecondWidth) << std::setfill('0')
+           << fractional_seconds.count() << 'Z';
+    return output.str();
+  }
+};
+
+#endif  // BIERGARTEN_PIPELINE_INCLUDES_SERVICES_DATE_TIME_PROVIDER_H_

pipeline/includes/services/export_service.h

@@ -0,0 +1,40 @@
+#ifndef BIERGARTEN_PIPELINE_INCLUDES_SERVICES_EXPORT_SERVICE_H_
+#define BIERGARTEN_PIPELINE_INCLUDES_SERVICES_EXPORT_SERVICE_H_
+
+/**
+ * @file services/export_service.h
+ * @brief Abstraction for persisting generated brewery data.
+ */
+
+#include "data_model/generated_brewery.h"
+
+/**
+ * @brief Interface for services that persist generated brewery records.
+ */
+class IExportService {
+ public:
+  IExportService() = default;
+
+  /// @brief Virtual destructor for polymorphic cleanup.
+  virtual ~IExportService() = default;
+
+  IExportService(const IExportService&) = delete;
+  IExportService& operator=(const IExportService&) = delete;
+  IExportService(IExportService&&) = delete;
+  IExportService& operator=(IExportService&&) = delete;
+
+  /// @brief Prepares the export destination for a new run.
+  virtual void Initialize() = 0;
+
+  /**
+   * @brief Persists one generated brewery record.
+   *
+   * @param brewery Generated brewery payload to store.
+   */
+  virtual void ProcessRecord(const GeneratedBrewery& brewery) = 0;
+
+  /// @brief Finalizes the export destination.
+  virtual void Finalize() = 0;
+};
+
+#endif  // BIERGARTEN_PIPELINE_INCLUDES_SERVICES_EXPORT_SERVICE_H_

pipeline/includes/services/sqlite_export_service.h

@@ -0,0 +1,57 @@
+#ifndef BIERGARTEN_PIPELINE_INCLUDES_SERVICES_SQLITE_EXPORT_SERVICE_H_
+#define BIERGARTEN_PIPELINE_INCLUDES_SERVICES_SQLITE_EXPORT_SERVICE_H_
+
+/**
+ * @file services/sqlite_export_service.h
+ * @brief SQLite-backed export service for generated brewery data.
+ */
+
+#include <filesystem>
+#include <memory>
+#include <string>
+#include <unordered_map>
+
+#include "services/date_time_provider.h"
+#include "services/export_service.h"
+#include "services/sqlite_export_service_helpers.h"
+
+/**
+ * @brief Persists generated brewery records into a fresh SQLite database.
+ */
+class SqliteExportService final : public IExportService {
+ public:
+  SqliteExportService();
+  ~SqliteExportService() override;
+
+  SqliteExportService(const SqliteExportService&) = delete;
+  SqliteExportService& operator=(const SqliteExportService&) = delete;
+  SqliteExportService(SqliteExportService&&) = delete;
+  SqliteExportService& operator=(SqliteExportService&&) = delete;
+
+  void Initialize() override;
+  void ProcessRecord(const GeneratedBrewery& brewery) override;
+  void Finalize() override;
+
+ private:
+  using SqliteDatabaseHandle = sqlite_export_service_internal::SqliteDatabaseHandle;
+  using SqliteStatementHandle = sqlite_export_service_internal::SqliteStatementHandle;
+
+  void InitializeSchema();
+  void PrepareStatements();
+  void RollbackAndCloseNoThrow() noexcept;
+  void FinalizeStatements() noexcept;
+
+  [[nodiscard]] std::filesystem::path BuildDatabasePath() const;
+  [[nodiscard]] static std::string BuildLocationKey(const Location& location);
+
+  std::unique_ptr<IDateTimeProvider> date_time_provider_;
+  std::string run_timestamp_utc_;
+  std::filesystem::path database_path_;
+  SqliteDatabaseHandle db_handle_;
+  SqliteStatementHandle insert_location_stmt_;
+  SqliteStatementHandle insert_brewery_stmt_;
+  bool transaction_open_ = false;
+  std::unordered_map<std::string, sqlite3_int64> location_cache_;
+};
+
+#endif  // BIERGARTEN_PIPELINE_INCLUDES_SERVICES_SQLITE_EXPORT_SERVICE_H_

pipeline/includes/services/sqlite_export_service_helpers.h

@@ -0,0 +1,250 @@
+#ifndef BIERGARTEN_PIPELINE_INCLUDES_SERVICES_SQLITE_EXPORT_SERVICE_HELPERS_H_
+#define BIERGARTEN_PIPELINE_INCLUDES_SERVICES_SQLITE_EXPORT_SERVICE_HELPERS_H_
+
+/**
+ * @file services/sqlite_export_service_helpers.h
+ * @brief Internal SQLite export helpers shared across per-method translation
+ * units.
+ */
+
+#include <sqlite3.h>
+
+#include <boost/json.hpp>
+#include <cstddef>
+#include <cstring>
+#include <filesystem>
+#include <limits>
+#include <memory>
+#include <stdexcept>
+#include <string>
+#include <string_view>
+#include <vector>
+
+namespace sqlite_export_service_internal {
+
+struct SqliteDatabaseDeleter {
+  void operator()(sqlite3* handle) const noexcept {
+    if (handle != nullptr) {
+      sqlite3_close(handle);
+    }
+  }
+};
+
+struct SqliteStatementDeleter {
+  void operator()(sqlite3_stmt* statement) const noexcept {
+    if (statement != nullptr) {
+      sqlite3_finalize(statement);
+    }
+  }
+};
+
+using SqliteDatabaseHandle = std::unique_ptr<sqlite3, SqliteDatabaseDeleter>;
+using SqliteStatementHandle =
+    std::unique_ptr<sqlite3_stmt, SqliteStatementDeleter>;
+
+inline constexpr std::string_view kCreateLocationsTableSql = R"sql(
+
+CREATE TABLE IF NOT EXISTS locations (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  city TEXT NOT NULL,
+  state_province TEXT NOT NULL,
+  iso3166_2 TEXT NOT NULL,
+  country TEXT NOT NULL,
+  iso3166_1 TEXT NOT NULL,
+  local_languages_json TEXT NOT NULL,
+  latitude REAL NOT NULL,
+  longitude REAL NOT NULL,
+  UNIQUE(city, state_province, iso3166_2, country, latitude, longitude)
+);
+
+)sql";
+
+inline constexpr std::string_view kCreateBreweriesTableSql = R"sql(
+
+CREATE TABLE IF NOT EXISTS breweries (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  location_id INTEGER NOT NULL,
+  name_en TEXT NOT NULL,
+  description_en TEXT NOT NULL,
+  name_local TEXT NOT NULL,
+  description_local TEXT NOT NULL,
+  FOREIGN KEY(location_id) REFERENCES locations(id) ON DELETE CASCADE
+);
+
+CREATE INDEX IF NOT EXISTS idx_breweries_location_id ON breweries(location_id);
+
+)sql";
+
+inline constexpr std::string_view kInsertLocationSql = R"sql(
+INSERT INTO locations (
+  city,
+  state_province,
+  iso3166_2,
+  country,
+  iso3166_1,
+  local_languages_json,
+  latitude,
+  longitude
+) VALUES (?, ?, ?, ?, ?, ?, ?, ?);
+)sql";
+
+inline constexpr std::string_view kInsertBrewerySql = R"sql(
+INSERT INTO breweries (
+  location_id,
+  name_en,
+  description_en,
+  name_local,
+  description_local
+) VALUES (?, ?, ?, ?, ?);
+)sql";
+
+inline constexpr int kLocationCityBindIndex = 1;
+inline constexpr int kLocationStateProvinceBindIndex = 2;
+inline constexpr int kLocationIso31662BindIndex = 3;
+inline constexpr int kLocationCountryBindIndex = 4;
+inline constexpr int kLocationIso31661BindIndex = 5;
+inline constexpr int kLocationLanguagesBindIndex = 6;
+inline constexpr int kLocationLatitudeBindIndex = 7;
+inline constexpr int kLocationLongitudeBindIndex = 8;
+
+inline constexpr int kBreweryLocationIdBindIndex = 1;
+inline constexpr int kBreweryEnglishNameBindIndex = 2;
+inline constexpr int kBreweryEnglishDescriptionBindIndex = 3;
+inline constexpr int kBreweryLocalNameBindIndex = 4;
+inline constexpr int kBreweryLocalDescriptionBindIndex = 5;
+
+inline 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);
+}
+
+inline SqliteDatabaseHandle OpenDatabase(const std::filesystem::path& path) {
+  sqlite3* raw_handle = nullptr;
+  const std::string path_string = path.string();
+  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;
+}
+
+inline 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);
+  }
+}
+
+inline 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;
+}
+
+inline void ResetStatement(SqliteStatementHandle& statement) {
+  if (statement != nullptr) {
+    sqlite3_reset(statement.get());
+    sqlite3_clear_bindings(statement.get());
+  }
+}
+
+inline void DeleteCharArray(void* data) noexcept {
+  delete[] static_cast<char*>(data);
+}
+
+inline void BindText(const SqliteStatementHandle& statement, int index,
+                     std::string_view value, const char* action) {
+  const auto byte_count = value.size();
+  if (byte_count > static_cast<std::size_t>(std::numeric_limits<int>::max())) {
+    ThrowSqliteError(sqlite3_db_handle(statement.get()), action);
+  }
+
+  auto buffer = std::make_unique<char[]>(byte_count + 1);
+  std::memcpy(buffer.get(), value.data(), byte_count);
+  buffer[byte_count] = '\0';
+
+  char* raw_buffer = buffer.release();
+  const int result = sqlite3_bind_text(statement.get(), index, raw_buffer,
+                                       static_cast<int>(byte_count),
+                                       DeleteCharArray);
+  if (result != SQLITE_OK) {
+    DeleteCharArray(raw_buffer);
+    ThrowSqliteError(sqlite3_db_handle(statement.get()), action);
+  }
+}
+
+inline void BindDouble(const SqliteStatementHandle& statement, int index,
+                       double value, std::string_view action) {
+  const int result = sqlite3_bind_double(statement.get(), index, value);
+  if (result != SQLITE_OK) {
+    ThrowSqliteError(sqlite3_db_handle(statement.get()), action);
+  }
+}
+
+inline void BindInt64(const SqliteStatementHandle& statement, int index,
+                      sqlite3_int64 value, std::string_view action) {
+  const int result = sqlite3_bind_int64(statement.get(), index, value);
+  if (result != SQLITE_OK) {
+    ThrowSqliteError(sqlite3_db_handle(statement.get()), action);
+  }
+}
+
+inline void StepStatement(const SqliteDatabaseHandle& db_handle,
+                          const SqliteStatementHandle& statement,
+                          std::string_view action) {
+  const int result = sqlite3_step(statement.get());
+  if (result != SQLITE_DONE) {
+    ThrowSqliteError(db_handle.get(), action);
+  }
+}
+
+inline sqlite3_int64 LastInsertRowId(const SqliteDatabaseHandle& db_handle) {
+  return sqlite3_last_insert_rowid(db_handle.get());
+}
+
+inline void RollbackTransactionNoThrow(
+    const SqliteDatabaseHandle& db_handle) noexcept {
+  if (!db_handle) {
+    return;
+  }
+
+  sqlite3_exec(db_handle.get(), "ROLLBACK;", nullptr, nullptr, nullptr);
+}
+
+inline 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);
+}
+
+}  // namespace sqlite_export_service_internal
+
+#endif  // BIERGARTEN_PIPELINE_INCLUDES_SERVICES_SQLITE_EXPORT_SERVICE_HELPERS_H_