This is an automated email from the ASF dual-hosted git repository.
Cole-Greer pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/tinkerpop.git
The following commit(s) were added to refs/heads/master by this push:
new 7ab1be1278 Fix gremlin-go/dotnet P.outside() and gremlin-go negative
BigInteger (#3522)
7ab1be1278 is described below
commit 7ab1be1278ab5f7e9fd9216cd9ab050ae46e23bb
Author: Guian Gumpac <[email protected]>
AuthorDate: Mon Jul 20 10:26:25 2026 -0700
Fix gremlin-go/dotnet P.outside() and gremlin-go negative BigInteger (#3522)
Assisted-by: Kiro: Claude Opus 4.8
---
CHANGELOG.asciidoc | 2 +
.../Gremlin.Net/Process/Traversal/GremlinLang.cs | 2 +-
.../Gremlin.Net.IntegrationTest/Gherkin/Gremlin.cs | 6 ++
.../Process/Traversal/GremlinLangTests.cs | 21 ++++++
gremlin-go/driver/cucumber/gremlin.go | 3 +
gremlin-go/driver/graphBinaryDeserializer.go | 4 +-
gremlin-go/driver/graphBinarySerializer_test.go | 23 +++++++
gremlin-go/driver/gremlinlang.go | 5 +-
gremlin-go/driver/gremlinlang_test.go | 12 ++++
.../gremlin-javascript/test/cucumber/gremlin.js | 3 +
.../src/main/python/tests/feature/gremlin.py | 3 +
.../gremlin/language/translator/translations.json | 75 ++++++++++++++++++++++
.../gremlin/test/features/data/BigDecimal.feature | 15 +++++
.../gremlin/test/features/data/BigInt.feature | 15 +++++
.../gremlin/test/features/filter/Is.feature | 12 ++++
15 files changed, 196 insertions(+), 5 deletions(-)
diff --git a/CHANGELOG.asciidoc b/CHANGELOG.asciidoc
index e17a9c506e..3dbf8bf53c 100644
--- a/CHANGELOG.asciidoc
+++ b/CHANGELOG.asciidoc
@@ -27,6 +27,8 @@
image::https://raw.githubusercontent.com/apache/tinkerpop/master/docs/static/ima
* Fixed `gremlin-python` `GremlinLang` equality (`__eq__`) which compared a
traversal to itself, so traversals with different steps but equal parameters
were incorrectly considered equal.
* Removed the deprecated `gremlin-python` `DriverRemoteConnection.submitAsync`
method in favor of `submit_async`.
+* Fixed `gremlin-go` GraphBinary deserialization of negative `BigInteger` and
negative-unscaled `BigDecimal` values, which decoded to incorrect values
because the two's-complement width was computed one byte too wide.
+* Fixed `gremlin-go` and `gremlin-dotnet` `P.outside()` gremlin-lang
generation to emit comma-separated arguments (`outside(a,b)`) like
`between`/`inside`, instead of the invalid list-wrapped form (`outside([a,b])`)
that the server could not parse.
* Added GraphBinary `Tree` (`0x2b`) serialization and deserialization with a
native tree-shaped API to `gremlin-python`, `gremlin-dotnet`, `gremlin-go`, and
`gremlin-javascript`.
* Added a `gremlin/io` package export in `gremlin-javascript` exposing the
GraphBinary type serializers.
* Raised the minimum Java version to 17 for building and running *(breaking)*.
diff --git a/gremlin-dotnet/src/Gremlin.Net/Process/Traversal/GremlinLang.cs
b/gremlin-dotnet/src/Gremlin.Net/Process/Traversal/GremlinLang.cs
index 661004fd46..1c78bdf77e 100644
--- a/gremlin-dotnet/src/Gremlin.Net/Process/Traversal/GremlinLang.cs
+++ b/gremlin-dotnet/src/Gremlin.Net/Process/Traversal/GremlinLang.cs
@@ -459,7 +459,7 @@ namespace Gremlin.Net.Process.Traversal
// For predicates like between/inside, the value is an
object[] with 2 elements
if (p.Value is object[] valArr)
{
- if (valArr.Length > 1 && p.OperatorName != "between" &&
p.OperatorName != "inside")
+ if (valArr.Length > 1 && p.OperatorName != "between" &&
p.OperatorName != "inside" && p.OperatorName != "outside")
{
sb.Append('[');
for (int i = 0; i < valArr.Length; i++)
diff --git a/gremlin-dotnet/test/Gremlin.Net.IntegrationTest/Gherkin/Gremlin.cs
b/gremlin-dotnet/test/Gremlin.Net.IntegrationTest/Gherkin/Gremlin.cs
index 9bb1aa80ac..4530230285 100644
--- a/gremlin-dotnet/test/Gremlin.Net.IntegrationTest/Gherkin/Gremlin.cs
+++ b/gremlin-dotnet/test/Gremlin.Net.IntegrationTest/Gherkin/Gremlin.cs
@@ -229,6 +229,7 @@ namespace Gremlin.Net.IntegrationTest.Gherkin
{"g_unionXaddVXpersonX_propertyXname_aliceX_addVXpersonX_propertyXname_bobX_addVXpersonX_propertyXname_chrisX_name",
new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>>
{(g,p) =>g.Union<object>(__.AddV((string) "person").Property("name", "alice"),
__.AddV((string) "person").Property("name", "bob"), __.AddV((string)
"person").Property("name", "chris")).Values<object>("name")}},
{"g_VX_hasLabelXpersonX_unionX_whereX_out_count_isXgtX2XXX_valuesXageX_notX_whereX_bothE_count_isXgt2XXX_valusXnameXX",
new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>>
{(g,p)
=>g.V().HasLabel("person").Union<object>(__.Where(__.OutE().Count().Is(P.Gt(2))).Values<object>("age"),
__.Not(__.Where(__.OutE().Count().Is(P.Gt(2)))).Values<object>("name"))}},
{"g_V_valuesXintX_asNumberXGType_BIGDECIMALX_isXtypeOfXGType_BIGDECIMALXX", new
List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>>
{(g,p) =>g.AddV((string) "data").Property("int", 123), (g,p)
=>g.V().Values<object>("int").AsNumber(GType.BigDecimal).Is(P.TypeOf(GType.BigDecimal))}},
+
{"g_V_valuesXintX_asNumberXGType_BIGDECIMALX_negative_isXtypeOfXGType_BIGDECIMALXX",
new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>>
{(g,p) =>g.AddV((string) "data").Property("int", -456), (g,p)
=>g.V().Values<object>("int").AsNumber(GType.BigDecimal).Is(P.TypeOf(GType.BigDecimal))}},
{"g_V_valuesXintX_asNumberXGType_BIGDECIMALX_isXtypeOfXGType_BIGDECIMALXX_mathXaddX0_5XX",
new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>>
{(g,p) =>g.AddV((string) "data").Property("int", 10), (g,p)
=>g.V().Values<object>("int").AsNumber(GType.BigDecimal).Is(P.TypeOf(GType.BigDecimal)).Math("_
+ 0.5")}},
{"g_V_valuesXintX_asNumberXGType_BIGDECIMALX_isXtypeOfXGType_BIGDECIMALXX_isXgtX0XX",
new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>>
{(g,p) =>g.AddV((string) "data").Property("int", 5), (g,p)
=>g.V().Values<object>("int").AsNumber(GType.BigDecimal).Is(P.TypeOf(GType.BigDecimal)).Is(P.Gt(0))}},
{"g_V_valuesXintX_asNumberXGType_BIGDECIMALX_isXtypeOfXGType_BIGDECIMALXX_sumX",
new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>>
{(g,p) =>g.AddV((string) "data").Property("int", 2).AddV((string)
"data").Property("int", 3).AddV((string) "data").Property("int", 4), (g,p)
=>g.V().Values<object>("int").AsNumber(GType.BigDecimal).Is(P.TypeOf(GType.BigDecimal)).Sum<object>()}},
@@ -238,6 +239,7 @@ namespace Gremlin.Net.IntegrationTest.Gherkin
{"g_injectX99X_asNumberXGType_BIGDECIMALX_isXtypeOfXGType_BIGDECIMALXX_groupCount",
new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>>
{(g,p)
=>g.Inject<object>(99).AsNumber(GType.BigDecimal).Is(P.TypeOf(GType.BigDecimal)).GroupCount<object>()}},
{"g_V_valuesXageX_isXtypeOfXGType_BIGDECIMALXX", new
List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>>
{(g,p) =>g.V().Values<object>("age").Is(P.TypeOf(GType.BigDecimal))}},
{"g_V_valuesXintX_asNumberXGType_BIGINTX_isXtypeOfXGType_BIGINTXX", new
List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>>
{(g,p) =>g.AddV((string) "data").Property("int", 456), (g,p)
=>g.V().Values<object>("int").AsNumber(GType.BigInt).Is(P.TypeOf(GType.BigInt))}},
+
{"g_V_valuesXintX_asNumberXGType_BIGINTX_negative_isXtypeOfXGType_BIGINTXX",
new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>>
{(g,p) =>g.AddV((string) "data").Property("int", -456), (g,p)
=>g.V().Values<object>("int").AsNumber(GType.BigInt).Is(P.TypeOf(GType.BigInt))}},
{"g_V_valuesXintX_asNumberXGType_BIGINTX_isXtypeOfXGType_BIGINTXX_mathXmulX1000XX",
new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>>
{(g,p) =>g.AddV((string) "data").Property("int", 100), (g,p)
=>g.V().Values<object>("int").AsNumber(GType.BigInt).Is(P.TypeOf(GType.BigInt)).Math("_
* 1000")}},
{"g_V_valuesXintX_asNumberXGType_BIGINTX_isXtypeOfXGType_BIGINTXX_isXeqX42XX",
new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>>
{(g,p) =>g.AddV((string) "data").Property("int", 42), (g,p)
=>g.V().Values<object>("int").AsNumber(GType.BigInt).Is(P.TypeOf(GType.BigInt)).Is(P.Eq(42))}},
{"g_V_valuesXintX_asNumberXGType_BIGINTX_isXtypeOfXGType_BIGINTXX_sumX", new
List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>>
{(g,p) =>g.AddV((string) "data").Property("int", 10).AddV((string)
"data").Property("int", 20).AddV((string) "data").Property("int", 30), (g,p)
=>g.V().Values<object>("int").AsNumber(GType.BigInt).Is(P.TypeOf(GType.BigInt)).Sum<object>()}},
@@ -598,6 +600,7 @@ namespace Gremlin.Net.IntegrationTest.Gherkin
{"g_V_valuesXageX_isX32varX", new
List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>>
{(g,p) =>g.V().Values<object>("age").Is(p["xx1"])}},
{"g_V_valuesXageX_isXlte_30X", new
List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>>
{(g,p) =>g.V().Values<object>("age").Is(P.Lte(30))}},
{"g_V_valuesXageX_isXlte_30varX", new
List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>>
{(g,p) =>g.V().Values<object>("age").Is(P.Lte(p["xx1"]))}},
+ {"g_V_valuesXageX_isXoutsideX28_33XX", new
List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>>
{(g,p) =>g.V().Values<object>("age").Is(P.Outside(28, 33))}},
{"g_V_valuesXageX_isXgte_29X_isXlt_34X", new
List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>>
{(g,p) =>g.V().Values<object>("age").Is(P.Gte(29)).Is(P.Lt(34))}},
{"g_V_valuesXageX_isXgte_29vaarX_isXlt_34varX", new
List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>>
{(g,p) =>g.V().Values<object>("age").Is(P.Gte(p["xx1"])).Is(P.Lt(p["xx2"]))}},
{"g_V_whereXinXcreatedX_count_isX1XX_valuesXnameX", new
List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>>
{(g,p) =>g.V().Where(__.In("created").Count().Is(1)).Values<object>("name")}},
@@ -2580,6 +2583,7 @@ namespace Gremlin.Net.IntegrationTest.Gherkin
{"g_unionXaddVXpersonX_propertyXname_aliceX_addVXpersonX_propertyXname_bobX_addVXpersonX_propertyXname_chrisX_name",
new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>>
{(g,p) =>g.Union<object>(__.AddV((string) "person").Property("name", "alice"),
__.AddV((string) "person").Property("name", "bob"), __.AddV((string)
"person").Property("name", "chris")).Values<object>("name")}},
{"g_VX_hasLabelXpersonX_unionX_whereX_out_count_isXgtX2XXX_valuesXageX_notX_whereX_bothE_count_isXgt2XXX_valusXnameXX",
new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>>
{(g,p)
=>g.V().HasLabel("person").Union<object>(__.Where(__.OutE().Count().Is(P.Gt(2))).Values<object>("age"),
__.Not(__.Where(__.OutE().Count().Is(P.Gt(2)))).Values<object>("name"))}},
{"g_V_valuesXintX_asNumberXGType_BIGDECIMALX_isXtypeOfXGType_BIGDECIMALXX", new
List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>>
{(g,p) =>g.AddV((string) "data").Property("int", 123), (g,p)
=>g.V().Values<object>("int").AsNumber(GType.BigDecimal).Is(P.TypeOf(GType.BigDecimal))}},
+
{"g_V_valuesXintX_asNumberXGType_BIGDECIMALX_negative_isXtypeOfXGType_BIGDECIMALXX",
new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>>
{(g,p) =>g.AddV((string) "data").Property("int", -456), (g,p)
=>g.V().Values<object>("int").AsNumber(GType.BigDecimal).Is(P.TypeOf(GType.BigDecimal))}},
{"g_V_valuesXintX_asNumberXGType_BIGDECIMALX_isXtypeOfXGType_BIGDECIMALXX_mathXaddX0_5XX",
new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>>
{(g,p) =>g.AddV((string) "data").Property("int", 10), (g,p)
=>g.V().Values<object>("int").AsNumber(GType.BigDecimal).Is(P.TypeOf(GType.BigDecimal)).Math("_
+ 0.5")}},
{"g_V_valuesXintX_asNumberXGType_BIGDECIMALX_isXtypeOfXGType_BIGDECIMALXX_isXgtX0XX",
new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>>
{(g,p) =>g.AddV((string) "data").Property("int", 5), (g,p)
=>g.V().Values<object>("int").AsNumber(GType.BigDecimal).Is(P.TypeOf(GType.BigDecimal)).Is(P.Gt(0))}},
{"g_V_valuesXintX_asNumberXGType_BIGDECIMALX_isXtypeOfXGType_BIGDECIMALXX_sumX",
new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>>
{(g,p) =>g.AddV((string) "data").Property("int", 2).AddV((string)
"data").Property("int", 3).AddV((string) "data").Property("int", 4), (g,p)
=>g.V().Values<object>("int").AsNumber(GType.BigDecimal).Is(P.TypeOf(GType.BigDecimal)).Sum<object>()}},
@@ -2589,6 +2593,7 @@ namespace Gremlin.Net.IntegrationTest.Gherkin
{"g_injectX99X_asNumberXGType_BIGDECIMALX_isXtypeOfXGType_BIGDECIMALXX_groupCount",
new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>>
{(g,p)
=>g.Inject<object>(99).AsNumber(GType.BigDecimal).Is(P.TypeOf(GType.BigDecimal)).GroupCount<object>()}},
{"g_V_valuesXageX_isXtypeOfXGType_BIGDECIMALXX", new
List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>>
{(g,p) =>g.V().Values<object>("age").Is(P.TypeOf(GType.BigDecimal))}},
{"g_V_valuesXintX_asNumberXGType_BIGINTX_isXtypeOfXGType_BIGINTXX", new
List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>>
{(g,p) =>g.AddV((string) "data").Property("int", 456), (g,p)
=>g.V().Values<object>("int").AsNumber(GType.BigInt).Is(P.TypeOf(GType.BigInt))}},
+
{"g_V_valuesXintX_asNumberXGType_BIGINTX_negative_isXtypeOfXGType_BIGINTXX",
new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>>
{(g,p) =>g.AddV((string) "data").Property("int", -456), (g,p)
=>g.V().Values<object>("int").AsNumber(GType.BigInt).Is(P.TypeOf(GType.BigInt))}},
{"g_V_valuesXintX_asNumberXGType_BIGINTX_isXtypeOfXGType_BIGINTXX_mathXmulX1000XX",
new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>>
{(g,p) =>g.AddV((string) "data").Property("int", 100), (g,p)
=>g.V().Values<object>("int").AsNumber(GType.BigInt).Is(P.TypeOf(GType.BigInt)).Math("_
* 1000")}},
{"g_V_valuesXintX_asNumberXGType_BIGINTX_isXtypeOfXGType_BIGINTXX_isXeqX42XX",
new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>>
{(g,p) =>g.AddV((string) "data").Property("int", 42), (g,p)
=>g.V().Values<object>("int").AsNumber(GType.BigInt).Is(P.TypeOf(GType.BigInt)).Is(P.Eq(42))}},
{"g_V_valuesXintX_asNumberXGType_BIGINTX_isXtypeOfXGType_BIGINTXX_sumX", new
List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>>
{(g,p) =>g.AddV((string) "data").Property("int", 10).AddV((string)
"data").Property("int", 20).AddV((string) "data").Property("int", 30), (g,p)
=>g.V().Values<object>("int").AsNumber(GType.BigInt).Is(P.TypeOf(GType.BigInt)).Sum<object>()}},
@@ -2949,6 +2954,7 @@ namespace Gremlin.Net.IntegrationTest.Gherkin
{"g_V_valuesXageX_isX32varX", new
List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>>
{(g,p) =>g.V().Values<object>("age").Is(p["xx1"])}},
{"g_V_valuesXageX_isXlte_30X", new
List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>>
{(g,p) =>g.V().Values<object>("age").Is(P.Lte(30))}},
{"g_V_valuesXageX_isXlte_30varX", new
List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>>
{(g,p) =>g.V().Values<object>("age").Is(P.Lte(p["xx1"]))}},
+ {"g_V_valuesXageX_isXoutsideX28_33XX", new
List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>>
{(g,p) =>g.V().Values<object>("age").Is(P.Outside(28, 33))}},
{"g_V_valuesXageX_isXgte_29X_isXlt_34X", new
List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>>
{(g,p) =>g.V().Values<object>("age").Is(P.Gte(29)).Is(P.Lt(34))}},
{"g_V_valuesXageX_isXgte_29vaarX_isXlt_34varX", new
List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>>
{(g,p) =>g.V().Values<object>("age").Is(P.Gte(p["xx1"])).Is(P.Lt(p["xx2"]))}},
{"g_V_whereXinXcreatedX_count_isX1XX_valuesXnameX", new
List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>>
{(g,p) =>g.V().Where(__.In("created").Count().Is(1)).Values<object>("name")}},
diff --git
a/gremlin-dotnet/test/Gremlin.Net.UnitTest/Process/Traversal/GremlinLangTests.cs
b/gremlin-dotnet/test/Gremlin.Net.UnitTest/Process/Traversal/GremlinLangTests.cs
index c7a60feaf1..d453919e25 100644
---
a/gremlin-dotnet/test/Gremlin.Net.UnitTest/Process/Traversal/GremlinLangTests.cs
+++
b/gremlin-dotnet/test/Gremlin.Net.UnitTest/Process/Traversal/GremlinLangTests.cs
@@ -367,6 +367,27 @@ namespace Gremlin.Net.UnitTest.Process.Traversal
_g.V("1", "2").Has("region", P.Within("US-TX",
"US-GA")).GremlinLang.GetGremlin());
}
+ [Fact]
+ public void g_V_Has_age_Outside_28_33()
+ {
+ Assert.Equal("g.V().has(\"age\",outside(28,33))",
+ _g.V().Has("age", P.Outside(28, 33)).GremlinLang.GetGremlin());
+ }
+
+ [Fact]
+ public void g_V_Has_age_Between_28_33()
+ {
+ Assert.Equal("g.V().has(\"age\",between(28,33))",
+ _g.V().Has("age", P.Between(28, 33)).GremlinLang.GetGremlin());
+ }
+
+ [Fact]
+ public void g_V_Has_age_Inside_28_33()
+ {
+ Assert.Equal("g.V().has(\"age\",inside(28,33))",
+ _g.V().Has("age", P.Inside(28, 33)).GremlinLang.GetGremlin());
+ }
+
[Fact]
public void g_V_And_Has_runways_Gt_5_Has_region_USTX()
{
diff --git a/gremlin-go/driver/cucumber/gremlin.go
b/gremlin-go/driver/cucumber/gremlin.go
index ad78ab4cb4..2f4e07a82e 100644
--- a/gremlin-go/driver/cucumber/gremlin.go
+++ b/gremlin-go/driver/cucumber/gremlin.go
@@ -182,6 +182,7 @@ var translationMap = map[string][]func(g
*gremlingo.GraphTraversalSource, p map[
"g_unionXaddVXpersonX_propertyXname_aliceX_addVXpersonX_propertyXname_bobX_addVXpersonX_propertyXname_chrisX_name":
{func(g *gremlingo.GraphTraversalSource, p map[string]interface{})
*gremlingo.GraphTraversal {return
g.Union(gremlingo.T__.AddV("person").Property("name", "alice"),
gremlingo.T__.AddV("person").Property("name", "bob"),
gremlingo.T__.AddV("person").Property("name", "chris")).Values("name")}},
"g_VX_hasLabelXpersonX_unionX_whereX_out_count_isXgtX2XXX_valuesXageX_notX_whereX_bothE_count_isXgt2XXX_valusXnameXX":
{func(g *gremlingo.GraphTraversalSource, p map[string]interface{})
*gremlingo.GraphTraversal {return
g.V().HasLabel("person").Union(gremlingo.T__.Where(gremlingo.T__.OutE().Count().Is(gremlingo.P.Gt(2))).Values("age"),
gremlingo.T__.Not(gremlingo.T__.Where(gremlingo.T__.OutE().Count().Is(gremlingo.P.Gt(2)))).Values("name"))}},
"g_V_valuesXintX_asNumberXGType_BIGDECIMALX_isXtypeOfXGType_BIGDECIMALXX":
{func(g *gremlingo.GraphTraversalSource, p map[string]interface{})
*gremlingo.GraphTraversal {return g.AddV("data").Property("int", 123)}, func(g
*gremlingo.GraphTraversalSource, p map[string]interface{})
*gremlingo.GraphTraversal {return
g.V().Values("int").AsNumber(gremlingo.GType.BigDecimal).Is(gremlingo.P.TypeOf(gremlingo.GType.BigDecimal))}},
+
"g_V_valuesXintX_asNumberXGType_BIGDECIMALX_negative_isXtypeOfXGType_BIGDECIMALXX":
{func(g *gremlingo.GraphTraversalSource, p map[string]interface{})
*gremlingo.GraphTraversal {return g.AddV("data").Property("int", -456)}, func(g
*gremlingo.GraphTraversalSource, p map[string]interface{})
*gremlingo.GraphTraversal {return
g.V().Values("int").AsNumber(gremlingo.GType.BigDecimal).Is(gremlingo.P.TypeOf(gremlingo.GType.BigDecimal))}},
"g_V_valuesXintX_asNumberXGType_BIGDECIMALX_isXtypeOfXGType_BIGDECIMALXX_mathXaddX0_5XX":
{func(g *gremlingo.GraphTraversalSource, p map[string]interface{})
*gremlingo.GraphTraversal {return g.AddV("data").Property("int", 10)}, func(g
*gremlingo.GraphTraversalSource, p map[string]interface{})
*gremlingo.GraphTraversal {return
g.V().Values("int").AsNumber(gremlingo.GType.BigDecimal).Is(gremlingo.P.TypeOf(gremlingo.GType.BigDecimal)).Math("_
+ 0.5")}},
"g_V_valuesXintX_asNumberXGType_BIGDECIMALX_isXtypeOfXGType_BIGDECIMALXX_isXgtX0XX":
{func(g *gremlingo.GraphTraversalSource, p map[string]interface{})
*gremlingo.GraphTraversal {return g.AddV("data").Property("int", 5)}, func(g
*gremlingo.GraphTraversalSource, p map[string]interface{})
*gremlingo.GraphTraversal {return
g.V().Values("int").AsNumber(gremlingo.GType.BigDecimal).Is(gremlingo.P.TypeOf(gremlingo.GType.BigDecimal)).Is(gremlingo.P.Gt(0))}},
"g_V_valuesXintX_asNumberXGType_BIGDECIMALX_isXtypeOfXGType_BIGDECIMALXX_sumX":
{func(g *gremlingo.GraphTraversalSource, p map[string]interface{})
*gremlingo.GraphTraversal {return g.AddV("data").Property("int",
2).AddV("data").Property("int", 3).AddV("data").Property("int", 4)}, func(g
*gremlingo.GraphTraversalSource, p map[string]interface{})
*gremlingo.GraphTraversal {return
g.V().Values("int").AsNumber(gremlingo.GType.BigDecimal).Is(gremlingo.P.TypeOf(gremlingo.GType.BigDecimal))
[...]
@@ -191,6 +192,7 @@ var translationMap = map[string][]func(g
*gremlingo.GraphTraversalSource, p map[
"g_injectX99X_asNumberXGType_BIGDECIMALX_isXtypeOfXGType_BIGDECIMALXX_groupCount":
{func(g *gremlingo.GraphTraversalSource, p map[string]interface{})
*gremlingo.GraphTraversal {return
g.Inject(99).AsNumber(gremlingo.GType.BigDecimal).Is(gremlingo.P.TypeOf(gremlingo.GType.BigDecimal)).GroupCount()}},
"g_V_valuesXageX_isXtypeOfXGType_BIGDECIMALXX": {func(g
*gremlingo.GraphTraversalSource, p map[string]interface{})
*gremlingo.GraphTraversal {return
g.V().Values("age").Is(gremlingo.P.TypeOf(gremlingo.GType.BigDecimal))}},
"g_V_valuesXintX_asNumberXGType_BIGINTX_isXtypeOfXGType_BIGINTXX": {func(g
*gremlingo.GraphTraversalSource, p map[string]interface{})
*gremlingo.GraphTraversal {return g.AddV("data").Property("int", 456)}, func(g
*gremlingo.GraphTraversalSource, p map[string]interface{})
*gremlingo.GraphTraversal {return
g.V().Values("int").AsNumber(gremlingo.GType.BigInt).Is(gremlingo.P.TypeOf(gremlingo.GType.BigInt))}},
+
"g_V_valuesXintX_asNumberXGType_BIGINTX_negative_isXtypeOfXGType_BIGINTXX":
{func(g *gremlingo.GraphTraversalSource, p map[string]interface{})
*gremlingo.GraphTraversal {return g.AddV("data").Property("int", -456)}, func(g
*gremlingo.GraphTraversalSource, p map[string]interface{})
*gremlingo.GraphTraversal {return
g.V().Values("int").AsNumber(gremlingo.GType.BigInt).Is(gremlingo.P.TypeOf(gremlingo.GType.BigInt))}},
"g_V_valuesXintX_asNumberXGType_BIGINTX_isXtypeOfXGType_BIGINTXX_mathXmulX1000XX":
{func(g *gremlingo.GraphTraversalSource, p map[string]interface{})
*gremlingo.GraphTraversal {return g.AddV("data").Property("int", 100)}, func(g
*gremlingo.GraphTraversalSource, p map[string]interface{})
*gremlingo.GraphTraversal {return
g.V().Values("int").AsNumber(gremlingo.GType.BigInt).Is(gremlingo.P.TypeOf(gremlingo.GType.BigInt)).Math("_
* 1000")}},
"g_V_valuesXintX_asNumberXGType_BIGINTX_isXtypeOfXGType_BIGINTXX_isXeqX42XX":
{func(g *gremlingo.GraphTraversalSource, p map[string]interface{})
*gremlingo.GraphTraversal {return g.AddV("data").Property("int", 42)}, func(g
*gremlingo.GraphTraversalSource, p map[string]interface{})
*gremlingo.GraphTraversal {return
g.V().Values("int").AsNumber(gremlingo.GType.BigInt).Is(gremlingo.P.TypeOf(gremlingo.GType.BigInt)).Is(gremlingo.P.Eq(42))}},
"g_V_valuesXintX_asNumberXGType_BIGINTX_isXtypeOfXGType_BIGINTXX_sumX":
{func(g *gremlingo.GraphTraversalSource, p map[string]interface{})
*gremlingo.GraphTraversal {return g.AddV("data").Property("int",
10).AddV("data").Property("int", 20).AddV("data").Property("int", 30)}, func(g
*gremlingo.GraphTraversalSource, p map[string]interface{})
*gremlingo.GraphTraversal {return
g.V().Values("int").AsNumber(gremlingo.GType.BigInt).Is(gremlingo.P.TypeOf(gremlingo.GType.BigInt)).Sum()}},
@@ -551,6 +553,7 @@ var translationMap = map[string][]func(g
*gremlingo.GraphTraversalSource, p map[
"g_V_valuesXageX_isX32varX": {func(g *gremlingo.GraphTraversalSource, p
map[string]interface{}) *gremlingo.GraphTraversal {return
g.V().Values("age").Is(p["xx1"])}},
"g_V_valuesXageX_isXlte_30X": {func(g *gremlingo.GraphTraversalSource, p
map[string]interface{}) *gremlingo.GraphTraversal {return
g.V().Values("age").Is(gremlingo.P.Lte(30))}},
"g_V_valuesXageX_isXlte_30varX": {func(g *gremlingo.GraphTraversalSource,
p map[string]interface{}) *gremlingo.GraphTraversal {return
g.V().Values("age").Is(gremlingo.P.Lte(p["xx1"]))}},
+ "g_V_valuesXageX_isXoutsideX28_33XX": {func(g
*gremlingo.GraphTraversalSource, p map[string]interface{})
*gremlingo.GraphTraversal {return
g.V().Values("age").Is(gremlingo.P.Outside(28, 33))}},
"g_V_valuesXageX_isXgte_29X_isXlt_34X": {func(g
*gremlingo.GraphTraversalSource, p map[string]interface{})
*gremlingo.GraphTraversal {return
g.V().Values("age").Is(gremlingo.P.Gte(29)).Is(gremlingo.P.Lt(34))}},
"g_V_valuesXageX_isXgte_29vaarX_isXlt_34varX": {func(g
*gremlingo.GraphTraversalSource, p map[string]interface{})
*gremlingo.GraphTraversal {return
g.V().Values("age").Is(gremlingo.P.Gte(p["xx1"])).Is(gremlingo.P.Lt(p["xx2"]))}},
"g_V_whereXinXcreatedX_count_isX1XX_valuesXnameX": {func(g
*gremlingo.GraphTraversalSource, p map[string]interface{})
*gremlingo.GraphTraversal {return
g.V().Where(gremlingo.T__.In("created").Count().Is(1)).Values("name")}},
diff --git a/gremlin-go/driver/graphBinaryDeserializer.go
b/gremlin-go/driver/graphBinaryDeserializer.go
index 920edfb374..b086cdfed4 100644
--- a/gremlin-go/driver/graphBinaryDeserializer.go
+++ b/gremlin-go/driver/graphBinaryDeserializer.go
@@ -780,7 +780,9 @@ func (d *GraphBinaryDeserializer) readBigInt() (*big.Int,
error) {
bi := big.NewInt(0).SetBytes(b)
if b[0]&0x80 != 0 {
one := big.NewInt(1)
- bitLen := uint((len(b)*8)/8+1) * 8
+ // High bit set: the bytes are a two's-complement negative, so
recover the
+ // signed value by subtracting 2^(bit width), where the width
is 8 bits per byte.
+ bitLen := uint(len(b)) * 8
bi.Sub(bi, new(big.Int).Lsh(one, bitLen))
}
return bi, nil
diff --git a/gremlin-go/driver/graphBinarySerializer_test.go
b/gremlin-go/driver/graphBinarySerializer_test.go
index 7df297cc83..a3cc90b6c9 100644
--- a/gremlin-go/driver/graphBinarySerializer_test.go
+++ b/gremlin-go/driver/graphBinarySerializer_test.go
@@ -221,6 +221,29 @@ func TestGraphBinaryV4(t *testing.T) {
assert.Nil(t, err)
assert.Equal(t, new(big.Int).SetUint64(uint64(source)),
res)
})
+ t.Run("read-write bigInt negative", func(t *testing.T) {
+ large, _ :=
new(big.Int).SetString("-1606938044258990275541962092341162602522202993782792835301376",
10)
+ for _, source := range []*big.Int{big.NewInt(-1),
big.NewInt(-128), big.NewInt(-129), big.NewInt(-256), big.NewInt(-65535),
large} {
+ var buffer bytes.Buffer
+ err := bigIntWriter(*source, &buffer, nil)
+ assert.Nil(t, err)
+ d :=
NewGraphBinaryDeserializer(bytes.NewReader(buffer.Bytes()))
+ res, err := d.readBigInt()
+ assert.Nil(t, err)
+ assert.Equal(t, source, res)
+ }
+ })
+ t.Run("read-write BigDecimal negative", func(t *testing.T) {
+ for _, source := range []*BigDecimal{{2,
big.NewInt(-1234)}, {0, big.NewInt(-1)}, {4, big.NewInt(-256)}} {
+ var buffer bytes.Buffer
+ err := bigDecimalWriter(source, &buffer, nil)
+ assert.Nil(t, err)
+ d :=
NewGraphBinaryDeserializer(bytes.NewReader(buffer.Bytes()))
+ res, err := d.readBigDecimal()
+ assert.Nil(t, err)
+ assert.Equal(t, source, res)
+ }
+ })
t.Run("read-write list", func(t *testing.T) {
var buffer bytes.Buffer
source := []interface{}{int32(111), "str"}
diff --git a/gremlin-go/driver/gremlinlang.go b/gremlin-go/driver/gremlinlang.go
index 7e90cb341e..e5565c6837 100644
--- a/gremlin-go/driver/gremlinlang.go
+++ b/gremlin-go/driver/gremlinlang.go
@@ -136,7 +136,6 @@ func escapeString(s string) string {
return sb.String()
}
-
func isValidParameterName(name string) bool {
runes := []rune(name)
if len(runes) == 0 {
@@ -481,7 +480,7 @@ func (gl *GremlinLang) translatePValue(operator string,
values []interface{}) (s
}
}
- if len(values) > 1 && !allTraversals && operator != "between" &&
operator != "inside" {
+ if len(values) > 1 && !allTraversals && operator != "between" &&
operator != "inside" && operator != "outside" {
sb.WriteString("[")
}
@@ -496,7 +495,7 @@ func (gl *GremlinLang) translatePValue(operator string,
values []interface{}) (s
}
}
- if len(values) > 1 && !allTraversals && operator != "between" &&
operator != "inside" {
+ if len(values) > 1 && !allTraversals && operator != "between" &&
operator != "inside" && operator != "outside" {
sb.WriteString("]")
}
sb.WriteString(")")
diff --git a/gremlin-go/driver/gremlinlang_test.go
b/gremlin-go/driver/gremlinlang_test.go
index c8c353b59c..dbd7b19b77 100644
--- a/gremlin-go/driver/gremlinlang_test.go
+++ b/gremlin-go/driver/gremlinlang_test.go
@@ -516,6 +516,18 @@ func Test_GremlinLang(t *testing.T) {
},
equals: "g.V().has(\"runways\",between(3,5))",
},
+ {
+ assert: func(g *GraphTraversalSource) *GraphTraversal {
+ return g.V().Has("runways", P.Outside(3, 5))
+ },
+ equals: "g.V().has(\"runways\",outside(3,5))",
+ },
+ {
+ assert: func(g *GraphTraversalSource) *GraphTraversal {
+ return g.V().Has("runways", P.Inside(3, 5))
+ },
+ equals: "g.V().has(\"runways\",inside(3,5))",
+ },
{
assert: func(g *GraphTraversalSource) *GraphTraversal {
return g.V().Has("runways", P.Inside(3, 5))
diff --git a/gremlin-js/gremlin-javascript/test/cucumber/gremlin.js
b/gremlin-js/gremlin-javascript/test/cucumber/gremlin.js
index 85bc334b7a..31b50c2df9 100644
--- a/gremlin-js/gremlin-javascript/test/cucumber/gremlin.js
+++ b/gremlin-js/gremlin-javascript/test/cucumber/gremlin.js
@@ -213,6 +213,7 @@ const gremlins = {
g_unionXaddVXpersonX_propertyXname_aliceX_addVXpersonX_propertyXname_bobX_addVXpersonX_propertyXname_chrisX_name:
[function({g}) { return g.union(__.addV("person").property("name", "alice"),
__.addV("person").property("name", "bob"), __.addV("person").property("name",
"chris")).values("name") }],
g_VX_hasLabelXpersonX_unionX_whereX_out_count_isXgtX2XXX_valuesXageX_notX_whereX_bothE_count_isXgt2XXX_valusXnameXX:
[function({g}) { return
g.V().hasLabel("person").union(__.where(__.outE().count().is(P.gt(2))).values("age"),
__.not(__.where(__.outE().count().is(P.gt(2)))).values("name")) }],
g_V_valuesXintX_asNumberXGType_BIGDECIMALX_isXtypeOfXGType_BIGDECIMALXX:
[function({g}) { return g.addV("data").property("int", 123) }, function({g}) {
return
g.V().values("int").asNumber(GType.bigDecimal).is(P.typeOf(GType.bigDecimal))
}],
+
g_V_valuesXintX_asNumberXGType_BIGDECIMALX_negative_isXtypeOfXGType_BIGDECIMALXX:
[function({g}) { return g.addV("data").property("int", -456) }, function({g})
{ return
g.V().values("int").asNumber(GType.bigDecimal).is(P.typeOf(GType.bigDecimal))
}],
g_V_valuesXintX_asNumberXGType_BIGDECIMALX_isXtypeOfXGType_BIGDECIMALXX_mathXaddX0_5XX:
[function({g}) { return g.addV("data").property("int", 10) }, function({g}) {
return
g.V().values("int").asNumber(GType.bigDecimal).is(P.typeOf(GType.bigDecimal)).math("_
+ 0.5") }],
g_V_valuesXintX_asNumberXGType_BIGDECIMALX_isXtypeOfXGType_BIGDECIMALXX_isXgtX0XX:
[function({g}) { return g.addV("data").property("int", 5) }, function({g}) {
return
g.V().values("int").asNumber(GType.bigDecimal).is(P.typeOf(GType.bigDecimal)).is(P.gt(0))
}],
g_V_valuesXintX_asNumberXGType_BIGDECIMALX_isXtypeOfXGType_BIGDECIMALXX_sumX:
[function({g}) { return g.addV("data").property("int",
2).addV("data").property("int", 3).addV("data").property("int", 4) },
function({g}) { return
g.V().values("int").asNumber(GType.bigDecimal).is(P.typeOf(GType.bigDecimal)).sum()
}],
@@ -222,6 +223,7 @@ const gremlins = {
g_injectX99X_asNumberXGType_BIGDECIMALX_isXtypeOfXGType_BIGDECIMALXX_groupCount:
[function({g}) { return
g.inject(99).asNumber(GType.bigDecimal).is(P.typeOf(GType.bigDecimal)).groupCount()
}],
g_V_valuesXageX_isXtypeOfXGType_BIGDECIMALXX: [function({g}) { return
g.V().values("age").is(P.typeOf(GType.bigDecimal)) }],
g_V_valuesXintX_asNumberXGType_BIGINTX_isXtypeOfXGType_BIGINTXX:
[function({g}) { return g.addV("data").property("int", 456) }, function({g}) {
return g.V().values("int").asNumber(GType.bigInt).is(P.typeOf(GType.bigInt))
}],
+ g_V_valuesXintX_asNumberXGType_BIGINTX_negative_isXtypeOfXGType_BIGINTXX:
[function({g}) { return g.addV("data").property("int", -456) }, function({g}) {
return g.V().values("int").asNumber(GType.bigInt).is(P.typeOf(GType.bigInt))
}],
g_V_valuesXintX_asNumberXGType_BIGINTX_isXtypeOfXGType_BIGINTXX_mathXmulX1000XX:
[function({g}) { return g.addV("data").property("int", 100) }, function({g}) {
return
g.V().values("int").asNumber(GType.bigInt).is(P.typeOf(GType.bigInt)).math("_ *
1000") }],
g_V_valuesXintX_asNumberXGType_BIGINTX_isXtypeOfXGType_BIGINTXX_isXeqX42XX:
[function({g}) { return g.addV("data").property("int", 42) }, function({g}) {
return
g.V().values("int").asNumber(GType.bigInt).is(P.typeOf(GType.bigInt)).is(P.eq(42))
}],
g_V_valuesXintX_asNumberXGType_BIGINTX_isXtypeOfXGType_BIGINTXX_sumX:
[function({g}) { return g.addV("data").property("int",
10).addV("data").property("int", 20).addV("data").property("int", 30) },
function({g}) { return
g.V().values("int").asNumber(GType.bigInt).is(P.typeOf(GType.bigInt)).sum() }],
@@ -582,6 +584,7 @@ const gremlins = {
g_V_valuesXageX_isX32varX: [function({g, xx1}) { return
g.V().values("age").is(xx1) }],
g_V_valuesXageX_isXlte_30X: [function({g}) { return
g.V().values("age").is(P.lte(30)) }],
g_V_valuesXageX_isXlte_30varX: [function({g, xx1}) { return
g.V().values("age").is(P.lte(xx1)) }],
+ g_V_valuesXageX_isXoutsideX28_33XX: [function({g}) { return
g.V().values("age").is(P.outside(28, 33)) }],
g_V_valuesXageX_isXgte_29X_isXlt_34X: [function({g}) { return
g.V().values("age").is(P.gte(29)).is(P.lt(34)) }],
g_V_valuesXageX_isXgte_29vaarX_isXlt_34varX: [function({g, xx1, xx2}) {
return g.V().values("age").is(P.gte(xx1)).is(P.lt(xx2)) }],
g_V_whereXinXcreatedX_count_isX1XX_valuesXnameX: [function({g}) { return
g.V().where(__.in_("created").count().is(1)).values("name") }],
diff --git a/gremlin-python/src/main/python/tests/feature/gremlin.py
b/gremlin-python/src/main/python/tests/feature/gremlin.py
index 4e346fe4ef..3e779314b2 100644
--- a/gremlin-python/src/main/python/tests/feature/gremlin.py
+++ b/gremlin-python/src/main/python/tests/feature/gremlin.py
@@ -187,6 +187,7 @@ world.gremlins = {
'g_unionXaddVXpersonX_propertyXname_aliceX_addVXpersonX_propertyXname_bobX_addVXpersonX_propertyXname_chrisX_name':
[(lambda g:g.union(__.add_v('person').property('name', 'alice'),
__.add_v('person').property('name', 'bob'), __.add_v('person').property('name',
'chris')).values('name'))],
'g_VX_hasLabelXpersonX_unionX_whereX_out_count_isXgtX2XXX_valuesXageX_notX_whereX_bothE_count_isXgt2XXX_valusXnameXX':
[(lambda
g:g.V().has_label('person').union(__.where(__.out_e().count().is_(P.gt(2))).values('age'),
__.not_(__.where(__.out_e().count().is_(P.gt(2)))).values('name')))],
'g_V_valuesXintX_asNumberXGType_BIGDECIMALX_isXtypeOfXGType_BIGDECIMALXX':
[(lambda g:g.add_v('data').property('int', 123)), (lambda
g:g.V().values('int').as_number(GType.BIGDECIMAL).is_(P.type_of(GType.BIGDECIMAL)))],
+
'g_V_valuesXintX_asNumberXGType_BIGDECIMALX_negative_isXtypeOfXGType_BIGDECIMALXX':
[(lambda g:g.add_v('data').property('int', -456)), (lambda
g:g.V().values('int').as_number(GType.BIGDECIMAL).is_(P.type_of(GType.BIGDECIMAL)))],
'g_V_valuesXintX_asNumberXGType_BIGDECIMALX_isXtypeOfXGType_BIGDECIMALXX_mathXaddX0_5XX':
[(lambda g:g.add_v('data').property('int', 10)), (lambda
g:g.V().values('int').as_number(GType.BIGDECIMAL).is_(P.type_of(GType.BIGDECIMAL)).math('_
+ 0.5'))],
'g_V_valuesXintX_asNumberXGType_BIGDECIMALX_isXtypeOfXGType_BIGDECIMALXX_isXgtX0XX':
[(lambda g:g.add_v('data').property('int', 5)), (lambda
g:g.V().values('int').as_number(GType.BIGDECIMAL).is_(P.type_of(GType.BIGDECIMAL)).is_(P.gt(0)))],
'g_V_valuesXintX_asNumberXGType_BIGDECIMALX_isXtypeOfXGType_BIGDECIMALXX_sumX':
[(lambda g:g.add_v('data').property('int', 2).add_v('data').property('int',
3).add_v('data').property('int', 4)), (lambda
g:g.V().values('int').as_number(GType.BIGDECIMAL).is_(P.type_of(GType.BIGDECIMAL)).sum_())],
@@ -196,6 +197,7 @@ world.gremlins = {
'g_injectX99X_asNumberXGType_BIGDECIMALX_isXtypeOfXGType_BIGDECIMALXX_groupCount':
[(lambda
g:g.inject(99).as_number(GType.BIGDECIMAL).is_(P.type_of(GType.BIGDECIMAL)).group_count())],
'g_V_valuesXageX_isXtypeOfXGType_BIGDECIMALXX': [(lambda
g:g.V().values('age').is_(P.type_of(GType.BIGDECIMAL)))],
'g_V_valuesXintX_asNumberXGType_BIGINTX_isXtypeOfXGType_BIGINTXX':
[(lambda g:g.add_v('data').property('int', 456)), (lambda
g:g.V().values('int').as_number(GType.BIGINT).is_(P.type_of(GType.BIGINT)))],
+
'g_V_valuesXintX_asNumberXGType_BIGINTX_negative_isXtypeOfXGType_BIGINTXX':
[(lambda g:g.add_v('data').property('int', -456)), (lambda
g:g.V().values('int').as_number(GType.BIGINT).is_(P.type_of(GType.BIGINT)))],
'g_V_valuesXintX_asNumberXGType_BIGINTX_isXtypeOfXGType_BIGINTXX_mathXmulX1000XX':
[(lambda g:g.add_v('data').property('int', 100)), (lambda
g:g.V().values('int').as_number(GType.BIGINT).is_(P.type_of(GType.BIGINT)).math('_
* 1000'))],
'g_V_valuesXintX_asNumberXGType_BIGINTX_isXtypeOfXGType_BIGINTXX_isXeqX42XX':
[(lambda g:g.add_v('data').property('int', 42)), (lambda
g:g.V().values('int').as_number(GType.BIGINT).is_(P.type_of(GType.BIGINT)).is_(P.eq(42)))],
'g_V_valuesXintX_asNumberXGType_BIGINTX_isXtypeOfXGType_BIGINTXX_sumX':
[(lambda g:g.add_v('data').property('int', 10).add_v('data').property('int',
20).add_v('data').property('int', 30)), (lambda
g:g.V().values('int').as_number(GType.BIGINT).is_(P.type_of(GType.BIGINT)).sum_())],
@@ -556,6 +558,7 @@ world.gremlins = {
'g_V_valuesXageX_isX32varX': [(lambda g,
xx1=None:g.V().values('age').is_(xx1))],
'g_V_valuesXageX_isXlte_30X': [(lambda
g:g.V().values('age').is_(P.lte(30)))],
'g_V_valuesXageX_isXlte_30varX': [(lambda g,
xx1=None:g.V().values('age').is_(P.lte(xx1)))],
+ 'g_V_valuesXageX_isXoutsideX28_33XX': [(lambda
g:g.V().values('age').is_(P.outside(28, 33)))],
'g_V_valuesXageX_isXgte_29X_isXlt_34X': [(lambda
g:g.V().values('age').is_(P.gte(29)).is_(P.lt(34)))],
'g_V_valuesXageX_isXgte_29vaarX_isXlt_34varX': [(lambda g,
xx1=None,xx2=None:g.V().values('age').is_(P.gte(xx1)).is_(P.lt(xx2)))],
'g_V_whereXinXcreatedX_count_isX1XX_valuesXnameX': [(lambda
g:g.V().where(__.in_('created').count().is_(1)).values('name'))],
diff --git
a/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/language/translator/translations.json
b/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/language/translator/translations.json
index 903b797992..65dc301518 100644
---
a/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/language/translator/translations.json
+++
b/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/language/translator/translations.json
@@ -2616,6 +2616,35 @@
}
]
},
+ {
+ "scenario":
"g_V_valuesXintX_asNumberXGType_BIGDECIMALX_negative_isXtypeOfXGType_BIGDECIMALXX",
+ "traversals": [
+ {
+ "original": "g.addV(\"data\").property(\"int\", -456)",
+ "language": "g.addV(\"data\").property(\"int\", -456)",
+ "canonical": "g.addV(\"data\").property(\"int\", -456)",
+ "anonymized": "g.addV(string0).property(string1, number0)",
+ "dotnet": "g.AddV((string) \"data\").Property(\"int\", -456)",
+ "go": "g.AddV(\"data\").Property(\"int\", -456)",
+ "groovy": "g.addV(\"data\").property(\"int\", -456)",
+ "java": "g.addV(\"data\").property(\"int\", -456)",
+ "javascript": "g.addV(\"data\").property(\"int\", -456)",
+ "python": "g.add_v('data').property('int', -456)"
+ },
+ {
+ "original":
"g.V().values(\"int\").asNumber(GType.BIGDECIMAL).is(P.typeOf(GType.BIGDECIMAL))",
+ "language":
"g.V().values(\"int\").asNumber(GType.BIGDECIMAL).is(P.typeOf(GType.BIGDECIMAL))",
+ "canonical":
"g.V().values(\"int\").asNumber(GType.BIGDECIMAL).is(P.typeOf(GType.BIGDECIMAL))",
+ "anonymized":
"g.V().values(string0).asNumber(GType.BIGDECIMAL).is(P.typeOf(GType.BIGDECIMAL))",
+ "dotnet":
"g.V().Values<object>(\"int\").AsNumber(GType.BigDecimal).Is(P.TypeOf(GType.BigDecimal))",
+ "go":
"g.V().Values(\"int\").AsNumber(gremlingo.GType.BigDecimal).Is(gremlingo.P.TypeOf(gremlingo.GType.BigDecimal))",
+ "groovy":
"g.V().values(\"int\").asNumber(GType.BIGDECIMAL).is(P.typeOf(GType.BIGDECIMAL))",
+ "java":
"g.V().values(\"int\").asNumber(GType.BIGDECIMAL).is(P.typeOf(GType.BIGDECIMAL))",
+ "javascript":
"g.V().values(\"int\").asNumber(GType.bigDecimal).is(P.typeOf(GType.bigDecimal))",
+ "python":
"g.V().values('int').as_number(GType.BIGDECIMAL).is_(P.type_of(GType.BIGDECIMAL))"
+ }
+ ]
+ },
{
"scenario":
"g_V_valuesXintX_asNumberXGType_BIGDECIMALX_isXtypeOfXGType_BIGDECIMALXX_mathXaddX0_5XX",
"traversals": [
@@ -2853,6 +2882,35 @@
}
]
},
+ {
+ "scenario":
"g_V_valuesXintX_asNumberXGType_BIGINTX_negative_isXtypeOfXGType_BIGINTXX",
+ "traversals": [
+ {
+ "original": "g.addV(\"data\").property(\"int\", -456)",
+ "language": "g.addV(\"data\").property(\"int\", -456)",
+ "canonical": "g.addV(\"data\").property(\"int\", -456)",
+ "anonymized": "g.addV(string0).property(string1, number0)",
+ "dotnet": "g.AddV((string) \"data\").Property(\"int\", -456)",
+ "go": "g.AddV(\"data\").Property(\"int\", -456)",
+ "groovy": "g.addV(\"data\").property(\"int\", -456)",
+ "java": "g.addV(\"data\").property(\"int\", -456)",
+ "javascript": "g.addV(\"data\").property(\"int\", -456)",
+ "python": "g.add_v('data').property('int', -456)"
+ },
+ {
+ "original":
"g.V().values(\"int\").asNumber(GType.BIGINT).is(P.typeOf(GType.BIGINT))",
+ "language":
"g.V().values(\"int\").asNumber(GType.BIGINT).is(P.typeOf(GType.BIGINT))",
+ "canonical":
"g.V().values(\"int\").asNumber(GType.BIGINT).is(P.typeOf(GType.BIGINT))",
+ "anonymized":
"g.V().values(string0).asNumber(GType.BIGINT).is(P.typeOf(GType.BIGINT))",
+ "dotnet":
"g.V().Values<object>(\"int\").AsNumber(GType.BigInt).Is(P.TypeOf(GType.BigInt))",
+ "go":
"g.V().Values(\"int\").AsNumber(gremlingo.GType.BigInt).Is(gremlingo.P.TypeOf(gremlingo.GType.BigInt))",
+ "groovy":
"g.V().values(\"int\").asNumber(GType.BIGINT).is(P.typeOf(GType.BIGINT))",
+ "java":
"g.V().values(\"int\").asNumber(GType.BIGINT).is(P.typeOf(GType.BIGINT))",
+ "javascript":
"g.V().values(\"int\").asNumber(GType.bigInt).is(P.typeOf(GType.bigInt))",
+ "python":
"g.V().values('int').as_number(GType.BIGINT).is_(P.type_of(GType.BIGINT))"
+ }
+ ]
+ },
{
"scenario":
"g_V_valuesXintX_asNumberXGType_BIGINTX_isXtypeOfXGType_BIGINTXX_mathXmulX1000XX",
"traversals": [
@@ -10095,6 +10153,23 @@
}
]
},
+ {
+ "scenario": "g_V_valuesXageX_isXoutsideX28_33XX",
+ "traversals": [
+ {
+ "original": "g.V().values(\"age\").is(P.outside(28, 33))",
+ "language": "g.V().values(\"age\").is(P.outside(28, 33))",
+ "canonical": "g.V().values(\"age\").is(P.outside(28, 33))",
+ "anonymized": "g.V().values(string0).is(P.outside(number0,
number1))",
+ "dotnet": "g.V().Values<object>(\"age\").Is(P.Outside(28,
33))",
+ "go": "g.V().Values(\"age\").Is(gremlingo.P.Outside(28, 33))",
+ "groovy": "g.V().values(\"age\").is(P.outside(28, 33))",
+ "java": "g.V().values(\"age\").is(P.outside(28, 33))",
+ "javascript": "g.V().values(\"age\").is(P.outside(28, 33))",
+ "python": "g.V().values('age').is_(P.outside(28, 33))"
+ }
+ ]
+ },
{
"scenario": "g_V_valuesXageX_isXgte_29X_isXlt_34X",
"traversals": [
diff --git
a/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/data/BigDecimal.feature
b/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/data/BigDecimal.feature
index 64c1de0bcb..95734322d9 100644
---
a/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/data/BigDecimal.feature
+++
b/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/data/BigDecimal.feature
@@ -33,6 +33,21 @@ Feature: Data - BIGDECIMAL
| result |
| d[123].m |
+ Scenario:
g_V_valuesXintX_asNumberXGType_BIGDECIMALX_negative_isXtypeOfXGType_BIGDECIMALXX
+ Given the empty graph
+ And the graph initializer of
+ """
+ g.addV("data").property("int", -456)
+ """
+ And the traversal of
+ """
+
g.V().values("int").asNumber(GType.BIGDECIMAL).is(P.typeOf(GType.BIGDECIMAL))
+ """
+ When iterated to list
+ Then the result should be unordered
+ | result |
+ | d[-456].m |
+
Scenario:
g_V_valuesXintX_asNumberXGType_BIGDECIMALX_isXtypeOfXGType_BIGDECIMALXX_mathXaddX0_5XX
Given the empty graph
And the graph initializer of
diff --git
a/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/data/BigInt.feature
b/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/data/BigInt.feature
index 7cff49d0e7..95501b5554 100644
---
a/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/data/BigInt.feature
+++
b/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/data/BigInt.feature
@@ -33,6 +33,21 @@ Feature: Data - BIGINT
| result |
| d[456].n |
+ Scenario:
g_V_valuesXintX_asNumberXGType_BIGINTX_negative_isXtypeOfXGType_BIGINTXX
+ Given the empty graph
+ And the graph initializer of
+ """
+ g.addV("data").property("int", -456)
+ """
+ And the traversal of
+ """
+ g.V().values("int").asNumber(GType.BIGINT).is(P.typeOf(GType.BIGINT))
+ """
+ When iterated to list
+ Then the result should be unordered
+ | result |
+ | d[-456].n |
+
Scenario:
g_V_valuesXintX_asNumberXGType_BIGINTX_isXtypeOfXGType_BIGINTXX_mathXmulX1000XX
Given the empty graph
And the graph initializer of
diff --git
a/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/filter/Is.feature
b/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/filter/Is.feature
index 93afd854b9..b79471b0e9 100644
---
a/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/filter/Is.feature
+++
b/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/filter/Is.feature
@@ -66,6 +66,18 @@ Feature: Step - is()
| d[27].i |
| d[29].i |
+ Scenario: g_V_valuesXageX_isXoutsideX28_33XX
+ Given the modern graph
+ And the traversal of
+ """
+ g.V().values("age").is(P.outside(28, 33))
+ """
+ When iterated to list
+ Then the result should be unordered
+ | result |
+ | d[27].i |
+ | d[35].i |
+
Scenario: g_V_valuesXageX_isXgte_29X_isXlt_34X
Given the modern graph
And the traversal of
