OmniSciDB  85c2d10cdc
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
Execute.cpp File Reference
#include "Execute.h"
#include "AggregateUtils.h"
#include "CodeGenerator.h"
#include "ColumnFetcher.h"
#include "Descriptors/QueryCompilationDescriptor.h"
#include "Descriptors/QueryFragmentDescriptor.h"
#include "DynamicWatchdog.h"
#include "EquiJoinCondition.h"
#include "ErrorHandling.h"
#include "ExpressionRewrite.h"
#include "ExternalCacheInvalidators.h"
#include "GpuMemUtils.h"
#include "InPlaceSort.h"
#include "JoinHashTable/BaselineJoinHashTable.h"
#include "JoinHashTable/OverlapsJoinHashTable.h"
#include "JsonAccessors.h"
#include "OutputBufferInitialization.h"
#include "QueryEngine/QueryDispatchQueue.h"
#include "QueryRewrite.h"
#include "QueryTemplateGenerator.h"
#include "ResultSetReductionJIT.h"
#include "RuntimeFunctions.h"
#include "SpeculativeTopN.h"
#include "TableFunctions/TableFunctionCompilationContext.h"
#include "TableFunctions/TableFunctionExecutionContext.h"
#include "CudaMgr/CudaMgr.h"
#include "DataMgr/BufferMgr/BufferMgr.h"
#include "Parser/ParserNode.h"
#include "Shared/SystemParameters.h"
#include "Shared/TypedDataAccessors.h"
#include "Shared/checked_alloc.h"
#include "Shared/measure.h"
#include "Shared/misc.h"
#include "Shared/scope.h"
#include "Shared/shard_key.h"
#include "Shared/threadpool.h"
#include "AggregatedColRange.h"
#include "StringDictionaryGenerations.h"
#include <llvm/Transforms/Utils/BasicBlockUtils.h>
#include <boost/filesystem/operations.hpp>
#include <boost/filesystem/path.hpp>
#include <chrono>
#include <ctime>
#include <future>
#include <iostream>
#include <memory>
#include <numeric>
#include <set>
#include <thread>
#include "ArrayOps.cpp"
#include "DateAdd.cpp"
#include "StringFunctions.cpp"

Go to the source code of this file.

Classes

class  anonymous_namespace{Execute.cpp}::OutVecOwner
 

Namespaces

 anonymous_namespace{Execute.cpp}
 

Macros

#define EXECUTE_INCLUDE
 

Functions

 cpu_code_cache_ (code_cache_size)
 
 gpu_code_cache_ (code_cache_size)
 
 block_size_x_ (block_size_x)
 
 grid_size_x_ (grid_size_x)
 
 max_gpu_slab_size_ (max_gpu_slab_size)
 
 debug_dir_ (debug_dir)
 
 debug_file_ (debug_file)
 
 executor_id_ (executor_id)
 
 catalog_ (nullptr)
 
 temporary_tables_ (nullptr)
 
 input_table_info_cache_ (this)
 
ResultSetPtr anonymous_namespace{Execute.cpp}::get_merged_result (std::vector< std::pair< ResultSetPtr, std::vector< size_t >>> &results_per_device)
 
ReductionCode anonymous_namespace{Execute.cpp}::get_reduction_code (std::vector< std::pair< ResultSetPtr, std::vector< size_t >>> &results_per_device, int64_t *compilation_queue_time)
 
std::unordered_set< int > get_available_gpus (const Catalog_Namespace::Catalog &cat)
 
size_t get_context_count (const ExecutorDeviceType device_type, const size_t cpu_count, const size_t gpu_count)
 
size_t anonymous_namespace{Execute.cpp}::compute_buffer_entry_guess (const std::vector< InputTableInfo > &query_infos)
 
std::string anonymous_namespace{Execute.cpp}::get_table_name (const InputDescriptor &input_desc, const Catalog_Namespace::Catalog &cat)
 
size_t anonymous_namespace{Execute.cpp}::getDeviceBasedScanLimit (const ExecutorDeviceType device_type, const int device_count)
 
