feat: Implement ST_Point ST_X ST_Y (facebookincubator#13372)

Summary:
Pull Request resolved: facebookincubator#13372

These construct a point and access its members.

Reviewed By: bikramSingh91, Sullivan-Patrick

Differential Revision: D74898391

fbshipit-source-id: 40b64b7b4805f67dc76fa7537718a42131c1b480

Author: jagill

velox/docs/functions/presto/geospatial.rst

@@ -67,6 +67,11 @@ Geometry Constructors
 
     Returns the Well-Known Binary (WKB) formatted binary of the Geometry object.
 
+.. function:: ST_Point(x: double, y: double) -> geometry: Geometry
+
+    Returns the Point geometry at the given coordinates.  This will raise an
+    error if ``x`` or ``y`` is ``NaN`` or ``infinity``.
+
 Spatial Predicates
 ------------------
 
@@ -160,6 +165,17 @@ Accessors
     returns the sum of the areas of the individual geometries. Empty geometries
     return 0.
 
+.. function:: ST_X(geometry: Geometry) -> x: double
+
+    Returns the ``x`` coordinate of the geometry if it is a Point.  Returns
+    ``null`` if the geometry is empty.  Raises an error if the geometry is
+    not a Point and not empty.
+
+.. function:: ST_Y(geometry: Geometry) -> x: double
+
+    Returns the ``y`` coordinate of the geometry if it is a Point.  Returns
+    ``null`` if the geometry is empty.  Raises an error if the geometry is
+    not a Point and not empty.
 
 Bing Tile Functions
 -------------------

velox/expression/fuzzer/ExpressionFuzzerTest.cpp

@@ -147,6 +147,9 @@ int main(int argc, char** argv) {
       "st_intersection",
       "st_symdifference",
       "st_union",
+      "st_point",
+      "st_x",
+      "st_y",
   };
   size_t initialSeed = FLAGS_seed == 0 ? std::time(nullptr) : FLAGS_seed;
 

velox/functions/prestosql/GeometryFunctions.h

@@ -16,10 +16,14 @@
 
 #pragma once
 
+#include <geos/geom/Coordinate.h>
 #include <geos/io/WKBReader.h>
 #include <geos/io/WKBWriter.h>
 #include <geos/io/WKTReader.h>
 #include <geos/io/WKTWriter.h>
+#include <geos/util/AssertionFailedException.h>
+#include <geos/util/UnsupportedOperationException.h>
+#include <cmath>
 
 #include <velox/type/StringView.h>
 #include "velox/functions/Macros.h"
@@ -109,6 +113,32 @@ struct StAsBinaryFunction {
   }
 };
 
+template <typename T>
+struct StPointFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE Status call(
+      out_type<Geometry>& result,
+      const arg_type<double>& x,
+      const arg_type<double>& y) {
+    if (!std::isfinite(x) || !std::isfinite(y)) {
+      return Status::UserError(fmt::format(
+          "ST_Point requires finite coordinates, got x={} y={}", x, y));
+    }
+    GEOS_TRY(
+        {
+          geos::geom::GeometryFactory::Ptr factory =
+              geos::geom::GeometryFactory::create();
+          geos::geom::Point* point =
+              factory->createPoint(geos::geom::Coordinate(x, y));
+          result = geospatial::serializeGeometry(*point);
+          factory->destroyGeometry(point);
+        },
+        "Failed to create point geometry");
+    return Status::OK();
+  }
+};
+
 // Predicates
 
 template <typename T>
@@ -391,6 +421,8 @@ struct StUnionFunction {
   }
 };
 
+// Accessors
+
 template <typename T>
 struct StAreaFunction {
   VELOX_DEFINE_FUNCTION_TYPES(T);
@@ -409,4 +441,52 @@ struct StAreaFunction {
   }
 };
 
+template <typename T>
+struct StXFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE bool call(
+      out_type<double>& result,
+      const arg_type<Geometry>& geometry) {
+    std::unique_ptr<geos::geom::Geometry> geosGeometry =
+        geospatial::deserializeGeometry(geometry);
+    if (geosGeometry->getGeometryTypeId() !=
+        geos::geom::GeometryTypeId::GEOS_POINT) {
+      throw Status::UserError(fmt::format(
+          "ST_X requires a Point geometry, found {}",
+          geosGeometry->getGeometryType()));
+    }
+    if (geosGeometry->isEmpty()) {
+      return false;
+    }
+    auto coordinate = geosGeometry->getCoordinate();
+    result = coordinate->x;
+    return true;
+  }
+};
+
+template <typename T>
+struct StYFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE bool call(
+      out_type<double>& result,
+      const arg_type<Geometry>& geometry) {
+    std::unique_ptr<geos::geom::Geometry> geosGeometry =
+        geospatial::deserializeGeometry(geometry);
+    if (geosGeometry->getGeometryTypeId() !=
+        geos::geom::GeometryTypeId::GEOS_POINT) {
+      throw Status::UserError(fmt::format(
+          "ST_Y requires a Point geometry, found {}",
+          geosGeometry->getGeometryType()));
+    }
+    if (geosGeometry->isEmpty()) {
+      return false;
+    }
+    auto coordinate = geosGeometry->getCoordinate();
+    result = coordinate->y;
+    return true;
+  }
+};
+
 } // namespace facebook::velox::functions

velox/functions/prestosql/registration/GeometryFunctionsRegistration.cpp

@@ -22,6 +22,20 @@
 namespace facebook::velox::functions {
 
 namespace {
+
+void registerConstructors(const std::string& prefix) {
+  registerFunction<StGeometryFromTextFunction, Geometry, Varchar>(
+      {{prefix + "ST_GeometryFromText"}});
+  registerFunction<StGeomFromBinaryFunction, Geometry, Varbinary>(
+      {{prefix + "ST_GeomFromBinary"}});
+  registerFunction<StAsTextFunction, Varchar, Geometry>(
+      {{prefix + "ST_AsText"}});
+  registerFunction<StAsBinaryFunction, Varbinary, Geometry>(
+      {{prefix + "ST_AsBinary"}});
+  registerFunction<StPointFunction, Geometry, double, double>(
+      {{prefix + "ST_Point"}});
+}
+
 void registerRelationPredicates(const std::string& prefix) {
   registerFunction<StRelateFunction, bool, Geometry, Geometry, Varchar>(
       {{prefix + "ST_Relate"}});
@@ -55,26 +69,20 @@ void registerOverlayOperations(const std::string& prefix) {
       {{prefix + "ST_Union"}});
 }
 
+void registerAccessors(const std::string& prefix) {
+  registerFunction<StAreaFunction, double, Geometry>({{prefix + "ST_Area"}});
+  registerFunction<StXFunction, double, Geometry>({{prefix + "ST_X"}});
+  registerFunction<StYFunction, double, Geometry>({{prefix + "ST_Y"}});
+}
+
 } // namespace
 
 void registerGeometryFunctions(const std::string& prefix) {
   registerGeometryType();
-  registerFunction<StGeometryFromTextFunction, Geometry, Varchar>(
-      {{prefix + "ST_GeometryFromText"}});
-
-  registerFunction<StGeomFromBinaryFunction, Geometry, Varbinary>(
-      {{prefix + "ST_GeomFromBinary"}});
-
-  registerFunction<StAsTextFunction, Varchar, Geometry>(
-      {{prefix + "ST_AsText"}});
-
-  registerFunction<StAsBinaryFunction, Varbinary, Geometry>(
-      {{prefix + "ST_AsBinary"}});
-
-  registerFunction<StAreaFunction, double, Geometry>({{prefix + "ST_Area"}});
-
+  registerConstructors(prefix);
   registerRelationPredicates(prefix);
   registerOverlayOperations(prefix);
+  registerAccessors(prefix);
 }
 
 } // namespace facebook::velox::functions

velox/functions/prestosql/tests/GeometryFunctionsTest.cpp

@@ -236,6 +236,44 @@ TEST_F(GeometryFunctionsTest, wktAndWkb) {
       "Invalid number of points in LinearRing found 2 - must be 0 or >= 4");
 }
 
+// Constructors and accessors
+
+TEST_F(GeometryFunctionsTest, testStPoint) {
+  const auto assertPoint = [&](const std::optional<double>& x,
+                               const std::optional<double> y) {
+    std::optional<double> actualX =
+        evaluateOnce<double>("ST_X(ST_Point(c0, c1))", x, y);
+    std::optional<double> actualY =
+        evaluateOnce<double>("ST_Y(ST_Point(c0, c1))", x, y);
+    if (x.has_value() && y.has_value()) {
+      EXPECT_TRUE(actualX.has_value());
+      EXPECT_TRUE(actualY.has_value());
+      EXPECT_EQ(x.value(), actualX.value());
+      EXPECT_EQ(y.value(), actualY.value());
+    } else {
+      EXPECT_FALSE(actualX.has_value());
+      EXPECT_FALSE(actualY.has_value());
+    }
+  };
+
+  assertPoint(std::nullopt, 0.0);
+  assertPoint(0.0, 0.0);
+  assertPoint(1.0, -23.12344);
+  VELOX_ASSERT_THROW(
+      assertPoint(0.0, NAN),
+      "ST_Point requires finite coordinates, got x=0 y=nan");
+  VELOX_ASSERT_THROW(
+      assertPoint(INFINITY, 0.0),
+      "ST_Point requires finite coordinates, got x=inf y=0");
+
+  std::optional<double> nullX =
+      evaluateOnce<double>("ST_X(ST_GeometryFromText('POINT EMPTY'))");
+  EXPECT_FALSE(nullX.has_value());
+  std::optional<double> nullY =
+      evaluateOnce<double>("ST_Y(ST_GeometryFromText('POINT EMPTY'))");
+  EXPECT_FALSE(nullY.has_value());
+}
+
 // Relationship predicates
 
 TEST_F(GeometryFunctionsTest, testStRelate) {