Organize and consolidate header files (#220)

tooling/pipeline/includes/services/database/export_service.h

@@ -0,0 +1,42 @@
+#ifndef BIERGARTEN_PIPELINE_INCLUDES_SERVICES_DATABASE_EXPORT_SERVICE_H_
+#define BIERGARTEN_PIPELINE_INCLUDES_SERVICES_DATABASE_EXPORT_SERVICE_H_
+
+/**
+ * @file services/export_service.h
+ * @brief Abstraction for persisting generated brewery data.
+ */
+
+#include <cstdint>
+
+#include "data_model/generated_models.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 uint64_t ProcessRecord(const GeneratedBrewery& brewery) = 0;
+
+  /// @brief Finalizes the export destination.
+  virtual void Finalize() = 0;
+};
+
+#endif  // BIERGARTEN_PIPELINE_INCLUDES_SERVICES_DATABASE_EXPORT_SERVICE_H_

tooling/pipeline/includes/services/database/sqlite_connection_helpers.h

@@ -0,0 +1,30 @@
+#ifndef BIERGARTEN_PIPELINE_INCLUDES_SERVICES_DATABASE_SQLITE_CONNECTION_HELPERS_H_
+#define BIERGARTEN_PIPELINE_INCLUDES_SERVICES_DATABASE_SQLITE_CONNECTION_HELPERS_H_
+
+/**
+ * @file services/sqlite_connection_helpers.h
+ * @brief Declarations for connection-level SQLite helper functions.
+ */
+
+#include <sqlite3.h>
+
+#include <filesystem>
+#include <string>
+#include <string_view>
+
+#include "sqlite_handle_types.h"
+
+namespace sqlite_export_service_internal {
+
+void ThrowSqliteError(sqlite3* db_handle, std::string_view action);
+
+SqliteDatabaseHandle OpenDatabase(const std::filesystem::path& path);
+
+void ExecSql(const SqliteDatabaseHandle& db_handle, std::string_view sql,
+             const char* action);
+
+void RollbackTransactionNoThrow(const SqliteDatabaseHandle& db_handle) noexcept;
+
+}  // namespace sqlite_export_service_internal
+
+#endif  // BIERGARTEN_PIPELINE_INCLUDES_SERVICES_DATABASE_SQLITE_CONNECTION_HELPERS_H_

tooling/pipeline/includes/services/database/sqlite_export_service.h

