RelAlgDag Class Reference

#include <RelAlgDag.h>

Inheritance diagram for RelAlgDag:

Collaboration diagram for RelAlgDag:

Public Types
enum	BuildState { BuildState::kNotBuilt, BuildState::kBuiltNotOptimized, BuildState::kBuiltOptimized }

Public Member Functions
	RelAlgDag ()
BuildState	getBuildState () const
void	eachNode (std::function< void(RelAlgNode const *)> const &) const
const RelAlgNode &	getRootNode () const
std::shared_ptr< const RelAlgNode >	getRootNodeShPtr () const
std::vector< std::shared_ptr < RelAlgNode > > &	getNodes ()
void	registerSubquery (std::shared_ptr< RexSubQuery > subquery)
const std::vector < std::shared_ptr< RexSubQuery > > &	getSubqueries () const
void	registerQueryHints (std::shared_ptr< RelAlgNode > node, Hints *hints_delivered, RegisteredQueryHint &global_query_hint)
void	registerQueryHint (const RelAlgNode *node, const RegisteredQueryHint &query_hint)
std::optional < RegisteredQueryHint >	getQueryHint (const RelAlgNode *node) const
std::unordered_map< size_t, std::unordered_map< unsigned, RegisteredQueryHint > > &	getQueryHints ()
const RegisteredQueryHint &	getGlobalHints () const
void	setGlobalQueryHints (const RegisteredQueryHint &global_hints)
void	resetQueryExecutionState ()

Private Attributes
BuildState	build_state_
std::vector< std::shared_ptr < RelAlgNode > >	nodes_
std::vector< std::shared_ptr < RexSubQuery > >	subqueries_
std::unordered_map< size_t, std::unordered_map< unsigned, RegisteredQueryHint > >	query_hint_
RegisteredQueryHint	global_hints_

Friends
struct	RelAlgDagSerializer
struct	RelAlgDagModifier

Detailed Description

Class defining an in-memory, easy-to-navigate internal representation of a relational algebra DAG interpreted from a JSON provided by Calcite. Must be built through the RelAlgDagBuilder interface.

Definition at line 2799 of file RelAlgDag.h.

Member Enumeration Documentation

enum RelAlgDag::BuildState

strong

Enumerator
kNotBuilt
kBuiltNotOptimized
kBuiltOptimized

Definition at line 2801 of file RelAlgDag.h.

{ kNotBuilt, kBuiltNotOptimized, kBuiltOptimized };

Constructor & Destructor Documentation

RelAlgDag::RelAlgDag ( )

inline

Definition at line 2803 of file RelAlgDag.h.

References kNotBuilt.

: build_state_{BuildState::kNotBuilt} {}

Member Function Documentation

void RelAlgDag::eachNode

(

std::function< void(RelAlgNode const *)> const &

callback

)

const

Definition at line 3463 of file RelAlgDag.cpp.

References nodes_.

                                                                                   {
  for (auto const& node : nodes_) {
    if (node) {
      callback(node.get());
    }
  }
}

BuildState RelAlgDag::getBuildState ( ) const

inline

Definition at line 2805 of file RelAlgDag.h.

References build_state_.

Referenced by RelAlgDagBuilder::optimizeDag().

{ return build_state_; }

Here is the caller graph for this function:

const RegisteredQueryHint& RelAlgDag::getGlobalHints ( ) const

inline

Definition at line 3367 of file RelAlgDag.h.

References global_hints_.

Referenced by anonymous_namespace{RelAlgDag.cpp}::parse_subquery().

{ return global_hints_; }

Here is the caller graph for this function:

std::vector<std::shared_ptr<RelAlgNode> >& RelAlgDag::getNodes ( )

inline

Definition at line 2824 of file RelAlgDag.h.

References nodes_.

Referenced by RelAlgExecutor::executeRelAlgQueryNoRetry().

{ return nodes_; }

Here is the caller graph for this function:

std::optional<RegisteredQueryHint> RelAlgDag::getQueryHint ( const RelAlgNode *  node ) const

inline

Definition at line 3339 of file RelAlgDag.h.

References RelAlgNode::getId(), global_hints_, RegisteredQueryHint::isAnyQueryHintDelivered(), query_hint_, and RelAlgNode::toHash().

                                                                              {
    auto node_it = query_hint_.find(node->toHash());
    if (node_it != query_hint_.end()) {
      auto const& registered_query_hint_map = node_it->second;
      auto hint_it = registered_query_hint_map.find(node->getId());
      if (hint_it != registered_query_hint_map.end()) {
        auto const& registered_query_hint = hint_it->second;
        if (global_hints_.isAnyQueryHintDelivered()) {
          // apply global hint to the registered query hint for this query block
          return std::make_optional(registered_query_hint || global_hints_);
        } else {
          return std::make_optional(registered_query_hint);
        }
      }
    }
    if (global_hints_.isAnyQueryHintDelivered()) {
      // if no hint is registered from this query block
      // we return global hint instead
      return std::make_optional(global_hints_);
    }
    return std::nullopt;
  }

Here is the call graph for this function:

std::unordered_map<size_t, std::unordered_map<unsigned, RegisteredQueryHint> >& RelAlgDag::getQueryHints ( )

inline

Definition at line 3363 of file RelAlgDag.h.

References query_hint_.

                  {
    return query_hint_;
  }

const RelAlgNode& RelAlgDag::getRootNode ( ) const

inline

Returns the root node of the DAG.

Definition at line 2812 of file RelAlgDag.h.

References CHECK, and nodes_.

                                        {
    CHECK(nodes_.size());
    const auto& last_ptr = nodes_.back();
    CHECK(last_ptr);
    return *last_ptr;
  }

std::shared_ptr<const RelAlgNode> RelAlgDag::getRootNodeShPtr ( ) const

inline

Definition at line 2819 of file RelAlgDag.h.

References CHECK, and nodes_.

                                                           {
    CHECK(nodes_.size());
    return nodes_.back();
  }

const std::vector<std::shared_ptr<RexSubQuery> >& RelAlgDag::getSubqueries ( ) const

inline

Gets all registered subqueries. Only the root DAG can contain subqueries.

Definition at line 2837 of file RelAlgDag.h.

References subqueries_.

                                                                     {
    return subqueries_;
  }

void RelAlgDag::registerQueryHint ( const RelAlgNode *  node, const RegisteredQueryHint &  query_hint  )

inline

Definition at line 3327 of file RelAlgDag.h.

References RelAlgNode::getId(), query_hint_, and RelAlgNode::toHash().

Referenced by anonymous_namespace{RelAlgDag.cpp}::parse_subquery(), and registerQueryHints().

                                                                                        {
    auto node_key = node->toHash();
    auto it = query_hint_.find(node_key);
    if (it == query_hint_.end()) {
      std::unordered_map<unsigned, RegisteredQueryHint> hint_map;
      hint_map.emplace(node->getId(), query_hint);
      query_hint_.emplace(node_key, hint_map);
    } else {
      it->second.emplace(node->getId(), query_hint);
    }
  }

Here is the call graph for this function:

Here is the caller graph for this function:

void RelAlgDag::registerQueryHints ( std::shared_ptr< RelAlgNode >  node, Hints *  hints_delivered, RegisteredQueryHint &  global_query_hint  )

inline

Definition at line 2842 of file RelAlgDag.h.

References RegisteredQueryHint::aggregate_tree_fanout, RegisteredQueryHint::bbox_intersect_allow_gpu_build, RegisteredQueryHint::bbox_intersect_bucket_threshold, RegisteredQueryHint::bbox_intersect_keys_per_bin, RegisteredQueryHint::bbox_intersect_max_size, RegisteredQueryHint::bbox_intersect_no_cache, CHECK_EQ, RegisteredQueryHint::columnar_output, RegisteredQueryHint::cpu_mode, RegisteredQueryHint::cuda_block_size, RegisteredQueryHint::cuda_grid_size_multiplier, RegisteredQueryHint::dynamic_watchdog, RegisteredQueryHint::force_baseline_hash_join, RegisteredQueryHint::force_one_to_many_hash_join, g_enable_columnar_output, g_enable_data_recycler, g_enable_dynamic_watchdog, g_enable_watchdog, g_use_query_resultset_cache, kAggregateTreeFanout, kAllowLoopJoin, kBBoxIntersectAllowGpuBuild, kBBoxIntersectBucketThreshold, kBBoxIntersectKeysPerBin, kBBoxIntersectMaxSize, kBBoxIntersectNoCache, kColumnarOutput, kCpuMode, kCudaBlockSize, kCudaGridSize, kDisableLoopJoin, kDynamicWatchdog, kDynamicWatchdogOff, RegisteredQueryHint::keep_result, RegisteredQueryHint::keep_table_function_result, kforceBaselineHashJoin, kforceOneToManyHashJoin, kKeepResult, kKeepTableFuncResult, kLoopJoinInnerTableMaxNumRows, kMaxJoinHashTableSize, kNDVGroupsEstimatorMultiplier, kOptCudaBlockAndGridSizes, kPreflightCountQueryThreshold, kQueryTimeLimit, kRowwiseOutput, kTableReorderingOff, kWatchdog, kWatchdogMaxProjectedRowsPerDevice, kWatchdogOff, RegisteredQueryHint::loop_join_inner_table_max_num_rows, RegisteredQueryHint::max_join_hash_table_size, RegisteredQueryHint::ndv_groups_estimator_multiplier, RegisteredQueryHint::opt_cuda_grid_and_block_size, RegisteredQueryHint::preflight_count_query_threshold, RegisteredQueryHint::query_time_limit, RegisteredQueryHint::registerHint(), registerQueryHint(), RegisteredQueryHint::rowwise_output, RegisteredQueryHint::table_reordering_off, RegisteredQueryHint::use_loop_join, VLOG, RegisteredQueryHint::watchdog, and RegisteredQueryHint::watchdog_max_projected_rows_per_device.

                                                                  {
    std::optional<bool> has_global_columnar_output_hint = std::nullopt;
    std::optional<bool> has_global_rowwise_output_hint = std::nullopt;
    RegisteredQueryHint query_hint;
    for (auto it = hints_delivered->begin(); it != hints_delivered->end(); it++) {
      auto target = it->second;
      auto hint_type = it->first;
      switch (hint_type) {
        case QueryHint::kCpuMode: {
          query_hint.registerHint(QueryHint::kCpuMode);
          query_hint.cpu_mode = true;
          if (target.isGlobalHint()) {
            global_query_hint.registerHint(QueryHint::kCpuMode);
            global_query_hint.cpu_mode = true;
          }
          break;
        }
        case QueryHint::kColumnarOutput: {
          has_global_columnar_output_hint = target.isGlobalHint();
          break;
        }
        case QueryHint::kRowwiseOutput: {
          has_global_rowwise_output_hint = target.isGlobalHint();
          break;
        }
        case QueryHint::kBBoxIntersectBucketThreshold: {
          if (target.getListOptions().size() != 1) {
            VLOG(1) << "Skip the given query hint \"bbox_intersect_bucket_threshold\" ("
                    << target.getListOptions()[0]
                    << ") : invalid # hint options are given";
            break;
          }
          double bbox_intersect_bucket_threshold = std::stod(target.getListOptions()[0]);
          if (bbox_intersect_bucket_threshold >= 0.0 &&
              bbox_intersect_bucket_threshold <= 90.0) {
            query_hint.registerHint(QueryHint::kBBoxIntersectBucketThreshold);
            query_hint.bbox_intersect_bucket_threshold = bbox_intersect_bucket_threshold;
            if (target.isGlobalHint()) {
              global_query_hint.registerHint(QueryHint::kBBoxIntersectBucketThreshold);
              global_query_hint.bbox_intersect_bucket_threshold =
                  bbox_intersect_bucket_threshold;
            }
          } else {
            VLOG(1) << "Skip the given query hint \"bbox_intersect_bucket_threshold\" ("
                    << bbox_intersect_bucket_threshold
                    << ") : the hint value should be within 0.0 ~ 90.0";
          }
          break;
        }
        case QueryHint::kBBoxIntersectMaxSize: {
          if (target.getListOptions().size() != 1) {
            VLOG(1) << "Skip the given query hint \"bbox_intersect_max_size\" ("
                    << target.getListOptions()[0]
                    << ") : invalid # hint options are given";
            break;
          }
          std::stringstream ss(target.getListOptions()[0]);
          int bbox_intersect_max_size;
          ss >> bbox_intersect_max_size;
          if (bbox_intersect_max_size >= 0) {
            query_hint.registerHint(QueryHint::kBBoxIntersectMaxSize);
            query_hint.bbox_intersect_max_size = (size_t)bbox_intersect_max_size;
            if (target.isGlobalHint()) {
              global_query_hint.registerHint(QueryHint::kBBoxIntersectMaxSize);
              global_query_hint.bbox_intersect_max_size = (size_t)bbox_intersect_max_size;
            }
          } else {
            VLOG(1) << "Skip the query hint \"bbox_intersect_max_size\" ("
                    << bbox_intersect_max_size
                    << ") : the hint value should be larger than or equal to zero";
          }
          break;
        }
        case QueryHint::kBBoxIntersectAllowGpuBuild: {
          query_hint.registerHint(QueryHint::kBBoxIntersectAllowGpuBuild);
          query_hint.bbox_intersect_allow_gpu_build = true;
          if (target.isGlobalHint()) {
            global_query_hint.registerHint(QueryHint::kBBoxIntersectAllowGpuBuild);
            global_query_hint.bbox_intersect_allow_gpu_build = true;
          }
          break;
        }
        case QueryHint::kBBoxIntersectNoCache: {
          query_hint.registerHint(QueryHint::kBBoxIntersectNoCache);
          query_hint.bbox_intersect_no_cache = true;
          if (target.isGlobalHint()) {
            global_query_hint.registerHint(QueryHint::kBBoxIntersectNoCache);
            global_query_hint.bbox_intersect_no_cache = true;
          }
          VLOG(1) << "Skip auto tuner and hashtable caching for bbox_intersect join.";
          break;
        }
        case QueryHint::kBBoxIntersectKeysPerBin: {
          if (target.getListOptions().size() != 1) {
            VLOG(1) << "Skip the given query hint \"bbox_intersect_keys_per_bin\" ("
                    << target.getListOptions()[0]
                    << ") : invalid # hint options are given";
            break;
          }
          double bbox_intersect_keys_per_bin = std::stod(target.getListOptions()[0]);
          if (bbox_intersect_keys_per_bin > 0.0 &&
              bbox_intersect_keys_per_bin < std::numeric_limits<double>::max()) {
            query_hint.registerHint(QueryHint::kBBoxIntersectKeysPerBin);
            query_hint.bbox_intersect_keys_per_bin = bbox_intersect_keys_per_bin;
            if (target.isGlobalHint()) {
              global_query_hint.registerHint(QueryHint::kBBoxIntersectKeysPerBin);
              global_query_hint.bbox_intersect_keys_per_bin = bbox_intersect_keys_per_bin;
            }
          } else {
            VLOG(1) << "Skip the given query hint \"bbox_intersect_keys_per_bin\" ("
                    << bbox_intersect_keys_per_bin
                    << ") : the hint value should be larger than zero";
          }
          break;
        }
        case QueryHint::kKeepResult: {
          if (!g_enable_data_recycler || !g_use_query_resultset_cache) {
            VLOG(1) << "Skip query hint \'keep_result\' because neither data recycler "
                       "nor query resultset recycler is enabled";
          } else {
            query_hint.registerHint(QueryHint::kKeepResult);
            query_hint.keep_result = true;
            if (target.isGlobalHint()) {
              global_query_hint.registerHint(QueryHint::kKeepResult);
              global_query_hint.keep_result = true;
            }
          }
          break;
        }
        case QueryHint::kKeepTableFuncResult: {
          if (!g_enable_data_recycler || !g_use_query_resultset_cache) {
            VLOG(1) << "Skip query hint \'keep_table_function_result\' because neither "
                       "data recycler "
                       "nor query resultset recycler is enabled";
          } else {
            // we assume table function's hint is handled as global hint by default
            global_query_hint.registerHint(QueryHint::kKeepTableFuncResult);
            global_query_hint.keep_table_function_result = true;
          }
          break;
        }
        case QueryHint::kAggregateTreeFanout: {
          if (target.getListOptions().size() != 1u) {
            VLOG(1) << "Skip the given query hint \"aggregate_tree_fanout\" ("
                    << target.getListOptions()[0]
                    << ") : invalid # hint options are given";
            break;
          }
          int aggregate_tree_fanout = std::stoi(target.getListOptions()[0]);
          if (aggregate_tree_fanout < 0) {
            VLOG(1) << "A fan-out of an aggregate tree should be larger than zero";
          } else if (aggregate_tree_fanout > 1024) {
            VLOG(1) << "Too large fanout is provided (i.e., fanout < 1024)";
          } else {
            query_hint.registerHint(QueryHint::kAggregateTreeFanout);
            query_hint.aggregate_tree_fanout = aggregate_tree_fanout;
            if (target.isGlobalHint()) {
              global_query_hint.registerHint(QueryHint::kAggregateTreeFanout);
              global_query_hint.aggregate_tree_fanout = aggregate_tree_fanout;
            }
          }
          break;
        }
        case QueryHint::kCudaBlockSize: {
          CHECK_EQ(1u, target.getListOptions().size());
          int cuda_block_size = std::stoi(target.getListOptions()[0]);
          if (cuda_block_size <= 0) {
            VLOG(1) << "CUDA block size should be larger than zero";
          } else if (cuda_block_size > 1024) {
            VLOG(1) << "CUDA block size should be less or equal to 1024";
          } else {
            query_hint.registerHint(QueryHint::kCudaBlockSize);
            query_hint.cuda_block_size = cuda_block_size;
            if (target.isGlobalHint()) {
              global_query_hint.registerHint(QueryHint::kCudaBlockSize);
              global_query_hint.cuda_block_size = cuda_block_size;
            }
          }
          break;
        }
        case QueryHint::kCudaGridSize: {
          CHECK_EQ(1u, target.getListOptions().size());
          double cuda_grid_size_multiplier = std::stod(target.getListOptions()[0]);
          double min_grid_size_multiplier{0};
          double max_grid_size_multiplier{1024};
          if (cuda_grid_size_multiplier <= min_grid_size_multiplier) {
            VLOG(1) << "CUDA grid size multiplier should be larger than zero";
          } else if (cuda_grid_size_multiplier > max_grid_size_multiplier) {
            VLOG(1) << "CUDA grid size multiplier should be less than 1024";
          } else {
            query_hint.registerHint(QueryHint::kCudaGridSize);
            query_hint.cuda_grid_size_multiplier = cuda_grid_size_multiplier;
            if (target.isGlobalHint()) {
              global_query_hint.registerHint(QueryHint::kCudaGridSize);
              global_query_hint.cuda_grid_size_multiplier = cuda_grid_size_multiplier;
            }
          }
          break;
        }
        case QueryHint::kOptCudaBlockAndGridSizes: {
          query_hint.registerHint(QueryHint::kOptCudaBlockAndGridSizes);
          query_hint.opt_cuda_grid_and_block_size = true;
          if (target.isGlobalHint()) {
            global_query_hint.registerHint(QueryHint::kOptCudaBlockAndGridSizes);
            global_query_hint.opt_cuda_grid_and_block_size = true;
          }
          break;
        }
        case QueryHint::kWatchdog: {
          if (g_enable_watchdog) {
            VLOG(1) << "Skip the given query hint \"watchdog\": already enabled";
          } else {
            query_hint.registerHint(QueryHint::kWatchdog);
            query_hint.watchdog = true;
            if (target.isGlobalHint()) {
              global_query_hint.registerHint(QueryHint::kWatchdog);
              global_query_hint.watchdog = true;
            }
          }
          break;
        }
        case QueryHint::kWatchdogOff: {
          if (!g_enable_watchdog) {
            VLOG(1) << "Skip the given query hint \"watchdog_off\": already disabled";
          } else {
            query_hint.registerHint(QueryHint::kWatchdogOff);
            query_hint.watchdog = false;
            if (target.isGlobalHint()) {
              global_query_hint.registerHint(QueryHint::kWatchdogOff);
              global_query_hint.watchdog = false;
            }
          }

          break;
        }
        case QueryHint::kDynamicWatchdog: {
          if (g_enable_dynamic_watchdog) {
            VLOG(1) << "Skip the given query hint \"dynamic_watchdog\": already enabled";
          } else {
            query_hint.registerHint(QueryHint::kDynamicWatchdog);
            query_hint.dynamic_watchdog = true;
            if (target.isGlobalHint()) {
              global_query_hint.registerHint(QueryHint::kDynamicWatchdog);
              global_query_hint.dynamic_watchdog = true;
            }
          }
          break;
        }
        case QueryHint::kDynamicWatchdogOff: {
          if (!g_enable_dynamic_watchdog) {
            VLOG(1)
                << "Skip the given query hint \"dynamic_watchdog_off\": already disabled";
          } else {
            query_hint.registerHint(QueryHint::kDynamicWatchdogOff);
            query_hint.dynamic_watchdog = false;
            if (target.isGlobalHint()) {
              global_query_hint.registerHint(QueryHint::kDynamicWatchdogOff);
              global_query_hint.dynamic_watchdog = false;
            }
          }
          break;
        }
        case QueryHint::kQueryTimeLimit: {
          if (hints_delivered->find(QueryHint::kDynamicWatchdogOff) !=
              hints_delivered->end()) {
            VLOG(1) << "Skip the given query hint \"query_time_limit\" ("
                    << target.getListOptions()[0]
                    << ") : cannot use it with \"dynamic_watchdog_off\" hint";
            break;
          }
          if (target.getListOptions().size() != 1) {
            VLOG(1) << "Skip the given query hint \"query_time_limit\" ("
                    << target.getListOptions()[0]
                    << ") : invalid # hint options are given";
            break;
          }
          double query_time_limit = std::stoi(target.getListOptions()[0]);
          if (query_time_limit <= 0) {
            VLOG(1) << "Skip the given query hint \"query_time_limit\" ("
                    << target.getListOptions()[0]
                    << ") : the hint value should be larger than zero";
            break;
          }
          query_hint.registerHint(QueryHint::kQueryTimeLimit);
          query_hint.query_time_limit = query_time_limit;
          if (target.isGlobalHint()) {
            global_query_hint.registerHint(QueryHint::kQueryTimeLimit);
            global_query_hint.query_time_limit = query_time_limit;
          }
          break;
        }
        case QueryHint::kAllowLoopJoin: {
          query_hint.registerHint(QueryHint::kAllowLoopJoin);
          query_hint.use_loop_join = true;
          if (target.isGlobalHint()) {
            global_query_hint.registerHint(QueryHint::kAllowLoopJoin);
            global_query_hint.use_loop_join = true;
          }
          break;
        }
        case QueryHint::kDisableLoopJoin: {
          query_hint.registerHint(QueryHint::kDisableLoopJoin);
          query_hint.use_loop_join = false;
          if (target.isGlobalHint()) {
            global_query_hint.registerHint(QueryHint::kDisableLoopJoin);
            global_query_hint.use_loop_join = false;
          }
          break;
        }
        case QueryHint::kLoopJoinInnerTableMaxNumRows: {
          CHECK_EQ(1u, target.getListOptions().size());
          int loop_size_threshold = std::stoi(target.getListOptions()[0]);
          if (loop_size_threshold <= 0) {
            VLOG(1)
                << "Skip the given query hint \"loop_join_inner_table_max_num_rows\" ("
                << target.getListOptions()[0]
                << ") : the hint value should be larger than zero";
          } else {
            query_hint.registerHint(QueryHint::kLoopJoinInnerTableMaxNumRows);
            query_hint.loop_join_inner_table_max_num_rows = loop_size_threshold;
            if (target.isGlobalHint()) {
              global_query_hint.registerHint(QueryHint::kLoopJoinInnerTableMaxNumRows);
              global_query_hint.loop_join_inner_table_max_num_rows = loop_size_threshold;
            }
          }
          break;
        }
        case QueryHint::kMaxJoinHashTableSize: {
          CHECK_EQ(1u, target.getListOptions().size());
          int max_join_hash_table_size = std::stoi(target.getListOptions()[0]);
          if (max_join_hash_table_size <= 0) {
            VLOG(1) << "Skip the given query hint \"max_join_hashtable_size\" ("
                    << target.getListOptions()[0]
                    << ") : the hint value should be larger than zero";
          } else {
            query_hint.registerHint(QueryHint::kMaxJoinHashTableSize);
            query_hint.max_join_hash_table_size = max_join_hash_table_size;
            if (target.isGlobalHint()) {
              global_query_hint.registerHint(QueryHint::kMaxJoinHashTableSize);
              global_query_hint.max_join_hash_table_size = max_join_hash_table_size;
            }
          }
          break;
        }
        case QueryHint::kforceBaselineHashJoin: {
          query_hint.registerHint(QueryHint::kforceBaselineHashJoin);
          query_hint.force_baseline_hash_join = true;
          if (target.isGlobalHint()) {
            global_query_hint.registerHint(QueryHint::kforceBaselineHashJoin);
            global_query_hint.force_baseline_hash_join = true;
          }
          break;
        }
        case QueryHint::kforceOneToManyHashJoin: {
          query_hint.registerHint(QueryHint::kforceOneToManyHashJoin);
          query_hint.force_one_to_many_hash_join = true;
          if (target.isGlobalHint()) {
            global_query_hint.registerHint(QueryHint::kforceOneToManyHashJoin);
            global_query_hint.force_one_to_many_hash_join = true;
          }
          break;
        }
        case QueryHint::kWatchdogMaxProjectedRowsPerDevice: {
          CHECK_EQ(1u, target.getListOptions().size());
          int watchdog_max_projected_rows_per_device =
              std::stoi(target.getListOptions()[0]);
          if (watchdog_max_projected_rows_per_device <= 0) {
            VLOG(1) << "Skip the given query hint "
                       "\"watchdog_max_projected_rows_per_device\" ("
                    << target.getListOptions()[0]
                    << ") : the hint value should be larger than zero";
          } else {
            query_hint.registerHint(QueryHint::kWatchdogMaxProjectedRowsPerDevice);
            query_hint.watchdog_max_projected_rows_per_device =
                watchdog_max_projected_rows_per_device;
            if (target.isGlobalHint()) {
              global_query_hint.registerHint(
                  QueryHint::kWatchdogMaxProjectedRowsPerDevice);
              global_query_hint.watchdog_max_projected_rows_per_device =
                  watchdog_max_projected_rows_per_device;
            }
          }
          break;
        }
        case QueryHint::kPreflightCountQueryThreshold: {
          CHECK_EQ(1u, target.getListOptions().size());
          int preflight_count_query_threshold = std::stoi(target.getListOptions()[0]);
          if (preflight_count_query_threshold <= 0) {
            VLOG(1) << "Skip the given query hint \"preflight_count_query_threshold\" ("
                    << target.getListOptions()[0]
                    << ") : the hint value should be larger than zero";
          } else {
            query_hint.registerHint(QueryHint::kPreflightCountQueryThreshold);
            query_hint.preflight_count_query_threshold = preflight_count_query_threshold;
            if (target.isGlobalHint()) {
              global_query_hint.registerHint(QueryHint::kPreflightCountQueryThreshold);
              global_query_hint.preflight_count_query_threshold =
                  preflight_count_query_threshold;
            }
          }
          break;
        }
        case QueryHint::kTableReorderingOff: {
          query_hint.registerHint(QueryHint::kTableReorderingOff);
          query_hint.table_reordering_off = true;
          if (target.isGlobalHint()) {
            global_query_hint.registerHint(QueryHint::kTableReorderingOff);
            global_query_hint.table_reordering_off = true;
          }
          break;
        }
        case QueryHint::kNDVGroupsEstimatorMultiplier: {
          CHECK_EQ(1u, target.getListOptions().size());
          double ndv_groups_estimator_multiplier = std::stod(target.getListOptions()[0]);
          if (ndv_groups_estimator_multiplier < 1.0 ||
              ndv_groups_estimator_multiplier > 2.0) {
            VLOG(1) << "Skip the given query hint \"ndv_groups_estimator_multiplier\" ("
                    << target.getListOptions()[0]
                    << ") : the valid hint value range is 1.0 <= "
                       "ndv_groups_estimator_multiplier <= 2.0";
          } else {
            query_hint.registerHint(QueryHint::kNDVGroupsEstimatorMultiplier);
            query_hint.ndv_groups_estimator_multiplier = ndv_groups_estimator_multiplier;
            if (target.isGlobalHint()) {
              global_query_hint.registerHint(QueryHint::kNDVGroupsEstimatorMultiplier);
              global_query_hint.ndv_groups_estimator_multiplier =
                  ndv_groups_estimator_multiplier;
            }
          }
          break;
        }
        default:
          break;
      }
    }
    // we have four cases depending on 1) g_enable_columnar_output flag
    // and 2) query hint status: columnar_output and rowwise_output
    // case 1. g_enable_columnar_output = true
    // case 1.a) columnar_output = true (so rowwise_output = false);
    // case 1.b) rowwise_output = true (so columnar_output = false);
    // case 2. g_enable_columnar_output = false
    // case 2.a) columnar_output = true (so rowwise_output = false);
    // case 2.b) rowwise_output = true (so columnar_output = false);
    // case 1.a --> use columnar output
    // case 1.b --> use rowwise output
    // case 2.a --> use columnar output
    // case 2.b --> use rowwise output
    if (has_global_columnar_output_hint.has_value() &&
        has_global_rowwise_output_hint.has_value()) {
      VLOG(1)
          << "Two hints 1) columnar output and 2) rowwise output are enabled together, "
          << "so skip them and use the runtime configuration "
             "\"g_enable_columnar_output\"";
    } else if (has_global_columnar_output_hint.has_value() &&
               !has_global_rowwise_output_hint.has_value()) {
      if (g_enable_columnar_output) {
        VLOG(1) << "We already enable columnar output by default "
                   "(g_enable_columnar_output = true), so skip this columnar output hint";
      } else {
        query_hint.registerHint(QueryHint::kColumnarOutput);
        query_hint.columnar_output = true;
        if (*has_global_columnar_output_hint) {
          global_query_hint.registerHint(QueryHint::kColumnarOutput);
          global_query_hint.columnar_output = true;
        }
      }
    } else if (!has_global_columnar_output_hint.has_value() &&
               has_global_rowwise_output_hint.has_value()) {
      if (!g_enable_columnar_output) {
        VLOG(1) << "We already use the default rowwise output (g_enable_columnar_output "
                   "= false), so skip this rowwise output hint";
      } else {
        query_hint.registerHint(QueryHint::kRowwiseOutput);
        query_hint.rowwise_output = true;
        if (*has_global_rowwise_output_hint) {
          global_query_hint.registerHint(QueryHint::kRowwiseOutput);
          global_query_hint.rowwise_output = true;
        }
      }
    }
    registerQueryHint(node.get(), query_hint);
  }

