[Bug Fix] fix some bugs found in cypher e2e test (#2579)

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

## What do these changes do?

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

Several bugs fixed, including:

* In schema 
1. modern graph schema with a wrong label id;

* In IrCore
1. in pattern matching, when generating source opr, assign the proper
table info.
2. when processing PathExpand in pattern, throw the unsupported error
for PathExpand ranging from 0, only when it is in the Intersection

* In runtime
1. do not throw error when GetV Opt is not `EndV` for path anymore, as
this can be either `StartV` or `EndV` for now, according to the
direction of EdgeExpand in PathExpand's ExpandBase.

## Related issue number

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

Fixes

---------

Co-authored-by: MeloYang <[email protected]>

Author: BingqingLyu

interactive_engine/executor/ir/core/resource/modern_schema.json

@@ -90,7 +90,7 @@
             "name": "person"
           },
           "dst": {
-            "id": 0,
+            "id": 1,
             "name": "software"
           }
         }

interactive_engine/executor/ir/core/resource/modern_schema_pk.json

@@ -90,7 +90,7 @@
             "name": "person"
           },
           "dst": {
-            "id": 0,
+            "id": 1,
             "name": "software"
           }
         }

interactive_engine/executor/ir/core/src/glogue/pattern.rs

@@ -647,18 +647,31 @@ fn generate_source_operator(
     pattern: &Pattern, source_extend: &ExactExtendStep,
 ) -> IrPatternResult<pb::logical_plan::Operator> {
     let source_vertex_id = source_extend.get_target_vertex_id();
-    let source_vertex_table = generate_vertex_table(pattern, source_vertex_id)?;
+    let inferred_vertex_table = generate_vertex_table(pattern, source_vertex_id)?;
     // Fuse `source_vertex_label` into source, for efficiently scan
     let source_vertex_param = if let Some(mut vertex_param) = pattern
         .get_vertex_parameters(source_vertex_id)?
         .cloned()
     {
-        if source_vertex_table.len() > 0 {
-            vertex_param.tables = source_vertex_table;
+        // if user given vertex table is empty, using the inferred vertex table
+        // and vise versa
+        if vertex_param.tables.len() == 0 {
+            vertex_param.tables = inferred_vertex_table;
+        }
+        // if the two tables are both not empty
+        // intersect user given labels and inferred labels
+        else if inferred_vertex_table.len() > 0 {
+            let user_given_vertex_table = vertex_param.tables;
+            vertex_param.tables = vec![];
+            for inferred_vertex_label in inferred_vertex_table {
+                if user_given_vertex_table.contains(&inferred_vertex_label) {
+                    vertex_param.tables.push(inferred_vertex_label)
+                }
+            }
         }
         vertex_param
     } else {
-        query_params(source_vertex_table, vec![], None)
+        query_params(inferred_vertex_table, vec![], None)
     };
     let source_scan = pb::Scan {
         scan_opt: 0,
@@ -876,17 +889,6 @@ fn get_edge_expand_from_binder<'a, 'b>(
 ) -> IrPatternResult<&'a pb::EdgeExpand> {
     use pb::pattern::binder::Item as BinderItem;
     if let Some(BinderItem::Path(path_expand)) = binder.item.as_ref() {
-        let hop_range = path_expand
-            .hop_range
-            .as_ref()
-            .ok_or(ParsePbError::EmptyFieldError("pb::PathExpand::hop_range".to_string()))?;
-        if hop_range.lower < 1 {
-            // The path with range from 0 cannot be translated to oprs that can be intersected.
-            return Err(IrPatternError::Unsupported(format!(
-                "PathExpand in Pattern with lower range of {:?}",
-                hop_range.lower
-            )))?;
-        }
         let expand_base = path_expand
             .base
             .as_ref()

interactive_engine/executor/ir/core/src/plan/physical.rs

@@ -805,9 +805,17 @@ fn add_intersect_job_builder(
             if get_v.alias.is_none() || !get_v.alias.as_ref().unwrap().eq(intersect_tag) {
                 Err(IrError::InvalidPattern("Cannot intersect on different tags".to_string()))?
             }
+            // If the first operator is PathExpand, pick its last expand out from the path
             let mut edge_expand = if let Some(Edge(edge_expand)) = first_opr.borrow().opr.opr.as_ref() {
-                Ok(edge_expand.clone())
+                edge_expand.clone()
             } else if let Some(Path(path_expand)) = first_opr.borrow().opr.opr.as_ref() {
+                // Process path_expand as follows:
+                // 1. If path_expand range from 0, it is unsupported;
+                // 2. If it is path_expand(1,2), optimized as edge_expand;
+                // 3. Otherwise, translate path_expand(l,h) to path_expand(l-1, h-1) + endV() + edge_expand,
+                //    and the last edge_expand is the one to intersect.
+                //    Notice that if we have predicates for vertices in path_expand, or for the last vertex of path_expand,
+                //    do the filtering after intersection.
                 let mut path_expand = path_expand.clone();
                 let path_expand_base = path_expand
                     .base
@@ -828,37 +836,52 @@ fn add_intersect_job_builder(
                     Err(IrError::Unsupported(
                         "Edge Only PathExpand in Intersection's subplan has not been supported yet"
                             .to_string(),
-                    ))?;
+                    ))?
                 }
+                // Combine the params for the last vertex in path.
+                // That is, it should satisfy both params in `GetV` in PathExpand's ExpandBase,
+                // and the params in `EndV` following PathExpand.
                 if let Some(path_get_v) = path_get_v_opt {
                     get_v = combine_get_v_by_query_params(get_v, path_get_v);
                 }
+                // pick the last edge expand out from the path expand
                 let mut last_edge_expand = base_edge_expand.clone();
                 last_edge_expand.v_tag = None;
                 let hop_range = path_expand
                     .hop_range
                     .as_mut()
                     .ok_or(ParsePbError::EmptyFieldError("pb::PathExpand::hop_range".to_string()))?;
+                if hop_range.lower < 1 {
+                    Err(IrError::Unsupported(format!(
+                        "PathExpand in Intersection with lower range of {:?}",
+                        hop_range.lower
+                    )))?
+                }
                 if hop_range.lower == 1 && hop_range.upper == 2 {
+                    // optimized Path(1..2) to as EdgeExpand
                     last_edge_expand.v_tag = path_expand.start_tag;
                 } else {
+                    // translate path_expand(l,h) to path_expand(l-1, h-1) + endV() + edge_expand,
                     hop_range.lower -= 1;
                     hop_range.upper -= 1;
                     let mut end_v = pb::GetV::default();
                     end_v.opt = pb::get_v::VOpt::End as i32;
+                    // build the path expansion
                     path_expand.add_job_builder(builder, plan_meta)?;
                     end_v.add_job_builder(builder, plan_meta)?;
                 }
-                Ok(last_edge_expand)
+                last_edge_expand
             } else {
                 Err(IrError::InvalidPattern(
                     "First node of Intersection's subplan is neither EdgeExpand or PathExpand".to_string(),
-                ))
-            }?;
+                ))?
+            };
+            // build the edge expansion
+            // the opt should be vertex because now only intersection on vertex is supported
             edge_expand.expand_opt = pb::edge_expand::ExpandOpt::Vertex as i32;
             edge_expand.alias = get_v.alias.clone();
             edge_expand.add_job_builder(&mut sub_bldr, plan_meta)?;
