Merge pull request #61 from eclipse/repleace_token_graph

Improves Query by method in the Graph

Author: otaviojava

artemis-graph/pom.xml

@@ -72,6 +72,11 @@
             <artifactId>artemis-core</artifactId>
             <version>${project.version}</version>
         </dependency>
+        <dependency>
+            <groupId>org.jnosql.query</groupId>
+            <artifactId>jnosql-query-antlr</artifactId>
+            <version>${project.version}</version>
+        </dependency>
         <dependency>
             <groupId>org.apache.tinkerpop</groupId>
             <artifactId>gremlin-core</artifactId>
@@ -84,7 +89,6 @@
             <version>${tinkerpop.version}</version>
             <scope>provided</scope>
         </dependency>
-
         <dependency>
             <groupId>org.apache.tinkerpop</groupId>
             <artifactId>neo4j-gremlin</artifactId>

artemis-graph/src/main/java/org/jnosql/artemis/graph/query/AbstractGraphRepositoryProxy.java

@@ -15,9 +15,9 @@
 package org.jnosql.artemis.graph.query;
 
 import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal;
-import org.apache.tinkerpop.gremlin.structure.Element;
 import org.apache.tinkerpop.gremlin.structure.Graph;
 import org.apache.tinkerpop.gremlin.structure.Vertex;
+import org.jnosql.artemis.Converters;
 import org.jnosql.artemis.Param;
 import org.jnosql.artemis.PreparedStatement;
 import org.jnosql.artemis.Query;
@@ -47,18 +47,21 @@
 abstract class AbstractGraphRepositoryProxy<T, ID> implements InvocationHandler {
 
 
+    private final SelectQueryConverter converter = new SelectQueryConverter();
+    private final DeleteQueryConverter deleteConverter = new DeleteQueryConverter();
+
     protected abstract ClassRepresentation getClassRepresentation();
 
     protected abstract Repository getRepository();
 
-    protected abstract GraphQueryParser getQueryParser();
-
     protected abstract Graph getGraph();
 
     protected abstract GraphConverter getConverter();
 
     protected abstract GraphTemplate getTemplate();
 
+    protected abstract Converters getConverters();
+
 
     @Override
     public Object invoke(Object instance, Method method, Object[] args) throws Throwable {
@@ -70,9 +73,9 @@ public Object invoke(Object instance, Method method, Object[] args) throws Throw
             case DEFAULT:
                 return method.invoke(getRepository(), args);
             case FIND_BY:
-                return executeFindByMethod(method, args, methodName);
+                return executeFindByMethod(method, args);
             case DELETE_BY:
-                return executeDeleteMethod(args, methodName);
+                return executeDeleteMethod(method, args);
             case FIND_ALL:
                 return executeFindAll(method, args);
             case OBJECT_METHOD:
@@ -86,26 +89,24 @@ public Object invoke(Object instance, Method method, Object[] args) throws Throw
         }
     }
 
