postgresql_statement.hpp

Go to the documentation of this file.

#pragma once
 
#include "postgresql_connection.hpp"
 
#include <expected>
#include <memory>
#include <optional>
#include <sstream>
#include <string>
#include <string_view>
#include <type_traits>
#include <vector>
 
// Forward declaration
struct pg_result;
using PGresult = pg_result;
namespace relx::connection {
 
class PostgreSQLStatement {
public:
  PostgreSQLStatement(PostgreSQLConnection& connection, std::string name, std::string sql,
                      int param_count);
 
  ~PostgreSQLStatement();
 
  // Delete copy operations
  PostgreSQLStatement(const PostgreSQLStatement&) = delete;
  PostgreSQLStatement& operator=(const PostgreSQLStatement&) = delete;
 
  // Allow move operations
  PostgreSQLStatement(PostgreSQLStatement&&) noexcept;
  PostgreSQLStatement& operator=(PostgreSQLStatement&&) noexcept;
 
  ConnectionResult<result::ResultSet> execute(const std::vector<std::string>& params = {});
 
  template <typename... Args>
  ConnectionResult<result::ResultSet> execute_typed(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 with our converted parameters
    return execute(param_strings);
  }
 
  const std::string& name() const { return name_; }
 
  const std::string& sql() const { return sql_; }
 
  int param_count() const { return param_count_; }
 
  bool is_valid() const { return is_valid_; }
 
private:
  PostgreSQLConnection& connection_;
  std::string name_;
  std::string sql_;
  int param_count_;
  bool is_valid_ = true;
 
  ConnectionResult<PGresult*> execute_raw(const std::vector<std::string>& params,
                                          int result_format = 0);
 
  static ConnectionResult<result::ResultSet> process_result(PGresult* pg_result);
 
  static std::string escape_string(const std::string& str);
};
 
}  // namespace relx::connection