Support nullable members in range predicates

GreaterThan, GreaterThanOrEqual, SmallerThan and SmallerThanOrEqual only
exposed int64_t and double member-pointer overloads, so they could not be
used with nullable numeric members at all, even though value predicates on
nullable members are documented to compare against the contained value.
Add fcpp::optional_t<int64_t> and fcpp::optional_t<double> overloads that
route through the existing QueryPredicate constructor, which already
unwraps the optional and fails fast on an empty one.

Also fix the README nullness-predicate example, which took the address of
a temporary (the pattern Clang and MSVC reject), and mention the range
predicates in the nullable value-predicate documentation.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01NUt3c1wdseRtRSSXfg3MCK

Author: claude

README.md

@@ -169,14 +169,18 @@ state. A stored empty string and a stored zero are distinct from `NULL` and hydr
 Two predicates cover nullness tests, since SQL's `= NULL` never matches:
 
 ```c++
-const auto unpaid = db->Fetch<Employee>(&IsNull(&Employee::salary));
-const auto paid = db->Fetch<Employee>(&IsNotNull(&Employee::salary));
+const auto is_unpaid = IsNull(&Employee::salary);
+const auto unpaid = db->Fetch<Employee>(&is_unpaid);
+const auto is_paid = IsNotNull(&Employee::salary);
+const auto paid = db->Fetch<Employee>(&is_paid);
 ```
 
-Value predicates (`Equal`, `Like`, ...) on a nullable field compare against the contained
-value and take an optional as the comparison argument, e.g.
-`Equal(&Employee::salary, fcpp::optional_t<double>(50000.0))`. Passing an *empty* optional to a
-value predicate throws `std::invalid_argument` — use `IsNull`/`IsNotNull` for that instead.
+Value predicates (`Equal`, `Like`, `GreaterThan`, `SmallerThanOrEqual`, ...) on a nullable
+field compare against the contained value and take an optional as the comparison argument,
+e.g. `Equal(&Employee::salary, fcpp::optional_t<double>(50000.0))` or
+`GreaterThan(&Employee::salary, fcpp::optional_t<double>(40000.0))`. Passing an *empty*
+optional to a value predicate throws `std::invalid_argument` — use `IsNull`/`IsNotNull` for
+that instead.
 
 Non-nullable columns are now created with an explicit `NOT NULL` constraint, so the schema
 enforces what the object model assumes. Because tables are created with

include/query_predicates.h

@@ -265,6 +265,14 @@ class REFLECTION_EXPORT GreaterThan final : public QueryPredicate {
 
     template <typename T>
     explicit GreaterThan(double T::* fn, double value) : QueryPredicate(fn, value, ">") {}
+
+    template <typename T>
+    explicit GreaterThan(fcpp::optional_t<int64_t> T::* fn, fcpp::optional_t<int64_t> value)
+        : QueryPredicate(fn, value, ">") {}
+
+    template <typename T>
+    explicit GreaterThan(fcpp::optional_t<double> T::* fn, fcpp::optional_t<double> value)
+        : QueryPredicate(fn, value, ">") {}
 };
 
 /// A wrapper for a comparison predicate, for which the value of the
@@ -279,6 +287,14 @@ class REFLECTION_EXPORT GreaterThanOrEqual final : public QueryPredicate {
 
     template <typename T>
     explicit GreaterThanOrEqual(double T::* fn, double value) : QueryPredicate(fn, value, ">=") {}
+
+    template <typename T>
+    explicit GreaterThanOrEqual(fcpp::optional_t<int64_t> T::* fn, fcpp::optional_t<int64_t> value)
+        : QueryPredicate(fn, value, ">=") {}
+
+    template <typename T>
+    explicit GreaterThanOrEqual(fcpp::optional_t<double> T::* fn, fcpp::optional_t<double> value)
+        : QueryPredicate(fn, value, ">=") {}
 };
 
 /// A wrapper for a comparison predicate, for which the value of the