-    private Object executeDeleteMethod(Object[] args, String methodName) {
-        GraphTraversal<Vertex, Vertex> traversal = getGraph().traversal().V();
-        getQueryParser().deleteByParse(methodName, args, getClassRepresentation(), traversal);
+    private Object executeDeleteMethod(Method method, Object[] args) {
 
-        List<?> vertices = traversal.toList();
+        GraphQueryMethod queryMethod = new GraphQueryMethod(getClassRepresentation(),
+                getGraph().traversal().V(),
+                getConverters(), method, args);
 
-        for (Object element : vertices) {
-            if (Element.class.isInstance(element)) {
-                Element.class.cast(element).remove();
-            }
-        }
+        List<Vertex> vertices = deleteConverter.apply(queryMethod);
+        vertices.forEach(Vertex::remove);
         return Void.class;
     }
 
-    private Object executeFindByMethod(Method method, Object[] args, String methodName) {
+    private Object executeFindByMethod(Method method, Object[] args) {
         Class<?> classInstance = getClassRepresentation().getClassInstance();
-        GraphTraversal<Vertex, Vertex> traversal = getGraph().traversal().V();
-        getQueryParser().findByParse(methodName, args, getClassRepresentation(), traversal);
+        GraphQueryMethod queryMethod = new GraphQueryMethod(getClassRepresentation(),
+                getGraph().traversal().V(),
+                getConverters(), method, args);
 
-        List<Vertex> vertices = traversal.hasLabel(getClassRepresentation().getName()).toList();
+        List<Vertex> vertices = converter.apply(queryMethod);
         Stream<T> stream = vertices.stream().map(getConverter()::toEntity);
 
         return returnObject(stream, classInstance, method);

artemis-graph/src/main/java/org/jnosql/artemis/graph/query/AbstractQueryConvert.java

@@ -0,0 +1,66 @@
+/*
+ *  Copyright (c) 2017 Otávio Santana and others
+ *   All rights reserved. This program and the accompanying materials
+ *   are made available under the terms of the Eclipse Public License v1.0
+ *   and Apache License v2.0 which accompanies this distribution.
+ *   The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html
+ *   and the Apache License v2.0 is available at http://www.opensource.org/licenses/apache2.0.php.
+ *
+ *   You may elect to redistribute this code under either of these licenses.
+ *
+ *   Contributors:
+ *
+ *   Otavio Santana
+ */
+package org.jnosql.artemis.graph.query;
+
+import org.apache.tinkerpop.gremlin.process.traversal.P;
+import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal;
+import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__;
+import org.apache.tinkerpop.gremlin.structure.Vertex;
+import org.jnosql.artemis.reflection.ClassRepresentation;
+import org.jnosql.query.Condition;
+import org.jnosql.query.ConditionValue;
+import org.jnosql.query.Operator;
+
+abstract class AbstractQueryConvert {
+
+
+    protected GraphTraversal<Vertex, Vertex> getPredicate(GraphQueryMethod graphQuery, Condition condition,
+                                                        ClassRepresentation representation) {
+        Operator operator = condition.getOperator();
+        String name = condition.getName();
+        String nativeName = representation.getColumnField(name);
+        switch (operator) {
+            case EQUALS:
+                return __.has(nativeName, P.eq(graphQuery.getValue(name)));
+            case GREATER_THAN:
+                return __.has(nativeName, P.gt(graphQuery.getValue(name)));
+            case GREATER_EQUALS_THAN:
+                return __.has(nativeName, P.gte(graphQuery.getValue(name)));
+            case LESSER_THAN:
+                return __.has(nativeName, P.lt(graphQuery.getValue(name)));
+            case LESSER_EQUALS_THAN:
+                return __.has(nativeName, P.lte(graphQuery.getValue(name)));
+            case BETWEEN:
+                return __.has(nativeName, P.between(graphQuery.getValue(name), graphQuery.getValue(name)));
+            case IN:
+                return __.has(nativeName, P.within(graphQuery.getInValue(name)));
+            case NOT:
+                Condition notCondition = ConditionValue.class.cast(condition.getValue()).get().get(0);
+                return __.not(getPredicate(graphQuery, notCondition, representation));
+            case AND:
+                return ConditionValue.class.cast(condition.getValue()).get().stream()
+                        .map(c -> getPredicate(graphQuery, c, representation)).reduce((a, b) -> a.and(b))
+                        .orElseThrow(() -> new UnsupportedOperationException("There is an inconsistency at the AND operator"));
+            case OR:
+                return ConditionValue.class.cast(condition.getValue()).get().stream()
+                        .map(c -> getPredicate(graphQuery, c, representation)).reduce((a, b) -> a.or(b))
+                        .orElseThrow(() -> new UnsupportedOperationException("There is an inconsistency at the OR operator"));
+            default:
+                throw new UnsupportedOperationException("There is not support to the type " + operator + " in graph");
+
+
+        }
+    }
+}

artemis-graph/src/main/java/org/jnosql/artemis/graph/query/DefaultGraphRepositoryProducer.java

@@ -15,6 +15,7 @@
 package org.jnosql.artemis.graph.query;
 
 import org.apache.tinkerpop.gremlin.structure.Graph;
+import org.jnosql.artemis.Converters;
 import org.jnosql.artemis.Repository;
 import org.jnosql.artemis.graph.GraphConverter;
 import org.jnosql.artemis.graph.GraphRepositoryProducer;
@@ -39,14 +40,16 @@ class DefaultGraphRepositoryProducer implements GraphRepositoryProducer {
     private GraphConverter converter;
     @Inject
     private GraphTemplateProducer producer;
+    @Inject
+    private Converters converters;
 
     @Override
     public <E, ID, T extends Repository<E, ID>> T get(Class<T> repositoryClass, Graph manager) {
         Objects.requireNonNull(repositoryClass, "repository class is required");
         Objects.requireNonNull(manager, "manager class is required");
         GraphTemplate template = producer.get(manager);
         GraphRepositoryProxy<T, ID> handler = new GraphRepositoryProxy(template,
-                classRepresentations, repositoryClass, reflections, manager, converter);
+                classRepresentations, repositoryClass, reflections, manager, converter, converters);
         return (T) Proxy.newProxyInstance(repositoryClass.getClassLoader(),
                 new Class[]{repositoryClass},
                 handler);

artemis-graph/src/main/java/org/jnosql/artemis/graph/query/DeleteQueryConverter.java

@@ -0,0 +1,46 @@
+/*
+ *  Copyright (c) 2017 Otávio Santana and others
+ *   All rights reserved. This program and the accompanying materials
+ *   are made available under the terms of the Eclipse Public License v1.0
+ *   and Apache License v2.0 which accompanies this distribution.
+ *   The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html
+ *   and the Apache License v2.0 is available at http://www.opensource.org/licenses/apache2.0.php.
+ *
+ *   You may elect to redistribute this code under either of these licenses.
+ *
+ *   Contributors:
+ *
+ *   Otavio Santana
+ */
+package org.jnosql.artemis.graph.query;
+
+import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal;
+import org.apache.tinkerpop.gremlin.structure.Vertex;
+import org.jnosql.aphrodite.antlr.method.DeleteMethodFactory;
+import org.jnosql.artemis.reflection.ClassRepresentation;
+import org.jnosql.query.Condition;
+import org.jnosql.query.DeleteQuery;
+import org.jnosql.query.Where;
+
+import java.util.List;
+import java.util.function.Function;
+
+final class DeleteQueryConverter extends AbstractQueryConvert implements Function<GraphQueryMethod, List<Vertex>> {
+
+    @Override
+    public List<Vertex> apply(GraphQueryMethod graphQuery) {
+        DeleteMethodFactory factory = DeleteMethodFactory.get();
+        DeleteQuery deleteQuery = factory.apply(graphQuery.getMethod(), graphQuery.getEntityName());
+        ClassRepresentation representation = graphQuery.getRepresentation();
+        GraphTraversal<Vertex, Vertex> traversal = graphQuery.getTraversal();
+        if (deleteQuery.getWhere().isPresent()) {
+            Where where = deleteQuery.getWhere().get();
+
+            Condition condition = where.getCondition();
+            traversal.filter(getPredicate(graphQuery, condition, representation));
+        }
+
+        traversal.hasLabel(representation.getName());
+        return traversal.toList();
+    }
+}

artemis-graph/src/main/java/org/jnosql/artemis/graph/query/GraphQueryMethod.java

@@ -0,0 +1,92 @@
+/*
+ *  Copyright (c) 2017 Otávio Santana and others
+ *   All rights reserved. This program and the accompanying materials
+ *   are made available under the terms of the Eclipse Public License v1.0
+ *   and Apache License v2.0 which accompanies this distribution.
+ *   The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html
+ *   and the Apache License v2.0 is available at http://www.opensource.org/licenses/apache2.0.php.
+ *
+ *   You may elect to redistribute this code under either of these licenses.
+ *
+ *   Contributors:
+ *
+ *   Otavio Santana
+ */
+package org.jnosql.artemis.graph.query;
+
+import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal;
+import org.apache.tinkerpop.gremlin.structure.Vertex;
+import org.jnosql.artemis.Converters;
+import org.jnosql.artemis.DynamicQueryException;
+import org.jnosql.artemis.reflection.ClassRepresentation;
+import org.jnosql.artemis.util.ConverterUtil;
+
+import java.lang.reflect.Method;
+import java.util.Collection;
+import java.util.stream.Collectors;
+import java.util.stream.StreamSupport;
+
+import static java.util.Collections.singletonList;
+
+final class GraphQueryMethod {
+
+    private final ClassRepresentation representation;
+    private final GraphTraversal<Vertex, Vertex> traversal;
+    private final Object[] args;
+    private final Converters converters;
+    private final Method method;
+    private int counter = 0;
+
+    GraphQueryMethod(ClassRepresentation representation,
+                     GraphTraversal<Vertex, Vertex> traversal,
+                     Converters converters, Method method, Object[] args) {
+        this.representation = representation;
+        this.traversal = traversal;
+        this.args = args;
+        this.converters = converters;
+        this.method = method;
+    }
+
+    public Method getMethod() {
+        return method;
+    }
+
+    public String getEntityName() {
+        return representation.getName();
+    }
+
+    public ClassRepresentation getRepresentation() {
+        return representation;
+    }
+
+    public GraphTraversal<Vertex, Vertex> getTraversal() {
+        return traversal;
+    }
+
+    public Object getValue(String name) {
+        Object value = getValue();
+        return ConverterUtil.getValue(value, representation, name, converters);
+    }
+
+    public  Collection<?> getInValue(String name) {
+        Object value = getValue();
+        if(value instanceof Iterable<?>) {
+            return (Collection<?>) StreamSupport.stream(Iterable.class.cast(value).spliterator(), false)
+                    .map(v -> ConverterUtil.getValue(v, representation, name, converters))
+                    .collect(Collectors.toList());
+        }
+        return singletonList(ConverterUtil.getValue(value, representation, name, converters));
+    }
+
+    private Object getValue() {
+        if ((counter + 1) > args.length) {
+            throw new DynamicQueryException(String.format("There is a missed argument in the method %s",
+                    method));
+        }
+        Object value = args[counter];
+        counter++;
+        return value;
+    }
+
+
+}