Geospatial::GeoTypesFactory Class Reference

#include <Types.h>

Static Public Member Functions
static OGRGeometry *	createOGRGeometry (const std::string &wkt_or_wkb_hex, const bool validate_with_geos_if_available)
static std::unique_ptr< GeoBase >	createGeoType (const std::string &wkt_or_wkb_hex, const bool validate_with_geos_if_available)
static std::unique_ptr< GeoBase >	createGeoType (const WkbView, const bool validate_with_geos_if_available)
static std::unique_ptr< GeoBase >	createGeoType (OGRGeometry *geom, const bool validate_with_geos_if_available)
static bool	getGeoColumns (const std::string &wkt_or_wkb_hex, SQLTypeInfo &ti, std::vector< double > &coords, std::vector< double > &bounds, std::vector< int > &ring_sizes, std::vector< int > &poly_rings, const bool validate_with_geos_if_available)
static bool	getGeoColumns (const std::vector< uint8_t > &wkb, SQLTypeInfo &ti, std::vector< double > &coords, std::vector< double > &bounds, std::vector< int > &ring_sizes, std::vector< int > &poly_rings, const bool validate_with_geos_if_available)
static bool	getGeoColumns (OGRGeometry *geom, SQLTypeInfo &ti, std::vector< double > &coords, std::vector< double > &bounds, std::vector< int > &ring_sizes, std::vector< int > &poly_rings, const bool validate_with_geos_if_available)
static bool	getGeoColumns (const std::vector< std::string > *wkt_or_wkb_hex_column, SQLTypeInfo &ti, std::vector< std::vector< double >> &coords_column, std::vector< std::vector< double >> &bounds_column, std::vector< std::vector< int >> &ring_sizes_column, std::vector< std::vector< int >> &poly_rings_column, const bool validate_with_geos_if_available)
static void	getNullGeoColumns (SQLTypeInfo &ti, std::vector< double > &coords, std::vector< double > &bounds, std::vector< int > &ring_sizes, std::vector< int > &poly_rings)

Static Private Member Functions
static std::unique_ptr < Geospatial::GeoBase >	createGeoTypeImpl (OGRGeometry *geom, const bool owns_geom_obj=true)
static void	getGeoColumnsImpl (const std::unique_ptr< GeoBase > &geospatial_base, SQLTypeInfo &ti, std::vector< double > &coords, std::vector< double > &bounds, std::vector< int > &ring_sizes, std::vector< int > &poly_rings)

Detailed Description

Definition at line 291 of file Types.h.

Member Function Documentation

std::unique_ptr< GeoBase > Geospatial::GeoTypesFactory::createGeoType ( const std::string &  wkt_or_wkb_hex, const bool  validate_with_geos_if_available  )

static

Definition at line 1085 of file Types.cpp.

References createGeoTypeImpl(), createOGRGeometry(), and Geospatial::anonymous_namespace{Types.cpp}::validate_ogr().

