#include <QueryHint.h>

Public Member Functions
	RegisteredQueryHint ()

RegisteredQueryHint	operator\|\| (const RegisteredQueryHint &global_hints) const

bool	isAnyQueryHintDelivered () const

void	registerHint (const QueryHint hint)

bool	isHintRegistered (const QueryHint hint) const

Static Public Member Functions
static RegisteredQueryHint	defaults ()

static QueryHint	translateQueryHint (const std::string &hint_name)

Public Attributes
bool	cpu_mode

bool	columnar_output

bool	rowwise_output

bool	keep_result

bool	keep_table_function_result

std::optional< bool >	watchdog

std::optional< bool >	dynamic_watchdog

size_t	query_time_limit

size_t	watchdog_max_projected_rows_per_device

size_t	preflight_count_query_threshold

bool	table_reordering_off

double	ndv_groups_estimator_multiplier

size_t	cuda_block_size

double	cuda_grid_size_multiplier

bool	opt_cuda_grid_and_block_size

size_t	aggregate_tree_fanout

double	bbox_intersect_bucket_threshold

size_t	bbox_intersect_max_size

bool	bbox_intersect_allow_gpu_build

bool	bbox_intersect_no_cache

double	bbox_intersect_keys_per_bin

std::optional< bool >	use_loop_join

size_t	loop_join_inner_table_max_num_rows

size_t	max_join_hash_table_size

bool	force_baseline_hash_join

bool	force_one_to_many_hash_join

std::vector< bool >	registered_hint

Detailed Description

Definition at line 190 of file QueryHint.h.

Constructor & Destructor Documentation

RegisteredQueryHint::RegisteredQueryHint ( )

inline

Definition at line 198 of file QueryHint.h.

Referenced by defaults().

       : cpu_mode(false)
       , columnar_output(false)
       , rowwise_output(false)
       , keep_result(false)
       , keep_table_function_result(false)
       , watchdog(std::nullopt)
       , dynamic_watchdog(std::nullopt)
       , query_time_limit(0)
       , watchdog_max_projected_rows_per_device(g_watchdog_max_projected_rows_per_device)
       , preflight_count_query_threshold(g_preflight_count_query_threshold)
       , table_reordering_off(false)
       , ndv_groups_estimator_multiplier(2.0)
       , cuda_block_size(0)
       , cuda_grid_size_multiplier(0.0)
       , opt_cuda_grid_and_block_size(false)
       , aggregate_tree_fanout(8)
       , bbox_intersect_bucket_threshold(std::numeric_limits<double>::max())
       , bbox_intersect_max_size(g_bbox_intersect_max_table_size_bytes)
       , bbox_intersect_allow_gpu_build(false)
       , bbox_intersect_no_cache(false)
       , bbox_intersect_keys_per_bin(g_bbox_intersect_target_entries_per_bin)
       , use_loop_join(std::nullopt)
       , loop_join_inner_table_max_num_rows(g_trivial_loop_join_threshold)
       , max_join_hash_table_size(std::numeric_limits<size_t>::max())
       , force_baseline_hash_join(false)
       , force_one_to_many_hash_join(false)
       , registered_hint(QueryHint::kHintCount, false) {}

Here is the caller graph for this function:

Member Function Documentation

static RegisteredQueryHint RegisteredQueryHint::defaults ( )

inlinestatic

Definition at line 379 of file QueryHint.h.

References RegisteredQueryHint().

Referenced by anonymous_namespace{RelAlgDag.cpp}::create_compound(), RelAlgExecutor::createAggregateWorkUnit(), RelAlgExecutor::createCompoundWorkUnit(), RelAlgExecutor::createFilterWorkUnit(), RelAlgExecutor::createProjectWorkUnit(), RelAlgExecutor::createUnionWorkUnit(), RelAlgExecutor::executeWorkUnit(), QueryRunner::QueryRunner::getParsedQueryHint(), and HashJoin::getSyntheticInstance().

379 { return RegisteredQueryHint(); }

RegisteredQueryHint::RegisteredQueryHint

RegisteredQueryHint()

Definition: QueryHint.h:198

Here is the call graph for this function:

Here is the caller graph for this function:

bool RegisteredQueryHint::isAnyQueryHintDelivered ( ) const

inline

Definition at line 388 of file QueryHint.h.

References anonymous_namespace{QueryMemoryDescriptor.cpp}::any_of(), and registered_hint.

