spatial_type::NumGeometries Class Reference

#include <NumGeometries.h>

Inheritance diagram for spatial_type::NumGeometries:

Collaboration diagram for spatial_type::NumGeometries:

Public Member Functions
	NumGeometries (const Analyzer::GeoOperator *geo_operator)
size_t	size () const final
SQLTypeInfo	getNullType () const final
const SQLTypeInfo	getOperandTypeInfo (const size_t index)
const Analyzer::Expr *	getOperand (const size_t index) 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	~Codegen ()

Protected Attributes
std::unique_ptr < Analyzer::ColumnVar >	operand_owned_
Protected Attributes inherited from spatial_type::Codegen
const Analyzer::GeoOperator *	operator_
bool	is_nullable_ {true}

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

Detailed Description

Definition at line 23 of file NumGeometries.h.

Constructor & Destructor Documentation

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

inline

Definition at line 25 of file NumGeometries.h.

: Codegen(geo_operator) {}

Member Function Documentation

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

References run_benchmark_import::args, CHECK, CHECK_EQ, spatial_type::Codegen::getTypeInfo(), and spatial_type::Codegen::isNullable().

                                                                        {
    CHECK_EQ(args.size(), size_t(1));
    if (isNullable()) {
      CHECK(nullcheck_codegen);
      return {nullcheck_codegen->finalize(cgen_state->inlineIntNull(getTypeInfo()),
                                          args.front())};
    }
    return {args.front()};
  }

Here is the call graph for this function:

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

References CHECK, CHECK_EQ, SQLTypeInfo::get_elem_type(), get_int_type(), Analyzer::Expr::get_type_info(), getOperand(), getOperandTypeInfo(), spatial_type::Codegen::getTypeInfo(), IS_GEO_MULTI, spatial_type::Codegen::isNullable(), kENCODING_GEOINT, kMULTIPOINT, kTINYINT, log2_bytes(), and size().

                                   {
    CHECK_EQ(pos_lvs.size(), size());
    CHECK_EQ(arg_lvs.size(), size_t(1));

    const auto& oper_ti = getOperandTypeInfo(0);
    auto const is_multi_geo = IS_GEO_MULTI(oper_ti.get_type());

    // non-MULTI non-nullable geo, just return 1 (no function call)
    if (!isNullable() && !is_multi_geo) {
      auto* const one = cgen_state->llInt(1);
      return {{one}, one};
    }

    // will be a function call, the first two arguments
    std::string fn_name("array_size");
    auto& argument_lv = arg_lvs.front();
    std::vector<llvm::Value*> array_size_args = {argument_lv, pos_lvs.front()};

    if (is_multi_geo) {
      // MULTI geo, fetch and append element log size argument
      const auto& elem_ti = getOperand(0)->get_type_info().get_elem_type();
      uint32_t elem_log_sz_value{};
      if (oper_ti.get_type() == kMULTIPOINT) {
        // we must have been passed the coords column
        CHECK(elem_ti.get_type() == kTINYINT);
        // we want to return the number of points (two coords),
        // so divide by either 8 (compressed) or 16 (uncompressed)
        if (oper_ti.get_compression() == kENCODING_GEOINT) {
          // number of INT pairs
          elem_log_sz_value = 3;
        } else {
          // number of DOUBLE pairs
          elem_log_sz_value = 4;
        }
      } else {
        // some other count (ring_sizes or poly_sizes)
        elem_log_sz_value = log2_bytes(elem_ti.get_logical_size());
      }
      array_size_args.push_back(cgen_state->llInt(elem_log_sz_value));
    } else {
      // non-MULTI but nullable geo, return 1 or NULL
      fn_name += "_1";
    }

    // nullable, add NULL value
    if (isNullable()) {
      fn_name += "_nullable";
      array_size_args.push_back(cgen_state->inlineIntNull(getTypeInfo()));
    }

    const auto total_num_geometries_lv = cgen_state->emitExternalCall(
        fn_name, get_int_type(32, cgen_state->context_), array_size_args);

    return {{total_num_geometries_lv}, total_num_geometries_lv};
  }

Here is the call graph for this function:

SQLTypeInfo spatial_type::NumGeometries::getNullType ( ) const

inlinefinalvirtual

Implements spatial_type::Codegen.

Definition at line 29 of file NumGeometries.h.

References kINT.

{ return SQLTypeInfo(kINT); }

const Analyzer::Expr* spatial_type::NumGeometries::getOperand ( const size_t  index )

inlinefinalvirtual

Reimplemented from spatial_type::Codegen.

Definition at line 42 of file NumGeometries.h.

References CHECK, CHECK_EQ, get_column_descriptor(), spatial_type::Codegen::getName(), Analyzer::GeoOperator::getOperand(), spatial_type::Codegen::is_nullable_, kLINESTRING, kMULTILINESTRING, kMULTIPOINT, kMULTIPOLYGON, kPOINT, kPOLYGON, operand_owned_, spatial_type::Codegen::operator_, and UNREACHABLE.

Referenced by codegenLoads().

                                                           {
    CHECK_EQ(index, size_t(0));
    if (operand_owned_) {
      return operand_owned_.get();
    }

    const auto operand = operator_->getOperand(0);
    auto col_var = dynamic_cast<const Analyzer::ColumnVar*>(operand);
    if (!col_var) {
      throw std::runtime_error(getName() +
                               " requires a geo column as its input argument.");
    }

    const auto& geo_ti = col_var->get_type_info();
    if (!geo_ti.is_geometry()) {
      throw std::runtime_error(getName() +
                               " requires a geo column as its input argument.");
    }
    is_nullable_ = !geo_ti.get_notnull();

    auto const geo_type = geo_ti.get_type();
    int column_offset{};
    switch (geo_type) {
      case kMULTIPOLYGON:
        column_offset = 3;  // poly_rings
        break;
      case kMULTILINESTRING:
        column_offset = 2;  // ring_sizes
        break;
      case kMULTIPOINT:
        column_offset = 1;  // points
        break;
      case kPOINT:
      case kLINESTRING:
      case kPOLYGON:
        column_offset = 1;  // nothing to count, but allow through
        break;
      default:
        UNREACHABLE();
    }

    // create a new operand which is just the column to count, and codegen it
    const auto column_id = col_var->getColumnKey().column_id + column_offset;
    shared::ColumnKey column_key{col_var->getTableKey(), column_id};
    const auto cd = get_column_descriptor(column_key);
    CHECK(cd);

    operand_owned_ = std::make_unique<Analyzer::ColumnVar>(
        cd->columnType, column_key, col_var->get_rte_idx());
    return operand_owned_.get();
  }

Here is the call graph for this function:

Here is the caller graph for this function:

const SQLTypeInfo spatial_type::NumGeometries::getOperandTypeInfo ( const size_t  index )

inline

Definition at line 31 of file NumGeometries.h.

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

Referenced by codegenLoads().

                                                           {
    CHECK_EQ(index, size_t(0));
    const auto operand = operator_->getOperand(0);
    auto col_var = dynamic_cast<const Analyzer::ColumnVar*>(operand);
    if (!col_var) {
      throw std::runtime_error(getName() +
                               " requires a geo column as its input argument.");
    }
    return col_var->get_type_info();
  }

Here is the call graph for this function:

Here is the caller graph for this function:

size_t spatial_type::NumGeometries::size ( ) const

inlinefinalvirtual

Implements spatial_type::Codegen.

Definition at line 27 of file NumGeometries.h.

Referenced by codegenLoads().

{ return 1; }

Here is the caller graph for this function:

Member Data Documentation

std::unique_ptr<Analyzer::ColumnVar> spatial_type::NumGeometries::operand_owned_

protected

Definition at line 168 of file NumGeometries.h.

Referenced by getOperand().

---

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

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