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 2024/07/10 19:50:08 UTC
(tinkerpop) branch gvalue created (now 3f9b30f452)
This is an automated email from the ASF dual-hosted git repository.
spmallette pushed a change to branch gvalue
in repository https://gitbox.apache.org/repos/asf/tinkerpop.git
at 3f9b30f452 wip - parameters
This branch includes the following new commits:
new 3f9b30f452 wip - parameters
The 1 revisions listed above as "new" are entirely new to this
repository and will be described in separate emails. The revisions
listed as "add" were already present in the repository and have only
been added to this reference.
(tinkerpop) 01/01: wip - parameters
Posted by sp...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
spmallette pushed a commit to branch gvalue
in repository https://gitbox.apache.org/repos/asf/tinkerpop.git
commit 3f9b30f452b09cec4c80e33f67ff724cfc5a1963
Author: Stephen Mallette <st...@amazon.com>
AuthorDate: Wed Jul 10 15:49:35 2024 -0400
wip - parameters
---
.../language/grammar/TraversalMethodVisitor.java | 11 +-
.../gremlin/language/grammar/VariableResolver.java | 37 +++++-
.../tinkerpop/gremlin/process/traversal/P.java | 6 +-
.../traversal/dsl/graph/GraphTraversal.java | 42 +++++++
.../gremlin/process/traversal/step/GType.java | 59 +++++++++
.../gremlin/process/traversal/step/GValue.java | 138 +++++++++++++++++++++
.../process/traversal/step/filter/CoinStep.java | 26 +++-
.../gremlin/structure/VertexProperty.java | 3 -
.../language/grammar/ArgumentVisitorTest.java | 116 ++++++++---------
.../language/grammar/GremlinQueryParserTest.java | 8 +-
.../tinkergraph/structure/TinkerGraphPlayTest.java | 30 +++--
11 files changed, 388 insertions(+), 88 deletions(-)
diff --git a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/language/grammar/TraversalMethodVisitor.java b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/language/grammar/TraversalMethodVisitor.java
index 440bd502c8..d183445b9a 100644
--- a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/language/grammar/TraversalMethodVisitor.java
+++ b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/language/grammar/TraversalMethodVisitor.java
@@ -23,6 +23,8 @@ import org.apache.tinkerpop.gremlin.process.traversal.Order;
import org.apache.tinkerpop.gremlin.process.traversal.SackFunctions;
import org.apache.tinkerpop.gremlin.process.traversal.Traversal;
import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal;
+import org.apache.tinkerpop.gremlin.process.traversal.step.GType;
+import org.apache.tinkerpop.gremlin.process.traversal.step.GValue;
import org.apache.tinkerpop.gremlin.structure.VertexProperty.Cardinality;
import java.util.Map;
@@ -441,7 +443,14 @@ public class TraversalMethodVisitor extends TraversalRootVisitor<GraphTraversal>
*/
@Override
public GraphTraversal visitTraversalMethod_coin(final GremlinParser.TraversalMethod_coinContext ctx) {
- return graphTraversal.coin(((Number) antlr.argumentVisitor.visitFloatArgument(ctx.floatArgument())).doubleValue());
+ final Object literalOrVar = antlr.argumentVisitor.visitFloatArgument(ctx.floatArgument());
+ if (literalOrVar instanceof Number)
+ return graphTraversal.coin(((Number) literalOrVar).doubleValue());
+ else if (literalOrVar instanceof GValue && ((GValue) literalOrVar).getType() == GType.DOUBLE)
+ return graphTraversal.asAdmin().coin((GValue<Double>) literalOrVar);
+ else
+ throw new IllegalArgumentException("coin() argument must be a double");
+
}
/**
diff --git a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/language/grammar/VariableResolver.java b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/language/grammar/VariableResolver.java
index a97bd4b646..e017808faf 100644
--- a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/language/grammar/VariableResolver.java
+++ b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/language/grammar/VariableResolver.java
@@ -18,24 +18,25 @@
*/
package org.apache.tinkerpop.gremlin.language.grammar;
+import org.apache.tinkerpop.gremlin.process.traversal.step.GValue;
import java.util.Map;
import java.util.function.BiFunction;
/**
* Resolves parameters in Gremlin to objects.
*/
-public interface VariableResolver extends BiFunction<String, GremlinParser.VariableContext, Object> {
+public interface VariableResolver<T> extends BiFunction<String, GremlinParser.VariableContext, T> {
/**
* This function resolves a variable name and the given parsers context to an object.
*/
@Override
- Object apply(final String varName, final GremlinParser.VariableContext variableContext);
+ T apply(final String varName, final GremlinParser.VariableContext variableContext);
/**
* This {@link VariableResolver} implementation throws exceptions for all variable names.
*/
- class NoVariableResolver implements VariableResolver {
+ class NoVariableResolver implements VariableResolver<Object> {
private static NoVariableResolver instance = new NoVariableResolver();
public static VariableResolver instance() {
@@ -48,12 +49,35 @@ public interface VariableResolver extends BiFunction<String, GremlinParser.Varia
}
}
+ /**
+ * Allows for a provided variable set in the form of a {@code Map}, where the keys are variable names and the
+ * values are the parameter values to be injected into the traversal in their place. The value is provided to a
+ * {@link GValue} object along with the variable name for further reference.
+ */
+ class DefaultVariableResolver implements VariableResolver<GValue<?>> {
+
+ private final Map<String, Object> variables;
+
+ public DefaultVariableResolver(final Map<String, Object> variables) {
+ this.variables = variables;
+ }
+
+ @Override
+ public GValue<?> apply(final String s, final GremlinParser.VariableContext variableContext) {
+ if (!variables.containsKey(s)) {
+ throw new VariableResolverException(String.format("No variable found for %s", s));
+ }
+
+ return GValue.of(s, variables.get(s));
+ }
+ }
+
/**
* This {@link VariableResolver} simply provides a {@code null} value for all variable names. It's typical use
* is for when you really don't intend to execute the traversal and just want to get an instance of one when
* bindings are being used as with {@link NoOpTerminalVisitor}.
*/
- class NullVariableResolver implements VariableResolver {
+ class NullVariableResolver implements VariableResolver<Object> {
private static NullVariableResolver instance = new NullVariableResolver();
public static VariableResolver instance() {
@@ -70,11 +94,11 @@ public interface VariableResolver extends BiFunction<String, GremlinParser.Varia
* Allows for a provided variable set in the form of a {@code Map}, where the keys are variable names and the
* values are the parameter values to be injected into the traversal in their place.
*/
- class DefaultVariableResolver implements VariableResolver {
+ class DirectVariableResolver implements VariableResolver<Object> {
private final Map<String, Object> variables;
- public DefaultVariableResolver(final Map<String, Object> variables) {
+ public DirectVariableResolver(final Map<String, Object> variables) {
this.variables = variables;
}
@@ -87,4 +111,5 @@ public interface VariableResolver extends BiFunction<String, GremlinParser.Varia
return variables.get(s);
}
}
+
}
\ No newline at end of file
diff --git a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/P.java b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/P.java
index 917a13891d..56e1946368 100644
--- a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/P.java
+++ b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/P.java
@@ -18,6 +18,7 @@
*/
package org.apache.tinkerpop.gremlin.process.traversal;
+import org.apache.tinkerpop.gremlin.process.traversal.step.GValue;
import org.apache.tinkerpop.gremlin.process.traversal.util.AndP;
import org.apache.tinkerpop.gremlin.process.traversal.util.OrP;
@@ -74,7 +75,10 @@ public class P<V> implements Predicate<V>, Serializable, Cloneable {
@Override
public boolean test(final V testValue) {
- return this.biPredicate.test(testValue, this.value);
+ if (this.value instanceof GValue)
+ return this.biPredicate.test(testValue, ((GValue<V>) this.value).get());
+ else
+ return this.biPredicate.test(testValue, this.value);
}
@Override
diff --git a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/dsl/graph/GraphTraversal.java b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/dsl/graph/GraphTraversal.java
index aa364e4fc4..496ba1a473 100644
--- a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/dsl/graph/GraphTraversal.java
+++ b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/dsl/graph/GraphTraversal.java
@@ -47,6 +47,8 @@ import org.apache.tinkerpop.gremlin.process.traversal.lambda.TrueTraversal;
import org.apache.tinkerpop.gremlin.process.traversal.step.ByModulating;
import org.apache.tinkerpop.gremlin.process.traversal.step.Configuring;
import org.apache.tinkerpop.gremlin.process.traversal.step.FromToModulating;
+import org.apache.tinkerpop.gremlin.process.traversal.step.GType;
+import org.apache.tinkerpop.gremlin.process.traversal.step.GValue;
import org.apache.tinkerpop.gremlin.process.traversal.step.Mutating;
import org.apache.tinkerpop.gremlin.process.traversal.step.ReadWriting;
import org.apache.tinkerpop.gremlin.process.traversal.step.TimesModulating;
@@ -230,8 +232,48 @@ import static org.apache.tinkerpop.gremlin.structure.VertexProperty.Cardinality.
*/
public interface GraphTraversal<S, E> extends Traversal<S, E> {
+ /**
+ * Exposes administrative methods that are either internal to TinkerPop or for users with advanced needs. This
+ * separation helps keep the Gremlin API more concise. Any {@code GraphTraversal} can get an instance of its
+ * administrative form by way of {@link GraphTraversal#asAdmin()}.
+ * <p/>
+ * Note that step overloads allowing use of {@link GValue} objects do not construct bytecode with that object.
+ * Bytecode does not make use of parameterization in that fashion so it there isn't a need to really preserve that
+ * functionality there (doing so would require changes to serializers).
+ */
public interface Admin<S, E> extends Traversal.Admin<S, E>, GraphTraversal<S, E> {
+ /**
+ * Filter the <code>E</code> object given a biased coin toss.
+ *
+ * @param probability the probability that the object will pass through the filter
+ * @return the traversal with an appended {@link CoinStep}.
+ * @see <a href="http://tinkerpop.apache.org/docs/${project.version}/reference/#coin-step" target="_blank">Reference Documentation - Coin Step</a>
+ * @since 3.7.3
+ */
+ public default GraphTraversal<S, E> coin(final GValue<Double> probability) {
+ this.asAdmin().getBytecode().addStep(GraphTraversal.Symbols.coin, probability.get());
+ return this.asAdmin().addStep(new CoinStep<>(this.asAdmin(), probability));
+ }
+
+ /**
+ * Filter the <code>E</code> object given a biased coin toss where the argument can be either a {@link GValue}
+ * object or a double.
+ *
+ * @param probability the probability that the object will pass through and must be a {@link GValue} object or a double.
+ * @return the traversal with an appended {@link CoinStep}.
+ * @see <a href="http://tinkerpop.apache.org/docs/${project.version}/reference/#coin-step" target="_blank">Reference Documentation - Coin Step</a>
+ * @since 3.7.3
+ */
+ public default GraphTraversal<S, E> coin(final Object probability) {
+ if (probability instanceof Number)
+ return this.coin(((Number) probability).doubleValue());
+ else if (probability instanceof GValue && ((GValue) probability).getType() == GType.DOUBLE)
+ return this.coin(probability);
+ else
+ throw new IllegalArgumentException("The probability must be a GValue<Double> or a double");
+ }
+
@Override
public default <E2> GraphTraversal.Admin<S, E2> addStep(final Step<?, E2> step) {
return (GraphTraversal.Admin<S, E2>) Traversal.Admin.super.addStep((Step) step);
diff --git a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/GType.java b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/GType.java
new file mode 100644
index 0000000000..cd12d7e191
--- /dev/null
+++ b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/GType.java
@@ -0,0 +1,59 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.tinkerpop.gremlin.process.traversal.step;
+
+/**
+ * An enum that describes types that are used in the Gremlin language.
+ */
+public enum GType {
+ INTEGER,
+ STRING,
+ BOOLEAN,
+ DOUBLE,
+ LONG,
+ MAP,
+ LIST,
+ SET,
+ VERTEX,
+ EDGE,
+ PATH,
+ PROPERTY,
+ UNKNOWN;
+
+ GType() {}
+
+ /**
+ * Convert an object to a matching {@link GType} and if not matched return {@link GType#UNKNOWN}.
+ */
+ public static GType getType(final Object object) {
+ if (object instanceof Integer) return INTEGER;
+ else if (object instanceof String) return STRING;
+ else if (object instanceof Boolean) return BOOLEAN;
+ else if (object instanceof Double) return DOUBLE;
+ else if (object instanceof Long) return LONG;
+ else if (object instanceof java.util.Map) return MAP;
+ else if (object instanceof java.util.List) return LIST;
+ else if (object instanceof java.util.Set) return SET;
+ else if (object instanceof org.apache.tinkerpop.gremlin.structure.Vertex) return VERTEX;
+ else if (object instanceof org.apache.tinkerpop.gremlin.structure.Edge) return EDGE;
+ else if (object instanceof org.apache.tinkerpop.gremlin.process.traversal.Path) return PATH;
+ else if (object instanceof org.apache.tinkerpop.gremlin.structure.Property) return PROPERTY;
+ else return UNKNOWN;
+ }
+}
diff --git a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/GValue.java b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/GValue.java
new file mode 100644
index 0000000000..b9f0c8d23b
--- /dev/null
+++ b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/GValue.java
@@ -0,0 +1,138 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.tinkerpop.gremlin.process.traversal.step;
+
+import org.apache.tinkerpop.gremlin.process.traversal.Path;
+import org.apache.tinkerpop.gremlin.process.traversal.Traversal;
+import org.apache.tinkerpop.gremlin.structure.Edge;
+import org.apache.tinkerpop.gremlin.structure.Property;
+import org.apache.tinkerpop.gremlin.structure.Vertex;
+
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.Set;
+
+/**
+ * A {@code GValue} is a variable or literal value that is used in a {@link Traversal}. It is composed of a key-value
+ * pair where the key is the name given to the variable and the value is the object that the variable resolved to. If
+ * the name is not given, the value was provided literally in the traversal. The value of the variable can be any
+ * object. The {@code GValue} also includes the {@link GType} that describes the type it contains.
+ */
+public class GValue<V> {
+ private final String name;
+ private final GType type;
+
+ private final V value;
+
+ private GValue(final GType type, final V value) {
+ this(null, type, value);
+ }
+
+ private GValue(final String name, final GType type, final V value) {
+ this.name = name;
+ this.type = type;
+ this.value = value;
+ }
+
+ public boolean isVariable() {
+ return this.name != null;
+ }
+
+ public Optional<String> getName() {
+ return Optional.ofNullable(this.name);
+ }
+
+ public GType getType() {
+ return this.type;
+ }
+
+ public V get() {
+ return this.value;
+ }
+
+ @Override
+ public String toString() {
+ return isVariable() ?
+ String.format("%s&%s", name, value) : Objects.toString(value);
+ }
+
+ /**
+ * Create a new {@code Var} with the specified name and value.
+ *
+ * @param name the name of the variable
+ * @param value the value of the variable
+ */
+ public static <V> GValue<V> of(final String name, final V value) {
+ return new GValue<>(name, GType.getType(value), value);
+ }
+
+ public static GValue<String> ofString(final String name, final String value) {
+ return new GValue<>(name, GType.STRING, value);
+ }
+
+ public static GValue<Integer> ofInteger(final String name, final Integer value) {
+ return new GValue<>(name, GType.INTEGER, value);
+ }
+
+ public static GValue<Boolean> ofBoolean(final String name, final Boolean value) {
+ return new GValue<>(name, GType.BOOLEAN, value);
+ }
+
+ public static GValue<Double> ofDouble(final String name, final Double value) {
+ return new GValue<>(name, GType.DOUBLE, value);
+ }
+
+ public static GValue<Double> ofDouble(final Double value) {
+ return new GValue<>(GType.DOUBLE, value);
+ }
+
+ public static GValue<Long> ofLong(final String name, final Long value) {
+ return new GValue<>(name, GType.LONG, value);
+ }
+
+ public static GValue<Map> ofMap(final String name, final java.util.Map value) {
+ return new GValue<>(name, GType.MAP, value);
+ }
+
+ public static GValue<List> ofList(final String name, final java.util.List value) {
+ return new GValue<>(name, GType.LIST, value);
+ }
+
+ public static GValue<Set> ofSet(final String name, final java.util.Set value) {
+ return new GValue<>(name, GType.SET, value);
+ }
+
+ public static GValue<Vertex> ofVertex(final String name, final org.apache.tinkerpop.gremlin.structure.Vertex value) {
+ return new GValue<>(name, GType.VERTEX, value);
+ }
+
+ public static GValue<Edge> ofEdge(final String name, final org.apache.tinkerpop.gremlin.structure.Edge value) {
+ return new GValue<>(name, GType.EDGE, value);
+ }
+
+ public static GValue<Path> ofPath(final String name, final org.apache.tinkerpop.gremlin.process.traversal.Path value) {
+ return new GValue<>(name, GType.PATH, value);
+ }
+
+ public static GValue<Property> ofProperty(final String name, final org.apache.tinkerpop.gremlin.structure.Property value) {
+ return new GValue<>(name, GType.PROPERTY, value);
+ }
+}
diff --git a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/filter/CoinStep.java b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/filter/CoinStep.java
index e4a44abe93..7395dd8544 100644
--- a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/filter/CoinStep.java
+++ b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/filter/CoinStep.java
@@ -21,6 +21,7 @@ package org.apache.tinkerpop.gremlin.process.traversal.step.filter;
import org.apache.tinkerpop.gremlin.process.traversal.Traversal;
import org.apache.tinkerpop.gremlin.process.traversal.Traverser;
import org.apache.tinkerpop.gremlin.process.traversal.step.Seedable;
+import org.apache.tinkerpop.gremlin.process.traversal.step.GValue;
import org.apache.tinkerpop.gremlin.process.traversal.traverser.TraverserRequirement;
import org.apache.tinkerpop.gremlin.structure.util.StringFactory;
@@ -29,14 +30,25 @@ import java.util.Random;
import java.util.Set;
/**
+ * A filter step that will randomly allow traversers to pass through the step based on a probability value.
+ *
* @author Marko A. Rodriguez (http://markorodriguez.com)
*/
public final class CoinStep<S> extends FilterStep<S> implements Seedable {
private final Random random = new Random();
- private final double probability;
+ private final GValue<Double> probability;
+ /**
+ * @deprecated As of release 3.7.3, replaced by {@link #CoinStep(Traversal.Admin, GValue)}
+ */
+ @Deprecated
public CoinStep(final Traversal.Admin traversal, final double probability) {
+ super(traversal);
+ this.probability = GValue.ofDouble(probability);
+ }
+
+ public CoinStep(final Traversal.Admin traversal, final GValue<Double> probability) {
super(traversal);
this.probability = probability;
}
@@ -46,8 +58,12 @@ public final class CoinStep<S> extends FilterStep<S> implements Seedable {
random.setSeed(seed);
}
+ public GValue<Double> getProbabilityGValue() {
+ return probability;
+ }
+
public double getProbability() {
- return this.probability;
+ return this.probability.get();
}
@Override
@@ -55,11 +71,11 @@ public final class CoinStep<S> extends FilterStep<S> implements Seedable {
long newBulk = 0l;
if (traverser.bulk() < 100) {
for (int i = 0; i < traverser.bulk(); i++) {
- if (this.probability >= random.nextDouble())
+ if (this.probability.get() >= random.nextDouble())
newBulk++;
}
} else {
- newBulk = Math.round(this.probability * traverser.bulk());
+ newBulk = Math.round(this.probability.get() * traverser.bulk());
}
if (0 == newBulk) return false;
traverser.setBulk(newBulk);
@@ -73,7 +89,7 @@ public final class CoinStep<S> extends FilterStep<S> implements Seedable {
@Override
public int hashCode() {
- return super.hashCode() ^ Double.hashCode(this.probability);
+ return super.hashCode() ^ Double.hashCode(this.probability.get());
}
@Override
diff --git a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/structure/VertexProperty.java b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/structure/VertexProperty.java
index af7a18a1d9..962140adb5 100644
--- a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/structure/VertexProperty.java
+++ b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/structure/VertexProperty.java
@@ -18,9 +18,6 @@
*/
package org.apache.tinkerpop.gremlin.structure;
-import org.apache.tinkerpop.gremlin.process.traversal.Traversal;
-import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal;
-import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__;
import org.apache.tinkerpop.gremlin.process.traversal.lambda.CardinalityValueTraversal;
import org.apache.tinkerpop.gremlin.structure.util.empty.EmptyVertexProperty;
diff --git a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/language/grammar/ArgumentVisitorTest.java b/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/language/grammar/ArgumentVisitorTest.java
index 43f33054b5..e9c98cd2c3 100644
--- a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/language/grammar/ArgumentVisitorTest.java
+++ b/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/language/grammar/ArgumentVisitorTest.java
@@ -84,81 +84,81 @@ public class ArgumentVisitorTest {
public static Iterable<Object[]> generateTestParameters() {
return Arrays.asList(new Object[][]{
{Boolean.class, "x", new VariableResolverException("x"), createAntlr(VariableResolver.NoVariableResolver.instance())},
- {Boolean.class, "true", true, createAntlr(new VariableResolver.DefaultVariableResolver(ElementHelper.asMap("x", true)))},
- {Boolean.class, "false", false, createAntlr(new VariableResolver.DefaultVariableResolver(ElementHelper.asMap("x", true)))},
- {Boolean.class, "x", true, createAntlr(new VariableResolver.DefaultVariableResolver(ElementHelper.asMap("x", true)))},
+ {Boolean.class, "true", true, createAntlr(new VariableResolver.DirectVariableResolver(ElementHelper.asMap("x", true)))},
+ {Boolean.class, "false", false, createAntlr(new VariableResolver.DirectVariableResolver(ElementHelper.asMap("x", true)))},
+ {Boolean.class, "x", true, createAntlr(new VariableResolver.DirectVariableResolver(ElementHelper.asMap("x", true)))},
{Integer.class, "x", new VariableResolverException("x"), createAntlr(VariableResolver.NoVariableResolver.instance())},
- {Integer.class, "0", 0, createAntlr(new VariableResolver.DefaultVariableResolver(ElementHelper.asMap("x", 100)))},
- {Integer.class, "0i", 0, createAntlr(new VariableResolver.DefaultVariableResolver(ElementHelper.asMap("x", 100)))},
- {Integer.class, "0L", 0L, createAntlr(new VariableResolver.DefaultVariableResolver(ElementHelper.asMap("x", 100)))},
- {Integer.class, "x", 0, createAntlr(new VariableResolver.DefaultVariableResolver(ElementHelper.asMap("x", 0)))},
- {Integer.class, "x", 0L, createAntlr(new VariableResolver.DefaultVariableResolver(ElementHelper.asMap("x", 0L)))},
+ {Integer.class, "0", 0, createAntlr(new VariableResolver.DirectVariableResolver(ElementHelper.asMap("x", 100)))},
+ {Integer.class, "0i", 0, createAntlr(new VariableResolver.DirectVariableResolver(ElementHelper.asMap("x", 100)))},
+ {Integer.class, "0L", 0L, createAntlr(new VariableResolver.DirectVariableResolver(ElementHelper.asMap("x", 100)))},
+ {Integer.class, "x", 0, createAntlr(new VariableResolver.DirectVariableResolver(ElementHelper.asMap("x", 0)))},
+ {Integer.class, "x", 0L, createAntlr(new VariableResolver.DirectVariableResolver(ElementHelper.asMap("x", 0L)))},
{Float.class, "x", new VariableResolverException("x"), createAntlr(VariableResolver.NoVariableResolver.instance())},
- {Float.class, "0.0d", 0.0, createAntlr(new VariableResolver.DefaultVariableResolver(ElementHelper.asMap("x", 1000.0)))},
- {Float.class, "0d", 0.0, createAntlr(new VariableResolver.DefaultVariableResolver(ElementHelper.asMap("x", 1000.0)))},
- {Float.class, "0F", 0.0F, createAntlr(new VariableResolver.DefaultVariableResolver(ElementHelper.asMap("x", 1000.0F)))},
- {Float.class, "x", 0.0, createAntlr(new VariableResolver.DefaultVariableResolver(ElementHelper.asMap("x", 0.0)))},
- {Float.class, "x", 0.0F, createAntlr(new VariableResolver.DefaultVariableResolver(ElementHelper.asMap("x", 0.0F)))},
+ {Float.class, "0.0d", 0.0, createAntlr(new VariableResolver.DirectVariableResolver(ElementHelper.asMap("x", 1000.0)))},
+ {Float.class, "0d", 0.0, createAntlr(new VariableResolver.DirectVariableResolver(ElementHelper.asMap("x", 1000.0)))},
+ {Float.class, "0F", 0.0F, createAntlr(new VariableResolver.DirectVariableResolver(ElementHelper.asMap("x", 1000.0F)))},
+ {Float.class, "x", 0.0, createAntlr(new VariableResolver.DirectVariableResolver(ElementHelper.asMap("x", 0.0)))},
+ {Float.class, "x", 0.0F, createAntlr(new VariableResolver.DirectVariableResolver(ElementHelper.asMap("x", 0.0F)))},
{String.class, "x", new VariableResolverException("x"), createAntlr(VariableResolver.NoVariableResolver.instance())},
- {String.class, "'test'", "test", createAntlr(new VariableResolver.DefaultVariableResolver(ElementHelper.asMap("x", "nope")))},
- {String.class, "x", "test", createAntlr(new VariableResolver.DefaultVariableResolver(ElementHelper.asMap("x", "test")))},
- {String.class, "x", "graphson", createAntlr(new VariableResolver.DefaultVariableResolver(ElementHelper.asMap("x", IO.graphson)))},
+ {String.class, "'test'", "test", createAntlr(new VariableResolver.DirectVariableResolver(ElementHelper.asMap("x", "nope")))},
+ {String.class, "x", "test", createAntlr(new VariableResolver.DirectVariableResolver(ElementHelper.asMap("x", "test")))},
+ {String.class, "x", "graphson", createAntlr(new VariableResolver.DirectVariableResolver(ElementHelper.asMap("x", IO.graphson)))},
{StringNullable.class, "x", new VariableResolverException("x"), createAntlr(VariableResolver.NoVariableResolver.instance())},
- {StringNullable.class, "null", null, createAntlr(new VariableResolver.DefaultVariableResolver(ElementHelper.asMap("x", "nope")))},
- {StringNullable.class, "x", null, createAntlr(new VariableResolver.DefaultVariableResolver(nullMap))},
+ {StringNullable.class, "null", null, createAntlr(new VariableResolver.DirectVariableResolver(ElementHelper.asMap("x", "nope")))},
+ {StringNullable.class, "x", null, createAntlr(new VariableResolver.DirectVariableResolver(nullMap))},
{Object.class, "x", new VariableResolverException("x"), createAntlr(VariableResolver.NoVariableResolver.instance())},
- {Object.class, "'test'", "test", createAntlr(new VariableResolver.DefaultVariableResolver(ElementHelper.asMap("x", "nope")))},
- {Object.class, "x", "test", createAntlr(new VariableResolver.DefaultVariableResolver(ElementHelper.asMap("x", "test")))},
- {Object.class, "x", now, createAntlr(new VariableResolver.DefaultVariableResolver(ElementHelper.asMap("x", now)))},
- {Object.class, "[1,2,3]", Arrays.asList(1, 2, 3), createAntlr(new VariableResolver.DefaultVariableResolver(ElementHelper.asMap("x", now)))},
- {Object.class, "x", P.eq(100), createAntlr(new VariableResolver.DefaultVariableResolver(ElementHelper.asMap("x", P.eq(100))))},
+ {Object.class, "'test'", "test", createAntlr(new VariableResolver.DirectVariableResolver(ElementHelper.asMap("x", "nope")))},
+ {Object.class, "x", "test", createAntlr(new VariableResolver.DirectVariableResolver(ElementHelper.asMap("x", "test")))},
+ {Object.class, "x", now, createAntlr(new VariableResolver.DirectVariableResolver(ElementHelper.asMap("x", now)))},
+ {Object.class, "[1,2,3]", Arrays.asList(1, 2, 3), createAntlr(new VariableResolver.DirectVariableResolver(ElementHelper.asMap("x", now)))},
+ {Object.class, "x", P.eq(100), createAntlr(new VariableResolver.DirectVariableResolver(ElementHelper.asMap("x", P.eq(100))))},
{Direction.class, "x", new VariableResolverException("x"), createAntlr(VariableResolver.NoVariableResolver.instance())},
- {Direction.class, "Direction.OUT", Direction.OUT, createAntlr(new VariableResolver.DefaultVariableResolver(ElementHelper.asMap("x", "nope")))},
- {Direction.class, "OUT", Direction.OUT, createAntlr(new VariableResolver.DefaultVariableResolver(ElementHelper.asMap("x", "nope")))},
- {Direction.class, "x", Direction.OUT, createAntlr(new VariableResolver.DefaultVariableResolver(ElementHelper.asMap("x", Direction.OUT)))},
- {Direction.class, "x", Direction.from, createAntlr(new VariableResolver.DefaultVariableResolver(ElementHelper.asMap("x", Direction.from)))},
+ {Direction.class, "Direction.OUT", Direction.OUT, createAntlr(new VariableResolver.DirectVariableResolver(ElementHelper.asMap("x", "nope")))},
+ {Direction.class, "OUT", Direction.OUT, createAntlr(new VariableResolver.DirectVariableResolver(ElementHelper.asMap("x", "nope")))},
+ {Direction.class, "x", Direction.OUT, createAntlr(new VariableResolver.DirectVariableResolver(ElementHelper.asMap("x", Direction.OUT)))},
+ {Direction.class, "x", Direction.from, createAntlr(new VariableResolver.DirectVariableResolver(ElementHelper.asMap("x", Direction.from)))},
{Vertex.class, "x", new VariableResolverException("x"), createAntlr(VariableResolver.NoVariableResolver.instance())},
- {Vertex.class, "new Vertex(1i,'person')", new ReferenceVertex(1, "person"), createAntlr(new VariableResolver.DefaultVariableResolver(ElementHelper.asMap("x", Direction.from)))},
- {Vertex.class, "x", new ReferenceVertex(1, "person"), createAntlr(new VariableResolver.DefaultVariableResolver(ElementHelper.asMap("x", new ReferenceVertex(1, "person"))))},
+ {Vertex.class, "new Vertex(1i,'person')", new ReferenceVertex(1, "person"), createAntlr(new VariableResolver.DirectVariableResolver(ElementHelper.asMap("x", Direction.from)))},
+ {Vertex.class, "x", new ReferenceVertex(1, "person"), createAntlr(new VariableResolver.DirectVariableResolver(ElementHelper.asMap("x", new ReferenceVertex(1, "person"))))},
{Order.class, "x", new VariableResolverException("x"), createAntlr(VariableResolver.NoVariableResolver.instance())},
- {Order.class, "Order.desc", Order.desc, createAntlr(new VariableResolver.DefaultVariableResolver(ElementHelper.asMap("x", "nope")))},
- {Order.class, "x", Order.desc, createAntlr(new VariableResolver.DefaultVariableResolver(ElementHelper.asMap("x", Order.desc)))},
+ {Order.class, "Order.desc", Order.desc, createAntlr(new VariableResolver.DirectVariableResolver(ElementHelper.asMap("x", "nope")))},
+ {Order.class, "x", Order.desc, createAntlr(new VariableResolver.DirectVariableResolver(ElementHelper.asMap("x", Order.desc)))},
{Scope.class, "x", new VariableResolverException("x"), createAntlr(VariableResolver.NoVariableResolver.instance())},
- {Scope.class, "Scope.local", Scope.local, createAntlr(new VariableResolver.DefaultVariableResolver(ElementHelper.asMap("x", "nope")))},
- {Scope.class, "local", Scope.local, createAntlr(new VariableResolver.DefaultVariableResolver(ElementHelper.asMap("x", "nope")))},
- {Scope.class, "x", Scope.local, createAntlr(new VariableResolver.DefaultVariableResolver(ElementHelper.asMap("x", Scope.local)))},
+ {Scope.class, "Scope.local", Scope.local, createAntlr(new VariableResolver.DirectVariableResolver(ElementHelper.asMap("x", "nope")))},
+ {Scope.class, "local", Scope.local, createAntlr(new VariableResolver.DirectVariableResolver(ElementHelper.asMap("x", "nope")))},
+ {Scope.class, "x", Scope.local, createAntlr(new VariableResolver.DirectVariableResolver(ElementHelper.asMap("x", Scope.local)))},
{T.class, "x", new VariableResolverException("x"), createAntlr(VariableResolver.NoVariableResolver.instance())},
- {T.class, "T.label", T.label, createAntlr(new VariableResolver.DefaultVariableResolver(ElementHelper.asMap("x", "nope")))},
- {T.class, "label", T.label, createAntlr(new VariableResolver.DefaultVariableResolver(ElementHelper.asMap("x", "nope")))},
- {T.class, "x", T.label, createAntlr(new VariableResolver.DefaultVariableResolver(ElementHelper.asMap("x", T.label)))},
+ {T.class, "T.label", T.label, createAntlr(new VariableResolver.DirectVariableResolver(ElementHelper.asMap("x", "nope")))},
+ {T.class, "label", T.label, createAntlr(new VariableResolver.DirectVariableResolver(ElementHelper.asMap("x", "nope")))},
+ {T.class, "x", T.label, createAntlr(new VariableResolver.DirectVariableResolver(ElementHelper.asMap("x", T.label)))},
{VertexProperty.Cardinality.class, "x", new VariableResolverException("x"), createAntlr(VariableResolver.NoVariableResolver.instance())},
- {VertexProperty.Cardinality.class, "Cardinality.list", VertexProperty.Cardinality.list, createAntlr(new VariableResolver.DefaultVariableResolver(ElementHelper.asMap("x", "nope")))},
- {VertexProperty.Cardinality.class, "list", VertexProperty.Cardinality.list, createAntlr(new VariableResolver.DefaultVariableResolver(ElementHelper.asMap("x", "nope")))},
- {VertexProperty.Cardinality.class, "x", VertexProperty.Cardinality.list, createAntlr(new VariableResolver.DefaultVariableResolver(ElementHelper.asMap("x", VertexProperty.Cardinality.list)))},
+ {VertexProperty.Cardinality.class, "Cardinality.list", VertexProperty.Cardinality.list, createAntlr(new VariableResolver.DirectVariableResolver(ElementHelper.asMap("x", "nope")))},
+ {VertexProperty.Cardinality.class, "list", VertexProperty.Cardinality.list, createAntlr(new VariableResolver.DirectVariableResolver(ElementHelper.asMap("x", "nope")))},
+ {VertexProperty.Cardinality.class, "x", VertexProperty.Cardinality.list, createAntlr(new VariableResolver.DirectVariableResolver(ElementHelper.asMap("x", VertexProperty.Cardinality.list)))},
{DT.class, "x", new VariableResolverException("x"), createAntlr(VariableResolver.NoVariableResolver.instance())},
- {DT.class, "DT.hour", DT.hour, createAntlr(new VariableResolver.DefaultVariableResolver(ElementHelper.asMap("x", "nope")))},
- {DT.class, "hour", DT.hour, createAntlr(new VariableResolver.DefaultVariableResolver(ElementHelper.asMap("x", "nope")))},
- {DT.class, "x", DT.hour, createAntlr(new VariableResolver.DefaultVariableResolver(ElementHelper.asMap("x", DT.hour)))},
+ {DT.class, "DT.hour", DT.hour, createAntlr(new VariableResolver.DirectVariableResolver(ElementHelper.asMap("x", "nope")))},
+ {DT.class, "hour", DT.hour, createAntlr(new VariableResolver.DirectVariableResolver(ElementHelper.asMap("x", "nope")))},
+ {DT.class, "x", DT.hour, createAntlr(new VariableResolver.DirectVariableResolver(ElementHelper.asMap("x", DT.hour)))},
{Merge.class, "x", new VariableResolverException("x"), createAntlr(VariableResolver.NoVariableResolver.instance())},
- {Merge.class, "Merge.onMatch", Merge.onMatch, createAntlr(new VariableResolver.DefaultVariableResolver(ElementHelper.asMap("x", "nope")))},
- {Merge.class, "onMatch", Merge.onMatch, createAntlr(new VariableResolver.DefaultVariableResolver(ElementHelper.asMap("x", "nope")))},
- {Merge.class, "x", Merge.onMatch, createAntlr(new VariableResolver.DefaultVariableResolver(ElementHelper.asMap("x", Merge.onMatch)))},
+ {Merge.class, "Merge.onMatch", Merge.onMatch, createAntlr(new VariableResolver.DirectVariableResolver(ElementHelper.asMap("x", "nope")))},
+ {Merge.class, "onMatch", Merge.onMatch, createAntlr(new VariableResolver.DirectVariableResolver(ElementHelper.asMap("x", "nope")))},
+ {Merge.class, "x", Merge.onMatch, createAntlr(new VariableResolver.DirectVariableResolver(ElementHelper.asMap("x", Merge.onMatch)))},
{Pop.class, "x", new VariableResolverException("x"), createAntlr(VariableResolver.NoVariableResolver.instance())},
- {Pop.class, "Pop.last", Pop.last, createAntlr(new VariableResolver.DefaultVariableResolver(ElementHelper.asMap("x", "nope")))},
- {Pop.class, "last", Pop.last, createAntlr(new VariableResolver.DefaultVariableResolver(ElementHelper.asMap("x", "nope")))},
- {Pop.class, "x", Pop.last, createAntlr(new VariableResolver.DefaultVariableResolver(ElementHelper.asMap("x", Pop.last)))},
+ {Pop.class, "Pop.last", Pop.last, createAntlr(new VariableResolver.DirectVariableResolver(ElementHelper.asMap("x", "nope")))},
+ {Pop.class, "last", Pop.last, createAntlr(new VariableResolver.DirectVariableResolver(ElementHelper.asMap("x", "nope")))},
+ {Pop.class, "x", Pop.last, createAntlr(new VariableResolver.DirectVariableResolver(ElementHelper.asMap("x", Pop.last)))},
{Operator.class, "x", new VariableResolverException("x"), createAntlr(VariableResolver.NoVariableResolver.instance())},
- {Operator.class, "Operator.sum", Operator.sum, createAntlr(new VariableResolver.DefaultVariableResolver(ElementHelper.asMap("x", "nope")))},
- {Operator.class, "sum", Operator.sum, createAntlr(new VariableResolver.DefaultVariableResolver(ElementHelper.asMap("x", "nope")))},
- {Operator.class, "x", Operator.sum, createAntlr(new VariableResolver.DefaultVariableResolver(ElementHelper.asMap("x", Operator.sum)))},
+ {Operator.class, "Operator.sum", Operator.sum, createAntlr(new VariableResolver.DirectVariableResolver(ElementHelper.asMap("x", "nope")))},
+ {Operator.class, "sum", Operator.sum, createAntlr(new VariableResolver.DirectVariableResolver(ElementHelper.asMap("x", "nope")))},
+ {Operator.class, "x", Operator.sum, createAntlr(new VariableResolver.DirectVariableResolver(ElementHelper.asMap("x", Operator.sum)))},
{Column.class, "x", new VariableResolverException("x"), createAntlr(VariableResolver.NoVariableResolver.instance())},
- {Column.class, "Column.keys", Column.keys, createAntlr(new VariableResolver.DefaultVariableResolver(ElementHelper.asMap("x", "nope")))},
- {Column.class, "keys", Column.keys, createAntlr(new VariableResolver.DefaultVariableResolver(ElementHelper.asMap("x", "nope")))},
- {Column.class, "x", Column.keys, createAntlr(new VariableResolver.DefaultVariableResolver(ElementHelper.asMap("x", Column.keys)))},
+ {Column.class, "Column.keys", Column.keys, createAntlr(new VariableResolver.DirectVariableResolver(ElementHelper.asMap("x", "nope")))},
+ {Column.class, "keys", Column.keys, createAntlr(new VariableResolver.DirectVariableResolver(ElementHelper.asMap("x", "nope")))},
+ {Column.class, "x", Column.keys, createAntlr(new VariableResolver.DirectVariableResolver(ElementHelper.asMap("x", Column.keys)))},
{SackFunctions.Barrier.class, "x", new VariableResolverException("x"), createAntlr(VariableResolver.NoVariableResolver.instance())},
- {SackFunctions.Barrier.class, "Barrier.normSack", SackFunctions.Barrier.normSack, createAntlr(new VariableResolver.DefaultVariableResolver(ElementHelper.asMap("x", "nope")))},
- {SackFunctions.Barrier.class, "Barrier.normSack", SackFunctions.Barrier.normSack, createAntlr(new VariableResolver.DefaultVariableResolver(ElementHelper.asMap("x", "nope")))},
- {SackFunctions.Barrier.class, "x", SackFunctions.Barrier.normSack, createAntlr(new VariableResolver.DefaultVariableResolver(ElementHelper.asMap("x", SackFunctions.Barrier.normSack)))},
+ {SackFunctions.Barrier.class, "Barrier.normSack", SackFunctions.Barrier.normSack, createAntlr(new VariableResolver.DirectVariableResolver(ElementHelper.asMap("x", "nope")))},
+ {SackFunctions.Barrier.class, "Barrier.normSack", SackFunctions.Barrier.normSack, createAntlr(new VariableResolver.DirectVariableResolver(ElementHelper.asMap("x", "nope")))},
+ {SackFunctions.Barrier.class, "x", SackFunctions.Barrier.normSack, createAntlr(new VariableResolver.DirectVariableResolver(ElementHelper.asMap("x", SackFunctions.Barrier.normSack)))},
});
}
diff --git a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/language/grammar/GremlinQueryParserTest.java b/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/language/grammar/GremlinQueryParserTest.java
index 9b67393e66..8439e56878 100644
--- a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/language/grammar/GremlinQueryParserTest.java
+++ b/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/language/grammar/GremlinQueryParserTest.java
@@ -41,7 +41,7 @@ public class GremlinQueryParserTest {
public void shouldParseVariables() {
final GremlinAntlrToJava gremlinAntlrToJava = new GremlinAntlrToJava("g",
EmptyGraph.instance(), __::start, g,
- new VariableResolver.DefaultVariableResolver(ElementHelper.asMap("z", 50)));
+ new VariableResolver.DirectVariableResolver(ElementHelper.asMap("z", 50)));
final GraphTraversal<?, ?> t = (GraphTraversal<?, ?>) GremlinQueryParser.parse("g.V().has('name',gt(z))", gremlinAntlrToJava);
assertEquals(g.V().has("name", P.gt(50)).asAdmin().getBytecode(),
@@ -52,7 +52,7 @@ public class GremlinQueryParserTest {
public void shouldParseVariablesInVarargs() {
final GremlinAntlrToJava gremlinAntlrToJava = new GremlinAntlrToJava("g",
EmptyGraph.instance(), __::start, g,
- new VariableResolver.DefaultVariableResolver(ElementHelper.asMap("x", 100,
+ new VariableResolver.DirectVariableResolver(ElementHelper.asMap("x", 100,
"y", 200,
"z", 50)));
@@ -73,7 +73,7 @@ public class GremlinQueryParserTest {
public void shouldNotParseVariablesInList() {
final GremlinAntlrToJava gremlinAntlrToJava = new GremlinAntlrToJava("g",
EmptyGraph.instance(), __::start, g,
- new VariableResolver.DefaultVariableResolver(ElementHelper.asMap("x", 100,
+ new VariableResolver.DirectVariableResolver(ElementHelper.asMap("x", 100,
"y", 200,
"z", 50)));
GremlinQueryParser.parse("g.V([x, y, 300]).has('name',gt(z))", gremlinAntlrToJava);
@@ -83,7 +83,7 @@ public class GremlinQueryParserTest {
public void shouldNotParseVariablesWhichAreTraversalBased() {
final GremlinAntlrToJava gremlinAntlrToJava = new GremlinAntlrToJava("g",
EmptyGraph.instance(), __::start, g,
- new VariableResolver.DefaultVariableResolver(ElementHelper.asMap("x", 100,
+ new VariableResolver.DirectVariableResolver(ElementHelper.asMap("x", 100,
"y", 200,
"z", __.out())));
GremlinQueryParser.parse("g.V([x, y, 300]).where(z)", gremlinAntlrToJava);
diff --git a/tinkergraph-gremlin/src/test/java/org/apache/tinkerpop/gremlin/tinkergraph/structure/TinkerGraphPlayTest.java b/tinkergraph-gremlin/src/test/java/org/apache/tinkerpop/gremlin/tinkergraph/structure/TinkerGraphPlayTest.java
index 3560027d2f..e419553ba9 100644
--- a/tinkergraph-gremlin/src/test/java/org/apache/tinkerpop/gremlin/tinkergraph/structure/TinkerGraphPlayTest.java
+++ b/tinkergraph-gremlin/src/test/java/org/apache/tinkerpop/gremlin/tinkergraph/structure/TinkerGraphPlayTest.java
@@ -18,8 +18,10 @@
*/
package org.apache.tinkerpop.gremlin.tinkergraph.structure;
+import org.apache.tinkerpop.gremlin.jsr223.GremlinLangScriptEngine;
import org.apache.tinkerpop.gremlin.process.computer.Computer;
import org.apache.tinkerpop.gremlin.process.traversal.P;
+import org.apache.tinkerpop.gremlin.process.traversal.Scope;
import org.apache.tinkerpop.gremlin.process.traversal.Traversal;
import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal;
import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversalSource;
@@ -39,6 +41,7 @@ import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
+import javax.script.Bindings;
import java.util.Arrays;
import java.util.List;
import java.util.function.BiFunction;
@@ -273,17 +276,24 @@ public class TinkerGraphPlayTest {
}
@Test
- @Ignore
- public void testBugs() {
+ public void testBugs() throws Exception {
final GraphTraversalSource g = TinkerFactory.createModern().traversal();
- Object o1 = g.V().map(__.V(1));
- System.out.println(g.V().as("a").both().as("b").dedup("a", "b").by(T.label).select("a", "b").explain());
- System.out.println(g.V().as("a").both().as("b").dedup("a", "b").by(T.label).select("a", "b").toList());
-
- Traversal<?,?> t =
- g.V("3").
- union(__.repeat(out().simplePath()).times(2).count(),
- __.repeat(in().simplePath()).times(2).count());
+ final GremlinLangScriptEngine se = new GremlinLangScriptEngine();
+
+ final Bindings b = se.createBindings();
+ b.put("g", g);
+ System.out.println(((GraphTraversal) se.eval("g.V().coin(0.5).count()", b)).toList());
+
+ b.clear();
+ b.put("g", g);
+ b.put("x", 0.5d);
+ System.out.println(((GraphTraversal) se.eval("g.V().coin(x).count()", b)).toList());
+
+ b.clear();
+ b.put("g", g);
+ b.put("x", "josh");
+ b.put("y", 32);
+ System.out.println(((GraphTraversal) se.eval("g.V().has('name', x).has('age', y).count()", b)).toList());
}
@Test