OmniSciDB  c0231cc57d
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
TargetExprCodegenBuilder Struct Reference

#include <TargetExprBuilder.h>

+ Collaboration diagram for TargetExprCodegenBuilder:

Public Member Functions

 TargetExprCodegenBuilder (const RelAlgExecutionUnit &ra_exe_unit, const bool is_group_by)
 
void operator() (const Analyzer::Expr *target_expr, const Executor *executor, QueryMemoryDescriptor &query_mem_desc, const CompilationOptions &co)
 
void codegen (GroupByAndAggregate *group_by_and_agg, Executor *executor, const QueryMemoryDescriptor &query_mem_desc, const CompilationOptions &co, const GpuSharedMemoryContext &gpu_smem_context, const std::tuple< llvm::Value *, llvm::Value * > &agg_out_ptr_w_idx, const std::vector< llvm::Value * > &agg_out_vec, llvm::Value *output_buffer_byte_stream, llvm::Value *out_row_idx, llvm::Value *varlen_output_buffer, DiamondCodegen &diamond_codegen) const
 
void codegenSampleExpressions (GroupByAndAggregate *group_by_and_agg, Executor *executor, const QueryMemoryDescriptor &query_mem_desc, const CompilationOptions &co, const std::tuple< llvm::Value *, llvm::Value * > &agg_out_ptr_w_idx, const std::vector< llvm::Value * > &agg_out_vec, llvm::Value *output_buffer_byte_stream, llvm::Value *out_row_idx, DiamondCodegen &diamond_codegen) const
 
void codegenSingleSlotSampleExpression (GroupByAndAggregate *group_by_and_agg, Executor *executor, const QueryMemoryDescriptor &query_mem_desc, const CompilationOptions &co, const std::tuple< llvm::Value *, llvm::Value * > &agg_out_ptr_w_idx, const std::vector< llvm::Value * > &agg_out_vec, llvm::Value *output_buffer_byte_stream, llvm::Value *out_row_idx, DiamondCodegen &diamond_codegen) const
 
void codegenMultiSlotSampleExpressions (GroupByAndAggregate *group_by_and_agg, Executor *executor, const QueryMemoryDescriptor &query_mem_desc, const CompilationOptions &co, const std::tuple< llvm::Value *, llvm::Value * > &agg_out_ptr_w_idx, const std::vector< llvm::Value * > &agg_out_vec, llvm::Value *output_buffer_byte_stream, llvm::Value *out_row_idx, DiamondCodegen &diamond_codegen) const
 
llvm::Value * codegenSlotEmptyKey (llvm::Value *agg_col_ptr, std::vector< llvm::Value * > &target_lvs, Executor *executor, const QueryMemoryDescriptor &query_mem_desc, const int64_t init_val) const
 

Public Attributes

size_t target_index_counter {0}
 
size_t slot_index_counter {0}
 
const RelAlgExecutionUnitra_exe_unit
 
std::vector< TargetExprCodegentarget_exprs_to_codegen
 
std::vector< TargetExprCodegensample_exprs_to_codegen
 
bool is_group_by
 

Detailed Description

Definition at line 78 of file TargetExprBuilder.h.

Constructor & Destructor Documentation

TargetExprCodegenBuilder::TargetExprCodegenBuilder ( const RelAlgExecutionUnit ra_exe_unit,
const bool  is_group_by 
)
inline

Definition at line 79 of file TargetExprBuilder.h.

80  : ra_exe_unit(ra_exe_unit), is_group_by(is_group_by) {}
const RelAlgExecutionUnit & ra_exe_unit

Member Function Documentation

void TargetExprCodegenBuilder::codegen ( GroupByAndAggregate group_by_and_agg,
Executor executor,
const QueryMemoryDescriptor query_mem_desc,
const CompilationOptions co,
const GpuSharedMemoryContext gpu_smem_context,
const std::tuple< llvm::Value *, llvm::Value * > &  agg_out_ptr_w_idx,
const std::vector< llvm::Value * > &  agg_out_vec,
llvm::Value *  output_buffer_byte_stream,
llvm::Value *  out_row_idx,
llvm::Value *  varlen_output_buffer,
DiamondCodegen diamond_codegen 
) const

Definition at line 718 of file TargetExprBuilder.cpp.

References AUTOMATIC_IR_METADATA, and CHECK.

Referenced by GroupByAndAggregate::codegenAggCalls().

