connection.hpp

Go to the documentation of this file.

#pragma once
 
#include "../query/core.hpp"
#include "../results/result.hpp"
#include "meta.hpp"
 
#include <expected>
#include <memory>
#include <sstream>
#include <string>
#include <string_view>
#include <tuple>
#include <type_traits>
#include <vector>
 
#include <boost/pfr.hpp>
 
namespace relx {
namespace connection {
 
struct ConnectionError {
  std::string message;
  int error_code = 0;
};
 
template <typename T>
using ConnectionResult = std::expected<T, ConnectionError>;
 
enum class IsolationLevel {
  ReadUncommitted,  
  ReadCommitted,    
  RepeatableRead,   
  Serializable      
};
 
struct PostgreSQLConnectionParams {
  std::string host = "localhost";
  uint16_t port = 5432;
  std::string dbname;
  std::string user;
  std::string password;
  std::string application_name;
  int connect_timeout = 30;  // seconds
 
  // Optional parameters
  std::string ssl_mode;  // disable, require, verify-ca, verify-full
  std::string ssl_cert;
  std::string ssl_key;
  std::string ssl_root_cert;
 
  std::string to_connection_string() const {
    std::ostringstream conn_str;
 
    if (!host.empty()) {
      conn_str << "host=" << host << " ";
    }
    conn_str << "port=" << port << " ";
    if (!dbname.empty()) {
      conn_str << "dbname=" << dbname << " ";
    }
    if (!user.empty()) {
      conn_str << "user=" << user << " ";
    }
    if (!password.empty()) {
      conn_str << "password=" << password << " ";
    }
    if (!application_name.empty()) {
      conn_str << "application_name=" << application_name << " ";
    }
    conn_str << "connect_timeout=" << connect_timeout << " ";
 
    // Optional SSL parameters
    if (!ssl_mode.empty()) {
      conn_str << "sslmode=" << ssl_mode << " ";
    }
    if (!ssl_cert.empty()) {
      conn_str << "sslcert=" << ssl_cert << " ";
    }
    if (!ssl_key.empty()) {
      conn_str << "sslkey=" << ssl_key << " ";
    }
    if (!ssl_root_cert.empty()) {
      conn_str << "sslrootcert=" << ssl_root_cert << " ";
    }
 
    std::string result = conn_str.str();
    if (!result.empty() && result.back() == ' ') {
      result.pop_back();  // Remove trailing space
    }
 
    return result;
  }
};
 
class Connection {
public:
  virtual ~Connection() = default;
 
  [[nodiscard]] virtual ConnectionResult<void> connect() = 0;
 
  [[nodiscard]] virtual ConnectionResult<void> disconnect() = 0;
 
  [[nodiscard]]
  virtual ConnectionResult<result::ResultSet> execute_raw(
      const std::string& sql, const std::vector<std::string>& params = {}) = 0;
 
  template <query::SqlExpr Query>
  [[nodiscard]]
  ConnectionResult<result::ResultSet> execute(const Query& query) {
    std::string sql = query.to_sql();
    std::vector<std::string> params = query.bind_params();
    return execute_raw(sql, params);
  }
 
