fix(postgresql): use Postgresql.null for NULL parameter values

The PostgreSQL driver was converting Value.Null to empty string which
caused NULL parameters to be treated as empty strings instead of SQL
NULL values.

Also adds comprehensive integration tests for Pdate (date type) in both
SQLite and PostgreSQL drivers, plus unit tests for date conversions.

driver-postgresql/repodb_postgresql.ml

···
 
   let value_to_string (v : Repodb.Driver.Value.t) : string =
     match v with
-    | Repodb.Driver.Value.Null -> ""
+    | Repodb.Driver.Value.Null -> Postgresql.null
     | Repodb.Driver.Value.Int n -> string_of_int n
     | Repodb.Driver.Value.Int64 n -> Int64.to_string n
     | Repodb.Driver.Value.Float f -> string_of_float f

driver-postgresql/test_integration.ml

···
     ("concurrent_domains", `Slow, test_pool_concurrent_domains);
   ]
 
+let test_date_insert_and_query =
+  with_db (fun conn ->
+      let _ =
+        Repodb_postgresql.exec conn "DROP TABLE IF EXISTS events" ~params:[||]
+      in
+      let _ =
+        Repodb_postgresql.exec conn
+          "CREATE TABLE events (id SERIAL PRIMARY KEY, name TEXT, event_date \
+           DATE)"
+          ~params:[||]
+      in
+      let date : Ptime.date = (2024, 6, 15) in
+      let date_value = Repodb.Types.to_value Repodb.Types.pdate date in
+      let insert =
+        Repodb_postgresql.exec conn
+          "INSERT INTO events (name, event_date) VALUES ($1, $2)"
+          ~params:[| Repodb.Driver.Value.text "Conference"; date_value |]
+      in
+      (match insert with
+      | Error e -> Alcotest.fail (Repodb_postgresql.error_message e)
+      | Ok () -> ());
+      match
+        Repodb_postgresql.query conn
+          "SELECT event_date FROM events WHERE name = $1"
+          ~params:[| Repodb.Driver.Value.text "Conference" |]
+      with
+      | Error e -> Alcotest.fail (Repodb_postgresql.error_message e)
+      | Ok [] -> Alcotest.fail "expected row"
+      | Ok (row :: _) -> (
+          let raw_value = Repodb.Driver.row_get_idx row 0 in
+          match Repodb.Types.of_value Repodb.Types.pdate raw_value with
+          | Error e -> Alcotest.fail ("failed to decode date: " ^ e)
+          | Ok (y, m, d) ->
+              Alcotest.(check int) "year" 2024 y;
+              Alcotest.(check int) "month" 6 m;
+              Alcotest.(check int) "day" 15 d))
+
+let test_date_comparison =
+  with_db (fun conn ->
+      let _ =
+        Repodb_postgresql.exec conn "DROP TABLE IF EXISTS events" ~params:[||]
+      in
+      let _ =
+        Repodb_postgresql.exec conn
+          "CREATE TABLE events (id SERIAL PRIMARY KEY, name TEXT, event_date \
+           DATE)"
+          ~params:[||]
+      in
+      let dates =
+        [
+          ((2024, 1, 10), "Event A");
+          ((2024, 6, 15), "Event B");
+          ((2024, 12, 25), "Event C");
+        ]
+      in
+      List.iter
+        (fun (date, name) ->
+          let date_value = Repodb.Types.to_value Repodb.Types.pdate date in
+          let _ =
+            Repodb_postgresql.exec conn
+              "INSERT INTO events (name, event_date) VALUES ($1, $2)"
+              ~params:[| Repodb.Driver.Value.text name; date_value |]
+          in
+          ())
+        dates;
+      match
+        Repodb_postgresql.query conn
+          "SELECT name FROM events WHERE event_date > $1 ORDER BY event_date"
+          ~params:[| Repodb.Driver.Value.text "2024-06-01" |]
+      with
+      | Error e -> Alcotest.fail (Repodb_postgresql.error_message e)
+      | Ok rows ->
+          Alcotest.(check int) "two events after June 1" 2 (List.length rows);
+          Alcotest.(check string)
+            "first is Event B" "Event B"
+            (Repodb.Driver.row_text (List.nth rows 0) 0);
+          Alcotest.(check string)
+            "second is Event C" "Event C"
+            (Repodb.Driver.row_text (List.nth rows 1) 0))
+
+let test_date_null_handling =
+  with_db (fun conn ->
+      let _ =
+        Repodb_postgresql.exec conn "DROP TABLE IF EXISTS events" ~params:[||]
+      in
+      let _ =
+        Repodb_postgresql.exec conn
+          "CREATE TABLE events (id SERIAL PRIMARY KEY, name TEXT, event_date \
+           DATE)"
+          ~params:[||]
+      in
+      let _ =
+        Repodb_postgresql.exec conn
+          "INSERT INTO events (name, event_date) VALUES ($1, $2)"
+          ~params:
+            [| Repodb.Driver.Value.text "TBD Event"; Repodb.Driver.Value.null |]
+      in
+      match
+        Repodb_postgresql.query_one conn
+          "SELECT event_date FROM events WHERE name = $1"
+          ~params:[| Repodb.Driver.Value.text "TBD Event" |]
+      with
+      | Error e -> Alcotest.fail (Repodb_postgresql.error_message e)
+      | Ok None -> Alcotest.fail "expected row"
+      | Ok (Some row) -> (
+          let raw_value = Repodb.Driver.row_get_idx row 0 in
+          match
+            Repodb.Types.of_value
+              (Repodb.Types.option Repodb.Types.pdate)
+              raw_value
+          with
+          | Error e -> Alcotest.fail ("failed to decode: " ^ e)
+          | Ok None -> ()
+          | Ok (Some _) -> Alcotest.fail "expected None for NULL date"))
+
+let test_date_roundtrip =
+  with_db (fun conn ->
+      let _ =
+        Repodb_postgresql.exec conn "DROP TABLE IF EXISTS events" ~params:[||]
+      in
+      let _ =
+        Repodb_postgresql.exec conn
+          "CREATE TABLE events (id SERIAL PRIMARY KEY, event_date DATE)"
+          ~params:[||]
+      in
+      let test_dates =
+        [ (2024, 1, 1); (2024, 12, 31); (1999, 6, 15); (2030, 2, 28) ]
+      in
+      List.iter
+        (fun date ->
+          let date_value = Repodb.Types.to_value Repodb.Types.pdate date in
+          let _ =
+            Repodb_postgresql.exec conn
+              "INSERT INTO events (event_date) VALUES ($1)"
+              ~params:[| date_value |]
+          in
+          ())
+        test_dates;
+      match
+        Repodb_postgresql.query conn "SELECT event_date FROM events ORDER BY id"
+          ~params:[||]
+      with
+      | Error e -> Alcotest.fail (Repodb_postgresql.error_message e)
+      | Ok rows ->
+          List.iter2
+            (fun expected_date row ->
+              let raw_value = Repodb.Driver.row_get_idx row 0 in
+              match Repodb.Types.of_value Repodb.Types.pdate raw_value with
+              | Error e -> Alcotest.fail ("decode failed: " ^ e)
+              | Ok actual_date ->
+                  Alcotest.(check (triple int int int))
+                    "date roundtrip" expected_date actual_date)
+            test_dates rows)
+
+let test_date_current_date =
+  with_db (fun conn ->
+      match
+        Repodb_postgresql.query_one conn "SELECT CURRENT_DATE" ~params:[||]
+      with
+      | Error e -> Alcotest.fail (Repodb_postgresql.error_message e)
+      | Ok None -> Alcotest.fail "expected row"
+      | Ok (Some row) -> (
+          let raw_value = Repodb.Driver.row_get_idx row 0 in
+          match Repodb.Types.of_value Repodb.Types.pdate raw_value with
+          | Error e -> Alcotest.fail ("failed to decode CURRENT_DATE: " ^ e)
+          | Ok (y, m, d) ->
+              Alcotest.(check bool)
+                "year reasonable" true
+                (y >= 2024 && y <= 2100);
+              Alcotest.(check bool) "month valid" true (m >= 1 && m <= 12);
+              Alcotest.(check bool) "day valid" true (d >= 1 && d <= 31)))
+
+let date_tests =
+  [
+    ("insert_and_query", `Quick, test_date_insert_and_query);
+    ("comparison", `Quick, test_date_comparison);
+    ("null_handling", `Quick, test_date_null_handling);
+    ("roundtrip", `Quick, test_date_roundtrip);
+    ("current_date", `Quick, test_date_current_date);
+  ]
+
 let () =
   Alcotest.run "repodb-postgresql"
     [
···
       ("Multi", multi_tests);
       ("Query-Repo", query_repo_tests);
       ("Pool", pool_tests);
+      ("Date", date_tests);
     ]

