New tests for object-mapping features.

Author: rspeele

src/Rezoom.SQL.Test.UserTypes/UserPrimitives.fs

@@ -93,4 +93,25 @@ type FileHash = FileHash of byte[]
 /// Single-case DU over byte[] with [<SQLTypeLength>] acts like
 /// BinaryTypeName(Some 32).
 [<SQLTypeLength(32)>]
-type ShortHash = ShortHash of byte[]
+type ShortHash = ShortHash of byte[]
+
+// --- SQLParameterDbType fixtures --------------------------------------
+// These exist purely so the loader-inspection tests in
+// Rezoom.SQL.Test.TestUserTypeAnnotations can assert the
+// SQLParameterDbType attribute round-trips into UserPrimitiveType. The
+// types themselves are never bound at runtime in the Rezoom.SQL.Test
+// suite; the assertions read the loaded UserTypeLibrary directly.
+
+/// Exercises the single-arg constructor — SQLParameterDbType(DbType).
+/// Expected to surface as ("DbType", int DbType.AnsiString) on the
+/// loaded UserPrimitiveType.SQLParameterDbType.
+[<SQLParameterDbType(System.Data.DbType.AnsiString)>]
+type AnsiLabel = AnsiLabel of string
+
+/// Exercises the two-arg escape-hatch constructor for provider-specific
+/// enums — SQLParameterDbType(propertyName, int). The values here are
+/// deliberately not bound at runtime; we only care that the metadata
+/// round-trips. (36 happens to be NpgsqlDbType.Jsonb but no
+/// Postgres-specific assembly is referenced from this fixture.)
+[<SQLParameterDbType("NpgsqlDbType", 36)>]
+type OpaqueDbTypeProbe = OpaqueDbTypeProbe of string

src/Rezoom.SQL.Test/TestUserTypeAnnotations.fs

@@ -1,5 +1,6 @@
 module Rezoom.SQL.Test.TestUserTypeAnnotations
 open NUnit.Framework
+open Rezoom.SQL.Mapping
 
 // --- SQLite: RawBackendSQLType emits the literal type verbatim --------
 
@@ -250,3 +251,48 @@ let ``tsql DU over byte[] without SQLTypeLength emits VARBINARY(max)`` () =
                     |> Some
             } |> Good
     } |> assertSimple
+
+// --- SQLParameterDbType loader-inspection regression tests ------------
+// These do not exercise SQL emission. Instead they load the user-types
+// library and inspect UserPrimitiveType.SQLParameterDbType directly,
+// catching attribute-loader breakage at compiler-test speed instead of
+// having to wait for a TPU run to surface it as a downstream PG error
+// like `column "home" is of type jsonb but expression is of type text`.
+
+let private userTypesLib =
+    lazy ((userModelByName "user-model-7-usertypes").UserTypeLibrary)
+
+let private primitive name =
+    match userTypesLib.Value.UserPrimitiveByName(name) with
+    | FoundType prim -> prim
+    | AmbiguousType _ ->
+        Assert.Fail(sprintf "User primitive '%s' is ambiguous in the loaded library." name)
+        Unchecked.defaultof<_>
+    | NotFoundType _ ->
+        Assert.Fail(sprintf "User primitive '%s' was not found in the loaded library." name)
+        Unchecked.defaultof<_>
+
+[<Test>]
+let ``SQLParameterDbType single-arg ctor on AnsiLabel loads as Some(DbType, int)`` () =
+    // [<SQLParameterDbType(System.Data.DbType.AnsiString)>] on AnsiLabel
+    // is the standard-DbType ctor; the C# attribute delegates to the
+    // two-arg form with property name "DbType" and value (int)dbType,
+    // and the loader records the same shape.
+    let expected = Some ("DbType", int System.Data.DbType.AnsiString)
+    Assert.That((primitive "AnsiLabel").SQLParameterDbType, Is.EqualTo(expected))
+
+[<Test>]
+let ``SQLParameterDbType two-arg ctor on OpaqueDbTypeProbe loads as Some(prop, int)`` () =
+    // [<SQLParameterDbType("NpgsqlDbType", 36)>] on OpaqueDbTypeProbe is
+    // the escape-hatch ctor used by provider-specific enums; the
+    // attribute identity check, ctor-arity branch, and tuple read all
+    // have to survive for the metadata to round-trip.
+    let expected = Some ("NpgsqlDbType", 36)
+    Assert.That((primitive "OpaqueDbTypeProbe").SQLParameterDbType, Is.EqualTo(expected))
+
+[<Test>]
+let ``SQLParameterDbType is None on a primitive without the attribute`` () =
+    // CompactInt has [<RawBackendSQLType>] but no [<SQLParameterDbType>],
+    // so the loader should leave the field as None. Guards against a
+    // future change that accidentally always-Somes the field.
+    Assert.That((primitive "CompactInt").SQLParameterDbType, Is.EqualTo(None))

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

