pylegend 0.11.0__py3-none-any.whl → 0.13.0__py3-none-any.whl

pylegend/core/language/shared/operations/boolean_operation_expressions.py

@@ -28,6 +28,8 @@ from pylegend.core.sql.metamodel import (
     LogicalBinaryExpression,
     LogicalBinaryType,
     NotExpression,
+    ComparisonExpression,
+    ComparisonOperator,
 )
 from pylegend.core.tds.tds_frame import FrameToSqlConfig
 from pylegend.core.tds.tds_frame import FrameToPureConfig
@@ -37,6 +39,11 @@ __all__: PyLegendSequence[str] = [
     "PyLegendBooleanOrExpression",
     "PyLegendBooleanAndExpression",
     "PyLegendBooleanNotExpression",
+    "PyLegendBooleanLessThanExpression",
+    "PyLegendBooleanLessThanEqualExpression",
+    "PyLegendBooleanGreaterThanExpression",
+    "PyLegendBooleanGreaterThanEqualExpression",
+    "PyLegendBooleanXorExpression"
 ]
 
 
@@ -98,6 +105,143 @@ class PyLegendBooleanAndExpression(PyLegendBinaryExpression, PyLegendExpressionB
         )
 
 
+class PyLegendBooleanLessThanExpression(PyLegendBinaryExpression, PyLegendExpressionBooleanReturn):
+
+    @staticmethod
+    def __to_sql_func(
+            expression1: Expression,
+            expression2: Expression,
+            frame_name_to_base_query_map: PyLegendDict[str, QuerySpecification],
+            config: FrameToSqlConfig
+    ) -> Expression:
+        return ComparisonExpression(expression1, expression2, ComparisonOperator.LESS_THAN)
+
+    @staticmethod
+    def __to_pure_func(op1_expr: str, op2_expr: str, config: FrameToPureConfig) -> str:
+        return f"({op1_expr} < {op2_expr})"
+
+    def __init__(self, operand1: PyLegendExpressionBooleanReturn, operand2: PyLegendExpressionBooleanReturn) -> None:
+        PyLegendExpressionBooleanReturn.__init__(self)
+        PyLegendBinaryExpression.__init__(
+            self,
+            operand1,
+            operand2,
+            PyLegendBooleanLessThanExpression.__to_sql_func,
+            PyLegendBooleanLessThanExpression.__to_pure_func,
+            non_nullable=True
+        )
+
+
+class PyLegendBooleanLessThanEqualExpression(PyLegendBinaryExpression, PyLegendExpressionBooleanReturn):
+
+    @staticmethod
+    def __to_sql_func(
+            expression1: Expression,
+            expression2: Expression,
+            frame_name_to_base_query_map: PyLegendDict[str, QuerySpecification],
+            config: FrameToSqlConfig
+    ) -> Expression:
+        return ComparisonExpression(expression1, expression2, ComparisonOperator.LESS_THAN_OR_EQUAL)
+
+    @staticmethod
+    def __to_pure_func(op1_expr: str, op2_expr: str, config: FrameToPureConfig) -> str:
+        return f"({op1_expr} <= {op2_expr})"
+
+    def __init__(self, operand1: PyLegendExpressionBooleanReturn, operand2: PyLegendExpressionBooleanReturn) -> None:
+        PyLegendExpressionBooleanReturn.__init__(self)
+        PyLegendBinaryExpression.__init__(
+            self,
+            operand1,
+            operand2,
+            PyLegendBooleanLessThanEqualExpression.__to_sql_func,
+            PyLegendBooleanLessThanEqualExpression.__to_pure_func,
+            non_nullable=True
+        )
+
+
+class PyLegendBooleanGreaterThanExpression(PyLegendBinaryExpression, PyLegendExpressionBooleanReturn):
+
+    @staticmethod
+    def __to_sql_func(
+            expression1: Expression,
+            expression2: Expression,
+            frame_name_to_base_query_map: PyLegendDict[str, QuerySpecification],
+            config: FrameToSqlConfig
+    ) -> Expression:
+        return ComparisonExpression(expression1, expression2, ComparisonOperator.GREATER_THAN)
+
+    @staticmethod
+    def __to_pure_func(op1_expr: str, op2_expr: str, config: FrameToPureConfig) -> str:
+        return f"({op1_expr} > {op2_expr})"
+
+    def __init__(self, operand1: PyLegendExpressionBooleanReturn, operand2: PyLegendExpressionBooleanReturn) -> None:
+        PyLegendExpressionBooleanReturn.__init__(self)
+        PyLegendBinaryExpression.__init__(
+            self,
+            operand1,
+            operand2,
+            PyLegendBooleanGreaterThanExpression.__to_sql_func,
+            PyLegendBooleanGreaterThanExpression.__to_pure_func,
+            non_nullable=True
+        )
+
+
+class PyLegendBooleanGreaterThanEqualExpression(PyLegendBinaryExpression, PyLegendExpressionBooleanReturn):
+
+    @staticmethod
+    def __to_sql_func(
+            expression1: Expression,
+            expression2: Expression,
+            frame_name_to_base_query_map: PyLegendDict[str, QuerySpecification],
+            config: FrameToSqlConfig
+    ) -> Expression:
+        return ComparisonExpression(expression1, expression2, ComparisonOperator.GREATER_THAN_OR_EQUAL)
+
+    @staticmethod
+    def __to_pure_func(op1_expr: str, op2_expr: str, config: FrameToPureConfig) -> str:
+        return f"({op1_expr} >= {op2_expr})"
+
+    def __init__(self, operand1: PyLegendExpressionBooleanReturn, operand2: PyLegendExpressionBooleanReturn) -> None:
+        PyLegendExpressionBooleanReturn.__init__(self)
+        PyLegendBinaryExpression.__init__(
+            self,
+            operand1,
+            operand2,
+            PyLegendBooleanGreaterThanEqualExpression.__to_sql_func,
+            PyLegendBooleanGreaterThanEqualExpression.__to_pure_func,
+            non_nullable=True
+        )
+
+
+class PyLegendBooleanXorExpression(PyLegendBinaryExpression, PyLegendExpressionBooleanReturn):
+
+    @staticmethod
+    def __to_sql_func(
+            expression1: Expression,
+            expression2: Expression,
+            frame_name_to_base_query_map: PyLegendDict[str, QuerySpecification],
+            config: FrameToSqlConfig
+    ) -> Expression:
+        return ComparisonExpression(expression1, expression2, ComparisonOperator.NOT_EQUAL)
+
+    @staticmethod
+    def __to_pure_func(op1_expr: str, op2_expr: str, config: FrameToPureConfig) -> str:
+        return generate_pure_functional_call("xor", [op1_expr, op2_expr])
+
+    def __init__(self, operand1: PyLegendExpressionBooleanReturn, operand2: PyLegendExpressionBooleanReturn) -> None:
+        PyLegendExpressionBooleanReturn.__init__(self)
+        PyLegendBinaryExpression.__init__(
+            self,
+            operand1,
+            operand2,
+            PyLegendBooleanXorExpression.__to_sql_func,
+            PyLegendBooleanXorExpression.__to_pure_func,
+            non_nullable=True,
+            first_operand_needs_to_be_non_nullable=True,
+            second_operand_needs_to_be_non_nullable=True
+        )
+
+
 class PyLegendBooleanNotExpression(PyLegendUnaryExpression, PyLegendExpressionBooleanReturn):
 
     @staticmethod

pylegend/core/language/shared/operations/date_operation_expressions.py

@@ -22,8 +22,10 @@ from pylegend.core.language.shared.expression import (
     PyLegendExpressionStrictDateReturn,
     PyLegendExpressionIntegerReturn,
     PyLegendExpressionBooleanReturn,
+    PyLegendExpression
 )
 from pylegend.core.language.shared.operations.binary_expression import PyLegendBinaryExpression
+from pylegend.core.language.shared.operations.nary_expression import PyLegendNaryExpression
 from pylegend.core.language.shared.operations.nullary_expression import PyLegendNullaryExpression
 from pylegend.core.language.shared.operations.unary_expression import PyLegendUnaryExpression
 from pylegend.core.language.shared.helpers import generate_pure_functional_call
@@ -61,6 +63,10 @@ from pylegend.core.sql.metamodel_extension import (
     MinuteExpression,
     SecondExpression,
     EpochExpression,
+    DateAdjustExpression,
+    DateDiffExpression,
+    DateTimeBucketExpression,
+    DateType,
 )
 
 
@@ -91,6 +97,9 @@ __all__: PyLegendSequence[str] = [
     "PyLegendDateLessThanEqualExpression",
     "PyLegendDateGreaterThanExpression",
     "PyLegendDateGreaterThanEqualExpression",
+    "PyLegendDateAdjustExpression",
+    "PyLegendDateDiffExpression",
+    "PyLegendDateTimeBucketExpression",
 ]
 
 
@@ -780,3 +789,85 @@ class PyLegendDateGreaterThanEqualExpression(PyLegendBinaryExpression, PyLegendE
 
     def is_non_nullable(self) -> bool:
         return True
+
+
+class PyLegendDateAdjustExpression(PyLegendNaryExpression, PyLegendExpressionDateReturn):
+
+    @staticmethod
+    def __to_sql_func(
+            expressions: list[Expression],
+            frame_name_to_base_query_map: PyLegendDict[str, QuerySpecification],
+            config: FrameToSqlConfig
+    ) -> Expression:
+        return DateAdjustExpression(expressions[0], expressions[1], expressions[2])  # type:ignore
+
+    @staticmethod
+    def __to_pure_func(op_expr: list[str], config: FrameToPureConfig) -> str:
+        return generate_pure_functional_call("adjust", [op_expr[0], op_expr[1], f"DurationUnit.{op_expr[2]}"])
+
+    def __init__(self, operands: list[PyLegendExpression]) -> None:
+        PyLegendExpressionDateReturn.__init__(self)
+        PyLegendNaryExpression.__init__(
+            self,
+            operands,
+            PyLegendDateAdjustExpression.__to_sql_func,
+            PyLegendDateAdjustExpression.__to_pure_func,
+            non_nullable=True,
+            operands_non_nullable_flags=[True, True, True]
+        )
+
+
+class PyLegendDateDiffExpression(PyLegendNaryExpression, PyLegendExpressionIntegerReturn):
+
+    @staticmethod
+    def __to_sql_func(
+            expressions: list[Expression],
+            frame_name_to_base_query_map: PyLegendDict[str, QuerySpecification],
+            config: FrameToSqlConfig
+    ) -> Expression:
+        return DateDiffExpression(expressions[0], expressions[1], expressions[2])  # type: ignore
+
+    @staticmethod
+    def __to_pure_func(op_expr: list[str], config: FrameToPureConfig) -> str:
+        return generate_pure_functional_call("dateDiff", [op_expr[0], op_expr[1], f"DurationUnit.{op_expr[2]}"])
+
+    def __init__(self, operands: list[PyLegendExpression]) -> None:
+        PyLegendExpressionIntegerReturn.__init__(self)
+        PyLegendNaryExpression.__init__(
+            self,
+            operands,
+            PyLegendDateDiffExpression.__to_sql_func,
+            PyLegendDateDiffExpression.__to_pure_func,
+            non_nullable=True,
+            operands_non_nullable_flags=[True, True, True]
+        )
+
+
+class PyLegendDateTimeBucketExpression(PyLegendNaryExpression, PyLegendExpressionDateReturn):
+
+    @staticmethod
+    def __to_sql_func(
+            expressions: list[Expression],
+            frame_name_to_base_query_map: PyLegendDict[str, QuerySpecification],
+            config: FrameToSqlConfig
+    ) -> Expression:
+        return DateTimeBucketExpression(
+            expressions[0],
+            expressions[1],
+            expressions[2],  # type: ignore
+            DateType.DateTime if expressions[3].value == "DATETIME" else DateType.StrictDate)  # type: ignore
+
+    @staticmethod
+    def __to_pure_func(op_expr: list[str], config: FrameToPureConfig) -> str:
+        return generate_pure_functional_call("timeBucket", [op_expr[0], op_expr[1], f"DurationUnit.{op_expr[2]}"])
+
+    def __init__(self, operands: list[PyLegendExpression]) -> None:
+        PyLegendExpressionDateReturn.__init__(self)
+        PyLegendNaryExpression.__init__(
+            self,
+            operands,
+            PyLegendDateTimeBucketExpression.__to_sql_func,
+            PyLegendDateTimeBucketExpression.__to_pure_func,
+            non_nullable=True,
+            operands_non_nullable_flags=[True, True, True]
+        )

pylegend/core/language/shared/operations/integer_operation_expressions.py

@@ -30,10 +30,15 @@ from pylegend.core.sql.metamodel import (
     ArithmeticExpression,
     NegativeExpression,
     FunctionCall,
-    QualifiedName
+    QualifiedName,
+    BitwiseBinaryExpression,
+    BitwiseBinaryOperator,
+    BitwiseShiftExpression,
+    BitwiseShiftDirection
 )
 from pylegend.core.sql.metamodel_extension import (
     AbsoluteExpression,
+    BitwiseNotExpression,
 )
 from pylegend.core.tds.tds_frame import FrameToSqlConfig
 from pylegend.core.tds.tds_frame import FrameToPureConfig
@@ -47,6 +52,12 @@ __all__: PyLegendSequence[str] = [
     "PyLegendIntegerMultiplyExpression",
     "PyLegendIntegerModuloExpression",
     "PyLegendIntegerCharExpression",
+    "PyLegendIntegerBitAndExpression",
+    "PyLegendIntegerBitOrExpression",
+    "PyLegendIntegerBitXorExpression",
+    "PyLegendIntegerBitShiftLeftExpression",
+    "PyLegendIntegerBitShiftRightExpression",
+    "PyLegendIntegerBitNotExpression"
 ]
 
 
@@ -253,3 +264,174 @@ class PyLegendIntegerCharExpression(PyLegendUnaryExpression, PyLegendExpressionS
             non_nullable=True,
             operand_needs_to_be_non_nullable=True,
         )
+
+
+class PyLegendIntegerBitAndExpression(PyLegendBinaryExpression, PyLegendExpressionIntegerReturn):
+
+    @staticmethod
+    def __to_sql_func(
+            expression1: Expression,
+            expression2: Expression,
+            frame_name_to_base_query_map: PyLegendDict[str, QuerySpecification],
+            config: FrameToSqlConfig
+    ) -> Expression:
+        return BitwiseBinaryExpression(expression1, expression2, BitwiseBinaryOperator.AND)
+
+    @staticmethod
+    def __to_pure_func(op1_expr: str, op2_expr: str, config: FrameToPureConfig) -> str:
+        return generate_pure_functional_call("bitAnd", [op1_expr, op2_expr])
+
+    def __init__(self, operand1: PyLegendExpressionIntegerReturn, operand2: PyLegendExpressionIntegerReturn) -> None:
+        PyLegendExpressionIntegerReturn.__init__(self)
+        PyLegendBinaryExpression.__init__(
+            self,
+            operand1,
+            operand2,
+            PyLegendIntegerBitAndExpression.__to_sql_func,
+            PyLegendIntegerBitAndExpression.__to_pure_func,
+            non_nullable=True,
+            first_operand_needs_to_be_non_nullable=True,
+            second_operand_needs_to_be_non_nullable=True
+        )
+
+
+class PyLegendIntegerBitOrExpression(PyLegendBinaryExpression, PyLegendExpressionIntegerReturn):
+
+    @staticmethod
+    def __to_sql_func(
+            expression1: Expression,
+            expression2: Expression,
+            frame_name_to_base_query_map: PyLegendDict[str, QuerySpecification],
+            config: FrameToSqlConfig
+    ) -> Expression:
+        return BitwiseBinaryExpression(expression1, expression2, BitwiseBinaryOperator.OR)
+
+    @staticmethod
+    def __to_pure_func(op1_expr: str, op2_expr: str, config: FrameToPureConfig) -> str:
+        return generate_pure_functional_call("bitOr", [op1_expr, op2_expr])
+
+    def __init__(self, operand1: PyLegendExpressionIntegerReturn, operand2: PyLegendExpressionIntegerReturn) -> None:
+        PyLegendExpressionIntegerReturn.__init__(self)
+        PyLegendBinaryExpression.__init__(
+            self,
+            operand1,
+            operand2,
+            PyLegendIntegerBitOrExpression.__to_sql_func,
+            PyLegendIntegerBitOrExpression.__to_pure_func,
+            non_nullable=True,
+            first_operand_needs_to_be_non_nullable=True,
+            second_operand_needs_to_be_non_nullable=True
+        )
+
+
+class PyLegendIntegerBitXorExpression(PyLegendBinaryExpression, PyLegendExpressionIntegerReturn):
+
+    @staticmethod
+    def __to_sql_func(
+            expression1: Expression,
+            expression2: Expression,
+            frame_name_to_base_query_map: PyLegendDict[str, QuerySpecification],
+            config: FrameToSqlConfig
+    ) -> Expression:
+        return BitwiseBinaryExpression(expression1, expression2, BitwiseBinaryOperator.XOR)
+
+    @staticmethod
+    def __to_pure_func(op1_expr: str, op2_expr: str, config: FrameToPureConfig) -> str:
+        return generate_pure_functional_call("bitXor", [op1_expr, op2_expr])
+
+    def __init__(self, operand1: PyLegendExpressionIntegerReturn, operand2: PyLegendExpressionIntegerReturn) -> None:
+        PyLegendExpressionIntegerReturn.__init__(self)
+        PyLegendBinaryExpression.__init__(
+            self,
+            operand1,
+            operand2,
+            PyLegendIntegerBitXorExpression.__to_sql_func,
+            PyLegendIntegerBitXorExpression.__to_pure_func,
+            non_nullable=True,
+            first_operand_needs_to_be_non_nullable=True,
+            second_operand_needs_to_be_non_nullable=True
+        )
+
+
+class PyLegendIntegerBitShiftLeftExpression(PyLegendBinaryExpression, PyLegendExpressionIntegerReturn):
+
+    @staticmethod
+    def __to_sql_func(
+            expression1: Expression,
+            expression2: Expression,
+            frame_name_to_base_query_map: PyLegendDict[str, QuerySpecification],
+            config: FrameToSqlConfig
+    ) -> Expression:
+        return BitwiseShiftExpression(expression1, expression2, BitwiseShiftDirection.LEFT)
+
+    @staticmethod
+    def __to_pure_func(op1_expr: str, op2_expr: str, config: FrameToPureConfig) -> str:
+        return generate_pure_functional_call("bitShiftLeft", [op1_expr, op2_expr])
+
+    def __init__(self, operand1: PyLegendExpressionIntegerReturn, operand2: PyLegendExpressionIntegerReturn) -> None:
+        PyLegendExpressionIntegerReturn.__init__(self)
+        PyLegendBinaryExpression.__init__(
+            self,
+            operand1,
+            operand2,
+            PyLegendIntegerBitShiftLeftExpression.__to_sql_func,
+            PyLegendIntegerBitShiftLeftExpression.__to_pure_func,
+            non_nullable=True,
+            first_operand_needs_to_be_non_nullable=True,
+            second_operand_needs_to_be_non_nullable=True
+        )
+
+
+class PyLegendIntegerBitShiftRightExpression(PyLegendBinaryExpression, PyLegendExpressionIntegerReturn):
+
+    @staticmethod
+    def __to_sql_func(
+            expression1: Expression,
+            expression2: Expression,
+            frame_name_to_base_query_map: PyLegendDict[str, QuerySpecification],
+            config: FrameToSqlConfig
+    ) -> Expression:
+        return BitwiseShiftExpression(expression1, expression2, BitwiseShiftDirection.RIGHT)
+
+    @staticmethod
+    def __to_pure_func(op1_expr: str, op2_expr: str, config: FrameToPureConfig) -> str:
+        return generate_pure_functional_call("bitShiftRight", [op1_expr, op2_expr])
+
+    def __init__(self, operand1: PyLegendExpressionIntegerReturn, operand2: PyLegendExpressionIntegerReturn) -> None:
+        PyLegendExpressionIntegerReturn.__init__(self)
+        PyLegendBinaryExpression.__init__(
+            self,
+            operand1,
+            operand2,
+            PyLegendIntegerBitShiftRightExpression.__to_sql_func,
+            PyLegendIntegerBitShiftRightExpression.__to_pure_func,
+            non_nullable=True,
+            first_operand_needs_to_be_non_nullable=True,
+            second_operand_needs_to_be_non_nullable=True
+        )
+
+
+class PyLegendIntegerBitNotExpression(PyLegendUnaryExpression, PyLegendExpressionIntegerReturn):
+
+    @staticmethod
+    def __to_sql_func(
+            expression: Expression,
+            frame_name_to_base_query_map: PyLegendDict[str, QuerySpecification],
+            config: FrameToSqlConfig
+    ) -> Expression:
+        return BitwiseNotExpression(expression)
+
+    @staticmethod
+    def __to_pure_func(op_expr: str, config: FrameToPureConfig) -> str:
+        return generate_pure_functional_call("bitNot", [op_expr])
+
+    def __init__(self, operand: PyLegendExpressionIntegerReturn) -> None:
+        PyLegendExpressionIntegerReturn.__init__(self)
+        PyLegendUnaryExpression.__init__(
+            self,
+            operand,
+            PyLegendIntegerBitNotExpression.__to_sql_func,
+            PyLegendIntegerBitNotExpression.__to_pure_func,
+            non_nullable=True,
+            operand_needs_to_be_non_nullable=True,
+        )

pylegend/core/language/shared/operations/string_operation_expressions.py

@@ -92,7 +92,8 @@ __all__: PyLegendSequence[str] = [
     "PyLegendStringSplitPartExpression",
     "PyLegendStringRepeatStringExpression",
     "PyLegendStringFullMatchExpression",
-    "PyLegendStringMatchExpression"
+    "PyLegendStringMatchExpression",
+    "PyLegendStringCoalesceExpression"
 ]
 
 
@@ -1149,6 +1150,35 @@ class PyLegendStringSplitPartExpression(PyLegendNaryExpression, PyLegendExpressi
         )
 
 
+class PyLegendStringCoalesceExpression(PyLegendNaryExpression, PyLegendExpressionStringReturn):
+
+    @staticmethod
+    def __to_sql_func(
+            expressions: list[Expression],
+            frame_name_to_base_query_map: PyLegendDict[str, QuerySpecification],
+            config: FrameToSqlConfig
+    ) -> Expression:
+        return FunctionCall(
+            name=QualifiedName(parts=["COALESCE"]),
+            distinct=False,
+            arguments=expressions,
+            filter_=None, window=None
+        )
+
+    @staticmethod
+    def __to_pure_func(op_expr: list[str], config: FrameToPureConfig) -> str:
+        return generate_pure_functional_call("meta::pure::functions::flow::coalesce", op_expr)
+
+    def __init__(self, operands: list[PyLegendExpression]) -> None:
+        PyLegendExpressionStringReturn.__init__(self)
+        PyLegendNaryExpression.__init__(
+            self,
+            operands,
+            PyLegendStringCoalesceExpression.__to_sql_func,
+            PyLegendStringCoalesceExpression.__to_pure_func
+        )
+
+
 class PyLegendCurrentUserExpression(PyLegendNullaryExpression, PyLegendExpressionStringReturn):
 
     @staticmethod

pylegend/core/language/shared/primitives/boolean.py

@@ -24,6 +24,11 @@ from pylegend.core.language.shared.operations.boolean_operation_expressions impo
     PyLegendBooleanOrExpression,
     PyLegendBooleanAndExpression,
     PyLegendBooleanNotExpression,
+    PyLegendBooleanLessThanExpression,
+    PyLegendBooleanLessThanEqualExpression,
+    PyLegendBooleanGreaterThanExpression,
+    PyLegendBooleanGreaterThanEqualExpression,
+    PyLegendBooleanXorExpression,
 )
 from pylegend.core.sql.metamodel import (
     Expression,
@@ -83,6 +88,41 @@ class PyLegendBoolean(PyLegendPrimitive):
     def __invert__(self) -> "PyLegendBoolean":
         return PyLegendBoolean(PyLegendBooleanNotExpression(self.__value))
 
+    def __lt__(self, other: PyLegendUnion[bool, "PyLegendBoolean"]) -> "PyLegendBoolean":
+        return self._create_binary_expression(other, PyLegendBooleanLessThanExpression, "less than (<)")
+
+    def __le__(self, other: PyLegendUnion[bool, "PyLegendBoolean"]) -> "PyLegendBoolean":
+        return self._create_binary_expression(other, PyLegendBooleanLessThanEqualExpression, "less than equal (<=)")
+
+    def __gt__(self, other: PyLegendUnion[bool, "PyLegendBoolean"]) -> "PyLegendBoolean":
+        return self._create_binary_expression(other, PyLegendBooleanGreaterThanExpression, "greater than (>)")
+
+    def __ge__(self, other: PyLegendUnion[bool, "PyLegendBoolean"]) -> "PyLegendBoolean":
+        return self._create_binary_expression(
+            other,
+            PyLegendBooleanGreaterThanEqualExpression,
+            "greater than equal (>=)")
+
+    def __xor__(self, other: PyLegendUnion[bool, "PyLegendBoolean"]) -> "PyLegendBoolean":
+        return self._create_binary_expression(other, PyLegendBooleanXorExpression, "xor (^)")
+
+    def __rxor__(self, other: PyLegendUnion[bool, "PyLegendBoolean"]) -> "PyLegendBoolean":
+        return self._create_binary_expression(other, PyLegendBooleanXorExpression, "xor (^)", reverse=True)
+
+    def _create_binary_expression(
+            self,
+            other: PyLegendUnion[bool, "PyLegendBoolean"],
+            expression_class: type,
+            operation_name: str,
+            reverse: bool = False
+    ) -> "PyLegendBoolean":
+        PyLegendBoolean.__validate__param_to_be_bool(other, f"Boolean {operation_name} parameter")
+        other_op = PyLegendBooleanLiteralExpression(other) if isinstance(other, bool) else other.__value
+
+        if reverse:
+            return PyLegendBoolean(expression_class(other_op, self.__value))
+        return PyLegendBoolean(expression_class(self.__value, other_op))
+
     @staticmethod
     def __validate__param_to_be_bool(param: PyLegendUnion[bool, "PyLegendBoolean"], desc: str) -> None:
         if not isinstance(param, (bool, PyLegendBoolean)):

pylegend/core/language/shared/primitives/date.py

@@ -28,6 +28,8 @@ from pylegend.core.language.shared.expression import (
 from pylegend.core.language.shared.literal_expressions import (
     PyLegendDateTimeLiteralExpression,
     PyLegendStrictDateLiteralExpression,
+    PyLegendIntegerLiteralExpression,
+    PyLegendStringLiteralExpression,
 )
 from pylegend.core.language.shared.operations.date_operation_expressions import (
     PyLegendFirstDayOfYearExpression,
@@ -54,6 +56,8 @@ from pylegend.core.language.shared.operations.date_operation_expressions import
     PyLegendDateLessThanEqualExpression,
     PyLegendDateGreaterThanExpression,
     PyLegendDateGreaterThanEqualExpression,
+    PyLegendDateAdjustExpression,
+    PyLegendDateDiffExpression,
 )
 from pylegend.core.sql.metamodel import (
     Expression,
@@ -158,6 +162,23 @@ class PyLegendDate(PyLegendPrimitive):
         from pylegend.core.language.shared.primitives.strictdate import PyLegendStrictDate
         return PyLegendStrictDate(PyLegendDatePartExpression(self.__value))
 
+    def timedelta(self, number: PyLegendUnion[int, "PyLegendInteger"], duration_unit: str) -> "PyLegendDate":
+        self.validate_param_to_be_int_or_int_expr(number, "timedelta number parameter")
+        number_op = PyLegendIntegerLiteralExpression(number) if isinstance(number, int) else number.value()
+        self.validate_duration_unit_param(duration_unit)
+        duration_unit_op = PyLegendStringLiteralExpression(duration_unit.upper())
+        return PyLegendDate(PyLegendDateAdjustExpression([self.__value, number_op, duration_unit_op]))
+
+    def diff(
+            self,
+            other: PyLegendUnion[date, datetime, "PyLegendStrictDate", "PyLegendDateTime", "PyLegendDate"],
+            duration_unit: str) -> "PyLegendInteger":
+        self.validate_param_to_be_date(other, "Diff parameter")
+        other_op = PyLegendDate.__convert_to_date_expr(other)
+        self.validate_duration_unit_param(duration_unit)
+        duration_unit_op = PyLegendStringLiteralExpression(duration_unit.upper())
+        return PyLegendInteger(PyLegendDateDiffExpression([self.__value, other_op, duration_unit_op]))
+
     def __lt__(
             self,
             other: PyLegendUnion[date, datetime, "PyLegendStrictDate", "PyLegendDateTime", "PyLegendDate"]
@@ -211,3 +232,21 @@ class PyLegendDate(PyLegendPrimitive):
             raise TypeError(desc + " should be a datetime.date/datetime.datetime or a Date expression"
                                    " (PyLegendDateTime/PyLegendStrictDate/PyLegendDate)."
                                    " Got value " + str(param) + " of type: " + str(type(param)))
+
+    @staticmethod
+    def validate_duration_unit_param(duration_unit: str) -> None:
+        if duration_unit.lower() not in ('years', 'months', 'weeks', 'days', 'hours', 'minutes', 'seconds',
+                                         'milliseconds', 'microseconds', 'nanoseconds'):
+            raise ValueError(
+                f"Unknown duration unit - {duration_unit}. Supported values are - YEARS, MONTHS, WEEKS, DAYS, HOURS,"
+                " MINUTES, SECONDS, MILLISECONDS, MICROSECONDS, NANOSECONDS"
+            )
+
+    @staticmethod
+    def validate_param_to_be_int_or_int_expr(
+            param: PyLegendUnion[int, "PyLegendInteger"],
+            desc: str
+    ) -> None:
+        if not isinstance(param, (int, PyLegendInteger)):
+            raise TypeError(desc + " should be a int or an integer expression (PyLegendInteger)."
+                                   " Got value " + str(param) + " of type: " + str(type(param)))

pylegend/core/language/shared/primitives/datetime.py

@@ -18,12 +18,16 @@ from pylegend._typing import (
     PyLegendDict,
     PyLegendUnion,
 )
+from pylegend.core.language.shared.operations.date_operation_expressions import PyLegendDateTimeBucketExpression
+from pylegend.core.language.shared.primitives.integer import PyLegendInteger
 from pylegend.core.language.shared.primitives.date import PyLegendDate
 from pylegend.core.language.shared.expression import (
     PyLegendExpressionDateTimeReturn,
 )
 from pylegend.core.language.shared.literal_expressions import (
     PyLegendDateTimeLiteralExpression,
+    PyLegendIntegerLiteralExpression,
+    PyLegendStringLiteralExpression,
 )
 from pylegend.core.sql.metamodel import (
     Expression,
@@ -57,6 +61,20 @@ class PyLegendDateTime(PyLegendDate):
     def value(self) -> PyLegendExpressionDateTimeReturn:
         return self.__value
 
+    def time_bucket(
+            self,
+            quantity: PyLegendUnion[int, "PyLegendInteger"],
+            duration_unit: str) -> "PyLegendDate":
+        self.validate_param_to_be_int_or_int_expr(quantity, "time bucket quantity parameter")
+        quantity_op = PyLegendIntegerLiteralExpression(quantity) if isinstance(quantity, int) else quantity.value()
+        self.validate_duration_unit_param(duration_unit)
+        duration_unit_op = PyLegendStringLiteralExpression(duration_unit.upper())
+        return PyLegendDate(PyLegendDateTimeBucketExpression([
+            self.__value,
+            quantity_op,
+            duration_unit_op,
+            PyLegendStringLiteralExpression("DATETIME")]))
+
     @staticmethod
     def __convert_to_datetime_expr(
             val: PyLegendUnion[datetime, "PyLegendDateTime"]