fix(expressions): accept a bare true / false as an AND / OR / NOT operand

The BooleanLiteral to AlwaysTrue/AlwaysFalse conversion was attached only to
the whole expression, so a bare boolean reached And/Or/Not as a
BooleanLiteral and failed pydantic validation:

    parse("(false) or foo = 1")  ->  EqualTo(foo, 1)
    parse("false or foo = 1")    ->  ValidationError: 1 validation error for Or

Seeding a filter with `true` and appending clauses is a common way to build
a row_filter, so `row_filter="true and status = 'x'"` raised instead of
scanning. Give `predicate` its own copy of the boolean element that folds to
AlwaysTrue/AlwaysFalse; `literal` and `literal_set` keep the raw
BooleanLiteral, so `foo = true` and `foo in (true, false)` are unchanged.

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

Author: jackylee-ch

pyiceberg/expressions/parser.py

@@ -121,6 +121,16 @@ def _(result: ParseResults) -> Literal[bool]:
         return BooleanLiteral(False)
 
 
+# As an operand a bare boolean has to fold to AlwaysTrue/AlwaysFalse. This needs its own
+# copy because `literal` and `literal_set` keep the raw BooleanLiteral for `foo = true`.
+always_boolean = boolean.copy()
+
+
+@always_boolean.add_parse_action
+def _(result: ParseResults) -> BooleanExpression:
+    return AlwaysTrue() if result[0].value else AlwaysFalse()
+
+
 @string.set_parse_action
 def _(result: ParseResults) -> Literal[str]:
     return StringLiteral(result.raw_quoted_string[1:-1].replace("''", "'"))
@@ -265,7 +275,9 @@ def _evaluate_like_statement(result: ParseResults) -> BooleanExpression:
         return EqualTo(result.column, StringLiteral(literal_like.value.replace("\\%", "%")))
 
 
-predicate = (between | comparison | in_check | null_check | nan_check | starts_check | boolean).set_results_name("predicate")
+predicate = (between | comparison | in_check | null_check | nan_check | starts_check | always_boolean).set_results_name(
+    "predicate"
+)
 
 
 def handle_not(result: ParseResults) -> Not:

tests/expressions/test_parser.py

@@ -24,6 +24,7 @@
     AlwaysFalse,
     AlwaysTrue,
     And,
+    BooleanExpression,
     EqualTo,
     GreaterThan,
     GreaterThanOrEqual,
@@ -272,3 +273,24 @@ def test_valid_between_with_numerics() -> None:
     ) == parser.parse("foo between '2025-01-01T00:00:00.000000' and '2025-01-10T12:00:00.000000'")
 
     assert parser.parse("foo between 1 and 3") == parser.parse("1 <= foo and foo <= 3")
+
+
+@pytest.mark.parametrize(
+    "expression, expected",
+    [
+        ("true and foo = 1", EqualTo(Reference("foo"), literal(1))),
+        ("foo = 1 and true", EqualTo(Reference("foo"), literal(1))),
+        ("foo = 1 or false", EqualTo(Reference("foo"), literal(1))),
+        ("foo = 1 or true", AlwaysTrue()),
+        ("foo = 1 and false", AlwaysFalse()),
+        ("not true", AlwaysFalse()),
+        ("not false", AlwaysTrue()),
+    ],
+)
+def test_boolean_as_operand(expression: str, expected: BooleanExpression) -> None:
+    assert parser.parse(expression) == expected
+
+
+def test_boolean_as_literal_is_unchanged() -> None:
+    assert parser.parse("foo = true") == EqualTo(Reference("foo"), literal(True))
+    assert parser.parse("foo in (true, false)") == In(Reference("foo"), {literal(True), literal(False)})