fix(server): preserve count and Cypher transport results

Author: contrueCT

docs/upgrade-tinkerpop-3.8.md

@@ -78,6 +78,16 @@ registry limited to untyped V1 messages. Standard graph-file IO and typed
 GraphSON serializers keep `HugeGraphIoRegistry` alone and use the TinkerPop
 Tree format for their negotiated version.
 
+Groovy interpolated strings (`GString`, including subclasses) return as standard
+strings over GraphBinary, including inside lists and maps. For example,
+`def value = 42; "r3-value:${value}"` returns `"r3-value:42"`. The untyped GraphSON
+path retains the legacy GString bean map with its `values` and `strings` fields.
+
+Cypher extension predicates use the current TinkerPop predicate constructor
+through the existing translator extension point. Computed-expression regex
+filters retain whole-string matching (`String.matches`), so `"marko"` matches
+`"mar.*"` and does not match `"ark"`.
+
 Cypher results normalize HugeGraph IDs, including
 values nested in collections, maps and paths. Cyclic results and nesting deeper
 than 32 levels are rejected.

hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/opencypher/CypherGremlinPredicates.java

@@ -0,0 +1,55 @@
+/*
+ * 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.opencypher;
+
+import org.apache.tinkerpop.gremlin.process.traversal.P;
+import org.apache.tinkerpop.gremlin.process.traversal.PBiPredicate;
+import org.opencypher.gremlin.translation.traversal.TraversalGremlinPredicates;
+import org.opencypher.gremlin.traversal.CustomPredicate;
+
+/**
+ * Adapt the extension factories compiled against the pre-3.8 P constructor.
+ * The original predicates retain Cypher type checks and whole-string regex matching.
+ */
+public final class CypherGremlinPredicates extends TraversalGremlinPredicates {
+
+    @Override
+    public P<Object> regexMatch(Object value) {
+        return predicate(CustomPredicate.cypherRegex, value);
+    }
+
+    @Override
+    public P<Object> isNode() {
+        return predicate(CustomPredicate.cypherIsNode, null);
+    }
+
+    @Override
+    public P<Object> isRelationship() {
+        return predicate(CustomPredicate.cypherIsRelationship, null);
+    }
+
+    @Override
+    public P<Object> isString() {
+        return predicate(CustomPredicate.cypherIsString, null);
+    }
+
+    private static P<Object> predicate(CustomPredicate predicate, Object value) {
+        PBiPredicate<Object, Object> adapter = predicate::test;
+        return new P<>(adapter, value);
+    }
+}

hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/opencypher/CypherOpProcessor.java

@@ -55,6 +55,8 @@
 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;
