details::RelAlgDispatcher Class Reference

Collaboration diagram for details::RelAlgDispatcher:

Public Member Functions
	RelAlgDispatcher (const Catalog_Namespace::Catalog &cat)
std::vector< std::shared_ptr < RelAlgNode > >	run (const rapidjson::Value &rels, RelAlgDag &root_dag)

Private Member Functions
std::shared_ptr< RelScan >	dispatchTableScan (const rapidjson::Value &scan_ra)
std::shared_ptr< RelProject >	dispatchProject (const rapidjson::Value &proj_ra, RelAlgDag &root_dag)
std::shared_ptr< RelFilter >	dispatchFilter (const rapidjson::Value &filter_ra, RelAlgDag &root_dag)
std::shared_ptr< RelAggregate >	dispatchAggregate (const rapidjson::Value &agg_ra)
std::shared_ptr< RelJoin >	dispatchJoin (const rapidjson::Value &join_ra, RelAlgDag &root_dag)
std::shared_ptr< RelSort >	dispatchSort (const rapidjson::Value &sort_ra)
std::shared_ptr< RelModify >	dispatchModify (const rapidjson::Value &logical_modify_ra)
std::shared_ptr< RelTableFunction >	dispatchTableFunction (const rapidjson::Value &table_func_ra, RelAlgDag &root_dag)
std::shared_ptr< RelLogicalValues >	dispatchLogicalValues (const rapidjson::Value &logical_values_ra)
std::shared_ptr< RelLogicalUnion >	dispatchUnion (const rapidjson::Value &logical_union_ra)
RelAlgInputs	getRelAlgInputs (const rapidjson::Value &node)
std::pair< std::string, std::string >	getKVOptionPair (std::string &str, size_t &pos)
ExplainedQueryHint	parseHintString (std::string &hint_string)
void	getRelAlgHints (const rapidjson::Value &json_node, std::shared_ptr< RelAlgNode > node)
std::shared_ptr< const RelAlgNode >	prev (const rapidjson::Value &crt_node)

Private Attributes
const Catalog_Namespace::Catalog &	cat_
std::vector< std::shared_ptr < RelAlgNode > >	nodes_

Detailed Description

Definition at line 2776 of file RelAlgDag.cpp.

Constructor & Destructor Documentation

details::RelAlgDispatcher::RelAlgDispatcher ( const Catalog_Namespace::Catalog &  cat )

inline

Definition at line 2778 of file RelAlgDag.cpp.

: cat_(cat) {}

Member Function Documentation

std::shared_ptr<RelAggregate> details::RelAlgDispatcher::dispatchAggregate ( const rapidjson::Value &  agg_ra )

inlineprivate

Definition at line 2865 of file RelAlgDag.cpp.

References CHECK, CHECK_EQ, field(), getRelAlgHints(), getRelAlgInputs(), anonymous_namespace{RelAlgDag.cpp}::indices_from_json_array(), anonymous_namespace{RelAlgDag.cpp}::parse_aggregate_expr(), and anonymous_namespace{RelAlgDag.cpp}::strings_from_json_array().

Referenced by run().

                                                                              {
    const auto inputs = getRelAlgInputs(agg_ra);
    CHECK_EQ(size_t(1), inputs.size());
    const auto fields = strings_from_json_array(field(agg_ra, "fields"));
    const auto group = indices_from_json_array(field(agg_ra, "group"));
    for (size_t i = 0; i < group.size(); ++i) {
      CHECK_EQ(i, group[i]);
    }
    if (agg_ra.HasMember("groups") || agg_ra.HasMember("indicator")) {
      throw QueryNotSupported("GROUP BY extensions not supported");
    }
    const auto& aggs_json_arr = field(agg_ra, "aggs");
    CHECK(aggs_json_arr.IsArray());
    std::vector<std::unique_ptr<const RexAgg>> aggs;
    for (auto aggs_json_arr_it = aggs_json_arr.Begin();
         aggs_json_arr_it != aggs_json_arr.End();
         ++aggs_json_arr_it) {
      aggs.emplace_back(parse_aggregate_expr(*aggs_json_arr_it));
    }
    if (agg_ra.HasMember("hints")) {
      auto agg_node =
          std::make_shared<RelAggregate>(group.size(), aggs, fields, inputs.front());
      getRelAlgHints(agg_ra, agg_node);
      return agg_node;
    }
    return std::make_shared<RelAggregate>(group.size(), aggs, fields, inputs.front());
  }

Here is the call graph for this function:

Here is the caller graph for this function:

std::shared_ptr<RelFilter> details::RelAlgDispatcher::dispatchFilter ( const rapidjson::Value &  filter_ra, RelAlgDag &  root_dag  )

inlineprivate

Definition at line 2855 of file RelAlgDag.cpp.

References cat_, CHECK, CHECK_EQ, field(), getRelAlgInputs(), anonymous_namespace{RelAlgDag.cpp}::node_id(), and anonymous_namespace{RelAlgDag.cpp}::parse_scalar_expr().

Referenced by run().

                                                                 {
    const auto inputs = getRelAlgInputs(filter_ra);
    CHECK_EQ(size_t(1), inputs.size());
    const auto id = node_id(filter_ra);
    CHECK(id);
    auto condition = parse_scalar_expr(field(filter_ra, "condition"), cat_, root_dag);
    return std::make_shared<RelFilter>(condition, inputs.front());
  }

Here is the call graph for this function:

Here is the caller graph for this function:

std::shared_ptr<RelJoin> details::RelAlgDispatcher::dispatchJoin ( const rapidjson::Value &  join_ra, RelAlgDag &  root_dag  )

inlineprivate

Definition at line 2893 of file RelAlgDag.cpp.

References cat_, CHECK_EQ, field(), getRelAlgHints(), getRelAlgInputs(), json_str(), anonymous_namespace{RelAlgDag.cpp}::parse_scalar_expr(), and anonymous_namespace{RelAlgDag.cpp}::to_join_type().

Referenced by run().

                                                             {
    const auto inputs = getRelAlgInputs(join_ra);
    CHECK_EQ(size_t(2), inputs.size());
    const auto join_type = to_join_type(json_str(field(join_ra, "joinType")));
    auto filter_rex = parse_scalar_expr(field(join_ra, "condition"), cat_, root_dag);
    if (join_ra.HasMember("hints")) {
      auto join_node =
          std::make_shared<RelJoin>(inputs[0], inputs[1], filter_rex, join_type);
      getRelAlgHints(join_ra, join_node);
      return join_node;
    }
    return std::make_shared<RelJoin>(inputs[0], inputs[1], filter_rex, join_type);
  }

Here is the call graph for this function:

Here is the caller graph for this function:

std::shared_ptr<RelLogicalValues> details::RelAlgDispatcher::dispatchLogicalValues ( const rapidjson::Value &  logical_values_ra )

inlineprivate

Definition at line 3043 of file RelAlgDag.cpp.

References CHECK, CHECK_EQ, field(), json_str(), anonymous_namespace{RelAlgDag.cpp}::parse_literal(), and anonymous_namespace{RelAlgDag.cpp}::parse_type().

Referenced by run().

                                               {
    const auto& tuple_type_arr = field(logical_values_ra, "type");
    CHECK(tuple_type_arr.IsArray());
    std::vector<TargetMetaInfo> tuple_type;
    for (auto tuple_type_arr_it = tuple_type_arr.Begin();
         tuple_type_arr_it != tuple_type_arr.End();
         ++tuple_type_arr_it) {
      const auto component_type = parse_type(*tuple_type_arr_it);
      const auto component_name = json_str(field(*tuple_type_arr_it, "name"));
      tuple_type.emplace_back(component_name, component_type);
    }
    const auto& inputs_arr = field(logical_values_ra, "inputs");
    CHECK(inputs_arr.IsArray());
    const auto& tuples_arr = field(logical_values_ra, "tuples");
    CHECK(tuples_arr.IsArray());

    if (inputs_arr.Size()) {
      throw QueryNotSupported("Inputs not supported in logical values yet.");
    }

    std::vector<RelLogicalValues::RowValues> values;
    if (tuples_arr.Size()) {
      for (const auto& row : tuples_arr.GetArray()) {
        CHECK(row.IsArray());
        const auto values_json = row.GetArray();
        if (!values.empty()) {
          CHECK_EQ(values[0].size(), values_json.Size());
        }
        values.emplace_back(RelLogicalValues::RowValues{});
        for (const auto& value : values_json) {
          CHECK(value.IsObject());
          CHECK(value.HasMember("literal"));
          values.back().emplace_back(parse_literal(value));
        }
      }
    }

    return std::make_shared<RelLogicalValues>(tuple_type, values);
  }

