This is an automated email from the ASF dual-hosted git repository. xiazcy pushed a commit to branch master in repository https://gitbox.apache.org/repos/asf/tinkerpop.git
commit 3bd2bbef440f46fa5978d23a6bc45d844ea9f2ae Merge: 2c3f31fdab e515cc5bb0 Author: xiazcy <[email protected]> AuthorDate: Fri Oct 24 15:23:31 2025 -0700 Merge branch '3.8-dev' CHANGELOG.asciidoc | 2 + docs/src/dev/provider/gremlin-semantics.asciidoc | 34 ++- docs/src/reference/gremlin-variants.asciidoc | 36 +++ docs/src/reference/the-traversal.asciidoc | 83 +++++- docs/src/upgrade/release-3.8.x.asciidoc | 84 ++++-- .../tinkerpop/gremlin/jsr223/CoreImports.java | 6 +- .../gremlin/language/grammar/ArgumentVisitor.java | 1 - .../grammar/DefaultGremlinBaseVisitor.java | 8 +- .../language/grammar/GenericLiteralVisitor.java | 4 +- .../language/grammar/TraversalEnumParser.java | 13 +- .../language/grammar/TraversalMethodVisitor.java | 6 +- .../grammar/TraversalPredicateVisitor.java | 19 +- .../translator/DotNetTranslateVisitor.java | 13 + .../language/translator/GoTranslateVisitor.java | 15 ++ .../translator/GroovyTranslateVisitor.java | 9 - .../language/translator/JavaTranslateVisitor.java | 10 - .../translator/JavascriptTranslateVisitor.java | 7 +- .../language/translator/TranslateVisitor.java | 14 +- .../gremlin/process/traversal/CompareType.java | 116 +++++++++ .../tinkerpop/gremlin/process/traversal/GType.java | 106 ++++++++ .../gremlin/process/traversal/GremlinLang.java | 5 +- .../tinkerpop/gremlin/process/traversal/N.java | 48 ---- .../tinkerpop/gremlin/process/traversal/P.java | 28 ++ .../traversal/dsl/graph/GraphTraversal.java | 8 +- .../gremlin/process/traversal/dsl/graph/__.java | 8 +- .../gremlin/process/traversal/step/GType.java | 105 -------- .../process/traversal/step/map/AsNumberStep.java | 23 +- .../gremlin/structure/io/binary/DataType.java | 2 +- .../io/binary/TypeSerializerRegistry.java | 4 +- .../structure/io/binary/types/EnumSerializer.java | 3 +- .../structure/io/binary/types/NSerializer.java | 46 ---- .../structure/io/binary/types/PSerializer.java | 5 +- .../structure/io/graphson/GraphSONModule.java | 14 +- .../io/graphson/TraversalSerializersV2.java | 42 +-- .../io/graphson/TraversalSerializersV3.java | 42 +-- .../gremlin/structure/io/gryo/GryoVersion.java | 9 +- .../tinkerpop/gremlin/util/NumberHelper.java | 16 +- .../grammar/GeneralLiteralVisitorTest.java | 49 ++-- .../language/translator/GremlinTranslatorTest.java | 63 +++-- .../tinkerpop/gremlin/process/traversal/PTest.java | 18 ++ .../gremlin/process/traversal/step/GTypeTest.java | 91 ------- .../traversal/step/map/AsNumberStepTest.java | 236 ++++++++--------- .../tinkerpop/gremlin/util/NumberHelperTest.java | 50 ++-- .../src/Gremlin.Net/Process/Traversal/GType.cs | 112 ++++++++ .../Process/Traversal/GraphTraversal.cs | 4 +- .../src/Gremlin.Net/Process/Traversal/N.cs | 74 ------ .../src/Gremlin.Net/Process/Traversal/P.cs | 6 + .../src/Gremlin.Net/Process/Traversal/__.cs | 4 +- .../Structure/IO/GraphBinary/DataType.cs | 2 +- .../IO/GraphBinary/TypeSerializerRegistry.cs | 4 +- .../IO/GraphBinary/Types/EnumSerializer.cs | 8 +- .../{NDeserializer.cs => GTypeDeserializer.cs} | 6 +- .../Structure/IO/GraphSON/GraphSONReader.cs | 2 +- .../Gherkin/GherkinTestRunner.cs | 2 + .../Gremlin.Net.IntegrationTest/Gherkin/Gremlin.cs | 175 ++++++++++++- .../Structure/IO/GraphBinary/GraphBinaryTests.cs | 6 +- .../Structure/IO/GraphSON/GraphSONReaderTests.cs | 8 +- .../Structure/IO/GraphSON/GraphSONWriterTests.cs | 8 +- gremlin-go/driver/anonymousTraversal.go | 14 +- gremlin-go/driver/cucumber/gremlin.go | 175 ++++++++++++- gremlin-go/driver/graphBinary.go | 8 +- gremlin-go/driver/serializer.go | 10 +- gremlin-go/driver/traversal.go | 104 +++++--- gremlin-javascript/build/generate.groovy | 2 +- .../gremlin-javascript/docker-compose.yml | 1 + .../gremlin-javascript/lib/process/traversal.ts | 14 + .../lib/structure/io/binary/internals/DataType.js | 2 +- .../io/binary/internals/EnumSerializer.js | 2 +- .../javascript/gremlin-javascript/package.json | 8 +- .../gremlin-javascript/test/cucumber/gremlin.js | 177 +++++++++++-- .../test/unit/graphbinary/AnySerializer-test.js | 12 +- .../test/unit/graphbinary/EnumSerializer-test.js | 22 +- gremlin-language/src/main/antlr4/Gremlin.g4 | 160 ++++++++++-- gremlin-python/build/generate.groovy | 2 +- gremlin-python/docker-compose.yml | 10 +- .../python/gremlin_python/process/traversal.py | 52 +++- .../gremlin_python/structure/io/graphbinaryV4.py | 10 +- gremlin-python/src/main/python/radish/gremlin.py | 177 +++++++++++-- .../tests/driver/test_driver_remote_connection.py | 1 + .../gremlin/test/features/data/BigDecimal.feature | 151 +++++++++++ .../gremlin/test/features/data/BigInt.feature | 151 +++++++++++ .../gremlin/test/features/data/Byte.feature | 132 ++++++++++ .../gremlin/test/features/data/DateTime.feature | 133 ++++++++++ .../gremlin/test/features/data/Double.feature | 189 ++++++++++++++ .../gremlin/test/features/data/Float.feature | 148 +++++++++++ .../gremlin/test/features/data/Int.feature | 144 +++++++++++ .../gremlin/test/features/data/List.feature | 160 ++++++++++++ .../gremlin/test/features/data/Long.feature | 111 ++++++++ .../gremlin/test/features/data/Map.feature | 144 +++++++++++ .../gremlin/test/features/data/Set.feature | 159 ++++++++++++ .../gremlin/test/features/data/Short.feature | 119 +++++++++ .../gremlin/test/features/data/UUID.feature | 158 ++++++++++++ .../gremlin/test/features/filter/Or.feature | 3 +- .../gremlin/test/features/filter/TypeOf.feature | 281 +++++++++++++++++++++ .../test/features/filter/TypeOfGraph.feature | 143 +++++++++++ .../gremlin/test/features/map/AsNumber.feature | 116 +++++---- .../test/features/sideEffect/Subgraph.feature | 2 +- .../gremlin/test/features/sideEffect/Uuid.feature | 41 --- .../gremlin/neo4j/Neo4jGraphFeatureTest.java | 1 + .../tinkergraph/structure/TinkerGraphPlayTest.java | 9 + 100 files changed, 4360 insertions(+), 1020 deletions(-) diff --cc docs/src/reference/gremlin-variants.asciidoc index 604c3a36c0,90840f7672..fc336c417b --- a/docs/src/reference/gremlin-variants.asciidoc +++ b/docs/src/reference/gremlin-variants.asciidoc @@@ -1378,10 -1369,44 +1378,46 @@@ java -cp target/run-examples-shaded.ja java -cp target/run-examples-shaded.jar examples.ModernTraversals ---- + [[gremlin-java-differences]] + === Differences + + Gremlin-Java provides additional syntactic sugar that leverages Java's type system for the `P.typeOf()` predicate, + which accepts Java `Class` objects directly, providing a more natural way to perform type checking: + + [gremlin-groovy,modern] + ---- + // Java-specific syntax using Class objects + g.V().values("age").is(P.typeOf(Integer.class)) + g.V().values("name").is(P.typeOf(String.class)) + + // Further simplification with Groovy sugar syntax + g.E().has("weight", P.typeOf(Double)) + ---- + + This is equivalent to using `GType` enums. Other Gremlin language variants must use the canonical `GType` enum approach: + + [gremlin-groovy,modern] + ---- + // Canonical syntax available in all languages + g.V().values("age").is(P.typeOf(GType.INT)) + g.V().values("name").is(P.typeOf(GType.STRING)) + ---- + + Any valid Java class accepted in the Console and with embedded Java is also accepted by `P.typeOf()`, as they are not + restricted by the grammar or serialization. + [gremlin-groovy,modern] + ---- + // Using java.awt.Color for example + gremlin> g.inject(java.awt.Color.red) + ==>java.awt.Color[r=255,g=0,b=0] + gremlin> g.inject(java.awt.Color.red, "hi", 123).is(P.typeOf(java.awt.Color)) + ==>java.awt.Color[r=255,g=0,b=0] + ---- + [[gremlin-javascript]] == Gremlin-JavaScript +IMPORTANT: 4.0.0-beta.1 Release - Gremlin-JavaScript is not available in this beta, please consider testing with +Java or Python. image:gremlin-js.png[width=130,float=right] Apache TinkerPop's Gremlin-JavaScript implements Gremlin within the JavaScript language. It targets Node.js runtime and can be used on different operating systems on any Node.js 6 or diff --cc gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/jsr223/CoreImports.java index d6b61add60,df48440801..03706b3bac --- a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/jsr223/CoreImports.java +++ b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/jsr223/CoreImports.java @@@ -58,10 -56,11 +58,10 @@@ import org.apache.tinkerpop.gremlin.pro import org.apache.tinkerpop.gremlin.process.computer.traversal.strategy.verification.VertexProgramRestrictionStrategy; import org.apache.tinkerpop.gremlin.process.remote.RemoteConnection; import org.apache.tinkerpop.gremlin.process.traversal.AnonymousTraversalSource; -import org.apache.tinkerpop.gremlin.process.traversal.Bindings; import org.apache.tinkerpop.gremlin.process.traversal.DT; + import org.apache.tinkerpop.gremlin.process.traversal.GType; import org.apache.tinkerpop.gremlin.process.traversal.IO; import org.apache.tinkerpop.gremlin.process.traversal.Merge; - import org.apache.tinkerpop.gremlin.process.traversal.N; import org.apache.tinkerpop.gremlin.process.traversal.Operator; import org.apache.tinkerpop.gremlin.process.traversal.Order; import org.apache.tinkerpop.gremlin.process.traversal.P; diff --cc gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/language/grammar/TraversalEnumParser.java index 0ce7a44cba,03b6a5cc4c..9cc9e5863a --- 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,13 -19,9 +19,13 @@@ 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.GType; import org.apache.tinkerpop.gremlin.process.traversal.Scope; +import org.apache.tinkerpop.gremlin.structure.Column; import org.apache.tinkerpop.gremlin.structure.Direction; +import org.apache.tinkerpop.gremlin.structure.T; + +import java.util.function.Function; /** * Traversal enum parser parses all the enums like (e.g. {@link Scope} in graph traversal. @@@ -71,23 -67,14 +71,24 @@@ public class TraversalEnumParser return Direction.directionValueOf(text); } + public static Function parseTraversalFunctionFromContext(final GremlinParser.TraversalFunctionContext context) { + if (context.traversalT() != null) { + return TraversalEnumParser.parseTraversalEnumFromContext(T.class, context.traversalT()); + } else if (context.traversalColumn() != null) + return TraversalEnumParser.parseTraversalEnumFromContext(Column.class, context.traversalColumn()); + else { + throw new GremlinParserException("Unrecognized enum for traversal function"); + } + } + /** - * Parsing of {@link N} requires some special handling because of java keyword collision. + * Parsing of {@link GType} requires some special handling as grammar allows lowercase for tokens. */ - public static N parseTraversalNFromContext(final GremlinParser.TraversalNContext context) { + public static GType parseTraversalGTypeFromContext(final GremlinParser.TraversalGTypeContext 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 + "_"); + if (text.startsWith(GType.class.getSimpleName())) { + text = text.substring(GType.class.getSimpleName().length() + 1); + } + return GType.valueOf(text.toUpperCase()); } } diff --cc gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/CompareType.java index 0000000000,c3854d2de2..072b416469 mode 000000,100644..100644 --- a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/CompareType.java +++ b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/CompareType.java @@@ -1,0 -1,115 +1,116 @@@ + /* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ + package org.apache.tinkerpop.gremlin.process.traversal; + ++import org.apache.tinkerpop.gremlin.process.traversal.traverser.util.TraverserSet; ++ + import java.util.Map; + import java.util.Optional; + import java.util.concurrent.ConcurrentHashMap; + + /** + * {@code CompareType} is a {@code BiPredicate} that determines whether the first argument is a type of the second argument. + * + */ + public enum CompareType implements PBiPredicate<Object, Object> { + + /** + * Evaluates if the first object is an instance of the second class. + * + * @since 3.8.0 + */ + typeOf { + @Override + public boolean test(final Object first, final Object second) { - Class<?> valueClass; + if (first == null) { - return second == null; ++ return second == null || (second instanceof GType && ((GType) second).getType() == null); + } ++ ++ Class<?> valueClass; + if (second instanceof String) { - // need to assess the string token at run time on server - final Optional<Class<?>> opt = CompareType.GlobalTypeCache.getRegisteredType((String) second); - if (opt.isEmpty()) { - throw new IllegalArgumentException(second + " is not a registered type"); - } - else - valueClass = opt.get(); ++ valueClass = CompareType.GlobalTypeCache.getRegisteredType((String) second) ++ .orElseThrow(() -> new IllegalArgumentException(second + " is not a registered type")); ++ } else if (second instanceof GType) { ++ valueClass = ((GType) second).getType(); + } else { + valueClass = (Class<?>) second; + } - return second != null && valueClass.isAssignableFrom(first.getClass()); ++ ++ return valueClass != null && valueClass.isAssignableFrom(first.getClass()); + } + + }; + + public static final class GlobalTypeCache { + + private GlobalTypeCache() { + throw new IllegalStateException("Utility class"); + } + + /** + * A register of enum names for all types. + */ + private static final Map<String, Class<?>> GLOBAL_TYPE_REGISTRY = new ConcurrentHashMap<>(); + + // register the GType classes for convenience use of simple class names in grammar + static { + for (GType value : GType.values()) { + if (value == GType.NULL) { + // skip the null type + continue; + } + registerDataType(value.getType()); + } + } + + /** + * Register a type with a custom name. Convention is to use PascalCase with simple type names. + * If the type is not in the registry then type comparison fails with an exception + */ + public static void registerDataType(final String name, final Class<?> type) { + GLOBAL_TYPE_REGISTRY.put(name, type); + } + + /** + * Register a type by its simple name. + * If the type is not in the registry then type comparison fails with an exception + */ + public static void registerDataType(final Class<?> type) { + GLOBAL_TYPE_REGISTRY.put(type.getSimpleName(), type); + } + + /** + * Unregisters a type by its name. + * If the type is not in the registry then type comparison fails with an exception + */ + public static void unregisterDataType(final String name) { + GLOBAL_TYPE_REGISTRY.remove(name); + } + + /** + * Looks up a Gremlin DataType by its simple name. + */ + public static Optional<Class<?>> getRegisteredType(final String typeName) { + if (GLOBAL_TYPE_REGISTRY.containsKey(typeName)) + return Optional.of(GLOBAL_TYPE_REGISTRY.get(typeName)); + + return Optional.empty(); + } + } + } diff --cc gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/GremlinLang.java index 8bc86906f6,0000000000..72a13df299 mode 100644,000000..100644 --- a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/GremlinLang.java +++ b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/GremlinLang.java @@@ -1,527 -1,0 +1,526 @@@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ + +package org.apache.tinkerpop.gremlin.process.traversal; + +import org.apache.commons.configuration2.Configuration; +import org.apache.commons.text.StringEscapeUtils; +import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal; +import org.apache.tinkerpop.gremlin.process.traversal.step.GValue; +import org.apache.tinkerpop.gremlin.process.traversal.strategy.TraversalStrategyProxy; +import org.apache.tinkerpop.gremlin.process.traversal.strategy.decoration.OptionsStrategy; +import org.apache.tinkerpop.gremlin.process.traversal.util.ConnectiveP; +import org.apache.tinkerpop.gremlin.process.traversal.util.DefaultTraversal; +import org.apache.tinkerpop.gremlin.structure.Column; +import org.apache.tinkerpop.gremlin.structure.T; +import org.apache.tinkerpop.gremlin.structure.Vertex; +import org.apache.tinkerpop.gremlin.util.NumberHelper; + +import javax.lang.model.SourceVersion; +import java.io.Serializable; +import java.math.BigDecimal; +import java.math.BigInteger; +import java.time.OffsetDateTime; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.Iterator; +import java.util.LinkedHashMap; +import java.util.LinkedHashSet; +import java.util.List; +import java.util.Map; +import java.util.Objects; +import java.util.Set; +import java.util.UUID; +import java.util.concurrent.atomic.AtomicInteger; + +import static org.apache.tinkerpop.gremlin.util.DatetimeHelper.format; +import static org.apache.tinkerpop.gremlin.util.iterator.IteratorUtils.asIterator; + +/** + * This class helps to build a gremlin-lang compatible string representation based on a {@link TraversalSource} + * and then a {@link Traversal}. + */ +public class GremlinLang implements Cloneable, Serializable { + + private static final Object[] EMPTY_ARRAY = new Object[]{}; + + private StringBuilder gremlin = new StringBuilder(); + private Map<String, Object> parameters = new HashMap<>(); + private static final AtomicInteger paramCount = new AtomicInteger(0); + private List<OptionsStrategy> optionsStrategies = new ArrayList<>(); + + public GremlinLang() { + } + + public GremlinLang(final String sourceName, final Object... arguments) { + addToGremlin(sourceName, arguments); + } + + private void addToGremlin(final String name, final Object... arguments) { + final Object[] flattenedArguments = flattenArguments(arguments); + + // todo: figure out solution for AbstractLambdaTraversal + if ("CardinalityValueTraversal".equals(name)) { + gremlin.append("Cardinality.").append(flattenedArguments[0]) + .append("(").append(flattenedArguments[1]).append(")"); + return; + } + + gremlin.append(".").append(name).append('('); + + for (int i = 0; i < flattenedArguments.length; i++) { + if (i != 0) { + gremlin.append(','); + } + gremlin.append(argAsString(flattenedArguments[i])); + } + + gremlin.append(')'); + } + + private String argAsString(final Object arg) { + if (arg == null) + return "null"; + + if (arg instanceof String) + return String.format("\"%s\"", StringEscapeUtils.escapeJava((String) arg)); + if (arg instanceof Boolean) + return arg.toString(); + + if (arg instanceof Byte) + return String.format("%sB", arg); + if (arg instanceof Short) + return String.format("%sS", arg); + if (arg instanceof Integer) + return arg.toString(); + if (arg instanceof Long) + return String.format("%sL", arg); + + if (arg instanceof BigInteger) + return String.format("%sN", arg); + if (arg instanceof Float) { + if (NumberHelper.isNaN(arg)) + return "NaN"; + if (NumberHelper.isPositiveInfinity(arg)) + return "+Infinity"; + if (NumberHelper.isNegativeInfinity(arg)) + return "-Infinity"; + + return String.format("%sF", arg); + } + if (arg instanceof Double) { + if (NumberHelper.isNaN(arg)) + return "NaN"; + if (NumberHelper.isPositiveInfinity(arg)) + return "+Infinity"; + if (NumberHelper.isNegativeInfinity(arg)) + return "-Infinity"; + return String.format("%sD", arg); + } + if (arg instanceof BigDecimal) + return String.format("%sM", arg); + + if (arg instanceof OffsetDateTime) + return String.format("datetime(\"%s\")", format(((OffsetDateTime) arg).toInstant())); + + if (arg instanceof UUID) { + return String.format("UUID(\"%s\")", arg); + } + + if (arg instanceof Enum) { + // special handling for enums with additional interfaces + if (arg instanceof T) + return String.format("T.%s", arg); - if (arg instanceof N) { - return String.format("N.%s", arg).replace("_",""); - } ++ if (arg instanceof GType) ++ return String.format("GType.%s", arg); + if (arg instanceof Order) + return String.format("Order.%s", arg); + if (arg instanceof Column) + return String.format("Column.%s", arg); + if (arg instanceof Operator) + return String.format("Operator.%s", arg); + if (arg instanceof SackFunctions.Barrier) + return String.format("Barrier.%s", arg); + + return String.format("%s.%s", arg.getClass().getSimpleName(), arg); + } + + if (arg instanceof Vertex) + return argAsString(((Vertex) arg).id()); + + if (arg instanceof P) { + return asString((P<?>) arg); + } + + if (arg instanceof GremlinLang || arg instanceof DefaultTraversal) { + final GremlinLang gremlinLang = arg instanceof GremlinLang ? (GremlinLang) arg : ((DefaultTraversal) arg).getGremlinLang(); + parameters.putAll(gremlinLang.getParameters()); + return gremlinLang.getGremlin("__"); + } + + if (arg instanceof GValue) { + final GValue gValue = (GValue) arg; + String key = gValue.getName(); + + if (key == null) { + return argAsString(((GValue<?>) arg).get()); + } + + if (!SourceVersion.isIdentifier(key)) { + throw new IllegalArgumentException(String.format("Invalid parameter name [%s].", key)); + } + + if (parameters.containsKey(key)) { + if (!Objects.equals(parameters.get(key), gValue.get())) { + throw new IllegalArgumentException(String.format("Parameter with name [%s] already defined.", key)); + } + } else { + parameters.put(key, gValue.get()); + } + return key; + } + + if (arg instanceof Map) { + return asString((Map) arg); + } + + if (arg instanceof Set) { + return asString((Set) arg); + } + + // handle all iterables in similar way + if (arg instanceof List || arg instanceof Object[] || arg.getClass().isArray()) { + return asString(asIterator(arg)); + } + + if (arg instanceof Class) { + return ((Class) arg).getSimpleName(); + } + + return asParameter(arg); + } + + private String asParameter(final Object arg) { + final String paramName = String.format("_%d", paramCount.getAndIncrement()); + // todo: consider resetting paramCount when it's larger then 1_000_000 + parameters.put(paramName, arg); + return paramName; + } + + private String asString(final Iterator itty) { + final StringBuilder sb = new StringBuilder().append("["); + + while (itty.hasNext()) { + sb.append(argAsString(itty.next())); + if (itty.hasNext()) + sb.append(","); + } + + return sb.append("]").toString(); + } + + private String asString(final Set<?> set) { + final StringBuilder sb = new StringBuilder().append("{"); + + final Iterator itty = asIterator(set); + + while (itty.hasNext()) { + sb.append(argAsString(itty.next())); + if (itty.hasNext()) + sb.append(","); + } + + return sb.append("}").toString(); + } + + // borrowed from Groovy translator + private String asString(final P<?> p) { + final StringBuilder sb = new StringBuilder(); + if (p instanceof TextP) { + sb.append("TextP.").append(p.getPredicateName()).append("("); + sb.append(argAsString(p.getValue())); + } else if (p instanceof ConnectiveP) { + // ConnectiveP gets some special handling because it's reduced to and(P, P, P) and we want it + // generated the way it was written which was P.and(P).and(P) + final List<P<?>> list = ((ConnectiveP) p).getPredicates(); + final String connector = p.getPredicateName(); + for (int i = 0; i < list.size(); i++) { + sb.append(argAsString(list.get(i))); + + // for the first/last P there is no parent to close + if (i > 0 && i < list.size() - 1) sb.append(")"); + + // add the connector for all but last P + if (i < list.size() - 1) { + sb.append(".").append(connector).append("("); + } + } + } else if (p instanceof NotP) { + sb.append("P.not("); + sb.append(argAsString(p.negate())); // Wrap internal P in `P.not(%s)` + } else { + sb.append("P.").append(p.getPredicateName()).append("("); + sb.append(argAsString(p.getValue())); + } + sb.append(")"); + return sb.toString(); + } + + private String asString(final Map<?, ?> map) { + final StringBuilder sb = new StringBuilder("["); + int size = map.size(); + + if (size == 0) { + sb.append(":"); + } else { + for (Map.Entry<?, ?> entry : map.entrySet()) { + String key = argAsString(entry.getKey()); + // special handling for non-string keys + if (entry.getKey() instanceof Enum && key.contains(".")) { + key = String.format("(%s)", key); + } + + sb.append(key).append(":").append(argAsString(entry.getValue())); + if (--size > 0) { + sb.append(','); + } + } + } + + sb.append("]"); + return sb.toString(); + } + + /** + * Get gremlin-lang compatible representation of Traversal + * @return gremlin-lang compatible String + */ + public String getGremlin() { + return getGremlin("g"); + } + + /** + * Get gremlin-lang compatible representation of Traversal. + * "g" is expected for gremlin-lang. + * "__" can be used for an anonymous {@link GraphTraversal}. + * + * @param g GraphTraversalSource name + * @return gremlin-lang compatible String + */ + public String getGremlin(final String g) { + // special handling for CardinalityValueTraversal + if (gremlin.length() != 0 && gremlin.charAt(0) != '.') { + return gremlin.toString(); + } + return g + gremlin; + } + + /** + * Get parameters used in Traversal. + * + * @return parameters Map + */ + public Map<String, Object> getParameters() { + return parameters; + } + + /** + * The alias to set. + */ + public void addG(final String g) { + parameters.put("g", g); + } + + /** + * Reset parameter naming counter. Mainly intended to make testing easier + */ + public void reset() { + paramCount.set(0); + } + + /** + * Add a {@link TraversalSource} instruction to the GremlinLang. + * + * @param sourceName the traversal source method name (e.g. withSack()) + * @param arguments the traversal source method arguments + */ + public void addSource(final String sourceName, final Object... arguments) { + if (sourceName.equals(TraversalSource.Symbols.withStrategies) && arguments.length != 0) { + final String args = buildStrategyArgs(arguments); + + // possible to have empty strategies list to send + if (!args.isEmpty()) { + gremlin.append('.').append(TraversalSource.Symbols.withStrategies).append('(').append(args).append(')'); + } + return; + } + + addToGremlin(sourceName, arguments); + } + + private String buildStrategyArgs(final Object[] arguments) { + final StringBuilder sb = new StringBuilder(); + for (int i = 0; i < arguments.length; i++) { + // special handling for OptionsStrategy + if (arguments[i] instanceof OptionsStrategy) { + optionsStrategies.add((OptionsStrategy) arguments[i]); + break; + } + + Configuration configuration; + String strategyName; + + // special handling for TraversalStrategyProxy + if (arguments[i] instanceof TraversalStrategyProxy) { + configuration = ((TraversalStrategy) arguments[i]).getConfiguration(); + strategyName = ((TraversalStrategyProxy) arguments[i]).getStrategyName(); + } else { + configuration = ((TraversalStrategy) arguments[i]).getConfiguration(); + strategyName = arguments[i].getClass().getSimpleName(); + } + + if (configuration.isEmpty()) { + sb.append(strategyName); + } else { + sb.append("new ") + .append(strategyName) + .append("("); + + configuration.getKeys().forEachRemaining(key -> { + if (!key.equals("strategy")) { + sb.append(key).append(":").append(argAsString(configuration.getProperty(key))).append(","); + } + }); + // remove last comma + if (sb.lastIndexOf(",") == sb.length() - 1) { + sb.setLength(sb.length() - 1); + } + + sb.append(')'); + } + + if (i != arguments.length - 1) + sb.append(','); + } + + return sb.toString(); + } + + /** + * Add a {@link Traversal} instruction to the GremlinLang. + * + * @param stepName the traversal method name (e.g. out()) + * @param arguments the traversal method arguments + */ + public void addStep(final String stepName, final Object... arguments) { + addToGremlin(stepName, arguments); + } + + /** + * Provides a way to get configuration of a Traversal. + * + * @return list of OptionsStrategy + */ + public List<OptionsStrategy> getOptionsStrategies() { + return optionsStrategies; + } + + public boolean isEmpty() { + return this.gremlin.length() == 0; + } + + @Override + public String toString() { + return gremlin.toString(); + } + + // todo: clarify equality with parameters + @Override + public boolean equals(Object o) { + if (this == o) return true; + if (o == null || getClass() != o.getClass()) return false; + final GremlinLang gremlinLang = (GremlinLang) o; + return Objects.equals(gremlin.toString(), gremlinLang.gremlin.toString()) && + Objects.equals(parameters, gremlinLang.parameters); + } + + @Override + public int hashCode() { + return Objects.hash(gremlin, parameters); + } + + @Override + public GremlinLang clone() { + try { + final GremlinLang clone = (GremlinLang) super.clone(); + clone.parameters = new HashMap<>(parameters); + clone.gremlin = new StringBuilder(gremlin.length()); + clone.gremlin.append(gremlin); + clone.optionsStrategies = new ArrayList<>(this.optionsStrategies); + return clone; + } catch (final CloneNotSupportedException e) { + throw new IllegalStateException(e.getMessage(), e); + } + } + + private Object[] flattenArguments(final Object... arguments) { + if (arguments == null || arguments.length == 0) + return EMPTY_ARRAY; + final List<Object> flatArguments = new ArrayList<>(arguments.length); + for (final Object object : arguments) { + if (object instanceof Object[]) { + for (final Object nestObject : (Object[]) object) { + flatArguments.add(convertArgument(nestObject)); + } + } else + flatArguments.add(convertArgument(object)); + } + return flatArguments.toArray(); + } + + private Object convertArgument(final Object argument) { + if (argument instanceof Traversal) { + // prevent use of "g" to spawn child traversals + if (((Traversal) argument).asAdmin().getTraversalSource().isPresent()) + throw new IllegalStateException(String.format( + "The child traversal of %s was not spawned anonymously - use the __ class rather than a TraversalSource to construct the child traversal", argument)); + + return ((Traversal) argument).asAdmin().getGremlinLang(); + } else if (argument instanceof Map) { + final Map<Object, Object> map = new LinkedHashMap<>(((Map) argument).size()); + for (final Map.Entry<?, ?> entry : ((Map<?, ?>) argument).entrySet()) { + map.put(convertArgument(entry.getKey()), convertArgument(entry.getValue())); + } + return map; + } else if (argument instanceof List) { + final List<Object> list = new ArrayList<>(((List) argument).size()); + for (final Object item : (List) argument) { + list.add(convertArgument(item)); + } + return list; + } else if (argument instanceof Set) { + final Set<Object> set = new LinkedHashSet<>(((Set) argument).size()); + for (final Object item : (Set) argument) { + set.add(convertArgument(item)); + } + return set; + } else + return argument; + } +} diff --cc gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/P.java index 776981dc68,cea7a9258f..559682a56e --- a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/P.java +++ b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/P.java @@@ -437,6 -438,33 +438,33 @@@ public class P<V> implements Predicate< return new P(Contains.without, value); } + /** + * Determines if a value is of a type denoted by {@code GType}. + * + * @since 3.8.0 + */ + public static <V> P<V> typeOf(final GType value) { - return new P(CompareType.typeOf, value.getType()); ++ return new P(CompareType.typeOf, value); + } + + /** + * Determines if a value is of a type denoted by String key of GlobalTypeCache. + * + * @since 3.8.0 + */ + public static <V> P<V> typeOf(final String value) { + return new P(CompareType.typeOf, value); + } + + /** + * Sugar method for Java/Groovy embedded cases only, determines if a value is of a type denoted by class. + * + * @since 3.8.0 + */ + public static <V> P<V> typeOf(final Class<?> value) { + return new P(CompareType.typeOf, value); + } + /** * Construct an instance of {@code P} from a {@code BiPredicate}. * diff --cc gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/dsl/graph/GraphTraversal.java index fa36d7c307,d27c62fe3f..9d86079fbf --- a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/dsl/graph/GraphTraversal.java +++ b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/dsl/graph/GraphTraversal.java @@@ -2337,9 -2323,9 +2337,9 @@@ public interface GraphTraversal<S, E> e * @see <a href="http://tinkerpop.apache.org/docs/${project.version}/reference/#AsNumberStep-step"; target="_blank">Reference Documentation - AsNumberStep Step</a> * @since 3.8.0 */ - public default GraphTraversal<S, Number> asNumber(final N numberToken) { - this.asAdmin().getGremlinLang().addStep(Symbols.asNumber, numberToken); - return this.asAdmin().addStep(new AsNumberStep<>(this.asAdmin(), numberToken)); + public default GraphTraversal<S, Number> asNumber(final GType typeToken) { - this.asAdmin().getBytecode().addStep(Symbols.asNumber, typeToken); ++ this.asAdmin().getGremlinLang().addStep(Symbols.asNumber, typeToken); + return this.asAdmin().addStep(new AsNumberStep<>(this.asAdmin(), typeToken)); } /** diff --cc gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/structure/io/binary/DataType.java index e2522c03c3,1abdb90fcf..0e62220ac5 --- a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/structure/io/binary/DataType.java +++ b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/structure/io/binary/DataType.java @@@ -51,9 -64,15 +51,9 @@@ public enum DataType BYTEBUFFER(0X25), SHORT(0X26), BOOLEAN(0x27), - TEXTP(0x28), - TRAVERSALSTRATEGY(0X29), - BULKSET(0X2A), + BULKSET(0X2A), // todo: TREE(0X2B), - N(0x30), - METRICS(0x2C), - TRAVERSALMETRICS(0x2D), - MERGE(0x2E), - DT(0x2F), + GTYPE(0x30), CHAR(0X80), DURATION(0X81), diff --cc gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/structure/io/binary/TypeSerializerRegistry.java index 8b1499465a,b9309878c7..6cc390ae66 --- 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 @@@ -18,14 -18,32 +18,14 @@@ */ package org.apache.tinkerpop.gremlin.structure.io.binary; -import org.apache.tinkerpop.gremlin.process.traversal.Bytecode; -import org.apache.tinkerpop.gremlin.process.traversal.DT; import org.apache.tinkerpop.gremlin.process.traversal.Merge; -import org.apache.tinkerpop.gremlin.process.traversal.NotP; -import org.apache.tinkerpop.gremlin.process.traversal.Operator; -import org.apache.tinkerpop.gremlin.process.traversal.Order; -import org.apache.tinkerpop.gremlin.process.traversal.P; import org.apache.tinkerpop.gremlin.process.traversal.Path; - import org.apache.tinkerpop.gremlin.process.traversal.N; -import org.apache.tinkerpop.gremlin.process.traversal.Pick; -import org.apache.tinkerpop.gremlin.process.traversal.Pop; -import org.apache.tinkerpop.gremlin.process.traversal.SackFunctions; -import org.apache.tinkerpop.gremlin.process.traversal.Scope; -import org.apache.tinkerpop.gremlin.process.traversal.TextP; -import org.apache.tinkerpop.gremlin.process.traversal.TraversalStrategy; -import org.apache.tinkerpop.gremlin.process.traversal.Traverser; ++import org.apache.tinkerpop.gremlin.process.traversal.GType; import org.apache.tinkerpop.gremlin.process.traversal.step.util.BulkSet; import org.apache.tinkerpop.gremlin.process.traversal.step.util.Tree; -import org.apache.tinkerpop.gremlin.process.traversal.util.AndP; -import org.apache.tinkerpop.gremlin.process.traversal.util.Metrics; -import org.apache.tinkerpop.gremlin.process.traversal.util.OrP; import org.apache.tinkerpop.gremlin.process.traversal.util.TraversalExplanation; -import org.apache.tinkerpop.gremlin.process.traversal.util.TraversalMetrics; -import org.apache.tinkerpop.gremlin.structure.Column; import org.apache.tinkerpop.gremlin.structure.Direction; import org.apache.tinkerpop.gremlin.structure.Edge; -import org.apache.tinkerpop.gremlin.process.traversal.GType; import org.apache.tinkerpop.gremlin.structure.Graph; import org.apache.tinkerpop.gremlin.structure.Property; import org.apache.tinkerpop.gremlin.structure.T; @@@ -42,12 -64,22 +42,11 @@@ import org.apache.tinkerpop.gremlin.str 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.DateTimeSerializer; - import org.apache.tinkerpop.gremlin.structure.io.binary.types.NSerializer; 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; @@@ -103,10 -160,29 +102,9 @@@ public class TypeSerializerRegistry new RegistryEntry<>(Property.class, new PropertySerializer()), new RegistryEntry<>(Graph.class, new GraphSerializer()), new RegistryEntry<>(Vertex.class, new VertexSerializer()), - new RegistryEntry<>(SackFunctions.Barrier.class, EnumSerializer.BarrierSerializer), - new RegistryEntry<>(Bytecode.Binding.class, new BindingSerializer()), - new RegistryEntry<>(Bytecode.class, new ByteCodeSerializer()), - new RegistryEntry<>(VertexProperty.Cardinality.class, EnumSerializer.CardinalitySerializer), - new RegistryEntry<>(Column.class, EnumSerializer.ColumnSerializer), new RegistryEntry<>(Direction.class, EnumSerializer.DirectionSerializer), - new RegistryEntry<>(DT.class, EnumSerializer.DTSerializer), - new RegistryEntry<>(GType.class, EnumSerializer.GTypeSerializer), - new RegistryEntry<>(Merge.class, EnumSerializer.MergeSerializer), - new RegistryEntry<>(Operator.class, EnumSerializer.OperatorSerializer), - new RegistryEntry<>(Order.class, EnumSerializer.OrderSerializer), - new RegistryEntry<>(Pick.class, EnumSerializer.PickSerializer), - new RegistryEntry<>(Pop.class, EnumSerializer.PopSerializer), - new RegistryEntry<>(Lambda.class, new LambdaSerializer()), - new RegistryEntry<>(P.class, new PSerializer<>(DataType.P, P.class)), - new RegistryEntry<>(AndP.class, new PSerializer<>(DataType.P, AndP.class)), - new RegistryEntry<>(OrP.class, new PSerializer<>(DataType.P, OrP.class)), - new RegistryEntry<>(NotP.class, new PSerializer<>(DataType.P, NotP.class)), - new RegistryEntry<>(TextP.class, new PSerializer<>(DataType.TEXTP, TextP.class)), - new RegistryEntry<>(Scope.class, EnumSerializer.ScopeSerializer), new RegistryEntry<>(T.class, EnumSerializer.TSerializer), - new RegistryEntry<>(Traverser.class, new TraverserSerializer()), new RegistryEntry<>(Merge.class, EnumSerializer.MergeSerializer), - new RegistryEntry<>(N.class, new NSerializer()), new RegistryEntry<>(BigDecimal.class, new BigDecimalSerializer()), new RegistryEntry<>(BigInteger.class, new BigIntegerSerializer()), new RegistryEntry<>(Byte.class, SingleTypeSerializer.ByteSerializer), diff --cc gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/structure/io/binary/types/EnumSerializer.java index a0e0bf77e3,299ee54bbc..a2382848dd --- 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 @@@ -46,9 -46,19 +46,10 @@@ import java.util.function.Function */ public class EnumSerializer<E extends Enum> extends SimpleTypeSerializer<E> { - public static final EnumSerializer<SackFunctions.Barrier> BarrierSerializer = new EnumSerializer<>(DataType.BARRIER, SackFunctions.Barrier::valueOf); - public static final EnumSerializer<VertexProperty.Cardinality> CardinalitySerializer = new EnumSerializer<>(DataType.CARDINALITY, VertexProperty.Cardinality::valueOf); - public static final EnumSerializer<Column> ColumnSerializer = new EnumSerializer<>(DataType.COLUMN, Column::valueOf); 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<GType> GTypeSerializer = new EnumSerializer<>(DataType.GTYPE, GType::valueOf); - public static final EnumSerializer<Merge> MergeSerializer = new EnumSerializer<>(DataType.MERGE, Merge::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); - public static final EnumSerializer<Pop> PopSerializer = new EnumSerializer<>(DataType.POP, Pop::valueOf); - public static final EnumSerializer<Scope> ScopeSerializer = new EnumSerializer<>(DataType.SCOPE, Scope::valueOf); public static final EnumSerializer<T> TSerializer = new EnumSerializer<>(DataType.T, T::valueOf); + public static final EnumSerializer<Merge> MergeSerializer = new EnumSerializer<>(DataType.MERGE, Merge::valueOf); ++ public static final EnumSerializer<GType> GTypeSerializer = new EnumSerializer<>(DataType.GTYPE, GType::valueOf); private final Function<String, E> readFunc; diff --cc gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/structure/io/graphson/GraphSONModule.java index 7271c1ea38,259a684da9..1ffcc09ce7 --- 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 @@@ -19,10 -19,14 +19,10 @@@ package org.apache.tinkerpop.gremlin.structure.io.graphson; import org.apache.tinkerpop.gremlin.process.computer.traversal.strategy.decoration.VertexProgramStrategy; -import org.apache.tinkerpop.gremlin.process.computer.traversal.strategy.finalization.ComputerFinalizationStrategy; import org.apache.tinkerpop.gremlin.process.computer.traversal.strategy.optimization.GraphFilterStrategy; -import org.apache.tinkerpop.gremlin.process.computer.traversal.strategy.optimization.MessagePassingReductionStrategy; -import org.apache.tinkerpop.gremlin.process.computer.traversal.strategy.verification.VertexProgramRestrictionStrategy; -import org.apache.tinkerpop.gremlin.process.traversal.Bytecode; import org.apache.tinkerpop.gremlin.process.traversal.DT; + import org.apache.tinkerpop.gremlin.process.traversal.GType; import org.apache.tinkerpop.gremlin.process.traversal.Merge; - import org.apache.tinkerpop.gremlin.process.traversal.N; import org.apache.tinkerpop.gremlin.process.traversal.NotP; import org.apache.tinkerpop.gremlin.process.traversal.Operator; import org.apache.tinkerpop.gremlin.process.traversal.Order; @@@ -400,9 -289,9 +401,8 @@@ abstract class GraphSONModule extends T 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()); addSerializer(Traverser.class, new TraversalSerializersV3.TraverserJacksonSerializer()); addSerializer(TraversalStrategy.class, new TraversalSerializersV3.TraversalStrategyJacksonSerializer()); @@@ -642,9 -547,9 +643,8 @@@ 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()); addSerializer(Traverser.class, new TraversalSerializersV2.TraverserJacksonSerializer()); addSerializer(TraversalStrategy.class, new TraversalSerializersV2.TraversalStrategyJacksonSerializer()); diff --cc gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/structure/io/graphson/TraversalSerializersV2.java index 8541a43f8a,3d162994b3..ae374ccd77 --- 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,7 -22,8 +22,7 @@@ package org.apache.tinkerpop.gremlin.st 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.N; -import org.apache.tinkerpop.gremlin.process.traversal.Bytecode; + import org.apache.tinkerpop.gremlin.process.traversal.GType; import org.apache.tinkerpop.gremlin.process.traversal.NotP; import org.apache.tinkerpop.gremlin.process.traversal.P; import org.apache.tinkerpop.gremlin.process.traversal.TextP; diff --cc gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/structure/io/graphson/TraversalSerializersV3.java index fd5cd09716,d771edc702..db3ab05486 --- 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,7 -22,8 +22,7 @@@ package org.apache.tinkerpop.gremlin.st 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.N; -import org.apache.tinkerpop.gremlin.process.traversal.Bytecode; + import org.apache.tinkerpop.gremlin.process.traversal.GType; import org.apache.tinkerpop.gremlin.process.traversal.NotP; import org.apache.tinkerpop.gremlin.process.traversal.P; import org.apache.tinkerpop.gremlin.process.traversal.TextP; diff --cc gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/structure/io/gryo/GryoVersion.java index 0bf3ceac08,ac1083e3a8..4e8fa1c5f9 --- a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/structure/io/gryo/GryoVersion.java +++ b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/structure/io/gryo/GryoVersion.java @@@ -26,10 -25,11 +26,10 @@@ import org.apache.tinkerpop.gremlin.pro import org.apache.tinkerpop.gremlin.process.computer.util.ComputerGraph; import org.apache.tinkerpop.gremlin.process.computer.util.MapMemory; import org.apache.tinkerpop.gremlin.process.remote.traversal.DefaultRemoteTraverser; -import org.apache.tinkerpop.gremlin.process.traversal.Bytecode; import org.apache.tinkerpop.gremlin.process.traversal.Contains; import org.apache.tinkerpop.gremlin.process.traversal.DT; + import org.apache.tinkerpop.gremlin.process.traversal.GType; import org.apache.tinkerpop.gremlin.process.traversal.Merge; - import org.apache.tinkerpop.gremlin.process.traversal.N; import org.apache.tinkerpop.gremlin.process.traversal.Operator; import org.apache.tinkerpop.gremlin.process.traversal.Order; import org.apache.tinkerpop.gremlin.process.traversal.P; @@@ -429,7 -430,8 +430,7 @@@ public enum GryoVersion add(GryoTypeReg.of(LabelledCounter.class, 180)); add(GryoTypeReg.of(Stack.class, 181)); add(GryoTypeReg.of(ReferenceMap.class, 182)); - add(GryoTypeReg.of(GValue.class, 199, new JavaSerializer())); // ***LAST ID*** - + add(GryoTypeReg.of(GValue.class, 199, new JavaSerializer())); // placeholder serializers for classes that don't live here in core. this will allow them to be used if // present or ignored if the class isn't available. either way the registration numbers are held as @@@ -644,7 -645,8 +645,7 @@@ add(GryoTypeReg.of(LabelledCounter.class, 180)); add(GryoTypeReg.of(Stack.class, 181)); add(GryoTypeReg.of(ReferenceMap.class, 182)); - add(GryoTypeReg.of(GValue.class, 199, new JavaSerializer())); // ***LAST ID*** - + add(GryoTypeReg.of(GValue.class, 199, new JavaSerializer())); }}; } diff --cc gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/language/translator/GremlinTranslatorTest.java index b5f56c10dc,1c743e62c6..c42df77556 --- 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 @@@ -742,33 -741,51 +742,60 @@@ 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.inject(\"123.4\").asNumber(GType.INT)", + null, + "g.inject(string0).asNumber(GType.INT)", + "g.Inject<object>(\"123.4\").AsNumber(GType.Int)", + "g.Inject(\"123.4\").AsNumber(gremlingo.GType.Int)", + "g.inject(\"123.4\").asNumber(GType.INT)", + "g.inject(\"123.4\").asNumber(GType.INT)", + "g.inject(\"123.4\").asNumber(GType.int)", + "g.inject('123.4').as_number(GType.INT)"}, + {"g.inject(\"123.4\").asNumber(GType.BIGINT)", + null, + "g.inject(string0).asNumber(GType.BIGINT)", + "g.Inject<object>(\"123.4\").AsNumber(GType.BigInt)", + "g.Inject(\"123.4\").AsNumber(gremlingo.GType.BigInt)", + null, + null, + "g.inject(\"123.4\").asNumber(GType.bigInt)", + "g.inject('123.4').as_number(GType.BIGINT)"}, + {"g.inject(123).is(P.typeOf(GType.BIGINT))", + null, + "g.inject(number0).is(P.typeOf(GType.BIGINT))", + "g.Inject<object>(123).Is(P.TypeOf(GType.BigInt))", + "g.Inject(123).Is(gremlingo.P.TypeOf(gremlingo.GType.BigInt))", + null, + null, + "g.inject(123).is(P.typeOf(GType.bigInt))", + "g.inject(123).is_(P.type_of(GType.BIGINT))"}, + {"g.inject(123).is(P.typeOf(GType.BYTE))", + null, + "g.inject(number0).is(P.typeOf(GType.BYTE))", + "g.Inject<object>(123).Is(P.TypeOf(GType.Byte))", + "g.Inject(123).Is(gremlingo.P.TypeOf(gremlingo.GType.Byte))", + null, + null, + "g.inject(123).is(P.typeOf(GType.byte))", + "g.inject(123).is_(P.type_of(GType.BYTE))"}, + {"g.inject(123).is(P.typeOf(GType.UUID))", + null, + "g.inject(number0).is(P.typeOf(GType.UUID))", + "g.Inject<object>(123).Is(P.TypeOf(GType.UUID))", + "g.Inject(123).Is(gremlingo.P.TypeOf(gremlingo.GType.UUID))", + null, + null, + "g.inject(123).is(P.typeOf(GType.uuid))", + "g.inject(123).is_(P.type_of(GType.UUID))"}, + {"g.inject(null, null).inject(null, null)", + null, + "g.inject(object0, object0).inject(object0, object0)", + "g.Inject<object>(null, null).Inject(null, null)", + "g.Inject(nil, nil).Inject(nil, nil)", + "g.inject(null, (Object) null).inject(null, (Object) null)", + "g.inject(null, null).inject(null, null)", + "g.inject(null, null).inject(null, null)", + "g.inject(None, None).inject(None, None)"}, {"g.V().hasLabel(null)", null, "g.V().hasLabel(string0)", diff --cc gremlin-dotnet/test/Gremlin.Net.IntegrationTest/Gherkin/Gremlin.cs index 80b02d8a0e,803907fbe2..282a3f0432 --- a/gremlin-dotnet/test/Gremlin.Net.IntegrationTest/Gherkin/Gremlin.cs +++ b/gremlin-dotnet/test/Gremlin.Net.IntegrationTest/Gherkin/Gremlin.cs @@@ -169,8 -170,124 +169,124 @@@ namespace Gremlin.Net.IntegrationTest.G {"g_VX1_2X_unionXoutE_count__inE_count__outE_weight_sumX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V(p["vid1"], p["vid2"]).Union<object>(__.OutE().Count(), __.InE().Count(), __.OutE().Values<object>("weight").Sum<object>())}}, {"g_VX1_2X_localXunionXoutE_count__inE_count__outE_weight_sumXX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V(p["vid1"], p["vid2"]).Local<object>(__.Union<object>(__.OutE().Count(), __.InE().Count(), __.OutE().Values<object>("weight").Sum<object>()))}}, {"g_VX1_2X_localXunionXcountXX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V(p["vid1"], p["vid2"]).Local<object>(__.Union<object>(__.Count()))}}, - {"g_unionXaddVXpersonX_propertyXname_aliceX_addVXpersonX_propertyXname_bobX_addVXpersonX_propertyXname_chrisX_name", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Union<object>(__.AddV("person").Property("name", "alice"), __.AddV("person").Property("name", "bob"), __.AddV("person").Property("name", "chris")).Values<object>("name")}}, + {"g_unionXaddVXpersonX_propertyXname_aliceX_addVXpersonX_propertyXname_bobX_addVXpersonX_propertyXname_chrisX_name", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Union<object>(__.AddV((string) "person").Property("name", "alice"), __.AddV((string) "person").Property("name", "bob"), __.AddV((string) "person").Property("name", "chris")).Values<object>("name")}}, {"g_VX_hasLabelXpersonX_unionX_whereX_out_count_isXgtX2XXX_valuesXageX_notX_whereX_bothE_count_isXgt2XXX_valusXnameXX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().HasLabel("person").Union<object>(__.Where(__.OutE().Count().Is(P.Gt(2))).Values<object>("age"), __.Not(__.Where(__.OutE().Count().Is(P.Gt(2)))).Values<object>("name"))}}, + {"g_V_valuesXintX_asNumberXGType_BIGDECIMALX_isXtypeOfXGType_BIGDECIMALXX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("data").Property("int", 123), (g,p) =>g.V().Values<object>("int").AsNumber(GType.BigDecimal).Is(P.TypeOf(GType.BigDecimal))}}, + {"g_V_valuesXintX_asNumberXGType_BIGDECIMALX_isXtypeOfXGType_BIGDECIMALXX_mathXaddX0_5XX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("data").Property("int", 10), (g,p) =>g.V().Values<object>("int").AsNumber(GType.BigDecimal).Is(P.TypeOf(GType.BigDecimal)).Math("_ + 0.5")}}, + {"g_V_valuesXintX_asNumberXGType_BIGDECIMALX_isXtypeOfXGType_BIGDECIMALXX_isXgtX0XX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("data").Property("int", 5), (g,p) =>g.V().Values<object>("int").AsNumber(GType.BigDecimal).Is(P.TypeOf(GType.BigDecimal)).Is(P.Gt(0))}}, + {"g_V_valuesXintX_asNumberXGType_BIGDECIMALX_isXtypeOfXGType_BIGDECIMALXX_sumX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("data").Property("int", 2).AddV("data").Property("int", 3).AddV("data").Property("int", 4), (g,p) =>g.V().Values<object>("int").AsNumber(GType.BigDecimal).Is(P.TypeOf(GType.BigDecimal)).Sum<object>()}}, + {"g_V_valuesXintX_asNumberXGType_BIGDECIMALX_isXtypeOfXGType_BIGDECIMALXX_minX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("data").Property("int", 1).AddV("data").Property("int", 5).AddV("data").Property("int", 10), (g,p) =>g.V().Values<object>("int").AsNumber(GType.BigDecimal).Is(P.TypeOf(GType.BigDecimal)).Min<object>()}}, + {"g_V_valuesXintX_asNumberXGType_BIGDECIMALX_isXtypeOfXGType_BIGDECIMALXX_maxX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("data").Property("int", 7).AddV("data").Property("int", 14).AddV("data").Property("int", 21), (g,p) =>g.V().Values<object>("int").AsNumber(GType.BigDecimal).Is(P.TypeOf(GType.BigDecimal)).Max<object>()}}, + {"g_V_valuesXintX_asNumberXGType_BIGDECIMALX_isXtypeOfXGType_BIGDECIMALXX_project_byXidentityX_byXmathXmulX10XXX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("data").Property("int", 6), (g,p) =>g.V().Values<object>("int").AsNumber(GType.BigDecimal).Is(P.TypeOf(GType.BigDecimal)).Project<object>("original", "multiplied").By(__.Identity()).By(__.Math("_ * 10"))}}, + {"g_injectX99X_asNumberXGType_BIGDECIMALX_isXtypeOfXGType_BIGDECIMALXX_groupCount", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(99).AsNumber(GType.BigDecimal).Is(P.TypeOf(GType.BigDecimal)).GroupCount<object>()}}, + {"g_V_valuesXageX_isXtypeOfXGType_BIGDECIMALXX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Values<object>("age").Is(P.TypeOf(GType.BigDecimal))}}, + {"g_V_valuesXintX_asNumberXGType_BIGINTX_isXtypeOfXGType_BIGINTXX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("data").Property("int", 456), (g,p) =>g.V().Values<object>("int").AsNumber(GType.BigInt).Is(P.TypeOf(GType.BigInt))}}, + {"g_V_valuesXintX_asNumberXGType_BIGINTX_isXtypeOfXGType_BIGINTXX_mathXmulX1000XX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("data").Property("int", 100), (g,p) =>g.V().Values<object>("int").AsNumber(GType.BigInt).Is(P.TypeOf(GType.BigInt)).Math("_ * 1000")}}, + {"g_V_valuesXintX_asNumberXGType_BIGINTX_isXtypeOfXGType_BIGINTXX_isXeqX42XX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("data").Property("int", 42), (g,p) =>g.V().Values<object>("int").AsNumber(GType.BigInt).Is(P.TypeOf(GType.BigInt)).Is(P.Eq(42))}}, + {"g_V_valuesXintX_asNumberXGType_BIGINTX_isXtypeOfXGType_BIGINTXX_sumX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("data").Property("int", 10).AddV("data").Property("int", 20).AddV("data").Property("int", 30), (g,p) =>g.V().Values<object>("int").AsNumber(GType.BigInt).Is(P.TypeOf(GType.BigInt)).Sum<object>()}}, + {"g_V_valuesXintX_asNumberXGType_BIGINTX_isXtypeOfXGType_BIGINTXX_minX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("data").Property("int", 5).AddV("data").Property("int", 15).AddV("data").Property("int", 25), (g,p) =>g.V().Values<object>("int").AsNumber(GType.BigInt).Is(P.TypeOf(GType.BigInt)).Min<object>()}}, + {"g_V_valuesXintX_asNumberXGType_BIGINTX_isXtypeOfXGType_BIGINTXX_maxX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("data").Property("int", 100).AddV("data").Property("int", 200).AddV("data").Property("int", 300), (g,p) =>g.V().Values<object>("int").AsNumber(GType.BigInt).Is(P.TypeOf(GType.BigInt)).Max<object>()}}, + {"g_V_valuesXintX_asNumberXGType_BIGINTX_isXtypeOfXGType_BIGINTXX_project_byXidentityX_byXmathXaddX999XXX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("data").Property("int", 50), (g,p) =>g.V().Values<object>("int").AsNumber(GType.BigInt).Is(P.TypeOf(GType.BigInt)).Project<object>("original", "added").By(__.Identity()).By(__.Math("_ + 999"))}}, + {"g_injectX777X_asNumberXGType_BIGINTX_isXtypeOfXGType_BIGINTXX_groupCount", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(777).AsNumber(GType.BigInt).Is(P.TypeOf(GType.BigInt)).GroupCount<object>()}}, + {"g_V_valuesXageX_isXtypeOfXGType_BIGINTXX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Values<object>("age").Is(P.TypeOf(GType.BigInt))}}, + {"g_V_valuesXintX_asNumberXGType_BYTEX_isXtypeOfXGType_BYTEXX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("data").Property("int", 5), (g,p) =>g.V().Values<object>("int").AsNumber(GType.Byte).Is(P.TypeOf(GType.Byte))}}, + {"g_V_valuesXintX_asNumberXGType_BYTEX_isXtypeOfXGType_BYTEXX_mathXaddX20XX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("data").Property("int", 10), (g,p) =>g.V().Values<object>("int").AsNumber(GType.Byte).Is(P.TypeOf(GType.Byte)).Math("_ + 20")}}, + {"g_V_valuesXintX_asNumberXGType_BYTEX_isXtypeOfXGType_BYTEXX_isXltX10XX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("data").Property("int", 7), (g,p) =>g.V().Values<object>("int").AsNumber(GType.Byte).Is(P.TypeOf(GType.Byte)).Is(P.Lt(10))}}, + {"g_V_valuesXintX_asNumberXGType_BYTEX_isXtypeOfXGType_BYTEXX_sumX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("data").Property("int", 1).AddV("data").Property("int", 2).AddV("data").Property("int", 3), (g,p) =>g.V().Values<object>("int").AsNumber(GType.Byte).Is(P.TypeOf(GType.Byte)).Sum<object>()}}, + {"g_V_valuesXintX_asNumberXGType_BYTEX_isXtypeOfXGType_BYTEXX_project_byXidentityX_byXmathXmulX2XXX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("data").Property("int", 8), (g,p) =>g.V().Values<object>("int").AsNumber(GType.Byte).Is(P.TypeOf(GType.Byte)).Project<object>("original", "doubled").By(__.Identity()).By(__.Math("_ * 2"))}}, + {"g_V_valuesXintX_asNumberXGType_BYTEX_isXtypeOfXGType_BYTEXX_chooseXisXeqX12XX_constantXtwelveX_constantXotherXX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("data").Property("int", 12), (g,p) =>g.V().Values<object>("int").AsNumber(GType.Byte).Is(P.TypeOf(GType.Byte)).Choose<object>(__.Is(P.Eq(12)), __.Constant<object>("twelve"), __.Constant<object>("other"))}}, + {"g_injectX15X_asNumberXGType_BYTEX_isXtypeOfXGType_BYTEXX_groupCount", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(15).AsNumber(GType.Byte).Is(P.TypeOf(GType.Byte)).GroupCount<object>()}}, + {"g_V_valuesXageX_isXtypeOfXGType_BYTEXX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Values<object>("age").Is(P.TypeOf(GType.Byte))}}, + {"g_V_valuesXdatetimeX_isXtypeOfXGType_DATETIMEXX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("event").Property("datetime", DateTimeOffset.Parse("2023-08-08T00:00Z")), (g,p) =>g.V().Values<object>("datetime").Is(P.TypeOf(GType.DateTime))}}, + {"g_V_valuesXdatetimeX_isXtypeOfXGType_DATETIMEXX_project_byXidentityX_byXdateAddXDT_dayX1XX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("event").Property("datetime", DateTimeOffset.Parse("2023-08-08T00:00Z")), (g,p) =>g.V().Values<object>("datetime").Is(P.TypeOf(GType.DateTime)).Project<object>("original", "nextDay").By(__.Identity()).By(__.DateAdd(DT.Day, 1))}}, + {"g_V_valuesXdatetimeX_isXtypeOfXGType_DATETIMEXX_dateDiffXdatetimeX2023_08_10XX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("event").Property("datetime", DateTimeOffset.Parse("2023-08-08T00:00Z")), (g,p) =>g.V().Values<object>("datetime").Is(P.TypeOf(GType.DateTime)).DateDiff(DateTimeOffset.Parse("2023-08-08T00:00:30Z"))}}, + {"g_V_valuesXdatetimeX_isXtypeOfXGType_DATETIMEXX_whereXisXgtXdatetimeX2020_01_01XXXX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("event").Property("datetime", DateTimeOffset.Parse("2023-08-08T00:00Z")), (g,p) =>g.V().Values<object>("datetime").Is(P.TypeOf(GType.DateTime)).Where(__.Is(P.Gt(DateTimeOffset.Parse("2020-01-01T00:00Z"))))}}, + {"g_V_valuesXdatetimeX_isXtypeOfXGType_DATETIMEXX_chooseXisXeqXdatetimeX2023_08_08XXXX_constantXmatchX_constantXnoMatchXX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("event").Property("datetime", DateTimeOffset.Parse("2023-08-08T00:00Z")), (g,p) =>g.V().Values<object>("datetime").Is(P.TypeOf(GType.DateTime)).Choose<object>(__.Is(P.Eq(DateTimeOffset.Parse("2023-08-08T00:00Z"))), __.Constant<object>("match"), __.Constant<o [...] + {"g_V_valuesXdatetimeX_isXtypeOfXGType_DATETIMEXX_localXaggregateXaX_capXaX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("event").Property("datetime", DateTimeOffset.Parse("2023-08-08T00:00Z")), (g,p) =>g.V().Values<object>("datetime").Is(P.TypeOf(GType.DateTime)).Local<object>(__.Aggregate("a")).Cap<object>("a")}}, + {"g_injectXdatetimeX_isXtypeOfXGType_DATETIMEXX_aggregateXaX_capXaX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(DateTimeOffset.Parse("2023-08-08T00:00Z")).Is(P.TypeOf(GType.DateTime)).Aggregate("a").Cap<object>("a")}}, + {"g_injectXdatetimeX_isXtypeOfXGType_DATETIMEXX_groupCount", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(DateTimeOffset.Parse("2023-08-08T00:00Z")).Is(P.TypeOf(GType.DateTime)).GroupCount<object>()}}, + {"g_V_valuesXdoubleX_isXtypeOfXGType_DOUBLEXX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("data").Property("double", 1.5d), (g,p) =>g.V().Values<object>("double").Is(P.TypeOf(GType.Double))}}, + {"g_E_valuesXweightX_isXtypeOfXGType_DOUBLEXX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.E().Values<object>("weight").Is(P.TypeOf(GType.Double))}}, + {"g_V_valuesXdoubleX_isXtypeOfXGType_DOUBLEXX_mathXceilX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("data").Property("double", 2.7d), (g,p) =>g.V().Values<object>("double").Is(P.TypeOf(GType.Double)).Math("ceil _")}}, + {"g_V_valuesXdoubleX_isXtypeOfXGType_DOUBLEXX_isXgtX1_0XX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("data").Property("double", 0.8d).AddV("data").Property("double", 1.2d), (g,p) =>g.V().Values<object>("double").Is(P.TypeOf(GType.Double)).Is(P.Gt(1.0d))}}, + {"g_V_valuesXdoubleX_isXtypeOfXGType_DOUBLEXX_sumX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("data").Property("double", 1.5d).AddV("data").Property("double", 2.5d).AddV("data").Property("double", 3.5d), (g,p) =>g.V().Values<object>("double").Is(P.TypeOf(GType.Double)).Sum<object>()}}, + {"g_V_valuesXdoubleX_isXtypeOfXGType_DOUBLEXX_minX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("data").Property("double", 0.1d).AddV("data").Property("double", 0.5d).AddV("data").Property("double", 0.9d), (g,p) =>g.V().Values<object>("double").Is(P.TypeOf(GType.Double)).Min<object>()}}, + {"g_V_valuesXdoubleX_isXtypeOfXGType_DOUBLEXX_maxX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("data").Property("double", 2.1d).AddV("data").Property("double", 3.7d).AddV("data").Property("double", 1.9d), (g,p) =>g.V().Values<object>("double").Is(P.TypeOf(GType.Double)).Max<object>()}}, + {"g_V_valuesXdoubleX_isXtypeOfXGType_DOUBLEXX_meanX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("data").Property("double", 2.1d).AddV("data").Property("double", 4.1d).AddV("data").Property("double", 6.1d), (g,p) =>g.V().Values<object>("double").Is(P.TypeOf(GType.Double)).Mean<object>()}}, + {"g_V_valuesXdoubleX_isXtypeOfXGType_DOUBLEXX_order_byXascX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("data").Property("double", 3.2d).AddV("data").Property("double", 1.8d).AddV("data").Property("double", 2.5d), (g,p) =>g.V().Values<object>("double").Is(P.TypeOf(GType.Double)).Order().By(Order.Asc)}}, + {"g_injectX5_5dX_isXtypeOfXGType_DOUBLEXX_groupCount", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(5.5d).Is(P.TypeOf(GType.Double)).GroupCount<object>()}}, + {"g_V_valuesXageX_isXtypeOfXGType_DOUBLEXX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Values<object>("age").Is(P.TypeOf(GType.Double))}}, + {"g_V_valuesXfloatX_isXtypeOfXGType_FLOATXX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("data").Property("float", 2.5), (g,p) =>g.V().Values<object>("float").AsNumber(GType.Float).Is(P.TypeOf(GType.Float))}}, + {"g_V_valuesXfloatX_isXtypeOfXGType_FLOATXX_mathXmulX2XX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("data").Property("float", 3.0), (g,p) =>g.V().Values<object>("float").AsNumber(GType.Float).Is(P.TypeOf(GType.Float)).Math("_ * 2")}}, + {"g_V_valuesXfloatX_isXtypeOfXGType_FLOATXX_isXeqX1_5XX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("data").Property("float", 1.5), (g,p) =>g.V().Values<object>("float").AsNumber(GType.Float).Is(P.TypeOf(GType.Float)).Is(P.Eq(1.5))}}, + {"g_V_valuesXfloatX_isXtypeOfXGType_FLOATXX_sumX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("data").Property("float", 1.5).AddV("data").Property("float", 2.5).AddV("data").Property("float", 3.0), (g,p) =>g.V().Values<object>("float").AsNumber(GType.Float).Is(P.TypeOf(GType.Float)).Sum<object>()}}, + {"g_V_valuesXfloatX_isXtypeOfXGType_FLOATXX_project_byXidentityX_byXmathXmulX10XXX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("data").Property("float", 4.5), (g,p) =>g.V().Values<object>("float").AsNumber(GType.Float).Is(P.TypeOf(GType.Float)).Project<object>("original", "multiplied").By(__.Identity()).By(__.Math("_ * 10"))}}, + {"g_V_valuesXfloatX_isXtypeOfXGType_FLOATXX_whereXisXgtX1_0XXX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("data").Property("float", 0.5).AddV("data").Property("float", 1.5), (g,p) =>g.V().Values<object>("float").AsNumber(GType.Float).Is(P.TypeOf(GType.Float)).Where(__.Is(P.Gt(1.0)))}}, + {"g_V_valuesXfloatX_isXtypeOfXGType_FLOATXX_chooseXisXeqX3_0XX_constantXthreeX_constantXotherXX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("data").Property("float", 3.0), (g,p) =>g.V().Values<object>("float").AsNumber(GType.Float).Is(P.TypeOf(GType.Float)).Choose<object>(__.Is(P.Eq(3.0)), __.Constant<object>("three"), __.Constant<object>("other"))}}, + {"g_injectX2_0fX_isXtypeOfXGType_FLOATXX_groupCount", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(2.0).AsNumber(GType.Float).Is(P.TypeOf(GType.Float)).GroupCount<object>()}}, + {"g_V_valuesXageX_isXtypeOfXGType_FLOATXX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Values<object>("age").Is(P.TypeOf(GType.Float))}}, + {"g_V_valuesXageX_isXtypeOfXGType_INTXX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Values<object>("age").Is(P.TypeOf(GType.Int))}}, + {"g_V_hasXage_typeOfXGType_INTXX_valuesXnameX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Has("age", P.TypeOf(GType.Int)).Values<object>("name")}}, + {"g_V_whereXvaluesXageX_isXtypeOfXGType_INTXXX_valuesXnameX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Where(__.Values<object>("age").Is(P.TypeOf(GType.Int))).Values<object>("name")}}, + {"g_V_valuesXageX_isXtypeOfXGType_INTXX_mathXincX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Values<object>("name", "age").Is(P.TypeOf(GType.Int)).Math("_ + 1")}}, + {"g_V_valuesXageX_isXtypeOfXGType_INTXX_sumX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Values<object>("age").Is(P.TypeOf(GType.Int)).Sum<object>()}}, + {"g_V_valuesXageX_isXtypeOfXGType_INTXX_minX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Values<object>("age").Is(P.TypeOf(GType.Int)).Min<object>()}}, + {"g_V_valuesXageX_isXtypeOfXGType_INTXX_maxX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Values<object>("age").Is(P.TypeOf(GType.Int)).Max<object>()}}, + {"g_V_valuesXageX_isXtypeOfXGType_INTXX_meanX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Values<object>("age").Is(P.TypeOf(GType.Int)).Mean<object>()}}, + {"g_V_valuesXageX_isXtypeOfXGType_INTXX_order_byXdescX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Values<object>("age").Is(P.TypeOf(GType.Int)).Order().By(Order.Desc)}}, + {"g_V_valuesXageX_isXtypeOfXGType_INTXX_groupCount", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Values<object>("age").Is(P.TypeOf(GType.Int)).GroupCount<object>()}}, + {"g_V_valuesXnameX_fold_isXtypeOfXGType_LISTXX_count", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Values<object>("name").Fold().Is(P.TypeOf(GType.List)).Count()}}, + {"g_V_valuesXageX_isXtypeOfXGType_LISTXX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Values<object>("age").Is(P.TypeOf(GType.List))}}, + {"g_V_valuesXlistX_isXtypeOfXGType_LISTXX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("data").Property("list", new List<object> { "a", "b", "c" }), (g,p) =>g.V().Values<object>("list").Is(P.TypeOf(GType.List))}}, + {"g_V_hasXlist_typeOfXGType_LISTXX_valuesXnameX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("data").Property("name", "test").Property("list", new List<object> { 1, 2, 3 }), (g,p) =>g.V().Has("list", P.TypeOf(GType.List)).Values<object>("name")}}, + {"g_V_valuesXlistX_isXtypeOfXGType_LISTXX_unfold", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("data").Property("list", new List<object> { "x", "y", "z" }), (g,p) =>g.V().Values<object>("list").Is(P.TypeOf(GType.List)).Unfold<object>()}}, + {"g_V_valuesXlistX_isXtypeOfXGType_LISTXX_countXlocalX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("data").Property("list", new List<object> { 1, 2, 3, 4, 5 }), (g,p) =>g.V().Values<object>("list").Is(P.TypeOf(GType.List)).Count(Scope.Local)}}, + {"g_V_valuesXlistX_isXtypeOfXGType_LISTXX_unfold_rangeX1_3X", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("data").Property("list", new List<object> { "first", "second", "third", "fourth" }), (g,p) =>g.V().Values<object>("list").Is(P.TypeOf(GType.List)).Unfold<object>().Range<object>(1, 3)}}, + {"g_V_valuesXlistX_isXtypeOfXGType_LISTXX_project_byXidentityX_byXcountXlocalX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("data").Property("list", new List<object> { "apple", "banana" }), (g,p) =>g.V().Values<object>("list").Is(P.TypeOf(GType.List)).Project<object>("original", "size").By(__.Identity()).By(__.Count(Scope.Local))}}, + {"g_V_valuesXlistX_isXtypeOfXGType_LISTXX_whereXcountXlocalX_isXgtX2XXX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("data").Property("list", new List<object> { 1 }).AddV("data").Property("list", new List<object> { 1, 2, 3 }), (g,p) =>g.V().Values<object>("list").Is(P.TypeOf(GType.List)).Where(__.Count(Scope.Local).Is(P.Gt(2)))}}, + {"g_injectXlistX_isXtypeOfXGType_LISTXX_groupCount", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(new List<object> { "test" }).Is(P.TypeOf(GType.List)).GroupCount<object>()}}, + {"g_V_valuesXlongX_isXtypeOfXGType_LONGXX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("data").Property("long", 1l), (g,p) =>g.V().Values<object>("long").Is(P.TypeOf(GType.Long))}}, + {"g_V_hasXlong_typeOfXGType_LONGXX_valuesXnameX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("data").Property("name", "test").Property("long", 1l), (g,p) =>g.V().Has("long", P.TypeOf(GType.Long)).Values<object>("name")}}, + {"g_V_valuesXlongX_isXtypeOfXGType_LONGXX_mathXmulX2XX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("data").Property("long", 5l), (g,p) =>g.V().Values<object>("long").Is(P.TypeOf(GType.Long)).Math("_ * 2")}}, + {"g_V_valuesXlongX_isXtypeOfXGType_LONGXX_isXgtX5XX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("data").Property("long", 10l), (g,p) =>g.V().Values<object>("long").Is(P.TypeOf(GType.Long)).Is(P.Gt(5l))}}, + {"g_V_valuesXlongX_isXtypeOfXGType_LONGXX_sumX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("data").Property("long", 1l).AddV("data").Property("long", 2l).AddV("data").Property("long", 3l), (g,p) =>g.V().Values<object>("long").Is(P.TypeOf(GType.Long)).Sum<object>()}}, + {"g_V_valuesXlongX_isXtypeOfXGType_LONGXX_localXaggregateXaXX_capXaX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("data").Property("long", 100l), (g,p) =>g.V().Values<object>("long").Is(P.TypeOf(GType.Long)).Local<object>(__.Aggregate("a")).Cap<object>("a")}}, + {"g_V_hasLabelXpersonX_valueMap_isXtypeOfXGType_MAPXX_count", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().HasLabel("person").ValueMap<object, object>().Is(P.TypeOf(GType.Map)).Count()}}, + {"g_V_groupCount_byXlabelX_isXtypeOfXGType_MAPX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().GroupCount<object>().By(T.Label).Is(P.TypeOf(GType.Map))}}, + {"g_V_valuesXageX_isXtypeOfXGType_MAPXX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Values<object>("age").Is(P.TypeOf(GType.Map))}}, + {"g_V_valuesXmapX_isXtypeOfXGType_MAPXX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("data").Property("map", new Dictionary<object, object> {{ "key1", "1" }, { "key2", "2" }}), (g,p) =>g.V().Values<object>("map").Is(P.TypeOf(GType.Map))}}, + {"g_V_hasXmap_typeOfXGType_MAPXX_valuesXnameX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("data").Property("name", "test").Property("map", new Dictionary<object, object> {{ "a", 1 }, { "b", 2 }}), (g,p) =>g.V().Has("map", P.TypeOf(GType.Map)).Values<object>("name")}}, + {"g_V_valuesXmapX_isXtypeOfXGType_MAPXX_countXlocalX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("data").Property("map", new Dictionary<object, object> {{ "a", 1 }, { "b", 2 }, { "c", 3 }}), (g,p) =>g.V().Values<object>("map").Is(P.TypeOf(GType.Map)).Count(Scope.Local)}}, + {"g_V_valuesXmapX_isXtypeOfXGType_MAPXX_selectXvaluesX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("data").Property("map", new Dictionary<object, object> {{ "city", "NYC" }, { "country", "USA" }}), (g,p) =>g.V().Values<object>("map").Is(P.TypeOf(GType.Map)).Select<object>(Column.Values)}}, + {"g_V_valuesXmapX_isXtypeOfXGType_MAPXX_whereX_countXlocalX_isXgtX1XXX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("data").Property("map", new Dictionary<object, object> {{ "single", "value" }}).AddV("data").Property("map", new Dictionary<object, object> {{ "key1", "1" }, { "key2", "2" }}), (g,p) =>g.V().Values<object>("map").Is(P.TypeOf(GType.Map)).Where(__.Count(Scope.Local).Is(P.Gt(1)))}}, + {"g_V_valuesXmapX_isXtypeOfXGType_MAPXX_foldX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("data").Property("map", new Dictionary<object, object> {{ "a", 1 }}).AddV("data").Property("map", new Dictionary<object, object> {{ "b", 2 }, { "c", 3 }}), (g,p) =>g.V().Values<object>("map").Is(P.TypeOf(GType.Map)).Fold()}}, + {"g_V_valueXnameX_aggregateXxX_capXxX_isXtypeOfXGType_SETX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Values<object>("name").Aggregate("x").Cap<object>("x").Is(P.TypeOf(GType.Set))}}, + {"g_V_valuesXageX_isXtypeOfXGType_SETXX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Values<object>("age").Is(P.TypeOf(GType.Set))}}, + {"g_V_valueMap_selectXkeysX_dedup_isXtypeOfXGType_SETXX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().ValueMap<object, object>().Select<object>(Column.Keys).Dedup().Is(P.TypeOf(GType.Set))}}, + {"g_V_valuesXsetX_isXtypeOfXGType_SETXX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("data").Property("set", new HashSet<object> { "a", "b", "c" }), (g,p) =>g.V().Values<object>("set").Is(P.TypeOf(GType.Set))}}, + {"g_V_hasXset_typeOfXGType_SETXX_valuesXnameX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("data").Property("name", "test").Property("set", new HashSet<object> { 1, 2, 3 }), (g,p) =>g.V().Has("set", P.TypeOf(GType.Set)).Values<object>("name")}}, + {"g_V_valuesXsetX_isXtypeOfXGType_SETXX_unfold", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("data").Property("set", new HashSet<object> { "x", "y", "z" }), (g,p) =>g.V().Values<object>("set").Is(P.TypeOf(GType.Set)).Unfold<object>()}}, + {"g_V_valuesXsetX_isXtypeOfXGType_SETXX_countXlocalX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("data").Property("set", new HashSet<object> { 1, 2, 3, 4, 5 }), (g,p) =>g.V().Values<object>("set").Is(P.TypeOf(GType.Set)).Count(Scope.Local)}}, + {"g_V_valuesXsetX_isXtypeOfXGType_SETXX_whereXcountXlocalX_isXeqX3XXX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("data").Property("set", new HashSet<object> { 1, 2 }).AddV("data").Property("set", new HashSet<object> { 1, 2, 3 }), (g,p) =>g.V().Values<object>("set").Is(P.TypeOf(GType.Set)).Where(__.Count(Scope.Local).Is(P.Eq(3)))}}, + {"g_V_valuesXsetX_isXtypeOfXGType_SETXX_unfold_limitX2X", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("data").Property("set", new HashSet<object> { "first", "second", "third", "fourth" }), (g,p) =>g.V().Values<object>("set").Is(P.TypeOf(GType.Set)).Unfold<object>().Limit<object>(2)}}, + {"g_injectXsetX_isXtypeOfXGType_SETXX_groupCount", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(new HashSet<object> { "test" }).Is(P.TypeOf(GType.Set)).GroupCount<object>()}}, + {"g_V_valuesXintX_asNumberXGType_SHORTX_isXtypeOfXGType_SHORTXX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("data").Property("int", 100), (g,p) =>g.V().Values<object>("int").AsNumber(GType.Short).Is(P.TypeOf(GType.Short))}}, + {"g_V_valuesXintX_asNumberXGType_SHORTX_isXtypeOfXGType_SHORTXX_mathXmulX10XX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("data").Property("int", 50), (g,p) =>g.V().Values<object>("int").AsNumber(GType.Short).Is(P.TypeOf(GType.Short)).Math("_ * 10")}}, + {"g_V_valuesXintX_asNumberXGType_SHORTX_isXtypeOfXGType_SHORTXX_isXbetweenX20_30XX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("data").Property("int", 25), (g,p) =>g.V().Values<object>("int").AsNumber(GType.Short).Is(P.TypeOf(GType.Short)).Is(P.Between(20, 30))}}, + {"g_V_valuesXintX_asNumberXGType_SHORTX_isXtypeOfXGType_SHORTXX_minX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("data").Property("int", 10).AddV("data").Property("int", 20).AddV("data").Property("int", 30), (g,p) =>g.V().Values<object>("int").AsNumber(GType.Short).Is(P.TypeOf(GType.Short)).Min<object>()}}, + {"g_V_valuesXintX_asNumberXGType_SHORTX_isXtypeOfXGType_SHORTXX_maxX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("data").Property("int", 15).AddV("data").Property("int", 25).AddV("data").Property("int", 35), (g,p) =>g.V().Values<object>("int").AsNumber(GType.Short).Is(P.TypeOf(GType.Short)).Max<object>()}}, + {"g_injectX42X_asNumberXGType_SHORTX_isXtypeOfXGType_SHORTXX_storeXaX_capXaX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(42).AsNumber(GType.Short).Is(P.TypeOf(GType.Short)).Store("a").Cap<object>("a")}}, + {"g_V_valuesXageX_isXtypeOfXGType_SHORTXX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Values<object>("age").Is(P.TypeOf(GType.Short))}}, + {"g_V_valuesXuuidX_isXtypeOfXGType_UUIDXX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("data").Property("uuid", Guid.Parse("f47af10b-58cc-4372-a567-0f02b2f3d479")), (g,p) =>g.V().Values<object>("uuid").Is(P.TypeOf(GType.UUID))}}, + {"g_V_hasXuuid_typeOfXGType_UUIDXX_valuesXnameX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("data").Property("name", "test").Property("uuid", Guid.Parse("f47af10b-58cc-4372-a567-0f02b2f3d479")), (g,p) =>g.V().Has("uuid", P.TypeOf(GType.UUID)).Values<object>("name")}}, + {"g_V_valuesXuuidX_isXtypeOfXGType_UUIDXX_project_byXidentityX_byXconstantXuuidXX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("data").Property("uuid", Guid.Parse("f47af10b-58cc-4372-a567-0f02b2f3d479")), (g,p) =>g.V().Values<object>("uuid").Is(P.TypeOf(GType.UUID)).Project<object>("original", "type").By(__.Identity()).By(__.Constant<object>("uuid"))}}, + {"g_V_valuesXuuidX_isXtypeOfXGType_UUIDXX_whereXisXeqXuuidXX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("data").Property("uuid", Guid.Parse("f47af10b-58cc-4372-a567-0f02b2f3d479")), (g,p) =>g.V().Values<object>("uuid").Is(P.TypeOf(GType.UUID)).Where(__.Is(P.Eq(Guid.Parse("f47af10b-58cc-4372-a567-0f02b2f3d479"))))}}, + {"g_V_valuesXuuidX_isXtypeOfXGType_UUIDXX_chooseXisXeqXuuidXX_constantXmatchX_constantXnoMatchXX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("data").Property("uuid", Guid.Parse("f47af10b-58cc-4372-a567-0f02b2f3d479")), (g,p) =>g.V().Values<object>("uuid").Is(P.TypeOf(GType.UUID)).Choose<object>(__.Is(P.Eq(Guid.Parse("f47af10b-58cc-4372-a567-0f02b2f3d479"))), __.Constant<object>("match"), __.Constant<object>("noMatch"))}}, + {"g_V_valuesXuuidX_isXtypeOfXGType_UUIDXX_localXaggregateXaXX_capXaX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("data").Property("uuid", Guid.Parse("f47af10b-58cc-4372-a567-0f02b2f3d479")), (g,p) =>g.V().Values<object>("uuid").Is(P.TypeOf(GType.UUID)).Local<object>(__.Aggregate("a")).Cap<object>("a")}}, + {"g_V_valuesXuuidX_isXtypeOfXGType_UUIDXX_aggregateXaX_capXaX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV("data").Property("uuid", Guid.Parse("f47af10b-58cc-4372-a567-0f02b2f3d479")), (g,p) =>g.V().Values<object>("uuid").Is(P.TypeOf(GType.UUID)).Aggregate("a").Cap<object>("a")}}, + {"g_injectXuuidX_isXtypeOfXGType_UUIDXX_groupCount", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(Guid.Parse("f47af10b-58cc-4372-a567-0f02b2f3d479")).Is(P.TypeOf(GType.UUID)).GroupCount<object>()}}, + {"g_injectXUUIDX47af10b_58cc_4372_a567_0f02b2f3d479XX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(Guid.Parse("f47af10b-58cc-4372-a567-0f02b2f3d479"))}}, + {"g_injectXUUIDXXX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(Guid.NewGuid())}}, {"g_V_aggregateXxX_byXnameX_byXageX_capXxX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Aggregate("x").By("name").By("age").Cap<object>("x")}}, {"g_V_aggregateXScope_local_xX_byXnameX_byXageX_capXxX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Aggregate(Scope.Local, "x").By("name").By("age").Cap<object>("x")}}, {"g_V_valuesXageX_allXgtX32XX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Values<object>("age").All(P.Gt(32))}}, diff --cc gremlin-javascript/src/main/javascript/gremlin-javascript/lib/process/traversal.ts index 299c930ee0,11bd6ea406..5ab11721d0 --- a/gremlin-javascript/src/main/javascript/gremlin-javascript/lib/process/traversal.ts +++ b/gremlin-javascript/src/main/javascript/gremlin-javascript/lib/process/traversal.ts @@@ -347,8 -345,13 +347,13 @@@ export class P<T1 = any, T2 = any> return createP('outside', args); } + /** @param {...Object} args */ - static typeOf(...args) { ++ static typeOf(...args: any[]) { + return createP('typeOf', args); + } + /** @param {...Object} args */ - static test(...args) { + static test(...args: any[]) { return createP('test', args); } } @@@ -491,29 -492,50 +496,38 @@@ function toDirectionEnum(typeName: stri return result; } -function toGTypeEnum(typeName, keys) { - const result = {}; ++function toGTypeEnum(typeName: string, keys: string) { ++ const result: { [key: string]: any } = {}; + keys.split(' ').forEach((k) => { + result[k] = new EnumValue(typeName, k.toUpperCase()); + }); + return result; + } + -class EnumValue { - constructor(typeName, elementName) { - this.typeName = typeName; - this.elementName = elementName; - } +export class EnumValue { + constructor( + public typeName: string, + public elementName: string, + ) {} toString() { return this.elementName; } } -module.exports = { - EnumValue, - P, - TextP, - withOptions, - IO, - Traversal, - TraversalSideEffects, - Traverser, - barrier: toEnum('Barrier', 'normSack'), - cardinality: toEnum('Cardinality', 'list set single'), - column: toEnum('Column', 'keys values'), - direction: toDirectionEnum('Direction', 'BOTH IN OUT from_ to'), - dt: toEnum('DT', 'second minute hour day'), - gType: toGTypeEnum( - 'GType', - 'bigDecimal bigInt binary boolean byte char datetime double duration edge float graph int list long map null number path property set short string tree uuid vertex vproperty', - ), - graphSONVersion: toEnum('GraphSONVersion', 'V1_0 V2_0 V3_0'), - gryoVersion: toEnum('GryoVersion', 'V1_0 V3_0'), - merge: toEnum('Merge', 'onCreate onMatch outV inV'), - operator: toEnum('Operator', 'addAll and assign div max min minus mult or sum sumLong'), - order: toEnum('Order', 'asc desc shuffle'), - pick: toEnum('Pick', 'any none unproductive'), - pop: toEnum('Pop', 'all first last mixed'), - scope: toEnum('Scope', 'global local'), - t: toEnum('T', 'id key label value'), -}; +export const barrier = toEnum('Barrier', 'normSack'); +export const cardinality = toEnum('Cardinality', 'list set single'); +export const column = toEnum('Column', 'keys values'); +export const direction = toDirectionEnum('Direction', 'BOTH IN OUT from_ to'); +export const dt = toEnum('DT', 'second minute hour day'); ++export const gType = toGTypeEnum('GType', 'bigDecimal bigInt binary boolean byte char datetime double duration edge float graph int list long map null number path property set short string tree uuid vertex vproperty'); +export const graphSONVersion = toEnum('GraphSONVersion', 'V1_0 V2_0 V3_0'); +export const gryoVersion = toEnum('GryoVersion', 'V1_0 V3_0'); +export const merge = toEnum('Merge', 'onCreate onMatch outV inV'); +export const operator = toEnum('Operator', 'addAll and assign div max min minus mult or sum sumLong'); +export const order = toEnum('Order', 'asc desc shuffle'); +export const pick = toEnum('Pick', 'any none unproductive'); +export const pop = toEnum('Pop', 'all first last mixed'); +export const scope = toEnum('Scope', 'global local'); +export const t = toEnum('T', 'id key label value'); +export const n = toEnum('N', 'byte_ short_ int_ long_ float_ double_ bigInt bigDecimal'); diff --cc gremlin-javascript/src/main/javascript/gremlin-javascript/lib/structure/io/binary/internals/EnumSerializer.js index 43b4b50f84,ab36841ec6..809cbe0e68 --- a/gremlin-javascript/src/main/javascript/gremlin-javascript/lib/structure/io/binary/internals/EnumSerializer.js +++ b/gremlin-javascript/src/main/javascript/gremlin-javascript/lib/structure/io/binary/internals/EnumSerializer.js @@@ -52,19 -38,19 +52,19 @@@ export default class EnumSerializer }; const DT = ioc.DataType; this.types = [ - { name: 'Barrier', code: DT.BARRIER, enum: to_orig_enum(t.barrier) }, - { name: 'Cardinality', code: DT.CARDINALITY, enum: to_orig_enum(t.cardinality) }, - { name: 'Column', code: DT.COLUMN, enum: to_orig_enum(t.column) }, - { name: 'Direction', code: DT.DIRECTION, enum: to_orig_enum(t.direction) }, - { name: 'DT', code: DT.DT, enum: to_orig_enum(t.dt) }, - { name: 'GType', code: DT.GTYPE, enum: to_orig_enum(t.gType) }, - { name: 'Merge', code: DT.MERGE, enum: to_orig_enum(t.merge) }, - { name: 'Operator', code: DT.OPERATOR, enum: to_orig_enum(t.operator) }, - { name: 'Order', code: DT.ORDER, enum: to_orig_enum(t.order) }, - { name: 'Pick', code: DT.PICK, enum: to_orig_enum(t.pick) }, - { name: 'Pop', code: DT.POP, enum: to_orig_enum(t.pop) }, - { name: 'Scope', code: DT.SCOPE, enum: to_orig_enum(t.scope) }, - { name: 'T', code: DT.T, enum: to_orig_enum(t.t) }, + { name: 'Barrier', code: DT.BARRIER, enum: to_orig_enum(barrier) }, + { name: 'Cardinality', code: DT.CARDINALITY, enum: to_orig_enum(cardinality) }, + { name: 'Column', code: DT.COLUMN, enum: to_orig_enum(column) }, + { name: 'Direction', code: DT.DIRECTION, enum: to_orig_enum(direction) }, + { name: 'DT', code: DT.DT, enum: to_orig_enum(dt) }, ++ { name: 'GType', code: DT.GTYPE, enum: to_orig_enum(gType) }, + { name: 'Merge', code: DT.MERGE, enum: to_orig_enum(merge) }, + { name: 'Operator', code: DT.OPERATOR, enum: to_orig_enum(operator) }, + { name: 'Order', code: DT.ORDER, enum: to_orig_enum(order) }, + { name: 'Pick', code: DT.PICK, enum: to_orig_enum(pick) }, + { name: 'Pop', code: DT.POP, enum: to_orig_enum(pop) }, + { name: 'Scope', code: DT.SCOPE, enum: to_orig_enum(scope) }, + { name: 'T', code: DT.T, enum: to_orig_enum(_t) }, - { name: 'N', code: DT.N, enum: to_orig_enum(_n) }, ]; this.byname = {}; this.bycode = {}; diff --cc gremlin-javascript/src/main/javascript/gremlin-javascript/package.json index 7abc1072bf,f3a22a6220..dad0edc45b --- a/gremlin-javascript/src/main/javascript/gremlin-javascript/package.json +++ b/gremlin-javascript/src/main/javascript/gremlin-javascript/package.json @@@ -64,20 -48,18 +64,20 @@@ "url": "https://issues.apache.org/jira/browse/TINKERPOP"; }, "scripts": { + "build": "rm -rf build && duel --dirs", + "prepare": "npm run build", "test": "npm run unit-test && npm run integration-test", - "unit-test": "mocha test/unit/*", + "unit-test": "cross-env TS_NODE_PROJECT='tsconfig.test.json' mocha test/unit/*", "integration-test": "npm run integration-test-graphson30 && npm run integration-test-graphbinary", - "integration-test-graphson30": "cross-env CLIENT_MIMETYPE='application/vnd.gremlin-v3.0+json' ./node_modules/mocha/bin/mocha.js test/integration -t 5000", - "integration-test-graphbinary": "cross-env CLIENT_MIMETYPE='application/vnd.graphbinary-v1.0' ./node_modules/mocha/bin/mocha.js test/integration -t 5000", + "integration-test-graphson30": "cross-env TS_NODE_PROJECT='tsconfig.test.json' CLIENT_MIMETYPE='application/vnd.gremlin-v3.0+json' ./node_modules/mocha/bin/mocha.js test/integration -t 5000", + "integration-test-graphbinary": "cross-env TS_NODE_PROJECT='tsconfig.test.json' CLIENT_MIMETYPE='application/vnd.graphbinary-v1.0' ./node_modules/mocha/bin/mocha.js test/integration -t 5000", "TODO": "# test other mime types like graphbinary stringd", "features": "npm run features-graphson30 && npm run features-graphbinary", - "features-graphson30": "cross-env NODE_OPTIONS='--loader ts-node/esm' TS_NODE_PROJECT='tsconfig.test.json' CLIENT_MIMETYPE='application/vnd.gremlin-v3.0+json' cucumber-js --import test/cucumber ../../../../../gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/", - "features-graphbinary": "cross-env NODE_OPTIONS='--loader ts-node/esm' TS_NODE_PROJECT='tsconfig.test.json' CLIENT_MIMETYPE='application/vnd.graphbinary-v1.0' cucumber-js --import test/cucumber ../../../../../gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/", - "features-graphson30": "cross-env CLIENT_MIMETYPE='application/vnd.gremlin-v3.0+json' cucumber-js --tags \"not @DataUUID and not @DataLong\" --require test/cucumber ../../../../../gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/", - "features-graphbinary": "cross-env CLIENT_MIMETYPE='application/vnd.graphbinary-v1.0' cucumber-js --tags \"not @DataBigDecimal and not @DataBigInt and not @DataUUID and not @DataLong\" --require test/cucumber ../../../../../gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/", ++ "features-graphson30": "cross-env NODE_OPTIONS='--loader ts-node/esm' TS_NODE_PROJECT='tsconfig.test.json' CLIENT_MIMETYPE='application/vnd.gremlin-v3.0+json' cucumber-js --tags \"not @DataUUID and not @DataLong\" --import test/cucumber ../../../../../gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/", ++ "features-graphbinary": "cross-env NODE_OPTIONS='--loader ts-node/esm' TS_NODE_PROJECT='tsconfig.test.json' CLIENT_MIMETYPE='application/vnd.graphbinary-v1.0' cucumber-js --tags \"not @DataBigDecimal and not @DataBigInt and not @DataUUID and not @DataLong\" --import test/cucumber ../../../../../gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/", "features-docker": "npm run features-graphson30-docker && npm run features-graphbinary-docker", - "features-graphson30-docker": "cross-env NODE_OPTIONS='--loader ts-node/esm' TS_NODE_PROJECT='tsconfig.test.json' CLIENT_MIMETYPE='application/vnd.gremlin-v3.0+json' cucumber-js --import test/cucumber ../gremlin-test/", - "features-graphbinary-docker": "cross-env NODE_OPTIONS='--loader ts-node/esm' TS_NODE_PROJECT='tsconfig.test.json' CLIENT_MIMETYPE='application/vnd.graphbinary-v1.0' cucumber-js --import test/cucumber ../gremlin-test/", - "features-graphson30-docker": "cross-env CLIENT_MIMETYPE='application/vnd.gremlin-v3.0+json' cucumber-js --tags \"not @DataUUID and not @DataLong\" --require test/cucumber ../gremlin-test/", - "features-graphbinary-docker": "cross-env CLIENT_MIMETYPE='application/vnd.graphbinary-v1.0' cucumber-js --tags \"not @DataBigDecimal and not @DataBigInt and not @DataUUID and not @DataLong\" --require test/cucumber ../gremlin-test/", ++ "features-graphson30-docker": "cross-env NODE_OPTIONS='--loader ts-node/esm' TS_NODE_PROJECT='tsconfig.test.json' CLIENT_MIMETYPE='application/vnd.gremlin-v3.0+json' cucumber-js --tags \"not @DataUUID and not @DataLong\" --import test/cucumber ../gremlin-test/", ++ "features-graphbinary-docker": "cross-env NODE_OPTIONS='--loader ts-node/esm' TS_NODE_PROJECT='tsconfig.test.json' CLIENT_MIMETYPE='application/vnd.graphbinary-v1.0' cucumber-js --tags \"not @DataBigDecimal and not @DataBigInt and not @DataUUID and not @DataLong\" --import test/cucumber ../gremlin-test/", "lint": "eslint --ext .js ." }, "engines": { diff --cc gremlin-javascript/src/main/javascript/gremlin-javascript/test/cucumber/gremlin.js index 34f9017f3d,6df14113d7..74f355386d --- a/gremlin-javascript/src/main/javascript/gremlin-javascript/test/cucumber/gremlin.js +++ b/gremlin-javascript/src/main/javascript/gremlin-javascript/test/cucumber/gremlin.js @@@ -1889,8 -2036,6 +2038,6 @@@ const gremlins = g_VX1X_out_out_out_tree: [function({g}) { return g.V().out().out().out().tree() }], g_VX1X_outE_inV_bothE_otherV_tree: [function({g, vid1}) { return g.V(vid1).outE().inV().bothE().otherV().tree() }], g_VX1X_outE_inV_bothE_otherV_tree_byXnameX_byXlabelX: [function({g, vid1}) { return g.V(vid1).outE().inV().bothE().otherV().tree().by("name").by(T.label) }], - g_injectXUUIDX47af10b_58cc_4372_a567_0f02b2f3d479XX: [function({g}) { return g.inject("f47af10b-58cc-4372-a567-0f02b2f3d479") }], - g_injectXUUIDXXX: [function({g}) { return g.inject(uuid.v4()) }], } -exports.gremlin = gremlins +export const gremlin = gremlins diff --cc gremlin-javascript/src/main/javascript/gremlin-javascript/test/unit/graphbinary/AnySerializer-test.js index 24bcae2ed5,f3e77bff02..bcd323ac96 --- 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 @@@ -157,27 -158,27 +157,27 @@@ describe('GraphBinary.AnySerializer', ( }, // EnumSerializer (actually represents different enum like types) - { v: new t.EnumValue('Barrier', 'normSack'), + { v: new EnumValue('Barrier', 'normSack'), b: [ DataType.BARRIER,0x00, DataType.STRING,0x00, 0x00,0x00,0x00,0x08, ...from('normSack') ] }, - { v: new t.EnumValue('Cardinality', 'single'), + { v: new EnumValue('Cardinality', 'single'), b: [ DataType.CARDINALITY,0x00, DataType.STRING,0x00, 0x00,0x00,0x00,0x06, ...from('single') ] }, - { v: new t.EnumValue('Column', 'keys'), + { v: new EnumValue('Column', 'keys'), b: [ DataType.COLUMN,0x00, DataType.STRING,0x00, 0x00,0x00,0x00,0x04, ...from('keys') ] }, - { v: new t.EnumValue('Direction', 'OUT'), + { v: new EnumValue('Direction', 'OUT'), b: [ DataType.DIRECTION,0x00, DataType.STRING,0x00, 0x00,0x00,0x00,0x03, ...from('OUT') ] }, - { v: new t.EnumValue('DT', 'minute'), + { v: new EnumValue('DT', 'minute'), b: [ DataType.DT,0x00, DataType.STRING,0x00, 0x00,0x00,0x00,0x06, ...from('minute') ] }, - { v: new t.EnumValue('GType', 'BYTE'), - b: [ DataType.GTYPE,0x00, DataType.STRING,0x00, 0x00,0x00,0x00,0x04, ...from('BYTE') ] - }, - { v: new t.EnumValue('Merge', 'onMatch'), + { v: new EnumValue('Merge', 'onMatch'), b: [ DataType.MERGE,0x00, DataType.STRING,0x00, 0x00,0x00,0x00,0x07, ...from('onMatch') ] }, - { v: new t.EnumValue('N', 'byte'), - b: [ DataType.N,0x00, DataType.STRING,0x00, 0x00,0x00,0x00,0x04, ...from('byte') ] ++ { v: new EnumValue('GType', 'BYTE'), ++ b: [ DataType.GTYPE,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') ] }, @@@ -513,19 -514,19 +513,19 @@@ // DT { v:null, b:[0x2f,0x01] }, - { v:new t.EnumValue('DT','minute'), b:[0x2f,0x00, 0x03,0x00, 0x00,0x00,0x00,0x06, ...from('minute')] }, + { v:new EnumValue('DT','minute'), b:[0x2f,0x00, 0x03,0x00, 0x00,0x00,0x00,0x06, ...from('minute')] }, + // GType + { v:null, b:[0x30,0x01] }, - { v:new t.EnumValue('GType','BYTE'), b:[0x30,0x00, 0x03,0x00, 0x00,0x00,0x00,0x04, ...from('BYTE')] }, ++ { v:new EnumValue('GType','BYTE'), b:[0x30,0x00, 0x03,0x00, 0x00,0x00,0x00,0x04, ...from('BYTE')] }, + // MERGE { v:null, b:[0x2e,0x01] }, - { v:new t.EnumValue('Merge','onCreate'), b:[0x2e,0x00, 0x03,0x00, 0x00,0x00,0x00,0x08, ...from('onCreate')] }, + { v:new EnumValue('Merge','onCreate'), b:[0x2e,0x00, 0x03,0x00, 0x00,0x00,0x00,0x08, ...from('onCreate')] }, - // N - { v:null, b:[0x30,0x01] }, - { v:new t.EnumValue('N','byte'), b:[0x30,0x00, 0x03,0x00, 0x00,0x00,0x00,0x04, ...from('byte')] }, - // OPERATOR { v:null, b:[0x19,0x01] }, - { v:new t.EnumValue('Operator','addAll'), b:[0x19,0x00, 0x03,0x00, 0x00,0x00,0x00,0x06, ...from('addAll')] }, + { v:new EnumValue('Operator','addAll'), b:[0x19,0x00, 0x03,0x00, 0x00,0x00,0x00,0x06, ...from('addAll')] }, // ORDER { v:null, b:[0x1A,0x01] }, diff --cc gremlin-python/docker-compose.yml index 7c367138eb,8b6117a168..28bb770e89 --- a/gremlin-python/docker-compose.yml +++ b/gremlin-python/docker-compose.yml @@@ -47,24 -50,29 +47,24 @@@ services volumes: - ${BUILD_DIR:-./src/main/python}:/python_app - ../gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features:/python_app/gremlin-test/features + - ../gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/structure/io/graphbinary:/python_app/gremlin-test/graphbinary + - ../gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/structure/io/graphson:/python_app/gremlin-test/graphson - ../docker/gremlin-test-server:/python_app/gremlin-test-server - - ../gremlin-tools/gremlin-socket-server/conf:/python_app/gremlin-socket-server/conf/ - environment: - DEBIAN_FRONTEND=noninteractive - - KRB5_CONFIG=./gremlin-test-server/krb5.conf - - KRB5CCNAME=./test-tkt.cc - - GREMLIN_SERVER_URL=ws://gremlin-server-test-python:{}/gremlin - - GREMLIN_SERVER_BASIC_AUTH_URL=wss://gremlin-server-test-python:{}/gremlin - - GREMLIN_SERVER_URL_HTTP=http://gremlin-server-test-python:{}/ - - GREMLIN_SERVER_BASIC_AUTH_URL_HTTP=https://gremlin-server-test-python:{}/ - - KRB_HOSTNAME=${KRB_HOSTNAME:-gremlin-server-test} - - GREMLIN_SOCKET_SERVER_URL=ws://gremlin-socket-server-python:{}/gremlin - - GREMLIN_SOCKET_SERVER_CONFIG_PATH=/python_app/gremlin-socket-server/conf/test-ws-gremlin.yaml + - GREMLIN_SERVER_URL=http://gremlin-server-test-python:{}/gremlin + - GREMLIN_SERVER_BASIC_AUTH_URL=https://gremlin-server-test-python:{}/gremlin + - IO_TEST_DIRECTORY=/python_app/gremlin-test/graphbinary/ + - IO_TEST_DIRECTORY_GRAPHSON=/python_app/gremlin-test/graphson/ working_dir: /python_app command: > - bash -c "apt-get update && apt-get -y install libkrb5-dev krb5-user - && echo 'password' | kinit stephen - && klist - && pip install .[test,kerberos] + bash -c "pip install .[test,kerberos] && pytest - && radish -f dots -e -t -b ./radish ./gremlin-test --user-data='serializer=application/vnd.graphbinary-v4.0' --user-data='bulked=true' - && radish -f dots -e -t -b ./radish ./gremlin-test --user-data='serializer=application/vnd.graphbinary-v4.0' --user-data='parameterize=true' - && radish -f dots -e -t -b ./radish ./gremlin-test --user-data='serializer=application/vnd.graphbinary-v4.0' - && radish -f dots -e -t -b ./radish ./gremlin-test --user-data='serializer=application/vnd.gremlin-v4.0+json' --user-data='parameterize=true' - && radish -f dots -e -t -b ./radish ./gremlin-test --user-data='serializer=application/vnd.gremlin-v4.0+json'; - && radish -f dots -e -t -b ./radish ./gremlin-test --tags='not DataBigDecimal' --user-data='serializer=application/vnd.gremlin-v3.0+json' - && radish -f dots -e -t -b ./radish ./gremlin-test --tags='not DataBigDecimal' --user-data='serializer=application/vnd.graphbinary-v1.0'; ++ && radish -f dots -e -t -b ./radish ./gremlin-test --tags='not DataBigDecimal' --user-data='serializer=application/vnd.graphbinary-v4.0' --user-data='bulked=true' ++ && radish -f dots -e -t -b ./radish ./gremlin-test --tags='not DataBigDecimal' --user-data='serializer=application/vnd.graphbinary-v4.0' --user-data='parameterize=true' ++ && radish -f dots -e -t -b ./radish ./gremlin-test --tags='not DataBigDecimal' --user-data='serializer=application/vnd.graphbinary-v4.0' ++ && radish -f dots -e -t -b ./radish ./gremlin-test --tags='not DataBigDecimal' --user-data='serializer=application/vnd.gremlin-v4.0+json' --user-data='parameterize=true' ++ && radish -f dots -e -t -b ./radish ./gremlin-test --tags='not DataBigDecimal' --user-data='serializer=application/vnd.gremlin-v4.0+json'; EXIT_CODE=$$?; chown -R `stat -c "%u:%g" .` .; exit $$EXIT_CODE" depends_on: gremlin-server-test-python: diff --cc gremlin-python/src/main/python/gremlin_python/structure/io/graphbinaryV4.py index dda7c0845d,4bfa71e43a..50a5c24a3f --- a/gremlin-python/src/main/python/gremlin_python/structure/io/graphbinaryV4.py +++ b/gremlin-python/src/main/python/gremlin_python/structure/io/graphbinaryV4.py @@@ -16,22 -16,29 +16,22 @@@ KIND, either express or implied. See t specific language governing permissions and limitations under the License. """ - -import datetime import calendar -import uuid -import math import io +import logging +import math import struct +import uuid from collections import OrderedDict -import logging - +from datetime import datetime, timedelta, timezone from struct import pack, unpack + from aenum import Enum - from gremlin_python.process.traversal import Direction, T, Merge, N -from datetime import timedelta -from gremlin_python import statics -from gremlin_python.statics import FloatType, BigDecimal, FunctionType, ShortType, IntType, LongType, BigIntType, \ - TypeType, DictType, ListType, SetType, SingleByte, ByteBufferType, GremlinType, \ - SingleChar -from gremlin_python.process.traversal import Barrier, Binding, Bytecode, Cardinality, Column, Direction, DT, GType, \ - Merge,Operator, Order, Pick, Pop, P, Scope, TextP, Traversal, Traverser, \ - TraversalStrategy, T -from gremlin_python.process.graph_traversal import GraphTraversal ++from gremlin_python.process.traversal import Direction, T, Merge, GType +from gremlin_python.statics import FloatType, BigDecimal, ShortType, IntType, LongType, BigIntType, \ + DictType, SetType, SingleByte, SingleChar from gremlin_python.structure.graph import Graph, Edge, Property, Vertex, VertexProperty, Path -from gremlin_python.structure.io.util import HashableDict, SymbolUtil +from gremlin_python.structure.io.util import HashableDict, SymbolUtil, Marker log = logging.getLogger(__name__) @@@ -66,14 -87,33 +66,14 @@@ class DataType(Enum) bigdecimal = 0x22 biginteger = 0x23 byte = 0x24 - bytebuffer = 0x25 + binary = 0x25 short = 0x26 boolean = 0x27 - textp = 0x28 - traversalstrategy = 0x29 - bulkset = 0x2a tree = 0x2b # not supported - no tree object in Python yet - n = 0x30 - metrics = 0x2c - traversalmetrics = 0x2d - merge = 0x2e - dt = 0x2f + gtype = 0x30 char = 0x80 duration = 0x81 - inetaddress = 0x82 # todo - instant = 0x83 # todo - localdate = 0x84 # todo - localdatetime = 0x85 # todo - localtime = 0x86 # todo - monthday = 0x87 # todo - offsetdatetime = 0x88 - offsettime = 0x89 # todo - period = 0x8a # todo - year = 0x8b # todo - yearmonth = 0x8c # todo - zonedatetime = 0x8d # todo - zoneoffset = 0x8e # todo + marker = 0xfd custom = 0x00 # todo @@@ -747,11 -978,43 +747,11 @@@ class MergeIO(_EnumIO) python_type = Merge - class NIO(_EnumIO): - graphbinary_type = DataType.n - python_type = N -class ScopeIO(_EnumIO): - graphbinary_type = DataType.scope - python_type = Scope - - -class TIO(_EnumIO): - graphbinary_type = DataType.t - python_type = T - - + class GTYPEIO(_EnumIO): + graphbinary_type = DataType.gtype + python_type = GType -class TraverserIO(_GraphBinaryTypeIO): - graphbinary_type = DataType.traverser - python_type = Traverser - - @classmethod - def dictify(cls, obj, writer, to_extend, as_value=False, nullable=True): - cls.prefix_bytes(cls.graphbinary_type, as_value, nullable, to_extend) - to_extend.extend(int64_pack(obj.bulk)) - writer.to_dict(obj.object, to_extend) - return to_extend - - @classmethod - def objectify(cls, buff, reader, nullable=True): - return cls.is_null(buff, reader, cls._read_traverser, nullable) - - @classmethod - def _read_traverser(cls, b, r): - bulk = int64_unpack(b.read(8)) - obj = r.read_object(b) - return Traverser(obj, bulk=bulk) - - class ByteIO(_GraphBinaryTypeIO): python_type = SingleByte graphbinary_type = DataType.byte diff --cc gremlin-python/src/main/python/tests/driver/test_driver_remote_connection.py index ef59ffd6f6,90250c3837..27cc98f574 --- 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 @@@ -18,12 -18,15 +18,13 @@@ # import os +import pytest + from gremlin_python import statics + from gremlin_python.driver import serializer from gremlin_python.driver.driver_remote_connection import DriverRemoteConnection -from gremlin_python.driver.protocol import GremlinServerError -from gremlin_python.statics import long, bigint -from gremlin_python.process.traversal import Traverser, Operator, Barrier -from gremlin_python.process.traversal import TraversalStrategy -from gremlin_python.process.traversal import Bindings -from gremlin_python.process.traversal import P, Order, T +from gremlin_python.statics import long +from gremlin_python.process.traversal import TraversalStrategy, P, Order, T, DT, GValue, Cardinality from gremlin_python.process.graph_traversal import __ from gremlin_python.process.anonymous_traversal import traversal from gremlin_python.structure.graph import Vertex diff --cc neo4j-gremlin/src/test/java/org/apache/tinkerpop/gremlin/neo4j/Neo4jGraphFeatureTest.java index e03987a1d3,c88dd84ee2..aff9188e42 --- a/neo4j-gremlin/src/test/java/org/apache/tinkerpop/gremlin/neo4j/Neo4jGraphFeatureTest.java +++ b/neo4j-gremlin/src/test/java/org/apache/tinkerpop/gremlin/neo4j/Neo4jGraphFeatureTest.java @@@ -50,7 -50,8 +50,8 @@@ import static org.apache.tinkerpop.grem @RunWith(Cucumber.class) @CucumberOptions( - tags = "not @MultiProperties and not @MetaProperties and not @GraphComputerOnly and " + + tags = "not @MultiProperties and not @MetaProperties and not @GraphComputerOnly and not @StepHasId and " + + "not @DataDateTime and not @DataList and not @DataMap and not @DataSet and not @DataUUID and " + "not @AllowNullPropertyValues and not @UserSuppliedVertexPropertyIds and not @UserSuppliedEdgeIds and " + "not @UserSuppliedVertexIds and not @TinkerServiceRegistry and not @InsertionOrderingRequired and not @StepHasId", //TODO:: can we include hasId? glue = { "org.apache.tinkerpop.gremlin.features" }, diff --cc tinkergraph-gremlin/src/test/java/org/apache/tinkerpop/gremlin/tinkergraph/structure/TinkerGraphPlayTest.java index c086813b7c,1d5436ea28..837994a574 --- a/tinkergraph-gremlin/src/test/java/org/apache/tinkerpop/gremlin/tinkergraph/structure/TinkerGraphPlayTest.java +++ b/tinkergraph-gremlin/src/test/java/org/apache/tinkerpop/gremlin/tinkergraph/structure/TinkerGraphPlayTest.java @@@ -18,12 -18,9 +18,13 @@@ */ package org.apache.tinkerpop.gremlin.tinkergraph.structure; +import org.apache.tinkerpop.gremlin.jsr223.GremlinLangScriptEngine; +import org.apache.tinkerpop.gremlin.jsr223.VariableResolverCustomizer; +import org.apache.tinkerpop.gremlin.language.grammar.VariableResolver; import org.apache.tinkerpop.gremlin.process.computer.Computer; + import org.apache.tinkerpop.gremlin.process.traversal.GType; import org.apache.tinkerpop.gremlin.process.traversal.P; +import org.apache.tinkerpop.gremlin.process.traversal.Scope; import org.apache.tinkerpop.gremlin.process.traversal.Traversal; import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal; import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversalSource;