729  {
730  CHECK(group_by_and_agg);
731  CHECK(executor);
732  AUTOMATIC_IR_METADATA(executor->cgen_state_.get());
733 
734  for (const auto& target_expr_codegen : target_exprs_to_codegen) {
735  target_expr_codegen.codegen(group_by_and_agg,
736  executor,
737  query_mem_desc,
738  co,
739  gpu_smem_context,
740  agg_out_ptr_w_idx,
741  agg_out_vec,
742  output_buffer_byte_stream,
743  out_row_idx,
744  varlen_output_buffer,
745  diamond_codegen);
746  }
747  if (!sample_exprs_to_codegen.empty()) {
748  codegenSampleExpressions(group_by_and_agg,
749  executor,
750  query_mem_desc,
751  co,
752  agg_out_ptr_w_idx,
753  agg_out_vec,
754  output_buffer_byte_stream,
755  out_row_idx,
756  diamond_codegen);
757  }
758 }
std::vector< TargetExprCodegen > target_exprs_to_codegen
void codegenSampleExpressions(GroupByAndAggregate *group_by_and_agg, Executor *executor, const QueryMemoryDescriptor &query_mem_desc, const CompilationOptions &co, const std::tuple< llvm::Value *, llvm::Value * > &agg_out_ptr_w_idx, const std::vector< llvm::Value * > &agg_out_vec, llvm::Value *output_buffer_byte_stream, llvm::Value *out_row_idx, DiamondCodegen &diamond_codegen) const
std::vector< TargetExprCodegen > sample_exprs_to_codegen
#define AUTOMATIC_IR_METADATA(CGENSTATE)
#define CHECK(condition)
Definition: Logger.h:222

+ Here is the caller graph for this function:

void TargetExprCodegenBuilder::codegenMultiSlotSampleExpressions ( GroupByAndAggregate group_by_and_agg,
Executor executor,
const QueryMemoryDescriptor query_mem_desc,
const CompilationOptions co,
const std::tuple< llvm::Value *, llvm::Value * > &  agg_out_ptr_w_idx,
const std::vector< llvm::Value * > &  agg_out_vec,
llvm::Value *  output_buffer_byte_stream,
llvm::Value *  out_row_idx,
DiamondCodegen diamond_codegen 
) const

Definition at line 825 of file TargetExprBuilder.cpp.

References AUTOMATIC_IR_METADATA, CHECK, CHECK_GE, CHECK_LT, GroupByAndAggregate::codegenAggArg(), GroupByAndAggregate::codegenAggColumnPtr(), CompilationOptions::device_type, anonymous_namespace{TargetExprBuilder.cpp}::get_initial_agg_val(), GPU, TargetExprCodegen::is_group_by, and QueryMemoryDescriptor::isLogicalSizedColumnsAllowed().