@@ -293,6 +309,14 @@ class REFLECTION_EXPORT SmallerThan final : public QueryPredicate {
 
     template <typename T>
     explicit SmallerThan(double T::* fn, double value) : QueryPredicate(fn, value, "<") {}
+
+    template <typename T>
+    explicit SmallerThan(fcpp::optional_t<int64_t> T::* fn, fcpp::optional_t<int64_t> value)
+        : QueryPredicate(fn, value, "<") {}
+
+    template <typename T>
+    explicit SmallerThan(fcpp::optional_t<double> T::* fn, fcpp::optional_t<double> value)
+        : QueryPredicate(fn, value, "<") {}
 };
 
 /// A wrapper for a comparison predicate, for which the value of the
@@ -307,6 +331,14 @@ class REFLECTION_EXPORT SmallerThanOrEqual final : public QueryPredicate {
 
     template <typename T>
     explicit SmallerThanOrEqual(double T::* fn, double value) : QueryPredicate(fn, value, "<=") {}
+
+    template <typename T>
+    explicit SmallerThanOrEqual(fcpp::optional_t<int64_t> T::* fn, fcpp::optional_t<int64_t> value)
+        : QueryPredicate(fn, value, "<=") {}
+
+    template <typename T>
+    explicit SmallerThanOrEqual(fcpp::optional_t<double> T::* fn, fcpp::optional_t<double> value)
+        : QueryPredicate(fn, value, "<=") {}
 };
 
 /// A wrapper of a compound predicate, which combines two other predicates,

tests/nullable_test.cc

@@ -217,6 +217,51 @@ TEST_F(NullableTest, ValuePredicatesOperateOnTheContainedValue) {
     EXPECT_THROW(Equal(&NullableRecord::maybe_int, fcpp::optional_t<int64_t>()), std::invalid_argument);
 }
 
+TEST_F(NullableTest, RangePredicatesOperateOnTheContainedValue) {
+    const auto db = Database::Instance();
+
+    NullableRecord low;
+    low.label = L"low";
+    low.maybe_int = static_cast<int64_t>(3);
+    low.maybe_real = 1.5;
+    low.id = 1;
+    db->Save(low);
+
+    NullableRecord high;
+    high.label = L"high";
+    high.maybe_int = static_cast<int64_t>(9);
+    high.maybe_real = 9.5;
+    high.id = 2;
+    db->Save(high);
+
+    // A row with NULL columns never matches a range comparison in SQL
+    NullableRecord unset;
+    unset.label = L"unset";
+    unset.id = 3;
+    db->Save(unset);
+
+    const auto greater = GreaterThan(&NullableRecord::maybe_int, fcpp::optional_t<int64_t>(static_cast<int64_t>(5)));
+    const auto greater_rows = db->Fetch<NullableRecord>(&greater);
+    ASSERT_EQ(1, greater_rows.size());
+    EXPECT_EQ(2, greater_rows[0].id);
+
+    const auto greater_equal =
+        GreaterThanOrEqual(&NullableRecord::maybe_int, fcpp::optional_t<int64_t>(static_cast<int64_t>(3)));
+    EXPECT_EQ(2, db->Fetch<NullableRecord>(&greater_equal).size());
+
+    const auto smaller = SmallerThan(&NullableRecord::maybe_real, fcpp::optional_t<double>(9.5));
+    const auto smaller_rows = db->Fetch<NullableRecord>(&smaller);
+    ASSERT_EQ(1, smaller_rows.size());
+    EXPECT_EQ(1, smaller_rows[0].id);
+
+    const auto smaller_equal = SmallerThanOrEqual(&NullableRecord::maybe_real, fcpp::optional_t<double>(9.5));
+    EXPECT_EQ(2, db->Fetch<NullableRecord>(&smaller_equal).size());
+
+    // Like every value predicate, an empty optional is a misuse and fails fast
+    EXPECT_THROW(GreaterThan(&NullableRecord::maybe_int, fcpp::optional_t<int64_t>()), std::invalid_argument);
+    EXPECT_THROW(SmallerThan(&NullableRecord::maybe_real, fcpp::optional_t<double>()), std::invalid_argument);
+}
+
 TEST_F(NullableTest, NonNullableRecordsRoundTripUnchanged) {
     const auto db = Database::Instance();