fix: Make warnings available as soon as they are received.

pgjdbc/src/main/java/org/postgresql/jdbc/PgResultSet.java

@@ -1772,13 +1772,12 @@ public void handleCommandStatus(String status, int updateCount, long insertOID)
           PSQLState.PROTOCOL_VIOLATION));
     }
 
-    public void handleCompletion() throws SQLException {
-      SQLWarning warning = getWarning();
-      if (warning != null) {
-        PgResultSet.this.addWarning(warning);
-      }
-      super.handleCompletion();
+    @Override
+    public void handleWarning(SQLWarning warning) {
+      super.handleWarning(warning);
+      PgResultSet.this.warnings = this.getWarning();
     }
+
   }
 
 

pgjdbc/src/main/java/org/postgresql/jdbc/PgStatement.java

@@ -17,6 +17,7 @@
 import org.postgresql.core.ResultHandlerBase;
 import org.postgresql.core.SqlCommand;
 import org.postgresql.util.GT;
+import org.postgresql.util.PGSQLWarningWrapper;
 import org.postgresql.util.PSQLException;
 import org.postgresql.util.PSQLState;
 
@@ -98,11 +99,7 @@ public class PgStatement implements Statement, BaseStatement {
   /**
    * The warnings chain.
    */
-  protected SQLWarning warnings = null;
-  /**
-   * The last warning of the warning chain.
-   */
-  protected SQLWarning lastWarning = null;
+  protected volatile PGSQLWarningWrapper warnings = null;
 
   /**
    * Maximum number of rows to return, 0 = unlimited
@@ -218,13 +215,10 @@ public void handleCommandStatus(String status, int updateCount, long insertOID)
     }
 
     @Override
-    public void handleCompletion() throws SQLException {
-      SQLWarning warning = getWarning();
-      if (warning != null) {
-        PgStatement.this.addWarning(warning);
-      }
-      super.handleCompletion();
+    public void handleWarning(SQLWarning warning) {
+      PgStatement.this.addWarning(warning);
     }
+
   }
 
   public java.sql.ResultSet executeQuery(String p_sql) throws SQLException {
@@ -536,25 +530,29 @@ public void setQueryTimeoutMs(int millis) throws SQLException {
   }
 
   /**
-   * This adds a warning to the warning chain. We track the tail of the warning chain as well to
-   * avoid O(N) behavior for adding a new warning to an existing chain. Some server functions which
-   * RAISE NOTICE (or equivalent) produce a ton of warnings.
+   * Either initializes new warning wrapper, or adds warning onto the chain.
+   *
+   * Although warnings are expected to be added sequentially, the warnings chain may be cleared
+   * concurrently at any time via {@link #clearWarnings()}, therefore it is possible that a warning
+   * added via this method is placed onto the end of the previous warning chain
    *
    * @param warn warning to add
    */
   public void addWarning(SQLWarning warn) {
-    if (warnings == null) {
-      warnings = warn;
-      lastWarning = warn;
+    //copy reference to avoid NPE from concurrent modification of this.warnings
+    final PGSQLWarningWrapper warnWrap = this.warnings;
+    if (warnWrap == null) {
+      this.warnings = new PGSQLWarningWrapper(warn);
     } else {
-      lastWarning.setNextWarning(warn);
-      lastWarning = warn;
+      warnWrap.addWarning(warn);
     }
   }
 
   public SQLWarning getWarnings() throws SQLException {
     checkClosed();
-    return warnings;
+    //copy reference to avoid NPE from concurrent modification of this.warnings
+    final PGSQLWarningWrapper warnWrap = this.warnings;
+    return warnWrap != null ? warnWrap.getFirstWarning() : null;
   }
 
   public int getMaxFieldSize() throws SQLException {
@@ -571,9 +569,15 @@ public void setMaxFieldSize(int max) throws SQLException {
     maxfieldSize = max;
   }
 
+  /**
+   * Clears the warning chain.<p>
+   * Note that while it is safe to clear warnings while the query is executing, warnings that are
+   * added between calls to {@link #getWarnings()} and #clearWarnings() may be missed.
+   * Therefore you should hold a reference to the tail of the previous warning chain
+   * and verify if its {@link SQLWarning#getNextWarning()} value is holds any new value.
+   */
   public void clearWarnings() throws SQLException {
     warnings = null;
-    lastWarning = null;
   }
 
   public java.sql.ResultSet getResultSet() throws SQLException {

pgjdbc/src/main/java/org/postgresql/util/PGSQLWarningWrapper.java

@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) 2017, PostgreSQL Global Development Group
+ * See the LICENSE file in the project root for more information.
+ */
+
+package org.postgresql.util;
+
+import java.sql.SQLWarning;
+
+/**
+ * Wrapper class for SQLWarnings that provides an optimisation to add
+ * new warnings to the tail of the SQLWarning singly linked list, avoiding Θ(n) insertion time
+ * of calling #setNextWarning on the head. By encapsulating this into a single object it allows
+ * users(ie PgStatement) to atomically set and clear the warning chain.
+ */
+public class PGSQLWarningWrapper {
+
+  private final SQLWarning firstWarning;
+  private SQLWarning lastWarning;
+
+  public PGSQLWarningWrapper(SQLWarning warning) {
+    firstWarning = warning;
+    lastWarning = warning;
+  }
+
+  public void addWarning(SQLWarning sqlWarning) {
+    lastWarning.setNextWarning(sqlWarning);
+    lastWarning = sqlWarning;
+  }
+
+  public SQLWarning getFirstWarning() {
+    return firstWarning;
+  }
+
+}

pgjdbc/src/test/java/org/postgresql/test/jdbc2/StatementTest.java

@@ -24,8 +24,18 @@
 import java.sql.PreparedStatement;
 import java.sql.ResultSet;
 import java.sql.SQLException;
+import java.sql.SQLWarning;
 import java.sql.Statement;
+
+import java.util.concurrent.Callable;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.ScheduledFuture;
 import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.concurrent.atomic.AtomicReference;
 
@@ -411,6 +421,104 @@ public void testWarningsAreCleared() throws SQLException {
     stmt.close();
   }
 
+  @Test
+  public void testWarningsAreAvailableAsap()
+      throws SQLException, InterruptedException, ExecutionException {
+    con.createStatement()
+            .execute("CREATE OR REPLACE FUNCTION notify_then_sleep() RETURNS VOID AS "
+                + "$BODY$ "
+                + "BEGIN "
+                + "RAISE NOTICE 'Test 1'; "
+                + "RAISE NOTICE 'Test 2'; "
+                + "EXECUTE pg_sleep(2); "
+                + "END "
+                + "$BODY$ "
+                + "LANGUAGE plpgsql;");
+    con.createStatement().execute("SET SESSION client_min_messages = 'NOTICE'");
+    final PreparedStatement preparedStatement = con.prepareStatement("SELECT notify_then_sleep()");
+    ScheduledExecutorService executorService = Executors.newScheduledThreadPool(1);
+    ScheduledFuture<SQLWarning> future = executorService.schedule(new Callable<SQLWarning>() {
+      @Override
+      public SQLWarning call() throws SQLException {
+        return preparedStatement.getWarnings();
+      }
+    }, 1000, TimeUnit.MILLISECONDS);
+    preparedStatement.execute();
+
+    SQLWarning warning = future.get();
+    executorService.shutdown();
+
+    assertNotNull(warning);
+    assertEquals("First warning received not first notice raised",
+        warning.getMessage(), "Test 1");
+    assertEquals("Second warning received not second notice raised",
+        warning.getNextWarning().getMessage(), "Test 2");
+  }
+
+  /**
+   * Demonstrates a safe approach to concurrently reading the latest
+   * warnings while periodically clearing them.
+   *
+   * One drawback of this approach is that it requires the reader to make it to the end of the
+   * warning chain before clearing it, so long as your warning processing step is not very slow,
+   * this should happen more or less instantaneously even if you receive a lot of warnings.
+   */
+  @Test
+  public void testConcurrentWarningReadAndClear()
+      throws SQLException, InterruptedException, ExecutionException, TimeoutException {
+    final int iterations = 1000;
+    final ExecutorService executor = Executors.newSingleThreadExecutor();
+    con.createStatement()
+        .execute("CREATE OR REPLACE FUNCTION notify_loop() RETURNS VOID AS "
+            + "$BODY$ "
+            + "BEGIN "
+            + "FOR i IN 1.. " + iterations + " LOOP "
+            + "  RAISE NOTICE 'Warning %', i; "
+            + "END LOOP; "
+            + "END "
+            + "$BODY$ "
+            + "LANGUAGE plpgsql;");
+    con.createStatement().execute("SET SESSION client_min_messages = 'NOTICE'");
+    final PreparedStatement statement = con.prepareStatement("SELECT notify_loop()");
+
+    final Future warningReaderThread = executor.submit(new Callable<Object>() {
+      @Override
+      public Object call() throws SQLException, InterruptedException {
+        SQLWarning lastProcessed = null;
+        int warnings = 0;
+        //For production code replace this with some condition that
+        //ends after the statement finishes execution
+        while (warnings < iterations) {
+          SQLWarning warn = statement.getWarnings();
+          //if next linked warning has value use that, otherwise keep using latest head
+          if (lastProcessed != null && lastProcessed.getNextWarning() != null) {
+            warn = lastProcessed.getNextWarning();
+          }
+          if (warn != null) {
+            warnings++;
+            //System.out.println("Processing " + warn.getMessage());
+            lastProcessed = warn;
+            if (warn == statement.getWarnings()) {
+              //System.out.println("Clearing warnings");
+              statement.clearWarnings();
+            }
+          } else {
+            //Not required for this test, but a good idea adding some delay for production code
+            //to avoid high cpu usage while the query is running and no warnings are coming in.
+            //Alternatively use JDK9's Thread.onSpinWait()
+            Thread.sleep(10);
+          }
+        }
+        //Ensure that we didn't double process the same warning.
+        assertEquals(lastProcessed.getMessage(), "Warning " + iterations);
+        return null;
+      }
+    });
+    statement.execute();
+    //If the reader doesn't return after 2 seconds, it failed.
+    warningReaderThread.get(2, TimeUnit.SECONDS);
+  }
+
   /**
    * The parser tries to break multiple statements into individual queries as required by the V3
    * extended query protocol. It can be a little overzealous sometimes and this test ensures we keep