OmniSciDB  a987f07e93
 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 735 of file TargetExprBuilder.cpp.

References AUTOMATIC_IR_METADATA, and CHECK.

Referenced by GroupByAndAggregate::codegenAggCalls().

746  {
747  CHECK(group_by_and_agg);
748  CHECK(executor);
749  AUTOMATIC_IR_METADATA(executor->cgen_state_.get());
750 
751  for (const auto& target_expr_codegen : target_exprs_to_codegen) {
752  target_expr_codegen.codegen(group_by_and_agg,
753  executor,
754  query_mem_desc,
755  co,
756  gpu_smem_context,
757  agg_out_ptr_w_idx,
758  agg_out_vec,
759  output_buffer_byte_stream,
760  out_row_idx,
761  varlen_output_buffer,
762  diamond_codegen);
763  }
764  if (!sample_exprs_to_codegen.empty()) {
765  codegenSampleExpressions(group_by_and_agg,
766  executor,
767  query_mem_desc,
768  co,
769  agg_out_ptr_w_idx,
770  agg_out_vec,
771  output_buffer_byte_stream,
772  out_row_idx,
773  diamond_codegen);
774  }
775 }
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:289

+ 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 842 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().

851  {
852  AUTOMATIC_IR_METADATA(executor->cgen_state_.get());
853  CHECK(sample_exprs_to_codegen.size() > 1 ||
854  sample_exprs_to_codegen.front().target_info.sql_type.is_varlen());
856  const auto& first_sample_expr = sample_exprs_to_codegen.front();
857  auto target_lvs = group_by_and_agg->codegenAggArg(first_sample_expr.target_expr, co);
858  CHECK_GE(target_lvs.size(), size_t(1));
859 
860  const auto init_val =
861  get_initial_agg_val(first_sample_expr.target_info, query_mem_desc);
862 
863  llvm::Value* agg_col_ptr{nullptr};
864  if (is_group_by) {
865  const auto agg_column_size_bytes =
866  query_mem_desc.isLogicalSizedColumnsAllowed() &&
867  !first_sample_expr.target_info.sql_type.is_varlen()
868  ? first_sample_expr.target_info.sql_type.get_size()
869  : sizeof(int64_t);
870  agg_col_ptr = group_by_and_agg->codegenAggColumnPtr(output_buffer_byte_stream,
871  out_row_idx,
872  agg_out_ptr_w_idx,
873  query_mem_desc,
874  agg_column_size_bytes,
875  first_sample_expr.base_slot_index,
876  first_sample_expr.target_idx);
877  } else {
878  CHECK_LT(static_cast<size_t>(first_sample_expr.base_slot_index), agg_out_vec.size());
879  agg_col_ptr =
880  executor->castToIntPtrTyIn(agg_out_vec[first_sample_expr.base_slot_index], 64);
881  }
882 
883  auto sample_cas_lv =
884  codegenSlotEmptyKey(agg_col_ptr, target_lvs, executor, query_mem_desc, init_val);
885 
886  DiamondCodegen sample_cfg(
887  sample_cas_lv, executor, false, "sample_valcheck", &diamond_codegen, false);
888 
889  for (const auto& target_expr_codegen : sample_exprs_to_codegen) {
890  target_expr_codegen.codegen(group_by_and_agg,
891  executor,
892  query_mem_desc,
893  co,
894  {},
895  agg_out_ptr_w_idx,
896  agg_out_vec,
897  output_buffer_byte_stream,
898  out_row_idx,
899  /*varlen_output_buffer=*/nullptr,
900  diamond_codegen,
901  &sample_cfg);
902  }
903 }
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:302
std::vector< TargetExprCodegen > sample_exprs_to_codegen
#define AUTOMATIC_IR_METADATA(CGENSTATE)
ExecutorDeviceType device_type
#define CHECK_LT(x, y)
Definition: Logger.h:299
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:289
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 777 of file TargetExprBuilder.cpp.

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