  template <typename T, query::SqlExpr Query>
  [[nodiscard]]
  ConnectionResult<T> execute(const Query& query) {
    auto result = execute(query);
    if (!result) {
      return std::unexpected(result.error());
    }
 
    const auto& result_set = *result;
    if (result_set.empty()) {
      return std::unexpected(ConnectionError{.message = "No results found"});
    }
 
    // Create an instance of T
    T obj{};
 
    // Get the first row of results
    const auto& row = result_set.at(0);
 
    // Use Boost.PFR to get the tuple type that matches our struct
    auto structure_tie = boost::pfr::structure_tie(obj);
 
    // Make sure the number of columns matches the number of fields in the struct
    // TODO What if struct has less fields than columns? Why is it working?
    if (result_set.column_count() != boost::pfr::tuple_size_v<std::remove_cvref_t<T>>) {
      std::stringstream ss;
      for (const auto& param : query.bind_params()) {
        ss << param << ", ";
      }
      return std::unexpected(ConnectionError{
          .message = "Column count does not match struct field count, " +
                     std::to_string(result_set.column_count()) +
                     " != " + std::to_string(boost::pfr::tuple_size_v<std::remove_cvref_t<T>>) +
                     " for struct " + typeid(T).name() + " and query " + query.to_sql() +
                     " with params " + ss.str(),
          .error_code = -1});
    }
 
    // Convert each value in the result row to the appropriate type in the struct
    try {
      // Create a vector of values from the row
      std::vector<std::string> values;
      for (size_t i = 0; i < result_set.column_count(); ++i) {
        auto cell_result = row.get_cell(i);
        if (!cell_result) {
          return std::unexpected(
              ConnectionError{.message = "Failed to get cell value: " + cell_result.error().message,
                              .error_code = -1});
        }
        values.push_back((*cell_result)->raw_value());
      }
 
      // Apply tuple assignment from the row values to the struct fields
      relx::connection::map_row_to_tuple(structure_tie, values);
    } catch (const std::exception& e) {
      return std::unexpected(
          ConnectionError{.message = std::string("Failed to convert result to struct: ") + e.what(),
                          .error_code = -1});
    }
 
    return obj;
  }
 
  template <typename T, query::SqlExpr Query>
  [[nodiscard]]
  ConnectionResult<std::vector<T>> execute_many(const Query& query) {
    auto result = execute(query);
    if (!result) {
      return std::unexpected(result.error());
    }
 
    const auto& result_set = *result;
    std::vector<T> objects;
    objects.reserve(result_set.size());
 
    // Check if we have at least one row to determine column count
    if (result_set.empty()) {
      return objects;  // Return empty vector
    }
 
    // Make sure the number of columns matches the number of fields in the struct
    // TODO
    if (result_set.column_count() != boost::pfr::tuple_size_v<std::remove_cvref_t<T>>) {
      std::stringstream ss;
      for (const auto& param : query.bind_params()) {
        ss << param << ", ";
      }
      return std::unexpected(ConnectionError{
          .message = "Column count does not match struct field count, " +
                     std::to_string(result_set.column_count()) +
                     " != " + std::to_string(boost::pfr::tuple_size_v<std::remove_cvref_t<T>>) +
                     " for struct " + typeid(T).name() + " and query " + query.to_sql() +
                     " with params " + ss.str(),
          .error_code = -1});
    }
 
    // Process each row
    for (size_t row_idx = 0; row_idx < result_set.size(); ++row_idx) {
      const auto& row = result_set.at(row_idx);
      T obj{};
      auto structure_tie = boost::pfr::structure_tie(obj);
 
      try {
        // Create a vector of values from the row
        std::vector<std::string> values;
        for (size_t i = 0; i < result_set.column_count(); ++i) {
          auto cell_result = row.get_cell(i);
          if (!cell_result) {
            return std::unexpected(ConnectionError{.message = "Failed to get cell value: " +
                                                              cell_result.error().message,
                                                   .error_code = -1});
          }
          values.push_back((*cell_result)->raw_value());
        }
 
        relx::connection::map_row_to_tuple(structure_tie, values);
        objects.push_back(std::move(obj));
      } catch (const std::exception& e) {
        return std::unexpected(ConnectionError{
            .message = std::string("Failed to convert result to struct: ") + e.what(),
            .error_code = -1});
      }
    }
 
    return objects;
  }
 
  virtual bool is_connected() const = 0;
 
  [[nodiscard]]
  virtual ConnectionResult<void> begin_transaction(
      IsolationLevel isolation_level = IsolationLevel::ReadCommitted) = 0;
 
  [[nodiscard]]
  virtual ConnectionResult<void> commit_transaction() = 0;
 
  [[nodiscard]]
  virtual ConnectionResult<void> rollback_transaction() = 0;
 
  virtual bool in_transaction() const = 0;
 
private:
};
 
}  // namespace connection
 
// Convenient imports from the connection namespace
using relx::connection::Connection;
using relx::connection::ConnectionError;
using relx::connection::ConnectionResult;
using relx::connection::IsolationLevel;
}  // namespace relx