Python: Implement project in Transform implementations (#6128)

Author: Fokko

python/pyiceberg/expressions/__init__.py

@@ -309,6 +309,11 @@ def __eq__(self, other: Any) -> bool:
             return self.term == other.term
         return False
 
+    @property
+    @abstractmethod
+    def as_unbound(self) -> Type[UnboundPredicate[Any]]:
+        ...
+
 
 class UnboundPredicate(Generic[L], Unbound[BooleanExpression], BooleanExpression, ABC):
     term: UnboundTerm[Any]
@@ -347,6 +352,11 @@ class BoundUnaryPredicate(BoundPredicate[L], ABC):
     def __repr__(self) -> str:
         return f"{str(self.__class__.__name__)}(term={repr(self.term)})"
 
+    @property
+    @abstractmethod
+    def as_unbound(self) -> Type[UnaryPredicate]:
+        ...
+
 
 class BoundIsNull(BoundUnaryPredicate[L]):
     def __new__(cls, term: BoundTerm[L]):  # pylint: disable=W0221
@@ -357,6 +367,10 @@ def __new__(cls, term: BoundTerm[L]):  # pylint: disable=W0221
     def __invert__(self) -> BoundNotNull[L]:
         return BoundNotNull(self.term)
 
+    @property
+    def as_unbound(self) -> Type[IsNull]:
+        return IsNull
+
 
 class BoundNotNull(BoundUnaryPredicate[L]):
     def __new__(cls, term: BoundTerm[L]):  # pylint: disable=W0221
@@ -367,6 +381,10 @@ def __new__(cls, term: BoundTerm[L]):  # pylint: disable=W0221
     def __invert__(self) -> BoundIsNull[L]:
         return BoundIsNull(self.term)
 
+    @property
+    def as_unbound(self) -> Type[NotNull]:
+        return NotNull
+
 
 class IsNull(UnaryPredicate):
     def __invert__(self) -> NotNull:
@@ -396,6 +414,10 @@ def __new__(cls, term: BoundTerm[L]):  # pylint: disable=W0221
     def __invert__(self) -> BoundNotNaN[L]:
         return BoundNotNaN(self.term)
 
+    @property
+    def as_unbound(self) -> Type[IsNaN]:
+        return IsNaN
+
 
 class BoundNotNaN(BoundUnaryPredicate[L]):
     def __new__(cls, term: BoundTerm[L]):  # pylint: disable=W0221
@@ -407,6 +429,10 @@ def __new__(cls, term: BoundTerm[L]):  # pylint: disable=W0221
     def __invert__(self) -> BoundIsNaN[L]:
         return BoundIsNaN(self.term)
 
+    @property
+    def as_unbound(self) -> Type[NotNaN]:
+        return NotNaN
+
 
 class IsNaN(UnaryPredicate):
     def __invert__(self) -> NotNaN:
@@ -477,6 +503,11 @@ def __repr__(self) -> str:
     def __eq__(self, other: Any) -> bool:
         return self.term == other.term and self.literals == other.literals if isinstance(other, BoundSetPredicate) else False
 
+    @property
+    @abstractmethod
+    def as_unbound(self) -> Type[SetPredicate[L]]:
+        ...
+
 
 class BoundIn(BoundSetPredicate[L]):
     def __new__(cls, term: BoundTerm[L], literals: Set[Literal[L]]):  # pylint: disable=W0221
@@ -494,6 +525,10 @@ def __invert__(self) -> BoundNotIn[L]:
     def __eq__(self, other: Any) -> bool:
         return self.term == other.term and self.literals == other.literals if isinstance(other, BoundIn) else False
 
+    @property
+    def as_unbound(self) -> Type[In[L]]:
+        return In
+
 
 class BoundNotIn(BoundSetPredicate[L]):
     def __new__(  # pylint: disable=W0221
@@ -512,6 +547,10 @@ def __new__(  # pylint: disable=W0221
     def __invert__(self) -> BoundIn[L]:
         return BoundIn(self.term, self.literals)
 
+    @property
+    def as_unbound(self) -> Type[NotIn[L]]:
+        return NotIn
+
 
 class In(SetPredicate[L]):
     def __new__(
@@ -601,36 +640,65 @@ def __eq__(self, other):
     def __repr__(self) -> str:
         return f"{str(self.__class__.__name__)}(term={repr(self.term)}, literal={repr(self.literal)})"
 
+    @property
+    @abstractmethod
+    def as_unbound(self) -> Type[LiteralPredicate[L]]:
+        ...
+
 
 class BoundEqualTo(BoundLiteralPredicate[L]):
     def __invert__(self) -> BoundNotEqualTo[L]:
         return BoundNotEqualTo[L](self.term, self.literal)
 
+    @property
+    def as_unbound(self) -> Type[EqualTo[L]]:
+        return EqualTo
+
 
 class BoundNotEqualTo(BoundLiteralPredicate[L]):
     def __invert__(self) -> BoundEqualTo[L]:
         return BoundEqualTo[L](self.term, self.literal)
 
+    @property
+    def as_unbound(self) -> Type[NotEqualTo[L]]:
+        return NotEqualTo
+
 
 class BoundGreaterThanOrEqual(BoundLiteralPredicate[L]):
     def __invert__(self) -> BoundLessThan[L]:
         return BoundLessThan[L](self.term, self.literal)
 
+    @property
+    def as_unbound(self) -> Type[GreaterThanOrEqual[L]]:
+        return GreaterThanOrEqual[L]
+
 
 class BoundGreaterThan(BoundLiteralPredicate[L]):
     def __invert__(self) -> BoundLessThanOrEqual[L]:
         return BoundLessThanOrEqual(self.term, self.literal)
 
+    @property
+    def as_unbound(self) -> Type[GreaterThan[L]]:
+        return GreaterThan[L]
+
 
 class BoundLessThan(BoundLiteralPredicate[L]):
     def __invert__(self) -> BoundGreaterThanOrEqual[L]:
         return BoundGreaterThanOrEqual[L](self.term, self.literal)
 
+    @property
+    def as_unbound(self) -> Type[LessThan[L]]:
+        return LessThan[L]
+
 
 class BoundLessThanOrEqual(BoundLiteralPredicate[L]):
     def __invert__(self) -> BoundGreaterThan[L]:
         return BoundGreaterThan[L](self.term, self.literal)
 
+    @property
+    def as_unbound(self) -> Type[LessThanOrEqual[L]]:
+        return LessThanOrEqual[L]
+
 
 class EqualTo(LiteralPredicate[L]):
     def __invert__(self) -> NotEqualTo[L]:

python/pyiceberg/expressions/literals.py

@@ -53,6 +53,7 @@
     timestamp_to_micros,
     timestamptz_to_micros,
 )
+from pyiceberg.utils.decimal import decimal_to_unscaled, unscaled_to_decimal
 from pyiceberg.utils.singleton import Singleton
 
 
@@ -210,6 +211,12 @@ def __init__(self, value: int):
     def to(self, type_var: IcebergType) -> Literal:  # type: ignore
         raise TypeError(f"Cannot convert LongLiteral into {type_var}")
 
+    def increment(self) -> Literal[int]:
+        return LongLiteral(self.value + 1)
+
+    def decrement(self) -> Literal[int]:
+        return LongLiteral(self.value - 1)
+
     @to.register(LongType)
     def _(self, _: LongType) -> Literal[int]:
         return self
@@ -319,6 +326,12 @@ class DateLiteral(Literal[int]):
     def __init__(self, value: int):
         super().__init__(value, int)
 
+    def increment(self) -> Literal[int]:
+        return DateLiteral(self.value + 1)
+
+    def decrement(self) -> Literal[int]:
+        return DateLiteral(self.value - 1)
+
     @singledispatchmethod
     def to(self, type_var: IcebergType) -> Literal:  # type: ignore
         raise TypeError(f"Cannot convert DateLiteral into {type_var}")
@@ -345,6 +358,12 @@ class TimestampLiteral(Literal[int]):
     def __init__(self, value: int):
         super().__init__(value, int)
 
+    def increment(self) -> Literal[int]:
+        return TimestampLiteral(self.value + 1)
+
+    def decrement(self) -> Literal[int]:
+        return TimestampLiteral(self.value - 1)
+
     @singledispatchmethod
     def to(self, type_var: IcebergType) -> Literal:  # type: ignore
         raise TypeError(f"Cannot convert TimestampLiteral into {type_var}")
@@ -362,6 +381,16 @@ class DecimalLiteral(Literal[Decimal]):
     def __init__(self, value: Decimal):
         super().__init__(value, Decimal)
 
+    def increment(self) -> Literal[Decimal]:
+        original_scale = abs(self.value.as_tuple().exponent)
+        unscaled = decimal_to_unscaled(self.value)
+        return DecimalLiteral(unscaled_to_decimal(unscaled + 1, original_scale))
+
+    def decrement(self) -> Literal[Decimal]:
+        original_scale = abs(self.value.as_tuple().exponent)
+        unscaled = decimal_to_unscaled(self.value)
+        return DecimalLiteral(unscaled_to_decimal(unscaled - 1, original_scale))
+
     @singledispatchmethod
     def to(self, type_var: IcebergType) -> Literal:  # type: ignore
         raise TypeError(f"Cannot convert DecimalLiteral into {type_var}")