786  {
787  AUTOMATIC_IR_METADATA(executor->cgen_state_.get());
788  CHECK(!sample_exprs_to_codegen.empty());
790  if (sample_exprs_to_codegen.size() == 1 &&
791  !sample_exprs_to_codegen.front().target_info.sql_type.is_varlen()) {
792  codegenSingleSlotSampleExpression(group_by_and_agg,
793  executor,
794  query_mem_desc,
795  co,
796  agg_out_ptr_w_idx,
797  agg_out_vec,
798  output_buffer_byte_stream,
799  out_row_idx,
800  diamond_codegen);
801  } else {
802  codegenMultiSlotSampleExpressions(group_by_and_agg,
803  executor,
804  query_mem_desc,
805  co,
806  agg_out_ptr_w_idx,
807  agg_out_vec,
808  output_buffer_byte_stream,
809  out_row_idx,
810  diamond_codegen);
811  }
812 }
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:289
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 814 of file TargetExprBuilder.cpp.

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

823  {
824  AUTOMATIC_IR_METADATA(executor->cgen_state_.get());
825  CHECK_EQ(size_t(1), sample_exprs_to_codegen.size());
826  CHECK(!sample_exprs_to_codegen.front().target_info.sql_type.is_varlen());
828  // no need for the atomic if we only have one SAMPLE target
829  sample_exprs_to_codegen.front().codegen(group_by_and_agg,
830  executor,
831  query_mem_desc,
832  co,
833  {},
834  agg_out_ptr_w_idx,
835  agg_out_vec,
836  output_buffer_byte_stream,
837  out_row_idx,
838  /*varlen_output_buffer=*/nullptr,
839  diamond_codegen);
840 }
#define CHECK_EQ(x, y)
Definition: Logger.h:297
std::vector< TargetExprCodegen > sample_exprs_to_codegen
#define AUTOMATIC_IR_METADATA(CGENSTATE)
ExecutorDeviceType device_type
#define CHECK(condition)
Definition: Logger.h:289
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 905 of file TargetExprBuilder.cpp.

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

910  {
911  AUTOMATIC_IR_METADATA(executor->cgen_state_.get());
912  const auto& first_sample_expr = sample_exprs_to_codegen.front();
913  const auto first_sample_slot_bytes =
914  first_sample_expr.target_info.sql_type.is_varlen()
915  ? sizeof(int64_t)
916  : first_sample_expr.target_info.sql_type.get_size();
917  llvm::Value* target_lv_casted{nullptr};
918  // deciding whether proper casting is required for the first sample's slot:
919  if (first_sample_expr.target_info.sql_type.is_varlen()) {
920  target_lv_casted =
921  LL_BUILDER.CreatePtrToInt(target_lvs.front(), llvm::Type::getInt64Ty(LL_CONTEXT));
922  } else if (first_sample_expr.target_info.sql_type.is_fp()) {
923  // Initialization value for SAMPLE on a float column should be 0
924  CHECK_EQ(init_val, 0);
925  if (query_mem_desc.isLogicalSizedColumnsAllowed()) {
926  target_lv_casted = executor->cgen_state_->ir_builder_.CreateFPToSI(
927  target_lvs.front(),
928  first_sample_slot_bytes == sizeof(float) ? llvm::Type::getInt32Ty(LL_CONTEXT)
929  : llvm::Type::getInt64Ty(LL_CONTEXT));
930  } else {
931  target_lv_casted = executor->cgen_state_->ir_builder_.CreateFPToSI(
932  target_lvs.front(), llvm::Type::getInt64Ty(LL_CONTEXT));
933  }
934  } else if (first_sample_slot_bytes != sizeof(int64_t) &&
935  !query_mem_desc.isLogicalSizedColumnsAllowed()) {
936  target_lv_casted =
937  executor->cgen_state_->ir_builder_.CreateCast(llvm::Instruction::CastOps::SExt,
938  target_lvs.front(),
939  llvm::Type::getInt64Ty(LL_CONTEXT));
940  } else {
941  target_lv_casted = target_lvs.front();
942  }
943 
944  std::string slot_empty_cas_func_name("slotEmptyKeyCAS");
945  llvm::Value* init_val_lv{LL_INT(init_val)};
946  if (query_mem_desc.isLogicalSizedColumnsAllowed() &&
947  !first_sample_expr.target_info.sql_type.is_varlen()) {
948  // add proper suffix to the function name:
949  switch (first_sample_slot_bytes) {
950  case 1:
951  slot_empty_cas_func_name += "_int8";
952  break;
953  case 2:
954  slot_empty_cas_func_name += "_int16";
955  break;
956  case 4:
957  slot_empty_cas_func_name += "_int32";
958  break;
959  case 8:
960  break;
961  default:
962  UNREACHABLE() << "Invalid slot size for slotEmptyKeyCAS function.";
963  break;
964  }
965  if (first_sample_slot_bytes != sizeof(int64_t)) {
966  init_val_lv = llvm::ConstantInt::get(
967  get_int_type(first_sample_slot_bytes * 8, LL_CONTEXT), init_val);
968  }
969  }
970 
971  auto sample_cas_lv = executor->cgen_state_->emitExternalCall(
972  slot_empty_cas_func_name,
973  llvm::Type::getInt1Ty(executor->cgen_state_->context_),
974  {agg_col_ptr, target_lv_casted, init_val_lv});
975  return sample_cas_lv;
976 }
#define LL_BUILDER
#define CHECK_EQ(x, y)
Definition: Logger.h:297
bool isLogicalSizedColumnsAllowed() const
#define UNREACHABLE()
Definition: Logger.h:333
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 646 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.

