Added:

* JavaDocs
* ExpirableEntriesCacheManager.java implementation
* toString(), equals(), hashCode() implementations in QueryNode.java
* SQLConnectionBuilder#withCacheManager
* TestCase3.java

Changed:
* Optimized some imports
* DefaultNamingStrategy.java is now SymbolSeparatedNamingStrategy.java
* SymbolSeparatedNamingStrategy.java now has option to specify symbol and case type
* TestCase1#test6_Pool now prints SQLException stack trace

Author: ZorTik

api/src/main/java/me/zort/sqllib/api/cache/CacheManager.java

@@ -5,16 +5,43 @@
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
+/**
+ * A cache manager that caches query results. This is used
+ * primarly in {@link me.zort.sqllib.api.SQLConnection} instances
+ * that hold a cache manager.
+ *
+ * @author ZorTik
+ */
 public interface CacheManager {
 
+    /**
+     * Sets a query result to the cache.
+     * If the query is already cached, it should be overwritten.
+     *
+     * @param query Query that was executed
+     * @param result Result
+     */
     void set(@NotNull Query query, @NotNull QueryResult result);
+
+    /**
+     * Returns a query result from the cache, or null if
+     * the query is not cached.
+     *
+     * @param query Query that was executed
+     * @param isExec Whether the query is an exec (no ResultSet) query
+     * @return The nullable query result
+     */
     @Nullable QueryResult get(@NotNull Query query, boolean isExec);
 
+    /**
+     * Returns a cache manager that does not cache anything.
+     *
+     * @return The cache manager
+     */
     static CacheManager noCache() {
         return new CacheManager() {
             @Override
-            public void set(@NotNull Query query, @NotNull QueryResult result) {
-            }
+            public void set(@NotNull Query query, @NotNull QueryResult result) {}
             @Override
             public @Nullable QueryResult get(@NotNull Query query, boolean isExec) {
                 return null;

api/src/main/java/me/zort/sqllib/api/options/NamingStrategy.java

@@ -1,5 +1,10 @@
 package me.zort.sqllib.api.options;
 
+/**
+ * A naming strategy that converts field names to column names.
+ *
+ * @author ZorTik
+ */
 public interface NamingStrategy {
 
     String fieldNameToColumn(String str);

core/build.gradle

@@ -14,6 +14,7 @@ dependencies {
     implementation project(":shared")
     implementation group: 'org.jetbrains', name: 'annotations', version: '20.1.0'
     implementation 'com.google.code.gson:gson:2.9.0'
+    implementation 'com.google.guava:guava:31.0-jre'
     compileOnly 'org.projectlombok:lombok:1.18.24'
     annotationProcessor 'org.projectlombok:lombok:1.18.24'
 }

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

@@ -4,6 +4,7 @@
 import me.zort.sqllib.api.ISQLConnectionBuilder;
 import me.zort.sqllib.api.ISQLDatabaseOptions;
 import me.zort.sqllib.api.SQLEndpoint;
+import me.zort.sqllib.api.cache.CacheManager;
 import me.zort.sqllib.internal.Constants;
 import me.zort.sqllib.internal.exception.SQLDriverNotFoundException;
 import me.zort.sqllib.internal.exception.SQLEndpointNotValidException;
@@ -34,14 +35,15 @@ public final class SQLConnectionBuilder implements ISQLConnectionBuilder<SQLData
         return of(new SQLEndpointImpl("jdbc:sqlite:" + path, null, null)).withDriver("org.sqlite.JDBC");
     }
 
-    public static SQLConnectionBuilder of(SQLEndpoint endpoint) {
+    public static @NotNull SQLConnectionBuilder of(SQLEndpoint endpoint) {
         if(!endpoint.isValid()) throw new SQLEndpointNotValidException(endpoint);
         return new SQLConnectionBuilder(endpoint);
     }
 
     private SQLEndpoint endpoint;
     private String jdbc;
     private String driver = null;
+    private CacheManager cacheManager = null;
 
     public SQLConnectionBuilder() {
         this(null);
@@ -72,6 +74,11 @@ public SQLConnectionBuilder(@Nullable SQLEndpoint endpoint) {
         return this;
     }
 
+    public @NotNull SQLConnectionBuilder withCacheManager(final @Nullable CacheManager cacheManager) {
+        this.cacheManager = cacheManager;
+        return this;
+    }
+
     public @NotNull SQLDatabaseConnection build() {
         return build(null);
     }
@@ -81,12 +88,16 @@ public SQLConnectionBuilder(@Nullable SQLEndpoint endpoint) {
     }
 
     public @NotNull SQLDatabaseConnection build(@Nullable String driver, @Nullable ISQLDatabaseOptions options) {
+        SQLDatabaseConnection connection = buildConnection(driver, options);
+        if(cacheManager != null) connection.enableCaching(cacheManager);
+        return connection;
+    }
+
+    private @NotNull SQLDatabaseConnection buildConnection(@Nullable String driver, @Nullable ISQLDatabaseOptions options) {
         Objects.requireNonNull(endpoint, "Endpoint must be set!");
         Objects.requireNonNull(jdbc);
-        if(driver == null) {
-            driver = Constants.DEFAULT_DRIVER;
-        }
-        SQLConnectionFactory connectionFactory = new BuilderSQLConnectionFactory(this, driver);
+        if (driver == null) driver = Constants.DEFAULT_DRIVER;
+        SQLConnectionFactory connectionFactory = new LocalConnectionFactory(driver);
         return jdbc.contains("jdbc:sqlite")
                 ? new SQLiteDatabaseConnectionImpl(connectionFactory, options)
                 : new SQLDatabaseConnectionImpl(connectionFactory, options);
@@ -102,22 +113,20 @@ protected SQLConnectionBuilder clone() throws CloneNotSupportedException {
     }
 
     @RequiredArgsConstructor
-    public static class BuilderSQLConnectionFactory implements SQLConnectionFactory {
+    class LocalConnectionFactory implements SQLConnectionFactory {
 
-        private final SQLConnectionBuilder builder;
-        private final String driver;
+        private final String localDriver;
 
         @Nullable
         @Override
         public Connection connect() throws SQLException {
             try {
-                Class.forName(driver);
+                Class.forName(localDriver);
             } catch (ClassNotFoundException e) {
-                throw new SQLDriverNotFoundException(driver, e);
+                throw new SQLDriverNotFoundException(localDriver, e);
             }
-            String jdbc = builder.jdbc;
-            String usr = builder.endpoint.getUsername();
-            String pwd = builder.endpoint.getPassword();
+            String usr = endpoint.getUsername();
+            String pwd = endpoint.getPassword();
             return DriverManager.getConnection(jdbc, usr, pwd);
         }
 

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

@@ -1,7 +1,10 @@
 package me.zort.sqllib;
 
 import com.google.gson.Gson;
-import lombok.*;
+import lombok.Getter;
+import lombok.RequiredArgsConstructor;
+import lombok.Setter;
+import lombok.SneakyThrows;
 import me.zort.sqllib.api.ISQLDatabaseOptions;
 import me.zort.sqllib.api.ObjectMapper;
 import me.zort.sqllib.api.Query;
@@ -20,10 +23,9 @@
 import me.zort.sqllib.internal.factory.SQLConnectionFactory;
 import me.zort.sqllib.internal.fieldResolver.ConstructorParameterResolver;
 import me.zort.sqllib.internal.fieldResolver.LinkedOneFieldResolver;
-import me.zort.sqllib.internal.impl.DefaultNamingStrategy;
+import me.zort.sqllib.naming.SymbolSeparatedNamingStrategy;
 import me.zort.sqllib.internal.impl.DefaultObjectMapper;
 import me.zort.sqllib.internal.impl.QueryResultImpl;
-import me.zort.sqllib.mapping.DefaultResultAdapter;
 import me.zort.sqllib.mapping.DefaultStatementMappingFactory;
 import me.zort.sqllib.pool.PooledSQLDatabaseConnection;
 import me.zort.sqllib.transaction.Transaction;
@@ -62,7 +64,7 @@ public class SQLDatabaseConnectionImpl extends PooledSQLDatabaseConnection {
     public static final boolean DEFAULT_AUTO_RECONNECT = true;
     public static final boolean DEFAULT_DEBUG = false;
     public static final boolean DEFAULT_LOG_SQL_ERRORS = true;
-    public static final NamingStrategy DEFAULT_NAMING_STRATEGY = new DefaultNamingStrategy();
+    public static final NamingStrategy DEFAULT_NAMING_STRATEGY = new SymbolSeparatedNamingStrategy('_');
     public static final Gson DEFAULT_GSON = Defaults.DEFAULT_GSON;
 
     // --***-- Options & Utilities --***--
@@ -97,9 +99,7 @@ public SQLDatabaseConnectionImpl(final @NotNull SQLConnectionFactory connectionF
      */
     public SQLDatabaseConnectionImpl(final @NotNull SQLConnectionFactory connectionFactory, @Nullable ISQLDatabaseOptions options) {
         super(connectionFactory);
-        if (options == null) options = defaultOptions();
-
-        this.options = options;
+        this.options = options == null ? defaultOptions() : options;
         this.objectMapper = new DefaultObjectMapper(this);
         this.mappingFactory = new DefaultStatementMappingFactory();
         this.errorStateHandlers = new CopyOnWriteArrayList<>();

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

@@ -7,7 +7,7 @@
 import me.zort.sqllib.api.ISQLDatabaseOptions;
 import me.zort.sqllib.api.options.NamingStrategy;
 import me.zort.sqllib.internal.Defaults;
-import me.zort.sqllib.internal.impl.DefaultNamingStrategy;
+import me.zort.sqllib.naming.SymbolSeparatedNamingStrategy;
 import org.jetbrains.annotations.NotNull;
 
 @AllArgsConstructor
@@ -18,7 +18,7 @@ public final class SQLDatabaseOptions implements ISQLDatabaseOptions {
     private boolean autoReconnect = true;
     private boolean debug = false;
     private boolean logSqlErrors = true;
-    private transient NamingStrategy namingStrategy = new DefaultNamingStrategy();
+    private transient NamingStrategy namingStrategy = SQLDatabaseConnectionImpl.DEFAULT_NAMING_STRATEGY;
     private transient Gson gson = Defaults.DEFAULT_GSON;
 
     /**

core/src/main/java/me/zort/sqllib/cache/ExpirableEntriesCacheManager.java

@@ -1,20 +1,38 @@
 package me.zort.sqllib.cache;
 
+import com.google.common.cache.Cache;
+import com.google.common.cache.CacheBuilder;
 import me.zort.sqllib.api.Query;
 import me.zort.sqllib.api.cache.CacheManager;
 import me.zort.sqllib.api.data.QueryResult;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
+import java.util.concurrent.TimeUnit;
+
 public class ExpirableEntriesCacheManager implements CacheManager {
+
+    private final Cache<Query, QueryResult> cache;
+
+    /**
+     * Creates a new cache manager with provided expiration duration
+     * in milliseconds.
+     *
+     * @param expirationDuration The expiration duration
+     */
+    public ExpirableEntriesCacheManager(long expirationDuration) {
+        cache = CacheBuilder.newBuilder()
+                .expireAfterWrite(expirationDuration, TimeUnit.MILLISECONDS)
+                .build();
+    }
+
     @Override
     public void set(@NotNull Query query, @NotNull QueryResult result) {
-        // TODO: Implement
+        cache.put(query, result);
     }
 
     @Override
     public @Nullable QueryResult get(@NotNull Query query, boolean isExec) {
-        // TODO: Implement
-        return null;
+        return cache.getIfPresent(query);
     }
 }

core/src/main/java/me/zort/sqllib/internal/impl/DefaultNamingStrategy.java

@@ -1,5 +1,6 @@
 package me.zort.sqllib.internal.query;
 
+import com.google.gson.Gson;
 import lombok.*;
 import me.zort.sqllib.SQLConnectionRegistry;
 import me.zort.sqllib.util.Pair;
@@ -129,6 +130,10 @@ public int length() {
         return queryStr.length();
     }
 
+    public String toString() {
+        return "QueryDetails{str=" + queryStr + ", values=" + new Gson().toJson(values) + "}";
+    }
+
     @RequiredArgsConstructor
     public static class Builder {
 

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

@@ -194,4 +194,19 @@ private void debug(String message) {
         }
     }
 
+    public String toString() {
+        return "QueryNode{details=" + buildQueryDetails().toString() + "}";
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (!(obj instanceof QueryNode)) return false;
+        QueryNode<?> other = (QueryNode<?>) obj;
+        return toString().equals(other.toString());
+    }
+
+    @Override
+    public int hashCode() {
+        return toString().hashCode();
+    }
 }