[jira] [Commented] (TINKERPOP-2959) Allow the grammar to support parameters
[
https://issues.apache.org/jira/browse/TINKERPOP-2959?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=17732216#comment-17732216
]
ASF GitHub Bot commented on TINKERPOP-2959:
---
spmallette opened a new pull request, #2094:
URL: https://github.com/apache/tinkerpop/pull/2094
https://issues.apache.org/jira/browse/TINKERPOP-2959
This adds functionality similar to `GremlinGroovyScriptEngine` where
bindings can be applied to a script as in `g.V(x)` where `x` is a variable that
can be bound to a value external to the script. This functionality doesn't
offer any particular performance enhancement for the grammar the way that it
does for groovy but it does better allow one engine to be swapped for the other
which is crucial for a migration away from the groovy engine. This change also
opens up better opportunities for translator and gherkin improvements as well.
Purposefully did not add upgrade docs as I still don't think this
functionality is completely ready for general usage.
This is a fairly large diff because it essentially rewrites the core of the
antlr grammar and that force a rewrite of much of the parser. It might be best
to focus on what's being tested and to try to determine if anything further
should be tested in relation to this functionality.
Performance testing showed that somehow, these changes actually made the
parser a tiny bit faster. I basically ran all the Gremlin (minus a few
troublemakers) in the documentation (about 600 queries) through the parser
1 times. My runs with these changes tended to finish in about 65~ seconds
typically. Runs on `master` prior to these changes typically ran around 72~
seconds. Here's the script which I just pasted into Gremlin Console (if you
want to run be sure to replace `TINKERPOP_HOME_PATH` with the path to your
TinkerPop git repo home:
```groovy
import org.apache.tinkerpop.gremlin.language.corpus.*
g = TinkerGraph.open().traversal()
b = new javax.script.SimpleBindings()
b.put('g', g)
lang = new GremlinLangScriptEngine()
home = 'TINKERPOP_HOME_PATH'
gremlins = DocumentationReader.parse(home + '/docs/src'); []
gremlins = gremlins.findAll{ !it.contains("g.union") &&
!it.contains("coalesce(E") && !it.contains("eq(constant('josh'))") &&
!it.contains("xx") && !it.contains("branch") && !it.contains("program") &&
!it.contains("profile") && !it.contains("explain") &&
!it.contains("connectedComponent") && !it.contains("fill") &&
!it.contains("next") && !it.contains("toList") && !it.contains("iterate") &&
!it.contains("withComputer") && !it.contains("{") &&
!it.contains("withoutStrategies") };[]
start = System.currentTimeMillis()
gremlins.each { lang.eval(it, b);[] }
(0..1).each {
if (it % 10 == 9)
println "."
else
print "."
gremlins.each { lang.eval(it, b);[] }
}
end = System.currentTimeMillis() - start
```
VOTE +1
> Allow the grammar to support parameters
> ---
>
> Key: TINKERPOP-2959
> URL: https://issues.apache.org/jira/browse/TINKERPOP-2959
> Project: TinkerPop
> Issue Type: Improvement
> Components: language
>Affects Versions: 3.6.4
>Reporter: Stephen Mallette
>Priority: Major
>
> Allow the grammar to support parameters similar to how the groovy engine does
> like, {{g.inject(x,y,z)}}. Doing this will make it easier for a transition
> away from the groovy engine as a lot of Gremlin in the world today uses
> parameters. The grammar may have to come with some limitations though as
> groovy is wide open in terms of what can be treated as a variable. Probably
> going to keep parameters tied to primitives, collections and tokens/enums
> like {{Order}} and {{Scope}}. Collections themselves will not contain
> parameters and things like a {{Traversal}} or {{P}} cannot be treated as one.
--
This message was sent by Atlassian Jira
(v8.20.10#820010)
[jira] [Commented] (TINKERPOP-2959) Allow the grammar to support parameters
[
https://issues.apache.org/jira/browse/TINKERPOP-2959?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=17732220#comment-17732220
]
ASF GitHub Bot commented on TINKERPOP-2959:
---
codecov-commenter commented on PR #2094:
URL: https://github.com/apache/tinkerpop/pull/2094#issuecomment-1589864179
##
[Codecov](https://app.codecov.io/gh/apache/tinkerpop/pull/2094?src=pr&el=h1&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=apache)
Report
> Merging
[#2094](https://app.codecov.io/gh/apache/tinkerpop/pull/2094?src=pr&el=desc&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=apache)
(f08fac1) into
[master](https://app.codecov.io/gh/apache/tinkerpop/commit/6d55564560bb2210f78e8e0a0bea0e9ce41bd6a1?el=desc&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=apache)
(6d55564) will **decrease** coverage by `4.73%`.
> The diff coverage is `n/a`.
```diff
@@ Coverage Diff @@
## master#2094 +/- ##
- Coverage 74.82% 70.10% -4.73%
Files 1025 24-1001
Lines 62019 3532 -58487
Branches 68440-6844
- Hits 46404 2476 -43928
+ Misses13068 884 -12184
+ Partials 2547 172-2375
```
[see 998 files with indirect coverage
changes](https://app.codecov.io/gh/apache/tinkerpop/pull/2094/indirect-changes?src=pr&el=tree-more&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=apache)
:mega: We’re building smart automated test selection to slash your CI/CD
build times. [Learn
more](https://about.codecov.io/iterative-testing/?utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=apache)
> Allow the grammar to support parameters
> ---
>
> Key: TINKERPOP-2959
> URL: https://issues.apache.org/jira/browse/TINKERPOP-2959
> Project: TinkerPop
> Issue Type: Improvement
> Components: language
>Affects Versions: 3.6.4
>Reporter: Stephen Mallette
>Priority: Major
>
> Allow the grammar to support parameters similar to how the groovy engine does
> like, {{g.inject(x,y,z)}}. Doing this will make it easier for a transition
> away from the groovy engine as a lot of Gremlin in the world today uses
> parameters. The grammar may have to come with some limitations though as
> groovy is wide open in terms of what can be treated as a variable. Probably
> going to keep parameters tied to primitives, collections and tokens/enums
> like {{Order}} and {{Scope}}. Collections themselves will not contain
> parameters and things like a {{Traversal}} or {{P}} cannot be treated as one.
--
This message was sent by Atlassian Jira
(v8.20.10#820010)
[jira] [Commented] (TINKERPOP-2959) Allow the grammar to support parameters
[
https://issues.apache.org/jira/browse/TINKERPOP-2959?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=17733218#comment-17733218
]
ASF GitHub Bot commented on TINKERPOP-2959:
---
vkagamlyk commented on code in PR #2094:
URL: https://github.com/apache/tinkerpop/pull/2094#discussion_r1231504873
##
gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/language/grammar/ArgumentVisitor.java:
##
@@ -0,0 +1,420 @@
+/*
+ * 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.language.grammar;
+
+import org.apache.tinkerpop.gremlin.process.traversal.Merge;
+import org.apache.tinkerpop.gremlin.process.traversal.Operator;
+import org.apache.tinkerpop.gremlin.process.traversal.Order;
+import org.apache.tinkerpop.gremlin.process.traversal.Pop;
+import org.apache.tinkerpop.gremlin.process.traversal.SackFunctions;
+import org.apache.tinkerpop.gremlin.process.traversal.Scope;
+import org.apache.tinkerpop.gremlin.structure.Column;
+import org.apache.tinkerpop.gremlin.structure.Direction;
+import org.apache.tinkerpop.gremlin.structure.T;
+import org.apache.tinkerpop.gremlin.structure.Vertex;
+import org.apache.tinkerpop.gremlin.structure.VertexProperty;
+
+import java.lang.reflect.Array;
+import java.util.Collection;
+import java.util.Comparator;
+import java.util.Map;
+import java.util.function.Function;
+
+public class ArgumentVisitor extends DefaultGremlinBaseVisitor {
+
+private final VariableResolver resolver;
+
+private final GremlinAntlrToJava antlr;
+
+public ArgumentVisitor(final VariableResolver resolver, final
GremlinAntlrToJava antlr) {
+this.resolver = resolver;
+this.antlr = antlr;
+}
+
+/**
+ * Wrapper to visit function for boolean.
+ */
+public boolean parseBoolean(final GremlinParser.BooleanArgumentContext
ctx) {
+return (boolean) visitBooleanArgument(ctx);
+}
+
+/**
+ * Wrapper to visit function for integer types.
+ */
+public Number parseNumber(final GremlinParser.IntegerArgumentContext ctx) {
+return (Number) visitIntegerArgument(ctx);
+}
+
+/**
+ * Wrapper to visit function for float types.
+ */
+public Number parseNumber(final GremlinParser.FloatArgumentContext ctx) {
+return (Number) visitFloatArgument(ctx);
+}
+
+/**
+ * Wrapper to visit function for string types.
+ */
+public String parseString(final GremlinParser.StringArgumentContext ctx) {
+return (String) visitStringArgument(ctx);
+}
+
+/**
+ * Wrapper for visit function for object types.
+ */
+public Object parseObject(final
GremlinParser.GenericLiteralArgumentContext ctx) {
+return visitGenericLiteralArgument(ctx);
+}
+
+/**
+ * Wrapper for visit function for {@link Direction} types.
+ */
+public Direction parseDirection(final
GremlinParser.TraversalDirectionArgumentContext ctx) {
+return (Direction) visitTraversalDirectionArgument(ctx);
+}
+
+/**
+ * Wrapper for visit function for {@link Vertex} types.
+ */
+public Vertex parseVertex(final
GremlinParser.StructureVertexArgumentContext ctx) {
+return (Vertex) visitStructureVertexArgument(ctx);
+}
+
+/**
+ * Wrapper for visit function for {@link Order} types.
+ */
+public Order parseOrder(final GremlinParser.TraversalOrderArgumentContext
ctx) {
+return (Order) visitTraversalOrderArgument(ctx);
+}
+
+/**
+ * Wrapper for visit function for {@link Scope} types.
+ */
+public Scope parseScope(final GremlinParser.TraversalScopeArgumentContext
ctx) {
+return (Scope) visitTraversalScopeArgument(ctx);
+}
+
+/**
+ * Wrapper for visit function for {@link T} types.
+ */
+public T parseT(final GremlinParser.TraversalTokenArgumentContext ctx) {
+return (T) visitTraversalTokenArgument(ctx);
+}
+
+/**
+ * Wrapper for visit function for {@link VertexProperty.Cardinality} types.
+ */
+public VertexProperty.Cardinality parseCardinality(final
GremlinParser.TraversalCardinalityArgumentContext
[jira] [Commented] (TINKERPOP-2959) Allow the grammar to support parameters
[
https://issues.apache.org/jira/browse/TINKERPOP-2959?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=17733233#comment-17733233
]
ASF GitHub Bot commented on TINKERPOP-2959:
---
xiazcy commented on PR #2094:
URL: https://github.com/apache/tinkerpop/pull/2094#issuecomment-1593701729
This feature definitely opens up improvement opportunties. I'm not too
familiar with many of the technical details, but on a high level the change
looks good. I also like how the grammar variables are more intuitive now. VOTE
+1
> Allow the grammar to support parameters
> ---
>
> Key: TINKERPOP-2959
> URL: https://issues.apache.org/jira/browse/TINKERPOP-2959
> Project: TinkerPop
> Issue Type: Improvement
> Components: language
>Affects Versions: 3.6.4
>Reporter: Stephen Mallette
>Priority: Major
>
> Allow the grammar to support parameters similar to how the groovy engine does
> like, {{g.inject(x,y,z)}}. Doing this will make it easier for a transition
> away from the groovy engine as a lot of Gremlin in the world today uses
> parameters. The grammar may have to come with some limitations though as
> groovy is wide open in terms of what can be treated as a variable. Probably
> going to keep parameters tied to primitives, collections and tokens/enums
> like {{Order}} and {{Scope}}. Collections themselves will not contain
> parameters and things like a {{Traversal}} or {{P}} cannot be treated as one.
--
This message was sent by Atlassian Jira
(v8.20.10#820010)
[jira] [Commented] (TINKERPOP-2959) Allow the grammar to support parameters
[
https://issues.apache.org/jira/browse/TINKERPOP-2959?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=17733238#comment-17733238
]
ASF GitHub Bot commented on TINKERPOP-2959:
---
vkagamlyk commented on code in PR #2094:
URL: https://github.com/apache/tinkerpop/pull/2094#discussion_r1231535172
##
gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/language/grammar/ArgumentVisitorTest.java:
##
@@ -0,0 +1,260 @@
+/*
+ * 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.language.grammar;
+
+import org.antlr.v4.runtime.CharStreams;
+import org.antlr.v4.runtime.CommonTokenStream;
+import org.apache.tinkerpop.gremlin.process.traversal.IO;
+import org.apache.tinkerpop.gremlin.process.traversal.Merge;
+import org.apache.tinkerpop.gremlin.process.traversal.Operator;
+import org.apache.tinkerpop.gremlin.process.traversal.Order;
+import org.apache.tinkerpop.gremlin.process.traversal.P;
+import org.apache.tinkerpop.gremlin.process.traversal.Pop;
+import org.apache.tinkerpop.gremlin.process.traversal.SackFunctions;
+import org.apache.tinkerpop.gremlin.process.traversal.Scope;
+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.Column;
+import org.apache.tinkerpop.gremlin.structure.Direction;
+import org.apache.tinkerpop.gremlin.structure.T;
+import org.apache.tinkerpop.gremlin.structure.Vertex;
+import org.apache.tinkerpop.gremlin.structure.VertexProperty;
+import org.apache.tinkerpop.gremlin.structure.util.ElementHelper;
+import org.apache.tinkerpop.gremlin.structure.util.empty.EmptyGraph;
+import org.apache.tinkerpop.gremlin.structure.util.reference.ReferenceVertex;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+import java.util.Arrays;
+import java.util.Date;
+import java.util.List;
+import java.util.function.Supplier;
+
+import static
org.apache.tinkerpop.gremlin.process.traversal.AnonymousTraversalSource.traversal;
+import static org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__.has;
+import static
org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__.hasLabel;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.core.IsInstanceOf.instanceOf;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.fail;
+
+@RunWith(Parameterized.class)
+public class ArgumentVisitorTest {
+@Parameterized.Parameter(value = 0)
+public Class clazz;
+
+@Parameterized.Parameter(value = 1)
+public String script;
+
+@Parameterized.Parameter(value = 2)
+public Object expected;
+
+@Parameterized.Parameter(value = 3)
+public GremlinAntlrToJava antlrToLanguage;
+
+private static final GraphTraversalSource g =
EmptyGraph.instance().traversal();
+
+private static final Date now = new Date();
+
+@Parameterized.Parameters(name = "{0}")
+public static Iterable 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)))},
+{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
[jira] [Commented] (TINKERPOP-2959) Allow the grammar to support parameters
[
https://issues.apache.org/jira/browse/TINKERPOP-2959?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=17733251#comment-17733251
]
ASF GitHub Bot commented on TINKERPOP-2959:
---
Cole-Greer commented on code in PR #2094:
URL: https://github.com/apache/tinkerpop/pull/2094#discussion_r1231588579
##
gremlin-language/src/main/antlr4/Gremlin.g4:
##
@@ -1403,7 +1521,7 @@ genericLiteralMap
| LBRACK mapEntry (COMMA mapEntry)* RBRACK
;
-// allow builds of Map that sorta make sense in the Gremlin context
+// allow builds of Map that sorta make sense in the Gremlin context.
mapEntry
: NEW COLON genericLiteral // explicit for [new: true] - if we had other
keywords like that maybe we'd group them up?
| (LPAREN stringLiteral RPAREN | stringLiteral) COLON genericLiteral
Review Comment:
I believe that for each of these, the value part of the mapEntry should be a
`genericLiteralArgument` instead of just a `genericLiteral`. Just checked in
console and groovy allows passing variables as the value in maps.
> Allow the grammar to support parameters
> ---
>
> Key: TINKERPOP-2959
> URL: https://issues.apache.org/jira/browse/TINKERPOP-2959
> Project: TinkerPop
> Issue Type: Improvement
> Components: language
>Affects Versions: 3.6.4
>Reporter: Stephen Mallette
>Priority: Major
>
> Allow the grammar to support parameters similar to how the groovy engine does
> like, {{g.inject(x,y,z)}}. Doing this will make it easier for a transition
> away from the groovy engine as a lot of Gremlin in the world today uses
> parameters. The grammar may have to come with some limitations though as
> groovy is wide open in terms of what can be treated as a variable. Probably
> going to keep parameters tied to primitives, collections and tokens/enums
> like {{Order}} and {{Scope}}. Collections themselves will not contain
> parameters and things like a {{Traversal}} or {{P}} cannot be treated as one.
--
This message was sent by Atlassian Jira
(v8.20.10#820010)
[jira] [Commented] (TINKERPOP-2959) Allow the grammar to support parameters
[
https://issues.apache.org/jira/browse/TINKERPOP-2959?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=17733253#comment-17733253
]
ASF GitHub Bot commented on TINKERPOP-2959:
---
Cole-Greer commented on PR #2094:
URL: https://github.com/apache/tinkerpop/pull/2094#issuecomment-1593795756
Thanks for putting this all together Stephen. I'm a big fan of anything
which reduces the gap between gremlin-lang and gremlin-groovy. This is a bit
out of my wheelhouse but I took a good look through the new grammar and tests.
Other than the one question I posted above about mapEntry, it all looks good to
me.
> Allow the grammar to support parameters
> ---
>
> Key: TINKERPOP-2959
> URL: https://issues.apache.org/jira/browse/TINKERPOP-2959
> Project: TinkerPop
> Issue Type: Improvement
> Components: language
>Affects Versions: 3.6.4
>Reporter: Stephen Mallette
>Priority: Major
>
> Allow the grammar to support parameters similar to how the groovy engine does
> like, {{g.inject(x,y,z)}}. Doing this will make it easier for a transition
> away from the groovy engine as a lot of Gremlin in the world today uses
> parameters. The grammar may have to come with some limitations though as
> groovy is wide open in terms of what can be treated as a variable. Probably
> going to keep parameters tied to primitives, collections and tokens/enums
> like {{Order}} and {{Scope}}. Collections themselves will not contain
> parameters and things like a {{Traversal}} or {{P}} cannot be treated as one.
--
This message was sent by Atlassian Jira
(v8.20.10#820010)
[jira] [Commented] (TINKERPOP-2959) Allow the grammar to support parameters
[
https://issues.apache.org/jira/browse/TINKERPOP-2959?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=17733495#comment-17733495
]
ASF GitHub Bot commented on TINKERPOP-2959:
---
spmallette commented on code in PR #2094:
URL: https://github.com/apache/tinkerpop/pull/2094#discussion_r1232213927
##
gremlin-language/src/main/antlr4/Gremlin.g4:
##
@@ -1403,7 +1521,7 @@ genericLiteralMap
| LBRACK mapEntry (COMMA mapEntry)* RBRACK
;
-// allow builds of Map that sorta make sense in the Gremlin context
+// allow builds of Map that sorta make sense in the Gremlin context.
mapEntry
: NEW COLON genericLiteral // explicit for [new: true] - if we had other
keywords like that maybe we'd group them up?
| (LPAREN stringLiteral RPAREN | stringLiteral) COLON genericLiteral
Review Comment:
ehhh - i purposefully didn't allow that. if you want a variable in a `Map`
for the grammar then you gotta do the whole `Map`. if we hate that in the
future we can always open that up i guess.
> Allow the grammar to support parameters
> ---
>
> Key: TINKERPOP-2959
> URL: https://issues.apache.org/jira/browse/TINKERPOP-2959
> Project: TinkerPop
> Issue Type: Improvement
> Components: language
>Affects Versions: 3.6.4
>Reporter: Stephen Mallette
>Priority: Major
>
> Allow the grammar to support parameters similar to how the groovy engine does
> like, {{g.inject(x,y,z)}}. Doing this will make it easier for a transition
> away from the groovy engine as a lot of Gremlin in the world today uses
> parameters. The grammar may have to come with some limitations though as
> groovy is wide open in terms of what can be treated as a variable. Probably
> going to keep parameters tied to primitives, collections and tokens/enums
> like {{Order}} and {{Scope}}. Collections themselves will not contain
> parameters and things like a {{Traversal}} or {{P}} cannot be treated as one.
--
This message was sent by Atlassian Jira
(v8.20.10#820010)
[jira] [Commented] (TINKERPOP-2959) Allow the grammar to support parameters
[
https://issues.apache.org/jira/browse/TINKERPOP-2959?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=17733514#comment-17733514
]
ASF GitHub Bot commented on TINKERPOP-2959:
---
spmallette commented on PR #2094:
URL: https://github.com/apache/tinkerpop/pull/2094#issuecomment-1594707500
@vkagamlyk addressed your comments and pushed a new version
> Allow the grammar to support parameters
> ---
>
> Key: TINKERPOP-2959
> URL: https://issues.apache.org/jira/browse/TINKERPOP-2959
> Project: TinkerPop
> Issue Type: Improvement
> Components: language
>Affects Versions: 3.6.4
>Reporter: Stephen Mallette
>Priority: Major
>
> Allow the grammar to support parameters similar to how the groovy engine does
> like, {{g.inject(x,y,z)}}. Doing this will make it easier for a transition
> away from the groovy engine as a lot of Gremlin in the world today uses
> parameters. The grammar may have to come with some limitations though as
> groovy is wide open in terms of what can be treated as a variable. Probably
> going to keep parameters tied to primitives, collections and tokens/enums
> like {{Order}} and {{Scope}}. Collections themselves will not contain
> parameters and things like a {{Traversal}} or {{P}} cannot be treated as one.
--
This message was sent by Atlassian Jira
(v8.20.10#820010)
[jira] [Commented] (TINKERPOP-2959) Allow the grammar to support parameters
[
https://issues.apache.org/jira/browse/TINKERPOP-2959?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=17733554#comment-17733554
]
ASF GitHub Bot commented on TINKERPOP-2959:
---
vkagamlyk commented on PR #2094:
URL: https://github.com/apache/tinkerpop/pull/2094#issuecomment-1594866325
> @vkagamlyk addressed your comments and pushed a new version
Thank you!
VOTE +1
> Allow the grammar to support parameters
> ---
>
> Key: TINKERPOP-2959
> URL: https://issues.apache.org/jira/browse/TINKERPOP-2959
> Project: TinkerPop
> Issue Type: Improvement
> Components: language
>Affects Versions: 3.6.4
>Reporter: Stephen Mallette
>Priority: Major
>
> Allow the grammar to support parameters similar to how the groovy engine does
> like, {{g.inject(x,y,z)}}. Doing this will make it easier for a transition
> away from the groovy engine as a lot of Gremlin in the world today uses
> parameters. The grammar may have to come with some limitations though as
> groovy is wide open in terms of what can be treated as a variable. Probably
> going to keep parameters tied to primitives, collections and tokens/enums
> like {{Order}} and {{Scope}}. Collections themselves will not contain
> parameters and things like a {{Traversal}} or {{P}} cannot be treated as one.
--
This message was sent by Atlassian Jira
(v8.20.10#820010)
[jira] [Commented] (TINKERPOP-2959) Allow the grammar to support parameters
[
https://issues.apache.org/jira/browse/TINKERPOP-2959?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=17733592#comment-17733592
]
ASF GitHub Bot commented on TINKERPOP-2959:
---
Cole-Greer commented on PR #2094:
URL: https://github.com/apache/tinkerpop/pull/2094#issuecomment-1594952371
LGTM VOTE +1
> Allow the grammar to support parameters
> ---
>
> Key: TINKERPOP-2959
> URL: https://issues.apache.org/jira/browse/TINKERPOP-2959
> Project: TinkerPop
> Issue Type: Improvement
> Components: language
>Affects Versions: 3.6.4
>Reporter: Stephen Mallette
>Priority: Major
>
> Allow the grammar to support parameters similar to how the groovy engine does
> like, {{g.inject(x,y,z)}}. Doing this will make it easier for a transition
> away from the groovy engine as a lot of Gremlin in the world today uses
> parameters. The grammar may have to come with some limitations though as
> groovy is wide open in terms of what can be treated as a variable. Probably
> going to keep parameters tied to primitives, collections and tokens/enums
> like {{Order}} and {{Scope}}. Collections themselves will not contain
> parameters and things like a {{Traversal}} or {{P}} cannot be treated as one.
--
This message was sent by Atlassian Jira
(v8.20.10#820010)
[jira] [Commented] (TINKERPOP-2959) Allow the grammar to support parameters
[
https://issues.apache.org/jira/browse/TINKERPOP-2959?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=17733616#comment-17733616
]
ASF GitHub Bot commented on TINKERPOP-2959:
---
spmallette merged PR #2094:
URL: https://github.com/apache/tinkerpop/pull/2094
> Allow the grammar to support parameters
> ---
>
> Key: TINKERPOP-2959
> URL: https://issues.apache.org/jira/browse/TINKERPOP-2959
> Project: TinkerPop
> Issue Type: Improvement
> Components: language
>Affects Versions: 3.6.4
>Reporter: Stephen Mallette
>Priority: Major
>
> Allow the grammar to support parameters similar to how the groovy engine does
> like, {{g.inject(x,y,z)}}. Doing this will make it easier for a transition
> away from the groovy engine as a lot of Gremlin in the world today uses
> parameters. The grammar may have to come with some limitations though as
> groovy is wide open in terms of what can be treated as a variable. Probably
> going to keep parameters tied to primitives, collections and tokens/enums
> like {{Order}} and {{Scope}}. Collections themselves will not contain
> parameters and things like a {{Traversal}} or {{P}} cannot be treated as one.
--
This message was sent by Atlassian Jira
(v8.20.10#820010)
