wop

Author: dankmolot

source/async_postgres.hpp

@@ -42,6 +42,24 @@ namespace GLua = GarrysMod::Lua;
     int name##__Imp([[maybe_unused]] GarrysMod::Lua::ILuaInterface* lua)
 
 namespace async_postgres {
+    typedef std::variant<std::nullptr_t, std::string, double, bool> ParamValue;
+
+    struct ParamValues {
+        ParamValues(int n_params)
+            : strings(n_params),
+              values(n_params),
+              lengths(n_params, 0),
+              formats(n_params, 0) {}
+
+        inline int length() const { return strings.size(); }
+
+        std::vector<std::string> strings;
+        // vectors below are used in PQexecParams-like functions
+        std::vector<const char*> values;
+        std::vector<int> lengths;
+        std::vector<int> formats;
+    };
+
     struct SocketStatus {
         bool read_ready = false;
         bool write_ready = false;
@@ -54,7 +72,7 @@ namespace async_postgres {
 
     struct ParameterizedCommand {
         std::string command;
-        std::vector<std::string> values;
+        ParamValues param;
     };
 
     struct Query {
@@ -104,10 +122,11 @@ namespace async_postgres {
 
     // misc.cpp
     void register_misc_connection_functions(GLua::ILuaInterface* lua);
-    std::vector<std::optional<std::string>> lua_array_to_params();
 
     // util.cpp
     std::string_view get_string(GLua::ILuaInterface* lua, int index = -1);
     void pcall(GLua::ILuaInterface* lua, int nargs, int nresults);
+    // Converts a lua array at given index to a ParamValues
+    ParamValues array_to_params(GLua::ILuaInterface* lua, int index);
     SocketStatus check_socket_status(PGconn* conn);
 };  // namespace async_postgres

source/main.cpp

@@ -101,21 +101,10 @@ namespace async_postgres::lua {
 
         auto state = lua_connection_state();
 
-        async_postgres::ParameterizedCommand command = {lua->GetString(2)};
-
-        lua->Push(3);
-        for (int i = 1;; i++) {
-            lua->PushNumber(i);
-            lua->GetTable(-2);
-            if (lua->IsType(-1, GLua::Type::Nil)) {
-                lua->Pop(2);
-                break;
-            }
-
-            auto str = get_string(lua, -1);
-            command.values.push_back({str.data(), str.size()});
-            lua->Pop(1);
-        }
+        async_postgres::ParameterizedCommand command = {
+            lua->GetString(2),
+            async_postgres::array_to_params(lua, 3),
+        };
 
         async_postgres::Query query = {std::move(command)};
         query.callback = GLua::AutoReference(lua, 4);

source/query.cpp

@@ -9,23 +9,11 @@ inline bool send_query(PGconn* conn, Query& query) {
         return PQsendQuery(conn, command->command.c_str()) == 1;
     } else if (const auto* command =
                    std::get_if<ParameterizedCommand>(&query.command)) {
-        // TODO: support binary format
-        size_t nParams = command->values.size();
-        std::vector<const char*> paramValues(nParams);
-        std::vector<int> paramLengths(nParams);
-        std::vector<int> paramFormats(nParams, 1);
-        for (size_t i = 0; i < nParams; i++) {
-            const auto& value = command->values[i];
-            paramValues[i] = value.c_str();
-            paramLengths[i] = value.size();
-        }
-
-        bool success =
-            PQsendQueryParams(conn, command->command.c_str(), nParams, nullptr,
-                              paramValues.data(), paramLengths.data(),
-                              paramFormats.data(), 1) == 1;
-
-        return success;
+        return PQsendQueryParams(conn, command->command.c_str(),
+                                 command->param.length(), nullptr,
+                                 command->param.values.data(),
+                                 command->param.lengths.data(),
+                                 command->param.formats.data(), 0) == 1;
     }
     return false;
 }

source/util.cpp

@@ -33,6 +33,42 @@ void async_postgres::pcall(GLua::ILuaInterface* lua, int nargs, int nresults) {
     lua->Pop();  // ErrorNoHaltWithStack
 }
 
+ParamValues async_postgres::array_to_params(GLua::ILuaInterface* lua,
+                                            int index) {
+    lua->Push(index);
+    int len = lua->ObjLen(-1);
+
+    ParamValues param(len);
+    for (int i = 0; i < len; i++) {
+        lua->PushNumber(i + 1);
+        lua->GetTable(-2);
+
+        auto type = lua->GetType(-1);
+        if (type == GLua::Type::String) {
+            auto value = get_string(lua, -1);
+            param.strings[i] = std::string(value.data(), value.size());
+            param.values[i] = param.strings[i].c_str();
+            param.lengths[i] = value.length();
+            param.formats[i] = 1;
+        } else if (type == GLua::Type::Number) {
+            param.strings[i] = std::to_string(lua->GetNumber(-1));
+            param.values[i] = param.strings[i].c_str();
+        } else if (type == GLua::Type::Bool) {
+            param.values[i] = lua->GetBool(-1) ? "true" : "false";
+        } else if (type == GLua::Type::Nil) {
+            param.values[i] = nullptr;
+        } else {
+            throw std::runtime_error(
+                "unsupported type given into params array");
+        }
+
+        lua->Pop(1);
+    }
+
+    lua->Pop(1);
+    return param;
+}
+
 #if SYSTEM_IS_WINDOWS
 #include <WinSock2.h>
 #define poll WSAPoll