fix(interactive): Fix Expand Direction in Graph Type Inference (#4580)

<!--
Thanks for your contribution! please review
https://github.com/alibaba/GraphScope/blob/main/CONTRIBUTING.md before
opening an issue.
-->

## What do these changes do?
as titled.

<!-- Please give a short brief about these changes. -->

## Related issue number

<!-- Are there any issues opened that will be resolved by merging this
change? -->

Fixes

Author: shirly121

interactive_engine/compiler/src/main/java/com/alibaba/graphscope/common/config/PlannerConfig.java

@@ -39,7 +39,9 @@ public class PlannerConfig {
     public static final Config<Integer> GRAPH_PLANNER_GROUP_CLEAR_INTERVAL_MINUTES =
             Config.intConfig("graph.planner.group.clear.interval.minutes", 30);
     public static final Config<String> TRIM_CLASS_NAMES =
-            Config.stringConfig("graph.planner.trim.class.names", "GraphLogicalExpand");
+            Config.stringConfig(
+                    "graph.planner.trim.class.names",
+                    "GraphLogicalExpand, GraphLogicalSource, GraphLogicalGetV");
 
     private final Configs configs;
     private final List<String> rules;

interactive_engine/compiler/src/main/java/com/alibaba/graphscope/common/config/YamlConfigs.java

@@ -40,6 +40,9 @@ public class YamlConfigs extends Configs {
                 .put(
                         "graph.planner.cbo.glogue.size",
                         (Configs configs) -> configs.get("compiler.planner.cbo.glogue.size"))
+                .put(
+                        "graph.planner.trim.class.names",
+                        (Configs configs) -> configs.get("compiler.planner.trim_class_names"))
                 .put(
                         "graph.planner.rules",
                         (Configs configs) -> {
@@ -216,7 +219,10 @@ public class YamlConfigs extends Configs {
                         (Configs configs) -> configs.get("compiler.calcite_default_charset"))
                 .put(
                         "gremlin.script.language.name",
-                        (Configs configs) -> configs.get("compiler.gremlin_script_language_name"));
+                        (Configs configs) -> configs.get("compiler.gremlin_script_language_name"))
+                .put(
+                        "graph.type.inference.enabled",
+                        (Configs configs) -> configs.get("compiler.type_inference_enabled"));
         valueGetterMap = mapBuilder.build();
     }
 

interactive_engine/compiler/src/main/java/com/alibaba/graphscope/common/ir/planner/GraphIOProcessor.java

@@ -16,6 +16,8 @@
 
 package com.alibaba.graphscope.common.ir.planner;
 
+import com.alibaba.graphscope.common.config.Configs;
+import com.alibaba.graphscope.common.config.FrontendConfig;
 import com.alibaba.graphscope.common.ir.meta.IrMeta;
 import com.alibaba.graphscope.common.ir.meta.glogue.CountHandler;
 import com.alibaba.graphscope.common.ir.meta.glogue.DetailedExpandCost;
@@ -456,6 +458,10 @@ private PatternEdge visitEdge(
         }
 
         private void checkPattern(Pattern pattern) {
+            Configs configs = (Configs) builder.getContext();
+            if (configs != null && !FrontendConfig.GRAPH_TYPE_INFERENCE_ENABLED.get(configs)) {
+                return;
+            }
             for (PatternEdge edge : pattern.getEdgeSet()) {
                 PatternVertex src = edge.getSrcVertex();
                 PatternVertex dst = edge.getDstVertex();

interactive_engine/compiler/src/main/java/com/alibaba/graphscope/common/ir/type/GraphTypeInference.java

@@ -135,16 +135,61 @@ private RelNode dfs(
             }
         }
         RelDataType oldType = getType(top);
+        RelNode newTop = top;
         if (!typeEquals(oldType, newType)) {
             updated.add(top);
-            RelNode newTop = newRel(top, newType);
+            newTop = newRel(top, newType);
+        }
+        newTop = newExpandOpt(newTop, newNeighbors);
+        if (top != newTop) {
             RelNode parent = relGraph.getParent(top);
             if (parent != null) {
                 parent.replaceInput(0, newTop);
             }
-            return newTop;
         }
-        return top;
+        return newTop;
+    }
+
+    private GraphOpt.Expand getExpandOpt(
+            GraphLogicalExpand expand, GraphSchemaType expandType, List<RelNode> children) {
+        if (expand.getOpt() != GraphOpt.Expand.BOTH) {
+            return expand.getOpt();
+        }
+        List<String> childrenLabels = Lists.newArrayList();
+        children.forEach(
+                c -> {
+                    RelDataType type = getType(c);
+                    if (type instanceof GraphSchemaType) {
+                        childrenLabels.addAll(
+                                ((GraphSchemaType) type)
+                                        .getLabelType().getLabelsEntry().stream()
+                                                .map(k -> k.getLabel())
+                                                .collect(Collectors.toList()));
+                    }
+                });
+        List<String> srcLabels = Lists.newArrayList();
+        List<String> dstLabels = Lists.newArrayList();
+        expandType
+                .getLabelType()
+                .getLabelsEntry()
+                .forEach(
+                        k -> {
+                            srcLabels.add(k.getSrcLabel());
+                            dstLabels.add(k.getDstLabel());
+                        });
+        if (srcLabels.stream().noneMatch(dstLabels::contains)) {
+            if (childrenLabels.stream()
+                    .collect(Collectors.toSet())
+                    .equals(srcLabels.stream().collect(Collectors.toSet()))) {
+                return GraphOpt.Expand.OUT;
+            }
+            if (childrenLabels.stream()
+                    .collect(Collectors.toSet())
+                    .equals(dstLabels.stream().collect(Collectors.toSet()))) {
+                return GraphOpt.Expand.IN;
+            }
+        }
+        return expand.getOpt();
     }
 
     private boolean typeEquals(RelDataType type1, RelDataType type2) {
@@ -702,6 +747,49 @@ private RelNode newRel(RelNode rel, RelDataType newType) {
         return rel;
     }
 
+    private RelNode newExpandOpt(RelNode rel, List<RelNode> children) {
+        if (rel instanceof GraphLogicalExpand) {
+            GraphLogicalExpand expand = (GraphLogicalExpand) rel;
+            GraphSchemaType expandType =
+                    (GraphSchemaType) expand.getRowType().getFieldList().get(0).getType();
+            GraphOpt.Expand newOpt = getExpandOpt(expand, expandType, children);
+            if (expand.getOpt() != newOpt) {
+                GraphLogicalExpand newExpand =
+                        GraphLogicalExpand.create(
+                                (GraphOptCluster) builder.getCluster(),
+                                ImmutableList.of(),
+                                expand.getInputs().isEmpty() ? null : expand.getInput(0),
+                                newOpt,
+                                expand.getTableConfig(),
+                                expand.getAliasName(),
+                                expand.getStartAlias(),
+                                expand.isOptional(),
+                                expand.getFilters(),
+                                expandType);
+                return newExpand;
+            }
+        } else if (rel instanceof GraphLogicalPathExpand) {
+            GraphLogicalPathExpand pxd = (GraphLogicalPathExpand) rel;
+            RelNode newExpand = newExpandOpt(pxd.getExpand(), children);
+            if (newExpand != pxd.getExpand()) {
+                return GraphLogicalPathExpand.create(
+                        (GraphOptCluster) builder.getCluster(),
+                        ImmutableList.of(),
+                        pxd.getInput(),
+                        newExpand,
+                        pxd.getGetV(),
+                        pxd.getOffset(),
+                        pxd.getFetch(),
+                        pxd.getResultOpt(),
+                        pxd.getPathOpt(),
+                        pxd.getUntilCondition(),
+                        pxd.getAliasName(),
+                        pxd.getStartAlias());
+            }
+        }
+        return rel;
+    }
+
     private TableConfig newTableConfig(AbstractBindableTableScan rel, RelDataType newType) {
         List<RelOptTable> oldTables = rel.getTableConfig().getTables();
         List<RelOptTable> newTables = Lists.newArrayList();

interactive_engine/compiler/src/test/java/com/alibaba/graphscope/common/ir/GraphTypeInferenceTest.java

@@ -251,4 +251,48 @@ public void schema_type_test_10() {
         }
         Assert.fail();
     }
+
+    @Test
+    public void person_likes_post_type_test() {
+        RelNode match =
+                com.alibaba.graphscope.cypher.antlr4.Utils.eval(
+                                "Match (a:PERSON)-[:KNOWS]-(:PERSON)-[:LIKES]-(c:POST) Return c",
+                                Utils.mockGraphBuilder("schema/ldbc.json"))
+                        .build();
+        Assert.assertEquals(
+                "GraphLogicalProject(c=[c], isAppend=[false])\n"
+                        + "  GraphLogicalSingleMatch(input=[null],"
+                        + " sentence=[GraphLogicalGetV(tableConfig=[{isAll=false, tables=[POST]}],"
+                        + " alias=[c], opt=[OTHER])\n"
+                        + "  GraphLogicalExpand(tableConfig=[[EdgeLabel(LIKES, PERSON, POST)]],"
+                        + " alias=[_], opt=[OUT])\n"
+                        + "    GraphLogicalGetV(tableConfig=[{isAll=false, tables=[PERSON]}],"
+                        + " alias=[_], opt=[OTHER])\n"
+                        + "      GraphLogicalExpand(tableConfig=[{isAll=false, tables=[KNOWS]}],"
+                        + " alias=[_], opt=[BOTH])\n"
+                        + "        GraphLogicalSource(tableConfig=[{isAll=false, tables=[PERSON]}],"
+                        + " alias=[a], opt=[VERTEX])\n"
+                        + "], matchOpt=[INNER])",
+                match.explain().trim());
+    }
+
+    @Test
+    public void person_likes_post_type_test_2() {
+        RelNode match =
+                com.alibaba.graphscope.cypher.antlr4.Utils.eval(
+                                "Match (a)-[:LIKES]-(c) Return c",
+                                Utils.mockGraphBuilder("schema/ldbc.json"))
+                        .build();
+        Assert.assertEquals(
+                "GraphLogicalProject(c=[c], isAppend=[false])\n"
+                    + "  GraphLogicalSingleMatch(input=[null],"
+                    + " sentence=[GraphLogicalGetV(tableConfig=[{isAll=false, tables=[PERSON, POST,"
+                    + " COMMENT]}], alias=[c], opt=[OTHER])\n"
+                    + "  GraphLogicalExpand(tableConfig=[{isAll=false, tables=[LIKES]}], alias=[_],"
+                    + " opt=[BOTH])\n"
+                    + "    GraphLogicalSource(tableConfig=[{isAll=false, tables=[PERSON, POST,"
+                    + " COMMENT]}], alias=[a], opt=[VERTEX])\n"
+                    + "], matchOpt=[INNER])",
+                match.explain().trim());
+    }
 }

interactive_engine/compiler/src/test/java/com/alibaba/graphscope/gremlin/antlr4x/GraphBuilderTest.java

@@ -1830,13 +1830,11 @@ public void g_V_match_as_a_person_both_as_b_test() {
         RelNode after2 = optimizer.optimize(node2, new GraphIOProcessor(builder, irMeta));
         Assert.assertEquals(
                 "GraphLogicalAggregate(keys=[{variables=[], aliases=[]}], values=[[{operands=[a,"
-                    + " b], aggFunction=COUNT, alias='$f0', distinct=false}]])\n"
-                    + "  GraphPhysicalGetV(tableConfig=[{isAll=false, tables=[person]}], alias=[b],"
-                    + " opt=[OTHER], physicalOpt=[ITSELF])\n"
-                    + "    GraphPhysicalExpand(tableConfig=[{isAll=false, tables=[created]}],"
-                    + " alias=[_], startAlias=[a], opt=[BOTH], physicalOpt=[VERTEX])\n"
-                    + "      GraphLogicalSource(tableConfig=[{isAll=false, tables=[software]}],"
-                    + " alias=[a], opt=[VERTEX])",
+                        + " b], aggFunction=COUNT, alias='$f0', distinct=false}]])\n"
+                        + "  GraphPhysicalExpand(tableConfig=[{isAll=false, tables=[created]}],"
+                        + " alias=[b], startAlias=[a], opt=[IN], physicalOpt=[VERTEX])\n"
+                        + "    GraphLogicalSource(tableConfig=[{isAll=false, tables=[software]}],"
+                        + " alias=[a], opt=[VERTEX])",
                 after2.explain().trim());
         RelNode node3 = eval("g.V().match(as('a').both().as('b')).count()", builder);
         RelNode after3 = optimizer.optimize(node3, new GraphIOProcessor(builder, irMeta));