#include <CodeGenerator.h>

Inheritance diagram for CodeGenerator:

Collaboration diagram for CodeGenerator:

Classes
struct	ArgNullcheckBBs

struct	ExecutorRequired

struct	GPUTarget

struct	NullCheckCodegen

Public Member Functions
	CodeGenerator (Executor *executor)

	CodeGenerator (CgenState cgen_state, PlanState plan_state)

std::vector< llvm::Value * >	codegen (const Analyzer::Expr *, const bool fetch_columns, const CompilationOptions &)

llvm::Value *	codegenPerRowStringOper (const Analyzer::StringOper *string_oper, const CompilationOptions &co)

llvm::Value *	codegenPseudoStringOper (const Analyzer::ColumnVar *, const std::vector< StringOps_Namespace::StringOpInfo > &string_op_infos, const CompilationOptions &)

std::vector< llvm::Value * >	codegenHoistedConstants (const std::vector< const Analyzer::Constant * > &constants, const EncodingType enc_type, const shared::StringDictKey &dict_id)

llvm::Value *	codegenCastBetweenIntTypes (llvm::Value *operand_lv, const SQLTypeInfo &operand_ti, const SQLTypeInfo &ti, bool upscale=true)

void	codegenCastBetweenIntTypesOverflowChecks (llvm::Value *operand_lv, const SQLTypeInfo &operand_ti, const SQLTypeInfo &ti, const int64_t scale)

llvm::Value *	posArg (const Analyzer::Expr *) const

llvm::Value *	toBool (llvm::Value *)

llvm::Value *	castArrayPointer (llvm::Value *ptr, const SQLTypeInfo &elem_ti)

llvm::Value *	codegenCastBetweenTimestamps (llvm::Value *ts_lv, const SQLTypeInfo &operand_dimen, const SQLTypeInfo &target_dimen, const bool nullable)

llvm::Value *	codegenWindowPosition (const WindowFunctionContext window_func_context, llvm::Value pos_arg)

Static Public Member Functions
static llvm::ConstantInt *	codegenIntConst (const Analyzer::Constant constant, CgenState cgen_state)

static std::unordered_set < llvm::Function * >	markDeadRuntimeFuncs (llvm::Module &module, const std::vector< llvm::Function * > &roots, const std::vector< llvm::Function * > &leaves)

static ExecutionEngineWrapper	generateNativeCPUCode (llvm::Function func, const std::unordered_set< llvm::Function > &live_funcs, const CompilationOptions &co)

static std::string	generatePTX (const std::string &cuda_llir, llvm::TargetMachine *nvptx_target_machine, llvm::LLVMContext &context)

static std::unique_ptr < llvm::TargetMachine >	initializeNVPTXBackend (const CudaMgr_Namespace::NvidiaDeviceArch arch)

static bool	alwaysCloneRuntimeFunction (const llvm::Function *func)

static void	linkModuleWithLibdevice (Executor *executor, llvm::Module &module, llvm::PassManagerBuilder &pass_manager_builder, const GPUTarget &gpu_target)

static std::shared_ptr < GpuCompilationContext >	generateNativeGPUCode (Executor executor, llvm::Function func, llvm::Function wrapper_func, const std::unordered_set< llvm::Function > &live_funcs, const bool is_gpu_smem_used, const CompilationOptions &co, const GPUTarget &gpu_target)

static void	link_udf_module (const std::unique_ptr< llvm::Module > &udf_module, llvm::Module &module, CgenState *cgen_state, llvm::Linker::Flags flags=llvm::Linker::Flags::None)

static bool	prioritizeQuals (const RelAlgExecutionUnit &ra_exe_unit, std::vector< Analyzer::Expr * > &primary_quals, std::vector< Analyzer::Expr * > &deferred_quals, const PlanState::HoistedFiltersSet &hoisted_quals)

static ArrayLoadCodegen	codegenGeoArrayLoadAndNullcheck (llvm::Value byte_stream, llvm::Value pos, const SQLTypeInfo &ti, CgenState *cgen_state)

Protected Member Functions
Executor *	executor () const

Protected Attributes
CgenState *	cgen_state_

PlanState *	plan_state_

Private Member Functions
std::vector< llvm::Value * >	codegen (const Analyzer::Constant *, const EncodingType enc_type, const shared::StringDictKey &dict_id, const CompilationOptions &)

virtual std::vector < llvm::Value * >	codegenColumn (const Analyzer::ColumnVar *, const bool fetch_column, const CompilationOptions &)

llvm::Value *	codegenArith (const Analyzer::BinOper *, const CompilationOptions &)

llvm::Value *	codegenUMinus (const Analyzer::UOper *, const CompilationOptions &)

llvm::Value *	codegenCmp (const Analyzer::BinOper *, const CompilationOptions &)

llvm::Value *	codegenCmp (const SQLOps, const SQLQualifier, std::vector< llvm::Value * >, const SQLTypeInfo &, const Analyzer::Expr *, const CompilationOptions &)

llvm::Value *	codegenIsNull (const Analyzer::UOper *, const CompilationOptions &)

llvm::Value *	codegenIsNullNumber (llvm::Value *, const SQLTypeInfo &)

llvm::Value *	codegenLogical (const Analyzer::BinOper *, const CompilationOptions &)

llvm::Value *	codegenLogical (const Analyzer::UOper *, const CompilationOptions &)

llvm::Value *	codegenCast (const Analyzer::UOper *, const CompilationOptions &)

llvm::Value *	codegenCast (llvm::Value *operand_lv, const SQLTypeInfo &operand_ti, const SQLTypeInfo &ti, const bool operand_is_const, const CompilationOptions &co)

llvm::Value *	codegen (const Analyzer::InValues *, const CompilationOptions &)

llvm::Value *	codegen (const Analyzer::InIntegerSet *expr, const CompilationOptions &co)

std::vector< llvm::Value * >	codegen (const Analyzer::CaseExpr *, const CompilationOptions &)

llvm::Value *	codegen (const Analyzer::ExtractExpr *, const CompilationOptions &)

llvm::Value *	codegen (const Analyzer::DateaddExpr *, const CompilationOptions &)

llvm::Value *	codegen (const Analyzer::DatediffExpr *, const CompilationOptions &)

llvm::Value *	codegen (const Analyzer::DatetruncExpr *, const CompilationOptions &)

llvm::Value *	codegen (const Analyzer::CharLengthExpr *, const CompilationOptions &)

llvm::Value *	codegen (const Analyzer::KeyForStringExpr *, const CompilationOptions &)

llvm::Value *	codegen (const Analyzer::SampleRatioExpr *, const CompilationOptions &)

llvm::Value *	codegen (const Analyzer::WidthBucketExpr *, const CompilationOptions &)

llvm::Value *	codegenConstantWidthBucketExpr (const Analyzer::WidthBucketExpr *, const CompilationOptions &)

llvm::Value *	codegenWidthBucketExpr (const Analyzer::WidthBucketExpr *, const CompilationOptions &)

llvm::Value *	codegen (const Analyzer::MLPredictExpr *, const CompilationOptions &)

llvm::Value *	codegen (const Analyzer::PCAProjectExpr *, const CompilationOptions &)

llvm::Value *	codegenLinRegPredict (const Analyzer::MLPredictExpr *, const std::shared_ptr< AbstractMLModel > &model, const CompilationOptions &)

llvm::Value *	codegenTreeRegPredict (const Analyzer::MLPredictExpr *, const std::shared_ptr< AbstractTreeModel > &tree_model, const CompilationOptions &)

llvm::Value *	codegen (const Analyzer::StringOper *, const CompilationOptions &)

llvm::Value *	codegen (const Analyzer::LikeExpr *, const CompilationOptions &)

llvm::Value *	codegen (const Analyzer::RegexpExpr *, const CompilationOptions &)

llvm::Value *	codegenUnnest (const Analyzer::UOper *, const CompilationOptions &)

llvm::Value *	codegenArrayAt (const Analyzer::BinOper *, const CompilationOptions &)

llvm::Value *	codegen (const Analyzer::CardinalityExpr *, const CompilationOptions &)

std::vector< llvm::Value * >	codegenArrayExpr (const Analyzer::ArrayExpr *, const CompilationOptions &)

std::vector< llvm::Value * >	codegenGeoColumnVar (const Analyzer::GeoColumnVar *, const bool fetch_columns, const CompilationOptions &co)

std::vector< llvm::Value * >	codegenGeoExpr (const Analyzer::GeoExpr *, const CompilationOptions &)

std::vector< llvm::Value * >	codegenGeoConstant (const Analyzer::GeoConstant *, const CompilationOptions &)

std::vector< llvm::Value * >	codegenGeoOperator (const Analyzer::GeoOperator *, const CompilationOptions &)

std::vector< llvm::Value * >	codegenGeoUOper (const Analyzer::GeoUOper *, const CompilationOptions &)

std::vector< llvm::Value * >	codegenGeoBinOper (const Analyzer::GeoBinOper *, const CompilationOptions &)

std::vector< llvm::Value * >	codegenGeosPredicateCall (const std::string &, std::vector< llvm::Value * >, const CompilationOptions &)

std::vector< llvm::Value * >	codegenGeosConstructorCall (const std::string &, std::vector< llvm::Value * >, llvm::Value *, const CompilationOptions &)

std::vector< llvm::Value * >	codegenGeoArgs (const std::vector< std::shared_ptr< Analyzer::Expr >> &, const CompilationOptions &)

llvm::Value *	codegenFunctionOper (const Analyzer::FunctionOper *, const CompilationOptions &)

llvm::Value *	codegenFunctionOperWithCustomTypeHandling (const Analyzer::FunctionOperWithCustomTypeHandling *, const CompilationOptions &)

llvm::Value *	codegen (const Analyzer::BinOper *, const CompilationOptions &)

llvm::Value *	codegen (const Analyzer::UOper *, const CompilationOptions &)

std::vector< llvm::Value * >	codegenHoistedConstantsLoads (const SQLTypeInfo &type_info, const EncodingType enc_type, const shared::StringDictKey &dict_id, const int16_t lit_off, const size_t lit_bytes)

std::vector< llvm::Value * >	codegenHoistedConstantsPlaceholders (const SQLTypeInfo &type_info, const EncodingType enc_type, const int16_t lit_off, const std::vector< llvm::Value * > &literal_loads)

std::vector< llvm::Value * >	codegenColVar (const Analyzer::ColumnVar *, const bool fetch_column, const bool update_query_plan, const CompilationOptions &)

llvm::Value *	codegenFixedLengthColVar (const Analyzer::ColumnVar col_var, llvm::Value col_byte_stream, llvm::Value pos_arg, const WindowFunctionContext window_function_context=nullptr)

llvm::Value *	codegenFixedLengthColVarInWindow (const Analyzer::ColumnVar col_var, llvm::Value col_byte_stream, llvm::Value pos_arg, const CompilationOptions &co, const WindowFunctionContext window_function_context=nullptr)

std::vector< llvm::Value * >	codegenVariableLengthStringColVar (llvm::Value col_byte_stream, llvm::Value pos_arg)

llvm::Value *	codegenRowId (const Analyzer::ColumnVar *col_var, const CompilationOptions &co)

llvm::Value *	codgenAdjustFixedEncNull (llvm::Value *, const SQLTypeInfo &)

std::vector< llvm::Value * >	codegenOuterJoinNullPlaceholder (const Analyzer::ColumnVar *col_var, const bool fetch_column, const CompilationOptions &co)

llvm::Value *	codegenIntArith (const Analyzer::BinOper , llvm::Value , llvm::Value *, const CompilationOptions &)

llvm::Value *	codegenFpArith (const Analyzer::BinOper , llvm::Value , llvm::Value *)

llvm::Value *	codegenCastTimestampToTime (llvm::Value *ts_lv, const int dimen, const bool nullable)

llvm::Value *	codegenCastTimestampToDate (llvm::Value *ts_lv, const int dimen, const bool nullable)

llvm::Value *	codegenCastFromString (llvm::Value *operand_lv, const SQLTypeInfo &operand_ti, const SQLTypeInfo &ti, const bool operand_is_const, const CompilationOptions &co)

llvm::Value *	codegenCastNonStringToString (llvm::Value *operand_lv, const SQLTypeInfo &operand_ti, const SQLTypeInfo &ti, const bool operand_is_const, const CompilationOptions &co)

llvm::Value *	codegenCastToFp (llvm::Value *operand_lv, const SQLTypeInfo &operand_ti, const SQLTypeInfo &ti)

llvm::Value *	codegenCastFromFp (llvm::Value *operand_lv, const SQLTypeInfo &operand_ti, const SQLTypeInfo &ti)

llvm::Value *	codegenAdd (const Analyzer::BinOper , llvm::Value , llvm::Value *, const std::string &null_typename, const std::string &null_check_suffix, const SQLTypeInfo &, const CompilationOptions &)

llvm::Value *	codegenSub (const Analyzer::BinOper , llvm::Value , llvm::Value *, const std::string &null_typename, const std::string &null_check_suffix, const SQLTypeInfo &, const CompilationOptions &)

void	codegenSkipOverflowCheckForNull (llvm::Value lhs_lv, llvm::Value rhs_lv, llvm::BasicBlock *no_overflow_bb, const SQLTypeInfo &ti)

llvm::Value *	codegenMul (const Analyzer::BinOper , llvm::Value , llvm::Value *, const std::string &null_typename, const std::string &null_check_suffix, const SQLTypeInfo &, const CompilationOptions &, bool downscale=true)

llvm::Value *	codegenDiv (llvm::Value , llvm::Value , const std::string &null_typename, const std::string &null_check_suffix, const SQLTypeInfo &, bool upscale=true)

llvm::Value *	codegenDeciDiv (const Analyzer::BinOper *, const CompilationOptions &)

llvm::Value *	codegenMod (llvm::Value , llvm::Value , const std::string &null_typename, const std::string &null_check_suffix, const SQLTypeInfo &)

llvm::Value *	codegenCase (const Analyzer::CaseExpr , llvm::Type case_llvm_type, const bool is_real_str, const CompilationOptions &)

llvm::Value *	codegenExtractHighPrecisionTimestamps (llvm::Value *, const SQLTypeInfo &, const ExtractField &)

llvm::Value *	codegenDateTruncHighPrecisionTimestamps (llvm::Value *, const SQLTypeInfo &, const DatetruncField &)

llvm::Value *	codegenCmpDecimalConst (const SQLOps, const SQLQualifier, const Analyzer::Expr , const SQLTypeInfo &, const Analyzer::Expr , const CompilationOptions &)

llvm::Value *	codegenBoundingBoxIntersect (const SQLOps, const SQLQualifier, const std::shared_ptr< Analyzer::Expr >, const std::shared_ptr< Analyzer::Expr >, const CompilationOptions &)

llvm::Value *	codegenStrCmp (const SQLOps, const SQLQualifier, const std::shared_ptr< Analyzer::Expr >, const std::shared_ptr< Analyzer::Expr >, const CompilationOptions &)

llvm::Value *	codegenQualifierCmp (const SQLOps, const SQLQualifier, std::vector< llvm::Value * >, const Analyzer::Expr *, const CompilationOptions &)

llvm::Value *	codegenLogicalShortCircuit (const Analyzer::BinOper *, const CompilationOptions &)

llvm::Value *	codegenDictLike (const std::shared_ptr< Analyzer::Expr > arg, const Analyzer::Constant *pattern, const bool ilike, const bool is_simple, const char escape_char, const CompilationOptions &)

llvm::Value *	codegenDictStrCmp (const std::shared_ptr< Analyzer::Expr >, const std::shared_ptr< Analyzer::Expr >, const SQLOps, const CompilationOptions &co)

llvm::Value *	codegenDictRegexp (const std::shared_ptr< Analyzer::Expr > arg, const Analyzer::Constant *pattern, const char escape_char, const CompilationOptions &)

llvm::Value *	foundOuterJoinMatch (const size_t nesting_level) const

llvm::Value *	resolveGroupedColumnReference (const Analyzer::ColumnVar *)

llvm::Value *	colByteStream (const Analyzer::ColumnVar *col_var, const bool fetch_column, const bool hoist_literals)

std::shared_ptr< const Analyzer::Expr >	hashJoinLhs (const Analyzer::ColumnVar *rhs) const

std::shared_ptr< const Analyzer::ColumnVar >	hashJoinLhsTuple (const Analyzer::ColumnVar rhs, const Analyzer::BinOper tautological_eq) const

bool	needCastForHashJoinLhs (const Analyzer::ColumnVar *rhs) const

std::unique_ptr< InValuesBitmap >	createInValuesBitmap (const Analyzer::InValues *, const CompilationOptions &)

bool	checkExpressionRanges (const Analyzer::UOper *, int64_t, int64_t)

bool	checkExpressionRanges (const Analyzer::BinOper *, int64_t, int64_t)

std::tuple< ArgNullcheckBBs, llvm::Value * >	beginArgsNullcheck (const Analyzer::FunctionOper function_oper, const std::vector< llvm::Value > &orig_arg_lvs)

llvm::Value *	endArgsNullcheck (const ArgNullcheckBBs &, llvm::Value , llvm::Value , const Analyzer::FunctionOper *)

llvm::Value *	codegenFunctionOperNullArg (const Analyzer::FunctionOper , const std::vector< llvm::Value > &)

llvm::Value *	codegenCompression (const SQLTypeInfo &type_info)

std::pair< llvm::Value , llvm::Value >	codegenArrayBuff (llvm::Value chunk, llvm::Value row_pos, SQLTypes array_type, bool cast_and_extend)

void	codegenBufferArgs (const std::string &udf_func_name, size_t param_num, llvm::Value buffer_buf, llvm::Value buffer_size, llvm::Value buffer_is_null, std::vector< llvm::Value > &output_args)

llvm::StructType *	createPointStructType (const std::string &udf_func_name, size_t param_num)

void	codegenGeoPointArgs (const std::string &udf_func_name, size_t param_num, llvm::Value point_buf, llvm::Value point_size, llvm::Value compression, llvm::Value input_srid, llvm::Value output_srid, std::vector< llvm::Value > &output_args)

llvm::StructType *	createMultiPointStructType (const std::string &udf_func_name, size_t param_num)

void	codegenGeoMultiPointArgs (const std::string &udf_func_name, size_t param_num, llvm::Value multi_point_buf, llvm::Value multi_point_size, llvm::Value compression, llvm::Value input_srid, llvm::Value output_srid, std::vector< llvm::Value > &output_args)

llvm::StructType *	createLineStringStructType (const std::string &udf_func_name, size_t param_num)

void	codegenGeoLineStringArgs (const std::string &udf_func_name, size_t param_num, llvm::Value line_string_buf, llvm::Value line_string_size, llvm::Value compression, llvm::Value input_srid, llvm::Value output_srid, std::vector< llvm::Value > &output_args)

llvm::StructType *	createMultiLineStringStructType (const std::string &udf_func_name, size_t param_num)

void	codegenGeoMultiLineStringArgs (const std::string &udf_func_name, size_t param_num, llvm::Value multi_linestring_coords, llvm::Value multi_linestring_size, llvm::Value linestring_sizes, llvm::Value linestring_sizes_size, llvm::Value compression, llvm::Value input_srid, llvm::Value output_srid, std::vector< llvm::Value > &output_args)

llvm::StructType *	createPolygonStructType (const std::string &udf_func_name, size_t param_num)

void	codegenGeoPolygonArgs (const std::string &udf_func_name, size_t param_num, llvm::Value polygon_buf, llvm::Value polygon_size, llvm::Value ring_sizes_buf, llvm::Value num_rings, llvm::Value compression, llvm::Value input_srid, llvm::Value output_srid, std::vector< llvm::Value > &output_args)