driver-sqlite/test_integration.ml

···
     ("concurrent_domains", `Quick, test_pool_concurrent_domains);
   ]
 
+let test_date_insert_and_query =
+  with_db (fun conn ->
+      let _ =
+        Repodb_sqlite.exec conn
+          "CREATE TABLE events (id INTEGER PRIMARY KEY, name TEXT, event_date \
+           TEXT)"
+          ~params:[||]
+      in
+      let date : Ptime.date = (2024, 6, 15) in
+      let date_value = Repodb.Types.to_value Repodb.Types.pdate date in
+      let insert =
+        Repodb_sqlite.exec conn
+          "INSERT INTO events (name, event_date) VALUES (?, ?)"
+          ~params:[| Repodb.Driver.Value.text "Conference"; date_value |]
+      in
+      (match insert with
+      | Error e -> Alcotest.fail (Repodb_sqlite.error_message e)
+      | Ok () -> ());
+      match
+        Repodb_sqlite.query conn "SELECT event_date FROM events WHERE name = ?"
+          ~params:[| Repodb.Driver.Value.text "Conference" |]
+      with
+      | Error e -> Alcotest.fail (Repodb_sqlite.error_message e)
+      | Ok [] -> Alcotest.fail "expected row"
+      | Ok (row :: _) -> (
+          let raw_value = Repodb.Driver.row_get_idx row 0 in
+          match Repodb.Types.of_value Repodb.Types.pdate raw_value with
+          | Error e -> Alcotest.fail ("failed to decode date: " ^ e)
+          | Ok (y, m, d) ->
+              Alcotest.(check int) "year" 2024 y;
+              Alcotest.(check int) "month" 6 m;
+              Alcotest.(check int) "day" 15 d))
+
+let test_date_comparison =
+  with_db (fun conn ->
+      let _ =
+        Repodb_sqlite.exec conn
+          "CREATE TABLE events (id INTEGER PRIMARY KEY, name TEXT, event_date \
+           TEXT)"
+          ~params:[||]
+      in
+      let dates =
+        [
+          ((2024, 1, 10), "Event A");
+          ((2024, 6, 15), "Event B");
+          ((2024, 12, 25), "Event C");
+        ]
+      in
+      List.iter
+        (fun (date, name) ->
+          let date_value = Repodb.Types.to_value Repodb.Types.pdate date in
+          let _ =
+            Repodb_sqlite.exec conn
+              "INSERT INTO events (name, event_date) VALUES (?, ?)"
+              ~params:[| Repodb.Driver.Value.text name; date_value |]
+          in
+          ())
+        dates;
+      match
+        Repodb_sqlite.query conn
+          "SELECT name FROM events WHERE event_date > ? ORDER BY event_date"
+          ~params:[| Repodb.Driver.Value.text "2024-06-01" |]
+      with
+      | Error e -> Alcotest.fail (Repodb_sqlite.error_message e)
+      | Ok rows ->
+          Alcotest.(check int) "two events after June 1" 2 (List.length rows);
+          Alcotest.(check string)
+            "first is Event B" "Event B"
+            (Repodb.Driver.row_text (List.nth rows 0) 0);
+          Alcotest.(check string)
+            "second is Event C" "Event C"
+            (Repodb.Driver.row_text (List.nth rows 1) 0))
+
+let test_date_null_handling =
+  with_db (fun conn ->
+      let _ =
+        Repodb_sqlite.exec conn
+          "CREATE TABLE events (id INTEGER PRIMARY KEY, name TEXT, event_date \
+           TEXT)"
+          ~params:[||]
+      in
+      let _ =
+        Repodb_sqlite.exec conn
+          "INSERT INTO events (name, event_date) VALUES (?, ?)"
+          ~params:
+            [| Repodb.Driver.Value.text "TBD Event"; Repodb.Driver.Value.null |]
+      in
+      match
+        Repodb_sqlite.query_one conn
+          "SELECT event_date FROM events WHERE name = ?"
+          ~params:[| Repodb.Driver.Value.text "TBD Event" |]
+      with
+      | Error e -> Alcotest.fail (Repodb_sqlite.error_message e)
+      | Ok None -> Alcotest.fail "expected row"
+      | Ok (Some row) -> (
+          let raw_value = Repodb.Driver.row_get_idx row 0 in
+          match
+            Repodb.Types.of_value
+              (Repodb.Types.option Repodb.Types.pdate)
+              raw_value
+          with
+          | Error e -> Alcotest.fail ("failed to decode: " ^ e)
+          | Ok None -> ()
+          | Ok (Some _) -> Alcotest.fail "expected None for NULL date"))
+
+let test_date_roundtrip =
+  with_db (fun conn ->
+      let _ =
+        Repodb_sqlite.exec conn
+          "CREATE TABLE events (id INTEGER PRIMARY KEY, event_date TEXT)"
+          ~params:[||]
+      in
+      let test_dates =
+        [ (2024, 1, 1); (2024, 12, 31); (1999, 6, 15); (2030, 2, 28) ]
+      in
+      List.iter
+        (fun date ->
+          let date_value = Repodb.Types.to_value Repodb.Types.pdate date in
+          let _ =
+            Repodb_sqlite.exec conn "INSERT INTO events (event_date) VALUES (?)"
+              ~params:[| date_value |]
+          in
+          ())
+        test_dates;
+      match
+        Repodb_sqlite.query conn "SELECT event_date FROM events ORDER BY id"
+          ~params:[||]
+      with
+      | Error e -> Alcotest.fail (Repodb_sqlite.error_message e)
+      | Ok rows ->
+          List.iter2
+            (fun expected_date row ->
+              let raw_value = Repodb.Driver.row_get_idx row 0 in
+              match Repodb.Types.of_value Repodb.Types.pdate raw_value with
+              | Error e -> Alcotest.fail ("decode failed: " ^ e)
+              | Ok actual_date ->
+                  Alcotest.(check (triple int int int))
+                    "date roundtrip" expected_date actual_date)
+            test_dates rows)
+
+let date_tests =
+  [
+    ("insert_and_query", `Quick, test_date_insert_and_query);
+    ("comparison", `Quick, test_date_comparison);
+    ("null_handling", `Quick, test_date_null_handling);
+    ("roundtrip", `Quick, test_date_roundtrip);
+  ]
+
 let () =
   Alcotest.run "repodb-sqlite"
     [
···
       ("Multi", multi_tests);
       ("Query-Repo", query_repo_tests);
       ("Pool", pool_tests);
+      ("Date", date_tests);
     ]

test/test_types.ml

···
     "ptime maps to TIMESTAMPTZ" "TIMESTAMPTZ"
     (Types.sql_type_name Types.ptime)
 
+let test_sql_type_name_pdate () =
+  Alcotest.(check string)
+    "pdate maps to DATE" "DATE"
+    (Types.sql_type_name Types.pdate)
+
+let test_sql_type_name_pdate_sqlite () =
+  Alcotest.(check string)
+    "pdate maps to TEXT for SQLite" "TEXT"
+    (Types.sql_type_name_for_sqlite Types.pdate)
+
 let test_sql_type_name_uuid () =
   Alcotest.(check string)
     "uuid maps to UUID" "UUID"
···
     "custom type name" "CUSTOM_TYPE"
     (Types.sql_type_name custom)
 
+let test_pdate_to_value () =
+  let date : Ptime.date = (2024, 1, 15) in
+  let value = Types.to_value Types.pdate date in
+  match value with
+  | Driver.Value.Text s ->
+      Alcotest.(check string) "date serializes to YYYY-MM-DD" "2024-01-15" s
+  | _ -> Alcotest.fail "expected Text value"
+
+let test_pdate_to_value_single_digit_month_day () =
+  let date : Ptime.date = (2024, 3, 5) in
+  let value = Types.to_value Types.pdate date in
+  match value with
+  | Driver.Value.Text s ->
+      Alcotest.(check string) "single digit month/day padded" "2024-03-05" s
+  | _ -> Alcotest.fail "expected Text value"
+
+let test_pdate_of_value () =
+  let value = Driver.Value.Text "2024-01-15" in
+  match Types.of_value Types.pdate value with
+  | Ok (y, m, d) ->
+      Alcotest.(check int) "year" 2024 y;
+      Alcotest.(check int) "month" 1 m;
+      Alcotest.(check int) "day" 15 d
+  | Error e -> Alcotest.fail ("failed to parse date: " ^ e)
+
+let test_pdate_of_value_unpadded () =
+  let value = Driver.Value.Text "2024-3-5" in
+  match Types.of_value Types.pdate value with
+  | Ok (y, m, d) ->
+      Alcotest.(check int) "year" 2024 y;
+      Alcotest.(check int) "month" 3 m;
+      Alcotest.(check int) "day" 5 d
+  | Error e -> Alcotest.fail ("failed to parse date: " ^ e)
+
+let test_pdate_roundtrip () =
+  let original : Ptime.date = (2023, 12, 31) in
+  let value = Types.to_value Types.pdate original in
+  match Types.of_value Types.pdate value with
+  | Ok result ->
+      Alcotest.(check (triple int int int))
+        "roundtrip preserves date" original result
+  | Error e -> Alcotest.fail ("roundtrip failed: " ^ e)
+
+let test_pdate_of_value_invalid () =
+  let value = Driver.Value.Text "not-a-date" in
+  match Types.of_value Types.pdate value with
+  | Ok _ -> Alcotest.fail "should have failed on invalid date"
+  | Error _ -> ()
+
+let test_pdate_of_value_null () =
+  let value = Driver.Value.Null in
+  match Types.of_value Types.pdate value with
+  | Ok _ -> Alcotest.fail "should have failed on NULL"
+  | Error _ -> ()
+
+let test_pdate_option_null () =
+  let value = Driver.Value.Null in
+  match Types.of_value (Types.option Types.pdate) value with
+  | Ok None -> ()
+  | Ok (Some _) -> Alcotest.fail "expected None for NULL"
+  | Error e -> Alcotest.fail ("unexpected error: " ^ e)
+
+let test_pdate_option_some () =
+  let value = Driver.Value.Text "2024-06-15" in
+  match Types.of_value (Types.option Types.pdate) value with
+  | Ok (Some (y, m, d)) ->
+      Alcotest.(check int) "year" 2024 y;
+      Alcotest.(check int) "month" 6 m;
+      Alcotest.(check int) "day" 15 d
+  | Ok None -> Alcotest.fail "expected Some date"
+  | Error e -> Alcotest.fail ("unexpected error: " ^ e)
+
 let tests =
   [
     ("sql_type_name int", `Quick, test_sql_type_name_int);
