#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

llvm::Value *	codegenCmpEqNullptr (llvm::IRBuilder<> &builder, llvm::Value *arg_lv)

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)

static char const *	pointIsNullFunctionName (SQLTypeInfo const &)

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 89 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:

llvm::Value* spatial_type::PointAccessors::codegenCmpEqNullptr	(	llvm::IRBuilder<> &	builder,
		llvm::Value *	arg_lv
	)

inline

Definition at line 34 of file PointAccessors.h.

References CHECK.

Referenced by codegenLoads().

                                                                               {
     auto* const ptr_type = llvm::dyn_cast<llvm::PointerType>(arg_lv->getType());
     CHECK(ptr_type);
     return builder.CreateICmpEQ(arg_lv, llvm::ConstantPointerNull::get(ptr_type));
   }

Here is the caller 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 41 of file PointAccessors.h.

References ArrayLoadCodegen::buffer, CHECK, CHECK_EQ, codegenCmpEqNullptr(), CodeGenerator::codegenGeoArrayLoadAndNullcheck(), spatial_type::Codegen::getOperand(), is_null(), spatial_type::Codegen::is_nullable_, kPOINT, spatial_type::Codegen::operator_, spatial_type::Codegen::pointIsNullFunctionName(), 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)) {
         is_null = codegenCmpEqNullptr(builder, arg_lvs.front());
         return std::make_tuple(arg_lvs, is_null);
       }
       // 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)) {
         if (geo_ti.get_type() == kPOINT && !geo_ti.is_variable_size()) {
           char const* const fname = pointIsNullFunctionName(geo_ti);
           is_null = cgen_state->emitCall(fname, {arg_lvs.front()});
         } else {
           // The above branch tests for both nullptr and null sentinel, whereas this
           // branch only tests for nullptr. If not for this branch, the GeospatialTest
           // LLVMOptimization test fails due to non-removal of the
           // decompress_{x,y}_coord_geoint function call in the generated IR. See QE-1007.
           is_null = codegenCmpEqNullptr(builder, arg_lvs.front());
         }
       }
       // 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);
   }