postgres: support postgis point data type

Similar to the support we have for mysql's spatial `point` data type,
add support for postgis's `point`. Note: this is different from
postgres's built-in geometric data types.

Release-Note-Core: Add support for replicating postgis
  `geometry(point)` data type.
Fixes: REA-5721
Change-Id: I66a4fc0b1928f93f62e347253d9112960d2add9c
Reviewed-on: https://gerrit.readyset.name/c/readyset/+/9420
Tested-by: Buildkite CI
Reviewed-by: Michael Zink <michael.z@readyset.io>

Author: jasobrown-rs

data-generator/src/lib.rs

@@ -544,6 +544,7 @@ pub fn value_of_type(typ: &SqlType) -> DfValue {
         SqlType::Array(_) => unimplemented!(),
         SqlType::Other(_) => unimplemented!(),
         SqlType::Point => unimplemented!(),
+        SqlType::PostgisPoint => unimplemented!(),
     }
 }
 
@@ -684,6 +685,7 @@ where
         SqlType::Array(_) => unimplemented!(),
         SqlType::Other(_) => unimplemented!(),
         SqlType::Point => unimplemented!(),
+        SqlType::PostgisPoint => unimplemented!(),
     }
 }
 
@@ -829,5 +831,6 @@ pub fn unique_value_of_type(typ: &SqlType, idx: u32) -> DfValue {
         SqlType::Array(_) => unimplemented!(),
         SqlType::Other(_) => unimplemented!(),
         SqlType::Point => unimplemented!(),
+        SqlType::PostgisPoint => unimplemented!(),
     }
 }

logictests/replicated/postgis/point_spatial_type.test

@@ -0,0 +1,44 @@
+statement ok
+create extension postgis;
+
+statement ok
+create table locations (id int primary key, loc geometry(point));
+
+statement ok
+insert into locations values
+  (1, ST_PointFromText('POINT(1 2)')),
+  (2, ST_PointFromText('POINT(8.123 9.3145732)'));
+
+sleep 1000
+
+query B nosort
+select loc from locations where id = 1
+----
+0x0101000000000000000000F03F0000000000000040
+
+query B nosort
+select loc from locations where id = 2
+----
+0x0101000000E5D022DBF93E204069650CBD0FA12240
+
+
+
+# now test tables that explicitly set the SRID
+
+statement ok
+create table locations2 (id int primary key, loc geometry(point, 4326));
+
+statement ok
+insert into locations2 values
+  (1, ST_PointFromText('POINT(1 2)', 4326)),
+  (2, ST_PointFromText('POINT(8.123 9.3145732)', 4326));
+
+query B nosort
+select loc from locations2 where id = 1
+----
+0x0101000020E6100000000000000000F03F0000000000000040
+
+query B nosort
+select loc from locations2 where id = 2
+----
+0x0101000020E6100000E5D022DBF93E204069650CBD0FA12240

nom-sql/src/sql_type.rs

@@ -466,6 +466,22 @@ fn type_identifier_part3(
                 )),
                 |_| SqlType::Point,
             ),
+            // look for the postgis syntax of "geometry(point, 4326)"
+            map(
+                tuple((
+                    tag_no_case("geometry"),
+                    tuple((
+                        whitespace0,
+                        tag("("),
+                        whitespace0,
+                        tag_no_case("point"),
+                        opt(tuple((tag(","), whitespace0, digit1))),
+                        whitespace0,
+                        tag(")"),
+                    )),
+                )),
+                |_| SqlType::PostgisPoint,
+            ),
             map(other_type(dialect), SqlType::Other),
         ))(i)
     }
@@ -714,6 +730,17 @@ mod tests {
                 SqlType::MediumInt(None)
             );
         }
+        #[test]
+        fn point_type() {
+            let res = test_parse!(type_identifier(Dialect::MySQL), b"point");
+            assert_eq!(res, SqlType::Point);
+        }
+
+        #[test]
+        fn point_type_with_srid() {
+            let res = test_parse!(type_identifier(Dialect::MySQL), b"point srid 4326");
+            assert_eq!(res, SqlType::Point);
+        }
     }
 
     mod postgres {
@@ -780,15 +807,17 @@ mod tests {
         }
 
         #[test]
-        fn point_type() {
-            let res = test_parse!(type_identifier(Dialect::PostgreSQL), b"point");
-            assert_eq!(res, SqlType::Point);
+        fn geometry_point_type() {
+            let res = test_parse!(type_identifier(Dialect::PostgreSQL), b"geometry(point)");
+            assert_eq!(res, SqlType::PostgisPoint);
         }
-
         #[test]
-        fn point_type_with_srid() {
-            let res = test_parse!(type_identifier(Dialect::PostgreSQL), b"point srid 4326");
-            assert_eq!(res, SqlType::Point);
+        fn geometry_point_type_with_srid() {
+            let res = test_parse!(
+                type_identifier(Dialect::PostgreSQL),
+                b"geometry(point, 4326)"
+            );
+            assert_eq!(res, SqlType::PostgisPoint);
         }
 
         #[test]

readyset-data/src/float.rs

@@ -176,7 +176,8 @@ pub(crate) fn coerce_f64(val: f64, to_ty: &DfType, from_ty: &DfType) -> ReadySet
         | DfType::VarBit(_)
         | DfType::Array(_)
         | DfType::Row
-        | DfType::Point => Err(err("not allowed")),
+        | DfType::Point
+        | DfType::PostgisPoint => Err(err("not allowed")),
     }
 }
 
@@ -284,6 +285,7 @@ pub(crate) fn coerce_decimal(
         | DfType::VarBit(_)
         | DfType::Array(_)
         | DfType::Point
+        | DfType::PostgisPoint
         | DfType::Row => Err(ReadySetError::DfValueConversionError {
             src_type: "Decimal".to_string(),
             target_type: to_ty.to_string(),

readyset-data/src/integer.rs

@@ -206,7 +206,8 @@ where
         | DfType::VarBit(_)
         | DfType::Array(_)
         | DfType::Row
-        | DfType::Point => Err(ReadySetError::DfValueConversionError {
+        | DfType::Point
+        | DfType::PostgisPoint => Err(ReadySetError::DfValueConversionError {
             src_type: from_ty.to_string(),
             target_type: to_ty.to_string(),
             details: "Not allowed".to_string(),

readyset-data/src/lib.rs

@@ -2213,6 +2213,8 @@ impl<'a> FromSql<'a> for DfValue {
                     <&str>::from_sql(ty, raw)?,
                     Collation::Citext,
                 )),
+                // catch the postgis geometry types, and just pass through
+                ref ty if ty.name() == "geometry" => mk_from_sql!(Vec<u8>),
                 ref ty => Ok(DfValue::PassThrough(Arc::new(PassThrough {
                     ty: ty.clone(),
                     format: PassThroughFormat::Binary,
@@ -2580,7 +2582,8 @@ mod arbitrary {
             | Some(DfType::Uuid)
             | Some(DfType::Inet)
             | Some(DfType::Row)
-            | Some(DfType::Point) => Just(DfValue::None).boxed(),
+            | Some(DfType::Point)
+            | Some(DfType::PostgisPoint) => Just(DfValue::None).boxed(),
         }
     }
 }

readyset-data/src/text.rs

@@ -597,9 +597,11 @@ pub(crate) trait TextCoerce: Sized + Clone + Into<DfValue> {
                 }
             }
 
-            DfType::Bit(_) | DfType::VarBit(_) | DfType::Row | DfType::Point => {
-                Err(Self::coerce_err(to_ty, "Not allowed"))
-            }
+            DfType::Bit(_)
+            | DfType::VarBit(_)
+            | DfType::Row
+            | DfType::Point
+            | DfType::PostgisPoint => Err(Self::coerce_err(to_ty, "Not allowed")),
         }
     }
 }

readyset-data/src/timestamp.rs

@@ -568,7 +568,8 @@ impl TimestampTz {
             | DfType::VarBit(_)
             | DfType::Array(_)
             | DfType::Row
-            | DfType::Point => Err(ReadySetError::DfValueConversionError {
+            | DfType::Point
+            | DfType::PostgisPoint => Err(ReadySetError::DfValueConversionError {
                 src_type: "DfValue::TimestampTz".to_string(),
                 target_type: format!("{:?}", to_ty),
                 details: "Not allowed".to_string(),

readyset-data/src/type.rs

@@ -206,9 +206,13 @@ pub enum DfType {
     Jsonb,
 
     /// [MySQL `point`](https://dev.mysql.com/doc/refman/8.4/en/gis-class-point.html)
-    /// Note: We aren't supporting the old, legacy `point`/geometry data types that
-    /// are native to postgres. Instead, we'll support the postgis spatial types.
     Point,
+
+    /// [PostGIS `point`](https://postgis.net/docs/manual-3.5/using_postgis_dbmanagement.html#Point)
+    ///
+    /// This "postgis"-specific type is meant to distinguish it from the native `point` type in
+    /// PostgreSQL.
+    PostgisPoint,
 }
 
 /// Defaults.
@@ -323,6 +327,7 @@ impl DfType {
             Inet => unsupported!("Unsupported type: Inet"),
             Citext => Self::Text(Collation::Citext),
             Point => Self::Point,
+            PostgisPoint => Self::PostgisPoint,
             Other(ref id) => resolve_custom_type(id.clone()).ok_or_else(|| {
                 let id_upper = format!("{}", id.display_unquoted()).to_uppercase();
                 unsupported_err!("Unsupported type: {}", id_upper)
@@ -383,7 +388,8 @@ impl DfType {
             | DfType::Enum { .. }
             | DfType::Json
             | DfType::Jsonb
-            | DfType::Point => PgTypeCategory::UserDefined,
+            | DfType::Point
+            | DfType::PostgisPoint => PgTypeCategory::UserDefined,
         }
     }
 
@@ -829,6 +835,7 @@ impl fmt::Display for DfType {
             }
             Self::Numeric { prec, scale } => write!(f, "{kind:?}({prec}, {scale})"),
             Self::Point => write!(f, "Point"),
+            Self::PostgisPoint => write!(f, "Postgis Geometry(Point)"),
         }
     }
 }

readyset-e2e-tests/tests/types_mysql.rs

@@ -318,7 +318,7 @@ fn arbitrary_mysql_value_for_type(sql_type: SqlType) -> impl Strategy<Value = Va
         SqlType::Signed | SqlType::Unsigned | SqlType::UnsignedInteger | SqlType::SignedInteger => {
             unimplemented!("This type is only valid in `CAST` and can't be used as a Column Def")
         }
-        SqlType::Point => unimplemented!("Points aren't implemented yet"),
+        SqlType::Point | SqlType::PostgisPoint => unimplemented!("Points aren't implemented yet"),
     }
 }