postgresql_connection.hpp

Go to the documentation of this file.

#pragma once
 
#include "connection.hpp"
 
#include <memory>
#include <sstream>
#include <string>
#include <string_view>
#include <type_traits>
 
// Forward declarations to avoid including libpq headers in our public API
struct pg_conn;
using PGconn = pg_conn;
struct pg_result;
using PGresult = pg_result;
 
// Forward declare statement class
namespace relx::connection {
class PostgreSQLStatement;
}  // namespace relx::connection
 
namespace relx::connection {
 
class PostgreSQLConnection : public Connection {
public:
  explicit PostgreSQLConnection(std::string_view connection_string);
 
  explicit PostgreSQLConnection(const PostgreSQLConnectionParams& params);
 
  ~PostgreSQLConnection() override;
 
  // Delete copy constructor and assignment operator
  PostgreSQLConnection(const PostgreSQLConnection&) = delete;
  PostgreSQLConnection& operator=(const PostgreSQLConnection&) = delete;
 
  // Allow move operations
  PostgreSQLConnection(PostgreSQLConnection&&) noexcept;
  PostgreSQLConnection& operator=(PostgreSQLConnection&&) noexcept;
 
  ConnectionResult<void> connect() override;
 
  ConnectionResult<void> disconnect() override;
 
  ConnectionResult<result::ResultSet> execute_raw(
      const std::string& sql, const std::vector<std::string>& params = {}) override;
 
  // TODO make binary type for bytea type in postgresql instead of this hacky function
  ConnectionResult<result::ResultSet> execute_raw_binary(
      const std::string& sql, const std::vector<std::string>& params,
      const std::vector<bool>& is_binary);  // TODO replace vector bool
 
  template <typename... Args>
  ConnectionResult<result::ResultSet> execute_typed(const std::string& sql, Args&&... args) {
    // Convert each parameter to its string representation
    std::vector<std::string> param_strings;
    param_strings.reserve(sizeof...(Args));
 
    // Helper to convert a parameter to string and add to vector
    auto add_param = [&param_strings](auto&& param) {
      using ParamType = std::remove_cvref_t<decltype(param)>;
 
      if constexpr (std::is_same_v<ParamType, std::nullptr_t>) {
        // Handle NULL values
        param_strings.push_back("NULL");
      } else if constexpr (std::is_same_v<ParamType, std::string> ||
                           std::is_same_v<ParamType, const char*> ||
                           std::is_same_v<ParamType, std::string_view>) {
        // String types
        param_strings.push_back(std::string(param));
      } else if constexpr (std::is_arithmetic_v<ParamType>) {
        // Numeric types
        param_strings.push_back(std::to_string(param));
      } else if constexpr (std::is_same_v<ParamType, bool>) {
        // Boolean values
        param_strings.push_back(param ? "t" : "f");
      } else {
        // Other types, try to use stream conversion
        std::ostringstream ss;
        ss << param;
        param_strings.push_back(ss.str());
      }
    };
 
    // Add each parameter to the vector
    (add_param(std::forward<Args>(args)), ...);
 
    // Call the string-based execute_raw with our converted parameters
    return execute_raw(sql, param_strings);
  }
 
  bool is_connected() const override;
 
  ConnectionResult<void> begin_transaction(
      IsolationLevel isolation_level = IsolationLevel::ReadCommitted) override;
 
  ConnectionResult<void> commit_transaction() override;
 
  ConnectionResult<void> rollback_transaction() override;
 
  bool in_transaction() const override;
 
  std::unique_ptr<PostgreSQLStatement> prepare_statement(const std::string& name,
                                                         const std::string& sql, int param_count);
 
  PGconn* get_pg_conn() { return pg_conn_; }
 
  static std::string convert_placeholders(const std::string& sql);
 
private:
  std::string connection_string_;
  PGconn* pg_conn_ = nullptr;
  bool is_connected_ = false;
  bool in_transaction_ = false;
 
  ConnectionResult<PGresult*> handle_pg_result(PGresult* result, int expected_status = -1);
};
 
}  // namespace relx::connection