649  {
650  AUTOMATIC_IR_METADATA(executor->cgen_state_.get());
651  if (query_mem_desc.getPaddedSlotWidthBytes(slot_index_counter) == 0) {
652  CHECK(!dynamic_cast<const Analyzer::AggExpr*>(target_expr));
655  return;
656  }
657  if (dynamic_cast<const Analyzer::UOper*>(target_expr) &&
658  static_cast<const Analyzer::UOper*>(target_expr)->get_optype() == kUNNEST) {
659  throw std::runtime_error("UNNEST not supported in the projection list yet.");
660  }
661  if ((executor->plan_state_->isLazyFetchColumn(target_expr) || !is_group_by) &&
662  (static_cast<size_t>(query_mem_desc.getPaddedSlotWidthBytes(slot_index_counter)) <
663  sizeof(int64_t)) &&
664  !is_columnar_projection(query_mem_desc)) {
665  // TODO(miyu): enable different byte width in the layout w/o padding
667  }
668 
669  if (is_columnar_projection(query_mem_desc) &&
670  executor->plan_state_->isLazyFetchColumn(target_expr)) {
671  // For columnar outputs, we need to pad lazy fetched columns to 8 bytes to allow the
672  // lazy fetch index to be placed in the column. The QueryMemoryDescriptor is created
673  // before Lazy Fetch information is known, therefore we need to update the QMD with
674  // the new slot size width bytes for these columns.
675  query_mem_desc.setPaddedSlotWidthBytes(slot_index_counter, int8_t(8));
676  CHECK_EQ(query_mem_desc.getPaddedSlotWidthBytes(slot_index_counter), int8_t(8));
677  }
678 
679  auto target_info = get_target_info(target_expr, g_bigint_count);
680  auto arg_expr = agg_arg(target_expr);
681  if (arg_expr) {
682  if (target_info.agg_kind == kSINGLE_VALUE || target_info.agg_kind == kSAMPLE ||
683  target_info.agg_kind == kAPPROX_QUANTILE) {
684  target_info.skip_null_val = false;
685  } else if (query_mem_desc.getQueryDescriptionType() ==
687  !arg_expr->get_type_info().is_varlen()) {
688  // TODO: COUNT is currently not null-aware for varlen types. Need to add proper code
689  // generation for handling varlen nulls.
690  target_info.skip_null_val = true;
691  } else if (constrained_not_null(arg_expr, ra_exe_unit.quals)) {
692  target_info.skip_null_val = false;
693  }
694  }
695 
696  if (!(query_mem_desc.getQueryDescriptionType() ==
698  (co.device_type == ExecutorDeviceType::GPU) && target_info.is_agg &&
699  (target_info.agg_kind == kSAMPLE)) {
700  sample_exprs_to_codegen.emplace_back(target_expr,
701  target_info,
704  is_group_by);
705  } else {
706  target_exprs_to_codegen.emplace_back(target_expr,
707  target_info,
710  is_group_by);
711  }
712 
713  const auto agg_fn_names = agg_fn_base_names(
714  target_info, is_varlen_projection(target_expr, target_info.sql_type));
715  slot_index_counter += agg_fn_names.size();
716 }
const RelAlgExecutionUnit & ra_exe_unit
const Analyzer::Expr * agg_arg(const Analyzer::Expr *expr)
#define CHECK_EQ(x, y)
Definition: Logger.h:297
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:88
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:289
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: