Backout ST_NumPoints function

Summary: Backing out the St_NumPoints function to fix unrecognized geometry fuzzer errors: https://github.com/facebookincubator/velox/actions/runs/16604171017/job/46974781558 .

Differential Revision: D79218935

Author: Krishna Pai

velox/docs/functions/presto/geospatial.rst

@@ -211,12 +211,6 @@ Accessors
    Returns an array of points in a geometry. Empty or null inputs
    return null.
 
-.. function:: ST_NumPoints(geometry: Geometry) -> points: integer
-
-   Returns the number of points in a geometry. This is an extension
-   to the SQL/MM ``ST_NumPoints`` function which only applies to
-   point and linestring.
-
 .. function:: geometry_nearest_points(geometry1: Geometry, geometry2: Geometry) -> points: array(geometry)
 
    Returns the points on each geometry nearest the other. If either geometry

velox/functions/prestosql/GeometryFunctions.h

@@ -1359,101 +1359,4 @@ struct StEnvelopeAsPtsFunction {
   geos::geom::GeometryFactory::Ptr factory_;
 };
 
-template <typename T>
-struct StNumPointsFunction {
-  VELOX_DEFINE_FUNCTION_TYPES(T);
-
-  FOLLY_ALWAYS_INLINE void call(
-      out_type<int32_t>& result,
-      const arg_type<Geometry>& geometry) {
-    auto geosGeometry = geospatial::GeometryDeserializer::deserialize(geometry);
-
-    result = pointCount(*geosGeometry);
-  }
-
- private:
-  int32_t pointCount(const geos::geom::Geometry& geometry) {
-    if (geometry.isEmpty()) {
-      return 0;
-    }
-    if (geometry.getGeometryTypeId() ==
-        geos::geom::GeometryTypeId::GEOS_POINT) {
-      return 1;
-    }
-    if (geometry.getGeometryTypeId() ==
-        geos::geom::GeometryTypeId::GEOS_LINESTRING) {
-      return static_cast<int32_t>(geometry.getNumPoints());
-    }
-    if (geospatial::isMultiType(geometry)) {
-      auto numGeometries = geometry.getNumGeometries();
-      auto multiTypePointCount = 0;
-      for (int i = 0; i < numGeometries; i++) {
-        auto entry = geometry.getGeometryN(i);
-        multiTypePointCount += pointCount(*entry);
-      }
-      return multiTypePointCount;
-    }
-    if (geometry.getGeometryTypeId() ==
-        geos::geom::GeometryTypeId::GEOS_POLYGON) {
-      auto polygon = static_cast<const geos::geom::Polygon*>(&geometry);
-      // Subtract 1 to remove closing point, since we don't count the closing
-      // point in Java.
-      auto polygonPointCount = polygon->getExteriorRing()->getNumPoints() - 1;
-      for (int i = 0; i < polygon->getNumInteriorRing(); i++) {
-        auto interiorRing = polygon->getInteriorRingN(i);
-        polygonPointCount += interiorRing->getNumPoints() - 1;
-      }
-      return static_cast<int32_t>(polygonPointCount);
-    }
-    VELOX_FAIL(fmt::format(
-        "Unexpected failure in ST_NumPoints: geometry type {}",
-        geometry.getGeometryType()));
-  }
-};
-
-template <typename T>
-struct GeometryNearestPointsFunction {
-  VELOX_DEFINE_FUNCTION_TYPES(T);
-
-  GeometryNearestPointsFunction() {
-    factory_ = geos::geom::GeometryFactory::create();
-  }
-
-  FOLLY_ALWAYS_INLINE bool call(
-      out_type<Array<Geometry>>& result,
-      const arg_type<Geometry>& leftGeometry,
-      const arg_type<Geometry>& rightGeometry) {
-    auto left = geospatial::GeometryDeserializer::deserialize(leftGeometry);
-    auto right = geospatial::GeometryDeserializer::deserialize(rightGeometry);
-
-    if (left->isEmpty() || right->isEmpty()) {
-      return false;
-    }
-
-    GEOS_RETHROW(
-        {
-          std::unique_ptr<geos::geom::CoordinateSequence> nearestCoordinates =
-              geos::operation::distance::DistanceOp::nearestPoints(
-                  left.get(), right.get());
-
-          auto pointA =
-              std::unique_ptr<geos::geom::Point>(factory_->createPoint(
-                  geos::geom::Coordinate(nearestCoordinates->getAt(0))));
-          auto pointB =
-              std::unique_ptr<geos::geom::Point>(factory_->createPoint(
-                  geos::geom::Coordinate(nearestCoordinates->getAt(1))));
-
-          result.reserve(2);
-          geospatial::GeometrySerializer::serialize(*pointA, result.add_item());
-          geospatial::GeometrySerializer::serialize(*pointB, result.add_item());
-        },
-        "Failed to compute nearest points between geometries");
-
-    return true;
-  }
-
- private:
-  geos::geom::GeometryFactory::Ptr factory_;
-};
-
 } // namespace facebook::velox::functions

velox/functions/prestosql/registration/GeometryFunctionsRegistration.cpp

@@ -136,13 +136,6 @@ void registerAccessors(const std::string& prefix) {
       std::make_unique<StCoordDimFunction>());
   registerFunction<StPointsFunction, Array<Geometry>, Geometry>(
       {{prefix + "ST_Points"}});
-  registerFunction<StNumPointsFunction, int32_t, Geometry>(
-      {{prefix + "ST_NumPoints"}});
-  registerFunction<
-      GeometryNearestPointsFunction,
-      Array<Geometry>,
-      Geometry,
-      Geometry>({{prefix + "geometry_nearest_points"}});
 }
 
 } // namespace

velox/functions/prestosql/tests/GeometryFunctionsTest.cpp

@@ -2476,43 +2476,6 @@ TEST_F(GeometryFunctionsTest, testStEnvelopeAsPts) {
   testStEnvelopeAsPtsNullAndEmptyFunc(std::nullopt);
 }
 
-TEST_F(GeometryFunctionsTest, testStNumPoints) {
-  const auto testStNumPointsFunc = [&](const std::optional<std::string>& wkt,
-                                       const std::optional<int32_t>& expected) {
-    std::optional<int32_t> result =
-        evaluateOnce<int32_t>("ST_NumPoints(ST_GeometryFromText(c0))", wkt);
-
-    if (expected.has_value()) {
-      ASSERT_TRUE(result.has_value());
-      ASSERT_EQ(result.value(), expected.value());
-    } else {
-      ASSERT_FALSE(result.has_value());
-    }
-  };
-
-  testStNumPointsFunc("POINT EMPTY", 0);
-  testStNumPointsFunc("MULTIPOINT EMPTY", 0);
-  testStNumPointsFunc("LINESTRING EMPTY", 0);
-  testStNumPointsFunc("MULTILINESTRING EMPTY", 0);
-  testStNumPointsFunc("POLYGON EMPTY", 0);
-  testStNumPointsFunc("MULTIPOLYGON EMPTY", 0);
-  testStNumPointsFunc("GEOMETRYCOLLECTION EMPTY", 0);
-
-  testStNumPointsFunc("POINT (1 2)", 1);
-  testStNumPointsFunc("MULTIPOINT (1 2, 2 4, 3 6, 4 8)", 4);
-  testStNumPointsFunc("LINESTRING (8 4, 5 7)", 2);
-  testStNumPointsFunc("MULTILINESTRING ((1 1, 5 1), (2 4, 4 4))", 4);
-  testStNumPointsFunc("POLYGON ((0 0, 8 0, 0 8, 0 0))", 3);
-  testStNumPointsFunc(
-      "POLYGON ((0 0, 8 0, 0 8, 0 0), (1 1, 1 5, 5 1, 1 1))", 6);
-  testStNumPointsFunc(
-      "MULTIPOLYGON (((1 1, 1 3, 3 3, 3 1, 1 1)), ((2 4, 2 6, 6 6, 6 4, 2 4)))",
-      8);
-  testStNumPointsFunc(
-      "GEOMETRYCOLLECTION (POINT (1 1), GEOMETRYCOLLECTION (LINESTRING (0 0, 1 1), GEOMETRYCOLLECTION (POLYGON ((2 2, 2 3, 3 3, 3 2, 2 2)))))",
-      7);
-}
-
 TEST_F(GeometryFunctionsTest, testGeometryNearestPoints) {
   const auto testGeometryNearestPointsFunc = [&](const std::optional<
                                                      std::string>& wkt1,