Here is the call graph for this function:

void RelAlgDag::registerSubquery ( std::shared_ptr< RexSubQuery >  subquery )

inline

Registers a subquery with a root DAG builder. Should only be called during DAG building and registration should only occur on the root.

Definition at line 2830 of file RelAlgDag.h.

References subqueries_.

Referenced by anonymous_namespace{RelAlgDag.cpp}::parse_subquery().

                                                             {
    subqueries_.push_back(subquery);
  }

Here is the caller graph for this function:

void RelAlgDag::resetQueryExecutionState

(

)

Gets all registered subqueries. Only the root DAG can contain subqueries.

Definition at line 3471 of file RelAlgDag.cpp.

References nodes_.

                                         {
  for (auto& node : nodes_) {
    if (node) {
      node->resetQueryExecutionState();
    }
  }
}

void RelAlgDag::setGlobalQueryHints ( const RegisteredQueryHint &  global_hints )

inline

Definition at line 3369 of file RelAlgDag.h.

References global_hints_.

Referenced by RelAlgExecutor::executeRelAlgQueryNoRetry(), and anonymous_namespace{RelAlgDag.cpp}::parse_subquery().

                                                                    {
    global_hints_ = global_hints;
  }

Here is the caller graph for this function:

Friends And Related Function Documentation

