chore: fix TinkerPop unit test

hugegraph-core/src/main/java/org/apache/hugegraph/StandardHugeGraph.java

@@ -193,7 +193,8 @@ public StandardHugeGraph(HugeConfig config) {
 
         this.taskManager = TaskManager.instance();
 
-        this.features = new HugeFeatures(this, true);
+        boolean supportsPersistence = !"memory".equals(config.get(CoreOptions.BACKEND));
+        this.features = new HugeFeatures(this, supportsPersistence);
 
         this.name = config.get(CoreOptions.STORE);
         this.started = false;

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

@@ -51,7 +51,7 @@ public static List<ConditionQuery> flatten(ConditionQuery query) {
     public static List<ConditionQuery> flatten(ConditionQuery query,
                                                boolean supportIn) {
         if (query.isFlattened() && !query.mayHasDupKeys(SPECIAL_KEYS)) {
-            return ImmutableList.of(query);
+            return flattenRelations(query);
         }
 
         List<ConditionQuery> queries = new ArrayList<>();
@@ -251,6 +251,25 @@ private static ConditionQuery newQueryFromRelations(ConditionQuery query,
         return cq;
     }
 
+    private static ImmutableList<ConditionQuery> flattenRelations(ConditionQuery query) {
+        Relations relations = new Relations();
+        List<Condition> noRelations = new ArrayList<>();
+        for (Condition condition : query.conditions()) {
+            if (condition.isRelation()) {
+                relations.add((Relation) condition);
+            } else {
+                noRelations.add(condition);
+            }
+        }
+        relations = optimizeRelations(relations);
+        if (relations != null) {
+            ConditionQuery cq = newQueryFromRelations(query, relations);
+            cq.query(noRelations);
+            return ImmutableList.of(cq);
+        }
+        return ImmutableList.of(query);
+    }
+
     private static Relations optimizeRelations(Relations relations) {
         // Optimize and-relations in one query
         // e.g. (age>1 and age>2) -> (age>2)

hugegraph-core/src/main/java/org/apache/hugegraph/structure/HugeFeatures.java

@@ -271,6 +271,11 @@ public VertexProperty.Cardinality getCardinality(final String key) {
             return VertexProperty.Cardinality.single;
         }
 
+        @Override
+        public boolean supportsNullPropertyValues() {
+            return false;
+        }
+
         public boolean supportsDefaultLabel() {
             return true;
         }
@@ -291,6 +296,11 @@ public class HugeEdgeFeatures extends HugeElementFeatures
         public EdgePropertyFeatures properties() {
             return this.edgePropertyFeatures;
         }
+
+        @Override
+        public boolean supportsNullPropertyValues() {
+            return false;
+        }
     }
 
     public class HugeDataTypeFeatures implements DataTypeFeatures {

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

@@ -54,6 +54,9 @@ public void apply(Traversal.Admin<?, ?> traversal) {
         List<GraphStep> steps = TraversalHelper.getStepsOfClass(
                                 GraphStep.class, traversal);
         for (GraphStep originStep : steps) {
+            TraversalUtil.trySetGraph(originStep,
+                                      TraversalUtil.tryGetGraph(steps.get(0)));
+
             HugeGraphStep<?, ?> newStep = new HugeGraphStep<>(originStep);
             TraversalHelper.replaceStep(originStep, newStep, traversal);
 

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

@@ -25,6 +25,7 @@
 import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
+import java.util.Optional;
 import java.util.function.BiPredicate;
 import java.util.function.Function;
 import java.util.regex.Matcher;
@@ -54,6 +55,7 @@
 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.step.HasContainerHolder;
+import org.apache.tinkerpop.gremlin.process.traversal.step.TraversalParent;
 import org.apache.tinkerpop.gremlin.process.traversal.step.filter.FilterStep;
 import org.apache.tinkerpop.gremlin.process.traversal.step.filter.HasStep;
 import org.apache.tinkerpop.gremlin.process.traversal.step.filter.RangeGlobalStep;
@@ -105,12 +107,73 @@ public static HugeGraph getGraph(Step<?, ?> step) {
     }
 
     public static HugeGraph tryGetGraph(Step<?, ?> step) {
-        Graph graph = step.getTraversal().getGraph().get();
-        if (graph instanceof HugeGraph) {
-            return (HugeGraph) graph;
+        // TODO: remove these EmptyGraph judgments when upgrading tinkerpop to a fixed version
+        Optional<Graph> graph = step.getTraversal()
+                                    .getGraph()
+                                    .filter(g -> {
+                                        return !(g instanceof EmptyGraph);
+                                    });
+        if (!graph.isPresent()) {
+            TraversalParent parent = step.getTraversal().getParent();
+            if (parent instanceof Traversal) {
+                Optional<Graph> parentGraph = ((Traversal<?, ?>) parent)
+                                              .asAdmin()
+                                              .getGraph()
+                                              .filter(g -> {
+                                                 return !(g instanceof EmptyGraph);
+                                              });
+                if (parentGraph.isPresent()) {
+                    step.getTraversal().setGraph(parentGraph.get());
+                    return (HugeGraph) parentGraph.get();
+                }
+            }
+
+            return null;
         }
-        assert graph == null || graph instanceof EmptyGraph;
-        return null;
+
+        assert graph.get() instanceof HugeGraph;
+        return (HugeGraph) graph.get();
+    }
+
+    public static void trySetGraph(Step<?, ?> step, HugeGraph graph) {
+        if (graph == null || step == null || step.getTraversal() == null) {
+            return;
+        }
+
+        // TODO: remove these EmptyGraph judgments when upgrading tinkerpop to a fixed version
+        Optional<Graph> stepGraph = step.getTraversal()
+                                        .getGraph()
+                                        .filter(g -> {
+                                            return !(g instanceof EmptyGraph);
+                                        });
+
+        if (step instanceof TraversalParent) {
+            for (final Traversal.Admin<?, ?> local : ((TraversalParent) step).getLocalChildren()) {
+                if (local.getGraph()
+                         .filter(g -> {
+                             return !(g instanceof EmptyGraph);
+                         }).isPresent()) {
+                    continue;
+                }
+                local.setGraph(graph);
+            }
+            for (final Traversal.Admin<?, ?> global : ((TraversalParent) step).getGlobalChildren()) {
+                if (global.getGraph()
+                          .filter(g -> {
+                              return !(g instanceof EmptyGraph);
+                          }).isPresent()) {
+                    continue;
+                }
+                global.setGraph(graph);
+            }
+        }
+
+        if (stepGraph.isPresent()) {
+            assert stepGraph.get() instanceof HugeGraph;
+            return;
+        }
+
+        step.getTraversal().setGraph(graph);
     }
 
     public static void extractHasContainer(HugeGraphStep<?, ?> newStep,
@@ -580,14 +643,34 @@ public static void convAllHasSteps(Traversal.Admin<?, ?> traversal) {
         List<HasStep> steps =
                       TraversalHelper.getStepsOfAssignableClassRecursively(
                       HasStep.class, traversal);
+
+        if (steps.isEmpty()) {
+            return;
+        }
+
         /*
          * The graph in traversal may be null, for example:
          *   `g.V().hasLabel('person').union(__.has('name', 'tom'))`
          * Here `__.has()` will create a new traversal, but the graph is null
          */
-        if (steps.isEmpty() || !traversal.getGraph().isPresent()) {
-            return;
+        if (!traversal.getGraph()
+                      .filter(g -> {
+                            return !(g instanceof EmptyGraph);
+                      }).isPresent()) {
+            if (traversal.getParent() == null || !(traversal.getParent() instanceof Traversal)) {
+                return;
+            }
+
+            Optional<Graph> parentGraph = ((Traversal<?, ?>) traversal.getParent())
+                                                                      .asAdmin()
+                                                                      .getGraph();
+            if (parentGraph.filter(g -> {
+                  return !(g instanceof EmptyGraph);
+               }).isPresent()) {
+                traversal.setGraph(parentGraph.get());
+            }
         }
+
         HugeGraph graph = (HugeGraph) traversal.getGraph().get();
         for (HasStep<?> step : steps) {
             TraversalUtil.convHasStep(graph, step);