pylegend 0.12.0__py3-none-any.whl → 0.14.0__py3-none-any.whl

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"]

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

@@ -33,7 +33,13 @@ from pylegend.core.language.shared.operations.integer_operation_expressions impo
     PyLegendIntegerSubtractExpression,
     PyLegendIntegerMultiplyExpression,
     PyLegendIntegerModuloExpression,
-    PyLegendIntegerCharExpression
+    PyLegendIntegerCharExpression,
+    PyLegendIntegerBitAndExpression,
+    PyLegendIntegerBitOrExpression,
+    PyLegendIntegerBitXorExpression,
+    PyLegendIntegerBitShiftLeftExpression,
+    PyLegendIntegerBitShiftRightExpression,
+    PyLegendIntegerBitNotExpression
 )
 if TYPE_CHECKING:
     from pylegend.core.language.shared.primitives import PyLegendFloat
@@ -159,6 +165,53 @@ class PyLegendInteger(PyLegendNumber):
     def __pos__(self) -> "PyLegendInteger":
         return self
 
+    def __invert__(self) -> "PyLegendInteger":
+        return PyLegendInteger(PyLegendIntegerBitNotExpression(self.__value_copy))
+
+    def __and__(self, other: PyLegendUnion[int, "PyLegendInteger"]) -> "PyLegendInteger":
+        return self._create_binary_expression(other, PyLegendIntegerBitAndExpression, "and (&)")
+
+    def __rand__(self, other: PyLegendUnion[int, "PyLegendInteger"]) -> "PyLegendInteger":
+        return self._create_binary_expression(other, PyLegendIntegerBitAndExpression, "and (&)", reverse=True)
+
+    def __or__(self, other: PyLegendUnion[int, "PyLegendInteger"]) -> "PyLegendInteger":
+        return self._create_binary_expression(other, PyLegendIntegerBitOrExpression, "or (|)")
+
+    def __ror__(self, other: PyLegendUnion[int, "PyLegendInteger"]) -> "PyLegendInteger":
+        return self._create_binary_expression(other, PyLegendIntegerBitOrExpression, "or (|)", reverse=True)
+
+    def __xor__(self, other: PyLegendUnion[int, "PyLegendInteger"]) -> "PyLegendInteger":
+        return self._create_binary_expression(other, PyLegendIntegerBitXorExpression, "xor (^)")
+
+    def __rxor__(self, other: PyLegendUnion[int, "PyLegendInteger"]) -> "PyLegendInteger":
+        return self._create_binary_expression(other, PyLegendIntegerBitXorExpression, "xor (^)", reverse=True)
+
+    def __lshift__(self, other: PyLegendUnion[int, "PyLegendInteger"]) -> "PyLegendInteger":
+        return self._create_binary_expression(other, PyLegendIntegerBitShiftLeftExpression, "left shift (<<)")
+
+    def __rlshift__(self, other: PyLegendUnion[int, "PyLegendInteger"]) -> "PyLegendInteger":
+        return self._create_binary_expression(other, PyLegendIntegerBitShiftLeftExpression, "left shift (<<)", reverse=True)
+
+    def __rshift__(self, other: PyLegendUnion[int, "PyLegendInteger"]) -> "PyLegendInteger":
+        return self._create_binary_expression(other, PyLegendIntegerBitShiftRightExpression, "right shift (>>)")
+
+    def __rrshift__(self, other: PyLegendUnion[int, "PyLegendInteger"]) -> "PyLegendInteger":
+        return self._create_binary_expression(other, PyLegendIntegerBitShiftRightExpression, "right shift (>>)", reverse=True)
+
+    def _create_binary_expression(
+            self,
+            other: PyLegendUnion[int, "PyLegendInteger"],
+            expression_class: type,
+            operation_name: str,
+            reverse: bool = False
+    ) -> "PyLegendInteger":
+        PyLegendInteger.__validate__param_to_be_integer(other, f"Integer {operation_name} parameter")
+        other_op = PyLegendInteger.__convert_to_integer_expr(other)
+
+        if reverse:
+            return PyLegendInteger(expression_class(other_op, self.__value_copy))
+        return PyLegendInteger(expression_class(self.__value_copy, other_op))
+
     @staticmethod
     def __convert_to_integer_expr(
             val: PyLegendUnion[int, "PyLegendInteger"]

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

@@ -24,13 +24,16 @@ from pylegend.core.language.shared.expression import (
 )
 from pylegend.core.language.shared.literal_expressions import (
     PyLegendStrictDateLiteralExpression,
+    PyLegendIntegerLiteralExpression,
+    PyLegendStringLiteralExpression
 )
 from pylegend.core.sql.metamodel import (
     Expression,
     QuerySpecification
 )
 from pylegend.core.tds.tds_frame import FrameToSqlConfig
-
+from pylegend.core.language.shared.operations.date_operation_expressions import PyLegendDateTimeBucketExpression
+from pylegend.core.language.shared.primitives.integer import PyLegendInteger
 
 __all__: PyLegendSequence[str] = [
     "PyLegendStrictDate"
@@ -57,6 +60,20 @@ class PyLegendStrictDate(PyLegendDate):
     def value(self) -> PyLegendExpressionStrictDateReturn:
         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("STRICTDATE")]))
