#include <PointAccessors.h>

Inheritance diagram for spatial_type::PointAccessors:

Collaboration diagram for spatial_type::PointAccessors:

Public Member Functions
	PointAccessors (const Analyzer::GeoOperator *geo_operator)

size_t	size () const final

SQLTypeInfo	getNullType () const final

std::tuple< std::vector < llvm::Value * >, llvm::Value * >	codegenLoads (const std::vector< llvm::Value * > &arg_lvs, const std::vector< llvm::Value * > &pos_lvs, CgenState *cgen_state) final

std::vector< llvm::Value * >	codegen (const std::vector< llvm::Value * > &args, CodeGenerator::NullCheckCodegen nullcheck_codegen, CgenState cgen_state, const CompilationOptions &co) final

Public Member Functions inherited from spatial_type::Codegen
	Codegen (const Analyzer::GeoOperator *geo_operator)

auto	isNullable () const

auto	getTypeInfo () const

std::string	getName () const

virtual std::unique_ptr < CodeGenerator::NullCheckCodegen >	getNullCheckCodegen (llvm::Value null_lv, CgenState cgen_state, Executor *executor)

virtual const Analyzer::Expr *	getOperand (const size_t index)

virtual	~Codegen ()

Additional Inherited Members
Static Public Member Functions inherited from spatial_type::Codegen
static std::unique_ptr< Codegen >	init (const Analyzer::GeoOperator *geo_operator)

Protected Attributes inherited from spatial_type::Codegen
const Analyzer::GeoOperator *	operator_

bool	is_nullable_ {true}

Detailed Description

Definition at line 24 of file PointAccessors.h.

Constructor & Destructor Documentation

spatial_type::PointAccessors::PointAccessors ( const Analyzer::GeoOperator * geo_operator )

inline

Definition at line 26 of file PointAccessors.h.

References CHECK_EQ, spatial_type::Codegen::operator_, and Analyzer::GeoOperator::size().

                                                           : Codegen(geo_operator) {
     CHECK_EQ(operator_->size(), size_t(1));
   }

Here is the call graph for this function:

Member Function Documentation

std::vector<llvm::Value*> spatial_type::PointAccessors::codegen	(	const std::vector< llvm::Value * > &	args,
		CodeGenerator::NullCheckCodegen *	nullcheck_codegen,
		CgenState *	cgen_state,
		const CompilationOptions &	co
	)

inlinefinalvirtual

Implements spatial_type::Codegen.

Definition at line 88 of file PointAccessors.h.

References run_benchmark_import::args, CHECK, CHECK_EQ, Analyzer::Expr::get_type_info(), Analyzer::GeoOperator::getName(), spatial_type::Codegen::getOperand(), kENCODING_GEOINT, and spatial_type::Codegen::operator_.

                                                                         {
     CHECK_EQ(args.size(), size_t(1));
     const auto array_buff_ptr = args.front();
 
     const auto& geo_ti = getOperand(0)->get_type_info();
     CHECK(geo_ti.is_geometry());
     auto& builder = cgen_state->ir_builder_;
 
     const bool is_x = operator_->getName() == "ST_X";
     const std::string expr_name = is_x ? "x" : "y";
 
     llvm::Value* coord_lv;
     if (geo_ti.get_compression() == kENCODING_GEOINT) {
       auto compressed_arr_ptr = builder.CreateBitCast(
           array_buff_ptr, llvm::Type::getInt32PtrTy(cgen_state->context_));
       auto coord_index = is_x ? cgen_state->llInt(0) : cgen_state->llInt(1);
       auto coord_lv_ptr = builder.CreateGEP(
           compressed_arr_ptr->getType()->getScalarType()->getPointerElementType(),
           compressed_arr_ptr,
           coord_index,
           expr_name + "_coord_ptr");
       auto compressed_coord_lv =
           builder.CreateLoad(coord_lv_ptr->getType()->getPointerElementType(),
                              coord_lv_ptr,
                              expr_name + "_coord_compressed");
 
       coord_lv =
           cgen_state->emitExternalCall("decompress_" + expr_name + "_coord_geoint",
                                        llvm::Type::getDoubleTy(cgen_state->context_),
                                        {compressed_coord_lv});
     } else {
       auto coord_arr_ptr = builder.CreateBitCast(
           array_buff_ptr, llvm::Type::getDoublePtrTy(cgen_state->context_));
       auto coord_index = is_x ? cgen_state->llInt(0) : cgen_state->llInt(1);
       auto coord_lv_ptr = builder.CreateGEP(
           coord_arr_ptr->getType()->getScalarType()->getPointerElementType(),
           coord_arr_ptr,
           coord_index,
           expr_name + "_coord_ptr");
       coord_lv = builder.CreateLoad(coord_lv_ptr->getType()->getPointerElementType(),
                                     coord_lv_ptr,
                                     expr_name + "_coord");
     }
 
     auto ret = coord_lv;
     if (is_nullable_) {
       CHECK(nullcheck_codegen);
       ret = nullcheck_codegen->finalize(cgen_state->inlineFpNull(SQLTypeInfo(kDOUBLE)),
                                         ret);
     }
     const auto key = operator_->toString();
     CHECK(cgen_state->geo_target_cache_.insert(std::make_pair(key, ret)).second);
     return {ret};
   }

