This is an automated email from the ASF dual-hosted git repository.
colegreer 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 9924ab35ae Misc GremlinLang and ResultSet fixes (#3373)
9924ab35ae is described below
commit 9924ab35ae3d45ed5eb077f54fca02b25e272605
Author: Cole Greer <[email protected]>
AuthorDate: Mon Mar 30 18:14:38 2026 -0700
Misc GremlinLang and ResultSet fixes (#3373)
Contains a series of updates to GremlinLang handling of dates in different
languages:
- .Net: Fixes precision issue, the old format pattern was only set to
seconds precision thus milliseconds were being truncated from dates. This is a
simple update to add millis to the pattern, and this PR includes updates to
unit tests, as well as updating some feature tests to utilize non-zero millis
in datetimes.
- Java: Adds additional handling to GremlinLang to process java.util.Date
in addition to OffsetDateTime
- Python: Adds a few extra test cases to validate correct handling of
tzinfo when setting datestring suffixes.
Also included is a fix to ResultSet construction in .Net. Non-Traverser
results are now automatically boxed into Traverser's in BuildResultSet. If the
server is sending bulked results, this boxing already happens automatically
during deserialization, but if results are unbulked, they come back as raw
results (Vertex, Edge, Map...).
ResultSet assumes that all results are wrapped in Traverser's, so this
change adds
an extra check to ensure all results become boxed.
---
.../gremlin/process/traversal/GremlinLang.java | 4 ++
.../gremlin/process/traversal/GremlinLangTest.java | 3 ++
.../src/Gremlin.Net/Driver/Connection.cs | 11 ++--
.../Gremlin.Net/Process/Traversal/GremlinLang.cs | 2 +-
gremlin-dotnet/src/pom.xml | 7 ++-
.../Gremlin.Net.IntegrationTest/Gherkin/Gremlin.cs | 4 +-
.../Gremlin.Net.UnitTest/Driver/ConnectionTests.cs | 61 +++++++++++++++++++++-
.../Process/Traversal/GremlinLangTests.cs | 14 ++---
gremlin-dotnet/test/pom.xml | 7 ++-
gremlin-go/driver/cucumber/gremlin.go | 4 +-
.../gremlin-javascript/test/cucumber/gremlin.js | 4 +-
.../src/main/python/tests/feature/gremlin.py | 4 +-
.../python/tests/unit/process/test_gremlin_lang.py | 12 ++++-
.../gremlin/language/translator/translations.json | 36 ++++++-------
.../gremlin/test/features/data/DateTime.feature | 8 +--
15 files changed, 130 insertions(+), 51 deletions(-)
diff --git
a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/GremlinLang.java
b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/GremlinLang.java
index dad70aca38..e174b5aeca 100644
---
a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/GremlinLang.java
+++
b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/GremlinLang.java
@@ -34,6 +34,7 @@ import org.apache.tinkerpop.gremlin.util.NumberHelper;
import javax.lang.model.SourceVersion;
import java.io.Serializable;
+import java.util.Date;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.time.OffsetDateTime;
@@ -139,6 +140,9 @@ public class GremlinLang implements Cloneable, Serializable
{
if (arg instanceof OffsetDateTime)
return String.format("datetime(\"%s\")", format(((OffsetDateTime)
arg).toInstant()));
+ if (arg instanceof Date)
+ return String.format("datetime(\"%s\")", format(((Date)
arg).toInstant()));
+
if (arg instanceof UUID) {
return String.format("UUID(\"%s\")", arg);
}
diff --git
a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/GremlinLangTest.java
b/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/GremlinLangTest.java
index 60fbd865f5..cf29daa0f1 100644
---
a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/GremlinLangTest.java
+++
b/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/GremlinLangTest.java
@@ -39,6 +39,7 @@ import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.Arrays;
import java.util.Collections;
+import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.UUID;
@@ -86,6 +87,8 @@ public class GremlinLangTest {
"g.inject(+Infinity,-Infinity)"},
{g.inject(DatetimeHelper.parse("2018-03-21T08:35:44.741Z")),
"g.inject(datetime(\"2018-03-21T08:35:44.741Z\"))"},
+
{g.inject(Date.from(DatetimeHelper.parse("2018-03-21T08:35:44.741Z").toInstant())),
+ "g.inject(datetime(\"2018-03-21T08:35:44.741Z\"))"},
{g.inject(asMap("age", VertexProperty.Cardinality.list(33))),
"g.inject([\"age\":Cardinality.list(33)])"},
{g.inject(new HashMap<>()), "g.inject([:])"},
diff --git a/gremlin-dotnet/src/Gremlin.Net/Driver/Connection.cs
b/gremlin-dotnet/src/Gremlin.Net/Driver/Connection.cs
index 84ec963d40..415513918c 100644
--- a/gremlin-dotnet/src/Gremlin.Net/Driver/Connection.cs
+++ b/gremlin-dotnet/src/Gremlin.Net/Driver/Connection.cs
@@ -32,6 +32,7 @@ using System.Threading;
using System.Threading.Tasks;
using Gremlin.Net.Driver.Messages;
using Gremlin.Net.Process;
+using Gremlin.Net.Process.Traversal;
using Gremlin.Net.Structure.IO;
namespace Gremlin.Net.Driver
@@ -237,9 +238,13 @@ namespace Gremlin.Net.Driver
private static ResultSet<T>
BuildResultSet<T>(ResponseMessage<List<object>> responseMessage)
{
- return new ResultSet<T>(
- responseMessage.Result.Cast<T>().ToList(),
- new Dictionary<string, object>());
+ var results = typeof(T) == typeof(Traverser)
+ ? responseMessage.Result
+ .Select(item => item is Traverser ? item : (object)new
Traverser(item))
+ .Cast<T>().ToList()
+ : responseMessage.Result.Cast<T>().ToList();
+
+ return new ResultSet<T>(results, new Dictionary<string, object>());
}
/// <summary>
diff --git a/gremlin-dotnet/src/Gremlin.Net/Process/Traversal/GremlinLang.cs
b/gremlin-dotnet/src/Gremlin.Net/Process/Traversal/GremlinLang.cs
index f6df5bc87b..aa5a975879 100644
--- a/gremlin-dotnet/src/Gremlin.Net/Process/Traversal/GremlinLang.cs
+++ b/gremlin-dotnet/src/Gremlin.Net/Process/Traversal/GremlinLang.cs
@@ -233,7 +233,7 @@ namespace Gremlin.Net.Process.Traversal
return $"{decimalVal.ToString(CultureInfo.InvariantCulture)}M";
if (arg is DateTimeOffset dto)
- return
$"datetime(\"{dto.ToUniversalTime():yyyy-MM-ddTHH:mm:ssZ}\")";
+ return
$"datetime(\"{dto.ToUniversalTime():yyyy-MM-ddTHH:mm:ss.fffZ}\")";
if (arg is Guid guid)
return $"UUID(\"{guid}\")";
diff --git a/gremlin-dotnet/src/pom.xml b/gremlin-dotnet/src/pom.xml
index 69b75d4ddb..50a3b2a521 100644
--- a/gremlin-dotnet/src/pom.xml
+++ b/gremlin-dotnet/src/pom.xml
@@ -121,10 +121,9 @@ limitations under the License.
<id>gremlin-dotnet</id>
<activation>
<activeByDefault>false</activeByDefault>
- <!-- TODO re-enable after gremlin-dotnet is implemented -->
-<!-- <file>-->
-<!-- <exists>.glv</exists>-->
-<!-- </file>-->
+ <file>
+ <exists>.glv</exists>
+ </file>
</activation>
<properties>
<packaging.type>dotnet-library</packaging.type>
diff --git a/gremlin-dotnet/test/Gremlin.Net.IntegrationTest/Gherkin/Gremlin.cs
b/gremlin-dotnet/test/Gremlin.Net.IntegrationTest/Gherkin/Gremlin.cs
index d9b871d889..2efd471c8e 100644
--- a/gremlin-dotnet/test/Gremlin.Net.IntegrationTest/Gherkin/Gremlin.cs
+++ b/gremlin-dotnet/test/Gremlin.Net.IntegrationTest/Gherkin/Gremlin.cs
@@ -237,11 +237,11 @@ namespace Gremlin.Net.IntegrationTest.Gherkin
{"g_V_valuesXdatetimeX_isXtypeOfXGType_DATETIMEXX", new
List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>>
{(g,p) =>g.AddV((string) "event").Property("datetime",
DateTimeOffset.Parse("2023-08-08T00:00Z")), (g,p)
=>g.V().Values<object>("datetime").Is(P.TypeOf(GType.DateTime))}},
{"g_V_valuesXdatetimeX_isXtypeOfXGType_DATETIMEXX_project_byXidentityX_byXdateAddXDT_dayX1XX",
new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>>
{(g,p) =>g.AddV((string) "event").Property("datetime",
DateTimeOffset.Parse("2023-08-08T00:00Z")), (g,p)
=>g.V().Values<object>("datetime").Is(P.TypeOf(GType.DateTime)).Project<object>("original",
"nextDay").By(__.Identity()).By(__.DateAdd(DT.Day, 1))}},
{"g_V_valuesXdatetimeX_isXtypeOfXGType_DATETIMEXX_dateDiffXdatetimeX2023_08_10XX",
new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>>
{(g,p) =>g.AddV((string) "event").Property("datetime",
DateTimeOffset.Parse("2023-08-08T00:00Z")), (g,p)
=>g.V().Values<object>("datetime").Is(P.TypeOf(GType.DateTime)).DateDiff(DateTimeOffset.Parse("2023-08-08T00:00:30Z"))}},
-
{"g_V_valuesXdatetimeX_isXtypeOfXGType_DATETIMEXX_whereXisXgtXdatetimeX2020_01_01XXXX",
new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>>
{(g,p) =>g.AddV((string) "event").Property("datetime",
DateTimeOffset.Parse("2023-08-08T00:00Z")), (g,p)
=>g.V().Values<object>("datetime").Is(P.TypeOf(GType.DateTime)).Where(__.Is(P.Gt(DateTimeOffset.Parse("2020-01-01T00:00Z"))))}},
+
{"g_V_valuesXdatetimeX_isXtypeOfXGType_DATETIMEXX_whereXisXgtXdatetimeX2020_01_01XXXX",
new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>>
{(g,p) =>g.AddV((string) "event").Property("datetime",
DateTimeOffset.Parse("2023-08-08T12:34:56Z")), (g,p)
=>g.V().Values<object>("datetime").Is(P.TypeOf(GType.DateTime)).Where(__.Is(P.Gt(DateTimeOffset.Parse("2020-01-01T00:00Z"))))}},
{"g_V_valuesXdatetimeX_isXtypeOfXGType_DATETIMEXX_chooseXisXeqXdatetimeX2023_08_08XXXX_constantXmatchX_constantXnoMatchXX",
new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>>
{(g,p) =>g.AddV((string) "event").Property("datetime",
DateTimeOffset.Parse("2023-08-08T00:00Z")), (g,p)
=>g.V().Values<object>("datetime").Is(P.TypeOf(GType.DateTime)).Choose<object>(__.Is(P.Eq(DateTimeOffset.Parse("2023-08-08T00:00Z"))),
__.Constant<object>("match"), __.Co [...]
{"g_V_valuesXdatetimeX_isXtypeOfXGType_DATETIMEXX_localXaggregateXaX_capXaX",
new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>>
{(g,p) =>g.AddV((string) "event").Property("datetime",
DateTimeOffset.Parse("2023-08-08T00:00Z")), (g,p)
=>g.V().Values<object>("datetime").Is(P.TypeOf(GType.DateTime)).Local<object>(__.Aggregate("a")).Cap<object>("a")}},
{"g_injectXdatetimeX_isXtypeOfXGType_DATETIMEXX_aggregateXaX_capXaX", new
List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>>
{(g,p)
=>g.Inject<object>(DateTimeOffset.Parse("2023-08-08T00:00Z")).Is(P.TypeOf(GType.DateTime)).Aggregate("a").Cap<object>("a")}},
- {"g_injectXdatetimeX_isXtypeOfXGType_DATETIMEXX_groupCount",
new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>>
{(g,p)
=>g.Inject<object>(DateTimeOffset.Parse("2023-08-08T00:00Z")).Is(P.TypeOf(GType.DateTime)).GroupCount<object>()}},
+ {"g_injectXdatetimeX_isXtypeOfXGType_DATETIMEXX_groupCount",
new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>>
{(g,p)
=>g.Inject<object>(DateTimeOffset.Parse("2023-08-08T12:34:56Z")).Is(P.TypeOf(GType.DateTime)).GroupCount<object>()}},
{"g_V_valuesXdoubleX_isXtypeOfXGType_DOUBLEXX", new
List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>>
{(g,p) =>g.AddV((string) "data").Property("double", 1.5d), (g,p)
=>g.V().Values<object>("double").Is(P.TypeOf(GType.Double))}},
{"g_E_valuesXweightX_isXtypeOfXGType_DOUBLEXX", new
List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>>
{(g,p) =>g.E().Values<object>("weight").Is(P.TypeOf(GType.Double))}},
{"g_V_valuesXdoubleX_isXtypeOfXGType_DOUBLEXX_mathXceilX", new
List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>>
{(g,p) =>g.AddV((string) "data").Property("double", 2.7d), (g,p)
=>g.V().Values<object>("double").Is(P.TypeOf(GType.Double)).Math("ceil _")}},
diff --git a/gremlin-dotnet/test/Gremlin.Net.UnitTest/Driver/ConnectionTests.cs
b/gremlin-dotnet/test/Gremlin.Net.UnitTest/Driver/ConnectionTests.cs
index 9857552a07..ca499380ba 100644
--- a/gremlin-dotnet/test/Gremlin.Net.UnitTest/Driver/ConnectionTests.cs
+++ b/gremlin-dotnet/test/Gremlin.Net.UnitTest/Driver/ConnectionTests.cs
@@ -33,6 +33,7 @@ using System.Threading;
using System.Threading.Tasks;
using Gremlin.Net.Driver;
using Gremlin.Net.Driver.Messages;
+using Gremlin.Net.Process.Traversal;
using Gremlin.Net.Structure.IO;
using NSubstitute;
using Xunit;
@@ -269,6 +270,13 @@ namespace Gremlin.Net.UnitTest.Driver
private static IMessageSerializer CreateMockSerializer(
string mimeType = SerializationTokens.GraphBinary4MimeType)
+ {
+ return CreateMockSerializer(new List<object>(), mimeType);
+ }
+
+ private static IMessageSerializer CreateMockSerializer(
+ List<object> results,
+ string mimeType = SerializationTokens.GraphBinary4MimeType)
{
var serializer = Substitute.For<IMessageSerializer>();
serializer.MimeType.Returns(mimeType);
@@ -276,7 +284,7 @@ namespace Gremlin.Net.UnitTest.Driver
.Returns(Task.FromResult(new byte[] { 0x84 }));
serializer.DeserializeMessageAsync(Arg.Any<byte[]>(),
Arg.Any<CancellationToken>())
.Returns(Task.FromResult(
- new ResponseMessage<List<object>>(false, new
List<object>(), 200, null, null)));
+ new ResponseMessage<List<object>>(false, results, 200,
null, null)));
return serializer;
}
@@ -942,6 +950,57 @@ namespace Gremlin.Net.UnitTest.Driver
h => h.MediaType == "application/vnd.custom-response-v2.0");
}
+ [Fact]
+ public async Task ShouldBoxNonTraverserResultsIntoTraversers()
+ {
+ var (httpClient, _) = CreateMockHttpClient();
+ var serializer = CreateMockSerializer(new List<object> { "hello",
42 });
+ var settings = new ConnectionSettings();
+ using var connection = new Connection(TestUri, serializer,
serializer, settings, httpClient);
+
+ var result = await
connection.SubmitAsync<Traverser>(CreateTestRequest());
+
+ var items = result.ToList();
+ Assert.Equal(2, items.Count);
+ Assert.Equal("hello", items[0].Object);
+ Assert.Equal(1, items[0].Bulk);
+ Assert.Equal(42, items[1].Object);
+ Assert.Equal(1, items[1].Bulk);
+ }
+
+ [Fact]
+ public async Task ShouldNotDoubleBoxTraverserResults()
+ {
+ var (httpClient, _) = CreateMockHttpClient();
+ var serializer = CreateMockSerializer(new List<object> { new
Traverser("existing", 5) });
+ var settings = new ConnectionSettings();
+ using var connection = new Connection(TestUri, serializer,
serializer, settings, httpClient);
+
+ var result = await
connection.SubmitAsync<Traverser>(CreateTestRequest());
+
+ var item = result.Single();
+ Assert.Equal("existing", item.Object);
+ Assert.Equal(5, item.Bulk);
+ }
+
+ [Fact]
+ public async Task ShouldBoxMixedTraverserAndNonTraverserResults()
+ {
+ var (httpClient, _) = CreateMockHttpClient();
+ var serializer = CreateMockSerializer(new List<object> { new
Traverser("already", 3), "raw" });
+ var settings = new ConnectionSettings();
+ using var connection = new Connection(TestUri, serializer,
serializer, settings, httpClient);
+
+ var result = await
connection.SubmitAsync<Traverser>(CreateTestRequest());
+
+ var items = result.ToList();
+ Assert.Equal(2, items.Count);
+ Assert.Equal("already", items[0].Object);
+ Assert.Equal(3, items[0].Bulk);
+ Assert.Equal("raw", items[1].Object);
+ Assert.Equal(1, items[1].Bulk);
+ }
+
/// <summary>
/// A test HttpMessageHandler that captures the request and
returns a canned response.
/// </summary>
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 f1a78c1ae2..3167499c45 100644
---
a/gremlin-dotnet/test/Gremlin.Net.UnitTest/Process/Traversal/GremlinLangTests.cs
+++
b/gremlin-dotnet/test/Gremlin.Net.UnitTest/Process/Traversal/GremlinLangTests.cs
@@ -470,14 +470,14 @@ namespace Gremlin.Net.UnitTest.Process.Traversal
[Fact]
public void g_AddV_test_Property_date_DateTimeOffset()
{
-
Assert.Equal("g.addV(\"test\").property(\"date\",datetime(\"2021-02-01T09:30:00Z\"))",
+
Assert.Equal("g.addV(\"test\").property(\"date\",datetime(\"2021-02-01T09:30:00.000Z\"))",
_g.AddV("test").Property("date", new DateTimeOffset(2021, 2,
1, 9, 30, 0, TimeSpan.Zero)).GremlinLang.GetGremlin());
}
[Fact]
public void g_AddV_test_Property_date_DateTimeOffset_midnight()
{
-
Assert.Equal("g.addV(\"test\").property(\"date\",datetime(\"2021-02-01T00:00:00Z\"))",
+
Assert.Equal("g.addV(\"test\").property(\"date\",datetime(\"2021-02-01T00:00:00.000Z\"))",
_g.AddV("test").Property("date", new DateTimeOffset(2021, 2,
1, 0, 0, 0, TimeSpan.Zero)).GremlinLang.GetGremlin());
}
@@ -587,14 +587,14 @@ namespace Gremlin.Net.UnitTest.Process.Traversal
[Fact]
public void g_V_Has_date_DateTimeOffset()
{
-
Assert.Equal("g.V().has(\"date\",datetime(\"2021-02-22T00:00:00Z\"))",
+
Assert.Equal("g.V().has(\"date\",datetime(\"2021-02-22T00:00:00.000Z\"))",
_g.V().Has("date", new DateTimeOffset(2021, 2, 22, 0, 0, 0,
TimeSpan.Zero)).GremlinLang.GetGremlin());
}
[Fact]
public void g_V_Has_date_Within_dates()
{
-
Assert.Equal("g.V().has(\"date\",within([datetime(\"2021-02-22T00:00:00Z\"),datetime(\"2021-01-01T00:00:00Z\")]))",
+
Assert.Equal("g.V().has(\"date\",within([datetime(\"2021-02-22T00:00:00.000Z\"),datetime(\"2021-01-01T00:00:00.000Z\")]))",
_g.V().Has("date", P.Within(
new DateTimeOffset(2021, 2, 22, 0, 0, 0, TimeSpan.Zero),
new DateTimeOffset(2021, 1, 1, 0, 0, 0,
TimeSpan.Zero))).GremlinLang.GetGremlin());
@@ -603,7 +603,7 @@ namespace Gremlin.Net.UnitTest.Process.Traversal
[Fact]
public void g_V_Has_date_Between_dates()
{
-
Assert.Equal("g.V().has(\"date\",between(datetime(\"2021-01-01T00:00:00Z\"),datetime(\"2021-02-22T00:00:00Z\")))",
+
Assert.Equal("g.V().has(\"date\",between(datetime(\"2021-01-01T00:00:00.000Z\"),datetime(\"2021-02-22T00:00:00.000Z\")))",
_g.V().Has("date", P.Between(
new DateTimeOffset(2021, 1, 1, 0, 0, 0, TimeSpan.Zero),
new DateTimeOffset(2021, 2, 22, 0, 0, 0,
TimeSpan.Zero))).GremlinLang.GetGremlin());
@@ -612,7 +612,7 @@ namespace Gremlin.Net.UnitTest.Process.Traversal
[Fact]
public void g_V_Has_date_Inside_dates()
{
-
Assert.Equal("g.V().has(\"date\",inside(datetime(\"2021-01-01T00:00:00Z\"),datetime(\"2021-02-22T00:00:00Z\")))",
+
Assert.Equal("g.V().has(\"date\",inside(datetime(\"2021-01-01T00:00:00.000Z\"),datetime(\"2021-02-22T00:00:00.000Z\")))",
_g.V().Has("date", P.Inside(
new DateTimeOffset(2021, 1, 1, 0, 0, 0, TimeSpan.Zero),
new DateTimeOffset(2021, 2, 22, 0, 0, 0,
TimeSpan.Zero))).GremlinLang.GetGremlin());
@@ -621,7 +621,7 @@ namespace Gremlin.Net.UnitTest.Process.Traversal
[Fact]
public void g_V_Has_date_Gt_DateTimeOffset()
{
-
Assert.Equal("g.V().has(\"date\",gt(datetime(\"2021-01-01T09:30:00Z\")))",
+
Assert.Equal("g.V().has(\"date\",gt(datetime(\"2021-01-01T09:30:00.000Z\")))",
_g.V().Has("date", P.Gt(new DateTimeOffset(2021, 1, 1, 9, 30,
0, TimeSpan.Zero))).GremlinLang.GetGremlin());
}
diff --git a/gremlin-dotnet/test/pom.xml b/gremlin-dotnet/test/pom.xml
index 4e18f40088..a546d7f8a1 100644
--- a/gremlin-dotnet/test/pom.xml
+++ b/gremlin-dotnet/test/pom.xml
@@ -76,10 +76,9 @@ limitations under the License.
<id>gremlin-dotnet</id>
<activation>
<activeByDefault>false</activeByDefault>
- <!-- TODO re-enable after gremlin-dotnet is implemented -->
-<!-- <file>-->
-<!-- <exists>.glv</exists>-->
-<!-- </file>-->
+ <file>
+ <exists>.glv</exists>
+ </file>
</activation>
<build>
<finalName>${project.artifactId}-${project.version}</finalName>
diff --git a/gremlin-go/driver/cucumber/gremlin.go
b/gremlin-go/driver/cucumber/gremlin.go
index bfa80b3fa1..069e508ada 100644
--- a/gremlin-go/driver/cucumber/gremlin.go
+++ b/gremlin-go/driver/cucumber/gremlin.go
@@ -207,11 +207,11 @@ var translationMap = map[string][]func(g
*gremlingo.GraphTraversalSource, p map[
"g_V_valuesXdatetimeX_isXtypeOfXGType_DATETIMEXX": {func(g
*gremlingo.GraphTraversalSource, p map[string]interface{})
*gremlingo.GraphTraversal {return g.AddV("event").Property("datetime",
time.Date(2023, 8, 8, 0, 0, 0, 0, time.FixedZone("UTC+00:00", 0)))}, func(g
*gremlingo.GraphTraversalSource, p map[string]interface{})
*gremlingo.GraphTraversal {return
g.V().Values("datetime").Is(gremlingo.P.TypeOf(gremlingo.GType.DateTime))}},
"g_V_valuesXdatetimeX_isXtypeOfXGType_DATETIMEXX_project_byXidentityX_byXdateAddXDT_dayX1XX":
{func(g *gremlingo.GraphTraversalSource, p map[string]interface{})
*gremlingo.GraphTraversal {return g.AddV("event").Property("datetime",
time.Date(2023, 8, 8, 0, 0, 0, 0, time.FixedZone("UTC+00:00", 0)))}, func(g
*gremlingo.GraphTraversalSource, p map[string]interface{})
*gremlingo.GraphTraversal {return
g.V().Values("datetime").Is(gremlingo.P.TypeOf(gremlingo.GType.DateTime)).Project("orig
[...]
"g_V_valuesXdatetimeX_isXtypeOfXGType_DATETIMEXX_dateDiffXdatetimeX2023_08_10XX":
{func(g *gremlingo.GraphTraversalSource, p map[string]interface{})
*gremlingo.GraphTraversal {return g.AddV("event").Property("datetime",
time.Date(2023, 8, 8, 0, 0, 0, 0, time.FixedZone("UTC+00:00", 0)))}, func(g
*gremlingo.GraphTraversalSource, p map[string]interface{})
*gremlingo.GraphTraversal {return
g.V().Values("datetime").Is(gremlingo.P.TypeOf(gremlingo.GType.DateTime)).DateDiff(time.Date(2023,
[...]
-
"g_V_valuesXdatetimeX_isXtypeOfXGType_DATETIMEXX_whereXisXgtXdatetimeX2020_01_01XXXX":
{func(g *gremlingo.GraphTraversalSource, p map[string]interface{})
*gremlingo.GraphTraversal {return g.AddV("event").Property("datetime",
time.Date(2023, 8, 8, 0, 0, 0, 0, time.FixedZone("UTC+00:00", 0)))}, func(g
*gremlingo.GraphTraversalSource, p map[string]interface{})
*gremlingo.GraphTraversal {return
g.V().Values("datetime").Is(gremlingo.P.TypeOf(gremlingo.GType.DateTime)).Where(gremlingo.T__.
[...]
+
"g_V_valuesXdatetimeX_isXtypeOfXGType_DATETIMEXX_whereXisXgtXdatetimeX2020_01_01XXXX":
{func(g *gremlingo.GraphTraversalSource, p map[string]interface{})
*gremlingo.GraphTraversal {return g.AddV("event").Property("datetime",
time.Date(2023, 8, 8, 12, 34, 56, 0, time.FixedZone("UTC+00:00", 0)))}, func(g
*gremlingo.GraphTraversalSource, p map[string]interface{})
*gremlingo.GraphTraversal {return
g.V().Values("datetime").Is(gremlingo.P.TypeOf(gremlingo.GType.DateTime)).Where(gremlingo.T
[...]
"g_V_valuesXdatetimeX_isXtypeOfXGType_DATETIMEXX_chooseXisXeqXdatetimeX2023_08_08XXXX_constantXmatchX_constantXnoMatchXX":
{func(g *gremlingo.GraphTraversalSource, p map[string]interface{})
*gremlingo.GraphTraversal {return g.AddV("event").Property("datetime",
time.Date(2023, 8, 8, 0, 0, 0, 0, time.FixedZone("UTC+00:00", 0)))}, func(g
*gremlingo.GraphTraversalSource, p map[string]interface{})
*gremlingo.GraphTraversal {return
g.V().Values("datetime").Is(gremlingo.P.TypeOf(gremlingo.G [...]
"g_V_valuesXdatetimeX_isXtypeOfXGType_DATETIMEXX_localXaggregateXaX_capXaX":
{func(g *gremlingo.GraphTraversalSource, p map[string]interface{})
*gremlingo.GraphTraversal {return g.AddV("event").Property("datetime",
time.Date(2023, 8, 8, 0, 0, 0, 0, time.FixedZone("UTC+00:00", 0)))}, func(g
*gremlingo.GraphTraversalSource, p map[string]interface{})
*gremlingo.GraphTraversal {return
g.V().Values("datetime").Is(gremlingo.P.TypeOf(gremlingo.GType.DateTime)).Local(gremlingo.T__.Aggregate(
[...]
"g_injectXdatetimeX_isXtypeOfXGType_DATETIMEXX_aggregateXaX_capXaX":
{func(g *gremlingo.GraphTraversalSource, p map[string]interface{})
*gremlingo.GraphTraversal {return g.Inject(time.Date(2023, 8, 8, 0, 0, 0, 0,
time.FixedZone("UTC+00:00",
0))).Is(gremlingo.P.TypeOf(gremlingo.GType.DateTime)).Aggregate("a").Cap("a")}},
- "g_injectXdatetimeX_isXtypeOfXGType_DATETIMEXX_groupCount": {func(g
*gremlingo.GraphTraversalSource, p map[string]interface{})
*gremlingo.GraphTraversal {return g.Inject(time.Date(2023, 8, 8, 0, 0, 0, 0,
time.FixedZone("UTC+00:00",
0))).Is(gremlingo.P.TypeOf(gremlingo.GType.DateTime)).GroupCount()}},
+ "g_injectXdatetimeX_isXtypeOfXGType_DATETIMEXX_groupCount": {func(g
*gremlingo.GraphTraversalSource, p map[string]interface{})
*gremlingo.GraphTraversal {return g.Inject(time.Date(2023, 8, 8, 12, 34, 56, 0,
time.FixedZone("UTC+00:00",
0))).Is(gremlingo.P.TypeOf(gremlingo.GType.DateTime)).GroupCount()}},
"g_V_valuesXdoubleX_isXtypeOfXGType_DOUBLEXX": {func(g
*gremlingo.GraphTraversalSource, p map[string]interface{})
*gremlingo.GraphTraversal {return g.AddV("data").Property("double", 1.5)},
func(g *gremlingo.GraphTraversalSource, p map[string]interface{})
*gremlingo.GraphTraversal {return
g.V().Values("double").Is(gremlingo.P.TypeOf(gremlingo.GType.Double))}},
"g_E_valuesXweightX_isXtypeOfXGType_DOUBLEXX": {func(g
*gremlingo.GraphTraversalSource, p map[string]interface{})
*gremlingo.GraphTraversal {return
g.E().Values("weight").Is(gremlingo.P.TypeOf(gremlingo.GType.Double))}},
"g_V_valuesXdoubleX_isXtypeOfXGType_DOUBLEXX_mathXceilX": {func(g
*gremlingo.GraphTraversalSource, p map[string]interface{})
*gremlingo.GraphTraversal {return g.AddV("data").Property("double", 2.7)},
func(g *gremlingo.GraphTraversalSource, p map[string]interface{})
*gremlingo.GraphTraversal {return
g.V().Values("double").Is(gremlingo.P.TypeOf(gremlingo.GType.Double)).Math("ceil
_")}},
diff --git a/gremlin-js/gremlin-javascript/test/cucumber/gremlin.js
b/gremlin-js/gremlin-javascript/test/cucumber/gremlin.js
index 008c9d96df..66138f47f6 100644
--- a/gremlin-js/gremlin-javascript/test/cucumber/gremlin.js
+++ b/gremlin-js/gremlin-javascript/test/cucumber/gremlin.js
@@ -238,11 +238,11 @@ const gremlins = {
g_V_valuesXdatetimeX_isXtypeOfXGType_DATETIMEXX: [function({g}) { return
g.addV("event").property("datetime", new Date('2023-08-08T00:00Z')) },
function({g}) { return g.V().values("datetime").is(P.typeOf(GType.datetime))
}],
g_V_valuesXdatetimeX_isXtypeOfXGType_DATETIMEXX_project_byXidentityX_byXdateAddXDT_dayX1XX:
[function({g}) { return g.addV("event").property("datetime", new
Date('2023-08-08T00:00Z')) }, function({g}) { return
g.V().values("datetime").is(P.typeOf(GType.datetime)).project("original",
"nextDay").by(__.identity()).by(__.dateAdd(DT.day, 1)) }],
g_V_valuesXdatetimeX_isXtypeOfXGType_DATETIMEXX_dateDiffXdatetimeX2023_08_10XX:
[function({g}) { return g.addV("event").property("datetime", new
Date('2023-08-08T00:00Z')) }, function({g}) { return
g.V().values("datetime").is(P.typeOf(GType.datetime)).dateDiff(new
Date('2023-08-08T00:00:30Z')) }],
-
g_V_valuesXdatetimeX_isXtypeOfXGType_DATETIMEXX_whereXisXgtXdatetimeX2020_01_01XXXX:
[function({g}) { return g.addV("event").property("datetime", new
Date('2023-08-08T00:00Z')) }, function({g}) { return
g.V().values("datetime").is(P.typeOf(GType.datetime)).where(__.is(P.gt(new
Date('2020-01-01T00:00Z')))) }],
+
g_V_valuesXdatetimeX_isXtypeOfXGType_DATETIMEXX_whereXisXgtXdatetimeX2020_01_01XXXX:
[function({g}) { return g.addV("event").property("datetime", new
Date('2023-08-08T12:34:56Z')) }, function({g}) { return
g.V().values("datetime").is(P.typeOf(GType.datetime)).where(__.is(P.gt(new
Date('2020-01-01T00:00Z')))) }],
g_V_valuesXdatetimeX_isXtypeOfXGType_DATETIMEXX_chooseXisXeqXdatetimeX2023_08_08XXXX_constantXmatchX_constantXnoMatchXX:
[function({g}) { return g.addV("event").property("datetime", new
Date('2023-08-08T00:00Z')) }, function({g}) { return
g.V().values("datetime").is(P.typeOf(GType.datetime)).choose(__.is(P.eq(new
Date('2023-08-08T00:00Z'))), __.constant("match"), __.constant("noMatch")) }],
g_V_valuesXdatetimeX_isXtypeOfXGType_DATETIMEXX_localXaggregateXaX_capXaX:
[function({g}) { return g.addV("event").property("datetime", new
Date('2023-08-08T00:00Z')) }, function({g}) { return
g.V().values("datetime").is(P.typeOf(GType.datetime)).local(__.aggregate("a")).cap("a")
}],
g_injectXdatetimeX_isXtypeOfXGType_DATETIMEXX_aggregateXaX_capXaX:
[function({g}) { return g.inject(new
Date('2023-08-08T00:00Z')).is(P.typeOf(GType.datetime)).aggregate("a").cap("a")
}],
- g_injectXdatetimeX_isXtypeOfXGType_DATETIMEXX_groupCount: [function({g}) {
return g.inject(new
Date('2023-08-08T00:00Z')).is(P.typeOf(GType.datetime)).groupCount() }],
+ g_injectXdatetimeX_isXtypeOfXGType_DATETIMEXX_groupCount: [function({g}) {
return g.inject(new
Date('2023-08-08T12:34:56Z')).is(P.typeOf(GType.datetime)).groupCount() }],
g_V_valuesXdoubleX_isXtypeOfXGType_DOUBLEXX: [function({g}) { return
g.addV("data").property("double", 1.5) }, function({g}) { return
g.V().values("double").is(P.typeOf(GType.double)) }],
g_E_valuesXweightX_isXtypeOfXGType_DOUBLEXX: [function({g}) { return
g.E().values("weight").is(P.typeOf(GType.double)) }],
g_V_valuesXdoubleX_isXtypeOfXGType_DOUBLEXX_mathXceilX: [function({g}) {
return g.addV("data").property("double", 2.7) }, function({g}) { return
g.V().values("double").is(P.typeOf(GType.double)).math("ceil _") }],
diff --git a/gremlin-python/src/main/python/tests/feature/gremlin.py
b/gremlin-python/src/main/python/tests/feature/gremlin.py
index e8f87ae80f..d1cfbf06ab 100644
--- a/gremlin-python/src/main/python/tests/feature/gremlin.py
+++ b/gremlin-python/src/main/python/tests/feature/gremlin.py
@@ -210,11 +210,11 @@ world.gremlins = {
'g_V_valuesXdatetimeX_isXtypeOfXGType_DATETIMEXX': [(lambda
g:g.add_v('event').property('datetime',
datetime.datetime.fromisoformat('2023-08-08T00:00+00:00'))), (lambda
g:g.V().values('datetime').is_(P.type_of(GType.DATETIME)))],
'g_V_valuesXdatetimeX_isXtypeOfXGType_DATETIMEXX_project_byXidentityX_byXdateAddXDT_dayX1XX':
[(lambda g:g.add_v('event').property('datetime',
datetime.datetime.fromisoformat('2023-08-08T00:00+00:00'))), (lambda
g:g.V().values('datetime').is_(P.type_of(GType.DATETIME)).project('original',
'nextDay').by(__.identity()).by(__.date_add(DT.day, 1)))],
'g_V_valuesXdatetimeX_isXtypeOfXGType_DATETIMEXX_dateDiffXdatetimeX2023_08_10XX':
[(lambda g:g.add_v('event').property('datetime',
datetime.datetime.fromisoformat('2023-08-08T00:00+00:00'))), (lambda
g:g.V().values('datetime').is_(P.type_of(GType.DATETIME)).date_diff(datetime.datetime.fromisoformat('2023-08-08T00:00:30+00:00')))],
-
'g_V_valuesXdatetimeX_isXtypeOfXGType_DATETIMEXX_whereXisXgtXdatetimeX2020_01_01XXXX':
[(lambda g:g.add_v('event').property('datetime',
datetime.datetime.fromisoformat('2023-08-08T00:00+00:00'))), (lambda
g:g.V().values('datetime').is_(P.type_of(GType.DATETIME)).where(__.is_(P.gt(datetime.datetime.fromisoformat('2020-01-01T00:00+00:00')))))],
+
'g_V_valuesXdatetimeX_isXtypeOfXGType_DATETIMEXX_whereXisXgtXdatetimeX2020_01_01XXXX':
[(lambda g:g.add_v('event').property('datetime',
datetime.datetime.fromisoformat('2023-08-08T12:34:56+00:00'))), (lambda
g:g.V().values('datetime').is_(P.type_of(GType.DATETIME)).where(__.is_(P.gt(datetime.datetime.fromisoformat('2020-01-01T00:00+00:00')))))],
'g_V_valuesXdatetimeX_isXtypeOfXGType_DATETIMEXX_chooseXisXeqXdatetimeX2023_08_08XXXX_constantXmatchX_constantXnoMatchXX':
[(lambda g:g.add_v('event').property('datetime',
datetime.datetime.fromisoformat('2023-08-08T00:00+00:00'))), (lambda
g:g.V().values('datetime').is_(P.type_of(GType.DATETIME)).choose(__.is_(P.eq(datetime.datetime.fromisoformat('2023-08-08T00:00+00:00'))),
__.constant('match'), __.constant('noMatch')))],
'g_V_valuesXdatetimeX_isXtypeOfXGType_DATETIMEXX_localXaggregateXaX_capXaX':
[(lambda g:g.add_v('event').property('datetime',
datetime.datetime.fromisoformat('2023-08-08T00:00+00:00'))), (lambda
g:g.V().values('datetime').is_(P.type_of(GType.DATETIME)).local(__.aggregate('a')).cap('a'))],
'g_injectXdatetimeX_isXtypeOfXGType_DATETIMEXX_aggregateXaX_capXaX':
[(lambda
g:g.inject(datetime.datetime.fromisoformat('2023-08-08T00:00+00:00')).is_(P.type_of(GType.DATETIME)).aggregate('a').cap('a'))],
- 'g_injectXdatetimeX_isXtypeOfXGType_DATETIMEXX_groupCount': [(lambda
g:g.inject(datetime.datetime.fromisoformat('2023-08-08T00:00+00:00')).is_(P.type_of(GType.DATETIME)).group_count())],
+ 'g_injectXdatetimeX_isXtypeOfXGType_DATETIMEXX_groupCount': [(lambda
g:g.inject(datetime.datetime.fromisoformat('2023-08-08T12:34:56+00:00')).is_(P.type_of(GType.DATETIME)).group_count())],
'g_V_valuesXdoubleX_isXtypeOfXGType_DOUBLEXX': [(lambda
g:g.add_v('data').property('double', 1.5)), (lambda
g:g.V().values('double').is_(P.type_of(GType.DOUBLE)))],
'g_E_valuesXweightX_isXtypeOfXGType_DOUBLEXX': [(lambda
g:g.E().values('weight').is_(P.type_of(GType.DOUBLE)))],
'g_V_valuesXdoubleX_isXtypeOfXGType_DOUBLEXX_mathXceilX': [(lambda
g:g.add_v('data').property('double', 2.7)), (lambda
g:g.V().values('double').is_(P.type_of(GType.DOUBLE)).math('ceil _'))],
diff --git
a/gremlin-python/src/main/python/tests/unit/process/test_gremlin_lang.py
b/gremlin-python/src/main/python/tests/unit/process/test_gremlin_lang.py
index 52939aca9b..b4c738a7ac 100644
--- a/gremlin-python/src/main/python/tests/unit/process/test_gremlin_lang.py
+++ b/gremlin-python/src/main/python/tests/unit/process/test_gremlin_lang.py
@@ -28,7 +28,7 @@ from gremlin_python.statics import SingleByte, short, long,
bigint, BigDecimal
from gremlin_python.structure.graph import Graph, Vertex, Edge, VertexProperty
from gremlin_python.process.anonymous_traversal import traversal
from gremlin_python.process.graph_traversal import __
-from datetime import datetime
+from datetime import datetime, timezone, timedelta
class TestGremlinLang(object):
@@ -470,6 +470,16 @@ class TestGremlinLang(object):
tests.append([g.inject(uuid.UUID('9b8d8a9c-61c2-43e5-9cc8-c27b9261290e')),
'g.inject(UUID("9b8d8a9c-61c2-43e5-9cc8-c27b9261290e"))'])
+ # 119
+ tests.append([g.add_v('test').property('date', datetime(2021, 2, 1, 9,
30, tzinfo=timezone.utc)),
+
"g.addV('test').property('date',datetime(\"2021-02-01T09:30:00+00:00\"))"])
+ # 120
+ tests.append([g.add_v('test').property('date', datetime(2021, 2, 1, 9,
30, tzinfo=timezone(timedelta(hours=7)))),
+
"g.addV('test').property('date',datetime(\"2021-02-01T09:30:00+07:00\"))"])
+ # 121
+ tests.append([g.add_v('test').property('date', datetime(2021, 2, 1, 9,
30, tzinfo=timezone(timedelta(hours=-5)))),
+
"g.addV('test').property('date',datetime(\"2021-02-01T09:30:00-05:00\"))"])
+
for t in range(len(tests)):
gremlin_lang = tests[t][0].gremlin_lang.get_gremlin()
assert gremlin_lang == tests[t][1]
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 579faea9e3..04249b8786 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
@@ -3309,16 +3309,16 @@
"scenario":
"g_V_valuesXdatetimeX_isXtypeOfXGType_DATETIMEXX_whereXisXgtXdatetimeX2020_01_01XXXX",
"traversals": [
{
- "original": "g.addV(\"event\").property(\"datetime\",
datetime(\"2023-08-08T00:00:00Z\"))",
- "language": "g.addV(\"event\").property(\"datetime\",
datetime(\"2023-08-08T00:00:00Z\"))",
- "canonical": "g.addV(\"event\").property(\"datetime\",
datetime(\"2023-08-08T00:00:00Z\"))",
+ "original": "g.addV(\"event\").property(\"datetime\",
datetime(\"2023-08-08T12:34:56Z\"))",
+ "language": "g.addV(\"event\").property(\"datetime\",
datetime(\"2023-08-08T12:34:56Z\"))",
+ "canonical": "g.addV(\"event\").property(\"datetime\",
datetime(\"2023-08-08T12:34:56Z\"))",
"anonymized": "g.addV(string0).property(string1,
offsetdatetime0)",
- "dotnet": "g.AddV((string) \"event\").Property(\"datetime\",
DateTimeOffset.Parse(\"2023-08-08T00:00Z\"))",
- "go": "g.AddV(\"event\").Property(\"datetime\",
time.Date(2023, 8, 8, 0, 0, 0, 0, time.FixedZone(\"UTC+00:00\", 0)))",
- "groovy": "g.addV(\"event\").property(\"datetime\",
datetime(\"2023-08-08T00:00:00Z\"))",
- "java": "g.addV(\"event\").property(\"datetime\",
OffsetDateTime.parse(\"2023-08-08T00:00Z\"))",
- "javascript": "g.addV(\"event\").property(\"datetime\", new
Date('2023-08-08T00:00Z'))",
- "python": "g.add_v('event').property('datetime',
datetime.datetime.fromisoformat('2023-08-08T00:00+00:00'))"
+ "dotnet": "g.AddV((string) \"event\").Property(\"datetime\",
DateTimeOffset.Parse(\"2023-08-08T12:34:56Z\"))",
+ "go": "g.AddV(\"event\").Property(\"datetime\",
time.Date(2023, 8, 8, 12, 34, 56, 0, time.FixedZone(\"UTC+00:00\", 0)))",
+ "groovy": "g.addV(\"event\").property(\"datetime\",
datetime(\"2023-08-08T12:34:56Z\"))",
+ "java": "g.addV(\"event\").property(\"datetime\",
OffsetDateTime.parse(\"2023-08-08T12:34:56Z\"))",
+ "javascript": "g.addV(\"event\").property(\"datetime\", new
Date('2023-08-08T12:34:56Z'))",
+ "python": "g.add_v('event').property('datetime',
datetime.datetime.fromisoformat('2023-08-08T12:34:56+00:00'))"
},
{
"original":
"g.V().values(\"datetime\").is(P.typeOf(GType.DATETIME)).where(__.is(P.gt(datetime(\"2020-01-01T00:00:00Z\"))))",
@@ -3413,16 +3413,16 @@
"scenario": "g_injectXdatetimeX_isXtypeOfXGType_DATETIMEXX_groupCount",
"traversals": [
{
- "original":
"g.inject(datetime(\"2023-08-08T00:00:00Z\")).is(P.typeOf(GType.DATETIME)).groupCount()",
- "language":
"g.inject(datetime(\"2023-08-08T00:00:00Z\")).is(P.typeOf(GType.DATETIME)).groupCount()",
- "canonical":
"g.inject(datetime(\"2023-08-08T00:00:00Z\")).is(P.typeOf(GType.DATETIME)).groupCount()",
+ "original":
"g.inject(datetime(\"2023-08-08T12:34:56Z\")).is(P.typeOf(GType.DATETIME)).groupCount()",
+ "language":
"g.inject(datetime(\"2023-08-08T12:34:56Z\")).is(P.typeOf(GType.DATETIME)).groupCount()",
+ "canonical":
"g.inject(datetime(\"2023-08-08T12:34:56Z\")).is(P.typeOf(GType.DATETIME)).groupCount()",
"anonymized":
"g.inject(offsetdatetime0).is(P.typeOf(GType.DATETIME)).groupCount()",
- "dotnet":
"g.Inject<object>(DateTimeOffset.Parse(\"2023-08-08T00:00Z\")).Is(P.TypeOf(GType.DateTime)).GroupCount<object>()",
- "go": "g.Inject(time.Date(2023, 8, 8, 0, 0, 0, 0,
time.FixedZone(\"UTC+00:00\",
0))).Is(gremlingo.P.TypeOf(gremlingo.GType.DateTime)).GroupCount()",
- "groovy":
"g.inject(datetime(\"2023-08-08T00:00:00Z\")).is(P.typeOf(GType.DATETIME)).groupCount()",
- "java":
"g.inject(OffsetDateTime.parse(\"2023-08-08T00:00Z\")).is(P.typeOf(GType.DATETIME)).groupCount()",
- "javascript": "g.inject(new
Date('2023-08-08T00:00Z')).is(P.typeOf(GType.datetime)).groupCount()",
- "python":
"g.inject(datetime.datetime.fromisoformat('2023-08-08T00:00+00:00')).is_(P.type_of(GType.DATETIME)).group_count()"
+ "dotnet":
"g.Inject<object>(DateTimeOffset.Parse(\"2023-08-08T12:34:56Z\")).Is(P.TypeOf(GType.DateTime)).GroupCount<object>()",
+ "go": "g.Inject(time.Date(2023, 8, 8, 12, 34, 56, 0,
time.FixedZone(\"UTC+00:00\",
0))).Is(gremlingo.P.TypeOf(gremlingo.GType.DateTime)).GroupCount()",
+ "groovy":
"g.inject(datetime(\"2023-08-08T12:34:56Z\")).is(P.typeOf(GType.DATETIME)).groupCount()",
+ "java":
"g.inject(OffsetDateTime.parse(\"2023-08-08T12:34:56Z\")).is(P.typeOf(GType.DATETIME)).groupCount()",
+ "javascript": "g.inject(new
Date('2023-08-08T12:34:56Z')).is(P.typeOf(GType.datetime)).groupCount()",
+ "python":
"g.inject(datetime.datetime.fromisoformat('2023-08-08T12:34:56+00:00')).is_(P.type_of(GType.DATETIME)).group_count()"
}
]
},
diff --git
a/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/data/DateTime.feature
b/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/data/DateTime.feature
index 06956a9185..338b196fd0 100644
---
a/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/data/DateTime.feature
+++
b/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/data/DateTime.feature
@@ -71,7 +71,7 @@ Feature: Data - DATETIME
Given the empty graph
And the graph initializer of
"""
- g.addV("event").property("datetime", datetime("2023-08-08T00:00:00Z"))
+ g.addV("event").property("datetime", datetime("2023-08-08T12:34:56Z"))
"""
And the traversal of
"""
@@ -80,7 +80,7 @@ Feature: Data - DATETIME
When iterated to list
Then the result should be unordered
| result |
- | dt[2023-08-08T00:00:00Z] |
+ | dt[2023-08-08T12:34:56Z] |
@AllowDateTimePropertyValues
Scenario:
g_V_valuesXdatetimeX_isXtypeOfXGType_DATETIMEXX_chooseXisXeqXdatetimeX2023_08_08XXXX_constantXmatchX_constantXnoMatchXX
@@ -131,9 +131,9 @@ Feature: Data - DATETIME
Given the empty graph
And the traversal of
"""
-
g.inject(datetime("2023-08-08T00:00:00Z")).is(P.typeOf(GType.DATETIME)).groupCount()
+
g.inject(datetime("2023-08-08T12:34:56Z")).is(P.typeOf(GType.DATETIME)).groupCount()
"""
When iterated to list
Then the result should be unordered
| result |
- | m[{"dt[2023-08-08T00:00:00Z]":"d[1].l"}] |
+ | m[{"dt[2023-08-08T12:34:56Z]":"d[1].l"}] |
