Pool getResource block when exhausted.

Author: ZorTik

core/src/main/java/me/zort/sqllib/SQLConnectionBuilder.java

@@ -66,10 +66,10 @@ public SQLConnectionBuilder(@Nullable SQLEndpoint endpoint) {
     }
 
     public @NotNull SQLConnectionBuilder withParam(String key, String value) {
-        Optional.ofNullable(endpoint).ifPresent(endpoint -> {
-                    jdbc += (jdbc.contains("?") ? "&" : "?");
-                    jdbc += key + "=" + value;
-                });
+        if (endpoint != null) {
+            jdbc += (jdbc.contains("?") ? "&" : "?");
+            jdbc += key + "=" + value;
+        }
         return this;
     }
 

core/src/main/java/me/zort/sqllib/SQLConnectionPool.java

@@ -25,11 +25,18 @@ public final class SQLConnectionPool {
 
     @Data
     public static final class Options {
+        // Max number of connections in the pool
         private int maxConnections = 10;
+        // Max wait time for getResource in milliseconds when the pool is exhausted
+        private long borrowObjectTimeout = 5000L;
+        // Block or throw an exception when the pool is exhausted
+        private boolean blockWhenExhausted = true;
     }
 
     private final SQLConnectionBuilder builder;
     private final int maxConnections;
+    private final long borrowObjectTimeout;
+    private final boolean blockWhenExhausted;
 
     // --***-- Pooled connection caches --***--
     private final Queue<SQLPooledConnection> freeConnections = new ConcurrentLinkedQueue<>();
@@ -49,6 +56,8 @@ public SQLConnectionPool(@NotNull SQLConnectionBuilder from) {
     public SQLConnectionPool(@NotNull SQLConnectionBuilder from, @NotNull Options poolOptions) {
         this.builder = from;
         this.maxConnections = poolOptions.maxConnections;
+        this.borrowObjectTimeout = poolOptions.borrowObjectTimeout;
+        this.blockWhenExhausted = poolOptions.blockWhenExhausted;
     }
 
     /**
@@ -63,18 +72,36 @@ public Resource getResource() throws SQLException {
         freeConnections.removeIf(SQLPooledConnection::expired);
         SQLPooledConnection polled = freeConnections.poll();
         if (polled == null && usedConnections.size() < maxConnections) {
-            polled = new SQLPooledConnection(builder.build());
-            polled.connection.connect();
-
-            SQLException error = polled.connection.getLastError();
-            if (error != null) throw error;
+            polled = establishObject();
         } else if(polled == null) {
-            throw new IllegalStateException("Connection limit reached!");
+
+            if (!blockWhenExhausted) {
+                throw new SQLException("No connections available.");
+            }
+
+            long start = System.currentTimeMillis();
+            while ((polled = freeConnections.poll()) == null) {
+                if (System.currentTimeMillis() - start > borrowObjectTimeout) {
+                    throw new SQLException("Timeout while waiting for a connection.");
+                } else if(usedConnections.size() < maxConnections) {
+                    polled = establishObject();
+                    break;
+                }
+            }
         }
         usedConnections.add(polled);
         return new Resource(this, polled);
     }
 
+    private SQLPooledConnection establishObject() throws SQLException {
+        SQLPooledConnection polled = new SQLPooledConnection(builder.build());
+        polled.connection.connect();
+
+        SQLException error = polled.connection.getLastError();
+        if (error != null) throw error;
+        return polled;
+    }
+
     /**
      * Closes all connections in the pool and
      * clears the caches.

core/src/main/java/me/zort/sqllib/SQLDatabaseConnection.java

@@ -160,6 +160,7 @@ public boolean connect() {
 
         try {
             connection = connectionFactory.connect();
+            lastError = null;
         } catch (SQLException e) {
             logSqlError(e);
             connection = null;
@@ -173,6 +174,7 @@ public void disconnect() {
         if(isConnected()) {
             try {
                 connection.close();
+                lastError = null;
             } catch (SQLException e) {
                 logSqlError(e);
                 lastError = e;