@@ -0,0 +1,27 @@
+namespace TypeProviderUser.Postgres.UserTypes
+
+open System.Text.Json
+open Rezoom.SQL.Annotations
+
+/// Address as a user primitive that stores as PG jsonb. Demonstrates the
+/// System.Object underlying-CLR-type escape hatch: ToPrimitive returns
+/// `obj` (a JSON-serialized string boxed), and FromPrimitive accepts the
+/// same `obj` shape coming back from the driver. The RawBackendSQLType
+/// pins the SQL type as "jsonb" and the ParameterDbType attribute tells
+/// the runtime to set NpgsqlDbType.Jsonb on the parameter so Npgsql
+/// binds it as the right backend type.
+// Note: 36 = NpgsqlTypes.NpgsqlDbType.Jsonb (Npgsql 8.x).
+// F# does not accept enum-to-int casts in attribute argument
+// position so the integer literal is the cleanest available form.
+[<RawBackendSQLType("jsonb")>]
+[<SQLParameterDbType("NpgsqlDbType", 36)>]
+type Address =
+    {   Street : string
+        City : string
+        State : string
+        Zip : string
+    }
+    static member ToPrimitive(a : Address) : obj =
+        box (JsonSerializer.Serialize(a))
+    static member FromPrimitive(o : obj) : Address =
+        JsonSerializer.Deserialize<Address>(o :?> string)

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

@@ -0,0 +1,24 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net10.0</TargetFramework>
+    <GenerateDocumentationFile>true</GenerateDocumentationFile>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <Compile Include="Library.fs" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\..\Rezoom.SQL.Annotations\Rezoom.SQL.Annotations.csproj" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <!-- Pulled in only so the NpgsqlDbType enum is available at compile
+         time for the [<ParameterDbType("NpgsqlDbType", int NpgsqlDbType.Jsonb)>]
+         attribute argument. The attribute itself stores the int; Rezoom's
+         MLC loader doesn't need to resolve Npgsql at TP design time. -->
+    <PackageReference Include="Npgsql" Version="8.0.5" />
+  </ItemGroup>
+
+</Project>

src/TypeProviderUsers/TypeProviderUser.Postgres/Shared.fs

@@ -12,11 +12,12 @@ type TestModel = SQLModel<".">
 
 type CleanTestData = SQL<"""
 vendor postgres {
-    drop table __RZSQL_MIGRATIONS;
-    drop table ArticleComments;
-    drop table Articles;
-    drop table Users;
-    drop table Pictures;
+    drop table if exists __RZSQL_MIGRATIONS;
+    drop table if exists UserAddresses;
+    drop table if exists ArticleComments;
+    drop table if exists Articles;
+    drop table if exists Users;
+    drop table if exists Pictures;
 }
 """>
 

src/TypeProviderUsers/TypeProviderUser.Postgres/TestUserPrimitiveSystemObject.fs

@@ -0,0 +1,104 @@
+module TypeProviderUser.Postgres.TestUserPrimitiveSystemObject
+open NUnit.Framework
+open Rezoom.SQL
+open Rezoom.SQL.Raw
+open TypeProviderUser.Postgres.UserTypes
+
+let private homerAddr =
+    {   Street = "742 Evergreen Terrace"
+        City = "Springfield"
+        State = "OR"
+        Zip = "97477"
+    }
+
+let private margeAddr =
+    {   Street = "742 Evergreen Terrace"
+        City = "Springfield"
+        State = "OR"
+        Zip = "97477"
+    }
+
+let private bartAddr =
+    {   Street = "1313 Mockingbird Lane"
+        City = "Shelbyville"
+        State = "OR"
+        Zip = "97001"
+    }
+
+type InsertAndSelectAddresses = SQL<"""
+insert into UserAddresses(UserId, Home)
+values((select Id from Users where Name = 'Homer'), @homer);
+insert into UserAddresses(UserId, Home)
+values((select Id from Users where Name = 'Marge'), @marge);
+select Home from UserAddresses order by Id;
+""">
+
+[<Test>]
+let ``select roundtrips an Address user primitive over System.Object`` () =
+    let results = InsertAndSelectAddresses.Command(homerAddr, margeAddr) |> runOnTestData
+    Assert.AreEqual(2, results.Count)
+    Assert.AreEqual(homerAddr, results.[0].Home)
+    Assert.AreEqual(margeAddr, results.[1].Home)
+
+type FindAddressByParameterEquality = SQL<"""
+insert into UserAddresses(UserId, Home)
+values((select Id from Users where Name = 'Homer'), @homer);
+insert into UserAddresses(UserId, Home)
+values((select Id from Users where Name = 'Marge'), @bart);
+select Home from UserAddresses where Home = @needle;
+""">
+
+[<Test>]
+let ``select with Address parameter equality matches via PG jsonb = operator`` () =
+    let results =
+        FindAddressByParameterEquality.Command(bartAddr, homerAddr, homerAddr)
+        |> runOnTestData
+    Assert.AreEqual(1, results.Count)
+    Assert.AreEqual(homerAddr, results.[0].Home)
+
+type FindAddressByStateViaJsonOperator = SQL<"""
+insert into UserAddresses(UserId, Home)
+values((select Id from Users where Name = 'Homer'), @homer);
+insert into UserAddresses(UserId, Home)
+values((select Id from Users where Name = 'Marge'), @marge);
+select Home from UserAddresses ua where unsafe_inject_raw(@filter) order by ua.Id;
+""">
+
+[<Test>]
+let ``PG jsonb path operator on Address column works via unsafe_inject_raw`` () =
+    // We alias UserAddresses as ua in the SQL above so the raw filter
+    // can reference the column with a known qualifier. Rezoom's PG
+    // backend emits identifiers unquoted, so PG folds them to lowercase
+    // — the raw filter must use ua.home (lowercase) to resolve.
+    let results =
+        FindAddressByStateViaJsonOperator.Command
+            ( filter = [| sql "ua.home ->> 'City' = 'Shelbyville'" |]
+            , homer = homerAddr
+            , marge = bartAddr
+            )
+        |> runOnTestData
+    Assert.AreEqual(1, results.Count)
+    Assert.AreEqual(bartAddr, results.[0].Home)
+
+type FindAddressByInList = SQL<"""
+insert into UserAddresses(UserId, Home)
+values((select Id from Users where Name = 'Homer'), @homer);
+insert into UserAddresses(UserId, Home)
+values((select Id from Users where Name = 'Marge'), @marge);
+select Home from UserAddresses where Home in @needles;
+""">
+
+[<Test>]
+let ``select Address where in non-empty list matches the expected row`` () =
+    let results =
+        FindAddressByInList.Command(homerAddr, bartAddr, [| homerAddr |])
+        |> runOnTestData
+    Assert.AreEqual(1, results.Count)
+    Assert.AreEqual(homerAddr, results.[0].Home)
+
+[<Test>]
+let ``select Address where in empty list returns zero rows via jsonb empty-IN substitution`` () =
+    let results =
+        FindAddressByInList.Command(homerAddr, bartAddr, [||])
+        |> runOnTestData
+    Assert.AreEqual(0, results.Count)

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

@@ -16,6 +16,7 @@
     <Compile Include="AssemblyInfo.fs" />
     <Compile Include="Shared.fs" />
     <Compile Include="TestSelects.fs" />
+    <Compile Include="TestUserPrimitiveSystemObject.fs" />
     <Compile Include="TestMigrateConnectionString.fs" />
     <Compile Include="Program.fs" />
     <None Include="appsettings.json" CopyToOutputDirectory="PreserveNewest" />
@@ -39,4 +40,8 @@
     <PackageReference Include="NUnit3TestAdapter" Version="4.6.0" />
   </ItemGroup>
 
+  <ItemGroup>
+    <ProjectReference Include="..\TypeProviderUser.Postgres.UserTypes\TypeProviderUser.Postgres.UserTypes.fsproj" />
+  </ItemGroup>
+
 </Project>

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

@@ -30,3 +30,9 @@ create table ArticleComments
 
 create index IX_ArticleComments_AuthorId on ArticleComments(AuthorId);
 
+create table UserAddresses
+( Id int64 primary key autoincrement
+, UserId int64 references Users(Id)
+, Home Address
+);
+

src/TypeProviderUsers/TypeProviderUser.Postgres/rzsql.json

@@ -1,3 +1,4 @@
-{
-  "backend":  "postgres"
-}
+{
+  "backend": "postgres",
+  "usertypes": [ "TypeProviderUser.Postgres.UserTypes" ]
+}

src/TypeProviderUsers/TypeProviderUser.SQLite/TestUserPrimitiveByteArray.fs

@@ -0,0 +1,54 @@
+module TypeProviderUser.SQLite.TestUserPrimitiveByteArray
+open NUnit.Framework
+open Rezoom.SQL
+open TypeProviderUser.UserTypes
+
+type InsertAndSelectFileHashes = SQL<"""
+insert into HashedBlobs(Hash) values(@h1);
+insert into HashedBlobs(Hash) values(@h2);
+select Hash from HashedBlobs order by Id;
+""">
+
+[<Test>]
+let ``select roundtrips a FileHash user primitive over byte[]`` () =
+    let h1 = FileHash [| 0x01uy; 0x02uy; 0x03uy; 0x04uy |]
+    let h2 = FileHash [| 0xFFuy; 0xEEuy; 0xDDuy; 0xCCuy |]
+    let results = InsertAndSelectFileHashes.Command(h1, h2) |> runOnTestData
+    Assert.AreEqual(2, results.Count)
+    Assert.AreEqual(h1, results.[0].Hash)
+    Assert.AreEqual(h2, results.[1].Hash)
+
+type FindFileHashByParameter = SQL<"""
+insert into HashedBlobs(Hash) values(@seed1);
+insert into HashedBlobs(Hash) values(@seed2);
+select Hash from HashedBlobs where Hash = @needle;
+""">
+
+[<Test>]
+let ``select with FileHash parameter equality returns the matching row only`` () =
+    let target = FileHash [| 0xCAuy; 0xFEuy; 0xBAuy; 0xBEuy |]
+    let other = FileHash [| 0xDEuy; 0xADuy; 0xBEuy; 0xEFuy |]
+    let results = FindFileHashByParameter.Command(target, other, target) |> runOnTestData
+    Assert.AreEqual(1, results.Count)
+    Assert.AreEqual(target, results.[0].Hash)
+
+type FindFileHashByOptionalParameter = SQL<"""
+insert into HashedBlobs(Hash) values(@seed1);
+insert into HashedBlobs(Hash) values(@seed2);
+select Hash from HashedBlobs where Hash = @needle or @needle is null;
+""">
+
+[<Test>]
+let ``select with optional FileHash parameter filters when Some and returns all when None`` () =
+    let target = FileHash [| 0x12uy; 0x34uy; 0x56uy; 0x78uy |]
+    let other = FileHash [| 0x9Auy; 0xBCuy; 0xDEuy; 0xF0uy |]
+    // Rezoom orders Command args alphabetically by name: needle, seed1, seed2.
+    let withSome =
+        FindFileHashByOptionalParameter.Command(Some target, target, other)
+        |> runOnTestData
+    Assert.AreEqual(1, withSome.Count)
+    Assert.AreEqual(target, withSome.[0].Hash)
+    let withNone =
+        FindFileHashByOptionalParameter.Command(None, target, other)
+        |> runOnTestData
+    Assert.AreEqual(2, withNone.Count)