29 const auto key = std::make_pair(byte_stream, pos);
32 return cache_itr->second;
39 llvm::Type::getInt8PtrTy(cgen_state->
context_),
40 {key.first, key.second});
41 llvm::Value* pt_is_null{
nullptr};
43 pt_is_null = cgen_state->emitExternalCall(
"point_coord_array_is_null",
44 llvm::Type::getInt1Ty(cgen_state->context_),
45 {key.first, key.second});
48 cgen_state->array_load_cache_.insert(std::make_pair(key, arr_load));
54 const bool fetch_columns,
56 auto generate_column_lvs = [
this, geo_col_var, &co](
const int column_id) {
65 const auto lv_vec =
codegen(&col_var,
true, co);
71 switch (ti.get_type()) {
77 std::vector<llvm::Value*> geo_lvs;
79 for (
int i = 0; i < ti.get_physical_coord_cols(); i++) {
81 const auto lvs = generate_column_lvs(column_id);
83 geo_lvs.insert(geo_lvs.end(), lvs.begin(), lvs.end());
114 std::vector<llvm::Value*> ret;
115 for (
size_t i = 0; i < geo_constant->
physicalCols(); i++) {
117 auto operand_lvs =
codegen(physical_constant.get(),
true, co);
118 CHECK_EQ(operand_lvs.size(), size_t(2));
119 auto array_buff_lv = operand_lvs[0];
124 ret.push_back(array_buff_lv);
125 ret.push_back(operand_lvs[1]);
135 bool (*)(
const Analyzer::ColumnVar*,
const Analyzer::ColumnVar*)>
136 colvar_set(comparator);
138 std::for_each(colvar_set.begin(), colvar_set.end(), [&](
const Analyzer::ColumnVar* cv) {
152 if (geo_operator->
getName() ==
"ST_X" || geo_operator->
getName() ==
"ST_Y") {
153 const auto key = geo_operator->
toString();
156 return {geo_target_cache_it->second};
165 std::vector<llvm::Value*> load_lvs;
166 std::vector<llvm::Value*> pos_lvs;
167 for (
size_t i = 0; i < op_codegen->size(); i++) {
168 auto intermediate_lvs =
169 codegen(op_codegen->getOperand(i),
true, co);
170 load_lvs.insert(load_lvs.end(), intermediate_lvs.begin(), intermediate_lvs.end());
171 pos_lvs.push_back(
posArg(op_codegen->getOperand(i)));
174 auto [arg_lvs, null_lv] = op_codegen->codegenLoads(load_lvs, pos_lvs,
cgen_state_);
176 std::unique_ptr<CodeGenerator::NullCheckCodegen> nullcheck_codegen =
178 return op_codegen->codegen(arg_lvs, nullcheck_codegen.get(),
cgen_state_, co);
194 return argument_list;
198 throw std::runtime_error(
"Geo operation requires GEOS support.");
203 std::string func =
"Geos_Wkb"s;
210 throw std::runtime_error(
"GEOS runtime: input/output srids have to match.");
214 argument_list.insert(
215 argument_list.begin(),
218 argument_list.insert(argument_list.begin(),
221 argument_list.insert(argument_list.end(),
222 llvm::ConstantPointerNull::get(
227 argument_list.insert(
232 argument_list.insert(
236 argument_list.insert(
250 argument_list.insert(argument_list.end(),
cgen_state_->
llFp(
double(0)));
257 throw std::runtime_error(
"Unsupported unary geo operation.");
269 throw std::runtime_error(
"Geo operation requires GEOS support.");
276 std::string func =
"Geos_Wkb"s;
282 throw std::runtime_error(
"GEOS runtime: input/output srids have to match.");
286 argument_list.insert(
287 argument_list.begin(),
290 argument_list.insert(argument_list.begin(),
293 argument_list.insert(argument_list.end(),
294 llvm::ConstantPointerNull::get(
299 argument_list.insert(
304 argument_list.insert(
308 argument_list.insert(
320 func +=
"_Predicate"s;
327 arg1_list.insert(arg1_list.end(),
328 llvm::ConstantPointerNull::get(
333 arg1_list.insert(arg1_list.end(),
337 arg1_list.insert(arg1_list.end(),
340 arg1_list.insert(arg1_list.end(),
346 #if (GEOS_VERSION_MAJOR > 3) || (GEOS_VERSION_MAJOR == 3 && GEOS_VERSION_MINOR >= 11)
350 throw std::runtime_error(
"ST_ConcaveHull requires GEOS 3.11 or newer");
353 throw std::runtime_error(
"Unsupported binary geo operation.");
357 argument_list.insert(argument_list.end(), arg1_list.begin(), arg1_list.end());
370 const std::vector<std::shared_ptr<Analyzer::Expr>>& geo_args,
373 std::vector<llvm::Value*> argument_list;
374 bool coord_col =
true;
375 for (
const auto& geo_arg : geo_args) {
376 const auto arg = geo_arg.get();
377 const auto& arg_ti = arg->get_type_info();
378 const auto elem_ti = arg_ti.get_elem_type();
379 const auto arg_lvs =
codegen(arg,
true, co);
380 if (arg_ti.is_number()) {
381 argument_list.emplace_back(arg_lvs.front());
384 if (arg_ti.is_geometry()) {
385 argument_list.insert(argument_list.end(), arg_lvs.begin(), arg_lvs.end());
388 CHECK(arg_ti.is_array());
389 if (arg_lvs.size() > 1) {
390 CHECK_EQ(
size_t(2), arg_lvs.size());
391 auto ptr_lv = arg_lvs.front();
398 argument_list.emplace_back(ptr_lv);
401 argument_list.emplace_back(cast_len_lv);
403 CHECK_EQ(
size_t(1), arg_lvs.size());
404 if (arg_ti.get_size() > 0) {
406 auto ptr_lv = arg_lvs.front();
411 "fast_fixlen_array_buff",
413 {arg_lvs.front(),
posArg(arg)});
421 argument_list.emplace_back(ptr_lv);
427 {arg_lvs.front(),
posArg(arg)});
434 argument_list.emplace_back(ptr_lv);
443 argument_list.emplace_back(cast_len_lv);
447 return argument_list;
451 const std::string& func,
452 std::vector<llvm::Value*> argument_list,
457 argument_list.emplace_back(
result);
464 llvm::BasicBlock* geos_pred_ok_bb{
nullptr};
465 llvm::BasicBlock* geos_pred_fail_bb{
nullptr};
466 geos_pred_ok_bb = llvm::BasicBlock::Create(
468 geos_pred_fail_bb = llvm::BasicBlock::Create(
484 const std::string& func,
485 std::vector<llvm::Value*> argument_list,
486 llvm::Value* result_srid,
493 auto pi8_type = llvm::PointerType::get(i8_type, 0);
494 auto pi32_type = llvm::PointerType::get(i32_type, 0);
500 auto result_coords_size =
502 auto result_ring_sizes =
504 auto result_ring_sizes_size =
506 auto result_poly_rings =
508 auto result_poly_rings_size =
511 argument_list.emplace_back(result_type);
512 argument_list.emplace_back(result_coords);
513 argument_list.emplace_back(result_coords_size);
514 argument_list.emplace_back(result_ring_sizes);
515 argument_list.emplace_back(result_ring_sizes_size);
516 argument_list.emplace_back(result_poly_rings);
517 argument_list.emplace_back(result_poly_rings_size);
518 argument_list.emplace_back(result_srid);
525 llvm::BasicBlock* geos_ok_bb{
nullptr};
526 llvm::BasicBlock* geos_fail_bb{
nullptr};
527 geos_ok_bb = llvm::BasicBlock::Create(
529 geos_fail_bb = llvm::BasicBlock::Create(
547 result_coords->getType()->getPointerElementType(), result_coords);
549 result_coords_size->getType()->getPointerElementType(), result_coords_size);
551 result_ring_sizes->getType()->getPointerElementType(), result_ring_sizes);
553 result_ring_sizes_size->getType()->getPointerElementType(), result_ring_sizes_size);
555 result_poly_rings->getType()->getPointerElementType(), result_poly_rings);
557 result_poly_rings_size->getType()->getPointerElementType(), result_poly_rings_size);
561 "register_buffer_with_executor_rsm",
565 cgen_state_->emitExternalCall(
566 "register_buffer_with_executor_rsm",
567 llvm::Type::getVoidTy(cgen_state_->context_),
568 {cgen_state_->llInt(reinterpret_cast<int64_t>(executor())),
569 cgen_state_->ir_builder_.CreatePointerCast(buf2, pi8_type)});
570 cgen_state_->emitExternalCall(
571 "register_buffer_with_executor_rsm",
572 llvm::Type::getVoidTy(cgen_state_->context_),
573 {cgen_state_->llInt(reinterpret_cast<int64_t>(executor())),
574 cgen_state_->ir_builder_.CreatePointerCast(buf3, pi8_type)});
576 return {cgen_state_->ir_builder_.CreatePointerCast(buf1, pi8_type),
578 cgen_state_->ir_builder_.CreatePointerCast(buf2, pi32_type),
580 cgen_state_->ir_builder_.CreatePointerCast(buf3, pi32_type),
const SQLTypeInfo getTypeInfo0() const
const std::vector< std::shared_ptr< Analyzer::Expr > > & getArgs0() const
void mark_logical_column_to_fetch(const Analyzer::GeoOperator *geo_operator, PlanState *plan_state)
static bool colvar_comp(const ColumnVar *l, const ColumnVar *r)
const SQLTypeInfo getTypeInfo0() const
std::map< std::pair< llvm::Value *, llvm::Value * >, ArrayLoadCodegen > array_load_cache_
void addColumnToFetch(const shared::ColumnKey &column_key, bool unmark_lazy_fetch=false)
llvm::IRBuilder ir_builder_
int32_t get_compression_scheme(const SQLTypeInfo &ti)
llvm::Value * posArg(const Analyzer::Expr *) const
const SQLTypeInfo getTypeInfo1() const
llvm::ConstantInt * llBool(const bool v) const
static const int32_t ERR_GEOS
HOST DEVICE SQLTypes get_type() const
llvm::Type * get_int_type(const int width, llvm::LLVMContext &context)
std::vector< llvm::Value * > codegenGeoBinOper(const Analyzer::GeoBinOper *, const CompilationOptions &)
std::unordered_map< std::string, llvm::Value * > geo_target_cache_
std::vector< llvm::Value * > codegenGeoExpr(const Analyzer::GeoExpr *, const CompilationOptions &)
llvm::LLVMContext & context_
llvm::Function * current_func_
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)
std::vector< llvm::Value * > codegenGeoOperator(const Analyzer::GeoOperator *, const CompilationOptions &)
std::vector< llvm::Value * > codegenGeoUOper(const Analyzer::GeoUOper *, const CompilationOptions &)
const std::vector< std::shared_ptr< Analyzer::Expr > > & getArgs0() const
std::string toString() const override
const ColumnDescriptor * get_column_descriptor(const shared::ColumnKey &column_key)
const std::string & getName() const
llvm::ConstantFP * llFp(const float v) const
std::vector< llvm::Value * > codegenGeosConstructorCall(const std::string &, std::vector< llvm::Value * >, llvm::Value *, const CompilationOptions &)
const SQLTypeInfo & get_type_info() const
ExecutorDeviceType device_type
std::vector< llvm::Value * > codegen(const Analyzer::Expr *, const bool fetch_columns, const CompilationOptions &)
virtual std::string toString() const =0
const shared::ColumnKey & getColumnKey() const
std::vector< llvm::Value * > codegenGeosPredicateCall(const std::string &, std::vector< llvm::Value * >, const CompilationOptions &)
static ArrayLoadCodegen codegenGeoArrayLoadAndNullcheck(llvm::Value *byte_stream, llvm::Value *pos, const SQLTypeInfo &ti, CgenState *cgen_state)
std::vector< llvm::Value * > codegenGeoColumnVar(const Analyzer::GeoColumnVar *, const bool fetch_columns, const CompilationOptions &co)
HOST DEVICE int get_input_srid() const
llvm::ConstantInt * llInt(const T v) const
std::vector< llvm::Value * > codegenGeoArgs(const std::vector< std::shared_ptr< Analyzer::Expr >> &, const CompilationOptions &)
Geospatial::GeoBase::GeoOp getOp() const
std::vector< llvm::Value * > codegenGeoConstant(const Analyzer::GeoConstant *, const CompilationOptions &)
uint32_t log2_bytes(const uint32_t bytes)
std::shared_ptr< Analyzer::Constant > makePhysicalConstant(const size_t index) const
void collect_column_var(std::set< const ColumnVar *, bool(*)(const ColumnVar *, const ColumnVar *)> &colvar_set, bool include_agg) const final
HOST DEVICE bool get_notnull() const
std::string toString() const override
int32_t get_rte_idx() const
int get_physical_coord_cols() const
size_t physicalCols() const
Geospatial::GeoBase::GeoOp getOp() const
static std::unique_ptr< Codegen > init(const Analyzer::GeoOperator *geo_operator)
const std::vector< std::shared_ptr< Analyzer::Expr > > & getArgs1() const
HOST DEVICE int get_output_srid() const
Executor * executor() const