834  {
835  AUTOMATIC_IR_METADATA(executor->cgen_state_.get());
836  CHECK(sample_exprs_to_codegen.size() > 1 ||
837  sample_exprs_to_codegen.front().target_info.sql_type.is_varlen());
839  const auto& first_sample_expr = sample_exprs_to_codegen.front();
840  auto target_lvs = group_by_and_agg->codegenAggArg(first_sample_expr.target_expr, co);
841  CHECK_GE(target_lvs.size(), size_t(1));
842 
843  const auto init_val =
844  get_initial_agg_val(first_sample_expr.target_info, query_mem_desc);
845 
846  llvm::Value* agg_col_ptr{nullptr};
847  if (is_group_by) {
848  const auto agg_column_size_bytes =
849  query_mem_desc.isLogicalSizedColumnsAllowed() &&
850  !first_sample_expr.target_info.sql_type.is_varlen()
851  ? first_sample_expr.target_info.sql_type.get_size()
852  : sizeof(int64_t);
853  agg_col_ptr = group_by_and_agg->codegenAggColumnPtr(output_buffer_byte_stream,
854  out_row_idx,
855  agg_out_ptr_w_idx,
856  query_mem_desc,
857  agg_column_size_bytes,
858  first_sample_expr.base_slot_index,
859  first_sample_expr.target_idx);
860  } else {
861  CHECK_LT(static_cast<size_t>(first_sample_expr.base_slot_index), agg_out_vec.size());
862  agg_col_ptr =
863  executor->castToIntPtrTyIn(agg_out_vec[first_sample_expr.base_slot_index], 64);
864  }
865 
866  auto sample_cas_lv =
867  codegenSlotEmptyKey(agg_col_ptr, target_lvs, executor, query_mem_desc, init_val);
868 
869  DiamondCodegen sample_cfg(
870  sample_cas_lv, executor, false, "sample_valcheck", &diamond_codegen, false);
871 
872  for (const auto& target_expr_codegen : sample_exprs_to_codegen) {
873  target_expr_codegen.codegen(group_by_and_agg,
874  executor,
875  query_mem_desc,
876  co,
877  {},
878  agg_out_ptr_w_idx,
879  agg_out_vec,
880  output_buffer_byte_stream,
881  out_row_idx,
882  /*varlen_output_buffer=*/nullptr,
883  diamond_codegen,
884  &sample_cfg);
885  }
886 }
llvm::Value * codegenAggColumnPtr(llvm::Value *output_buffer_byte_stream, llvm::Value *out_row_idx, const std::tuple< llvm::Value *, llvm::Value * > &agg_out_ptr_w_idx, const QueryMemoryDescriptor &query_mem_desc, const size_t chosen_bytes, const size_t agg_out_off, const size_t target_idx)
: returns the pointer to where the aggregation should be stored.
bool isLogicalSizedColumnsAllowed() const
#define CHECK_GE(x, y)
Definition: Logger.h:235
std::vector< TargetExprCodegen > sample_exprs_to_codegen
#define AUTOMATIC_IR_METADATA(CGENSTATE)
ExecutorDeviceType device_type
#define CHECK_LT(x, y)
Definition: Logger.h:232
llvm::Value * codegenSlotEmptyKey(llvm::Value *agg_col_ptr, std::vector< llvm::Value * > &target_lvs, Executor *executor, const QueryMemoryDescriptor &query_mem_desc, const int64_t init_val) const
std::vector< llvm::Value * > codegenAggArg(const Analyzer::Expr *target_expr, const CompilationOptions &co)
#define CHECK(condition)
Definition: Logger.h:222
int64_t get_initial_agg_val(const TargetInfo &target_info, const QueryMemoryDescriptor &query_mem_desc)

+ Here is the call graph for this function:

void TargetExprCodegenBuilder::codegenSampleExpressions ( GroupByAndAggregate group_by_and_agg,
Executor executor,
const QueryMemoryDescriptor query_mem_desc,
const CompilationOptions co,
const std::tuple< llvm::Value *, llvm::Value * > &  agg_out_ptr_w_idx,
const std::vector< llvm::Value * > &  agg_out_vec,
llvm::Value *  output_buffer_byte_stream,
llvm::Value *  out_row_idx,
DiamondCodegen diamond_codegen 
) const

Definition at line 760 of file TargetExprBuilder.cpp.

References AUTOMATIC_IR_METADATA, CHECK, CompilationOptions::device_type, and GPU.

769  {
770  AUTOMATIC_IR_METADATA(executor->cgen_state_.get());
771  CHECK(!sample_exprs_to_codegen.empty());
773  if (sample_exprs_to_codegen.size() == 1 &&
774  !sample_exprs_to_codegen.front().target_info.sql_type.is_varlen()) {
775  codegenSingleSlotSampleExpression(group_by_and_agg,
776  executor,
777  query_mem_desc,
778  co,
779  agg_out_ptr_w_idx,
780  agg_out_vec,
781  output_buffer_byte_stream,
782  out_row_idx,
783  diamond_codegen);
784  } else {
785  codegenMultiSlotSampleExpressions(group_by_and_agg,
786  executor,
787  query_mem_desc,
788  co,
789  agg_out_ptr_w_idx,
790  agg_out_vec,
791  output_buffer_byte_stream,
792  out_row_idx,
793  diamond_codegen);
794  }
795 }
void codegenMultiSlotSampleExpressions(GroupByAndAggregate *group_by_and_agg, Executor *executor, const QueryMemoryDescriptor &query_mem_desc, const CompilationOptions &co, const std::tuple< llvm::Value *, llvm::Value * > &agg_out_ptr_w_idx, const std::vector< llvm::Value * > &agg_out_vec, llvm::Value *output_buffer_byte_stream, llvm::Value *out_row_idx, DiamondCodegen &diamond_codegen) const
std::vector< TargetExprCodegen > sample_exprs_to_codegen
#define AUTOMATIC_IR_METADATA(CGENSTATE)
ExecutorDeviceType device_type
#define CHECK(condition)
Definition: Logger.h:222
void codegenSingleSlotSampleExpression(GroupByAndAggregate *group_by_and_agg, Executor *executor, const QueryMemoryDescriptor &query_mem_desc, const CompilationOptions &co, const std::tuple< llvm::Value *, llvm::Value * > &agg_out_ptr_w_idx, const std::vector< llvm::Value * > &agg_out_vec, llvm::Value *output_buffer_byte_stream, llvm::Value *out_row_idx, DiamondCodegen &diamond_codegen) const
void TargetExprCodegenBuilder::codegenSingleSlotSampleExpression ( GroupByAndAggregate group_by_and_agg,
Executor executor,
const QueryMemoryDescriptor query_mem_desc,
const CompilationOptions co,
const std::tuple< llvm::Value *, llvm::Value * > &  agg_out_ptr_w_idx,
const std::vector< llvm::Value * > &  agg_out_vec,
llvm::Value *  output_buffer_byte_stream,
llvm::Value *  out_row_idx,
DiamondCodegen diamond_codegen 
) const