Here is the call graph for this function:

std::tuple<std::vector<llvm::Value>, llvm::Value> spatial_type::PointAccessors::codegenLoads	(	const std::vector< llvm::Value * > &	arg_lvs,
		const std::vector< llvm::Value * > &	pos_lvs,
		CgenState *	cgen_state
	)

inlinefinalvirtual

Implements spatial_type::Codegen.

Definition at line 35 of file PointAccessors.h.

References ArrayLoadCodegen::buffer, CHECK, CHECK_EQ, CodeGenerator::codegenGeoArrayLoadAndNullcheck(), spatial_type::Codegen::getOperand(), is_null(), spatial_type::Codegen::is_nullable_, kENCODING_GEOINT, spatial_type::Codegen::operator_, size(), and Analyzer::GeoOperator::toString().

                                    {
     CHECK_EQ(pos_lvs.size(), size());
     auto operand = getOperand(0);
     CHECK(operand);
     const auto& geo_ti = operand->get_type_info();
     CHECK(geo_ti.is_geometry());
     auto& builder = cgen_state->ir_builder_;
 
     llvm::Value* array_buff_ptr{nullptr};
     llvm::Value* is_null{nullptr};
     if (arg_lvs.size() == 1) {
       if (dynamic_cast<const Analyzer::GeoExpr*>(operand)) {
         const auto ptr_type =
             llvm::dyn_cast<llvm::PointerType>(arg_lvs.front()->getType());
         CHECK(ptr_type);
         const auto is_null_lv =
             builder.CreateICmp(llvm::CmpInst::ICMP_EQ,
                                arg_lvs.front(),
                                llvm::ConstantPointerNull::get(ptr_type));
         return std::make_tuple(arg_lvs, is_null_lv);
       }
       // col byte stream, get the array buffer ptr and is null attributes and cache
       auto arr_load_lvs = CodeGenerator::codegenGeoArrayLoadAndNullcheck(
           arg_lvs.front(), pos_lvs.front(), geo_ti, cgen_state);
       array_buff_ptr = arr_load_lvs.buffer;
       is_null = arr_load_lvs.is_null;
     } else {
       // ptr and size
       CHECK_EQ(arg_lvs.size(), size_t(2));
       if (dynamic_cast<const Analyzer::GeoOperator*>(operand)) {
         // null check will be if the ptr is a nullptr
         is_null = builder.CreateICmp(
             llvm::CmpInst::ICMP_EQ,
             arg_lvs.front(),
             llvm::ConstantPointerNull::get(  // TODO: check ptr address space
                 geo_ti.get_compression() == kENCODING_GEOINT
                     ? llvm::Type::getInt32PtrTy(cgen_state->context_)
                     : llvm::Type::getDoublePtrTy(cgen_state->context_)));
       }
 
       // TODO: nulls from other types not yet supported
       array_buff_ptr = arg_lvs.front();
     }
     CHECK(array_buff_ptr) << operator_->toString();
     if (!is_null) {
       is_nullable_ = false;
     }
     return std::make_tuple(std::vector<llvm::Value*>{array_buff_ptr}, is_null);
   }