#include <Analyzer.h>

Inheritance diagram for Analyzer::GeoConstant:

Collaboration diagram for Analyzer::GeoConstant:

Public Member Functions
	GeoConstant (std::unique_ptr< Geospatial::GeoBase > &&geo, const SQLTypeInfo &ti)

std::shared_ptr< Analyzer::Expr >	deep_copy () const final

std::string	toString () const final

bool	operator== (const Expr &) const final

size_t	physicalCols () const

std::shared_ptr < Analyzer::Constant >	makePhysicalConstant (const size_t index) const

std::shared_ptr< Analyzer::Expr >	add_cast (const SQLTypeInfo &new_type_info) final

std::string	getWKTString () const

Public Member Functions inherited from Analyzer::GeoExpr
	GeoExpr (const SQLTypeInfo &ti)

virtual std::vector < Analyzer::Expr * >	getChildExprs () const

Public Member Functions inherited from Analyzer::Expr
	Expr (SQLTypes t, bool notnull)

	Expr (SQLTypes t, int d, bool notnull)

	Expr (SQLTypes t, int d, int s, bool notnull)

	Expr (const SQLTypeInfo &ti, bool has_agg=false)

virtual	~Expr ()

std::shared_ptr< Analyzer::Expr >	get_shared_ptr ()

const SQLTypeInfo &	get_type_info () const

void	set_type_info (const SQLTypeInfo &ti)

bool	get_contains_agg () const

void	set_contains_agg (bool a)

virtual void	check_group_by (const std::list< std::shared_ptr< Analyzer::Expr >> &groupby) const

virtual std::shared_ptr < Analyzer::Expr >	normalize_simple_predicate (int &rte_idx) const

virtual void	group_predicates (std::list< const Expr * > &scan_predicates, std::list< const Expr * > &join_predicates, std::list< const Expr * > &const_predicates) const

virtual void	collect_rte_idx (std::set< int > &rte_idx_set) const

virtual void	collect_column_var (std::set< const ColumnVar , bool()(const ColumnVar , const ColumnVar )> &colvar_set, bool include_agg) const

virtual size_t	get_num_column_vars (const bool include_agg) const

virtual std::shared_ptr < Analyzer::Expr >	rewrite_with_targetlist (const std::vector< std::shared_ptr< TargetEntry >> &tlist) const

virtual std::shared_ptr < Analyzer::Expr >	rewrite_with_child_targetlist (const std::vector< std::shared_ptr< TargetEntry >> &tlist) const

virtual std::shared_ptr < Analyzer::Expr >	rewrite_agg_to_var (const std::vector< std::shared_ptr< TargetEntry >> &tlist) const

virtual void	print () const

virtual void	add_unique (std::list< const Expr * > &expr_list) const

virtual void	find_expr (std::function< bool(const Expr )> f, std::list< const Expr > &expr_list) const

std::shared_ptr< Analyzer::Expr >	decompress ()

virtual void	get_domain (DomainSet &domain_set) const

Private Attributes
std::unique_ptr < Geospatial::GeoBase >	geo_

Additional Inherited Members
Protected Attributes inherited from Analyzer::Expr
SQLTypeInfo	type_info

bool	contains_agg

Detailed Description

Definition at line 3248 of file Analyzer.h.

Constructor & Destructor Documentation

Analyzer::GeoConstant::GeoConstant	(	std::unique_ptr< Geospatial::GeoBase > &&	geo,
		const SQLTypeInfo &	ti
	)

Definition at line 4037 of file Analyzer.cpp.

References CHECK, geo_, Analyzer::anonymous_namespace{Analyzer.cpp}::get_ti_from_geo(), SQLTypeInfo::get_type(), and SQLTypeInfo::get_type_name().

     : GeoExpr(ti), geo_(std::move(geo)) {
   CHECK(geo_);
   if (get_ti_from_geo(geo_.get()) != ti.get_type()) {
     throw std::runtime_error("Conflicting types for geo data " + geo_->getWktString() +
                              " (type provided: " + ti.get_type_name() + ")");
   }
 }

Here is the call graph for this function:

Member Function Documentation

std::shared_ptr< Analyzer::Expr > Analyzer::GeoConstant::add_cast ( const SQLTypeInfo & new_type_info )

finalvirtual

Reimplemented from Analyzer::Expr.

Definition at line 4130 of file Analyzer.cpp.

References CHECK, geo_, Geo::get_input_srid(), SQLTypeInfo::get_output_srid(), Analyzer::Expr::get_type_info(), SQLTypeInfo::set_input_srid(), and toString().

                                                                                   {
   // TODO: we should eliminate the notion of input and output SRIDs on a type. A type can
   // only have 1 SRID. A cast or transforms changes the SRID of the type.
   // NOTE: SRID 0 indicates set srid, skip cast
   SQLTypeInfo cast_type_info = new_type_info;
   if (!(get_type_info().get_input_srid() == 0) &&
       (get_type_info().get_input_srid() != new_type_info.get_output_srid())) {
     // run cast
     CHECK(geo_);
     if (!geo_->transform(get_type_info().get_input_srid(),
                          new_type_info.get_output_srid())) {
       throw std::runtime_error("Failed to transform constant geometry: " + toString());
     }
     // The geo constant has been transformed but the new type info still encodes
     // a transform. Need to reset it and eliminate srid transition.
     cast_type_info.set_input_srid(new_type_info.get_output_srid());
   }
   return makeExpr<GeoConstant>(std::move(geo_), cast_type_info);
 }

