adapter = predicate::test;
+ return new P<>(adapter, value);
+ }
+}
diff --git a/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/opencypher/CypherOpProcessor.java b/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/opencypher/CypherOpProcessor.java
index dfad9b9594..2bcfa7ec83 100644
--- a/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/opencypher/CypherOpProcessor.java
+++ b/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/opencypher/CypherOpProcessor.java
@@ -19,7 +19,7 @@
import static java.util.Collections.emptyMap;
import static java.util.Collections.singletonList;
import static java.util.Optional.empty;
-import static org.apache.tinkerpop.gremlin.driver.message.ResponseStatusCode.SERVER_ERROR;
+import static org.apache.tinkerpop.gremlin.util.message.ResponseStatusCode.SERVER_ERROR;
import static org.opencypher.gremlin.translation.StatementOption.EXPLAIN;
import static org.slf4j.LoggerFactory.getLogger;
@@ -33,10 +33,6 @@
import java.util.concurrent.FutureTask;
import java.util.concurrent.TimeUnit;
-import org.apache.tinkerpop.gremlin.driver.Tokens;
-import org.apache.tinkerpop.gremlin.driver.message.RequestMessage;
-import org.apache.tinkerpop.gremlin.driver.message.ResponseMessage;
-import org.apache.tinkerpop.gremlin.driver.message.ResponseStatusCode;
import org.apache.tinkerpop.gremlin.process.traversal.P;
import org.apache.tinkerpop.gremlin.process.traversal.TraversalSource;
import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.DefaultGraphTraversal;
@@ -49,12 +45,18 @@
import org.apache.tinkerpop.gremlin.server.op.AbstractEvalOpProcessor;
import org.apache.tinkerpop.gremlin.server.op.OpProcessorException;
import org.apache.tinkerpop.gremlin.structure.Graph;
+import org.apache.tinkerpop.gremlin.util.Tokens;
import org.apache.tinkerpop.gremlin.util.function.ThrowingConsumer;
+import org.apache.tinkerpop.gremlin.util.message.RequestMessage;
+import org.apache.tinkerpop.gremlin.util.message.ResponseMessage;
+import org.apache.tinkerpop.gremlin.util.message.ResponseStatusCode;
import org.opencypher.gremlin.translation.CypherAst;
import org.opencypher.gremlin.translation.groovy.GroovyPredicate;
import org.opencypher.gremlin.translation.ir.TranslationWriter;
import org.opencypher.gremlin.translation.ir.model.GremlinStep;
import org.opencypher.gremlin.translation.translator.Translator;
+import org.opencypher.gremlin.translation.traversal.TraversalGremlinBindings;
+import org.opencypher.gremlin.translation.traversal.TraversalGremlinSteps;
import org.opencypher.gremlin.traversal.ParameterNormalizer;
import org.opencypher.gremlin.traversal.ProcedureContext;
import org.opencypher.gremlin.traversal.ReturnNormalizer;
@@ -66,7 +68,7 @@
/**
* Description of the modifications:
*
- * 1) Changed the method signature to adopt the gremlin-server 3.5.1.
+ * 1) Changed the method signature to adopt the gremlin-server Context API.
*
* public Optional> selectOther(RequestMessage requestMessage)
* -->
@@ -139,7 +141,9 @@ private void evalCypher(Context context) throws OpProcessorException {
.build(translatorDefinition);
Translator traversalTranslator = Translator.builder()
- .traversal(g)
+ .custom(new TraversalGremlinSteps(g),
+ new CypherGremlinPredicates(),
+ new TraversalGremlinBindings())
.build(translatorDefinition);
Seq ir = ast.translate(strTranslator.flavor(),
diff --git a/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/opencypher/CypherPlugin.java b/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/opencypher/CypherPlugin.java
index 6d7899dd19..fef7c73bdc 100644
--- a/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/opencypher/CypherPlugin.java
+++ b/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/opencypher/CypherPlugin.java
@@ -40,15 +40,14 @@
import org.apache.tinkerpop.gremlin.jsr223.GremlinPlugin;
import org.apache.tinkerpop.gremlin.jsr223.ImportCustomizer;
import org.opencypher.gremlin.traversal.CustomFunctions;
-import org.opencypher.gremlin.traversal.CustomPredicate;
public class CypherPlugin implements GremlinPlugin {
private static final ImportCustomizer IMPORTS =
DefaultImportCustomizer.build()
- .addClassImports(CustomPredicate.class)
+ .addClassImports(CypherGremlinPredicates.class)
.addMethodImports(
- getDeclaredPublicMethods(CustomPredicate.class))
+ getDeclaredPublicMethods(CypherGremlinPredicates.class))
.addClassImports(CustomFunctions.class)
.addMethodImports(
getDeclaredPublicMethods(CustomFunctions.class))
@@ -57,7 +56,8 @@ public class CypherPlugin implements GremlinPlugin {
private static List getDeclaredPublicMethods(Class klass) {
Method[] declaredMethods = klass.getDeclaredMethods();
return Stream.of(declaredMethods)
- .filter(method -> Modifier.isPublic(method.getModifiers()))
+ .filter(method -> Modifier.isPublic(method.getModifiers()) &&
+ Modifier.isStatic(method.getModifiers()))
.collect(Collectors.toList());
}
diff --git a/hugegraph-server/hugegraph-core/pom.xml b/hugegraph-server/hugegraph-core/pom.xml
index 4e03478a53..70b7a125af 100644
--- a/hugegraph-server/hugegraph-core/pom.xml
+++ b/hugegraph-server/hugegraph-core/pom.xml
@@ -49,17 +49,14 @@
com.fasterxml.jackson.core
jackson-databind
- 2.13.2
com.fasterxml.jackson.core
jackson-core
- 2.13.2
com.fasterxml.jackson.core
jackson-annotations
- 2.15.2
io.fabric8
diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/query/Condition.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/query/Condition.java
index e77f2f0b1e..d956a8ace7 100644
--- a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/query/Condition.java
+++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/query/Condition.java
@@ -25,7 +25,6 @@
import java.util.Objects;
import java.util.Set;
import java.util.function.BiFunction;
-import java.util.function.BiPredicate;
import org.apache.commons.lang.ArrayUtils;
import org.apache.hugegraph.backend.id.Id;
@@ -37,6 +36,7 @@
import org.apache.hugegraph.util.DateUtil;
import org.apache.hugegraph.util.E;
import org.apache.hugegraph.util.NumericUtil;
+import org.apache.tinkerpop.gremlin.process.traversal.PBiPredicate;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableSet;
@@ -51,7 +51,7 @@ public enum ConditionType {
NOT
}
- public enum RelationType implements BiPredicate {
+ public enum RelationType implements PBiPredicate {
EQ("==", RelationType::equals),
@@ -165,6 +165,11 @@ public String string() {
return this.operator;
}
+ @Override
+ public String getPredicateName() {
+ return this.operator;
+ }
+
/**
* Determine two values of any type equal
*
diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/io/HugeGraphSONModule.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/io/HugeGraphSONModule.java
index ddb7c1a981..c7758989fe 100644
--- a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/io/HugeGraphSONModule.java
+++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/io/HugeGraphSONModule.java
@@ -57,7 +57,6 @@
import org.apache.hugegraph.util.SafeDateUtil;
import org.apache.tinkerpop.gremlin.process.traversal.Path;
import org.apache.tinkerpop.gremlin.process.traversal.step.util.Tree;
-import org.apache.tinkerpop.gremlin.structure.Element;
import org.apache.tinkerpop.gremlin.structure.io.graphson.GraphSONIo;
import org.apache.tinkerpop.gremlin.structure.io.graphson.GraphSONTokens;
import org.apache.tinkerpop.gremlin.structure.io.graphson.TinkerPopJacksonModule;
@@ -103,12 +102,14 @@ public class HugeGraphSONModule extends TinkerPopJacksonModule {
TYPE_DEFINITIONS = new ConcurrentHashMap<>();
TYPE_DEFINITIONS.put(Optional.class, "Optional");
+ TYPE_DEFINITIONS.put(File.class, "File");
TYPE_DEFINITIONS.put(Date.class, "Date");
TYPE_DEFINITIONS.put(UUID.class, "UUID");
// HugeGraph id serializer
TYPE_DEFINITIONS.put(StringId.class, "StringId");
TYPE_DEFINITIONS.put(LongId.class, "LongId");
+ TYPE_DEFINITIONS.put(UuidId.class, "UuidId");
TYPE_DEFINITIONS.put(EdgeId.class, "EdgeId");
// HugeGraph schema serializer
@@ -171,6 +172,7 @@ public static void registerCommonSerializers(SimpleModule module) {
module.addSerializer(Shard.class, new ShardSerializer());
module.addSerializer(File.class, new FileSerializer());
+ module.addDeserializer(File.class, new FileDeserializer());
boolean useTimestamp = false;
module.addSerializer(Date.class,
@@ -222,8 +224,14 @@ public static void registerGraphSerializers(SimpleModule module) {
*/
module.addSerializer(HugeVertex.class, new HugeVertexSerializer());
module.addSerializer(HugeEdge.class, new HugeEdgeSerializer());
+ }
+ public static void registerTraversalSerializers(SimpleModule module) {
module.addSerializer(Path.class, new PathSerializer());
+ registerLegacyTreeSerializer(module);
+ }
+
+ public static void registerLegacyTreeSerializer(SimpleModule module) {
module.addSerializer(Tree.class, new TreeSerializer());
}
@@ -641,8 +649,8 @@ public T deserialize(JsonParser jsonParser,
String idValue = ctxt.readValue(jsonParser, String.class);
return (T) IdGenerator.of(idValue);
} else if (clazz.equals(UuidId.class)) {
- UUID idValue = ctxt.readValue(jsonParser, UUID.class);
- return (T) IdGenerator.of(idValue);
+ String idValue = ctxt.readValue(jsonParser, String.class);
+ return (T) IdGenerator.of(UUID.fromString(idValue));
} else {
assert clazz.equals(EdgeId.class);
String idValue = ctxt.readValue(jsonParser, String.class);
@@ -883,9 +891,8 @@ public TreeSerializer() {
public void serialize(Tree tree, JsonGenerator jsonGenerator,
SerializerProvider provider) throws IOException {
jsonGenerator.writeStartArray();
- @SuppressWarnings("unchecked")
- Set> set = tree.entrySet();
- for (Map.Entry entry : set) {
+ for (Object item : tree.entrySet()) {
+ Map.Entry entry = (Map.Entry) item;
jsonGenerator.writeStartObject();
jsonGenerator.writeObjectField(GraphSONTokens.KEY,
entry.getKey());
@@ -924,9 +931,65 @@ public FileSerializer() {
public void serialize(File file, JsonGenerator jsonGenerator,
SerializerProvider provider) throws IOException {
jsonGenerator.writeStartObject();
- jsonGenerator.writeStringField("file", file.getName());
+ this.writeFields(file, jsonGenerator);
jsonGenerator.writeEndObject();
}
+
+ @Override
+ public void serializeWithType(File file,
+ JsonGenerator jsonGenerator,
+ SerializerProvider provider,
+ TypeSerializer typeSer)
+ throws IOException {
+ WritableTypeId typeId = typeSer.typeId(
+ file, JsonToken.VALUE_EMBEDDED_OBJECT);
+ typeSer.writeTypePrefix(jsonGenerator, typeId);
+ this.serialize(file, jsonGenerator, provider);
+ typeSer.writeTypeSuffix(jsonGenerator, typeId);
+ }
+
+ private void writeFields(File file, JsonGenerator jsonGenerator)
+ throws IOException {
+ jsonGenerator.writeStringField("file", file.getName());
+ }
+ }
+
+ private static class FileDeserializer extends StdDeserializer {
+
+ public FileDeserializer() {
+ super(File.class);
+ }
+
+ @Override
+ public File deserialize(JsonParser jsonParser,
+ DeserializationContext ctxt)
+ throws IOException {
+ JsonToken token = jsonParser.currentToken();
+ if (token == null) {
+ token = jsonParser.nextToken();
+ }
+ if (token == JsonToken.VALUE_STRING) {
+ return new File(jsonParser.getValueAsString());
+ }
+ if (token == JsonToken.START_OBJECT) {
+ String file = null;
+ while (jsonParser.nextToken() != JsonToken.END_OBJECT) {
+ String field = jsonParser.currentName();
+ jsonParser.nextToken();
+ if ("file".equals(field)) {
+ file = jsonParser.getValueAsString();
+ } else {
+ jsonParser.skipChildren();
+ }
+ }
+ if (file == null) {
+ return (File) ctxt.handleUnexpectedToken(File.class,
+ jsonParser);
+ }
+ return new File(file);
+ }
+ return (File) ctxt.handleUnexpectedToken(File.class, jsonParser);
+ }
}
private static class BlobSerializer extends StdSerializer {
diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/io/HugeGraphSONV1MessageIoRegistry.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/io/HugeGraphSONV1MessageIoRegistry.java
new file mode 100644
index 0000000000..9c79766ff4
--- /dev/null
+++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/io/HugeGraphSONV1MessageIoRegistry.java
@@ -0,0 +1,42 @@
+/*
+ * 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.hugegraph.io;
+
+import org.apache.tinkerpop.gremlin.structure.io.AbstractIoRegistry;
+import org.apache.tinkerpop.gremlin.structure.io.graphson.GraphSONIo;
+import org.apache.tinkerpop.shaded.jackson.databind.module.SimpleModule;
+
+/**
+ * Legacy Tree response shape for the untyped GraphSON V1 message serializer.
+ * Standard graph IO and typed message serializers use HugeGraphIoRegistry.
+ */
+public final class HugeGraphSONV1MessageIoRegistry extends AbstractIoRegistry {
+
+ private static final HugeGraphSONV1MessageIoRegistry INSTANCE =
+ new HugeGraphSONV1MessageIoRegistry();
+
+ public static HugeGraphSONV1MessageIoRegistry instance() {
+ return INSTANCE;
+ }
+
+ private HugeGraphSONV1MessageIoRegistry() {
+ SimpleModule module = new SimpleModule("hugegraph-v1-message");
+ HugeGraphSONModule.registerLegacyTreeSerializer(module);
+ this.register(GraphSONIo.class, null, module);
+ }
+}
diff --git a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/io/HugeGraphTypeSerializerRegistryBuilder.java b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/io/HugeGraphTypeSerializerRegistryBuilder.java
new file mode 100644
index 0000000000..28cb79bd74
--- /dev/null
+++ b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/io/HugeGraphTypeSerializerRegistryBuilder.java
@@ -0,0 +1,206 @@
+/*
+ * 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.hugegraph.io;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.function.Function;
+
+import org.apache.hugegraph.backend.id.Id;
+import org.apache.hugegraph.backend.store.Shard;
+import org.apache.hugegraph.schema.EdgeLabel;
+import org.apache.hugegraph.schema.IndexLabel;
+import org.apache.hugegraph.schema.PropertyKey;
+import org.apache.hugegraph.schema.SchemaElement;
+import org.apache.hugegraph.schema.SchemaManager;
+import org.apache.hugegraph.schema.VertexLabel;
+import org.apache.hugegraph.type.define.HugeKeys;
+import org.apache.hugegraph.util.Blob;
+import org.apache.tinkerpop.gremlin.structure.io.Buffer;
+import org.apache.tinkerpop.gremlin.structure.io.binary.GraphBinaryReader;
+import org.apache.tinkerpop.gremlin.structure.io.binary.GraphBinaryWriter;
+import org.apache.tinkerpop.gremlin.structure.io.binary.TypeSerializer;
+import org.apache.tinkerpop.gremlin.structure.io.binary.TypeSerializerRegistry;
+import org.apache.tinkerpop.gremlin.structure.io.binary.types.SimpleTypeSerializer;
+import org.apache.tinkerpop.gremlin.structure.io.binary.types.TransformSerializer;
+
+import groovy.lang.GString;
+
+public final class HugeGraphTypeSerializerRegistryBuilder
+ extends TypeSerializerRegistry.Builder {
+
+ private static final TypeSerializer ID_TRANSFORM_SERIALIZER =
+ new WireTransformSerializer<>(Id::asObject);
+ private static final TypeSerializer BLOB_TRANSFORM_SERIALIZER =
+ new WireTransformSerializer<>(blob -> ByteBuffer.wrap(blob.bytes()));
+ private static final TypeSerializer SHARD_TRANSFORM_SERIALIZER =
+ new WireTransformSerializer<>(HugeGraphTypeSerializerRegistryBuilder::shardMap);
+ private static final TypeSerializer SCHEMA_TRANSFORM_SERIALIZER =
+ new WireTransformSerializer<>(HugeGraphTypeSerializerRegistryBuilder::schemaMap);
+ private static final TypeSerializer SCHEMA_MANAGER_TRANSFORM_SERIALIZER =
+ new WireTransformSerializer<>(HugeGraphTypeSerializerRegistryBuilder::schemaManagerMap);
+ private static final TypeSerializer> ENUM_TRANSFORM_SERIALIZER =
+ new WireTransformSerializer<>(Enum::name);
+
+ private static final TypeSerializer> OPTIONAL_TRANSFORM_SERIALIZER =
+ new WireTransformSerializer<>(optional -> optional.orElse(null));
+ private static final TypeSerializer FILE_TRANSFORM_SERIALIZER =
+ new WireTransformSerializer<>(file -> Map.of("file", file.getName()));
+
+ private static final TypeSerializer GSTRING_TRANSFORM_SERIALIZER =
+ new WireTransformSerializer<>(GString::toString);
+
+ public HugeGraphTypeSerializerRegistryBuilder() {
+ this.withFallbackResolver(type -> {
+ if (Id.class.isAssignableFrom(type)) {
+ return ID_TRANSFORM_SERIALIZER;
+ }
+ if (Blob.class.isAssignableFrom(type)) {
+ return BLOB_TRANSFORM_SERIALIZER;
+ }
+ if (Shard.class.isAssignableFrom(type)) {
+ return SHARD_TRANSFORM_SERIALIZER;
+ }
+ if (SchemaElement.class.isAssignableFrom(type)) {
+ return SCHEMA_TRANSFORM_SERIALIZER;
+ }
+ if (SchemaManager.class.isAssignableFrom(type)) {
+ return SCHEMA_MANAGER_TRANSFORM_SERIALIZER;
+ }
+ if (isHugeGraphEnum(type)) {
+ return ENUM_TRANSFORM_SERIALIZER;
+ }
+ if (Optional.class.isAssignableFrom(type)) {
+ return OPTIONAL_TRANSFORM_SERIALIZER;
+ }
+ if (File.class.isAssignableFrom(type)) {
+ return FILE_TRANSFORM_SERIALIZER;
+ }
+ if (GString.class.isAssignableFrom(type)) {
+ return GSTRING_TRANSFORM_SERIALIZER;
+ }
+ return null;
+ });
+ }
+
+ private static boolean isHugeGraphEnum(Class type) {
+ // Scope the fallback to HugeGraph; native TinkerPop enums keep their serializers.
+ return Enum.class.isAssignableFrom(type) &&
+ type.getName().startsWith("org.apache.hugegraph.");
+ }
+
+ private static Map shardMap(Shard shard) {
+ // Match the existing GraphSON contract, including open range boundaries.
+ Map result = new LinkedHashMap<>();
+ result.put("start", shard.start());
+ result.put("end", shard.end());
+ result.put("length", shard.length());
+ return result;
+ }
+
+ private static Map schemaManagerMap(SchemaManager schema) {
+ Map result = new LinkedHashMap<>();
+ result.put("propertykeys", schemaValue(schema.getPropertyKeys()));
+ result.put("vertexlabels", schemaValue(schema.getVertexLabels()));
+ result.put("edgelabels", schemaValue(schema.getEdgeLabels()));
+ result.put("indexlabels", schemaValue(schema.getIndexLabels()));
+ return result;
+ }
+
+ private static Map schemaMap(SchemaElement schema) {
+ // Use the same field names and values as the existing GraphSON schema API.
+ GraphSONSchemaSerializer serializer = new GraphSONSchemaSerializer();
+ Map fields;
+ if (schema instanceof PropertyKey) {
+ fields = serializer.writePropertyKey((PropertyKey) schema);
+ } else if (schema instanceof VertexLabel) {
+ fields = serializer.writeVertexLabel((VertexLabel) schema);
+ } else if (schema instanceof EdgeLabel) {
+ fields = serializer.writeEdgeLabel((EdgeLabel) schema);
+ } else if (schema instanceof IndexLabel) {
+ fields = serializer.writeIndexLabel((IndexLabel) schema);
+ } else {
+ throw new IllegalArgumentException("Unsupported schema type: " + schema.getClass());
+ }
+ Map result = new LinkedHashMap<>();
+ fields.forEach((key, value) -> result.put(key.string(), schemaValue(value)));
+ return result;
+ }
+
+ private static Object schemaValue(Object value) {
+ if (value instanceof Enum && isHugeGraphEnum(value.getClass())) {
+ return ((Enum) value).name();
+ }
+ if (value instanceof SchemaElement) {
+ return schemaMap((SchemaElement) value);
+ }
+ if (value instanceof SchemaManager) {
+ return schemaManagerMap((SchemaManager) value);
+ }
+ if (value instanceof Map) {
+ Map result = new LinkedHashMap<>();
+ ((Map) value).forEach((key, item) -> result.put(schemaValue(key), schemaValue(item)));
+ return result;
+ }
+ if (value instanceof Collection) {
+ List
- org.apache.tinkerpop
- gremlin-groovy-test
- 3.2.11
+ com.google.inject
+ guice
+ 4.2.3
+ provided
org.glassfish.jersey.test-framework.providers
@@ -196,6 +197,8 @@
**/ProcessStandardTest.java
+ **/HugeGraphFeatureTest.java
+ **/HugeGraphProviderLifecycleTest.java