···
     ("sql_type_name bool", `Quick, test_sql_type_name_bool);
     ("sql_type_name float", `Quick, test_sql_type_name_float);
     ("sql_type_name ptime", `Quick, test_sql_type_name_ptime);
+    ("sql_type_name pdate", `Quick, test_sql_type_name_pdate);
+    ("sql_type_name pdate sqlite", `Quick, test_sql_type_name_pdate_sqlite);
     ("sql_type_name uuid", `Quick, test_sql_type_name_uuid);
     ("sql_type_name json", `Quick, test_sql_type_name_json);
     ("sql_type_name option", `Quick, test_sql_type_name_option);
···
     ("is_nullable option", `Quick, test_is_nullable_option);
     ("is_nullable non-option", `Quick, test_is_nullable_non_option);
     ("custom type", `Quick, test_custom_type);
+    ("pdate to_value", `Quick, test_pdate_to_value);
+    ("pdate to_value padded", `Quick, test_pdate_to_value_single_digit_month_day);
+    ("pdate of_value", `Quick, test_pdate_of_value);
+    ("pdate of_value unpadded", `Quick, test_pdate_of_value_unpadded);
+    ("pdate roundtrip", `Quick, test_pdate_roundtrip);
+    ("pdate of_value invalid", `Quick, test_pdate_of_value_invalid);
+    ("pdate of_value null", `Quick, test_pdate_of_value_null);
+    ("pdate option null", `Quick, test_pdate_option_null);
+    ("pdate option some", `Quick, test_pdate_option_some);
   ]