spatial_type::PointN Class Reference

#include <PointN.h>

Inheritance diagram for spatial_type::PointN:

Collaboration diagram for spatial_type::PointN:

Public Member Functions
	PointN (const Analyzer::GeoOperator *geo_operator)
std::unique_ptr < CodeGenerator::NullCheckCodegen >	getNullCheckCodegen (llvm::Value *null_lv, CgenState *cgen_state, Executor *executor) final
size_t	size () const final
SQLTypeInfo	getNullType () const final
llvm::Value *	codegenGeoSize (CgenState *cgen_state, SQLTypeInfo const &geo_ti, const std::vector< llvm::Value * > &arg_lvs, const std::vector< llvm::Value * > &pos_lvs)
llvm::Value *	codegenIndexOutOfBoundCheck (CgenState *cgen_state, llvm::Value *index_lv, llvm::Value *geosize_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 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 23 of file PointN.h.

Constructor & Destructor Documentation

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

inline

Definition at line 25 of file PointN.h.

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

                                                  : Codegen(geo_operator) {
    CHECK_EQ(operator_->size(), size_t(2));
    // set is nullable to true, because an index outside of the linestring will return
    // null
    // note we could probably just set this based on the operator type, as the operator
    // type needs to match
    this->is_nullable_ = true;
  }

Here is the call graph for this function:

Member Function Documentation

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

References run_benchmark_import::args, CHECK, CHECK_EQ, and kENCODING_GEOINT.

                                                                        {
    CHECK_EQ(args.size(), size_t(3));  // ptr, size, index
    const auto& geo_ti = getOperand(0)->get_type_info();
    CHECK(geo_ti.is_geometry());

    llvm::Value* array_buff_cast{nullptr};

    auto& builder = cgen_state->ir_builder_;
    if (geo_ti.get_compression() == kENCODING_GEOINT) {
      array_buff_cast = builder.CreateBitCast(
          args.front(), llvm::Type::getInt32PtrTy(cgen_state->context_));
    } else {
      array_buff_cast = builder.CreateBitCast(
          args.front(), llvm::Type::getDoublePtrTy(cgen_state->context_));
    }

    const auto index_lv = args.back();
    auto array_offset_lv = builder.CreateGEP(
        array_buff_cast->getType()->getScalarType()->getPointerElementType(),
        array_buff_cast,
        index_lv,
        operator_->getName() + "_Offset");
    CHECK(nullcheck_codegen);
    auto ret_lv = nullcheck_codegen->finalize(
        llvm::ConstantPointerNull::get(
            geo_ti.get_compression() == kENCODING_GEOINT
                ? llvm::PointerType::get(llvm::Type::getInt32Ty(cgen_state->context_), 0)
                : llvm::PointerType::get(llvm::Type::getDoubleTy(cgen_state->context_),
                                         0)),
        array_offset_lv);
    const auto geo_size_lv = args[1];
    return {ret_lv, geo_size_lv};
  }

llvm::Value* spatial_type::PointN::codegenGeoSize ( CgenState *  cgen_state, SQLTypeInfo const &  geo_ti, const std::vector< llvm::Value * > &  arg_lvs, const std::vector< llvm::Value * > &  pos_lvs  )

inline

Definition at line 54 of file PointN.h.

References CHECK, CgenState::context_, CgenState::emitExternalCall(), get_int_type(), SQLTypeInfo::get_notnull(), CgenState::llInt(), and log2_bytes().

Referenced by codegenLoads().

                                                                    {
    llvm::Value* geo_size_lv{nullptr};
    if (arg_lvs.size() == 2) {
      const bool is_nullable = !geo_ti.get_notnull();
      std::string size_fn_name = "array_size";
      if (is_nullable) {
        size_fn_name += "_nullable";
      }

      uint32_t elem_sz = 1;  // TINYINT coords array
      std::vector<llvm::Value*> array_sz_args{
          arg_lvs.front(), pos_lvs.front(), cgen_state->llInt(log2_bytes(elem_sz))};
      if (is_nullable) {
        array_sz_args.push_back(
            cgen_state->llInt(static_cast<int32_t>(inline_int_null_value<int32_t>())));
      }
      geo_size_lv = cgen_state->emitExternalCall(
          size_fn_name, get_int_type(32, cgen_state->context_), array_sz_args);
    } else {
      geo_size_lv = arg_lvs[1];
    }
    CHECK(geo_size_lv);
    return geo_size_lv;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

llvm::Value* spatial_type::PointN::codegenIndexOutOfBoundCheck ( CgenState *  cgen_state, llvm::Value *  index_lv, llvm::Value *  geosize_lv  )

inline

Definition at line 82 of file PointN.h.

References CgenState::ir_builder_, CgenState::llBool(), and CgenState::llInt().

Referenced by codegenLoads().

                                                                  {
    llvm::Value* is_null_lv = cgen_state->llBool(false);
    is_null_lv = cgen_state->ir_builder_.CreateOr(
        is_null_lv,
        cgen_state->ir_builder_.CreateICmp(llvm::ICmpInst::ICMP_SLT,
                                           index_lv,
                                           cgen_state->llInt(static_cast<int32_t>(0))));
    return cgen_state->ir_builder_.CreateOr(
        is_null_lv,
        cgen_state->ir_builder_.CreateICmp(
            llvm::ICmpInst::ICMP_SGE,
            cgen_state->ir_builder_.CreateMul(index_lv,
                                              cgen_state->llInt(static_cast<int32_t>(8))),
            geosize_lv));
  }

Here is the call graph for this function:

Here is the caller graph for this function:

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

References CHECK, CHECK_EQ, codegenGeoSize(), codegenIndexOutOfBoundCheck(), spatial_type::Codegen::getOperand(), kLINESTRING, and size().

                                   {
    CHECK_EQ(pos_lvs.size(), size());
    CHECK_EQ(pos_lvs.front(), pos_lvs.back());
    auto operand = getOperand(0);
    CHECK(operand);
    const auto& geo_ti = operand->get_type_info();
    CHECK(geo_ti.get_type() == kLINESTRING);

    auto& builder = cgen_state->ir_builder_;

    std::vector<llvm::Value*> array_operand_lvs;
    CHECK(!arg_lvs.empty());
    llvm::Value* raw_index_lv = arg_lvs.back();
    llvm::Value* geo_size_lv = codegenGeoSize(cgen_state, geo_ti, arg_lvs, pos_lvs);
    llvm::Value* pt_size_lv = cgen_state->llInt(16);
    llvm::Value* num_pts_lv = builder.CreateUDiv(geo_size_lv, pt_size_lv);
    llvm::Value* is_negative_lv =
        builder.CreateICmpSLT(raw_index_lv, cgen_state->llInt(0));
    llvm::Value* negative_raw_index_lv = builder.CreateAdd(raw_index_lv, num_pts_lv);
    llvm::Value* positive_raw_index_lv =
        builder.CreateSub(raw_index_lv, cgen_state->llInt(1));
    raw_index_lv = builder.CreateSelect(
        is_negative_lv, negative_raw_index_lv, positive_raw_index_lv);
    raw_index_lv =
        builder.CreateMul(raw_index_lv, cgen_state->llInt(static_cast<int32_t>(2)));
    llvm::Value* is_null_lv =
        codegenIndexOutOfBoundCheck(cgen_state, raw_index_lv, geo_size_lv);
    if (arg_lvs.size() == 2) {
      // col byte stream from column on disk
      array_operand_lvs.push_back(
          cgen_state->emitExternalCall("array_buff",
                                       llvm::Type::getInt8PtrTy(cgen_state->context_),
                                       {arg_lvs.front(), pos_lvs.front()}));
      array_operand_lvs.push_back(geo_size_lv);
      // convert the index to a byte index
      raw_index_lv =
          builder.CreateMul(raw_index_lv, cgen_state->llInt(static_cast<int32_t>(8)));
      const auto input_is_null_lv = builder.CreateICmp(
          llvm::ICmpInst::ICMP_EQ,
          geo_size_lv,
          cgen_state->llInt(static_cast<int32_t>(inline_int_null_value<int32_t>())));
      is_null_lv = builder.CreateOr(is_null_lv, input_is_null_lv);
    } else {
      CHECK_EQ(arg_lvs.size(), size_t(3));  // ptr, size, index
      array_operand_lvs.push_back(arg_lvs[0]);
      array_operand_lvs.push_back(arg_lvs[1]);
    }
    array_operand_lvs.push_back(raw_index_lv);
    return std::make_tuple(array_operand_lvs, is_null_lv);
  }

Here is the call graph for this function:

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

inlinefinalvirtual

Reimplemented from spatial_type::Codegen.

Definition at line 34 of file PointN.h.

References CHECK, spatial_type::Codegen::getName(), getNullType(), and spatial_type::Codegen::isNullable().

                                {
    if (isNullable()) {
      CHECK(null_lv);
      return std::make_unique<CodeGenerator::NullCheckCodegen>(
          cgen_state, executor, null_lv, getNullType(), getName() + "_nullcheck");
    } else {
      return nullptr;
    }
  }

Here is the call graph for this function:

SQLTypeInfo spatial_type::PointN::getNullType ( ) const

inlinefinalvirtual

Implements spatial_type::Codegen.

Definition at line 49 of file PointN.h.

References kBOOLEAN.

Referenced by getNullCheckCodegen().

                                        {
    // nullability is the expression `linestring is null OR size within bounds`
    return SQLTypeInfo(kBOOLEAN);
  }

Here is the caller graph for this function:

size_t spatial_type::PointN::size ( ) const

inlinefinalvirtual

Implements spatial_type::Codegen.

Definition at line 47 of file PointN.h.

Referenced by codegenLoads().

{ return 2; }

Here is the caller graph for this function:

---

The documentation for this class was generated from the following file:

• /home/jenkins-slave/workspace/core-os-doxygen/QueryEngine/GeoOperators/PointN.h