Here is the call graph for this function:

Here is the caller graph for this function:

std::shared_ptr<RelModify> details::RelAlgDispatcher::dispatchModify ( const rapidjson::Value &  logical_modify_ra )

inlineprivate

Definition at line 2930 of file RelAlgDag.cpp.

References cat_, CHECK, CHECK_EQ, RelModify::Delete, field(), getRelAlgInputs(), anonymous_namespace{RelAlgDag.cpp}::getTableFromScanNode(), json_bool(), anonymous_namespace{RelAlgDag.cpp}::json_node_to_string(), json_str(), and RelModify::Update.

Referenced by run().

                                                                                   {
    const auto inputs = getRelAlgInputs(logical_modify_ra);
    CHECK_EQ(size_t(1), inputs.size());

    const auto table_descriptor = getTableFromScanNode(cat_, logical_modify_ra);
    if (table_descriptor->isView) {
      throw std::runtime_error("UPDATE of a view is unsupported.");
    }

    bool flattened = json_bool(field(logical_modify_ra, "flattened"));
    std::string op = json_str(field(logical_modify_ra, "operation"));
    RelModify::TargetColumnList target_column_list;

    if (op == "UPDATE") {
      const auto& update_columns = field(logical_modify_ra, "updateColumnList");
      CHECK(update_columns.IsArray());

      for (auto column_arr_it = update_columns.Begin();
           column_arr_it != update_columns.End();
           ++column_arr_it) {
        target_column_list.push_back(column_arr_it->GetString());
      }
    }

    auto modify_node = std::make_shared<RelModify>(
        cat_, table_descriptor, flattened, op, target_column_list, inputs[0]);
    switch (modify_node->getOperation()) {
      case RelModify::ModifyOperation::Delete: {
        modify_node->applyDeleteModificationsToInputNode();
        break;
      }
      case RelModify::ModifyOperation::Update: {
        modify_node->applyUpdateModificationsToInputNode();
        break;
      }
      default:
        throw std::runtime_error("Unsupported RelModify operation: " +
                                 json_node_to_string(logical_modify_ra));
    }

    return modify_node;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

std::shared_ptr<RelProject> details::RelAlgDispatcher::dispatchProject ( const rapidjson::Value &  proj_ra, RelAlgDag &  root_dag  )

inlineprivate

Definition at line 2833 of file RelAlgDag.cpp.

References cat_, CHECK, CHECK_EQ, field(), getRelAlgHints(), getRelAlgInputs(), anonymous_namespace{RelAlgDag.cpp}::parse_scalar_expr(), and anonymous_namespace{RelAlgDag.cpp}::strings_from_json_array().

Referenced by run().

                                                                   {
    const auto inputs = getRelAlgInputs(proj_ra);
    CHECK_EQ(size_t(1), inputs.size());
    const auto& exprs_json = field(proj_ra, "exprs");
    CHECK(exprs_json.IsArray());
    std::vector<std::unique_ptr<const RexScalar>> exprs;
    for (auto exprs_json_it = exprs_json.Begin(); exprs_json_it != exprs_json.End();
         ++exprs_json_it) {
      exprs.emplace_back(parse_scalar_expr(*exprs_json_it, cat_, root_dag));
    }
    const auto& fields = field(proj_ra, "fields");
    if (proj_ra.HasMember("hints")) {
      auto project_node = std::make_shared<RelProject>(
          exprs, strings_from_json_array(fields), inputs.front());
      getRelAlgHints(proj_ra, project_node);
      return project_node;
    }
    return std::make_shared<RelProject>(
        exprs, strings_from_json_array(fields), inputs.front());
  }

Here is the call graph for this function:

Here is the caller graph for this function:

std::shared_ptr<RelSort> details::RelAlgDispatcher::dispatchSort ( const rapidjson::Value &  sort_ra )

inlineprivate

Definition at line 2908 of file RelAlgDag.cpp.

References CHECK, CHECK_EQ, field(), anonymous_namespace{RelAlgDag.cpp}::get_int_literal_field(), getRelAlgInputs(), json_i64(), anonymous_namespace{RelAlgDag.cpp}::parse_nulls_position(), and anonymous_namespace{RelAlgDag.cpp}::parse_sort_direction().

Referenced by run().

                                                                     {
    const auto inputs = getRelAlgInputs(sort_ra);
    CHECK_EQ(size_t(1), inputs.size());
    std::vector<SortField> collation;
    const auto& collation_arr = field(sort_ra, "collation");
    CHECK(collation_arr.IsArray());
    for (auto collation_arr_it = collation_arr.Begin();
         collation_arr_it != collation_arr.End();
         ++collation_arr_it) {
      const size_t field_idx = json_i64(field(*collation_arr_it, "field"));
      const auto sort_dir = parse_sort_direction(*collation_arr_it);
      const auto null_pos = parse_nulls_position(*collation_arr_it);
      collation.emplace_back(field_idx, sort_dir, null_pos);
    }
    auto limit = get_int_literal_field(sort_ra, "fetch", -1);
    const auto offset = get_int_literal_field(sort_ra, "offset", 0);
    auto ret = std::make_shared<RelSort>(
        collation, limit > 0 ? limit : 0, offset, inputs.front(), limit > 0);
    ret->setEmptyResult(limit == 0);
    return ret;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

std::shared_ptr<RelTableFunction> details::RelAlgDispatcher::dispatchTableFunction ( const rapidjson::Value &  table_func_ra, RelAlgDag &  root_dag  )

inlineprivate

Definition at line 2973 of file RelAlgDag.cpp.

References cat_, CHECK, CHECK_GE, CHECK_LT, field(), getRelAlgInputs(), json_str(), and anonymous_namespace{RelAlgDag.cpp}::parse_scalar_expr().

Referenced by run().

                           {
    const auto inputs = getRelAlgInputs(table_func_ra);
    const auto& invocation = field(table_func_ra, "invocation");
    CHECK(invocation.IsObject());

    const auto& operands = field(invocation, "operands");
    CHECK(operands.IsArray());
    CHECK_GE(operands.Size(), unsigned(0));

    std::vector<const Rex*> col_inputs;
    std::vector<std::unique_ptr<const RexScalar>> table_func_inputs;
    std::vector<std::string> fields;

    for (auto exprs_json_it = operands.Begin(); exprs_json_it != operands.End();
         ++exprs_json_it) {
      const auto& expr_json = *exprs_json_it;
      CHECK(expr_json.IsObject());
      if (expr_json.HasMember("op")) {
        const auto op_str = json_str(field(expr_json, "op"));
        if (op_str == "CAST" && expr_json.HasMember("type")) {
          const auto& expr_type = field(expr_json, "type");
          CHECK(expr_type.IsObject());
          CHECK(expr_type.HasMember("type"));
          const auto& expr_type_name = json_str(field(expr_type, "type"));
          if (expr_type_name == "CURSOR") {
            CHECK(expr_json.HasMember("operands"));
            const auto& expr_operands = field(expr_json, "operands");
            CHECK(expr_operands.IsArray());
            if (expr_operands.Size() != 1) {
              throw std::runtime_error(
                  "Table functions currently only support one ResultSet input");
            }
            auto pos = field(expr_operands[0], "input").GetInt();
            CHECK_LT(pos, inputs.size());
            for (size_t i = inputs[pos]->size(); i > 0; i--) {
              table_func_inputs.emplace_back(
                  std::make_unique<RexAbstractInput>(col_inputs.size()));
              col_inputs.emplace_back(table_func_inputs.back().get());
            }
            continue;
          }
        }
      }
      table_func_inputs.emplace_back(parse_scalar_expr(*exprs_json_it, cat_, root_dag));
    }

    const auto& op_name = field(invocation, "op");
    CHECK(op_name.IsString());

    std::vector<std::unique_ptr<const RexScalar>> table_function_projected_outputs;
    const auto& row_types = field(table_func_ra, "rowType");
    CHECK(row_types.IsArray());
    CHECK_GE(row_types.Size(), unsigned(0));
    const auto& row_types_array = row_types.GetArray();
    for (size_t i = 0; i < row_types_array.Size(); i++) {
      // We don't care about the type information in rowType -- replace each output with
      // a reference to be resolved later in the translator
      table_function_projected_outputs.emplace_back(std::make_unique<RexRef>(i));
      fields.emplace_back("");
    }
    return std::make_shared<RelTableFunction>(op_name.GetString(),
                                              inputs,
                                              fields,
                                              col_inputs,
                                              table_func_inputs,
                                              table_function_projected_outputs);
  }

Here is the call graph for this function:

Here is the caller graph for this function:

std::shared_ptr<RelScan> details::RelAlgDispatcher::dispatchTableScan ( const rapidjson::Value &  scan_ra )

inlineprivate

Definition at line 2820 of file RelAlgDag.cpp.

References cat_, CHECK, anonymous_namespace{RelAlgDag.cpp}::check_empty_inputs_field(), anonymous_namespace{RelAlgDag.cpp}::getFieldNamesFromScanNode(), getRelAlgHints(), and anonymous_namespace{RelAlgDag.cpp}::getTableFromScanNode().

Referenced by run().

                                                                          {
    check_empty_inputs_field(scan_ra);
    CHECK(scan_ra.IsObject());
    const auto td = getTableFromScanNode(cat_, scan_ra);
    const auto field_names = getFieldNamesFromScanNode(scan_ra);
    if (scan_ra.HasMember("hints")) {
      auto scan_node = std::make_shared<RelScan>(td, field_names);
      getRelAlgHints(scan_ra, scan_node);
      return scan_node;
    }
    return std::make_shared<RelScan>(td, field_names);
  }

Here is the call graph for this function:

Here is the caller graph for this function:

std::shared_ptr<RelLogicalUnion> details::RelAlgDispatcher::dispatchUnion ( const rapidjson::Value &  logical_union_ra )

inlineprivate

Definition at line 3084 of file RelAlgDag.cpp.

References CHECK, field(), and getRelAlgInputs().

Referenced by run().

                                              {
    auto inputs = getRelAlgInputs(logical_union_ra);
    auto const& all_type_bool = field(logical_union_ra, "all");
    CHECK(all_type_bool.IsBool());
    return std::make_shared<RelLogicalUnion>(std::move(inputs), all_type_bool.GetBool());
  }

Here is the call graph for this function:

Here is the caller graph for this function:

std::pair<std::string, std::string> details::RelAlgDispatcher::getKVOptionPair ( std::string &  str, size_t &  pos  )

inlineprivate

Definition at line 3104 of file RelAlgDag.cpp.

Referenced by parseHintString().

                                                                             {
    auto option = str.substr(0, pos);
    std::string delim = "=";
    size_t delim_pos = option.find(delim);
    auto key = option.substr(0, delim_pos);
    auto val = option.substr(delim_pos + 1, option.length());
    str.erase(0, pos + delim.length() + 1);
    return {key, val};
  }

Here is the caller graph for this function:

void details::RelAlgDispatcher::getRelAlgHints ( const rapidjson::Value &  json_node, std::shared_ptr< RelAlgNode >  node  )

inlineprivate

Definition at line 3172 of file RelAlgDag.cpp.

References field(), json_str(), and parseHintString().

Referenced by dispatchAggregate(), dispatchJoin(), dispatchProject(), and dispatchTableScan().

                                                      {
    std::string hint_explained = json_str(field(json_node, "hints"));
    size_t pos = 0;
    std::string delim = "|";
    std::vector<std::string> hint_list;
    while ((pos = hint_explained.find(delim)) != std::string::npos) {
      hint_list.emplace_back(hint_explained.substr(0, pos));
      hint_explained.erase(0, pos + delim.length());
    }
    // handling the last one
    hint_list.emplace_back(hint_explained.substr(0, pos));

    const auto agg_node = std::dynamic_pointer_cast<RelAggregate>(node);
    if (agg_node) {
      for (std::string& hint : hint_list) {
        auto parsed_hint = parseHintString(hint);
        agg_node->addHint(parsed_hint);
      }
    }
    const auto project_node = std::dynamic_pointer_cast<RelProject>(node);
    if (project_node) {
      for (std::string& hint : hint_list) {
        auto parsed_hint = parseHintString(hint);
        project_node->addHint(parsed_hint);
      }
    }
    const auto scan_node = std::dynamic_pointer_cast<RelScan>(node);
    if (scan_node) {
      for (std::string& hint : hint_list) {
        auto parsed_hint = parseHintString(hint);
        scan_node->addHint(parsed_hint);
      }
    }
    const auto join_node = std::dynamic_pointer_cast<RelJoin>(node);
    if (join_node) {
      for (std::string& hint : hint_list) {
        auto parsed_hint = parseHintString(hint);
        join_node->addHint(parsed_hint);
      }
    }

    const auto compound_node = std::dynamic_pointer_cast<RelCompound>(node);
    if (compound_node) {
      for (std::string& hint : hint_list) {
        auto parsed_hint = parseHintString(hint);
        compound_node->addHint(parsed_hint);
      }
    }
  }

Here is the call graph for this function:

Here is the caller graph for this function:

RelAlgInputs details::RelAlgDispatcher::getRelAlgInputs ( const rapidjson::Value &  node )

inlineprivate

Definition at line 3092 of file RelAlgDag.cpp.

References field(), nodes_, prev(), and anonymous_namespace{RelAlgDag.cpp}::strings_from_json_array().

Referenced by dispatchAggregate(), dispatchFilter(), dispatchJoin(), dispatchModify(), dispatchProject(), dispatchSort(), dispatchTableFunction(), and dispatchUnion().

                                                           {
    if (node.HasMember("inputs")) {
      const auto str_input_ids = strings_from_json_array(field(node, "inputs"));
      RelAlgInputs ra_inputs;
      for (const auto& str_id : str_input_ids) {
        ra_inputs.push_back(nodes_[std::stoi(str_id)]);
      }
      return ra_inputs;
    }
    return {prev(node)};
  }

Here is the call graph for this function:

Here is the caller graph for this function:

ExplainedQueryHint details::RelAlgDispatcher::parseHintString ( std::string &  hint_string )

inlineprivate

Definition at line 3114 of file RelAlgDag.cpp.

References CHECK, getKVOptionPair(), and RegisteredQueryHint::translateQueryHint().

Referenced by getRelAlgHints().

                                                             {
    std::string white_space_delim = " ";
    int l = hint_string.length();
    hint_string = hint_string.erase(0, 1).substr(0, l - 2);
    size_t pos = 0;
    auto global_hint_checker = [&](const std::string& input_hint_name) -> HintIdentifier {
      bool global_hint = false;
      std::string hint_name = input_hint_name;
      auto global_hint_identifier = hint_name.substr(0, 2);
      if (global_hint_identifier.compare("g_") == 0) {
        global_hint = true;
        hint_name = hint_name.substr(2, hint_string.length());
      }
      return {global_hint, hint_name};
    };
    auto parsed_hint =
        global_hint_checker(hint_string.substr(0, hint_string.find(white_space_delim)));
    auto hint_type = RegisteredQueryHint::translateQueryHint(parsed_hint.hint_name);
    if ((pos = hint_string.find("options:")) != std::string::npos) {
      // need to parse hint options
      std::vector<std::string> tokens;
      bool kv_list_op = false;
      std::string raw_options = hint_string.substr(pos + 8, hint_string.length() - 2);
      if (raw_options.find('{') != std::string::npos) {
        kv_list_op = true;
      } else {
        CHECK(raw_options.find('[') != std::string::npos);
      }
      auto t1 = raw_options.erase(0, 1);
      raw_options = t1.substr(0, t1.length() - 1);
      std::string op_delim = ", ";
      if (kv_list_op) {
        // kv options
        std::unordered_map<std::string, std::string> kv_options;
        while ((pos = raw_options.find(op_delim)) != std::string::npos) {
          auto kv_pair = getKVOptionPair(raw_options, pos);
          kv_options.emplace(kv_pair.first, kv_pair.second);
        }
        // handle the last kv pair
        auto kv_pair = getKVOptionPair(raw_options, pos);
        kv_options.emplace(kv_pair.first, kv_pair.second);
        return {hint_type, parsed_hint.global_hint, false, true, kv_options};
      } else {
        std::vector<std::string> list_options;
        while ((pos = raw_options.find(op_delim)) != std::string::npos) {
          list_options.emplace_back(raw_options.substr(0, pos));
          raw_options.erase(0, pos + white_space_delim.length() + 1);
        }
        // handle the last option
        list_options.emplace_back(raw_options.substr(0, pos));
        return {hint_type, parsed_hint.global_hint, false, false, list_options};
      }
    } else {
      // marker hint: no extra option for this hint
      return {hint_type, parsed_hint.global_hint, true, false};
    }
  }

Here is the call graph for this function:

Here is the caller graph for this function:

std::shared_ptr<const RelAlgNode> details::RelAlgDispatcher::prev ( const rapidjson::Value &  crt_node )

inlineprivate

Definition at line 3223 of file RelAlgDag.cpp.

References CHECK, CHECK_EQ, anonymous_namespace{RelAlgDag.cpp}::node_id(), and nodes_.

Referenced by getRelAlgInputs().

                                                                       {
    const auto id = node_id(crt_node);
    CHECK(id);
    CHECK_EQ(static_cast<size_t>(id), nodes_.size());
    return nodes_.back();
  }

Here is the call graph for this function:

Here is the caller graph for this function:

std::vector<std::shared_ptr<RelAlgNode> > details::RelAlgDispatcher::run ( const rapidjson::Value &  rels, RelAlgDag &  root_dag  )

inline

Definition at line 2780 of file RelAlgDag.cpp.

References CHECK, CHECK_EQ, dispatchAggregate(), dispatchFilter(), dispatchJoin(), dispatchLogicalValues(), dispatchModify(), dispatchProject(), dispatchSort(), dispatchTableFunction(), dispatchTableScan(), dispatchUnion(), field(), json_str(), anonymous_namespace{RelAlgDag.cpp}::node_id(), and nodes_.

Referenced by RelAlgDagBuilder::build().

                                                                    {
    for (auto rels_it = rels.Begin(); rels_it != rels.End(); ++rels_it) {
      const auto& crt_node = *rels_it;
      const auto id = node_id(crt_node);
      CHECK_EQ(static_cast<size_t>(id), nodes_.size());
      CHECK(crt_node.IsObject());
      std::shared_ptr<RelAlgNode> ra_node = nullptr;
      const auto rel_op = json_str(field(crt_node, "relOp"));
      if (rel_op == std::string("EnumerableTableScan") ||
          rel_op == std::string("LogicalTableScan")) {
        ra_node = dispatchTableScan(crt_node);
      } else if (rel_op == std::string("LogicalProject")) {
        ra_node = dispatchProject(crt_node, root_dag);
      } else if (rel_op == std::string("LogicalFilter")) {
        ra_node = dispatchFilter(crt_node, root_dag);
      } else if (rel_op == std::string("LogicalAggregate")) {
        ra_node = dispatchAggregate(crt_node);
      } else if (rel_op == std::string("LogicalJoin")) {
        ra_node = dispatchJoin(crt_node, root_dag);
      } else if (rel_op == std::string("LogicalSort")) {
        ra_node = dispatchSort(crt_node);
      } else if (rel_op == std::string("LogicalValues")) {
        ra_node = dispatchLogicalValues(crt_node);
      } else if (rel_op == std::string("LogicalTableModify")) {
        ra_node = dispatchModify(crt_node);
      } else if (rel_op == std::string("LogicalTableFunctionScan")) {
        ra_node = dispatchTableFunction(crt_node, root_dag);
      } else if (rel_op == std::string("LogicalUnion")) {
        ra_node = dispatchUnion(crt_node);
      } else {
        throw QueryNotSupported(std::string("Node ") + rel_op + " not supported yet");
      }
      nodes_.push_back(ra_node);
    }

    return std::move(nodes_);
  }

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

const Catalog_Namespace::Catalog& details::RelAlgDispatcher::cat_

private

Definition at line 3230 of file RelAlgDag.cpp.

Referenced by dispatchFilter(), dispatchJoin(), dispatchModify(), dispatchProject(), dispatchTableFunction(), and dispatchTableScan().

std::vector<std::shared_ptr<RelAlgNode> > details::RelAlgDispatcher::nodes_

private

Definition at line 3231 of file RelAlgDag.cpp.

Referenced by getRelAlgInputs(), prev(), and run().

---

The documentation for this class was generated from the following file:

• /home/jenkins-slave/workspace/core-os-doxygen/QueryEngine/RelAlgDag.cpp