Definition at line 797 of file TargetExprBuilder.cpp.

References AUTOMATIC_IR_METADATA, CHECK, CHECK_EQ, CompilationOptions::device_type, and GPU.

806  {
807  AUTOMATIC_IR_METADATA(executor->cgen_state_.get());
808  CHECK_EQ(size_t(1), sample_exprs_to_codegen.size());
809  CHECK(!sample_exprs_to_codegen.front().target_info.sql_type.is_varlen());
811  // no need for the atomic if we only have one SAMPLE target
812  sample_exprs_to_codegen.front().codegen(group_by_and_agg,
813  executor,
814  query_mem_desc,
815  co,
816  {},
817  agg_out_ptr_w_idx,
818  agg_out_vec,
819  output_buffer_byte_stream,
820  out_row_idx,
821  /*varlen_output_buffer=*/nullptr,
822  diamond_codegen);
823 }
#define CHECK_EQ(x, y)
Definition: Logger.h:230
std::vector< TargetExprCodegen > sample_exprs_to_codegen
#define AUTOMATIC_IR_METADATA(CGENSTATE)
ExecutorDeviceType device_type
#define CHECK(condition)
Definition: Logger.h:222
llvm::Value * TargetExprCodegenBuilder::codegenSlotEmptyKey ( llvm::Value *  agg_col_ptr,
std::vector< llvm::Value * > &  target_lvs,
Executor executor,
const QueryMemoryDescriptor query_mem_desc,
const int64_t  init_val 
) const

Definition at line 888 of file TargetExprBuilder.cpp.

References AUTOMATIC_IR_METADATA, CHECK_EQ, get_int_type(), QueryMemoryDescriptor::isLogicalSizedColumnsAllowed(), LL_BUILDER, LL_CONTEXT, LL_INT, and UNREACHABLE.

