#include <AreaPerimeter.h>

Inheritance diagram for spatial_type::AreaPerimeter:

Collaboration diagram for spatial_type::AreaPerimeter:

Public Member Functions
	AreaPerimeter (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 AreaPerimeter.h.

Constructor & Destructor Documentation

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

inline

Definition at line 26 of file AreaPerimeter.h.

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

                                                          : Codegen(geo_operator) {
     CHECK_EQ(operator_->size(), size_t(1));
     const auto& ti = operator_->get_type_info();
     is_nullable_ = !ti.get_notnull();
   }

Here is the call graph for this function:

Member Function Documentation

std::vector<llvm::Value*> spatial_type::AreaPerimeter::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 84 of file AreaPerimeter.h.

References run_benchmark_import::args, CHECK, Geospatial::get_compression_scheme(), kDOUBLE, kFLOAT, kGEOGRAPHY, kMULTIPOLYGON, kPOLYGON, and spatial_type::suffix().

                                                                         {
     auto operand_lvs = args;
 
     const auto& operand_ti = getOperand(0)->get_type_info();
     CHECK(operand_ti.get_type() == kPOLYGON || operand_ti.get_type() == kMULTIPOLYGON);
     const bool is_geodesic =
         operand_ti.get_subtype() == kGEOGRAPHY && operand_ti.get_output_srid() == 4326;
 
     std::string func_name = getName() + suffix(operand_ti.get_type());
     if (is_geodesic && getName() == "ST_Perimeter") {
       func_name += "_Geodesic";
     }
 
     // push back ic, isr, osr for now
     operand_lvs.push_back(
         cgen_state->llInt(Geospatial::get_compression_scheme(operand_ti)));  // ic
     operand_lvs.push_back(cgen_state->llInt(operand_ti.get_input_srid()));   // in srid
     auto output_srid = operand_ti.get_output_srid();
     if (const auto srid_override = operator_->getOutputSridOverride()) {
       output_srid = *srid_override;
     }
     operand_lvs.push_back(cgen_state->llInt(output_srid));  // out srid
 
     const auto& ret_ti = operator_->get_type_info();
     CHECK(ret_ti.get_type() == kDOUBLE || ret_ti.get_type() == kFLOAT);
 
     auto ret = cgen_state->emitExternalCall(
         func_name,
         ret_ti.get_type() == kDOUBLE ? llvm::Type::getDoubleTy(cgen_state->context_)
                                      : llvm::Type::getFloatTy(cgen_state->context_),
         operand_lvs);
     if (is_nullable_) {
       CHECK(nullcheck_codegen);
       ret = nullcheck_codegen->finalize(cgen_state->inlineFpNull(ret_ti), ret);
     }
     return {ret};
   }

Here is the call graph for this function:

std::tuple<std::vector<llvm::Value>, llvm::Value> spatial_type::AreaPerimeter::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 36 of file AreaPerimeter.h.

References CHECK, CHECK_EQ, get_int_type(), spatial_type::Codegen::getOperand(), spatial_type::Codegen::is_nullable_, log2_bytes(), and size().

                                    {
     CHECK_EQ(pos_lvs.size(), size());
     const auto operand = getOperand(0);
     CHECK(operand);
     const auto& operand_ti = operand->get_type_info();
 
     std::string size_fn_name = "array_size";
     if (is_nullable_) {
       size_fn_name += "_nullable";
     }
 
     std::vector<llvm::Value*> operand_lvs;
     // iterate over column inputs
     if (dynamic_cast<const Analyzer::ColumnVar*>(operand)) {
       for (size_t i = 0; i < arg_lvs.size(); i++) {
         auto lv = arg_lvs[i];
         operand_lvs.push_back(
             cgen_state->emitExternalCall("array_buff",
                                          llvm::Type::getInt8PtrTy(cgen_state->context_),
                                          {lv, pos_lvs.front()}));
         const auto ptr_type = llvm::dyn_cast_or_null<llvm::PointerType>(lv->getType());
         CHECK(ptr_type);
         const auto elem_type = ptr_type->getPointerElementType();
         CHECK(elem_type);
         auto const is_coords = (i == 0);
         auto const shift = log2_bytes(is_coords ? 1 : 4);
         std::vector<llvm::Value*> array_sz_args{
             lv, pos_lvs.front(), cgen_state->llInt(shift)};
         if (is_nullable_) {  // TODO: should we do this for all arguments, or just points?
           array_sz_args.push_back(
               cgen_state->llInt(static_cast<int32_t>(inline_int_null_value<int32_t>())));
         }
         operand_lvs.push_back(cgen_state->emitExternalCall(
             size_fn_name, get_int_type(32, cgen_state->context_), array_sz_args));
       }
     } else {
       operand_lvs = arg_lvs;
     }
     CHECK_EQ(operand_lvs.size(),
              size_t(2 * operand_ti.get_physical_coord_cols()));  // array ptr and size
 
     // use the points array size argument for nullability
     return std::make_tuple(operand_lvs, is_nullable_ ? operand_lvs[1] : nullptr);
   }