Referenced by getGeoColumns(), Geospatial::GeoBase::optimized_run(), Geospatial::GeoBase::run(), RelAlgTranslator::translateGeoFunctionArg(), and ddl_utils::anonymous_namespace{DdlUtils.cpp}::validate_literal().

                                                {
  auto g = GeoTypesFactory::createGeoTypeImpl(
      createOGRGeometry(wkt_or_wkb_hex, false));  // validate next
  if (validate_with_geos_if_available) {
    validate_ogr(g->getOGRGeometry());
  }
  return g;
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::unique_ptr< GeoBase > Geospatial::GeoTypesFactory::createGeoType ( const WkbView  wkb_view, const bool  validate_with_geos_if_available  )

static

Definition at line 1096 of file Types.cpp.

References Geospatial::GeoBase::createFromWkbView(), createGeoTypeImpl(), and Geospatial::anonymous_namespace{Types.cpp}::validate_ogr().

                                                {
  OGRGeometry* geom = nullptr;
  const auto err = GeoBase::createFromWkbView(&geom, wkb_view);
  if (err != OGRERR_NONE) {
    throw GeoTypesError("GeoFactory", err);
  }
  auto g = GeoTypesFactory::createGeoTypeImpl(geom);
  if (validate_with_geos_if_available) {
    validate_ogr(g->getOGRGeometry());
  }
  return g;
}

Here is the call graph for this function:

std::unique_ptr< GeoBase > Geospatial::GeoTypesFactory::createGeoType ( OGRGeometry *  geom, const bool  validate_with_geos_if_available  )

static

Definition at line 1111 of file Types.cpp.

References createGeoTypeImpl(), and Geospatial::anonymous_namespace{Types.cpp}::validate_ogr().

                                                {
  auto g = GeoTypesFactory::createGeoTypeImpl(geom, false);
  if (validate_with_geos_if_available) {
    validate_ogr(g->getOGRGeometry());
  }
  return g;
}

Here is the call graph for this function:

std::unique_ptr< GeoBase > Geospatial::GeoTypesFactory::createGeoTypeImpl ( OGRGeometry *  geom, const bool  owns_geom_obj = true  )

staticprivate

Definition at line 1241 of file Types.cpp.

Referenced by createGeoType().

                                                                                      {
  switch (wkbFlatten(geom->getGeometryType())) {
    case wkbPoint:
      return std::unique_ptr<GeoPoint>(new GeoPoint(geom, owns_geom_obj));
    case wkbMultiPoint:
      return std::unique_ptr<GeoMultiPoint>(new GeoMultiPoint(geom, owns_geom_obj));
    case wkbLineString:
      return std::unique_ptr<GeoLineString>(new GeoLineString(geom, owns_geom_obj));
    case wkbMultiLineString:
      return std::unique_ptr<GeoMultiLineString>(
          new GeoMultiLineString(geom, owns_geom_obj));
    case wkbPolygon:
      return std::unique_ptr<GeoPolygon>(new GeoPolygon(geom, owns_geom_obj));
    case wkbMultiPolygon:
      return std::unique_ptr<GeoMultiPolygon>(new GeoMultiPolygon(geom, owns_geom_obj));
    case wkbGeometryCollection:
      return std::unique_ptr<GeoGeometryCollection>(
          new GeoGeometryCollection(geom, owns_geom_obj));
    default:
      throw GeoTypesError(
          "GeoTypesFactory",
          "Unrecognized geometry type: " + std::string(geom->getGeometryName()));
  }
}

Here is the caller graph for this function:

OGRGeometry * Geospatial::GeoTypesFactory::createOGRGeometry ( const std::string &  wkt_or_wkb_hex, const bool  validate_with_geos_if_available  )

static

Definition at line 1063 of file Types.cpp.

References Geospatial::GeoBase::createFromWkbView(), Geospatial::GeoBase::createFromWktString(), Geospatial::anonymous_namespace{Types.cpp}::hex_string_to_binary_vector(), and Geospatial::anonymous_namespace{Types.cpp}::validate_ogr().

Referenced by createGeoType(), and import_export::import_thread_delimited().

                                                {
  OGRGeometry* geom = nullptr;
  OGRErr err = OGRERR_NONE;
  if (wkt_or_wkb_hex.empty()) {
    err = OGRERR_NOT_ENOUGH_DATA;
  } else if (wkt_or_wkb_hex[0] == '0') {  // all WKB hex strings start with a 0
    auto const wkb = hex_string_to_binary_vector(wkt_or_wkb_hex);
    err = GeoBase::createFromWkbView(&geom, {wkb.data(), wkb.size()});
  } else {
    err = GeoBase::createFromWktString(wkt_or_wkb_hex, &geom);
  }
  if (err != OGRERR_NONE) {
    throw GeoTypesError("GeoFactory", err);
  }
  if (validate_with_geos_if_available) {
    validate_ogr(geom);
  }
  return geom;
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool Geospatial::GeoTypesFactory::getGeoColumns ( const std::string &  wkt_or_wkb_hex, SQLTypeInfo &  ti, std::vector< double > &  coords, std::vector< double > &  bounds, std::vector< int > &  ring_sizes, std::vector< int > &  poly_rings, const bool  validate_with_geos_if_available  )

static

Definition at line 1121 of file Types.cpp.

References createGeoType(), logger::ERROR, getGeoColumnsImpl(), getNullGeoColumns(), and LOG.

Referenced by Parser::InsertValuesStmt::analyze(), import_export::TypedImportBuffer::convert_arrow_val_to_import_buffer(), Parser::AddColumnStmt::execute(), import_export::fill_missing_columns(), DBHandler::fillGeoColumns(), getGeoColumns(), import_export::import_thread_delimited(), import_export::import_thread_shapefile(), Analyzer::GeoConstant::makePhysicalConstant(), foreign_storage::TextFileBufferParser::processGeoColumn(), foreign_storage::GeospatialEncoder::processGeoElement(), and RelAlgTranslator::translateGeoLiteral().

                                                                                {
  try {
    if (wkt_or_wkb_hex.empty() || wkt_or_wkb_hex == "NULL") {
      getNullGeoColumns(ti, coords, bounds, ring_sizes, poly_rings);
      return true;
    }

    const auto geospatial_base =
        GeoTypesFactory::createGeoType(wkt_or_wkb_hex, validate_with_geos_if_available);

    if (!geospatial_base || !geospatial_base->transform(ti)) {
      return false;
    }

    getGeoColumnsImpl(geospatial_base, ti, coords, bounds, ring_sizes, poly_rings);

  } catch (const std::exception& e) {
    LOG(ERROR) << "Geospatial Import Error: " << e.what();
    return false;
  }

  return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool Geospatial::GeoTypesFactory::getGeoColumns ( const std::vector< uint8_t > &  wkb, SQLTypeInfo &  ti, std::vector< double > &  coords, std::vector< double > &  bounds, std::vector< int > &  ring_sizes, std::vector< int > &  poly_rings, const bool  validate_with_geos_if_available  )

static

Definition at line 1151 of file Types.cpp.

References createGeoType(), logger::ERROR, getGeoColumnsImpl(), and LOG.

                                                                                {
  try {
    const auto geospatial_base = GeoTypesFactory::createGeoType(
        {wkb.data(), wkb.size()}, validate_with_geos_if_available);

    if (!geospatial_base || !geospatial_base->transform(ti)) {
      return false;
    }

    getGeoColumnsImpl(geospatial_base, ti, coords, bounds, ring_sizes, poly_rings);

  } catch (const std::exception& e) {
    LOG(ERROR) << "Geospatial Import Error: " << e.what();
    return false;
  }

  return true;
}

Here is the call graph for this function:

bool Geospatial::GeoTypesFactory::getGeoColumns ( OGRGeometry *  geom, SQLTypeInfo &  ti, std::vector< double > &  coords, std::vector< double > &  bounds, std::vector< int > &  ring_sizes, std::vector< int > &  poly_rings, const bool  validate_with_geos_if_available  )

static

Definition at line 1176 of file Types.cpp.

References createGeoType(), logger::ERROR, getGeoColumnsImpl(), and LOG.

                                                                                {
  try {
    const auto geospatial_base =
        GeoTypesFactory::createGeoType(geom, validate_with_geos_if_available);

    if (!geospatial_base || !geospatial_base->transform(ti)) {
      return false;
    }

    getGeoColumnsImpl(geospatial_base, ti, coords, bounds, ring_sizes, poly_rings);

  } catch (const std::exception& e) {
    LOG(ERROR) << "Geospatial Import Error: " << e.what();
    return false;
  }

  return true;
}

Here is the call graph for this function:

bool Geospatial::GeoTypesFactory::getGeoColumns ( const std::vector< std::string > *  wkt_or_wkb_hex_column, SQLTypeInfo &  ti, std::vector< std::vector< double >> &  coords_column, std::vector< std::vector< double >> &  bounds_column, std::vector< std::vector< int >> &  ring_sizes_column, std::vector< std::vector< int >> &  poly_rings_column, const bool  validate_with_geos_if_available  )

static

Definition at line 1201 of file Types.cpp.

References logger::ERROR, geo_promoted_type_match(), SQLTypeInfo::get_type(), getGeoColumns(), and LOG.

                                                                                {
  try {
    for (const auto& wkt_or_wkb_hex : *wkt_or_wkb_hex_column) {
      std::vector<double> coords;
      std::vector<double> bounds;
      std::vector<int> ring_sizes;
      std::vector<int> poly_rings;

      SQLTypeInfo row_ti{ti};
      getGeoColumns(wkt_or_wkb_hex,
                    row_ti,
                    coords,
                    bounds,
                    ring_sizes,
                    poly_rings,
                    validate_with_geos_if_available);

      if (!geo_promoted_type_match(row_ti.get_type(), ti.get_type())) {
        throw GeoTypesError("GeoFactory", "Columnar: Geometry type mismatch");
      }
      coords_column.push_back(coords);
      bounds_column.push_back(bounds);
      ring_sizes_column.push_back(ring_sizes);
      poly_rings_column.push_back(poly_rings);
    }

  } catch (const std::exception& e) {
    LOG(ERROR) << "Geospatial column Import Error: " << e.what();
    return false;
  }

  return true;
}

Here is the call graph for this function:

void Geospatial::GeoTypesFactory::getGeoColumnsImpl ( const std::unique_ptr< GeoBase > &  geospatial_base, SQLTypeInfo &  ti, std::vector< double > &  coords, std::vector< double > &  bounds, std::vector< int > &  ring_sizes, std::vector< int > &  poly_rings  )

staticprivate

Definition at line 1267 of file Types.cpp.

References CHECK, CHECK_EQ, CHECK_GT, Geospatial::GeoBase::kGEOMETRY, Geospatial::GeoBase::kGEOMETRYCOLLECTION, Geospatial::GeoBase::kLINESTRING, kLINESTRING, Geospatial::GeoBase::kMULTILINESTRING, kMULTILINESTRING, Geospatial::GeoBase::kMULTIPOINT, kMULTIPOINT, Geospatial::GeoBase::kMULTIPOLYGON, kMULTIPOLYGON, Geospatial::GeoBase::kPOINT, kPOINT, Geospatial::GeoBase::kPOLYGON, kPOLYGON, and SQLTypeInfo::set_type().

Referenced by getGeoColumns().

                                                                    {
  switch (geospatial_base->getType()) {
    case GeoBase::GeoType::kPOINT: {
      const auto geospatial_point = dynamic_cast<GeoPoint*>(geospatial_base.get());
      CHECK(geospatial_point);
      geospatial_point->getColumns(coords);
      ti.set_type(kPOINT);
      // in case of promotion to MULTIPOINT
      CHECK_EQ(coords.size(), 2u);
      bounds.reserve(4);
      bounds.push_back(coords[0]);
      bounds.push_back(coords[1]);
      bounds.push_back(coords[0]);
      bounds.push_back(coords[1]);
      break;
    }
    case GeoBase::GeoType::kMULTIPOINT: {
      const auto geospatial_multipoint =
          dynamic_cast<GeoMultiPoint*>(geospatial_base.get());
      CHECK(geospatial_multipoint);
      geospatial_multipoint->getColumns(coords, bounds);
      ti.set_type(kMULTIPOINT);
      break;
    }
    case GeoBase::GeoType::kLINESTRING: {
      const auto geospatial_linestring =
          dynamic_cast<GeoLineString*>(geospatial_base.get());
      CHECK(geospatial_linestring);
      geospatial_linestring->getColumns(coords, bounds);
      ti.set_type(kLINESTRING);
      // in case of promotion to MULTILINESTRING
      ring_sizes.push_back(coords.size() / 2);
      break;
    }
    case GeoBase::GeoType::kMULTILINESTRING: {
      const auto geospatial_multilinestring =
          dynamic_cast<GeoMultiLineString*>(geospatial_base.get());
      CHECK(geospatial_multilinestring);
      geospatial_multilinestring->getColumns(coords, ring_sizes, bounds);
      ti.set_type(kMULTILINESTRING);
      break;
    }
    case GeoBase::GeoType::kPOLYGON: {
      const auto geospatial_poly = dynamic_cast<GeoPolygon*>(geospatial_base.get());
      CHECK(geospatial_poly);
      geospatial_poly->getColumns(coords, ring_sizes, bounds);
      ti.set_type(kPOLYGON);
      // in case of promotion to MULTIPOLYGON
      if (ring_sizes.size()) {
        CHECK_GT(coords.size(), 0u);
        poly_rings.push_back(1 + geospatial_poly->getNumInteriorRings());
      } else {
        poly_rings.push_back(0);
      }
      break;
    }
    case GeoBase::GeoType::kMULTIPOLYGON: {
      const auto geospatial_mpoly = dynamic_cast<GeoMultiPolygon*>(geospatial_base.get());
      CHECK(geospatial_mpoly);
      geospatial_mpoly->getColumns(coords, ring_sizes, poly_rings, bounds);
      ti.set_type(kMULTIPOLYGON);
      break;
    }
    case GeoBase::GeoType::kGEOMETRY:
    case GeoBase::GeoType::kGEOMETRYCOLLECTION:
    default:
      throw std::runtime_error("Unrecognized geospatial type");
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Geospatial::GeoTypesFactory::getNullGeoColumns ( SQLTypeInfo &  ti, std::vector< double > &  coords, std::vector< double > &  bounds, std::vector< int > &  ring_sizes, std::vector< int > &  poly_rings  )

static

Definition at line 1342 of file Types.cpp.

References SQLTypeInfo::get_type(), kLINESTRING, kMULTILINESTRING, kMULTIPOINT, kMULTIPOLYGON, kPOINT, kPOLYGON, NULL_ARRAY_DOUBLE, and NULL_DOUBLE.

Referenced by import_export::TypedImportBuffer::convert_arrow_val_to_import_buffer(), getGeoColumns(), import_export::import_thread_delimited(), import_export::import_thread_shapefile(), foreign_storage::TextFileBufferParser::processGeoColumn(), foreign_storage::TextFileBufferParser::processInvalidGeoColumn(), and foreign_storage::GeospatialEncoder::processNullGeoElement().

                                                                    {
  auto t = ti.get_type();
  switch (t) {
    case kPOINT: {
      // NULL fixlen coords array
      coords.push_back(NULL_ARRAY_DOUBLE);
      coords.push_back(NULL_DOUBLE);
    } break;
    case kMULTIPOINT:
    case kLINESTRING:
    case kMULTILINESTRING:
    case kPOLYGON:
    case kMULTIPOLYGON: {
      // Leaving coords array empty
      // NULL fixlen bounds array
      bounds.push_back(NULL_ARRAY_DOUBLE);
      bounds.push_back(NULL_DOUBLE);
      bounds.push_back(NULL_DOUBLE);
      bounds.push_back(NULL_DOUBLE);
      // Leaving ring_sizes and poly_rings arrays empty
    } break;
    default:
      throw std::runtime_error("Unsupported NULL geo");
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

---

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

• /home/jenkins-slave/workspace/core-os-doxygen/Geospatial/Types.h
• /home/jenkins-slave/workspace/core-os-doxygen/Geospatial/Types.cpp