friend struct RelAlgDagModifier

friend

Definition at line 3392 of file RelAlgDag.h.

friend struct RelAlgDagSerializer

friend

Definition at line 3391 of file RelAlgDag.h.

Member Data Documentation

BuildState RelAlgDag::build_state_

private

Definition at line 3379 of file RelAlgDag.h.

Referenced by getBuildState(), RelAlgDagSerializer::serialize(), and RelAlgDagModifier::setBuildState().

RegisteredQueryHint RelAlgDag::global_hints_

private

Definition at line 3389 of file RelAlgDag.h.

Referenced by getGlobalHints(), getQueryHint(), RelAlgDagSerializer::serialize(), and setGlobalQueryHints().

std::vector<std::shared_ptr<RelAlgNode> > RelAlgDag::nodes_

private

Definition at line 3381 of file RelAlgDag.h.

Referenced by eachNode(), getNodes(), RelAlgDagModifier::getNodes(), getRootNode(), getRootNodeShPtr(), resetQueryExecutionState(), and RelAlgDagSerializer::serialize().

std::unordered_map<size_t, std::unordered_map<unsigned, RegisteredQueryHint> > RelAlgDag::query_hint_

private

Definition at line 3388 of file RelAlgDag.h.

Referenced by getQueryHint(), getQueryHints(), RelAlgDagModifier::getQueryHints(), registerQueryHint(), and RelAlgDagSerializer::serialize().

std::vector<std::shared_ptr<RexSubQuery> > RelAlgDag::subqueries_

private

Definition at line 3382 of file RelAlgDag.h.

Referenced by getSubqueries(), RelAlgDagModifier::getSubqueries(), registerSubquery(), and RelAlgDagSerializer::serialize().

---

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

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