llvm::StructType *	createMultiPolygonStructType (const std::string &udf_func_name, size_t param_num)

void	codegenGeoMultiPolygonArgs (const std::string &udf_func_name, size_t param_num, llvm::Value polygon_coords, llvm::Value polygon_coords_size, llvm::Value ring_sizes_buf, llvm::Value ring_sizes, llvm::Value polygon_bounds, llvm::Value polygon_bounds_sizes, llvm::Value compression, llvm::Value input_srid, llvm::Value output_srid, std::vector< llvm::Value > &output_args)

std::vector< llvm::Value * >	codegenFunctionOperCastArgs (const Analyzer::FunctionOper , const ExtensionFunction , const std::vector< llvm::Value * > &, const std::vector< size_t > &, const std::unordered_map< llvm::Value , llvm::Value > &, const CompilationOptions &)

llvm::StructType *	createStringViewStructType ()

llvm::Function *	getArithWithOverflowIntrinsic (const Analyzer::BinOper bin_oper, llvm::Type type)

llvm::Value *	codegenBinOpWithOverflowForCPU (const Analyzer::BinOper bin_oper, llvm::Value lhs_lv, llvm::Value *rhs_lv, const std::string &null_check_suffix, const SQLTypeInfo &ti)

std::pair< std::vector < llvm::Value * > , std::unique_ptr < CodeGenerator::NullCheckCodegen > >	codegenStringFetchAndEncode (const Analyzer::StringOper *expr, const CompilationOptions &co, const size_t arg_idx, const bool codegen_nullcheck)

Private Attributes
Executor *	executor_

Static Private Attributes
static std::mutex	initialize_nvptx_mutex_

static std::mutex	initialize_cpu_backend_mutex_

Friends
class	GroupByAndAggregate

Detailed Description

Definition at line 29 of file CodeGenerator.h.

Constructor & Destructor Documentation

CodeGenerator::CodeGenerator ( Executor * executor )

inline

Definition at line 31 of file CodeGenerator.h.

       : executor_(executor)
       , cgen_state_(executor->cgen_state_.get())
       , plan_state_(executor->plan_state_.get()) {}

CodeGenerator::CodeGenerator	(	CgenState *	cgen_state,
		PlanState *	plan_state
	)

inline

Definition at line 38 of file CodeGenerator.h.

39 : executor_(nullptr), cgen_state_(cgen_state), plan_state_(plan_state) {}

CodeGenerator::cgen_state_

CgenState * cgen_state_

Definition: CodeGenerator.h:666

CodeGenerator::executor_

Executor * executor_

Definition: CodeGenerator.h:656

CodeGenerator::plan_state_

PlanState * plan_state_

Definition: CodeGenerator.h:667

Member Function Documentation

bool CodeGenerator::alwaysCloneRuntimeFunction ( const llvm::Function * func )

static

Definition at line 1574 of file NativeCodegen.cpp.

Referenced by CgenState::set_module_shallow_copy().

                                                                        {
   auto const candidate_func_name = func->getName().str();
   return std::any_of(TARGET_RUNTIME_FUNCTIONS_FOR_MODULE_CLONING.begin(),
                      TARGET_RUNTIME_FUNCTIONS_FOR_MODULE_CLONING.end(),
                      [candidate_func_name](std::string_view func_name) {
                        return candidate_func_name == func_name;
                      });
 }

Here is the caller graph for this function:

std::tuple< CodeGenerator::ArgNullcheckBBs, llvm::Value * > CodeGenerator::beginArgsNullcheck	(	const Analyzer::FunctionOper *	function_oper,
		const std::vector< llvm::Value * > &	orig_arg_lvs
	)

private

Definition at line 428 of file ExtensionsIR.cpp.

References AUTOMATIC_IR_METADATA, cgen_state_, codegenFunctionOperNullArg(), CgenState::context_, CgenState::current_func_, anonymous_namespace{ExtensionsIR.cpp}::ext_func_call_requires_nullcheck(), anonymous_namespace{ExtensionsIR.cpp}::get_buffer_struct_type(), anonymous_namespace{ExtensionsIR.cpp}::get_llvm_type_from_sql_array_type(), Analyzer::Expr::get_type_info(), Analyzer::FunctionOper::getName(), and CgenState::ir_builder_.