void anonymous_namespace{Execute.cpp}::checkWorkUnitWatchdog (const RelAlgExecutionUnit &ra_exe_unit, const std::vector< InputTableInfo > &table_infos, const Catalog_Namespace::Catalog &cat, const ExecutorDeviceType device_type, const int device_count)
 
bool is_trivial_loop_join (const std::vector< InputTableInfo > &query_infos, const RelAlgExecutionUnit &ra_exe_unit)
 
template<typename T >
std::vector< std::string > anonymous_namespace{Execute.cpp}::expr_container_to_string (const T &expr_container)
 
template<>
std::vector< std::string > anonymous_namespace{Execute.cpp}::expr_container_to_string (const std::list< Analyzer::OrderEntry > &expr_container)
 
std::string anonymous_namespace{Execute.cpp}::join_type_to_string (const JoinType type)
 
std::string anonymous_namespace{Execute.cpp}::sort_algorithm_to_string (const SortAlgorithm algorithm)
 
std::string ra_exec_unit_desc_for_caching (const RelAlgExecutionUnit &ra_exe_unit)
 
std::ostream & operator<< (std::ostream &os, const RelAlgExecutionUnit &ra_exe_unit)
 
RelAlgExecutionUnit anonymous_namespace{Execute.cpp}::replace_scan_limit (const RelAlgExecutionUnit &ra_exe_unit_in, const size_t new_scan_limit)
 
int64_t anonymous_namespace{Execute.cpp}::inline_null_val (const SQLTypeInfo &ti, const bool float_argument_input)
 
void anonymous_namespace{Execute.cpp}::fill_entries_for_empty_input (std::vector< TargetInfo > &target_infos, std::vector< int64_t > &entry, const std::vector< Analyzer::Expr * > &target_exprs, const QueryMemoryDescriptor &query_mem_desc)
 
ResultSetPtr anonymous_namespace{Execute.cpp}::build_row_for_empty_input (const std::vector< Analyzer::Expr * > &target_exprs_in, const QueryMemoryDescriptor &query_mem_desc, const ExecutorDeviceType device_type)
 
size_t anonymous_namespace{Execute.cpp}::permute_storage_columnar (const ResultSetStorage *input_storage, const QueryMemoryDescriptor &input_query_mem_desc, const ResultSetStorage *output_storage, size_t output_row_index, const QueryMemoryDescriptor &output_query_mem_desc, const std::vector< uint32_t > &top_permutation)
 
size_t anonymous_namespace{Execute.cpp}::permute_storage_row_wise (const ResultSetStorage *input_storage, const ResultSetStorage *output_storage, size_t output_row_index, const QueryMemoryDescriptor &output_query_mem_desc, const std::vector< uint32_t > &top_permutation)
 
bool anonymous_namespace{Execute.cpp}::has_lazy_fetched_columns (const std::vector< ColumnLazyFetchInfo > &fetched_cols)
 
const ColumnDescriptoranonymous_namespace{Execute.cpp}::try_get_column_descriptor (const InputColDescriptor *col_desc, const Catalog_Namespace::Catalog &cat)
 
std::map< size_t, std::vector
< uint64_t > > 
get_table_id_to_frag_offsets (const std::vector< InputDescriptor > &input_descs, const std::map< int, const TableFragments * > &all_tables_fragments)
 
std::ostream & operator<< (std::ostream &os, FetchResult const &fetch_result)
 
bool anonymous_namespace{Execute.cpp}::check_rows_less_than_needed (const ResultSetPtr &results, const size_t scan_limit)
 
void anonymous_namespace{Execute.cpp}::add_deleted_col_to_map (PlanState::DeletedColumnsMap &deleted_cols_map, const ColumnDescriptor *deleted_cd)
 
std::tuple< bool, int64_t,
int64_t > 
anonymous_namespace{Execute.cpp}::get_hpt_overflow_underflow_safe_scaled_values (const int64_t chunk_min, const int64_t chunk_max, const SQLTypeInfo &lhs_type, const SQLTypeInfo &rhs_type)
 

Variables

bool g_enable_watchdog false
 
bool g_enable_dynamic_watchdog {false}
 
bool g_use_tbb_pool {false}
 
bool g_enable_filter_function {true}
 
unsigned g_dynamic_watchdog_time_limit {10000}
 
bool g_allow_cpu_retry {true}
 
bool g_null_div_by_zero {false}
 
unsigned g_trivial_loop_join_threshold {1000}
 
bool g_from_table_reordering {true}
 
bool g_inner_join_fragment_skipping {true}
 
bool g_enable_smem_group_by
 
std::unique_ptr< llvm::Module > udf_gpu_module
 
std::unique_ptr< llvm::Module > udf_cpu_module
 
bool g_enable_filter_push_down {false}
 
float g_filter_push_down_low_frac {-1.0f}
 
float g_filter_push_down_high_frac {-1.0f}
 
size_t g_filter_push_down_passing_row_ubound {0}
 
bool g_enable_columnar_output {false}
 
bool g_enable_left_join_filter_hoisting {true}
 
bool g_optimize_row_initialization {true}
 
bool g_enable_overlaps_hashjoin {true}
 
bool g_enable_hashjoin_many_to_many {false}
 
size_t g_overlaps_max_table_size_bytes {1024 * 1024 * 1024}
 
double g_overlaps_target_entries_per_bin {1.3}
 
bool g_strip_join_covered_quals {false}
 
size_t g_constrained_by_in_threshold {10}
 
size_t g_big_group_threshold {20000}
 
bool g_enable_window_functions {true}
 
bool g_enable_table_functions {false}
 
size_t g_max_memory_allocation_size {2000000000}
 
size_t g_min_memory_allocation_size
 
bool g_enable_bump_allocator {false}
 
double g_bump_allocator_step_reduction {0.75}
 
bool g_enable_direct_columnarization {true}
 
bool g_enable_experimental_string_functions
 
bool g_enable_lazy_fetch {true}
 
bool g_enable_runtime_query_interrupt {false}
 
bool g_enable_non_kernel_time_query_interrupt {true}
 
bool g_use_estimator_result_cache {true}
 
unsigned g_pending_query_interrupt_freq {1000}
 
double g_running_query_interrupt_freq {0.5}
 
size_t g_gpu_smem_threshold
 
bool g_enable_smem_grouped_non_count_agg
 
bool g_enable_smem_non_grouped_agg
 
bool g_is_test_env {false}
 
size_t g_approx_quantile_buffer {1000}
 
size_t g_approx_quantile_centroids {300}
 
bool g_cache_string_hash
 

Macro Definition Documentation

#define EXECUTE_INCLUDE

Definition at line 3413 of file Execute.cpp.

Function Documentation

block_size_x_ ( block_size_x  )

Referenced by Executor::blockSize().

+ Here is the caller graph for this function:

cpu_code_cache_ ( code_cache_size  )

Referenced by Executor::optimizeAndCodegenCPU().

+ Here is the caller graph for this function:

debug_dir_ ( debug_dir  )
debug_file_ ( debug_file  )
executor_id_ ( executor_id  )

Referenced by Executor::attachExecutorToQuerySession(), Executor::clearQuerySessionStatus(), Executor::enrollQuerySession(), Executor::executeUpdate(), Executor::executeWorkUnit(), Executor::removeFromQuerySessionList(), and Executor::updateQuerySessionStatus().

+ Here is the caller graph for this function:

std::unordered_set<int> get_available_gpus ( const Catalog_Namespace::Catalog cat)

Definition at line 1032 of file Execute.cpp.

References CHECK_GT, Data_Namespace::DataMgr::getCudaMgr(), Catalog_Namespace::Catalog::getDataMgr(), CudaMgr_Namespace::CudaMgr::getDeviceCount(), and Data_Namespace::DataMgr::gpusPresent().

Referenced by Executor::executeWorkUnitImpl().

1032  {
1033  std::unordered_set<int> available_gpus;
1034  if (cat.getDataMgr().gpusPresent()) {
1035  int gpu_count = cat.getDataMgr().getCudaMgr()->getDeviceCount();
1036  CHECK_GT(gpu_count, 0);
1037  for (int gpu_id = 0; gpu_id < gpu_count; ++gpu_id) {
1038  available_gpus.insert(gpu_id);
1039  }
1040  }
1041  return available_gpus;
1042 }
CudaMgr_Namespace::CudaMgr * getCudaMgr() const
Definition: DataMgr.h:207
Data_Namespace::DataMgr & getDataMgr() const
Definition: Catalog.h:222
#define CHECK_GT(x, y)
Definition: Logger.h:209
int getDeviceCount() const
Definition: CudaMgr.h:86

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

size_t get_context_count ( const ExecutorDeviceType  device_type,
const size_t  cpu_count,
const size_t  gpu_count 
)

Definition at line 1044 of file Execute.cpp.

References GPU.

Referenced by Executor::executeWorkUnitImpl().

1046  {
1047  return device_type == ExecutorDeviceType::GPU ? gpu_count
1048  : static_cast<size_t>(cpu_count);
1049 }

+ Here is the caller graph for this function:

std::map<size_t, std::vector<uint64_t> > get_table_id_to_frag_offsets ( const std::vector< InputDescriptor > &  input_descs,
const std::map< int, const TableFragments * > &  all_tables_fragments 
)

Definition at line 2316 of file Execute.cpp.

References CHECK, and i.

Referenced by Executor::getRowCountAndOffsetForAllFrags().

2318  {
2319  std::map<size_t, std::vector<uint64_t>> tab_id_to_frag_offsets;
2320  for (auto& desc : input_descs) {
2321  const auto fragments_it = all_tables_fragments.find(desc.getTableId());
2322  CHECK(fragments_it != all_tables_fragments.end());
2323  const auto& fragments = *fragments_it->second;
2324  std::vector<uint64_t> frag_offsets(fragments.size(), 0);
2325  for (size_t i = 0, off = 0; i < fragments.size(); ++i) {
2326  frag_offsets[i] = off;
2327  off += fragments[i].getNumTuples();
2328  }
2329  tab_id_to_frag_offsets.insert(std::make_pair(desc.getTableId(), frag_offsets));
2330  }
2331  return tab_id_to_frag_offsets;
2332 }
#define CHECK(condition)
Definition: Logger.h:197

+ Here is the caller graph for this function:

gpu_code_cache_ ( code_cache_size  )
grid_size_x_ ( grid_size_x  )

Referenced by Executor::gridSize(), and Executor::numBlocksPerMP().

+ Here is the caller graph for this function:

input_table_info_cache_ ( this  )

Definition at line 159 of file Execute.cpp.

Referenced by Executor::clearMetaInfoCache(), and Executor::getTableInfo().

159 {}

+ Here is the caller graph for this function:

bool is_trivial_loop_join ( const std::vector< InputTableInfo > &  query_infos,
const RelAlgExecutionUnit ra_exe_unit 
)

Definition at line 1152 of file Execute.cpp.

References CHECK, g_trivial_loop_join_threshold, i, and RelAlgExecutionUnit::input_descs.

Referenced by anonymous_namespace{IRCodegen.cpp}::check_if_loop_join_is_allowed().

1153  {
1154  if (ra_exe_unit.input_descs.size() < 2) {
1155  return false;
1156  }
1157 
1158  // We only support loop join at the end of folded joins
1159  // where ra_exe_unit.input_descs.size() > 2 for now.
1160  const auto inner_table_id = ra_exe_unit.input_descs.back().getTableId();
1161 
1162  std::optional<size_t> inner_table_idx;
1163  for (size_t i = 0; i < query_infos.size(); ++i) {
1164  if (query_infos[i].table_id == inner_table_id) {
1165  inner_table_idx = i;
1166  break;
1167  }
1168  }
1169  CHECK(inner_table_idx);
1170  return query_infos[*inner_table_idx].info.getNumTuples() <=
1172 }
std::vector< InputDescriptor > input_descs
unsigned g_trivial_loop_join_threshold
Definition: Execute.cpp:83
#define CHECK(condition)
Definition: Logger.h:197

+ Here is the caller graph for this function:

max_gpu_slab_size_ ( max_gpu_slab_size  )

Referenced by Executor::maxGpuSlabSize().

+ Here is the caller graph for this function:

std::ostream& operator<< ( std::ostream &  os,
const RelAlgExecutionUnit ra_exe_unit 
)

Definition at line 1278 of file Execute.cpp.

References RelAlgExecutionUnit::estimator, anonymous_namespace{Execute.cpp}::expr_container_to_string(), RelAlgExecutionUnit::groupby_exprs, i, RelAlgExecutionUnit::input_col_descs, join(), RelAlgExecutionUnit::join_quals, anonymous_namespace{Execute.cpp}::join_type_to_string(), RelAlgExecutionUnit::quals, RelAlgExecutionUnit::scan_limit, RelAlgExecutionUnit::simple_quals, anonymous_namespace{Execute.cpp}::sort_algorithm_to_string(), RelAlgExecutionUnit::sort_info, RelAlgExecutionUnit::target_exprs, to_string(), toString(), RelAlgExecutionUnit::union_all, and RelAlgExecutionUnit::use_bump_allocator.

1278  {
1279  os << "\n\tTable/Col/Levels: ";
1280  for (const auto& input_col_desc : ra_exe_unit.input_col_descs) {
1281  const auto& scan_desc = input_col_desc->getScanDesc();
1282  os << "(" << scan_desc.getTableId() << ", " << input_col_desc->getColId() << ", "
1283  << scan_desc.getNestLevel() << ") ";
1284  }
1285  if (!ra_exe_unit.simple_quals.empty()) {
1286  os << "\n\tSimple Quals: "
1288  ", ");
1289  }
1290  if (!ra_exe_unit.quals.empty()) {
1291  os << "\n\tQuals: "
1292  << boost::algorithm::join(expr_container_to_string(ra_exe_unit.quals), ", ");
1293  }
1294  if (!ra_exe_unit.join_quals.empty()) {
1295  os << "\n\tJoin Quals: ";
1296  for (size_t i = 0; i < ra_exe_unit.join_quals.size(); i++) {
1297  const auto& join_condition = ra_exe_unit.join_quals[i];
1298  os << "\t\t" << std::to_string(i) << " "
1299  << join_type_to_string(join_condition.type);
1300  os << boost::algorithm::join(expr_container_to_string(join_condition.quals), ", ");
1301  }
1302  }
1303  if (!ra_exe_unit.groupby_exprs.empty()) {
1304  os << "\n\tGroup By: "
1306  ", ");
1307  }
1308  os << "\n\tProjected targets: "
1310  os << "\n\tHas Estimator: " << ::toString(ra_exe_unit.estimator == nullptr);
1311  os << "\n\tSort Info: ";
1312  const auto& sort_info = ra_exe_unit.sort_info;
1313  os << "\n\t Order Entries: "
1314  << boost::algorithm::join(expr_container_to_string(sort_info.order_entries), ", ");
1315  os << "\n\t Algorithm: " << sort_algorithm_to_string(sort_info.algorithm);
1316  os << "\n\t Limit: " << std::to_string(sort_info.limit);
1317  os << "\n\t Offset: " << std::to_string(sort_info.offset);
1318  os << "\n\tScan Limit: " << std::to_string(ra_exe_unit.scan_limit);
1319  os << "\n\tBump Allocator: " << ::toString(ra_exe_unit.use_bump_allocator);
1320  if (ra_exe_unit.union_all) {
1321  os << "\n\tUnion: " << std::string(*ra_exe_unit.union_all ? "UNION ALL" : "UNION");
1322  }
1323  return os;
1324 }
std::vector< Analyzer::Expr * > target_exprs
std::string toString(const ExtArgumentType &sig_type)
const std::optional< bool > union_all
std::string join(T const &container, std::string const &delim)
std::string join_type_to_string(const JoinType type)
Definition: Execute.cpp:1199
const std::list< std::shared_ptr< Analyzer::Expr > > groupby_exprs
std::string to_string(char const *&&v)
const SortInfo sort_info
const JoinQualsPerNestingLevel join_quals
std::vector< std::string > expr_container_to_string(const T &expr_container)
Definition: Execute.cpp:1177
const std::shared_ptr< Analyzer::Estimator > estimator
std::string sort_algorithm_to_string(const SortAlgorithm algorithm)
Definition: Execute.cpp:1212
std::list< std::shared_ptr< Analyzer::Expr > > quals
std::list< std::shared_ptr< const InputColDescriptor > > input_col_descs
std::list< std::shared_ptr< Analyzer::Expr > > simple_quals

