This is an automated email from the ASF dual-hosted git repository.
xiazcy pushed a commit to branch type-enum-poc
in repository https://gitbox.apache.org/repos/asf/tinkerpop.git
commit 13a51e9dfb61b8856230899edae39b80e51b1ad8
Author: xiazcy <xia...@gmail.com>
AuthorDate: Mon Jul 28 19:38:29 2025 -0700
handled overflow edge cases in bigint conversion and refactored coerceTo
and castTo to use the same conversion logic in NumberHelper. Removed `n` from N
enum value in Grammar, and used `_` suffix for keyword collisions in
Java/Groovy/JS.
---
docs/src/reference/the-traversal.asciidoc | 19 +-
docs/src/upgrade/release-3.8.x.asciidoc | 14 +-
.../language/grammar/GenericLiteralVisitor.java | 5 +
.../language/grammar/TraversalEnumParser.java | 11 +
.../language/grammar/TraversalMethodVisitor.java | 2 +-
.../translator/GroovyTranslateVisitor.java | 9 +
.../language/translator/JavaTranslateVisitor.java | 11 +
.../translator/JavascriptTranslateVisitor.java | 9 +
.../tinkerpop/gremlin/process/traversal/N.java | 26 +--
.../io/binary/TypeSerializerRegistry.java | 49 +----
.../structure/io/binary/types/EnumSerializer.java | 1 -
.../structure/io/binary/types/NSerializer.java | 46 ++++
.../structure/io/graphson/GraphSONModule.java | 8 +-
.../io/graphson/TraversalSerializersV2.java | 40 +++-
.../io/graphson/TraversalSerializersV3.java | 40 +++-
.../tinkerpop/gremlin/util/NumberHelper.java | 88 ++++----
.../grammar/GeneralLiteralVisitorTest.java | 38 +++-
.../language/translator/GremlinTranslatorTest.java | 18 ++
.../traversal/step/map/AsNumberStepTest.java | 236 +++++++++++----------
.../tinkerpop/gremlin/util/NumberHelperTest.java | 30 +--
.../src/Gremlin.Net/Process/Traversal/N.cs | 32 +--
.../Gremlin.Net.IntegrationTest/Gherkin/Gremlin.cs | 24 +--
gremlin-go/driver/cucumber/gremlin.go | 24 +--
gremlin-go/driver/serializer.go | 2 +-
gremlin-go/driver/traversal.go | 32 +--
.../gremlin-javascript/lib/process/traversal.js | 10 +-
.../gremlin-javascript/test/cucumber/gremlin.js | 24 +--
.../test/unit/graphbinary/AnySerializer-test.js | 6 +-
.../test/unit/graphbinary/EnumSerializer-test.js | 1 +
gremlin-language/src/main/antlr4/Gremlin.g4 | 16 +-
.../language/corpus/DocumentationReader.java | 4 +-
.../python/gremlin_python/process/traversal.py | 21 +-
gremlin-python/src/main/python/radish/gremlin.py | 24 +--
.../tests/driver/test_driver_remote_connection.py | 2 +-
.../gremlin/test/features/map/AsNumber.feature | 46 ++--
35 files changed, 577 insertions(+), 391 deletions(-)
diff --git a/docs/src/reference/the-traversal.asciidoc
b/docs/src/reference/the-traversal.asciidoc
index 550a1af3d3..6b587212f3 100644
--- a/docs/src/reference/the-traversal.asciidoc
+++ b/docs/src/reference/the-traversal.asciidoc
@@ -844,9 +844,9 @@ All other input types will result in
`IllegalArgumentException`.
----
g.inject(1234).asNumber() <1>
g.inject(1.76).asNumber() <2>
-g.inject(1.76).asNumber(N.nint) <3>
+g.inject(1.76).asNumber(N.int_) <3>
g.inject("1b").asNumber() <4>
-g.inject(33550336).asNumber(N.nbyte) <5>
+g.inject(33550336).asNumber(N.byte_) <5>
----
<1> An int will be passed through.
@@ -855,6 +855,21 @@ g.inject(33550336).asNumber(N.nbyte) <5>
<4> String containing any character other than numerical ones will result in
`NumberFormatException`.
<5> Narrowing of int to byte that overflows will throw `ArithmeticException`.
+[NOTE, caption=Java]
+====
+The enums values `byte`, `short`, `int`, `long`, `float`, `double` are
reserved word in Java, and therefore must be referred to in Gremlin with an
underscore appended as a suffix: `byte_`, `short_`, `int_`, `long_`, `float_`,
`double_`.
+====
+
+[NOTE, caption=Groovy & Gremlin Console]
+====
+The enums values `byte`, `short`, `int`, `long`, `float`, `double` are
reserved word in Groovy, therefore as the Gremlin Console is Groovy-based, they
must be referred to in Gremlin with an underscore appended as a suffix:
`byte_`, `short_`, `int_`, `long_`, `float_`, `double_`.
+====
+
+[NOTE, caption=JavaScript]
+====
+The enums values `byte`, `short`, `int`, `long`, `float`, `double` are
reserved word in Javascript, and therefore must be referred to in Gremlin with
an underscore appended as a suffix: `byte_`, `short_`, `int_`, `long_`,
`float_`, `double_`.
+====
+
*Additional References*
link:++https://tinkerpop.apache.org/javadocs/x.y.z/core/org/apache/tinkerpop/gremlin/process/traversal/dsl/graph/GraphTraversal.html#asNumber()++[`asNumber()`]
diff --git a/docs/src/upgrade/release-3.8.x.asciidoc
b/docs/src/upgrade/release-3.8.x.asciidoc
index 31e9738afc..2ca45e6322 100644
--- a/docs/src/upgrade/release-3.8.x.asciidoc
+++ b/docs/src/upgrade/release-3.8.x.asciidoc
@@ -51,7 +51,7 @@ gremlin> g.inject(1.0, 2l, 3, "4", "0x5").asNumber().sum()
==>15.0
// given sum() step returned a double, one can use asNumber() to further cast
the result into desired type
-gremlin> g.inject(1.0, 2l, 3, "4", "0x5").asNumber().sum().asNumber(N.nint)
+gremlin> g.inject(1.0, 2l, 3, "4", "0x5").asNumber().sum().asNumber(N.int_)
==>15
----
@@ -61,11 +61,11 @@ Numerical input will pass through unless a type is
specified by the number token
[source,text]
----
-gremlin> g.inject(5.0).asNumber(N.nint)
+gremlin> g.inject(5.0).asNumber(N.int_)
==> 5 // casts double to int
-gremlin> g.inject(12).asNumber(N.nbyte)
+gremlin> g.inject(12).asNumber(N.byte_)
==> 12
-gremlin> g.inject(128).asNumber(N.nbyte)
+gremlin> g.inject(128).asNumber(N.byte_)
==> ArithmeticException
----
@@ -75,11 +75,11 @@ String input will be parsed. By default, the smalled unit
of number to be parsed
----
gremlin> g.inject("5").asNumber()
==> 5
-gremlin> g.inject("5.7").asNumber(N.nint)
+gremlin> g.inject("5.7").asNumber(N.int_)
==> 5
-gremlin> g.inject("1,000").asNumber(N.nint)
+gremlin> g.inject("1,000").asNumber(N.int_)
==> NumberFormatException
-gremlin> g.inject("128").asNumber(N.nbyte)
+gremlin> g.inject("128").asNumber(N.byte_)
==> ArithmeticException
----
diff --git
a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/language/grammar/GenericLiteralVisitor.java
b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/language/grammar/GenericLiteralVisitor.java
index 2556f6ee87..eb0b9dc343 100644
---
a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/language/grammar/GenericLiteralVisitor.java
+++
b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/language/grammar/GenericLiteralVisitor.java
@@ -601,6 +601,11 @@ public class GenericLiteralVisitor extends
DefaultGremlinBaseVisitor<Object> {
return TraversalEnumParser.parseTraversalEnumFromContext(Pick.class,
ctx);
}
+ @Override
+ public Object visitTraversalN(final GremlinParser.TraversalNContext ctx) {
+ return TraversalEnumParser.parseTraversalNFromContext(ctx);
+ }
+
@Override
public Object visitTraversalStrategy(final
GremlinParser.TraversalStrategyContext ctx) {
return antlr.traversalStrategyVisitor.visitTraversalStrategy(ctx);
diff --git
a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/language/grammar/TraversalEnumParser.java
b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/language/grammar/TraversalEnumParser.java
index 0c43f9ba49..e894f8bf24 100644
---
a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/language/grammar/TraversalEnumParser.java
+++
b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/language/grammar/TraversalEnumParser.java
@@ -19,6 +19,7 @@
package org.apache.tinkerpop.gremlin.language.grammar;
import org.antlr.v4.runtime.tree.ParseTree;
+import org.apache.tinkerpop.gremlin.process.traversal.N;
import org.apache.tinkerpop.gremlin.process.traversal.Scope;
import org.apache.tinkerpop.gremlin.structure.Direction;
@@ -65,4 +66,14 @@ public class TraversalEnumParser {
text = text.substring(Direction.class.getSimpleName().length() +
1);
return Direction.directionValueOf(text);
}
+
+ /**
+ * Parsing of {@link N} requires some special handling because of java
keyword collision.
+ */
+ public static N parseTraversalNFromContext(final
GremlinParser.TraversalNContext context) {
+ String text = context.getText();
+ if (text.startsWith(N.class.getSimpleName()))
+ text = text.substring(N.class.getSimpleName().length() + 1);
+ return text.startsWith("big") ? N.valueOf(text) : N.valueOf(text +
"_");
+ }
}
diff --git
a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/language/grammar/TraversalMethodVisitor.java
b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/language/grammar/TraversalMethodVisitor.java
index 06044ef9dc..2fc4434d3d 100644
---
a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/language/grammar/TraversalMethodVisitor.java
+++
b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/language/grammar/TraversalMethodVisitor.java
@@ -2117,7 +2117,7 @@ public class TraversalMethodVisitor extends
TraversalRootVisitor<GraphTraversal>
@Override
public GraphTraversal visitTraversalMethod_asNumber_traversalN(final
GremlinParser.TraversalMethod_asNumber_traversalNContext ctx) {
return graphTraversal.asNumber(
- TraversalEnumParser.parseTraversalEnumFromContext(N.class,
ctx.traversalN()));
+
TraversalEnumParser.parseTraversalNFromContext(ctx.traversalN()));
}
public GraphTraversal[] getNestedTraversalList(final
GremlinParser.NestedTraversalListContext ctx) {
diff --git
a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/language/translator/GroovyTranslateVisitor.java
b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/language/translator/GroovyTranslateVisitor.java
index 97e76358ea..c5d83388d5 100644
---
a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/language/translator/GroovyTranslateVisitor.java
+++
b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/language/translator/GroovyTranslateVisitor.java
@@ -45,6 +45,15 @@ public class GroovyTranslateVisitor extends TranslateVisitor
{
super(graphTraversalSourceName);
}
+ @Override
+ public Void visitTraversalN(GremlinParser.TraversalNContext ctx) {
+ final String[] split = ctx.getText().split("\\.");
+ sb.append(processGremlinSymbol(split[0])).append(".");
+ sb.append(processGremlinSymbol(split[1]));
+ if (!split[1].startsWith("big")) sb.append("_");
+ return null;
+ }
+
@Override
public Void visitIntegerLiteral(final GremlinParser.IntegerLiteralContext
ctx) {
final String integerLiteral = ctx.getText().toLowerCase();
diff --git
a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/language/translator/JavaTranslateVisitor.java
b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/language/translator/JavaTranslateVisitor.java
index 81b6b25b84..18ae1bd05c 100644
---
a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/language/translator/JavaTranslateVisitor.java
+++
b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/language/translator/JavaTranslateVisitor.java
@@ -21,7 +21,9 @@ package org.apache.tinkerpop.gremlin.language.translator;
import org.antlr.v4.runtime.tree.ParseTree;
import org.antlr.v4.runtime.tree.TerminalNode;
import org.apache.tinkerpop.gremlin.language.grammar.GremlinParser;
+import org.apache.tinkerpop.gremlin.process.traversal.N;
import
org.apache.tinkerpop.gremlin.process.traversal.strategy.decoration.OptionsStrategy;
+import org.apache.tinkerpop.gremlin.structure.Direction;
import org.apache.tinkerpop.gremlin.structure.util.reference.ReferenceVertex;
import org.apache.tinkerpop.gremlin.util.DatetimeHelper;
@@ -106,6 +108,15 @@ public class JavaTranslateVisitor extends
AbstractTranslateVisitor {
return null;
}
+ @Override
+ public Void visitTraversalN(GremlinParser.TraversalNContext ctx) {
+ final String[] split = ctx.getText().split("\\.");
+ sb.append(processGremlinSymbol(split[0])).append(".");
+ sb.append(processGremlinSymbol(split[1]));
+ if (!split[1].startsWith("big")) sb.append("_");
+ return null;
+ }
+
@Override
public Void visitGenericMapLiteral(final
GremlinParser.GenericMapLiteralContext ctx) {
sb.append("new LinkedHashMap<Object, Object>() {{ ");
diff --git
a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/language/translator/JavascriptTranslateVisitor.java
b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/language/translator/JavascriptTranslateVisitor.java
index 23d2bf7d80..bd86a8ca43 100644
---
a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/language/translator/JavascriptTranslateVisitor.java
+++
b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/language/translator/JavascriptTranslateVisitor.java
@@ -87,6 +87,15 @@ public class JavascriptTranslateVisitor extends
AbstractTranslateVisitor {
return null;
}
+ @Override
+ public Void visitTraversalN(GremlinParser.TraversalNContext ctx) {
+ final String[] split = ctx.getText().split("\\.");
+ sb.append(processGremlinSymbol(split[0])).append(".");
+ sb.append(processGremlinSymbol(split[1]));
+ if (!split[1].startsWith("big")) sb.append("_");
+ return null;
+ }
+
@Override
public Void visitGenericMapLiteral(final
GremlinParser.GenericMapLiteralContext ctx) {
sb.append("new Map([");
diff --git
a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/N.java
b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/N.java
index 4a8d56b48b..7ac673b4c1 100644
---
a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/N.java
+++
b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/N.java
@@ -28,25 +28,21 @@ import java.math.BigInteger;
* Used with {@link AsNumberStep} step.
*/
public enum N {
- nbyte(Byte.class),
- nshort(Short.class),
- nint(Integer.class),
- nlong(Long.class),
- nfloat(Float.class),
- ndouble(Double.class),
- nbigInt(BigInteger.class),
- nbigDecimal(BigDecimal.class),;
+ byte_(Byte.class),
+ short_(Short.class),
+ int_(Integer.class),
+ long_(Long.class),
+ float_(Float.class),
+ double_(Double.class),
+ bigInt(BigInteger.class),
+ bigDecimal(BigDecimal.class),;
- private final Class<?> type;
+ private final Class<? extends Number> type;
- N(Class<?> type) {this.type = type;}
+ N(Class<? extends Number> type) {this.type = type;}
- public Class<?> getType() {
+ public Class<? extends Number> getType() {
return this.type;
}
- @Override
- public String toString() {
- return this.type.getSimpleName();
- }
}
\ No newline at end of file
diff --git
a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/structure/io/binary/TypeSerializerRegistry.java
b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/structure/io/binary/TypeSerializerRegistry.java
index 4b48d8d211..62597d16d9 100644
---
a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/structure/io/binary/TypeSerializerRegistry.java
+++
b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/structure/io/binary/TypeSerializerRegistry.java
@@ -49,52 +49,7 @@ 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.io.IoRegistry;
-import
org.apache.tinkerpop.gremlin.structure.io.binary.types.BigDecimalSerializer;
-import
org.apache.tinkerpop.gremlin.structure.io.binary.types.BigIntegerSerializer;
-import
org.apache.tinkerpop.gremlin.structure.io.binary.types.BindingSerializer;
-import
org.apache.tinkerpop.gremlin.structure.io.binary.types.BulkSetSerializer;
-import
org.apache.tinkerpop.gremlin.structure.io.binary.types.ByteBufferSerializer;
-import
org.apache.tinkerpop.gremlin.structure.io.binary.types.ByteCodeSerializer;
-import org.apache.tinkerpop.gremlin.structure.io.binary.types.CharSerializer;
-import org.apache.tinkerpop.gremlin.structure.io.binary.types.ClassSerializer;
-import
org.apache.tinkerpop.gremlin.structure.io.binary.types.CustomTypeSerializer;
-import org.apache.tinkerpop.gremlin.structure.io.binary.types.DateSerializer;
-import
org.apache.tinkerpop.gremlin.structure.io.binary.types.DurationSerializer;
-import org.apache.tinkerpop.gremlin.structure.io.binary.types.EdgeSerializer;
-import org.apache.tinkerpop.gremlin.structure.io.binary.types.EnumSerializer;
-import org.apache.tinkerpop.gremlin.structure.io.binary.types.GraphSerializer;
-import
org.apache.tinkerpop.gremlin.structure.io.binary.types.InetAddressSerializer;
-import
org.apache.tinkerpop.gremlin.structure.io.binary.types.InstantSerializer;
-import org.apache.tinkerpop.gremlin.structure.io.binary.types.LambdaSerializer;
-import org.apache.tinkerpop.gremlin.structure.io.binary.types.ListSerializer;
-import
org.apache.tinkerpop.gremlin.structure.io.binary.types.LocalDateSerializer;
-import
org.apache.tinkerpop.gremlin.structure.io.binary.types.LocalDateTimeSerializer;
-import
org.apache.tinkerpop.gremlin.structure.io.binary.types.LocalTimeSerializer;
-import
org.apache.tinkerpop.gremlin.structure.io.binary.types.MapEntrySerializer;
-import org.apache.tinkerpop.gremlin.structure.io.binary.types.MapSerializer;
-import
org.apache.tinkerpop.gremlin.structure.io.binary.types.MetricsSerializer;
-import
org.apache.tinkerpop.gremlin.structure.io.binary.types.MonthDaySerializer;
-import
org.apache.tinkerpop.gremlin.structure.io.binary.types.OffsetDateTimeSerializer;
-import
org.apache.tinkerpop.gremlin.structure.io.binary.types.OffsetTimeSerializer;
-import org.apache.tinkerpop.gremlin.structure.io.binary.types.PSerializer;
-import org.apache.tinkerpop.gremlin.structure.io.binary.types.PathSerializer;
-import org.apache.tinkerpop.gremlin.structure.io.binary.types.PeriodSerializer;
-import
org.apache.tinkerpop.gremlin.structure.io.binary.types.PropertySerializer;
-import org.apache.tinkerpop.gremlin.structure.io.binary.types.SetSerializer;
-import
org.apache.tinkerpop.gremlin.structure.io.binary.types.SingleTypeSerializer;
-import org.apache.tinkerpop.gremlin.structure.io.binary.types.StringSerializer;
-import
org.apache.tinkerpop.gremlin.structure.io.binary.types.TransformSerializer;
-import
org.apache.tinkerpop.gremlin.structure.io.binary.types.TraversalExplanationSerializer;
-import
org.apache.tinkerpop.gremlin.structure.io.binary.types.TraversalMetricsSerializer;
-import
org.apache.tinkerpop.gremlin.structure.io.binary.types.TraversalStrategySerializer;
-import
org.apache.tinkerpop.gremlin.structure.io.binary.types.TraverserSerializer;
-import org.apache.tinkerpop.gremlin.structure.io.binary.types.TreeSerializer;
-import org.apache.tinkerpop.gremlin.structure.io.binary.types.UUIDSerializer;
-import
org.apache.tinkerpop.gremlin.structure.io.binary.types.VertexPropertySerializer;
-import org.apache.tinkerpop.gremlin.structure.io.binary.types.VertexSerializer;
-import
org.apache.tinkerpop.gremlin.structure.io.binary.types.YearMonthSerializer;
-import
org.apache.tinkerpop.gremlin.structure.io.binary.types.ZoneOffsetSerializer;
-import
org.apache.tinkerpop.gremlin.structure.io.binary.types.ZonedDateTimeSerializer;
+import org.apache.tinkerpop.gremlin.structure.io.binary.types.*;
import org.apache.tinkerpop.gremlin.util.function.Lambda;
import org.javatuples.Pair;
@@ -167,7 +122,7 @@ public class TypeSerializerRegistry {
new RegistryEntry<>(Direction.class,
EnumSerializer.DirectionSerializer),
new RegistryEntry<>(DT.class, EnumSerializer.DTSerializer),
new RegistryEntry<>(Merge.class, EnumSerializer.MergeSerializer),
- new RegistryEntry<>(N.class, EnumSerializer.NSerializer),
+ new RegistryEntry<>(N.class, new NSerializer()),
new RegistryEntry<>(Operator.class,
EnumSerializer.OperatorSerializer),
new RegistryEntry<>(Order.class, EnumSerializer.OrderSerializer),
new RegistryEntry<>(Pick.class, EnumSerializer.PickSerializer),
diff --git
a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/structure/io/binary/types/EnumSerializer.java
b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/structure/io/binary/types/EnumSerializer.java
index 730ffab1c9..7ee0dd0406 100644
---
a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/structure/io/binary/types/EnumSerializer.java
+++
b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/structure/io/binary/types/EnumSerializer.java
@@ -52,7 +52,6 @@ public class EnumSerializer<E extends Enum> extends
SimpleTypeSerializer<E> {
public static final EnumSerializer<Direction> DirectionSerializer = new
EnumSerializer<>(DataType.DIRECTION, Direction::valueOf);
public static final EnumSerializer<DT> DTSerializer = new
EnumSerializer<>(DataType.DT, DT::valueOf);
public static final EnumSerializer<Merge> MergeSerializer = new
EnumSerializer<>(DataType.MERGE, Merge::valueOf);
- public static final EnumSerializer<N> NSerializer = new
EnumSerializer<>(DataType.N, N::valueOf);
public static final EnumSerializer<Operator> OperatorSerializer = new
EnumSerializer<>(DataType.OPERATOR, Operator::valueOf);
public static final EnumSerializer<Order> OrderSerializer = new
EnumSerializer<>(DataType.ORDER, Order::valueOf);
public static final EnumSerializer<Pick> PickSerializer = new
EnumSerializer<>(DataType.PICK, Pick::valueOf);
diff --git
a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/structure/io/binary/types/NSerializer.java
b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/structure/io/binary/types/NSerializer.java
new file mode 100644
index 0000000000..b70388ab6f
--- /dev/null
+++
b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/structure/io/binary/types/NSerializer.java
@@ -0,0 +1,46 @@
+/*
+ * 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.structure.io.binary.types;
+
+import org.apache.tinkerpop.gremlin.process.traversal.N;
+import org.apache.tinkerpop.gremlin.structure.io.Buffer;
+import org.apache.tinkerpop.gremlin.structure.io.binary.DataType;
+import org.apache.tinkerpop.gremlin.structure.io.binary.GraphBinaryReader;
+import org.apache.tinkerpop.gremlin.structure.io.binary.GraphBinaryWriter;
+
+import java.io.IOException;
+import java.time.MonthDay;
+
+public class NSerializer extends SimpleTypeSerializer<N> {
+ public NSerializer() {
+ super(DataType.N);
+ }
+
+ @Override
+ protected N readValue(final Buffer buffer, final GraphBinaryReader
context) throws IOException {
+ String name = context.read(buffer);
+ return name.startsWith("big") ? N.valueOf(name) : N.valueOf(name +
"_");
+ }
+
+ @Override
+ protected void writeValue(final N value, final Buffer buffer, final
GraphBinaryWriter context) throws IOException {
+ String name = value.name().replace("_", "");
+ context.write(name, buffer);
+ }
+}
diff --git
a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/structure/io/graphson/GraphSONModule.java
b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/structure/io/graphson/GraphSONModule.java
index 1869f3d3b1..b40d029a98 100644
---
a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/structure/io/graphson/GraphSONModule.java
+++
b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/structure/io/graphson/GraphSONModule.java
@@ -279,7 +279,6 @@ abstract class GraphSONModule extends
TinkerPopJacksonModule {
Direction.class,
DT.class,
Merge.class,
- N.class,
Operator.class,
Order.class,
Pop.class,
@@ -287,6 +286,7 @@ abstract class GraphSONModule extends
TinkerPopJacksonModule {
Scope.class,
Pick.class,
T.class).forEach(e -> addSerializer(e, new
TraversalSerializersV3.EnumJacksonSerializer()));
+ addSerializer(N.class, new
TraversalSerializersV3.NJacksonSerializer());
addSerializer(P.class, new
TraversalSerializersV3.PJacksonSerializer());
addSerializer(Lambda.class, new
TraversalSerializersV3.LambdaJacksonSerializer());
addSerializer(Bytecode.Binding.class, new
TraversalSerializersV3.BindingJacksonSerializer());
@@ -327,7 +327,6 @@ abstract class GraphSONModule extends
TinkerPopJacksonModule {
Direction.values(),
DT.values(),
Merge.values(),
- N.values(),
Operator.values(),
Order.values(),
Pop.values(),
@@ -335,6 +334,7 @@ abstract class GraphSONModule extends
TinkerPopJacksonModule {
Scope.values(),
Pick.values(),
T.values()).flatMap(Stream::of).forEach(e ->
addDeserializer(e.getClass(), new
TraversalSerializersV3.EnumJacksonDeserializer(e.getDeclaringClass())));
+ addDeserializer(N.class, new
TraversalSerializersV3.NJacksonDeserializer());
addDeserializer(P.class, new
TraversalSerializersV3.PJacksonDeserializer());
addDeserializer(TextP.class, new
TraversalSerializersV3.TextPJacksonDeserializer());
addDeserializer(Lambda.class, new
TraversalSerializersV3.LambdaJacksonDeserializer());
@@ -536,7 +536,6 @@ abstract class GraphSONModule extends
TinkerPopJacksonModule {
Direction.class,
DT.class,
Merge.class,
- N.class,
Operator.class,
Order.class,
Pop.class,
@@ -544,6 +543,7 @@ abstract class GraphSONModule extends
TinkerPopJacksonModule {
Scope.class,
Pick.class,
T.class).forEach(e -> addSerializer(e, new
TraversalSerializersV2.EnumJacksonSerializer()));
+ addSerializer(N.class, new
TraversalSerializersV2.NJacksonSerializer());
addSerializer(P.class, new
TraversalSerializersV2.PJacksonSerializer());
addSerializer(Lambda.class, new
TraversalSerializersV2.LambdaJacksonSerializer());
addSerializer(Bytecode.Binding.class, new
TraversalSerializersV2.BindingJacksonSerializer());
@@ -576,7 +576,6 @@ abstract class GraphSONModule extends
TinkerPopJacksonModule {
Direction.values(),
DT.values(),
Merge.values(),
- N.values(),
Operator.values(),
Order.values(),
Pop.values(),
@@ -584,6 +583,7 @@ abstract class GraphSONModule extends
TinkerPopJacksonModule {
Scope.values(),
Pick.values(),
T.values()).flatMap(Stream::of).forEach(e ->
addDeserializer(e.getClass(), new
TraversalSerializersV2.EnumJacksonDeserializer(e.getDeclaringClass())));
+ addDeserializer(N.class, new
TraversalSerializersV2.NJacksonDeserializer());
addDeserializer(P.class, new
TraversalSerializersV2.PJacksonDeserializer());
addDeserializer(TextP.class, new
TraversalSerializersV2.TextPJacksonDeserializer());
addDeserializer(Lambda.class, new
TraversalSerializersV2.LambdaJacksonDeserializer());
diff --git
a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/structure/io/graphson/TraversalSerializersV2.java
b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/structure/io/graphson/TraversalSerializersV2.java
index 2ef49eaa33..4a234098b6 100644
---
a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/structure/io/graphson/TraversalSerializersV2.java
+++
b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/structure/io/graphson/TraversalSerializersV2.java
@@ -22,12 +22,7 @@ package org.apache.tinkerpop.gremlin.structure.io.graphson;
import org.apache.commons.configuration2.BaseConfiguration;
import org.apache.commons.configuration2.ConfigurationConverter;
import
org.apache.tinkerpop.gremlin.process.remote.traversal.DefaultRemoteTraverser;
-import org.apache.tinkerpop.gremlin.process.traversal.Bytecode;
-import org.apache.tinkerpop.gremlin.process.traversal.P;
-import org.apache.tinkerpop.gremlin.process.traversal.TextP;
-import org.apache.tinkerpop.gremlin.process.traversal.Traversal;
-import org.apache.tinkerpop.gremlin.process.traversal.TraversalStrategy;
-import org.apache.tinkerpop.gremlin.process.traversal.Traverser;
+import org.apache.tinkerpop.gremlin.process.traversal.*;
import
org.apache.tinkerpop.gremlin.process.traversal.strategy.TraversalStrategyProxy;
import org.apache.tinkerpop.gremlin.process.traversal.util.AndP;
import org.apache.tinkerpop.gremlin.process.traversal.util.ConnectiveP;
@@ -136,6 +131,21 @@ final class TraversalSerializersV2 {
}
+ static class NJacksonSerializer extends StdScalarSerializer<N> {
+
+ public NJacksonSerializer() {
+ super(N.class);
+ }
+
+ @Override
+ public void serialize(final N enumInstance, final JsonGenerator
jsonGenerator, final SerializerProvider serializerProvider)
+ throws IOException {
+ String name = enumInstance.name();
+ jsonGenerator.writeString(name.replace("_", ""));
+ }
+
+ }
+
final static class PJacksonSerializer extends StdScalarSerializer<P> {
public PJacksonSerializer() {
@@ -316,6 +326,24 @@ final class TraversalSerializersV2 {
}
}
+ final static class NJacksonDeserializer extends StdDeserializer<N> {
+
+ public NJacksonDeserializer() {
+ super(N.class);
+ }
+
+ @Override
+ public N deserialize(final JsonParser jsonParser, final
DeserializationContext deserializationContext) throws IOException,
JsonProcessingException {
+ final String enumName = jsonParser.getText();
+ return N.valueOf(enumName.startsWith("big") ? enumName : enumName
+ "_");
+ }
+
+ @Override
+ public boolean isCachable() {
+ return true;
+ }
+ }
+
final static class PJacksonDeserializer extends StdDeserializer<P> {
public PJacksonDeserializer() {
diff --git
a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/structure/io/graphson/TraversalSerializersV3.java
b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/structure/io/graphson/TraversalSerializersV3.java
index 9bd1002ac7..3b234de375 100644
---
a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/structure/io/graphson/TraversalSerializersV3.java
+++
b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/structure/io/graphson/TraversalSerializersV3.java
@@ -22,12 +22,7 @@ package org.apache.tinkerpop.gremlin.structure.io.graphson;
import org.apache.commons.configuration2.BaseConfiguration;
import org.apache.commons.configuration2.ConfigurationConverter;
import
org.apache.tinkerpop.gremlin.process.remote.traversal.DefaultRemoteTraverser;
-import org.apache.tinkerpop.gremlin.process.traversal.Bytecode;
-import org.apache.tinkerpop.gremlin.process.traversal.P;
-import org.apache.tinkerpop.gremlin.process.traversal.TextP;
-import org.apache.tinkerpop.gremlin.process.traversal.Traversal;
-import org.apache.tinkerpop.gremlin.process.traversal.TraversalStrategy;
-import org.apache.tinkerpop.gremlin.process.traversal.Traverser;
+import org.apache.tinkerpop.gremlin.process.traversal.*;
import org.apache.tinkerpop.gremlin.process.traversal.step.util.BulkSet;
import
org.apache.tinkerpop.gremlin.process.traversal.strategy.TraversalStrategyProxy;
import org.apache.tinkerpop.gremlin.process.traversal.util.AndP;
@@ -143,6 +138,21 @@ final class TraversalSerializersV3 {
}
+ static class NJacksonSerializer extends StdScalarSerializer<N> {
+
+ public NJacksonSerializer() {
+ super(N.class);
+ }
+
+ @Override
+ public void serialize(final N enumInstance, final JsonGenerator
jsonGenerator, final SerializerProvider serializerProvider)
+ throws IOException {
+ String name = enumInstance.name();
+ jsonGenerator.writeString(name.replace("_", ""));
+ }
+
+ }
+
final static class PJacksonSerializer extends StdScalarSerializer<P> {
public PJacksonSerializer() {
@@ -336,6 +346,24 @@ final class TraversalSerializersV3 {
}
}
+ final static class NJacksonDeserializer extends StdDeserializer<N> {
+
+ public NJacksonDeserializer() {
+ super(N.class);
+ }
+
+ @Override
+ public N deserialize(final JsonParser jsonParser, final
DeserializationContext deserializationContext) throws IOException,
JsonProcessingException {
+ final String enumName = jsonParser.getText();
+ return N.valueOf(enumName.startsWith("big") ? enumName : enumName
+ "_");
+ }
+
+ @Override
+ public boolean isCachable() {
+ return true;
+ }
+ }
+
final static class PJacksonDeserializer extends
AbstractReflectJacksonDeserializer<P> {
public PJacksonDeserializer() {
diff --git
a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/util/NumberHelper.java
b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/util/NumberHelper.java
index b9e6f8b7c5..41beeaa392 100644
---
a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/util/NumberHelper.java
+++
b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/util/NumberHelper.java
@@ -689,38 +689,12 @@ public final class NumberHelper {
* @throws IllegalArgumentException if the specified numeric type is
unsupported
*/
public static Number coerceTo(final Number a, final Class<? extends
Number> clazz) {
- if (a.getClass().equals(clazz)) {
+ try {
+ return performConversion(a, clazz);
+ } catch (ArithmeticException e) {
+ // return as-is since it didn't fit the type we wanted to coerce to
return a;
- } else if (clazz.equals(Integer.class)) {
- if (a.longValue() >= Integer.MIN_VALUE && a.longValue() <=
Integer.MAX_VALUE) {
- return a.intValue();
- }
- } else if (clazz.equals(Long.class)) {
- return a.longValue();
- } else if (clazz.equals(Float.class)) {
- if (a.doubleValue() >= -Float.MAX_VALUE && a.doubleValue() <=
Float.MAX_VALUE) {
- return a.floatValue();
- }
- } else if (clazz.equals(Double.class)) {
- return a.doubleValue();
- } else if (clazz.equals(Byte.class)) {
- if (a.longValue() >= Byte.MIN_VALUE && a.longValue() <=
Byte.MAX_VALUE) {
- return a.byteValue();
- }
- } else if (clazz.equals(Short.class)) {
- if (a.longValue() >= Short.MIN_VALUE && a.longValue() <=
Short.MAX_VALUE) {
- return a.shortValue();
- }
- } else if (clazz.equals(BigInteger.class)) {
- return NumberHelper.bigIntegerValue(a);
- } else if (clazz.equals(BigDecimal.class)) {
- return NumberHelper.bigDecimalValue(a);
- } else {
- throw new IllegalArgumentException("Unsupported numeric type: " +
clazz);
}
-
- // return as-is since it didn't fit the type we wanted to coerce to
- return a;
}
/**
@@ -734,27 +708,36 @@ public final class NumberHelper {
* @throws ArithmeticException if the number overflows
*/
public static Number castTo(final Number a, final N numberToken) {
- Class<?> clazz = numberToken.getType();
+ Class<? extends Number> clazz = numberToken.getType();
+ return performConversion(a, clazz);
+ }
+
+ /**
+ * Core conversion logic.
+ * Throws ArithmeticException when conversion would overflow.
+ */
+ private static Number performConversion(final Number a, final Class<?
extends Number> clazz) {
if (a.getClass().equals(clazz)) {
return a;
- } else if (clazz.equals(Integer.class)) {
- Long val = getLong(a, numberToken);
+ }
+ if (clazz.equals(Integer.class)) {
+ Long val = getLong(a, clazz);
if (val >= Integer.MIN_VALUE && val <= Integer.MAX_VALUE) {
return a.intValue();
}
} else if (clazz.equals(Long.class)) {
- return getLong(a, numberToken);
+ return getLong(a, clazz);
} else if (clazz.equals(Float.class)) {
- // BigDecimal to double will overflow into Infinity, we want to
throw instead of passing through
+ // BigDecimal to double will overflow into Infinity, we want to
handle this
if (!a.getClass().equals(BigDecimal.class) &&
- (Double.isInfinite(a.doubleValue()) ||
Double.isNaN(a.doubleValue()))) {
+ (Double.isInfinite(a.doubleValue()) ||
Double.isNaN(a.doubleValue()))) {
return a.floatValue();
}
if (a.doubleValue() >= -Float.MAX_VALUE && a.doubleValue() <=
Float.MAX_VALUE) {
return a.floatValue();
}
} else if (clazz.equals(Double.class)) {
- // BigDecimal to double will overflow into Infinity, we want to
throw instead of passing through
+ // BigDecimal to double will overflow into Infinity, we want to
handle this
if (!a.getClass().equals(BigDecimal.class) &&
(Double.isInfinite(a.doubleValue()) ||
Double.isNaN(a.doubleValue()))) {
return a.doubleValue();
@@ -764,41 +747,45 @@ public final class NumberHelper {
return a.getClass().equals(Float.class) ?
Double.parseDouble(a.toString()) : a.doubleValue();
}
} else if (clazz.equals(Byte.class)) {
- Long val = getLong(a, numberToken);
+ Long val = getLong(a, clazz);
if (val >= Byte.MIN_VALUE && val <= Byte.MAX_VALUE) {
return a.byteValue();
}
} else if (clazz.equals(Short.class)) {
- Long val = getLong(a, numberToken);
+ Long val = getLong(a, clazz);
if (val >= Short.MIN_VALUE && val <= Short.MAX_VALUE) {
return a.shortValue();
}
} else if (clazz.equals(BigInteger.class)) {
return NumberHelper.bigIntegerValue(a);
} else if (clazz.equals(BigDecimal.class)) {
- // float losses precision, use string intermediate
- return a.getClass().equals(Float.class) ? new
BigDecimal(a.toString()) : NumberHelper.bigDecimalValue(a);
+ return NumberHelper.bigDecimalValue(a);
} else {
- throw new IllegalArgumentException("Unsupported number type token:
" + numberToken);
+ throw new IllegalArgumentException("Unsupported numeric type: " +
clazz);
}
throw new ArithmeticException(String.format("Can't convert number of
type %s to %s due to overflow.",
- a.getClass().getSimpleName(), numberToken));
+ a.getClass().getSimpleName(), clazz.getSimpleName()));
}
- private static Long getLong(final Number num, final N numberToken) {
+ private static Long getLong(final Number num, final Class<? extends
Number> clazz) {
// Explicitly throw when converting floating point infinity and NaN to
whole numbers
if (Double.isNaN(num.doubleValue())) {
- throw new ArithmeticException(String.format("Can't convert NaN to
%s.", numberToken));
+ throw new ArithmeticException(String.format("Can't convert NaN to
%s.", clazz.getSimpleName()));
}
if (Double.isInfinite(num.doubleValue())) {
- throw new ArithmeticException(String.format("Can't convert
floating point infinity to %s.", numberToken));
+ throw new ArithmeticException(String.format("Can't convert
floating point infinity to %s.", clazz.getSimpleName()));
+ }
+ String msg = String.format("Can't convert number of type %s to %s due
to overflow.",
+ num.getClass().getSimpleName(), clazz.getSimpleName());
+ if ((num.getClass().equals(Double.class) ||
num.getClass().equals(Float.class)) && (num.doubleValue()) > Long.MAX_VALUE) {
+ throw new ArithmeticException(msg);
}
try {
+ if (num.getClass().equals(BigDecimal.class)) return ((BigDecimal)
num).longValueExact();
return num.getClass().equals(BigInteger.class) ? ((BigInteger)
num).longValueExact() : num.longValue();
} catch (ArithmeticException ae) {
- throw new ArithmeticException(String.format("Can't convert number
of type %s to %s due to overflow.",
- num.getClass().getSimpleName(), numberToken));
+ throw new ArithmeticException(msg);
}
}
@@ -834,6 +821,8 @@ public final class NumberHelper {
private static BigInteger bigIntegerValue(final Number number) {
if (number == null) return null;
if (number instanceof BigInteger) return (BigInteger) number;
+ if (number instanceof BigDecimal) return ((BigDecimal)
number).toBigInteger();
+ if (number instanceof Double) return
BigDecimal.valueOf(number.doubleValue()).toBigInteger();
return BigInteger.valueOf(number.longValue());
}
@@ -841,7 +830,8 @@ public final class NumberHelper {
if (number == null) return null;
if (number instanceof BigDecimal) return (BigDecimal) number;
if (number instanceof BigInteger) return new BigDecimal((BigInteger)
number);
- return (number instanceof Double || number instanceof Float)
+ if (number instanceof Float) return new BigDecimal(number.toString());
// float losses precision, use string intermediate
+ return (number instanceof Double)
? BigDecimal.valueOf(number.doubleValue())
: BigDecimal.valueOf(number.longValue());
}
diff --git
a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/language/grammar/GeneralLiteralVisitorTest.java
b/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/language/grammar/GeneralLiteralVisitorTest.java
index 2409663e47..03165106a9 100644
---
a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/language/grammar/GeneralLiteralVisitorTest.java
+++
b/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/language/grammar/GeneralLiteralVisitorTest.java
@@ -20,6 +20,7 @@ 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.N;
import org.apache.tinkerpop.gremlin.structure.Direction;
import org.apache.tinkerpop.gremlin.structure.T;
import org.apache.tinkerpop.gremlin.structure.VertexProperty;
@@ -31,15 +32,12 @@ import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
import java.lang.reflect.Constructor;
-import java.math.BigDecimal;
import java.math.BigInteger;
import java.time.LocalDateTime;
import java.time.OffsetDateTime;
import java.time.ZoneOffset;
-import java.time.ZonedDateTime;
import java.util.ArrayList;
import java.util.Arrays;
-import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
@@ -459,6 +457,40 @@ public class GeneralLiteralVisitorTest {
}
}
+ @RunWith(Parameterized.class)
+ public static class ValidEnumNLiteralTest {
+
+ @Parameterized.Parameter(value = 0)
+ public String script;
+
+ @Parameterized.Parameter(value = 1)
+ public N expected;
+
+ @Parameterized.Parameters(name = "{0}")
+ public static Iterable<Object[]> generateTestParameters() {
+ return Arrays.asList(new Object[][]{
+ {"byte", N.byte_},
+ {"short", N.short_},
+ {"int", N.int_},
+ {"long", N.long_},
+ {"float", N.float_},
+ {"double", N.double_},
+ {"bigInt", N.bigInt},
+ {"bigDecimal", N.bigDecimal},
+ });
+ }
+
+ @Test
+ public void shouldParse() {
+ final GremlinLexer lexer = new
GremlinLexer(CharStreams.fromString(script));
+ final GremlinParser parser = new GremlinParser(new
CommonTokenStream(lexer));
+ final GremlinParser.TraversalNContext ctx = parser.traversalN();
+
+ final N n = (N) new GenericLiteralVisitor(new
GremlinAntlrToJava()).visitTraversalN(ctx);
+ assertEquals(expected, n);
+ }
+ }
+
@RunWith(Parameterized.class)
public static class ValidDatetimeLiteralTest {
diff --git
a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/language/translator/GremlinTranslatorTest.java
b/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/language/translator/GremlinTranslatorTest.java
index 746a0cd711..0b47507c46 100644
---
a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/language/translator/GremlinTranslatorTest.java
+++
b/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/language/translator/GremlinTranslatorTest.java
@@ -740,6 +740,24 @@ public class GremlinTranslatorTest {
null,
null,
"g.inject(long(1694017707000)).as_date()"},
+ {"g.inject(\"123.4\").asNumber(N.int)",
+ null,
+ "g.inject(string0).asNumber(N.int)",
+ "g.Inject<object>(\"123.4\").AsNumber(N.Int)",
+ "g.Inject(\"123.4\").AsNumber(gremlingo.N.Int)",
+ "g.inject(\"123.4\").asNumber(N.int_)",
+ "g.inject(\"123.4\").asNumber(N.int_)",
+ "g.inject(\"123.4\").asNumber(N.int_)",
+ "g.inject('123.4').as_number(N.int)"},
+ {"g.inject(\"123.4\").asNumber(N.bigInt)",
+ null,
+ "g.inject(string0).asNumber(N.bigInt)",
+ "g.Inject<object>(\"123.4\").AsNumber(N.BigInt)",
+ "g.Inject(\"123.4\").AsNumber(gremlingo.N.BigInt)",
+ "g.inject(\"123.4\").asNumber(N.bigInt)",
+ "g.inject(\"123.4\").asNumber(N.bigInt)",
+ "g.inject(\"123.4\").asNumber(N.bigInt)",
+ "g.inject('123.4').as_number(N.big_int)"},
{"g.V().hasLabel(null)",
null,
"g.V().hasLabel(string0)",
diff --git
a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/step/map/AsNumberStepTest.java
b/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/step/map/AsNumberStepTest.java
index 1eef3b829b..ec98bd0285 100644
---
a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/step/map/AsNumberStepTest.java
+++
b/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/process/traversal/step/map/AsNumberStepTest.java
@@ -43,18 +43,18 @@ public class AsNumberStepTest extends StepTest {
@Test
public void testReturnTypes() {
assertEquals(1, __.__(1).asNumber().next());
- assertEquals((byte) 1, __.__(1).asNumber(N.nbyte).next());
- assertEquals(1, __.__(1.8).asNumber(N.nint).next());
- assertEquals(1, __.__(1L).asNumber(N.nint).next());
+ assertEquals((byte) 1, __.__(1).asNumber(N.byte_).next());
+ assertEquals(1, __.__(1.8).asNumber(N.int_).next());
+ assertEquals(1, __.__(1L).asNumber(N.int_).next());
assertEquals(1L, __.__(1L).asNumber().next());
- assertEquals(3.14f, __.__(3.14).asNumber(N.nfloat).next());
- assertEquals(3.14, __.__(3.14f).asNumber(N.ndouble).next());
- assertEquals(1, __.__("1").asNumber(N.nint).next());
+ assertEquals(3.14f, __.__(3.14).asNumber(N.float_).next());
+ assertEquals(3.14, __.__(3.14f).asNumber(N.double_).next());
+ assertEquals(1, __.__("1").asNumber(N.int_).next());
assertEquals(1, __.__("1").asNumber().next());
- assertEquals((byte) 1, __.__("1").asNumber(N.nbyte).next());
- assertEquals((short) 1, __.__("1").asNumber(N.nshort).next());
- assertEquals(1L, __.__("1").asNumber(N.nlong).next());
- assertEquals(3.14, __.__("3.14").asNumber(N.ndouble).next()); //float
to double
+ assertEquals((byte) 1, __.__("1").asNumber(N.byte_).next());
+ assertEquals((short) 1, __.__("1").asNumber(N.short_).next());
+ assertEquals(1L, __.__("1").asNumber(N.long_).next());
+ assertEquals(3.14, __.__("3.14").asNumber(N.double_).next()); //float
to double
// NumberUtils allows additional string processing
assertEquals(123.0f, __.__("123.").asNumber().next());
assertEquals(291, __.__("0x123").asNumber().next());
@@ -83,215 +83,231 @@ public class AsNumberStepTest extends StepTest {
@Test(expected = ArithmeticException.class)
public void shouldThrowOverflowExceptionWhenParsedNumberOverflows() {
- __.__("128").asNumber(N.nbyte).next();
+ __.__("128").asNumber(N.byte_).next();
}
@Test(expected = ArithmeticException.class)
public void shouldThrowOverflowExceptionWhenCastNumberOverflows() {
- __.__(128).asNumber(N.nbyte).next();
+ __.__(128).asNumber(N.byte_).next();
}
@Test
public void testStringToByte() {
- assertEquals((byte) 0, __.__("0").asNumber(N.nbyte).next());
- assertEquals((byte) 127, __.__("127").asNumber(N.nbyte).next());
- assertEquals((byte) -128, __.__("-128").asNumber(N.nbyte).next());
- assertEquals((byte) 42, __.__("42").asNumber(N.nbyte).next());
- assertEquals((byte) -42, __.__("-42").asNumber(N.nbyte).next());
- assertEquals((byte) 1, __.__("1").asNumber(N.nbyte).next());
+ assertEquals((byte) 0, __.__("0").asNumber(N.byte_).next());
+ assertEquals((byte) 127, __.__("127").asNumber(N.byte_).next());
+ assertEquals((byte) -128, __.__("-128").asNumber(N.byte_).next());
+ assertEquals((byte) 42, __.__("42").asNumber(N.byte_).next());
+ assertEquals((byte) -42, __.__("-42").asNumber(N.byte_).next());
+ assertEquals((byte) 1, __.__("1").asNumber(N.byte_).next());
}
@Test
public void testStringToShort() {
- assertEquals((short) 0, __.__("0").asNumber(N.nshort).next());
- assertEquals((short) 32767, __.__("32767").asNumber(N.nshort).next());
- assertEquals((short) -32768,
__.__("-32768").asNumber(N.nshort).next());
- assertEquals((short) 1000, __.__("1000").asNumber(N.nshort).next());
- assertEquals((short) -1000, __.__("-1000").asNumber(N.nshort).next());
- assertEquals((short) 255, __.__("255").asNumber(N.nshort).next());
+ assertEquals((short) 0, __.__("0").asNumber(N.short_).next());
+ assertEquals((short) 32767, __.__("32767").asNumber(N.short_).next());
+ assertEquals((short) -32768,
__.__("-32768").asNumber(N.short_).next());
+ assertEquals((short) 1000, __.__("1000").asNumber(N.short_).next());
+ assertEquals((short) -1000, __.__("-1000").asNumber(N.short_).next());
+ assertEquals((short) 255, __.__("255").asNumber(N.short_).next());
}
@Test
public void testStringToInt() {
- assertEquals(0, __.__("0").asNumber(N.nint).next());
- assertEquals(2147483647, __.__("2147483647").asNumber(N.nint).next());
- assertEquals(-2147483648,
__.__("-2147483648").asNumber(N.nint).next());
- assertEquals(123456, __.__("123456").asNumber(N.nint).next());
- assertEquals(-123456, __.__("-123456").asNumber(N.nint).next());
- assertEquals(65536, __.__("65536").asNumber(N.nint).next());
+ assertEquals(0, __.__("0").asNumber(N.int_).next());
+ assertEquals(2147483647, __.__("2147483647").asNumber(N.int_).next());
+ assertEquals(-2147483648,
__.__("-2147483648").asNumber(N.int_).next());
+ assertEquals(123456, __.__("123456").asNumber(N.int_).next());
+ assertEquals(-123456, __.__("-123456").asNumber(N.int_).next());
+ assertEquals(65536, __.__("65536").asNumber(N.int_).next());
}
@Test
public void testStringToLong() {
- assertEquals(0L, __.__("0").asNumber(N.nlong).next());
- assertEquals(9223372036854775807L,
__.__("9223372036854775807").asNumber(N.nlong).next());
- assertEquals(-9223372036854775808L,
__.__("-9223372036854775808").asNumber(N.nlong).next());
- assertEquals(123456789L, __.__("123456789").asNumber(N.nlong).next());
- assertEquals(-123456789L,
__.__("-123456789").asNumber(N.nlong).next());
- assertEquals(4294967296L,
__.__("4294967296").asNumber(N.nlong).next());
+ assertEquals(0L, __.__("0").asNumber(N.long_).next());
+ assertEquals(9223372036854775807L,
__.__("9223372036854775807").asNumber(N.long_).next());
+ assertEquals(-9223372036854775808L,
__.__("-9223372036854775808").asNumber(N.long_).next());
+ assertEquals(123456789L, __.__("123456789").asNumber(N.long_).next());
+ assertEquals(-123456789L,
__.__("-123456789").asNumber(N.long_).next());
+ assertEquals(4294967296L,
__.__("4294967296").asNumber(N.long_).next());
}
@Test
public void testStringToFloat() {
- assertEquals(0.0f, __.__("0.0").asNumber(N.nfloat).next());
- assertEquals(3.14f, __.__("3.14").asNumber(N.nfloat).next());
- assertEquals(-3.14f, __.__("-3.14").asNumber(N.nfloat).next());
- assertEquals(1.23e10f, __.__("1.23e10").asNumber(N.nfloat).next());
- assertEquals(-1.23e-10f, __.__("-1.23e-10").asNumber(N.nfloat).next());
- assertEquals(Float.MAX_VALUE,
__.__("3.4028235E38").asNumber(N.nfloat).next());
- assertEquals(Float.MIN_VALUE,
__.__("1.4E-45").asNumber(N.nfloat).next());
+ assertEquals(0.0f, __.__("0.0").asNumber(N.float_).next());
+ assertEquals(3.14f, __.__("3.14").asNumber(N.float_).next());
+ assertEquals(-3.14f, __.__("-3.14").asNumber(N.float_).next());
+ assertEquals(1.23e10f, __.__("1.23e10").asNumber(N.float_).next());
+ assertEquals(-1.23e-10f, __.__("-1.23e-10").asNumber(N.float_).next());
+ assertEquals(Float.MAX_VALUE,
__.__("3.4028235E38").asNumber(N.float_).next());
+ assertEquals(Float.MIN_VALUE,
__.__("1.4E-45").asNumber(N.float_).next());
}
@Test
public void testStringToDouble() {
- assertEquals(0.0, __.__("0.0").asNumber(N.ndouble).next());
- assertEquals(3.141592653589793,
__.__("3.141592653589793").asNumber(N.ndouble).next());
- assertEquals(-3.141592653589793,
__.__("-3.141592653589793").asNumber(N.ndouble).next());
- assertEquals(1.23e100, __.__("1.23e100").asNumber(N.ndouble).next());
- assertEquals(-1.23e-100,
__.__("-1.23e-100").asNumber(N.ndouble).next());
- assertEquals(Double.MAX_VALUE,
__.__("1.7976931348623157E308").asNumber(N.ndouble).next());
- assertEquals(Double.MIN_VALUE,
__.__("4.9E-324").asNumber(N.ndouble).next());
+ assertEquals(0.0, __.__("0.0").asNumber(N.double_).next());
+ assertEquals(3.141592653589793,
__.__("3.141592653589793").asNumber(N.double_).next());
+ assertEquals(-3.141592653589793,
__.__("-3.141592653589793").asNumber(N.double_).next());
+ assertEquals(1.23e100, __.__("1.23e100").asNumber(N.double_).next());
+ assertEquals(-1.23e-100,
__.__("-1.23e-100").asNumber(N.double_).next());
+ assertEquals(Double.MAX_VALUE,
__.__("1.7976931348623157E308").asNumber(N.double_).next());
+ assertEquals(Double.MIN_VALUE,
__.__("4.9E-324").asNumber(N.double_).next());
}
@Test
public void testStringToBigInteger() {
- assertEquals(new BigInteger("0"),
__.__("0").asNumber(N.nbigInt).next());
+ assertEquals(new BigInteger("0"),
__.__("0").asNumber(N.bigInt).next());
assertEquals(new BigInteger("123456789012345678901234567890"),
-
__.__("123456789012345678901234567890").asNumber(N.nbigInt).next());
+
__.__("123456789012345678901234567890").asNumber(N.bigInt).next());
assertEquals(new BigInteger("-123456789012345678901234567890"),
-
__.__("-123456789012345678901234567890").asNumber(N.nbigInt).next());
+
__.__("-123456789012345678901234567890").asNumber(N.bigInt).next());
assertEquals(new
BigInteger("999999999999999999999999999999999999999999999999999"),
-
__.__("999999999999999999999999999999999999999999999999999").asNumber(N.nbigInt).next());
- assertEquals(new BigInteger("1"),
__.__("1").asNumber(N.nbigInt).next());
+
__.__("999999999999999999999999999999999999999999999999999").asNumber(N.bigInt).next());
+ assertEquals(new BigInteger("1"),
__.__("1").asNumber(N.bigInt).next());
+ assertEquals(new BigInteger("1000000000000000000000"), __.__(new
Double("1000000000000000000000")).asNumber(N.bigInt).next());
}
@Test
public void testStringToBigDecimal() {
- assertEquals(new BigDecimal("0.0"),
__.__("0.0").asNumber(N.nbigDecimal).next());
+ assertEquals(new BigDecimal("0.0"),
__.__("0.0").asNumber(N.bigDecimal).next());
assertEquals(new
BigDecimal("123456789012345678901234567890.123456789"),
-
__.__("123456789012345678901234567890.123456789").asNumber(N.nbigDecimal).next());
+
__.__("123456789012345678901234567890.123456789").asNumber(N.bigDecimal).next());
assertEquals(new
BigDecimal("-123456789012345678901234567890.123456789"),
-
__.__("-123456789012345678901234567890.123456789").asNumber(N.nbigDecimal).next());
+
__.__("-123456789012345678901234567890.123456789").asNumber(N.bigDecimal).next());
// Note directly constructing BigDecimal returns 1E-39, but parsing
then converting from double results in 1.0E-39
assertEquals(BigDecimal.valueOf(Double.parseDouble("0.000000000000000000000000000000000000001")),
-
__.__("0.000000000000000000000000000000000000001").asNumber(N.nbigDecimal).next());
- assertEquals(new BigDecimal("1.0"),
__.__("1.0").asNumber(N.nbigDecimal).next());
+
__.__("0.000000000000000000000000000000000000001").asNumber(N.bigDecimal).next());
+ assertEquals(new BigDecimal("1.0"),
__.__("1.0").asNumber(N.bigDecimal).next());
}
// ===== EDGE CASE TESTS =====
@Test
public void testCastInfinityAndNaN() {
- assertEquals(Double.POSITIVE_INFINITY,
__.__(Float.POSITIVE_INFINITY).asNumber(N.ndouble).next());
- assertEquals(Double.NEGATIVE_INFINITY,
__.__(Float.NEGATIVE_INFINITY).asNumber(N.ndouble).next());
- assertEquals(Double.NaN, __.__(Float.NaN).asNumber(N.ndouble).next());
- assertEquals(Float.POSITIVE_INFINITY,
__.__(Double.POSITIVE_INFINITY).asNumber(N.nfloat).next());
- assertEquals(Float.NEGATIVE_INFINITY,
__.__(Double.NEGATIVE_INFINITY).asNumber(N.nfloat).next());
- assertEquals(Float.NaN, __.__(Double.NaN).asNumber(N.nfloat).next());
+ assertEquals(Double.POSITIVE_INFINITY,
__.__(Float.POSITIVE_INFINITY).asNumber(N.double_).next());
+ assertEquals(Double.NEGATIVE_INFINITY,
__.__(Float.NEGATIVE_INFINITY).asNumber(N.double_).next());
+ assertEquals(Double.NaN, __.__(Float.NaN).asNumber(N.double_).next());
+ assertEquals(Float.POSITIVE_INFINITY,
__.__(Double.POSITIVE_INFINITY).asNumber(N.float_).next());
+ assertEquals(Float.NEGATIVE_INFINITY,
__.__(Double.NEGATIVE_INFINITY).asNumber(N.float_).next());
+ assertEquals(Float.NaN, __.__(Double.NaN).asNumber(N.float_).next());
}
@Test
public void testStringWithWhitespace() {
- assertEquals(42, __.__(" 42 ").asNumber(N.nint).next());
- assertEquals(42, __.__("\t42\n").asNumber(N.nint).next());
- assertEquals(3.14, __.__(" 3.14 ").asNumber(N.ndouble).next());
- assertEquals((byte) 127, __.__(" 127 ").asNumber(N.nbyte).next());
+ assertEquals(42, __.__(" 42 ").asNumber(N.int_).next());
+ assertEquals(42, __.__("\t42\n").asNumber(N.int_).next());
+ assertEquals(3.14, __.__(" 3.14 ").asNumber(N.double_).next());
+ assertEquals((byte) 127, __.__(" 127 ").asNumber(N.byte_).next());
}
@Test
public void testStringWithPlusSign() {
- assertEquals(42, __.__("+42").asNumber(N.nint).next());
- assertEquals(3.14, __.__("+3.14").asNumber(N.ndouble).next());
- assertEquals((byte) 42, __.__("+42").asNumber(N.nbyte).next());
- assertEquals(new BigInteger("42"),
__.__("+42").asNumber(N.nbigInt).next());
+ assertEquals(42, __.__("+42").asNumber(N.int_).next());
+ assertEquals(3.14, __.__("+3.14").asNumber(N.double_).next());
+ assertEquals((byte) 42, __.__("+42").asNumber(N.byte_).next());
+ assertEquals(new BigInteger("42"),
__.__("+42").asNumber(N.bigInt).next());
}
@Test
public void testZeroValues() {
- assertEquals((byte) 0, __.__("0").asNumber(N.nbyte).next());
- assertEquals((short) 0, __.__("0").asNumber(N.nshort).next());
- assertEquals(0, __.__("0").asNumber(N.nint).next());
- assertEquals(0L, __.__("0").asNumber(N.nlong).next());
- assertEquals(0.0f, __.__("0.0").asNumber(N.nfloat).next());
- assertEquals(0.0, __.__("0.0").asNumber(N.ndouble).next());
- assertEquals(new BigInteger("0"),
__.__("0").asNumber(N.nbigInt).next());
- assertEquals(new BigDecimal("0.0"),
__.__("0.0").asNumber(N.nbigDecimal).next());
+ assertEquals((byte) 0, __.__("0").asNumber(N.byte_).next());
+ assertEquals((short) 0, __.__("0").asNumber(N.short_).next());
+ assertEquals(0, __.__("0").asNumber(N.int_).next());
+ assertEquals(0L, __.__("0").asNumber(N.long_).next());
+ assertEquals(0.0f, __.__("0.0").asNumber(N.float_).next());
+ assertEquals(0.0, __.__("0.0").asNumber(N.double_).next());
+ assertEquals(new BigInteger("0"),
__.__("0").asNumber(N.bigInt).next());
+ assertEquals(new BigDecimal("0.0"),
__.__("0.0").asNumber(N.bigDecimal).next());
}
@Test
public void testScientificNotation() {
- assertEquals(1.23e10f, __.__("1.23e10").asNumber(N.nfloat).next());
- assertEquals(1.23e10, __.__("1.23e10").asNumber(N.ndouble).next());
- assertEquals(1.23e-10f, __.__("1.23e-10").asNumber(N.nfloat).next());
- assertEquals(1.23e-10, __.__("1.23e-10").asNumber(N.ndouble).next());
- assertEquals(new BigDecimal("1.23E10"),
__.__("1.23e10").asNumber(N.nbigDecimal).next());
+ assertEquals(1.23e10f, __.__("1.23e10").asNumber(N.float_).next());
+ assertEquals(1.23e10, __.__("1.23e10").asNumber(N.double_).next());
+ assertEquals(1.23e-10f, __.__("1.23e-10").asNumber(N.float_).next());
+ assertEquals(1.23e-10, __.__("1.23e-10").asNumber(N.double_).next());
+ assertEquals(new BigDecimal("1.23E10"),
__.__("1.23e10").asNumber(N.bigDecimal).next());
}
// ===== OVERFLOW EXCEPTION TESTS =====
@Test(expected = ArithmeticException.class)
public void shouldThrowCastExceptionConvertingInfinityToWholeNumber() {
- __.__(Double.POSITIVE_INFINITY).asNumber(N.nlong).next();
+ __.__(Double.POSITIVE_INFINITY).asNumber(N.long_).next();
}
@Test(expected = ArithmeticException.class)
public void shouldThrowCastExceptionConvertingNaNToWholeNumber() {
- __.__(Double.NaN).asNumber(N.nint).next();
+ __.__(Double.NaN).asNumber(N.int_).next();
}
@Test(expected = ArithmeticException.class)
public void shouldThrowOverflowExceptionWhenStringByteOverflowsPositive() {
- __.__("128").asNumber(N.nbyte).next();
+ __.__("128").asNumber(N.byte_).next();
}
@Test(expected = ArithmeticException.class)
public void shouldThrowOverflowExceptionWhenStringByteOverflowsNegative() {
- __.__("-129").asNumber(N.nbyte).next();
+ __.__("-129").asNumber(N.byte_).next();
}
@Test(expected = ArithmeticException.class)
public void shouldThrowOverflowExceptionWhenStringShortOverflowsPositive()
{
- __.__("32768").asNumber(N.nshort).next();
+ __.__("32768").asNumber(N.short_).next();
}
@Test(expected = ArithmeticException.class)
public void shouldThrowOverflowExceptionWhenStringShortOverflowsNegative()
{
- __.__("-32769").asNumber(N.nshort).next();
+ __.__("-32769").asNumber(N.short_).next();
+ }
+
+ @Test(expected = ArithmeticException.class)
+ public void shouldThrowOverflowExceptionWhenBigDecimalToShortOverflows() {
+ __.__(new BigDecimal(Long.MAX_VALUE+"1")).asNumber(N.short_).next();
+ }
+
+ @Test(expected = ArithmeticException.class)
+ public void shouldThrowOverflowExceptionWhenFloatToLongOverflows() {
+ __.__(new Float(Long.MAX_VALUE+"1")).asNumber(N.long_).next();
+ }
+
+ @Test(expected = ArithmeticException.class)
+ public void shouldThrowOverflowExceptionWhenDoubleToLongOverflows() {
+ __.__(new Double(Long.MAX_VALUE+"1")).asNumber(N.long_).next();
}
@Test(expected = ArithmeticException.class)
public void shouldThrowOverflowExceptionWhenStringIntOverflowsPositive() {
- __.__("2147483648").asNumber(N.nint).next();
+ __.__("2147483648").asNumber(N.int_).next();
}
@Test(expected = ArithmeticException.class)
public void shouldThrowOverflowExceptionWhenStringIntOverflowsNegative() {
- __.__("-2147483649").asNumber(N.nint).next();
+ __.__("-2147483649").asNumber(N.int_).next();
}
@Test(expected = ArithmeticException.class)
public void shouldThrowOverflowExceptionWhenStringLongOverflowsPositive() {
- __.__("9223372036854775809").asNumber(N.nlong).next();
+ __.__("9223372036854775809").asNumber(N.long_).next();
}
@Test(expected = ArithmeticException.class)
public void shouldThrowOverflowExceptionWhenStringLongOverflowsNegative() {
- __.__("-9223372036854775809").asNumber(N.nlong).next();
+ __.__("-9223372036854775809").asNumber(N.long_).next();
}
@Test(expected = ArithmeticException.class)
public void shouldThrowOverflowExceptionWhenDoubleStringToFloatOverflows()
{
- __.__("3.5E38").asNumber(N.nfloat).next();
+ __.__("3.5E38").asNumber(N.float_).next();
}
@Test(expected = ArithmeticException.class)
public void
shouldThrowOverflowExceptionWhenBigDecimalStringToDoubleOverflows() {
- __.__("1.8E308").asNumber(N.ndouble).next();
+ __.__("1.8E308").asNumber(N.double_).next();
}
@Test(expected = ArithmeticException.class)
public void
shouldThrowOverflowExceptionWhenBigDecimalStringToFloatOverflows() {
- __.__("1.8E308").asNumber(N.nfloat).next();
+ __.__("1.8E308").asNumber(N.float_).next();
}
// ===== INVALID FORMAT EXCEPTION TESTS =====
@@ -355,26 +371,26 @@ public class AsNumberStepTest extends StepTest {
@Test
public void testBoundaryValues() {
- assertEquals(Byte.MAX_VALUE, __.__("127").asNumber(N.nbyte).next());
- assertEquals(Byte.MIN_VALUE, __.__("-128").asNumber(N.nbyte).next());
- assertEquals(Short.MAX_VALUE,
__.__("32767").asNumber(N.nshort).next());
- assertEquals(Short.MIN_VALUE,
__.__("-32768").asNumber(N.nshort).next());
- assertEquals(Integer.MAX_VALUE,
__.__("2147483647").asNumber(N.nint).next());
- assertEquals(Integer.MIN_VALUE,
__.__("-2147483648").asNumber(N.nint).next());
- assertEquals(Long.MAX_VALUE,
__.__("9223372036854775807").asNumber(N.nlong).next());
- assertEquals(Long.MIN_VALUE,
__.__("-9223372036854775808").asNumber(N.nlong).next());
+ assertEquals(Byte.MAX_VALUE, __.__("127").asNumber(N.byte_).next());
+ assertEquals(Byte.MIN_VALUE, __.__("-128").asNumber(N.byte_).next());
+ assertEquals(Short.MAX_VALUE,
__.__("32767").asNumber(N.short_).next());
+ assertEquals(Short.MIN_VALUE,
__.__("-32768").asNumber(N.short_).next());
+ assertEquals(Integer.MAX_VALUE,
__.__("2147483647").asNumber(N.int_).next());
+ assertEquals(Integer.MIN_VALUE,
__.__("-2147483648").asNumber(N.int_).next());
+ assertEquals(Long.MAX_VALUE,
__.__("9223372036854775807").asNumber(N.long_).next());
+ assertEquals(Long.MIN_VALUE,
__.__("-9223372036854775808").asNumber(N.long_).next());
}
@Test
public void testHighPrecisionDecimals() {
assertEquals(new
BigDecimal("3.141592653589793238462643383279502884197169399375105820974944592307816406286208998628034825342117067"),
-
__.__("3.141592653589793238462643383279502884197169399375105820974944592307816406286208998628034825342117067").asNumber(N.nbigDecimal).next());
+
__.__("3.141592653589793238462643383279502884197169399375105820974944592307816406286208998628034825342117067").asNumber(N.bigDecimal).next());
}
@Test
public void testVeryLargeNumbers() {
String largeNumber =
"12345678901234567890123456789012345678901234567890123456789012345678901234567890";
- assertEquals(new BigInteger(largeNumber),
__.__(largeNumber).asNumber(N.nbigInt).next());
+ assertEquals(new BigInteger(largeNumber),
__.__(largeNumber).asNumber(N.bigInt).next());
}
}
diff --git
a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/util/NumberHelperTest.java
b/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/util/NumberHelperTest.java
index 20772da0c9..ac848f6025 100644
---
a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/util/NumberHelperTest.java
+++
b/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/util/NumberHelperTest.java
@@ -715,73 +715,79 @@ public class NumberHelperTest {
@Test
public void shouldCastToReturnSameInstanceForSameClass() {
final Integer value = 42;
- assertEquals(value, NumberHelper.castTo(value, N.nint));
+ assertEquals(value, NumberHelper.castTo(value, N.int_));
}
@Test
public void shouldCastToConvertToByte() {
final Integer value = 42;
- assertEquals(Byte.valueOf((byte) 42), NumberHelper.castTo(value,
N.nbyte));
+ assertEquals(Byte.valueOf((byte) 42), NumberHelper.castTo(value,
N.byte_));
}
@Test
public void shouldCastToConvertToShort() {
final Integer value = 42;
- assertEquals(Short.valueOf((short) 42), NumberHelper.castTo(value,
N.nshort));
+ assertEquals(Short.valueOf((short) 42), NumberHelper.castTo(value,
N.short_));
}
@Test
public void shouldCastToConvertToLong() {
final Integer value = 42;
- assertEquals(Long.valueOf(42L), NumberHelper.castTo(value, N.nlong));
+ assertEquals(Long.valueOf(42L), NumberHelper.castTo(value, N.long_));
}
@Test
public void shouldCastToConvertToFloat() {
final Integer value = 42;
- assertEquals(Float.valueOf(42.0f), NumberHelper.castTo(value,
N.nfloat));
+ assertEquals(Float.valueOf(42.0f), NumberHelper.castTo(value,
N.float_));
}
@Test
public void shouldCastToConvertToDouble() {
final Integer value = 42;
- assertEquals(Double.valueOf(42.0), NumberHelper.castTo(value,
N.ndouble));
+ assertEquals(Double.valueOf(42.0), NumberHelper.castTo(value,
N.double_));
}
@Test
public void shouldCastToConvertToBigInteger() {
final Integer value = 42;
- assertEquals(BigInteger.valueOf(42), NumberHelper.castTo(value,
N.nbigInt));
+ assertEquals(BigInteger.valueOf(42), NumberHelper.castTo(value,
N.bigInt));
+ }
+
+ @Test
+ public void shouldCastToConvertDoubleToBigInteger() {
+ final Double value = new Double("1000000000000000000000");
+ assertEquals(new BigInteger("1000000000000000000000"),
NumberHelper.castTo(value, N.bigInt));
}
@Test
public void shouldCastToConvertToBigDecimal() {
final Integer value = 42;
- assertEquals(BigDecimal.valueOf(42), NumberHelper.castTo(value,
N.nbigDecimal));
+ assertEquals(BigDecimal.valueOf(42), NumberHelper.castTo(value,
N.bigDecimal));
}
@Test(expected = ArithmeticException.class)
public void shouldOverflowIfCannotFitInByte() {
final Integer value = 128;
- NumberHelper.castTo(value, N.nbyte);
+ NumberHelper.castTo(value, N.byte_);
}
@Test(expected = ArithmeticException.class)
public void shouldOverflowIfCannotFitInShort() {
final Integer value = 32768;
- NumberHelper.castTo(value, N.nshort);
+ NumberHelper.castTo(value, N.short_);
}
@Test(expected = ArithmeticException.class)
public void shouldOverflowIfCannotFitInInteger() {
final Long value = 2147483648L;
- NumberHelper.castTo(value, N.nint);
+ NumberHelper.castTo(value, N.int_);
}
@Test(expected = ArithmeticException.class)
public void shouldOverflowIfCannotFitInFloat() {
final Double value = Double.MAX_VALUE;
- NumberHelper.castTo(value, N.nfloat);
+ NumberHelper.castTo(value, N.float_);
}
}
diff --git a/gremlin-dotnet/src/Gremlin.Net/Process/Traversal/N.cs
b/gremlin-dotnet/src/Gremlin.Net/Process/Traversal/N.cs
index 8996957b30..b0081ba3d0 100644
--- a/gremlin-dotnet/src/Gremlin.Net/Process/Traversal/N.cs
+++ b/gremlin-dotnet/src/Gremlin.Net/Process/Traversal/N.cs
@@ -35,25 +35,25 @@ namespace Gremlin.Net.Process.Traversal
{
}
- public static N NByte => new N("nbyte");
- public static N NShort => new N("nshort");
- public static N NInt => new N("nint");
- public static N NLong => new N("nlong");
- public static N NFloat => new N("nfloat");
- public static N NDouble => new N("ndouble");
- public static N NBigInt => new N("nbigInt");
- public static N NBigDecimal => new N("nbigDecimal");
+ public static N Byte => new N("byte");
+ public static N Short => new N("short");
+ public static N Int => new N("int");
+ public static N Long => new N("long");
+ public static N Float => new N("float");
+ public static N Double => new N("double");
+ public static N BigInt => new N("bigInt");
+ public static N BigDecimal => new N("bigDecimal");
private static readonly Dictionary<string, N> Properties = new()
{
- { "nbyte", NByte },
- { "nshort", NShort },
- { "nint", NInt },
- { "nlong", NLong },
- { "nfloat", NFloat },
- { "ndouble", NDouble },
- { "nbigInt", NBigInt },
- { "nbigDecimal", NBigDecimal },
+ { "byte", Byte },
+ { "short", Short },
+ { "int", Int },
+ { "long", Long },
+ { "float", Float },
+ { "double", Double },
+ { "bigInt", BigInt },
+ { "bigDecimal", BigDecimal },
};
/// <summary>
diff --git a/gremlin-dotnet/test/Gremlin.Net.IntegrationTest/Gherkin/Gremlin.cs
b/gremlin-dotnet/test/Gremlin.Net.IntegrationTest/Gherkin/Gremlin.cs
index 466499259a..776bf8d651 100644
--- a/gremlin-dotnet/test/Gremlin.Net.IntegrationTest/Gherkin/Gremlin.cs
+++ b/gremlin-dotnet/test/Gremlin.Net.IntegrationTest/Gherkin/Gremlin.cs
@@ -629,23 +629,23 @@ namespace Gremlin.Net.IntegrationTest.Gherkin
{"g_injectX5nX_asNumber", new List<Func<GraphTraversalSource,
IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(new
BigInteger(5)).AsNumber()}},
{"g_injectX5_0X_asNumber", new List<Func<GraphTraversalSource,
IDictionary<string, object>, ITraversal>> {(g,p)
=>g.Inject<object>(5.0).AsNumber()}},
{"g_injectX5_75fX_asNumber", new
List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>>
{(g,p) =>g.Inject<object>(5.75f).AsNumber()}},
- {"g_injectX5_43X_asNumberXN_nintX", new
List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>>
{(g,p) =>g.Inject<object>(5.43).AsNumber(N.Nint)}},
- {"g_injectX5_67X_asNumberXN_nintX", new
List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>>
{(g,p) =>g.Inject<object>(5.67).AsNumber(N.Nint)}},
- {"g_injectX5X_asNumberXN_nlongX", new
List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>>
{(g,p) =>g.Inject<object>(5).AsNumber(N.Nlong)}},
- {"g_injectX12X_asNumberXN_nbyteX", new
List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>>
{(g,p) =>g.Inject<object>(12).AsNumber(N.Nbyte)}},
- {"g_injectX32768X_asNumberXN_nshortX", new
List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>>
{(g,p) =>g.Inject<object>(32768).AsNumber(N.Nshort)}},
- {"g_injectX300X_asNumberXN_nbyteX", new
List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>>
{(g,p) =>g.Inject<object>(300).AsNumber(N.Nbyte)}},
+ {"g_injectX5_43X_asNumberXN_intX", new
List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>>
{(g,p) =>g.Inject<object>(5.43).AsNumber(N.Int)}},
+ {"g_injectX5_67X_asNumberXN_intX", new
List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>>
{(g,p) =>g.Inject<object>(5.67).AsNumber(N.Int)}},
+ {"g_injectX5X_asNumberXN_longX", new
List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>>
{(g,p) =>g.Inject<object>(5).AsNumber(N.Long)}},
+ {"g_injectX12X_asNumberXN_byteX", new
List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>>
{(g,p) =>g.Inject<object>(12).AsNumber(N.Byte)}},
+ {"g_injectX32768X_asNumberXN_shortX", new
List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>>
{(g,p) =>g.Inject<object>(32768).AsNumber(N.Short)}},
+ {"g_injectX300X_asNumberXN_byteX", new
List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>>
{(g,p) =>g.Inject<object>(300).AsNumber(N.Byte)}},
{"g_injectX5X_asNumber", new List<Func<GraphTraversalSource,
IDictionary<string, object>, ITraversal>> {(g,p)
=>g.Inject<object>("5").AsNumber()}},
- {"g_injectX5X_asNumberXN_byteX", new
List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>>
{(g,p) =>g.Inject<object>("5").AsNumber(N.Nbyte)}},
- {"g_injectX1_000X_asNumberXN_nintX", new
List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>>
{(g,p) =>g.Inject<object>("1,000").AsNumber(N.Nint)}},
+ {"g_injectX5X_asNumberXN_byteX", new
List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>>
{(g,p) =>g.Inject<object>("5").AsNumber(N.Byte)}},
+ {"g_injectX1_000X_asNumberXN_bigIntX", new
List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>>
{(g,p) =>g.Inject<object>("1,000").AsNumber(N.BigInt)}},
{"g_injectXtestX_asNumber", new List<Func<GraphTraversalSource,
IDictionary<string, object>, ITraversal>> {(g,p)
=>g.Inject<object>("test").AsNumber()}},
{"g_injectX_1_2_3_4X_asNumber", new
List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>>
{(g,p) =>g.Inject<object>(new List<object> { 1, 2, 3, 4 }).AsNumber()}},
{"g_injectX1_2_3_4X_unfold_asNumber", new
List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>>
{(g,p) =>g.Inject<object>(new List<object> { 1, 2, 3, 4
}).Unfold<object>().AsNumber()}},
{"g_injectX_1__2__3__4_X_asNumberXX_foldXX", new
List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>>
{(g,p) =>g.Inject<object>("1", 2, "3", 4).AsNumber().Fold()}},
- {"g_injectX1_2_3_4_0x5X_asNumber_sum_asNumberXnbyteX", new
List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>>
{(g,p) =>g.Inject<object>(p["xx1"], p["xx2"], p["xx3"], "4",
"0x5").AsNumber().Sum<object>().AsNumber(N.Nbyte)}},
- {"g_VX1X_asNumberXN_nintX", new List<Func<GraphTraversalSource,
IDictionary<string, object>, ITraversal>> {(g,p)
=>g.Inject<object>(null).AsNumber(N.Nint)}},
-
{"g_V_asXaX_outXknowsX_asXbX_mathXa_plus_bX_byXageX_asNumberXnintX", new
List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>>
{(g,p) =>g.V().As("a").Out("knows").As("b").Math("a +
b").By("age").AsNumber(N.Nint)}},
-
{"g_withSideEffectXx_100X_V_age_mathX__plus_xX_asNumberXnlongX", new
List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>>
{(g,p) =>g.WithSideEffect("x", p["xx1"]).V().Values<object>("age").Math("_ +
x").AsNumber(N.Nlong)}},
+ {"g_injectX1_2_3_4_0x5X_asNumber_sum_asNumberXbyteX", new
List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>>
{(g,p) =>g.Inject<object>(p["xx1"], p["xx2"], p["xx3"], "4",
"0x5").AsNumber().Sum<object>().AsNumber(N.Byte)}},
+ {"g_VX1X_asNumberXN_intX", new List<Func<GraphTraversalSource,
IDictionary<string, object>, ITraversal>> {(g,p)
=>g.Inject<object>(null).AsNumber(N.Int)}},
+
{"g_V_asXaX_outXknowsX_asXbX_mathXa_plus_bX_byXageX_asNumberXintX", new
List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>>
{(g,p) =>g.V().As("a").Out("knows").As("b").Math("a +
b").By("age").AsNumber(N.Int)}},
+ {"g_withSideEffectXx_100X_V_age_mathX__plus_xX_asNumberXlongX",
new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>>
{(g,p) =>g.WithSideEffect("x", p["xx1"]).V().Values<object>("age").Math("_ +
x").AsNumber(N.Long)}},
{"g_injectX1_2X_asString", new List<Func<GraphTraversalSource,
IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(p["xx1"],
p["xx2"]).AsString()}},
{"g_injectX1_2X_asStringXlocalX", new
List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>>
{(g,p) =>g.Inject<object>(p["xx1"], p["xx2"]).AsString<object>(Scope.Local)}},
{"g_injectXlist_1_2X_asStringXlocalX", new
List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>>
{(g,p) =>g.Inject<object>(p["xx1"]).AsString<object>(Scope.Local)}},
diff --git a/gremlin-go/driver/cucumber/gremlin.go
b/gremlin-go/driver/cucumber/gremlin.go
index 9beb85fe5f..21ca5e9065 100644
--- a/gremlin-go/driver/cucumber/gremlin.go
+++ b/gremlin-go/driver/cucumber/gremlin.go
@@ -599,23 +599,23 @@ var translationMap = map[string][]func(g
*gremlingo.GraphTraversalSource, p map[
"g_injectX5nX_asNumber": {func(g *gremlingo.GraphTraversalSource, p
map[string]interface{}) *gremlingo.GraphTraversal {return
g.Inject(5).AsNumber()}},
"g_injectX5_0X_asNumber": {func(g *gremlingo.GraphTraversalSource, p
map[string]interface{}) *gremlingo.GraphTraversal {return
g.Inject(5.0).AsNumber()}},
"g_injectX5_75fX_asNumber": {func(g *gremlingo.GraphTraversalSource, p
map[string]interface{}) *gremlingo.GraphTraversal {return
g.Inject(5.75).AsNumber()}},
- "g_injectX5_43X_asNumberXN_nintX": {func(g
*gremlingo.GraphTraversalSource, p map[string]interface{})
*gremlingo.GraphTraversal {return g.Inject(5.43).AsNumber(gremlingo.N.Nint)}},
- "g_injectX5_67X_asNumberXN_nintX": {func(g
*gremlingo.GraphTraversalSource, p map[string]interface{})
*gremlingo.GraphTraversal {return g.Inject(5.67).AsNumber(gremlingo.N.Nint)}},
- "g_injectX5X_asNumberXN_nlongX": {func(g *gremlingo.GraphTraversalSource,
p map[string]interface{}) *gremlingo.GraphTraversal {return
g.Inject(5).AsNumber(gremlingo.N.Nlong)}},
- "g_injectX12X_asNumberXN_nbyteX": {func(g *gremlingo.GraphTraversalSource,
p map[string]interface{}) *gremlingo.GraphTraversal {return
g.Inject(12).AsNumber(gremlingo.N.Nbyte)}},
- "g_injectX32768X_asNumberXN_nshortX": {func(g
*gremlingo.GraphTraversalSource, p map[string]interface{})
*gremlingo.GraphTraversal {return
g.Inject(32768).AsNumber(gremlingo.N.Nshort)}},
- "g_injectX300X_asNumberXN_nbyteX": {func(g
*gremlingo.GraphTraversalSource, p map[string]interface{})
*gremlingo.GraphTraversal {return g.Inject(300).AsNumber(gremlingo.N.Nbyte)}},
+ "g_injectX5_43X_asNumberXN_intX": {func(g *gremlingo.GraphTraversalSource,
p map[string]interface{}) *gremlingo.GraphTraversal {return
g.Inject(5.43).AsNumber(gremlingo.N.Int)}},
+ "g_injectX5_67X_asNumberXN_intX": {func(g *gremlingo.GraphTraversalSource,
p map[string]interface{}) *gremlingo.GraphTraversal {return
g.Inject(5.67).AsNumber(gremlingo.N.Int)}},
+ "g_injectX5X_asNumberXN_longX": {func(g *gremlingo.GraphTraversalSource, p
map[string]interface{}) *gremlingo.GraphTraversal {return
g.Inject(5).AsNumber(gremlingo.N.Long)}},
+ "g_injectX12X_asNumberXN_byteX": {func(g *gremlingo.GraphTraversalSource,
p map[string]interface{}) *gremlingo.GraphTraversal {return
g.Inject(12).AsNumber(gremlingo.N.Byte)}},
+ "g_injectX32768X_asNumberXN_shortX": {func(g
*gremlingo.GraphTraversalSource, p map[string]interface{})
*gremlingo.GraphTraversal {return
g.Inject(32768).AsNumber(gremlingo.N.Short)}},
+ "g_injectX300X_asNumberXN_byteX": {func(g *gremlingo.GraphTraversalSource,
p map[string]interface{}) *gremlingo.GraphTraversal {return
g.Inject(300).AsNumber(gremlingo.N.Byte)}},
"g_injectX5X_asNumber": {func(g *gremlingo.GraphTraversalSource, p
map[string]interface{}) *gremlingo.GraphTraversal {return
g.Inject("5").AsNumber()}},
- "g_injectX5X_asNumberXN_byteX": {func(g *gremlingo.GraphTraversalSource, p
map[string]interface{}) *gremlingo.GraphTraversal {return
g.Inject("5").AsNumber(gremlingo.N.Nbyte)}},
- "g_injectX1_000X_asNumberXN_nintX": {func(g
*gremlingo.GraphTraversalSource, p map[string]interface{})
*gremlingo.GraphTraversal {return
g.Inject("1,000").AsNumber(gremlingo.N.Nint)}},
+ "g_injectX5X_asNumberXN_byteX": {func(g *gremlingo.GraphTraversalSource, p
map[string]interface{}) *gremlingo.GraphTraversal {return
g.Inject("5").AsNumber(gremlingo.N.Byte)}},
+ "g_injectX1_000X_asNumberXN_bigIntX": {func(g
*gremlingo.GraphTraversalSource, p map[string]interface{})
*gremlingo.GraphTraversal {return
g.Inject("1,000").AsNumber(gremlingo.N.BigInt)}},
"g_injectXtestX_asNumber": {func(g *gremlingo.GraphTraversalSource, p
map[string]interface{}) *gremlingo.GraphTraversal {return
g.Inject("test").AsNumber()}},
"g_injectX_1_2_3_4X_asNumber": {func(g *gremlingo.GraphTraversalSource, p
map[string]interface{}) *gremlingo.GraphTraversal {return
g.Inject([]interface{}{1, 2, 3, 4}).AsNumber()}},
"g_injectX1_2_3_4X_unfold_asNumber": {func(g
*gremlingo.GraphTraversalSource, p map[string]interface{})
*gremlingo.GraphTraversal {return g.Inject([]interface{}{1, 2, 3,
4}).Unfold().AsNumber()}},
"g_injectX_1__2__3__4_X_asNumberXX_foldXX": {func(g
*gremlingo.GraphTraversalSource, p map[string]interface{})
*gremlingo.GraphTraversal {return g.Inject("1", 2, "3", 4).AsNumber().Fold()}},
- "g_injectX1_2_3_4_0x5X_asNumber_sum_asNumberXnbyteX": {func(g
*gremlingo.GraphTraversalSource, p map[string]interface{})
*gremlingo.GraphTraversal {return g.Inject(p["xx1"], p["xx2"], p["xx3"], "4",
"0x5").AsNumber().Sum().AsNumber(gremlingo.N.Nbyte)}},
- "g_VX1X_asNumberXN_nintX": {func(g *gremlingo.GraphTraversalSource, p
map[string]interface{}) *gremlingo.GraphTraversal {return
g.Inject(nil).AsNumber(gremlingo.N.Nint)}},
- "g_V_asXaX_outXknowsX_asXbX_mathXa_plus_bX_byXageX_asNumberXnintX":
{func(g *gremlingo.GraphTraversalSource, p map[string]interface{})
*gremlingo.GraphTraversal {return g.V().As("a").Out("knows").As("b").Math("a +
b").By("age").AsNumber(gremlingo.N.Nint)}},
- "g_withSideEffectXx_100X_V_age_mathX__plus_xX_asNumberXnlongX": {func(g
*gremlingo.GraphTraversalSource, p map[string]interface{})
*gremlingo.GraphTraversal {return g.WithSideEffect("x",
p["xx1"]).V().Values("age").Math("_ + x").AsNumber(gremlingo.N.Nlong)}},
+ "g_injectX1_2_3_4_0x5X_asNumber_sum_asNumberXbyteX": {func(g
*gremlingo.GraphTraversalSource, p map[string]interface{})
*gremlingo.GraphTraversal {return g.Inject(p["xx1"], p["xx2"], p["xx3"], "4",
"0x5").AsNumber().Sum().AsNumber(gremlingo.N.Byte)}},
+ "g_VX1X_asNumberXN_intX": {func(g *gremlingo.GraphTraversalSource, p
map[string]interface{}) *gremlingo.GraphTraversal {return
g.Inject(nil).AsNumber(gremlingo.N.Int)}},
+ "g_V_asXaX_outXknowsX_asXbX_mathXa_plus_bX_byXageX_asNumberXintX": {func(g
*gremlingo.GraphTraversalSource, p map[string]interface{})
*gremlingo.GraphTraversal {return g.V().As("a").Out("knows").As("b").Math("a +
b").By("age").AsNumber(gremlingo.N.Int)}},
+ "g_withSideEffectXx_100X_V_age_mathX__plus_xX_asNumberXlongX": {func(g
*gremlingo.GraphTraversalSource, p map[string]interface{})
*gremlingo.GraphTraversal {return g.WithSideEffect("x",
p["xx1"]).V().Values("age").Math("_ + x").AsNumber(gremlingo.N.Long)}},
"g_injectX1_2X_asString": {func(g *gremlingo.GraphTraversalSource, p
map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(p["xx1"],
p["xx2"]).AsString()}},
"g_injectX1_2X_asStringXlocalX": {func(g *gremlingo.GraphTraversalSource,
p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(p["xx1"],
p["xx2"]).AsString(gremlingo.Scope.Local)}},
"g_injectXlist_1_2X_asStringXlocalX": {func(g
*gremlingo.GraphTraversalSource, p map[string]interface{})
*gremlingo.GraphTraversal {return
g.Inject(p["xx1"]).AsString(gremlingo.Scope.Local)}},
diff --git a/gremlin-go/driver/serializer.go b/gremlin-go/driver/serializer.go
index 8a2dec9d56..314d2767f9 100644
--- a/gremlin-go/driver/serializer.go
+++ b/gremlin-go/driver/serializer.go
@@ -328,7 +328,7 @@ func initDeserializers() {
tType: enumReader,
directionType: enumReader,
dtType: enumReader,
- nType: enumReader,
+ nType: enumReader,
bindingType: bindingReader,
// Metrics
diff --git a/gremlin-go/driver/traversal.go b/gremlin-go/driver/traversal.go
index bd21fb6a06..811ff971e1 100644
--- a/gremlin-go/driver/traversal.go
+++ b/gremlin-go/driver/traversal.go
@@ -364,33 +364,33 @@ type n string
type ns struct {
// number type byte
- Nbyte n
+ Byte n
// number type short
- Nshort n
+ Short n
// number type int
- Nint n
+ Int n
// number type long
- Nlong n
+ Long n
// number type float
- Nfloat n
+ Float n
// number type double
- Ndouble n
+ Double n
// number type bigInt
- NbigInt n
+ BigInt n
// number type bigDecimal
- NbigDecimal n
+ BigDecimal n
}
// N is a set of operations for denoting number types during conversion.
var N = ns{
- Nbyte: "nbyte",
- Nshort: "nshort",
- Nint: "nint",
- Nlong: "nlong",
- Nfloat: "nfloat",
- Ndouble: "ndouble",
- NbigInt: "nbigInt",
- NbigDecimal: "nbigDecimal",
+ Byte: "byte",
+ Short: "short",
+ Int: "int",
+ Long: "long",
+ Float: "float",
+ Double: "double",
+ BigInt: "bigInt",
+ BigDecimal: "bigDecimal",
}
type operator string
diff --git
a/gremlin-javascript/src/main/javascript/gremlin-javascript/lib/process/traversal.js
b/gremlin-javascript/src/main/javascript/gremlin-javascript/lib/process/traversal.js
index 84c8482f8f..2bc9705fe9 100644
---
a/gremlin-javascript/src/main/javascript/gremlin-javascript/lib/process/traversal.js
+++
b/gremlin-javascript/src/main/javascript/gremlin-javascript/lib/process/traversal.js
@@ -487,6 +487,14 @@ function toDirectionEnum(typeName, keys) {
return result;
}
+function toNEnum(typeName, keys) {
+ const result = {};
+ keys.split(' ').forEach((k) => {
+ result[k] = new EnumValue(typeName, k.replace('_', ''));
+ });
+ return result;
+}
+
class EnumValue {
constructor(typeName, elementName) {
this.typeName = typeName;
@@ -512,7 +520,7 @@ module.exports = {
column: toEnum('Column', 'keys values'),
direction: toDirectionEnum('Direction', 'BOTH IN OUT from_ to'),
dt: toEnum('DT', 'second minute hour day'),
- n: toEnum('N', 'nbyte nshort nint nlong nfloat ndouble nbigint nbigdecimal'),
+ n: toNEnum('N', 'byte_ short_ int_ long_ float_ double_ bigInt bigDecimal'),
graphSONVersion: toEnum('GraphSONVersion', 'V1_0 V2_0 V3_0'),
gryoVersion: toEnum('GryoVersion', 'V1_0 V3_0'),
merge: toEnum('Merge', 'onCreate onMatch outV inV'),
diff --git
a/gremlin-javascript/src/main/javascript/gremlin-javascript/test/cucumber/gremlin.js
b/gremlin-javascript/src/main/javascript/gremlin-javascript/test/cucumber/gremlin.js
index 9ad1b33b8e..aab5f6a21e 100644
---
a/gremlin-javascript/src/main/javascript/gremlin-javascript/test/cucumber/gremlin.js
+++
b/gremlin-javascript/src/main/javascript/gremlin-javascript/test/cucumber/gremlin.js
@@ -630,23 +630,23 @@ const gremlins = {
g_injectX5nX_asNumber: [function({g}) { return g.inject(5).asNumber() }],
g_injectX5_0X_asNumber: [function({g}) { return g.inject(5.0).asNumber()
}],
g_injectX5_75fX_asNumber: [function({g}) { return
g.inject(5.75).asNumber() }],
- g_injectX5_43X_asNumberXN_nintX: [function({g}) { return
g.inject(5.43).asNumber(N.nint) }],
- g_injectX5_67X_asNumberXN_nintX: [function({g}) { return
g.inject(5.67).asNumber(N.nint) }],
- g_injectX5X_asNumberXN_nlongX: [function({g}) { return
g.inject(5).asNumber(N.nlong) }],
- g_injectX12X_asNumberXN_nbyteX: [function({g}) { return
g.inject(12).asNumber(N.nbyte) }],
- g_injectX32768X_asNumberXN_nshortX: [function({g}) { return
g.inject(32768).asNumber(N.nshort) }],
- g_injectX300X_asNumberXN_nbyteX: [function({g}) { return
g.inject(300).asNumber(N.nbyte) }],
+ g_injectX5_43X_asNumberXN_intX: [function({g}) { return
g.inject(5.43).asNumber(N.int_) }],
+ g_injectX5_67X_asNumberXN_intX: [function({g}) { return
g.inject(5.67).asNumber(N.int_) }],
+ g_injectX5X_asNumberXN_longX: [function({g}) { return
g.inject(5).asNumber(N.long_) }],
+ g_injectX12X_asNumberXN_byteX: [function({g}) { return
g.inject(12).asNumber(N.byte_) }],
+ g_injectX32768X_asNumberXN_shortX: [function({g}) { return
g.inject(32768).asNumber(N.short_) }],
+ g_injectX300X_asNumberXN_byteX: [function({g}) { return
g.inject(300).asNumber(N.byte_) }],
g_injectX5X_asNumber: [function({g}) { return g.inject("5").asNumber() }],
- g_injectX5X_asNumberXN_byteX: [function({g}) { return
g.inject("5").asNumber(N.nbyte) }],
- g_injectX1_000X_asNumberXN_nintX: [function({g}) { return
g.inject("1,000").asNumber(N.nint) }],
+ g_injectX5X_asNumberXN_byteX: [function({g}) { return
g.inject("5").asNumber(N.byte_) }],
+ g_injectX1_000X_asNumberXN_bigIntX: [function({g}) { return
g.inject("1,000").asNumber(N.bigInt) }],
g_injectXtestX_asNumber: [function({g}) { return
g.inject("test").asNumber() }],
g_injectX_1_2_3_4X_asNumber: [function({g}) { return g.inject([1, 2, 3,
4]).asNumber() }],
g_injectX1_2_3_4X_unfold_asNumber: [function({g}) { return g.inject([1, 2,
3, 4]).unfold().asNumber() }],
g_injectX_1__2__3__4_X_asNumberXX_foldXX: [function({g}) { return
g.inject("1", 2, "3", 4).asNumber().fold() }],
- g_injectX1_2_3_4_0x5X_asNumber_sum_asNumberXnbyteX: [function({g, xx1,
xx3, xx2}) { return g.inject(xx1, xx2, xx3, "4",
"0x5").asNumber().sum().asNumber(N.nbyte) }],
- g_VX1X_asNumberXN_nintX: [function({g}) { return
g.inject(null).asNumber(N.nint) }],
- g_V_asXaX_outXknowsX_asXbX_mathXa_plus_bX_byXageX_asNumberXnintX:
[function({g}) { return g.V().as("a").out("knows").as("b").math("a +
b").by("age").asNumber(N.nint) }],
- g_withSideEffectXx_100X_V_age_mathX__plus_xX_asNumberXnlongX:
[function({g, xx1}) { return g.withSideEffect("x",
xx1).V().values("age").math("_ + x").asNumber(N.nlong) }],
+ g_injectX1_2_3_4_0x5X_asNumber_sum_asNumberXbyteX: [function({g, xx1, xx3,
xx2}) { return g.inject(xx1, xx2, xx3, "4",
"0x5").asNumber().sum().asNumber(N.byte_) }],
+ g_VX1X_asNumberXN_intX: [function({g}) { return
g.inject(null).asNumber(N.int_) }],
+ g_V_asXaX_outXknowsX_asXbX_mathXa_plus_bX_byXageX_asNumberXintX:
[function({g}) { return g.V().as("a").out("knows").as("b").math("a +
b").by("age").asNumber(N.int_) }],
+ g_withSideEffectXx_100X_V_age_mathX__plus_xX_asNumberXlongX: [function({g,
xx1}) { return g.withSideEffect("x", xx1).V().values("age").math("_ +
x").asNumber(N.long_) }],
g_injectX1_2X_asString: [function({g, xx1, xx2}) { return g.inject(xx1,
xx2).asString() }],
g_injectX1_2X_asStringXlocalX: [function({g, xx1, xx2}) { return
g.inject(xx1, xx2).asString(Scope.local) }],
g_injectXlist_1_2X_asStringXlocalX: [function({g, xx1}) { return
g.inject(xx1).asString(Scope.local) }],
diff --git
a/gremlin-javascript/src/main/javascript/gremlin-javascript/test/unit/graphbinary/AnySerializer-test.js
b/gremlin-javascript/src/main/javascript/gremlin-javascript/test/unit/graphbinary/AnySerializer-test.js
index b9399a6fff..d723c85cd9 100644
---
a/gremlin-javascript/src/main/javascript/gremlin-javascript/test/unit/graphbinary/AnySerializer-test.js
+++
b/gremlin-javascript/src/main/javascript/gremlin-javascript/test/unit/graphbinary/AnySerializer-test.js
@@ -176,8 +176,8 @@ describe('GraphBinary.AnySerializer', () => {
{ v: new t.EnumValue('Merge', 'onMatch'),
b: [ DataType.MERGE,0x00, DataType.STRING,0x00, 0x00,0x00,0x00,0x07,
...from('onMatch') ]
},
- { v: new t.EnumValue('N', 'nbyte'),
- b: [ DataType.N,0x00, DataType.STRING,0x00, 0x00,0x00,0x00,0x05,
...from('nbyte') ]
+ { v: new t.EnumValue('N', 'byte'),
+ b: [ DataType.N,0x00, DataType.STRING,0x00, 0x00,0x00,0x00,0x04,
...from('byte') ]
},
{ v: new t.EnumValue('Operator', 'addAll'),
b: [ DataType.OPERATOR,0x00, DataType.STRING,0x00,
0x00,0x00,0x00,0x06, ...from('addAll') ]
@@ -522,7 +522,7 @@ describe('GraphBinary.AnySerializer', () => {
// N
{ v:null, b:[0x30,0x01] },
- { v:new t.EnumValue('N','nbyte'), b:[0x30,0x00, 0x03,0x00,
0x00,0x00,0x00,0x05, ...from('nbyte')] },
+ { v:new t.EnumValue('N','byte'), b:[0x30,0x00, 0x03,0x00,
0x00,0x00,0x00,0x04, ...from('byte')] },
// OPERATOR
{ v:null, b:[0x19,0x01] },
diff --git
a/gremlin-javascript/src/main/javascript/gremlin-javascript/test/unit/graphbinary/EnumSerializer-test.js
b/gremlin-javascript/src/main/javascript/gremlin-javascript/test/unit/graphbinary/EnumSerializer-test.js
index a5765995da..4dc0abd616 100644
---
a/gremlin-javascript/src/main/javascript/gremlin-javascript/test/unit/graphbinary/EnumSerializer-test.js
+++
b/gremlin-javascript/src/main/javascript/gremlin-javascript/test/unit/graphbinary/EnumSerializer-test.js
@@ -36,6 +36,7 @@ describe('GraphBinary.EnumSerializer', () => {
{ name: 'Cardinality', code: from([0x16]), enum: t.cardinality },
{ name: 'Column', code: from([0x17]), enum: t.column },
{ name: 'Direction', code: from([0x18]), enum: t.direction },
+ { name: 'N', code: from([0x30]), enum: t.n },
{ name: 'Operator', code: from([0x19]), enum: t.operator },
{ name: 'Order', code: from([0x1A]), enum: t.order },
{ name: 'Pick', code: from([0x1B]), enum: t.pick },
diff --git a/gremlin-language/src/main/antlr4/Gremlin.g4
b/gremlin-language/src/main/antlr4/Gremlin.g4
index d7037a4fff..00031355f6 100644
--- a/gremlin-language/src/main/antlr4/Gremlin.g4
+++ b/gremlin-language/src/main/antlr4/Gremlin.g4
@@ -1963,15 +1963,15 @@ K_BARRIER: 'barrier';
K_BARRIERU: 'Barrier';
K_BEGIN: 'begin';
K_BETWEEN: 'between';
-K_BIGDECIMAL: 'nbigDecimal';
-K_BIGINT: 'nbigInt';
+K_BIGDECIMAL: 'bigDecimal';
+K_BIGINT: 'bigInt';
K_BOTH: 'both';
K_BOTHU: 'BOTH';
K_BOTHE: 'bothE';
K_BOTHV: 'bothV';
K_BRANCH: 'branch';
K_BY: 'by';
-K_BYTE: 'nbyte';
+K_BYTE: 'byte';
K_CALL: 'call';
K_CAP: 'cap';
K_CARDINALITY: 'Cardinality';
@@ -2003,7 +2003,7 @@ K_DIRECTION: 'Direction';
K_DISJUNCT: 'disjunct';
K_DISTANCE: 'distance';
K_DIV: 'div';
-K_DOUBLE: 'ndouble';
+K_DOUBLE: 'double';
K_DROP: 'drop';
K_DT: 'DT';
K_E: 'E';
@@ -2019,7 +2019,7 @@ K_FALSE: 'false';
K_FILTER: 'filter';
K_FIRST: 'first';
K_FLATMAP: 'flatMap';
-K_FLOAT: 'nfloat';
+K_FLOAT: 'float';
K_FOLD: 'fold';
K_FORMAT: 'format';
K_FROM: 'from';
@@ -2052,7 +2052,7 @@ K_INDEX: 'index';
K_INFINITY: 'Infinity';
K_INJECT: 'inject';
K_INSIDE: 'inside';
-K_INT: 'nint';
+K_INT: 'int';
K_INTERSECT: 'intersect';
K_INV: 'inV';
K_IOU: 'IO';
@@ -2068,7 +2068,7 @@ K_LENGTH: 'length';
K_LIMIT: 'limit';
K_LIST: 'list';
K_LOCAL: 'local';
-K_LONG: 'nlong';
+K_LONG: 'long';
K_LOOPS: 'loops';
K_LT: 'lt';
K_LTE: 'lte';
@@ -2149,7 +2149,7 @@ K_SET: 'set';
K_SHORTESTPATHU: 'ShortestPath';
K_SHORTESTPATH: 'shortestPath';
K_SHUFFLE: 'shuffle';
-K_SHORT: 'nshort';
+K_SHORT: 'short';
K_SIDEEFFECT: 'sideEffect';
K_SIMPLEPATH: 'simplePath';
K_SINGLE: 'single';
diff --git
a/gremlin-language/src/main/java/org/apache/tinkerpop/gremlin/language/corpus/DocumentationReader.java
b/gremlin-language/src/main/java/org/apache/tinkerpop/gremlin/language/corpus/DocumentationReader.java
index d68af03fc7..d25f59d98e 100644
---
a/gremlin-language/src/main/java/org/apache/tinkerpop/gremlin/language/corpus/DocumentationReader.java
+++
b/gremlin-language/src/main/java/org/apache/tinkerpop/gremlin/language/corpus/DocumentationReader.java
@@ -122,6 +122,8 @@ public class DocumentationReader {
replace(".getClass()", "").
replace("result.toArray()", "4").
replace("vA.value('amount')", "0.0").
- replace("vA", "\"vA\"");
+ replace("vA", "\"vA\"").
+ replace("N.int_", "N.int").
+ replace("N.byte_", "N.byte");
}
}
diff --git a/gremlin-python/src/main/python/gremlin_python/process/traversal.py
b/gremlin-python/src/main/python/gremlin_python/process/traversal.py
index 4f93bf97ad..70b4902da8 100644
--- a/gremlin-python/src/main/python/gremlin_python/process/traversal.py
+++ b/gremlin-python/src/main/python/gremlin_python/process/traversal.py
@@ -208,15 +208,16 @@ statics.add_static('on_match', Merge.on_match)
statics.add_static('in_v', Merge.in_v)
statics.add_static('out_v', Merge.out_v)
-N = Enum('N', ' nbyte nshort nint nlong nfloat ndouble nbigInt nbigDecimal')
-statics.add_static('nbyte', N.nbyte)
-statics.add_static('nshort', N.nshort)
-statics.add_static('nint', N.nint)
-statics.add_static('nlong', N.nlong)
-statics.add_static('nfloat', N.nfloat)
-statics.add_static('ndouble', N.ndouble)
-statics.add_static('nbigInt', N.nbigInt)
-statics.add_static('nbigDecimal', N.nbigDecimal)
+N = Enum('N', ' byte short int long float double big_int big_decimal')
+# no keyword collision so enum is defined as lang, but has collision with type
aliases defined in statics
+statics.add_static('byte_', N.byte)
+statics.add_static('short_', N.short)
+statics.add_static('int_', N.int)
+statics.add_static('long_', N.long)
+statics.add_static('float_', N.float)
+statics.add_static('double_', N.double)
+statics.add_static('big_int', N.big_int)
+statics.add_static('big_decimal', N.big_decimal)
Order = Enum('Order', ' asc desc shuffle')
@@ -326,7 +327,7 @@ class P(object):
return P("within", list(args[0]))
else:
return P("within", list(args))
-
+
@staticmethod
def without(*args):
if len(args) == 1 and type(args[0]) == list:
diff --git a/gremlin-python/src/main/python/radish/gremlin.py
b/gremlin-python/src/main/python/radish/gremlin.py
index f33c343d58..38a2fdaa4f 100644
--- a/gremlin-python/src/main/python/radish/gremlin.py
+++ b/gremlin-python/src/main/python/radish/gremlin.py
@@ -602,23 +602,23 @@ world.gremlins = {
'g_injectX5nX_asNumber': [(lambda g:g.inject(bigint(5)).as_number())],
'g_injectX5_0X_asNumber': [(lambda g:g.inject(5.0).as_number())],
'g_injectX5_75fX_asNumber': [(lambda g:g.inject(5.75).as_number())],
- 'g_injectX5_43X_asNumberXN_nintX': [(lambda
g:g.inject(5.43).as_number(N.nint))],
- 'g_injectX5_67X_asNumberXN_nintX': [(lambda
g:g.inject(5.67).as_number(N.nint))],
- 'g_injectX5X_asNumberXN_nlongX': [(lambda
g:g.inject(5).as_number(N.nlong))],
- 'g_injectX12X_asNumberXN_nbyteX': [(lambda
g:g.inject(12).as_number(N.nbyte))],
- 'g_injectX32768X_asNumberXN_nshortX': [(lambda
g:g.inject(32768).as_number(N.nshort))],
- 'g_injectX300X_asNumberXN_nbyteX': [(lambda
g:g.inject(300).as_number(N.nbyte))],
+ 'g_injectX5_43X_asNumberXN_intX': [(lambda
g:g.inject(5.43).as_number(N.int))],
+ 'g_injectX5_67X_asNumberXN_intX': [(lambda
g:g.inject(5.67).as_number(N.int))],
+ 'g_injectX5X_asNumberXN_longX': [(lambda
g:g.inject(5).as_number(N.long))],
+ 'g_injectX12X_asNumberXN_byteX': [(lambda
g:g.inject(12).as_number(N.byte))],
+ 'g_injectX32768X_asNumberXN_shortX': [(lambda
g:g.inject(32768).as_number(N.short))],
+ 'g_injectX300X_asNumberXN_byteX': [(lambda
g:g.inject(300).as_number(N.byte))],
'g_injectX5X_asNumber': [(lambda g:g.inject('5').as_number())],
- 'g_injectX5X_asNumberXN_byteX': [(lambda
g:g.inject('5').as_number(N.nbyte))],
- 'g_injectX1_000X_asNumberXN_nintX': [(lambda
g:g.inject('1,000').as_number(N.nint))],
+ 'g_injectX5X_asNumberXN_byteX': [(lambda
g:g.inject('5').as_number(N.byte))],
+ 'g_injectX1_000X_asNumberXN_bigIntX': [(lambda
g:g.inject('1,000').as_number(N.big_int))],
'g_injectXtestX_asNumber': [(lambda g:g.inject('test').as_number())],
'g_injectX_1_2_3_4X_asNumber': [(lambda g:g.inject([1, 2, 3,
4]).as_number())],
'g_injectX1_2_3_4X_unfold_asNumber': [(lambda g:g.inject([1, 2, 3,
4]).unfold().as_number())],
'g_injectX_1__2__3__4_X_asNumberXX_foldXX': [(lambda g:g.inject('1', 2,
'3', 4).as_number().fold())],
- 'g_injectX1_2_3_4_0x5X_asNumber_sum_asNumberXnbyteX': [(lambda g,
xx1=None,xx3=None,xx2=None:g.inject(xx1, xx2, xx3, '4',
'0x5').as_number().sum_().as_number(N.nbyte))],
- 'g_VX1X_asNumberXN_nintX': [(lambda g:g.inject(None).as_number(N.nint))],
- 'g_V_asXaX_outXknowsX_asXbX_mathXa_plus_bX_byXageX_asNumberXnintX':
[(lambda g:g.V().as_('a').out('knows').as_('b').math('a +
b').by('age').as_number(N.nint))],
- 'g_withSideEffectXx_100X_V_age_mathX__plus_xX_asNumberXnlongX': [(lambda
g, xx1=None:g.with_side_effect('x', xx1).V().values('age').math('_ +
x').as_number(N.nlong))],
+ 'g_injectX1_2_3_4_0x5X_asNumber_sum_asNumberXbyteX': [(lambda g,
xx1=None,xx3=None,xx2=None:g.inject(xx1, xx2, xx3, '4',
'0x5').as_number().sum_().as_number(N.byte))],
+ 'g_VX1X_asNumberXN_intX': [(lambda g:g.inject(None).as_number(N.int))],
+ 'g_V_asXaX_outXknowsX_asXbX_mathXa_plus_bX_byXageX_asNumberXintX':
[(lambda g:g.V().as_('a').out('knows').as_('b').math('a +
b').by('age').as_number(N.int))],
+ 'g_withSideEffectXx_100X_V_age_mathX__plus_xX_asNumberXlongX': [(lambda g,
xx1=None:g.with_side_effect('x', xx1).V().values('age').math('_ +
x').as_number(N.long))],
'g_injectX1_2X_asString': [(lambda g, xx1=None,xx2=None:g.inject(xx1,
xx2).as_string())],
'g_injectX1_2X_asStringXlocalX': [(lambda g,
xx1=None,xx2=None:g.inject(xx1, xx2).as_string(Scope.local))],
'g_injectXlist_1_2X_asStringXlocalX': [(lambda g,
xx1=None:g.inject(xx1).as_string(Scope.local))],
diff --git
a/gremlin-python/src/main/python/tests/driver/test_driver_remote_connection.py
b/gremlin-python/src/main/python/tests/driver/test_driver_remote_connection.py
index fe402a1091..eb6beee5c6 100644
---
a/gremlin-python/src/main/python/tests/driver/test_driver_remote_connection.py
+++
b/gremlin-python/src/main/python/tests/driver/test_driver_remote_connection.py
@@ -25,7 +25,7 @@ from gremlin_python.statics import long
from gremlin_python.process.traversal import Traverser
from gremlin_python.process.traversal import TraversalStrategy
from gremlin_python.process.traversal import Bindings
-from gremlin_python.process.traversal import P, Order, T, N
+from gremlin_python.process.traversal import P, Order, T
from gremlin_python.process.graph_traversal import __
from gremlin_python.process.anonymous_traversal import traversal
from gremlin_python.structure.graph import Vertex
diff --git
a/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/map/AsNumber.feature
b/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/map/AsNumber.feature
index cb36ba87b6..1777cfb785 100644
---
a/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/map/AsNumber.feature
+++
b/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/map/AsNumber.feature
@@ -103,11 +103,11 @@ Feature: Step - asNumber()
| d[5.75].f |
@GraphComputerVerificationInjectionNotSupported
- Scenario: g_injectX5_43X_asNumberXN_nintX
+ Scenario: g_injectX5_43X_asNumberXN_intX
Given the empty graph
And the traversal of
"""
- g.inject(5.43).asNumber(N.nint)
+ g.inject(5.43).asNumber(N.int)
"""
When iterated to list
Then the result should be unordered
@@ -115,11 +115,11 @@ Feature: Step - asNumber()
| d[5].i |
@GraphComputerVerificationInjectionNotSupported
- Scenario: g_injectX5_67X_asNumberXN_nintX
+ Scenario: g_injectX5_67X_asNumberXN_intX
Given the empty graph
And the traversal of
"""
- g.inject(5.67).asNumber(N.nint)
+ g.inject(5.67).asNumber(N.int)
"""
When iterated to list
Then the result should be unordered
@@ -127,11 +127,11 @@ Feature: Step - asNumber()
| d[5].i |
@GraphComputerVerificationInjectionNotSupported
- Scenario: g_injectX5X_asNumberXN_nlongX
+ Scenario: g_injectX5X_asNumberXN_longX
Given the empty graph
And the traversal of
"""
- g.inject(5).asNumber(N.nlong)
+ g.inject(5).asNumber(N.long)
"""
When iterated to list
Then the result should be unordered
@@ -139,11 +139,11 @@ Feature: Step - asNumber()
| d[5].l |
@GraphComputerVerificationInjectionNotSupported
- Scenario: g_injectX12X_asNumberXN_nbyteX
+ Scenario: g_injectX12X_asNumberXN_byteX
Given the empty graph
And the traversal of
"""
- g.inject(12).asNumber(N.nbyte)
+ g.inject(12).asNumber(N.byte)
"""
When iterated to list
Then the result should be unordered
@@ -151,21 +151,21 @@ Feature: Step - asNumber()
| d[12].b |
@GraphComputerVerificationInjectionNotSupported
- Scenario: g_injectX32768X_asNumberXN_nshortX
+ Scenario: g_injectX32768X_asNumberXN_shortX
Given the empty graph
And the traversal of
"""
- g.inject(32768).asNumber(N.nshort)
+ g.inject(32768).asNumber(N.short)
"""
When iterated to list
Then the traversal will raise an error with message containing text of
"Can't convert number of type Integer to Short due to overflow."
@GraphComputerVerificationInjectionNotSupported
- Scenario: g_injectX300X_asNumberXN_nbyteX
+ Scenario: g_injectX300X_asNumberXN_byteX
Given the empty graph
And the traversal of
"""
- g.inject(300).asNumber(N.nbyte)
+ g.inject(300).asNumber(N.byte)
"""
When iterated to list
Then the traversal will raise an error with message containing text of
"Can't convert number of type Integer to Byte due to overflow."
@@ -187,7 +187,7 @@ Feature: Step - asNumber()
Given the empty graph
And the traversal of
"""
- g.inject("5").asNumber(N.nbyte)
+ g.inject("5").asNumber(N.byte)
"""
When iterated to list
Then the result should be unordered
@@ -195,11 +195,11 @@ Feature: Step - asNumber()
| d[5].b |
@GraphComputerVerificationInjectionNotSupported
- Scenario: g_injectX1_000X_asNumberXN_nintX
+ Scenario: g_injectX1_000X_asNumberXN_bigIntX
Given the empty graph
And the traversal of
"""
- g.inject("1,000").asNumber(N.nint)
+ g.inject("1,000").asNumber(N.bigInt)
"""
When iterated to list
Then the traversal will raise an error with message containing text of
"Can't parse string '1,000' as number."
@@ -252,14 +252,14 @@ Feature: Step - asNumber()
| l[d[1].i,d[2].i,d[3].i,d[4].i] |
@GraphComputerVerificationInjectionNotSupported
- Scenario: g_injectX1_2_3_4_0x5X_asNumber_sum_asNumberXnbyteX
+ Scenario: g_injectX1_2_3_4_0x5X_asNumber_sum_asNumberXbyteX
Given the empty graph
And using the parameter xx1 defined as "d[1.0].d"
And using the parameter xx2 defined as "d[2].i"
And using the parameter xx3 defined as "d[3].l"
And the traversal of
"""
- g.inject(xx1, xx2, xx3, "4", "0x5").asNumber().sum().asNumber(N.nbyte)
+ g.inject(xx1, xx2, xx3, "4", "0x5").asNumber().sum().asNumber(N.byte)
"""
When iterated to list
Then the result should be unordered
@@ -267,21 +267,21 @@ Feature: Step - asNumber()
| d[15].b |
@GraphComputerVerificationInjectionNotSupported
- Scenario: g_VX1X_asNumberXN_nintX
+ Scenario: g_VX1X_asNumberXN_intX
Given the empty graph
And the traversal of
"""
- g.inject(null).asNumber(N.nint)
+ g.inject(null).asNumber(N.int)
"""
When iterated to list
Then the traversal will raise an error with message containing text of
"Can't parse type null as number."
@GraphComputerVerificationReferenceOnly
- Scenario: g_V_asXaX_outXknowsX_asXbX_mathXa_plus_bX_byXageX_asNumberXnintX
+ Scenario: g_V_asXaX_outXknowsX_asXbX_mathXa_plus_bX_byXageX_asNumberXintX
Given the modern graph
And the traversal of
"""
- g.V().as("a").out("knows").as("b").math("a +
b").by("age").asNumber(N.nint)
+ g.V().as("a").out("knows").as("b").math("a +
b").by("age").asNumber(N.int)
"""
When iterated to list
Then the result should be unordered
@@ -289,12 +289,12 @@ Feature: Step - asNumber()
| d[56].i |
| d[61].i |
- Scenario: g_withSideEffectXx_100X_V_age_mathX__plus_xX_asNumberXnlongX
+ Scenario: g_withSideEffectXx_100X_V_age_mathX__plus_xX_asNumberXlongX
Given the modern graph
And using the parameter xx1 defined as "d[100].i"
And the traversal of
"""
- g.withSideEffect("x", xx1).V().values("age").math("_ +
x").asNumber(N.nlong)
+ g.withSideEffect("x", xx1).V().values("age").math("_ +
x").asNumber(N.long)
"""
When iterated to list
Then the result should be unordered
