Experimental: Proxy mapping

Author: ZorTik

api/src/main/java/me/zort/sqllib/api/StatementFactory.java

@@ -4,8 +4,22 @@
 import java.sql.SQLException;
 import java.sql.Statement;
 
+/**
+ * The StatementFactory is responsible for creating new Statements for
+ * the given connection.
+ *
+ * @param <T> The Statement type.
+ * @author ZorTik
+ */
 public interface StatementFactory<T extends Statement> {
 
+    /**
+     * Prepares the statement for executing in {@link SQLConnection}.
+     *
+     * @param connection The connection to use.
+     * @return The prepared statement.
+     * @throws SQLException If an error occurs while preparing.
+     */
     T prepare(Connection connection) throws SQLException;
 
 }

api/src/main/java/me/zort/sqllib/api/StatementMapping.java

@@ -0,0 +1,39 @@
+package me.zort.sqllib.api;
+
+import me.zort.sqllib.api.data.QueryResult;
+import org.jetbrains.annotations.Nullable;
+
+import java.lang.reflect.Method;
+
+/**
+ * Represents an abstract proxy mapping that is used for execution of
+ * queries using mapped methods in a proxy instance.
+ *
+ * @param <T> The type of the proxy instance.
+ * @author ZorTik
+ */
+public interface StatementMapping<T> {
+
+    /**
+     * Executes query based on invoked method with invoked args from
+     * proxy instance. MapTo is used as type of entity to be mapped in the
+     * request. If there is no mapping required, MapTo can be null.
+     *
+     * @param method The method that was executed in the proxy.
+     * @param args The arguments passed.
+     * @param mapTo The type of entity that needs to be mapped.
+     * @return The QueryResult of the executed query.
+     */
+    QueryResult executeQuery(Method method, Object[] args, @Nullable Class<?> mapTo);
+
+    /**
+     * Checks if the method is eligible for mapping. If this returns false,
+     * the method is executed in proxy mapping as normal method, eg. does not
+     * return any mapping results.
+     *
+     * @param method The method that was executed in the proxy.
+     * @return True if the method is eligible for mapping, or false.
+     */
+    boolean isMappingMethod(Method method);
+
+}

api/src/main/java/me/zort/sqllib/api/StatementMappingFactory.java

@@ -0,0 +1,22 @@
+package me.zort.sqllib.api;
+
+/**
+ * The StatementMappingFactory is responsible for creating new StatementMapping
+ * for defined interfaces.
+ *
+ * @author ZorTik
+ */
+public interface StatementMappingFactory {
+
+    /**
+     * Creates a new StatementMapping for the given interface class that
+     * is responsible for handling that specific interface.
+     *
+     * @param interfaceClass The interface class
+     * @param connection The connection to use.
+     * @return The StatementMapping.
+     * @param <T> The interface class type.
+     */
+    <T> StatementMapping<T> create(Class<T> interfaceClass, SQLConnection connection);
+
+}

api/src/main/java/me/zort/sqllib/api/StatementMappingResultAdapter.java

@@ -0,0 +1,34 @@
+package me.zort.sqllib.api;
+
+import me.zort.sqllib.api.data.QueryResult;
+
+import java.lang.reflect.Method;
+
+/**
+ * Result adapter used for handling operations between {@link SQLConnection}
+ * and {@link StatementMapping}.
+ *
+ * @author ZorTik
+ */
+public interface StatementMappingResultAdapter {
+
+    /**
+     * Adapts invoked {@link StatementMapping} method QueryResult to
+     * the final result that can be passed to proxy instance.
+     *
+     * @param method The invoked proxy method.
+     * @param result The QueryResult of the invoked method.
+     * @return The adapted result.
+     */
+    Object adaptResult(Method method, QueryResult result);
+
+    /**
+     * Retrieves type of entity that needs to be mapped in the request
+     * to be passed in adaptResult as type in QueryResult.
+     *
+     * @param method The invoked proxy method.
+     * @return The type of entity that needs to be mapped.
+     */
+    Class<?> retrieveResultType(Method method);
+
+}

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

