Added option to get row fields as array

Author: dankmolot

async_postgres.lua

@@ -90,6 +90,9 @@
 ---@field escapeBytea       fun(self: PGconn, str: string): string
 ---@field unescapeBytea     fun(self: PGconn, str: string): string
 ---@field setNotifyCallback fun(self: PGconn, callback: fun(channel: string, payload: string, backendPID: number))
+---@field getNotifyCallback fun(self: PGconn): fun(channel: string, payload: string, backendPID: number)
+---@field setArrayResult    fun(self: PGconn, enabled: boolean)
+---@field getArrayResult    fun(self: PGconn): boolean
 
 ---@class PGResult
 ---@field fields { name: string, type: number }[] list of fields in the result
@@ -161,6 +164,7 @@ end
 ---@field url string **readonly** connection url
 ---@field connecting boolean **readonly** is client connecting to the database
 ---@field closed boolean **readonly** is client closed (to change it to true use `:close()`)
+---@field array_result boolean option to receive PGResult row fields as array instead of table (default: false)
 ---@field private conn PGconn native connection object (do not use it directly, otherwise be careful not to store it anywhere else, otherwise closing connection will be impossible)
 ---@field private queries { push: fun(self, q: PGQuery), prepend: fun(self, q: PGQuery), pop: (fun(self): PGQuery), size: fun(self): number } list of queries
 ---@field package acquired boolean
@@ -275,7 +279,17 @@ end
 ---@private
 ---@param query PGQuery
 function Client:runQuery(query)
+    local array_result = self.array_result
+    if array_result then
+        self.conn:setArrayResult(true)
+    end
+
     local function callback(ok, result, errdata)
+        if array_result and not self.conn:querying() then
+            -- final query, reset array result
+            self.conn:setArrayResult(false)
+        end
+
         xpcall(query.callback, ErrorNoHaltWithStack, ok, result, errdata)
         self:processQueue()
     end
@@ -934,6 +948,7 @@ function Pool:describePortal(name, callback)
     end)
 end
 
+---@async
 local function transactionThread(client, callback)
     xpcall(function()
         local ctx = TransactionContext.new(client)

source/async_postgres.hpp

@@ -113,6 +113,7 @@ namespace async_postgres {
         std::shared_ptr<Query> query;
         std::shared_ptr<ResetEvent> reset_event;
         GLua::AutoReference on_notify;
+        bool array_result = false;
 
         Connection(GLua::ILuaInterface* lua, pg::conn&& conn);
         ~Connection();
@@ -139,7 +140,8 @@ namespace async_postgres {
     void process_query(GLua::ILuaInterface* lua, Connection* state);
 
     // result.cpp
-    void create_result_table(GLua::ILuaInterface* lua, PGresult* result);
+    void create_result_table(GLua::ILuaInterface* lua, PGresult* result,
+                             bool array_result);
 
     // misc.cpp
     void register_misc_connection_functions(GLua::ILuaInterface* lua);

source/main.cpp

@@ -198,6 +198,15 @@ namespace async_postgres::lua {
         return 0;
     }
 
+    lua_protected_fn(getNotifyCallback) {
+        lua->CheckType(1, async_postgres::connection_meta);
+        auto state = lua_connection_state();
+        if (!state->on_notify.Push()) {
+            lua->PushNil();
+        }
+        return 1;
+    }
+
     lua_protected_fn(wait) {
         lua->CheckType(1, async_postgres::connection_meta);
 
@@ -263,6 +272,21 @@ namespace async_postgres::lua {
         lua->PushBool(!!state->reset_event);
         return 1;
     }
+
+    lua_protected_fn(setArrayResult) {
+        lua->CheckType(1, async_postgres::connection_meta);
+        lua->CheckType(2, GLua::Type::Bool);
+        auto state = lua_connection_state();
+        state->array_result = lua->GetBool(2);
+        return 0;
+    }
+
+    lua_protected_fn(getArrayResult) {
+        lua->CheckType(1, async_postgres::connection_meta);
+        auto state = lua_connection_state();
+        lua->PushBool(state->array_result);
+        return 1;
+    }
 }  // namespace async_postgres::lua
 
 #define register_lua_fn(name)                      \
@@ -284,10 +308,13 @@ void register_connection_mt(GLua::ILuaInterface* lua) {
     register_lua_fn(describePortal);
     register_lua_fn(reset);
     register_lua_fn(setNotifyCallback);
+    register_lua_fn(getNotifyCallback);
     register_lua_fn(wait);
     register_lua_fn(isBusy);
     register_lua_fn(querying);
     register_lua_fn(resetting);
+    register_lua_fn(setArrayResult);
+    register_lua_fn(getArrayResult);
 
     async_postgres::register_misc_connection_functions(lua);
 

source/query.cpp

@@ -94,11 +94,11 @@ inline void create_result_error_table(GLua::ILuaInterface* lua,
 }
 
 void query_result(GLua::ILuaInterface* lua, pg::result&& result,
-                  GLua::AutoReference& callback) {
+                  GLua::AutoReference& callback, bool array_result) {
     if (callback.Push()) {
         if (!bad_result(result.get())) {
             lua->PushBool(true);
-            create_result_table(lua, result.get());
+            create_result_table(lua, result.get(), array_result);
             pcall(lua, 2, 0);
         } else {
             lua->PushBool(false);
@@ -144,19 +144,22 @@ void async_postgres::process_result(GLua::ILuaInterface* lua, Connection* state,
             auto query = state->query;
             state->query.reset();
 
-            query_result(lua, std::move(result), query->callback);
+            query_result(lua, std::move(result), query->callback,
+                         state->array_result);
 
             // callback might added another query, process it rightaway
             process_query(lua, state);
         } else {
             // query is not done, but also since we own next result
             // we need to call query callback and process next result
-            query_result(lua, std::move(result), state->query->callback);
+            query_result(lua, std::move(result), state->query->callback,
+                         state->array_result);
             process_result(lua, state, std::move(next_result));
         }
     } else {
         // query is not done, but we don't need to process next result
-        query_result(lua, std::move(result), state->query->callback);
+        query_result(lua, std::move(result), state->query->callback,
+                     state->array_result);
     }
 }
 

source/result.cpp

@@ -10,7 +10,7 @@ struct FieldInfo {
 };
 
 void async_postgres::create_result_table(GLua::ILuaInterface* lua,
-                                         PGresult* result) {
+                                         PGresult* result, bool array_result) {
     lua->CreateTable();
 
     std::vector<FieldInfo> fields;
@@ -46,7 +46,11 @@ void async_postgres::create_result_table(GLua::ILuaInterface* lua,
             // skip NULL values
             if (!PQgetisnull(result, i, j)) {
                 // field name
-                lua->PushString(fields[j].name);
+                if (!array_result) {
+                    lua->PushString(fields[j].name);
+                } else {
+                    lua->PushNumber(j + 1);
+                }
 
                 // field value
                 lua->PushString(PQgetvalue(result, i, j),