Use C++17 feature constexpr if to simplify pgsql code

Also adds a crucial std::decay_t<> which makes sure this works for all
sorts of types.

Author: joto

src/pgsql.hpp

@@ -122,51 +122,6 @@ class pg_result_t
     std::unique_ptr<PGresult, pg_result_deleter_t> m_result;
 };
 
-// Do not use anonymous namespace in header file
-// https://wiki.sei.cmu.edu/confluence/display/cplusplus/DCL59-CPP.+Do+not+define+an+unnamed+namespace+in+a+header+file
-namespace detail {
-
-/**
- * Helper for pg_conn_t::exec_prepared() function. All parameters to
- * that function are given to the exec_arg::to_str function which will
- * pass through string-like parameters and convert other parameters to
- * strings.
- */
-template <typename T>
-struct exec_arg
-{
-    constexpr static std::size_t const buffers_needed = 1;
-    static char const *to_str(std::vector<std::string> *data, T param)
-    {
-        return data->emplace_back(fmt::to_string(std::forward<T>(param)))
-            .c_str();
-    }
-};
-
-template <>
-struct exec_arg<char const *>
-{
-    constexpr static std::size_t const buffers_needed = 0;
-    static char const *to_str(std::vector<std::string> * /*data*/,
-                              char const *param) noexcept
-    {
-        return param;
-    }
-};
-
-template <>
-struct exec_arg<std::string const &>
-{
-    constexpr static std::size_t const buffers_needed = 0;
-    static char const *to_str(std::vector<std::string> * /*data*/,
-                              std::string const &param) noexcept
-    {
-        return param.c_str();
-    }
-};
-
-} // namespace detail
-
 /**
  * PostgreSQL connection.
  *
@@ -258,6 +213,39 @@ class pg_conn_t
                                        int *param_lengths, int *param_formats,
                                        int result_format) const;
 
+    /**
+     * Helper for pg_conn_t::exec_prepared_with_result_format() function. Used
+     * to find out how many buffers we need. Must always be in sync with the
+     * to_str() function below.
+     */
+    template <typename T>
+    static constexpr std::size_t buffers_needed() noexcept
+    {
+        if constexpr (std::is_same_v<T, char const *>) {
+            return 0;
+        } else if constexpr (std::is_same_v<T, std::string>) {
+            return 0;
+        }
+        return 1;
+    }
+
+    /**
+     * Helper for pg_conn_t::exec_prepared_with_result_format() function. All
+     * parameters to that function are given to the to_str() function which
+     * will pass through string-like parameters and convert other parameters to
+     * strings.
+     */
+    template <typename T>
+    static char const *to_str(std::vector<std::string> *data, T const &param)
+    {
+        if constexpr (std::is_same_v<T, char const *>) {
+            return param;
+        } else if constexpr (std::is_same_v<T, std::string>) {
+            return param.c_str();
+        }
+        return data->emplace_back(fmt::to_string(param)).c_str();
+    }
+
     /**
      * Run the named prepared SQL statement and return the results.
      *
@@ -279,16 +267,16 @@ class pg_conn_t
         // so that pointers into the strings in that vector remain valid
         // after new parameters have been added.
         constexpr auto const total_buffers_needed =
-            (0 + ... + detail::exec_arg<TArgs>::buffers_needed);
+            (0 + ... + buffers_needed<std::decay_t<TArgs>>());
         std::vector<std::string> exec_params;
         exec_params.reserve(total_buffers_needed);
 
         // This array holds the pointers to all parameter strings, either
         // to the original string parameters or to the recently converted
         // in the exec_params vector.
         std::array<char const *, sizeof...(params)> param_ptrs = {
-            detail::exec_arg<TArgs>::to_str(&exec_params,
-                                            std::forward<TArgs>(params))...};
+            to_str<std::decay_t<TArgs>>(&exec_params,
+                                        std::forward<TArgs>(params))...};
 
         return exec_prepared_internal(stmt, sizeof...(params),
                                       param_ptrs.data(), nullptr, nullptr,

tests/test-pgsql.cpp

@@ -83,13 +83,17 @@ TEST_CASE("exec_prepared with single string parameters should work")
 TEST_CASE("exec_prepared with string parameters should work")
 {
     auto conn = db.db().connect();
-    conn.exec("PREPARE test(int, int, int) AS SELECT $1 + $2 + $3");
+    conn.exec("PREPARE test(int, int, int, int, int)"
+              " AS SELECT $1 + $2 + $3 + $4 + $5");
 
-    auto const result = conn.exec_prepared("test", "1", "2", std::string{"3"});
+    std::string a{"4"}; // NOLINT(misc-const-correctness)
+    std::string const b{"5"};
+    auto const result =
+        conn.exec_prepared("test", "1", "2", std::string{"3"}, a, b);
     REQUIRE(result.status() == PGRES_TUPLES_OK);
     REQUIRE(result.num_fields() == 1);
     REQUIRE(result.num_tuples() == 1);
-    REQUIRE(result.get(0, 0) == "6");
+    REQUIRE(result.get(0, 0) == "15");
 }
 
 TEST_CASE("exec_prepared with non-string parameters should work")