Geospatial Namespace Reference

Namespaces
	anonymous_namespace{GDAL.cpp}
	anonymous_namespace{Types.cpp}

Classes
class	GDAL
struct	WkbView
class	GeoTypesError
class	GeoBase
class	GeoPoint
class	GeoMultiPoint
class	GeoLineString
class	GeoMultiLineString
class	GeoPolygon
class	GeoMultiPolygon
class	GeoGeometry
class	GeoGeometryCollection
class	GeoTypesFactory

Functions
int32_t	get_compression_scheme (const SQLTypeInfo &ti)
uint64_t	compress_coord (double coord, const SQLTypeInfo &ti, bool x)
uint64_t	compress_null_point (const SQLTypeInfo &ti, bool x)
std::vector< uint8_t >	compress_coords (const std::vector< double > &coords, const SQLTypeInfo &ti)
template<typename T >
void	unpack_geo_vector (std::vector< T > &output, const int8_t *input_ptr, const size_t sz)
template<>
void	unpack_geo_vector< int32_t > (std::vector< int32_t > &output, const int8_t *input_ptr, const size_t sz)
template<typename T >
void	decompress_geo_coords_geoint32 (std::vector< T > &dec, const int8_t *enc, const size_t sz)
template<>
std::shared_ptr< std::vector < double > >	decompress_coords< double, SQLTypeInfo > (const SQLTypeInfo &geo_ti, const int8_t *coords, const size_t coords_sz)
template<>
std::shared_ptr< std::vector < double > >	decompress_coords< double, int32_t > (const int32_t &ic, const int8_t *coords, const size_t coords_sz)
bool	is_null_point (const SQLTypeInfo &geo_ti, const int8_t *coords, const size_t coords_sz)
template<typename T , typename C >
std::shared_ptr< std::vector< T > >	decompress_coords (const C &compression, const int8_t *coords, const size_t coords_sz)
DEVICE double	decompress_longitude_coord_geoint32 (const int32_t compressed)
DEVICE double	decompress_latitude_coord_geoint32 (const int32_t compressed)
DEVICE bool	is_null_point_longitude_geoint32 (const int32_t compressed)
DEVICE bool	is_null_point_latitude_geoint32 (const int32_t compressed)
DEVICE uint64_t	compress_longitude_coord_geoint32 (const double coord)
DEVICE uint64_t	compress_latitude_coord_geoint32 (const double coord)
DEVICE constexpr uint64_t	compress_null_point_longitude_geoint32 ()
DEVICE constexpr uint64_t	compress_null_point_latitude_geoint32 ()
std::shared_ptr < Analyzer::Constant >	convert_coords (const std::vector< double > &coords, const SQLTypeInfo &ti)
std::shared_ptr < Analyzer::Constant >	convert_rings (const std::vector< int > &rings)
bool	geos_validation_available ()
bool	geos_validate_wkb (const unsigned char *, const size_t)

Variables
const std::string	kGeoColumnName {"geom"}
std::mutex	transformation_map_mutex_
std::map< std::tuple< int32_t, int32_t >, std::shared_ptr < OGRCoordinateTransformation > >	transformation_map_

Function Documentation

uint64_t Geospatial::compress_coord	(	double	coord,
		const SQLTypeInfo &	ti,
		bool	x
	)

Definition at line 33 of file Compression.cpp.

References compress_latitude_coord_geoint32(), compress_longitude_coord_geoint32(), SQLTypeInfo::get_comp_param(), SQLTypeInfo::get_compression(), and kENCODING_GEOINT.

