Added support for notices and warnings

Author: dankmolot

async_postgres.lua

@@ -91,6 +91,8 @@
 ---@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 setNoticeCallback fun(self: PGconn, callback: fun(message: string, errdata: table))
+---@field getNoticeCallback fun(self: PGconn): fun(message: string, errdata: table)
 ---@field setArrayResult    fun(self: PGconn, enabled: boolean)
 ---@field getArrayResult    fun(self: PGconn): boolean
 
@@ -119,10 +121,6 @@ if async_postgres.LUA_API_VERSION ~= 1 then
         "expected 1, got " .. async_postgres.LUA_API_VERSION)
 end
 
-
----@class async_postgres_module : async_postgres
-local module = setmetatable({}, { __index = async_postgres })
-
 local Queue = {}
 Queue.__index = Queue
 
@@ -244,6 +242,9 @@ function Client:connect(callback)
             self.conn:setNotifyCallback(function(channel, payload, backendPID)
                 xpcall(self.onNotify, self.errorHandler, self, channel, payload, backendPID)
             end)
+            self.conn:setNoticeCallback(function(message, errdata)
+                xpcall(self.onNotice, self.errorHandler, self, message, errdata)
+            end)
 
             xpcall(callback, self.errorHandler, ok)
             self:processQueue()
@@ -663,6 +664,17 @@ end
 function Client:onNotify(channel, payload, backendPID)
 end
 
+--- This **event** function is called when server sends a notice/warning message
+--- during a query
+---
+--- You can set it to your own function to handle notices
+--- By default this function calls `ErrorNoHalt`
+---@param message string notice message
+---@param errdata table additional data
+function Client:onNotice(message, errdata)
+    ErrorNoHalt(tostring(self) .. " " .. message)
+end
+
 --- This **event** function is called whenever an error occurs inside connect/query callback.
 ---
 --- You can set it to your own function to handle errors.
@@ -696,7 +708,7 @@ end
 --- connectiong url format can be found at https://www.postgresql.org/docs/current/libpq-connect.html#LIBPQ-CONNSTRING
 ---@param url string connection url, see libpq documentation for more information
 ---@return PGClient
-function module.Client(url)
+function async_postgres.Client(url)
     ---@class PGClient
     local client = setmetatable({
         url = url,
@@ -891,7 +903,7 @@ function Pool:processQueue()
     local waiters = self.queue:size()
     local threshold = clients * self.threshold
     if clients < self.max and waiters > threshold then
-        local client = module.Client(self.url)
+        local client = async_postgres.Client(self.url)
         client.onError = function(client, message)
             return self:onError(message)
         end
@@ -1079,11 +1091,12 @@ end
 --- Creates a new connection pool with given connection url,
 --- then use :connect() to get available connection,
 --- and then :release() to release it back to the pool
-function module.Pool(url)
+---@return PGPool
+function async_postgres.Pool(url)
     ---@class PGPool
     local pool = setmetatable({
         url = url,
-        clients = { module.Client(url) },
+        clients = { async_postgres.Client(url) },
         queue = Queue.new(),
         max = 10,
         threshold = 5,

pgsqloo.lua

@@ -0,0 +1 @@
+/Users/retr0/Library/Application Support/Steam/steamapps/common/GarrysMod/garrysmod/addons/moon/lua/autorun/pgsqloo.lua

source/async_postgres.hpp

@@ -2,7 +2,6 @@
 #include <GarrysMod/Lua/AutoReference.h>
 #include <GarrysMod/Lua/Interface.h>
 #include <GarrysMod/Lua/LuaInterface.h>
-#include <libpq-fe.h>
 
 #include <algorithm>
 #include <chrono>
@@ -109,10 +108,12 @@ namespace async_postgres {
     };
 
     struct Connection {
+        GLua::ILuaInterface* lua;
         pg::conn conn;
         std::shared_ptr<Query> query;
         std::shared_ptr<ResetEvent> reset_event;
         GLua::AutoReference on_notify;
+        GLua::AutoReference on_notice;
         bool array_result = false;
 
         Connection(GLua::ILuaInterface* lua, pg::conn&& conn);
@@ -142,6 +143,8 @@ namespace async_postgres {
     // result.cpp
     void create_result_table(GLua::ILuaInterface* lua, PGresult* result,
                              bool array_result);
+    void create_result_error_table(GLua::ILuaInterface* lua,
+                                   const PGresult* result);
 
     // misc.cpp
     void register_misc_connection_functions(GLua::ILuaInterface* lua);

source/connection.cpp

@@ -5,7 +5,7 @@ using namespace async_postgres;
 std::vector<Connection*> async_postgres::connections = {};
 
 Connection::Connection(GLua::ILuaInterface* lua, pg::conn&& conn)
-    : conn(std::move(conn)) {
+    : conn(std::move(conn)), lua(lua) {
     // add connection to global list
     connections.push_back(this);
 }
@@ -35,6 +35,17 @@ inline bool socket_is_ready(PGconn* conn, PostgresPollingStatusType status) {
     return true;
 }
 
+static void noticeReceiver(void* arg, const PGresult* res) {
+    auto state = static_cast<Connection*>(arg);
+    if (state->on_notice.IsValid()) {
+        auto lua = state->lua;
+        state->on_notice.Push();
+        lua->PushString(PQresultErrorMessage(res));
+        create_result_error_table(lua, res);
+        pcall(lua, 2, 0);
+    }
+}
+
 void async_postgres::connect(GLua::ILuaInterface* lua, std::string_view url,
                              GLua::AutoReference&& callback) {
     auto conn = pg::connectStart(url);
@@ -65,6 +76,8 @@ inline bool poll_pending_connection(GLua::ILuaInterface* lua,
     if (event.status == PGRES_POLLING_OK) {
         auto state = new Connection(lua, std::move(event.conn));
 
+        PQsetNoticeReceiver(state->conn.get(), noticeReceiver, state);
+
         event.callback.Push();
         lua->PushBool(true);
         lua->PushUserType(state, connection_meta);

source/main.cpp

@@ -207,6 +207,26 @@ namespace async_postgres::lua {
         return 1;
     }
 
+    lua_protected_fn(setNoticeCallback) {
+        lua->CheckType(1, async_postgres::connection_meta);
+
+        auto state = lua_connection_state();
+        if (lua->IsType(2, GLua::Type::Function)) {
+            state->on_notice = GLua::AutoReference(lua, 2);
+        }
+
+        return 0;
+    }
+
+    lua_protected_fn(getNoticeCallback) {
+        lua->CheckType(1, async_postgres::connection_meta);
+        auto state = lua_connection_state();
+        if (!state->on_notice.Push()) {
+            lua->PushNil();
+        }
+        return 1;
+    }
+
     lua_protected_fn(wait) {
         lua->CheckType(1, async_postgres::connection_meta);
 
@@ -309,6 +329,8 @@ void register_connection_mt(GLua::ILuaInterface* lua) {
     register_lua_fn(reset);
     register_lua_fn(setNotifyCallback);
     register_lua_fn(getNotifyCallback);
+    register_lua_fn(setNoticeCallback);
+    register_lua_fn(getNoticeCallback);
     register_lua_fn(wait);
     register_lua_fn(isBusy);
     register_lua_fn(querying);

source/query.cpp

@@ -60,39 +60,6 @@ inline bool bad_result(PGresult* result) {
            status == PGRES_FATAL_ERROR;
 }
 
-#define set_error_field(name, field)                                 \
-    {                                                                \
-        const char* field_value = PQresultErrorField(result, field); \
-        if (field_value) {                                           \
-            lua->PushString(field_value);                            \
-            lua->SetField(-2, name);                                 \
-        }                                                            \
-    }
-
-inline void create_result_error_table(GLua::ILuaInterface* lua,
-                                      PGresult* result) {
-    lua->CreateTable();
-
-    lua->PushString(PQresStatus(PQresultStatus(result)));
-    lua->SetField(-2, "status");
-
-    set_error_field("severity", PG_DIAG_SEVERITY_NONLOCALIZED);
-    set_error_field("sqlState", PG_DIAG_SQLSTATE);
-    set_error_field("messagePrimary", PG_DIAG_MESSAGE_PRIMARY);
-    set_error_field("messageDetail", PG_DIAG_MESSAGE_DETAIL);
-    set_error_field("messageHint", PG_DIAG_MESSAGE_HINT);
-    set_error_field("statementPosition", PG_DIAG_STATEMENT_POSITION);
-    set_error_field("context", PG_DIAG_CONTEXT);
-    set_error_field("schemaName", PG_DIAG_SCHEMA_NAME);
-    set_error_field("tableName", PG_DIAG_TABLE_NAME);
-    set_error_field("columnName", PG_DIAG_COLUMN_NAME);
-    set_error_field("dataType", PG_DIAG_DATATYPE_NAME);
-    set_error_field("constraintName", PG_DIAG_CONSTRAINT_NAME);
-    set_error_field("sourceFile", PG_DIAG_SOURCE_FILE);
-    set_error_field("sourceLine", PG_DIAG_SOURCE_LINE);
-    set_error_field("sourceFunction", PG_DIAG_SOURCE_FUNCTION);
-}
-
 void query_result(GLua::ILuaInterface* lua, pg::result&& result,
                   GLua::AutoReference& callback, bool array_result) {
     if (callback.Push()) {

source/result.cpp

@@ -69,3 +69,36 @@ void async_postgres::create_result_table(GLua::ILuaInterface* lua,
     lua->PushNumber(PQoidValue(result));
     lua->SetField(-2, "oid");
 }
+
+#define set_error_field(name, field)                                 \
+    {                                                                \
+        const char* field_value = PQresultErrorField(result, field); \
+        if (field_value) {                                           \
+            lua->PushString(field_value);                            \
+            lua->SetField(-2, name);                                 \
+        }                                                            \
+    }
+
+void async_postgres::create_result_error_table(GLua::ILuaInterface* lua,
+                                               const PGresult* result) {
+    lua->CreateTable();
+
+    lua->PushString(PQresStatus(PQresultStatus(result)));
+    lua->SetField(-2, "status");
+
+    set_error_field("severity", PG_DIAG_SEVERITY_NONLOCALIZED);
+    set_error_field("sqlState", PG_DIAG_SQLSTATE);
+    set_error_field("messagePrimary", PG_DIAG_MESSAGE_PRIMARY);
+    set_error_field("messageDetail", PG_DIAG_MESSAGE_DETAIL);
+    set_error_field("messageHint", PG_DIAG_MESSAGE_HINT);
+    set_error_field("statementPosition", PG_DIAG_STATEMENT_POSITION);
+    set_error_field("context", PG_DIAG_CONTEXT);
+    set_error_field("schemaName", PG_DIAG_SCHEMA_NAME);
+    set_error_field("tableName", PG_DIAG_TABLE_NAME);
+    set_error_field("columnName", PG_DIAG_COLUMN_NAME);
+    set_error_field("dataType", PG_DIAG_DATATYPE_NAME);
+    set_error_field("constraintName", PG_DIAG_CONSTRAINT_NAME);
+    set_error_field("sourceFile", PG_DIAG_SOURCE_FILE);
+    set_error_field("sourceLine", PG_DIAG_SOURCE_LINE);
+    set_error_field("sourceFunction", PG_DIAG_SOURCE_FUNCTION);
+}