[WIP] Verify codegen

.github/workflows/hqps-db-ci.yml

@@ -155,13 +155,14 @@ jobs:
         cd ${GITHUB_WORKSPACE}/flex/bin
 
         for i in 1 2 3 4 5 6 7 8 9 10 11 12;
-        do
-          cmd="./load_plan_and_gen.sh -e=hqps -i=../resources/queries/ic/adhoc/ic${i}_adhoc.cypher -w=/tmp/codegen/"
-          cmd=${cmd}" -o=/tmp/plugin --ir_conf=../tests/hqps/engine_config_test.yaml "
-          cmd=${cmd}" --graph_schema_path=${INTERACTIVE_WORKSPACE}/data/ldbc/graph.yaml"
-          echo $cmd
-          eval ${cmd} || exit 1
-        done
+for i in 12;
+do
+  cmd="GLOG_v=10 ./load_plan_and_gen.sh -e=hqps -i=../resources/queries/ic/stored_procedure/ic${i}.cypher -w=/tmp/codegen/"
+  cmd=${cmd}" -o=/tmp/plugin --ir_conf=../tests/hqps/engine_config_test.yaml "
+  cmd=${cmd}" --graph_schema_path=${INTERACTIVE_WORKSPACE}/data/ldbc/graph.yaml"
+  echo $cmd
+  eval ${cmd}
+done
 
         for i in 1 2 3 4 5 6 7 8 9 10 11 12;
         do

.gitignore

@@ -100,4 +100,6 @@ flex/interactive/examples/sf0.1-raw/
 flex/interactive/.running
 flex/interactive/.env
 
+flex/**/*.so
+
 **/.cache/

flex/.devcontainer.json

@@ -26,6 +26,9 @@
             ]
         }
     },
+    "mounts": [
+        "source=/mnt/zhanglei,target=/home/graphscope/data/,type=bind,consistency=cached"
+    ],
     // Set `remoteUser` to `root` to connect as root instead. More info: https://aka.ms/vscode-remote/containers/non-root.
     "remoteUser": "graphscope",
     "postCreateCommand": "sudo chown -R graphscope /workspaces && bash pre-commit/install-hook.sh && bash pre-commit/prepare-commit-msg"

flex/codegen/gen_code_from_plan.cc