@@ -0,0 +1,60 @@
+#ifndef BIERGARTEN_PIPELINE_INCLUDES_SERVICES_DATABASE_SQLITE_EXPORT_SERVICE_H_
+#define BIERGARTEN_PIPELINE_INCLUDES_SERVICES_DATABASE_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 "data_model/models.h"
+#include "../datetime/date_time_provider.h"
+#include "export_service.h"
+#include "sqlite_export_service_helpers.h"
+
+/**
+ * @brief Persists generated brewery records into a fresh SQLite database.
+ */
+class SqliteExportService final : public IExportService {
+ public:
+  explicit SqliteExportService(const ApplicationOptions& options);
+  ~SqliteExportService() override;
+
+  SqliteExportService(const SqliteExportService&) = delete;
+  SqliteExportService& operator=(const SqliteExportService&) = delete;
+  SqliteExportService(SqliteExportService&&) = delete;
+  SqliteExportService& operator=(SqliteExportService&&) = delete;
+
+  void Initialize() override;
+  uint64_t 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() const;
+  void PrepareStatements();
+  void RollbackAndCloseNoThrow() noexcept;
+
+  [[nodiscard]] std::filesystem::path BuildDatabasePath() const;
+  [[nodiscard]] static std::string BuildLocationKey(const Location& location);
+
+  std::unique_ptr<IDateTimeProvider> date_time_provider_;
+  std::filesystem::path output_path_;
+  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_DATABASE_SQLITE_EXPORT_SERVICE_H_

tooling/pipeline/includes/services/database/sqlite_export_service_helpers.h

@@ -0,0 +1,10 @@
+#ifndef BIERGARTEN_PIPELINE_INCLUDES_SERVICES_DATABASE_SQLITE_EXPORT_SERVICE_HELPERS_H_
+#define BIERGARTEN_PIPELINE_INCLUDES_SERVICES_DATABASE_SQLITE_EXPORT_SERVICE_HELPERS_H_
+
+/* Umbrella header for backward compatibility. */
+
+#include "sqlite_connection_helpers.h"
+#include "sqlite_handle_types.h"
+#include "sqlite_statement_helpers.h"
+
+#endif  // BIERGARTEN_PIPELINE_INCLUDES_SERVICES_DATABASE_SQLITE_EXPORT_SERVICE_HELPERS_H_

tooling/pipeline/includes/services/database/sqlite_handle_types.h

@@ -0,0 +1,36 @@
+#ifndef BIERGARTEN_PIPELINE_INCLUDES_SERVICES_DATABASE_SQLITE_HANDLE_TYPES_H_
+#define BIERGARTEN_PIPELINE_INCLUDES_SERVICES_DATABASE_SQLITE_HANDLE_TYPES_H_
+
+/**
+ * Shared handle and parameter type declarations used by SQLite helper units.
+ */
+
+#include <sqlite3.h>
+
+#include <memory>
+#include <string_view>
+
+namespace sqlite_export_service_internal {
+
+struct SqliteDatabaseDeleter {
+  void operator()(sqlite3* handle) const noexcept;
+};
+
+struct SqliteStatementDeleter {
+  void operator()(sqlite3_stmt* statement) const noexcept;
+};
+
+using SqliteDatabaseHandle = std::unique_ptr<sqlite3, SqliteDatabaseDeleter>;
+using SqliteStatementHandle =
+    std::unique_ptr<sqlite3_stmt, SqliteStatementDeleter>;
+
+template <typename T>
+struct BindParam {
+  int index;
+  T value;
+  std::string_view action;
+};
+
+}  // namespace sqlite_export_service_internal
+
+#endif  // BIERGARTEN_PIPELINE_INCLUDES_SERVICES_DATABASE_SQLITE_HANDLE_TYPES_H_

tooling/pipeline/includes/services/database/sqlite_statement_helpers.h

@@ -0,0 +1,116 @@
+#ifndef BIERGARTEN_PIPELINE_INCLUDES_SERVICES_DATABASE_SQLITE_STATEMENT_HELPERS_H_
+#define BIERGARTEN_PIPELINE_INCLUDES_SERVICES_DATABASE_SQLITE_STATEMENT_HELPERS_H_
+
+/**
+ * @file services/sqlite_statement_helpers.h
+ * @brief Declarations for statement-level SQLite helper functions and
+ * constants.
+ */
+
+#include <sqlite3.h>
+
+#include <string>
+#include <string_view>
+#include <vector>
+
+#include "sqlite_handle_types.h"
+
+namespace sqlite_export_service_internal {
+
+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;
+
+SqliteStatementHandle PrepareStatement(const SqliteDatabaseHandle& db_handle,
+                                       std::string_view sql,
+                                       const char* action);
+
+void ResetStatement(SqliteStatementHandle& statement);
+
+void Bind(const SqliteStatementHandle& statement,
+          const BindParam<std::string_view>& param);
+
+void Bind(const SqliteStatementHandle& statement,
+          const BindParam<double>& param);
+
+void Bind(const SqliteStatementHandle& statement,
+          const BindParam<sqlite3_int64>& param);
+
+void StepStatement(const SqliteDatabaseHandle& db_handle,
+                   const SqliteStatementHandle& statement,
+                   std::string_view action);
+
+sqlite3_int64 LastInsertRowId(const SqliteDatabaseHandle& db_handle);
+
+std::string SerializeVector(const std::vector<std::string>& str_vec);
+
+}  // namespace sqlite_export_service_internal
+
+#endif  // BIERGARTEN_PIPELINE_INCLUDES_SERVICES_DATABASE_SQLITE_STATEMENT_HELPERS_H_