OmniSciDB  16c4e035a1
 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 716 of file TargetExprBuilder.cpp.

References AUTOMATIC_IR_METADATA, and CHECK.

Referenced by GroupByAndAggregate::codegenAggCalls().

727  {
728  CHECK(group_by_and_agg);
729  CHECK(executor);
730  AUTOMATIC_IR_METADATA(executor->cgen_state_.get());
731 
732  for (const auto& target_expr_codegen : target_exprs_to_codegen) {
733  target_expr_codegen.codegen(group_by_and_agg,
734  executor,
735  query_mem_desc,
736  co,
737  gpu_smem_context,
738  agg_out_ptr_w_idx,
739  agg_out_vec,
740  output_buffer_byte_stream,
741  out_row_idx,
742  varlen_output_buffer,
743  diamond_codegen);
744  }
745  if (!sample_exprs_to_codegen.empty()) {
746  codegenSampleExpressions(group_by_and_agg,
747  executor,
748  query_mem_desc,
749  co,
750  agg_out_ptr_w_idx,
751  agg_out_vec,
752  output_buffer_byte_stream,
753  out_row_idx,
754  diamond_codegen);
755  }
756 }
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:211

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

832  {
833  AUTOMATIC_IR_METADATA(executor->cgen_state_.get());
834  CHECK(sample_exprs_to_codegen.size() > 1 ||
835  sample_exprs_to_codegen.front().target_info.sql_type.is_varlen());
837  const auto& first_sample_expr = sample_exprs_to_codegen.front();
838  auto target_lvs = group_by_and_agg->codegenAggArg(first_sample_expr.target_expr, co);
839  CHECK_GE(target_lvs.size(), size_t(1));
840 
841  const auto init_val =
842  get_initial_agg_val(first_sample_expr.target_info, query_mem_desc);
843 
844  llvm::Value* agg_col_ptr{nullptr};
845  if (is_group_by) {
846  const auto agg_column_size_bytes =
847  query_mem_desc.isLogicalSizedColumnsAllowed() &&
848  !first_sample_expr.target_info.sql_type.is_varlen()
849  ? first_sample_expr.target_info.sql_type.get_size()
850  : sizeof(int64_t);
851  agg_col_ptr = group_by_and_agg->codegenAggColumnPtr(output_buffer_byte_stream,
852  out_row_idx,
853  agg_out_ptr_w_idx,
854  query_mem_desc,
855  agg_column_size_bytes,
856  first_sample_expr.base_slot_index,
857  first_sample_expr.target_idx);
858  } else {
859  CHECK_LT(static_cast<size_t>(first_sample_expr.base_slot_index), agg_out_vec.size());
860  agg_col_ptr =
861  executor->castToIntPtrTyIn(agg_out_vec[first_sample_expr.base_slot_index], 64);
862  }
863 
864  auto sample_cas_lv =
865  codegenSlotEmptyKey(agg_col_ptr, target_lvs, executor, query_mem_desc, init_val);
866 
867  DiamondCodegen sample_cfg(
868  sample_cas_lv, executor, false, "sample_valcheck", &diamond_codegen, false);
869 
870  for (const auto& target_expr_codegen : sample_exprs_to_codegen) {
871  target_expr_codegen.codegen(group_by_and_agg,
872  executor,
873  query_mem_desc,
874  co,
875  {},
876  agg_out_ptr_w_idx,
877  agg_out_vec,
878  output_buffer_byte_stream,
879  out_row_idx,
880  /*varlen_output_buffer=*/nullptr,
881  diamond_codegen,
882  &sample_cfg);
883  }
884 }
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:224
std::vector< TargetExprCodegen > sample_exprs_to_codegen
#define AUTOMATIC_IR_METADATA(CGENSTATE)
ExecutorDeviceType device_type
#define CHECK_LT(x, y)
Definition: Logger.h:221
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:211
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 758 of file TargetExprBuilder.cpp.

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

767  {
768  AUTOMATIC_IR_METADATA(executor->cgen_state_.get());
769  CHECK(!sample_exprs_to_codegen.empty());
771  if (sample_exprs_to_codegen.size() == 1 &&
772  !sample_exprs_to_codegen.front().target_info.sql_type.is_varlen()) {
773  codegenSingleSlotSampleExpression(group_by_and_agg,
774  executor,
775  query_mem_desc,
776  co,
777  agg_out_ptr_w_idx,
778  agg_out_vec,
779  output_buffer_byte_stream,
780  out_row_idx,
781  diamond_codegen);
782  } else {
783  codegenMultiSlotSampleExpressions(group_by_and_agg,
784  executor,
785  query_mem_desc,
786  co,
787  agg_out_ptr_w_idx,
788  agg_out_vec,
789  output_buffer_byte_stream,
790  out_row_idx,
791  diamond_codegen);
792  }
793 }
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:211
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 795 of file TargetExprBuilder.cpp.

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

804  {
805  AUTOMATIC_IR_METADATA(executor->cgen_state_.get());
806  CHECK_EQ(size_t(1), sample_exprs_to_codegen.size());
807  CHECK(!sample_exprs_to_codegen.front().target_info.sql_type.is_varlen());
809  // no need for the atomic if we only have one SAMPLE target
810  sample_exprs_to_codegen.front().codegen(group_by_and_agg,
811  executor,
812  query_mem_desc,
813  co,
814  {},
815  agg_out_ptr_w_idx,
816  agg_out_vec,
817  output_buffer_byte_stream,
818  out_row_idx,
819  /*varlen_output_buffer=*/nullptr,
820  diamond_codegen);
821 }
#define CHECK_EQ(x, y)
Definition: Logger.h:219
std::vector< TargetExprCodegen > sample_exprs_to_codegen
#define AUTOMATIC_IR_METADATA(CGENSTATE)
ExecutorDeviceType device_type
#define CHECK(condition)
Definition: Logger.h:211
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 886 of file TargetExprBuilder.cpp.

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

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

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