pylegend 0.3.0__py3-none-any.whl → 0.5.0__py3-none-any.whl

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

@@ -0,0 +1,155 @@
+# 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 (
+    PyLegendExpression,
+    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,
+    ComparisonExpression,
+    ComparisonOperator,
+    IsNullPredicate,
+    IsNotNullPredicate,
+)
+from pylegend.core.tds.tds_frame import FrameToSqlConfig
+from pylegend.core.tds.tds_frame import FrameToPureConfig
+
+
+__all__: PyLegendSequence[str] = [
+    "PyLegendPrimitiveEqualsExpression",
+    "PyLegendPrimitiveNotEqualsExpression",
+    "PyLegendIsEmptyExpression",
+    "PyLegendIsNotEmptyExpression",
+]
+
+
+class PyLegendPrimitiveEqualsExpression(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.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: PyLegendExpression, operand2: PyLegendExpression) -> None:
+        PyLegendExpressionBooleanReturn.__init__(self)
+        PyLegendBinaryExpression.__init__(
+            self,
+            operand1,
+            operand2,
+            PyLegendPrimitiveEqualsExpression.__to_sql_func,
+            PyLegendPrimitiveEqualsExpression.__to_pure_func
+        )
+
+    def is_non_nullable(self) -> bool:
+        return True
+
+
+class PyLegendPrimitiveNotEqualsExpression(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 f"({op1_expr} != {op2_expr})"
+
+    def __init__(self, operand1: PyLegendExpression, operand2: PyLegendExpression) -> None:
+        PyLegendExpressionBooleanReturn.__init__(self)
+        PyLegendBinaryExpression.__init__(
+            self,
+            operand1,
+            operand2,
+            PyLegendPrimitiveNotEqualsExpression.__to_sql_func,
+            PyLegendPrimitiveNotEqualsExpression.__to_pure_func
+        )
+
+    def is_non_nullable(self) -> bool:
+        return True
+
+
+class PyLegendIsEmptyExpression(PyLegendUnaryExpression, PyLegendExpressionBooleanReturn):
+
+    @staticmethod
+    def __to_sql_func(
+            expression: Expression,
+            frame_name_to_base_query_map: PyLegendDict[str, QuerySpecification],
+            config: FrameToSqlConfig
+    ) -> Expression:
+        return IsNullPredicate(expression)
+
+    @staticmethod
+    def __to_pure_func(op_expr: str, config: FrameToPureConfig) -> str:
+        return generate_pure_functional_call("isEmpty", [op_expr])
+
+    def __init__(self, operand: PyLegendExpression) -> None:
+        PyLegendExpressionBooleanReturn.__init__(self)
+        PyLegendUnaryExpression.__init__(
+            self,
+            operand,
+            PyLegendIsEmptyExpression.__to_sql_func,
+            PyLegendIsEmptyExpression.__to_pure_func
+        )
+
+    def is_non_nullable(self) -> bool:
+        return True
+
+
+class PyLegendIsNotEmptyExpression(PyLegendUnaryExpression, PyLegendExpressionBooleanReturn):
+
+    @staticmethod
+    def __to_sql_func(
+            expression: Expression,
+            frame_name_to_base_query_map: PyLegendDict[str, QuerySpecification],
+            config: FrameToSqlConfig
+    ) -> Expression:
+        return IsNotNullPredicate(expression)
+
+    @staticmethod
+    def __to_pure_func(op_expr: str, config: FrameToPureConfig) -> str:
+        return generate_pure_functional_call("isNotEmpty", [op_expr])
+
+    def __init__(self, operand: PyLegendExpression) -> None:
+        PyLegendExpressionBooleanReturn.__init__(self)
+        PyLegendUnaryExpression.__init__(
+            self,
+            operand,
+            PyLegendIsNotEmptyExpression.__to_sql_func,
+            PyLegendIsNotEmptyExpression.__to_pure_func
+        )
+
+    def is_non_nullable(self) -> bool:
+        return True

pylegend/core/language/{operations → shared/operations}/string_operation_expressions.py

@@ -16,14 +16,16 @@ from pylegend._typing import (
     PyLegendSequence,
     PyLegendDict,
 )
-from pylegend.core.language.expression import (
+from pylegend.core.language.shared.expression import (
     PyLegendExpressionStringReturn,
     PyLegendExpressionIntegerReturn,
     PyLegendExpressionFloatReturn,
     PyLegendExpressionBooleanReturn,
 )
-from pylegend.core.language.operations.binary_expression import PyLegendBinaryExpression
-from pylegend.core.language.operations.unary_expression import PyLegendUnaryExpression
+from pylegend.core.language.shared.operations.binary_expression import PyLegendBinaryExpression
+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
 from pylegend.core.sql.metamodel import (
     Expression,
     QuerySpecification,
@@ -31,6 +33,7 @@ from pylegend.core.sql.metamodel import (
     Cast,
     ComparisonOperator,
     ComparisonExpression,
+    StringLiteral,
 )
 from pylegend.core.sql.metamodel_extension import (
     StringLengthExpression,
@@ -41,13 +44,17 @@ from pylegend.core.sql.metamodel_extension import (
     StringTrimExpression,
     StringPosExpression,
     StringConcatExpression,
+    ConstantExpression,
 )
 from pylegend.core.tds.tds_frame import FrameToSqlConfig
+from pylegend.core.tds.tds_frame import FrameToPureConfig
 
 
 __all__: PyLegendSequence[str] = [
     "PyLegendStringLengthExpression",
-    "PyLegendStringLikeExpression",
+    "PyLegendStringStartsWithExpression",
+    "PyLegendStringEndsWithExpression",
+    "PyLegendStringContainsExpression",
     "PyLegendStringUpperExpression",
     "PyLegendStringLowerExpression",
     "PyLegendStringLTrimExpression",
@@ -61,6 +68,7 @@ __all__: PyLegendSequence[str] = [
     "PyLegendStringLessThanEqualExpression",
     "PyLegendStringGreaterThanExpression",
     "PyLegendStringGreaterThanEqualExpression",
+    "PyLegendCurrentUserExpression",
 ]
 
 
@@ -74,16 +82,49 @@ class PyLegendStringLengthExpression(PyLegendUnaryExpression, PyLegendExpression
     ) -> Expression:
         return StringLengthExpression(expression)
 
+    @staticmethod
+    def __to_pure_func(op_expr: str, config: FrameToPureConfig) -> str:
+        return generate_pure_functional_call("length", [op_expr], auto_map=True)
+
     def __init__(self, operand: PyLegendExpressionStringReturn) -> None:
         PyLegendExpressionIntegerReturn.__init__(self)
         PyLegendUnaryExpression.__init__(
             self,
             operand,
-            PyLegendStringLengthExpression.__to_sql_func
+            PyLegendStringLengthExpression.__to_sql_func,
+            PyLegendStringLengthExpression.__to_pure_func
+        )
+
+
+class PyLegendStringStartsWithExpression(PyLegendBinaryExpression, PyLegendExpressionBooleanReturn):
+
+    @staticmethod
+    def __to_sql_func(
+            expression1: Expression,
+            expression2: Expression,
+            frame_name_to_base_query_map: PyLegendDict[str, QuerySpecification],
+            config: FrameToSqlConfig
+    ) -> Expression:
+        assert isinstance(expression2, StringLiteral)
+        escaped = _escape_like_param(expression2.value)
+        return StringLikeExpression(expression1, StringLiteral(value=escaped + "%", quoted=False))
+
+    @staticmethod
+    def __to_pure_func(op1_expr: str, op2_expr: str, config: FrameToPureConfig) -> str:
+        return generate_pure_functional_call("startsWith", [op1_expr, op2_expr])
+
+    def __init__(self, operand1: PyLegendExpressionStringReturn, operand2: PyLegendExpressionStringReturn) -> None:
+        PyLegendExpressionBooleanReturn.__init__(self)
+        PyLegendBinaryExpression.__init__(
+            self,
+            operand1,
+            operand2,
+            PyLegendStringStartsWithExpression.__to_sql_func,
+            PyLegendStringStartsWithExpression.__to_pure_func
         )
 
 
-class PyLegendStringLikeExpression(PyLegendBinaryExpression, PyLegendExpressionBooleanReturn):
+class PyLegendStringEndsWithExpression(PyLegendBinaryExpression, PyLegendExpressionBooleanReturn):
 
     @staticmethod
     def __to_sql_func(
@@ -92,7 +133,41 @@ class PyLegendStringLikeExpression(PyLegendBinaryExpression, PyLegendExpressionB
             frame_name_to_base_query_map: PyLegendDict[str, QuerySpecification],
             config: FrameToSqlConfig
     ) -> Expression:
-        return StringLikeExpression(expression1, expression2)
+        assert isinstance(expression2, StringLiteral)
+        escaped = _escape_like_param(expression2.value)
+        return StringLikeExpression(expression1, StringLiteral(value="%" + escaped, quoted=False))
+
+    @staticmethod
+    def __to_pure_func(op1_expr: str, op2_expr: str, config: FrameToPureConfig) -> str:
+        return generate_pure_functional_call("endsWith", [op1_expr, op2_expr])
+
+    def __init__(self, operand1: PyLegendExpressionStringReturn, operand2: PyLegendExpressionStringReturn) -> None:
+        PyLegendExpressionBooleanReturn.__init__(self)
+        PyLegendBinaryExpression.__init__(
+            self,
+            operand1,
+            operand2,
+            PyLegendStringEndsWithExpression.__to_sql_func,
+            PyLegendStringEndsWithExpression.__to_pure_func
+        )
+
+
+class PyLegendStringContainsExpression(PyLegendBinaryExpression, PyLegendExpressionBooleanReturn):
+
+    @staticmethod
+    def __to_sql_func(
+            expression1: Expression,
+            expression2: Expression,
+            frame_name_to_base_query_map: PyLegendDict[str, QuerySpecification],
+            config: FrameToSqlConfig
+    ) -> Expression:
+        assert isinstance(expression2, StringLiteral)
+        escaped = _escape_like_param(expression2.value)
+        return StringLikeExpression(expression1, StringLiteral(value="%" + escaped + "%", quoted=False))
+
+    @staticmethod
+    def __to_pure_func(op1_expr: str, op2_expr: str, config: FrameToPureConfig) -> str:
+        return generate_pure_functional_call("contains", [op1_expr, op2_expr])
 
     def __init__(self, operand1: PyLegendExpressionStringReturn, operand2: PyLegendExpressionStringReturn) -> None:
         PyLegendExpressionBooleanReturn.__init__(self)
@@ -100,7 +175,8 @@ class PyLegendStringLikeExpression(PyLegendBinaryExpression, PyLegendExpressionB
             self,
             operand1,
             operand2,
-            PyLegendStringLikeExpression.__to_sql_func
+            PyLegendStringContainsExpression.__to_sql_func,
+            PyLegendStringContainsExpression.__to_pure_func
         )
 
 
@@ -114,12 +190,17 @@ class PyLegendStringUpperExpression(PyLegendUnaryExpression, PyLegendExpressionS
     ) -> Expression:
         return StringUpperExpression(expression)
 
+    @staticmethod
+    def __to_pure_func(op_expr: str, config: FrameToPureConfig) -> str:
+        return generate_pure_functional_call("toUpper", [op_expr], auto_map=True)
+
     def __init__(self, operand: PyLegendExpressionStringReturn) -> None:
         PyLegendExpressionStringReturn.__init__(self)
         PyLegendUnaryExpression.__init__(
             self,
             operand,
-            PyLegendStringUpperExpression.__to_sql_func
+            PyLegendStringUpperExpression.__to_sql_func,
+            PyLegendStringUpperExpression.__to_pure_func
         )
 
 
@@ -133,12 +214,17 @@ class PyLegendStringLowerExpression(PyLegendUnaryExpression, PyLegendExpressionS
     ) -> Expression:
         return StringLowerExpression(expression)
 
+    @staticmethod
+    def __to_pure_func(op_expr: str, config: FrameToPureConfig) -> str:
+        return generate_pure_functional_call("toLower", [op_expr], auto_map=True)
+
     def __init__(self, operand: PyLegendExpressionStringReturn) -> None:
         PyLegendExpressionStringReturn.__init__(self)
         PyLegendUnaryExpression.__init__(
             self,
             operand,
-            PyLegendStringLowerExpression.__to_sql_func
+            PyLegendStringLowerExpression.__to_sql_func,
+            PyLegendStringLowerExpression.__to_pure_func
         )
 
 
@@ -152,12 +238,17 @@ class PyLegendStringLTrimExpression(PyLegendUnaryExpression, PyLegendExpressionS
     ) -> Expression:
         return StringTrimExpression(expression, trim_type=TrimType.Left)
 
+    @staticmethod
+    def __to_pure_func(op_expr: str, config: FrameToPureConfig) -> str:
+        return generate_pure_functional_call("ltrim", [op_expr], auto_map=True)
+
     def __init__(self, operand: PyLegendExpressionStringReturn) -> None:
         PyLegendExpressionStringReturn.__init__(self)
         PyLegendUnaryExpression.__init__(
             self,
             operand,
-            PyLegendStringLTrimExpression.__to_sql_func
+            PyLegendStringLTrimExpression.__to_sql_func,
+            PyLegendStringLTrimExpression.__to_pure_func
         )
 
 
@@ -171,12 +262,17 @@ class PyLegendStringRTrimExpression(PyLegendUnaryExpression, PyLegendExpressionS
     ) -> Expression:
         return StringTrimExpression(expression, trim_type=TrimType.Right)
 
+    @staticmethod
+    def __to_pure_func(op_expr: str, config: FrameToPureConfig) -> str:
+        return generate_pure_functional_call("rtrim", [op_expr], auto_map=True)
+
     def __init__(self, operand: PyLegendExpressionStringReturn) -> None:
         PyLegendExpressionStringReturn.__init__(self)
         PyLegendUnaryExpression.__init__(
             self,
             operand,
-            PyLegendStringRTrimExpression.__to_sql_func
+            PyLegendStringRTrimExpression.__to_sql_func,
+            PyLegendStringRTrimExpression.__to_pure_func
         )
 
 
@@ -190,12 +286,17 @@ class PyLegendStringBTrimExpression(PyLegendUnaryExpression, PyLegendExpressionS
     ) -> Expression:
         return StringTrimExpression(expression, trim_type=TrimType.Both)
 
+    @staticmethod
+    def __to_pure_func(op_expr: str, config: FrameToPureConfig) -> str:
+        return generate_pure_functional_call("trim", [op_expr], auto_map=True)
+
     def __init__(self, operand: PyLegendExpressionStringReturn) -> None:
         PyLegendExpressionStringReturn.__init__(self)
         PyLegendUnaryExpression.__init__(
             self,
             operand,
-            PyLegendStringBTrimExpression.__to_sql_func
+            PyLegendStringBTrimExpression.__to_sql_func,
+            PyLegendStringBTrimExpression.__to_pure_func
         )
 
 
@@ -210,15 +311,23 @@ class PyLegendStringPosExpression(PyLegendBinaryExpression, PyLegendExpressionIn
     ) -> Expression:
         return StringPosExpression(expression1, expression2)
 
+    @staticmethod
+    def __to_pure_func(op1_expr: str, op2_expr: str, config: FrameToPureConfig) -> str:
+        return generate_pure_functional_call("indexOf", [op1_expr, op2_expr], auto_map=True)
+
     def __init__(self, operand1: PyLegendExpressionStringReturn, operand2: PyLegendExpressionStringReturn) -> None:
         PyLegendExpressionIntegerReturn.__init__(self)
         PyLegendBinaryExpression.__init__(
             self,
             operand1,
             operand2,
-            PyLegendStringPosExpression.__to_sql_func
+            PyLegendStringPosExpression.__to_sql_func,
+            PyLegendStringPosExpression.__to_pure_func
         )
 
+    def to_pure_expression(self, config: FrameToPureConfig) -> str:
+        return PyLegendBinaryExpression.to_pure_expression_with_to_one_on_second_operand(self, config)
+
 
 class PyLegendStringParseIntExpression(PyLegendUnaryExpression, PyLegendExpressionIntegerReturn):
 
@@ -230,12 +339,17 @@ class PyLegendStringParseIntExpression(PyLegendUnaryExpression, PyLegendExpressi
     ) -> Expression:
         return Cast(expression, ColumnType(name="INTEGER", parameters=[]))
 
+    @staticmethod
+    def __to_pure_func(op_expr: str, config: FrameToPureConfig) -> str:
+        return generate_pure_functional_call("parseInteger", [op_expr], auto_map=True)
+
     def __init__(self, operand: PyLegendExpressionStringReturn) -> None:
         PyLegendExpressionIntegerReturn.__init__(self)
         PyLegendUnaryExpression.__init__(
             self,
             operand,
-            PyLegendStringParseIntExpression.__to_sql_func
+            PyLegendStringParseIntExpression.__to_sql_func,
+            PyLegendStringParseIntExpression.__to_pure_func
         )
 
 
@@ -249,12 +363,17 @@ class PyLegendStringParseFloatExpression(PyLegendUnaryExpression, PyLegendExpres
     ) -> Expression:
         return Cast(expression, ColumnType(name="DOUBLE PRECISION", parameters=[]))
 
+    @staticmethod
+    def __to_pure_func(op_expr: str, config: FrameToPureConfig) -> str:
+        return generate_pure_functional_call("parseFloat", [op_expr], auto_map=True)
+
     def __init__(self, operand: PyLegendExpressionStringReturn) -> None:
         PyLegendExpressionFloatReturn.__init__(self)
         PyLegendUnaryExpression.__init__(
             self,
             operand,
-            PyLegendStringParseFloatExpression.__to_sql_func
+            PyLegendStringParseFloatExpression.__to_sql_func,
+            PyLegendStringParseFloatExpression.__to_pure_func
         )
 
 
@@ -269,15 +388,23 @@ class PyLegendStringConcatExpression(PyLegendBinaryExpression, PyLegendExpressio
     ) -> Expression:
         return StringConcatExpression(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: PyLegendExpressionStringReturn, operand2: PyLegendExpressionStringReturn) -> None:
         PyLegendExpressionStringReturn.__init__(self)
         PyLegendBinaryExpression.__init__(
             self,
             operand1,
             operand2,
-            PyLegendStringConcatExpression.__to_sql_func
+            PyLegendStringConcatExpression.__to_sql_func,
+            PyLegendStringConcatExpression.__to_pure_func
         )
 
+    def to_pure_expression(self, config: FrameToPureConfig) -> str:
+        return PyLegendBinaryExpression.to_pure_expression_with_to_one_on_both_operands(self, config)
+
 
 class PyLegendStringLessThanExpression(PyLegendBinaryExpression, PyLegendExpressionBooleanReturn):
 
@@ -290,13 +417,18 @@ class PyLegendStringLessThanExpression(PyLegendBinaryExpression, PyLegendExpress
     ) -> 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: PyLegendExpressionStringReturn, operand2: PyLegendExpressionStringReturn) -> None:
         PyLegendExpressionBooleanReturn.__init__(self)
         PyLegendBinaryExpression.__init__(
             self,
             operand1,
             operand2,
-            PyLegendStringLessThanExpression.__to_sql_func
+            PyLegendStringLessThanExpression.__to_sql_func,
+            PyLegendStringLessThanExpression.__to_pure_func
         )
 
 
@@ -311,13 +443,18 @@ class PyLegendStringLessThanEqualExpression(PyLegendBinaryExpression, PyLegendEx
     ) -> 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: PyLegendExpressionStringReturn, operand2: PyLegendExpressionStringReturn) -> None:
         PyLegendExpressionBooleanReturn.__init__(self)
         PyLegendBinaryExpression.__init__(
             self,
             operand1,
             operand2,
-            PyLegendStringLessThanEqualExpression.__to_sql_func
+            PyLegendStringLessThanEqualExpression.__to_sql_func,
+            PyLegendStringLessThanEqualExpression.__to_pure_func
         )
 
 
@@ -332,13 +469,18 @@ class PyLegendStringGreaterThanExpression(PyLegendBinaryExpression, PyLegendExpr
     ) -> 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: PyLegendExpressionStringReturn, operand2: PyLegendExpressionStringReturn) -> None:
         PyLegendExpressionBooleanReturn.__init__(self)
         PyLegendBinaryExpression.__init__(
             self,
             operand1,
             operand2,
-            PyLegendStringGreaterThanExpression.__to_sql_func
+            PyLegendStringGreaterThanExpression.__to_sql_func,
+            PyLegendStringGreaterThanExpression.__to_pure_func
         )
 
 
@@ -353,11 +495,42 @@ class PyLegendStringGreaterThanEqualExpression(PyLegendBinaryExpression, PyLegen
     ) -> 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: PyLegendExpressionStringReturn, operand2: PyLegendExpressionStringReturn) -> None:
         PyLegendExpressionBooleanReturn.__init__(self)
         PyLegendBinaryExpression.__init__(
             self,
             operand1,
             operand2,
-            PyLegendStringGreaterThanEqualExpression.__to_sql_func
+            PyLegendStringGreaterThanEqualExpression.__to_sql_func,
+            PyLegendStringGreaterThanEqualExpression.__to_pure_func
+        )
+
+
+class PyLegendCurrentUserExpression(PyLegendNullaryExpression, PyLegendExpressionStringReturn):
+
+    @staticmethod
+    def __to_sql_func(
+            frame_name_to_base_query_map: PyLegendDict[str, QuerySpecification],
+            config: FrameToSqlConfig
+    ) -> Expression:
+        return ConstantExpression('CURRENT_USER')
+
+    @staticmethod
+    def __to_pure_func(config: FrameToPureConfig) -> str:
+        return "currentUserId()"
+
+    def __init__(self) -> None:
+        PyLegendExpressionStringReturn.__init__(self)
+        PyLegendNullaryExpression.__init__(
+            self,
+            PyLegendCurrentUserExpression.__to_sql_func,
+            PyLegendCurrentUserExpression.__to_pure_func
         )
+
+
+def _escape_like_param(param: str) -> str:
+    return param.replace("_", "\\_").replace("%", "\\%")

pylegend/core/language/{operations → shared/operations}/unary_expression.py

@@ -18,7 +18,7 @@ from pylegend._typing import (
     PyLegendDict,
     PyLegendCallable,
 )
-from pylegend.core.language.expression import (
+from pylegend.core.language.shared.expression import (
     PyLegendExpression,
 )
 from pylegend.core.sql.metamodel import (
@@ -26,6 +26,7 @@ from pylegend.core.sql.metamodel import (
     QuerySpecification,
 )
 from pylegend.core.tds.tds_frame import FrameToSqlConfig
+from pylegend.core.tds.tds_frame import FrameToPureConfig
 
 
 __all__: PyLegendSequence[str] = [
@@ -39,6 +40,7 @@ class PyLegendUnaryExpression(PyLegendExpression, metaclass=ABCMeta):
         [Expression, PyLegendDict[str, QuerySpecification], FrameToSqlConfig],
         Expression
     ]
+    __to_pure_func: PyLegendCallable[[str, FrameToPureConfig], str]
 
     def __init__(
             self,
@@ -46,10 +48,12 @@ class PyLegendUnaryExpression(PyLegendExpression, metaclass=ABCMeta):
             to_sql_func: PyLegendCallable[
                 [Expression, PyLegendDict[str, QuerySpecification], FrameToSqlConfig],
                 Expression
-            ]
+            ],
+            to_pure_func: PyLegendCallable[[str, FrameToPureConfig], str]
     ) -> None:
         self.__operand = operand
         self.__to_sql_func = to_sql_func
+        self.__to_pure_func = to_pure_func
 
     def to_sql_expression(
             self,
@@ -62,3 +66,7 @@ class PyLegendUnaryExpression(PyLegendExpression, metaclass=ABCMeta):
             frame_name_to_base_query_map,
             config
         )
+
+    def to_pure_expression(self, config: FrameToPureConfig) -> str:
+        op_expr = self.__operand.to_pure_expression(config)
+        return self.__to_pure_func(op_expr, config)

pylegend/core/language/{primitive_collection.py → shared/primitive_collection.py}

@@ -18,7 +18,7 @@ from pylegend._typing import (
     PyLegendSequence,
     PyLegendUnion,
 )
-from pylegend.core.language.primitives.primitive import PyLegendPrimitiveOrPythonPrimitive
+from pylegend.core.language.shared.primitives.primitive import PyLegendPrimitiveOrPythonPrimitive
 from pylegend.core.language import (
     PyLegendInteger,
     PyLegendFloat,
@@ -30,7 +30,7 @@ from pylegend.core.language import (
     PyLegendStrictDate,
     convert_literal_to_literal_expression,
 )
-from pylegend.core.language.operations.collection_operation_expressions import (
+from pylegend.core.language.shared.operations.collection_operation_expressions import (
     PyLegendCountExpression,
     PyLegendDistinctCountExpression,
     PyLegendAverageExpression,

pylegend/core/language/{primitives → shared/primitives}/__init__.py

@@ -16,15 +16,15 @@
 from pylegend._typing import (
     PyLegendSequence,
 )
-from pylegend.core.language.primitives.primitive import PyLegendPrimitive, PyLegendPrimitiveOrPythonPrimitive
-from pylegend.core.language.primitives.boolean import PyLegendBoolean
-from pylegend.core.language.primitives.string import PyLegendString
-from pylegend.core.language.primitives.number import PyLegendNumber
-from pylegend.core.language.primitives.integer import PyLegendInteger
-from pylegend.core.language.primitives.float import PyLegendFloat
-from pylegend.core.language.primitives.date import PyLegendDate
-from pylegend.core.language.primitives.datetime import PyLegendDateTime
-from pylegend.core.language.primitives.strictdate import PyLegendStrictDate
+from pylegend.core.language.shared.primitives.primitive import PyLegendPrimitive, PyLegendPrimitiveOrPythonPrimitive
+from pylegend.core.language.shared.primitives.boolean import PyLegendBoolean
+from pylegend.core.language.shared.primitives.string import PyLegendString
+from pylegend.core.language.shared.primitives.number import PyLegendNumber
+from pylegend.core.language.shared.primitives.integer import PyLegendInteger
+from pylegend.core.language.shared.primitives.float import PyLegendFloat
+from pylegend.core.language.shared.primitives.date import PyLegendDate
+from pylegend.core.language.shared.primitives.datetime import PyLegendDateTime
+from pylegend.core.language.shared.primitives.strictdate import PyLegendStrictDate
 
 
 __all__: PyLegendSequence[str] = [