Here is the call graph for this function:

std::shared_ptr< Analyzer::Expr > Analyzer::GeoConstant::deep_copy ( ) const

finalvirtual

Implements Analyzer::Expr.

Definition at line 4047 of file Analyzer.cpp.

References CHECK, geo_, and Analyzer::Expr::type_info.

                                                          {
   CHECK(geo_);
   return makeExpr<GeoConstant>(geo_->clone(), type_info);
 }

std::string Analyzer::GeoConstant::getWKTString ( ) const

Definition at line 4060 of file Analyzer.cpp.

References CHECK, and geo_.

                                           {
   CHECK(geo_);
   return geo_->getWktString();
 }

std::shared_ptr< Analyzer::Constant > Analyzer::GeoConstant::makePhysicalConstant ( const size_t index ) const

Definition at line 4087 of file Analyzer.cpp.

References CHECK_GE, CHECK_LE, Geospatial::convert_coords(), Geospatial::convert_rings(), geo_, SQLTypeInfo::get_physical_coord_cols(), Geospatial::GeoTypesFactory::getGeoColumns(), Analyzer::Expr::type_info, and UNREACHABLE.

Referenced by CodeGenerator::codegenGeoConstant().

                               {
   // TODO: handle bounds, etc
   const auto num_phys_coords = type_info.get_physical_coord_cols();
   CHECK_GE(num_phys_coords, 0);
   CHECK_LE(index, size_t(num_phys_coords));
   SQLTypeInfo ti = type_info;
 
   std::vector<double> coords;
   std::vector<double> bounds;
   std::vector<int> ring_sizes;  // also linestring_sizes
   std::vector<int> poly_rings;
 
   const bool validate_with_geos_if_available = false;
   bool success =
       Geospatial::GeoTypesFactory::getGeoColumns(geo_->getWktString(),
                                                  ti,
                                                  coords,
                                                  bounds,
                                                  ring_sizes,
                                                  poly_rings,
                                                  validate_with_geos_if_available);
   if (!success) {
     std::ostringstream oss;
     oss << "Failed to create geometry from WKT string: " << geo_->getWktString();
     throw std::runtime_error(oss.str());
   }
 
   switch (index) {
     case 0:  // coords
       return Geospatial::convert_coords(coords, ti);
     case 1:  // ring sizes
       return Geospatial::convert_rings(ring_sizes);
     case 2:  // poly rings
       return Geospatial::convert_rings(poly_rings);
     default:
       UNREACHABLE();
   }
 
   UNREACHABLE();
   return nullptr;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool Analyzer::GeoConstant::operator== ( const Expr & rhs ) const

finalvirtual

Implements Analyzer::Expr.

Definition at line 4065 of file Analyzer.cpp.

References geo_, Analyzer::Expr::get_type_info(), and Analyzer::Expr::type_info.

                                                   {
   if (typeid(rhs) != typeid(GeoConstant)) {
     return false;
   }
   const GeoConstant& rhs_c = dynamic_cast<const GeoConstant&>(rhs);
   if (type_info != rhs_c.get_type_info() /*|| is_null != rhs_c.get_is_null()*/) {
     return false;
   }
   /* TODO: constant nulls
   if (is_null && rhs_c.get_is_null()) {
     return true;
   }
 
   */
   return *geo_ == *rhs_c.geo_;
 }

Here is the call graph for this function:

size_t Analyzer::GeoConstant::physicalCols ( ) const

Definition at line 4082 of file Analyzer.cpp.

References CHECK, SQLTypeInfo::get_physical_coord_cols(), SQLTypeInfo::is_geometry(), and Analyzer::Expr::type_info.

Referenced by CodeGenerator::codegenGeoConstant().

                                        {
   CHECK(type_info.is_geometry());
   return type_info.get_physical_coord_cols();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

std::string Analyzer::GeoConstant::toString ( ) const

finalvirtual

Implements Analyzer::Expr.

Definition at line 4052 of file Analyzer.cpp.

References CHECK, and geo_.

Referenced by add_cast().

                                       {
   std::string str{"(GeoConstant "};
   CHECK(geo_);
   str += geo_->getWktString();
   str += ") ";
   return str;
 }

Here is the caller graph for this function:

Member Data Documentation

std::unique_ptr<Geospatial::GeoBase> Analyzer::GeoConstant::geo_

private

Definition at line 3267 of file Analyzer.h.

Referenced by add_cast(), deep_copy(), GeoConstant(), getWKTString(), makePhysicalConstant(), operator==(), and toString().

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

/home/jenkins-slave/workspace/core-os-doxygen/Analyzer/Analyzer.h
/home/jenkins-slave/workspace/core-os-doxygen/Analyzer/Analyzer.cpp

Public Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation