17 #ifndef QUERYENGINE_EXECUTE_H
18 #define QUERYENGINE_EXECUTE_H
22 #include <condition_variable>
32 #include <unordered_map>
33 #include <unordered_set>
35 #include <llvm/IR/Function.h>
36 #include <llvm/IR/Value.h>
37 #include <llvm/Linker/Linker.h>
38 #include <llvm/Transforms/Utils/ValueMapper.h>
39 #include <rapidjson/document.h>
102 const std::string& query_str,
103 const std::string& submitted_time)
110 const size_t executor_id,
111 const std::string& query_str,
112 const std::string& submitted_time)
119 const size_t executor_id,
120 const std::string& query_str,
121 const std::string& submitted_time,
153 std::map<const QuerySessionId, std::map<std::string, QuerySessionStatus>>;
167 for (
auto& arg : func->args()) {
168 if (arg.getName() ==
name) {
203 if (!cast_expr || cast_expr->get_optype() !=
kCAST) {
206 return cast_expr->get_operand();
229 const int table_id) {
231 const auto it = temporary_tables->find(table_id);
232 CHECK(it != temporary_tables->end());
240 CHECK(cd || temporary_tables);
247 return temp->getColType(col_id);
253 : std::runtime_error(
"Retry query compilation with no GPU lazy fetch.") {}
259 : std::runtime_error(
"Retry query compilation with new scan limit.")
273 : std::runtime_error(
"Retry query compilation with no compaction.") {}
304 ParseIRError(
const std::string message) : std::runtime_error(message) {}
310 : std::runtime_error(
311 "NONE ENCODED String types are not supported as input result set.") {}
331 const std::shared_ptr<ResultSet>& rs);
333 std::vector<TargetValue>
getEntryAt(
const size_t index)
const override;
338 return rs_->getRowSetMemOwner()->getLiteralStringDictProxy();
352 using Callback = std::function<void(const UpdateLogForFragment&, TableUpdateMetadata&)>;
359 std::shared_ptr<ResultSet>
rs_;
369 static_assert(
sizeof(
float) == 4 &&
sizeof(
double) == 8,
370 "Host hardware not supported, unexpected size of float / double.");
371 static_assert(
sizeof(time_t) == 8,
372 "Host hardware not supported, 64-bit time support is required.");
381 const size_t block_size_x,
382 const size_t grid_size_x,
383 const size_t max_gpu_slab_size,
384 const std::string& debug_dir,
385 const std::string& debug_file);
393 const int current_db_id) {
394 bool clearEntireCache =
true;
397 if (!table_chunk_key_prefix.empty()) {
398 auto table_key = boost::hash_value(table_chunk_key_prefix);
405 clearEntireCache =
false;
408 if (clearEntireCache) {
418 void reset(
bool discard_runtime_modules_only =
false);
420 template <
typename F>
432 std::lock_guard<std::mutex> register_lock(
437 executor_item.second->reset(
true);
444 register_extension_functions();
452 const std::string& debug_dir =
"",
453 const std::string& debug_file =
"",
457 mapd_unique_lock<mapd_shared_mutex> flush_lock(
467 static void addUdfIrToModule(
const std::string& udf_ir_filename,
const bool is_cuda_ir);
491 std::lock_guard<std::mutex> lock(
530 const bool with_generation)
const {
537 const std::shared_ptr<RowSetMemoryOwner> row_set_mem_owner,
538 const bool with_generation)
const;
541 const int source_dict_id,
542 const int dest_dict_id,
544 const std::vector<StringOps_Namespace::StringOpInfo>& string_op_infos,
545 std::shared_ptr<RowSetMemoryOwner> row_set_mem_owner,
546 const bool with_generation)
const;
551 const std::vector<StringOps_Namespace::StringOpInfo>& source_string_op_infos,
552 const std::vector<StringOps_Namespace::StringOpInfo>& dest_source_string_op_infos,
553 std::shared_ptr<RowSetMemoryOwner> row_set_mem_owner)
const;
560 return cgen_state_->contains_left_deep_outer_join_;
590 const std::vector<Analyzer::Expr*>& target_exprs)
const;
600 const unsigned pending_query_check_freq)
const;
612 const std::vector<InputTableInfo>&,
618 const bool has_cardinality_estimation,
622 const std::vector<InputTableInfo>& table_infos,
627 std::shared_ptr<RowSetMemoryOwner> row_set_mem_owner,
633 const std::shared_ptr<RowSetMemoryOwner>& row_set_mem_owner);
664 llvm::Value* window_func_null_val,
665 llvm::Value* multiplicity_lv);
697 std::function<void(ResultSetPtr, const Fragmenter_Namespace::FragmentInfo&)>;
710 const std::set<size_t>& fragment_indexes_param);
720 const std::vector<InputTableInfo>& table_infos,
734 std::shared_ptr<RowSetMemoryOwner> row_set_mem_owner);
750 const std::vector<InputTableInfo>& table_infos,
753 const bool allow_single_frag_table_opt,
754 const size_t context_count,
758 std::unordered_set<int>& available_gpus,
759 int& available_cpus);
766 std::vector<std::unique_ptr<ExecutionKernel>>&& kernels,
772 const size_t table_idx,
773 const size_t outer_frag_idx,
774 std::map<int, const TableFragments*>& selected_tables_fragments,
775 const std::unordered_map<int, const Analyzer::BinOper*>&
776 inner_table_id_to_join_condition);
780 const int inner_table_id,
781 const std::unordered_map<int, const Analyzer::BinOper*>&
782 inner_table_id_to_join_condition,
790 const std::map<int, const TableFragments*>&,
793 std::list<ChunkIter>&,
794 std::list<std::shared_ptr<Chunk_NS::Chunk>>&,
796 const size_t thread_idx,
797 const bool allow_runtime_interrupt);
803 const std::map<int, const TableFragments*>&,
806 std::list<ChunkIter>&,
807 std::list<std::shared_ptr<Chunk_NS::Chunk>>&,
809 const size_t thread_idx,
810 const bool allow_runtime_interrupt);
812 std::pair<std::vector<std::vector<int64_t>>, std::vector<std::vector<uint64_t>>>
815 const CartesianProduct<std::vector<std::vector<size_t>>>& frag_ids_crossjoin,
816 const std::vector<InputDescriptor>& input_descs,
817 const std::map<int, const TableFragments*>& all_tables_fragments);
820 std::vector<std::vector<size_t>>& selected_fragments_crossjoin,
821 std::vector<size_t>& local_col_to_frag_pos,
822 const std::list<std::shared_ptr<const InputColDescriptor>>& col_global_ids,
827 std::vector<std::vector<size_t>>& selected_fragments_crossjoin,
828 std::vector<size_t>& local_col_to_frag_pos,
829 const std::list<std::shared_ptr<const InputColDescriptor>>& col_global_ids,
834 const size_t scan_idx,
840 const bool hoist_literals,
843 std::vector<std::vector<const int8_t*>>& col_buffers,
844 const std::vector<size_t> outer_tab_frag_ids,
846 const std::vector<std::vector<int64_t>>& num_rows,
847 const std::vector<std::vector<uint64_t>>& frag_offsets,
850 const int outer_table_id,
852 const uint32_t start_rowid,
853 const uint32_t num_tables,
854 const bool allow_runtime_interrupt,
856 const int64_t rows_to_process = -1);
861 const bool hoist_literals,
863 const std::vector<Analyzer::Expr*>& target_exprs,
865 std::vector<std::vector<const int8_t*>>& col_buffers,
867 const std::vector<std::vector<int64_t>>& num_rows,
868 const std::vector<std::vector<uint64_t>>& frag_offsets,
871 const uint32_t start_rowid,
872 const uint32_t num_tables,
873 const bool allow_runtime_interrupt,
875 const int64_t rows_to_process = -1);
880 const int64_t agg_init_val,
881 const int8_t out_byte_width,
882 const int64_t* out_vec,
883 const size_t out_vec_sz,
884 const bool is_group_by,
885 const bool float_argument_input);
891 const int device_id);
894 std::vector<std::pair<
ResultSetPtr, std::vector<size_t>>>& all_fragment_results,
895 std::shared_ptr<RowSetMemoryOwner>,
898 std::vector<std::pair<
ResultSetPtr, std::vector<size_t>>>& all_fragment_results,
899 std::shared_ptr<RowSetMemoryOwner>,
903 std::vector<std::pair<
ResultSetPtr, std::vector<size_t>>>& all_fragment_results,
904 std::shared_ptr<RowSetMemoryOwner>,
909 const bool allow_single_frag_table_opt,
910 const std::vector<InputTableInfo>&,
915 std::shared_ptr<RowSetMemoryOwner>,
917 const bool has_cardinality_estimation,
924 std::tuple<CompilationResult, std::unique_ptr<QueryMemoryDescriptor>>
compileWorkUnit(
925 const std::vector<InputTableInfo>& query_infos,
931 const bool allow_lazy_fetch,
932 std::shared_ptr<RowSetMemoryOwner>,
933 const size_t max_groups_buffer_entry_count,
934 const int8_t crt_min_byte_width,
935 const bool has_cardinality_estimation,
945 const std::vector<InputTableInfo>& query_infos,
952 const size_t level_idx,
953 const int inner_table_id,
957 std::function<llvm::Value*(const std::vector<llvm::Value*>&, llvm::Value*)>
959 const size_t level_idx,
968 const std::vector<InputTableInfo>& query_infos,
970 std::vector<std::string>& fail_reasons);
973 const size_t level_idx);
977 llvm::Function* query_func,
978 llvm::BasicBlock* entry_bb,
989 bool run_with_dynamic_watchdog,
990 bool run_with_allowing_runtime_interrupt,
991 const std::vector<JoinLoop>& join_loops,
993 const std::vector<InputTableInfo>& input_table_infos);
997 bool allow_runtime_query_interrupt);
1000 const std::vector<InputTableInfo>& query_infos);
1008 const std::shared_ptr<Analyzer::BinOper>& qual_bin_oper,
1009 const std::vector<InputTableInfo>& query_infos,
1012 const HashType preferred_hash_type,
1018 const std::vector<InputTableInfo>& query_infos,
1025 const std::unordered_set<llvm::Function*>&,
1030 std::unordered_set<llvm::Function*>&,
1031 const bool no_inline,
1033 const bool is_gpu_smem_used,
1035 std::string
generatePTX(
const std::string&)
const;
1046 const size_t col_width,
1048 const bool translate_null_val,
1049 const int64_t translated_null_val,
1051 std::stack<llvm::BasicBlock*>&,
1052 const bool thread_mem_shared);
1054 llvm::Value*
castToFP(llvm::Value*,
1059 std::tuple<RelAlgExecutionUnit, PlanState::DeletedColumnsMap>
addDeletedColumn(
1075 const std::list<std::shared_ptr<Analyzer::Expr>>& simple_quals,
1076 const std::vector<uint64_t>& frag_offsets,
1077 const size_t frag_idx);
1083 const std::vector<uint64_t>& frag_offsets,
1084 const size_t frag_idx);
1087 const std::unordered_set<PhysicalInput>& phys_inputs);
1089 const std::unordered_set<PhysicalInput>& phys_inputs);
1093 void setupCaching(
const std::unordered_set<PhysicalInput>& phys_inputs,
1094 const std::unordered_set<int>& phys_table_ids);
1102 mapd_shared_lock<mapd_shared_mutex>&
read_lock);
1104 mapd_shared_lock<mapd_shared_mutex>&
read_lock);
1107 const std::string& query_str,
1108 const std::string& submitted,
1109 const size_t executor_id,
1111 mapd_unique_lock<mapd_shared_mutex>&
write_lock);
1113 const std::string& submitted_time_str,
1114 mapd_unique_lock<mapd_shared_mutex>&
write_lock);
1116 mapd_unique_lock<mapd_shared_mutex>&
write_lock);
1118 mapd_shared_lock<mapd_shared_mutex>&
read_lock);
1120 mapd_shared_lock<mapd_shared_mutex>&
read_lock);
1123 const std::string& submitted_time_str,
1125 mapd_unique_lock<mapd_shared_mutex>&
write_lock);
1128 const std::string& submitted_time_str,
1129 const size_t executor_id,
1130 mapd_unique_lock<mapd_shared_mutex>&
write_lock);
1133 mapd_shared_lock<mapd_shared_mutex>&
read_lock);
1138 const std::string& query_str,
1139 const std::string& query_submitted_time);
1142 const std::string& submitted_time_str);
1144 const std::string& submitted_time_str,
1147 const std::string& query_str,
1148 const std::string& submitted_time_str,
1149 const size_t executor_id,
1179 executor_item.second->update_extension_modules(update_runtime_modules_only);
1185 const std::unordered_map<int, CgenState::LiteralValues>& literals,
1186 const int device_id);
1188 static size_t align(
const size_t off_in,
const size_t alignment) {
1189 size_t off = off_in;
1190 if (off % alignment != 0) {
1191 off += (alignment - off % alignment);
1208 const bool allow_lazy_fetch,
1209 const std::vector<InputTableInfo>& query_infos,
1229 static const std::unique_ptr<llvm::Module> empty;
1416 std::string null_check_suffix{
"_nullable"};
1419 null_check_suffix +=
"_rhs";
1422 null_check_suffix +=
"_lhs";
1424 return null_check_suffix;
1434 auto oper = (uoper && uoper->get_optype() ==
kCAST) ? uoper->
get_operand() : expr;
1436 return (arr && arr->isLocalAlloc() && arr->get_type_info().is_fixlen_array());
1445 const size_t cpu_count,
1446 const size_t gpu_count);
1456 return "template_module";
1458 return "rt_geos_module";
1460 return "rt_libdevice_module";
1462 return "udf_cpu_module";
1464 return "udf_gpu_module";
1466 return "rt_udf_cpu_module";
1468 return "rt_udf_gpu_module";
1470 LOG(
FATAL) <<
"Invalid LLVM module kind.";
1474 namespace foreign_storage {
1476 const int32_t col_id,
1480 #endif // QUERYENGINE_EXECUTE_H
void createErrorCheckControlFlow(llvm::Function *query_func, bool run_with_dynamic_watchdog, bool run_with_allowing_runtime_interrupt, const std::vector< JoinLoop > &join_loops, ExecutorDeviceType device_type, const std::vector< InputTableInfo > &input_table_infos)
bool updateQuerySessionStatusWithLock(const QuerySessionId &query_session, const std::string &submitted_time_str, const QuerySessionStatus::QueryStatus updated_query_status, mapd_unique_lock< mapd_shared_mutex > &write_lock)
SQLTypeInfo getColumnType(const size_t col_idx) const
CudaMgr_Namespace::CudaMgr * getCudaMgr() const
const std::string debug_dir_
QuerySessionId & getCurrentQuerySession(mapd_shared_lock< mapd_shared_mutex > &read_lock)
llvm::Value * translated_value
void executeWorkUnitPerFragment(const RelAlgExecutionUnit &ra_exe_unit, const InputTableInfo &table_info, const CompilationOptions &co, const ExecutionOptions &eo, const Catalog_Namespace::Catalog &cat, PerFragmentCallBack &cb, const std::set< size_t > &fragment_indexes_param)
Compiles and dispatches a work unit per fragment processing results with the per fragment callback...
bool is_agg(const Analyzer::Expr *expr)
static void invalidateCachesByTable(size_t table_key)
static CodeCacheAccessor< CpuCompilationContext > s_code_accessor
static mapd_shared_mutex executor_session_mutex_
AggregatedColRange computeColRangesCache(const std::unordered_set< PhysicalInput > &phys_inputs)
void enableRuntimeQueryInterrupt(const double runtime_query_check_freq, const unsigned pending_query_check_freq) const
const QueryPlanDAG getLatestQueryPlanDagExtracted() const
std::vector< std::unique_ptr< ExecutionKernel > > createKernels(SharedKernelContext &shared_context, const RelAlgExecutionUnit &ra_exe_unit, ColumnFetcher &column_fetcher, const std::vector< InputTableInfo > &table_infos, const ExecutionOptions &eo, const bool is_agg, const bool allow_single_frag_table_opt, const size_t context_count, const QueryCompilationDescriptor &query_comp_desc, const QueryMemoryDescriptor &query_mem_desc, RenderInfo *render_info, std::unordered_set< int > &available_gpus, int &available_cpus)
void codegenJoinLoops(const std::vector< JoinLoop > &join_loops, const RelAlgExecutionUnit &ra_exe_unit, GroupByAndAggregate &group_by_and_aggregate, llvm::Function *query_func, llvm::BasicBlock *entry_bb, QueryMemoryDescriptor &query_mem_desc, const CompilationOptions &co, const ExecutionOptions &eo)
const std::unique_ptr< llvm::Module > & get_udf_module(bool is_gpu=false) const
static QuerySessionMap queries_session_map_
CudaMgr_Namespace::CudaMgr * cudaMgr() const
static mapd_shared_mutex execute_mutex_
int32_t executePlanWithGroupBy(const RelAlgExecutionUnit &ra_exe_unit, const CompilationResult &, const bool hoist_literals, ResultSetPtr *results, const ExecutorDeviceType device_type, std::vector< std::vector< const int8_t * >> &col_buffers, const std::vector< size_t > outer_tab_frag_ids, QueryExecutionContext *, const std::vector< std::vector< int64_t >> &num_rows, const std::vector< std::vector< uint64_t >> &frag_offsets, Data_Namespace::DataMgr *, const int device_id, const int outer_table_id, const int64_t limit, const uint32_t start_rowid, const uint32_t num_tables, const bool allow_runtime_interrupt, RenderInfo *render_info, const int64_t rows_to_process=-1)
std::unique_ptr< llvm::TargetMachine > nvptx_target_machine_
bool has_libdevice_module() const
int64_t kernel_queue_time_ms_
size_t maxGpuSlabSize() const
ExecutorMutexHolder acquireExecuteMutex()
Data_Namespace::DataMgr * data_mgr_
int64_t compilation_queue_time_ms_
const std::string & getQuerySubmittedTime()
CompilationRetryNoLazyFetch()
std::map< const ColumnDescriptor *, std::set< int32_t >> ColumnToFragmentsMap
const std::unique_ptr< llvm::Module > & get_geos_module() const
void invalidateRunningQuerySession(mapd_unique_lock< mapd_shared_mutex > &write_lock)
static void initialize_extension_module_sources()
void checkPendingQueryStatus(const QuerySessionId &query_session)
const StringDictionaryProxy::IdMap * getJoinIntersectionStringProxyTranslationMap(const StringDictionaryProxy *source_proxy, StringDictionaryProxy *dest_proxy, const std::vector< StringOps_Namespace::StringOpInfo > &source_string_op_infos, const std::vector< StringOps_Namespace::StringOpInfo > &dest_source_string_op_infos, std::shared_ptr< RowSetMemoryOwner > row_set_mem_owner) const
static void registerActiveModule(void *module, const int device_id)
static const int32_t ERR_INTERRUPTED
const Analyzer::Expr * remove_cast_to_int(const Analyzer::Expr *expr)
class for a per-database catalog. also includes metadata for the current database and the current use...
std::vector< int8_t * > getJoinHashTablePtrs(const ExecutorDeviceType device_type, const int device_id)
bool is_trivial_loop_join(const std::vector< InputTableInfo > &query_infos, const RelAlgExecutionUnit &ra_exe_unit)
FetchCacheAnchor(CgenState *cgen_state)
const std::unique_ptr< llvm::Module > & get_extension_module(ExtModuleKinds kind) const
const std::shared_ptr< RowSetMemoryOwner > getRowSetMemoryOwner() const
StringDictionaryProxy * getLiteralDictionary() const override
std::atomic< bool > interrupted_
static ResultSetRecyclerHolder resultset_recycler_holder_
std::vector< size_t > getTableFragmentIndices(const RelAlgExecutionUnit &ra_exe_unit, const ExecutorDeviceType device_type, const size_t table_idx, const size_t outer_frag_idx, std::map< int, const TableFragments * > &selected_tables_fragments, const std::unordered_map< int, const Analyzer::BinOper * > &inner_table_id_to_join_condition)
ResultSetPtr executeTableFunction(const TableFunctionExecutionUnit exe_unit, const std::vector< InputTableInfo > &table_infos, const CompilationOptions &co, const ExecutionOptions &eo, const Catalog_Namespace::Catalog &cat)
Compiles and dispatches a table function; that is, a function that takes as input one or more columns...
Fragmenter_Namespace::RowDataProvider RowDataProvider
static CodeCacheAccessor< CpuCompilationContext > s_stubs_accessor
static const int max_gpu_count
GroupColLLVMValue groupByColumnCodegen(Analyzer::Expr *group_by_col, const size_t col_width, const CompilationOptions &, const bool translate_null_val, const int64_t translated_null_val, DiamondCodegen &, std::stack< llvm::BasicBlock * > &, const bool thread_mem_shared)
std::map< const QuerySessionId, std::map< std::string, QuerySessionStatus >> QuerySessionMap
size_t const getFragmentIndex() const
static const size_t code_cache_size
bool isArchPascalOrLater(const ExecutorDeviceType dt) const
void AutoTrackBuffersInRuntimeIR()
std::ostream & operator<<(std::ostream &os, const SessionInfo &session_info)
std::pair< QuerySessionId, std::string > CurrentQueryStatus
bool is_constructed_point(const Analyzer::Expr *expr)
static mapd_shared_mutex executors_cache_mutex_
std::function< llvm::BasicBlock *(llvm::BasicBlock *, llvm::BasicBlock *, const std::string &, llvm::Function *, CgenState *)> HoistedFiltersCallback
std::vector< ColumnLazyFetchInfo > getColLazyFetchInfo(const std::vector< Analyzer::Expr * > &target_exprs) const
static const size_t baseline_threshold
void updateQuerySessionStatus(const QuerySessionId &query_session, const std::string &submitted_time_str, const QuerySessionStatus::QueryStatus new_query_status)
const std::unique_ptr< llvm::Module > & get_rt_udf_module(bool is_gpu=false) const
std::unordered_set< int > get_available_gpus(const Data_Namespace::DataMgr *data_mgr)
std::tuple< RelAlgExecutionUnit, PlanState::DeletedColumnsMap > addDeletedColumn(const RelAlgExecutionUnit &ra_exe_unit, const CompilationOptions &co)
TableGenerations computeTableGenerations(std::unordered_set< int > phys_table_ids)
bool isArchPascalOrLater() const
bool hasLazyFetchColumns(const std::vector< Analyzer::Expr * > &target_exprs) const
const SQLTypeInfo get_column_type(const int col_id, const int table_id, const ColumnDescriptor *cd, const TemporaryTables *temporary_tables)
llvm::Value * aggregateWindowStatePtr()
Driver for running cleanup processes on a table. TableOptimizer provides functions for various cleanu...
static std::pair< int64_t, int32_t > reduceResults(const SQLAgg agg, const SQLTypeInfo &ti, const int64_t agg_init_val, const int8_t out_byte_width, const int64_t *out_vec, const size_t out_vec_sz, const bool is_group_by, const bool float_argument_input)
QuerySessionId current_query_session_
const Analyzer::Expr * extract_cast_arg(const Analyzer::Expr *expr)
bool checkCurrentQuerySession(const std::string &candidate_query_session, mapd_shared_lock< mapd_shared_mutex > &read_lock)
int32_t executePlanWithoutGroupBy(const RelAlgExecutionUnit &ra_exe_unit, const CompilationResult &, const bool hoist_literals, ResultSetPtr *results, const std::vector< Analyzer::Expr * > &target_exprs, const ExecutorDeviceType device_type, std::vector< std::vector< const int8_t * >> &col_buffers, QueryExecutionContext *query_exe_context, const std::vector< std::vector< int64_t >> &num_rows, const std::vector< std::vector< uint64_t >> &frag_offsets, Data_Namespace::DataMgr *data_mgr, const int device_id, const uint32_t start_rowid, const uint32_t num_tables, const bool allow_runtime_interrupt, RenderInfo *render_info, const int64_t rows_to_process=-1)
const QuerySessionStatus::QueryStatus getQueryStatus()
static const int32_t ERR_GEOS
const std::string query_str_
QuerySessionStatus(const QuerySessionId &query_session, const std::string &query_str, const std::string &submitted_time)
AggregatedColRange agg_col_range_cache_
std::shared_ptr< ResultSet > ResultSetPtr
static void * gpu_active_modules_[max_gpu_count]
std::unique_ptr< CgenState > cgen_state_
static const int32_t ERR_TOO_MANY_LITERALS
llvm::Value * original_value
void enrollQuerySession(const QuerySessionId &query_session, const std::string &query_str, const std::string &submitted_time_str, const size_t executor_id, const QuerySessionStatus::QueryStatus query_session_status)
ParseIRError(const std::string message)
static uint32_t gpu_active_modules_device_mask_
void launchKernels(SharedKernelContext &shared_context, std::vector< std::unique_ptr< ExecutionKernel >> &&kernels, const ExecutorDeviceType device_type)
TableUpdateMetadata executeUpdate(const RelAlgExecutionUnit &ra_exe_unit, const std::vector< InputTableInfo > &table_infos, const TableDescriptor *updated_table_desc, const CompilationOptions &co, const ExecutionOptions &eo, const Catalog_Namespace::Catalog &cat, std::shared_ptr< RowSetMemoryOwner > row_set_mem_owner, const UpdateLogForFragment::Callback &cb, const bool is_agg)
HOST DEVICE SQLTypes get_type() const
FragmentSkipStatus canSkipFragmentForFpQual(const Analyzer::BinOper *comp_expr, const Analyzer::ColumnVar *lhs_col, const Fragmenter_Namespace::FragmentInfo &fragment, const Analyzer::Constant *rhs_const) const
static void invalidateCaches()
void buildSelectedFragsMappingForUnion(std::vector< std::vector< size_t >> &selected_fragments_crossjoin, std::vector< size_t > &local_col_to_frag_pos, const std::list< std::shared_ptr< const InputColDescriptor >> &col_global_ids, const FragmentsList &selected_fragments, const RelAlgExecutionUnit &ra_exe_unit)
int deviceCount(const ExecutorDeviceType) const
llvm::Value * castToIntPtrTyIn(llvm::Value *val, const size_t bit_width)
size_t getNumBytesForFetchedRow(const std::set< int > &table_ids_to_fetch) const
void reset(bool discard_runtime_modules_only=false)
CompilationRetryNoCompaction()
static std::mutex kernel_mutex_
unsigned numBlocksPerMP() const
std::unique_ptr< CgenState > cgen_state_
Container for compilation results and assorted options for a single execution unit.
void clearCaches(bool runtime_only=false)
std::unique_ptr< WindowProjectNodeContext > window_project_node_context_owned_
std::vector< QuerySessionStatus > getQuerySessionInfo(const QuerySessionId &query_session, mapd_shared_lock< mapd_shared_mutex > &read_lock)
void addTransientStringLiterals(const RelAlgExecutionUnit &ra_exe_unit, const std::shared_ptr< RowSetMemoryOwner > &row_set_mem_owner)
std::vector< FragmentsPerTable > FragmentsList
bool needFetchAllFragments(const InputColDescriptor &col_desc, const RelAlgExecutionUnit &ra_exe_unit, const FragmentsList &selected_fragments) const
const QuerySessionId query_session_
std::shared_ptr< HashJoin > hash_table
bool checkIsQuerySessionInterrupted(const std::string &query_session, mapd_shared_lock< mapd_shared_mutex > &read_lock)
const StringDictionaryProxy::IdMap * getStringProxyTranslationMap(const int source_dict_id, const int dest_dict_id, const RowSetMemoryOwner::StringTranslationType translation_type, const std::vector< StringOps_Namespace::StringOpInfo > &string_op_infos, std::shared_ptr< RowSetMemoryOwner > row_set_mem_owner, const bool with_generation) const
mapd_shared_mutex & getSessionLock()
bool checkNonKernelTimeInterrupted() const
static void clearMemory(const Data_Namespace::MemoryLevel memory_level)
QuerySessionStatus(const QuerySessionId &query_session, const size_t executor_id, const std::string &query_str, const std::string &submitted_time)
std::function< void(const UpdateLogForFragment &, TableUpdateMetadata &)> Callback
void populate_string_dictionary(const int32_t table_id, const int32_t col_id, const Catalog_Namespace::Catalog &catalog)
Fragmenter_Namespace::TableInfo getTableInfo(const int table_id) const
RUNTIME_EXPORT void register_buffer_with_executor_rsm(int64_t exec, int8_t *buffer)
static const size_t high_scan_limit
const std::unique_ptr< llvm::Module > & get_libdevice_module() const
QueryMustRunOnCpu(const std::string &err)
static const int32_t ERR_STRING_CONST_IN_RESULTSET
void codegenWindowAvgEpilogue(llvm::Value *crt_val, llvm::Value *window_func_null_val, llvm::Value *multiplicity_lv)
static std::shared_ptr< Executor > getExecutor(const ExecutorId id, const std::string &debug_dir="", const std::string &debug_file="", const SystemParameters &system_parameters=SystemParameters())
void preloadFragOffsets(const std::vector< InputDescriptor > &input_descs, const std::vector< InputTableInfo > &query_infos)
bool isFragmentFullyDeleted(const int table_id, const Fragmenter_Namespace::FragmentInfo &fragment)
bool checkIsQuerySessionEnrolled(const QuerySessionId &query_session, mapd_shared_lock< mapd_shared_mutex > &read_lock)
void setQueryStatus(const QuerySessionStatus::QueryStatus &status)
FetchResult fetchUnionChunks(const ColumnFetcher &, const RelAlgExecutionUnit &ra_exe_unit, const int device_id, const Data_Namespace::MemoryLevel, const std::map< int, const TableFragments * > &, const FragmentsList &selected_fragments, const Catalog_Namespace::Catalog &, std::list< ChunkIter > &, std::list< std::shared_ptr< Chunk_NS::Chunk >> &, DeviceAllocator *device_allocator, const size_t thread_idx, const bool allow_runtime_interrupt)
static const int32_t ERR_STREAMING_TOP_N_NOT_SUPPORTED_IN_RENDER_QUERY
const ExecutorId executor_id_
static const int32_t ERR_COLUMNAR_CONVERSION_NOT_SUPPORTED
const ResultSetPtr & get_temporary_table(const TemporaryTables *temporary_tables, const int table_id)
std::map< QuerySessionId, bool > InterruptFlagMap
const size_t max_gpu_slab_size_
ResultSetPtr reduceSpeculativeTopN(const RelAlgExecutionUnit &, std::vector< std::pair< ResultSetPtr, std::vector< size_t >>> &all_fragment_results, std::shared_ptr< RowSetMemoryOwner >, const QueryMemoryDescriptor &) const
ResultSetPtr collectAllDeviceResults(SharedKernelContext &shared_context, const RelAlgExecutionUnit &ra_exe_unit, const QueryMemoryDescriptor &query_mem_desc, const ExecutorDeviceType device_type, std::shared_ptr< RowSetMemoryOwner > row_set_mem_owner)
const ColumnDescriptor * getPhysicalColumnDescriptor(const Analyzer::ColumnVar *, int) const
std::lock_guard< std::mutex > lock_
static void unregisterActiveModule(const int device_id)
static const int32_t ERR_DIV_BY_ZERO
std::tuple< CompilationResult, std::unique_ptr< QueryMemoryDescriptor > > compileWorkUnit(const std::vector< InputTableInfo > &query_infos, const PlanState::DeletedColumnsMap &deleted_cols_map, const RelAlgExecutionUnit &ra_exe_unit, const CompilationOptions &co, const ExecutionOptions &eo, const CudaMgr_Namespace::CudaMgr *cuda_mgr, const bool allow_lazy_fetch, std::shared_ptr< RowSetMemoryOwner >, const size_t max_groups_buffer_entry_count, const int8_t crt_min_byte_width, const bool has_cardinality_estimation, ColumnCacheMap &column_cache, RenderInfo *render_info=nullptr)
static CodeCacheAccessor< CpuCompilationContext > cpu_code_accessor
TableIdToNodeMap table_id_to_node_map_
bool addToQuerySessionList(const QuerySessionId &query_session, const std::string &query_str, const std::string &submitted, const size_t executor_id, const QuerySessionStatus::QueryStatus query_status, mapd_unique_lock< mapd_shared_mutex > &write_lock)
bool compileBody(const RelAlgExecutionUnit &ra_exe_unit, GroupByAndAggregate &group_by_and_aggregate, QueryMemoryDescriptor &query_mem_desc, const CompilationOptions &co, const GpuSharedMemoryContext &gpu_smem_context={})
std::unordered_map< size_t, HashTableBuildDag > HashTableBuildDagMap
llvm::Value * get_arg_by_name(llvm::Function *func, const std::string &name)
std::vector< llvm::Value * > LLVMValueVector
size_t get_context_count(const ExecutorDeviceType device_type, const size_t cpu_count, const size_t gpu_count)
const ColumnDescriptor * get_column_descriptor_maybe(const int col_id, const int table_id, const Catalog_Namespace::Catalog &cat)
std::vector< TargetValue > getEntryAt(const size_t index) const override
int get_logical_size() const
std::unordered_map< int, std::vector< llvm::Value * > > fetch_cache_
decltype(FragmentInfoType::fragmentId) const getFragmentId() const
int64_t deviceCycles(int milliseconds) const
std::string generatePTX(const std::string &) const
std::mutex str_dict_mutex_
const Catalog_Namespace::Catalog * catalog_
friend class PendingExecutionClosure
void setQuerySessionAsInterrupted(const QuerySessionId &query_session, mapd_unique_lock< mapd_shared_mutex > &write_lock)
static const int32_t ERR_OUT_OF_RENDER_MEM
std::unordered_map< TableId, const ColumnDescriptor * > DeletedColumnsMap
ResultSetPtr reduceMultiDeviceResults(const RelAlgExecutionUnit &, std::vector< std::pair< ResultSetPtr, std::vector< size_t >>> &all_fragment_results, std::shared_ptr< RowSetMemoryOwner >, const QueryMemoryDescriptor &) const
std::shared_timed_mutex mapd_shared_mutex
const std::string debug_file_
ResultSetPtr collectAllDeviceShardedTopResults(SharedKernelContext &shared_context, const RelAlgExecutionUnit &ra_exe_unit) const
CachedCardinality getCachedCardinality(const std::string &cache_key)
decltype(FragmentInfoType::physicalTableId) const getPhysicalTableId() const
std::unordered_map< int, const RelAlgNode * > TableIdToNodeMap
std::shared_ptr< RowSetMemoryOwner > row_set_mem_owner_
Used by Fragmenter classes to store info about each fragment - the fragment id and number of tuples(r...
void setColRangeCache(const AggregatedColRange &aggregated_col_range)
bool containsLeftDeepOuterJoin() const
static QueryPlanDAG latest_query_plan_extracted_
void setCatalog(const Catalog_Namespace::Catalog *catalog)
size_t getNumCurentSessionsEnrolled() const
bool has_rt_module() const
StringDictionaryProxy * getStringDictionaryProxy(const int dict_id, const bool with_generation) const
std::shared_ptr< CompilationContext > optimizeAndCodegenCPU(llvm::Function *, llvm::Function *, const std::unordered_set< llvm::Function * > &, const CompilationOptions &)
static const int32_t ERR_OVERFLOW_OR_UNDERFLOW
bool is_timeinterval() const
static std::unordered_map< std::string, size_t > cardinality_cache_
static InterruptFlagMap queries_interrupt_flag_
FragmentInfoType const & getFragmentInfo() const
const logger::ThreadId thread_id_
std::unique_ptr< PlanState > plan_state_
void insertErrorCodeChecker(llvm::Function *query_func, bool hoist_literals, bool allow_runtime_query_interrupt)
const ColumnDescriptor * getMetadataForColumn(int tableId, const std::string &colName) const
static const int32_t ERR_OUT_OF_TIME
void initializeNVPTXBackend() const
mapd_unique_lock< mapd_shared_mutex > unique_lock
std::map< int32_t, std::set< int32_t >> TableToFragmentIds
const std::string submitted_time_
const TableGeneration & getTableGeneration(const int table_id) const
llvm::Value * castToFP(llvm::Value *, SQLTypeInfo const &from_ti, SQLTypeInfo const &to_ti)
std::pair< bool, size_t > CachedCardinality
const ColumnDescriptor * getColumnDescriptor(const Analyzer::ColumnVar *) const
static const int32_t ERR_UNSUPPORTED_SELF_JOIN
const unsigned block_size_x_
const unsigned grid_size_x_
specifies the content in-memory of a row in the column metadata table
std::vector< TargetValue > getTranslatedEntryAt(const size_t index) const override
static const int32_t ERR_SINGLE_VALUE_FOUND_MULTIPLE_VALUES
static std::map< int, std::shared_ptr< Executor > > executors_
static const int32_t ERR_OUT_OF_GPU_MEM
std::string toString(const Executor::ExtModuleKinds &kind)
const TemporaryTables * getTemporaryTables()
std::string get_null_check_suffix(const SQLTypeInfo &lhs_ti, const SQLTypeInfo &rhs_ti)
const std::unique_ptr< llvm::Module > & get_rt_module() const
static const ExecutorId INVALID_EXECUTOR_ID
const Catalog_Namespace::Catalog * getCatalog() const
std::unordered_map< int, std::unordered_map< int, std::shared_ptr< const ColumnarResults >>> ColumnCacheMap
bool updateQuerySessionExecutorAssignment(const QuerySessionId &query_session, const std::string &submitted_time_str, const size_t executor_id, mapd_unique_lock< mapd_shared_mutex > &write_lock)
Executor(const ExecutorId id, Data_Namespace::DataMgr *data_mgr, const size_t block_size_x, const size_t grid_size_x, const size_t max_gpu_slab_size, const std::string &debug_dir, const std::string &debug_file)
std::string dumpCache() const
const std::vector< size_t > getExecutorIdsRunningQuery(const QuerySessionId &interrupt_session) const
ResultSetPtr resultsUnion(SharedKernelContext &shared_context, const RelAlgExecutionUnit &ra_exe_unit)
void registerExtractedQueryPlanDag(const QueryPlanDAG &query_plan_dag)
std::shared_ptr< ResultSet > rs_
JoinHashTableOrError buildHashTableForQualifier(const std::shared_ptr< Analyzer::BinOper > &qual_bin_oper, const std::vector< InputTableInfo > &query_infos, const MemoryLevel memory_level, const JoinType join_type, const HashType preferred_hash_type, ColumnCacheMap &column_cache, const HashTableBuildDagMap &hashtable_build_dag_map, const RegisteredQueryHint &query_hint, const TableIdToNodeMap &table_id_to_node_map)
std::vector< size_t > getFragmentCount(const FragmentsList &selected_fragments, const size_t scan_idx, const RelAlgExecutionUnit &ra_exe_unit)
static void addUdfIrToModule(const std::string &udf_ir_filename, const bool is_cuda_ir)
llvm::BasicBlock * codegenSkipDeletedOuterTableRow(const RelAlgExecutionUnit &ra_exe_unit, const CompilationOptions &co)
std::unique_ptr< QueryCompilationDescriptor > QueryCompilationDescriptorOwned
HOST DEVICE EncodingType get_compression() const
std::shared_ptr< HashJoin > buildCurrentLevelHashTable(const JoinCondition ¤t_level_join_conditions, size_t level_idx, RelAlgExecutionUnit &ra_exe_unit, const CompilationOptions &co, const std::vector< InputTableInfo > &query_infos, ColumnCacheMap &column_cache, std::vector< std::string > &fail_reasons)
static void update_after_registration(bool update_runtime_modules_only=false)
std::vector< int8_t > serializeLiterals(const std::unordered_map< int, CgenState::LiteralValues > &literals, const int device_id)
std::shared_ptr< CompilationContext > optimizeAndCodegenGPU(llvm::Function *, llvm::Function *, std::unordered_set< llvm::Function * > &, const bool no_inline, const CudaMgr_Namespace::CudaMgr *cuda_mgr, const bool is_gpu_smem_used, const CompilationOptions &)
mapd_shared_mutex & getDataRecyclerLock()
InputTableInfoCache input_table_info_cache_
const Expr * get_operand() const
std::chrono::steady_clock::time_point lock_queue_clock_
void codegenWindowFunctionStateInit(llvm::Value *aggregate_state)
static CodeCacheAccessor< CompilationContext > tf_code_accessor
std::pair< bool, int64_t > skipFragment(const InputDescriptor &table_desc, const Fragmenter_Namespace::FragmentInfo &frag_info, const std::list< std::shared_ptr< Analyzer::Expr >> &simple_quals, const std::vector< uint64_t > &frag_offsets, const size_t frag_idx)
unsigned gridSize() const
llvm::Value * spillDoubleElement(llvm::Value *elem_val, llvm::Type *elem_ty)
std::pair< std::vector< std::vector< int64_t > >, std::vector< std::vector< uint64_t > > > getRowCountAndOffsetForAllFrags(const RelAlgExecutionUnit &ra_exe_unit, const CartesianProduct< std::vector< std::vector< size_t >>> &frag_ids_crossjoin, const std::vector< InputDescriptor > &input_descs, const std::map< int, const TableFragments * > &all_tables_fragments)
friend class KernelSubtask
PlanState * getPlanStatePtr() const
static std::map< ExtModuleKinds, std::string > extension_module_sources
StringDictionaryGenerations computeStringDictionaryGenerations(const std::unordered_set< PhysicalInput > &phys_inputs)
bool has_udf_module(bool is_gpu=false) const
static const int32_t ERR_WIDTH_BUCKET_INVALID_ARGUMENT
Data_Namespace::DataMgr * getDataMgr() const
bool needLinearizeAllFragments(const ColumnDescriptor *cd, const InputColDescriptor &inner_col_desc, const RelAlgExecutionUnit &ra_exe_unit, const FragmentsList &selected_fragments, const Data_Namespace::MemoryLevel memory_level) const
void setExecutorId(const size_t executor_id)
std::unique_ptr< llvm::LLVMContext > context_
CgenState * getCgenStatePtr() const
FragmentInfoType const & fragment_info_
void nukeOldState(const bool allow_lazy_fetch, const std::vector< InputTableInfo > &query_infos, const PlanState::DeletedColumnsMap &deleted_cols_map, const RelAlgExecutionUnit *ra_exe_unit)
const std::string getQueryStr()
QuerySessionStatus::QueryStatus getQuerySessionStatus(const QuerySessionId &candidate_query_session, mapd_shared_lock< mapd_shared_mutex > &read_lock)
std::pair< bool, int64_t > skipFragmentInnerJoins(const InputDescriptor &table_desc, const RelAlgExecutionUnit &ra_exe_unit, const Fragmenter_Namespace::FragmentInfo &fragment, const std::vector< uint64_t > &frag_offsets, const size_t frag_idx)
void buildSelectedFragsMapping(std::vector< std::vector< size_t >> &selected_fragments_crossjoin, std::vector< size_t > &local_col_to_frag_pos, const std::list< std::shared_ptr< const InputColDescriptor >> &col_global_ids, const FragmentsList &selected_fragments, const RelAlgExecutionUnit &ra_exe_unit)
llvm::Value * codegenAggregateWindowState()
TableGenerations table_generations_
std::function< void(ResultSetPtr, const Fragmenter_Namespace::FragmentInfo &)> PerFragmentCallBack
mapd_shared_lock< mapd_shared_mutex > read_lock
const size_t getExecutorId()
bool removeFromQuerySessionList(const QuerySessionId &query_session, const std::string &submitted_time_str, mapd_unique_lock< mapd_shared_mutex > &write_lock)
static void registerExtensionFunctions(F register_extension_functions)
std::string QuerySessionId
llvm::Value * addJoinLoopIterator(const std::vector< llvm::Value * > &prev_iters, const size_t level_idx)
ResultSetPtr reduceMultiDeviceResultSets(std::vector< std::pair< ResultSetPtr, std::vector< size_t >>> &all_fragment_results, std::shared_ptr< RowSetMemoryOwner >, const QueryMemoryDescriptor &) const
llvm::Value * codegenWindowFunctionAggregate(const CompilationOptions &co)
void addToCardinalityCache(const std::string &cache_key, const size_t cache_value)
QueryPlanDagCache & getQueryPlanDagCache()
bool has_extension_module(ExtModuleKinds kind) const
static const int32_t ERR_OUT_OF_SLOTS
static void clearExternalCaches(bool for_update, const TableDescriptor *td, const int current_db_id)
CgenStateManager(Executor &executor)
std::mutex compilation_mutex_
void interrupt(const QuerySessionId &query_session="", const QuerySessionId &interrupt_session="")
bool has_rt_udf_module(bool is_gpu=false) const
std::vector< llvm::Value * > inlineHoistedLiterals()
static CodeCacheAccessor< GpuCompilationContext > gpu_code_accessor
FetchResult fetchChunks(const ColumnFetcher &, const RelAlgExecutionUnit &ra_exe_unit, const int device_id, const Data_Namespace::MemoryLevel, const std::map< int, const TableFragments * > &, const FragmentsList &selected_fragments, const Catalog_Namespace::Catalog &, std::list< ChunkIter > &, std::list< std::shared_ptr< Chunk_NS::Chunk >> &, DeviceAllocator *device_allocator, const size_t thread_idx, const bool allow_runtime_interrupt)
mapd_shared_lock< mapd_shared_mutex > shared_lock
ResultSetPtr executeWorkUnitImpl(size_t &max_groups_buffer_entry_guess, const bool is_agg, const bool allow_single_frag_table_opt, const std::vector< InputTableInfo > &, const RelAlgExecutionUnit &, const CompilationOptions &, const ExecutionOptions &options, const Catalog_Namespace::Catalog &, std::shared_ptr< RowSetMemoryOwner >, RenderInfo *render_info, const bool has_cardinality_estimation, ColumnCacheMap &column_cache)
std::unordered_map< int, const Analyzer::BinOper * > getInnerTabIdToJoinCond() const
ExecutorDeviceType getDeviceTypeForTargets(const RelAlgExecutionUnit &ra_exe_unit, const ExecutorDeviceType requested_device_type)
JoinLoop::HoistedFiltersCallback buildHoistLeftHandSideFiltersCb(const RelAlgExecutionUnit &ra_exe_unit, const size_t level_idx, const int inner_table_id, const CompilationOptions &co)
uint32_t log2_bytes(const uint32_t bytes)
ExpressionRange getColRange(const PhysicalInput &) const
std::string numeric_type_name(const SQLTypeInfo &ti)
CurrentQueryStatus attachExecutorToQuerySession(const QuerySessionId &query_session_id, const std::string &query_str, const std::string &query_submitted_time)
mapd_unique_lock< mapd_shared_mutex > write_lock
void redeclareFilterFunction()
QuerySessionStatus(const QuerySessionId &query_session, const size_t executor_id, const std::string &query_str, const std::string &submitted_time, const QuerySessionStatus::QueryStatus &query_status)
UpdateLogForFragment(FragmentInfoType const &fragment_info, size_t const, const std::shared_ptr< ResultSet > &rs)
bool is_unnest(const Analyzer::Expr *expr)
std::vector< JoinLoop > buildJoinLoops(RelAlgExecutionUnit &ra_exe_unit, const CompilationOptions &co, const ExecutionOptions &eo, const std::vector< InputTableInfo > &query_infos, ColumnCacheMap &column_cache)
std::function< llvm::Value *(const std::vector< llvm::Value * > &, llvm::Value *)> buildIsDeletedCb(const RelAlgExecutionUnit &ra_exe_unit, const size_t level_idx, const CompilationOptions &co)
auto getResultSet() const
unsigned blockSize() const
static std::mutex register_runtime_extension_functions_mutex_
Execution unit for relational algebra. It's a low-level description of any relational algebra operati...
HOST DEVICE bool get_notnull() const
std::unordered_map< int, std::vector< llvm::Value * > > saved_fetch_cache
ExecutorId getExecutorId() const
static size_t align(const size_t off_in, const size_t alignment)
std::unique_ptr< QueryMemoryDescriptor > QueryMemoryDescriptorOwned
size_t const getRowCount() const override
const QuerySessionId getQuerySession()
void clearQuerySessionStatus(const QuerySessionId &query_session, const std::string &submitted_time_str)
static const int32_t ERR_OUT_OF_CPU_MEM
QuerySessionStatus::QueryStatus query_status_
int deviceCountForMemoryLevel(const Data_Namespace::MemoryLevel memory_level) const
Descriptor for the fragments required for an execution kernel.
llvm::Value * codegenWindowFunctionAggregateCalls(llvm::Value *aggregate_state, const CompilationOptions &co)
Fragmenter_Namespace::FragmentInfo FragmentInfoType
static size_t getArenaBlockSize()
ResultSetPtr executeWorkUnit(size_t &max_groups_buffer_entry_guess, const bool is_agg, const std::vector< InputTableInfo > &, const RelAlgExecutionUnit &, const CompilationOptions &, const ExecutionOptions &options, const Catalog_Namespace::Catalog &, RenderInfo *render_info, const bool has_cardinality_estimation, ColumnCacheMap &column_cache)
std::mutex gpu_exec_mutex_[max_gpu_count]
DEVICE void swap(ARGS &&...args)
llvm::LLVMContext & getContext()
static mapd_shared_mutex recycler_mutex_
llvm::Value * codegenWindowFunction(const size_t target_index, const CompilationOptions &co)
std::vector< int > getTableChunkKey(const int getCurrentDBId) const
SQLOps get_optype() const
static QueryPlanDagCache query_plan_dag_cache_
WindowFunctionContext * active_window_function_
static std::mutex gpu_active_modules_mutex_
void setupCaching(const std::unordered_set< PhysicalInput > &phys_inputs, const std::unordered_set< int > &phys_table_ids)
static void nukeCacheOfExecutors()
void clearMetaInfoCache()
const ColumnDescriptor * get_column_descriptor(const int col_id, const int table_id, const Catalog_Namespace::Catalog &cat)
size_t const getEntryCount() const override
llvm::BasicBlock * codegenWindowResetStateControlFlow()
const TemporaryTables * temporary_tables_
CompilationRetryNewScanLimit(const size_t new_scan_limit)
WatchdogException(const std::string &cause)
static const ExecutorId UNITARY_EXECUTOR_ID
bool has_geos_module() const
void update_extension_modules(bool update_runtime_modules_only=false)
ResultSetRecyclerHolder & getRecultSetRecyclerHolder()
bool isArchMaxwell(const ExecutorDeviceType dt) const
bool skipFragmentPair(const Fragmenter_Namespace::FragmentInfo &outer_fragment_info, const Fragmenter_Namespace::FragmentInfo &inner_fragment_info, const int inner_table_id, const std::unordered_map< int, const Analyzer::BinOper * > &inner_table_id_to_join_condition, const RelAlgExecutionUnit &ra_exe_unit, const ExecutorDeviceType device_type)
ResultSetPtr executeExplain(const QueryCompilationDescriptor &)
std::map< ExtModuleKinds, std::unique_ptr< llvm::Module > > extension_modules_