-
+            // vertex parameter after the intersection
             if let Some(params) = get_v.params.as_ref() {
                 // the case that we need to further process getV's filter.
                 if params.is_queryable() || !params.tables.is_empty() {
@@ -870,13 +893,16 @@ fn add_intersect_job_builder(
         let sub_plan = sub_bldr.take_plan();
         intersect_plans.push(sub_plan);
     }
+    // intersect
     builder.intersect(intersect_plans, intersect_tag.clone());
+    // unfold the intersection
     let unfold = pb::Unfold {
         tag: Some(intersect_tag.clone()),
         alias: Some(intersect_tag.clone()),
         meta_data: None,
     };
     unfold.add_job_builder(builder, plan_meta)?;
+    // add vertex filters
     if let Some(mut auxilia) = auxilia {
         auxilia.tag = Some(intersect_tag.clone());
         builder.get_v(auxilia);

interactive_engine/executor/ir/runtime/src/process/operator/map/get_v.rs

@@ -49,15 +49,10 @@ impl FilterMapFunction<Record, Record> for GetVertexOperator {
                 input.append(vertex, self.alias.clone());
                 Ok(Some(input))
             } else if let Some(graph_path) = entry.as_graph_path() {
-                if let VOpt::End = self.opt {
-                    let path_end = graph_path.get_path_end().clone();
-                    input.append(path_end, self.alias.clone());
-                    Ok(Some(input))
-                } else {
-                    Err(FnExecError::unsupported_error(
-                        "Only support `GetV` with VOpt::End on a path entry",
-                    ))?
-                }
+                // TODO: we do not check VOpt here, and we treat all cases as to get the end vertex of the path.
+                let path_end = graph_path.get_path_end().clone();
+                input.append(path_end, self.alias.clone());
+                Ok(Some(input))
             } else {
                 Err(FnExecError::unexpected_data_error(
                     "Can only apply `GetV` (`Auxilia` instead) on an edge or path entry",
@@ -146,6 +141,17 @@ impl FilterMapFunction<Record, Record> for AuxiliaOperator {
             // e.g., for g.V().out().as("a").has("name", "marko"), we should compile as:
             // g.V().out().auxilia(as("a"))... where we give alias in auxilia,
             //     then we set tag=None and alias="a" in auxilia
+            // 1. filter by labels.
+            if !self.query_params.labels.is_empty() && entry.label().is_some() {
+                if !self
+                    .query_params
+                    .labels
+                    .contains(&entry.label().unwrap())
+                {
+                    return Ok(None);
+                }
+            }
+            // 2. further fetch properties, e.g., filter by columns.
             match entry.get_type() {
                 EntryType::Vertex => {
                     let graph = get_graph().ok_or(FnExecError::NullGraphError)?;