Reject out-of-range literals when binding IN / NOT IN

`SetPredicate.bind` kept the result of `Literal.to(field_type)` for every
literal. For a value outside the field's range that result is the
`AboveMax`/`BelowMin` sentinel, whose value is the type's max/min, so the
bound set held a literal the user never wrote.

On an `int` column, `id in (1, 2**40)` matched rows where `id` equals
2147483647, and the `not in` form dropped them. `LiteralPredicate.bind`
already folds these to `AlwaysTrue`/`AlwaysFalse`, and Java's
`bindInOperation` filters them out of the set; do the same here. An empty
set after filtering is already folded by `BoundIn`/`BoundNotIn`.

Co-Authored-By: Claude Code <noreply@anthropic.com>

Author: jackylee-ch

pyiceberg/expressions/__init__.py

@@ -697,8 +697,13 @@ def __init__(
 
     def bind(self, schema: Schema, case_sensitive: bool = True) -> BoundSetPredicate:
         bound_term = self.term.bind(schema, case_sensitive)
-        literal_set = self.literals
-        return self.as_bound(bound_term, {lit.to(bound_term.ref().field.field_type) for lit in literal_set})  # type: ignore
+        field_type = bound_term.ref().field.field_type
+        # Literals outside the field's range can never match, so drop them rather
+        # than keep the clamped AboveMax/BelowMin sentinel in the bound set
+        bound_literals = {lit.to(field_type) for lit in self.literals}
+        return self.as_bound(  # type: ignore
+            bound_term, {lit for lit in bound_literals if not isinstance(lit, (AboveMax, BelowMin))}
+        )
 
     def __str__(self) -> str:
         """Return the string representation of the SetPredicate class."""

tests/expressions/test_evaluator.py

@@ -24,6 +24,8 @@
 
 from pyiceberg.conversions import to_bytes
 from pyiceberg.expressions import (
+    AlwaysFalse,
+    AlwaysTrue,
     And,
     BooleanExpression,
     EqualTo,
@@ -51,6 +53,7 @@
     ROWS_MUST_MATCH,
     _InclusiveMetricsEvaluator,
     _StrictMetricsEvaluator,
+    expression_evaluator,
 )
 from pyiceberg.manifest import DataFile, FileFormat
 from pyiceberg.schema import Schema
@@ -1907,3 +1910,30 @@ def test_strict_metrics_eval_bounds_after_promotion(
 
     evaluator = _StrictMetricsEvaluator(schema, op("col", lit))
     assert evaluator.eval(data_file) == expected
+
+
+def test_above_int_bounds_in() -> None:
+    schema = Schema(NestedField(1, "id", IntegerType(), required=False))
+    above_max = IntegerType.max + 1
+
+    assert In("id", [1, above_max]).bind(schema) == EqualTo("id", 1).bind(schema)
+    assert NotIn("id", [1, above_max]).bind(schema) == NotEqualTo("id", 1).bind(schema)
+    assert In("id", [above_max]).bind(schema) == AlwaysFalse()
+    assert NotIn("id", [above_max]).bind(schema) == AlwaysTrue()
+
+    # The clamped literal used to match the field's maximum
+    assert expression_evaluator(schema, In("id", [1, above_max]), True)(Record(IntegerType.max)) is False
+    assert expression_evaluator(schema, NotIn("id", [1, above_max]), True)(Record(IntegerType.max)) is True
+
+
+def test_below_int_bounds_in() -> None:
+    schema = Schema(NestedField(1, "id", IntegerType(), required=False))
+    below_min = IntegerType.min - 1
+
+    assert In("id", [1, below_min]).bind(schema) == EqualTo("id", 1).bind(schema)
+    assert NotIn("id", [1, below_min]).bind(schema) == NotEqualTo("id", 1).bind(schema)
+    assert In("id", [below_min]).bind(schema) == AlwaysFalse()
+    assert NotIn("id", [below_min]).bind(schema) == AlwaysTrue()
+
+    assert expression_evaluator(schema, In("id", [1, below_min]), True)(Record(IntegerType.min)) is False
+    assert expression_evaluator(schema, NotIn("id", [1, below_min]), True)(Record(IntegerType.min)) is True