You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@tinkerpop.apache.org by sp...@apache.org on 2015/05/15 17:40:24 UTC
incubator-tinkerpop git commit: SubgraphStrategy now takes Traversal
rather than Predicate. TINKERPOP3-681
Repository: incubator-tinkerpop
Updated Branches:
refs/heads/master bdbac63b2 -> e48162f8f
SubgraphStrategy now takes Traversal rather than Predicate. TINKERPOP3-681
Project: http://git-wip-us.apache.org/repos/asf/incubator-tinkerpop/repo
Commit: http://git-wip-us.apache.org/repos/asf/incubator-tinkerpop/commit/e48162f8
Tree: http://git-wip-us.apache.org/repos/asf/incubator-tinkerpop/tree/e48162f8
Diff: http://git-wip-us.apache.org/repos/asf/incubator-tinkerpop/diff/e48162f8
Branch: refs/heads/master
Commit: e48162f8f81e898b670e8629bb148774a66f4b00
Parents: bdbac63
Author: Stephen Mallette <sp...@genoprime.com>
Authored: Fri May 15 11:39:42 2015 -0400
Committer: Stephen Mallette <sp...@genoprime.com>
Committed: Fri May 15 11:39:42 2015 -0400
----------------------------------------------------------------------
.../strategy/decoration/SubgraphStrategy.java | 111 ++++++++++++-------
.../decoration/SubgraphStrategyTest.java | 33 +++++-
.../SubgraphStrategyTraverseTest.java | 8 +-
.../decoration/SubgraphStrategyProcessTest.java | 75 +++++--------
4 files changed, 133 insertions(+), 94 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/incubator-tinkerpop/blob/e48162f8/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/decoration/SubgraphStrategy.java
----------------------------------------------------------------------
diff --git a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/decoration/SubgraphStrategy.java b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/decoration/SubgraphStrategy.java
index 5880720..b65eaa6 100644
--- a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/decoration/SubgraphStrategy.java
+++ b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/decoration/SubgraphStrategy.java
@@ -22,6 +22,9 @@ import org.apache.tinkerpop.gremlin.process.traversal.Step;
import org.apache.tinkerpop.gremlin.process.traversal.Traversal;
import org.apache.tinkerpop.gremlin.process.traversal.TraversalStrategy;
import org.apache.tinkerpop.gremlin.process.traversal.Traverser;
+import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__;
+import org.apache.tinkerpop.gremlin.process.traversal.step.filter.AndStep;
+import org.apache.tinkerpop.gremlin.process.traversal.step.filter.HasTraversalStep;
import org.apache.tinkerpop.gremlin.process.traversal.step.filter.LambdaFilterStep;
import org.apache.tinkerpop.gremlin.process.traversal.step.map.AddEdgeByPathStep;
import org.apache.tinkerpop.gremlin.process.traversal.step.map.AddEdgeStep;
@@ -45,14 +48,29 @@ import java.util.stream.Collectors;
/**
* @author Stephen Mallette (http://stephen.genoprime.com)
*/
-public final class SubgraphStrategy extends AbstractTraversalStrategy<TraversalStrategy.DecorationStrategy> implements TraversalStrategy.DecorationStrategy {
-
- private final Predicate<Traverser<Vertex>> vertexPredicate;
- private final Predicate<Traverser<Edge>> edgePredicate;
-
- private SubgraphStrategy(final Predicate<Vertex> vertexPredicate, final Predicate<Edge> edgePredicate) {
- this.vertexPredicate = t -> vertexPredicate.test(t.get());
- this.edgePredicate = t -> edgePredicate.test(t.get()) && vertexPredicate.test(t.get().inVertex()) && vertexPredicate.test(t.get().outVertex());
+public final class SubgraphStrategy extends AbstractTraversalStrategy<TraversalStrategy.DecorationStrategy>
+ implements TraversalStrategy.DecorationStrategy {
+
+ private final Traversal<Vertex, ?> vertexPredicate;
+ private final Traversal<Edge, ?> edgePredicate;
+
+ private SubgraphStrategy(final Traversal<Vertex, ?> vertexPredicate, final Traversal<Edge, ?> edgePredicate) {
+ this.vertexPredicate = vertexPredicate;
+
+ // if there is no vertex predicate there is no need to test either side of the edge
+ if (null == vertexPredicate) {
+ this.edgePredicate = edgePredicate;
+ } else {
+ final Traversal<Object, Vertex> inVertexPredicate = __.inV().has(vertexPredicate);
+ final Traversal<Object, Vertex> outVertexPredicate = __.outV().has(vertexPredicate);
+
+ // if there is a vertex predicate then there is an implied edge filter on vertices even if there is no
+ // edge predicate provided by the user.
+ if (null == edgePredicate)
+ this.edgePredicate = __.and(inVertexPredicate.asAdmin(), outVertexPredicate.asAdmin());
+ else
+ this.edgePredicate = edgePredicate.asAdmin().addStep(new AndStep<>(edgePredicate.asAdmin(), inVertexPredicate.asAdmin(), outVertexPredicate.asAdmin()));
+ }
}
@Override
@@ -60,61 +78,80 @@ public final class SubgraphStrategy extends AbstractTraversalStrategy<TraversalS
final List<GraphStep> graphSteps = TraversalHelper.getStepsOfAssignableClass(GraphStep.class, traversal);
final List<VertexStep> vertexSteps = TraversalHelper.getStepsOfAssignableClass(VertexStep.class, traversal);
- final List<Step> vertexStepsToInsertFilterAfter = new ArrayList<>();
- vertexStepsToInsertFilterAfter.addAll(TraversalHelper.getStepsOfAssignableClass(EdgeOtherVertexStep.class, traversal));
- vertexStepsToInsertFilterAfter.addAll(TraversalHelper.getStepsOfAssignableClass(EdgeVertexStep.class, traversal));
- vertexStepsToInsertFilterAfter.addAll(TraversalHelper.getStepsOfAssignableClass(AddVertexStep.class, traversal));
- vertexStepsToInsertFilterAfter.addAll(TraversalHelper.getStepsOfAssignableClass(AddVertexStartStep.class, traversal));
- vertexStepsToInsertFilterAfter.addAll(graphSteps.stream().filter(s -> s.getReturnClass().equals(Vertex.class)).collect(Collectors.toList()));
+ if (vertexPredicate != null) {
+ final List<Step> vertexStepsToInsertFilterAfter = new ArrayList<>();
+ vertexStepsToInsertFilterAfter.addAll(TraversalHelper.getStepsOfAssignableClass(EdgeOtherVertexStep.class, traversal));
+ vertexStepsToInsertFilterAfter.addAll(TraversalHelper.getStepsOfAssignableClass(EdgeVertexStep.class, traversal));
+ vertexStepsToInsertFilterAfter.addAll(TraversalHelper.getStepsOfAssignableClass(AddVertexStep.class, traversal));
+ vertexStepsToInsertFilterAfter.addAll(TraversalHelper.getStepsOfAssignableClass(AddVertexStartStep.class, traversal));
+ vertexStepsToInsertFilterAfter.addAll(graphSteps.stream().filter(s -> s.getReturnClass().equals(Vertex.class)).collect(Collectors.toList()));
- vertexStepsToInsertFilterAfter.forEach(s -> TraversalHelper.insertAfterStep(new LambdaFilterStep(traversal, vertexPredicate), s, traversal));
+ vertexStepsToInsertFilterAfter.forEach(s -> TraversalHelper.insertAfterStep(new HasTraversalStep<>(traversal, vertexPredicate.asAdmin().clone(), false), s, traversal));
+ }
- final List<Step> edgeStepsToInsertFilterAfter = new ArrayList<>();
- edgeStepsToInsertFilterAfter.addAll(TraversalHelper.getStepsOfAssignableClass(AddEdgeStep.class, traversal));
- edgeStepsToInsertFilterAfter.addAll(TraversalHelper.getStepsOfAssignableClass(AddEdgeByPathStep.class, traversal));
- edgeStepsToInsertFilterAfter.addAll(graphSteps.stream().filter(s -> s.getReturnClass().equals(Edge.class)).collect(Collectors.toList()));
- edgeStepsToInsertFilterAfter.addAll(vertexSteps.stream().filter(s -> s.getReturnClass().equals(Edge.class)).collect(Collectors.toList()));
+ if (edgePredicate != null) {
+ final List<Step> edgeStepsToInsertFilterAfter = new ArrayList<>();
+ edgeStepsToInsertFilterAfter.addAll(TraversalHelper.getStepsOfAssignableClass(AddEdgeStep.class, traversal));
+ edgeStepsToInsertFilterAfter.addAll(TraversalHelper.getStepsOfAssignableClass(AddEdgeByPathStep.class, traversal));
+ edgeStepsToInsertFilterAfter.addAll(graphSteps.stream().filter(s -> s.getReturnClass().equals(Edge.class)).collect(Collectors.toList()));
+ edgeStepsToInsertFilterAfter.addAll(vertexSteps.stream().filter(s -> s.getReturnClass().equals(Edge.class)).collect(Collectors.toList()));
- edgeStepsToInsertFilterAfter.forEach(s -> TraversalHelper.insertAfterStep(new LambdaFilterStep(traversal, edgePredicate), s, traversal));
+ edgeStepsToInsertFilterAfter.forEach(s -> TraversalHelper.insertAfterStep(new HasTraversalStep<>(traversal, edgePredicate.asAdmin().clone(), false), s, traversal));
+ }
- // explode g.V().out() to g.V().outE().inV()
+ // explode g.V().out() to g.V().outE().inV() only if there is an edge predicate otherwise
vertexSteps.stream().filter(s -> s.getReturnClass().equals(Vertex.class)).forEach(s -> {
- final VertexStep replacementVertexStep = new VertexStep(traversal, Edge.class, s.getDirection(), s.getEdgeLabels());
- Step intermediateFilterStep = null;
- if (s.getDirection() == Direction.BOTH)
- intermediateFilterStep = new EdgeOtherVertexStep(traversal);
- else
- intermediateFilterStep = new EdgeVertexStep(traversal, s.getDirection().opposite());
-
- TraversalHelper.replaceStep(s, replacementVertexStep, traversal);
- TraversalHelper.insertAfterStep(intermediateFilterStep, replacementVertexStep, traversal);
- TraversalHelper.insertAfterStep(new LambdaFilterStep(traversal, edgePredicate), replacementVertexStep, traversal);
- TraversalHelper.insertAfterStep(new LambdaFilterStep(traversal, vertexPredicate), intermediateFilterStep, traversal);
+ if (null == edgePredicate)
+ TraversalHelper.insertAfterStep(new HasTraversalStep<>(traversal, vertexPredicate.asAdmin().clone(), false), s, traversal);
+ else {
+ final VertexStep replacementVertexStep = new VertexStep(traversal, Edge.class, s.getDirection(), s.getEdgeLabels());
+ Step intermediateFilterStep = null;
+ if (s.getDirection() == Direction.BOTH)
+ intermediateFilterStep = new EdgeOtherVertexStep(traversal);
+ else
+ intermediateFilterStep = new EdgeVertexStep(traversal, s.getDirection().opposite());
+
+ TraversalHelper.replaceStep(s, replacementVertexStep, traversal);
+ TraversalHelper.insertAfterStep(intermediateFilterStep, replacementVertexStep, traversal);
+ TraversalHelper.insertAfterStep(new HasTraversalStep<>(traversal, edgePredicate.asAdmin().clone(), false), replacementVertexStep, traversal);
+
+ if (vertexPredicate != null)
+ TraversalHelper.insertAfterStep(new HasTraversalStep<>(traversal, vertexPredicate.asAdmin().clone(), false), intermediateFilterStep, traversal);
+ }
});
}
+ public Traversal<Vertex, ?> getVertexPredicate() {
+ return vertexPredicate;
+ }
+
+ public Traversal<Edge, ?> getEdgePredicate() {
+ return edgePredicate;
+ }
+
public static Builder build() {
return new Builder();
}
public static class Builder {
- private Predicate<Vertex> vertexPredicate = v -> true;
- private Predicate<Edge> edgePredicate = v -> true;
+ private Traversal<Vertex, ?> vertexPredicate = null;
+ private Traversal<Edge, ?> edgePredicate = null;
private Builder() {}
- public Builder vertexPredicate(final Predicate<Vertex> predicate) {
+ public Builder vertexPredicate(final Traversal<Vertex, ?> predicate) {
vertexPredicate = predicate;
return this;
}
- public Builder edgePredicate(final Predicate<Edge> predicate) {
+ public Builder edgePredicate(final Traversal<Edge, ?> predicate) {
edgePredicate = predicate;
return this;
}
public SubgraphStrategy create() {
+ if (null == edgePredicate && null == vertexPredicate) throw new IllegalStateException("A subgraph must be filtered by an edge or vertex filter");
return new SubgraphStrategy(vertexPredicate, edgePredicate);
}
}
http://git-wip-us.apache.org/repos/asf/incubator-tinkerpop/blob/e48162f8/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/decoration/SubgraphStrategyTest.java
----------------------------------------------------------------------
diff --git a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/decoration/SubgraphStrategyTest.java b/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/decoration/SubgraphStrategyTest.java
index d45583c..99c6789 100644
--- a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/decoration/SubgraphStrategyTest.java
+++ b/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/decoration/SubgraphStrategyTest.java
@@ -19,12 +19,17 @@
package org.apache.tinkerpop.gremlin.process.traversal.strategy.decoration;
import org.apache.tinkerpop.gremlin.process.traversal.Traversal;
+import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.DefaultGraphTraversal;
import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__;
-import org.apache.tinkerpop.gremlin.process.traversal.step.filter.LambdaFilterStep;
+import org.apache.tinkerpop.gremlin.process.traversal.step.filter.AndStep;
+import org.apache.tinkerpop.gremlin.process.traversal.step.filter.HasTraversalStep;
import org.apache.tinkerpop.gremlin.process.traversal.step.map.EdgeVertexStep;
import org.apache.tinkerpop.gremlin.process.traversal.step.map.VertexStep;
+import org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect.IdentityStep;
+import org.hamcrest.CoreMatchers;
import org.junit.Test;
+import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.Assert.assertEquals;
/**
@@ -32,21 +37,39 @@ import static org.junit.Assert.assertEquals;
*/
public class SubgraphStrategyTest {
- final SubgraphStrategy strategy = SubgraphStrategy.build().create();
-
@Test
public void shouldAddFilterAfterVertex() {
+ final SubgraphStrategy strategy = SubgraphStrategy.build().vertexPredicate(__.identity()).create();
final Traversal t = __.inV();
strategy.apply(t.asAdmin());
final EdgeVertexStep edgeVertexStep = (EdgeVertexStep) t.asAdmin().getStartStep();
- assertEquals(LambdaFilterStep.class, edgeVertexStep.getNextStep().getClass());
+ assertEquals(HasTraversalStep.class, edgeVertexStep.getNextStep().getClass());
+ final HasTraversalStep h = (HasTraversalStep) t.asAdmin().getEndStep();
+ assertEquals(1, h.getLocalChildren().size());
+ assertThat(((DefaultGraphTraversal) h.getLocalChildren().get(0)).getEndStep(), CoreMatchers.instanceOf(IdentityStep.class));
}
@Test
public void shouldAddFilterAfterEdge() {
+ final SubgraphStrategy strategy = SubgraphStrategy.build().edgePredicate(__.identity()).create();
+ final Traversal t = __.inE();
+ strategy.apply(t.asAdmin());
+ final VertexStep vertexStep = (VertexStep) t.asAdmin().getStartStep();
+ assertEquals(HasTraversalStep.class, vertexStep.getNextStep().getClass());
+ final HasTraversalStep h = (HasTraversalStep) t.asAdmin().getEndStep();
+ assertEquals(1, h.getLocalChildren().size());
+ assertThat(((DefaultGraphTraversal) h.getLocalChildren().get(0)).getEndStep(), CoreMatchers.instanceOf(IdentityStep.class));
+ }
+
+ @Test
+ public void shouldAddBothFiltersAfterVertex() {
+ final SubgraphStrategy strategy = SubgraphStrategy.build().edgePredicate(__.identity()).vertexPredicate(__.identity()).create();
final Traversal t = __.inE();
strategy.apply(t.asAdmin());
final VertexStep vertexStep = (VertexStep) t.asAdmin().getStartStep();
- assertEquals(LambdaFilterStep.class, vertexStep.getNextStep().getClass());
+ assertEquals(HasTraversalStep.class, vertexStep.getNextStep().getClass());
+ final HasTraversalStep h = (HasTraversalStep) t.asAdmin().getEndStep();
+ assertEquals(1, h.getLocalChildren().size());
+ assertThat(((DefaultGraphTraversal) h.getLocalChildren().get(0)).getEndStep(), CoreMatchers.instanceOf(AndStep.class));
}
}
http://git-wip-us.apache.org/repos/asf/incubator-tinkerpop/blob/e48162f8/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/decoration/SubgraphStrategyTraverseTest.java
----------------------------------------------------------------------
diff --git a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/decoration/SubgraphStrategyTraverseTest.java b/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/decoration/SubgraphStrategyTraverseTest.java
index 3bfaa34..6876316 100644
--- a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/decoration/SubgraphStrategyTraverseTest.java
+++ b/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/decoration/SubgraphStrategyTraverseTest.java
@@ -21,8 +21,7 @@ package org.apache.tinkerpop.gremlin.process.traversal.strategy.decoration;
import org.apache.tinkerpop.gremlin.process.traversal.Traversal;
import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.DefaultGraphTraversal;
import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__;
-import org.apache.tinkerpop.gremlin.process.traversal.step.filter.LambdaFilterStep;
-import org.apache.tinkerpop.gremlin.process.traversal.step.map.VertexStep;
+import org.apache.tinkerpop.gremlin.process.traversal.step.filter.HasTraversalStep;
import org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect.GraphStep;
import org.apache.tinkerpop.gremlin.process.traversal.util.TraversalHelper;
import org.apache.tinkerpop.gremlin.structure.Direction;
@@ -36,7 +35,6 @@ import java.util.Arrays;
import java.util.List;
import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
import static org.mockito.Mockito.mock;
/**
@@ -94,10 +92,10 @@ public class SubgraphStrategyTraverseTest {
@Test
public void shouldSubgraph() {
- final SubgraphStrategy strategy = SubgraphStrategy.build().create();
+ final SubgraphStrategy strategy = SubgraphStrategy.build().edgePredicate(__.identity()).vertexPredicate(__.identity()).create();
strategy.apply(traversal.asAdmin());
- final List<LambdaFilterStep> steps = TraversalHelper.getStepsOfClass(LambdaFilterStep.class, traversal.asAdmin());
+ final List<HasTraversalStep> steps = TraversalHelper.getStepsOfClass(HasTraversalStep.class, traversal.asAdmin());
assertEquals(expectedInsertedSteps, steps.size());
}
}
http://git-wip-us.apache.org/repos/asf/incubator-tinkerpop/blob/e48162f8/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/decoration/SubgraphStrategyProcessTest.java
----------------------------------------------------------------------
diff --git a/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/decoration/SubgraphStrategyProcessTest.java b/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/decoration/SubgraphStrategyProcessTest.java
index d945bcd..472021a 100644
--- a/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/decoration/SubgraphStrategyProcessTest.java
+++ b/gremlin-test/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/strategy/decoration/SubgraphStrategyProcessTest.java
@@ -25,13 +25,14 @@ import org.apache.tinkerpop.gremlin.process.IgnoreEngine;
import org.apache.tinkerpop.gremlin.process.traversal.Traversal;
import org.apache.tinkerpop.gremlin.process.traversal.TraversalEngine;
import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversalSource;
+import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__;
import org.apache.tinkerpop.gremlin.structure.Edge;
+import org.apache.tinkerpop.gremlin.structure.P;
import org.apache.tinkerpop.gremlin.structure.Vertex;
import org.junit.Test;
import org.junit.runner.RunWith;
import java.util.NoSuchElementException;
-import java.util.function.Predicate;
import static org.apache.tinkerpop.gremlin.LoadGraphWith.GraphData.MODERN;
import static org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__.bothE;
@@ -50,10 +51,9 @@ public class SubgraphStrategyProcessTest extends AbstractGremlinProcessTest {
@LoadGraphWith(MODERN)
@IgnoreEngine(TraversalEngine.Type.COMPUTER)
public void shouldFilterVertexCriterion() throws Exception {
- final Predicate<Vertex> vertexCriterion = vertex -> vertex.value("name").equals("josh") || vertex.value("name").equals("lop") || vertex.value("name").equals("ripple");
- final Predicate<Edge> edgeCriterion = edge -> true;
+ final Traversal<Vertex,?> vertexCriterion = __.has("name", P.within("josh", "lop", "ripple"));
- final SubgraphStrategy strategy = SubgraphStrategy.build().edgePredicate(edgeCriterion).vertexPredicate(vertexCriterion).create();
+ final SubgraphStrategy strategy = SubgraphStrategy.build().vertexPredicate(vertexCriterion).create();
final GraphTraversalSource sg = create(strategy);
// three vertices are included in the subgraph
@@ -134,25 +134,20 @@ public class SubgraphStrategyProcessTest extends AbstractGremlinProcessTest {
@Test
@LoadGraphWith(MODERN)
public void shouldFilterEdgeCriterion() throws Exception {
- final Predicate<Vertex> vertexCriterion = vertex -> true;
- final Predicate<Edge> edgeCriterion = edge -> {
- // 8
- if (edge.<Double>value("weight") == 1.0d && edge.label().equals("knows"))
- return true;
- // 9
- else if (edge.<Double>value("weight") == 0.4d && edge.label().equals("created") && edge.outVertex().value("name").equals("marko"))
- return true;
- // 10
- else if (edge.<Double>value("weight") == 1.0d && edge.label().equals("created"))
- return true;
- else return false;
- };
+ final Traversal<Edge,?> edgeCriterion = __.or(
+ __.has("weight", 1.0d).hasLabel("knows"), // 8
+ __.has("weight", 0.4d).hasLabel("created").outV().has("name", "marko"), // 9
+ __.has("weight", 1.0d).hasLabel("created") // 10
+ );
- final SubgraphStrategy strategy = SubgraphStrategy.build().edgePredicate(edgeCriterion).vertexPredicate(vertexCriterion).create();
+ final SubgraphStrategy strategy = SubgraphStrategy.build().edgePredicate(edgeCriterion).create();
final GraphTraversalSource sg = create(strategy);
// all vertices are here
assertEquals(6, g.V().count().next().longValue());
+ final Traversal t = sg.V();
+ t.hasNext();
+ printTraversalForm(t);
assertEquals(6, sg.V().count().next().longValue());
// only the given edges are included
@@ -183,7 +178,6 @@ public class SubgraphStrategyProcessTest extends AbstractGremlinProcessTest {
assertEquals(3, g.V(convertToVertexId("josh")).bothE().count().next().longValue());
assertEquals(2, sg.V(convertToVertexId("josh")).bothE().count().next().longValue());
assertEquals(3, g.V(convertToVertexId("josh")).both().count().next().longValue());
- final Traversal t = sg.V(convertToVertexId("josh")).both();
assertEquals(2, sg.V(convertToVertexId("josh")).both().count().next().longValue());
// with label
@@ -230,17 +224,13 @@ public class SubgraphStrategyProcessTest extends AbstractGremlinProcessTest {
@LoadGraphWith(MODERN)
@IgnoreEngine(TraversalEngine.Type.COMPUTER)
public void shouldFilterMixedCriteria() throws Exception {
- final Predicate<Vertex> vertexCriterion = vertex -> vertex.value("name").equals("josh") || vertex.value("name").equals("lop") || vertex.value("name").equals("ripple");
- final Predicate<Edge> edgeCriterion = edge -> {
- // 9 isn't present because marko is not in the vertex list
- // 11
- if (edge.<Double>value("weight") == 0.4d && edge.label().equals("created"))
- return true;
- // 10
- else if (edge.<Double>value("weight") == 1.0d && edge.label().equals("created"))
- return true;
- else return false;
- };
+ final Traversal<Vertex,?> vertexCriterion = __.has("name", P.within("josh", "lop", "ripple"));
+
+ // 9 isn't present because marko is not in the vertex list
+ final Traversal<Edge, ?> edgeCriterion = __.or(
+ __.has("weight", 0.4d).hasLabel("created"), // 11
+ __.has("weight", 1.0d).hasLabel("created") // 10
+ );
final SubgraphStrategy strategy = SubgraphStrategy.build().edgePredicate(edgeCriterion).vertexPredicate(vertexCriterion).create();
final GraphTraversalSource sg = create(strategy);
@@ -315,10 +305,9 @@ public class SubgraphStrategyProcessTest extends AbstractGremlinProcessTest {
@Test(expected = NoSuchElementException.class)
@LoadGraphWith(MODERN)
public void shouldGetExcludedVertex() throws Exception {
- final Predicate<Vertex> vertexCriterion = vertex -> vertex.value("name").equals("josh") || vertex.value("name").equals("lop") || vertex.value("name").equals("ripple");
- final Predicate<Edge> edgeCriterion = edge -> true;
+ final Traversal<Vertex,?> vertexCriterion = __.has("name", P.within("josh", "lop", "ripple"));
- final SubgraphStrategy strategy = SubgraphStrategy.build().edgePredicate(edgeCriterion).vertexPredicate(vertexCriterion).create();
+ final SubgraphStrategy strategy = SubgraphStrategy.build().vertexPredicate(vertexCriterion).create();
final GraphTraversalSource sg = create(strategy);
sg.V(convertToVertexId("marko")).next();
@@ -327,21 +316,13 @@ public class SubgraphStrategyProcessTest extends AbstractGremlinProcessTest {
@Test(expected = NoSuchElementException.class)
@LoadGraphWith(MODERN)
public void shouldGetExcludedEdge() throws Exception {
- final Predicate<Vertex> vertexCriterion = vertex -> true;
- final Predicate<Edge> edgeCriterion = edge -> {
- // 8
- if (edge.<Double>value("weight") == 1.0d && edge.label().equals("knows"))
- return true;
- // 9
- else if (edge.<Double>value("weight") == 0.4d && edge.label().equals("created") && edge.outVertex().value("name").equals("marko"))
- return true;
- // 10
- else if (edge.<Double>value("weight") == 1.0d && edge.label().equals("created"))
- return true;
- else return false;
- };
+ final Traversal<Edge,?> edgeCriterion = __.or(
+ __.has("weight", 1.0d).hasLabel("knows"), // 8
+ __.has("weight", 0.4d).hasLabel("created").outV().has("name", "marko"), // 9
+ __.has("weight", 1.0d).hasLabel("created") // 10
+ );
- final SubgraphStrategy strategy = SubgraphStrategy.build().edgePredicate(edgeCriterion).vertexPredicate(vertexCriterion).create();
+ final SubgraphStrategy strategy = SubgraphStrategy.build().edgePredicate(edgeCriterion).create();
final GraphTraversalSource sg = create(strategy);
sg.E(sg.E(convertToEdgeId("marko", "knows", "vadas")).next()).next();