remove other changes

Author: kevinjqliu

pyiceberg/expressions/visitors.py

@@ -938,82 +938,6 @@ def translate_column_names(
     return visit(expr, _ColumnNameTranslator(file_schema, case_sensitive, projected_fields))
 
 
-class _ProjectedColumnsEvaluator(BooleanExpressionVisitor[BooleanExpression]):
-    """Evaluated predicates which involve projected columns missing from the file.
-
-    Args:
-      file_schema (Schema): The schema of the file.
-      projected_schema (Schema): The schema to project onto the data files.
-      case_sensitive (bool): Whether to consider case when binding a reference to a field in a schema, defaults to True.
-      projected_missing_fields(dict[str, Any]): Map of fields missing in file_schema, but present as partition values.
-
-    Raises:
-        TypeError: In the case of an UnboundPredicate.
-    """
-
-    file_schema: Schema
-    case_sensitive: bool
-
-    def __init__(
-        self, file_schema: Schema, projected_schema: Schema, case_sensitive: bool, projected_missing_fields: dict[str, Any]
-    ) -> None:
-        self.file_schema = file_schema
-        self.projected_schema = projected_schema
-        self.case_sensitive = case_sensitive
-        self.projected_missing_fields = projected_missing_fields
-
-    def visit_true(self) -> BooleanExpression:
-        return AlwaysTrue()
-
-    def visit_false(self) -> BooleanExpression:
-        return AlwaysFalse()
-
-    def visit_not(self, child_result: BooleanExpression) -> BooleanExpression:
-        return Not(child=child_result)
-
-    def visit_and(self, left_result: BooleanExpression, right_result: BooleanExpression) -> BooleanExpression:
-        return And(left=left_result, right=right_result)
-
-    def visit_or(self, left_result: BooleanExpression, right_result: BooleanExpression) -> BooleanExpression:
-        return Or(left=left_result, right=right_result)
-
-    def visit_unbound_predicate(self, predicate: UnboundPredicate[L]) -> BooleanExpression:
-        raise TypeError(f"Expected Bound Predicate, got: {predicate.term}")
-
-    def visit_bound_predicate(self, predicate: BoundPredicate[L]) -> BooleanExpression:
-        file_column_name = self.file_schema.find_column_name(predicate.term.ref().field.field_id)
-
-        if file_column_name is None and (field_name := predicate.term.ref().field.name) in self.projected_missing_fields:
-            unbound_predicate: BooleanExpression
-            if isinstance(predicate, BoundUnaryPredicate):
-                unbound_predicate = predicate.as_unbound(field_name)
-            elif isinstance(predicate, BoundLiteralPredicate):
-                unbound_predicate = predicate.as_unbound(field_name, predicate.literal)
-            elif isinstance(predicate, BoundSetPredicate):
-                unbound_predicate = predicate.as_unbound(field_name, predicate.literals)
-            else:
-                raise ValueError(f"Unsupported predicate: {predicate}")
-            field = self.projected_schema.find_field(field_name)
-            schema = Schema(field)
-            evaluator = expression_evaluator(schema, unbound_predicate, self.case_sensitive)
-            if evaluator(Record(self.projected_missing_fields[field_name])):
-                return AlwaysTrue()
-            else:
-                return AlwaysFalse()
-
-        return predicate
-
-
-def evaluate_projected_columns(
-    expr: BooleanExpression,
-    file_schema: Schema,
-    projected_schema: Schema,
-    case_sensitive: bool,
-    projected_missing_fields: dict[str, Any],
-) -> BooleanExpression:
-    return visit(expr, _ProjectedColumnsEvaluator(file_schema, projected_schema, case_sensitive, projected_missing_fields))
-
-
 class _ExpressionFieldIDs(BooleanExpressionVisitor[Set[int]]):
     """Extracts the field IDs used in the BooleanExpression."""
 

tests/expressions/test_visitors.py

@@ -68,8 +68,6 @@
     BooleanExpressionVisitor,
     BoundBooleanExpressionVisitor,
     _ManifestEvalVisitor,
-    bind,
-    evaluate_projected_columns,
     expression_evaluator,
     expression_to_plain_format,
     rewrite_not,
@@ -1625,37 +1623,3 @@ def test_expression_evaluator_null() -> None:
     assert expression_evaluator(schema, LessThan("a", 1), case_sensitive=True)(struct) is False
     assert expression_evaluator(schema, StartsWith("a", 1), case_sensitive=True)(struct) is False
     assert expression_evaluator(schema, NotStartsWith("a", 1), case_sensitive=True)(struct) is True
-
-
-@pytest.mark.parametrize(
-    "before_expression,after_expression",
-    [
-        (In("id", {1, 2, 3}), AlwaysTrue()),
-        (EqualTo("id", 3), AlwaysFalse()),
-        (
-            And(EqualTo("id", 1), EqualTo("all_same_value_or_null", "string")),
-            And(AlwaysTrue(), EqualTo("all_same_value_or_null", "string")),
-        ),
-        (
-            And(EqualTo("all_same_value_or_null", "string"), GreaterThan("id", 2)),
-            And(EqualTo("all_same_value_or_null", "string"), AlwaysFalse()),
-        ),
-        (
-            Or(
-                And(EqualTo("id", 1), EqualTo("all_same_value_or_null", "string")),
-                And(EqualTo("all_same_value_or_null", "string"), GreaterThan("id", 2)),
-            ),
-            Or(
-                And(AlwaysTrue(), EqualTo("all_same_value_or_null", "string")),
-                And(EqualTo("all_same_value_or_null", "string"), AlwaysFalse()),
-            ),
-        ),
-    ],
-)
-def test_eval_projected_fields(schema: Schema, before_expression: BooleanExpression, after_expression: BooleanExpression) -> None:
-    # exclude id from file_schema pretending that it's part of partition values
-    file_schema = Schema(*[field for field in schema.columns if field.name != "id"])
-    projected_missing_fields = {"id": 1}
-    assert evaluate_projected_columns(
-        bind(schema, before_expression, True), file_schema, schema, True, projected_missing_fields
-    ) == bind(schema, after_expression, True)