36 return std::make_shared<FixedWidthInt>(1);
38 return std::make_shared<FixedWidthInt>(1);
40 return std::make_shared<FixedWidthInt>(2);
42 return std::make_shared<FixedWidthInt>(4);
44 return std::make_shared<FixedWidthInt>(8);
46 return std::make_shared<FixedWidthReal>(
false);
48 return std::make_shared<FixedWidthReal>(
true);
52 return std::make_shared<FixedWidthInt>(8);
58 CHECK(ti.is_string());
62 if (ti.get_size() < ti.get_logical_size()) {
63 return std::make_shared<FixedWidthUnsigned>(ti.get_size());
65 return std::make_shared<FixedWidthInt>(ti.get_size());
69 return std::make_shared<FixedWidthInt>(bit_width / 8);
72 CHECK(ti.is_date_in_days());
73 return col_var->
get_comp_param() == 16 ? std::make_shared<FixedWidthSmallDate>(2)
74 : std::make_shared<FixedWidthSmallDate>(4);
93 const bool fetch_column,
105 const bool fetch_column,
106 const bool update_query_plan,
113 const auto catalog =
executor()->getCatalog();
117 if (cd->isVirtualCol) {
118 CHECK(cd->columnName ==
"rowid");
121 auto col_ti = cd->columnType;
122 if (col_ti.get_physical_coord_cols() > 0) {
123 std::vector<llvm::Value*> cols;
124 for (
auto i = 0; i < col_ti.get_physical_coord_cols(); i++) {
128 CHECK(!cd0->isVirtualCol);
129 auto col0_var = makeExpr<Analyzer::ColumnVar>(
130 col0_ti, col_var->
get_table_id(), cd0->columnId, rte_idx);
131 auto col =
codegenColVar(col0_var.get(), fetch_column,
false, co);
132 cols.insert(cols.end(), col.begin(), col.end());
135 std::make_pair(col_var->
get_table_id(), col0_var->get_column_id()));
149 throw std::runtime_error(
150 "Geospatial columns not supported in temporary tables yet");
154 if (grouped_col_lv) {
155 return {grouped_col_lv};
158 const auto window_func_context =
162 if (!window_func_context) {
175 if (hash_join_lhs && hash_join_lhs->get_type_info() == col_var->
get_type_info()) {
180 return codegen(hash_join_lhs.get(), fetch_column, co);
182 auto pos_arg =
posArg(col_var);
183 if (window_func_context) {
186 auto col_byte_stream =
colByteStream(col_var, fetch_column, hoist_literals);
188 if (update_query_plan) {
203 if (col_ti.is_string() && col_ti.get_compression() ==
kENCODING_NONE) {
204 const auto varlen_str_column_lvs =
206 if (!window_func_context) {
208 std::make_pair(local_col_id, varlen_str_column_lvs));
211 return varlen_str_column_lvs;
213 if (col_ti.is_array()) {
214 return {col_byte_stream};
216 if (window_func_context) {
219 const auto fixed_length_column_lv =
222 std::make_pair(local_col_id, std::vector<llvm::Value*>{fixed_length_column_lv}));
223 return {it_ok.first->second};
228 llvm::Value* pos_arg) {
231 "row_number_window_func",
234 return window_position;
240 llvm::Value* col_byte_stream,
241 llvm::Value* pos_arg) {
244 auto dec_val = decoder->codegenDecode(col_byte_stream, pos_arg,
cgen_state_->
module_);
246 auto dec_type = dec_val->getType();
247 llvm::Value* dec_val_cast{
nullptr};
249 if (dec_type->isIntegerTy()) {
250 auto dec_width =
static_cast<llvm::IntegerType*
>(dec_type)->getBitWidth();
253 static_cast<size_t>(col_width) > dec_width ? llvm::Instruction::CastOps::SExt
254 : llvm::Instruction::CastOps::Trunc,
258 (col_ti.get_compression() ==
kENCODING_DICT && col_ti.get_size() < 4)) &&
259 !col_ti.get_notnull()) {
264 CHECK(dec_type->isFloatTy() || dec_type->isDoubleTy());
265 if (dec_type->isDoubleTy()) {
267 }
else if (dec_type->isFloatTy()) {
270 dec_val_cast = dec_val;
278 llvm::Value* col_byte_stream,
279 llvm::Value* pos_arg) {
282 const auto pos_is_valid =
284 const auto pos_valid_bb = llvm::BasicBlock::Create(
286 const auto pos_notvalid_bb = llvm::BasicBlock::Create(
290 const auto fixed_length_column_lv =
294 const auto window_func_call_phi =
296 window_func_call_phi->addIncoming(fixed_length_column_lv, pos_valid_bb);
301 window_func_call_phi->addIncoming(null_lv, orig_bb);
302 return window_func_call_phi;
306 llvm::Value* col_byte_stream,
307 llvm::Value* pos_arg) {
313 {col_byte_stream, pos_arg});
315 auto str_lv = cgen_state_->emitCall(
"extract_str_ptr", {ptr_and_len});
316 auto len_lv = cgen_state_->emitCall(
"extract_str_len", {ptr_and_len});
317 return {ptr_and_len, str_lv, len_lv};
324 llvm::Value* start_rowid_lv{
nullptr};
326 if (table_generation.start_rowid > 0) {
330 d.
bigintval = table_generation.start_rowid;
331 const auto start_rowid = makeExpr<Analyzer::Constant>(
kBIGINT,
false, d);
333 CHECK_EQ(
size_t(1), start_rowid_lvs.size());
334 start_rowid_lv = start_rowid_lvs.front();
336 auto rowid_lv =
posArg(col_var);
342 frag_off_ptr->getType()->getScalarType()->getPointerElementType(),
346 input_off_ptr->getType()->getPointerElementType(), input_off_ptr);
349 if (table_generation.start_rowid > 0) {
350 CHECK(start_rowid_lv);
381 const auto col_phys_width = col_ti.
get_size() * 8;
382 auto from_typename =
"int" +
std::to_string(col_phys_width) +
"_t";
384 llvm::Instruction::CastOps::Trunc,
388 from_typename =
"u" + from_typename;
389 llvm::Value* from_null{
nullptr};
427 const bool fetch_column,
431 if (grouped_col_lv) {
432 return {grouped_col_lv};
434 const auto outer_join_args_bb = llvm::BasicBlock::Create(
436 const auto outer_join_nulls_bb = llvm::BasicBlock::Create(
438 const auto phi_bb = llvm::BasicBlock::Create(
441 CHECK(outer_join_match_lv);
443 outer_join_match_lv, outer_join_args_bb, outer_join_nulls_bb);
444 const auto back_from_outer_join_bb = llvm::BasicBlock::Create(
448 const auto orig_lvs =
codegenColVar(col_var, fetch_column,
true, co);
452 if ((null_ti.is_string() && null_ti.get_compression() ==
kENCODING_NONE) ||
453 null_ti.is_array() || null_ti.is_geometry()) {
454 throw std::runtime_error(
"Projection type " + null_ti.get_type_name() +
455 " not supported for outer joins yet");
457 const auto null_constant = makeExpr<Analyzer::Constant>(null_ti,
true,
Datum{0});
458 const auto null_target_lvs =
464 CHECK_EQ(orig_lvs.size(), null_target_lvs.size());
466 std::vector<llvm::Value*> target_lvs;
467 for (
size_t i = 0; i < orig_lvs.size(); ++i) {
468 const auto target_type = orig_lvs[i]->getType();
469 CHECK_EQ(target_type, null_target_lvs[i]->getType());
471 target_phi->addIncoming(orig_lvs[i], outer_join_args_bb);
472 target_phi->addIncoming(null_target_lvs[i], outer_join_nulls_bb);
473 target_lvs.push_back(target_phi);
487 const auto var =
dynamic_cast<const Analyzer::Var*
>(col_var);
489 col_id = var->get_varno();
500 const bool fetch_column,
501 const bool hoist_literals) {
503 const auto stream_arg_name =
506 if (arg.getName() == stream_arg_name) {
518 if (col_var && col_var->get_rte_idx() > 0) {
519 const auto hash_pos_it =
522 if (hash_pos_it->second->getType()->isPointerTy()) {
523 CHECK(hash_pos_it->second->getType()->getPointerElementType()->isIntegerTy(32));
525 hash_pos_it->second->getType()->getPointerElementType(), hash_pos_it->second);
530 return hash_pos_it->second;
533 if (arg.getName() ==
"pos") {
534 CHECK(arg.getType()->isIntegerTy(64));
543 if (!uoper || uoper->get_optype() !=
kCAST) {
547 if (!target_ti.is_integer()) {
550 return uoper->get_operand();
557 if (dynamic_cast<const Analyzer::ExpressionTuple*>(
558 tautological_eq->get_left_operand())) {
564 auto eq_right_op = tautological_eq->get_right_operand();
569 eq_right_op = tautological_eq->get_right_operand();
571 if (*eq_right_op == *rhs) {
572 auto eq_left_op = tautological_eq->get_left_operand();
573 if (!eq_left_op->get_type_info().is_string()) {
577 eq_left_op = tautological_eq->get_left_operand();
579 if (eq_left_op->get_type_info().is_geometry()) {
589 if (!eq_left_op_col) {
590 if (dynamic_cast<const Analyzer::StringOper*>(eq_left_op)) {
593 if (dynamic_cast<const Analyzer::FunctionOper*>(eq_left_op)) {
597 CHECK(eq_left_op_col);
598 if (eq_left_op_col->get_rte_idx() != 0) {
602 return eq_left_op->deep_copy();
611 return makeExpr<Analyzer::UOper>(
622 const auto lhs_tuple_expr =
626 CHECK(lhs_tuple_expr && rhs_tuple_expr);
627 const auto& lhs_tuple = lhs_tuple_expr->getTuple();
628 const auto& rhs_tuple = rhs_tuple_expr->getTuple();
629 CHECK_EQ(lhs_tuple.size(), rhs_tuple.size());
630 for (
size_t i = 0; i < lhs_tuple.size(); ++i) {
631 if (*rhs_tuple[i] == *rhs) {
634 return lhs_col->
get_rte_idx() == 0 ? lhs_col :
nullptr;
HOST DEVICE SQLTypes get_subtype() const
std::vector< llvm::Value * > outer_join_match_found_per_level_
HOST DEVICE int get_size() const
const Analyzer::Expr * remove_cast_to_int(const Analyzer::Expr *expr)
#define IS_EQUIVALENCE(X)
llvm::Value * codegenRowId(const Analyzer::ColumnVar *col_var, const CompilationOptions &co)
HOST DEVICE int get_scale() const
llvm::Value * emitExternalCall(const std::string &fname, llvm::Type *ret_type, const std::vector< llvm::Value * > args, const std::vector< llvm::Attribute::AttrKind > &fnattrs={}, const bool has_struct_return=false)
const Expr * get_right_operand() const
bool is_constructed_point(const Analyzer::Expr *expr)
llvm::IRBuilder ir_builder_
std::vector< llvm::Value * > codegenOuterJoinNullPlaceholder(const Analyzer::ColumnVar *col_var, const bool fetch_column, const CompilationOptions &co)
llvm::Value * posArg(const Analyzer::Expr *) const
std::set< std::pair< TableId, ColumnId > > columns_to_fetch_
llvm::Value * codgenAdjustFixedEncNull(llvm::Value *, const SQLTypeInfo &)
const int8_t * output() const
llvm::Value * foundOuterJoinMatch(const size_t nesting_level) const
virtual std::vector< llvm::Value * > codegenColumn(const Analyzer::ColumnVar *, const bool fetch_column, const CompilationOptions &)
llvm::Type * get_int_type(const int width, llvm::LLVMContext &context)
std::shared_ptr< Decoder > get_col_decoder(const Analyzer::ColumnVar *col_var)
EncodingType get_compression() const
static WindowFunctionContext * getActiveWindowFunctionContext(Executor *executor)
llvm::Function * row_func_
std::set< std::pair< TableId, ColumnId > > columns_to_not_fetch_
std::vector< llvm::Value * > group_by_expr_cache_
std::shared_ptr< const Analyzer::Expr > hashJoinLhs(const Analyzer::ColumnVar *rhs) const
int getLocalColumnId(const Analyzer::ColumnVar *col_var, const bool fetch_column)
size_t get_bit_width(const SQLTypeInfo &ti)
llvm::LLVMContext & context_
llvm::Function * current_func_
llvm::Value * get_arg_by_name(llvm::Function *func, const std::string &name)
bool isLazyFetchColumn(const Analyzer::Expr *target_expr) const
int get_logical_size() const
std::unordered_map< int, std::vector< llvm::Value * > > fetch_cache_
size_t get_col_bit_width(const Analyzer::ColumnVar *col_var)
llvm::ConstantInt * inlineIntNull(const SQLTypeInfo &)
std::unordered_map< int, llvm::Value * > scan_idx_to_hash_pos_
std::vector< llvm::Value * > codegenColVar(const Analyzer::ColumnVar *, const bool fetch_column, const bool update_query_plan, const CompilationOptions &)
const SQLTypeInfo & get_type_info() const
llvm::Value * emitCall(const std::string &fname, const std::vector< llvm::Value * > &args)
SQLTypes decimal_to_int_type(const SQLTypeInfo &ti)
std::vector< llvm::Value * > codegen(const Analyzer::Expr *, const bool fetch_columns, const CompilationOptions &)
int get_comp_param() const
HOST DEVICE EncodingType get_compression() const
std::vector< llvm::Value * > frag_offsets_
HOST DEVICE int get_dimension() const
llvm::Value * codegenFixedLengthColVarInWindow(const Analyzer::ColumnVar *col_var, llvm::Value *col_byte_stream, llvm::Value *pos_arg)
llvm::ConstantInt * llInt(const T v) const
llvm::Value * colByteStream(const Analyzer::ColumnVar *col_var, const bool fetch_column, const bool hoist_literals)
llvm::Value * codegenWindowPosition(WindowFunctionContext *window_func_context, llvm::Value *pos_arg)
const Expr * get_left_operand() const
std::string numeric_type_name(const SQLTypeInfo &ti)
int get_column_id() const
std::shared_ptr< const Analyzer::ColumnVar > hashJoinLhsTuple(const Analyzer::ColumnVar *rhs, const Analyzer::BinOper *tautological_eq) const
std::vector< llvm::Value * > codegenVariableLengthStringColVar(llvm::Value *col_byte_stream, llvm::Value *pos_arg)
llvm::Value * codegenFixedLengthColVar(const Analyzer::ColumnVar *col_var, llvm::Value *col_byte_stream, llvm::Value *pos_arg)
SQLTypes get_phys_int_type(const size_t byte_sz)
int adjusted_range_table_index(const Analyzer::ColumnVar *col_var)
const ColumnDescriptor * get_column_descriptor(const int col_id, const int table_id, const Catalog_Namespace::Catalog &cat)
llvm::Value * resolveGroupedColumnReference(const Analyzer::ColumnVar *)
llvm::ConstantFP * inlineFpNull(const SQLTypeInfo &)
Executor * executor() const