Docs

Author: ZorTik

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

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

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

@@ -11,6 +11,15 @@
 import java.util.concurrent.ConcurrentLinkedQueue;
 import java.util.concurrent.CopyOnWriteArrayList;
 
+/**
+ * A connection pool.
+ * <p></p>
+ * This class is used to create a pool of connections to a database.
+ * It is recommended to use this class instead of creating a new connection
+ * every time you need to execute a query.
+ *
+ * @author ZorTik
+ */
 @RequiredArgsConstructor
 public final class SQLConnectionPool {
 
@@ -19,26 +28,42 @@ public static final class Options {
         private int maxConnections = 10;
     }
 
-    private final SQLConnectionBuilder from;
+    private final SQLConnectionBuilder builder;
     private final int maxConnections;
+
+    // --***-- Pooled connection caches --***--
     private final Queue<SQLPooledConnection> freeConnections = new ConcurrentLinkedQueue<>();
     private final List<SQLPooledConnection> usedConnections = new CopyOnWriteArrayList<>();
 
     public SQLConnectionPool(@NotNull SQLConnectionBuilder from) {
         this(from, new Options());
     }
 
+    /**
+     * Creates a new connection pool.
+     * A builder is used as a factory for creating new connections.
+     *
+     * @param from The builder used to create new connections.
+     * @param poolOptions The pool options.
+     */
     public SQLConnectionPool(@NotNull SQLConnectionBuilder from, @NotNull Options poolOptions) {
-        this.from = from;
+        this.builder = from;
         this.maxConnections = poolOptions.maxConnections;
     }
 
+    /**
+     * Gets a resource from the pool, or returns an existing one from
+     * the pool if there is any available.
+     *
+     * @return The resource.
+     * @throws SQLException Connection error.
+     */
     @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 = new SQLPooledConnection(builder.build());
             polled.connection.connect();
 
             SQLException error = polled.connection.getLastError();
@@ -50,6 +75,10 @@ public Resource getResource() throws SQLException {
         return new Resource(this, polled);
     }
 
+    /**
+     * Closes all connections in the pool and
+     * clears the caches.
+     */
     public void close() {
         usedConnections.forEach(c -> c.connection.disconnect());
         freeConnections.forEach(c -> c.connection.disconnect());

src/test/java/me/zort/sqllib/test/TestCase1.java

@@ -94,6 +94,7 @@ public void test2_Select() {
                 .where()
                 .isEqual("nickname", "User1"), User.class);
 
+        assertTrue(connection.select().from(TABLE_NAME).where().isEqual("nickname", "User1").obtainOne(User.class).isPresent());
         assertNull(result.getRejectMessage());
         assertEquals(1, result.size());
         assertEquals(user1.getNickname(), result.get(0).getNickname());