@@ -18,11 +18,7 @@
 
 public class SQLConnectionBuilder {
 
-    public static SQLConnectionBuilder of(String address,
-                                          int port,
-                                          String database,
-                                          String username,
-                                          String password) {
+    public static SQLConnectionBuilder of(String address, int port, String database, String username, String password) {
         return of(new DefaultSQLEndpoint(address + ":" + port, database, username, password));
     }
 
@@ -47,6 +43,10 @@ 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);
     }

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

@@ -8,6 +8,7 @@
 import me.zort.sqllib.api.data.Row;
 import me.zort.sqllib.internal.factory.SQLConnectionFactory;
 import me.zort.sqllib.internal.query.*;
+import org.jetbrains.annotations.ApiStatus;
 import org.jetbrains.annotations.Nullable;
 
 import java.sql.Connection;
@@ -32,6 +33,9 @@ public SQLDatabaseConnection(SQLConnectionFactory connectionFactory) {
         SQLConnectionPool.register(this);
     }
 
+    @ApiStatus.Experimental
+    public abstract <T> T createMapping(Class<T> mappingInterface);
+
     /**
      * Saves this mapping object into database using upsert query.
      * <p>

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

@@ -2,9 +2,7 @@
 
 import com.google.gson.Gson;
 import lombok.*;
-import me.zort.sqllib.api.ObjectMapper;
-import me.zort.sqllib.api.Query;
-import me.zort.sqllib.api.StatementFactory;
+import me.zort.sqllib.api.*;
 import me.zort.sqllib.api.data.QueryResult;
 import me.zort.sqllib.api.data.QueryRowsResult;
 import me.zort.sqllib.api.data.Row;
@@ -19,8 +17,11 @@
 import me.zort.sqllib.internal.impl.QueryResultImpl;
 import me.zort.sqllib.internal.query.*;
 import me.zort.sqllib.internal.query.part.SetStatement;
+import me.zort.sqllib.mapping.DefaultResultAdapter;
+import me.zort.sqllib.mapping.DefaultStatementMappingFactory;
 import me.zort.sqllib.util.Pair;
 import me.zort.sqllib.util.Validator;
+import org.jetbrains.annotations.ApiStatus;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
@@ -49,6 +50,10 @@ public class SQLDatabaseConnectionImpl extends SQLDatabaseConnection {
 
     @Getter
     private final SQLDatabaseOptions options;
+    @ApiStatus.Experimental
+    private final transient StatementMappingFactory mappingFactory;
+    @ApiStatus.Experimental
+    private final transient StatementMappingResultAdapter mappingResultAdapter;
     private transient ObjectMapper objectMapper;
 
     /**
@@ -81,6 +86,8 @@ public SQLDatabaseConnectionImpl(SQLConnectionFactory connectionFactory, @Nullab
 
         this.options = options;
         this.objectMapper = new DefaultObjectMapper(this);
+        this.mappingFactory = new DefaultStatementMappingFactory();
+        this.mappingResultAdapter = new DefaultResultAdapter();
 
         // Default backup value resolvers.
         registerBackupValueResolver(new LinkedOneFieldResolver());
@@ -97,6 +104,27 @@ public void setObjectMapper(@NotNull ObjectMapper objectMapper) {
         this.objectMapper = Objects.requireNonNull(objectMapper, "Object mapper cannot be null!");
     }
 
+    @SuppressWarnings("unchecked")
+    @ApiStatus.Experimental
+    public <T> T createMapping(Class<T> mappingInterface) {
+        StatementMapping<T> statementMapping = mappingFactory.create(mappingInterface, this);
+        return (T) Proxy.newProxyInstance(mappingInterface.getClassLoader(),
+                new Class[]{mappingInterface}, (proxy, method, args) -> {
+
+                    // Allow invokation from interfaces or abstract classes only.
+                    Class<?> declaringClass = method.getDeclaringClass();
+                    if ((declaringClass.isInterface() || Modifier.isAbstract(declaringClass.getModifiers()))
+                            && statementMapping.isMappingMethod(method)) {
+                        // Prepare and execute query based on invoked method.
+                        QueryResult result = statementMapping.executeQuery(method, args, mappingResultAdapter.retrieveResultType(method));
+                        // Adapt QueryResult to method return type.
+                        return mappingResultAdapter.adaptResult(method, result);
+                    }
+
+                    return method.invoke(this, args);
+                });
+    }
+
     /**
      * @see SQLDatabaseConnection#save(String, Object)
      */