@@ -139,7 +141,9 @@ private void evalCypher(Context context) throws OpProcessorException {
                                                                       .build(translatorDefinition);
 
         Translator<GraphTraversal, P> traversalTranslator = Translator.builder()
-                                                                      .traversal(g)
+                                                                      .custom(new TraversalGremlinSteps(g),
+                                                                              new CypherGremlinPredicates(),
+                                                                              new TraversalGremlinBindings())
                                                                       .build(translatorDefinition);
 
         Seq<GremlinStep> ir = ast.translate(strTranslator.flavor(),

hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/io/HugeGraphTypeSerializerRegistryBuilder.java

@@ -44,6 +44,8 @@
 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 {
 
@@ -59,6 +61,9 @@ public final class HugeGraphTypeSerializerRegistryBuilder
     private static final TypeSerializer<File> FILE_TRANSFORM_SERIALIZER =
             new WireTransformSerializer<>(file -> Map.of("file", file.getName()));
 
+    private static final TypeSerializer<GString> GSTRING_TRANSFORM_SERIALIZER =
+            new WireTransformSerializer<>(GString::toString);
+
     public HugeGraphTypeSerializerRegistryBuilder() {
         this.withFallbackResolver(type -> {
             if (Id.class.isAssignableFrom(type)) {
@@ -76,6 +81,9 @@ public HugeGraphTypeSerializerRegistryBuilder() {
             if (File.class.isAssignableFrom(type)) {
                 return FILE_TRANSFORM_SERIALIZER;
             }
+            if (GString.class.isAssignableFrom(type)) {
+                return GSTRING_TRANSFORM_SERIALIZER;
+            }
             return null;
         });
     }

hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/traversal/optimize/HugeCountStrategy.java

@@ -187,11 +187,11 @@ public void apply(final Traversal.Admin<?, ?> traversal) {
                 }
 
                 /*
-                 * HugeGraph extracts RangeGlobalStep into backend queries. A
-                 * negative upper bound is never useful for count(), and would
-                 * become an invalid backend range like [0, -3).
+                 * HugeGraph extracts RangeGlobalStep into backend queries.
+                 * Non-positive upper bounds cannot preserve count(). A zero
+                 * bound from without(-1) would replace a nonempty count with 0.
                  */
-                if (highRange != null && highRange < 0L) {
+                if (highRange != null && highRange <= 0L) {
                     highRange = null;
                 }
 

hugegraph-server/hugegraph-dist/src/assembly/travis/run-gremlin-console-smoke-test.sh

@@ -69,6 +69,16 @@ try {
                    "'${SMOKE_MARKER}-' + count"
     results = client.submit(remoteScript).all().get()
     println(results[0].object)
+    interpolation = client.submit('def value = 42; "r3-value:\${value}"').all().get()
+    assert interpolation.size() == 1
+    assert interpolation[0].object instanceof String
+    assert interpolation[0].object == 'r3-value:42'
+    nested = client.submit('def value = 42; [["r3-value:\${value}"], ' +
+                           '[value: "r3-value:\${value}"]]').all().get()
+    assert nested.size() == 2
+    assert nested[0].object == ['r3-value:42']
+    assert nested[1].object == [value: 'r3-value:42']
+    println('gremlin-console-gstring-ok')
 } finally {
     client.close()
     cluster.close()
@@ -81,3 +91,4 @@ EOF
 ) | tee "$SMOKE_LOG"
 
 grep -q "$SMOKE_MARKER" "$SMOKE_LOG"
+grep -q "gremlin-console-gstring-ok" "$SMOKE_LOG"

hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/api/CypherApiTest.java

@@ -60,6 +60,22 @@ public void testPost() {
         this.testCypherQueryAndContains(QUERY, QUERY_RESULT);
     }
 
+    @Test
+    public void testComputedRegexExecutesExtensionPredicate() {
+        String query = "MATCH (n:person) WHERE (n.name + '') =~ 'mar.*' " +
+                       "RETURN n.name AS name";
+        String content = this.testCypherQueryAndContains(query, "marko");
+        Assert.assertEquals(List.of(Map.of("name", "marko")), assertCypherSuccessData(content));
+    }
+
+    @Test
+    public void testComputedRegexRequiresWholeStringMatch() {
+        String query = "MATCH (n:person) WHERE (n.name + '') =~ 'ark' " +
+                       "RETURN n.name AS name";
+        String content = this.testCypherQueryAndContains(query, "data");
+        Assert.assertTrue(assertCypherSuccessData(content).isEmpty());
+    }
+
     @Test
     public void testCreate() {
         this.testCypherQueryAndContains("CREATE (n:person { name : 'test', " +

hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/core/CountStrategyCoreTest.java

@@ -484,6 +484,43 @@ public void testCountUnknownNumericPredicateKeepsFinalResults() {
                 customFalse.or(P.eq(0L)), P.not(custom).or(P.eq(0L))));
     }
 
+    @Test
+    public void testCountWithoutNegativeValuesKeepsEmptyCount() {
+        this.initSchema();
+        commitTx();
+        assertNegativeWithoutCounts(graph().traversal(), 0L);
+    }
+
+    @Test
+    public void testCountWithoutNegativeValuesKeepsNonemptyAndNestedCount() {
+        this.initSchema();
+        Vertex source = graph().addVertex(T.label, "person", "name", "source");
+        for (int i = 0; i < 5; i++) {
+            Vertex target = graph().addVertex(T.label, "person", "name", "target" + i);
+            source.addEdge("knows", target);
+        }
+        commitTx();
+        GraphTraversalSource g = graph().traversal();
+        assertNegativeWithoutCounts(g, 6L);
+        for (P<Long> predicate : List.of(P.without(-1L), P.without(-2L, -1L))) {
+            Assert.assertEquals(Collections.singletonList(source.id()),
+                                g.V().filter(__.out("knows").count().is(predicate.clone())
+                                               .is(P.gt(0L))).id().toList());
+        }
+    }
+
+    private static void assertNegativeWithoutCounts(GraphTraversalSource g, long count) {
+        GraphTraversalSource control = g.withoutStrategies(HugeCountStrategy.class);
+        for (P<Long> predicate : List.of(P.without(-1L), P.without(-2L, -1L))) {
+            Assert.assertEquals(Collections.singletonList(count),
+                                control.V().count().is(predicate.clone()).toList());
+            Assert.assertEquals(Collections.singletonList(count),
+                                g.V().count().is(predicate.clone()).toList());
+            Assert.assertEquals(count > 0L ? Collections.singletonList(count) : Collections.emptyList(),
+                                g.V().count().is(predicate.clone()).is(P.gt(0L)).toList());
+        }
+    }
+
     @Test
     public void testCountWithoutUsesBoundAboveAllExcludedCounts() {
         this.initSchema();

hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/unit/UnitTestSuite.java

@@ -84,6 +84,7 @@
 import org.apache.hugegraph.unit.id.IdTest;
 import org.apache.hugegraph.unit.id.IdUtilTest;
 import org.apache.hugegraph.unit.id.SplicingIdGeneratorTest;
+import org.apache.hugegraph.unit.opencypher.CypherGremlinPredicatesTest;
 import org.apache.hugegraph.unit.rocksdb.RocksDBCountersTest;
 import org.apache.hugegraph.unit.rocksdb.RocksDBSessionTest;
 import org.apache.hugegraph.unit.rocksdb.RocksDBSessionsTest;
@@ -125,6 +126,7 @@
         /* api gremlin */
         GremlinQueryAPITest.class,
         CypherClientTest.class,
+        CypherGremlinPredicatesTest.class,
         WsAndHttpBasicAuthHandlerTest.class,
         GraphSpaceGroupAPITest.class,
         GraphSpaceAuthPayloadTest.class,

hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/unit/config/GremlinConfigCompatibilityTest.java

@@ -75,6 +75,9 @@
 import org.apache.tinkerpop.gremlin.util.ser.GraphBinaryMessageSerializerV1;
 import org.apache.tinkerpop.gremlin.util.ser.MessageTextSerializer;
 import org.junit.Test;
+
+import groovy.lang.GString;
+import groovy.lang.GroovyShell;
 import org.mockito.Mockito;
 import org.yaml.snakeyaml.Yaml;
 import org.yaml.snakeyaml.error.YAMLException;
@@ -540,6 +543,44 @@ public void testDefaultGraphSONSerializerIncludesHugeGraphElementProperties()
         Assert.assertContains("0.75", pathJson);
     }
 
+    @Test
+    public void testDriverConfigsReturnEvaluatedGroovyStrings() throws Exception {
+        Object value = new GroovyShell().evaluate("def value = 42; \"r3-value:${value}\"");
+        Assert.assertInstanceOf(GString.class, value);
+        Settings.SerializerSettings serverSettings = readGremlinServerSettings().serializers.get(0);
+        MessageSerializer<?> server = newMessageSerializer(serverSettings.className);
+        server.configure(config(serverSettings.config), Collections.emptyMap());
+        List<Object> response = List.of(value, List.of(value), Map.of("value", value));
+        List<Object> expected = List.of("r3-value:42", List.of("r3-value:42"),
+                                       Map.of("value", "r3-value:42"));
+        for (String config : DRIVER_CONFIGS) {
+            RemoteSerializerSettings settings = readRemoteSerializerSettings(config);
+            MessageSerializer<?> client = newMessageSerializer(settings.className);
+            client.configure(config(settings.config), Collections.emptyMap());
+            Assert.assertEquals(config, expected,
+                                roundTripBinaryResponse(server, client, response).getResult().getData());
+        }
+        Assert.assertEquals(expected,
+                            roundTripBinaryResponse(server, new GraphBinaryMessageSerializerV1(), response)
+                            .getResult().getData());
+    }
+
+    @Test
+    public void testUntypedGraphsonKeepsEvaluatedGroovyStringBean() throws Exception {
+        Object value = new GroovyShell().evaluate("def value = 42; \"r3-value:${value}\"");
+        Settings.SerializerSettings settings = readGremlinServerSettings().serializers.stream()
+                                              .filter(s -> s.className.endsWith(
+                                                      "GraphSONUntypedMessageSerializerV1"))
+                                              .findFirst().orElseThrow();
+        MessageTextSerializer<?> serializer = (MessageTextSerializer<?>) newMessageSerializer(settings.className);
+        serializer.configure(config(settings.config), Collections.emptyMap());
+        Object result = roundTripResponse(serializer, value).getResult().getData();
+        Assert.assertInstanceOf(Map.class, result);
+        Map<?, ?> bean = (Map<?, ?>) result;
+        Assert.assertEquals(List.of(42), bean.get("values"));
+        Assert.assertEquals(List.of("r3-value:", ""), bean.get("strings"));
+    }
+
     @Test
     public void testDriverConfigsReturnOptionalAndFile() throws Exception {
         Settings.SerializerSettings serverSettings = readGremlinServerSettings()