Referenced by RelAlgDag::getQueryHint().

                                        {
     const auto identity = [](const bool b) { return b; };
     return std::any_of(registered_hint.begin(), registered_hint.end(), identity);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

bool RegisteredQueryHint::isHintRegistered ( const QueryHint hint ) const

inline

Definition at line 398 of file QueryHint.h.

References registered_hint.

Referenced by BaselineJoinHashTableBuilder::allocateDeviceMemory(), anonymous_namespace{IRCodegen.cpp}::check_if_loop_join_is_allowed(), anonymous_namespace{Execute.cpp}::checkWorkUnitWatchdog(), anonymous_namespace{RelAlgExecutor.cpp}::compute_output_buffer_size(), BoundingBoxIntersectJoinHashTable::getEffectiveMemoryLevel(), anonymous_namespace{RelAlgExecutor.cpp}::handle_query_hint(), PerfectJoinHashTable::initHashTableForDevice(), BaselineJoinHashTableBuilder::initHashTableOnCpu(), and BoundingBoxIntersectJoinHashTable::reifyWithLayout().

                                                     {
     const auto hint_class = static_cast<int>(hint);
     return registered_hint.at(hint_class);
   }

Here is the caller graph for this function:

RegisteredQueryHint RegisteredQueryHint::operator|| ( const RegisteredQueryHint & global_hints ) const

inline

Definition at line 227 of file QueryHint.h.

References aggregate_tree_fanout, bbox_intersect_bucket_threshold, bbox_intersect_keys_per_bin, bbox_intersect_max_size, CHECK_EQ, cuda_block_size, cuda_grid_size_multiplier, dynamic_watchdog, force_baseline_hash_join, force_one_to_many_hash_join, kAggregateTreeFanout, kAllowLoopJoin, kBBoxIntersectAllowGpuBuild, kBBoxIntersectBucketThreshold, kBBoxIntersectKeysPerBin, kBBoxIntersectMaxSize, kBBoxIntersectNoCache, kColumnarOutput, kCpuMode, kCudaBlockSize, kCudaGridSize, kDisableLoopJoin, kDynamicWatchdog, kDynamicWatchdogOff, keep_result, keep_table_function_result, kforceBaselineHashJoin, kforceOneToManyHashJoin, kHintCount, kKeepResult, kKeepTableFuncResult, kLoopJoinInnerTableMaxNumRows, kMaxJoinHashTableSize, kNDVGroupsEstimatorMultiplier, kOptCudaBlockAndGridSizes, kPreflightCountQueryThreshold, kQueryTimeLimit, kRowwiseOutput, kTableReorderingOff, kWatchdog, kWatchdogMaxProjectedRowsPerDevice, kWatchdogOff, loop_join_inner_table_max_num_rows, max_join_hash_table_size, ndv_groups_estimator_multiplier, preflight_count_query_threshold, query_time_limit, registered_hint, table_reordering_off, UNREACHABLE, use_loop_join, watchdog, and watchdog_max_projected_rows_per_device.

                                                                                 {
     CHECK_EQ(registered_hint.size(), global_hints.registered_hint.size());
     // apply registered global hint to the local hint if necessary
     // we prioritize global hint when both side of hints are enabled simultaneously
     RegisteredQueryHint updated_query_hints(*this);
 
     constexpr int num_hints = static_cast<int>(QueryHint::kHintCount);
     for (int i = 0; i < num_hints; ++i) {
       if (global_hints.registered_hint.at(i)) {
         updated_query_hints.registered_hint.at(i) = true;
         switch (static_cast<QueryHint>(i)) {
           case QueryHint::kCpuMode:
             updated_query_hints.cpu_mode = true;
             break;
           case QueryHint::kColumnarOutput:
             updated_query_hints.columnar_output = true;
             break;
           case QueryHint::kRowwiseOutput:
             updated_query_hints.rowwise_output = true;
             break;
           case QueryHint::kCudaBlockSize:
             updated_query_hints.cuda_block_size = global_hints.cuda_block_size;
             break;
           case QueryHint::kCudaGridSize:
             updated_query_hints.cuda_grid_size_multiplier =
                 global_hints.cuda_grid_size_multiplier;
             break;
           case QueryHint::kOptCudaBlockAndGridSizes:
             updated_query_hints.opt_cuda_grid_and_block_size = true;
             break;
           case QueryHint::kBBoxIntersectBucketThreshold:
             updated_query_hints.bbox_intersect_bucket_threshold =
                 global_hints.bbox_intersect_bucket_threshold;
             break;
           case QueryHint::kBBoxIntersectMaxSize:
             updated_query_hints.bbox_intersect_max_size =
                 global_hints.bbox_intersect_max_size;
             break;
           case QueryHint::kBBoxIntersectAllowGpuBuild:
             updated_query_hints.bbox_intersect_allow_gpu_build = true;
             break;
           case QueryHint::kBBoxIntersectNoCache:
             updated_query_hints.bbox_intersect_no_cache = true;
             break;
           case QueryHint::kBBoxIntersectKeysPerBin:
             updated_query_hints.bbox_intersect_keys_per_bin =
                 global_hints.bbox_intersect_keys_per_bin;
             break;
           case QueryHint::kKeepResult:
             updated_query_hints.keep_result = global_hints.keep_result;
             break;
           case QueryHint::kKeepTableFuncResult:
             updated_query_hints.keep_table_function_result =
                 global_hints.keep_table_function_result;
             break;
           case QueryHint::kAggregateTreeFanout:
             updated_query_hints.aggregate_tree_fanout =
                 global_hints.aggregate_tree_fanout;
             break;
           case QueryHint::kWatchdog:
           case QueryHint::kWatchdogOff:
             updated_query_hints.watchdog = global_hints.watchdog;
             break;
           case QueryHint::kDynamicWatchdog:
           case QueryHint::kDynamicWatchdogOff:
             updated_query_hints.dynamic_watchdog = global_hints.dynamic_watchdog;
             break;
           case QueryHint::kQueryTimeLimit:
             updated_query_hints.query_time_limit = global_hints.query_time_limit;
             break;
           case QueryHint::kAllowLoopJoin:
           case QueryHint::kDisableLoopJoin:
             updated_query_hints.use_loop_join = global_hints.use_loop_join;
             break;
           case QueryHint::kLoopJoinInnerTableMaxNumRows:
             updated_query_hints.loop_join_inner_table_max_num_rows =
                 global_hints.loop_join_inner_table_max_num_rows;
             break;
           case QueryHint::kMaxJoinHashTableSize:
             updated_query_hints.max_join_hash_table_size =
                 global_hints.max_join_hash_table_size;
             break;
           case QueryHint::kforceBaselineHashJoin:
             updated_query_hints.force_baseline_hash_join =
                 global_hints.force_baseline_hash_join;
             break;
           case QueryHint::kforceOneToManyHashJoin:
             updated_query_hints.force_one_to_many_hash_join =
                 global_hints.force_one_to_many_hash_join;
             break;
           case QueryHint::kWatchdogMaxProjectedRowsPerDevice:
             updated_query_hints.watchdog_max_projected_rows_per_device =
                 global_hints.watchdog_max_projected_rows_per_device;
             break;
           case QueryHint::kPreflightCountQueryThreshold:
             updated_query_hints.preflight_count_query_threshold =
                 global_hints.preflight_count_query_threshold;
             break;
           case QueryHint::kTableReorderingOff:
             updated_query_hints.table_reordering_off = global_hints.table_reordering_off;
             break;
           case QueryHint::kNDVGroupsEstimatorMultiplier:
             updated_query_hints.ndv_groups_estimator_multiplier =
                 global_hints.ndv_groups_estimator_multiplier;
             break;
           default:
             UNREACHABLE();
         }
       }
     }
     return updated_query_hints;
   }

void RegisteredQueryHint::registerHint ( const QueryHint hint )

inline

Definition at line 393 of file QueryHint.h.

References registered_hint.

Referenced by RelAlgDag::registerQueryHints().

                                           {
     const auto hint_class = static_cast<int>(hint);
     registered_hint.at(hint_class) = true;
   }

Here is the caller graph for this function:

static QueryHint RegisteredQueryHint::translateQueryHint ( const std::string & hint_name )

inlinestatic

Definition at line 382 of file QueryHint.h.

References kInvalidHint, and SupportedQueryHints.

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

                                                                   {
     const auto lowered_hint_name = boost::algorithm::to_lower_copy(hint_name);
     auto it = SupportedQueryHints.find(lowered_hint_name);
     return it == SupportedQueryHints.end() ? QueryHint::kInvalidHint : it->second;
   }