CalciteAdapter.cpp File Reference

#include "CalciteAdapter.h"
#include "CalciteDeserializerUtils.h"
#include "DateTimeTranslator.h"
#include "../Parser/ParserNode.h"
#include "../Shared/StringTransform.h"
#include <rapidjson/document.h>
#include <boost/algorithm/string/predicate.hpp>
#include <boost/algorithm/string/replace.hpp>
#include <boost/regex.hpp>
#include <set>
#include <unordered_map>
#include <unordered_set>

Include dependency graph for CalciteAdapter.cpp:

Go to the source code of this file.

Classes
class	anonymous_namespace{CalciteAdapter.cpp}::CalciteAdapter
struct	anonymous_namespace{CalciteAdapter.cpp}::CalciteAdapter::ColNames
struct	anonymous_namespace{CalciteAdapter.cpp}::LogicalSortInfo

Namespaces
	anonymous_namespace{CalciteAdapter.cpp}

Functions
ssize_t	anonymous_namespace{CalciteAdapter.cpp}::get_agg_operand_idx (const rapidjson::Value &expr)
std::tuple< const rapidjson::Value *, SQLTypeInfo, SQLTypeInfo >	anonymous_namespace{CalciteAdapter.cpp}::parse_literal (const rapidjson::Value &expr)
std::shared_ptr< Analyzer::Expr >	anonymous_namespace{CalciteAdapter.cpp}::set_transient_dict (const std::shared_ptr< Analyzer::Expr > expr)
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)
LogicalSortInfo	anonymous_namespace{CalciteAdapter.cpp}::get_logical_sort_info (const rapidjson::Value &rels)
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)
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)
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)
std::vector< size_t >	anonymous_namespace{CalciteAdapter.cpp}::collect_reproject_indices (const rapidjson::Value &exprs)
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)
bool	anonymous_namespace{CalciteAdapter.cpp}::needs_result_plan (const rapidjson::Value &exprs)
std::vector< std::shared_ptr < Analyzer::TargetEntry > >	anonymous_namespace{CalciteAdapter.cpp}::build_var_refs (const std::vector< std::shared_ptr< Analyzer::TargetEntry >> &in_targets)
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)
bool	anonymous_namespace{CalciteAdapter.cpp}::targets_are_refs (const std::vector< std::shared_ptr< Analyzer::TargetEntry >> &in_targets)
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)
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)
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)
void	anonymous_namespace{CalciteAdapter.cpp}::collect_used_columns (std::vector< std::shared_ptr< Analyzer::ColumnVar >> &used_cols, const std::shared_ptr< Analyzer::Expr > expr)
std::unordered_set< int >	anonymous_namespace{CalciteAdapter.cpp}::get_used_table_ids (const std::vector< std::shared_ptr< Analyzer::ColumnVar >> &used_cols)
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)
const std::string	anonymous_namespace{CalciteAdapter.cpp}::get_op_name (const rapidjson::Value &obj)
bool	anonymous_namespace{CalciteAdapter.cpp}::match_compound_seq (rapidjson::Value::ConstValueIterator &rels_it, const rapidjson::Value::ConstValueIterator rels_end)
bool	anonymous_namespace{CalciteAdapter.cpp}::match_filter_project_seq (rapidjson::Value::ConstValueIterator &rels_it, const rapidjson::Value::ConstValueIterator rels_end)
bool	anonymous_namespace{CalciteAdapter.cpp}::match_sort_seq (rapidjson::Value::ConstValueIterator &rels_it, const rapidjson::Value::ConstValueIterator rels_end)
bool	anonymous_namespace{CalciteAdapter.cpp}::query_is_supported (const rapidjson::Value &rels)
Planner::RootPlan *	translate_query (const std::string &query, const Catalog_Namespace::Catalog &cat)
std::string	anonymous_namespace{CalciteAdapter.cpp}::pg_shim_impl (const std::string &query)
std::string	pg_shim (const std::string &query)

Function Documentation

std::string pg_shim

(

const std::string &

query

)

Definition at line 1468 of file CalciteAdapter.cpp.

References LOG, anonymous_namespace{CalciteAdapter.cpp}::pg_shim_impl(), and logger::WARNING.

