#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	cuda_block_size

double	cuda_grid_size_multiplier

bool	opt_cuda_grid_and_block_size

size_t	aggregate_tree_fanout

double	overlaps_bucket_threshold

size_t	overlaps_max_size

bool	overlaps_allow_gpu_build

bool	overlaps_no_cache

double	overlaps_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

std::vector< bool >	registered_hint

Detailed Description

Definition at line 177 of file QueryHint.h.

Constructor & Destructor Documentation

RegisteredQueryHint::RegisteredQueryHint ( )

inline

Definition at line 185 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)
       , cuda_block_size(0)
       , cuda_grid_size_multiplier(0.0)
       , opt_cuda_grid_and_block_size(false)
       , aggregate_tree_fanout(8)
       , overlaps_bucket_threshold(std::numeric_limits<double>::max())
       , overlaps_max_size(g_overlaps_max_table_size_bytes)
       , overlaps_allow_gpu_build(false)
       , overlaps_no_cache(false)
       , overlaps_keys_per_bin(g_overlaps_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())
       , registered_hint(QueryHint::kHintCount, false) {}

Here is the caller graph for this function:

Member Function Documentation

static RegisteredQueryHint RegisteredQueryHint::defaults ( )

inlinestatic

Definition at line 329 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().

329 { return RegisteredQueryHint(); }

RegisteredQueryHint::RegisteredQueryHint

RegisteredQueryHint()

Definition: QueryHint.h:185

Here is the call graph for this function:

Here is the caller graph for this function:

bool RegisteredQueryHint::isAnyQueryHintDelivered ( ) const

inline

Definition at line 338 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 348 of file QueryHint.h.

References registered_hint.

Referenced by BaselineJoinHashTableBuilder::allocateDeviceMemory(), anonymous_namespace{IRCodegen.cpp}::check_if_loop_join_is_allowed(), OverlapsJoinHashTable::getEffectiveMemoryLevel(), PerfectJoinHashTable::initHashTableForDevice(), BaselineJoinHashTableBuilder::initHashTableOnCpu(), and OverlapsJoinHashTable::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 208 of file QueryHint.h.

References aggregate_tree_fanout, CHECK_EQ, cuda_block_size, cuda_grid_size_multiplier, dynamic_watchdog, kAggregateTreeFanout, kAllowLoopJoin, kColumnarOutput, kCpuMode, kCudaBlockSize, kCudaGridSize, kDisableLoopJoin, kDynamicWatchdog, kDynamicWatchdogOff, keep_result, keep_table_function_result, kHintCount, kKeepResult, kKeepTableFuncResult, kLoopJoinInnerTableMaxNumRows, kMaxJoinHashTableSize, kOptCudaBlockAndGridSizes, kOverlapsAllowGpuBuild, kOverlapsBucketThreshold, kOverlapsKeysPerBin, kOverlapsMaxSize, kOverlapsNoCache, kQueryTimeLimit, kRowwiseOutput, kWatchdog, kWatchdogOff, loop_join_inner_table_max_num_rows, max_join_hash_table_size, overlaps_bucket_threshold, overlaps_keys_per_bin, overlaps_max_size, query_time_limit, registered_hint, UNREACHABLE, use_loop_join, and watchdog.

                                                                                 {
     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::kOverlapsBucketThreshold:
             updated_query_hints.overlaps_bucket_threshold =
                 global_hints.overlaps_bucket_threshold;
             break;
           case QueryHint::kOverlapsMaxSize:
             updated_query_hints.overlaps_max_size = global_hints.overlaps_max_size;
             break;
           case QueryHint::kOverlapsAllowGpuBuild:
             updated_query_hints.overlaps_allow_gpu_build = true;
             break;
           case QueryHint::kOverlapsNoCache:
             updated_query_hints.overlaps_no_cache = true;
             break;
           case QueryHint::kOverlapsKeysPerBin:
             updated_query_hints.overlaps_keys_per_bin =
                 global_hints.overlaps_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;
           default:
             UNREACHABLE();
         }
       }
     }
     return updated_query_hints;
   }

void RegisteredQueryHint::registerHint ( const QueryHint hint )

inline

Definition at line 343 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 332 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;
   }