Connection pool, fixes

Author: ZorTik

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

@@ -8,6 +8,7 @@
 import me.zort.sqllib.internal.factory.SQLConnectionFactory;
 import me.zort.sqllib.internal.impl.DefaultSQLEndpoint;
 import me.zort.sqllib.internal.impl.SQLEndpointImpl;
+import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
 import java.sql.Connection;
@@ -16,17 +17,17 @@
 import java.util.Objects;
 import java.util.Optional;
 
-public class SQLConnectionBuilder {
+public final class SQLConnectionBuilder implements Cloneable {
 
-    public static SQLConnectionBuilder of(String address, int port, String database, String username, String password) {
+    public static @NotNull SQLConnectionBuilder of(String address, int port, String database, String username, String password) {
         return of(new DefaultSQLEndpoint(address + ":" + port, database, username, password));
     }
 
-    public static SQLConnectionBuilder of(String jdbc, String username, String password) {
+    public static @NotNull SQLConnectionBuilder of(String jdbc, String username, String password) {
         return of(new SQLEndpointImpl(jdbc, username, password));
     }
 
-    public static SQLConnectionBuilder ofSQLite(String path) {
+    public static @NotNull SQLConnectionBuilder ofSQLite(String path) {
         SQLConnectionBuilder builder = of(new SQLEndpointImpl("jdbc:sqlite:" + path, null, null));
         builder.withDriver("org.sqlite.JDBC");
         return builder;
@@ -43,28 +44,28 @@ public static SQLConnectionBuilder of(SQLEndpoint endpoint) {
     private String jdbc;
     private String driver = null;
 
-    public SQLConnectionBuilder(String address, int port, String database, String username, String password) {
-        this(new DefaultSQLEndpoint(address + ":" + port, database, username, password));
-    }
-
     public SQLConnectionBuilder() {
         this(null);
     }
 
+    public SQLConnectionBuilder(@NotNull String address, int port, @NotNull String database, @Nullable String username, @Nullable String password) {
+        this(new DefaultSQLEndpoint(address + ":" + port, database, username, password));
+    }
+
     public SQLConnectionBuilder(@Nullable SQLEndpoint endpoint) {
         this.endpoint = endpoint;
         this.jdbc = endpoint != null
                 ? endpoint.buildJdbc()
                 : null;
     }
 
-    public SQLConnectionBuilder withEndpoint(SQLEndpoint endpoint) {
+    public @NotNull SQLConnectionBuilder withEndpoint(SQLEndpoint endpoint) {
         this.endpoint = endpoint;
         this.jdbc = endpoint.buildJdbc();
         return this;
     }
 
-    public SQLConnectionBuilder withParam(String key, String value) {
+    public @NotNull SQLConnectionBuilder withParam(String key, String value) {
         Optional.ofNullable(endpoint)
                 .ifPresent(endpoint -> {
                     jdbc += (jdbc.contains("?") ? "&" : "?");
@@ -73,20 +74,20 @@ public SQLConnectionBuilder withParam(String key, String value) {
         return this;
     }
 
-    public SQLConnectionBuilder withDriver(String driver) {
+    public @NotNull SQLConnectionBuilder withDriver(String driver) {
         this.driver = driver;
         return this;
     }
 
-    public SQLDatabaseConnection build() {
+    public @NotNull SQLDatabaseConnection build() {
         return build(null);
     }
 
-    public SQLDatabaseConnection build(@Nullable SQLDatabaseOptions options) {
+    public @NotNull SQLDatabaseConnection build(@Nullable SQLDatabaseOptions options) {
         return build(driver, options);
     }
 
-    public SQLDatabaseConnection build(@Nullable String driver, @Nullable SQLDatabaseOptions options) {
+    public @NotNull SQLDatabaseConnection build(@Nullable String driver, @Nullable SQLDatabaseOptions options) {
         Objects.requireNonNull(endpoint, "Endpoint must be set!");
         Objects.requireNonNull(jdbc);
         if(driver == null) {
@@ -100,6 +101,11 @@ public SQLDatabaseConnection build(@Nullable String driver, @Nullable SQLDatabas
         }
     }
 
+    @Override
+    protected SQLConnectionBuilder clone() throws CloneNotSupportedException {
+        return (SQLConnectionBuilder) super.clone();
+    }
+
     @RequiredArgsConstructor
     public static class BuilderSQLConnectionFactory implements SQLConnectionFactory {
 

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

@@ -1,23 +1,88 @@
 package me.zort.sqllib;
 
-import java.sql.Connection;
+import lombok.AccessLevel;
+import lombok.Data;
+import lombok.RequiredArgsConstructor;
+import org.jetbrains.annotations.NotNull;
+
+import java.sql.SQLException;
 import java.util.List;
-import java.util.Optional;
+import java.util.Queue;
+import java.util.concurrent.ConcurrentLinkedQueue;
 import java.util.concurrent.CopyOnWriteArrayList;
 
+@RequiredArgsConstructor
 public final class SQLConnectionPool {
 
-    private SQLConnectionPool() {
+    @Data
+    public static final class Options {
+        private int maxConnections = 10;
+    }
+
+    private final SQLConnectionBuilder from;
+    private final int maxConnections;
+    private final Queue<SQLPooledConnection> freeConnections = new ConcurrentLinkedQueue<>();
+    private final List<SQLPooledConnection> usedConnections = new CopyOnWriteArrayList<>();
+
+    public SQLConnectionPool(@NotNull SQLConnectionBuilder from) {
+        this(from, new Options());
+    }
+
+    public SQLConnectionPool(@NotNull SQLConnectionBuilder from, @NotNull Options poolOptions) {
+        this.from = from;
+        this.maxConnections = poolOptions.maxConnections;
+    }
+
+    @NotNull
+    public Resource getResource() throws SQLException {
+        freeConnections.removeIf(SQLPooledConnection::expired);
+        SQLPooledConnection polled = freeConnections.poll();
+        if (polled == null && usedConnections.size() < maxConnections) {
+            polled = new SQLPooledConnection(from.build());
+            polled.connection.connect();
+
+            SQLException error = polled.connection.getLastError();
+            if (error != null) throw error;
+        } else if(polled == null) {
+            throw new IllegalStateException("Connection limit reached!");
+        }
+        usedConnections.add(polled);
+        return new Resource(this, polled);
+    }
+
+    public void close() {
+        usedConnections.forEach(c -> c.connection.disconnect());
+        freeConnections.forEach(c -> c.connection.disconnect());
+        usedConnections.clear();
+        freeConnections.clear();
     }
 
-    private static final List<SQLDatabaseConnection> CONNECTIONS = new CopyOnWriteArrayList<>();
+    @RequiredArgsConstructor(access = AccessLevel.PRIVATE)
+    private static class SQLPooledConnection {
+        private final SQLDatabaseConnection connection;
+        private long lastUsed = System.currentTimeMillis();
 
-    static void register(SQLDatabaseConnection connection) {
-        CONNECTIONS.add(connection);
+        public boolean expired() {
+            return System.currentTimeMillis() - lastUsed > 1000 * 60 * 5;
+        }
     }
 
-    static Optional<SQLDatabaseConnection> find(Connection connection) {
-        return CONNECTIONS.stream().filter(c -> c.getConnection() == connection).findFirst();
+    @RequiredArgsConstructor(access = AccessLevel.PRIVATE)
+    public static final class Resource implements AutoCloseable {
+
+        private final SQLConnectionPool pool;
+        private final SQLPooledConnection connection;
+
+        public SQLDatabaseConnection getConnection() {
+            return connection.connection;
+        }
+
+        @Override
+        public void close() {
+            connection.lastUsed = System.currentTimeMillis();
+            pool.freeConnections.add(connection);
+            pool.usedConnections.remove(connection);
+        }
     }
 
 }

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

@@ -0,0 +1,30 @@
+package me.zort.sqllib;
+
+import java.sql.Connection;
+import java.util.List;
+import java.util.Optional;
+import java.util.concurrent.CopyOnWriteArrayList;
+
+public final class SQLConnectionRegistry {
+
+    private SQLConnectionRegistry() {
+    }
+
+    private static final List<SQLDatabaseConnection> CONNECTIONS = new CopyOnWriteArrayList<>();
+
+    static void register(SQLDatabaseConnection connection) {
+        CONNECTIONS.add(connection);
+    }
+
+    static Optional<SQLDatabaseConnection> find(Connection connection) {
+        return CONNECTIONS.stream().filter(c -> c.getConnection() == connection).findFirst();
+    }
+
+    public static void debug(Connection connection, String message) {
+        find(connection)
+                .filter(c -> c instanceof SQLDatabaseConnectionImpl)
+                .ifPresent(c -> {
+                    if (c.isDebug()) ((SQLDatabaseConnectionImpl) c).debug(message);
+                });
+    }
+}

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

@@ -26,12 +26,14 @@ public abstract class SQLDatabaseConnection implements SQLConnection {
     private final SQLConnectionFactory connectionFactory;
     @Getter(onMethod_ = {@Nullable})
     private Connection connection;
+    @Getter(onMethod_ = {@Nullable})
+    private SQLException lastError = null;
 
     public SQLDatabaseConnection(SQLConnectionFactory connectionFactory) {
         this.connectionFactory = connectionFactory;
         this.connection = null;
 
-        SQLConnectionPool.register(this);
+        SQLConnectionRegistry.register(this);
     }
 
     /**
@@ -154,15 +156,14 @@ public DeleteQuery delete() {
 
     @Override
     public boolean connect() {
-        if(isConnected()) {
-            disconnect();
-        }
+        if(isConnected()) disconnect();
 
         try {
             connection = connectionFactory.connect();
         } catch (SQLException e) {
             logSqlError(e);
             connection = null;
+            lastError = e;
         }
         return isConnected();
     }
@@ -174,6 +175,7 @@ public void disconnect() {
                 connection.close();
             } catch (SQLException e) {
                 logSqlError(e);
+                lastError = e;
             }
         }
     }

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

@@ -478,7 +478,7 @@ private static class DefaultStatementFactory implements StatementFactory<Prepare
         public PreparedStatement prepare(Connection connection) throws SQLException {
             String queryString = query.getAncestor().buildQuery();
 
-            LocalLogger.debug(connection, "Query: " + queryString);
+            SQLConnectionRegistry.debug(connection, "Query: " + queryString);
             return connection.prepareStatement(queryString);
         }
     }

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

@@ -1,7 +1,7 @@
 package me.zort.sqllib.internal.query;
 
 import lombok.*;
-import me.zort.sqllib.LocalLogger;
+import me.zort.sqllib.SQLConnectionRegistry;
 import me.zort.sqllib.util.Pair;
 import me.zort.sqllib.util.Util;
 
@@ -52,8 +52,8 @@ protected PreparedStatement prepare(Connection connection) throws SQLException {
         Pair<String, Object[]> requirements = buildStatementDetails();
 
         // Shows plain query for prepared statement.
-        LocalLogger.debug(connection, String.format("P-Query: %s", requirements.getFirst()));
-        LocalLogger.debug(connection, String.format("P-Values: %s", Arrays.toString(requirements.getSecond())));
+        SQLConnectionRegistry.debug(connection, String.format("P-Query: %s", requirements.getFirst()));
+        SQLConnectionRegistry.debug(connection, String.format("P-Values: %s", Arrays.toString(requirements.getSecond())));
 
         PreparedStatement statement = connection.prepareStatement(requirements.getFirst());
         Object[] values = requirements.getSecond();

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

@@ -8,6 +8,19 @@ private Regex() {
     }
 
     public static String skipRegexCharacters(String input) {
+        boolean thrown = true;
+        while(thrown) {
+            try {
+                input.replaceAll(input, input);
+                thrown = false;
+            } catch(PatternSyntaxException e) {
+                input = _skipRegexCharacters(input);
+            }
+        }
+        return input;
+    }
+
+    private static String _skipRegexCharacters(String input) {
         String s = input;
         StringBuilder stringBuilder = new StringBuilder(s);
         try {

core/src/main/java/me/zort/sqllib/internal/query/QueryDetails.java

@@ -79,16 +79,16 @@ public interface DatabaseRepository {
         @Save // Upsert
         QueryResult save(User user);
 
-        @Insert(cols = {"nickname", "points"}, vals = {"{nickname}", "{points}"})
-        QueryResult insertNew(@Placeholder("nickname") String nickname, @Placeholder("points") int points);
+        @Insert(cols = {"nickname", "points"}, vals = {"{name}", "{points}"})
+        QueryResult insertNew(@Placeholder("name") String nickname, @Placeholder("points") int points);
 
         @Select
         @Where(value = {
-                @Where.Condition(column = "nickname", value = "{nickname}"),
+                @Where.Condition(column = "nickname", value = "{name}"),
                 @Where.Condition(column = "points", value = "500", type = Where.Condition.Type.BT)
         })
         @Limit(1)
-        Optional<User> selectOne(@Placeholder("nickname") String nickname);
+        Optional<User> selectOne(@Placeholder("name") String nickname);
 
         @Select
         List<User> selectAll();