@@ -83,6 +83,14 @@ void deserialize_plan_and_gen_hqps(const std::string& input_file_path,
   CHECK(plan_pb.ParseFromArray(content_str.data(), content_str.size()));
   LOG(INFO) << "deserialized plan size : " << plan_pb.ByteSizeLong();
   VLOG(1) << "deserialized plan : " << plan_pb.DebugString();
+  std::string output_path = output_file_path + ".json";
+  std::string json_plan;
+  google::protobuf::util::JsonOptions option;
+  option.always_print_primitive_fields = true;
+  google::protobuf::util::MessageToJsonString(plan_pb, &json_plan, option);
+  std::ofstream out(output_path);
+  out << json_plan;
+  out.close();
   BuildingContext context;
   std::shared_ptr<QueryGenerator<uint8_t>> query_generator;
   // load schema

flex/codegen/src/codegen_utils.h

@@ -201,13 +201,16 @@ codegen::ParamConst variable_to_param_const(const common::Variable& var,
     auto& var_property = var.property();
     if (var_property.has_label()) {
       param_const.var_name = "label";
+      param_const.expr_var_name = "label";
       param_const.type = codegen::DataType::kLabelId;
     } else if (var_property.has_key()) {
       param_const.var_name = var.property().key().name();
+      param_const.expr_var_name = var.property().key().name();
       param_const.type =
           common_data_type_pb_2_data_type(var.node_type().data_type());
     } else if (var_property.has_id()) {
       param_const.var_name = ctx.GetNextVarName();
+      param_const.expr_var_name = ctx.GetNextVarName();
       param_const.type = codegen::DataType::kGlobalVertexId;
     } else {
       LOG(FATAL) << "Unexpected property type: " << var_property.DebugString();
@@ -217,6 +220,7 @@ codegen::ParamConst variable_to_param_const(const common::Variable& var,
     if (var.has_node_type()) {
       auto node_type = var.node_type();
       param_const.var_name = ctx.GetNextVarName();
+      param_const.expr_var_name = param_const.var_name;
       if (node_type.type_case() == common::IrDataType::kDataType) {
         param_const.type =
             common_data_type_pb_2_data_type(node_type.data_type());

flex/codegen/src/graph_types.h

@@ -51,13 +51,14 @@ enum class DataType {
 struct ParamConst {
   DataType type;
   std::string var_name;
+  std::string expr_var_name;
   int32_t id;  // unique id for each param const
 };
 
 // implement operator == for ParamConst
 inline bool operator==(const ParamConst& lhs, const ParamConst& rhs) {
   return lhs.type == rhs.type && lhs.var_name == rhs.var_name &&
-         lhs.id == rhs.id;
+         lhs.expr_var_name == rhs.expr_var_name && lhs.id == rhs.id;
 }
 
 }  // namespace codegen
@@ -159,7 +160,7 @@ static codegen::ParamConst param_const_pb_to_param_const(
   CHECK(data_type_pb.type_case() == common::IrDataType::kDataType);
   return codegen::ParamConst{
       common_data_type_pb_2_data_type(data_type_pb.data_type()),
-      param_const_pb.name(), param_const_pb.index()};
+      param_const_pb.name(), param_const_pb.name(), param_const_pb.index()};
 }
 
 static codegen::ParamConst param_const_pb_to_param_const(
@@ -168,7 +169,8 @@ static codegen::ParamConst param_const_pb_to_param_const(
   if (ir_data_type.type_case() == common::IrDataType::kDataType) {
     auto primitive_type = ir_data_type.data_type();
     return codegen::ParamConst{common_data_type_pb_2_data_type(primitive_type),
-                               param_const_pb.name(), param_const_pb.index()};
+                               param_const_pb.name(), param_const_pb.name(),
+                               param_const_pb.index()};
   } else {
     throw std::runtime_error("Expect node type in ir_data_type");
   }
@@ -223,6 +225,8 @@ static std::string decode_type_as_str(const codegen::DataType& data_type) {
     return "get_string()";
   case codegen::DataType::kBoolean:
     return "get_bool()";
+  case codegen::DataType::kDate:
+    return "get_long()";
   default:
     // LOG(FATAL) << "unknown data type" << static_cast<int>(data_type);
     throw std::runtime_error("unknown data type when decode type as str: " +
@@ -279,11 +283,13 @@ static void parse_param_const_from_pb(
   if (data_type.type_case() == common::IrDataType::kDataType) {
     param_cost.type = common_data_type_pb_2_data_type(data_type.data_type());
     param_cost.var_name = param_const_pb.name();
+    param_cost.expr_var_name = param_const_pb.name();
     param_cost.id = param_const_pb.index();
     return;
   } else if (node_type.type_case() == common::IrDataType::kDataType) {
     param_cost.type = common_data_type_pb_2_data_type(node_type.data_type());
     param_cost.var_name = param_const_pb.name();
+    param_cost.expr_var_name = param_const_pb.name();
     param_cost.id = param_const_pb.index();
     return;
   } else {

flex/codegen/src/hqps/hqps_edge_expand_builder.h

@@ -408,12 +408,6 @@ static std::pair<std::string, std::string> BuildMultiLabelEdgeExpandOpt(
 
   std::vector<std::vector<int32_t>> edge_label_triplet =
       parse_edge_label_triplet_from_ir_data_type(meta_data.type());
-  CHECK(edge_label_triplet.size() == prop_names.size());
-  LOG(INFO) << "Find multiple edge triplet: " << edge_label_triplet.size();
-
-  auto func_template_str = make_edge_expand_e_func_template_str(prop_types);
-  auto edge_named_prop_array =
-      make_prop_tuple_array_tuple(prop_names, prop_types);
 
   if (params.has_predicate()) {
     VLOG(10) << "Found expr in edge expand with multiple label triplet";
@@ -424,6 +418,13 @@ static std::pair<std::string, std::string> BuildMultiLabelEdgeExpandOpt(
   boost::format formater;
   if (expand_opt ==
       physical::EdgeExpand::ExpandOpt::EdgeExpand_ExpandOpt_EDGE) {
+    // only parse the prop_names if the expand opt is edge.
+    CHECK(edge_label_triplet.size() == prop_names.size());
+    LOG(INFO) << "Find multiple edge triplet: " << edge_label_triplet.size();
+
+    auto func_template_str = make_edge_expand_e_func_template_str(prop_types);
+    auto edge_named_prop_array =
+        make_prop_tuple_array_tuple(prop_names, prop_types);
     auto edge_triplet_2d_array =
         edge_label_triplet_to_array_str(edge_label_triplet);
     if (params.has_predicate()) {

flex/codegen/src/hqps/hqps_expr_builder.h

@@ -358,7 +358,7 @@ class ExprBuilder {
       // and also set a expr node for it. which is unique.
       make_var_name_unique(param_const);
       func_call_vars_.push_back(param_const);
-      expr_nodes_.emplace_back(param_const.var_name);
+      expr_nodes_.emplace_back(param_const.expr_var_name);
 
       // expr_nodes_.emplace_back(param_const.var_name);
       // convert a variable to a tag property,
@@ -389,7 +389,7 @@ class ExprBuilder {
       VLOG(10) << "receive param const: " << param_const_pb.DebugString();
       make_var_name_unique(param_const);
       construct_params_.push_back(param_const);
-      expr_nodes_.emplace_back(param_const.var_name + "_");
+      expr_nodes_.emplace_back(param_const.expr_var_name);
       break;
     }
 
@@ -534,7 +534,7 @@ class ExprBuilder {
     std::stringstream ss;
     for (size_t i = 0; i < construct_params_.size(); ++i) {
       ss << data_type_2_string(construct_params_[i].type) << " "
-         << construct_params_[i].var_name;
+         << construct_params_[i].expr_var_name;
       if (i + 1 != construct_params_.size()) {
         ss << ",";
       }
@@ -548,8 +548,8 @@ class ExprBuilder {
       ss << ":";
     }
     for (size_t i = 0; i < construct_params_.size(); ++i) {
-      ss << construct_params_[i].var_name << "_"
-         << "(" << construct_params_[i].var_name << ")";
+      ss << construct_params_[i].expr_var_name << "("
+         << construct_params_[i].expr_var_name << ")";
       if (i != construct_params_.size() - 1) {
         ss << ",";
       }
@@ -578,7 +578,7 @@ class ExprBuilder {
     std::stringstream ss;
     for (size_t i = 0; i < func_call_vars_.size(); ++i) {
       ss << data_type_2_string(func_call_vars_[i].type) << " "
-         << func_call_vars_[i].var_name;
+         << func_call_vars_[i].expr_var_name;
       if (i != func_call_vars_.size() - 1) {
         ss << ",";
       }
@@ -600,31 +600,31 @@ class ExprBuilder {
     std::stringstream ss;
     for (size_t i = 0; i < construct_params_.size(); ++i) {
       ss << data_type_2_string(construct_params_[i].type) << " "
-         << construct_params_[i].var_name << "_;" << std::endl;
+         << construct_params_[i].expr_var_name << ";" << std::endl;
     }
     return ss.str();
   }
 
   void make_var_name_unique(codegen::ParamConst& param_const) {
     std::unordered_set<std::string> var_names;
     for (auto& param : construct_params_) {
-      auto res = var_names.insert(param.var_name);
-      CHECK(res.second) << "var name: " << param.var_name
+      auto res = var_names.insert(param.expr_var_name);
+      CHECK(res.second) << "var name: " << param.expr_var_name
                         << " already exists, illegal state";
     }
     for (auto& param : func_call_vars_) {
-      auto res = var_names.insert(param.var_name);
-      CHECK(res.second) << "var name: " << param.var_name
+      auto res = var_names.insert(param.expr_var_name);
+      CHECK(res.second) << "var name: " << param.expr_var_name
                         << " already exists, illegal state";
     }
-    auto cur_var_name = param_const.var_name;
+    auto cur_var_name = param_const.expr_var_name;
     int i = 0;
     while (var_names.find(cur_var_name) != var_names.end()) {
-      cur_var_name = param_const.var_name + "_" + std::to_string(i);
+      cur_var_name = param_const.expr_var_name + "_" + std::to_string(i);
       ++i;
     }
-    param_const.var_name = cur_var_name;
-    VLOG(10) << "make var name unique: " << param_const.var_name;
+    param_const.expr_var_name = cur_var_name;
+    VLOG(10) << "make var name unique: " << param_const.expr_var_name;
   }
 
   // this corresponding to the input params.

flex/codegen/src/hqps/hqps_path_expand_builder.h

@@ -387,10 +387,20 @@ static std::string BuildPathExpandVOp(
 
   // CHECK(!path_expand_pb.has_alias());
   builder.out_tag(out_tag_id);  // out_tag_id overrides alias
+  LOG(INFO) << "path expand op: " << path_expand_pb.DebugString()
+            << ", has get_v: "
+            << std::to_string(path_expand_pb.base().has_get_v());
+
+  physical::GetV get_v_pb;
+  if (path_expand_pb.base().has_get_v()) {
+    get_v_pb = path_expand_pb.base().get_v();
+  } else {
+    VLOG(10) << "get_v seems fused into edge_expand_base";
+    get_v_pb.set_opt(physical::GetV_VOpt_OTHER);
+  }
 
   return builder
-      .path_expand_opt(path_expand_pb.base().edge_expand(),
-                       path_expand_pb.base().get_v(),
+      .path_expand_opt(path_expand_pb.base().edge_expand(), get_v_pb,
                        meta_data)  // get_v_opt must be called first to
                                    // provide dst_label ids.
       .hop_range(path_expand_pb.hop_range())
@@ -422,9 +432,16 @@ static std::string BuildPathExpandPathOp(
     builder.out_tag(-1);
   }
 
+  physical::GetV get_v_pb;
+  if (path_expand_pb.base().has_get_v()) {
+    get_v_pb = path_expand_pb.base().get_v();
+  } else {
+    VLOG(10) << "get_v seems fused into edge_expand_base";
+    get_v_pb.set_opt(physical::GetV_VOpt_OTHER);
+  }
+
   return builder
-      .path_expand_opt(path_expand_pb.base().edge_expand(),
-                       path_expand_pb.base().get_v(),
+      .path_expand_opt(path_expand_pb.base().edge_expand(), get_v_pb,
                        meta_data)  // get_v_opt must be called first to
                                    // provide dst_label ids.
       .hop_range(path_expand_pb.hop_range())

flex/codegen/src/hqps/hqps_project_builder.h

@@ -70,9 +70,6 @@ std::tuple<std::string, std::string, std::string> concatenate_expr_built_result(
   }
   {
     std::stringstream ss;
-    if (func_construct_param_const.size() > 0) {
-      ss << ", ";
-    }
     for (size_t i = 0; i < func_construct_param_const.size(); ++i) {
       ss << func_construct_param_const[i].var_name;
       if (i != func_construct_param_const.size() - 1) {

flex/codegen/src/hqps_generator.h

@@ -258,11 +258,17 @@ class QueryGenerator {
     if (param_vars.size() > 0) {
       sort(param_vars.begin(), param_vars.end(),
            [](const auto& a, const auto& b) { return a.id < b.id; });
+      LOG(INFO) << "param vars size: " << param_vars.size();
+      for (auto& param_var : param_vars) {
+        LOG(INFO) << "param var: " << param_var.id << " " << param_var.var_name;
+      }
       CHECK(param_vars[0].id == 0);
       for (size_t i = 0; i < param_vars.size(); ++i) {
         if (i > 0 && param_vars[i].id == param_vars[i - 1].id) {
           // found duplicate
-          CHECK(param_vars[i] == param_vars[i - 1]);
+          CHECK(param_vars[i].var_name == param_vars[i - 1].var_name)
+              << " " << param_vars[i].var_name << " "
+              << param_vars[i - 1].var_name;
           continue;
         } else {
           ss << data_type_2_string(param_vars[i].type) << " "
@@ -290,7 +296,9 @@ class QueryGenerator {
 
     for (size_t i = 0; i < param_vars.size(); ++i) {
       if (i > 0 && param_vars[i].id == param_vars[i - 1].id) {
-        CHECK(param_vars[i] == param_vars[i - 1]);
+        CHECK(param_vars[i].var_name == param_vars[i - 1].var_name)
+            << " " << i << " " << param_vars[i].var_name << " "
+            << param_vars[i - 1].var_name;
         continue;
       } else {
         auto& cur_param_var = param_vars[i];
@@ -438,7 +446,7 @@ class QueryGenerator {
 
       case physical::PhysicalOpr::Operator::kVertex: {
         physical::PhysicalOpr::MetaData meta_data;
-        LOG(INFO) << "Found a get v operator";
+        LOG(INFO) << "Found a get v operator: " << opr.vertex().DebugString();
         auto& get_v_op = opr.vertex();
         auto get_v_code = BuildGetVOp<LabelT>(ctx_, get_v_op, meta_data);
         // first output code can be empty, just ignore
@@ -468,7 +476,6 @@ class QueryGenerator {
       // Path Expand + GetV shall be always fused.
       case physical::PhysicalOpr::Operator::kPath: {
         physical::PhysicalOpr::MetaData meta_data;
-        LOG(INFO) << "Found a path operator";
         auto& path_op = opr.path();
         if (FUSE_PATH_EXPAND_V && !path_op.has_alias() && (i + 1 < size)) {
           auto& next_op = plan_.plan(i + 1).opr();
@@ -489,6 +496,7 @@ class QueryGenerator {
           }
         }
         LOG(INFO) << " PathExpand to Path";
+        LOG(INFO) << "PathExpand: " << path_op.DebugString();
         // otherwise, just expand path
         auto res = BuildPathExpandPathOp<LabelT>(ctx_, path_op, meta_datas);
         ss << res;

flex/codegen/src/pb_parser/ir_data_type_parser.h

@@ -99,7 +99,9 @@ std::vector<std::vector<int32_t>> parse_edge_label_triplet_from_ir_data_type(
     auto ele = graph_ele_type.element_opt();
     if (ele == common::GraphDataType::GraphElementOpt::
                    GraphDataType_GraphElementOpt_VERTEX) {
-      LOG(ERROR) << "Vertex element does not have edge label triplet.";
+      // We construct edge triplet from source label, destination label and edge
+      // label
+
       return edge_label_triplets;
     } else {
       VLOG(10) << "Get edge label triplet: ";

flex/codegen/src/pegasus_generator.h

@@ -160,7 +160,8 @@ class PegasusGenerator {
     std::string plan_json;
     google::protobuf::util::JsonPrintOptions option;
     option.always_print_primitive_fields = true;
-    auto st = google::protobuf::util::MessageToJsonString(plan_, &plan_json, option);
+    auto st =
+        google::protobuf::util::MessageToJsonString(plan_, &plan_json, option);
     for (auto i = 0; i < size; ++i) {
       auto op = plan_.plan(i);
       LOG(INFO) << "Start codegen for operator " << i;

flex/engines/graph_db/grin/src/property/property.cc

@@ -88,7 +88,7 @@ void grin_destroy_vertex_property(GRIN_GRAPH g, GRIN_VERTEX_PROPERTY vp) {}
  */
 GRIN_DATATYPE grin_get_vertex_property_datatype(GRIN_GRAPH g,
                                                 GRIN_VERTEX_PROPERTY vp) {
-  return (GRIN_DATATYPE)(vp >> 16);
+  return (GRIN_DATATYPE) (vp >> 16);
 }
 
 int grin_get_vertex_property_value_of_int32(GRIN_GRAPH g, GRIN_VERTEX v,

flex/engines/hqps_db/core/base_engine.h

@@ -712,7 +712,7 @@ class BaseEngine {
         auto x_ele = iter.GetAllElement();
         auto pair = std::make_pair(std::get<real_x_ind0>(x_ele),
                                    std::get<real_x_ind1>(x_ele));
-        LOG(INFO) << "pair: " << pair.first << ", " << pair.second;
+        // LOG(INFO) << "pair: " << pair.first << ", " << pair.second;
         if (cur_ind != 0) {
           if (prev_tuple == pair && prev_res) {
             LOG(INFO) << gs::to_string(prev_tuple)