fix(core): retain unsafe label predicates for filtering

Author: contrueCT

hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/query/ConditionQuery.java

@@ -262,9 +262,13 @@ public boolean containsLabelOrUserpropRelation() {
      * This method keeps the historical behavior for existing callers:
      * <ul>
      * <li>returns {@code null} if no top-level EQ/IN relation exists</li>
-     * <li>returns {@code null} if top-level EQ/IN relations resolve to empty</li>
-     * <li>returns the single value if only one value is resolved</li>
-     * <li>returns the raw IN list if there is exactly one top-level IN relation</li>
+     * <li>returns the single EQ value if there is exactly one top-level EQ
+     * relation and no top-level IN relation</li>
+     * <li>returns the raw IN list, including an empty list, if there is exactly
+     * one top-level IN relation and no top-level EQ relation</li>
+     * <li>returns {@code null} if several top-level EQ/IN relations resolve to
+     * an empty set</li>
+     * <li>returns the single value if several relations resolve to one value</li>
      * <li>throws if multiple values remain after resolving several relations</li>
      * </ul>
      *

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

@@ -446,29 +446,38 @@ private static boolean extractHasContainers(HugeVertexStep<?> newStep,
     private static boolean canExtractHasContainers(HugeGraph graph,
                                                    HasContainerHolder holder) {
         List<HasContainer> hasContainers = holder.getHasContainers();
-        // Keep pure label non-EQ/IN predicates on GraphStep for TinkerPop filtering.
-        if (hasContainers.size() == 1 &&
-            isOnlyNonEqInLabelPredicate(hasContainers.get(0))) {
-            return false;
+        // Keep pure label non-EQ/IN predicates for TinkerPop filtering.
+        if (isPureLabelPredicateHolder(hasContainers)) {
+            for (HasContainer has : hasContainers) {
+                if (!isEqInLabelPredicate(has)) {
+                    return false;
+                }
+            }
         }
-        for (HasContainer has : holder.getHasContainers()) {
+        for (HasContainer has : hasContainers) {
             if (!canExtractHasContainer(graph, has)) {
                 return false;
             }
         }
         return true;
     }
 
-    private static boolean isOnlyNonEqInLabelPredicate(HasContainer has) {
-        if (!has.getKey().equals(T.label.getAccessor())) {
-            return false;
+    private static boolean isPureLabelPredicateHolder(
+                           List<HasContainer> hasContainers) {
+        for (HasContainer has : hasContainers) {
+            if (!has.getKey().equals(T.label.getAccessor())) {
+                return false;
+            }
         }
+        return true;
+    }
 
+    private static boolean isEqInLabelPredicate(HasContainer has) {
         List<P<Object>> predicates = new ArrayList<>();
         collectPredicates(predicates, ImmutableList.of(has.getPredicate()));
         for (P<Object> predicate : predicates) {
             BiPredicate<?, ?> bp = predicate.getBiPredicate();
-            if (bp == Compare.eq || bp == Contains.within) {
+            if (bp != Compare.eq && bp != Contains.within) {
                 return false;
             }
         }

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

@@ -3633,6 +3633,57 @@ public void testQueryEdgesByNonEqLabel() {
         }
     }
 
+    @Test
+    public void testQueryEdgesByMixedConnectiveLabel() {
+        HugeGraph graph = graph();
+        init18Edges();
+
+        GraphTraversalSource g = graph.traversal();
+
+        List<Edge> edges = g.E()
+                            .has(T.label, P.eq("created")
+                                           .or(P.neq("authored")))
+                            .toList();
+        Assert.assertEquals(15, edges.size());
+        for (Edge edge : edges) {
+            Assert.assertNotEquals("authored", edge.label());
+        }
+
+        edges = g.E()
+                 .has(T.label, P.eq("created")
+                                .and(P.neq("authored")))
+                 .toList();
+        Assert.assertEquals(2, edges.size());
+        for (Edge edge : edges) {
+            Assert.assertEquals("created", edge.label());
+        }
+    }
+
+    @Test
+    public void testQueryEdgesByMultipleNegativeLabelContainers() {
+        HugeGraph graph = graph();
+        init18Edges();
+
+        GraphTraversalSource g = graph.traversal();
+
+        List<Edge> edges = g.E().hasLabel("created")
+                            .has(T.label, P.neq("authored"))
+                            .toList();
+        Assert.assertEquals(2, edges.size());
+        for (Edge edge : edges) {
+            Assert.assertEquals("created", edge.label());
+        }
+
+        edges = g.E().has(T.label, P.neq("created"))
+                 .has(T.label, P.neq("authored"))
+                 .toList();
+        Assert.assertEquals(13, edges.size());
+        for (Edge edge : edges) {
+            Assert.assertNotEquals("created", edge.label());
+            Assert.assertNotEquals("authored", edge.label());
+        }
+    }
+
     @Test
     public void testQueryOutEdgesOfVertexBySortkeyWithRange() {
         // FIXME: skip this test for hstore

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

@@ -9111,6 +9111,56 @@ public void testQueryByNonEqLabel() {
         }
     }
 
+    @Test
+    public void testQueryByMixedConnectiveLabel() {
+        HugeGraph graph = graph();
+        init10Vertices();
+
+        GraphTraversalSource g = graph.traversal();
+
+        List<Vertex> vertices = g.V()
+                                 .has(T.label, P.eq("language")
+                                                .or(P.neq("author")))
+                                 .toList();
+        Assert.assertEquals(8, vertices.size());
+        for (Vertex vertex : vertices) {
+            Assert.assertNotEquals("author", vertex.label());
+        }
+
+        vertices = g.V()
+                    .has(T.label, P.eq("language")
+                                   .and(P.neq("author")))
+                    .toList();
+        Assert.assertEquals(3, vertices.size());
+        for (Vertex vertex : vertices) {
+            Assert.assertEquals("language", vertex.label());
+        }
+    }
+
+    @Test
+    public void testQueryByMultipleNegativeLabelContainers() {
+        HugeGraph graph = graph();
+        init10Vertices();
+
+        GraphTraversalSource g = graph.traversal();
+
+        List<Vertex> vertices = g.V().hasLabel("language")
+                                 .has(T.label, P.neq("author"))
+                                 .toList();
+        Assert.assertEquals(3, vertices.size());
+        for (Vertex vertex : vertices) {
+            Assert.assertEquals("language", vertex.label());
+        }
+
+        vertices = g.V().has(T.label, P.neq("author"))
+                    .has(T.label, P.neq("book"))
+                    .toList();
+        Assert.assertEquals(3, vertices.size());
+        for (Vertex vertex : vertices) {
+            Assert.assertEquals("language", vertex.label());
+        }
+    }
+
     @Test
     public void testCollectMatchedIndexesByJointLabelsWithIndexedProperties() {
         HugeGraph graph = graph();

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

@@ -102,6 +102,21 @@ public void testConditionWithSingleInValues() {
                             query.condition(HugeKeys.LABEL));
     }
 
+    @Test
+    public void testConditionWithEmptyInValues() {
+        ConditionQuery query = new ConditionQuery(HugeType.EDGE);
+        query.query(Condition.in(HugeKeys.LABEL, ImmutableList.of()));
+
+        Assert.assertTrue(query.containsCondition(HugeKeys.LABEL));
+        Assert.assertTrue(query.containsConditionValues(HugeKeys.LABEL));
+        Assert.assertEquals(ImmutableSet.of(),
+                            query.conditionValues(HugeKeys.LABEL));
+        Assert.assertNull(query.uniqueConditionValue(HugeKeys.LABEL));
+        Assert.assertNull(query.conditionValue(HugeKeys.LABEL));
+        Assert.assertEquals(ImmutableList.of(),
+                            query.condition(HugeKeys.LABEL));
+    }
+
     @Test
     public void testConditionWithConflictingEqAndIn() {
         Id label1 = IdGenerator.of(1);