pylegend 0.12.0__tar.gz → 0.13.0__tar.gz

{pylegend-0.12.0 → pylegend-0.13.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pylegend
-Version: 0.12.0
+Version: 0.13.0
 Summary: Python language binding for Legend data management platform
 License: Apache-2.0
 License-File: LICENSE

{pylegend-0.12.0 → pylegend-0.13.0}/pylegend/core/database/sql_to_string/db_extension.py

@@ -75,7 +75,11 @@ from pylegend.core.sql.metamodel import (
     WindowFrame,
     WindowFrameMode,
     FrameBound,
-    FrameBoundType
+    FrameBoundType,
+    BitwiseShiftExpression,
+    BitwiseShiftDirection,
+    BitwiseBinaryExpression,
+    BitwiseBinaryOperator
 )
 from pylegend.core.sql.metamodel_extension import (
     StringLengthExpression,
@@ -137,6 +141,11 @@ from pylegend.core.sql.metamodel_extension import (
     WindowExpression,
     ConstantExpression,
     StringSubStringExpression,
+    DateAdjustExpression,
+    BitwiseNotExpression,
+    DateDiffExpression,
+    DateTimeBucketExpression,
+    DateType,
 )
 
 __all__: PyLegendSequence[str] = [
@@ -460,6 +469,18 @@ def expression_processor(
         return expression.name
     elif isinstance(expression, StringSubStringExpression):
         return extension.process_string_substring_expression(expression, config)
+    elif isinstance(expression, DateAdjustExpression):
+        return extension.process_date_adjust_expression(expression, config)
+    elif isinstance(expression, DateDiffExpression):
+        return extension.process_date_diff_expression(expression, config)
+    elif isinstance(expression, DateTimeBucketExpression):
+        return extension.process_date_time_bucket_expression(expression, config)
+    elif isinstance(expression, BitwiseNotExpression):
+        return extension.process_bitwise_not_expression(expression, config)
+    elif isinstance(expression, BitwiseShiftExpression):
+        return extension.process_bitwise_shift_expression(expression, config)
+    elif isinstance(expression, BitwiseBinaryExpression):
+        return extension.process_bitwise_binary_expression(expression, config)
 
     else:
         raise ValueError("Unsupported expression type: " + str(type(expression)))  # pragma: no cover
@@ -520,6 +541,139 @@ def logical_binary_expression_processor(
     return f"({left} {op} {right})"
 
 
+def bitwise_binary_expression_processor(
+        bitwise: BitwiseBinaryExpression,
+        extension: "SqlToStringDbExtension",
+        config: SqlToStringConfig
+) -> str:
+    op_type = bitwise.operator
+    if op_type == BitwiseBinaryOperator.AND:
+        op = "&"
+    elif op_type == BitwiseBinaryOperator.OR:
+        op = "|"
+    elif op_type == BitwiseBinaryOperator.XOR:
+        op = "#"
+    else:
+        raise ValueError("Unknown bitwise binary operator type: " + str(op_type))  # pragma: no cover
+
+    left = extension.process_expression(bitwise.left, config)
+    right = extension.process_expression(bitwise.right, config)
+    return f"({left} {op} {right})"
+
+
+def date_diff_processor(
+        date_diff: DateDiffExpression,
+        extension: "SqlToStringDbExtension",
+        config: SqlToStringConfig
+) -> str:
+    unit = date_diff.duration_unit.value
+
+    end = extension.process_expression(date_diff.end_date, config)
+    start = extension.process_expression(date_diff.start_date, config)
+
+    def extract_diff(part: str) -> str:
+        return f"(EXTRACT({part} FROM {end}) - EXTRACT({part} FROM {start}))"
+
+    year_diff = extract_diff("YEAR")
+    month_diff = extract_diff("MONTH")
+    # d1 - d2 → Pure dateDiff(d1, d2) → evaluated as d2 - d1
+    # Reverse to preserve expected semantics.
+    # only for days
+    day_diff = f"CAST(CAST({start} AS DATE) - CAST({end} AS DATE) AS INTEGER)"
+    epoch_diff = f"(EXTRACT(EPOCH FROM {end}) - EXTRACT(EPOCH FROM {start}))"
+
+    if unit == "YEARS":
+        return year_diff
+
+    if unit == "MONTHS":
+        return f"({year_diff} * 12 + {month_diff})"
+
+    if unit == "DAYS":
+        return day_diff
+
+    if unit == "WEEKS":
+        return f"CAST(FLOOR({day_diff} / 7) AS INTEGER)"
+
+    if unit == "HOURS":
+        return f"CAST(FLOOR({epoch_diff} / 3600) AS INTEGER)"
+
+    if unit == "MINUTES":
+        return f"CAST(FLOOR({epoch_diff} / 60) AS INTEGER)"
+
+    if unit == "SECONDS":
+        return f"CAST({epoch_diff} AS BIGINT)"
+
+    if unit == "MILLISECONDS":
+        return f"CAST({epoch_diff} * 1000 AS BIGINT)"
+
+    raise ValueError(f"Unsupported DATE DIFF unit: {unit}")  # pragma: no cover
+
+
+def date_time_bucket_processor(
+        expression: DateTimeBucketExpression,
+        extension: "SqlToStringDbExtension",
+        config: SqlToStringConfig
+) -> str:
+    unit = expression.duration_unit.value
+    ts = extension.process_expression(expression.date, config)
+    q = extension.process_expression(expression.quantity, config)
+
+    def coerce_to_datetime(sql: str) -> str:
+        return (
+            f"(({sql}) + INTERVAL '0 second')"
+            if expression.date_type == DateType.DateTime
+            else sql
+        )
+
+    def epoch() -> str:
+        return (
+            f"EXTRACT(EPOCH FROM {ts})"
+        )
+
+    if unit == "YEARS":
+        return coerce_to_datetime(
+            f"make_date(1970,1,1) + "
+            f"(FLOOR((EXTRACT(YEAR FROM {ts}) - 1970) / {q}) * {q}) * INTERVAL '1 year'"
+        )
+
+    if unit == "MONTHS":
+        total_months_sql = f"((EXTRACT(YEAR FROM {ts}) - 1970) * 12 + (EXTRACT(MONTH FROM {ts}) - 1))"
+        return coerce_to_datetime(
+            f"make_date(1970,1,1) + "
+            f"(FLOOR({total_months_sql} / {q}) * {q}) * INTERVAL '1 month'"
+        )
+
+    if unit == "WEEKS":
+        return coerce_to_datetime(
+            f"make_date(1969,12,29) + ("
+            f"FLOOR(("
+            f"{epoch()} - EXTRACT(EPOCH FROM make_date(1969,12,29))"
+            f") / (86400 * {q} * 7))"
+            f") * ({q} * 7) * INTERVAL '1 day'"
+        )
+
+    if unit == "DAYS":
+        days_from_1970 = f"({epoch()} / 86400)"
+        return coerce_to_datetime(
+            f"make_date(1970,1,1) + "
+            f"(FLOOR({days_from_1970} / {q}) * {q}) * INTERVAL '1 day'"
+        )
+
+    unit_seconds_map = {
+        "HOURS": 3600,
+        "MINUTES": 60,
+        "SECONDS": 1
+    }
+
+    if unit in unit_seconds_map:
+        seconds_per_unit = unit_seconds_map[unit]
+        return (f"(make_date(1970,1,1) + "
+                f"(FLOOR({epoch()} / ({q} * {seconds_per_unit})) * ({q} * {seconds_per_unit})) "
+                f"* INTERVAL '1 second')")
+
+    raise ValueError(f"Unsupported TIME BUCKET unit: {unit}")  # pragma: no cover
+
+
 def not_expression_processor(
         not_expression: NotExpression,
         extension: "SqlToStringDbExtension",
@@ -1322,3 +1476,25 @@ class SqlToStringDbExtension:
 
     def process_frame_bound(self, frame_bound: FrameBound, config: SqlToStringConfig) -> str:
         return frame_bound_processor(frame_bound, self, config)
+
+    def process_date_adjust_expression(self, expr: DateAdjustExpression, config: SqlToStringConfig) -> str:
+        return (f"({self.process_expression(expr.date, config)}::DATE + "
+                f"(INTERVAL '{self.process_expression(expr.number, config)} "
+                f"{expr.duration_unit.value.upper()}'))::DATE")
+
+    def process_bitwise_not_expression(self, expr: BitwiseNotExpression, config: SqlToStringConfig) -> str:
+        return f"~({self.process_expression(expr.value, config)})"
+
+    def process_bitwise_shift_expression(self, expr: BitwiseShiftExpression, config: SqlToStringConfig) -> str:
+        return (f"({self.process_expression(expr.value, config)} "
+                f"{'>>' if expr.direction == BitwiseShiftDirection.RIGHT else '<<'} "
+                f"{self.process_expression(expr.shift, config)})")
+
+    def process_bitwise_binary_expression(self, expr: BitwiseBinaryExpression, config: SqlToStringConfig) -> str:
+        return bitwise_binary_expression_processor(expr, self, config)
+
+    def process_date_diff_expression(self, expr: DateDiffExpression, config: SqlToStringConfig) -> str:
+        return date_diff_processor(expr, self, config)
+
+    def process_date_time_bucket_expression(self, expr: DateTimeBucketExpression, config: SqlToStringConfig) -> str:
+        return date_time_bucket_processor(expr, self, config)

{pylegend-0.12.0 → pylegend-0.13.0}/pylegend/core/language/shared/expression.py

@@ -36,6 +36,7 @@ __all__: PyLegendSequence[str] = [
     "PyLegendExpressionDateReturn",
     "PyLegendExpressionDateTimeReturn",
     "PyLegendExpressionStrictDateReturn",
+    "PyLegendExpressionNullReturn"
 ]
 
 
@@ -86,3 +87,7 @@ class PyLegendExpressionDateTimeReturn(PyLegendExpressionDateReturn, metaclass=A
 
 class PyLegendExpressionStrictDateReturn(PyLegendExpressionDateReturn, metaclass=ABCMeta):
     pass
+
+
+class PyLegendExpressionNullReturn(PyLegendExpression, metaclass=ABCMeta):
+    pass

{pylegend-0.12.0 → pylegend-0.13.0}/pylegend/core/language/shared/literal_expressions.py

@@ -27,6 +27,7 @@ from pylegend.core.language.shared.expression import (
     PyLegendExpressionFloatReturn,
     PyLegendExpressionDateTimeReturn,
     PyLegendExpressionStrictDateReturn,
+    PyLegendExpressionNullReturn,
 )
 from pylegend.core.sql.metamodel import (
     Expression,
@@ -37,6 +38,7 @@ from pylegend.core.sql.metamodel import (
     QuerySpecification,
     Cast,
     ColumnType,
+    NullLiteral,
 )
 from pylegend.core.tds.tds_frame import FrameToSqlConfig
 from pylegend.core.tds.tds_frame import FrameToPureConfig
@@ -180,8 +182,25 @@ class PyLegendStrictDateLiteralExpression(PyLegendExpressionStrictDateReturn):
         return True
 
 
+class PyLegendNullLiteralExpression(PyLegendExpressionNullReturn):
+    __value: None
+
+    def __init__(self) -> None:
+        return
+
+    def to_sql_expression(
+            self,
+            frame_name_to_base_query_map: PyLegendDict[str, QuerySpecification],
+            config: FrameToSqlConfig
+    ) -> Expression:
+        return NullLiteral()
+
+    def to_pure_expression(self, config: FrameToPureConfig) -> str:
+        return "[]"
+
+
 def convert_literal_to_literal_expression(
-        literal: PyLegendUnion[int, float, bool, str, datetime, date]
+        literal: PyLegendUnion[int, float, bool, str, datetime, date, None]
 ) -> PyLegendExpression:
     if isinstance(literal, bool):
         return PyLegendBooleanLiteralExpression(literal)
@@ -195,5 +214,7 @@ def convert_literal_to_literal_expression(
         return PyLegendDateTimeLiteralExpression(literal)
     if isinstance(literal, date):
         return PyLegendStrictDateLiteralExpression(literal)
+    if isinstance(literal, type(None)):
+        return PyLegendNullLiteralExpression()
 
     raise TypeError(f"Cannot convert value - {literal} of type {type(literal)} to literal expression")

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

@@ -0,0 +1,268 @@
+# Copyright 2023 Goldman Sachs
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from pylegend._typing import (
+    PyLegendSequence,
+    PyLegendDict,
+)
+from pylegend.core.language.shared.expression import (
+    PyLegendExpressionBooleanReturn,
+)
+from pylegend.core.language.shared.helpers import generate_pure_functional_call
+from pylegend.core.language.shared.operations.binary_expression import PyLegendBinaryExpression
+from pylegend.core.language.shared.operations.unary_expression import PyLegendUnaryExpression
+from pylegend.core.sql.metamodel import (
+    Expression,
+    QuerySpecification,
+    LogicalBinaryExpression,
+    LogicalBinaryType,
+    NotExpression,
+    ComparisonExpression,
+    ComparisonOperator,
+)
+from pylegend.core.tds.tds_frame import FrameToSqlConfig
+from pylegend.core.tds.tds_frame import FrameToPureConfig
+
+
+__all__: PyLegendSequence[str] = [
+    "PyLegendBooleanOrExpression",
+    "PyLegendBooleanAndExpression",
+    "PyLegendBooleanNotExpression",
+    "PyLegendBooleanLessThanExpression",
+    "PyLegendBooleanLessThanEqualExpression",
+    "PyLegendBooleanGreaterThanExpression",
+    "PyLegendBooleanGreaterThanEqualExpression",
+    "PyLegendBooleanXorExpression"
+]
+
+
+class PyLegendBooleanOrExpression(PyLegendBinaryExpression, PyLegendExpressionBooleanReturn):
+
+    @staticmethod
+    def __to_sql_func(
+            expression1: Expression,
+            expression2: Expression,
+            frame_name_to_base_query_map: PyLegendDict[str, QuerySpecification],
+            config: FrameToSqlConfig
+    ) -> Expression:
+        return LogicalBinaryExpression(LogicalBinaryType.OR, expression1, expression2)
+
+    @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,
+            PyLegendBooleanOrExpression.__to_sql_func,
+            PyLegendBooleanOrExpression.__to_pure_func,
+            non_nullable=True,
+            first_operand_needs_to_be_non_nullable=True,
+            second_operand_needs_to_be_non_nullable=True
+        )
+
+
+class PyLegendBooleanAndExpression(PyLegendBinaryExpression, PyLegendExpressionBooleanReturn):
+
+    @staticmethod
+    def __to_sql_func(
+            expression1: Expression,
+            expression2: Expression,
+            frame_name_to_base_query_map: PyLegendDict[str, QuerySpecification],
+            config: FrameToSqlConfig
+    ) -> Expression:
+        return LogicalBinaryExpression(LogicalBinaryType.AND, expression1, expression2)
+
+    @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,
+            PyLegendBooleanAndExpression.__to_sql_func,
+            PyLegendBooleanAndExpression.__to_pure_func,
+            non_nullable=True,
+            first_operand_needs_to_be_non_nullable=True,
+            second_operand_needs_to_be_non_nullable=True
+        )
+
+
+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
+    def __to_sql_func(
+            expression: Expression,
+            frame_name_to_base_query_map: PyLegendDict[str, QuerySpecification],
+            config: FrameToSqlConfig
+    ) -> Expression:
+        return NotExpression(expression)
+
+    @staticmethod
+    def __to_pure_func(op_expr: str, config: FrameToPureConfig) -> str:
+        return generate_pure_functional_call("not", [op_expr])
+
+    def __init__(self, operand: PyLegendExpressionBooleanReturn) -> None:
+        PyLegendExpressionBooleanReturn.__init__(self)
+        PyLegendUnaryExpression.__init__(
+            self,
+            operand,
+            PyLegendBooleanNotExpression.__to_sql_func,
+            PyLegendBooleanNotExpression.__to_pure_func,
+            non_nullable=True,
+            operand_needs_to_be_non_nullable=True,
+        )

{pylegend-0.12.0 → pylegend-0.13.0}/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]
+        )