Extract ClampAndCheckConstraints helper, add constraint interaction tests

Factor the clamping + ExecConstraints sequence into a shared
ClampAndCheckConstraints helper used by both INSERT and UPDATE paths.

Add tests for CHECK constraint interaction with clamping:
- temporal clamp rescues a value that would fail strict CHECK
- temporal clamp still fails when clamped value violates CHECK
- NaN clamp to NULL succeeds on nullable column (INSERT and UPDATE)

Signed-off-by: sfc-gh-npuka <naisila.puka@snowflake.com>

Author: sfc-gh-npuka

pg_lake_table/src/fdw/pg_lake_table.c

@@ -504,6 +504,9 @@ static void merge_fdw_options(PgLakeRelationInfo * fpinfo,
 
 static void IcebergErrorOrClampSlotInPlace(TupleTableSlot *slot, TupleDesc tupleDesc,
 										   IcebergOutOfRangePolicy policy);
+static void ClampAndCheckConstraints(PgLakeModifyState * fmstate,
+									 ResultRelInfo *resultRelInfo,
+									 TupleTableSlot *slot, EState *estate);
 static void WriteInsertRecord(PgLakeModifyState * modifyState, TupleTableSlot *slot);
 static void PrepareDeletionSlot(PgLakeFileModifyState * fileModifyState,
 								uint64 fileRowNumber,
@@ -2222,24 +2225,7 @@ postgresExecForeignInsert(EState *estate,
 {
 	PgLakeModifyState *fmstate = (PgLakeModifyState *) resultRelInfo->ri_FdwState;
 
-	/*
-	 * Clamp out-of-range values (e.g. NaN → NULL) before constraint checks
-	 * so that ExecConstraints sees the post-clamp slot and can enforce NOT
-	 * NULL on values that were clamped to NULL.
-	 */
-	if (fmstate->outOfRangePolicy != ICEBERG_OOR_NONE &&
-		fmstate->needsOutOfRangeValidation)
-		IcebergErrorOrClampSlotInPlace(slot, fmstate->tupleDesc,
-									   fmstate->outOfRangePolicy);
-
-	/*
-	 * Constraint checks are skipped by PostgreSQL itself, since it assumes
-	 * them to be unenforceable as data can change underneath.
-	 */
-	Relation	resultRelationDesc = resultRelInfo->ri_RelationDesc;
-
-	if (resultRelationDesc->rd_att->constr)
-		ExecConstraints(resultRelInfo, slot, estate);
+	ClampAndCheckConstraints(fmstate, resultRelInfo, slot, estate);
 
 	WriteInsertRecord(fmstate, slot);
 
@@ -2280,22 +2266,7 @@ postgresExecForeignUpdate(EState *estate,
 		return NULL;
 	}
 
-	/*
-	 * Clamp out-of-range values (e.g. NaN → NULL) before constraint checks
-	 * so that ExecConstraints sees the post-clamp slot and can enforce NOT
-	 * NULL on values that were clamped to NULL.
-	 */
-	if (fmstate->outOfRangePolicy != ICEBERG_OOR_NONE &&
-		fmstate->needsOutOfRangeValidation)
-		IcebergErrorOrClampSlotInPlace(slot, fmstate->tupleDesc,
-									   fmstate->outOfRangePolicy);
-
-	/*
-	 * Constraint checks are skipped by PostgreSQL itself, since it assumes
-	 * them to be unenforceable as data can change underneath.
-	 */
-	if (resultRelation->rd_att->constr)
-		ExecConstraints(resultRelInfo, slot, estate);
+	ClampAndCheckConstraints(fmstate, resultRelInfo, slot, estate);
 
 	/*
 	 * Also check the tuple against the partition constraint, since PostgreSQL
@@ -2665,10 +2636,34 @@ IcebergErrorOrClampSlotInPlace(TupleTableSlot *slot, TupleDesc tupleDesc,
 
 
 /*
- * WriteInsertRecord forwards the tuple to the insert destination.
+ * ClampAndCheckConstraints normalizes the slot for Iceberg write and then
+ * runs PostgreSQL constraint checks (NOT NULL, CHECK, etc.).
+ *
+ * Clamping must happen first so that ExecConstraints sees post-clamp values,
+ * e.g. bounded numeric NaN clamped to NULL is caught by NOT NULL.
  *
- * Callers are responsible for running IcebergErrorOrClampSlotInPlace
- * before ExecConstraints so that NOT NULL checks see post-clamp values.
+ * PostgreSQL skips constraint checks on foreign tables, so we run them
+ * ourselves.
+ */
+static void
+ClampAndCheckConstraints(PgLakeModifyState * fmstate,
+						 ResultRelInfo *resultRelInfo,
+						 TupleTableSlot *slot, EState *estate)
+{
+	if (fmstate->outOfRangePolicy != ICEBERG_OOR_NONE &&
+		fmstate->needsOutOfRangeValidation)
+		IcebergErrorOrClampSlotInPlace(slot, fmstate->tupleDesc,
+									   fmstate->outOfRangePolicy);
+
+	Relation	rel = resultRelInfo->ri_RelationDesc;
+
+	if (rel->rd_att->constr)
+		ExecConstraints(resultRelInfo, slot, estate);
+}
+
+
+/*
+ * WriteInsertRecord forwards the tuple to the insert destination.
  */
 static void
 WriteInsertRecord(PgLakeModifyState * modifyState, TupleTableSlot *slot)

pg_lake_table/tests/pytests/test_iceberg_validation.py

@@ -2992,3 +2992,93 @@ def test_temporal_clamp_rescues_check_constraint(
         run_command("RESET search_path;", pg_conn)
         run_command(f"DROP SCHEMA IF EXISTS {schema} CASCADE;", pg_conn)
         pg_conn.commit()
+
+
+def test_temporal_clamp_still_fails_strict_check_constraint(
+    pg_conn, extension, s3, with_default_location
+):
+    """Temporal clamping cannot rescue a CHECK that the clamped value still violates.
+
+    infinity is clamped to 9999-12-31, but CHECK (d < '9999-12-31') uses
+    strict less-than, so the clamped value still fails.
+    """
+    schema = "test_clamp_check_strict"
+
+    run_command(f"CREATE SCHEMA {schema};", pg_conn)
+    run_command(f"SET search_path TO {schema};", pg_conn)
+    run_command("SET TIME ZONE 'UTC';", pg_conn)
+
+    try:
+        run_command(
+            "CREATE TABLE target (d date CHECK (d < '9999-12-31'::date))"
+            " USING iceberg WITH (out_of_range_values = 'clamp');",
+            pg_conn,
+        )
+        pg_conn.commit()
+
+        err = run_command(
+            "INSERT INTO target VALUES ('infinity'::date);",
+            pg_conn,
+            raise_error=False,
+        )
+        assert "check constraint" in str(err).lower()
+        pg_conn.rollback()
+    finally:
+        pg_conn.rollback()
+        run_command("RESET TIME ZONE;", pg_conn)
+        run_command("RESET search_path;", pg_conn)
+        run_command(f"DROP SCHEMA IF EXISTS {schema} CASCADE;", pg_conn)
+        pg_conn.commit()
+
+
+def test_numeric_nan_clamp_succeeds_on_nullable_column(
+    pg_conn, extension, s3, with_default_location
+):
+    """Bounded numeric NaN is clamped to NULL and stored when the column is nullable.
+
+    This is the happy-path counterpart of the NOT NULL tests: clamping
+    converts NaN to NULL, which is valid for a nullable column.  Covers
+    both INSERT and UPDATE.
+    """
+    schema = "test_clamp_nan_nullable"
+
+    run_command(f"CREATE SCHEMA {schema};", pg_conn)
+    run_command(f"SET search_path TO {schema};", pg_conn)
+
+    try:
+        run_command(
+            "CREATE TABLE target ("
+            "  id int,"
+            "  n numeric(18,6)"
+            ") USING iceberg WITH (out_of_range_values = 'clamp');",
+            pg_conn,
+        )
+        pg_conn.commit()
+
+        # INSERT: NaN is clamped to NULL and succeeds
+        run_command(
+            "INSERT INTO target VALUES (1, 'NaN'::numeric(18,6));",
+            pg_conn,
+        )
+        pg_conn.commit()
+
+        result = run_query("SELECT n FROM target WHERE id = 1;", pg_conn)
+        assert result[0][0] is None
+
+        # UPDATE: NaN is clamped to NULL and succeeds
+        run_command("INSERT INTO target VALUES (2, 99.0);", pg_conn)
+        pg_conn.commit()
+
+        run_command(
+            "UPDATE target SET n = 'NaN'::numeric(18,6) WHERE id = 2;",
+            pg_conn,
+        )
+        pg_conn.commit()
+
+        result = run_query("SELECT n FROM target WHERE id = 2;", pg_conn)
+        assert result[0][0] is None
+    finally:
+        pg_conn.rollback()
+        run_command("RESET search_path;", pg_conn)
+        run_command(f"DROP SCHEMA IF EXISTS {schema} CASCADE;", pg_conn)
+        pg_conn.commit()