Referenced by compress_coords().

                                                                     {
  if (ti.get_compression() == kENCODING_GEOINT && ti.get_comp_param() == 32) {
    return x ? Geospatial::compress_longitude_coord_geoint32(coord)
             : Geospatial::compress_latitude_coord_geoint32(coord);
  }
  return *reinterpret_cast<uint64_t*>(may_alias_ptr(&coord));
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::vector< uint8_t > Geospatial::compress_coords	(	const std::vector< double > &	coords,
		const SQLTypeInfo &	ti
	)

Definition at line 52 of file Compression.cpp.

References CHECK, compress_coord(), compress_null_point(), coord(), SQLTypeInfo::get_comp_param(), SQLTypeInfo::get_compression(), SQLTypeInfo::get_notnull(), SQLTypeInfo::get_output_srid(), SQLTypeInfo::get_type(), is_null_point(), kENCODING_GEOINT, kPOINT, NULL_ARRAY_DOUBLE, and to_string().

Referenced by Parser::InsertValuesStmt::analyze(), import_export::ImporterUtils::composeNullPointCoords(), convert_coords(), import_export::import_thread_shapefile(), import_export::Importer::importGDALRaster(), foreign_storage::GeospatialEncoder::processGeoElement(), foreign_storage::GeospatialEncoder::processNullGeoElement(), import_export::Importer::set_geo_physical_import_buffer(), import_export::Importer::set_geo_physical_import_buffer_columnar(), GeoPointValueConverter::toCompressedCoords(), RelAlgTranslator::translateGeoLiteral(), writeBackCellGeoNestedArray(), and writeBackCellGeoPoint().

                                                            {
  CHECK(!coords.empty()) << "Coord compression received no data";
  bool is_null_point = false;
  if (!ti.get_notnull()) {
    is_null_point = (ti.get_type() == kPOINT && coords[0] == NULL_ARRAY_DOUBLE);
  }

  bool x = true;
  bool is_geoint32 =
      (ti.get_compression() == kENCODING_GEOINT && ti.get_comp_param() == 32);
  size_t coord_data_size = (is_geoint32) ? (ti.get_comp_param() / 8) : sizeof(double);
  std::vector<uint8_t> compressed_coords;
  compressed_coords.reserve(coords.size() * coord_data_size);
  for (auto coord : coords) {
    uint64_t coord_data;
    if (is_null_point) {
      coord_data = compress_null_point(ti, x);
    } else {
      if (ti.get_output_srid() == 4326) {
        if (x) {
          if (coord < -180.0 || coord > 180.0) {
            throw std::runtime_error("WGS84 longitude " + std::to_string(coord) +
                                     " is out of bounds");
          }
        } else {
          if (coord < -90.0 || coord > 90.0) {
            throw std::runtime_error("WGS84 latitude " + std::to_string(coord) +
                                     " is out of bounds");
          }
        }
      }
      if (is_geoint32) {
        coord_data = compress_coord(coord, ti, x);
      } else {
        auto coord_data_ptr = reinterpret_cast<uint64_t*>(&coord);
        coord_data = *coord_data_ptr;
      }
    }
    for (size_t i = 0; i < coord_data_size; i++) {
      compressed_coords.push_back(coord_data & 0xFF);
      coord_data >>= 8;
    }
    x = !x;
  }
  return compressed_coords;
}

Here is the call graph for this function:

Here is the caller graph for this function:

DEVICE uint64_t Geospatial::compress_latitude_coord_geoint32 ( const double  coord )

inline

Definition at line 68 of file CompressionRuntime.h.

References compressed_coord().

Referenced by compress_coord(), Geo::compress_y_coord(), and Column< GeoPoint >::setItem().

                                                                            {
  // compress latitude: -90..90  --->  -2,147,483,647..2,147,483,647
  int32_t compressed_coord = static_cast<int32_t>(coord * (2147483647.0 / 90.0));
  return static_cast<uint64_t>(*reinterpret_cast<uint32_t*>(&compressed_coord));
}

Here is the call graph for this function:

Here is the caller graph for this function:

DEVICE uint64_t Geospatial::compress_longitude_coord_geoint32 ( const double  coord )

inline

Definition at line 62 of file CompressionRuntime.h.

References compressed_coord().

Referenced by compress_coord(), Geo::compress_x_coord(), and Column< GeoPoint >::setItem().

                                                                             {
  // compress longitude: -180..180  --->  -2,147,483,647..2,147,483,647
  int32_t compressed_coord = static_cast<int32_t>(coord * (2147483647.0 / 180.0));
  return static_cast<uint64_t>(*reinterpret_cast<uint32_t*>(&compressed_coord));
}

Here is the call graph for this function:

Here is the caller graph for this function:

uint64_t Geospatial::compress_null_point	(	const SQLTypeInfo &	ti,
		bool	x
	)

Definition at line 41 of file Compression.cpp.

References compress_null_point_latitude_geoint32(), compress_null_point_longitude_geoint32(), SQLTypeInfo::get_comp_param(), SQLTypeInfo::get_compression(), kENCODING_GEOINT, anonymous_namespace{Utm.h}::n, NULL_ARRAY_DOUBLE, and NULL_DOUBLE.

Referenced by compress_coords().

                                                            {
  if (ti.get_compression() == kENCODING_GEOINT && ti.get_comp_param() == 32) {
    return x ? Geospatial::compress_null_point_longitude_geoint32()
             : Geospatial::compress_null_point_latitude_geoint32();
  }
  double n = x ? NULL_ARRAY_DOUBLE : NULL_DOUBLE;
  auto u = *reinterpret_cast<uint64_t*>(may_alias_ptr(&n));
  return u;
}

Here is the call graph for this function:

Here is the caller graph for this function:

DEVICE constexpr uint64_t Geospatial::compress_null_point_latitude_geoint32

(

)

Definition at line 79 of file CompressionRuntime.h.

Referenced by compress_null_point().

                                                                  {
  // compress null point latitude: NULL  --->  -2,147,483,648
  return 0x0000000080000000ULL;
}

Here is the caller graph for this function:

DEVICE constexpr uint64_t Geospatial::compress_null_point_longitude_geoint32

(

)

Definition at line 74 of file CompressionRuntime.h.

Referenced by compress_null_point().

                                                                   {
  // compress null point longitude: NULL  --->  -2,147,483,648
  return 0x0000000080000000ULL;
}

Here is the caller graph for this function:

std::shared_ptr<Analyzer::Constant> Geospatial::convert_coords	(	const std::vector< double > &	coords,
		const SQLTypeInfo &	ti
	)

Definition at line 26 of file Conversion.h.

References compress_coords(), SQLTypeInfo::get_compression(), kARRAY, kENCODING_GEOINT, kTINYINT, SQLTypeInfo::set_comp_param(), SQLTypeInfo::set_compression(), SQLTypeInfo::set_size(), SQLTypeInfo::set_subtype(), and Datum::tinyintval.

Referenced by Analyzer::GeoConstant::makePhysicalConstant().

                                                                          {
  std::vector<uint8_t> compressed_coords = Geospatial::compress_coords(coords, ti);
  std::list<std::shared_ptr<Analyzer::Expr>> compressed_coords_exprs;
  for (auto cc : compressed_coords) {
    Datum d;
    d.tinyintval = cc;
    auto e = makeExpr<Analyzer::Constant>(kTINYINT, false, d);
    compressed_coords_exprs.push_back(e);
  }
  SQLTypeInfo arr_ti = SQLTypeInfo(kARRAY, true);
  arr_ti.set_subtype(kTINYINT);
  arr_ti.set_size(compressed_coords.size() * sizeof(int8_t));
  arr_ti.set_compression(ti.get_compression());
  arr_ti.set_comp_param((ti.get_compression() == kENCODING_GEOINT) ? 32 : 64);
  return makeExpr<Analyzer::Constant>(arr_ti, false, compressed_coords_exprs);
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::shared_ptr<Analyzer::Constant> Geospatial::convert_rings

(

const std::vector< int > &

rings

)

Definition at line 44 of file Conversion.h.

References Datum::intval, kARRAY, kINT, SQLTypeInfo::set_size(), and SQLTypeInfo::set_subtype().

Referenced by Analyzer::GeoConstant::makePhysicalConstant().

                                                                           {
  std::list<std::shared_ptr<Analyzer::Expr>> ring_size_exprs;
  for (auto c : rings) {
    Datum d;
    d.intval = c;
    auto e = makeExpr<Analyzer::Constant>(kINT, false, d);
    ring_size_exprs.push_back(e);
  }
  SQLTypeInfo arr_ti = SQLTypeInfo(kARRAY, true);
  arr_ti.set_subtype(kINT);
  arr_ti.set_size(rings.size() * sizeof(int32_t));
  return makeExpr<Analyzer::Constant>(arr_ti, false, ring_size_exprs);
}

Here is the call graph for this function:

Here is the caller graph for this function:

template<typename T , typename C >

std::shared_ptr<std::vector<T> > Geospatial::decompress_coords	(	const C &	compression,
		const int8_t *	coords,
		const size_t	coords_sz
	)

template<>

std::shared_ptr<std::vector<double> > Geospatial::decompress_coords< double, int32_t >	(	const int32_t &	ic,
		const int8_t *	coords,
		const size_t	coords_sz
	)

Definition at line 164 of file Compression.cpp.

References CHECK_EQ, COMPRESSION_GEOINT32, COMPRESSION_NONE, decompress_geo_coords_geoint32(), and unpack_geo_vector().

Referenced by to_Geospatial_GeoLineString(), to_Geospatial_GeoMultiLineString(), to_Geospatial_GeoMultiPoint(), to_Geospatial_GeoMultiPolygon(), and to_Geospatial_GeoPolygon().

                            {
  auto decompressed_coords_ptr = std::make_shared<std::vector<double>>();
  if (ic == COMPRESSION_GEOINT32) {
    decompress_geo_coords_geoint32(*decompressed_coords_ptr, coords, coords_sz);
  } else {
    CHECK_EQ(ic, COMPRESSION_NONE);
    unpack_geo_vector(*decompressed_coords_ptr, coords, coords_sz);
  }
  return decompressed_coords_ptr;
}

Here is the call graph for this function:

Here is the caller graph for this function:

template<>

std::shared_ptr<std::vector<double> > Geospatial::decompress_coords< double, SQLTypeInfo >	(	const SQLTypeInfo &	geo_ti,
		const int8_t *	coords,
		const size_t	coords_sz
	)

Definition at line 147 of file Compression.cpp.

References CHECK_EQ, decompress_geo_coords_geoint32(), kENCODING_GEOINT, kENCODING_NONE, and unpack_geo_vector().

Referenced by NestedArrayToGeoTargetValue(), GeoTargetValueSerializer< kPOINT >::serialize(), GeoWktSerializer< kPOINT >::serialize(), GeoTargetValueSerializer< kMULTIPOINT >::serialize(), GeoWktSerializer< kMULTIPOINT >::serialize(), GeoTargetValueSerializer< kLINESTRING >::serialize(), GeoWktSerializer< kLINESTRING >::serialize(), GeoTargetValueSerializer< kMULTILINESTRING >::serialize(), GeoWktSerializer< kMULTILINESTRING >::serialize(), GeoTargetValueSerializer< kPOLYGON >::serialize(), GeoWktSerializer< kPOLYGON >::serialize(), GeoTargetValueSerializer< kMULTIPOLYGON >::serialize(), and GeoWktSerializer< kMULTIPOLYGON >::serialize().

                            {
  auto decompressed_coords_ptr = std::make_shared<std::vector<double>>();
  if (geo_ti.get_compression() == kENCODING_GEOINT) {
    if (geo_ti.get_comp_param() == 32) {
      decompress_geo_coords_geoint32(*decompressed_coords_ptr, coords, coords_sz);
    }
  } else {
    CHECK_EQ(geo_ti.get_compression(), kENCODING_NONE);
    unpack_geo_vector(*decompressed_coords_ptr, coords, coords_sz);
  }
  return decompressed_coords_ptr;
}

Here is the call graph for this function:

Here is the caller graph for this function:

template<typename T >

void Geospatial::decompress_geo_coords_geoint32	(	std::vector< T > &	dec,
		const int8_t *	enc,
		const size_t	sz
	)

Definition at line 131 of file Compression.cpp.

References decompress_latitude_coord_geoint32(), and decompress_longitude_coord_geoint32().

Referenced by decompress_coords< double, int32_t >(), and decompress_coords< double, SQLTypeInfo >().

                                                     {
  if (sz == 0) {
    return;
  }
  const auto compressed_coords = reinterpret_cast<const int32_t*>(enc);
  const auto num_coords = sz / sizeof(int32_t);
  dec.resize(num_coords);
  for (size_t i = 0; i < num_coords; i += 2) {
    dec[i] = Geospatial::decompress_longitude_coord_geoint32(compressed_coords[i]);
    dec[i + 1] = Geospatial::decompress_latitude_coord_geoint32(compressed_coords[i + 1]);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

DEVICE double Geospatial::decompress_latitude_coord_geoint32 ( const int32_t  compressed )

inline

Definition at line 46 of file CompressionRuntime.h.

Referenced by decompress_coord(), decompress_geo_coords_geoint32(), Geo::decompress_y_coord(), get_bucket_key_for_range_compressed_impl(), and RangeKeyHandler::operator()().

                                                                                  {
  // decompress latitude: -2,147,483,647..2,147,483,647  --->  -90..90
  return static_cast<double>(compressed) *
         4.1909515877212172e-08;  // // (90.0 / 2147483647.0)
}

Here is the caller graph for this function:

DEVICE double Geospatial::decompress_longitude_coord_geoint32 ( const int32_t  compressed )

inline

Definition at line 40 of file CompressionRuntime.h.

Referenced by decompress_coord(), decompress_geo_coords_geoint32(), Geo::decompress_x_coord(), get_bucket_key_for_range_compressed_impl(), and RangeKeyHandler::operator()().

                                                                                   {
  // decompress longitude: -2,147,483,647..2,147,483,647  --->  -180..180
  return static_cast<double>(compressed) *
         8.3819031754424345e-08;  // (180.0 / 2147483647.0)
}

Here is the caller graph for this function:

bool Geospatial::geos_validate_wkb	(	const unsigned char *	,
		const size_t
	)

Definition at line 153 of file GeosValidation.cpp.

Referenced by Geospatial::anonymous_namespace{Types.cpp}::validate_ogr().

                                                               {
  return true;
}

Here is the caller graph for this function:

bool Geospatial::geos_validation_available

(

)

Definition at line 149 of file GeosValidation.cpp.

Referenced by Parser::anonymous_namespace{ParserNode.cpp}::parse_copy_params(), and Geospatial::anonymous_namespace{Types.cpp}::validate_ogr().

                                 {
  return false;
}

Here is the caller graph for this function:

int32_t Geospatial::get_compression_scheme

(

const SQLTypeInfo &

ti

)

Definition at line 23 of file Compression.cpp.

References COMPRESSION_GEOINT32, COMPRESSION_NONE, SQLTypeInfo::get_comp_param(), SQLTypeInfo::get_compression(), kENCODING_GEOINT, and kENCODING_NONE.

Referenced by spatial_type::AreaPerimeter::codegen(), spatial_type::Centroid::codegen(), spatial_type::Distance::codegen(), CodeGenerator::codegenGeoBinOper(), CodeGenerator::codegenGeoUOper(), RelAlgTranslator::translateBinaryGeoFunction(), RelAlgTranslator::translateFunctionWithGeoArg(), RelAlgTranslator::translateTernaryGeoFunction(), and RelAlgTranslator::translateUnaryGeoFunction().

                                                      {
  if (ti.get_compression() == kENCODING_GEOINT && ti.get_comp_param() == 32) {
    return COMPRESSION_GEOINT32;
  }
  if (ti.get_compression() != kENCODING_NONE) {
    throw std::runtime_error("Invalid compression");
  }
  return COMPRESSION_NONE;
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool Geospatial::is_null_point	(	const SQLTypeInfo &	geo_ti,
		const int8_t *	coords,
		const size_t	coords_sz
	)

Definition at line 178 of file Compression.cpp.

References CHECK_EQ, SQLTypeInfo::get_comp_param(), SQLTypeInfo::get_compression(), SQLTypeInfo::get_notnull(), SQLTypeInfo::get_type(), is_null_point_longitude_geoint32(), kENCODING_GEOINT, kENCODING_NONE, kPOINT, and NULL_ARRAY_DOUBLE.

Referenced by compress_coords(), anonymous_namespace{ResultSetIteration.cpp}::GeoLazyFetchHandler::fetch(), anonymous_namespace{ResultSetIteration.cpp}::GeoQueryOutputFetchHandler::fetch(), import_export::Importer::set_geo_physical_import_buffer(), and import_export::Importer::set_geo_physical_import_buffer_columnar().

                                           {
  if (geo_ti.get_type() == kPOINT && !geo_ti.get_notnull()) {
    if (geo_ti.get_compression() == kENCODING_GEOINT) {
      if (geo_ti.get_comp_param() == 32) {
        return Geospatial::is_null_point_longitude_geoint32(*((int32_t*)coords));
      }
    } else {
      CHECK_EQ(geo_ti.get_compression(), kENCODING_NONE);
      auto coords_ptr = (double*)coords;
      if (!coords_ptr) {
        return true;
      }
      return *coords_ptr == NULL_ARRAY_DOUBLE;
    }
  }
  return false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

DEVICE bool Geospatial::is_null_point_latitude_geoint32 ( const int32_t  compressed )

inline

Definition at line 57 of file CompressionRuntime.h.

                                                                             {
  // check compressed null point latitude: -2,147,483,648  --->  NULL
  return (*reinterpret_cast<const uint32_t*>(&compressed) == 0x80000000U);
}

DEVICE bool Geospatial::is_null_point_longitude_geoint32 ( const int32_t  compressed )

inline

Definition at line 52 of file CompressionRuntime.h.

Referenced by is_null_point().

                                                                              {
  // check compressed null point longitude: -2,147,483,648  --->  NULL
  return (*reinterpret_cast<const uint32_t*>(&compressed) == 0x80000000U);
}

Here is the caller graph for this function:

template<typename T >

void Geospatial::unpack_geo_vector	(	std::vector< T > &	output,
		const int8_t *	input_ptr,
		const size_t	sz
	)

Definition at line 101 of file Compression.cpp.

References CHECK_EQ, and heavydb.dtypes::T.

Referenced by decompress_coords< double, int32_t >(), decompress_coords< double, SQLTypeInfo >(), GeoTargetValueSerializer< kMULTILINESTRING >::serialize(), GeoWktSerializer< kMULTILINESTRING >::serialize(), GeoTargetValueSerializer< kPOLYGON >::serialize(), GeoWktSerializer< kPOLYGON >::serialize(), GeoTargetValueSerializer< kMULTIPOLYGON >::serialize(), and GeoWktSerializer< kMULTIPOLYGON >::serialize().

                                                                                       {
  if (sz == 0) {
    return;
  }
  auto elems = reinterpret_cast<const T*>(input_ptr);
  CHECK_EQ(size_t(0), sz % sizeof(T));
  const size_t num_elems = sz / sizeof(T);
  output.resize(num_elems);
  for (size_t i = 0; i < num_elems; i++) {
    output[i] = elems[i];
  }
}

Here is the caller graph for this function:

template<>

void Geospatial::unpack_geo_vector< int32_t >	(	std::vector< int32_t > &	output,
		const int8_t *	input_ptr,
		const size_t	sz
	)

Definition at line 115 of file Compression.cpp.

References CHECK_EQ.

                                                 {
  if (sz == 0) {
    return;
  }
  auto elems = reinterpret_cast<const int32_t*>(input_ptr);
  CHECK_EQ(size_t(0), sz % sizeof(int32_t));
  const size_t num_elems = sz / sizeof(int32_t);
  output.resize(num_elems);
  for (size_t i = 0; i < num_elems; i++) {
    output[i] = elems[i];
  }
}

Variable Documentation

const std::string Geospatial::kGeoColumnName {"geom"}

inline

Definition at line 23 of file ColumnNames.h.

Referenced by DBHandler::detect_column_types(), and QueryRunner::ImportDriver::importGeoTable().

std::map<std::tuple<int32_t, int32_t>, std::shared_ptr<OGRCoordinateTransformation> > Geospatial::transformation_map_

Definition at line 117 of file Types.cpp.

Referenced by Geospatial::GeoBase::getTransformation().

std::mutex Geospatial::transformation_map_mutex_

Definition at line 115 of file Types.cpp.

Referenced by Geospatial::GeoBase::getTransformation().