anonymous_namespace{RelAlgDag.cpp} Namespace Reference

Namespaces
	anonymous_namespace{RelAlgDag.cpp}

Classes
class	RexRebindInputsVisitor
class	RexRebindReindexInputsVisitor
class	PushDownGenericExpressionInWindowFunction
class	RANodeIterator
class	WindowFunctionCollector
class	RexWindowFuncReplacementVisitor
class	RexInputCollector

Typedefs
using	RexInputSet = std::unordered_set< RexInput >

Functions
std::vector< RexInput >	n_outputs (const RelAlgNode *node, const size_t n)
bool	isRenamedInput (const RelAlgNode *node, const size_t index, const std::string &new_name)
std::vector< std::unique_ptr < const RexAgg > >	copyAggExprs (std::vector< std::unique_ptr< const RexAgg >> const &agg_exprs)
std::vector< std::unique_ptr < const RexScalar > >	copyRexScalars (std::vector< std::unique_ptr< const RexScalar >> const &scalar_sources)
std::vector< const Rex * >	remapTargetPointers (std::vector< std::unique_ptr< const RexAgg >> const &agg_exprs_new, std::vector< std::unique_ptr< const RexScalar >> const &scalar_sources_new, std::vector< std::unique_ptr< const RexAgg >> const &agg_exprs_old, std::vector< std::unique_ptr< const RexScalar >> const &scalar_sources_old, std::vector< const Rex * > const &target_exprs_old)
void	reset_table_function_inputs (std::vector< const Rex * > &column_inputs, const std::vector< std::unique_ptr< const RexScalar >> &old_table_func_inputs, const std::vector< std::unique_ptr< const RexScalar >> &new_table_func_inputs)
std::set< std::pair< const RelAlgNode *, int > >	get_equiv_cols (const RelAlgNode *node, const size_t which_col)
std::vector< bool >	get_notnulls (std::vector< TargetMetaInfo > const &tmis0)
bool	same_ignoring_notnull (SQLTypeInfo ti0, SQLTypeInfo ti1)
void	set_notnulls (std::vector< TargetMetaInfo > *tmis0, std::vector< bool > const &notnulls)
unsigned	node_id (const rapidjson::Value &ra_node) noexcept
std::string	json_node_to_string (const rapidjson::Value &node) noexcept
std::unique_ptr< RexAbstractInput >	parse_abstract_input (const rapidjson::Value &expr) noexcept
std::unique_ptr< RexLiteral >	parse_literal (const rapidjson::Value &expr)
std::unique_ptr< const RexScalar >	parse_scalar_expr (const rapidjson::Value &expr, RelAlgDag &root_dag)
SQLTypeInfo	parse_type (const rapidjson::Value &type_obj)
std::vector< std::unique_ptr < const RexScalar > >	parse_expr_array (const rapidjson::Value &arr, RelAlgDag &root_dag)
SqlWindowFunctionKind	parse_window_function_kind (const std::string &name)
std::vector< std::unique_ptr < const RexScalar > >	parse_window_order_exprs (const rapidjson::Value &arr, RelAlgDag &root_dag)
SortDirection	parse_sort_direction (const rapidjson::Value &collation)
NullSortedPosition	parse_nulls_position (const rapidjson::Value &collation)
std::vector< SortField >	parse_window_order_collation (const rapidjson::Value &arr, RelAlgDag &root_dag)
RexWindowFunctionOperator::RexWindowBound	parse_window_bound (const rapidjson::Value &window_bound_obj, RelAlgDag &root_dag)
std::unique_ptr< const RexSubQuery >	parse_subquery (const rapidjson::Value &expr, RelAlgDag &root_dag)
std::unique_ptr< RexOperator >	parse_operator (const rapidjson::Value &expr, RelAlgDag &root_dag)
std::unique_ptr< RexCase >	parse_case (const rapidjson::Value &expr, RelAlgDag &root_dag)
std::vector< std::string >	strings_from_json_array (const rapidjson::Value &json_str_arr) noexcept
std::vector< size_t >	indices_from_json_array (const rapidjson::Value &json_idx_arr) noexcept
std::unique_ptr< const RexAgg >	parse_aggregate_expr (const rapidjson::Value &expr)
JoinType	to_join_type (const std::string &join_type_name)
std::unique_ptr< const RexScalar >	disambiguate_rex (const RexScalar *, const RANodeOutput &)
std::unique_ptr< const RexOperator >	disambiguate_operator (const RexOperator *rex_operator, const RANodeOutput &ra_output) noexcept
std::unique_ptr< const RexCase >	disambiguate_case (const RexCase *rex_case, const RANodeOutput &ra_output)
void	bind_project_to_input (RelProject *project_node, const RANodeOutput &input) noexcept
void	bind_table_func_to_input (RelTableFunction *table_func_node, const RANodeOutput &input) noexcept
void	bind_inputs (const std::vector< std::shared_ptr< RelAlgNode >> &nodes) noexcept
void	handle_query_hint (const std::vector< std::shared_ptr< RelAlgNode >> &nodes, RelAlgDag &rel_alg_dag) noexcept
void	compute_node_hash (const std::vector< std::shared_ptr< RelAlgNode >> &nodes)
void	mark_nops (const std::vector< std::shared_ptr< RelAlgNode >> &nodes) noexcept
void	create_compound (std::vector< std::shared_ptr< RelAlgNode >> &nodes, const std::vector< size_t > &pattern, std::unordered_map< size_t, std::unordered_map< unsigned, RegisteredQueryHint >> &query_hints) noexcept
void	coalesce_nodes (std::vector< std::shared_ptr< RelAlgNode >> &nodes, const std::vector< const RelAlgNode * > &left_deep_joins, std::unordered_map< size_t, std::unordered_map< unsigned, RegisteredQueryHint >> &query_hints)
void	handle_agg_over_join (std::vector< std::shared_ptr< RelAlgNode >> &nodes, std::unordered_map< size_t, std::unordered_map< unsigned, RegisteredQueryHint >> &query_hints)
void	eliminate_redundant_projection (std::vector< std::shared_ptr< RelAlgNode >> &nodes)
void	propagate_hints_to_new_project (std::shared_ptr< RelProject > prev_node, std::shared_ptr< RelProject > new_node, std::unordered_map< size_t, std::unordered_map< unsigned, RegisteredQueryHint >> &query_hints)
void	separate_window_function_expressions (std::vector< std::shared_ptr< RelAlgNode >> &nodes, std::unordered_map< size_t, std::unordered_map< unsigned, RegisteredQueryHint >> &query_hints)
void	add_window_function_pre_project (std::vector< std::shared_ptr< RelAlgNode >> &nodes, const bool always_add_project_if_first_project_is_window_expr, std::unordered_map< size_t, std::unordered_map< unsigned, RegisteredQueryHint >> &query_hints)
int64_t	get_int_literal_field (const rapidjson::Value &obj, const char field[], const int64_t default_val) noexcept
void	check_empty_inputs_field (const rapidjson::Value &node) noexcept
const std::pair< const Catalog_Namespace::Catalog *, const TableDescriptor * >	getCatalogAndTableFromScanNode (const rapidjson::Value &scan_ra)
std::vector< std::string >	getFieldNamesFromScanNode (const rapidjson::Value &scan_ra)

Variables
const unsigned	FIRST_RA_NODE_ID = 1

Typedef Documentation

using anonymous_namespace{RelAlgDag.cpp}::RexInputSet = typedef std::unordered_set<RexInput>

Definition at line 2573 of file RelAlgDag.cpp.

Function Documentation

void anonymous_namespace{RelAlgDag.cpp}::add_window_function_pre_project	(	std::vector< std::shared_ptr< RelAlgNode >> &	nodes,
		const bool	always_add_project_if_first_project_is_window_expr,
		std::unordered_map< size_t, std::unordered_map< unsigned, RegisteredQueryHint >> &	query_hints
	)

Inserts a simple project before any project containing a window function node. Forces all window function inputs into a single contiguous buffer for centralized processing (e.g. in distributed mode). This is also needed when a window function node is preceded by a filter node, both for correctness (otherwise a window operator will be coalesced with its preceding filter node and be computer over unfiltered results, and for performance, as currently filter nodes that are not coalesced into projects keep all columns from the table as inputs, and hence bring everything in memory. Once the new project has been created, the inputs in the window function project must be rewritten to read from the new project, and to index off the projected exprs in the new project.

Definition at line 2653 of file RelAlgDag.cpp.

References anonymous_namespace{Utm.h}::a, CHECK, CHECK_EQ, CHECK_GT, RelAggregate::getGroupByCount(), kBOOLEAN, anonymous_namespace{RelAlgDag.cpp}::anonymous_namespace{RelAlgDag.cpp}::need_pushdown_generic_expr(), propagate_hints_to_new_project(), gpu_enabled::sort(), and VLOG.

Referenced by RelAlgDagBuilder::optimizeDag().

                     {
  std::list<std::shared_ptr<RelAlgNode>> node_list(nodes.begin(), nodes.end());
  size_t project_node_counter{0};
  for (auto node_itr = node_list.begin(); node_itr != node_list.end(); ++node_itr) {
    const auto node = *node_itr;

    auto window_func_project_node = std::dynamic_pointer_cast<RelProject>(node);
    if (!window_func_project_node) {
      continue;
    }
    project_node_counter++;
    if (!window_func_project_node->hasWindowFunctionExpr()) {
      // this projection node does not have a window function
      // expression -- skip to the next node in the DAG.
      continue;
    }

    const auto prev_node_itr = std::prev(node_itr);
    const auto prev_node = *prev_node_itr;
    CHECK(prev_node);

    auto filter_node = std::dynamic_pointer_cast<RelFilter>(prev_node);
    auto join_node = std::dynamic_pointer_cast<RelJoin>(prev_node);

    auto scan_node = std::dynamic_pointer_cast<RelScan>(prev_node);
    const bool has_multi_fragment_scan_input =
        (scan_node &&
         (scan_node->getNumShards() > 0 || scan_node->getNumFragments() > 1));
    auto const [has_generic_expr_in_window_func, needs_expr_pushdown] =
        need_pushdown_generic_expr(window_func_project_node.get());

    // We currently add a preceding project node in one of two conditions:
    // 1. always_add_project_if_first_project_is_window_expr = true, which
    // we currently only set for distributed, but could also be set to support
    // multi-frag window function inputs, either if we can detect that an input table
    // is multi-frag up front, or using a retry mechanism like we do for join filter
    // push down.
    // TODO(todd): Investigate a viable approach for the above.
    // 2. Regardless of #1, if the window function project node is preceded by a
    // filter node. This is required both for correctness and to avoid pulling
    // all source input columns into memory since non-coalesced filter node
    // inputs are currently not pruned or eliminated via dead column elimination.
    // Note that we expect any filter node followed by a project node to be coalesced
    // into a single compound node in RelAlgDag::coalesce_nodes, and that action
    // prunes unused inputs.
    // TODO(todd): Investigate whether the shotgun filter node issue affects other
    // query plans, i.e. filters before joins, and whether there is a more general
    // approach to solving this (will still need the preceding project node for
    // window functions preceded by filter nodes for correctness though)
    // 3. Similar to the above, when the window function project node is preceded
    // by a join node.
    // 4. when partition by / order by clauses have a general expression instead of
    // referencing column

    if (!((always_add_project_if_first_project_is_window_expr &&
           project_node_counter == 1) ||
          filter_node || join_node || has_multi_fragment_scan_input ||
          needs_expr_pushdown)) {
      continue;
    }

    if (needs_expr_pushdown || join_node) {
      // previous logic cannot cover join_node case well, so use the newly introduced
      // push-down expression logic to safely add pre_project node before processing
      // window function
      std::unordered_map<size_t, size_t> expr_offset_cache;
      std::vector<std::unique_ptr<const RexScalar>> scalar_exprs_for_new_project;
      std::vector<std::unique_ptr<const RexScalar>> scalar_exprs_for_window_project;
      std::vector<std::string> fields_for_window_project;
      std::vector<std::string> fields_for_new_project;

      // step 0. create new project node with an empty scalar expr to rebind target
      // exprs
      std::vector<std::unique_ptr<const RexScalar>> dummy_scalar_exprs;
      std::vector<std::string> dummy_fields;
      auto new_project =
          std::make_shared<RelProject>(dummy_scalar_exprs, dummy_fields, prev_node);

      // step 1 - 2
      PushDownGenericExpressionInWindowFunction visitor(new_project,
                                                        scalar_exprs_for_new_project,
                                                        fields_for_new_project,
                                                        expr_offset_cache);
      for (size_t i = 0; i < window_func_project_node->size(); ++i) {
        auto projected_target = window_func_project_node->getProjectAt(i);
        auto new_projection_target = visitor.visit(projected_target);
        scalar_exprs_for_window_project.emplace_back(
            std::move(new_projection_target.release()));
      }
      new_project->setExpressions(scalar_exprs_for_new_project);
      new_project->setFields(std::move(fields_for_new_project));
      bool has_groupby = false;
      auto aggregate = std::dynamic_pointer_cast<RelAggregate>(prev_node);
      if (aggregate) {
        has_groupby = aggregate->getGroupByCount() > 0;
      }
      // force rowwise output to prevent computing incorrect query result
      if (has_groupby && visitor.hasPartitionExpression()) {
        // we currently may compute incorrect result with columnar output when
        // 1) the window function has partition expression, and
        // 2) a parent node of the window function projection node has group by
        // expression todo (yoonmin) : relax this
        VLOG(1)
            << "Query output overridden to row-wise format due to presence of a window "
               "function with partition expression and group-by expression.";
        new_project->forceRowwiseOutput();
      } else if (has_generic_expr_in_window_func) {
        VLOG(1) << "Query output overridden to row-wise format due to presence of a "
                   "generic expression as an input expression of the window "
                   "function.";
        new_project->forceRowwiseOutput();
      } else if (visitor.hasCaseExprAsWindowOperand()) {
        VLOG(1)
            << "Query output overridden to row-wise format due to presence of a window "
               "function with a case statement as its operand.";
        new_project->forceRowwiseOutput();
      }

      // step 3. finalize
      propagate_hints_to_new_project(window_func_project_node, new_project, query_hints);
      new_project->setPushedDownWindowExpr();
      node_list.insert(node_itr, new_project);
      window_func_project_node->replaceInput(prev_node, new_project);
      window_func_project_node->setExpressions(scalar_exprs_for_window_project);
    } else {
      // try to push rex_inputs listed in the projection target exprs down to a new
      // project node
      RexInputSet inputs;
      RexInputCollector input_collector;
      for (size_t i = 0; i < window_func_project_node->size(); i++) {
        auto new_inputs =
            input_collector.visit(window_func_project_node->getProjectAt(i));
        inputs.insert(new_inputs.begin(), new_inputs.end());
      }
      std::vector<std::unique_ptr<const RexScalar>> scalar_exprs;
      std::vector<std::string> fields;
      std::unordered_map<unsigned, unsigned> old_index_to_new_index;

      if (inputs.empty()) {
        // this case only happens when the input is multi-fragmented but has no expr(s)
        // to push down in the window_func_project_node's target exprs such as
        // SELECT SUM(1), ROW_NUMBER() over () FROM test where test is multi-fragmented
        // to handle this, we push an artificial literal down to the child project node
        // to make an input of window_func_project_node a single-fragmented table
        CHECK(has_multi_fragment_scan_input);
        CHECK(!needs_expr_pushdown);
        auto const bool_scale = std::numeric_limits<int32_t>::min();
        scalar_exprs.push_back(std::make_unique<RexLiteral>(
            true, SQLTypes::kBOOLEAN, SQLTypes::kBOOLEAN, bool_scale, 1, bool_scale, 1));
        old_index_to_new_index.insert(std::make_pair(0, 0));
        fields.emplace_back("");
      } else {
        // we have at least one rex_input to pushdown
        // let's make sure we have the correct # of exprs to pushdown
        std::vector<RexInput> sorted_inputs(inputs.begin(), inputs.end());
        std::sort(
            sorted_inputs.begin(), sorted_inputs.end(), [](const auto& a, const auto& b) {
              return a.getIndex() < b.getIndex();
            });

        for (auto& input : sorted_inputs) {
          CHECK_EQ(input.getSourceNode(), prev_node.get());
          CHECK(old_index_to_new_index
                    .insert(std::make_pair(input.getIndex(), scalar_exprs.size()))
                    .second);
          scalar_exprs.emplace_back(input.deepCopy());
          fields.emplace_back("");
        }
      }
      // modify window_func_project_node's target exprs to refer to push-downed expr in
      // the new projection node
      CHECK_GT(scalar_exprs.size(), 0UL);
      CHECK_EQ(scalar_exprs.size(), fields.size());
      auto new_project = std::make_shared<RelProject>(scalar_exprs, fields, prev_node);
      propagate_hints_to_new_project(window_func_project_node, new_project, query_hints);
      new_project->setPushedDownWindowExpr();
      node_list.insert(node_itr, new_project);
      window_func_project_node->replaceInput(
          prev_node, new_project, old_index_to_new_index);
    }
  }
  nodes.assign(node_list.begin(), node_list.end());
}

Here is the call graph for this function:

Here is the caller graph for this function:

void anonymous_namespace{RelAlgDag.cpp}::bind_inputs ( const std::vector< std::shared_ptr< RelAlgNode >> &  nodes )

noexcept

Definition at line 1532 of file RelAlgDag.cpp.

References bind_project_to_input(), bind_table_func_to_input(), CHECK_EQ, disambiguate_rex(), and get_node_output().

Referenced by RelAlgDagBuilder::build().

                                                                             {
  for (auto ra_node : nodes) {
    const auto filter_node = std::dynamic_pointer_cast<RelFilter>(ra_node);
    if (filter_node) {
      CHECK_EQ(size_t(1), filter_node->inputCount());
      auto disambiguated_condition = disambiguate_rex(
          filter_node->getCondition(), get_node_output(filter_node->getInput(0)));
      filter_node->setCondition(disambiguated_condition);
      continue;
    }
    const auto join_node = std::dynamic_pointer_cast<RelJoin>(ra_node);
    if (join_node) {
      CHECK_EQ(size_t(2), join_node->inputCount());
      auto disambiguated_condition =
          disambiguate_rex(join_node->getCondition(), get_node_output(join_node.get()));
      join_node->setCondition(disambiguated_condition);
      continue;
    }
    const auto project_node = std::dynamic_pointer_cast<RelProject>(ra_node);
    if (project_node) {
      bind_project_to_input(project_node.get(),
                            get_node_output(project_node->getInput(0)));
      continue;
    }
    const auto table_func_node = std::dynamic_pointer_cast<RelTableFunction>(ra_node);
    if (table_func_node) {
      /*
        Collect all inputs from table function input (non-literal)
        arguments.
      */
      RANodeOutput input;
      input.reserve(table_func_node->inputCount());
      for (size_t i = 0; i < table_func_node->inputCount(); i++) {
        auto node_output = get_node_output(table_func_node->getInput(i));
        input.insert(input.end(), node_output.begin(), node_output.end());
      }
      bind_table_func_to_input(table_func_node.get(), input);
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void anonymous_namespace{RelAlgDag.cpp}::bind_project_to_input ( RelProject *  project_node, const RANodeOutput &  input  )

noexcept

Definition at line 1504 of file RelAlgDag.cpp.

References CHECK_EQ, and disambiguate_rex().

Referenced by bind_inputs(), and create_compound().

                                                                                         {
  CHECK_EQ(size_t(1), project_node->inputCount());
  std::vector<std::unique_ptr<const RexScalar>> disambiguated_exprs;
  for (size_t i = 0; i < project_node->size(); ++i) {
    const auto projected_expr = project_node->getProjectAt(i);
    if (dynamic_cast<const RexSubQuery*>(projected_expr)) {
      disambiguated_exprs.emplace_back(project_node->getProjectAtAndRelease(i));
    } else {
      disambiguated_exprs.emplace_back(disambiguate_rex(projected_expr, input));
    }
  }
  project_node->setExpressions(disambiguated_exprs);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void anonymous_namespace{RelAlgDag.cpp}::bind_table_func_to_input ( RelTableFunction *  table_func_node, const RANodeOutput &  input  )

noexcept

Definition at line 1518 of file RelAlgDag.cpp.

References disambiguate_rex().

Referenced by bind_inputs().

                                                                  {
  std::vector<std::unique_ptr<const RexScalar>> disambiguated_exprs;
  for (size_t i = 0; i < table_func_node->getTableFuncInputsSize(); ++i) {
    const auto target_expr = table_func_node->getTableFuncInputAt(i);
    if (dynamic_cast<const RexSubQuery*>(target_expr)) {
      disambiguated_exprs.emplace_back(table_func_node->getTableFuncInputAtAndRelease(i));
    } else {
      disambiguated_exprs.emplace_back(disambiguate_rex(target_expr, input));
    }
  }
  table_func_node->setTableFuncInputs(std::move(disambiguated_exprs));
}

Here is the call graph for this function:

Here is the caller graph for this function:

void anonymous_namespace{RelAlgDag.cpp}::check_empty_inputs_field ( const rapidjson::Value &  node )

noexcept

Definition at line 2855 of file RelAlgDag.cpp.

References CHECK, and field().

Referenced by details::RelAlgDispatcher::dispatchTableScan().

                                                                   {
  const auto& inputs_json = field(node, "inputs");
  CHECK(inputs_json.IsArray() && !inputs_json.Size());
}

Here is the call graph for this function:

Here is the caller graph for this function:

void anonymous_namespace{RelAlgDag.cpp}::coalesce_nodes	(	std::vector< std::shared_ptr< RelAlgNode >> &	nodes,
		const std::vector< const RelAlgNode * > &	left_deep_joins,
		std::unordered_map< size_t, std::unordered_map< unsigned, RegisteredQueryHint >> &	query_hints
	)

Definition at line 2011 of file RelAlgDag.cpp.

References anonymous_namespace{RelAlgDag.cpp}::RANodeIterator::allVisited(), CHECK, CHECK_GE, create_compound(), anonymous_namespace{RelAlgDag.cpp}::anonymous_namespace{RelAlgDag.cpp}::input_can_be_coalesced(), and gpu_enabled::swap().

Referenced by RelAlgDagBuilder::optimizeDag().

                     {
  enum class CoalesceState { Initial, Filter, FirstProject, Aggregate };
  std::vector<size_t> crt_pattern;
  CoalesceState crt_state{CoalesceState::Initial};

  auto reset_state = [&crt_pattern, &crt_state]() {
    crt_state = CoalesceState::Initial;
    std::vector<size_t>().swap(crt_pattern);
  };

  for (RANodeIterator nodeIt(nodes); !nodeIt.allVisited();) {
    const auto ra_node = nodeIt != nodes.end() ? *nodeIt : nullptr;
    switch (crt_state) {
      case CoalesceState::Initial: {
        if (std::dynamic_pointer_cast<const RelFilter>(ra_node) &&
            std::find(left_deep_joins.begin(), left_deep_joins.end(), ra_node.get()) ==
                left_deep_joins.end()) {
          crt_pattern.push_back(size_t(nodeIt));
          crt_state = CoalesceState::Filter;
          nodeIt.advance(RANodeIterator::AdvancingMode::DUChain);
        } else if (auto project_node =
                       std::dynamic_pointer_cast<const RelProject>(ra_node)) {
          if (project_node->hasWindowFunctionExpr()) {
            nodeIt.advance(RANodeIterator::AdvancingMode::InOrder);
          } else {
            crt_pattern.push_back(size_t(nodeIt));
            crt_state = CoalesceState::FirstProject;
            nodeIt.advance(RANodeIterator::AdvancingMode::DUChain);
          }
        } else {
          nodeIt.advance(RANodeIterator::AdvancingMode::InOrder);
        }
        break;
      }
      case CoalesceState::Filter: {
        if (auto project_node = std::dynamic_pointer_cast<const RelProject>(ra_node)) {
          // Given we now add preceding projects for all window functions following
          // RelFilter nodes, the following should never occur
          CHECK(!project_node->hasWindowFunctionExpr());
          crt_pattern.push_back(size_t(nodeIt));
          crt_state = CoalesceState::FirstProject;
          nodeIt.advance(RANodeIterator::AdvancingMode::DUChain);
        } else {
          reset_state();
        }
        break;
      }
      case CoalesceState::FirstProject: {
        if (std::dynamic_pointer_cast<const RelAggregate>(ra_node)) {
          crt_pattern.push_back(size_t(nodeIt));
          crt_state = CoalesceState::Aggregate;
          nodeIt.advance(RANodeIterator::AdvancingMode::DUChain);
        } else {
          if (crt_pattern.size() >= 2) {
            create_compound(nodes, crt_pattern, query_hints);
          }
          reset_state();
        }
        break;
      }
      case CoalesceState::Aggregate: {
        if (auto project_node = std::dynamic_pointer_cast<const RelProject>(ra_node)) {
          if (!project_node->hasWindowFunctionExpr()) {
            // TODO(adb): overloading the simple project terminology again here
            bool is_simple_project{true};
            for (size_t i = 0; i < project_node->size(); i++) {
              const auto scalar_rex = project_node->getProjectAt(i);
              // If the top level scalar rex is an input node, we can bypass the visitor
              if (auto input_rex = dynamic_cast<const RexInput*>(scalar_rex)) {
                if (!input_can_be_coalesced(
                        input_rex->getSourceNode(), input_rex->getIndex(), true)) {
                  is_simple_project = false;
                  break;
                }
                continue;
              }
              CoalesceSecondaryProjectVisitor visitor;
              if (!visitor.visit(project_node->getProjectAt(i))) {
                is_simple_project = false;
                break;
              }
            }
            if (is_simple_project) {
              crt_pattern.push_back(size_t(nodeIt));
              nodeIt.advance(RANodeIterator::AdvancingMode::InOrder);
            }
          }
        }
        CHECK_GE(crt_pattern.size(), size_t(2));
        create_compound(nodes, crt_pattern, query_hints);
        reset_state();
        break;
      }
      default:
        CHECK(false);
    }
  }
  if (crt_state == CoalesceState::FirstProject || crt_state == CoalesceState::Aggregate) {
    if (crt_pattern.size() >= 2) {
      create_compound(nodes, crt_pattern, query_hints);
    }
    CHECK(!crt_pattern.empty());
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void anonymous_namespace{RelAlgDag.cpp}::compute_node_hash

(

const std::vector< std::shared_ptr< RelAlgNode >> &

nodes

)

Definition at line 1611 of file RelAlgDag.cpp.

References CHECK_NE.

Referenced by RelAlgDagBuilder::optimizeDag().

                                                                          {
  // compute each rel node's hash value in advance to avoid inconsistency of their hash
  // values depending on the toHash's caller
  // specifically, we manipulate our logical query plan before retrieving query step
  // sequence but once we compute a hash value we cached it so there is no way to update
  // it after the plan has been changed starting from the top node, we compute the hash
  // value (top-down manner)
  std::for_each(
      nodes.rbegin(), nodes.rend(), [](const std::shared_ptr<RelAlgNode>& node) {
        auto node_hash = node->toHash();
        CHECK_NE(node_hash, static_cast<size_t>(0));
      });
}

Here is the caller graph for this function:

std::vector<std::unique_ptr<const RexAgg> > anonymous_namespace{RelAlgDag.cpp}::copyAggExprs

(

std::vector< std::unique_ptr< const RexAgg >> const &

agg_exprs

)

Definition at line 617 of file RelAlgDag.cpp.

                                                             {
  std::vector<std::unique_ptr<const RexAgg>> agg_exprs_copy;
  agg_exprs_copy.reserve(agg_exprs.size());
  for (auto const& agg_expr : agg_exprs) {
    agg_exprs_copy.push_back(agg_expr->deepCopy());
  }
  return agg_exprs_copy;
}

std::vector<std::unique_ptr<const RexScalar> > anonymous_namespace{RelAlgDag.cpp}::copyRexScalars

(

std::vector< std::unique_ptr< const RexScalar >> const &

scalar_sources

)

Definition at line 627 of file RelAlgDag.cpp.

References RexVisitorBase< T >::visit().

                                                                     {
  std::vector<std::unique_ptr<const RexScalar>> scalar_sources_copy;
  scalar_sources_copy.reserve(scalar_sources.size());
  RexDeepCopyVisitor copier;
  for (auto const& scalar_source : scalar_sources) {
    scalar_sources_copy.push_back(copier.visit(scalar_source.get()));
  }
  return scalar_sources_copy;
}

Here is the call graph for this function:

void anonymous_namespace{RelAlgDag.cpp}::create_compound ( std::vector< std::shared_ptr< RelAlgNode >> &  nodes, const std::vector< size_t > &  pattern, std::unordered_map< size_t, std::unordered_map< unsigned, RegisteredQueryHint >> &  query_hints  )

noexcept

Definition at line 1685 of file RelAlgDag.cpp.

References bind_project_to_input(), CHECK, CHECK_EQ, CHECK_GE, CHECK_LE, CHECK_LT, RegisteredQueryHint::defaults(), get_node_output(), RelProject::getFields(), anonymous_namespace{RelAlgExecutor.cpp}::is_agg(), node_id(), anonymous_namespace{RelAlgDag.cpp}::anonymous_namespace{RelAlgDag.cpp}::reproject_targets(), and run_benchmark_import::result.

Referenced by coalesce_nodes().

                              {
  CHECK_GE(pattern.size(), size_t(2));
  CHECK_LE(pattern.size(), size_t(4));

  std::unique_ptr<const RexScalar> filter_rex;
  std::vector<std::unique_ptr<const RexScalar>> scalar_sources;
  size_t groupby_count{0};
  std::vector<std::string> fields;
  std::vector<const RexAgg*> agg_exprs;
  std::vector<const Rex*> target_exprs;
  bool first_project{true};
  bool is_agg{false};
  RelAlgNode* last_node{nullptr};

  std::shared_ptr<ModifyManipulationTarget> manipulation_target;
  size_t node_hash{0};
  unsigned node_id{0};
  bool hint_registered{false};
  RegisteredQueryHint registered_query_hint = RegisteredQueryHint::defaults();
  for (const auto node_idx : pattern) {
    const auto ra_node = nodes[node_idx];
    auto registered_query_hint_map_it = query_hints.find(ra_node->toHash());
    if (registered_query_hint_map_it != query_hints.end()) {
      auto& registered_query_hint_map = registered_query_hint_map_it->second;
      auto registered_query_hint_it = registered_query_hint_map.find(ra_node->getId());
      if (registered_query_hint_it != registered_query_hint_map.end()) {
        hint_registered = true;
        node_hash = registered_query_hint_map_it->first;
        node_id = registered_query_hint_it->first;
        registered_query_hint = registered_query_hint_it->second;
      }
    }
    const auto ra_filter = std::dynamic_pointer_cast<RelFilter>(ra_node);
    if (ra_filter) {
      CHECK(!filter_rex);
      filter_rex.reset(ra_filter->getAndReleaseCondition());
      CHECK(filter_rex);
      last_node = ra_node.get();
      continue;
    }
    const auto ra_project = std::dynamic_pointer_cast<RelProject>(ra_node);
    if (ra_project) {
      fields = ra_project->getFields();
      manipulation_target = ra_project;

      if (first_project) {
        CHECK_EQ(size_t(1), ra_project->inputCount());
        // Rebind the input of the project to the input of the filter itself
        // since we know that we'll evaluate the filter on the fly, with no
        // intermediate buffer.
        const auto filter_input = dynamic_cast<const RelFilter*>(ra_project->getInput(0));
        if (filter_input) {
          CHECK_EQ(size_t(1), filter_input->inputCount());
          bind_project_to_input(ra_project.get(),
                                get_node_output(filter_input->getInput(0)));
        }
        scalar_sources = ra_project->getExpressionsAndRelease();
        for (const auto& scalar_expr : scalar_sources) {
          target_exprs.push_back(scalar_expr.get());
        }
        first_project = false;
      } else {
        if (ra_project->isSimple()) {
          target_exprs = reproject_targets(ra_project.get(), target_exprs);
        } else {
          // TODO(adb): This is essentially a more general case of simple project, we
          // could likely merge the two
          std::vector<const Rex*> result;
          RexInputReplacementVisitor visitor(last_node, scalar_sources);
          for (size_t i = 0; i < ra_project->size(); ++i) {
            const auto rex = ra_project->getProjectAt(i);
            if (auto rex_input = dynamic_cast<const RexInput*>(rex)) {
              const auto index = rex_input->getIndex();
              CHECK_LT(index, target_exprs.size());
              result.push_back(target_exprs[index]);
            } else {
              scalar_sources.push_back(visitor.visit(rex));
              result.push_back(scalar_sources.back().get());
            }
          }
          target_exprs = result;
        }
      }
      last_node = ra_node.get();
      continue;
    }
    const auto ra_aggregate = std::dynamic_pointer_cast<RelAggregate>(ra_node);
    if (ra_aggregate) {
      is_agg = true;
      fields = ra_aggregate->getFields();
      agg_exprs = ra_aggregate->getAggregatesAndRelease();
      groupby_count = ra_aggregate->getGroupByCount();
      decltype(target_exprs){}.swap(target_exprs);
      CHECK_LE(groupby_count, scalar_sources.size());
      for (size_t group_idx = 0; group_idx < groupby_count; ++group_idx) {
        const auto rex_ref = new RexRef(group_idx + 1);
        target_exprs.push_back(rex_ref);
        scalar_sources.emplace_back(rex_ref);
      }
      for (const auto rex_agg : agg_exprs) {
        target_exprs.push_back(rex_agg);
      }
      last_node = ra_node.get();
      continue;
    }
  }

  auto compound_node =
      std::make_shared<RelCompound>(filter_rex,
                                    target_exprs,
                                    groupby_count,
                                    agg_exprs,
                                    fields,
                                    scalar_sources,
                                    is_agg,
                                    manipulation_target->isUpdateViaSelect(),
                                    manipulation_target->isDeleteViaSelect(),
                                    manipulation_target->isVarlenUpdateRequired(),
                                    manipulation_target->getModifiedTableDescriptor(),
                                    manipulation_target->getTargetColumns(),
                                    manipulation_target->getModifiedTableCatalog());
  auto old_node = nodes[pattern.back()];
  nodes[pattern.back()] = compound_node;
  auto first_node = nodes[pattern.front()];
  CHECK_EQ(size_t(1), first_node->inputCount());
  compound_node->addManagedInput(first_node->getAndOwnInput(0));
  if (hint_registered) {
    // pass the registered hint from the origin node to newly created compound node
    // where it is coalesced
    auto registered_query_hint_map_it = query_hints.find(node_hash);
    CHECK(registered_query_hint_map_it != query_hints.end());
    auto registered_query_hint_map = registered_query_hint_map_it->second;
    if (registered_query_hint_map.size() > 1) {
      registered_query_hint_map.erase(node_id);
    } else {
      CHECK_EQ(registered_query_hint_map.size(), static_cast<size_t>(1));
      query_hints.erase(node_hash);
    }
    std::unordered_map<unsigned, RegisteredQueryHint> hint_map;
    hint_map.emplace(compound_node->getId(), registered_query_hint);
    query_hints.emplace(compound_node->toHash(), hint_map);
  }
  for (size_t i = 0; i < pattern.size() - 1; ++i) {
    nodes[pattern[i]].reset();
  }
  for (auto node : nodes) {
    if (!node) {
      continue;
    }
    node->replaceInput(old_node, compound_node);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::unique_ptr<const RexCase> anonymous_namespace{RelAlgDag.cpp}::disambiguate_case	(	const RexCase *	rex_case,
		const RANodeOutput &	ra_output
	)

Definition at line 1457 of file RelAlgDag.cpp.

References RexCase::branchCount(), disambiguate_rex(), RexCase::getElse(), RexCase::getThen(), and RexCase::getWhen().

Referenced by disambiguate_rex().

                                                                                {
  std::vector<
      std::pair<std::unique_ptr<const RexScalar>, std::unique_ptr<const RexScalar>>>
      disambiguated_expr_pair_list;
  for (size_t i = 0; i < rex_case->branchCount(); ++i) {
    auto disambiguated_when = disambiguate_rex(rex_case->getWhen(i), ra_output);
    auto disambiguated_then = disambiguate_rex(rex_case->getThen(i), ra_output);
    disambiguated_expr_pair_list.emplace_back(std::move(disambiguated_when),
                                              std::move(disambiguated_then));
  }
  std::unique_ptr<const RexScalar> disambiguated_else{
      disambiguate_rex(rex_case->getElse(), ra_output)};
  return std::unique_ptr<const RexCase>(
      new RexCase(disambiguated_expr_pair_list, disambiguated_else));
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::unique_ptr<const RexOperator> anonymous_namespace{RelAlgDag.cpp}::disambiguate_operator ( const RexOperator *  rex_operator, const RANodeOutput &  ra_output  )

noexcept

Definition at line 1422 of file RelAlgDag.cpp.

References disambiguate_rex(), and RexWindowFunctionOperator::getPartitionKeys().

Referenced by disambiguate_rex().

                                            {
  std::vector<std::unique_ptr<const RexScalar>> disambiguated_operands;
  for (size_t i = 0; i < rex_operator->size(); ++i) {
    auto operand = rex_operator->getOperand(i);
    if (dynamic_cast<const RexSubQuery*>(operand)) {
      disambiguated_operands.emplace_back(rex_operator->getOperandAndRelease(i));
    } else {
      disambiguated_operands.emplace_back(disambiguate_rex(operand, ra_output));
    }
  }
  const auto rex_window_function_operator =
      dynamic_cast<const RexWindowFunctionOperator*>(rex_operator);
  if (rex_window_function_operator) {
    const auto& partition_keys = rex_window_function_operator->getPartitionKeys();
    std::vector<std::unique_ptr<const RexScalar>> disambiguated_partition_keys;
    for (const auto& partition_key : partition_keys) {
      disambiguated_partition_keys.emplace_back(
          disambiguate_rex(partition_key.get(), ra_output));
    }
    std::vector<std::unique_ptr<const RexScalar>> disambiguated_order_keys;
    const auto& order_keys = rex_window_function_operator->getOrderKeys();
    for (const auto& order_key : order_keys) {
      disambiguated_order_keys.emplace_back(disambiguate_rex(order_key.get(), ra_output));
    }
    return rex_window_function_operator->disambiguatedOperands(
        disambiguated_operands,
        disambiguated_partition_keys,
        disambiguated_order_keys,
        rex_window_function_operator->getCollation());
  }
  return rex_operator->getDisambiguated(disambiguated_operands);
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::unique_ptr< const RexScalar > anonymous_namespace{RelAlgDag.cpp}::disambiguate_rex	(	const RexScalar *	rex_scalar,
		const RANodeOutput &	ra_output
	)

Definition at line 1478 of file RelAlgDag.cpp.

References CHECK_LT, disambiguate_case(), and disambiguate_operator().

Referenced by bind_inputs(), bind_project_to_input(), bind_table_func_to_input(), disambiguate_case(), and disambiguate_operator().

                                                                                 {
  const auto rex_abstract_input = dynamic_cast<const RexAbstractInput*>(rex_scalar);
  if (rex_abstract_input) {
    CHECK_LT(static_cast<size_t>(rex_abstract_input->getIndex()), ra_output.size());
    return std::unique_ptr<const RexInput>(
        new RexInput(ra_output[rex_abstract_input->getIndex()]));
  }
  const auto rex_operator = dynamic_cast<const RexOperator*>(rex_scalar);
  if (rex_operator) {
    return disambiguate_operator(rex_operator, ra_output);
  }
  const auto rex_case = dynamic_cast<const RexCase*>(rex_scalar);
  if (rex_case) {
    return disambiguate_case(rex_case, ra_output);
  }
  if (auto const rex_literal = dynamic_cast<const RexLiteral*>(rex_scalar)) {
    return rex_literal->deepCopy();
  } else if (auto const rex_subquery = dynamic_cast<const RexSubQuery*>(rex_scalar)) {
    return rex_subquery->deepCopy();
  } else {
    throw QueryNotSupported("Unable to disambiguate expression of type " +
                            std::string(typeid(*rex_scalar).name()));
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void anonymous_namespace{RelAlgDag.cpp}::eliminate_redundant_projection

(

std::vector< std::shared_ptr< RelAlgNode >> &

nodes

)

Definition at line 2174 of file RelAlgDag.cpp.

References CHECK_EQ, and RexVisitorBase< T >::visit().

Referenced by RelAlgDagBuilder::optimizeDag().

                                                                                 {
  for (auto& node : nodes) {
    if (auto* proj_node = dynamic_cast<RelProject*>(node.get())) {
      if (proj_node->isSimple()) {
        if (auto child_proj_node =
                dynamic_cast<RelProject const*>(proj_node->getInput(0))) {
          std::vector<std::unique_ptr<RexScalar const>> scalar_exprs;
          RexDeepCopyVisitor copier;
          for (size_t i = 0; i < proj_node->size(); i++) {
            auto rex_abs_input =
                dynamic_cast<RexAbstractInput const*>(proj_node->getProjectAt(i));
            scalar_exprs.push_back(
                copier.visit(child_proj_node->getProjectAt(rex_abs_input->getIndex())));
          }
          CHECK_EQ(scalar_exprs.size(), proj_node->getFields().size());
          proj_node->setExpressions(scalar_exprs);
          proj_node->replaceInput(proj_node->getAndOwnInput(0),
                                  child_proj_node->getAndOwnInput(0));
        }
      }
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::set<std::pair<const RelAlgNode*, int> > anonymous_namespace{RelAlgDag.cpp}::get_equiv_cols	(	const RelAlgNode *	node,
		const size_t	which_col
	)

Definition at line 764 of file RelAlgDag.cpp.

References CHECK, and CHECK_EQ.

Referenced by RelSort::hasEquivCollationOf().

                                                                                   {
  std::set<std::pair<const RelAlgNode*, int>> work_set;
  auto walker = node;
  auto curr_col = which_col;
  while (true) {
    work_set.insert(std::make_pair(walker, curr_col));
    if (dynamic_cast<const RelScan*>(walker) || dynamic_cast<const RelJoin*>(walker)) {
      break;
    }
    CHECK_EQ(size_t(1), walker->inputCount());
    auto only_source = walker->getInput(0);
    if (auto project = dynamic_cast<const RelProject*>(walker)) {
      if (auto input = dynamic_cast<const RexInput*>(project->getProjectAt(curr_col))) {
        const auto join_source = dynamic_cast<const RelJoin*>(only_source);
        if (join_source) {
          CHECK_EQ(size_t(2), join_source->inputCount());
          auto lhs = join_source->getInput(0);
          CHECK((input->getIndex() < lhs->size() && lhs == input->getSourceNode()) ||
                join_source->getInput(1) == input->getSourceNode());
        } else {
          CHECK_EQ(input->getSourceNode(), only_source);
        }
        curr_col = input->getIndex();
      } else {
        break;
      }
    } else if (auto aggregate = dynamic_cast<const RelAggregate*>(walker)) {
      if (curr_col >= aggregate->getGroupByCount()) {
        break;
      }
    }
    walker = only_source;
  }
  return work_set;
}

Here is the caller graph for this function:

int64_t anonymous_namespace{RelAlgDag.cpp}::get_int_literal_field ( const rapidjson::Value &  obj, const char  field[], const int64_t  default_val  )

noexcept

Definition at line 2841 of file RelAlgDag.cpp.

References CHECK_EQ, field(), kDECIMAL, and parse_literal().

Referenced by details::RelAlgDispatcher::dispatchSort().

                                                                  {
  const auto it = obj.FindMember(field);
  if (it == obj.MemberEnd()) {
    return default_val;
  }
  std::unique_ptr<RexLiteral> lit(parse_literal(it->value));
  CHECK_EQ(kDECIMAL, lit->getType());
  CHECK_EQ(unsigned(0), lit->getScale());
  CHECK_EQ(unsigned(0), lit->getTargetScale());
  return lit->getVal<int64_t>();
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::vector<bool> anonymous_namespace{RelAlgDag.cpp}::get_notnulls

(

std::vector< TargetMetaInfo > const &

tmis0

)

Definition at line 882 of file RelAlgDag.cpp.

Referenced by RelLogicalUnion::getCompatibleMetainfoTypes().

                                                                     {
  std::vector<bool> notnulls(tmis0.size());
  for (size_t j = 0; j < tmis0.size(); ++j) {
    notnulls[j] = tmis0[j].get_type_info().get_notnull();
  }
  return notnulls;
}

Here is the caller graph for this function:

const std::pair<const Catalog_Namespace::Catalog*, const TableDescriptor*> anonymous_namespace{RelAlgDag.cpp}::getCatalogAndTableFromScanNode

(

const rapidjson::Value &

scan_ra

)

Definition at line 2861 of file RelAlgDag.cpp.

References cat(), CHECK, CHECK_EQ, field(), Catalog_Namespace::SysCatalog::getCatalog(), and Catalog_Namespace::SysCatalog::instance().

Referenced by details::RelAlgDispatcher::dispatchModify(), and details::RelAlgDispatcher::dispatchTableScan().

                                                              {
  const auto& table_json = field(scan_ra, "table");
  CHECK(table_json.IsArray());
  CHECK_EQ(unsigned(2), table_json.Size());
  const auto cat =
      Catalog_Namespace::SysCatalog::instance().getCatalog(table_json[0].GetString());
  CHECK(cat);
  const auto td = cat->getMetadataForTable(table_json[1].GetString());
  CHECK(td);
  return {cat.get(), td};
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::vector<std::string> anonymous_namespace{RelAlgDag.cpp}::getFieldNamesFromScanNode

(

const rapidjson::Value &

scan_ra

)

Definition at line 2873 of file RelAlgDag.cpp.

References field(), and strings_from_json_array().

Referenced by details::RelAlgDispatcher::dispatchTableScan().

                                                                              {
  const auto& fields_json = field(scan_ra, "fieldNames");
  return strings_from_json_array(fields_json);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void anonymous_namespace{RelAlgDag.cpp}::handle_agg_over_join	(	std::vector< std::shared_ptr< RelAlgNode >> &	nodes,
		std::unordered_map< size_t, std::unordered_map< unsigned, RegisteredQueryHint >> &	query_hints
	)

Definition at line 2138 of file RelAlgDag.cpp.

References CHECK, CHECK_EQ, CHECK_NE, and anonymous_namespace{RelAlgDag.cpp}::anonymous_namespace{RelAlgDag.cpp}::create_rex_input_for_new_project_node().

Referenced by RelAlgDagBuilder::optimizeDag().

                     {
  std::list<std::shared_ptr<RelAlgNode>> node_list(nodes.begin(), nodes.end());
  bool replace_nodes = false;
  for (auto node_itr = node_list.begin(); node_itr != node_list.end(); ++node_itr) {
    auto node = *node_itr;
    if (auto agg_node = std::dynamic_pointer_cast<RelAggregate>(node)) {
      std::vector<std::unique_ptr<const RexScalar>> scalar_exprs;
      std::vector<std::string> fields;
      std::shared_ptr<RelProject> new_project;
      CHECK_EQ(agg_node->getInputs().size(), size_t(1));
      CHECK_NE(*node_itr, *node_list.begin());
      const auto prev_node = *std::prev(node_itr);
      CHECK(prev_node);
      auto const input_node_ptr = agg_node->getAndOwnInput(0);
      if (auto join_node =
              std::dynamic_pointer_cast<RelLeftDeepInnerJoin const>(input_node_ptr)) {
        for (auto const* join_input_node : join_node->getInputs()) {
          create_rex_input_for_new_project_node(join_input_node, scalar_exprs, fields);
        }
        if (!scalar_exprs.empty()) {
          replace_nodes = true;
          new_project = std::make_shared<RelProject>(scalar_exprs, fields, join_node);
          agg_node->replaceInput(join_node, new_project);
          node_list.insert(node_itr, new_project);
        }
      }
    }
  }
  if (replace_nodes) {
    nodes.assign(node_list.begin(), node_list.end());
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void anonymous_namespace{RelAlgDag.cpp}::handle_query_hint ( const std::vector< std::shared_ptr< RelAlgNode >> &  nodes, RelAlgDag &  rel_alg_dag  )

noexcept

Definition at line 1573 of file RelAlgDag.cpp.

References RelProject::getDeliveredHints(), RelAggregate::getDeliveredHints(), and RelCompound::getDeliveredHints().

Referenced by RelAlgExecutor::executeRelAlgStep(), and RelAlgDagBuilder::optimizeDag().

                                                        {
  // query hint is delivered by the above three nodes
  // when a query block has top-sort node, a hint is registered to
  // one of the node which locates at the nearest from the sort node
  RegisteredQueryHint global_query_hint;
  for (auto node : nodes) {
    Hints* hint_delivered = nullptr;
    const auto agg_node = std::dynamic_pointer_cast<RelAggregate>(node);
    if (agg_node) {
      if (agg_node->hasDeliveredHint()) {
        hint_delivered = agg_node->getDeliveredHints();
      }
    }
    const auto project_node = std::dynamic_pointer_cast<RelProject>(node);
    if (project_node) {
      if (project_node->hasDeliveredHint()) {
        hint_delivered = project_node->getDeliveredHints();
      }
    }
    const auto compound_node = std::dynamic_pointer_cast<RelCompound>(node);
    if (compound_node) {
      if (compound_node->hasDeliveredHint()) {
        hint_delivered = compound_node->getDeliveredHints();
      }
    }
    if (hint_delivered && !hint_delivered->empty()) {
      rel_alg_dag.registerQueryHints(node, hint_delivered, global_query_hint);
    }
  }
  // the current rel_alg_dag may contain global query hints from the subquery
  // so we combine the current global hint we collected with the original one together
  // to propagate global query hints correctly
  const auto existing_global_query_hints = rel_alg_dag.getGlobalHints();
  const auto new_global_query_hints = existing_global_query_hints || global_query_hint;
  rel_alg_dag.setGlobalQueryHints(new_global_query_hints);
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::vector<size_t> anonymous_namespace{RelAlgDag.cpp}::indices_from_json_array ( const rapidjson::Value &  json_idx_arr )

noexcept

Definition at line 1348 of file RelAlgDag.cpp.

References CHECK, and CHECK_GE.

Referenced by details::RelAlgDispatcher::dispatchAggregate(), and parse_aggregate_expr().

                                                 {
  CHECK(json_idx_arr.IsArray());
  std::vector<size_t> indices;
  for (auto json_idx_arr_it = json_idx_arr.Begin(); json_idx_arr_it != json_idx_arr.End();
       ++json_idx_arr_it) {
    CHECK(json_idx_arr_it->IsInt());
    CHECK_GE(json_idx_arr_it->GetInt(), 0);
    indices.emplace_back(json_idx_arr_it->GetInt());
  }
  return indices;
}

Here is the caller graph for this function:

bool anonymous_namespace{RelAlgDag.cpp}::isRenamedInput	(	const RelAlgNode *	node,
		const size_t	index,
		const std::string &	new_name
	)

Definition at line 470 of file RelAlgDag.cpp.

References CHECK, CHECK_EQ, CHECK_GE, CHECK_LT, RelAlgNode::getInput(), join(), and RelAlgNode::size().

Referenced by RelProject::isRenaming().

                                               {
  CHECK_LT(index, node->size());
  if (auto join = dynamic_cast<const RelJoin*>(node)) {
    CHECK_EQ(size_t(2), join->inputCount());
    const auto lhs_size = join->getInput(0)->size();
    if (index < lhs_size) {
      return isRenamedInput(join->getInput(0), index, new_name);
    }
    CHECK_GE(index, lhs_size);
    return isRenamedInput(join->getInput(1), index - lhs_size, new_name);
  }

  if (auto scan = dynamic_cast<const RelScan*>(node)) {
    return new_name != scan->getFieldName(index);
  }

  if (auto aggregate = dynamic_cast<const RelAggregate*>(node)) {
    return new_name != aggregate->getFieldName(index);
  }

  if (auto project = dynamic_cast<const RelProject*>(node)) {
    return new_name != project->getFieldName(index);
  }

  if (auto table_func = dynamic_cast<const RelTableFunction*>(node)) {
    return new_name != table_func->getFieldName(index);
  }

  if (auto logical_values = dynamic_cast<const RelLogicalValues*>(node)) {
    const auto& tuple_type = logical_values->getTupleType();
    CHECK_LT(index, tuple_type.size());
    return new_name != tuple_type[index].get_resname();
  }

  CHECK(dynamic_cast<const RelSort*>(node) || dynamic_cast<const RelFilter*>(node) ||
        dynamic_cast<const RelLogicalUnion*>(node));
  return isRenamedInput(node->getInput(0), index, new_name);
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::string anonymous_namespace{RelAlgDag.cpp}::json_node_to_string ( const rapidjson::Value &  node )

noexcept

Definition at line 978 of file RelAlgDag.cpp.

Referenced by details::RelAlgDispatcher::dispatchModify(), parse_scalar_expr(), and parse_type().

                                                                   {
  rapidjson::StringBuffer buffer;
  rapidjson::Writer<rapidjson::StringBuffer> writer(buffer);
  node.Accept(writer);
  return buffer.GetString();
}

Here is the caller graph for this function:

void anonymous_namespace{RelAlgDag.cpp}::mark_nops ( const std::vector< std::shared_ptr< RelAlgNode >> &  nodes )

noexcept

Definition at line 1625 of file RelAlgDag.cpp.

References CHECK_EQ, and RelAlgNode::markAsNop().

Referenced by RelAlgDagBuilder::optimizeDag().

                                                                           {
  for (auto node : nodes) {
    const auto agg_node = std::dynamic_pointer_cast<RelAggregate>(node);
    if (!agg_node || agg_node->getAggExprsCount()) {
      continue;
    }
    CHECK_EQ(size_t(1), node->inputCount());
    const auto agg_input_node = dynamic_cast<const RelAggregate*>(node->getInput(0));
    if (agg_input_node && !agg_input_node->getAggExprsCount() &&
        agg_node->getGroupByCount() == agg_input_node->getGroupByCount()) {
      agg_node->markAsNop();
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::vector<RexInput> anonymous_namespace{RelAlgDag.cpp}::n_outputs	(	const RelAlgNode *	node,
		const size_t	n
	)

Definition at line 96 of file RelAlgDag.cpp.

References anonymous_namespace{Utm.h}::n.

Referenced by get_node_output().

                                                                      {
  std::vector<RexInput> outputs;
  outputs.reserve(n);
  for (size_t i = 0; i < n; ++i) {
    outputs.emplace_back(node, i);
  }
  return outputs;
}

Here is the caller graph for this function:

unsigned anonymous_namespace{RelAlgDag.cpp}::node_id ( const rapidjson::Value &  ra_node )

noexcept

Definition at line 973 of file RelAlgDag.cpp.

References field(), and json_str().

Referenced by create_compound(), details::RelAlgDispatcher::dispatchFilter(), RaExecutionSequence::extractQueryStepSkippingInfo(), QueryPlanDagExtractor::handleTranslatedJoin(), details::RelAlgDispatcher::prev(), and details::RelAlgDispatcher::run().

                                                         {
  const auto& id = field(ra_node, "id");
  return std::stoi(json_str(id));
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::unique_ptr<RexAbstractInput> anonymous_namespace{RelAlgDag.cpp}::parse_abstract_input ( const rapidjson::Value &  expr )

noexcept

Definition at line 989 of file RelAlgDag.cpp.

References field(), and json_i64().

Referenced by parse_scalar_expr().

                                         {
  const auto& input = field(expr, "input");
  return std::unique_ptr<RexAbstractInput>(new RexAbstractInput(json_i64(input)));
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::unique_ptr<const RexAgg> anonymous_namespace{RelAlgDag.cpp}::parse_aggregate_expr

(

const rapidjson::Value &

expr

)

Definition at line 1361 of file RelAlgDag.cpp.

References field(), indices_from_json_array(), logger::INFO, json_bool(), json_str(), LOG, parse_type(), and to_agg_kind().

Referenced by details::RelAlgDispatcher::dispatchAggregate().

                                                                             {
  const auto agg_str = json_str(field(expr, "agg"));
  if (agg_str == "APPROX_QUANTILE") {
    LOG(INFO) << "APPROX_QUANTILE is deprecated. Please use APPROX_PERCENTILE instead.";
  }
  const auto agg = to_agg_kind(agg_str);
  const auto distinct = json_bool(field(expr, "distinct"));
  const auto agg_ti = parse_type(field(expr, "type"));
  const auto operands = indices_from_json_array(field(expr, "operands"));
  bool const allow_multiple_args =
      shared::is_any<kAPPROX_COUNT_DISTINCT, kAPPROX_QUANTILE, kSUM_IF>(agg);
  if (operands.size() > 1 && (operands.size() != 2 || !allow_multiple_args)) {
    throw QueryNotSupported("Multiple arguments for aggregates aren't supported");
  }
  return std::unique_ptr<const RexAgg>(new RexAgg(agg, distinct, agg_ti, operands));
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::unique_ptr<RexCase> anonymous_namespace{RelAlgDag.cpp}::parse_case	(	const rapidjson::Value &	expr,
		RelAlgDag &	root_dag
	)

Definition at line 1316 of file RelAlgDag.cpp.

References CHECK, CHECK_GE, field(), and parse_scalar_expr().

Referenced by parse_scalar_expr().

                                                                                   {
  const auto& operands = field(expr, "operands");
  CHECK(operands.IsArray());
  CHECK_GE(operands.Size(), unsigned(2));
  std::unique_ptr<const RexScalar> else_expr;
  std::vector<
      std::pair<std::unique_ptr<const RexScalar>, std::unique_ptr<const RexScalar>>>
      expr_pair_list;
  for (auto operands_it = operands.Begin(); operands_it != operands.End();) {
    auto when_expr = parse_scalar_expr(*operands_it++, root_dag);
    if (operands_it == operands.End()) {
      else_expr = std::move(when_expr);
      break;
    }
    auto then_expr = parse_scalar_expr(*operands_it++, root_dag);
    expr_pair_list.emplace_back(std::move(when_expr), std::move(then_expr));
  }
  return std::unique_ptr<RexCase>(new RexCase(expr_pair_list, else_expr));
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::vector<std::unique_ptr<const RexScalar> > anonymous_namespace{RelAlgDag.cpp}::parse_expr_array	(	const rapidjson::Value &	arr,
		RelAlgDag &	root_dag
	)

Definition at line 1099 of file RelAlgDag.cpp.

References parse_scalar_expr().

Referenced by parse_operator().

                         {
  std::vector<std::unique_ptr<const RexScalar>> exprs;
  for (auto it = arr.Begin(); it != arr.End(); ++it) {
    exprs.emplace_back(parse_scalar_expr(*it, root_dag));
  }
  return exprs;
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::unique_ptr<RexLiteral> anonymous_namespace{RelAlgDag.cpp}::parse_literal

(

const rapidjson::Value &

expr

)

Definition at line 995 of file RelAlgDag.cpp.

References CHECK, field(), json_bool(), json_double(), json_i64(), json_str(), kBIGINT, kBOOLEAN, kDATE, kDECIMAL, kDOUBLE, kINT, kINTERVAL_DAY_TIME, kINTERVAL_YEAR_MONTH, kNULLT, kTEXT, kTIME, kTIMESTAMP, to_sql_type(), run_benchmark_import::type, and UNREACHABLE.

Referenced by details::RelAlgDispatcher::dispatchLogicalValues(), get_int_literal_field(), and parse_scalar_expr().

                                                                    {
  CHECK(expr.IsObject());
  const auto& literal = field(expr, "literal");
  const auto type = to_sql_type(json_str(field(expr, "type")));
  const auto target_type = to_sql_type(json_str(field(expr, "target_type")));
  const auto scale = json_i64(field(expr, "scale"));
  const auto precision = json_i64(field(expr, "precision"));
  const auto type_scale = json_i64(field(expr, "type_scale"));
  const auto type_precision = json_i64(field(expr, "type_precision"));
  if (literal.IsNull()) {
    return std::unique_ptr<RexLiteral>(new RexLiteral(target_type));
  }
  switch (type) {
    case kINT:
    case kBIGINT:
    case kDECIMAL:
    case kINTERVAL_DAY_TIME:
    case kINTERVAL_YEAR_MONTH:
    case kTIME:
    case kTIMESTAMP:
    case kDATE:
      return std::unique_ptr<RexLiteral>(new RexLiteral(json_i64(literal),
                                                        type,
                                                        target_type,
                                                        scale,
                                                        precision,
                                                        type_scale,
                                                        type_precision));
    case kDOUBLE: {
      if (literal.IsDouble()) {
        return std::unique_ptr<RexLiteral>(new RexLiteral(json_double(literal),
                                                          type,
                                                          target_type,
                                                          scale,
                                                          precision,
                                                          type_scale,
                                                          type_precision));
      } else if (literal.IsInt64()) {
        return std::make_unique<RexLiteral>(static_cast<double>(literal.GetInt64()),
                                            type,
                                            target_type,
                                            scale,
                                            precision,
                                            type_scale,
                                            type_precision);

      } else if (literal.IsUint64()) {
        return std::make_unique<RexLiteral>(static_cast<double>(literal.GetUint64()),
                                            type,
                                            target_type,
                                            scale,
                                            precision,
                                            type_scale,
                                            type_precision);
      }
      UNREACHABLE() << "Unhandled type: " << literal.GetType();
    }
    case kTEXT:
      return std::unique_ptr<RexLiteral>(new RexLiteral(json_str(literal),
                                                        type,
                                                        target_type,
                                                        scale,
                                                        precision,
                                                        type_scale,
                                                        type_precision));
    case kBOOLEAN:
      return std::unique_ptr<RexLiteral>(new RexLiteral(json_bool(literal),
                                                        type,
                                                        target_type,
                                                        scale,
                                                        precision,
                                                        type_scale,
                                                        type_precision));
    case kNULLT:
      return std::unique_ptr<RexLiteral>(new RexLiteral(target_type));
    default:
      CHECK(false);
  }
  CHECK(false);
  return nullptr;
}

Here is the call graph for this function:

Here is the caller graph for this function:

NullSortedPosition anonymous_namespace{RelAlgDag.cpp}::parse_nulls_position

(

const rapidjson::Value &

collation

)

Definition at line 1210 of file RelAlgDag.cpp.

References field(), First, json_str(), and Last.

Referenced by details::RelAlgDispatcher::dispatchSort(), and parse_window_order_collation().

                                                                         {
  return json_str(field(collation, "nulls")) == std::string("FIRST")
             ? NullSortedPosition::First
             : NullSortedPosition::Last;
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::unique_ptr<RexOperator> anonymous_namespace{RelAlgDag.cpp}::parse_operator	(	const rapidjson::Value &	expr,
		RelAlgDag &	root_dag
	)

Definition at line 1274 of file RelAlgDag.cpp.

References CHECK, field(), json_bool(), json_str(), kFUNCTION, kIN, gpu_enabled::lower_bound(), parse_expr_array(), parse_subquery(), parse_type(), parse_window_bound(), parse_window_function_kind(), parse_window_order_collation(), parse_window_order_exprs(), to_sql_op(), and gpu_enabled::upper_bound().

Referenced by parse_scalar_expr().

                                                                 {
  const auto op_name = json_str(field(expr, "op"));
  const bool is_quantifier =
      op_name == std::string("PG_ANY") || op_name == std::string("PG_ALL");
  const auto op = is_quantifier ? kFUNCTION : to_sql_op(op_name);
  const auto& operators_json_arr = field(expr, "operands");
  CHECK(operators_json_arr.IsArray());
  auto operands = parse_expr_array(operators_json_arr, root_dag);
  const auto type_it = expr.FindMember("type");
  CHECK(type_it != expr.MemberEnd());
  auto ti = parse_type(type_it->value);
  if (op == kIN && expr.HasMember("subquery")) {
    auto subquery = parse_subquery(expr, root_dag);
    operands.emplace_back(std::move(subquery));
  }
  if (expr.FindMember("partition_keys") != expr.MemberEnd()) {
    const auto& partition_keys_arr = field(expr, "partition_keys");
    auto partition_keys = parse_expr_array(partition_keys_arr, root_dag);
    const auto& order_keys_arr = field(expr, "order_keys");
    auto order_keys = parse_window_order_exprs(order_keys_arr, root_dag);
    const auto collation = parse_window_order_collation(order_keys_arr, root_dag);
    const auto kind = parse_window_function_kind(op_name);
    const auto lower_bound = parse_window_bound(field(expr, "lower_bound"), root_dag);
    const auto upper_bound = parse_window_bound(field(expr, "upper_bound"), root_dag);
    bool is_rows = json_bool(field(expr, "is_rows"));
    ti.set_notnull(false);
    return std::make_unique<RexWindowFunctionOperator>(kind,
                                                       operands,
                                                       partition_keys,
                                                       order_keys,
                                                       collation,
                                                       lower_bound,
                                                       upper_bound,
                                                       is_rows,
                                                       ti);
  }
  return std::unique_ptr<RexOperator>(op == kFUNCTION
                                          ? new RexFunctionOperator(op_name, operands, ti)
                                          : new RexOperator(op, operands, ti));
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::unique_ptr< const RexScalar > anonymous_namespace{RelAlgDag.cpp}::parse_scalar_expr	(	const rapidjson::Value &	expr,
		RelAlgDag &	root_dag
	)

Definition at line 1378 of file RelAlgDag.cpp.

References CHECK, field(), json_node_to_string(), json_str(), parse_abstract_input(), parse_case(), parse_literal(), parse_operator(), and parse_subquery().

Referenced by details::RelAlgDispatcher::dispatchFilter(), details::RelAlgDispatcher::dispatchJoin(), details::RelAlgDispatcher::dispatchProject(), details::RelAlgDispatcher::dispatchTableFunction(), parse_case(), parse_expr_array(), parse_window_bound(), and parse_window_order_exprs().

                                                                        {
  CHECK(expr.IsObject());
  if (expr.IsObject() && expr.HasMember("input")) {
    return std::unique_ptr<const RexScalar>(parse_abstract_input(expr));
  }
  if (expr.IsObject() && expr.HasMember("literal")) {
    return std::unique_ptr<const RexScalar>(parse_literal(expr));
  }
  if (expr.IsObject() && expr.HasMember("op")) {
    const auto op_str = json_str(field(expr, "op"));
    if (op_str == std::string("CASE")) {
      return std::unique_ptr<const RexScalar>(parse_case(expr, root_dag));
    }
    if (op_str == std::string("$SCALAR_QUERY")) {
      return std::unique_ptr<const RexScalar>(parse_subquery(expr, root_dag));
    }
    return std::unique_ptr<const RexScalar>(parse_operator(expr, root_dag));
  }
  std::string const node_str = json_node_to_string(expr);
  if (node_str.find("\"correl\":\"$cor") != std::string::npos) {
    throw QueryNotSupported("Unable to decorrelate one of the correlated subqueries.");
  }
  throw QueryNotSupported("Expression node " + node_str + " not supported");
}

Here is the call graph for this function:

Here is the caller graph for this function:

SortDirection anonymous_namespace{RelAlgDag.cpp}::parse_sort_direction

(

const rapidjson::Value &

collation

)

Definition at line 1204 of file RelAlgDag.cpp.

References Ascending, Descending, field(), and json_str().

Referenced by details::RelAlgDispatcher::dispatchSort(), and parse_window_order_collation().

                                                                    {
  return json_str(field(collation, "direction")) == std::string("DESCENDING")
             ? SortDirection::Descending
             : SortDirection::Ascending;
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::unique_ptr<const RexSubQuery> anonymous_namespace{RelAlgDag.cpp}::parse_subquery	(	const rapidjson::Value &	expr,
		RelAlgDag &	root_dag
	)

Definition at line 1247 of file RelAlgDag.cpp.

References RelAlgDagBuilder::buildDagForSubquery(), CHECK, CHECK_GE, field(), RelAlgDag::getGlobalHints(), RelAlgDag::registerQueryHint(), RelAlgDag::registerSubquery(), and RelAlgDag::setGlobalQueryHints().

Referenced by parse_operator(), and parse_scalar_expr().

                                                                       {
  const auto& operands = field(expr, "operands");
  CHECK(operands.IsArray());
  CHECK_GE(operands.Size(), unsigned(0));
  const auto& subquery_ast = field(expr, "subquery");

  auto subquery_dag = RelAlgDagBuilder::buildDagForSubquery(root_dag, subquery_ast);
  const auto subquery_root_node = subquery_dag->getRootNodeShPtr();
  auto subquery = std::make_shared<RexSubQuery>(subquery_root_node);
  auto query_hint = subquery_dag->getQueryHint(subquery_dag->getRootNodeShPtr().get());
  root_dag.registerSubquery(subquery);
  const auto subquery_global_hint = subquery_dag->getGlobalHints();
  if (subquery_global_hint.isAnyQueryHintDelivered()) {
    // we need to propagate global query hint found in this subquery to its parent
    const auto new_global_hint = root_dag.getGlobalHints() || subquery_global_hint;
    root_dag.setGlobalQueryHints(new_global_hint);
  }
  const auto subquery_local_hint = subquery_dag->getQueryHint(subquery_root_node.get());
  if (subquery_local_hint) {
    // register local query hint of this subquery to its parent to correctly
    // enables them when executing this subquery
    root_dag.registerQueryHint(subquery_root_node.get(), *subquery_local_hint);
  }
  return subquery->deepCopy();
}

Here is the call graph for this function:

Here is the caller graph for this function:

SQLTypeInfo anonymous_namespace{RelAlgDag.cpp}::parse_type

(

const rapidjson::Value &

type_obj

)

Definition at line 1080 of file RelAlgDag.cpp.

References CHECK, field(), json_bool(), json_i64(), json_node_to_string(), json_str(), SQLTypeInfo::set_precision(), SQLTypeInfo::set_scale(), to_sql_type(), and run_benchmark_import::type.

Referenced by details::RelAlgDispatcher::dispatchLogicalValues(), parse_aggregate_expr(), and parse_operator().

                                                       {
  if (type_obj.IsArray()) {
    throw QueryNotSupported("Composite types are not currently supported.");
  }
  CHECK(type_obj.IsObject() && type_obj.MemberCount() >= 2)
      << json_node_to_string(type_obj);
  const auto type = to_sql_type(json_str(field(type_obj, "type")));
  const auto nullable = json_bool(field(type_obj, "nullable"));
  const auto precision_it = type_obj.FindMember("precision");
  const int precision =
      precision_it != type_obj.MemberEnd() ? json_i64(precision_it->value) : 0;
  const auto scale_it = type_obj.FindMember("scale");
  const int scale = scale_it != type_obj.MemberEnd() ? json_i64(scale_it->value) : 0;
  SQLTypeInfo ti(type, !nullable);
  ti.set_precision(precision);
  ti.set_scale(scale);
  return ti;
}

Here is the call graph for this function:

Here is the caller graph for this function:

RexWindowFunctionOperator::RexWindowBound anonymous_namespace{RelAlgDag.cpp}::parse_window_bound	(	const rapidjson::Value &	window_bound_obj,
		RelAlgDag &	root_dag
	)

Definition at line 1228 of file RelAlgDag.cpp.

References CHECK, field(), json_bool(), json_i64(), parse_scalar_expr(), and RexWindowFunctionOperator::RexWindowBound::unbounded.

Referenced by parse_operator().

                         {
  CHECK(window_bound_obj.IsObject());
  RexWindowFunctionOperator::RexWindowBound window_bound;
  window_bound.unbounded = json_bool(field(window_bound_obj, "unbounded"));
  window_bound.preceding = json_bool(field(window_bound_obj, "preceding"));
  window_bound.following = json_bool(field(window_bound_obj, "following"));
  window_bound.is_current_row = json_bool(field(window_bound_obj, "is_current_row"));
  const auto& offset_field = field(window_bound_obj, "offset");
  if (offset_field.IsObject()) {
    window_bound.bound_expr = parse_scalar_expr(offset_field, root_dag);
  } else {
    CHECK(offset_field.IsNull());
  }
  window_bound.order_key = json_i64(field(window_bound_obj, "order_key"));
  return window_bound;
}

Here is the call graph for this function:

Here is the caller graph for this function:

SqlWindowFunctionKind anonymous_namespace{RelAlgDag.cpp}::parse_window_function_kind

(

const std::string &

name

)

Definition at line 1109 of file RelAlgDag.cpp.

References AVG, BACKWARD_FILL, CONDITIONAL_CHANGE_EVENT, COUNT, COUNT_IF, CUME_DIST, DENSE_RANK, FIRST_VALUE, FIRST_VALUE_IN_FRAME, FORWARD_FILL, LAG, LAG_IN_FRAME, LAST_VALUE, LAST_VALUE_IN_FRAME, LEAD, LEAD_IN_FRAME, MAX, MIN, NTH_VALUE, NTH_VALUE_IN_FRAME, NTILE, PERCENT_RANK, RANK, ROW_NUMBER, SUM, SUM_IF, and SUM_INTERNAL.

Referenced by parse_operator().

                                                                        {
  if (name == "ROW_NUMBER") {
    return SqlWindowFunctionKind::ROW_NUMBER;
  }
  if (name == "RANK") {
    return SqlWindowFunctionKind::RANK;
  }
  if (name == "DENSE_RANK") {
    return SqlWindowFunctionKind::DENSE_RANK;
  }
  if (name == "PERCENT_RANK") {
    return SqlWindowFunctionKind::PERCENT_RANK;
  }
  if (name == "CUME_DIST") {
    return SqlWindowFunctionKind::CUME_DIST;
  }
  if (name == "NTILE") {
    return SqlWindowFunctionKind::NTILE;
  }
  if (name == "LAG") {
    return SqlWindowFunctionKind::LAG;
  }
  if (name == "LAG_IN_FRAME") {
    return SqlWindowFunctionKind::LAG_IN_FRAME;
  }
  if (name == "LEAD") {
    return SqlWindowFunctionKind::LEAD;
  }
  if (name == "LEAD_IN_FRAME") {
    return SqlWindowFunctionKind::LEAD_IN_FRAME;
  }
  if (name == "FIRST_VALUE") {
    return SqlWindowFunctionKind::FIRST_VALUE;
  }
  if (name == "LAST_VALUE") {
    return SqlWindowFunctionKind::LAST_VALUE;
  }
  if (name == "NTH_VALUE") {
    return SqlWindowFunctionKind::NTH_VALUE;
  }
  if (name == "NTH_VALUE_IN_FRAME") {
    return SqlWindowFunctionKind::NTH_VALUE_IN_FRAME;
  }
  if (name == "FIRST_VALUE_IN_FRAME") {
    return SqlWindowFunctionKind::FIRST_VALUE_IN_FRAME;
  }
  if (name == "LAST_VALUE_IN_FRAME") {
    return SqlWindowFunctionKind::LAST_VALUE_IN_FRAME;
  }
  if (name == "AVG") {
    return SqlWindowFunctionKind::AVG;
  }
  if (name == "MIN") {
    return SqlWindowFunctionKind::MIN;
  }
  if (name == "MAX") {
    return SqlWindowFunctionKind::MAX;
  }
  if (name == "SUM") {
    return SqlWindowFunctionKind::SUM;
  }
  if (name == "COUNT") {
    return SqlWindowFunctionKind::COUNT;
  }
  if (name == "COUNT_IF") {
    return SqlWindowFunctionKind::COUNT_IF;
  }
  if (name == "SUM_IF") {
    return SqlWindowFunctionKind::SUM_IF;
  }
  if (name == "$SUM0") {
    return SqlWindowFunctionKind::SUM_INTERNAL;
  }
  if (name == "FORWARD_FILL") {
    return SqlWindowFunctionKind::FORWARD_FILL;
  }
  if (name == "BACKWARD_FILL") {
    return SqlWindowFunctionKind::BACKWARD_FILL;
  }
  if (name == "CONDITIONAL_CHANGE_EVENT") {
    return SqlWindowFunctionKind::CONDITIONAL_CHANGE_EVENT;
  }
  throw std::runtime_error("Unsupported window function: " + name);
}

Here is the caller graph for this function:

std::vector<SortField> anonymous_namespace{RelAlgDag.cpp}::parse_window_order_collation	(	const rapidjson::Value &	arr,
		RelAlgDag &	root_dag
	)

Definition at line 1216 of file RelAlgDag.cpp.

References parse_nulls_position(), and parse_sort_direction().

Referenced by parse_operator().

                                                                         {
  std::vector<SortField> collation;
  size_t field_idx = 0;
  for (auto it = arr.Begin(); it != arr.End(); ++it, ++field_idx) {
    const auto sort_dir = parse_sort_direction(*it);
    const auto null_pos = parse_nulls_position(*it);
    collation.emplace_back(field_idx, sort_dir, null_pos);
  }
  return collation;
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::vector<std::unique_ptr<const RexScalar> > anonymous_namespace{RelAlgDag.cpp}::parse_window_order_exprs	(	const rapidjson::Value &	arr,
		RelAlgDag &	root_dag
	)

Definition at line 1194 of file RelAlgDag.cpp.

References field(), and parse_scalar_expr().

Referenced by parse_operator().

                         {
  std::vector<std::unique_ptr<const RexScalar>> exprs;
  for (auto it = arr.Begin(); it != arr.End(); ++it) {
    exprs.emplace_back(parse_scalar_expr(field(*it, "field"), root_dag));
  }
  return exprs;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void anonymous_namespace{RelAlgDag.cpp}::propagate_hints_to_new_project	(	std::shared_ptr< RelProject >	prev_node,
		std::shared_ptr< RelProject >	new_node,
		std::unordered_map< size_t, std::unordered_map< unsigned, RegisteredQueryHint >> &	query_hints
	)

Definition at line 2415 of file RelAlgDag.cpp.

References CHECK.

Referenced by add_window_function_pre_project(), and separate_window_function_expressions().

                     {
  auto delivered_hints = prev_node->getDeliveredHints();
  bool needs_propagate_hints = !delivered_hints->empty();
  if (needs_propagate_hints) {
    for (auto& kv : *delivered_hints) {
      new_node->addHint(kv.second);
    }
    auto prev_it = query_hints.find(prev_node->toHash());
    // query hint for the prev projection node should be registered
    CHECK(prev_it != query_hints.end());
    auto prev_hint_it = prev_it->second.find(prev_node->getId());
    CHECK(prev_hint_it != prev_it->second.end());
    std::unordered_map<unsigned, RegisteredQueryHint> hint_map;
    hint_map.emplace(new_node->getId(), prev_hint_it->second);
    query_hints.emplace(new_node->toHash(), hint_map);
  }
}

Here is the caller graph for this function:

std::vector<const Rex*> anonymous_namespace{RelAlgDag.cpp}::remapTargetPointers	(	std::vector< std::unique_ptr< const RexAgg >> const &	agg_exprs_new,
		std::vector< std::unique_ptr< const RexScalar >> const &	scalar_sources_new,
		std::vector< std::unique_ptr< const RexAgg >> const &	agg_exprs_old,
		std::vector< std::unique_ptr< const RexScalar >> const &	scalar_sources_old,
		std::vector< const Rex * > const &	target_exprs_old
	)

Definition at line 638 of file RelAlgDag.cpp.

References CHECK.

                                                   {
  std::vector<const Rex*> target_exprs(target_exprs_old);
  std::unordered_map<const Rex*, const Rex*> old_to_new_target(target_exprs.size());
  for (size_t i = 0; i < agg_exprs_new.size(); ++i) {
    old_to_new_target.emplace(agg_exprs_old[i].get(), agg_exprs_new[i].get());
  }
  for (size_t i = 0; i < scalar_sources_new.size(); ++i) {
    old_to_new_target.emplace(scalar_sources_old[i].get(), scalar_sources_new[i].get());
  }
  for (auto& target : target_exprs) {
    auto target_it = old_to_new_target.find(target);
    CHECK(target_it != old_to_new_target.end());
    target = target_it->second;
  }
  return target_exprs;
}

void anonymous_namespace{RelAlgDag.cpp}::reset_table_function_inputs	(	std::vector< const Rex * > &	column_inputs,
		const std::vector< std::unique_ptr< const RexScalar >> &	old_table_func_inputs,
		const std::vector< std::unique_ptr< const RexScalar >> &	new_table_func_inputs
	)

Definition at line 711 of file RelAlgDag.cpp.

References CHECK, and CHECK_EQ.

Referenced by RelTableFunction::RelTableFunction(), and RelTableFunction::setTableFuncInputs().

                                                                            {
  CHECK_EQ(old_table_func_inputs.size(), new_table_func_inputs.size());
  std::unordered_map<const Rex*, const Rex*> old_to_new_input;
  for (size_t i = 0; i < old_table_func_inputs.size(); ++i) {
    old_to_new_input.emplace(old_table_func_inputs[i].get(),
                             new_table_func_inputs[i].get());
  }
  for (auto& target : column_inputs) {
    auto target_it = old_to_new_input.find(target);
    CHECK(target_it != old_to_new_input.end());
    target = target_it->second;
  }
}

Here is the caller graph for this function:

bool anonymous_namespace{RelAlgDag.cpp}::same_ignoring_notnull	(	SQLTypeInfo	ti0,
		SQLTypeInfo	ti1
	)

Definition at line 890 of file RelAlgDag.cpp.

References SQLTypeInfo::set_notnull().

Referenced by RelLogicalUnion::getCompatibleMetainfoTypes().

                                                             {
  ti0.set_notnull({});  // Actual value doesn't matter
  ti1.set_notnull({});  // as long as they are the same.
  return ti0 == ti1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void anonymous_namespace{RelAlgDag.cpp}::separate_window_function_expressions	(	std::vector< std::shared_ptr< RelAlgNode >> &	nodes,
		std::unordered_map< size_t, std::unordered_map< unsigned, RegisteredQueryHint >> &	query_hints
	)

Detect the presence of window function operators nested inside expressions. Separate the window function operator from the expression, computing the expression as a subsequent step by pushing the expression to a new project node, and replacing the nested window function operator with a RexInput. Also move all input nodes to the newly created project node. Overall, we have the following query plan: from: Window_Project -> Child to: Window_Project -> New_Project -> Child In pseudocode: for each rex in project list: detect nested window function expression if nested window function expression: push the nested window function expression to the new project P create a new RexInput r_i which references the w_i in P and put it to M (M: a map between nested window function expression w_i and r_i) else push it down to the new project P create a new RexInput r_i which references the rex in P and put it to M for each rex in the project list: visit the rex and find a chance to replace it (or its operand) by using M

Definition at line 2459 of file RelAlgDag.cpp.

References CHECK, anonymous_namespace{RelAlgDag.cpp}::anonymous_namespace{RelAlgDag.cpp}::is_window_function_operator(), propagate_hints_to_new_project(), and RexVisitorBase< T >::visit().

Referenced by RelAlgDagBuilder::optimizeDag().

                     {
  std::list<std::shared_ptr<RelAlgNode>> node_list(nodes.begin(), nodes.end());
  for (auto node_itr = node_list.begin(); node_itr != node_list.end(); ++node_itr) {
    const auto node = *node_itr;
    auto window_func_project_node = std::dynamic_pointer_cast<RelProject>(node);
    if (!window_func_project_node) {
      continue;
    }

    const auto prev_node_itr = std::prev(node_itr);
    const auto prev_node = *prev_node_itr;
    CHECK(prev_node);

    // map scalar expression index in the project node to window function ptr
    std::unordered_map<size_t, const RexScalar*> collected_window_func;
    WindowFunctionCollector collector(collected_window_func, false);
    // Iterate the target exprs of the project node and check for window function
    // expressions. If an embedded expression exists, collect it
    for (size_t i = 0; i < window_func_project_node->size(); i++) {
      const auto scalar_rex = window_func_project_node->getProjectAt(i);
      if (is_window_function_operator(scalar_rex)) {
        // top level window function exprs are fine
        continue;
      }
      collector.visit(scalar_rex);
    }

    if (!collected_window_func.empty()) {
      // we have a nested window function expression
      std::unordered_set<size_t> collected_window_func_hash;
      // the current window function needs a set of new rex input which references
      // expressions in the newly introduced projection node
      std::vector<std::unique_ptr<const RexScalar>> new_rex_input_for_window_func;
      // a target projection expression of the newly created projection node
      std::vector<std::unique_ptr<const RexScalar>> new_scalar_expr_for_window_project;
      // a map between nested window function (hash val) and
      // its rex index stored in the `new_rex_input_for_window_func`
      std::unordered_map<size_t, size_t> window_func_to_new_rex_input_idx_map;
      // a map between RexInput of the current window function projection node (hash
      // val) and its corresponding new RexInput which is pushed down to the new
      // projection node
      std::unordered_map<size_t, std::unique_ptr<const RexInput>>
          new_rex_input_from_child_node;
      RexDeepCopyVisitor copier;

      std::vector<std::unique_ptr<const RexScalar>> dummy_scalar_exprs;
      std::vector<std::string> dummy_fields;
      std::vector<std::string> new_project_field_names;
      // create a new project node, it will contain window function expressions
      auto new_project =
          std::make_shared<RelProject>(dummy_scalar_exprs, dummy_fields, prev_node);
      // insert this new project node between the current window project node and its
      // child node
      node_list.insert(node_itr, new_project);

      // retrieve various information to replace expressions in the current window
      // function project node w/ considering scalar expressions in the new project node
      std::for_each(collected_window_func.begin(),
                    collected_window_func.end(),
                    [&new_project_field_names,
                     &collected_window_func_hash,
                     &new_rex_input_for_window_func,
                     &new_scalar_expr_for_window_project,
                     &copier,
                     &new_project,
                     &window_func_to_new_rex_input_idx_map](const auto& kv) {
                      // compute window function expr's hash, and create a new rex_input
                      // for it
                      collected_window_func_hash.insert(kv.first);

                      // map an old expression in the window function project node
                      // to an index of the corresponding new RexInput
                      const auto rex_idx = new_rex_input_for_window_func.size();
                      window_func_to_new_rex_input_idx_map.emplace(kv.first, rex_idx);

                      // create a new RexInput and make it as one of new expression of
                      // the newly created project node
                      new_rex_input_for_window_func.emplace_back(
                          std::make_unique<const RexInput>(new_project.get(), rex_idx));
                      new_scalar_expr_for_window_project.push_back(
                          std::move(copier.visit(kv.second)));
                      new_project_field_names.emplace_back("");
                    });
      new_project->setExpressions(new_scalar_expr_for_window_project);
      new_project->setFields(std::move(new_project_field_names));

      auto window_func_scalar_exprs =
          window_func_project_node->getExpressionsAndRelease();
      RexWindowFuncReplacementVisitor replacer(collected_window_func_hash,
                                               new_rex_input_for_window_func,
                                               window_func_to_new_rex_input_idx_map,
                                               new_project.get(),
                                               new_rex_input_from_child_node);
      size_t rex_idx = 0;
      for (auto& scalar_expr : window_func_scalar_exprs) {
        // try to replace the old expressions in the window function project node
        // with expressions of the newly created project node
        auto new_parent_rex = replacer.visit(scalar_expr.get());
        window_func_scalar_exprs[rex_idx] = std::move(new_parent_rex);
        rex_idx++;
      }
      // Update the previous window project node
      window_func_project_node->setExpressions(window_func_scalar_exprs);
      window_func_project_node->replaceInput(prev_node, new_project);
      propagate_hints_to_new_project(window_func_project_node, new_project, query_hints);
      new_project->setPushedDownWindowExpr();
    }
  }
  nodes.assign(node_list.begin(), node_list.end());
}

Here is the call graph for this function:

Here is the caller graph for this function:

void anonymous_namespace{RelAlgDag.cpp}::set_notnulls	(	std::vector< TargetMetaInfo > *	tmis0,
		std::vector< bool > const &	notnulls
	)

Definition at line 896 of file RelAlgDag.cpp.

References SQLTypeInfo::set_notnull().

Referenced by RelLogicalUnion::getCompatibleMetainfoTypes().

                                                                                     {
  for (size_t j = 0; j < tmis0->size(); ++j) {
    SQLTypeInfo ti = (*tmis0)[j].get_type_info();
    SQLTypeInfo physical_ti = (*tmis0)[j].get_physical_type_info();
    ti.set_notnull(notnulls[j]);
    physical_ti.set_notnull(notnulls[j]);
    (*tmis0)[j] = TargetMetaInfo((*tmis0)[j].get_resname(), ti, physical_ti);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::vector<std::string> anonymous_namespace{RelAlgDag.cpp}::strings_from_json_array ( const rapidjson::Value &  json_str_arr )

noexcept

Definition at line 1336 of file RelAlgDag.cpp.

References CHECK.

Referenced by details::RelAlgDispatcher::dispatchAggregate(), details::RelAlgDispatcher::dispatchProject(), getFieldNamesFromScanNode(), and details::RelAlgDispatcher::getRelAlgInputs().

                                                 {
  CHECK(json_str_arr.IsArray());
  std::vector<std::string> fields;
  for (auto json_str_arr_it = json_str_arr.Begin(); json_str_arr_it != json_str_arr.End();
       ++json_str_arr_it) {
    CHECK(json_str_arr_it->IsString());
    fields.emplace_back(json_str_arr_it->GetString());
  }
  return fields;
}

Here is the caller graph for this function:

JoinType anonymous_namespace{RelAlgDag.cpp}::to_join_type

(

const std::string &

join_type_name

)

Definition at line 1404 of file RelAlgDag.cpp.

References ANTI, INNER, LEFT, and SEMI.

Referenced by details::RelAlgDispatcher::dispatchJoin().

                                                       {
  if (join_type_name == "inner") {
    return JoinType::INNER;
  }
  if (join_type_name == "left") {
    return JoinType::LEFT;
  }
  if (join_type_name == "semi") {
    return JoinType::SEMI;
  }
  if (join_type_name == "anti") {
    return JoinType::ANTI;
  }
  throw QueryNotSupported("Join type (" + join_type_name + ") not supported");
}

Here is the caller graph for this function:

Variable Documentation

const unsigned anonymous_namespace{RelAlgDag.cpp}::FIRST_RA_NODE_ID = 1

Definition at line 41 of file RelAlgDag.cpp.

Referenced by RelAlgNode::resetRelAlgFirstId().