Fix PG connection leak on failed establishment and add SQL warnings support

1.1 Connection leak: PostgreSQLRubyJdbcConnection#newConnection opened a
physical backend via super.newConnection() but then ran unwrap()/addDataType()
without cleanup. Any failure there leaked the open server-side connection,
since the caller only saw the exception and never got a handle to close it.
Wrap the post-connect setup so the connection is closed (suppressing close
errors) before re-raising, mirroring the native adapter discarding a
connection it could not fully establish.

1.2 SQL warnings (AR 7.2 db_warnings_action): capture statement.getWarnings()
in RubyJdbcConnection#execute before the statement closes and expose them via
#last_warnings. PostgreSQLRubyJdbcConnection#newWarning maps PSQLWarning's
ServerErrorMessage to [message, sqlstate, severity]. The PG raw_execute
override dispatches them through handle_warnings to ActiveRecord
.db_warnings_action and normalises the Integer update-count return to [] for
PG::Result API parity.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: skunkworker

lib/arjdbc/postgresql/database_statements.rb

@@ -15,6 +15,46 @@ def build_explain_clause(options = [])
 
         "EXPLAIN (#{options.join(", ").upcase})"
       end
+
+      # Overridden to surface any SQL warnings (PostgreSQL NOTICE / RAISE
+      # WARNING messages) emitted while running +sql+ to the configured
+      # +ActiveRecord.db_warnings_action+, matching the native PostgreSQL
+      # adapter. The warnings themselves are collected on the Java side during
+      # #execute and read back here via #last_warnings.
+      def raw_execute(sql, name, async: false, allow_retry: false, materialize_transactions: true)
+        log(sql, name, async: async) do
+          with_raw_connection(allow_retry: allow_retry, materialize_transactions: materialize_transactions) do |conn|
+            result = conn.execute(sql)
+            verified!
+            handle_warnings(sql)
+            # The native adapter returns a result object (PG::Result) whose
+            # #to_a is []; statements without a result set come back as an
+            # update count here, so normalise to an array for API parity.
+            result.is_a?(Integer) ? [] : result
+          end
+        end
+      end
+
+      private
+
+      # Dispatches SQL warnings collected by the most recent #execute to
+      # +ActiveRecord.db_warnings_action+ (mirrors the native adapter).
+      def handle_warnings(sql)
+        return if ActiveRecord.db_warnings_action.nil?
+
+        @raw_connection.last_warnings.each do |message, code, level|
+          warning = ActiveRecord::SQLWarning.new(message, code, level, sql, @pool)
+          next if warning_ignored?(warning)
+
+          ActiveRecord.db_warnings_action.call(warning)
+        end
+      end
+
+      # Only WARNING and above are treated as SQL warnings; NOTICE/INFO/DEBUG/LOG
+      # level messages are ignored, as in the native PostgreSQL adapter.
+      def warning_ignored?(warning)
+        ["WARNING", "ERROR", "FATAL", "PANIC"].exclude?(warning.level) || super
+      end
     end
   end
 end

src/java/arjdbc/jdbc/RubyJdbcConnection.java

@@ -40,6 +40,7 @@
 import java.sql.ResultSet;
 import java.sql.ResultSetMetaData;
 import java.sql.SQLException;
+import java.sql.SQLWarning;
 import java.sql.SQLXML;
 import java.sql.Statement;
 import java.sql.Date;
@@ -133,6 +134,10 @@ public class RubyJdbcConnection extends RubyObject {
     private boolean configureConnection = true; // final once initialized
     private int fetchSize = 0; // 0 = JDBC default
 
+    // SQL warnings collected by the most recent #execute call, exposed to the
+    // adapter via #last_warnings so it can honour ActiveRecord.db_warnings_action.
+    private transient IRubyObject lastWarnings;
+
     protected RubyJdbcConnection(Ruby runtime, RubyClass metaClass) {
         super(runtime, metaClass);
         attributeClass = runtime.getModule("ActiveModel").getClass("Attribute");
@@ -807,6 +812,10 @@ public IRubyObject execute(final ThreadContext context, final IRubyObject sql) {
                     updateCount = statement.getUpdateCount();
                 }
 
+                // Capture any SQL warnings (e.g. PostgreSQL RAISE WARNING / NOTICE)
+                // raised while executing, before the statement is closed below.
+                lastWarnings = mapWarnings(context, statement.getWarnings());
+
                 return result;
 
             } catch (final SQLException e) {
@@ -818,6 +827,42 @@ public IRubyObject execute(final ThreadContext context, final IRubyObject sql) {
         });
     }
 
+    /**
+     * @return the SQL warnings collected by the most recent {@link #execute}
+     *         as an Array of <code>[message, sql_state, level]</code> arrays.
+     */
+    @JRubyMethod(name = "last_warnings")
+    public IRubyObject last_warnings(final ThreadContext context) {
+        return lastWarnings == null ? context.runtime.newEmptyArray() : lastWarnings;
+    }
+
+    /**
+     * Maps a chain of {@link SQLWarning}s to a Ruby Array of warning tuples.
+     * @param warning the head of the warning chain (may be null)
+     * @return a (possibly empty) Ruby Array of <code>[message, sql_state, level]</code>
+     */
+    protected IRubyObject mapWarnings(final ThreadContext context, SQLWarning warning) {
+        final RubyArray warnings = context.runtime.newArray();
+        while (warning != null) {
+            warnings.append(newWarning(context, warning));
+            warning = warning.getNextWarning();
+        }
+        return warnings;
+    }
+
+    /**
+     * Builds a single warning tuple <code>[message, sql_state, level]</code>.
+     * The generic JDBC API does not expose a severity level, so it is left nil;
+     * adapters with richer driver support (e.g. PostgreSQL) may override this.
+     */
+    protected IRubyObject newWarning(final ThreadContext context, final SQLWarning warning) {
+        final Ruby runtime = context.runtime;
+        final IRubyObject message = RubyString.newUnicodeString(runtime, warning.getMessage());
+        final String sqlState = warning.getSQLState();
+        final IRubyObject code = sqlState == null ? context.nil : RubyString.newUnicodeString(runtime, sqlState);
+        return runtime.newArray(message, code, context.nil);
+    }
+
     protected Statement createStatement(final ThreadContext context, final Connection connection)
         throws SQLException {
         final Statement statement = connection.createStatement();

src/java/arjdbc/postgresql/PostgreSQLRubyJdbcConnection.java

@@ -66,6 +66,8 @@
 import org.postgresql.geometric.PGpolygon;
 import org.postgresql.util.PGInterval;
 import org.postgresql.util.PGobject;
+import org.postgresql.util.PSQLWarning;
+import org.postgresql.util.ServerErrorMessage;
 
 /**
  *
@@ -241,19 +243,35 @@ protected Connection newConnection() throws RaiseException, SQLException {
             }
             throw ex;
         }
-        final PGConnection pgConnection;
-        if ( connection instanceof PGConnection ) {
-            pgConnection = (PGConnection) connection;
+        // The physical connection is open now; if any of the post-connect
+        // setup below fails we must close it, otherwise the server-side backend
+        // leaks (the caller only sees the exception and never gets a handle to
+        // close). This mirrors the native adapter discarding a connection that
+        // could not be fully established.
+        try {
+            final PGConnection pgConnection;
+            if ( connection instanceof PGConnection ) {
+                pgConnection = (PGConnection) connection;
+            }
+            else {
+                pgConnection = connection.unwrap(PGConnection.class);
+            }
+            pgConnection.addDataType("daterange", DateRangeType.class);
+            pgConnection.addDataType("tsrange",   TsRangeType.class);
+            pgConnection.addDataType("tstzrange", TstzRangeType.class);
+            pgConnection.addDataType("int4range", Int4RangeType.class);
+            pgConnection.addDataType("int8range", Int8RangeType.class);
+            pgConnection.addDataType("numrange",  NumRangeType.class);
         }
-        else {
-            pgConnection = connection.unwrap(PGConnection.class);
+        catch (SQLException|RuntimeException ex) {
+            try {
+                connection.close();
+            }
+            catch (SQLException closeError) {
+                ex.addSuppressed(closeError);
+            }
+            throw ex;
         }
-        pgConnection.addDataType("daterange", DateRangeType.class);
-        pgConnection.addDataType("tsrange",   TsRangeType.class);
-        pgConnection.addDataType("tstzrange", TstzRangeType.class);
-        pgConnection.addDataType("int4range", Int4RangeType.class);
-        pgConnection.addDataType("int8range", Int8RangeType.class);
-        pgConnection.addDataType("numrange",  NumRangeType.class);
         return connection;
     }
 
@@ -277,6 +295,31 @@ protected IRubyObject mapQueryResult(final ThreadContext context, final Connecti
         return mapExecuteResult(context, connection, resultSet).toARResult(context);
     }
 
+    /**
+     * Builds a warning tuple <code>[message, sql_state, level]</code> for a
+     * PostgreSQL server message (e.g. <code>RAISE WARNING</code> / NOTICE).
+     * The driver wraps these as {@link PSQLWarning}, which carries the original
+     * {@link ServerErrorMessage} with the clean primary message, SQLSTATE and
+     * severity ("WARNING", "NOTICE", ...) that ActiveRecord's db_warnings
+     * handling needs.
+     */
+    @Override
+    protected IRubyObject newWarning(final ThreadContext context, final SQLWarning warning) {
+        if (warning instanceof PSQLWarning) {
+            final ServerErrorMessage serverError = ((PSQLWarning) warning).getServerErrorMessage();
+            if (serverError != null) {
+                final Ruby runtime = context.runtime;
+                final IRubyObject message = RubyString.newUnicodeString(runtime, serverError.getMessage());
+                final String sqlState = serverError.getSQLState();
+                final IRubyObject code = sqlState == null ? context.nil : RubyString.newUnicodeString(runtime, sqlState);
+                final String severity = serverError.getSeverity();
+                final IRubyObject level = severity == null ? context.nil : RubyString.newUnicodeString(runtime, severity);
+                return runtime.newArray(message, code, level);
+            }
+        }
+        return super.newWarning(context, warning);
+    }
+
     @Override
     protected void setArrayParameter(final ThreadContext context,
                                      final Connection connection, final PreparedStatement statement,