@@ -106,20 +134,24 @@ public QueryResult save(String table, Object obj) { // by default, it creates an
         if(defsValsPair == null) {
             return new QueryResultImpl(false);
         }
+
         String[] defs = defsValsPair.getFirst();
         UnknownValueWrapper[] vals = defsValsPair.getSecond();
 
         UpsertQuery upsert = upsert().into(table, defs);
         for(UnknownValueWrapper wrapper : vals) {
             upsert.appendVal(wrapper.getObject());
         }
+
         SetStatement<InsertQuery> setStmt = upsert.onDuplicateKey();
         for(int i = 0; i < defs.length; i++) {
             setStmt.and(defs[i], vals[i].getObject());
         }
+
         return setStmt.execute();
     }
 
+    @SuppressWarnings("unchecked")
     @Nullable
     protected Pair<String[], UnknownValueWrapper[]> buildDefsVals(Object obj) {
         Objects.requireNonNull(obj);
@@ -168,6 +200,7 @@ protected Pair<String[], UnknownValueWrapper[]> buildDefsVals(Object obj) {
     public <T> QueryRowsResult<T> query(Query query, Class<T> typeClass) {
         QueryRowsResult<Row> resultRows = query(query.getAncestor());
         QueryRowsResult<T> result = new QueryRowsResult<>(resultRows.isSuccessful());
+
         for(Row row : resultRows) {
             Optional.ofNullable(objectMapper.assignValues(row, typeClass))
                     .ifPresent(result::add);

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

@@ -5,7 +5,7 @@
 
 import java.util.ArrayList;
 
-public interface Conditional<P extends QueryNode<?> & Conditional<P>> {
+public interface Conditional<P extends QueryNode<?> & Conditional<P>> { // P = self
 
     default WhereStatement<P> where() {
         return where(QueryPriority.CONDITION.getPrior());

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

@@ -15,11 +15,11 @@ public class DeleteQuery extends QueryNode<QueryNode<?>> implements Executive, C
     @Getter
     private final SQLDatabaseConnection connection;
 
-    public DeleteQuery(SQLDatabaseConnection connection) {
+    public DeleteQuery(@Nullable SQLDatabaseConnection connection) {
         this(connection, null);
     }
 
-    public DeleteQuery(SQLDatabaseConnection connection, @Nullable String table) {
+    public DeleteQuery(@Nullable SQLDatabaseConnection connection, @Nullable String table) {
         super(null, new ArrayList<>(), QueryPriority.GENERAL);
         this.table = table;
         this.connection = connection;

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

@@ -22,11 +22,11 @@ public class InsertQuery extends QueryNode<QueryNode<?>> implements Executive, C
     @Getter
     private final SQLDatabaseConnection connection;
 
-    public InsertQuery(SQLDatabaseConnection connection) {
+    public InsertQuery(@Nullable SQLDatabaseConnection connection) {
         this(connection, null);
     }
 
-    public InsertQuery(SQLDatabaseConnection connection, @Nullable String table) {
+    public InsertQuery(@Nullable SQLDatabaseConnection connection, @Nullable String table) {
         super(null, new ArrayList<>(), QueryPriority.GENERAL);
         this.table = table;
         this.connection = connection;