anonymous_namespace{CalciteAdapter.cpp} Namespace Reference

Classes
class	CalciteAdapter
struct	LogicalSortInfo

Functions
ssize_t	get_agg_operand_idx (const rapidjson::Value &expr)
std::tuple< const rapidjson::Value *, SQLTypeInfo, SQLTypeInfo >	parse_literal (const rapidjson::Value &expr)
std::shared_ptr< Analyzer::Expr >	set_transient_dict (const std::shared_ptr< Analyzer::Expr > expr)
void	reproject_target_entries (std::vector< std::shared_ptr< Analyzer::TargetEntry >> &agg_targets, const std::vector< size_t > &result_proj_indices, const rapidjson::Value &fields)
LogicalSortInfo	get_logical_sort_info (const rapidjson::Value &rels)
Planner::Scan *	get_scan_plan (const TableDescriptor *td, const std::vector< std::shared_ptr< Analyzer::TargetEntry >> &scan_targets, std::list< std::shared_ptr< Analyzer::Expr >> &q, std::list< std::shared_ptr< Analyzer::Expr >> &sq, CalciteAdapter &calcite_adapter)
Planner::Plan *	get_agg_plan (const TableDescriptor *td, const std::vector< std::shared_ptr< Analyzer::TargetEntry >> &scan_targets, const std::vector< std::shared_ptr< Analyzer::TargetEntry >> &agg_targets, const std::list< std::shared_ptr< Analyzer::Expr >> &groupby_exprs, std::list< std::shared_ptr< Analyzer::Expr >> &q, std::list< std::shared_ptr< Analyzer::Expr >> &sq, CalciteAdapter &calcite_adapter)
Planner::Plan *	get_sort_plan (Planner::Plan *plan, const rapidjson::Value &rels, const std::vector< std::shared_ptr< Analyzer::TargetEntry >> &scan_targets, const std::vector< std::shared_ptr< Analyzer::TargetEntry >> &agg_targets)
std::vector< size_t >	collect_reproject_indices (const rapidjson::Value &exprs)
std::vector< std::shared_ptr < Analyzer::TargetEntry > >	get_input_targets (const std::vector< std::shared_ptr< Analyzer::TargetEntry >> &in_targets, const rapidjson::Value &exprs, const rapidjson::Value &fields, CalciteAdapter &calcite_adapter)
bool	needs_result_plan (const rapidjson::Value &exprs)
std::vector< std::shared_ptr < Analyzer::TargetEntry > >	build_var_refs (const std::vector< std::shared_ptr< Analyzer::TargetEntry >> &in_targets)
std::vector< std::shared_ptr < Analyzer::TargetEntry > >	build_result_plan_targets (const std::vector< std::shared_ptr< Analyzer::TargetEntry >> &in_targets, const rapidjson::Value &exprs, const rapidjson::Value &fields, CalciteAdapter &calcite_adapter)
bool	targets_are_refs (const std::vector< std::shared_ptr< Analyzer::TargetEntry >> &in_targets)
std::vector< std::shared_ptr < Analyzer::TargetEntry > >	handle_logical_project (std::vector< std::shared_ptr< Analyzer::TargetEntry >> &child_plan_targets, const std::vector< std::shared_ptr< Analyzer::TargetEntry >> &in_targets, const rapidjson::Value &logical_project, CalciteAdapter &calcite_adapter)
std::vector< std::shared_ptr < Analyzer::TargetEntry > >	handle_logical_aggregate (const std::vector< std::shared_ptr< Analyzer::TargetEntry >> &in_targets, std::list< std::shared_ptr< Analyzer::Expr >> &groupby_exprs, const rapidjson::Value &logical_aggregate, CalciteAdapter &calcite_adapter)
void	add_quals (const std::shared_ptr< Analyzer::Expr > qual_expr, std::list< std::shared_ptr< Analyzer::Expr >> &simple_quals, std::list< std::shared_ptr< Analyzer::Expr >> &quals)
void	collect_used_columns (std::vector< std::shared_ptr< Analyzer::ColumnVar >> &used_cols, const std::shared_ptr< Analyzer::Expr > expr)
std::unordered_set< int >	get_used_table_ids (const std::vector< std::shared_ptr< Analyzer::ColumnVar >> &used_cols)
void	separate_join_quals (std::unordered_map< int, std::list< std::shared_ptr< Analyzer::Expr >>> &quals, std::list< std::shared_ptr< Analyzer::Expr >> &join_quals, const std::list< std::shared_ptr< Analyzer::Expr >> &all_quals)
const std::string	get_op_name (const rapidjson::Value &obj)
bool	match_compound_seq (rapidjson::Value::ConstValueIterator &rels_it, const rapidjson::Value::ConstValueIterator rels_end)
bool	match_filter_project_seq (rapidjson::Value::ConstValueIterator &rels_it, const rapidjson::Value::ConstValueIterator rels_end)
bool	match_sort_seq (rapidjson::Value::ConstValueIterator &rels_it, const rapidjson::Value::ConstValueIterator rels_end)
bool	query_is_supported (const rapidjson::Value &rels)
std::string	pg_shim_impl (const std::string &query)

Function Documentation

void anonymous_namespace{CalciteAdapter.cpp}::add_quals	(	const std::shared_ptr< Analyzer::Expr >	qual_expr,
		std::list< std::shared_ptr< Analyzer::Expr >> &	simple_quals,
		std::list< std::shared_ptr< Analyzer::Expr >> &	quals
	)

Definition at line 940 of file CalciteAdapter.cpp.

References CHECK(), and kAND.

Referenced by translate_query().

                                                            {
  CHECK(qual_expr);
  const auto bin_oper = std::dynamic_pointer_cast<const Analyzer::BinOper>(qual_expr);
  if (!bin_oper) {
    quals.push_back(qual_expr);
    return;
  }
  if (bin_oper->get_optype() == kAND) {
    add_quals(bin_oper->get_own_left_operand(), simple_quals, quals);
    add_quals(bin_oper->get_own_right_operand(), simple_quals, quals);
    return;
  }
  int rte_idx{0};
  const auto simple_qual = bin_oper->normalize_simple_predicate(rte_idx);
  if (simple_qual) {
    simple_quals.push_back(simple_qual);
  } else {
    quals.push_back(qual_expr);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::vector<std::shared_ptr<Analyzer::TargetEntry> > anonymous_namespace{CalciteAdapter.cpp}::build_result_plan_targets	(	const std::vector< std::shared_ptr< Analyzer::TargetEntry >> &	in_targets,
		const rapidjson::Value &	exprs,
		const rapidjson::Value &	fields,
		CalciteAdapter &	calcite_adapter
	)

Definition at line 833 of file CalciteAdapter.cpp.

References build_var_refs(), CHECK(), CHECK_EQ, anonymous_namespace{CalciteAdapter.cpp}::CalciteAdapter::getExprFromNode(), and run_benchmark_import::result.

Referenced by handle_logical_project().

                                     {
  const auto var_refs_to_in_targets = build_var_refs(in_targets);
  std::vector<std::shared_ptr<Analyzer::TargetEntry>> result;
  CHECK(fields.IsArray());
  CHECK_EQ(exprs.Size(), fields.Size());
  auto fields_it = fields.Begin();
  for (auto exprs_it = exprs.Begin(); exprs_it != exprs.End(); ++exprs_it, ++fields_it) {
    const auto analyzer_expr =
        calcite_adapter.getExprFromNode(*exprs_it, var_refs_to_in_targets);
    CHECK(fields_it != exprs.End());
    CHECK(fields_it->IsString());
    result.emplace_back(
        new Analyzer::TargetEntry(fields_it->GetString(), analyzer_expr, false));
  }
  return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::vector<std::shared_ptr<Analyzer::TargetEntry> > anonymous_namespace{CalciteAdapter.cpp}::build_var_refs

(

const std::vector< std::shared_ptr< Analyzer::TargetEntry >> &

in_targets

)

Definition at line 820 of file CalciteAdapter.cpp.

References Analyzer::Var::kINPUT_OUTER, and var_ref().

Referenced by build_result_plan_targets(), and translate_query().

                                                                     {
  std::vector<std::shared_ptr<Analyzer::TargetEntry>> var_refs_to_in_targets;
  for (size_t i = 1; i <= in_targets.size(); ++i) {
    const auto target = in_targets[i - 1];
    var_refs_to_in_targets.emplace_back(new Analyzer::TargetEntry(
        target->get_resname(),
        var_ref(target->get_expr(), Analyzer::Var::kINPUT_OUTER, i),
        false));
  }
  return var_refs_to_in_targets;
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::vector<size_t> anonymous_namespace{CalciteAdapter.cpp}::collect_reproject_indices

(

const rapidjson::Value &

exprs

)

Definition at line 774 of file CalciteAdapter.cpp.

References CHECK().

Referenced by handle_logical_project().

                                                                         {
  std::vector<size_t> result_proj_indices;
  CHECK(exprs.IsArray());
  for (auto exprs_it = exprs.Begin(); exprs_it != exprs.End(); ++exprs_it) {
    CHECK(exprs_it->IsObject());
    result_proj_indices.push_back((*exprs_it)["input"].GetInt());
  }
  return result_proj_indices;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void anonymous_namespace{CalciteAdapter.cpp}::collect_used_columns	(	std::vector< std::shared_ptr< Analyzer::ColumnVar >> &	used_cols,
		const std::shared_ptr< Analyzer::Expr >	expr
	)

Definition at line 963 of file CalciteAdapter.cpp.

Referenced by separate_join_quals().

                                                                  {
  const auto col_var = std::dynamic_pointer_cast<Analyzer::ColumnVar>(expr);
  if (col_var && !std::dynamic_pointer_cast<Analyzer::Var>(col_var)) {
    used_cols.push_back(col_var);
    return;
  }
  const auto uoper = std::dynamic_pointer_cast<Analyzer::UOper>(expr);
  if (uoper) {
    collect_used_columns(used_cols, uoper->get_own_operand());
    return;
  }
  const auto bin_oper = std::dynamic_pointer_cast<Analyzer::BinOper>(expr);
  if (bin_oper) {
    collect_used_columns(used_cols, bin_oper->get_own_left_operand());
    collect_used_columns(used_cols, bin_oper->get_own_right_operand());
    return;
  }
  const auto extract_expr = std::dynamic_pointer_cast<Analyzer::ExtractExpr>(expr);
  if (extract_expr) {
    collect_used_columns(used_cols, extract_expr->get_own_from_expr());
    return;
  }
  const auto datetrunc_expr = std::dynamic_pointer_cast<Analyzer::DatetruncExpr>(expr);
  if (datetrunc_expr) {
    collect_used_columns(used_cols, datetrunc_expr->get_own_from_expr());
    return;
  }
  const auto charlength_expr = std::dynamic_pointer_cast<Analyzer::CharLengthExpr>(expr);
  if (charlength_expr) {
    collect_used_columns(used_cols, charlength_expr->get_own_arg());
    return;
  }
  const auto keyforstring_expr =
      std::dynamic_pointer_cast<Analyzer::KeyForStringExpr>(expr);
  if (keyforstring_expr) {
    collect_used_columns(used_cols, keyforstring_expr->get_own_arg());
    return;
  }
  const auto cardinality_expr =
      std::dynamic_pointer_cast<Analyzer::CardinalityExpr>(expr);
  if (cardinality_expr) {
    collect_used_columns(used_cols, cardinality_expr->get_own_arg());
    return;
  }
  const auto like_expr = std::dynamic_pointer_cast<Analyzer::LikeExpr>(expr);
  if (like_expr) {
    collect_used_columns(used_cols, like_expr->get_own_arg());
    return;
  }
}

Here is the caller graph for this function:

ssize_t anonymous_namespace{CalciteAdapter.cpp}::get_agg_operand_idx

(

const rapidjson::Value &

expr

)

Definition at line 35 of file CalciteAdapter.cpp.

References CHECK().

Referenced by anonymous_namespace{CalciteAdapter.cpp}::CalciteAdapter::translateAggregate().

                                                        {
  CHECK(expr.IsObject());
  CHECK(expr.HasMember("agg"));
  const auto& agg_operands = expr["operands"];
  CHECK(agg_operands.IsArray());
  CHECK(agg_operands.Size() <= 2);
  return agg_operands.Empty() ? -1 : agg_operands[0].GetInt();
}

Here is the call graph for this function:

Here is the caller graph for this function:

Planner::Plan* anonymous_namespace{CalciteAdapter.cpp}::get_agg_plan	(	const TableDescriptor *	td,
		const std::vector< std::shared_ptr< Analyzer::TargetEntry >> &	scan_targets,
		const std::vector< std::shared_ptr< Analyzer::TargetEntry >> &	agg_targets,
		const std::list< std::shared_ptr< Analyzer::Expr >> &	groupby_exprs,
		std::list< std::shared_ptr< Analyzer::Expr >> &	q,
		std::list< std::shared_ptr< Analyzer::Expr >> &	sq,
		CalciteAdapter &	calcite_adapter
	)

Definition at line 744 of file CalciteAdapter.cpp.

References get_scan_plan().

                                     {
  Planner::Plan* plan = get_scan_plan(td, scan_targets, q, sq, calcite_adapter);
  if (!agg_targets.empty()) {
    plan = new Planner::AggPlan(agg_targets, 0., plan, groupby_exprs);
  }
  return plan;
}

Here is the call graph for this function:

std::vector<std::shared_ptr<Analyzer::TargetEntry> > anonymous_namespace{CalciteAdapter.cpp}::get_input_targets	(	const std::vector< std::shared_ptr< Analyzer::TargetEntry >> &	in_targets,
		const rapidjson::Value &	exprs,
		const rapidjson::Value &	fields,
		CalciteAdapter &	calcite_adapter
	)

Definition at line 784 of file CalciteAdapter.cpp.

References CHECK(), CHECK_EQ, anonymous_namespace{CalciteAdapter.cpp}::CalciteAdapter::getExprFromNode(), and run_benchmark_import::result.

Referenced by handle_logical_project().

                                     {
  CHECK(exprs.IsArray());
  CHECK(fields.IsArray());
  CHECK_EQ(exprs.Size(), fields.Size());
  std::vector<std::shared_ptr<Analyzer::TargetEntry>> result;
  if (in_targets.empty()) {
    auto fields_it = fields.Begin();
    for (auto exprs_it = exprs.Begin(); exprs_it != exprs.End();
         ++exprs_it, ++fields_it) {
      const auto proj_expr = calcite_adapter.getExprFromNode(*exprs_it, in_targets);
      CHECK(fields_it != exprs.End());
      CHECK(fields_it->IsString());
      result.emplace_back(
          new Analyzer::TargetEntry(fields_it->GetString(), proj_expr, false));
    }
  } else {
    result = in_targets;
  }
  return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

LogicalSortInfo anonymous_namespace{CalciteAdapter.cpp}::get_logical_sort_info

(

const rapidjson::Value &

rels

)

Definition at line 658 of file CalciteAdapter.cpp.

References CHECK(), CHECK_EQ, anonymous_namespace{CalciteAdapter.cpp}::LogicalSortInfo::limit, anonymous_namespace{CalciteAdapter.cpp}::LogicalSortInfo::offset, anonymous_namespace{CalciteAdapter.cpp}::LogicalSortInfo::order_entries, parse_literal(), and run_benchmark_import::result.

Referenced by get_sort_plan().

                                                                  {
  LogicalSortInfo result;
  bool found{false};
  for (auto rels_it = rels.Begin(); rels_it != rels.End(); ++rels_it) {
    const auto& sort_rel = *rels_it;
    CHECK(sort_rel.IsObject() && sort_rel.HasMember("relOp"));
    if (std::string("LogicalSort") != sort_rel["relOp"].GetString()) {
      continue;
    }
    if (!found) {
      if (sort_rel.HasMember("fetch")) {
        const auto& limit_lit = parse_literal(sort_rel["fetch"]);
        CHECK(std::get<1>(limit_lit).is_decimal() &&
              std::get<1>(limit_lit).get_scale() == 0);
        CHECK(std::get<0>(limit_lit)->IsInt64());
        result.limit = std::get<0>(limit_lit)->GetInt64();
      }
      if (sort_rel.HasMember("offset")) {
        const auto& offset_lit = parse_literal(sort_rel["offset"]);
        CHECK(std::get<1>(offset_lit).is_decimal() &&
              std::get<1>(offset_lit).get_scale() == 0);
        CHECK(std::get<0>(offset_lit)->IsInt64());
        result.offset = std::get<0>(offset_lit)->GetInt64();
      }
      CHECK(sort_rel.HasMember("collation"));
      const auto& collation = sort_rel["collation"];
      CHECK(collation.IsArray());
      for (auto collation_it = collation.Begin(); collation_it != collation.End();
           ++collation_it) {
        const auto& oe_node = *collation_it;
        CHECK(oe_node.IsObject());
        result.order_entries.emplace_back(
            oe_node["field"].GetInt() + 1,
            std::string("DESCENDING") == oe_node["direction"].GetString(),
            std::string("FIRST") == oe_node["nulls"].GetString());
      }
      found = true;
    } else {
      // Looks like there are two structurally identical LogicalSortInfo nodes
      // in the Calcite AST. Validation for now, but maybe they can be different?
      if (sort_rel.HasMember("fetch")) {
        const auto& limit_lit = parse_literal(sort_rel["fetch"]);
        CHECK(std::get<1>(limit_lit).is_decimal() &&
              std::get<1>(limit_lit).get_scale() == 0);
        CHECK(std::get<0>(limit_lit)->IsInt64());
        CHECK_EQ(result.limit, std::get<0>(limit_lit)->GetInt64());
      }
      if (sort_rel.HasMember("offset")) {
        const auto& offset_lit = parse_literal(sort_rel["offset"]);
        CHECK(std::get<1>(offset_lit).is_decimal() &&
              std::get<1>(offset_lit).get_scale() == 0);
        CHECK(std::get<0>(offset_lit)->IsInt64());
        CHECK_EQ(result.offset, std::get<0>(offset_lit)->GetInt64());
      }
      CHECK(sort_rel.HasMember("collation"));
      const auto& collation = sort_rel["collation"];
      CHECK(collation.IsArray());
      CHECK_EQ(static_cast<size_t>(collation.Size()), result.order_entries.size());
      auto oe_it = result.order_entries.begin();
      for (size_t i = 0; i < result.order_entries.size(); ++i, ++oe_it) {
        const auto& oe_node = collation[i];
        const auto& oe = *oe_it;
        CHECK_EQ(oe.is_desc,
                 std::string("DESCENDING") == oe_node["direction"].GetString());
        CHECK_EQ(oe.nulls_first, std::string("FIRST") == oe_node["nulls"].GetString());
      }
    }
  }
  return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

const std::string anonymous_namespace{CalciteAdapter.cpp}::get_op_name

(

const rapidjson::Value &

obj

)

Definition at line 1042 of file CalciteAdapter.cpp.

References CHECK(), and field().

Referenced by match_compound_seq(), match_filter_project_seq(), match_sort_seq(), and query_is_supported().

                                                       {
  CHECK(obj.IsObject());
  const auto field_it = obj.FindMember("relOp");
  CHECK(field_it != obj.MemberEnd());
  const auto& field = field_it->value;
  CHECK(field.IsString());
  return field.GetString();
}

Here is the call graph for this function:

Here is the caller graph for this function:

Planner::Scan* anonymous_namespace{CalciteAdapter.cpp}::get_scan_plan	(	const TableDescriptor *	td,
		const std::vector< std::shared_ptr< Analyzer::TargetEntry >> &	scan_targets,
		std::list< std::shared_ptr< Analyzer::Expr >> &	q,
		std::list< std::shared_ptr< Analyzer::Expr >> &	sq,
		CalciteAdapter &	calcite_adapter
	)

Definition at line 729 of file CalciteAdapter.cpp.

References anonymous_namespace{CalciteAdapter.cpp}::CalciteAdapter::getUsedColumnList(), and TableDescriptor::tableId.

Referenced by get_agg_plan().

                                     {
  return new Planner::Scan(scan_targets,
                           q,
                           0.,
                           nullptr,
                           sq,
                           td->tableId,
                           calcite_adapter.getUsedColumnList(td->tableId));
}

Here is the call graph for this function:

Here is the caller graph for this function:

Planner::Plan* anonymous_namespace{CalciteAdapter.cpp}::get_sort_plan	(	Planner::Plan *	plan,
		const rapidjson::Value &	rels,
		const std::vector< std::shared_ptr< Analyzer::TargetEntry >> &	scan_targets,
		const std::vector< std::shared_ptr< Analyzer::TargetEntry >> &	agg_targets
	)

Definition at line 759 of file CalciteAdapter.cpp.

References get_logical_sort_info().

                                                                      {
  const auto logical_sort_info = get_logical_sort_info(rels);
  if (!logical_sort_info.order_entries.empty()) {
    const auto& sort_target_entries =
        agg_targets.empty() ? scan_targets : agg_targets;  // TODO(alex)
    plan = new Planner::Sort(
        sort_target_entries, 0, plan, logical_sort_info.order_entries, false);
  }
  return plan;
}

Here is the call graph for this function:

std::unordered_set<int> anonymous_namespace{CalciteAdapter.cpp}::get_used_table_ids

(

const std::vector< std::shared_ptr< Analyzer::ColumnVar >> &

used_cols

)

Definition at line 1015 of file CalciteAdapter.cpp.

References run_benchmark_import::result.

Referenced by separate_join_quals().

                                                                  {
  std::unordered_set<int> result;
  for (const auto col_var : used_cols) {
    result.insert(col_var->get_table_id());
  }
  return result;
}

Here is the caller graph for this function:

std::vector<std::shared_ptr<Analyzer::TargetEntry> > anonymous_namespace{CalciteAdapter.cpp}::handle_logical_aggregate	(	const std::vector< std::shared_ptr< Analyzer::TargetEntry >> &	in_targets,
		std::list< std::shared_ptr< Analyzer::Expr >> &	groupby_exprs,
		const rapidjson::Value &	logical_aggregate,
		CalciteAdapter &	calcite_adapter
	)

Definition at line 893 of file CalciteAdapter.cpp.

References CHECK(), CHECK_EQ, anonymous_namespace{CalciteAdapter.cpp}::CalciteAdapter::getExprFromNode(), is_unnest(), Analyzer::Var::kGROUPBY, kUNNEST, run_benchmark_import::result, set_transient_dict(), and var_ref().

Referenced by translate_query().

                                     {
  std::vector<std::shared_ptr<Analyzer::TargetEntry>> result;
  const auto& agg_nodes = logical_aggregate["aggs"];
  const auto& group_nodes = logical_aggregate["group"];
  CHECK(group_nodes.IsArray());
  for (auto group_nodes_it = group_nodes.Begin(); group_nodes_it != group_nodes.End();
       ++group_nodes_it) {
    CHECK(group_nodes_it->IsInt());
    const int target_idx = group_nodes_it->GetInt();
    groupby_exprs.push_back(set_transient_dict(in_targets[target_idx]->get_own_expr()));
  }
  CHECK(agg_nodes.IsArray());
  const auto& fields = logical_aggregate["fields"];
  CHECK(fields.IsArray());
  auto fields_it = fields.Begin();
  for (auto group_nodes_it = group_nodes.Begin(); group_nodes_it != group_nodes.End();
       ++group_nodes_it, ++fields_it) {
    CHECK(group_nodes_it->IsInt());
    const int target_idx = group_nodes_it->GetInt();
    const auto target = in_targets[target_idx];
    CHECK(fields_it != fields.End());
    CHECK(fields_it->IsString());
    CHECK_EQ(target->get_resname(), fields_it->GetString());
    const auto target_expr = set_transient_dict(target->get_own_expr());
    const auto uoper_expr = dynamic_cast<const Analyzer::UOper*>(target_expr.get());
    const bool is_unnest{uoper_expr && uoper_expr->get_optype() == kUNNEST};
    auto group_var_ref = var_ref(target_expr.get(),
                                 Analyzer::Var::kGROUPBY,
                                 group_nodes_it - group_nodes.Begin() + 1);
    result.emplace_back(
        new Analyzer::TargetEntry(target->get_resname(), group_var_ref, is_unnest));
  }
  for (auto agg_nodes_it = agg_nodes.Begin(); agg_nodes_it != agg_nodes.End();
       ++agg_nodes_it, ++fields_it) {
    auto agg_expr = calcite_adapter.getExprFromNode(*agg_nodes_it, in_targets);
    CHECK(fields_it != fields.End());
    CHECK(fields_it->IsString());
    result.emplace_back(
        new Analyzer::TargetEntry(fields_it->GetString(), agg_expr, false));
  }
  return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::vector<std::shared_ptr<Analyzer::TargetEntry> > anonymous_namespace{CalciteAdapter.cpp}::handle_logical_project	(	std::vector< std::shared_ptr< Analyzer::TargetEntry >> &	child_plan_targets,
		const std::vector< std::shared_ptr< Analyzer::TargetEntry >> &	in_targets,
		const rapidjson::Value &	logical_project,
		CalciteAdapter &	calcite_adapter
	)

Definition at line 865 of file CalciteAdapter.cpp.

References build_result_plan_targets(), CHECK(), collect_reproject_indices(), get_input_targets(), needs_result_plan(), reproject_target_entries(), run_benchmark_import::result, and targets_are_refs().

Referenced by translate_query().

                                     {
  const auto exprs_mem_it = logical_project.FindMember("exprs");
  CHECK(exprs_mem_it != logical_project.MemberEnd());
  const auto& exprs = exprs_mem_it->value;
  const auto fields_mem_it = logical_project.FindMember("fields");
  CHECK(fields_mem_it != logical_project.MemberEnd());
  const auto& fields = fields_mem_it->value;
  auto result = get_input_targets(in_targets, exprs, fields, calcite_adapter);
  if (in_targets.empty()) {  // source scan was the table itself
    return result;
  }
  // needs a re-projection or a result plan
  if (needs_result_plan(exprs)) {
    if (!targets_are_refs(result)) {
      child_plan_targets = result;
    }
    return build_result_plan_targets(result, exprs, fields, calcite_adapter);
  } else {  // just target permutation. no need to create a result plan
    const auto reproj_indices = collect_reproject_indices(exprs);
    reproject_target_entries(result, reproj_indices, fields);
  }
  return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool anonymous_namespace{CalciteAdapter.cpp}::match_compound_seq	(	rapidjson::Value::ConstValueIterator &	rels_it,
		const rapidjson::Value::ConstValueIterator	rels_end
	)

Definition at line 1051 of file CalciteAdapter.cpp.

References get_op_name().

Referenced by query_is_supported().

                                                                         {
  auto op_name = get_op_name(*rels_it);
  if (op_name == std::string("LogicalFilter")) {
    ++rels_it;
  }
  op_name = get_op_name(*rels_it++);
  if (op_name != std::string("LogicalProject")) {
    return false;
  }
  if (rels_it == rels_end) {
    return true;
  }
  op_name = get_op_name(*rels_it);
  if (op_name == std::string("LogicalAggregate")) {
    ++rels_it;
    if (rels_it == rels_end) {
      return true;
    }
    op_name = get_op_name(*rels_it);
    if (op_name == std::string("LogicalProject")) {
      ++rels_it;
    }
  }
  return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool anonymous_namespace{CalciteAdapter.cpp}::match_filter_project_seq	(	rapidjson::Value::ConstValueIterator &	rels_it,
		const rapidjson::Value::ConstValueIterator	rels_end
	)

Definition at line 1078 of file CalciteAdapter.cpp.

References CHECK(), and get_op_name().

Referenced by query_is_supported().

                                                                               {
  CHECK(rels_it != rels_end);
  auto op_name = get_op_name(*rels_it++);
  if (op_name != std::string("LogicalFilter")) {
    return false;
  }
  if (rels_it != rels_end && get_op_name(*rels_it) == std::string("LogicalProject")) {
    ++rels_it;
  }
  return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool anonymous_namespace{CalciteAdapter.cpp}::match_sort_seq	(	rapidjson::Value::ConstValueIterator &	rels_it,
		const rapidjson::Value::ConstValueIterator	rels_end
	)

Definition at line 1091 of file CalciteAdapter.cpp.

References get_op_name().

Referenced by query_is_supported().

                                                                     {
  auto op_name = get_op_name(*rels_it++);
  if (op_name != std::string("LogicalSort")) {
    return false;
  }
  if (rels_it == rels_end) {
    return true;
  }
  op_name = get_op_name(*rels_it++);
  if (op_name != std::string("LogicalProject")) {
    return false;
  }
  op_name = get_op_name(*rels_it++);
  if (op_name != std::string("LogicalSort")) {
    return false;
  }
  return rels_it == rels_end;
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool anonymous_namespace{CalciteAdapter.cpp}::needs_result_plan

(

const rapidjson::Value &

exprs

)

Definition at line 809 of file CalciteAdapter.cpp.

References CHECK().

Referenced by handle_logical_project().

                                                    {
  for (auto exprs_it = exprs.Begin(); exprs_it != exprs.End(); ++exprs_it) {
    const auto& expr = *exprs_it;
    CHECK(expr.IsObject());
    if (!expr.HasMember("input")) {
      return true;
    }
  }
  return false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::tuple<const rapidjson::Value*, SQLTypeInfo, SQLTypeInfo> anonymous_namespace{CalciteAdapter.cpp}::parse_literal

(

const rapidjson::Value &

expr

)

Definition at line 44 of file CalciteAdapter.cpp.

References CHECK(), and to_sql_type().

Referenced by anonymous_namespace{RelAlgDagBuilder.cpp}::get_int_literal_field(), get_logical_sort_info(), anonymous_namespace{RelAlgDagBuilder.cpp}::parse_scalar_expr(), and anonymous_namespace{CalciteAdapter.cpp}::CalciteAdapter::translateTypedLiteral().

                                {
  CHECK(expr.IsObject());
  auto val_it = expr.FindMember("literal");
  CHECK(val_it != expr.MemberEnd());
  auto type_it = expr.FindMember("type");
  CHECK(type_it != expr.MemberEnd());
  CHECK(type_it->value.IsString());
  const auto type_name = std::string(type_it->value.GetString());
  auto target_type_it = expr.FindMember("target_type");
  CHECK(target_type_it != expr.MemberEnd());
  CHECK(target_type_it->value.IsString());
  const auto target_type_name = std::string(target_type_it->value.GetString());
  auto scale_it = expr.FindMember("scale");
  CHECK(scale_it != expr.MemberEnd());
  CHECK(scale_it->value.IsInt());
  const int scale = scale_it->value.GetInt();
  auto type_scale_it = expr.FindMember("type_scale");
  CHECK(type_scale_it != expr.MemberEnd());
  CHECK(type_scale_it->value.IsInt());
  const int type_scale = type_scale_it->value.GetInt();
  auto precision_it = expr.FindMember("precision");
  CHECK(precision_it != expr.MemberEnd());
  CHECK(precision_it->value.IsInt());
  const int precision = precision_it->value.GetInt();
  auto type_precision_it = expr.FindMember("type_precision");
  CHECK(type_precision_it != expr.MemberEnd());
  CHECK(type_precision_it->value.IsInt());
  const int type_precision = type_precision_it->value.GetInt();
  SQLTypeInfo ti(to_sql_type(type_name), precision, scale, false);
  SQLTypeInfo target_ti(to_sql_type(target_type_name), type_precision, type_scale, false);
  return std::make_tuple(&(val_it->value), ti, target_ti);
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::string anonymous_namespace{CalciteAdapter.cpp}::pg_shim_impl

(

const std::string &

query

)

Definition at line 1320 of file CalciteAdapter.cpp.

References apply_shim(), LOG, run_benchmark_import::result, and logger::WARNING.

Referenced by pg_shim().

                                               {
  auto result = query;
  {
    boost::regex unnest_expr{R"((\s+|,)(unnest)\s*\()",
                             boost::regex::extended | boost::regex::icase};
    apply_shim(result, unnest_expr, [](std::string& result, const boost::smatch& what) {
      result.replace(what.position(), what.length(), what[1] + "PG_UNNEST(");
    });
  }
  {
    boost::regex cast_true_expr{R"(CAST\s*\(\s*'t'\s+AS\s+boolean\s*\))",
                                boost::regex::extended | boost::regex::icase};
    apply_shim(
        result, cast_true_expr, [](std::string& result, const boost::smatch& what) {
          result.replace(what.position(), what.length(), "true");
        });
  }
  {
    boost::regex cast_false_expr{R"(CAST\s*\(\s*'f'\s+AS\s+boolean\s*\))",
                                 boost::regex::extended | boost::regex::icase};
    apply_shim(
        result, cast_false_expr, [](std::string& result, const boost::smatch& what) {
          result.replace(what.position(), what.length(), "false");
        });
  }
  {
    boost::regex ilike_expr{
        R"((\s+|\()((?!\()[^\s]+)\s+ilike\s+('(?:[^']+|'')+')(\s+escape(\s+('[^']+')))?)",
        boost::regex::perl | boost::regex::icase};
    apply_shim(result, ilike_expr, [](std::string& result, const boost::smatch& what) {
      std::string esc = what[6];
      result.replace(what.position(),
                     what.length(),
                     what[1] + "PG_ILIKE(" + what[2] + ", " + what[3] +
                         (esc.empty() ? "" : ", " + esc) + ")");
    });
  }
  {
    boost::regex regexp_expr{
        R"((\s+)([^\s]+)\s+REGEXP\s+('(?:[^']+|'')+')(\s+escape(\s+('[^']+')))?)",
        boost::regex::perl | boost::regex::icase};
    apply_shim(result, regexp_expr, [](std::string& result, const boost::smatch& what) {
      std::string esc = what[6];
      result.replace(what.position(),
                     what.length(),
                     what[1] + "REGEXP_LIKE(" + what[2] + ", " + what[3] +
                         (esc.empty() ? "" : ", " + esc) + ")");
    });
  }
  {
    boost::regex extract_expr{R"(extract\s*\(\s*(\w+)\s+from\s+(.+)\))",
                              boost::regex::extended | boost::regex::icase};
    apply_shim(result, extract_expr, [](std::string& result, const boost::smatch& what) {
      result.replace(what.position(),
                     what.length(),
                     "PG_EXTRACT('" + what[1] + "', " + what[2] + ")");
    });
  }
  {
    boost::regex date_trunc_expr{R"(date_trunc\s*\(\s*(\w+)\s*,(.*)\))",
                                 boost::regex::extended | boost::regex::icase};
    apply_shim(
        result, date_trunc_expr, [](std::string& result, const boost::smatch& what) {
          result.replace(what.position(),
                         what.length(),
                         "PG_DATE_TRUNC('" + what[1] + "', " + what[2] + ")");
        });
  }
  {
    boost::regex quant_expr{R"(\s(any|all)\s+([^(\s|;)]+))",
                            boost::regex::extended | boost::regex::icase};
    apply_shim(result, quant_expr, [](std::string& result, const boost::smatch& what) {
      std::string qual_name = what[1];
      std::string quant_fname{boost::iequals(qual_name, "any") ? "PG_ANY" : "PG_ALL"};
      result.replace(what.position(), what.length(), quant_fname + "(" + what[2] + ")");
    });
  }
  {
    boost::regex immediate_cast_expr{R"(TIMESTAMP\(([0369])\)\s+('[^']+'))",
                                     boost::regex::extended | boost::regex::icase};
    apply_shim(
        result, immediate_cast_expr, [](std::string& result, const boost::smatch& what) {
          result.replace(what.position(),
                         what.length(),
                         "CAST(" + what[2] + " AS TIMESTAMP(" + what[1] + "))");
        });
  }
  {
    boost::regex timestampadd_expr{R"(TIMESTAMPADD\s*\(\s*(\w+)\s*,)",
                                   boost::regex::extended | boost::regex::icase};
    apply_shim(
        result, timestampadd_expr, [](std::string& result, const boost::smatch& what) {
          result.replace(what.position(), what.length(), "DATEADD('" + what[1] + "',");
        });
  }
  {
    boost::regex us_timestamp_cast_expr{
        R"(CAST\s*\(\s*('[^']+')\s*AS\s*TIMESTAMP\(6\)\s*\))",
        boost::regex::extended | boost::regex::icase};
    apply_shim(result,
               us_timestamp_cast_expr,
               [](std::string& result, const boost::smatch& what) {
                 result.replace(
                     what.position(), what.length(), "usTIMESTAMP(" + what[1] + ")");
               });
  }
  {
    boost::regex ns_timestamp_cast_expr{
        R"(CAST\s*\(\s*('[^']+')\s*AS\s*TIMESTAMP\(9\)\s*\))",
        boost::regex::extended | boost::regex::icase};
    apply_shim(result,
               ns_timestamp_cast_expr,
               [](std::string& result, const boost::smatch& what) {
                 result.replace(
                     what.position(), what.length(), "nsTIMESTAMP(" + what[1] + ")");
               });
  }
  {
    boost::regex corr_expr{R"((\s+|,|\()(corr)\s*\()",
                           boost::regex::extended | boost::regex::icase};
    apply_shim(result, corr_expr, [](std::string& result, const boost::smatch& what) {
      result.replace(what.position(), what.length(), what[1] + "CORRELATION(");
    });
  }
  {
    try {
      // the geography regex pattern is expensive and can sometimes run out of stack space
      // on long queries. Treat it separately from the other shims.
      boost::regex cast_to_geography_expr{
          R"(CAST\s*\(\s*(((?!geography).)+)\s+AS\s+geography\s*\))",
          boost::regex::perl | boost::regex::icase};
      apply_shim(result,
                 cast_to_geography_expr,
                 [](std::string& result, const boost::smatch& what) {
                   result.replace(what.position(),
                                  what.length(),
                                  "CastToGeography(" + what[1] + ")");
                 });
    } catch (const std::exception& e) {
      LOG(WARNING) << "Error apply geography cast shim: " << e.what()
                   << "\nContinuing query parse...";
    }
  }
  return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool anonymous_namespace{CalciteAdapter.cpp}::query_is_supported

(

const rapidjson::Value &

rels

)

Definition at line 1113 of file CalciteAdapter.cpp.

References CHECK(), get_op_name(), match_compound_seq(), match_filter_project_seq(), and match_sort_seq().

Referenced by translate_query().

                                                    {
  rapidjson::Value::ConstValueIterator rels_it = rels.Begin();
  if (std::string("EnumerableTableScan") != get_op_name(*rels_it++)) {
    return false;
  }
  const auto op_name = get_op_name(*rels_it);
  if (op_name == std::string("EnumerableTableScan")) {
    ++rels_it;
    CHECK(rels_it != rels.End());
    if (get_op_name(*rels_it++) != std::string("LogicalJoin")) {
      return false;
    }
  }
  if (!match_compound_seq(rels_it, rels.End())) {
    return false;
  }
  if (rels_it == rels.End()) {
    return true;
  }
  if (get_op_name(*rels_it) == std::string("LogicalSort")) {
    return match_sort_seq(rels_it, rels.End());
  }
  // HAVING query
  if (!match_filter_project_seq(rels_it, rels.End())) {
    return false;
  }
  if (rels_it == rels.End()) {
    return true;
  }
  if (!match_sort_seq(rels_it, rels.End())) {
    return false;
  }
  return rels_it == rels.End();
}

Here is the call graph for this function:

Here is the caller graph for this function:

void anonymous_namespace{CalciteAdapter.cpp}::reproject_target_entries	(	std::vector< std::shared_ptr< Analyzer::TargetEntry >> &	agg_targets,
		const std::vector< size_t > &	result_proj_indices,
		const rapidjson::Value &	fields
	)

Definition at line 628 of file CalciteAdapter.cpp.

References CHECK(), CHECK_EQ, and CHECK_LT.

Referenced by handle_logical_project().

                                  {
  CHECK(fields.IsArray());
  CHECK_EQ(static_cast<size_t>(fields.Size()), result_proj_indices.size());
  if (result_proj_indices.empty()) {
    return;
  }
  std::vector<std::shared_ptr<Analyzer::TargetEntry>> agg_targets_reproj;
  auto fields_it = fields.Begin();
  for (const auto proj_idx : result_proj_indices) {
    CHECK_LT(proj_idx, agg_targets.size());
    CHECK(fields_it != fields.End());
    CHECK(fields_it->IsString());
    const auto te = agg_targets[proj_idx];
    agg_targets_reproj.emplace_back(new Analyzer::TargetEntry(
        fields_it->GetString(), te->get_own_expr(), te->get_unnest()));
    ++fields_it;
  }
  agg_targets.swap(agg_targets_reproj);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void anonymous_namespace{CalciteAdapter.cpp}::separate_join_quals	(	std::unordered_map< int, std::list< std::shared_ptr< Analyzer::Expr >>> &	quals,
		std::list< std::shared_ptr< Analyzer::Expr >> &	join_quals,
		const std::list< std::shared_ptr< Analyzer::Expr >> &	all_quals
	)

Definition at line 1024 of file CalciteAdapter.cpp.

References CHECK(), CHECK_EQ, collect_used_columns(), and get_used_table_ids().

                                                           {
  for (auto qual_candidate : all_quals) {
    std::vector<std::shared_ptr<Analyzer::ColumnVar>> used_columns;
    collect_used_columns(used_columns, qual_candidate);
    const auto used_table_ids = get_used_table_ids(used_columns);
    if (used_table_ids.size() > 1) {
      CHECK_EQ(size_t(2), used_table_ids.size());
      join_quals.push_back(qual_candidate);
    } else {
      CHECK(!used_table_ids.empty());
      quals[*used_table_ids.begin()].push_back(qual_candidate);
    }
  }
}

Here is the call graph for this function:

std::shared_ptr<Analyzer::Expr> anonymous_namespace{CalciteAdapter.cpp}::set_transient_dict

(

const std::shared_ptr< Analyzer::Expr >

expr

)

Definition at line 78 of file CalciteAdapter.cpp.

References kENCODING_DICT, kENCODING_NONE, and TRANSIENT_DICT_ID.

Referenced by handle_logical_aggregate(), anonymous_namespace{RelAlgExecutor.cpp}::set_transient_dict_maybe(), anonymous_namespace{RelAlgExecutor.cpp}::translate_groupby_exprs(), and anonymous_namespace{RelAlgExecutor.cpp}::translate_targets().

                                            {
  const auto& ti = expr->get_type_info();
  if (!ti.is_string() || ti.get_compression() != kENCODING_NONE) {
    return expr;
  }
  auto transient_dict_ti = ti;
  transient_dict_ti.set_compression(kENCODING_DICT);
  transient_dict_ti.set_comp_param(TRANSIENT_DICT_ID);
  transient_dict_ti.set_fixed_size();
  return expr->add_cast(transient_dict_ti);
}

Here is the caller graph for this function:

bool anonymous_namespace{CalciteAdapter.cpp}::targets_are_refs

(

const std::vector< std::shared_ptr< Analyzer::TargetEntry >> &

in_targets

)

Definition at line 854 of file CalciteAdapter.cpp.

References CHECK().

Referenced by handle_logical_project().

                                                                     {
  CHECK(!in_targets.empty());
  for (const auto target : in_targets) {
    if (!dynamic_cast<const Analyzer::Var*>(target->get_expr())) {
      return false;
    }
  }
  return true;
}

Here is the call graph for this function:

Here is the caller graph for this function: