19 #include "../Execute.h"
20 #include "../ExpressionRewrite.h"
21 #include "../GroupByAndAggregate.h"
22 #include "../StreamingTopN.h"
23 #include "../UsedColumnsVisitor.h"
26 #include <boost/algorithm/cxx11/any_of.hpp>
46 const std::list<std::shared_ptr<Analyzer::Expr>>& groupby_exprs,
47 const std::vector<Analyzer::Expr*>& target_exprs) {
48 std::vector<int64_t> indices(target_exprs.size(), -1);
49 for (
size_t target_idx = 0; target_idx < target_exprs.size(); ++target_idx) {
50 const auto target_expr = target_exprs[target_idx];
51 if (dynamic_cast<const Analyzer::AggExpr*>(target_expr)) {
54 const auto var_expr =
dynamic_cast<const Analyzer::Var*
>(target_expr);
56 indices[target_idx] = var_expr->
get_varno() - 1;
68 std::vector<int64_t> target_indices(ra_exe_unit.
target_exprs.size(), -1);
70 std::unordered_set<shared::ColumnKey> used_columns;
71 for (
const auto& simple_qual : ra_exe_unit.
simple_quals) {
72 const auto crt_used_columns = columns_visitor.
visit(simple_qual.get());
73 used_columns.insert(crt_used_columns.begin(), crt_used_columns.end());
75 for (
const auto& qual : ra_exe_unit.
quals) {
76 const auto crt_used_columns = columns_visitor.visit(qual.get());
77 used_columns.insert(crt_used_columns.begin(), crt_used_columns.end());
83 if (!cd || !cd->isVirtualCol) {
87 const auto crt_used_columns = columns_visitor.visit(target);
88 used_columns.insert(crt_used_columns.begin(), crt_used_columns.end());
90 for (
size_t target_idx = 0; target_idx < ra_exe_unit.
target_exprs.size();
92 const auto target_expr = ra_exe_unit.
target_exprs[target_idx];
94 const auto& ti = target_expr->get_type_info();
103 if (!ti.is_varlen() &&
104 used_columns.find(col_var->getColumnKey()) == used_columns.end()) {
108 target_indices[target_idx] = 0;
111 return target_indices;
115 const size_t group_col_width) {
117 return sizeof(int64_t);
121 if (group_col_width ==
sizeof(int64_t) && range.
hasNulls()) {
122 return sizeof(int64_t);
127 return sizeof(int64_t);
131 return sizeof(int64_t);
136 const std::vector<InputTableInfo>& query_infos,
137 const Executor* executor) {
138 int8_t compact_width{4};
140 const auto expr_range =
getExpressionRange(groupby_expr.get(), query_infos, executor);
141 compact_width = std::max(compact_width,
143 expr_range, groupby_expr->get_type_info().get_size()));
145 return compact_width;
149 const bool output_columnar) {
154 for (
const auto target_expr : ra_exe_unit.
target_exprs) {
155 if (dynamic_cast<const Analyzer::AggExpr*>(target_expr)) {
158 if (dynamic_cast<const Analyzer::WindowFunction*>(target_expr)) {
169 CHECK_GT(only_order_entry.tle_no,
int(0));
170 CHECK_LE(static_cast<size_t>(only_order_entry.tle_no),
172 const auto order_entry_expr = ra_exe_unit.
target_exprs[only_order_entry.tle_no - 1];
174 if ((order_entry_expr->get_type_info().is_number() ||
175 order_entry_expr->get_type_info().is_time()) &&
186 std::vector<int8_t> col_widths;
187 size_t col_expr_idx = 0;
188 for (
const auto& col_expr : col_expr_list) {
191 col_widths.push_back(
sizeof(int64_t));
194 if constexpr (std::is_same<
T, std::list<std::shared_ptr<Analyzer::Expr>>>::value) {
203 col_widths.push_back(
sizeof(int64_t));
209 if ((chosen_type.is_string() && chosen_type.get_compression() ==
kENCODING_NONE) ||
210 chosen_type.is_array()) {
211 col_widths.push_back(
sizeof(int64_t));
212 col_widths.push_back(
sizeof(int64_t));
216 if (chosen_type.is_geometry()) {
217 for (
auto i = 0; i < chosen_type.get_physical_coord_cols(); ++i) {
218 col_widths.push_back(
sizeof(int64_t));
219 col_widths.push_back(
sizeof(int64_t));
225 CHECK_EQ(
size_t(0), col_expr_bitwidth % 8);
226 col_widths.push_back(static_cast<int8_t>(col_expr_bitwidth >> 3));
228 if (agg_info.agg_kind ==
kAVG) {
229 CHECK(agg_info.is_agg);
230 col_widths.push_back(
sizeof(int64_t));
241 const Executor* executor,
243 const std::vector<InputTableInfo>& query_infos,
246 const bool allow_multifrag,
248 const int8_t crt_min_byte_width,
249 const bool sort_on_gpu_hint,
250 const size_t shard_count,
251 const size_t max_groups_buffer_entry_count,
254 const bool must_use_baseline_sort,
255 const bool output_columnar_hint,
256 const bool streaming_top_n_hint,
257 const bool threads_can_reuse_group_by_buffers) {
259 const bool is_group_by{!group_col_widths.empty()};
264 ra_exe_unit, query_infos, crt_min_byte_width);
266 col_slot_context.setAllSlotsPaddedSize(min_slot_size);
267 col_slot_context.validate();
270 CHECK(!must_use_baseline_sort);
272 return std::make_unique<QueryMemoryDescriptor>(
287 std::vector<int8_t>{},
289 std::vector<int64_t>{},
291 count_distinct_descriptors,
293 output_columnar_hint,
294 render_info && render_info->isInSitu(),
295 must_use_baseline_sort,
297 threads_can_reuse_group_by_buffers);
300 size_t entry_count = 1;
301 auto actual_col_range_info = col_range_info;
302 bool interleaved_bins_on_gpu =
false;
303 bool keyless_hash =
false;
304 bool streaming_top_n =
false;
305 int8_t group_col_compact_width = 0;
306 int32_t idx_target_as_key = -1;
307 auto output_columnar = output_columnar_hint;
308 std::vector<int64_t> target_groupby_indices;
310 switch (col_range_info.hash_type_) {
315 render_info->setNonInSitu();
320 (!sort_on_gpu_hint ||
322 col_range_info.max, col_range_info.min, col_range_info.bucket)) &&
323 !col_range_info.bucket && !must_use_baseline_sort && keyless_info.keyless;
327 idx_target_as_key = keyless_info.target_index;
329 if (group_col_widths.size() > 1) {
331 entry_count =
static_cast<size_t>(actual_col_range_info.max);
332 actual_col_range_info.bucket = 0;
335 entry_count = std::max(
337 const size_t interleaved_max_threshold{512};
339 if (must_use_baseline_sort) {
341 ra_exe_unit.target_exprs);
346 bool has_varlen_sample_agg =
false;
347 for (
const auto& target_expr : ra_exe_unit.target_exprs) {
348 if (target_expr->get_contains_agg()) {
351 if (agg_expr->get_aggtype() ==
kSAMPLE &&
352 agg_expr->get_type_info().is_varlen()) {
353 has_varlen_sample_agg =
true;
359 interleaved_bins_on_gpu = keyless_hash && !has_varlen_sample_agg &&
360 (entry_count <= interleaved_max_threshold) &&
363 count_distinct_descriptors) &&
372 render_info->setNonInSitu();
374 entry_count = shard_count
375 ? (max_groups_buffer_entry_count + shard_count - 1) / shard_count
376 : max_groups_buffer_entry_count;
378 ra_exe_unit.target_exprs);
379 col_slot_context =
ColSlotContext(ra_exe_unit.target_exprs, target_groupby_indices);
381 group_col_compact_width =
385 actual_col_range_info =
390 CHECK(!must_use_baseline_sort);
393 streaming_top_n =
true;
395 ra_exe_unit.sort_info.offset + ra_exe_unit.sort_info.limit.value_or(0);
397 if (ra_exe_unit.use_bump_allocator) {
398 output_columnar =
false;
401 entry_count = ra_exe_unit.scan_limit
402 ?
static_cast<size_t>(ra_exe_unit.scan_limit)
403 : max_groups_buffer_entry_count;
407 target_groupby_indices = executor->plan_state_->allow_lazy_fetch_
409 : std::vector<int64_t>{};
411 col_slot_context =
ColSlotContext(ra_exe_unit.target_exprs, target_groupby_indices);
418 return std::make_unique<QueryMemoryDescriptor>(executor,
423 interleaved_bins_on_gpu,
425 actual_col_range_info,
428 group_col_compact_width,
429 target_groupby_indices,
431 count_distinct_descriptors,
434 render_info && render_info->isInSitu(),
435 must_use_baseline_sort,
437 threads_can_reuse_group_by_buffers);
441 template <
SQLAgg... agg_types>
442 bool any_of(std::vector<Analyzer::Expr*>
const& target_exprs) {
445 return agg && (... || (agg_types == agg->get_aggtype()));
451 const Executor* executor,
453 const std::vector<InputTableInfo>& query_infos,
454 const bool allow_multifrag,
455 const bool keyless_hash,
456 const bool interleaved_bins_on_gpu,
457 const int32_t idx_target_as_key,
460 const std::vector<int8_t>& group_col_widths,
461 const int8_t group_col_compact_width,
462 const std::vector<int64_t>& target_groupby_indices,
463 const size_t entry_count,
465 const bool sort_on_gpu_hint,
466 const bool output_columnar_hint,
467 const bool render_output,
468 const bool must_use_baseline_sort,
470 const bool threads_can_reuse_group_by_buffers)
472 , allow_multifrag_(allow_multifrag)
473 , query_desc_type_(col_range_info.hash_type_)
474 , keyless_hash_(keyless_hash)
475 , interleaved_bins_on_gpu_(interleaved_bins_on_gpu)
476 , idx_target_as_key_(idx_target_as_key)
477 , group_col_widths_(group_col_widths)
478 , group_col_compact_width_(group_col_compact_width)
479 , target_groupby_indices_(target_groupby_indices)
480 , entry_count_(entry_count)
481 , min_val_(col_range_info.min)
482 , max_val_(col_range_info.max)
483 , bucket_(col_range_info.bucket)
484 , has_nulls_(col_range_info.has_nulls)
485 , count_distinct_descriptors_(count_distinct_descriptors)
486 , output_columnar_(
false)
487 , render_output_(render_output)
488 , must_use_baseline_sort_(must_use_baseline_sort)
489 , use_streaming_top_n_(use_streaming_top_n)
490 , threads_can_reuse_group_by_buffers_(threads_can_reuse_group_by_buffers)
491 , force_4byte_float_(
false)
492 , col_slot_context_(col_slot_context)
511 !any_of<kAPPROX_QUANTILE, kMODE>(ra_exe_unit.
target_exprs);
520 !any_of<kAPPROX_QUANTILE, kMODE>(ra_exe_unit.
target_exprs);
539 const auto thread_count = executor->blockSize() * executor->gridSize();
540 const auto total_buff_size =
542 if (total_buff_size >
executor_->maxGpuSlabSize()) {
551 , allow_multifrag_(
false)
553 , keyless_hash_(
false)
554 , interleaved_bins_on_gpu_(
false)
555 , idx_target_as_key_(0)
556 , group_col_compact_width_(0)
562 , sort_on_gpu_(
false)
563 , output_columnar_(
false)
564 , render_output_(
false)
565 , must_use_baseline_sort_(
false)
566 , use_streaming_top_n_(
false)
567 , threads_can_reuse_group_by_buffers_(
false)
568 , force_4byte_float_(
false) {}
571 const size_t entry_count,
574 , allow_multifrag_(
false)
575 , query_desc_type_(query_desc_type)
576 , keyless_hash_(
false)
577 , interleaved_bins_on_gpu_(
false)
578 , idx_target_as_key_(0)
579 , group_col_compact_width_(0)
580 , entry_count_(entry_count)
585 , sort_on_gpu_(
false)
586 , output_columnar_(
false)
587 , render_output_(
false)
588 , must_use_baseline_sort_(
false)
589 , use_streaming_top_n_(
false)
590 , threads_can_reuse_group_by_buffers_(
false)
591 , force_4byte_float_(
false)
600 const int64_t min_val,
601 const int64_t max_val,
602 const bool has_nulls,
603 const std::vector<int8_t>& group_col_widths)
605 , allow_multifrag_(
false)
606 , query_desc_type_(query_desc_type)
607 , keyless_hash_(
false)
608 , interleaved_bins_on_gpu_(
false)
609 , idx_target_as_key_(0)
610 , group_col_widths_(group_col_widths)
611 , group_col_compact_width_(0)
617 , sort_on_gpu_(
false)
618 , output_columnar_(
false)
619 , render_output_(
false)
620 , must_use_baseline_sort_(
false)
621 , use_streaming_top_n_(
false)
622 , threads_can_reuse_group_by_buffers_(
false)
623 , force_4byte_float_(
false)
672 count_distinct_desc.device_type = ref_count_distinct_desc.device_type;
673 if (ref_count_distinct_desc != count_distinct_desc) {
695 const Executor* executor,
700 const int64_t num_rows,
701 const std::vector<std::vector<const int8_t*>>& col_buffers,
702 const std::vector<std::vector<uint64_t>>& frag_offsets,
703 std::shared_ptr<RowSetMemoryOwner> row_set_mem_owner,
704 const bool output_columnar,
706 const size_t thread_idx,
709 if (frag_offsets.empty()) {
712 return std::unique_ptr<QueryExecutionContext>(
732 const std::vector<InputTableInfo>& query_infos,
733 const int8_t crt_min_byte_width) {
735 return sizeof(int64_t);
737 int8_t compact_width{0};
740 int unnest_array_col_id{std::numeric_limits<int>::min()};
743 if (uoper && uoper->get_optype() ==
kUNNEST) {
745 CHECK(arg_ti.is_array());
746 const auto& elem_ti = arg_ti.get_elem_type();
747 if (elem_ti.is_string() && elem_ti.get_compression() ==
kENCODING_DICT) {
748 unnest_array_col_id = (*col_it)->getColId();
750 compact_width = crt_min_byte_width;
758 if (!compact_width &&
760 compact_width = crt_min_byte_width;
762 if (!compact_width) {
766 const auto& ti = target->get_type_info();
768 if (agg && agg->get_arg()) {
769 compact_width = crt_min_byte_width;
775 CHECK(!agg->get_is_distinct());
791 if (uoper && uoper->get_optype() ==
kUNNEST &&
792 (*col_it)->getColId() == unnest_array_col_id) {
794 CHECK(arg_ti.is_array());
795 const auto& elem_ti = arg_ti.get_elem_type();
796 if (elem_ti.is_string() && elem_ti.get_compression() ==
kENCODING_DICT) {
804 compact_width = crt_min_byte_width;
808 if (!compact_width) {
809 size_t total_tuples{0};
810 for (
const auto& qi : query_infos) {
811 total_tuples += qi.info.getNumTuples();
813 return total_tuples <= static_cast<size_t>(std::numeric_limits<uint32_t>::max()) ||
814 unnest_array_col_id != std::numeric_limits<int>::min()
816 : crt_min_byte_width;
820 compact_width = std::max(compact_width, wid);
822 return compact_width;
832 size_t total_bytes{0};
867 const size_t num_entries_per_column)
const {
881 const size_t projection_count)
const {
882 constexpr
size_t row_index_width =
sizeof(int64_t);
884 row_index_width * projection_count;
909 for (
size_t index = 0; index < col_idx; ++index) {
911 if (column_width > 0) {
920 for (
size_t index = 0; index < col_idx; ++index) {
952 const size_t group_idx)
const {
956 for (
size_t col_idx = 0; col_idx < group_idx; col_idx++) {
959 std::max(
groupColWidth(col_idx), static_cast<int8_t>(
sizeof(int64_t))) *
971 size_t buffer_size{0};
974 std::max(
groupColWidth(group_idx), static_cast<int8_t>(
sizeof(int64_t))) *
993 const size_t col_idx)
const {
999 if (col_idx + 1 == total_slot_count) {
1003 return static_cast<size_t>(
align_to_int64(col_ptr + chosen_bytes) - col_ptr);
1014 offset += bin * (next_chosen_bytes - chosen_bytes);
1018 if (next_chosen_bytes ==
sizeof(int64_t)) {
1019 return static_cast<size_t>(
align_to_int64(col_ptr + chosen_bytes) - col_ptr);
1021 return chosen_bytes;
1026 const size_t col_idx)
const {
1029 if (col_idx + 1 == total_slot_count) {
1030 return static_cast<size_t>(
align_to_int64(col_ptr + chosen_bytes) - col_ptr);
1035 if (next_chosen_bytes ==
sizeof(int64_t)) {
1036 return static_cast<size_t>(
align_to_int64(col_ptr + chosen_bytes) - col_ptr);
1038 return chosen_bytes;
1044 const unsigned thread_count,
1067 const size_t entry_count)
const {
1074 constexpr
size_t row_index_width =
sizeof(int64_t);
1075 size_t total_bytes{0};
1123 return total_slot_count;
1127 [](
const int64_t i) {
return i >= 0; });
1171 return executor_->cudaMgr()->isArchVoltaOrGreaterForAll();
1189 const int8_t bytes) {
1194 const size_t slot_idx)
const {
1199 const size_t col_idx)
const {
1201 CHECK_EQ(col_slots.size(), size_t(1));
1202 return col_slots.front();
1215 const int8_t actual_min_byte_width)
const {
1220 const std::vector<std::tuple<int8_t, int8_t>>& slots_for_col) {
1245 return "Perfect Hash";
1247 return "Baseline Hash";
1249 return "Projection";
1251 return "Table Function";
1253 return "Non-grouped Aggregate";
1279 auto const allow_lazy_fetch =
executor_->plan_state_
1280 ?
executor_->plan_state_->allow_lazy_fetch_
1282 str +=
"\tAllow Lazy Fetch: " +
::toString(allow_lazy_fetch) +
"\n";
1290 str +=
"Query Memory Descriptor State\n";
1300 if (group_indices_size) {
1301 std::vector<std::string> group_indices_strings;
1302 for (
size_t target_idx = 0; target_idx < group_indices_size; ++target_idx) {
1305 str +=
"\tTarget group by indices: " +
1313 const std::vector<Analyzer::Expr*>& targets,
1315 std::vector<TargetInfo> target_infos;
1317 for (
const auto target_expr : targets) {
1322 target.sql_type.set_notnull(
false);
1324 if (target.sql_type.supportsFlatBuffer()) {
1325 target.sql_type.setUsesFlatBuffer(
1328 target_infos.push_back(target);
1331 return target_infos;
1335 int64_t buffer_element_size{0};
1339 if (slot_element_size < 0) {
1340 return std::nullopt;
1342 buffer_element_size += slot_element_size;
1347 return buffer_element_size;
1351 int64_t buffer_element_size{0};
1353 for (
size_t i = 0; i < slot_idx; i++) {
1356 if (slot_element_size < 0) {
1359 buffer_element_size += slot_element_size;
1364 return buffer_element_size;
1370 auto by_cardinality = [](
auto&
a,
auto& b) {
return a.second < b.second; };
1371 auto itr = std::max_element(pdc.begin(), pdc.end(), by_cardinality);
1372 if (itr != pdc.end() && itr->second > 0) {
1375 return std::nullopt;
1385 auto is_left_join = [](
auto& join_qual) {
return join_qual.type ==
JoinType::LEFT; };
1387 return !
std::any_of(join_quals.begin(), join_quals.end(), is_left_join);
size_t varlenOutputRowSizeToSlot(const size_t slot_idx) const
int8_t getMinPaddedByteSize(const int8_t actual_min_byte_width) const
std::vector< Analyzer::Expr * > target_exprs
static bool many_entries(const int64_t max_val, const int64_t min_val, const int64_t bucket)
void addColSlotInfoFlatBuffer(const int64_t flatbuffer_size)
int64_t getIntMin() const
ColSlotContext col_slot_context_
size_t getSlotCount() const
bool canUsePerDeviceCardinality(const RelAlgExecutionUnit &ra_exe_unit) const
size_t getBufferSizeBytes(const RelAlgExecutionUnit &ra_exe_unit, const unsigned thread_count, const ExecutorDeviceType device_type) const
bool g_enable_smem_group_by
static int64_t getBucketedCardinality(const ColRangeInfo &col_range_info)
size_t getEntryCount() const
void alignPaddedSlots(const bool sort_on_gpu)
const Executor * executor_
std::vector< int64_t > target_expr_proj_indices(const RelAlgExecutionUnit &ra_exe_unit)
size_t getTotalBytesOfColumnarProjections(const size_t projection_count) const
int32_t idx_target_as_key_
int64_t getTargetGroupbyIndex(const size_t target_idx) const
void sort_on_gpu(int64_t *val_buff, int32_t *idx_buff, const uint64_t entry_count, const bool desc, const uint32_t chosen_bytes, ThrustAllocator &alloc, const int device_id)
std::string toString() const
bool isLogicalSizedColumnsAllowed() const
void setPaddedSlotWidthBytes(const size_t slot_idx, const int8_t bytes)
std::vector< int8_t > get_col_byte_widths(const T &col_expr_list)
int8_t pick_baseline_key_component_width(const ExpressionRange &range, const size_t group_col_width)
std::vector< InputDescriptor > input_descs
void setOutputColumnar(const bool val)
size_t getColCount() const
size_t getAllSlotsPaddedSize() const
bool threads_can_reuse_group_by_buffers_
static std::unique_ptr< QueryMemoryDescriptor > init(const Executor *executor, const RelAlgExecutionUnit &ra_exe_unit, const std::vector< InputTableInfo > &query_infos, const ColRangeInfo &col_range_info, const KeylessInfo &keyless_info, const bool allow_multifrag, const ExecutorDeviceType device_type, const int8_t crt_min_byte_width, const bool sort_on_gpu_hint, const size_t shard_count, const size_t max_groups_buffer_entry_count, RenderInfo *render_info, const CountDistinctDescriptors count_distinct_descriptors, const bool must_use_baseline_sort, const bool output_columnar_hint, const bool streaming_top_n_hint, const bool threads_can_reuse_group_by_buffers)
size_t getAllSlotsAlignedPaddedSize() const
size_t getNextColOffInBytes(const int8_t *col_ptr, const size_t bin, const size_t col_idx) const
size_t getEffectiveKeyWidth() const
bool use_streaming_top_n(const RelAlgExecutionUnit &ra_exe_unit, const bool output_columnar)
size_t g_streaming_topn_max
const std::list< std::shared_ptr< Analyzer::Expr > > groupby_exprs
T visit(const Analyzer::Expr *expr) const
void setAllSlotsSize(const int8_t slot_width_size)
TargetInfo get_target_info(const Analyzer::Expr *target_expr, const bool bigint_count)
size_t getWarpCount() const
std::optional< size_t > getMaxPerDeviceCardinality(const RelAlgExecutionUnit &ra_exe_unit) const
size_t getRowSize() const
void useConsistentSlotWidthSize(const int8_t slot_width_size)
const SlotSize & getSlotInfo(const size_t slot_idx) const
std::vector< Analyzer::Expr * > target_exprs_union
size_t getColOnlyOffInBytes(const size_t col_idx) const
size_t getColOnlyOffInBytes(const size_t slot_idx) const
const SQLTypeInfo get_compact_type(const TargetInfo &target)
bool is_varlen_projection(const Analyzer::Expr *target_expr, const SQLTypeInfo &ti)
bool blocksShareMemory() const
bool g_enable_columnar_output
int8_t groupColWidth(const size_t key_idx) const
std::vector< std::pair< std::vector< size_t >, size_t > > per_device_cardinality
size_t get_bit_width(const SQLTypeInfo &ti)
size_t getCompactByteWidth() const
void addColumnFlatBuffer(const int64_t flatbuffer_size)
std::vector< CountDistinctDescriptor > CountDistinctDescriptors
size_t getCompactByteWidth() const
Provides column info and slot info for the output buffer and some metadata helpers.
size_t getGroupbyColCount() const
const ColumnDescriptor * get_column_descriptor_maybe(const shared::ColumnKey &column_key)
const JoinQualsPerNestingLevel join_quals
bool lazyInitGroups(const ExecutorDeviceType) const
size_t targetGroupbyIndicesSize() const
std::optional< size_t > limit
size_t getPrependedGroupBufferSizeInBytes() const
std::list< Analyzer::OrderEntry > order_entries
size_t getTotalBytesOfColumnarBuffers() const
std::vector< int64_t > target_groupby_indices_
static int8_t pick_target_compact_width(const RelAlgExecutionUnit &ra_exe_unit, const std::vector< InputTableInfo > &query_infos, const int8_t crt_min_byte_width)
CountDistinctDescriptors count_distinct_descriptors_
int32_t get_varno() const
bool is_valid_int32_range(const ExpressionRange &range)
bool interleaved_bins_on_gpu_
const int8_t getPaddedSlotWidthBytes(const size_t slot_idx) const
ExpressionRange getExpressionRange(const Analyzer::BinOper *expr, const std::vector< InputTableInfo > &query_infos, const Executor *, boost::optional< std::list< std::shared_ptr< Analyzer::Expr >>> simple_quals)
int64_t varlenOutputElementSize(const size_t slot_idx) const
int64_t getPaddedSlotBufferSize(const size_t slot_idx) const
const SQLTypeInfo & get_type_info() const
QueryDescriptionType getQueryDescriptionType() const
std::vector< int64_t > target_expr_group_by_indices(const std::list< std::shared_ptr< Analyzer::Expr >> &groupby_exprs, const std::vector< Analyzer::Expr * > &target_exprs)
std::optional< size_t > varlenOutputBufferElemSize() const
void addColumn(const std::vector< std::tuple< int8_t, int8_t >> &slots_for_col)
size_t getNextColOffInBytesRowOnly(const int8_t *col_ptr, const size_t col_idx) const
const Expr * get_operand() const
QueryDescriptionType query_desc_type_
int8_t group_col_compact_width_
int8_t updateActualMinByteWidth(const int8_t actual_min_byte_width) const
size_t getTotalBytesOfColumnarBuffers(const size_t entry_count) const
bool operator==(const QueryMemoryDescriptor &other) const
Descriptor for the result set buffer layout.
size_t getColsSize() const
bool is_int_and_no_bigger_than(const SQLTypeInfo &ti, const size_t byte_width)
std::list< std::shared_ptr< Analyzer::Expr > > quals
bool canOutputColumnar() const
ExpressionRangeType getType() const
size_t get_heap_size(const size_t row_size, const size_t n, const size_t thread_count)
bool usesGetGroupValueFast() const
int64_t getIntMax() const
bool isWarpSyncRequired(const ExecutorDeviceType) const
std::string toString() const
size_t getSlotCount() const
void setAllSlotsPaddedSizeToLogicalSize()
bool interleavedBins(const ExecutorDeviceType) const
bool g_enable_watchdog false
bool threadsShareMemory() const
#define DEBUG_TIMER(name)
size_t getColCount() const
std::vector< int8_t > group_col_widths_
size_t getRowWidth() const
void setPaddedSlotWidthBytes(const size_t slot_idx, const int8_t bytes)
std::vector< TargetInfo > target_exprs_to_infos(const std::vector< Analyzer::Expr * > &targets, const QueryMemoryDescriptor &query_mem_desc)
const std::vector< size_t > & getSlotsForCol(const size_t col_idx) const
bool must_use_baseline_sort_
std::string queryDescTypeToString() const
bool any_of(std::vector< Analyzer::Expr * > const &target_exprs)
std::list< std::shared_ptr< const InputColDescriptor > > input_col_descs
void addColSlotInfo(const std::vector< std::tuple< int8_t, int8_t >> &slots_for_col)
bool use_streaming_top_n_
static bool countDescriptorsLogicallyEmpty(const CountDistinctDescriptors &count_distinct_descriptors)
void setAllUnsetSlotsPaddedSize(const int8_t padded_size)
int64_t getFlatBufferSize(const size_t slot_idx) const
const int8_t getSlotIndexForSingleSlotCol(const size_t col_idx) const
bool checkSlotUsesFlatBufferFormat(const size_t slot_idx) const
size_t getBufferColSlotCount() const
const int8_t getLogicalSlotWidthBytes(const size_t slot_idx) const
size_t getColOffInBytes(const size_t col_idx) const
size_t getColOffInBytesInNextBin(const size_t col_idx) const
std::unique_ptr< QueryExecutionContext > getQueryExecutionContext(const RelAlgExecutionUnit &, const Executor *executor, const ExecutorDeviceType device_type, const ExecutorDispatchMode dispatch_mode, const int device_id, const shared::TableKey &outer_table_key, const int64_t num_rows, const std::vector< std::vector< const int8_t * >> &col_buffers, const std::vector< std::vector< uint64_t >> &frag_offsets, std::shared_ptr< RowSetMemoryOwner >, const bool output_columnar, const bool sort_on_gpu, const size_t thread_idx, RenderInfo *) const
friend class QueryExecutionContext
FORCE_INLINE HOST DEVICE T align_to_int64(T addr)
int8_t pick_baseline_key_width(const RelAlgExecutionUnit &ra_exe_unit, const std::vector< InputTableInfo > &query_infos, const Executor *executor)
std::string reductionKey() const
std::list< std::shared_ptr< Analyzer::Expr > > simple_quals
void set_notnull(TargetInfo &target, const bool not_null)
int32_t getTargetIdxForKey() const
size_t getPrependedGroupColOffInBytes(const size_t group_idx) const