Referenced by Parser::CreateViewStmt::execute(), Parser::getResultSet(), MapDHandler::parse_to_ra(), QueryRunner::QueryRunner::parsePlanCalcite(), Parser::InsertIntoTableAsSelectStmt::LocalConnector::query(), QueryRunner::anonymous_namespace{QueryRunner.cpp}::run_select_query_with_filter_push_down(), and QueryRunner::QueryRunner::runSelectQuery().

                                          {
  try {
    return pg_shim_impl(query);
  } catch (const std::exception& e) {
    LOG(WARNING) << "Error applying shim: " << e.what() << "\nContinuing query parse...";
    // boost::regex throws an exception about the complexity of matching when
    // the wrong type of quotes are used or they're mismatched. Let the query
    // through unmodified, the parser will throw a much more informative error.
  }
  return query;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Planner::RootPlan* translate_query	(	const std::string &	query,
		const Catalog_Namespace::Catalog &	cat
	)

Definition at line 1150 of file CalciteAdapter.cpp.

References anonymous_namespace{CalciteAdapter.cpp}::add_quals(), anonymous_namespace{CalciteAdapter.cpp}::build_var_refs(), CHECK(), anonymous_namespace{CalciteAdapter.cpp}::handle_logical_aggregate(), anonymous_namespace{CalciteAdapter.cpp}::handle_logical_project(), and anonymous_namespace{CalciteAdapter.cpp}::query_is_supported().

Referenced by QueryRunner::QueryRunner::parsePlanCalcite().

                                                                        {
  rapidjson::Document query_ast;
  query_ast.Parse(query.c_str());
  CHECK(!query_ast.HasParseError());
  CHECK(query_ast.IsObject());
  const auto& rels = query_ast["rels"];
  if (!query_is_supported(rels)) {
    throw std::runtime_error("This query is not supported yet");
  }
  CHECK(rels.IsArray());
  CalciteAdapter calcite_adapter(cat, rels);
  std::list<std::shared_ptr<Analyzer::Expr>> quals;
  std::list<std::shared_ptr<Analyzer::Expr>> simple_quals;
  std::list<std::shared_ptr<Analyzer::Expr>> result_quals;
  std::list<std::shared_ptr<Analyzer::Expr>> all_join_simple_quals;
  std::list<std::shared_ptr<Analyzer::Expr>> all_join_quals;
  std::vector<std::shared_ptr<Analyzer::TargetEntry>> child_res_targets;
  std::vector<std::shared_ptr<Analyzer::TargetEntry>> res_targets;
  std::list<std::shared_ptr<Analyzer::Expr>> groupby_exprs;
  bool is_agg_plan{false};
  bool is_join{false};
  for (auto rels_it = rels.Begin(); rels_it != rels.End(); ++rels_it) {
    const auto& crt_node = *rels_it;
    CHECK(crt_node.IsObject());
    const auto rel_op_it = crt_node.FindMember("relOp");
    CHECK(rel_op_it != crt_node.MemberEnd());
    CHECK(rel_op_it->value.IsString());
    if (rel_op_it->value.GetString() == std::string("EnumerableTableScan") ||
        rel_op_it->value.GetString() == std::string("LogicalSort")) {
      continue;
    }
    if (rel_op_it->value.GetString() == std::string("LogicalProject")) {
      res_targets = handle_logical_project(
          child_res_targets, res_targets, crt_node, calcite_adapter);
    } else if (rel_op_it->value.GetString() == std::string("LogicalAggregate")) {
      is_agg_plan = true;
      CHECK(!res_targets.empty());
      res_targets =
          handle_logical_aggregate(res_targets, groupby_exprs, crt_node, calcite_adapter);
    } else if (rel_op_it->value.GetString() == std::string("LogicalFilter")) {
      if (res_targets.empty()) {
        if (is_join) {
          add_quals(calcite_adapter.getExprFromNode(crt_node["condition"], {}),
                    all_join_simple_quals,
                    all_join_quals);
        } else {
          add_quals(calcite_adapter.getExprFromNode(crt_node["condition"], {}),
                    simple_quals,
                    quals);
        }
      } else {
        child_res_targets = res_targets;
        res_targets = build_var_refs(res_targets);
        add_quals(calcite_adapter.getExprFromNode(crt_node["condition"], res_targets),
                  result_quals,
                  result_quals);
      }
    } else if (rel_op_it->value.GetString() == std::string("LogicalJoin")) {
      const auto condition = std::dynamic_pointer_cast<Analyzer::Constant>(
          calcite_adapter.getExprFromNode(crt_node["condition"], {}));
      if (!condition) {
        throw std::runtime_error("Unsupported join condition");
      }
      const auto condition_ti = condition->get_type_info();
      CHECK(condition_ti.is_boolean());
      if (crt_node["joinType"].GetString() != std::string("inner")) {
        throw std::runtime_error("Only inner joins supported for now");
      }
      // TODO(alex): use the information in this node?
      is_join = true;
    } else {
      throw std::runtime_error(std::string("Node ") + rel_op_it->value.GetString() +
                               " not supported yet");
    }
  }
  const auto tds = calcite_adapter.getTableDescriptors();
  if (is_join) {
    CHECK_EQ(size_t(2), tds.size());
  } else {
    CHECK_EQ(size_t(1), tds.size());
  }
  CHECK(!res_targets.empty());
  Planner::Plan* plan{nullptr};
  if (is_join) {
    std::unordered_map<int, std::list<std::shared_ptr<Analyzer::Expr>>> scan_quals;
    std::list<std::shared_ptr<Analyzer::Expr>> join_quals;
    separate_join_quals(scan_quals, join_quals, all_join_quals);
    std::unordered_map<int, std::list<std::shared_ptr<Analyzer::Expr>>> scan_simple_quals;
    std::list<std::shared_ptr<Analyzer::Expr>> join_simple_quals;
    separate_join_quals(scan_simple_quals, join_simple_quals, all_join_simple_quals);
    CHECK_LE(scan_quals.size(), size_t(2));
    CHECK_LE(scan_simple_quals.size(), size_t(2));
    const int outer_tid = tds[0]->tableId;
    const int inner_tid = tds[1]->tableId;
    auto outer_plan = get_agg_plan(tds[0],
                                   {},
                                   {},
                                   groupby_exprs,
                                   scan_quals[outer_tid],
                                   scan_simple_quals[outer_tid],
                                   calcite_adapter);
    auto inner_plan = get_agg_plan(tds[1],
                                   {},
                                   {},
                                   groupby_exprs,
                                   scan_quals[inner_tid],
                                   scan_simple_quals[inner_tid],
                                   calcite_adapter);
    if (child_res_targets.empty()) {
      if (is_agg_plan) {
        plan = new Planner::Join({}, join_quals, 0, outer_plan, inner_plan);
        plan = new Planner::AggPlan(res_targets, 0., plan, groupby_exprs);
      } else {
        plan = new Planner::Join(res_targets, join_quals, 0, outer_plan, inner_plan);
      }
    } else {
      if (is_agg_plan) {
        plan = new Planner::Join({}, join_quals, 0, outer_plan, inner_plan);
        plan = new Planner::AggPlan(child_res_targets, 0., plan, groupby_exprs);
      } else {
        plan =
            new Planner::Join(child_res_targets, join_quals, 0, outer_plan, inner_plan);
      }
      plan = new Planner::Result(res_targets, result_quals, 0, plan, {});
    }
  } else if (child_res_targets.empty()) {
    std::vector<std::shared_ptr<Analyzer::TargetEntry>> agg_targets{
        is_agg_plan ? res_targets
                    : std::vector<std::shared_ptr<Analyzer::TargetEntry>>{}};
    std::vector<std::shared_ptr<Analyzer::TargetEntry>> scan_targets{
        is_agg_plan ? std::vector<std::shared_ptr<Analyzer::TargetEntry>>{}
                    : res_targets};
    plan = get_agg_plan(tds[0],
                        scan_targets,
                        agg_targets,
                        groupby_exprs,
                        quals,
                        simple_quals,
                        calcite_adapter);
  } else {
    std::vector<std::shared_ptr<Analyzer::TargetEntry>> agg_targets{
        is_agg_plan ? child_res_targets
                    : std::vector<std::shared_ptr<Analyzer::TargetEntry>>{}};
    std::vector<std::shared_ptr<Analyzer::TargetEntry>> scan_targets{
        is_agg_plan ? std::vector<std::shared_ptr<Analyzer::TargetEntry>>{}
                    : child_res_targets};
    plan = get_agg_plan(tds[0],
                        scan_targets,
                        agg_targets,
                        groupby_exprs,
                        quals,
                        simple_quals,
                        calcite_adapter);
    plan = new Planner::Result(res_targets, result_quals, 0, plan, {});
  }
  CHECK(plan);
  const auto logical_sort_info = get_logical_sort_info(rels);
  plan = get_sort_plan(plan, rels, {}, res_targets);
  return new Planner::RootPlan(plan,
                               kSELECT,
                               tds[0]->tableId,
                               {},
                               cat,
                               logical_sort_info.limit,
                               logical_sort_info.offset);
}

Here is the call graph for this function:

Here is the caller graph for this function: