NativeQueryBuilder now properly executes ResultSetAware queries.

Author: ZorTik

core/src/main/java/me/zort/sqllib/mapping/builder/NativeQueryBuilder.java

@@ -6,6 +6,7 @@
 import me.zort.sqllib.internal.query.QueryDetails;
 import me.zort.sqllib.internal.query.QueryNode;
 import me.zort.sqllib.internal.query.QueryPriority;
+import me.zort.sqllib.internal.query.ResultSetAware;
 import me.zort.sqllib.mapping.PlaceholderMapper;
 import me.zort.sqllib.mapping.QueryAnnotation;
 import me.zort.sqllib.mapping.annotation.Exec;
@@ -17,60 +18,73 @@
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.Map;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.function.Supplier;
 
 public class NativeQueryBuilder implements QueryAnnotation.QueryBuilder<Annotation> {
     @Override
     public QueryNode<?> build(QueryAnnotation.DefaultMappingDetails details, Annotation queryAnnotation, Method method, ParameterPair[] parameters) {
         SQLConnection connection = details.getConnection();
         PlaceholderMapper mapper = new PlaceholderMapper(parameters);
-        return new LocalQueryNodeExecutive(connection) {
-            private int currPhIndex = 0;
-            @Override
-            public QueryDetails buildQueryDetails() {
-                String annotValue;
-                String[] annotParams;
+        AtomicInteger currPhIndex = new AtomicInteger(0);
+        Supplier<String> nextPlaceholder = () -> "nq_" + currPhIndex.getAndIncrement();
+        return buildNodeImpl(queryAnnotation, connection, () -> {
+            String annotValue;
+            String[] annotParams;
 
-                if (queryAnnotation instanceof Query) {
-                    annotValue = ((Query) queryAnnotation).value();
-                    annotParams = ((Query) queryAnnotation).params();
-                } else if(queryAnnotation instanceof Exec) {
-                    annotValue = ((Exec) queryAnnotation).value();
-                    annotParams = ((Exec) queryAnnotation).params();
-                } else {
-                    throw new IllegalArgumentException(String.format("NativeQueryBuilder does not support %s annotation!", queryAnnotation.getClass().getName()));
-                }
+            if (queryAnnotation instanceof Query) {
+                annotValue = ((Query) queryAnnotation).value();
+                annotParams = ((Query) queryAnnotation).params();
+            } else if(queryAnnotation instanceof Exec) {
+                annotValue = ((Exec) queryAnnotation).value();
+                annotParams = ((Exec) queryAnnotation).params();
+            } else {
+                throw new IllegalArgumentException(String.format("NativeQueryBuilder does not support %s annotation!", queryAnnotation.getClass().getName()));
+            }
 
-                annotValue = mapper.assignValues(annotValue);
+            annotValue = mapper.assignValues(annotValue);
 
-                Map<String, Object> params = new HashMap<>();
-                for (String param : annotParams) {
-                    param = mapper.assignValues(param);
-                    int index = annotValue.indexOf("?");
-                    if (index == -1)
-                        break;
+            Map<String, Object> params = new HashMap<>();
+            for (String param : annotParams) {
+                param = mapper.assignValues(param);
+                int index = annotValue.indexOf("?");
+                if (index == -1)
+                    break;
 
-                    String placeholder = nextPlaceholder();
-                    annotValue = annotValue.replaceFirst("\\?", "<" + placeholder + ">");
-                    params.put(placeholder, param);
-                }
-                return new QueryDetails(annotValue, params);
+                String placeholder = nextPlaceholder.get();
+                annotValue = annotValue.replaceFirst("\\?", "<" + placeholder + ">");
+                params.put(placeholder, param);
             }
+            return new QueryDetails(annotValue, params);
+        });
+    }
 
-            private String nextPlaceholder() {
-                return "nq_" + currPhIndex++;
-            }
+    private static QueryNode<?> buildNodeImpl(Annotation queryAnnotation, SQLConnection connection, Supplier<QueryDetails> detailsSupplier) {
+        if (queryAnnotation instanceof Exec) return new NodeExecutiveImpl(connection) {
+            @Override
+            public QueryDetails buildQueryDetails() {return detailsSupplier.get();}
         };
+        else if (queryAnnotation instanceof Query) return new NodeExecutiveImplRS(connection) {
+            @Override
+            public QueryDetails buildQueryDetails() {return detailsSupplier.get();}
+        };
+        throw new IllegalArgumentException();
     }
 
-    private static abstract class LocalQueryNodeExecutive extends QueryNode<QueryNode<?>> implements Executive {
-
+    private static abstract class NodeExecutiveImpl extends QueryNode<QueryNode<?>> implements Executive {
         @Getter
         private final SQLConnection connection;
 
-        public LocalQueryNodeExecutive(SQLConnection connection) {
+        public NodeExecutiveImpl(SQLConnection connection) {
             super(null, new ArrayList<>(), QueryPriority.GENERAL);
             this.connection = connection;
         }
     }
 
+    private static abstract class NodeExecutiveImplRS extends NodeExecutiveImpl implements ResultSetAware {
+        public NodeExecutiveImplRS(SQLConnection connection) {
+            super(connection);
+        }
+    }
+
 }