Experimental: Proxy mapping

Author: ZorTik

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

@@ -76,8 +76,7 @@ public SQLDatabaseConnectionImpl(SQLConnectionFactory connectionFactory, @Nullab
         super(connectionFactory);
 
         if (options == null)
-            options = new SQLDatabaseOptions(
-                    DEFAULT_AUTO_RECONNECT,
+            options = new SQLDatabaseOptions(DEFAULT_AUTO_RECONNECT,
                     DEFAULT_DEBUG,
                     DEFAULT_LOG_SQL_ERRORS,
                     DEFAULT_NAMING_STRATEGY,
@@ -94,16 +93,38 @@ public SQLDatabaseConnectionImpl(SQLConnectionFactory connectionFactory, @Nullab
         registerBackupValueResolver(new ConstructorParameterResolver());
     }
 
+    /**
+     * Registers a backup value resolver to the registry.
+     * Backup value resolvers are used when no value is found for mapped
+     * field in {@link ObjectMapper}.
+     *
+     * @param resolver Resolver to register.
+     */
     public void registerBackupValueResolver(@NotNull ObjectMapper.FieldValueResolver resolver) {
         Objects.requireNonNull(resolver, "Resolver cannot be null!");
 
         objectMapper.registerBackupValueResolver(resolver);
     }
 
+    /**
+     * Sets the object mapper to use.
+     * Object mapper maps queries to objects, as specified in {@link SQLDatabaseConnection#query(Query, Class)}.
+     *
+     * @param objectMapper Object mapper to use.
+     */
     public void setObjectMapper(@NotNull ObjectMapper objectMapper) {
         this.objectMapper = Objects.requireNonNull(objectMapper, "Object mapper cannot be null!");
     }
 
+    /**
+     * Constructs a mapping repository based on provided interface.
+     * The interface should follow rules for creating mapping repositories
+     * in this library.
+     *
+     * @param mappingInterface Interface to create mapping repository for.
+     * @return Mapping repository.
+     * @param <T> Type of mapping repository.
+     */
     @SuppressWarnings("unchecked")
     @ApiStatus.Experimental
     public <T> T createMapping(Class<T> mappingInterface) {

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

@@ -87,12 +87,15 @@ public <T> T assignValues(Row row, Class<T> typeClass) {
     private Object buildElementValue(AnnotatedElement element, Row row) {
         String name;
         Type type;
+        Class<?> declaringClass;
         if(element instanceof Field) {
             name = ((Field) element).getName();
             type = ((Field) element).getGenericType();
-        } else if(element instanceof Parameter) { // TODO: Parameter names are arg[a-zA-Z0-9]+, use different strategy.
+            declaringClass = ((Field) element).getDeclaringClass();
+        } else if(element instanceof Parameter) {
             name = ((Parameter) element).getName();
             type = ((Parameter) element).getType();
+            declaringClass = ((Parameter) element).getDeclaringExecutable().getDeclaringClass();
         } else {
             return null;
         }
@@ -109,7 +112,7 @@ private Object buildElementValue(AnnotatedElement element, Row row) {
                     }
                 }
 
-                debug(String.format("Cannot find column for target %s (%s)", name, converted));
+                debug(String.format("Cannot find column for class %s target %s (%s)", declaringClass.getName(), name, converted));
                 return null;
             }
         }

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

@@ -20,7 +20,7 @@
 public abstract class QueryNode<P extends QueryNode<?>> implements Query, StatementFactory<PreparedStatement> {
 
     @Getter(onMethod_ = {@Nullable})
-    private final P parent;
+    private final transient P parent;
     private final List<QueryNode<?>> children;
     private final int priority;
     private final Map<String, QueryDetails> details;

core/src/main/java/me/zort/sqllib/mapping/DefaultResultAdapter.java

@@ -5,16 +5,21 @@
 import me.zort.sqllib.api.data.QueryRowsResult;
 
 import java.lang.reflect.Method;
-import java.lang.reflect.TypeVariable;
+import java.lang.reflect.ParameterizedType;
+import java.lang.reflect.Type;
 import java.util.List;
 import java.util.Optional;
 
 public class DefaultResultAdapter implements StatementMappingResultAdapter {
     @Override
     public Object adaptResult(Method method, QueryResult result) {
         Class<?> returnType = method.getReturnType();
-        if (isVoid(returnType) || !(result instanceof QueryRowsResult))
+
+        if(returnType.equals(QueryResult.class)) {
+            return result;
+        } else if (isVoid(returnType) || !(result instanceof QueryRowsResult)) {
             return null;
+        }
 
         QueryRowsResult<?> rows = (QueryRowsResult<?>) result;
 
@@ -34,16 +39,17 @@ public Object adaptResult(Method method, QueryResult result) {
     public Class<?> retrieveResultType(Method method) {
         Class<?> returnType = method.getReturnType();
         if (returnType.equals(Optional.class) || returnType.equals(List.class)) {
-            return getGenericArgument(returnType, true);
+            return getGenericArgument(returnType, method.getGenericReturnType(), true);
         } else if (isVoid(returnType)) {
             return null;
         } else {
             return returnType;
         }
     }
 
-    private static Class<?> getGenericArgument(Class<?> clazz, boolean throwNotFound) {
-        TypeVariable<? extends Class<?>>[] typeParameters = clazz.getTypeParameters();
+    // List<T>
+    private static Class<?> getGenericArgument(Class<?> clazz, Type genericType, boolean throwNotFound) {
+        Type[] typeParameters = ((ParameterizedType) genericType).getActualTypeArguments();
         if (typeParameters.length < 1) {
             if (throwNotFound) {
                 throw new IllegalArgumentException("The given class does not have a generic argument");
@@ -52,7 +58,12 @@ private static Class<?> getGenericArgument(Class<?> clazz, boolean throwNotFound
             } // For simplicity, return itself to be mapped.
         }
 
-        return typeParameters[0].getGenericDeclaration(); // TODO: Test
+        try {
+            return Class.forName(typeParameters[0].getTypeName());
+        } catch (ClassNotFoundException e) {
+            e.printStackTrace();
+            return clazz;
+        }
     }
 
     private static boolean isVoid(Class<?> type) {

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

@@ -51,6 +51,8 @@ public void prepare() {
     @Timeout(10)
     @Test
     public void test1_Mapping() {
+        assertNull(connection.save("users", new User("User1", 1000)).getRejectMessage());
+
         DatabaseRepository repository = connection.createMapping(DatabaseRepository.class);
         // TODO: Insert
         assertTrue(repository.selectOne().isPresent());
@@ -63,15 +65,14 @@ public void test2_Close() {
         connection.disconnect();
     }
 
+    @Table("users")
     public interface DatabaseRepository {
 
         @Select
-        @Table("users")
         @Limit(1)
         Optional<User> selectOne();
 
         @Delete
-        @Table("users")
         QueryResult deleteAll();
     }