fix(server): avoid extracting text range filters

Author: LegendPei

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

@@ -171,6 +171,10 @@ public static void extractHasContainer(HugeGraphStep<?, ?> newStep,
             step = step.getNextStep();
             if (step instanceof HasStep) {
                 HasContainerHolder holder = (HasContainerHolder) step;
+                if (!canExtractHasContainers(TraversalUtil.getGraph(newStep),
+                                             holder.getHasContainers())) {
+                    break;
+                }
                 for (HasContainer has : holder.getHasContainers()) {
                     if (!GraphStep.processHasContainerIds(newStep, has)) {
                         newStep.addHasContainer(has);
@@ -188,6 +192,10 @@ public static void extractHasContainer(HugeVertexStep<?> newStep,
         do {
             if (step instanceof HasStep) {
                 HasContainerHolder holder = (HasContainerHolder) step;
+                if (!canExtractHasContainers(TraversalUtil.getGraph(newStep),
+                                             holder.getHasContainers())) {
+                    break;
+                }
                 for (HasContainer has : holder.getHasContainers()) {
                     newStep.addHasContainer(has);
                 }
@@ -198,6 +206,39 @@ public static void extractHasContainer(HugeVertexStep<?> newStep,
         } while (step instanceof HasStep || step instanceof NoOpBarrierStep);
     }
 
+    private static boolean canExtractHasContainers(HugeGraph graph,
+                                                   List<HasContainer> hasContainers) {
+        for (HasContainer has : hasContainers) {
+            if (!canExtractHasContainer(graph, has)) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    private static boolean canExtractHasContainer(HugeGraph graph,
+                                                  HasContainer has) {
+        if (isSysProp(has.getKey())) {
+            return true;
+        }
+
+        PropertyKey pkey = graph.propertyKey(has.getKey());
+        if (!pkey.dataType().isText()) {
+            return true;
+        }
+
+        List<P<Object>> predicates = new ArrayList<>();
+        collectPredicates(predicates, ImmutableList.of(has.getPredicate()));
+        for (P<Object> pred : predicates) {
+            BiPredicate<?, ?> bp = pred.getBiPredicate();
+            if (bp == Compare.gt || bp == Compare.gte ||
+                bp == Compare.lt || bp == Compare.lte) {
+                return false;
+            }
+        }
+        return true;
+    }
+
     public static void extractOrder(Step<?, ?> newStep,
                                     Traversal.Admin<?, ?> traversal) {
         Step<?, ?> step = newStep;

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

@@ -125,4 +125,29 @@ public void testWhereCountGteNegativeDoesNotBuildInvalidRange() {
 
         Assert.assertEquals(4L, count);
     }
+
+    @Test
+    public void testRepeatAfterTextRangeFilterWithEmptyResult() {
+        SchemaManager schema = graph().schema();
+        schema.propertyKey("vp4").asText().create();
+        schema.vertexLabel("vl1").properties("vp4")
+              .nullableKeys("vp4").create();
+        schema.edgeLabel("el2").link("vl1", "vl1").create();
+
+        Vertex v1 = graph().addVertex(T.label, "vl1", "vp4", "a");
+        Vertex v2 = graph().addVertex(T.label, "vl1", "vp4", "b");
+        v1.addEdge("el2", v2);
+        commitTx();
+
+        long direct = graph().traversal().V().has("vp4", P.lt(""))
+                           .repeat(__.out("el2")).emit().times(1)
+                           .count().next();
+        long viaMatch = graph().traversal().V()
+                             .match(__.as("start").has("vp4", P.lt(""))
+                                      .out("el2").as("m"))
+                             .select("m").count().next();
+
+        Assert.assertEquals(0L, direct);
+        Assert.assertEquals(viaMatch, direct);
+    }
 }