+ Here is the call graph for this function:

std::ostream& operator<< ( std::ostream &  os,
FetchResult const fetch_result 
)

Definition at line 2423 of file Execute.cpp.

References FetchResult::col_buffers, FetchResult::frag_offsets, FetchResult::num_rows, and shared::printContainer().

2423  {
2424  return os << "col_buffers" << shared::printContainer(fetch_result.col_buffers)
2425  << " num_rows" << shared::printContainer(fetch_result.num_rows)
2426  << " frag_offsets" << shared::printContainer(fetch_result.frag_offsets);
2427 }
PrintContainer< CONTAINER > printContainer(CONTAINER &container)
Definition: misc.h:64

+ Here is the call graph for this function:

std::string ra_exec_unit_desc_for_caching ( const RelAlgExecutionUnit ra_exe_unit)

Definition at line 1227 of file Execute.cpp.

References RelAlgExecutionUnit::estimator, RelAlgExecutionUnit::groupby_exprs, i, RelAlgExecutionUnit::input_col_descs, RelAlgExecutionUnit::join_quals, anonymous_namespace{Execute.cpp}::join_type_to_string(), RelAlgExecutionUnit::quals, RelAlgExecutionUnit::scan_limit, RelAlgExecutionUnit::simple_quals, RelAlgExecutionUnit::target_exprs, to_string(), and toString().

Referenced by RelAlgExecutor::executeWorkUnit().

1227  {
1228  // todo(yoonmin): replace a cache key as a DAG representation of a query plan
1229  // instead of ra_exec_unit description if possible
1230  std::ostringstream os;
1231  for (const auto& input_col_desc : ra_exe_unit.input_col_descs) {
1232  const auto& scan_desc = input_col_desc->getScanDesc();
1233  os << scan_desc.getTableId() << "," << input_col_desc->getColId() << ","
1234  << scan_desc.getNestLevel();
1235  }
1236  if (!ra_exe_unit.simple_quals.empty()) {
1237  for (const auto& qual : ra_exe_unit.simple_quals) {
1238  if (qual) {
1239  os << qual->toString() << ",";
1240  }
1241  }
1242  }
1243  if (!ra_exe_unit.quals.empty()) {
1244  for (const auto& qual : ra_exe_unit.quals) {
1245  if (qual) {
1246  os << qual->toString() << ",";
1247  }
1248  }
1249  }
1250  if (!ra_exe_unit.join_quals.empty()) {
1251  for (size_t i = 0; i < ra_exe_unit.join_quals.size(); i++) {
1252  const auto& join_condition = ra_exe_unit.join_quals[i];
1253  os << std::to_string(i) << join_type_to_string(join_condition.type);
1254  for (const auto& qual : join_condition.quals) {
1255  if (qual) {
1256  os << qual->toString() << ",";
1257  }
1258  }
1259  }
1260  }
1261  if (!ra_exe_unit.groupby_exprs.empty()) {
1262  for (const auto& qual : ra_exe_unit.groupby_exprs) {
1263  if (qual) {
1264  os << qual->toString() << ",";
1265  }
1266  }
1267  }
1268  for (const auto& expr : ra_exe_unit.target_exprs) {
1269  if (expr) {
1270  os << expr->toString() << ",";
1271  }
1272  }
1273  os << ::toString(ra_exe_unit.estimator == nullptr);
1274  os << std::to_string(ra_exe_unit.scan_limit);
1275  return os.str();
1276 }
std::vector< Analyzer::Expr * > target_exprs
std::string toString(const ExtArgumentType &sig_type)
std::string join_type_to_string(const JoinType type)
Definition: Execute.cpp:1199
const std::list< std::shared_ptr< Analyzer::Expr > > groupby_exprs
std::string to_string(char const *&&v)
const JoinQualsPerNestingLevel join_quals
const std::shared_ptr< Analyzer::Estimator > estimator
std::list< std::shared_ptr< Analyzer::Expr > > quals
std::list< std::shared_ptr< const InputColDescriptor > > input_col_descs
std::list< std::shared_ptr< Analyzer::Expr > > simple_quals

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

temporary_tables_ ( nullptr  )

Variable Documentation

false

Definition at line 76 of file Execute.cpp.

size_t g_approx_quantile_buffer {1000}
size_t g_approx_quantile_centroids {300}
size_t g_big_group_threshold {20000}

Definition at line 102 of file Execute.cpp.

Referenced by RelAlgExecutor::executeWorkUnit().

double g_bump_allocator_step_reduction {0.75}

Definition at line 110 of file Execute.cpp.

Referenced by create_dev_group_by_buffers().

bool g_cache_string_hash

Definition at line 45 of file StringDictionary.cpp.

size_t g_constrained_by_in_threshold {10}

Definition at line 101 of file Execute.cpp.

Referenced by QueryRewriter::rewriteConstrainedByInImpl().

unsigned g_dynamic_watchdog_time_limit {10000}
bool g_enable_bump_allocator {false}
bool g_enable_direct_columnarization {true}
bool g_enable_experimental_string_functions

Definition at line 39 of file RelAlgTranslator.cpp.

bool g_enable_filter_function {true}

Definition at line 79 of file Execute.cpp.

Referenced by CommandLineOptions::fillAdvancedOptions().

bool g_enable_hashjoin_many_to_many {false}

Definition at line 97 of file Execute.cpp.

Referenced by CommandLineOptions::fillOptions(), and rewrite_overlaps_conjunction().

bool g_enable_lazy_fetch {true}
bool g_enable_left_join_filter_hoisting {true}
bool g_enable_smem_group_by
bool g_enable_smem_grouped_non_count_agg
Initial value:
{
true}

Definition at line 124 of file Execute.cpp.

Referenced by CommandLineOptions::fillAdvancedOptions().

bool g_enable_smem_non_grouped_agg
Initial value:
{
true}

Definition at line 127 of file Execute.cpp.

Referenced by CommandLineOptions::fillAdvancedOptions().

bool g_enable_window_functions {true}
float g_filter_push_down_high_frac {-1.0f}
float g_filter_push_down_low_frac {-1.0f}
size_t g_filter_push_down_passing_row_ubound {0}
size_t g_gpu_smem_threshold
Initial value:
{
4096}

Definition at line 119 of file Execute.cpp.

Referenced by CommandLineOptions::fillAdvancedOptions().

bool g_inner_join_fragment_skipping {true}

Definition at line 85 of file Execute.cpp.

Referenced by Executor::createKernels(), and CommandLineOptions::fillOptions().

bool g_is_test_env {false}

Definition at line 130 of file Execute.cpp.

Referenced by Executor::getArenaBlockSize().

size_t g_max_memory_allocation_size {2000000000}
size_t g_min_memory_allocation_size
Initial value:
{
256}

Definition at line 106 of file Execute.cpp.

Referenced by create_dev_group_by_buffers(), and CommandLineOptions::fillAdvancedOptions().

bool g_null_div_by_zero {false}
bool g_optimize_row_initialization {true}
size_t g_overlaps_max_table_size_bytes {1024 * 1024 * 1024}
double g_overlaps_target_entries_per_bin {1.3}
bool g_strip_join_covered_quals {false}
unsigned g_trivial_loop_join_threshold {1000}

Definition at line 83 of file Execute.cpp.

Referenced by CommandLineOptions::fillOptions(), and is_trivial_loop_join().

bool g_use_estimator_result_cache {true}
std::unique_ptr<llvm::Module> udf_cpu_module

Definition at line 74 of file NativeCodegen.cpp.

std::unique_ptr<llvm::Module> udf_gpu_module

Definition at line 73 of file NativeCodegen.cpp.

Referenced by get_gpu_data_layout().