Experimental: Proxy mapping

ZorTik · ZorTik · commit 6e2225cd9a7e · 2023-01-27T23:51:26.000+01:00
diff --git a/api/src/main/java/me/zort/sqllib/api/StatementMappingFactory.java b/api/src/main/java/me/zort/sqllib/api/StatementMappingFactory.java
@@ -1,7 +1,7 @@
 package me.zort.sqllib.api;
 
 /**
- * The StatementMappingFactory is responsible for creating new StatementMapping
+ * The StatementMappingFactory is responsible for creating new {@link StatementMappingStrategy}
  * for defined interfaces.
  *
  * @author ZorTik
@@ -17,6 +17,6 @@ public interface StatementMappingFactory {
      * @return The StatementMapping.
      * @param <T> The interface class type.
      */
-    <T> StatementMapping<T> create(Class<T> interfaceClass, SQLConnection connection);
+    <T> StatementMappingStrategy<T> create(Class<T> interfaceClass, SQLConnection connection);
 
 }
diff --git a/api/src/main/java/me/zort/sqllib/api/StatementMappingResultAdapter.java b/api/src/main/java/me/zort/sqllib/api/StatementMappingResultAdapter.java
@@ -6,14 +6,14 @@
 
 /**
  * Result adapter used for handling operations between {@link SQLConnection}
- * and {@link StatementMapping}.
+ * and {@link StatementMappingStrategy}.
  *
  * @author ZorTik
  */
 public interface StatementMappingResultAdapter {
 
     /**
-     * Adapts invoked {@link StatementMapping} method QueryResult to
+     * Adapts invoked {@link StatementMappingStrategy} method QueryResult to
      * the final result that can be passed to proxy instance.
      *
      * @param method The invoked proxy method.
diff --git a/api/src/main/java/me/zort/sqllib/api/StatementMappingStrategy.java b/api/src/main/java/me/zort/sqllib/api/StatementMappingStrategy.java
@@ -12,7 +12,7 @@
  * @param <T> The type of the proxy instance.
  * @author ZorTik
  */
-public interface StatementMapping<T> {
+public interface StatementMappingStrategy<T> {
 
     /**
      * Executes query based on invoked method with invoked args from
diff --git a/api/src/main/java/me/zort/sqllib/api/data/QueryResult.java b/api/src/main/java/me/zort/sqllib/api/data/QueryResult.java
@@ -2,6 +2,11 @@
 
 import org.jetbrains.annotations.Nullable;
 
+/**
+ * Represents a query result.
+ *
+ * @author ZorTik
+ */
 public interface QueryResult {
 
     boolean isSuccessful();
diff --git a/core/src/main/java/me/zort/sqllib/SQLDatabaseConnectionImpl.java b/core/src/main/java/me/zort/sqllib/SQLDatabaseConnectionImpl.java
@@ -128,7 +128,7 @@ public void setObjectMapper(@NotNull ObjectMapper objectMapper) {
     @SuppressWarnings("unchecked")
     @ApiStatus.Experimental
     public <T> T createMapping(Class<T> mappingInterface) {
-        StatementMapping<T> statementMapping = mappingFactory.create(mappingInterface, this);
+        StatementMappingStrategy<T> statementMapping = mappingFactory.create(mappingInterface, this);
         return (T) Proxy.newProxyInstance(mappingInterface.getClassLoader(),
                 new Class[]{mappingInterface}, (proxy, method, args) -> {
 
diff --git a/core/src/main/java/me/zort/sqllib/mapping/DefaultStatementMapping.java b/core/src/main/java/me/zort/sqllib/mapping/DefaultStatementMapping.java
@@ -3,7 +3,7 @@
 import lombok.RequiredArgsConstructor;
 import me.zort.sqllib.SQLDatabaseConnection;
 import me.zort.sqllib.api.SQLConnection;
-import me.zort.sqllib.api.StatementMapping;
+import me.zort.sqllib.api.StatementMappingStrategy;
 import me.zort.sqllib.api.data.QueryResult;
 import me.zort.sqllib.internal.query.QueryNode;
 import me.zort.sqllib.internal.query.QueryNodeRequest;
@@ -15,8 +15,15 @@
 import java.lang.reflect.Method;
 import java.lang.reflect.Parameter;
 
+/**
+ * This mapping strategy uses annotations from me.zort.sqllib.mapping.annotation
+ * to build queries. It is the default mapping strategy.
+ *
+ * @param <T> The type of the proxy instance.
+ * @author ZorTik
+ */
 @RequiredArgsConstructor
-public class DefaultStatementMapping<T> implements StatementMapping<T> {
+public class DefaultStatementMapping<T> implements StatementMappingStrategy<T> {
 
     private final SQLConnection connection;
 
@@ -65,4 +72,5 @@ public boolean isMappingMethod(Method method) {
         }
         return false;
     }
+
 }
diff --git a/core/src/main/java/me/zort/sqllib/mapping/DefaultStatementMappingFactory.java b/core/src/main/java/me/zort/sqllib/mapping/DefaultStatementMappingFactory.java
@@ -1,14 +1,14 @@
 package me.zort.sqllib.mapping;
 
 import me.zort.sqllib.api.SQLConnection;
-import me.zort.sqllib.api.StatementMapping;
+import me.zort.sqllib.api.StatementMappingStrategy;
 import me.zort.sqllib.api.StatementMappingFactory;
 
 import java.lang.reflect.Modifier;
 
 public class DefaultStatementMappingFactory implements StatementMappingFactory {
     @Override
-    public <T> StatementMapping<T> create(Class<T> interfaceClass, SQLConnection connection) {
+    public <T> StatementMappingStrategy<T> create(Class<T> interfaceClass, SQLConnection connection) {
         if (!interfaceClass.isInterface() || !Modifier.isAbstract(interfaceClass.getModifiers()))
             throw new IllegalArgumentException("The given class is not an interface or is not abstract");
         return new DefaultStatementMapping<>(connection);
diff --git a/core/src/main/java/me/zort/sqllib/mapping/PlaceholderMapper.java b/core/src/main/java/me/zort/sqllib/mapping/PlaceholderMapper.java
@@ -0,0 +1,35 @@
+package me.zort.sqllib.mapping;
+
+import lombok.RequiredArgsConstructor;
+import me.zort.sqllib.mapping.annotation.Placeholder;
+import me.zort.sqllib.util.ParameterPair;
+import me.zort.sqllib.util.Regex;
+
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+@RequiredArgsConstructor
+public class PlaceholderMapper {
+
+    private final ParameterPair[] parameters;
+    private final Pattern pattern = Pattern.compile("\\{[a-zA-Z0-9]+}");
+
+    public String assignValues(String input) {
+        Matcher matcher = pattern.matcher(input);
+        while(matcher.find()) {
+            String placeholder = matcher.group();
+            String placeholderName = placeholder.substring(1, placeholder.length() - 1);
+            for (ParameterPair pair : parameters) {
+                if (!pair.getParameter().isAnnotationPresent(Placeholder.class))
+                    continue;
+
+                if (placeholderName.equals(pair.getParameter().getAnnotation(Placeholder.class).value())) {
+                    input = input.replaceAll(Regex.skipRegexCharacters(placeholder), String.valueOf(pair.getValue()));
+                }
+            }
+        }
+
+        return input;
+    }
+
+}
diff --git a/core/src/main/java/me/zort/sqllib/mapping/QueryAnnotation.java b/core/src/main/java/me/zort/sqllib/mapping/QueryAnnotation.java
@@ -63,8 +63,8 @@ public interface QueryBuilder<T extends Annotation> {
     }
 
     public static class Validator {
-        public static void requireTableDefinition(Method method) {
-            if (Table.Util.getFromContext(method) == null)
+        public static void requireTableDefinition(Method method, PlaceholderMapper placeholderMapper) {
+            if (Table.Util.getFromContext(method, placeholderMapper) == null)
                 throw new SQLMappingException("Method " + method.getName() + " requires @Table annotation", method, null);
         }
         public static void requireWhereDefinition(Method method) {
diff --git a/core/src/main/java/me/zort/sqllib/mapping/annotation/Placeholder.java b/core/src/main/java/me/zort/sqllib/mapping/annotation/Placeholder.java
@@ -0,0 +1,21 @@
+package me.zort.sqllib.mapping.annotation;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Defines a value to be declared to placeholder on some mapping
+ * annotations in a default proxy mapping.
+ *
+ * @author ZorTik
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.PARAMETER)
+public @interface Placeholder {
+
+    // The placeholder, without brackets
+    String value();
+
+}
diff --git a/core/src/main/java/me/zort/sqllib/mapping/annotation/Table.java b/core/src/main/java/me/zort/sqllib/mapping/annotation/Table.java
@@ -1,5 +1,6 @@
 package me.zort.sqllib.mapping.annotation;
 
+import me.zort.sqllib.mapping.PlaceholderMapper;
 import org.jetbrains.annotations.Nullable;
 
 import java.lang.annotation.ElementType;
@@ -15,11 +16,11 @@
 
     class Util {
         @Nullable
-        public static String getFromContext(Method method) {
+        public static String getFromContext(Method method, PlaceholderMapper mapper) {
             if (method.isAnnotationPresent(Table.class)) {
-                return method.getAnnotation(Table.class).value();
+                return mapper.assignValues(method.getAnnotation(Table.class).value());
             } else if(method.getDeclaringClass().isAnnotationPresent(Table.class)) {
-                return method.getDeclaringClass().getAnnotation(Table.class).value();
+                return mapper.assignValues(method.getDeclaringClass().getAnnotation(Table.class).value());
             } else {
                 return null;
             }
diff --git a/core/src/main/java/me/zort/sqllib/mapping/annotation/Where.java b/core/src/main/java/me/zort/sqllib/mapping/annotation/Where.java
@@ -2,6 +2,7 @@
 
 import me.zort.sqllib.internal.query.Conditional;
 import me.zort.sqllib.internal.query.part.WhereStatement;
+import me.zort.sqllib.mapping.PlaceholderMapper;
 import org.intellij.lang.annotations.Pattern;
 
 import java.lang.annotation.ElementType;
@@ -18,7 +19,6 @@
     @interface Condition {
 
         String column();
-        @Pattern("[a-zA-Z0-9_]+")
         String value();
         Type type() default Type.EQUALS;
 
@@ -28,24 +28,26 @@ enum Type {
     }
 
     class Builder {
-        public static WhereStatement<?> build(Conditional<?> parent, Where annotation) {
+        public static WhereStatement<?> build(Conditional<?> parent, Where annotation, PlaceholderMapper mapper) {
             WhereStatement<?> where = parent.where();
             for (Condition condition : annotation.value()) {
+                String value = mapper.assignValues(condition.value());
+
                 switch (condition.type()) {
                     case EQUALS:
-                        where.isEqual(condition.column(), condition.value());
+                        where.isEqual(condition.column(), value);
                         break;
                     case BT:
                     case LT:
                         try {
-                            int number = Integer.parseInt(condition.value());
+                            int number = Integer.parseInt(value);
                             if (condition.type().equals(Condition.Type.BT)) {
                                 where.bt(condition.column(), number);
                             } else {
                                 where.lt(condition.column(), number);
                             }
                         } catch (NumberFormatException e) {
-                            throw new IllegalArgumentException("Value of current @Where.Condition must be a number! (" + condition.value() + ")");
+                            throw new IllegalArgumentException("Value of current @Where.Condition must be a number! (" + value + ")");
                         }
                         break;
                 }
diff --git a/core/src/main/java/me/zort/sqllib/mapping/builder/DeleteQueryBuilder.java b/core/src/main/java/me/zort/sqllib/mapping/builder/DeleteQueryBuilder.java
@@ -4,6 +4,7 @@
 import me.zort.sqllib.internal.query.DeleteQuery;
 import me.zort.sqllib.internal.query.Limitable;
 import me.zort.sqllib.internal.query.QueryNode;
+import me.zort.sqllib.mapping.PlaceholderMapper;
 import me.zort.sqllib.mapping.QueryAnnotation;
 import me.zort.sqllib.mapping.annotation.Delete;
 import me.zort.sqllib.mapping.annotation.Limit;
@@ -16,13 +17,13 @@
 public class DeleteQueryBuilder implements QueryAnnotation.QueryBuilder<Delete> {
     @Override
     public QueryNode<?> build(Delete queryAnnotation, Method method, ParameterPair[] parameters) {
-        QueryAnnotation.Validator.requireTableDefinition(method);
-
-        String table = Table.Util.getFromContext(method);
+        PlaceholderMapper placeholderMapper = new PlaceholderMapper(parameters);
+        QueryAnnotation.Validator.requireTableDefinition(method, placeholderMapper);
+        String table = Table.Util.getFromContext(method, placeholderMapper);
 
         QueryNode<?> node = new DeleteQuery(null, table);
         if (method.isAnnotationPresent(Where.class)) {
-            node = Where.Builder.build((Conditional<?>) node, method.getAnnotation(Where.class));
+            node = Where.Builder.build((Conditional<?>) node, method.getAnnotation(Where.class), placeholderMapper);
             node = node.getAncestor();
         }
         if (method.isAnnotationPresent(Limit.class)) {
diff --git a/core/src/main/java/me/zort/sqllib/mapping/builder/SelectQueryBuilder.java b/core/src/main/java/me/zort/sqllib/mapping/builder/SelectQueryBuilder.java
@@ -4,6 +4,7 @@
 import me.zort.sqllib.internal.query.Limitable;
 import me.zort.sqllib.internal.query.QueryNode;
 import me.zort.sqllib.internal.query.SelectQuery;
+import me.zort.sqllib.mapping.PlaceholderMapper;
 import me.zort.sqllib.mapping.QueryAnnotation;
 import me.zort.sqllib.mapping.annotation.Limit;
 import me.zort.sqllib.mapping.annotation.Select;
@@ -18,14 +19,14 @@
 public class SelectQueryBuilder implements QueryAnnotation.QueryBuilder<Select> {
     @Override
     public QueryNode<?> build(Select queryAnnotation, Method method, ParameterPair[] parameters) {
-        QueryAnnotation.Validator.requireTableDefinition(method);
-
-        String table = Table.Util.getFromContext(method);
+        PlaceholderMapper placeholderMapper = new PlaceholderMapper(parameters);
+        QueryAnnotation.Validator.requireTableDefinition(method, placeholderMapper);
+        String table = Table.Util.getFromContext(method, placeholderMapper);
 
         QueryNode<?> node = new SelectQuery(null, table, queryAnnotation.value().equals("*")
         ? new ArrayList<>() : Arrays.asList(queryAnnotation.value().replaceAll(" ", "").split(",")));
         if (method.isAnnotationPresent(Where.class)) {
-            node = Where.Builder.build((Conditional<?>) node, method.getAnnotation(Where.class));
+            node = Where.Builder.build((Conditional<?>) node, method.getAnnotation(Where.class), placeholderMapper);
             node = node.getAncestor();
         }
         if (method.isAnnotationPresent(Limit.class)) {
diff --git a/core/src/main/java/me/zort/sqllib/util/Regex.java b/core/src/main/java/me/zort/sqllib/util/Regex.java
@@ -0,0 +1,22 @@
+package me.zort.sqllib.util;
+
+import java.util.regex.PatternSyntaxException;
+
+public class Regex {
+
+    private Regex() {
+    }
+
+    public static String skipRegexCharacters(String input) {
+        String s = input;
+        StringBuilder stringBuilder = new StringBuilder(s);
+        try {
+            s.replaceAll(s, s);
+            return input;
+        } catch(PatternSyntaxException e) {
+            stringBuilder.insert(e.getIndex() + 1, "\\");
+            return stringBuilder.toString();
+        }
+    }
+
+}
diff --git a/src/test/java/me/zort/sqllib/test/TestCase2.java b/src/test/java/me/zort/sqllib/test/TestCase2.java
@@ -6,10 +6,7 @@
 import me.zort.sqllib.SQLDatabaseConnection;
 import me.zort.sqllib.SQLDatabaseOptions;
 import me.zort.sqllib.api.data.QueryResult;
-import me.zort.sqllib.mapping.annotation.Delete;
-import me.zort.sqllib.mapping.annotation.Limit;
-import me.zort.sqllib.mapping.annotation.Select;
-import me.zort.sqllib.mapping.annotation.Table;
+import me.zort.sqllib.mapping.annotation.*;
 import org.junit.jupiter.api.*;
 import org.junit.jupiter.api.condition.EnabledOnOs;
 import org.junit.jupiter.api.condition.OS;
@@ -55,7 +52,7 @@ public void test1_Mapping() {
 
         DatabaseRepository repository = connection.createMapping(DatabaseRepository.class);
         // TODO: Insert
-        assertTrue(repository.selectOne().isPresent());
+        assertTrue(repository.selectOne("User1").isPresent());
         assertNull(repository.deleteAll().getRejectMessage());
     }
 
@@ -69,8 +66,12 @@ public void test2_Close() {
     public interface DatabaseRepository {
 
         @Select
+        @Where(value = {
+                @Where.Condition(column = "nickname", value = "{nickname}"),
+                @Where.Condition(column = "points", value = "500", type = Where.Condition.Type.BT)
+        })
         @Limit(1)
-        Optional<User> selectOne();
+        Optional<User> selectOne(@Placeholder("nickname") String nickname);
 
         @Delete
         QueryResult deleteAll();

Original file line number	Diff line number	Diff line change
`@@ -1,7 +1,7 @@`
`1`	`1`	`package me.zort.sqllib.api;`
`2`	`2`
`3`	`3`	`/**`
`4`		`- * The StatementMappingFactory is responsible for creating new StatementMapping`
	`4`	`+ * The StatementMappingFactory is responsible for creating new {@link StatementMappingStrategy}`
`5`	`5`	`* for defined interfaces.`
`6`	`6`	`*`
`7`	`7`	`* @author ZorTik`
`@@ -17,6 +17,6 @@ public interface StatementMappingFactory {`
`17`	`17`	`* @return The StatementMapping.`
`18`	`18`	`* @param <T> The interface class type.`
`19`	`19`	`*/`
`20`		`- <T> StatementMapping<T> create(Class<T> interfaceClass, SQLConnection connection);`
	`20`	`+ <T> StatementMappingStrategy<T> create(Class<T> interfaceClass, SQLConnection connection);`
`21`	`21`
`22`	`22`	`}`
Original file line number	Diff line number	Diff line change
`@@ -63,8 +63,8 @@ public interface QueryBuilder<T extends Annotation> {`
`63`	`63`	`}`
`64`	`64`
`65`	`65`	`public static class Validator {`
`66`		`- public static void requireTableDefinition(Method method) {`
`67`		`- if (Table.Util.getFromContext(method) == null)`
	`66`	`+ public static void requireTableDefinition(Method method, PlaceholderMapper placeholderMapper) {`
	`67`	`+ if (Table.Util.getFromContext(method, placeholderMapper) == null)`
`68`	`68`	`throw new SQLMappingException("Method " + method.getName() + " requires @Table annotation", method, null);`
`69`	`69`	`}`
`70`	`70`	`public static void requireWhereDefinition(Method method) {`