893  {
894  AUTOMATIC_IR_METADATA(executor->cgen_state_.get());
895  const auto& first_sample_expr = sample_exprs_to_codegen.front();
896  const auto first_sample_slot_bytes =
897  first_sample_expr.target_info.sql_type.is_varlen()
898  ? sizeof(int64_t)
899  : first_sample_expr.target_info.sql_type.get_size();
900  llvm::Value* target_lv_casted{nullptr};
901  // deciding whether proper casting is required for the first sample's slot:
902  if (first_sample_expr.target_info.sql_type.is_varlen()) {
903  target_lv_casted =
904  LL_BUILDER.CreatePtrToInt(target_lvs.front(), llvm::Type::getInt64Ty(LL_CONTEXT));
905  } else if (first_sample_expr.target_info.sql_type.is_fp()) {
906  // Initialization value for SAMPLE on a float column should be 0
907  CHECK_EQ(init_val, 0);
908  if (query_mem_desc.isLogicalSizedColumnsAllowed()) {
909  target_lv_casted = executor->cgen_state_->ir_builder_.CreateFPToSI(
910  target_lvs.front(),
911  first_sample_slot_bytes == sizeof(float) ? llvm::Type::getInt32Ty(LL_CONTEXT)
912  : llvm::Type::getInt64Ty(LL_CONTEXT));
913  } else {
914  target_lv_casted = executor->cgen_state_->ir_builder_.CreateFPToSI(
915  target_lvs.front(), llvm::Type::getInt64Ty(LL_CONTEXT));
916  }
917  } else if (first_sample_slot_bytes != sizeof(int64_t) &&
918  !query_mem_desc.isLogicalSizedColumnsAllowed()) {
919  target_lv_casted =
920  executor->cgen_state_->ir_builder_.CreateCast(llvm::Instruction::CastOps::SExt,
921  target_lvs.front(),
922  llvm::Type::getInt64Ty(LL_CONTEXT));
923  } else {
924  target_lv_casted = target_lvs.front();
925  }
926 
927  std::string slot_empty_cas_func_name("slotEmptyKeyCAS");
928  llvm::Value* init_val_lv{LL_INT(init_val)};
929  if (query_mem_desc.isLogicalSizedColumnsAllowed() &&
930  !first_sample_expr.target_info.sql_type.is_varlen()) {
931  // add proper suffix to the function name:
932  switch (first_sample_slot_bytes) {
933  case 1:
934  slot_empty_cas_func_name += "_int8";
935  break;
936  case 2:
937  slot_empty_cas_func_name += "_int16";
938  break;
939  case 4:
940  slot_empty_cas_func_name += "_int32";
941  break;
942  case 8:
943  break;
944  default:
945  UNREACHABLE() << "Invalid slot size for slotEmptyKeyCAS function.";
946  break;
947  }
948  if (first_sample_slot_bytes != sizeof(int64_t)) {
949  init_val_lv = llvm::ConstantInt::get(
950  get_int_type(first_sample_slot_bytes * 8, LL_CONTEXT), init_val);
951  }
952  }
953 
954  auto sample_cas_lv = executor->cgen_state_->emitExternalCall(
955  slot_empty_cas_func_name,
956  llvm::Type::getInt1Ty(executor->cgen_state_->context_),
957  {agg_col_ptr, target_lv_casted, init_val_lv});
958  return sample_cas_lv;
959 }
#define LL_BUILDER
#define CHECK_EQ(x, y)
Definition: Logger.h:230
bool isLogicalSizedColumnsAllowed() const
#define UNREACHABLE()
Definition: Logger.h:266
llvm::Type * get_int_type(const int width, llvm::LLVMContext &context)
#define LL_INT(v)
std::vector< TargetExprCodegen > sample_exprs_to_codegen
#define LL_CONTEXT
#define AUTOMATIC_IR_METADATA(CGENSTATE)

+ Here is the call graph for this function:

void TargetExprCodegenBuilder::operator() ( const Analyzer::Expr target_expr,
const Executor executor,
QueryMemoryDescriptor query_mem_desc,
const CompilationOptions co 
)

Definition at line 629 of file TargetExprBuilder.cpp.

References agg_arg(), anonymous_namespace{TargetExprBuilder.cpp}::agg_fn_base_names(), TargetInfo::agg_kind, AUTOMATIC_IR_METADATA, CHECK, CHECK_EQ, constrained_not_null(), CompilationOptions::device_type, g_bigint_count, get_target_info(), QueryMemoryDescriptor::getPaddedSlotWidthBytes(), QueryMemoryDescriptor::getQueryDescriptionType(), GPU, TargetInfo::is_agg, anonymous_namespace{TargetExprBuilder.cpp}::is_columnar_projection(), TargetExprCodegen::is_group_by, anonymous_namespace{TargetExprBuilder.cpp}::is_varlen_projection(), kAPPROX_QUANTILE, kSAMPLE, kSINGLE_VALUE, kUNNEST, NonGroupedAggregate, QueryMemoryDescriptor::setPaddedSlotWidthBytes(), TargetInfo::skip_null_val, TargetInfo::sql_type, and TargetExprCodegen::target_info.