Referenced by codegenFunctionOper(), and codegenFunctionOperWithCustomTypeHandling().

                                                                              {
   AUTOMATIC_IR_METADATA(cgen_state_);
   llvm::BasicBlock* args_null_bb{nullptr};
   llvm::BasicBlock* args_notnull_bb{nullptr};
   llvm::BasicBlock* orig_bb = cgen_state_->ir_builder_.GetInsertBlock();
   llvm::Value* null_array_alloca{nullptr};
   // Only generate the check if required (at least one argument must be nullable).
   if (ext_func_call_requires_nullcheck(function_oper)) {
     const auto func_ti = function_oper->get_type_info();
     if (func_ti.is_buffer()) {
       const auto arr_struct_ty = get_buffer_struct_type(
           cgen_state_,
           function_oper->getName(),
           0,
           get_llvm_type_from_sql_array_type(func_ti, cgen_state_->context_));
       null_array_alloca = cgen_state_->ir_builder_.CreateAlloca(arr_struct_ty);
     }
     const auto args_notnull_lv = cgen_state_->ir_builder_.CreateNot(
         codegenFunctionOperNullArg(function_oper, orig_arg_lvs));
     args_notnull_bb = llvm::BasicBlock::Create(
         cgen_state_->context_, "args_notnull", cgen_state_->current_func_);
     args_null_bb = llvm::BasicBlock::Create(
         cgen_state_->context_, "args_null", cgen_state_->current_func_);
     cgen_state_->ir_builder_.CreateCondBr(args_notnull_lv, args_notnull_bb, args_null_bb);
     cgen_state_->ir_builder_.SetInsertPoint(args_notnull_bb);
   }
   return std::make_tuple(
       CodeGenerator::ArgNullcheckBBs{args_null_bb, args_notnull_bb, orig_bb},
       null_array_alloca);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

llvm::Value * CodeGenerator::castArrayPointer	(	llvm::Value *	ptr,
		const SQLTypeInfo &	elem_ti
	)

Definition at line 1748 of file ExtensionsIR.cpp.

References AUTOMATIC_IR_METADATA, cgen_state_, CHECK, CgenState::context_, SQLTypeInfo::get_compression(), SQLTypeInfo::get_size(), SQLTypeInfo::get_type(), CgenState::ir_builder_, SQLTypeInfo::is_boolean(), SQLTypeInfo::is_integer(), SQLTypeInfo::is_string(), kDOUBLE, kENCODING_DICT, and kFLOAT.

Referenced by codegenFunctionOperCastArgs(), RangeJoinHashTable::codegenKey(), and BoundingBoxIntersectJoinHashTable::codegenKey().

                                                                          {
   AUTOMATIC_IR_METADATA(cgen_state_);
   if (elem_ti.get_type() == kFLOAT) {
     return cgen_state_->ir_builder_.CreatePointerCast(
         ptr, llvm::Type::getFloatPtrTy(cgen_state_->context_));
   }
   if (elem_ti.get_type() == kDOUBLE) {
     return cgen_state_->ir_builder_.CreatePointerCast(
         ptr, llvm::Type::getDoublePtrTy(cgen_state_->context_));
   }
   CHECK(elem_ti.is_integer() || elem_ti.is_boolean() ||
         (elem_ti.is_string() && elem_ti.get_compression() == kENCODING_DICT));
   switch (elem_ti.get_size()) {
     case 1:
       return cgen_state_->ir_builder_.CreatePointerCast(
           ptr, llvm::Type::getInt8PtrTy(cgen_state_->context_));
     case 2:
       return cgen_state_->ir_builder_.CreatePointerCast(
           ptr, llvm::Type::getInt16PtrTy(cgen_state_->context_));
     case 4:
       return cgen_state_->ir_builder_.CreatePointerCast(
           ptr, llvm::Type::getInt32PtrTy(cgen_state_->context_));
     case 8:
       return cgen_state_->ir_builder_.CreatePointerCast(
           ptr, llvm::Type::getInt64PtrTy(cgen_state_->context_));
     default:
       CHECK(false);
   }
   return nullptr;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool CodeGenerator::checkExpressionRanges	(	const Analyzer::UOper *	uoper,
		int64_t	min,
		int64_t	max
	)

private

Definition at line 630 of file ArithmeticIR.cpp.

References CHECK, executor(), executor_, Analyzer::Expr::get_type_info(), getExpressionRange(), Integer, SQLTypeInfo::is_decimal(), ExpressionRange::makeInvalidRange(), plan_state_, and PlanState::query_infos_.

Referenced by codegenAdd(), codegenMul(), codegenSub(), and codegenUMinus().

                                                        {
   if (uoper->get_type_info().is_decimal()) {
     return false;
   }
 
   CHECK(plan_state_);
   if (executor_) {
     auto expr_range_info =
         plan_state_->query_infos_.size() > 0
             ? getExpressionRange(uoper, plan_state_->query_infos_, executor())
             : ExpressionRange::makeInvalidRange();
     if (expr_range_info.getType() != ExpressionRangeType::Integer) {
       return false;
     }
     if (expr_range_info.getIntMin() >= min && expr_range_info.getIntMax() <= max) {
       return true;
     }
   }
 
   return false;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool CodeGenerator::checkExpressionRanges	(	const Analyzer::BinOper *	bin_oper,
		int64_t	min,
		int64_t	max
	)

private

Definition at line 189 of file ArithmeticIR.cpp.

References CHECK, executor(), executor_, Analyzer::BinOper::get_left_operand(), Analyzer::BinOper::get_right_operand(), Analyzer::Expr::get_type_info(), getExpressionRange(), Integer, SQLTypeInfo::is_decimal(), anonymous_namespace{ArithmeticIR.cpp}::is_temporary_column(), ExpressionRange::makeInvalidRange(), plan_state_, and PlanState::query_infos_.

                                                        {
   if (is_temporary_column(bin_oper->get_left_operand()) ||
       is_temporary_column(bin_oper->get_right_operand())) {
     // Computing the range for temporary columns is a lot more expensive than the overflow
     // check.
     return false;
   }
   if (bin_oper->get_type_info().is_decimal()) {
     return false;
   }
 
   CHECK(plan_state_);
   if (executor_) {
     auto expr_range_info =
         plan_state_->query_infos_.size() > 0
             ? getExpressionRange(bin_oper, plan_state_->query_infos_, executor())
             : ExpressionRange::makeInvalidRange();
     if (expr_range_info.getType() != ExpressionRangeType::Integer) {
       return false;
     }
     if (expr_range_info.getIntMin() >= min && expr_range_info.getIntMax() <= max) {
       return true;
     }
   }
 
   return false;
 }

Here is the call graph for this function:

std::vector< llvm::Value * > CodeGenerator::codegen	(	const Analyzer::Expr *	expr,
		const bool	fetch_columns,
		const CompilationOptions &	co
	)

Definition at line 30 of file IRCodegen.cpp.

References AUTOMATIC_IR_METADATA, cgen_state_, CHECK, CHECK_NE, codegenArrayExpr(), codegenColumn(), codegenFunctionOper(), codegenFunctionOperWithCustomTypeHandling(), codegenGeoBinOper(), codegenGeoColumnVar(), codegenGeoExpr(), codegenGeoUOper(), CgenState::context_, createStringViewStructType(), executor_, get_int_type(), Analyzer::Expr::get_type_info(), CgenState::ir_builder_, kENCODING_DICT, kENCODING_NONE, kLINESTRING, kMULTILINESTRING, kMULTIPOINT, kMULTIPOLYGON, kNULLT, kPOINT, kPOLYGON, CgenState::llInt(), posArg(), and width_bucket_expr().

Referenced by Executor::buildHoistLeftHandSideFiltersCb(), Executor::buildIsDeletedCb(), Executor::buildJoinLoops(), TreeModelPredictionMgr::codegen(), codegen(), GroupByAndAggregate::codegenAggArg(), TargetExprCodegen::codegenAggregate(), codegenArith(), codegenArrayAt(), codegenArrayExpr(), codegenCase(), codegenCast(), codegenCmp(), codegenCmpDecimalConst(), HashJoin::codegenColOrStringOper(), codegenColVar(), codegenConstantWidthBucketExpr(), codegenDeciDiv(), codegenDictLike(), codegenDictRegexp(), codegenDictStrCmp(), Executor::codegenFrameBoundExpr(), codegenFunctionOper(), codegenFunctionOperWithCustomTypeHandling(), codegenGeoArgs(), codegenGeoColumnVar(), codegenGeoConstant(), codegenGeoOperator(), codegenIsNull(), RangeJoinHashTable::codegenKey(), BoundingBoxIntersectJoinHashTable::codegenKey(), codegenLogical(), codegenLogicalShortCircuit(), BoundingBoxIntersectJoinHashTable::codegenManyKey(), codegenOuterJoinNullPlaceholder(), GroupByAndAggregate::codegenOutputSlot(), codegenPseudoStringOper(), codegenQualifierCmp(), codegenRowId(), codegenStringFetchAndEncode(), codegenTreeRegPredict(), codegenUMinus(), codegenUnnest(), codegenWidthBucketExpr(), Executor::codegenWindowFunctionAggregateCalls(), ScalarCodeGenerator::compile(), and Executor::groupByColumnCodegen().

                                                                                {
   AUTOMATIC_IR_METADATA(cgen_state_);
   if (!expr) {
     return {posArg(expr)};
   }
   auto bin_oper = dynamic_cast<const Analyzer::BinOper*>(expr);
   if (bin_oper) {
     return {codegen(bin_oper, co)};
   }
   auto u_oper = dynamic_cast<const Analyzer::UOper*>(expr);
   if (u_oper) {
     return {codegen(u_oper, co)};
   }
   auto geo_col_var = dynamic_cast<const Analyzer::GeoColumnVar*>(expr);
   if (geo_col_var) {
     // inherits from ColumnVar, so it is important we check this first
     return codegenGeoColumnVar(geo_col_var, fetch_columns, co);
   }
   auto col_var = dynamic_cast<const Analyzer::ColumnVar*>(expr);
   if (col_var) {
     return codegenColumn(col_var, fetch_columns, co);
   }
   auto constant = dynamic_cast<const Analyzer::Constant*>(expr);
   if (constant) {
     const auto& ti = constant->get_type_info();
     if (ti.get_type() == kNULLT) {
       throw std::runtime_error(
           "NULL type literals are not currently supported in this context.");
     }
     if (constant->get_is_null()) {
       const auto i8p_ty =
           llvm::PointerType::get(get_int_type(8, executor_->cgen_state_->context_), 0);
       if (ti.is_string() && ti.get_compression() == kENCODING_NONE) {
         std::vector<llvm::Value*> null_target_lvs;
         llvm::StructType* str_view_ty = createStringViewStructType();
         auto null_str_view_struct_lv = cgen_state_->ir_builder_.CreateAlloca(str_view_ty);
         // we do not need to fill the values of the string_view struct representing null
         // string
         null_target_lvs.push_back(
             cgen_state_->ir_builder_.CreateLoad(str_view_ty, null_str_view_struct_lv));
         null_target_lvs.push_back(llvm::ConstantPointerNull::get(
             llvm::PointerType::get(llvm::IntegerType::get(cgen_state_->context_, 8), 0)));
         null_target_lvs.push_back(cgen_state_->llInt((int32_t)0));
         return null_target_lvs;
       } else if (ti.is_geometry()) {
         std::vector<llvm::Value*> ret_lvs;
         // we classify whether the geo col value is null from the rhs of the left-join
         // qual i.e., table S in the qual: R left join S on R.v = S.v by checking 1)
         // nulled chunk_iter and 2) its col buffer w/ the size 0 for instance, we consider
         // the size of col buffer for point as 16 and for other types we use `array_size`
         // function to determine it, and they all assume valid geos have their buf size >
         // 0 thus, by returning all bufs' ptr as nullptr we can return 0 as the length of
         // the nulled geos' col val, and remaining logic can exploit this to finally
         // return "null" as the col value of the corresponding row in the resultset
         switch (ti.get_type()) {
           // outer join's phi node in the generated code expects the # returned lvs'
           // is the same as `col_ti.get_physical_coord_cols()`
           // now we have necessary logic to deal with these nullptr and can conclude
           // it as nulled geo val, i.e., see ResultSetIteration::991
           case kPOINT:
           case kMULTIPOINT:
           case kLINESTRING:
             return {llvm::ConstantPointerNull::get(i8p_ty)};
           case kMULTILINESTRING:
           case kPOLYGON:
             return {llvm::ConstantPointerNull::get(i8p_ty),
                     llvm::ConstantPointerNull::get(i8p_ty)};
           case kMULTIPOLYGON:
             return {llvm::ConstantPointerNull::get(i8p_ty),
                     llvm::ConstantPointerNull::get(i8p_ty),
                     llvm::ConstantPointerNull::get(i8p_ty)};
           default:
             CHECK(false);
             return {nullptr};
         }
       } else if (ti.is_array()) {
         // similar to above nulled geo case, we can use this `nullptr` to guide
         // `array_buff` and `array_size` functions representing nulled array value
         return {llvm::ConstantPointerNull::get(i8p_ty)};
       }
       return {ti.is_fp()
                   ? static_cast<llvm::Value*>(executor_->cgen_state_->inlineFpNull(ti))
                   : static_cast<llvm::Value*>(executor_->cgen_state_->inlineIntNull(ti))};
     }
     if (ti.get_compression() == kENCODING_DICT) {
       // The dictionary encoding case should be handled by the parent expression
       // (cast, for now), here is too late to know the dictionary id if not already set
       CHECK_NE(ti.getStringDictKey().dict_id, 0);
       return {codegen(constant, ti.get_compression(), ti.getStringDictKey(), co)};
     }
     return {codegen(constant, ti.get_compression(), {}, co)};
   }
   auto case_expr = dynamic_cast<const Analyzer::CaseExpr*>(expr);
   if (case_expr) {
     return {codegen(case_expr, co)};
   }
   auto extract_expr = dynamic_cast<const Analyzer::ExtractExpr*>(expr);
   if (extract_expr) {
     return {codegen(extract_expr, co)};
   }
   auto dateadd_expr = dynamic_cast<const Analyzer::DateaddExpr*>(expr);
   if (dateadd_expr) {
     return {codegen(dateadd_expr, co)};
   }
   auto datediff_expr = dynamic_cast<const Analyzer::DatediffExpr*>(expr);
   if (datediff_expr) {
     return {codegen(datediff_expr, co)};
   }
   auto datetrunc_expr = dynamic_cast<const Analyzer::DatetruncExpr*>(expr);
   if (datetrunc_expr) {
     return {codegen(datetrunc_expr, co)};
   }
   auto charlength_expr = dynamic_cast<const Analyzer::CharLengthExpr*>(expr);
   if (charlength_expr) {
     return {codegen(charlength_expr, co)};
   }
   auto keyforstring_expr = dynamic_cast<const Analyzer::KeyForStringExpr*>(expr);
   if (keyforstring_expr) {
     return {codegen(keyforstring_expr, co)};
   }
   auto sample_ratio_expr = dynamic_cast<const Analyzer::SampleRatioExpr*>(expr);
   if (sample_ratio_expr) {
     return {codegen(sample_ratio_expr, co)};
   }
   auto string_oper_expr = dynamic_cast<const Analyzer::StringOper*>(expr);
   if (string_oper_expr) {
     return {codegen(string_oper_expr, co)};
   }
   auto cardinality_expr = dynamic_cast<const Analyzer::CardinalityExpr*>(expr);
   if (cardinality_expr) {
     return {codegen(cardinality_expr, co)};
   }
   auto like_expr = dynamic_cast<const Analyzer::LikeExpr*>(expr);
   if (like_expr) {
     return {codegen(like_expr, co)};
   }
   auto regexp_expr = dynamic_cast<const Analyzer::RegexpExpr*>(expr);
   if (regexp_expr) {
     return {codegen(regexp_expr, co)};
   }
   auto width_bucket_expr = dynamic_cast<const Analyzer::WidthBucketExpr*>(expr);
   if (width_bucket_expr) {
     return {codegen(width_bucket_expr, co)};
   }
 
   auto ml_predict_expr = dynamic_cast<const Analyzer::MLPredictExpr*>(expr);
   if (ml_predict_expr) {
     return {codegen(ml_predict_expr, co)};
   }
 
   auto pca_project_expr = dynamic_cast<const Analyzer::PCAProjectExpr*>(expr);
   if (pca_project_expr) {
     return {codegen(pca_project_expr, co)};
   }
 
   auto likelihood_expr = dynamic_cast<const Analyzer::LikelihoodExpr*>(expr);
   if (likelihood_expr) {
     return {codegen(likelihood_expr->get_arg(), fetch_columns, co)};
   }
   auto in_expr = dynamic_cast<const Analyzer::InValues*>(expr);
   if (in_expr) {
     return {codegen(in_expr, co)};
   }
   auto in_integer_set_expr = dynamic_cast<const Analyzer::InIntegerSet*>(expr);
   if (in_integer_set_expr) {
     return {codegen(in_integer_set_expr, co)};
   }
   auto function_oper_with_custom_type_handling_expr =
       dynamic_cast<const Analyzer::FunctionOperWithCustomTypeHandling*>(expr);
   if (function_oper_with_custom_type_handling_expr) {
     return {codegenFunctionOperWithCustomTypeHandling(
         function_oper_with_custom_type_handling_expr, co)};
   }
   auto array_oper_expr = dynamic_cast<const Analyzer::ArrayExpr*>(expr);
   if (array_oper_expr) {
     return {codegenArrayExpr(array_oper_expr, co)};
   }
   auto geo_uop = dynamic_cast<const Analyzer::GeoUOper*>(expr);
   if (geo_uop) {
     return {codegenGeoUOper(geo_uop, co)};
   }
   auto geo_binop = dynamic_cast<const Analyzer::GeoBinOper*>(expr);
   if (geo_binop) {
     return {codegenGeoBinOper(geo_binop, co)};
   }
   auto function_oper_expr = dynamic_cast<const Analyzer::FunctionOper*>(expr);
   if (function_oper_expr) {
     return {codegenFunctionOper(function_oper_expr, co)};
   }
   auto geo_expr = dynamic_cast<const Analyzer::GeoExpr*>(expr);
   if (geo_expr) {
     return codegenGeoExpr(geo_expr, co);
   }
   if (dynamic_cast<const Analyzer::OffsetInFragment*>(expr)) {
     return {posArg(nullptr)};
   }
   if (dynamic_cast<const Analyzer::WindowFunction*>(expr)) {
     throw NativeExecutionError("Window expression not supported in this context");
   }
   abort();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

std::vector< llvm::Value * > CodeGenerator::codegen	(	const Analyzer::Constant *	constant,
		const EncodingType	enc_type,
		const shared::StringDictKey &	dict_id,
		const CompilationOptions &	co
	)

private

Definition at line 20 of file ConstantIR.cpp.

References CgenState::addStringConstant(), AUTOMATIC_IR_METADATA, Datum::boolval, cgen_state_, CHECK, codegenGeoConstant(), codegenHoistedConstants(), codegenIntConst(), CgenState::context_, decimal_to_int_type(), CompilationOptions::device_type, Datum::doubleval, executor(), Datum::floatval, Analyzer::Constant::get_constval(), get_int_type(), Analyzer::Constant::get_is_null(), Analyzer::Expr::get_type_info(), CompilationOptions::hoist_literals, inline_int_null_val(), kBIGINT, kBOOLEAN, kCHAR, kDATE, kDOUBLE, kENCODING_DICT, kFLOAT, kINT, kINTERVAL_DAY_TIME, kINTERVAL_YEAR_MONTH, kSMALLINT, kTEXT, kTIME, kTIMESTAMP, kTINYINT, kVARCHAR, CgenState::llInt(), Datum::stringval, and run_benchmark_import::type.

                                                                                {
   AUTOMATIC_IR_METADATA(cgen_state_);
   if (co.hoist_literals) {
     if (const auto geo_constant = dynamic_cast<const Analyzer::GeoConstant*>(constant)) {
       return codegenGeoConstant(geo_constant, co);
     } else {
       std::vector<const Analyzer::Constant*> constants(
           executor()->deviceCount(co.device_type), constant);
       return codegenHoistedConstants(constants, enc_type, dict_id);
     }
   }
   const auto& type_info = constant->get_type_info();
   const auto type =
       type_info.is_decimal() ? decimal_to_int_type(type_info) : type_info.get_type();
   switch (type) {
     case kBOOLEAN:
       return {llvm::ConstantInt::get(get_int_type(8, cgen_state_->context_),
                                      constant->get_constval().boolval)};
     case kTINYINT:
     case kSMALLINT:
     case kINT:
     case kBIGINT:
     case kTIME:
     case kTIMESTAMP:
     case kDATE:
     case kINTERVAL_DAY_TIME:
     case kINTERVAL_YEAR_MONTH:
       return {CodeGenerator::codegenIntConst(constant, cgen_state_)};
     case kFLOAT:
       return {llvm::ConstantFP::get(llvm::Type::getFloatTy(cgen_state_->context_),
                                     constant->get_constval().floatval)};
     case kDOUBLE:
       return {llvm::ConstantFP::get(llvm::Type::getDoubleTy(cgen_state_->context_),
                                     constant->get_constval().doubleval)};
     case kVARCHAR:
     case kCHAR:
     case kTEXT: {
       CHECK(constant->get_constval().stringval || constant->get_is_null());
       if (constant->get_is_null()) {
         if (enc_type == kENCODING_DICT) {
           return {
               cgen_state_->llInt(static_cast<int32_t>(inline_int_null_val(type_info)))};
         }
         return {cgen_state_->llInt(int64_t(0)),
                 llvm::Constant::getNullValue(
                     llvm::PointerType::get(get_int_type(8, cgen_state_->context_), 0)),
                 cgen_state_->llInt(int32_t(0))};
       }
       const auto& str_const = *constant->get_constval().stringval;
       if (enc_type == kENCODING_DICT) {
         return {
             cgen_state_->llInt(executor()
                                    ->getStringDictionaryProxy(
                                        dict_id, executor()->getRowSetMemoryOwner(), true)
                                    ->getIdOfString(str_const))};
       }
       return {cgen_state_->llInt(int64_t(0)),
               cgen_state_->addStringConstant(str_const),
               cgen_state_->llInt(static_cast<int32_t>(str_const.size()))};
     }
     default:
       CHECK(false);
   }
   abort();
 }

Here is the call graph for this function:

llvm::Value * CodeGenerator::codegen	(	const Analyzer::InValues *	expr,
		const CompilationOptions &	co
	)

private

Definition at line 23 of file InValuesIR.cpp.

References CgenState::addInValuesBitmap(), AUTOMATIC_IR_METADATA, cgen_state_, CHECK, CHECK_EQ, codegen(), InValuesBitmap::codegen(), codegenCmp(), CgenState::context_, createInValuesBitmap(), CgenState::emitCall(), executor(), Analyzer::InValues::get_arg(), Analyzer::Expr::get_type_info(), Analyzer::InValues::get_value_list(), CompilationOptions::hoist_literals, CgenState::inlineIntNull(), CgenState::ir_builder_, is_unnest(), kBOOLEAN, kEQ, kONE, CgenState::llInt(), run_benchmark_import::result, and toBool().

                                                                   {
   AUTOMATIC_IR_METADATA(cgen_state_);
   const auto in_arg = expr->get_arg();
   if (is_unnest(in_arg)) {
     throw std::runtime_error("IN not supported for unnested expressions");
   }
   const auto& expr_ti = expr->get_type_info();
   CHECK(expr_ti.is_boolean());
   const auto lhs_lvs = codegen(in_arg, true, co);
   llvm::Value* result{nullptr};
   if (expr_ti.get_notnull()) {
     result = llvm::ConstantInt::get(llvm::IntegerType::getInt1Ty(cgen_state_->context_),
                                     false);
   } else {
     result = cgen_state_->llInt(int8_t(0));
   }
   CHECK(result);
   if (co.hoist_literals) {  // TODO(alex): remove this constraint
     auto in_vals_bitmap = createInValuesBitmap(expr, co);
     if (in_vals_bitmap) {
       if (in_vals_bitmap->isEmpty()) {
         return in_vals_bitmap->hasNull()
                    ? cgen_state_->inlineIntNull(SQLTypeInfo(kBOOLEAN, false))
                    : result;
       }
       CHECK_EQ(size_t(1), lhs_lvs.size());
       return cgen_state_->addInValuesBitmap(in_vals_bitmap)
           ->codegen(lhs_lvs.front(), executor());
     }
   }
   if (expr_ti.get_notnull()) {
     for (auto in_val : expr->get_value_list()) {
       result = cgen_state_->ir_builder_.CreateOr(
           result,
           toBool(
               codegenCmp(kEQ, kONE, lhs_lvs, in_arg->get_type_info(), in_val.get(), co)));
     }
   } else {
     for (auto in_val : expr->get_value_list()) {
       const auto crt =
           codegenCmp(kEQ, kONE, lhs_lvs, in_arg->get_type_info(), in_val.get(), co);
       result = cgen_state_->emitCall("logical_or",
                                      {result, crt, cgen_state_->inlineIntNull(expr_ti)});
     }
   }
   return result;
 }

Here is the call graph for this function:

llvm::Value * CodeGenerator::codegen	(	const Analyzer::InIntegerSet *	expr,
		const CompilationOptions &	co
	)

private

Definition at line 72 of file InValuesIR.cpp.

References CgenState::addInValuesBitmap(), AUTOMATIC_IR_METADATA, cgen_state_, CHECK, CHECK_EQ, codegen(), InValuesBitmap::codegen(), CgenState::context_, Data_Namespace::CPU_LEVEL, CompilationOptions::device_type, executor(), Analyzer::InIntegerSet::get_arg(), Analyzer::Expr::get_type_info(), Analyzer::InIntegerSet::get_value_list(), GPU, Data_Namespace::GPU_LEVEL, CompilationOptions::hoist_literals, inline_int_null_val(), is_unnest(), CgenState::llInt(), and run_benchmark_import::result.

                                                                   {
   AUTOMATIC_IR_METADATA(cgen_state_);
   const auto in_arg = in_integer_set->get_arg();
   if (is_unnest(in_arg)) {
     throw std::runtime_error("IN not supported for unnested expressions");
   }
   const auto& ti = in_integer_set->get_arg()->get_type_info();
   const auto needle_null_val = inline_int_null_val(ti);
   if (!co.hoist_literals) {
     // We never run without literal hoisting in real world scenarios, this avoids a crash
     // when testing.
     throw std::runtime_error(
         "IN subquery with many right-hand side values not supported when literal "
         "hoisting is disabled");
   }
   auto in_vals_bitmap = std::make_unique<InValuesBitmap>(
       in_integer_set->get_value_list(),
       needle_null_val,
       co.device_type == ExecutorDeviceType::GPU ? Data_Namespace::GPU_LEVEL
                                                 : Data_Namespace::CPU_LEVEL,
       executor()->deviceCount(co.device_type),
       executor()->data_mgr_,
       co);
   const auto& in_integer_set_ti = in_integer_set->get_type_info();
   CHECK(in_integer_set_ti.is_boolean());
   const auto lhs_lvs = codegen(in_arg, true, co);
   llvm::Value* result{nullptr};
   if (in_integer_set_ti.get_notnull()) {
     result = llvm::ConstantInt::get(llvm::IntegerType::getInt1Ty(cgen_state_->context_),
                                     false);
   } else {
     result = cgen_state_->llInt(int8_t(0));
   }
   CHECK(result);
   CHECK_EQ(size_t(1), lhs_lvs.size());
   return cgen_state_->addInValuesBitmap(in_vals_bitmap)
       ->codegen(lhs_lvs.front(), executor());
 }

Here is the call graph for this function:

std::vector< llvm::Value * > CodeGenerator::codegen	(	const Analyzer::CaseExpr *	case_expr,
		const CompilationOptions &	co
	)

private

Definition at line 20 of file CaseIR.cpp.

References AUTOMATIC_IR_METADATA, cgen_state_, CHECK, CHECK_EQ, codegenCase(), CgenState::context_, createStringViewStructType(), get_bit_width(), Analyzer::CaseExpr::get_else_expr(), get_int_type(), Analyzer::Expr::get_type_info(), CgenState::ir_builder_, kENCODING_DICT, and kFLOAT.

                                                                                {
   AUTOMATIC_IR_METADATA(cgen_state_);
   const auto case_ti = case_expr->get_type_info();
   llvm::Type* case_llvm_type = nullptr;
   bool is_real_str = false;
   if (case_ti.is_integer() || case_ti.is_time() || case_ti.is_decimal()) {
     case_llvm_type = get_int_type(get_bit_width(case_ti), cgen_state_->context_);
   } else if (case_ti.is_fp()) {
     case_llvm_type = case_ti.get_type() == kFLOAT
                          ? llvm::Type::getFloatTy(cgen_state_->context_)
                          : llvm::Type::getDoubleTy(cgen_state_->context_);
   } else if (case_ti.is_string()) {
     if (case_ti.get_compression() == kENCODING_DICT) {
       case_llvm_type =
           get_int_type(8 * case_ti.get_logical_size(), cgen_state_->context_);
     } else {
       is_real_str = true;
       case_llvm_type = createStringViewStructType();
     }
   } else if (case_ti.is_boolean()) {
     case_llvm_type = get_int_type(8 * case_ti.get_logical_size(), cgen_state_->context_);
   } else if (case_ti.is_geometry()) {
     throw std::runtime_error(
         "Geospatial column projections are currently not supported in conditional "
         "expressions.");
   } else if (case_ti.is_array()) {
     throw std::runtime_error(
         "Array column projections are currently not supported in conditional "
         "expressions.");
   }
   CHECK(case_llvm_type);
   const auto& else_ti = case_expr->get_else_expr()->get_type_info();
   CHECK_EQ(else_ti.get_type(), case_ti.get_type());
   llvm::Value* case_val = codegenCase(case_expr, case_llvm_type, is_real_str, co);
   std::vector<llvm::Value*> ret_vals{case_val};
   if (is_real_str) {
     ret_vals.push_back(cgen_state_->ir_builder_.CreateExtractValue(case_val, 0));
     ret_vals.push_back(cgen_state_->ir_builder_.CreateExtractValue(case_val, 1));
     ret_vals.back() = cgen_state_->ir_builder_.CreateTrunc(
         ret_vals.back(), llvm::Type::getInt32Ty(cgen_state_->context_));
   }
   return ret_vals;
 }

Here is the call graph for this function:

llvm::Value * CodeGenerator::codegen	(	const Analyzer::ExtractExpr *	extract_expr,
		const CompilationOptions &	co
	)

private

Definition at line 76 of file DateTimeIR.cpp.

References AUTOMATIC_IR_METADATA, CHECK, DateTimeUtils::get_extract_timestamp_precision_scale(), Analyzer::ExtractExpr::get_field(), Analyzer::ExtractExpr::get_from_expr(), get_int_type(), Analyzer::Expr::get_type_info(), DateTimeUtils::is_subsecond_extract_field(), kDATE, kEPOCH, and kTIMESTAMP.

                                                                   {
   AUTOMATIC_IR_METADATA(cgen_state_);
   auto from_expr = codegen(extract_expr->get_from_expr(), true, co).front();
   const int32_t extract_field{extract_expr->get_field()};
   const auto& extract_expr_ti = extract_expr->get_from_expr()->get_type_info();
   if (extract_field == kEPOCH) {
     CHECK(extract_expr_ti.get_type() == kTIMESTAMP ||
           extract_expr_ti.get_type() == kDATE);
     if (from_expr->getType()->isIntegerTy(32)) {
       from_expr =
           cgen_state_->ir_builder_.CreateCast(llvm::Instruction::CastOps::SExt,
                                               from_expr,
                                               get_int_type(64, cgen_state_->context_));
       return from_expr;
     }
   }
   CHECK(from_expr->getType()->isIntegerTy(64));
   if (extract_expr_ti.is_high_precision_timestamp()) {
     from_expr = codegenExtractHighPrecisionTimestamps(
         from_expr, extract_expr_ti, extract_expr->get_field());
   }
   if (!extract_expr_ti.is_high_precision_timestamp() &&
       is_subsecond_extract_field(extract_expr->get_field())) {
     from_expr =
         extract_expr_ti.get_notnull()
             ? cgen_state_->ir_builder_.CreateMul(
                   from_expr,
                   cgen_state_->llInt(
                       get_extract_timestamp_precision_scale(extract_expr->get_field())))
             : cgen_state_->emitCall(
                   "mul_int64_t_nullable_lhs",
                   {from_expr,
                    cgen_state_->llInt(
                        get_extract_timestamp_precision_scale(extract_expr->get_field())),
                    cgen_state_->inlineIntNull(extract_expr_ti)});
   }
   const auto extract_fname = get_extract_function_name(extract_expr->get_field());
   if (!extract_expr_ti.get_notnull()) {
     llvm::BasicBlock* extract_nullcheck_bb{nullptr};
     llvm::PHINode* extract_nullcheck_value{nullptr};
     {
       DiamondCodegen null_check(cgen_state_->ir_builder_.CreateICmp(
                                     llvm::ICmpInst::ICMP_EQ,
                                     from_expr,
                                     cgen_state_->inlineIntNull(extract_expr_ti)),
                                 executor(),
                                 false,
                                 "extract_nullcheck",
                                 nullptr,
                                 false);
       // generate a phi node depending on whether we got a null or not
       extract_nullcheck_bb = llvm::BasicBlock::Create(
           cgen_state_->context_, "extract_nullcheck_bb", cgen_state_->current_func_);
 
       // update the blocks created by diamond codegen to point to the newly created phi
       // block
       cgen_state_->ir_builder_.SetInsertPoint(null_check.cond_true_);
       cgen_state_->ir_builder_.CreateBr(extract_nullcheck_bb);
       cgen_state_->ir_builder_.SetInsertPoint(null_check.cond_false_);
       auto extract_call =
           cgen_state_->emitExternalCall(extract_fname,
                                         get_int_type(64, cgen_state_->context_),
                                         std::vector<llvm::Value*>{from_expr});
       cgen_state_->ir_builder_.CreateBr(extract_nullcheck_bb);
 
       cgen_state_->ir_builder_.SetInsertPoint(extract_nullcheck_bb);
       extract_nullcheck_value = cgen_state_->ir_builder_.CreatePHI(
           get_int_type(64, cgen_state_->context_), 2, "extract_value");
       extract_nullcheck_value->addIncoming(extract_call, null_check.cond_false_);
       extract_nullcheck_value->addIncoming(cgen_state_->inlineIntNull(extract_expr_ti),
                                            null_check.cond_true_);
     }
 
     // diamond codegen will set the insert point in its destructor. override it to
     // continue using the extract nullcheck bb
     CHECK(extract_nullcheck_bb);
     cgen_state_->ir_builder_.SetInsertPoint(extract_nullcheck_bb);
     CHECK(extract_nullcheck_value);
     return extract_nullcheck_value;
   } else {
     return cgen_state_->emitExternalCall(extract_fname,
                                          get_int_type(64, cgen_state_->context_),
                                          std::vector<llvm::Value*>{from_expr});
   }
 }

Here is the call graph for this function:

llvm::Value * CodeGenerator::codegen	(	const Analyzer::DateaddExpr *	dateadd_expr,
		const CompilationOptions &	co
	)

private

Definition at line 163 of file DateTimeIR.cpp.

References AUTOMATIC_IR_METADATA, cgen_state_, CHECK, codegen(), CgenState::context_, CgenState::emitExternalCall(), Analyzer::DateaddExpr::get_datetime_expr(), Analyzer::DateaddExpr::get_field(), get_int_type(), Analyzer::DateaddExpr::get_number_expr(), Analyzer::Expr::get_type_info(), inline_fixed_encoding_null_val(), inline_int_null_val(), DateTimeUtils::is_subsecond_dateadd_field(), kDATE, kTIMESTAMP, CgenState::llInt(), and Analyzer::DateaddExpr::use_fixed_encoding_null_val().

                                                                   {
   AUTOMATIC_IR_METADATA(cgen_state_);
   const auto& dateadd_expr_ti = dateadd_expr->get_type_info();
   CHECK(dateadd_expr_ti.get_type() == kTIMESTAMP || dateadd_expr_ti.get_type() == kDATE);
   auto datetime = codegen(dateadd_expr->get_datetime_expr(), true, co).front();
   CHECK(datetime->getType()->isIntegerTy(64));
   auto number = codegen(dateadd_expr->get_number_expr(), true, co).front();
 
   const auto& datetime_ti = dateadd_expr->get_datetime_expr()->get_type_info();
   std::vector<llvm::Value*> dateadd_args{
       cgen_state_->llInt(static_cast<int32_t>(dateadd_expr->get_field())),
       number,
       datetime};
   std::string dateadd_fname{"DateAdd"};
   if (is_subsecond_dateadd_field(dateadd_expr->get_field()) ||
       dateadd_expr_ti.is_high_precision_timestamp()) {
     dateadd_fname += "HighPrecision";
     dateadd_args.push_back(
         cgen_state_->llInt(static_cast<int32_t>(datetime_ti.get_dimension())));
   }
   if (!datetime_ti.get_notnull()) {
     auto null_val = dateadd_expr->use_fixed_encoding_null_val()
                         ? inline_fixed_encoding_null_val(datetime_ti)
                         : inline_int_null_val(datetime_ti);
     dateadd_args.push_back(cgen_state_->llInt((int64_t)null_val));
     dateadd_fname += "Nullable";
   }
   return cgen_state_->emitExternalCall(dateadd_fname,
                                        get_int_type(64, cgen_state_->context_),
                                        dateadd_args,
                                        {llvm::Attribute::NoUnwind,
                                         llvm::Attribute::ReadNone,
                                         llvm::Attribute::Speculatable});
 }

Here is the call graph for this function:

llvm::Value * CodeGenerator::codegen	(	const Analyzer::DatediffExpr *	datediff_expr,
		const CompilationOptions &	co
	)

private

Definition at line 199 of file DateTimeIR.cpp.

References AUTOMATIC_IR_METADATA, cgen_state_, CHECK, codegen(), CgenState::context_, CgenState::emitExternalCall(), Analyzer::DatediffExpr::get_end_expr(), Analyzer::DatediffExpr::get_field(), get_int_type(), Analyzer::DatediffExpr::get_start_expr(), Analyzer::Expr::get_type_info(), CgenState::inlineIntNull(), and CgenState::llInt().

                                                                   {
   AUTOMATIC_IR_METADATA(cgen_state_);
   auto start = codegen(datediff_expr->get_start_expr(), true, co).front();
   CHECK(start->getType()->isIntegerTy(64));
   auto end = codegen(datediff_expr->get_end_expr(), true, co).front();
   CHECK(end->getType()->isIntegerTy(32) || end->getType()->isIntegerTy(64));
   const auto& start_ti = datediff_expr->get_start_expr()->get_type_info();
   const auto& end_ti = datediff_expr->get_end_expr()->get_type_info();
   std::vector<llvm::Value*> datediff_args{
       cgen_state_->llInt(static_cast<int32_t>(datediff_expr->get_field())), start, end};
   std::string datediff_fname{"DateDiff"};
   if (start_ti.is_high_precision_timestamp() || end_ti.is_high_precision_timestamp()) {
     datediff_fname += "HighPrecision";
     datediff_args.push_back(
         cgen_state_->llInt(static_cast<int32_t>(start_ti.get_dimension())));
     datediff_args.push_back(
         cgen_state_->llInt(static_cast<int32_t>(end_ti.get_dimension())));
   }
   const auto& ret_ti = datediff_expr->get_type_info();
   if (!start_ti.get_notnull() || !end_ti.get_notnull()) {
     datediff_args.push_back(cgen_state_->inlineIntNull(ret_ti));
     datediff_fname += "Nullable";
   }
   return cgen_state_->emitExternalCall(
       datediff_fname, get_int_type(64, cgen_state_->context_), datediff_args);
 }

Here is the call graph for this function:

llvm::Value * CodeGenerator::codegen	(	const Analyzer::DatetruncExpr *	datetrunc_expr,
		const CompilationOptions &	co
	)

private

Definition at line 227 of file DateTimeIR.cpp.

References AUTOMATIC_IR_METADATA, cgen_state_, CHECK, codegen(), codegenDateTruncHighPrecisionTimestamps(), CgenState::context_, datetrunc_fname_lookup, dtMICROSECOND, dtMILLISECOND, dtNANOSECOND, dtSECOND, CgenState::emitExternalCall(), executor(), field(), Analyzer::DatetruncExpr::get_field(), Analyzer::DatetruncExpr::get_from_expr(), get_int_type(), Analyzer::Expr::get_type_info(), and CgenState::ir_builder_.

                                                                   {
   AUTOMATIC_IR_METADATA(cgen_state_);
   auto from_expr = codegen(datetrunc_expr->get_from_expr(), true, co).front();
   const auto& datetrunc_expr_ti = datetrunc_expr->get_from_expr()->get_type_info();
   CHECK(from_expr->getType()->isIntegerTy(64));
   DatetruncField const field = datetrunc_expr->get_field();
   if (datetrunc_expr_ti.is_high_precision_timestamp()) {
     return codegenDateTruncHighPrecisionTimestamps(from_expr, datetrunc_expr_ti, field);
   }
   static_assert(dtSECOND + 1 == dtMILLISECOND, "Please keep these consecutive.");
   static_assert(dtMILLISECOND + 1 == dtMICROSECOND, "Please keep these consecutive.");
   static_assert(dtMICROSECOND + 1 == dtNANOSECOND, "Please keep these consecutive.");
   if (dtSECOND <= field && field <= dtNANOSECOND) {
     return cgen_state_->ir_builder_.CreateCast(llvm::Instruction::CastOps::SExt,
                                                from_expr,
                                                get_int_type(64, cgen_state_->context_));
   }
   std::unique_ptr<CodeGenerator::NullCheckCodegen> nullcheck_codegen;
   const bool is_nullable = !datetrunc_expr_ti.get_notnull();
   if (is_nullable) {
     nullcheck_codegen = std::make_unique<NullCheckCodegen>(
         cgen_state_, executor(), from_expr, datetrunc_expr_ti, "date_trunc_nullcheck");
   }
   char const* const fname = datetrunc_fname_lookup.at(field);
   auto ret = cgen_state_->emitExternalCall(
       fname, get_int_type(64, cgen_state_->context_), {from_expr});
   if (is_nullable) {
     ret = nullcheck_codegen->finalize(ll_int(NULL_BIGINT, cgen_state_->context_), ret);
   }
   return ret;
 }

Here is the call graph for this function:

llvm::Value * CodeGenerator::codegen	(	const Analyzer::CharLengthExpr *	expr,
		const CompilationOptions &	co
	)

private

Definition at line 239 of file StringOpsIR.cpp.

References AUTOMATIC_IR_METADATA, cgen_state_, CHECK_EQ, codegen(), CgenState::context_, CompilationOptions::device_type, CgenState::emitCall(), CgenState::emitExternalCall(), Analyzer::CharLengthExpr::get_arg(), Analyzer::CharLengthExpr::get_calc_encoded_length(), get_int_type(), SQLTypeInfo::get_notnull(), Analyzer::Expr::get_type_info(), GPU, CgenState::inlineIntNull(), and CgenState::ir_builder_.

                                                                   {
   AUTOMATIC_IR_METADATA(cgen_state_);
   auto str_lv = codegen(expr->get_arg(), true, co);
   if (str_lv.size() != 3) {
     CHECK_EQ(size_t(1), str_lv.size());
     str_lv.push_back(cgen_state_->ir_builder_.CreateExtractValue(str_lv.front(), 0));
     str_lv.push_back(cgen_state_->ir_builder_.CreateExtractValue(str_lv.front(), 1));
     str_lv.back() = cgen_state_->ir_builder_.CreateTrunc(
         str_lv.back(), llvm::Type::getInt32Ty(cgen_state_->context_));
     if (co.device_type == ExecutorDeviceType::GPU) {
       throw QueryMustRunOnCpu();
     }
   }
   std::vector<llvm::Value*> charlength_args{str_lv[1], str_lv[2]};
   std::string fn_name("char_length");
   if (expr->get_calc_encoded_length()) {
     fn_name += "_encoded";
   }
   const bool is_nullable{!expr->get_arg()->get_type_info().get_notnull()};
   if (is_nullable) {
     fn_name += "_nullable";
     charlength_args.push_back(cgen_state_->inlineIntNull(expr->get_type_info()));
   }
   return expr->get_calc_encoded_length()
              ? cgen_state_->emitExternalCall(
                    fn_name, get_int_type(32, cgen_state_->context_), charlength_args)
              : cgen_state_->emitCall(fn_name, charlength_args);
 }

Here is the call graph for this function:

llvm::Value * CodeGenerator::codegen	(	const Analyzer::KeyForStringExpr *	expr,
		const CompilationOptions &	co
	)

private

Definition at line 269 of file StringOpsIR.cpp.

References AUTOMATIC_IR_METADATA, cgen_state_, CHECK_EQ, codegen(), CgenState::emitCall(), and Analyzer::KeyForStringExpr::get_arg().

                                                                   {
   AUTOMATIC_IR_METADATA(cgen_state_);
   auto str_lv = codegen(expr->get_arg(), true, co);
   CHECK_EQ(size_t(1), str_lv.size());
   return cgen_state_->emitCall("key_for_string_encoded", str_lv);
 }

Here is the call graph for this function:

llvm::Value * CodeGenerator::codegen	(	const Analyzer::SampleRatioExpr *	expr,
		const CompilationOptions &	co
	)

private

Definition at line 278 of file IRCodegen.cpp.

References run_benchmark_import::args, AUTOMATIC_IR_METADATA, cgen_state_, CHECK, CHECK_EQ, codegen(), CgenState::context_, CgenState::emitCall(), executor(), Analyzer::SampleRatioExpr::get_arg(), kDOUBLE, ll_bool(), and posArg().

                                                                   {
   AUTOMATIC_IR_METADATA(cgen_state_);
   auto input_expr = expr->get_arg();
   CHECK(input_expr);
 
   auto double_lv = codegen(input_expr, true, co);
   CHECK_EQ(size_t(1), double_lv.size());
 
   std::unique_ptr<CodeGenerator::NullCheckCodegen> nullcheck_codegen;
   const bool is_nullable = !input_expr->get_type_info().get_notnull();
   if (is_nullable) {
     nullcheck_codegen = std::make_unique<NullCheckCodegen>(cgen_state_,
                                                            executor(),
                                                            double_lv.front(),
                                                            input_expr->get_type_info(),
                                                            "sample_ratio_nullcheck");
   }
   CHECK_EQ(input_expr->get_type_info().get_type(), kDOUBLE);
   std::vector<llvm::Value*> args{double_lv[0], posArg(nullptr)};
   auto ret = cgen_state_->emitCall("sample_ratio", args);
   if (nullcheck_codegen) {
     ret = nullcheck_codegen->finalize(ll_bool(false, cgen_state_->context_), ret);
   }
   return ret;
 }

Here is the call graph for this function:

llvm::Value * CodeGenerator::codegen	(	const Analyzer::WidthBucketExpr *	expr,
		const CompilationOptions &	co
	)

private

Definition at line 305 of file IRCodegen.cpp.

                                                                   {
   AUTOMATIC_IR_METADATA(cgen_state_);
   auto target_value_expr = expr->get_target_value();
   auto lower_bound_expr = expr->get_lower_bound();
   auto upper_bound_expr = expr->get_upper_bound();
   auto partition_count_expr = expr->get_partition_count();
   CHECK(target_value_expr);
   CHECK(lower_bound_expr);
   CHECK(upper_bound_expr);
   CHECK(partition_count_expr);
 
   auto is_constant_expr = [](const Analyzer::Expr* expr) {
     auto target_expr = expr;
     if (auto cast_expr = dynamic_cast<const Analyzer::UOper*>(expr)) {
       if (cast_expr->get_optype() == SQLOps::kCAST) {
         target_expr = cast_expr->get_operand();
       }
     }
     // there are more complex constant expr like 1+2, 1/2*3, and so on
     // but when considering a typical usage of width_bucket function
     // it is sufficient to consider a singleton constant expr
     auto constant_expr = dynamic_cast<const Analyzer::Constant*>(target_expr);
     if (constant_expr) {
       return true;
     }
     return false;
   };
   if (is_constant_expr(lower_bound_expr) && is_constant_expr(upper_bound_expr) &&
       is_constant_expr(partition_count_expr)) {
     expr->set_constant_expr();
   }
   // compute width_bucket's expresn range and check the possibility of avoiding oob check
   auto col_range =
       getExpressionRange(expr,
                          plan_state_->query_infos_,
                          executor_,
                          boost::make_optional(plan_state_->getSimpleQuals()));
   // check whether target_expr is valid
   if (col_range.getType() == ExpressionRangeType::Integer &&
       !expr->can_skip_out_of_bound_check() && col_range.getIntMin() > 0 &&
       col_range.getIntMax() <= expr->get_partition_count_val()) {
     // check whether target_col is not-nullable or has filter expr on it
     if (!col_range.hasNulls()) {
       // Even if the target_expr has its filter expression, target_col_range may exactly
       // the same with the col_range of the target_expr's operand col,
       // i.e., SELECT WIDTH_BUCKET(v1, 1, 10, 10) FROM T WHERE v1 != 1;
       // In that query, col_range of v1 with/without considering the filter expression
       // v1 != 1 have exactly the same col ranges, so we cannot recognize the existence
       // of the filter expression based on them. Also, is (not) null is located in
       // FilterNode, so we cannot trace it in here.
       // todo (yoonmin): relax this to allow skipping oob check more cases
       expr->skip_out_of_bound_check();
     }
   }
   return expr->is_constant_expr() ? codegenConstantWidthBucketExpr(expr, co)
                                   : codegenWidthBucketExpr(expr, co);
 }

Here is the call graph for this function:

llvm::Value * CodeGenerator::codegen	(	const Analyzer::MLPredictExpr *	expr,
		const CompilationOptions &	co
	)

private

Definition at line 288 of file MLPredictCodegen.cpp.

References CHECK, codegenLinRegPredict(), codegenTreeRegPredict(), DEBUG_TIMER, DECISION_TREE_REG, g_ml_models, GBT_REG, Analyzer::MLPredictExpr::get_model_value(), Analyzer::MLPredictExpr::get_regressor_values(), MLModelMap::getModel(), LINEAR_REG, and RANDOM_FOREST_REG.

                                                                   {
   auto timer = DEBUG_TIMER(__func__);
   const auto& model_expr = expr->get_model_value();
   CHECK(model_expr);
   auto model_constant_expr = dynamic_cast<const Analyzer::Constant*>(model_expr);
   CHECK(model_constant_expr);
   const auto model_datum = model_constant_expr->get_constval();
   const auto model_name_ptr = model_datum.stringval;
   CHECK(model_name_ptr);
   const auto model_name = *model_name_ptr;
   const auto abstract_model = g_ml_models.getModel(model_name);
   const auto model_type = abstract_model->getModelType();
   const auto& regressor_exprs = expr->get_regressor_values();
   if (abstract_model->getNumLogicalFeatures() !=
       static_cast<int64_t>(regressor_exprs.size())) {
     std::ostringstream error_oss;
     error_oss << "ML_PREDICT: Model '" << model_name
               << "' expects different number of predictor variables ("
               << abstract_model->getNumLogicalFeatures() << ") than provided ("
               << regressor_exprs.size() << ").";
     throw std::runtime_error(error_oss.str());
   }
 
   switch (model_type) {
     case MLModelType::LINEAR_REG: {
       return codegenLinRegPredict(expr, abstract_model, co);
     }
     case MLModelType::DECISION_TREE_REG:
     case MLModelType::GBT_REG:
     case MLModelType::RANDOM_FOREST_REG: {
       if (auto tree_model =
               std::dynamic_pointer_cast<AbstractTreeModel>(abstract_model)) {
         return codegenTreeRegPredict(expr, tree_model, co);
       } else {
         throw std::runtime_error(
             "Invalid ML model codegen call. Input model is not of expected type "
             "TreeModel.");
       }
     }
     default: {
       throw std::runtime_error("Unsupported model type.");
     }
   }
 }

Here is the call graph for this function:

llvm::Value * CodeGenerator::codegen	(	const Analyzer::PCAProjectExpr *	expr,
		const CompilationOptions &	co
	)

private

Definition at line 334 of file MLPredictCodegen.cpp.

References CHECK, codegenArith(), DEBUG_TIMER, Datum::doubleval, executor(), g_ml_models, generated_encoded_and_casted_features(), Analyzer::Constant::get_constval(), Analyzer::PCAProjectExpr::get_feature_values(), Analyzer::PCAProjectExpr::get_model_value(), Analyzer::PCAProjectExpr::get_pc_dimension_value(), MLModelMap::getModel(), Datum::intval, kDIVIDE, kDOUBLE, kMINUS, kMULTIPLY, kONE, kPLUS, PCA, and run_benchmark_import::result.

                                                                   {
   auto timer = DEBUG_TIMER(__func__);
   const auto& model_expr = expr->get_model_value();
   CHECK(model_expr);
   auto model_constant_expr = dynamic_cast<const Analyzer::Constant*>(model_expr);
   CHECK(model_constant_expr);
   const auto model_datum = model_constant_expr->get_constval();
   const auto model_name_ptr = model_datum.stringval;
   CHECK(model_name_ptr);
   const auto model_name = *model_name_ptr;
   const auto abstract_model = g_ml_models.getModel(model_name);
   const auto model_type = abstract_model->getModelType();
   if (model_type != MLModelType::PCA) {
     throw std::runtime_error("PCA_PROJECT: Model '" + model_name +
                              "' is not a PCA model.");
   }
   const auto pca_model = std::dynamic_pointer_cast<PcaModel>(abstract_model);
   const auto& feature_exprs = expr->get_feature_values();
   if (pca_model->getNumLogicalFeatures() != static_cast<int64_t>(feature_exprs.size())) {
     std::ostringstream error_oss;
     error_oss << "PCA_PROJECT: Model '" << model_name
               << "' expects different number of predictor variables ("
               << pca_model->getNumLogicalFeatures() << ") than provided ("
               << feature_exprs.size() << ").";
     throw std::runtime_error(error_oss.str());
   }
 
   const auto& pc_dimension_expr = expr->get_pc_dimension_value();
   auto pc_dimension_const_expr =
       dynamic_cast<const Analyzer::Constant*>(pc_dimension_expr);
   const auto pc_dimension_datum = pc_dimension_const_expr->get_constval();
   const auto pc_dimension = pc_dimension_datum.intval - 1;
   if (pc_dimension < 0 || pc_dimension >= pca_model->getNumFeatures()) {
     std::ostringstream error_oss;
     error_oss << "PCA_PROJECT: Invalid PC dimension (" << pc_dimension + 1
               << ") provided. Valid range is [1, " << pca_model->getNumFeatures() << "].";
     throw std::runtime_error(error_oss.str());
   }
 
   const auto& column_means = pca_model->getColumnMeans();
   const auto& column_std_devs = pca_model->getColumnStdDevs();
   const auto& eigenvectors = pca_model->getEigenvectors();
 
   const auto& cat_feature_keys = pca_model->getCatFeatureKeys();
 
   const auto casted_feature_exprs = generated_encoded_and_casted_features(
       feature_exprs,
       cat_feature_keys,
       pca_model->getModelMetadata().getFeaturePermutations(),
       executor());
 
   auto get_double_constant_expr = [](double const_val) {
     Datum d;
     d.doubleval = const_val;
     return makeExpr<Analyzer::Constant>(SQLTypeInfo(kDOUBLE, false), false, d);
   };
 
   std::shared_ptr<Analyzer::Expr> result;
 
   for (size_t feature_idx = 0; feature_idx < feature_exprs.size(); ++feature_idx) {
     auto mean_expr = get_double_constant_expr(column_means[feature_idx]);
     const auto& casted_feature_expr = casted_feature_exprs[feature_idx];
     // Subtract column mean from feature
     auto mean_diff_expr = makeExpr<Analyzer::BinOper>(
         SQLTypeInfo(kDOUBLE, false), false, kMINUS, kONE, casted_feature_expr, mean_expr);
     auto std_dev_expr = get_double_constant_expr(column_std_devs[feature_idx]);
     auto z_score_expr = makeExpr<Analyzer::BinOper>(
         SQLTypeInfo(kDOUBLE, false), false, kDIVIDE, kONE, mean_diff_expr, std_dev_expr);
     auto pc_term_expr = get_double_constant_expr(eigenvectors[pc_dimension][feature_idx]);
     auto pca_mul_expr = makeExpr<Analyzer::BinOper>(
         SQLTypeInfo(kDOUBLE, false), false, kMULTIPLY, kONE, z_score_expr, pc_term_expr);
     if (feature_idx == 0) {
       // There is no result yet, so set the result to the first term
       result = pca_mul_expr;
     } else {
       // Add the term to the result
       result = makeExpr<Analyzer::BinOper>(
           SQLTypeInfo(kDOUBLE, false), false, kPLUS, kONE, result, pca_mul_expr);
     }
   }
 
   // The following will codegen the expression tree we just created modeling
   // the linear regression formula
   return codegenArith(dynamic_cast<Analyzer::BinOper*>(result.get()), co);
 }

Here is the call graph for this function:

llvm::Value * CodeGenerator::codegen	(	const Analyzer::StringOper *	expr,
		const CompilationOptions &	co
	)

private

Definition at line 533 of file StringOpsIR.cpp.

References AUTOMATIC_IR_METADATA, cgen_state_, CHECK_EQ, CHECK_GE, codegen(), StringDictionaryTranslationMgr::codegen(), codegenPerRowStringOper(), CompilationOptions::device_type, executor(), Analyzer::Expr::get_type_info(), Analyzer::StringOper::getArg(), Analyzer::StringOper::getArity(), CgenState::moveStringDictionaryTranslationMgr(), Analyzer::StringOper::requiresPerRowTranslation(), and translate_dict_strings().

                                                                   {
   CHECK_GE(expr->getArity(), 1UL);
   if (expr->requiresPerRowTranslation()) {
     return codegenPerRowStringOper(expr, co);
   }
 
   AUTOMATIC_IR_METADATA(cgen_state_);
 
   auto string_dictionary_translation_mgr =
       translate_dict_strings(expr, co.device_type, executor());
 
   auto str_id_lv = codegen(expr->getArg(0), true, co);
   CHECK_EQ(size_t(1), str_id_lv.size());
   const auto& expr_ti = expr->get_type_info();
 
   return cgen_state_
       ->moveStringDictionaryTranslationMgr(std::move(string_dictionary_translation_mgr))
       ->codegen(str_id_lv[0], expr_ti, true /* add_nullcheck */, co);
 }

Here is the call graph for this function:

llvm::Value * CodeGenerator::codegen	(	const Analyzer::LikeExpr *	expr,
		const CompilationOptions &	co
	)

private

Definition at line 587 of file StringOpsIR.cpp.

References AUTOMATIC_IR_METADATA, cgen_state_, CHECK, CHECK_EQ, codegen(), codegenDictLike(), CgenState::context_, CompilationOptions::device_type, CgenState::emitCall(), extract_cast_arg(), g_enable_watchdog, Analyzer::LikeExpr::get_arg(), Analyzer::LikeExpr::get_escape_expr(), Analyzer::LikeExpr::get_is_ilike(), Analyzer::LikeExpr::get_is_simple(), Analyzer::LikeExpr::get_like_expr(), SQLTypeInfo::get_notnull(), Analyzer::LikeExpr::get_own_arg(), Analyzer::Expr::get_type_info(), GPU, CgenState::inlineIntNull(), CgenState::ir_builder_, is_unnest(), kENCODING_NONE, and CgenState::llInt().

                                                                   {
   AUTOMATIC_IR_METADATA(cgen_state_);
   if (is_unnest(extract_cast_arg(expr->get_arg()))) {
     throw std::runtime_error("LIKE not supported for unnested expressions");
   }
   char escape_char{'\\'};
   if (expr->get_escape_expr()) {
     auto escape_char_expr =
         dynamic_cast<const Analyzer::Constant*>(expr->get_escape_expr());
     CHECK(escape_char_expr);
     CHECK(escape_char_expr->get_type_info().is_string());
     CHECK_EQ(size_t(1), escape_char_expr->get_constval().stringval->size());
     escape_char = (*escape_char_expr->get_constval().stringval)[0];
   }
   auto pattern = dynamic_cast<const Analyzer::Constant*>(expr->get_like_expr());
   CHECK(pattern);
   auto fast_dict_like_lv = codegenDictLike(expr->get_own_arg(),
                                            pattern,
                                            expr->get_is_ilike(),
                                            expr->get_is_simple(),
                                            escape_char,
                                            co);
   if (fast_dict_like_lv) {
     return fast_dict_like_lv;
   }
   const auto& ti = expr->get_arg()->get_type_info();
   CHECK(ti.is_string());
   if (g_enable_watchdog && ti.get_compression() != kENCODING_NONE) {
     throw WatchdogException(
         "Cannot do LIKE / ILIKE on this dictionary encoded column, its cardinality is "
         "too high");
   }
   auto str_lv = codegen(expr->get_arg(), true, co);
   if (str_lv.size() != 3) {
     CHECK_EQ(size_t(1), str_lv.size());
     str_lv.push_back(cgen_state_->ir_builder_.CreateExtractValue(str_lv.front(), 0));
     str_lv.push_back(cgen_state_->ir_builder_.CreateExtractValue(str_lv.front(), 1));
     str_lv.back() = cgen_state_->ir_builder_.CreateTrunc(
         str_lv.back(), llvm::Type::getInt32Ty(cgen_state_->context_));
     if (co.device_type == ExecutorDeviceType::GPU) {
       throw QueryMustRunOnCpu();
     }
   }
   auto like_expr_arg_lvs = codegen(expr->get_like_expr(), true, co);
   CHECK_EQ(size_t(3), like_expr_arg_lvs.size());
   const bool is_nullable{!expr->get_arg()->get_type_info().get_notnull()};
   std::vector<llvm::Value*> str_like_args{str_lv[1],
                                           str_lv[2],
                                           like_expr_arg_lvs[1],
                                           like_expr_arg_lvs[2],
                                           cgen_state_->llInt(int8_t(escape_char))};
   std::string fn_name{expr->get_is_ilike() ? "string_ilike" : "string_like"};
   if (expr->get_is_simple()) {
     fn_name += "_simple";
   }
   if (is_nullable) {
     fn_name += "_nullable";
     str_like_args.push_back(cgen_state_->inlineIntNull(expr->get_type_info()));
   }
   return cgen_state_->emitCall(fn_name, str_like_args);
 }

Here is the call graph for this function:

llvm::Value * CodeGenerator::codegen	(	const Analyzer::RegexpExpr *	expr,
		const CompilationOptions &	co
	)

private

Definition at line 845 of file StringOpsIR.cpp.

References AUTOMATIC_IR_METADATA, cgen_state_, CHECK, CHECK_EQ, codegen(), codegenDictRegexp(), CgenState::context_, CompilationOptions::device_type, CgenState::emitExternalCall(), extract_cast_arg(), g_enable_watchdog, Analyzer::RegexpExpr::get_arg(), Analyzer::RegexpExpr::get_escape_expr(), get_int_type(), SQLTypeInfo::get_notnull(), Analyzer::RegexpExpr::get_own_arg(), Analyzer::RegexpExpr::get_pattern_expr(), Analyzer::Expr::get_type_info(), GPU, CgenState::inlineIntNull(), CgenState::ir_builder_, is_unnest(), kENCODING_NONE, and CgenState::llInt().

                                                                   {
   AUTOMATIC_IR_METADATA(cgen_state_);
   if (is_unnest(extract_cast_arg(expr->get_arg()))) {
     throw std::runtime_error("REGEXP not supported for unnested expressions");
   }
   char escape_char{'\\'};
   if (expr->get_escape_expr()) {
     auto escape_char_expr =
         dynamic_cast<const Analyzer::Constant*>(expr->get_escape_expr());
     CHECK(escape_char_expr);
     CHECK(escape_char_expr->get_type_info().is_string());
     CHECK_EQ(size_t(1), escape_char_expr->get_constval().stringval->size());
     escape_char = (*escape_char_expr->get_constval().stringval)[0];
   }
   auto pattern = dynamic_cast<const Analyzer::Constant*>(expr->get_pattern_expr());
   CHECK(pattern);
   auto fast_dict_pattern_lv =
       codegenDictRegexp(expr->get_own_arg(), pattern, escape_char, co);
   if (fast_dict_pattern_lv) {
     return fast_dict_pattern_lv;
   }
   const auto& ti = expr->get_arg()->get_type_info();
   CHECK(ti.is_string());
   if (g_enable_watchdog && ti.get_compression() != kENCODING_NONE) {
     throw WatchdogException(
         "Cannot do REGEXP_LIKE on this dictionary encoded column, its cardinality is too "
         "high");
   }
   // Now we know we are working on NONE ENCODED column. So switch back to CPU
   if (co.device_type == ExecutorDeviceType::GPU) {
     throw QueryMustRunOnCpu();
   }
   auto str_lv = codegen(expr->get_arg(), true, co);
   if (str_lv.size() != 3) {
     CHECK_EQ(size_t(1), str_lv.size());
     str_lv.push_back(cgen_state_->ir_builder_.CreateExtractValue(str_lv.front(), 0));
     str_lv.push_back(cgen_state_->ir_builder_.CreateExtractValue(str_lv.front(), 1));
     str_lv.back() = cgen_state_->ir_builder_.CreateTrunc(
         str_lv.back(), llvm::Type::getInt32Ty(cgen_state_->context_));
   }
   auto regexp_expr_arg_lvs = codegen(expr->get_pattern_expr(), true, co);
   CHECK_EQ(size_t(3), regexp_expr_arg_lvs.size());
   const bool is_nullable{!expr->get_arg()->get_type_info().get_notnull()};
   std::vector<llvm::Value*> regexp_args{
       str_lv[1], str_lv[2], regexp_expr_arg_lvs[1], regexp_expr_arg_lvs[2]};
   std::string fn_name("regexp_like");
   regexp_args.push_back(cgen_state_->llInt(int8_t(escape_char)));
   if (is_nullable) {
     fn_name += "_nullable";
     regexp_args.push_back(cgen_state_->inlineIntNull(expr->get_type_info()));
     return cgen_state_->emitExternalCall(
         fn_name, get_int_type(8, cgen_state_->context_), regexp_args);
   }
   return cgen_state_->emitExternalCall(
       fn_name, get_int_type(1, cgen_state_->context_), regexp_args);
 }

Here is the call graph for this function:

llvm::Value * CodeGenerator::codegen	(	const Analyzer::CardinalityExpr *	expr,
		const CompilationOptions &	co
	)

private

Definition at line 68 of file ArrayIR.cpp.

References AUTOMATIC_IR_METADATA, cgen_state_, CHECK, codegen(), CgenState::context_, CgenState::emitExternalCall(), Analyzer::CardinalityExpr::get_arg(), get_int_type(), Analyzer::Expr::get_type_info(), CgenState::inlineIntNull(), CgenState::llInt(), log2_bytes(), and posArg().

                                                                   {
   AUTOMATIC_IR_METADATA(cgen_state_);
   const auto arr_expr = expr->get_arg();
   const auto& array_ti = arr_expr->get_type_info();
   CHECK(array_ti.is_array());
   const auto& elem_ti = array_ti.get_elem_type();
   auto arr_lv = codegen(arr_expr, true, co);
   std::string fn_name("array_size");
 
   if (auto alloca = llvm::dyn_cast<llvm::AllocaInst>(arr_lv.front())) {
     if (alloca->getAllocatedType()->isStructTy()) {
       throw std::runtime_error("Unsupported type used in 'cardinality'");
     }
   }
 
   std::vector<llvm::Value*> array_size_args{
       arr_lv.front(),
       posArg(arr_expr),
       cgen_state_->llInt(log2_bytes(elem_ti.get_logical_size()))};
   const bool is_nullable{!arr_expr->get_type_info().get_notnull()};
   if (is_nullable) {
     fn_name += "_nullable";
     array_size_args.push_back(cgen_state_->inlineIntNull(expr->get_type_info()));
   }
   return cgen_state_->emitExternalCall(
       fn_name, get_int_type(32, cgen_state_->context_), array_size_args);
 }

Here is the call graph for this function:

llvm::Value * CodeGenerator::codegen	(	const Analyzer::BinOper *	bin_oper,
		const CompilationOptions &	co
	)

private

Definition at line 234 of file IRCodegen.cpp.

References AUTOMATIC_IR_METADATA, cgen_state_, codegenArith(), codegenArrayAt(), codegenCmp(), codegenLogical(), Analyzer::BinOper::get_optype(), IS_ARITHMETIC, IS_COMPARISON, IS_LOGIC, and kARRAY_AT.

                                                                   {
   AUTOMATIC_IR_METADATA(cgen_state_);
   const auto optype = bin_oper->get_optype();
   if (IS_ARITHMETIC(optype)) {
     return codegenArith(bin_oper, co);
   }
   if (IS_COMPARISON(optype)) {
     return codegenCmp(bin_oper, co);
   }
   if (IS_LOGIC(optype)) {
     return codegenLogical(bin_oper, co);
   }
   if (optype == kARRAY_AT) {
     return codegenArrayAt(bin_oper, co);
   }
   abort();
 }

Here is the call graph for this function:

llvm::Value * CodeGenerator::codegen	(	const Analyzer::UOper *	u_oper,
		const CompilationOptions &	co
	)

private

Definition at line 253 of file IRCodegen.cpp.

References AUTOMATIC_IR_METADATA, cgen_state_, codegenCast(), codegenIsNull(), codegenLogical(), codegenUMinus(), codegenUnnest(), Analyzer::UOper::get_optype(), kCAST, kISNULL, kNOT, kUMINUS, kUNNEST, and UNREACHABLE.

                                                                   {
   AUTOMATIC_IR_METADATA(cgen_state_);
   const auto optype = u_oper->get_optype();
   switch (optype) {
     case kNOT: {
       return codegenLogical(u_oper, co);
     }
     case kCAST: {
       return codegenCast(u_oper, co);
     }
     case kUMINUS: {
       return codegenUMinus(u_oper, co);
     }
     case kISNULL: {
       return codegenIsNull(u_oper, co);
     }
     case kUNNEST:
       return codegenUnnest(u_oper, co);
     default:
       UNREACHABLE();
   }
   return nullptr;
 }

Here is the call graph for this function:

llvm::Value * CodeGenerator::codegenAdd	(	const Analyzer::BinOper *	bin_oper,
		llvm::Value *	lhs_lv,
		llvm::Value *	rhs_lv,
		const std::string &	null_typename,
		const std::string &	null_check_suffix,
		const SQLTypeInfo &	ti,
		const CompilationOptions &	co
	)

private

Definition at line 219 of file ArithmeticIR.cpp.

References AUTOMATIC_IR_METADATA, cgen_state_, CHECK, CHECK_EQ, checkExpressionRanges(), codegenBinOpWithOverflowForCPU(), codegenSkipOverflowCheckForNull(), CgenState::context_, CPU, CgenState::current_func_, CompilationOptions::device_type, CgenState::emitCall(), SQLTypeInfo::get_size(), inline_int_null_val(), CgenState::inlineIntMaxMin(), CgenState::ir_builder_, SQLTypeInfo::is_decimal(), SQLTypeInfo::is_integer(), SQLTypeInfo::is_timeinterval(), CgenState::llInt(), and CgenState::needs_error_check_.

Referenced by codegenIntArith().

                                                                      {
   AUTOMATIC_IR_METADATA(cgen_state_);
   CHECK_EQ(lhs_lv->getType(), rhs_lv->getType());
   CHECK(ti.is_integer() || ti.is_decimal() || ti.is_timeinterval());
   llvm::Value* chosen_max{nullptr};
   llvm::Value* chosen_min{nullptr};
   std::tie(chosen_max, chosen_min) = cgen_state_->inlineIntMaxMin(ti.get_size(), true);
   auto need_overflow_check =
       !checkExpressionRanges(bin_oper,
                              static_cast<llvm::ConstantInt*>(chosen_min)->getSExtValue(),
                              static_cast<llvm::ConstantInt*>(chosen_max)->getSExtValue());
 
   if (need_overflow_check && co.device_type == ExecutorDeviceType::CPU) {
     return codegenBinOpWithOverflowForCPU(
         bin_oper, lhs_lv, rhs_lv, null_check_suffix, ti);
   }
 
   llvm::BasicBlock* add_ok{nullptr};
   llvm::BasicBlock* add_fail{nullptr};
   if (need_overflow_check) {
     cgen_state_->needs_error_check_ = true;
     add_ok = llvm::BasicBlock::Create(
         cgen_state_->context_, "add_ok", cgen_state_->current_func_);
     if (!null_check_suffix.empty()) {
       codegenSkipOverflowCheckForNull(lhs_lv, rhs_lv, add_ok, ti);
     }
     add_fail = llvm::BasicBlock::Create(
         cgen_state_->context_, "add_fail", cgen_state_->current_func_);
     llvm::Value* detected{nullptr};
     auto const_zero = llvm::ConstantInt::get(lhs_lv->getType(), 0, true);
     auto overflow = cgen_state_->ir_builder_.CreateAnd(
         cgen_state_->ir_builder_.CreateICmpSGT(lhs_lv, const_zero),
         cgen_state_->ir_builder_.CreateICmpSGT(
             rhs_lv, cgen_state_->ir_builder_.CreateSub(chosen_max, lhs_lv)));
     auto underflow = cgen_state_->ir_builder_.CreateAnd(
         cgen_state_->ir_builder_.CreateICmpSLT(lhs_lv, const_zero),
         cgen_state_->ir_builder_.CreateICmpSLT(
             rhs_lv, cgen_state_->ir_builder_.CreateSub(chosen_min, lhs_lv)));
     detected = cgen_state_->ir_builder_.CreateOr(overflow, underflow);
     cgen_state_->ir_builder_.CreateCondBr(detected, add_fail, add_ok);
     cgen_state_->ir_builder_.SetInsertPoint(add_ok);
   }
   auto ret = null_check_suffix.empty()
                  ? cgen_state_->ir_builder_.CreateAdd(lhs_lv, rhs_lv)
                  : cgen_state_->emitCall(
                        "add_" + null_typename + null_check_suffix,
                        {lhs_lv, rhs_lv, cgen_state_->llInt(inline_int_null_val(ti))});
   if (need_overflow_check) {
     cgen_state_->ir_builder_.SetInsertPoint(add_fail);
     cgen_state_->ir_builder_.CreateRet(
         cgen_state_->llInt(int32_t(ErrorCode::OVERFLOW_OR_UNDERFLOW)));
     cgen_state_->ir_builder_.SetInsertPoint(add_ok);
   }
   return ret;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

llvm::Value * CodeGenerator::codegenArith	(	const Analyzer::BinOper *	bin_oper,
		const CompilationOptions &	co
	)

private

Definition at line 38 of file ArithmeticIR.cpp.

References AUTOMATIC_IR_METADATA, cgen_state_, CHECK, CHECK_EQ, codegen(), codegenCastBetweenIntTypes(), codegenDeciDiv(), codegenFpArith(), codegenIntArith(), Analyzer::BinOper::get_left_operand(), Analyzer::BinOper::get_optype(), Analyzer::BinOper::get_right_operand(), Analyzer::Expr::get_type_info(), IS_ARITHMETIC, and kDIVIDE.

Referenced by codegen(), and codegenLinRegPredict().

                                                                        {
   AUTOMATIC_IR_METADATA(cgen_state_);
   const auto optype = bin_oper->get_optype();
   CHECK(IS_ARITHMETIC(optype));
   const auto lhs = bin_oper->get_left_operand();
   const auto rhs = bin_oper->get_right_operand();
   const auto& lhs_type = lhs->get_type_info();
   const auto& rhs_type = rhs->get_type_info();
 
   if (lhs_type.is_decimal() && rhs_type.is_decimal() && optype == kDIVIDE) {
     const auto ret = codegenDeciDiv(bin_oper, co);
     if (ret) {
       return ret;
     }
   }
 
   auto lhs_lv = codegen(lhs, true, co).front();
   auto rhs_lv = codegen(rhs, true, co).front();
   // Handle operations when a time interval operand is involved, an operation
   // between an integer and a time interval isn't normalized by the analyzer.
   if (lhs_type.is_timeinterval()) {
     rhs_lv = codegenCastBetweenIntTypes(rhs_lv, rhs_type, lhs_type);
   } else if (rhs_type.is_timeinterval()) {
     lhs_lv = codegenCastBetweenIntTypes(lhs_lv, lhs_type, rhs_type);
   } else {
     CHECK_EQ(lhs_type.get_type(), rhs_type.get_type());
   }
   if (lhs_type.is_integer() || lhs_type.is_decimal() || lhs_type.is_timeinterval()) {
     return codegenIntArith(bin_oper, lhs_lv, rhs_lv, co);
   }
   if (lhs_type.is_fp()) {
     return codegenFpArith(bin_oper, lhs_lv, rhs_lv);
   }
   CHECK(false);
   return nullptr;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

llvm::Value * CodeGenerator::codegenArrayAt	(	const Analyzer::BinOper *	array_at,
		const CompilationOptions &	co
	)

private

Definition at line 26 of file ArrayIR.cpp.

References AUTOMATIC_IR_METADATA, cgen_state_, CHECK, CHECK_EQ, codegen(), CgenState::context_, CgenState::emitExternalCall(), get_int_type(), Analyzer::BinOper::get_left_operand(), Analyzer::BinOper::get_right_operand(), Analyzer::Expr::get_type_info(), CgenState::inlineFpNull(), CgenState::inlineIntNull(), CgenState::ir_builder_, kDOUBLE, posArg(), and to_string().

Referenced by codegen().

                                                                          {
   AUTOMATIC_IR_METADATA(cgen_state_);
   const auto arr_expr = array_at->get_left_operand();
   const auto idx_expr = array_at->get_right_operand();
   const auto& idx_ti = idx_expr->get_type_info();
   CHECK(idx_ti.is_integer());
   auto idx_lvs = codegen(idx_expr, true, co);
   CHECK_EQ(size_t(1), idx_lvs.size());
   auto idx_lv = idx_lvs.front();
   if (idx_ti.get_logical_size() < 8) {
     idx_lv = cgen_state_->ir_builder_.CreateCast(llvm::Instruction::CastOps::SExt,
                                                  idx_lv,
                                                  get_int_type(64, cgen_state_->context_));
   }
   const auto& array_ti = arr_expr->get_type_info();
   CHECK(array_ti.is_array());
   const auto& elem_ti = array_ti.get_elem_type();
   const std::string array_at_fname{
       elem_ti.is_fp()
           ? "array_at_" + std::string(elem_ti.get_type() == kDOUBLE ? "double_checked"
                                                                     : "float_checked")
           : "array_at_int" + std::to_string(elem_ti.get_logical_size() * 8) +
                 "_t_checked"};
   const auto ret_ty =
       elem_ti.is_fp()
           ? (elem_ti.get_type() == kDOUBLE
                  ? llvm::Type::getDoubleTy(cgen_state_->context_)
                  : llvm::Type::getFloatTy(cgen_state_->context_))
           : get_int_type(elem_ti.get_logical_size() * 8, cgen_state_->context_);
   const auto arr_lvs = codegen(arr_expr, true, co);
   CHECK_EQ(size_t(1), arr_lvs.size());
   return cgen_state_->emitExternalCall(
       array_at_fname,
       ret_ty,
       {arr_lvs.front(),
        posArg(arr_expr),
        idx_lv,
        elem_ti.is_fp() ? static_cast<llvm::Value*>(cgen_state_->inlineFpNull(elem_ti))
                        : static_cast<llvm::Value*>(cgen_state_->inlineIntNull(elem_ti))});
 }

Here is the call graph for this function:

Here is the caller graph for this function:

std::pair< llvm::Value , llvm::Value > CodeGenerator::codegenArrayBuff	(	llvm::Value *	chunk,
		llvm::Value *	row_pos,
		SQLTypes	array_type,
		bool	cast_and_extend
	)

private

Definition at line 685 of file ExtensionsIR.cpp.

References AUTOMATIC_IR_METADATA, cgen_state_, CgenState::context_, CgenState::emitExternalCall(), SQLTypeInfo::get_elem_type(), kARRAY, and kENCODING_NONE.

Referenced by codegenFunctionOperCastArgs().

                           {
   AUTOMATIC_IR_METADATA(cgen_state_);
   const auto elem_ti =
       SQLTypeInfo(
           SQLTypes::kARRAY, 0, 0, false, EncodingType::kENCODING_NONE, 0, array_type)
           .get_elem_type();
 
   auto buff = cgen_state_->emitExternalCall(
       "array_buff", llvm::Type::getInt32PtrTy(cgen_state_->context_), {chunk, row_pos});
 
   auto len = cgen_state_->emitExternalCall(
       "array_size",
       get_int_type(32, cgen_state_->context_),
       {chunk, row_pos, cgen_state_->llInt(log2_bytes(elem_ti.get_logical_size()))});
 
   if (cast_and_extend) {
     buff = castArrayPointer(buff, elem_ti);
     len =
         cgen_state_->ir_builder_.CreateZExt(len, get_int_type(64, cgen_state_->context_));
   }
 
   return std::make_pair(buff, len);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

std::vector< llvm::Value * > CodeGenerator::codegenArrayExpr	(	const Analyzer::ArrayExpr *	array_expr,
		const CompilationOptions &	co
	)

private

Definition at line 97 of file ArrayIR.cpp.

References AUTOMATIC_IR_METADATA, cgen_state_, CHECK, codegen(), CgenState::context_, CompilationOptions::device_type, CgenState::emitExternalCall(), executor(), get_int_array_type(), get_int_type(), Analyzer::Expr::get_type_info(), Analyzer::ArrayExpr::getElement(), Analyzer::ArrayExpr::getElementCount(), GPU, CgenState::ir_builder_, Analyzer::ArrayExpr::isLocalAlloc(), Analyzer::ArrayExpr::isNull(), kENCODING_GEOINT, CgenState::llFp(), and CgenState::llInt().

Referenced by codegen().

                                   {
   AUTOMATIC_IR_METADATA(cgen_state_);
   using ValueVector = std::vector<llvm::Value*>;
   ValueVector argument_list;
   auto& ir_builder(cgen_state_->ir_builder_);
 
   const auto& return_type = array_expr->get_type_info();
   auto coord_compression = (return_type.get_compression() == kENCODING_GEOINT);
   if (coord_compression) {
     CHECK(array_expr->isLocalAlloc() && array_expr->getElementCount() == 2);
   }
   for (size_t i = 0; i < array_expr->getElementCount(); i++) {
     const auto arg = array_expr->getElement(i);
     const auto arg_lvs = codegen(arg, true, co);
     if (arg_lvs.size() == 1) {
       if (coord_compression) {
         // Compress double coords on the fly
         auto mult = cgen_state_->llFp(2147483647.0 / (i == 0 ? 180.0 : 90.0));
         auto c = ir_builder.CreateCast(llvm::Instruction::CastOps::FPToSI,
                                        ir_builder.CreateFMul(arg_lvs.front(), mult),
                                        get_int_type(32, cgen_state_->context_));
         argument_list.push_back(c);
       } else {
         argument_list.push_back(arg_lvs.front());
       }
     } else {
       throw std::runtime_error(
           "Unexpected argument count during array[] code generation.");
     }
   }
 
   auto array_element_size_bytes =
       return_type.get_elem_type().get_array_context_logical_size();
   auto* array_index_type =
       get_int_type(array_element_size_bytes * 8, cgen_state_->context_);
   auto* array_type = get_int_array_type(
       array_element_size_bytes * 8, array_expr->getElementCount(), cgen_state_->context_);
 
   if (array_expr->isNull()) {
     return {llvm::ConstantPointerNull::get(
                 llvm::PointerType::get(get_int_type(64, cgen_state_->context_), 0)),
             cgen_state_->llInt(0)};
   }
 
   if (0 == array_expr->getElementCount()) {
     llvm::Constant* dead_const = cgen_state_->llInt(0xdead);
     llvm::Value* dead_pointer = llvm::ConstantExpr::getIntToPtr(
         dead_const, llvm::PointerType::get(get_int_type(64, cgen_state_->context_), 0));
     return {dead_pointer, cgen_state_->llInt(0)};
   }
 
   llvm::Value* allocated_target_buffer;
   if (array_expr->isLocalAlloc()) {
     allocated_target_buffer = ir_builder.CreateAlloca(array_type);
   } else {
     if (co.device_type == ExecutorDeviceType::GPU) {
       throw QueryMustRunOnCpu();
     }
 
     allocated_target_buffer =
         cgen_state_->emitExternalCall("allocate_varlen_buffer",
                                       llvm::Type::getInt8PtrTy(cgen_state_->context_),
                                       {cgen_state_->llInt(array_expr->getElementCount()),
                                        cgen_state_->llInt(array_element_size_bytes)});
     cgen_state_->emitExternalCall(
         "register_buffer_with_executor_rsm",
         llvm::Type::getVoidTy(cgen_state_->context_),
         {cgen_state_->llInt(reinterpret_cast<int64_t>(executor())),
          allocated_target_buffer});
   }
   llvm::Value* casted_allocated_target_buffer =
       ir_builder.CreatePointerCast(allocated_target_buffer, array_type->getPointerTo());
 
   for (size_t i = 0; i < array_expr->getElementCount(); i++) {
     auto* element = argument_list[i];
     auto* element_ptr = ir_builder.CreateGEP(
         array_type,
         casted_allocated_target_buffer,
         std::vector<llvm::Value*>{cgen_state_->llInt(0), cgen_state_->llInt(i)});
 
     const auto& elem_ti = return_type.get_elem_type();
     if (elem_ti.is_boolean()) {
       const auto byte_casted_bit =
           ir_builder.CreateIntCast(element, array_index_type, true);
       ir_builder.CreateStore(byte_casted_bit, element_ptr);
     } else if (elem_ti.is_fp()) {
       switch (elem_ti.get_size()) {
         case sizeof(double): {
           const auto double_element_ptr = ir_builder.CreatePointerCast(
               element_ptr, llvm::Type::getDoublePtrTy(cgen_state_->context_));
           ir_builder.CreateStore(element, double_element_ptr);
           break;
         }
         case sizeof(float): {
           const auto float_element_ptr = ir_builder.CreatePointerCast(
               element_ptr, llvm::Type::getFloatPtrTy(cgen_state_->context_));
           ir_builder.CreateStore(element, float_element_ptr);
           break;
         }
         default:
           UNREACHABLE();
       }
     } else if (elem_ti.is_integer() || elem_ti.is_decimal() || elem_ti.is_date() ||
                elem_ti.is_timestamp() || elem_ti.is_time() || elem_ti.is_timeinterval() ||
                elem_ti.is_dict_encoded_string()) {
       // TODO(adb): this validation and handling should be done elsewhere
       const auto sign_extended_element = ir_builder.CreateSExt(element, array_index_type);
       ir_builder.CreateStore(sign_extended_element, element_ptr);
     } else {
       throw std::runtime_error("Unsupported type used in ARRAY construction.");
     }
   }
 
   return {ir_builder.CreateGEP(
               array_type, casted_allocated_target_buffer, cgen_state_->llInt(0)),
           cgen_state_->llInt(array_expr->getElementCount())};
 }

Here is the call graph for this function:

Here is the caller graph for this function:

llvm::Value * CodeGenerator::codegenBinOpWithOverflowForCPU	(	const Analyzer::BinOper *	bin_oper,
		llvm::Value *	lhs_lv,
		llvm::Value *	rhs_lv,
		const std::string &	null_check_suffix,
		const SQLTypeInfo &	ti
	)

private

Definition at line 728 of file ArithmeticIR.cpp.

References AUTOMATIC_IR_METADATA, cgen_state_, codegenSkipOverflowCheckForNull(), CgenState::context_, CgenState::current_func_, getArithWithOverflowIntrinsic(), inline_int_null_val(), CgenState::ir_builder_, CgenState::llInt(), and CgenState::needs_error_check_.

Referenced by codegenAdd(), codegenMul(), and codegenSub().

                            {
   AUTOMATIC_IR_METADATA(cgen_state_);
   cgen_state_->needs_error_check_ = true;
 
   llvm::BasicBlock* check_ok = llvm::BasicBlock::Create(
       cgen_state_->context_, "ovf_ok", cgen_state_->current_func_);
   llvm::BasicBlock* check_fail = llvm::BasicBlock::Create(
       cgen_state_->context_, "ovf_detected", cgen_state_->current_func_);
   llvm::BasicBlock* null_check{nullptr};
 
   if (!null_check_suffix.empty()) {
     null_check = cgen_state_->ir_builder_.GetInsertBlock();
     codegenSkipOverflowCheckForNull(lhs_lv, rhs_lv, check_ok, ti);
   }
 
   // Compute result and overflow flag
   auto func = getArithWithOverflowIntrinsic(bin_oper, lhs_lv->getType());
   auto ret_and_overflow = cgen_state_->ir_builder_.CreateCall(
       func, std::vector<llvm::Value*>{lhs_lv, rhs_lv});
   auto ret = cgen_state_->ir_builder_.CreateExtractValue(ret_and_overflow,
                                                          std::vector<unsigned>{0});
   auto overflow = cgen_state_->ir_builder_.CreateExtractValue(ret_and_overflow,
                                                               std::vector<unsigned>{1});
   auto val_bb = cgen_state_->ir_builder_.GetInsertBlock();
 
   // Return error on overflow
   cgen_state_->ir_builder_.CreateCondBr(overflow, check_fail, check_ok);
   cgen_state_->ir_builder_.SetInsertPoint(check_fail);
   cgen_state_->ir_builder_.CreateRet(
       cgen_state_->llInt(int32_t(ErrorCode::OVERFLOW_OR_UNDERFLOW)));
 
   cgen_state_->ir_builder_.SetInsertPoint(check_ok);
 
   // In case of null check we have to use NULL result on check fail
   if (null_check) {
     auto phi = cgen_state_->ir_builder_.CreatePHI(ret->getType(), 2);
     phi->addIncoming(llvm::ConstantInt::get(ret->getType(), inline_int_null_val(ti)),
                      null_check);
     phi->addIncoming(ret, val_bb);
     ret = phi;
   }
 
   return ret;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

llvm::Value * CodeGenerator::codegenBoundingBoxIntersect	(	const SQLOps	optype,
		const SQLQualifier	qualifier,
		const std::shared_ptr< Analyzer::Expr >	lhs,
		const std::shared_ptr< Analyzer::Expr >	rhs,
		const CompilationOptions &	co
	)

private

Definition at line 285 of file CompareIR.cpp.

References AUTOMATIC_IR_METADATA, cgen_state_, CHECK, codegenFunctionOper(), CgenState::context_, g_enable_bbox_intersect_hashjoin, get_int_type(), Catalog_Namespace::get_metadata_for_column(), Datum::intval, IS_GEO_POLY, kBOOLEAN, kDOUBLE, kENCODING_GEOINT, kINT, kPOINT, and VLOG.

Referenced by codegenCmp().

                                   {
   AUTOMATIC_IR_METADATA(cgen_state_);
   const auto lhs_ti = lhs->get_type_info();
   if (g_enable_bbox_intersect_hashjoin) {
     // failed to build a suitable hash table. short circuit the bounding box interesect
     // expression by always returning true. this will fall into the ST_Contains check,
     // which will do bounding box intersection before the heavier contains computation.
     VLOG(1) << "Failed to build bounding box intersect hash table, short circuiting "
                "bounding box intersect operator.";
     return llvm::ConstantInt::get(get_int_type(8, cgen_state_->context_), true);
   }
   // TODO(adb): we should never get here, but going to leave this in place for now since
   // it will likely be useful in factoring the bounds check out of ST_Contains
   CHECK(lhs_ti.is_geometry());
 
   if (lhs_ti.is_geometry()) {
     // only point in linestring/poly/mpoly is currently supported
     CHECK(lhs_ti.get_type() == kPOINT);
     const auto lhs_col = dynamic_cast<Analyzer::ColumnVar*>(lhs.get());
     CHECK(lhs_col);
 
     // Get the actual point data column descriptor
     auto lhs_column_key = lhs_col->getColumnKey();
     lhs_column_key.column_id = lhs_column_key.column_id + 1;
     const auto coords_cd = Catalog_Namespace::get_metadata_for_column(lhs_column_key);
     CHECK(coords_cd);
 
     std::vector<std::shared_ptr<Analyzer::Expr>> geoargs;
     geoargs.push_back(makeExpr<Analyzer::ColumnVar>(
         coords_cd->columnType,
         shared::ColumnKey{lhs_col->getTableKey(), coords_cd->columnId},
         lhs_col->get_rte_idx()));
 
     Datum input_compression;
     input_compression.intval =
         (lhs_ti.get_compression() == kENCODING_GEOINT && lhs_ti.get_comp_param() == 32)
             ? 1
             : 0;
     geoargs.push_back(makeExpr<Analyzer::Constant>(kINT, false, input_compression));
     Datum input_srid;
     input_srid.intval = lhs_ti.get_input_srid();
     geoargs.push_back(makeExpr<Analyzer::Constant>(kINT, false, input_srid));
     Datum output_srid;
     output_srid.intval = lhs_ti.get_output_srid();
     geoargs.push_back(makeExpr<Analyzer::Constant>(kINT, false, output_srid));
 
     const auto x_ptr_oper = makeExpr<Analyzer::FunctionOper>(
         SQLTypeInfo(kDOUBLE, true), "ST_X_Point", geoargs);
     const auto y_ptr_oper = makeExpr<Analyzer::FunctionOper>(
         SQLTypeInfo(kDOUBLE, true), "ST_Y_Point", geoargs);
 
     const auto rhs_ti = rhs->get_type_info();
     CHECK(IS_GEO_POLY(rhs_ti.get_type()));
     const auto rhs_col = dynamic_cast<Analyzer::ColumnVar*>(rhs.get());
     CHECK(rhs_col);
 
     auto rhs_column_key = rhs_col->getColumnKey();
     rhs_column_key.column_id =
         rhs_column_key.column_id + rhs_ti.get_physical_coord_cols() + 1;
     const auto poly_bounds_cd =
         Catalog_Namespace::get_metadata_for_column(rhs_column_key);
     CHECK(poly_bounds_cd);
 
     auto bbox_col_var = makeExpr<Analyzer::ColumnVar>(
         poly_bounds_cd->columnType,
         shared::ColumnKey{rhs_col->getTableKey(), poly_bounds_cd->columnId},
         rhs_col->get_rte_idx());
 
     const auto bbox_contains_func_oper =
         makeExpr<Analyzer::FunctionOper>(SQLTypeInfo(kBOOLEAN, false),
                                          "Point_Overlaps_Box",
                                          std::vector<std::shared_ptr<Analyzer::Expr>>{
                                              bbox_col_var, x_ptr_oper, y_ptr_oper});
 
     return codegenFunctionOper(bbox_contains_func_oper.get(), co);
   }
 
   CHECK(false) << "Unsupported type for bounding box intersect operator: "
                << lhs_ti.get_type_name();
   return nullptr;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void CodeGenerator::codegenBufferArgs	(	const std::string &	udf_func_name,
		size_t	param_num,
		llvm::Value *	buffer_buf,
		llvm::Value *	buffer_size,
		llvm::Value *	buffer_is_null,
		std::vector< llvm::Value * > &	output_args
	)

private

Definition at line 713 of file ExtensionsIR.cpp.

References AUTOMATIC_IR_METADATA, cgen_state_, CHECK, CgenState::context_, anonymous_namespace{ExtensionsIR.cpp}::get_buffer_struct_type(), and CgenState::ir_builder_.

Referenced by codegenFunctionOperCastArgs().

                                                                           {
   AUTOMATIC_IR_METADATA(cgen_state_);
   CHECK(buffer_buf);
   CHECK(buffer_size);
 
   auto buffer_abstraction = get_buffer_struct_type(
       cgen_state_, ext_func_name, param_num, buffer_buf->getType());
   auto alloc_mem = cgen_state_->ir_builder_.CreateAlloca(buffer_abstraction);
 
   auto buffer_buf_ptr =
       cgen_state_->ir_builder_.CreateStructGEP(buffer_abstraction, alloc_mem, 0);
   cgen_state_->ir_builder_.CreateStore(buffer_buf, buffer_buf_ptr);
 
   auto buffer_size_ptr =
       cgen_state_->ir_builder_.CreateStructGEP(buffer_abstraction, alloc_mem, 1);
   cgen_state_->ir_builder_.CreateStore(buffer_size, buffer_size_ptr);
 
   auto bool_extended_type = llvm::Type::getInt8Ty(cgen_state_->context_);
   auto buffer_null_extended =
       cgen_state_->ir_builder_.CreateZExt(buffer_null, bool_extended_type);
   auto buffer_is_null_ptr =
       cgen_state_->ir_builder_.CreateStructGEP(buffer_abstraction, alloc_mem, 2);
   cgen_state_->ir_builder_.CreateStore(buffer_null_extended, buffer_is_null_ptr);
   output_args.push_back(alloc_mem);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

llvm::Value * CodeGenerator::codegenCase	(	const Analyzer::CaseExpr *	case_expr,
		llvm::Type *	case_llvm_type,
		const bool	is_real_str,
		const CompilationOptions &	co
	)

private

Definition at line 65 of file CaseIR.cpp.

References AUTOMATIC_IR_METADATA, cgen_state_, CHECK_EQ, codegen(), CgenState::context_, CgenState::current_func_, CgenState::emitCall(), Analyzer::CaseExpr::get_expr_pair_list(), CgenState::ir_builder_, and toBool().

Referenced by codegen().

                                                                       {
   AUTOMATIC_IR_METADATA(cgen_state_);
   // Here the linear control flow will diverge and expressions cached during the
   // code branch code generation (currently just column decoding) are not going
   // to be available once we're done generating the case. Take a snapshot of
   // the cache with FetchCacheAnchor and restore it once we're done with CASE.
   Executor::FetchCacheAnchor anchor(cgen_state_);
   const auto& expr_pair_list = case_expr->get_expr_pair_list();
   std::vector<llvm::Value*> then_lvs;
   std::vector<llvm::BasicBlock*> then_bbs;
   const auto end_bb = llvm::BasicBlock::Create(
       cgen_state_->context_, "end_case", cgen_state_->current_func_);
   for (const auto& expr_pair : expr_pair_list) {
     Executor::FetchCacheAnchor branch_anchor(cgen_state_);
     const auto when_lv = toBool(codegen(expr_pair.first.get(), true, co).front());
     const auto cmp_bb = cgen_state_->ir_builder_.GetInsertBlock();
     const auto then_bb = llvm::BasicBlock::Create(cgen_state_->context_,
                                                   "then_case",
                                                   cgen_state_->current_func_,
                                                   /*insert_before=*/end_bb);
     cgen_state_->ir_builder_.SetInsertPoint(then_bb);
     auto then_bb_lvs = codegen(expr_pair.second.get(), true, co);
     if (is_real_str) {
       if (then_bb_lvs.size() == 3) {
         then_lvs.push_back(
             cgen_state_->emitCall("string_pack", {then_bb_lvs[1], then_bb_lvs[2]}));
       } else {
         then_lvs.push_back(then_bb_lvs.front());
       }
     } else {
       CHECK_EQ(size_t(1), then_bb_lvs.size());
       then_lvs.push_back(then_bb_lvs.front());
     }
     then_bbs.push_back(cgen_state_->ir_builder_.GetInsertBlock());
     cgen_state_->ir_builder_.CreateBr(end_bb);
     const auto when_bb = llvm::BasicBlock::Create(
         cgen_state_->context_, "when_case", cgen_state_->current_func_);
     cgen_state_->ir_builder_.SetInsertPoint(cmp_bb);
     cgen_state_->ir_builder_.CreateCondBr(when_lv, then_bb, when_bb);
     cgen_state_->ir_builder_.SetInsertPoint(when_bb);
   }
   const auto else_expr = case_expr->get_else_expr();
   CHECK(else_expr);
   auto else_lvs = codegen(else_expr, true, co);
   llvm::Value* else_lv{nullptr};
   if (else_lvs.size() == 3) {
     else_lv = cgen_state_->emitCall("string_pack", {else_lvs[1], else_lvs[2]});
   } else {
     else_lv = else_lvs.front();
   }
   CHECK(else_lv);
   auto else_bb = cgen_state_->ir_builder_.GetInsertBlock();
   cgen_state_->ir_builder_.CreateBr(end_bb);
   cgen_state_->ir_builder_.SetInsertPoint(end_bb);
   auto then_phi =
       cgen_state_->ir_builder_.CreatePHI(case_llvm_type, expr_pair_list.size() + 1);
   CHECK_EQ(then_bbs.size(), then_lvs.size());
   for (size_t i = 0; i < then_bbs.size(); ++i) {
     then_phi->addIncoming(then_lvs[i], then_bbs[i]);
   }
   then_phi->addIncoming(else_lv, else_bb);
   return then_phi;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

llvm::Value * CodeGenerator::codegenCast	(	const Analyzer::UOper *	uoper,
		const CompilationOptions &	co
	)

private

Definition at line 21 of file CastIR.cpp.

References AUTOMATIC_IR_METADATA, cgen_state_, CHECK_EQ, codegen(), CgenState::context_, CgenState::emitCall(), executor_, get_int_type(), Analyzer::UOper::get_operand(), Analyzer::UOper::get_optype(), Analyzer::Expr::get_type_info(), CgenState::ir_builder_, and kCAST.

Referenced by codegen(), codegenCmpDecimalConst(), codegenFunctionOper(), and codegenFunctionOperWithCustomTypeHandling().

                                                                       {
   AUTOMATIC_IR_METADATA(cgen_state_);
   CHECK_EQ(uoper->get_optype(), kCAST);
   const auto& ti = uoper->get_type_info();
   const auto operand = uoper->get_operand();
   const auto operand_as_const = dynamic_cast<const Analyzer::Constant*>(operand);
   // For dictionary encoded constants, the cast holds the dictionary id
   // information as the compression parameter; handle this case separately.
   llvm::Value* operand_lv{nullptr};
   if (operand_as_const) {
     const auto operand_lvs =
         codegen(operand_as_const, ti.get_compression(), ti.getStringDictKey(), co);
     if (operand_lvs.size() == 3) {
       operand_lv = cgen_state_->emitCall("string_pack", {operand_lvs[1], operand_lvs[2]});
     } else {
       operand_lv = operand_lvs.front();
     }
   } else {
     operand_lv = codegen(operand, true, co).front();
   }
 
   // If the operand is a TextEncodingNone struct ({i8*, i64, i8})
   // unpack it into an int64_t using "string_pack" so that codegenCast
   // can properly cast it to a TextEncodingDict
   if (operand_lv->getType()->isPointerTy() &&
       operand_lv->getType()->getPointerElementType()->isStructTy()) {
     auto _struct = cgen_state_->ir_builder_.CreateLoad(
         operand_lv->getType()->getPointerElementType(), operand_lv);
     auto ptr = cgen_state_->ir_builder_.CreateExtractValue(_struct, {0});
     auto len = cgen_state_->ir_builder_.CreateTrunc(
         cgen_state_->ir_builder_.CreateExtractValue(_struct, {1}),
         get_int_type(32, cgen_state_->context_));
     executor_->cgen_state_->emitExternalCall(
         "register_buffer_with_executor_rsm",
         llvm::Type::getVoidTy(executor_->cgen_state_->context_),
         {executor_->cgen_state_->llInt(reinterpret_cast<int64_t>(executor_)), ptr});
     operand_lv = cgen_state_->emitCall("string_pack", {ptr, len});
   }
   const auto& operand_ti = operand->get_type_info();
   return codegenCast(operand_lv, operand_ti, ti, operand_as_const, co);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

llvm::Value * CodeGenerator::codegenCast	(	llvm::Value *	operand_lv,
		const SQLTypeInfo &	operand_ti,
		const SQLTypeInfo &	ti,
		const bool	operand_is_const,
		const CompilationOptions &	co
	)

private

Definition at line 73 of file CastIR.cpp.

References AUTOMATIC_IR_METADATA, anonymous_namespace{CastIR.cpp}::byte_array_cast(), CgenState::castToTypeIn(), cgen_state_, CHECK, codegenCastBetweenIntTypes(), codegenCastBetweenTimestamps(), codegenCastFromFp(), codegenCastFromString(), codegenCastNonStringToString(), codegenCastTimestampToDate(), codegenCastTimestampToTime(), codegenCastToFp(), CgenState::context_, SQLTypeInfo::get_dimension(), get_int_array_type(), SQLTypeInfo::get_notnull(), SQLTypeInfo::get_size(), SQLTypeInfo::get_type(), CgenState::ir_builder_, SQLTypeInfo::is_boolean(), SQLTypeInfo::is_decimal(), SQLTypeInfo::is_integer(), SQLTypeInfo::is_string(), SQLTypeInfo::is_text_encoding_dict(), SQLTypeInfo::is_time(), SQLTypeInfo::is_timestamp(), kDATE, kTIME, and kTIMESTAMP.

                                                                       {
   AUTOMATIC_IR_METADATA(cgen_state_);
   if (byte_array_cast(operand_ti, ti)) {
     auto* byte_array_type = get_int_array_type(8, ti.get_size(), cgen_state_->context_);
     return cgen_state_->ir_builder_.CreatePointerCast(operand_lv,
                                                       byte_array_type->getPointerTo());
   } else if (!operand_ti.is_string() && ti.is_text_encoding_dict()) {
     return codegenCastNonStringToString(operand_lv, operand_ti, ti, operand_is_const, co);
   } else if (operand_ti.is_string()) {
     return codegenCastFromString(operand_lv, operand_ti, ti, operand_is_const, co);
   } else if (operand_lv->getType()->isIntegerTy()) {
     CHECK(operand_ti.is_integer() || operand_ti.is_decimal() || operand_ti.is_time() ||
           operand_ti.is_boolean());
 
     if (operand_ti.is_boolean()) {
       // cast boolean to int8
       CHECK(operand_lv->getType()->isIntegerTy(1) ||
             operand_lv->getType()->isIntegerTy(8));
       if (operand_lv->getType()->isIntegerTy(1)) {
         operand_lv = cgen_state_->castToTypeIn(operand_lv, 8);
       }
       if (ti.is_boolean()) {
         return operand_lv;
       }
     }
     if (operand_ti.is_integer() && operand_lv->getType()->isIntegerTy(8) &&
         ti.is_boolean()) {
       // cast int8 to boolean
       return codegenCastBetweenIntTypes(operand_lv, operand_ti, ti);
     }
     if (operand_ti.get_type() == kTIMESTAMP && ti.get_type() == kDATE) {
       // Maybe we should instead generate DatetruncExpr directly from RelAlgTranslator
       // for this pattern. However, DatetruncExpr is supposed to return a timestamp,
       // whereas this cast returns a date. The underlying type for both is still the same,
       // but it still doesn't look like a good idea to misuse DatetruncExpr.
       // Date will have default precision of day, but TIMESTAMP dimension would
       // matter but while converting date through seconds
       return codegenCastTimestampToDate(
           operand_lv, operand_ti.get_dimension(), !ti.get_notnull());
     }
     if (operand_ti.get_type() == kTIMESTAMP && ti.get_type() == kTIME) {
       return codegenCastTimestampToTime(
           operand_lv, operand_ti.get_dimension(), !ti.get_notnull());
     }
     if ((operand_ti.get_type() == kTIMESTAMP || operand_ti.get_type() == kDATE) &&
         ti.get_type() == kTIMESTAMP) {
       const auto operand_dimen =
           (operand_ti.is_timestamp()) ? operand_ti.get_dimension() : 0;
       if (operand_dimen != ti.get_dimension()) {
         return codegenCastBetweenTimestamps(
             operand_lv, operand_ti, ti, !ti.get_notnull());
       }
     }
     if (ti.is_integer() || ti.is_decimal() || ti.is_time()) {
       return codegenCastBetweenIntTypes(operand_lv, operand_ti, ti);
     } else {
       return codegenCastToFp(operand_lv, operand_ti, ti);
     }
   } else {
     return codegenCastFromFp(operand_lv, operand_ti, ti);
   }
   CHECK(false);
   return nullptr;
 }

Here is the call graph for this function:

llvm::Value * CodeGenerator::codegenCastBetweenIntTypes	(	llvm::Value *	operand_lv,
		const SQLTypeInfo &	operand_ti,
		const SQLTypeInfo &	ti,
		bool	upscale = `true`
	)

Definition at line 427 of file CastIR.cpp.

References AUTOMATIC_IR_METADATA, cgen_state_, CHECK, codegenCastBetweenIntTypesOverflowChecks(), CgenState::context_, CgenState::emitCall(), exp_to_scale(), get_bit_width(), get_int_type(), SQLTypeInfo::get_logical_size(), SQLTypeInfo::get_notnull(), SQLTypeInfo::get_scale(), inline_int_null_val(), CgenState::inlineIntNull(), CgenState::ir_builder_, SQLTypeInfo::is_decimal(), SQLTypeInfo::is_integer(), kBIGINT, CgenState::llInt(), and numeric_type_name().

Referenced by codegenArith(), codegenCast(), codegenDeciDiv(), codegenWidthBucketExpr(), and Executor::codegenWindowFunctionAggregateCalls().

                                                                      {
   AUTOMATIC_IR_METADATA(cgen_state_);
   if (ti.is_decimal() &&
       (!operand_ti.is_decimal() || operand_ti.get_scale() <= ti.get_scale())) {
     if (upscale) {
       if (operand_ti.get_scale() < ti.get_scale()) {  // scale only if needed
         auto scale = exp_to_scale(ti.get_scale() - operand_ti.get_scale());
         const auto scale_lv =
             llvm::ConstantInt::get(get_int_type(64, cgen_state_->context_), scale);
         operand_lv = cgen_state_->ir_builder_.CreateSExt(
             operand_lv, get_int_type(64, cgen_state_->context_));
 
         codegenCastBetweenIntTypesOverflowChecks(operand_lv, operand_ti, ti, scale);
 
         if (operand_ti.get_notnull()) {
           operand_lv = cgen_state_->ir_builder_.CreateMul(operand_lv, scale_lv);
         } else {
           operand_lv = cgen_state_->emitCall(
               "scale_decimal_up",
               {operand_lv,
                scale_lv,
                cgen_state_->llInt(inline_int_null_val(operand_ti)),
                cgen_state_->inlineIntNull(SQLTypeInfo(kBIGINT, false))});
         }
       }
     }
   } else if (operand_ti.is_decimal()) {
     // rounded scale down
     auto scale = (int64_t)exp_to_scale(operand_ti.get_scale() - ti.get_scale());
     const auto scale_lv =
         llvm::ConstantInt::get(get_int_type(64, cgen_state_->context_), scale);
 
     const auto operand_width =
         static_cast<llvm::IntegerType*>(operand_lv->getType())->getBitWidth();
 
     std::string method_name = "scale_decimal_down_nullable";
     if (operand_ti.get_notnull()) {
       method_name = "scale_decimal_down_not_nullable";
     }
 
     CHECK(operand_width == 64);
     operand_lv = cgen_state_->emitCall(
         method_name,
         {operand_lv, scale_lv, cgen_state_->llInt(inline_int_null_val(operand_ti))});
   }
   if (ti.is_integer() && operand_ti.is_integer() &&
       operand_ti.get_logical_size() > ti.get_logical_size()) {
     codegenCastBetweenIntTypesOverflowChecks(operand_lv, operand_ti, ti, 1);
   }
 
   const auto operand_width =
       static_cast<llvm::IntegerType*>(operand_lv->getType())->getBitWidth();
   const auto target_width = get_bit_width(ti);
   if (target_width == operand_width) {
     return operand_lv;
   }
   if (operand_ti.get_notnull()) {
     return cgen_state_->ir_builder_.CreateCast(
         target_width > operand_width ? llvm::Instruction::CastOps::SExt
                                      : llvm::Instruction::CastOps::Trunc,
         operand_lv,
         get_int_type(target_width, cgen_state_->context_));
   }
   return cgen_state_->emitCall("cast_" + numeric_type_name(operand_ti) + "_to_" +
                                    numeric_type_name(ti) + "_nullable",
                                {operand_lv,
                                 cgen_state_->inlineIntNull(operand_ti),
                                 cgen_state_->inlineIntNull(ti)});
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void CodeGenerator::codegenCastBetweenIntTypesOverflowChecks	(	llvm::Value *	operand_lv,
		const SQLTypeInfo &	operand_ti,
		const SQLTypeInfo &	ti,
		const int64_t	scale
	)

Definition at line 500 of file CastIR.cpp.

References AUTOMATIC_IR_METADATA, cgen_state_, CgenState::context_, CgenState::current_func_, CgenState::emitCall(), get_int_type(), SQLTypeInfo::get_logical_size(), SQLTypeInfo::get_notnull(), inline_int_null_val(), CgenState::inlineIntMaxMin(), CgenState::inlineIntNull(), CgenState::ir_builder_, kBOOLEAN, CgenState::llInt(), CgenState::needs_error_check_, numeric_type_name(), toBool(), and type_name().

Referenced by codegenCastBetweenIntTypes(), and codegenCastBetweenTimestamps().

                          {
   AUTOMATIC_IR_METADATA(cgen_state_);
   llvm::Value* chosen_max{nullptr};
   llvm::Value* chosen_min{nullptr};
   std::tie(chosen_max, chosen_min) =
       cgen_state_->inlineIntMaxMin(ti.get_logical_size(), true);
 
   cgen_state_->needs_error_check_ = true;
   auto cast_ok = llvm::BasicBlock::Create(
       cgen_state_->context_, "cast_ok", cgen_state_->current_func_);
   auto cast_fail = llvm::BasicBlock::Create(
       cgen_state_->context_, "cast_fail", cgen_state_->current_func_);
   auto operand_max = static_cast<llvm::ConstantInt*>(chosen_max)->getSExtValue() / scale;
   auto operand_min = static_cast<llvm::ConstantInt*>(chosen_min)->getSExtValue() / scale;
   const auto ti_llvm_type =
       get_int_type(8 * ti.get_logical_size(), cgen_state_->context_);
   llvm::Value* operand_max_lv = llvm::ConstantInt::get(ti_llvm_type, operand_max);
   llvm::Value* operand_min_lv = llvm::ConstantInt::get(ti_llvm_type, operand_min);
   const bool is_narrowing = operand_ti.get_logical_size() > ti.get_logical_size();
   if (is_narrowing) {
     const auto operand_ti_llvm_type =
         get_int_type(8 * operand_ti.get_logical_size(), cgen_state_->context_);
     operand_max_lv =
         cgen_state_->ir_builder_.CreateSExt(operand_max_lv, operand_ti_llvm_type);
     operand_min_lv =
         cgen_state_->ir_builder_.CreateSExt(operand_min_lv, operand_ti_llvm_type);
   }
   llvm::Value* over{nullptr};
   llvm::Value* under{nullptr};
   if (operand_ti.get_notnull()) {
     over = cgen_state_->ir_builder_.CreateICmpSGT(operand_lv, operand_max_lv);
     under = cgen_state_->ir_builder_.CreateICmpSLE(operand_lv, operand_min_lv);
   } else {
     const auto type_name =
         is_narrowing ? numeric_type_name(operand_ti) : numeric_type_name(ti);
     const auto null_operand_val = cgen_state_->llInt(inline_int_null_val(operand_ti));
     const auto null_bool_val = cgen_state_->inlineIntNull(SQLTypeInfo(kBOOLEAN, false));
     over = toBool(cgen_state_->emitCall(
         "gt_" + type_name + "_nullable_lhs",
         {operand_lv, operand_max_lv, null_operand_val, null_bool_val}));
     under = toBool(cgen_state_->emitCall(
         "le_" + type_name + "_nullable_lhs",
         {operand_lv, operand_min_lv, null_operand_val, null_bool_val}));
   }
   const auto detected = cgen_state_->ir_builder_.CreateOr(over, under, "overflow");
   cgen_state_->ir_builder_.CreateCondBr(detected, cast_fail, cast_ok);
 
   cgen_state_->ir_builder_.SetInsertPoint(cast_fail);
   cgen_state_->ir_builder_.CreateRet(
       cgen_state_->llInt(int32_t(heavyai::ErrorCode::OVERFLOW_OR_UNDERFLOW)));
 
   cgen_state_->ir_builder_.SetInsertPoint(cast_ok);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

llvm::Value * CodeGenerator::codegenCastBetweenTimestamps	(	llvm::Value *	ts_lv,
		const SQLTypeInfo &	operand_dimen,
		const SQLTypeInfo &	target_dimen,
		const bool	nullable
	)

Definition at line 199 of file CastIR.cpp.

References AUTOMATIC_IR_METADATA, cgen_state_, CHECK, codegenCastBetweenIntTypesOverflowChecks(), CgenState::emitCall(), SQLTypeInfo::get_dimension(), DateTimeUtils::get_timestamp_precision_scale(), CgenState::inlineIntNull(), CgenState::ir_builder_, and CgenState::llInt().

Referenced by codegenCast().

                                                                               {
   AUTOMATIC_IR_METADATA(cgen_state_);
   const auto operand_dimen = operand_ti.get_dimension();
   const auto target_dimen = target_ti.get_dimension();
   if (operand_dimen == target_dimen) {
     return ts_lv;
   }
   CHECK(ts_lv->getType()->isIntegerTy(64));
   const auto scale =
       DateTimeUtils::get_timestamp_precision_scale(abs(operand_dimen - target_dimen));
   if (operand_dimen < target_dimen) {
     codegenCastBetweenIntTypesOverflowChecks(ts_lv, operand_ti, target_ti, scale);
     return nullable
                ? cgen_state_->emitCall("mul_int64_t_nullable_lhs",
                                        {ts_lv,
                                         cgen_state_->llInt(static_cast<int64_t>(scale)),
                                         cgen_state_->inlineIntNull(operand_ti)})
                : cgen_state_->ir_builder_.CreateMul(
                      ts_lv, cgen_state_->llInt(static_cast<int64_t>(scale)));
   }
   return nullable
              ? cgen_state_->emitCall("floor_div_nullable_lhs",
                                      {ts_lv,
                                       cgen_state_->llInt(static_cast<int64_t>(scale)),
                                       cgen_state_->inlineIntNull(operand_ti)})
              : cgen_state_->ir_builder_.CreateSDiv(
                    ts_lv, cgen_state_->llInt(static_cast<int64_t>(scale)));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

llvm::Value * CodeGenerator::codegenCastFromFp	(	llvm::Value *	operand_lv,
		const SQLTypeInfo &	operand_ti,
		const SQLTypeInfo &	ti
	)

private

Definition at line 601 of file CastIR.cpp.

References AUTOMATIC_IR_METADATA, cgen_state_, CHECK, CgenState::context_, CgenState::emitCall(), get_bit_width(), get_int_type(), SQLTypeInfo::get_notnull(), SQLTypeInfo::get_type(), SQLTypeInfo::get_type_name(), CgenState::inlineFpNull(), CgenState::inlineIntNull(), CgenState::ir_builder_, SQLTypeInfo::is_decimal(), SQLTypeInfo::is_fp(), SQLTypeInfo::is_integer(), SQLTypeInfo::is_number(), kDOUBLE, kFLOAT, and numeric_type_name().

Referenced by codegenCast().

                                                                      {
   AUTOMATIC_IR_METADATA(cgen_state_);
   if (!operand_ti.is_fp() || !ti.is_number() || ti.is_decimal()) {
     throw std::runtime_error("Cast from " + operand_ti.get_type_name() + " to " +
                              ti.get_type_name() + " not supported");
   }
   if (operand_ti.get_type() == ti.get_type()) {
     // Should not have been called when both dimensions are same.
     return operand_lv;
   }
   CHECK(operand_lv->getType()->isFloatTy() || operand_lv->getType()->isDoubleTy());
   if (operand_ti.get_notnull()) {
     if (ti.get_type() == kDOUBLE) {
       return cgen_state_->ir_builder_.CreateFPExt(
           operand_lv, llvm::Type::getDoubleTy(cgen_state_->context_));
     } else if (ti.get_type() == kFLOAT) {
       return cgen_state_->ir_builder_.CreateFPTrunc(
           operand_lv, llvm::Type::getFloatTy(cgen_state_->context_));
     } else if (ti.is_integer()) {
       // Round by adding/subtracting 0.5 before fptosi.
       auto* fp_type = operand_lv->getType()->isFloatTy()
                           ? llvm::Type::getFloatTy(cgen_state_->context_)
                           : llvm::Type::getDoubleTy(cgen_state_->context_);
       auto* zero = llvm::ConstantFP::get(fp_type, 0.0);
       auto* mhalf = llvm::ConstantFP::get(fp_type, -0.5);
       auto* phalf = llvm::ConstantFP::get(fp_type, 0.5);
       auto* is_negative = cgen_state_->ir_builder_.CreateFCmpOLT(operand_lv, zero);
       auto* offset = cgen_state_->ir_builder_.CreateSelect(is_negative, mhalf, phalf);
       operand_lv = cgen_state_->ir_builder_.CreateFAdd(operand_lv, offset);
       return cgen_state_->ir_builder_.CreateFPToSI(
           operand_lv, get_int_type(get_bit_width(ti), cgen_state_->context_));
     } else {
       CHECK(false);
     }
   } else {
     const auto from_tname = numeric_type_name(operand_ti);
     const auto to_tname = numeric_type_name(ti);
     if (ti.is_fp()) {
       return cgen_state_->emitCall("cast_" + from_tname + "_to_" + to_tname + "_nullable",
                                    {operand_lv,
                                     cgen_state_->inlineFpNull(operand_ti),
                                     cgen_state_->inlineFpNull(ti)});
     } else if (ti.is_integer()) {
       return cgen_state_->emitCall("cast_" + from_tname + "_to_" + to_tname + "_nullable",
                                    {operand_lv,
                                     cgen_state_->inlineFpNull(operand_ti),
                                     cgen_state_->inlineIntNull(ti)});
     } else {
       CHECK(false);
     }
   }
   CHECK(false);
   return nullptr;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

llvm::Value * CodeGenerator::codegenCastFromString	(	llvm::Value *	operand_lv,
		const SQLTypeInfo &	operand_ti,
		const SQLTypeInfo &	ti,
		const bool	operand_is_const,
		const CompilationOptions &	co
	)

private

Definition at line 231 of file CastIR.cpp.

References AUTOMATIC_IR_METADATA, cgen_state_, CHECK, CHECK_EQ, StringDictionaryTranslationMgr::codegen(), CgenState::context_, CPU, Data_Namespace::CPU_LEVEL, createStringViewStructType(), CompilationOptions::device_type, shared::StringDictKey::dict_id, CgenState::emitExternalCall(), executor(), g_cluster, SQLTypeInfo::get_compression(), get_int_type(), SQLTypeInfo::get_type_name(), SQLTypeInfo::getStringDictKey(), GPU, Data_Namespace::GPU_LEVEL, SQLTypeInfo::is_dict_intersection(), SQLTypeInfo::is_string(), kENCODING_DICT, kENCODING_NONE, dict_ref_t::literalsDictId, CgenState::llInt(), and CgenState::moveStringDictionaryTranslationMgr().

Referenced by codegenCast().

                                                                                 {
   AUTOMATIC_IR_METADATA(cgen_state_);
   if (!ti.is_string()) {
     throw std::runtime_error("Cast from " + operand_ti.get_type_name() + " to " +
                              ti.get_type_name() + " not supported");
   }
   if (operand_ti.get_compression() == kENCODING_NONE &&
       ti.get_compression() == kENCODING_NONE) {
     return operand_lv;
   }
   if (ti.get_compression() == kENCODING_DICT &&
       operand_ti.get_compression() == kENCODING_DICT) {
     if (ti.getStringDictKey() == operand_ti.getStringDictKey()) {
       return operand_lv;
     }
     if (operand_ti.getStringDictKey().dict_id == DictRef::literalsDictId) {
       // Anything being casted from a literal dictionary is not materialized at this point
       // Should already have been kicked to CPU if it was originally a GPU query
 
       CHECK(co.device_type == ExecutorDeviceType::CPU);
       const int64_t source_string_proxy_handle =
           reinterpret_cast<int64_t>(executor()->getStringDictionaryProxy(
               operand_ti.getStringDictKey(), executor()->getRowSetMemoryOwner(), true));
 
       const int64_t dest_string_proxy_handle =
           reinterpret_cast<int64_t>(executor()->getStringDictionaryProxy(
               ti.getStringDictKey(), executor()->getRowSetMemoryOwner(), true));
 
       auto source_string_proxy_handle_lv = cgen_state_->llInt(source_string_proxy_handle);
       auto dest_string_proxy_handle_lv = cgen_state_->llInt(dest_string_proxy_handle);
 
       std::vector<llvm::Value*> string_cast_lvs{
           operand_lv, source_string_proxy_handle_lv, dest_string_proxy_handle_lv};
       if (ti.is_dict_intersection()) {
         return cgen_state_->emitExternalCall(
             "intersect_translate_string_id_to_other_dict",
             get_int_type(32, cgen_state_->context_),
             string_cast_lvs);
       } else {
         return cgen_state_->emitExternalCall("union_translate_string_id_to_other_dict",
                                              get_int_type(32, cgen_state_->context_),
                                              string_cast_lvs);
       }
     }
 
     const std::vector<StringOps_Namespace::StringOpInfo> string_op_infos;
     auto string_dictionary_translation_mgr =
         std::make_unique<StringDictionaryTranslationMgr>(
             operand_ti.getStringDictKey(),
             ti.getStringDictKey(),
             ti.is_dict_intersection(),
             ti,
             string_op_infos,
             co.device_type == ExecutorDeviceType::GPU ? Data_Namespace::GPU_LEVEL
                                                       : Data_Namespace::CPU_LEVEL,
             executor()->deviceCount(co.device_type),
             executor(),
             executor()->getDataMgr(),
             false /* delay_translation */);
 
     return cgen_state_
         ->moveStringDictionaryTranslationMgr(std::move(string_dictionary_translation_mgr))
         ->codegen(operand_lv, operand_ti, true /* add_nullcheck */, co);
   }
   // dictionary encode non-constant
   if (operand_ti.get_compression() != kENCODING_DICT && !operand_is_const) {
     if (g_cluster) {
       throw std::runtime_error(
           "Cast from none-encoded string to dictionary-encoded not supported for "
           "distributed queries");
     }
     CHECK_EQ(kENCODING_NONE, operand_ti.get_compression());
     CHECK_EQ(kENCODING_DICT, ti.get_compression());
     CHECK(operand_lv->getType()->isStructTy());  // StringView
     if (co.device_type == ExecutorDeviceType::GPU) {
       throw QueryMustRunOnCpu();
     }
     return cgen_state_->emitExternalCall(
         "string_compress",
         get_int_type(32, cgen_state_->context_),
         {operand_lv,
          cgen_state_->llInt(int64_t(executor()->getStringDictionaryProxy(
              ti.getStringDictKey(), executor()->getRowSetMemoryOwner(), true)))});
   }
   CHECK(operand_lv->getType()->isIntegerTy(32));
   if (ti.get_compression() == kENCODING_NONE) {
     if (g_cluster) {
       throw std::runtime_error(
           "Cast from dictionary-encoded string to none-encoded not "
           "currently supported for distributed queries.");
     }
     // Removed watchdog check here in exchange for row cardinality based check in
     // RelAlgExecutor
     CHECK_EQ(kENCODING_DICT, operand_ti.get_compression());
     if (co.device_type == ExecutorDeviceType::GPU) {
       throw QueryMustRunOnCpu();
     }
     const int64_t string_dictionary_ptr =
         operand_ti.getStringDictKey().dict_id == 0
             ? reinterpret_cast<int64_t>(
                   executor()->getRowSetMemoryOwner()->getLiteralStringDictProxy())
             : reinterpret_cast<int64_t>(
                   executor()->getStringDictionaryProxy(operand_ti.getStringDictKey(),
                                                        executor()->getRowSetMemoryOwner(),
                                                        true));
     return cgen_state_->emitExternalCall(
         "string_decompress",
         createStringViewStructType(),
         {operand_lv, cgen_state_->llInt(string_dictionary_ptr)});
   }
   CHECK(operand_is_const);
   CHECK_EQ(kENCODING_DICT, ti.get_compression());
   return operand_lv;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

llvm::Value * CodeGenerator::codegenCastNonStringToString	(	llvm::Value *	operand_lv,
		const SQLTypeInfo &	operand_ti,
		const SQLTypeInfo &	ti,
		const bool	operand_is_const,
		const CompilationOptions &	co
	)

private

Definition at line 350 of file CastIR.cpp.

References AUTOMATIC_IR_METADATA, cgen_state_, CHECK, CgenState::context_, CompilationOptions::device_type, CgenState::emitExternalCall(), executor(), g_cluster, SQLTypeInfo::get_compression(), SQLTypeInfo::get_dimension(), get_int_type(), SQLTypeInfo::get_notnull(), SQLTypeInfo::get_precision(), SQLTypeInfo::get_scale(), SQLTypeInfo::get_type(), SQLTypeInfo::getStringDictKey(), GPU, SQLTypeInfo::is_string(), kBIGINT, kBOOLEAN, kDATE, kDECIMAL, kDOUBLE, kENCODING_NONE, kFLOAT, kINT, kNUMERIC, kSMALLINT, kTIME, kTIMESTAMP, kTINYINT, CgenState::llInt(), to_lower(), and toString().

Referenced by codegenCast().

                                                                                        {
   AUTOMATIC_IR_METADATA(cgen_state_);
   CHECK(!operand_ti.is_string());
   if (ti.get_compression() == kENCODING_NONE) {
     throw std::runtime_error("Cast to none-encoded strings currently unsupported.");
   }
   if (g_cluster) {
     throw std::runtime_error(
         "Cast to dictionary-encoded string type not supported for "
         "distributed queries");
   }
   if (co.device_type == ExecutorDeviceType::GPU) {
     throw QueryMustRunOnCpu();
   }
   std::string fn_call{"convert_to_string_and_encode_"};
   const auto operand_type = operand_ti.get_type();
   std::vector operand_lvs{operand_lv};
   switch (operand_type) {
     case kBOOLEAN:
       fn_call += "bool";
       break;
     case kTINYINT:
     case kSMALLINT:
     case kINT:
     case kBIGINT:
     case kFLOAT:
     case kDOUBLE:
       fn_call += to_lower(toString(operand_type));
       break;
     case kNUMERIC:
     case kDECIMAL:
       fn_call += "decimal";
       operand_lvs.emplace_back(llvm::ConstantInt::get(
           get_int_type(32, cgen_state_->context_), operand_ti.get_precision()));
       operand_lvs.emplace_back(llvm::ConstantInt::get(
           get_int_type(32, cgen_state_->context_), operand_ti.get_scale()));
       break;
     case kTIME:
       fn_call += "time";
       break;
     case kTIMESTAMP:
       fn_call += "timestamp";
       operand_lvs.emplace_back(llvm::ConstantInt::get(
           get_int_type(32, cgen_state_->context_), operand_ti.get_dimension()));
       break;
     case kDATE:
       fn_call += "date";
       break;
     default:
       throw std::runtime_error("Unimplemented type for string cast");
   }
   operand_lvs.emplace_back(
       cgen_state_->llInt(int64_t(executor()->getStringDictionaryProxy(
           ti.getStringDictKey(), executor()->getRowSetMemoryOwner(), true))));
 
   auto ret = cgen_state_->emitExternalCall(
       fn_call, get_int_type(32, cgen_state_->context_), operand_lvs);
 
   std::unique_ptr<CodeGenerator::NullCheckCodegen> nullcheck_codegen;
   const bool is_nullable = !operand_ti.get_notnull();
   if (is_nullable) {
     nullcheck_codegen =
         std::make_unique<NullCheckCodegen>(cgen_state_,
                                            executor(),
                                            operand_lvs.front(),
                                            operand_ti,
                                            "cast_non_string_to_string_nullcheck");
     CHECK(nullcheck_codegen);
     ret = nullcheck_codegen->finalize(cgen_state_->inlineNull(ti), ret);
   }
   return ret;
 }

Classes

Public Member Functions

Static Public Member Functions

Protected Member Functions

Protected Attributes

Private Member Functions

Private Attributes

Static Private Attributes

Friends

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation