pylegend 0.8.0__py3-none-any.whl → 0.9.0__py3-none-any.whl

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

@@ -21,9 +21,12 @@ from pylegend.core.language.shared.expression import (
     PyLegendExpressionIntegerReturn,
     PyLegendExpressionFloatReturn,
     PyLegendExpressionBooleanReturn,
+    PyLegendExpressionDateTimeReturn,
 )
+from pylegend.core.language.shared.expression import PyLegendExpression
 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.nary_expression import PyLegendNaryExpression
 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 (
@@ -34,6 +37,9 @@ from pylegend.core.sql.metamodel import (
     ComparisonOperator,
     ComparisonExpression,
     StringLiteral,
+    FunctionCall,
+    QualifiedName,
+    IntegerLiteral
 )
 from pylegend.core.sql.metamodel_extension import (
     StringLengthExpression,
@@ -45,11 +51,11 @@ from pylegend.core.sql.metamodel_extension import (
     StringPosExpression,
     StringConcatExpression,
     ConstantExpression,
+    StringSubStringExpression
 )
 from pylegend.core.tds.tds_frame import FrameToSqlConfig
 from pylegend.core.tds.tds_frame import FrameToPureConfig
 
-
 __all__: PyLegendSequence[str] = [
     "PyLegendStringLengthExpression",
     "PyLegendStringStartsWithExpression",
@@ -69,6 +75,24 @@ __all__: PyLegendSequence[str] = [
     "PyLegendStringGreaterThanExpression",
     "PyLegendStringGreaterThanEqualExpression",
     "PyLegendCurrentUserExpression",
+    "PyLegendStringParseBooleanExpression",
+    "PyLegendStringParseDateTimeExpression",
+    "PyLegendStringAsciiExpression",
+    "PyLegendStringDecodeBase64Expression",
+    "PyLegendStringEncodeBase64Expression",
+    "PyLegendStringReverseExpression",
+    "PyLegendStringToLowerFirstCharacterExpression",
+    "PyLegendStringToUpperFirstCharacterExpression",
+    "PyLegendStringLeftExpression",
+    "PyLegendStringRightExpression",
+    "PyLegendStringSubStringExpression",
+    "PyLegendStringReplaceExpression",
+    "PyLegendStringLpadExpression",
+    "PyLegendStringRpadExpression",
+    "PyLegendStringSplitPartExpression",
+    "PyLegendStringRepeatStringExpression",
+    "PyLegendStringFullMatchExpression",
+    "PyLegendStringMatchExpression"
 ]
 
 
@@ -393,6 +417,292 @@ class PyLegendStringParseFloatExpression(PyLegendUnaryExpression, PyLegendExpres
         )
 
 
+class PyLegendStringParseBooleanExpression(PyLegendUnaryExpression, PyLegendExpressionBooleanReturn):
+
+    @staticmethod
+    def __to_sql_func(
+            expression: Expression,
+            frame_name_to_base_query_map: PyLegendDict[str, QuerySpecification],
+            config: FrameToSqlConfig
+    ) -> Expression:
+        return Cast(expression, ColumnType(name="BOOLEAN", parameters=[]))
+
+    @staticmethod
+    def __to_pure_func(op_expr: str, config: FrameToPureConfig) -> str:
+        return generate_pure_functional_call("parseBoolean", [op_expr])
+
+    def __init__(self, operand: PyLegendExpressionStringReturn) -> None:
+        PyLegendExpressionBooleanReturn.__init__(self)
+        PyLegendUnaryExpression.__init__(
+            self,
+            operand,
+            PyLegendStringParseBooleanExpression.__to_sql_func,
+            PyLegendStringParseBooleanExpression.__to_pure_func,
+            non_nullable=True,
+            operand_needs_to_be_non_nullable=True,
+        )
+
+
+class PyLegendStringParseDateTimeExpression(PyLegendUnaryExpression, PyLegendExpressionDateTimeReturn):
+
+    @staticmethod
+    def __to_sql_func(
+            expression: Expression,
+            frame_name_to_base_query_map: PyLegendDict[str, QuerySpecification],
+            config: FrameToSqlConfig
+    ) -> Expression:
+        return Cast(expression, ColumnType(name="TIMESTAMP", parameters=[]))
+
+    @staticmethod
+    def __to_pure_func(op_expr: str, config: FrameToPureConfig) -> str:
+        return generate_pure_functional_call("parseDate", [op_expr])
+
+    def __init__(self, operand: PyLegendExpressionStringReturn):
+        PyLegendExpressionDateTimeReturn.__init__(self)
+        PyLegendUnaryExpression.__init__(
+            self,
+            operand,
+            PyLegendStringParseDateTimeExpression.__to_sql_func,
+            PyLegendStringParseDateTimeExpression.__to_pure_func,
+            non_nullable=True,
+            operand_needs_to_be_non_nullable=True,
+        )
+
+
+class PyLegendStringDecodeBase64Expression(PyLegendUnaryExpression, PyLegendExpressionStringReturn):
+
+    @staticmethod
+    def __to_sql_func(
+            expression: Expression,
+            frame_name_to_base_query_map: PyLegendDict[str, QuerySpecification],
+            config: FrameToSqlConfig
+    ) -> Expression:
+        return FunctionCall(
+            name=QualifiedName(parts=["CONVERT_FROM"]),
+            distinct=False,
+            arguments=[
+                FunctionCall(
+                    name=QualifiedName(parts=["DECODE"]),
+                    distinct=False,
+                    arguments=[expression, StringLiteral("BASE64", quoted=False)],
+                    filter_=None, window=None
+                ), StringLiteral("UTF8", quoted=False)
+            ],
+            filter_=None, window=None
+        )
+
+    @staticmethod
+    def __to_pure_func(op_expr: str, config: FrameToPureConfig) -> str:
+        return generate_pure_functional_call("decodeBase64", [op_expr])
+
+    def __init__(self, operand: PyLegendExpressionStringReturn):
+        PyLegendExpressionStringReturn.__init__(self)
+        PyLegendUnaryExpression.__init__(
+            self,
+            operand,
+            PyLegendStringDecodeBase64Expression.__to_sql_func,
+            PyLegendStringDecodeBase64Expression.__to_pure_func,
+            non_nullable=True,
+            operand_needs_to_be_non_nullable=True,
+        )
+
+
+class PyLegendStringEncodeBase64Expression(PyLegendUnaryExpression, PyLegendExpressionStringReturn):
+
+    @staticmethod
+    def __to_sql_func(
+            expression: Expression,
+            frame_name_to_base_query_map: PyLegendDict[str, QuerySpecification],
+            config: FrameToSqlConfig
+    ) -> Expression:
+        return FunctionCall(
+            name=QualifiedName(parts=["ENCODE"]),
+            distinct=False,
+            arguments=[
+                FunctionCall(
+                    name=QualifiedName(parts=["CONVERT_TO"]),
+                    distinct=False,
+                    arguments=[expression, StringLiteral("UTF8", quoted=False)],
+                    filter_=None, window=None
+                ), StringLiteral("BASE64", quoted=False)
+            ],
+            filter_=None, window=None
+        )
+
+    @staticmethod
+    def __to_pure_func(op_expr: str, config: FrameToPureConfig) -> str:
+        return generate_pure_functional_call("encodeBase64", [op_expr])
+
+    def __init__(self, operand: PyLegendExpressionStringReturn):
+        PyLegendExpressionStringReturn.__init__(self)
+        PyLegendUnaryExpression.__init__(
+            self,
+            operand,
+            PyLegendStringEncodeBase64Expression.__to_sql_func,
+            PyLegendStringEncodeBase64Expression.__to_pure_func,
+            non_nullable=True,
+            operand_needs_to_be_non_nullable=True,
+        )
+
+
+class PyLegendStringAsciiExpression(PyLegendUnaryExpression, PyLegendExpressionIntegerReturn):
+
+    @staticmethod
+    def __to_sql_func(
+            expression: Expression,
+            frame_name_to_base_query_map: PyLegendDict[str, QuerySpecification],
+            config: FrameToSqlConfig
+    ) -> Expression:
+        return FunctionCall(
+            name=QualifiedName(parts=["ASCII"]),
+            distinct=False,
+            arguments=[expression],
+            filter_=None, window=None
+        )
+
+    @staticmethod
+    def __to_pure_func(op_expr: str, config: FrameToPureConfig) -> str:
+        return generate_pure_functional_call("ascii", [op_expr])
+
+    def __init__(self, operand: PyLegendExpressionStringReturn) -> None:
+        PyLegendExpressionIntegerReturn.__init__(self)
+        PyLegendUnaryExpression.__init__(
+            self,
+            operand,
+            PyLegendStringAsciiExpression.__to_sql_func,
+            PyLegendStringAsciiExpression.__to_pure_func,
+            non_nullable=True,
+            operand_needs_to_be_non_nullable=True,
+        )
+
+
+class PyLegendStringReverseExpression(PyLegendUnaryExpression, PyLegendExpressionStringReturn):
+
+    @staticmethod
+    def __to_sql_func(
+            expression: Expression,
+            frame_name_to_base_query_map: PyLegendDict[str, QuerySpecification],
+            config: FrameToSqlConfig
+    ) -> Expression:
+        return FunctionCall(
+            name=QualifiedName(parts=["REVERSE"]),
+            distinct=False,
+            arguments=[expression],
+            filter_=None, window=None
+        )
+
+    @staticmethod
+    def __to_pure_func(op_expr: str, config: FrameToPureConfig) -> str:
+        return generate_pure_functional_call("reverseString", [op_expr])
+
+    def __init__(self, operand: PyLegendExpressionStringReturn) -> None:
+        PyLegendExpressionStringReturn.__init__(self)
+        PyLegendUnaryExpression.__init__(
+            self,
+            operand,
+            PyLegendStringReverseExpression.__to_sql_func,
+            PyLegendStringReverseExpression.__to_pure_func,
+            non_nullable=True,
+            operand_needs_to_be_non_nullable=True,
+        )
+
+
+class PyLegendStringToLowerFirstCharacterExpression(PyLegendUnaryExpression, PyLegendExpressionStringReturn):
+
+    @staticmethod
+    def __to_sql_func(
+            expression: Expression,
+            frame_name_to_base_query_map: PyLegendDict[str, QuerySpecification],
+            config: FrameToSqlConfig
+    ) -> Expression:
+        return FunctionCall(
+            name=QualifiedName(parts=["CONCAT"]),
+            distinct=False,
+            arguments=[
+                FunctionCall(
+                    name=QualifiedName(parts=["LOWER"]),
+                    distinct=False,
+                    arguments=[FunctionCall(
+                        name=QualifiedName(parts=["LEFT"]),
+                        distinct=False,
+                        arguments=[expression, IntegerLiteral(1)],
+                        filter_=None, window=None
+                    )],
+                    filter_=None, window=None
+                ),
+                FunctionCall(
+                    name=QualifiedName(parts=["SUBSTR"]),
+                    distinct=False,
+                    arguments=[expression, IntegerLiteral(2)],
+                    filter_=None, window=None
+                )],
+            filter_=None, window=None
+        )
+
+    @staticmethod
+    def __to_pure_func(op_expr: str, config: FrameToPureConfig) -> str:
+        return generate_pure_functional_call("toLowerFirstCharacter", [op_expr])
+
+    def __init__(self, operand: PyLegendExpressionStringReturn) -> None:
+        PyLegendExpressionStringReturn.__init__(self)
+        PyLegendUnaryExpression.__init__(
+            self,
+            operand,
+            PyLegendStringToLowerFirstCharacterExpression.__to_sql_func,
+            PyLegendStringToLowerFirstCharacterExpression.__to_pure_func,
+            non_nullable=True,
+            operand_needs_to_be_non_nullable=True,
+        )
+
+
+class PyLegendStringToUpperFirstCharacterExpression(PyLegendUnaryExpression, PyLegendExpressionStringReturn):
+
+    @staticmethod
+    def __to_sql_func(
+            expression: Expression,
+            frame_name_to_base_query_map: PyLegendDict[str, QuerySpecification],
+            config: FrameToSqlConfig
+    ) -> Expression:
+        return FunctionCall(
+            name=QualifiedName(parts=["CONCAT"]),
+            distinct=False,
+            arguments=[
+                FunctionCall(
+                    name=QualifiedName(parts=["UPPER"]),
+                    distinct=False,
+                    arguments=[FunctionCall(
+                        name=QualifiedName(parts=["LEFT"]),
+                        distinct=False,
+                        arguments=[expression, IntegerLiteral(1)],
+                        filter_=None, window=None
+                    )],
+                    filter_=None, window=None
+                ),
+                FunctionCall(
+                    name=QualifiedName(parts=["SUBSTR"]),
+                    distinct=False,
+                    arguments=[expression, IntegerLiteral(2)],
+                    filter_=None, window=None
+                )],
+            filter_=None, window=None
+        )
+
+    @staticmethod
+    def __to_pure_func(op_expr: str, config: FrameToPureConfig) -> str:
+        return generate_pure_functional_call("toUpperFirstCharacter", [op_expr])
+
+    def __init__(self, operand: PyLegendExpressionStringReturn) -> None:
+        PyLegendExpressionStringReturn.__init__(self)
+        PyLegendUnaryExpression.__init__(
+            self,
+            operand,
+            PyLegendStringToUpperFirstCharacterExpression.__to_sql_func,
+            PyLegendStringToUpperFirstCharacterExpression.__to_pure_func,
+            non_nullable=True,
+            operand_needs_to_be_non_nullable=True,
+        )
+
+
 class PyLegendStringConcatExpression(PyLegendBinaryExpression, PyLegendExpressionStringReturn):
 
     @staticmethod
@@ -422,6 +732,98 @@ class PyLegendStringConcatExpression(PyLegendBinaryExpression, PyLegendExpressio
         )
 
 
+class PyLegendStringFullMatchExpression(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.LIKE)
+
+    @staticmethod
+    def __to_pure_func(op1_expr: str, op2_expr: str, config: FrameToPureConfig) -> str:
+        return generate_pure_functional_call("matches", [op1_expr, op2_expr])
+
+    def __init__(self, operand1: PyLegendExpressionStringReturn, operand2: PyLegendExpressionStringReturn) -> None:
+        PyLegendExpressionBooleanReturn.__init__(self)
+        PyLegendBinaryExpression.__init__(
+            self,
+            operand1,
+            operand2,
+            PyLegendStringFullMatchExpression.__to_sql_func,
+            PyLegendStringFullMatchExpression.__to_pure_func,
+            non_nullable=True,
+            first_operand_needs_to_be_non_nullable=True,
+            second_operand_needs_to_be_non_nullable=True
+        )
+
+
+class PyLegendStringMatchExpression(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.REGEX_MATCH)  # pragma: no cover
+
+    @staticmethod
+    def __to_pure_func(op1_expr: str, op2_expr: str, config: FrameToPureConfig) -> str:
+        return generate_pure_functional_call("regexpLike", [op1_expr, op2_expr])  # pragma: no cover
+
+    def __init__(self, operand1: PyLegendExpressionStringReturn, operand2: PyLegendExpressionStringReturn) -> None:
+        PyLegendExpressionBooleanReturn.__init__(self)  # pragma: no cover
+        PyLegendBinaryExpression.__init__(
+            self,
+            operand1,
+            operand2,
+            PyLegendStringMatchExpression.__to_sql_func,
+            PyLegendStringMatchExpression.__to_pure_func,
+            non_nullable=True,
+            first_operand_needs_to_be_non_nullable=True,
+            second_operand_needs_to_be_non_nullable=True
+        )  # pragma: no cover
+
+
+class PyLegendStringRepeatStringExpression(PyLegendBinaryExpression, PyLegendExpressionStringReturn):
+
+    @staticmethod
+    def __to_sql_func(
+            expression1: Expression,
+            expression2: Expression,
+            frame_name_to_base_query_map: PyLegendDict[str, QuerySpecification],
+            config: FrameToSqlConfig
+    ) -> Expression:
+        return FunctionCall(
+            name=QualifiedName(parts=["REPEAT"]),
+            distinct=False,
+            arguments=[expression1, expression2],
+            filter_=None, window=None
+        )
+
+    @staticmethod
+    def __to_pure_func(op1_expr: str, op2_expr: str, config: FrameToPureConfig) -> str:
+        return generate_pure_functional_call("repeatString", [op1_expr, op2_expr])
+
+    def __init__(self, operand1: PyLegendExpressionStringReturn, operand2: PyLegendExpressionIntegerReturn) -> None:
+        PyLegendExpressionStringReturn.__init__(self)
+        PyLegendBinaryExpression.__init__(
+            self,
+            operand1,
+            operand2,
+            PyLegendStringRepeatStringExpression.__to_sql_func,
+            PyLegendStringRepeatStringExpression.__to_pure_func,
+            non_nullable=True,
+            first_operand_needs_to_be_non_nullable=True,
+            second_operand_needs_to_be_non_nullable=True
+        )
+
+
 class PyLegendStringLessThanExpression(PyLegendBinaryExpression, PyLegendExpressionBooleanReturn):
 
     @staticmethod
@@ -526,6 +928,227 @@ class PyLegendStringGreaterThanEqualExpression(PyLegendBinaryExpression, PyLegen
         )
 
 
+class PyLegendStringLeftExpression(PyLegendBinaryExpression, PyLegendExpressionStringReturn):
+
+    @staticmethod
+    def __to_sql_func(
+            expression1: Expression,
+            expression2: Expression,
+            frame_name_to_base_query_map: PyLegendDict[str, QuerySpecification],
+            config: FrameToSqlConfig
+    ) -> Expression:
+        return FunctionCall(
+            name=QualifiedName(parts=["LEFT"]),
+            distinct=False,
+            arguments=[expression1, expression2],
+            filter_=None, window=None
+        )
+
+    @staticmethod
+    def __to_pure_func(op1_expr: str, op2_expr: str, config: FrameToPureConfig) -> str:
+        return generate_pure_functional_call("left", [op1_expr, op2_expr])
+
+    def __init__(self, operand1: PyLegendExpressionStringReturn, operand2: PyLegendExpressionIntegerReturn) -> None:
+        PyLegendExpressionStringReturn.__init__(self)
+        PyLegendBinaryExpression.__init__(
+            self,
+            operand1,
+            operand2,
+            PyLegendStringLeftExpression.__to_sql_func,
+            PyLegendStringLeftExpression.__to_pure_func,
+            non_nullable=True,
+            first_operand_needs_to_be_non_nullable=True,
+            second_operand_needs_to_be_non_nullable=True
+        )
+
+
+class PyLegendStringRightExpression(PyLegendBinaryExpression, PyLegendExpressionStringReturn):
+
+    @staticmethod
+    def __to_sql_func(
+            expression1: Expression,
+            expression2: Expression,
+            frame_name_to_base_query_map: PyLegendDict[str, QuerySpecification],
+            config: FrameToSqlConfig
+    ) -> Expression:
+        return FunctionCall(
+            name=QualifiedName(parts=["RIGHT"]),
+            distinct=False,
+            arguments=[expression1, expression2],
+            filter_=None, window=None
+        )
+
+    @staticmethod
+    def __to_pure_func(op1_expr: str, op2_expr: str, config: FrameToPureConfig) -> str:
+        return generate_pure_functional_call("right", [op1_expr, op2_expr])
+
+    def __init__(self, operand1: PyLegendExpressionStringReturn, operand2: PyLegendExpressionIntegerReturn) -> None:
+        PyLegendExpressionStringReturn.__init__(self)
+        PyLegendBinaryExpression.__init__(
+            self,
+            operand1,
+            operand2,
+            PyLegendStringRightExpression.__to_sql_func,
+            PyLegendStringRightExpression.__to_pure_func,
+            non_nullable=True,
+            first_operand_needs_to_be_non_nullable=True,
+            second_operand_needs_to_be_non_nullable=True
+        )
+
+
+class PyLegendStringSubStringExpression(PyLegendNaryExpression, PyLegendExpressionStringReturn):
+
+    @staticmethod
+    def __to_sql_func(
+            expressions: list[Expression],
+            frame_name_to_base_query_map: PyLegendDict[str, QuerySpecification],
+            config: FrameToSqlConfig
+    ) -> Expression:
+        if len(expressions) > 2:
+            return StringSubStringExpression(expressions[0], expressions[1], expressions[2])
+        else:
+            return StringSubStringExpression(expressions[0], expressions[1])
+
+    @staticmethod
+    def __to_pure_func(op_expr: list[str], config: FrameToPureConfig) -> str:
+        return generate_pure_functional_call("substring", op_expr)
+
+    def __init__(self, operands: list[PyLegendExpression]) -> None:
+        PyLegendExpressionStringReturn.__init__(self)
+        PyLegendNaryExpression.__init__(
+            self,
+            operands,
+            PyLegendStringSubStringExpression.__to_sql_func,
+            PyLegendStringSubStringExpression.__to_pure_func,
+            non_nullable=False,
+            operands_non_nullable_flags=[True, True, False]
+        )
+
+
+class PyLegendStringReplaceExpression(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=["REPLACE"]),
+            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("replace", op_expr)
+
+    def __init__(self, operands: list[PyLegendExpression]) -> None:
+        PyLegendExpressionStringReturn.__init__(self)
+        PyLegendNaryExpression.__init__(
+            self,
+            operands,
+            PyLegendStringReplaceExpression.__to_sql_func,
+            PyLegendStringReplaceExpression.__to_pure_func,
+            non_nullable=True,
+            operands_non_nullable_flags=[True, True, True]
+        )
+
+
+class PyLegendStringLpadExpression(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=["LPAD"]),
+            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("lpad", op_expr)
+
+    def __init__(self, operands: list[PyLegendExpression]) -> None:
+        PyLegendExpressionStringReturn.__init__(self)
+        PyLegendNaryExpression.__init__(
+            self,
+            operands,
+            PyLegendStringLpadExpression.__to_sql_func,
+            PyLegendStringLpadExpression.__to_pure_func,
+            non_nullable=True,
+            operands_non_nullable_flags=[True, True, True]
+        )
+
+
+class PyLegendStringRpadExpression(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=["RPAD"]),
+            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("rpad", op_expr)
+
+    def __init__(self, operands: list[PyLegendExpression]) -> None:
+        PyLegendExpressionStringReturn.__init__(self)
+        PyLegendNaryExpression.__init__(
+            self,
+            operands,
+            PyLegendStringRpadExpression.__to_sql_func,
+            PyLegendStringRpadExpression.__to_pure_func,
+            non_nullable=True,
+            operands_non_nullable_flags=[True, True, True]
+        )
+
+
+class PyLegendStringSplitPartExpression(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=["SPLIT_PART"]),
+            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("splitPart", op_expr)
+
+    def __init__(self, operands: list[PyLegendExpression]) -> None:
+        PyLegendExpressionStringReturn.__init__(self)
+        PyLegendNaryExpression.__init__(
+            self,
+            operands,
+            PyLegendStringSplitPartExpression.__to_sql_func,
+            PyLegendStringSplitPartExpression.__to_pure_func,
+            non_nullable=True,
+            operands_non_nullable_flags=[True, True, True]
+        )
+
+
 class PyLegendCurrentUserExpression(PyLegendNullaryExpression, PyLegendExpressionStringReturn):
 
     @staticmethod

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

@@ -33,9 +33,11 @@ from pylegend.core.language.shared.operations.integer_operation_expressions impo
     PyLegendIntegerSubtractExpression,
     PyLegendIntegerMultiplyExpression,
     PyLegendIntegerModuloExpression,
+    PyLegendIntegerCharExpression
 )
 if TYPE_CHECKING:
     from pylegend.core.language.shared.primitives import PyLegendFloat
+    from pylegend.core.language.shared.primitives.string import PyLegendString
 
 __all__: PyLegendSequence[str] = [
     "PyLegendInteger"
@@ -52,6 +54,10 @@ class PyLegendInteger(PyLegendNumber):
         self.__value_copy = value
         super().__init__(value)
 
+    def char(self) -> "PyLegendString":
+        from pylegend.core.language.shared.primitives.string import PyLegendString
+        return PyLegendString(PyLegendIntegerCharExpression(self.__value_copy))
+
     def to_sql_expression(
             self,
             frame_name_to_base_query_map: PyLegendDict[str, QuerySpecification],