632  {
633  AUTOMATIC_IR_METADATA(executor->cgen_state_.get());
634  if (query_mem_desc.getPaddedSlotWidthBytes(slot_index_counter) == 0) {
635  CHECK(!dynamic_cast<const Analyzer::AggExpr*>(target_expr));
638  return;
639  }
640  if (dynamic_cast<const Analyzer::UOper*>(target_expr) &&
641  static_cast<const Analyzer::UOper*>(target_expr)->get_optype() == kUNNEST) {
642  throw std::runtime_error("UNNEST not supported in the projection list yet.");
643  }
644  if ((executor->plan_state_->isLazyFetchColumn(target_expr) || !is_group_by) &&
645  (static_cast<size_t>(query_mem_desc.getPaddedSlotWidthBytes(slot_index_counter)) <
646  sizeof(int64_t)) &&
647  !is_columnar_projection(query_mem_desc)) {
648  // TODO(miyu): enable different byte width in the layout w/o padding
650  }
651 
652  if (is_columnar_projection(query_mem_desc) &&
653  executor->plan_state_->isLazyFetchColumn(target_expr)) {
654  // For columnar outputs, we need to pad lazy fetched columns to 8 bytes to allow the
655  // lazy fetch index to be placed in the column. The QueryMemoryDescriptor is created
656  // before Lazy Fetch information is known, therefore we need to update the QMD with
657  // the new slot size width bytes for these columns.
658  query_mem_desc.setPaddedSlotWidthBytes(slot_index_counter, int8_t(8));
659  CHECK_EQ(query_mem_desc.getPaddedSlotWidthBytes(slot_index_counter), int8_t(8));
660  }
661 
662  auto target_info = get_target_info(target_expr, g_bigint_count);
663  auto arg_expr = agg_arg(target_expr);
664  if (arg_expr) {
665  if (target_info.agg_kind == kSINGLE_VALUE || target_info.agg_kind == kSAMPLE ||
666  target_info.agg_kind == kAPPROX_QUANTILE) {
667  target_info.skip_null_val = false;
668  } else if (query_mem_desc.getQueryDescriptionType() ==
670  !arg_expr->get_type_info().is_varlen()) {
671  // TODO: COUNT is currently not null-aware for varlen types. Need to add proper code
672  // generation for handling varlen nulls.
673  target_info.skip_null_val = true;
674  } else if (constrained_not_null(arg_expr, ra_exe_unit.quals)) {
675  target_info.skip_null_val = false;
676  }
677  }
678 
679  if (!(query_mem_desc.getQueryDescriptionType() ==
681  (co.device_type == ExecutorDeviceType::GPU) && target_info.is_agg &&
682  (target_info.agg_kind == kSAMPLE)) {
683  sample_exprs_to_codegen.emplace_back(target_expr,
684  target_info,
687  is_group_by);
688  } else {
689  target_exprs_to_codegen.emplace_back(target_expr,
690  target_info,
693  is_group_by);
694  }
695 
696  const auto agg_fn_names = agg_fn_base_names(
697  target_info, is_varlen_projection(target_expr, target_info.sql_type));
698  slot_index_counter += agg_fn_names.size();
699 }
const RelAlgExecutionUnit & ra_exe_unit
const Analyzer::Expr * agg_arg(const Analyzer::Expr *expr)
#define CHECK_EQ(x, y)
Definition: Logger.h:230
bool constrained_not_null(const Analyzer::Expr *expr, const std::list< std::shared_ptr< Analyzer::Expr >> &quals)
std::vector< std::string > agg_fn_base_names(const TargetInfo &target_info, const bool is_varlen_projection)
std::vector< TargetExprCodegen > target_exprs_to_codegen
TargetInfo get_target_info(const Analyzer::Expr *target_expr, const bool bigint_count)
Definition: TargetInfo.h:97
bool is_varlen_projection(const Analyzer::Expr *target_expr, const SQLTypeInfo &ti)
bool g_bigint_count
std::vector< TargetExprCodegen > sample_exprs_to_codegen
const int8_t getPaddedSlotWidthBytes(const size_t slot_idx) const
#define AUTOMATIC_IR_METADATA(CGENSTATE)
QueryDescriptionType getQueryDescriptionType() const
ExecutorDeviceType device_type
std::list< std::shared_ptr< Analyzer::Expr > > quals
#define CHECK(condition)
Definition: Logger.h:222
void setPaddedSlotWidthBytes(const size_t slot_idx, const int8_t bytes)
bool is_columnar_projection(const QueryMemoryDescriptor &query_mem_desc)

+ Here is the call graph for this function:

Member Data Documentation

bool TargetExprCodegenBuilder::is_group_by

Definition at line 146 of file TargetExprBuilder.h.

const RelAlgExecutionUnit& TargetExprCodegenBuilder::ra_exe_unit

Definition at line 141 of file TargetExprBuilder.h.

std::vector<TargetExprCodegen> TargetExprCodegenBuilder::sample_exprs_to_codegen

Definition at line 144 of file TargetExprBuilder.h.

size_t TargetExprCodegenBuilder::slot_index_counter {0}

Definition at line 139 of file TargetExprBuilder.h.

std::vector<TargetExprCodegen> TargetExprCodegenBuilder::target_exprs_to_codegen

Definition at line 143 of file TargetExprBuilder.h.

size_t TargetExprCodegenBuilder::target_index_counter {0}

Definition at line 138 of file TargetExprBuilder.h.


The documentation for this struct was generated from the following files: