Postgres TPU tests for custom-mapped Point type.

Author: rspeele

src/TypeProviderUsers/TypeProviderUser.Postgres.UserTypes/Library.fs

@@ -25,3 +25,23 @@ type Address =
         box (JsonSerializer.Serialize(a))
     static member FromPrimitive(o : obj) : Address =
         JsonSerializer.Deserialize<Address>(o :?> string)
+
+/// 2D point as a user primitive that stores as PG `point`. Where Address
+/// exercises an obj-underlying type whose value carries the column data as
+/// a string, Point2D exercises an obj-underlying type whose value is a
+/// driver-specific struct (NpgsqlPoint) — Npgsql's native CLR
+/// representation for the `point` backend type. This proves the
+/// System.Object escape hatch also handles non-string driver values.
+// Note: 15 = NpgsqlTypes.NpgsqlDbType.Point (Npgsql 8.x). Hardcoded
+// as a literal for the same attribute-argument reason as Jsonb above.
+[<RawBackendSQLType("point")>]
+[<SQLParameterDbType("NpgsqlDbType", 15)>]
+type Point2D =
+    {   X : double
+        Y : double
+    }
+    static member ToPrimitive(p : Point2D) : obj =
+        box (NpgsqlTypes.NpgsqlPoint(p.X, p.Y))
+    static member FromPrimitive(o : obj) : Point2D =
+        let pt = o :?> NpgsqlTypes.NpgsqlPoint
+        { X = pt.X; Y = pt.Y }

src/TypeProviderUsers/TypeProviderUser.Postgres/Shared.fs

@@ -13,6 +13,7 @@ type TestModel = SQLModel<".">
 type CleanTestData = SQL<"""
 vendor postgres {
     drop table if exists __RZSQL_MIGRATIONS;
+    drop table if exists UserLocations;
     drop table if exists UserAddresses;
     drop table if exists ArticleComments;
     drop table if exists Articles;

src/TypeProviderUsers/TypeProviderUser.Postgres/TestUserPrimitivePoint.fs

@@ -0,0 +1,103 @@
+module TypeProviderUser.Postgres.TestUserPrimitivePoint
+open NUnit.Framework
+open Rezoom.SQL
+open Rezoom.SQL.Raw
+open TypeProviderUser.Postgres.UserTypes
+
+// Point2D maps to PG's `point` type via the System.Object escape hatch
+// with NpgsqlPoint as the driver value (not a string), exercising a
+// different shape from the jsonb/Address case in TestUserPrimitiveSystemObject.
+
+let private homerPoint = { X = 1.5; Y = 2.5 }
+let private margePoint = { X = 1.5; Y = 2.5 }
+let private bartPoint = { X = -7.25; Y = 99.0 }
+
+type InsertAndSelectPoints = SQL<"""
+insert into UserLocations(UserId, Coord)
+values((select Id from Users where Name = 'Homer'), @homer);
+insert into UserLocations(UserId, Coord)
+values((select Id from Users where Name = 'Marge'), @marge);
+select Coord from UserLocations order by Id;
+""">
+
+[<Test>]
+let ``select roundtrips a Point2D user primitive over PG point`` () =
+    let results = InsertAndSelectPoints.Command(homerPoint, margePoint) |> runOnTestData
+    Assert.AreEqual(2, results.Count)
+    Assert.AreEqual(homerPoint, results.[0].Coord)
+    Assert.AreEqual(margePoint, results.[1].Coord)
+
+// PG's point type has no `=` operator (42883: "operator does not
+// exist: point = point"). Equality is `~=` (the same-as operator),
+// which Rezoom's parser doesn't know — unsafe_inject_raw is the
+// idiomatic escape hatch here. The parameter @needle still binds
+// through Rezoom as a Point2D, then PG's ~= compares it against the
+// column value at row scan time, exercising the full
+// parameter-as-point pipeline.
+type FindPointByParameterSameAs = SQL<"""
+insert into UserLocations(UserId, Coord)
+values((select Id from Users where Name = 'Homer'), @homer);
+insert into UserLocations(UserId, Coord)
+values((select Id from Users where Name = 'Marge'), @bart);
+select Coord from UserLocations ul where unsafe_inject_raw(@filter);
+""">
+
+[<Test>]
+let ``select with Point2D parameter equality matches via PG ~= operator`` () =
+    // Identifiers are emitted unquoted by Rezoom's PG backend, so PG
+    // folds them lowercase — `ul.coord`, not `"Coord"`.
+    //
+    // Caveat: Rezoom.SQL.Raw.arg does not apply user-type ToPrimitive
+    // translation — it routes the value straight to ADO.NET with a
+    // guessed DbType. So we cannot pass a Point2D here and expect the
+    // Point2D → NpgsqlPoint conversion to happen automatically. We
+    // pre-convert to NpgsqlPoint in user space; Npgsql then
+    // auto-detects the wire format from the value's runtime type.
+    // The fully-translated user-type → parameter pipeline is already
+    // exercised by the INSERT in the roundtrip test above; this test
+    // covers the WHERE-side parameter comparison via ~=.
+    let needle = NpgsqlTypes.NpgsqlPoint(homerPoint.X, homerPoint.Y)
+    let results =
+        FindPointByParameterSameAs.Command
+            ( bart = bartPoint
+            , filter = [| sql "ul.coord ~= "; arg needle |]
+            , homer = homerPoint
+            )
+        |> runOnTestData
+    Assert.AreEqual(1, results.Count)
+    Assert.AreEqual(homerPoint, results.[0].Coord)
+
+// Same functional intent as FindPointByParameterSameAs above, but using
+// the vendor/imagine escape hatch instead of unsafe_inject_raw. The
+// IMAGINE clause is typechecked against Rezoom's dialect, informing the
+// typechecker that @needle is a Point2D and that the result set has a
+// Coord column. The vendor body runs PG-native SQL — including ~= and
+// the `{@needle}` extra-brace param reference — and the user-type
+// translation pipeline still fires for @needle on the parameter side,
+// so the caller passes a real Point2D, not a NpgsqlPoint, from F#.
+type FindPointByParameterVendor = SQL<"""
+insert into UserLocations(UserId, Coord)
+values((select Id from Users where Name = 'Homer'), @homer);
+insert into UserLocations(UserId, Coord)
+values((select Id from Users where Name = 'Marge'), @bart);
+vendor postgres {
+    select Coord from UserLocations where coord ~= {@needle}
+} imagine {
+    select Coord from UserLocations where Coord = @needle
+};
+""">
+
+[<Test>]
+let ``select with Point2D parameter equality matches via vendor ~= with IMAGINE`` () =
+    // No manual NpgsqlPoint conversion: @needle stays typed as Point2D
+    // all the way through Rezoom, so the user-type SQLParameterDbType
+    // attribute is applied to the actual parameter being compared.
+    let results =
+        FindPointByParameterVendor.Command
+            ( bart = bartPoint
+            , homer = homerPoint
+            , needle = homerPoint
+            )
+        |> runOnTestData
+    Assert.AreEqual(1, results.Count)
+    Assert.AreEqual(homerPoint, results.[0].Coord)

src/TypeProviderUsers/TypeProviderUser.Postgres/TypeProviderUser.Postgres.fsproj

@@ -17,6 +17,7 @@
     <Compile Include="Shared.fs" />
     <Compile Include="TestSelects.fs" />
     <Compile Include="TestUserPrimitiveSystemObject.fs" />
+    <Compile Include="TestUserPrimitivePoint.fs" />
     <Compile Include="TestMigrateConnectionString.fs" />
     <Compile Include="Program.fs" />
     <None Include="appsettings.json" CopyToOutputDirectory="PreserveNewest" />

src/TypeProviderUsers/TypeProviderUser.Postgres/V1.model.sql

@@ -36,3 +36,9 @@ create table UserAddresses
 , Home Address
 );
 
+create table UserLocations
+( Id int64 primary key autoincrement
+, UserId int64 references Users(Id)
+, Coord Point2D
+);
+