+
     @staticmethod
     def __convert_to_strictdate_expr(
             val: PyLegendUnion[date, "PyLegendStrictDate"]
@@ -73,3 +90,10 @@ class PyLegendStrictDate(PyLegendDate):
         if not isinstance(param, (date, PyLegendStrictDate)):
             raise TypeError(desc + " should be a datetime.date or a StrictDate expression (PyLegendStrictDate)."
                                    " 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'):
+            raise ValueError(
+                f"Unknown duration unit - {duration_unit}. Supported values are - YEARS, MONTHS, WEEKS, DAYS"
+            )

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

@@ -18,7 +18,10 @@ from pylegend._typing import (
     PyLegendUnion,
     PyLegendOptional
 )
-from pylegend.core.language.shared.literal_expressions import PyLegendIntegerLiteralExpression
+from pylegend.core.language.shared.literal_expressions import (
+    PyLegendIntegerLiteralExpression,
+    convert_literal_to_literal_expression
+)
 from pylegend.core.language.shared.primitives.primitive import PyLegendPrimitive
 from pylegend.core.language.shared.primitives.integer import PyLegendInteger
 from pylegend.core.language.shared.primitives.float import PyLegendFloat
@@ -67,7 +70,8 @@ from pylegend.core.language.shared.operations.string_operation_expressions impor
     PyLegendStringSplitPartExpression,
     PyLegendStringFullMatchExpression,
     PyLegendStringRepeatStringExpression,
-    PyLegendStringMatchExpression
+    PyLegendStringMatchExpression,
+    PyLegendStringCoalesceExpression
 )
 
 __all__: PyLegendSequence[str] = [
@@ -242,6 +246,16 @@ class PyLegendString(PyLegendPrimitive):
         times_op = PyLegendIntegerLiteralExpression(times) if isinstance(times, int) else times.value()
         return PyLegendString(PyLegendStringRepeatStringExpression(self.__value, times_op))
 
+    def coalesce(self, *other: PyLegendOptional[PyLegendUnion[str, "PyLegendString"]]) -> "PyLegendString":
+        other_op = []
+        for op in other:
+            if op is not None:
+                PyLegendString.__validate_param_to_be_str_or_str_expr(op, "coalesce parameter")
+            other_op.append(
+                convert_literal_to_literal_expression(op) if not isinstance(op, PyLegendString) else op.__value)
+
+        return PyLegendString(PyLegendStringCoalesceExpression([self.__value, *other_op]))
+
     def __add__(self, other: PyLegendUnion[str, "PyLegendString"]) -> "PyLegendString":
         PyLegendString.__validate_param_to_be_str_or_str_expr(other, "String plus (+) parameter")
         other_op = PyLegendStringLiteralExpression(other) if isinstance(other, str) else other.__value

pylegend/core/sql/metamodel.py

@@ -87,7 +87,11 @@ __all__: PyLegendSequence[str] = [
     'InPredicate',
     'Window',
     'WindowFrame',
-    'FrameBound'
+    'FrameBound',
+    'BitwiseShiftDirection',
+    'BitwiseBinaryOperator',
+    'BitwiseBinaryExpression',
+    'BitwiseShiftExpression',
 ]
 
 
@@ -179,6 +183,17 @@ class ExtractField(Enum):
     EPOCH = 17
 
 
+class BitwiseShiftDirection(Enum):
+    LEFT = 1
+    RIGHT = 2
+
+
+class BitwiseBinaryOperator(Enum):
+    AND = 1
+    OR = 2
+    XOR = 3
+
+
 class Node:
     _type: str
 
@@ -930,3 +945,37 @@ class FrameBound(Node):
         self.type_ = type_
         self.value = value
         self.duration_unit = duration_unit
+
+
+class BitwiseBinaryExpression(Expression):
+    left: "Expression"
+    right: "Expression"
+    operator: "BitwiseBinaryOperator"
+
+    def __init__(
+            self,
+            left: "Expression",
+            right: "Expression",
+            operator: "BitwiseBinaryOperator"
+    ) -> None:
+        super().__init__(_type="bitwiseBinaryExpression")
+        self.left = left
+        self.right = right
+        self.operator = operator
+
+
+class BitwiseShiftExpression(Expression):
+    value: "Expression"
+    shift: "Expression"
+    direction: "BitwiseShiftDirection"
+
+    def __init__(
+            self,
+            value: "Expression",
+            shift: "Expression",
+            direction: "BitwiseShiftDirection"
+    ) -> None:
+        super().__init__(_type="bitwiseShiftExpression")
+        self.value = value
+        self.shift = shift
+        self.direction = direction