snowpark-connect 0.20.2__py3-none-any.whl

snowflake/snowpark_connect/expression/map_cast.py

@@ -0,0 +1,343 @@
+#
+# Copyright (c) 2012-2025 Snowflake Computing Inc. All rights reserved.
+#
+
+import pyspark.sql.connect.proto.expressions_pb2 as expressions_proto
+import pyspark.sql.connect.proto.types_pb2 as types_proto
+from pyspark.errors.exceptions.base import (
+    AnalysisException,
+    NumberFormatException,
+    SparkRuntimeException,
+)
+
+import snowflake.snowpark.functions as snowpark_fn
+from snowflake.snowpark.types import (
+    BinaryType,
+    BooleanType,
+    DataType,
+    DateType,
+    DoubleType,
+    IntegerType,
+    LongType,
+    MapType,
+    NullType,
+    StringType,
+    StructType,
+    TimestampTimeZone,
+    TimestampType,
+    _FractionalType,
+    _IntegralType,
+    _NumericType,
+)
+from snowflake.snowpark_connect.column_name_handler import ColumnNameMap
+from snowflake.snowpark_connect.config import global_config
+from snowflake.snowpark_connect.expression.typer import ExpressionTyper
+from snowflake.snowpark_connect.type_mapping import (
+    map_type_string_to_snowpark_type,
+    proto_to_snowpark_type,
+    snowpark_to_proto_type,
+)
+from snowflake.snowpark_connect.typed_column import TypedColumn
+from snowflake.snowpark_connect.utils.context import (
+    get_is_evaluating_sql,
+    is_function_argument_being_resolved,
+)
+from snowflake.snowpark_connect.utils.udf_cache import cached_udf
+
+SYMBOL_FUNCTIONS = {"<", ">", "<=", ">=", "!=", "+", "-", "*", "/", "%", "div"}
+
+CAST_FUNCTIONS = {
+    "boolean": types_proto.DataType(boolean=types_proto.DataType.Boolean()),
+    "int": types_proto.DataType(integer=types_proto.DataType.Integer()),
+    "smallint": types_proto.DataType(integer=types_proto.DataType.Integer()),
+    "bigint": types_proto.DataType(long=types_proto.DataType.Long()),
+    "tinyint": types_proto.DataType(byte=types_proto.DataType.Byte()),
+    "float": types_proto.DataType(float=types_proto.DataType.Float()),
+    "double": types_proto.DataType(double=types_proto.DataType.Double()),
+    "string": types_proto.DataType(string=types_proto.DataType.String()),
+    "decimal": types_proto.DataType(
+        decimal=types_proto.DataType.Decimal(precision=10, scale=0)
+    ),
+    "date": types_proto.DataType(date=types_proto.DataType.Date()),
+    "timestamp": types_proto.DataType(timestamp=types_proto.DataType.Timestamp()),
+    "binary": types_proto.DataType(binary=types_proto.DataType.Binary()),
+}
+
+
+def map_cast(
+    exp: expressions_proto.Expression,
+    column_mapping: ColumnNameMap,
+    typer: ExpressionTyper,
+    from_type_cast: bool = False,
+) -> tuple[list[str], TypedColumn]:
+    """
+    Map a cast expression to a Snowpark expression.
+    """
+    from snowflake.snowpark_connect.expression.map_expression import (
+        map_single_column_expression,
+    )
+
+    spark_sql_ansi_enabled = global_config.spark_sql_ansi_enabled
+
+    match exp.cast.WhichOneof("cast_to_type"):
+        case "type":
+            to_type = proto_to_snowpark_type(exp.cast.type)
+        case "type_str":
+            to_type = map_type_string_to_snowpark_type(exp.cast.type_str)
+        case _:
+            raise ValueError("No type to cast to")
+
+    from_exp = exp.cast.expr
+    new_name, typed_column = map_single_column_expression(
+        from_exp, column_mapping, typer
+    )
+
+    match from_exp.WhichOneof("expr_type"):
+        case "unresolved_attribute" if not is_function_argument_being_resolved():
+            col_name = new_name
+        case "literal" if not is_function_argument_being_resolved() and from_type_cast:
+            col_name = new_name
+        case "unresolved_function" if from_exp.unresolved_function.function_name in SYMBOL_FUNCTIONS:
+            col_name = new_name
+        case _ if to_type.typeName().upper() in ("STRUCT", "ARRAY"):
+            col_name = new_name
+        case _ if get_is_evaluating_sql():
+            col_name = f"CAST({new_name} AS {to_type.simpleString().upper()})"
+        case _:
+            col_name = new_name
+
+    from_type = typed_column.typ
+
+    if from_exp.WhichOneof("expr_type") == "literal":
+        if (
+            spark_sql_ansi_enabled
+            and not isinstance(from_type, NullType)
+            and (
+                isinstance(to_type, _NumericType)
+                or isinstance(to_type, BinaryType)
+                or isinstance(to_type, BooleanType)
+            )
+        ):
+            sanity_check(to_type, new_name, from_type, from_type_cast)
+
+    col = typed_column.col
+    # On TCM, sometimes these are StringType(x) and TimestampType(tz=x)
+    # This normalizes them for the cast.
+    if isinstance(from_type, StringType):
+        from_type = StringType()
+    if isinstance(to_type, StringType):
+        to_type = StringType()
+    if isinstance(from_type, TimestampType):
+        from_type = TimestampType()
+    if isinstance(to_type, TimestampType):
+        to_type = TimestampType()
+    match (from_type, to_type):
+        case (_, _) if (from_type == to_type):
+            result_exp = col
+        case (NullType(), _):
+            result_exp = col.cast(to_type)
+        case (StructType(), _) if from_type.structured:
+            result_exp = col.cast(to_type, rename_fields=True)
+        case (MapType(), StringType()):
+
+            def _map_to_string(map: dict) -> str:
+                def format_value(v):
+                    if isinstance(v, dict):
+                        return _map_to_string(v)
+                    elif isinstance(v, list):
+                        return "[" + ", ".join(format_value(item) for item in v) + "]"
+                    elif isinstance(v, bool):
+                        return str(v).lower()  # Spark prints true/false
+                    elif v is None:
+                        return "null"
+                    else:
+                        return str(v)
+
+                if map is None:
+                    return None
+                parts = [f"{k} -> {format_value(v)}" for k, v in map.items()]
+                return "{" + ", ".join(parts) + "}"
+
+            _map_entries = cached_udf(
+                _map_to_string,
+                input_types=[StructType()],
+                return_type=StringType(),
+            )
+
+            result_exp = snowpark_fn.cast(
+                _map_entries(col.cast(StructType())),
+                StringType(),
+            )
+
+        # date and timestamp
+        case (TimestampType(), _) if isinstance(to_type, _NumericType):
+            epoch_s = snowpark_fn.date_part("epoch_seconds", col)
+            result_exp = epoch_s.cast(to_type)
+        case (TimestampType(), BooleanType()):
+            timestamp_0L = snowpark_fn.to_timestamp(snowpark_fn.lit(0))
+            result_exp = snowpark_fn.when(
+                col.is_not_null(),
+                col
+                != timestamp_0L,  # 0L timestamp is mapped to False, other values are mapped to True
+            ).otherwise(snowpark_fn.lit(None))
+        case (TimestampType(), DateType()):
+            result_exp = snowpark_fn.to_date(col)
+        case (DateType(), TimestampType()):
+            result_exp = snowpark_fn.to_timestamp(col)
+            result_exp = result_exp.cast(TimestampType(TimestampTimeZone.NTZ))
+        case (TimestampType(), TimestampType()):
+            result_exp = col
+        case (_, TimestampType()) if isinstance(from_type, _NumericType):
+            microseconds = col * snowpark_fn.lit(1000000)
+            result_exp = snowpark_fn.when(
+                col < 0, snowpark_fn.ceil(microseconds)
+            ).otherwise(snowpark_fn.floor(microseconds))
+            result_exp = result_exp.cast(LongType())
+            result_exp = snowpark_fn.to_timestamp(
+                result_exp, snowpark_fn.lit(6)
+            )  # microseconds precision
+            result_exp = result_exp.cast(TimestampType(TimestampTimeZone.NTZ))
+        case (_, TimestampType()) if isinstance(from_type, BooleanType):
+            result_exp = snowpark_fn.to_timestamp(
+                col.cast(LongType()), snowpark_fn.lit(6)
+            )  # microseconds precision
+            result_exp = result_exp.cast(TimestampType(TimestampTimeZone.NTZ))
+        case (_, TimestampType()):
+            if spark_sql_ansi_enabled:
+                result_exp = snowpark_fn.to_timestamp(col)
+            else:
+                result_exp = snowpark_fn.function("try_to_timestamp")(col)
+            result_exp = result_exp.cast(TimestampType(TimestampTimeZone.NTZ))
+        case (DateType(), _) if isinstance(to_type, (_NumericType, BooleanType)):
+            result_exp = snowpark_fn.cast(snowpark_fn.lit(None), to_type)
+        case (_, DateType()):
+            if spark_sql_ansi_enabled:
+                result_exp = snowpark_fn.to_date(col)
+            else:
+                result_exp = snowpark_fn.function("try_to_date")(col)
+        # boolean
+        case (BooleanType(), _) if isinstance(to_type, _NumericType):
+            result_exp = col.cast(LongType()).cast(to_type)
+        case (_, BooleanType()) if isinstance(from_type, _NumericType):
+            result_exp = col.cast(LongType()).cast(to_type)
+
+        # binary
+        case (StringType(), BinaryType()):
+            result_exp = snowpark_fn.to_binary(col, "UTF-8")
+        case (_IntegralType(), BinaryType()):
+            type_name = type(from_type).__name__.lower().replace("type", "")
+            match type_name:
+                case "byte":
+                    digits = 2
+                case "short":
+                    digits = 4
+                case "integer":
+                    digits = 8
+                case _:
+                    # default to long
+                    digits = 16
+
+            result_exp = snowpark_fn.when(
+                col.isNull(), snowpark_fn.lit(None)
+            ).otherwise(
+                snowpark_fn.to_binary(
+                    snowpark_fn.lpad(
+                        snowpark_fn.ltrim(
+                            snowpark_fn.to_char(col, snowpark_fn.lit("X" * digits))
+                        ),
+                        snowpark_fn.lit(digits),
+                        snowpark_fn.lit("0"),
+                    )
+                )
+            )
+        case (_, BinaryType()):
+            result_exp = snowpark_fn.try_to_binary(col)
+        case (BinaryType(), StringType()):
+            result_exp = snowpark_fn.to_varchar(col, "UTF-8")
+
+        # numeric
+        case (_, _) if isinstance(from_type, _FractionalType) and isinstance(
+            to_type, _IntegralType
+        ):
+            result_exp = snowpark_fn.when(col < 0, snowpark_fn.ceil(col)).otherwise(
+                snowpark_fn.floor(col)
+            )
+            result_exp = result_exp.cast(to_type)
+        case (StringType(), _) if (isinstance(to_type, _IntegralType)):
+            if spark_sql_ansi_enabled:
+                result_exp = snowpark_fn.cast(col, DoubleType())
+            else:
+                result_exp = snowpark_fn.try_cast(col, DoubleType())
+            result_exp = snowpark_fn.when(
+                result_exp < 0, snowpark_fn.ceil(result_exp)
+            ).otherwise(snowpark_fn.floor(result_exp))
+            result_exp = result_exp.cast(to_type)
+        # https://docs.snowflake.com/en/sql-reference/functions/try_cast Only works on certain types (mostly non-structured ones)
+        case (StringType(), _) if isinstance(to_type, _NumericType) or isinstance(
+            to_type, StringType
+        ) or isinstance(to_type, BooleanType) or isinstance(
+            to_type, DateType
+        ) or isinstance(
+            to_type, TimestampType
+        ) or isinstance(
+            to_type, BinaryType
+        ):
+            if spark_sql_ansi_enabled:
+                result_exp = snowpark_fn.cast(col, to_type)
+            else:
+                result_exp = snowpark_fn.try_cast(col, to_type)
+        case (StringType(), _):
+            raise AnalysisException(
+                f"""[DATATYPE_MISMATCH.CAST_WITHOUT_SUGGESTION] Cannot resolve "{col_name}" due to data type mismatch: cannot cast "{snowpark_to_proto_type(from_type, column_mapping)}" to "{exp.cast.type_str.upper()}".;"""
+            )
+        case _:
+            result_exp = snowpark_fn.cast(col, to_type)
+
+    return [col_name], TypedColumn(result_exp, lambda: [to_type])
+
+
+def sanity_check(
+    to_type: DataType, value: str, from_type: DataType, from_type_cast: bool
+) -> None:
+    """
+    This is a basic validation to ensure the casting is legal.
+    """
+
+    if isinstance(from_type, LongType) and isinstance(to_type, BinaryType):
+        raise NumberFormatException(
+            f"""[DATATYPE_MISMATCH.CAST_WITH_CONF_SUGGESTION] Cannot resolve "CAST({value} AS BINARY)" due to data type mismatch: cannot cast "BIGINT" to "BINARY" with ANSI mode on."""
+        )
+
+    if (
+        from_type_cast
+        and isinstance(from_type, StringType)
+        and isinstance(to_type, BooleanType)
+    ):
+        if value is not None:
+            value = value.strip().lower()
+        if value not in {"t", "true", "f", "false", "y", "yes", "n", "no", "0", "1"}:
+            raise SparkRuntimeException(
+                f"""[CAST_INVALID_INPUT] The value '{value}' of the type "STRING" cannot be cast to "BOOLEAN" because it is malformed. Correct the value as per the syntax, or change its target type. Use `try_cast` to tolerate malformed input and return NULL instead. If necessary set "spark.sql.ansi.enabled" to "false" to bypass this error."""
+            )
+
+    raise_cast_failure_exception = False
+    if isinstance(to_type, _IntegralType):
+        try:
+            x = int(value)
+            if isinstance(to_type, IntegerType) and (x > 2147483647 or x < -2147483648):
+                raise_cast_failure_exception = True
+            elif isinstance(to_type, LongType) and (
+                x > 9223372036854775807 or x < -9223372036854775808
+            ):
+                raise_cast_failure_exception = True
+        except Exception:
+            raise_cast_failure_exception = True
+    elif isinstance(to_type, _FractionalType):
+        try:
+            float(value)
+        except Exception:
+            raise_cast_failure_exception = True
+    if raise_cast_failure_exception:
+        raise NumberFormatException(
+            """[CAST_INVALID_INPUT] Correct the value as per the syntax, or change its target type. Use `try_cast` to tolerate malformed input and return NULL instead. If necessary setting "spark.sql.ansi.enabled" to "false" may bypass this error."""
+        )

snowflake/snowpark_connect/expression/map_expression.py

@@ -0,0 +1,293 @@
+#
+# Copyright (c) 2012-2025 Snowflake Computing Inc. All rights reserved.
+#
+
+import datetime
+from collections import defaultdict
+
+import pyspark.sql.connect.proto.expressions_pb2 as expressions_proto
+
+import snowflake.snowpark.functions as snowpark_fn
+from snowflake import snowpark
+from snowflake.snowpark import Session
+from snowflake.snowpark._internal.analyzer.expression import UnresolvedAttribute
+from snowflake.snowpark_connect.column_name_handler import ColumnNameMap
+from snowflake.snowpark_connect.expression import (
+    map_extension,
+    map_udf,
+    map_unresolved_attribute as map_att,
+    map_unresolved_extract_value as map_unresolved_extract_value,
+    map_unresolved_function as map_func,
+    map_unresolved_star as map_unresolved_star,
+    map_update_fields as map_update_fields,
+    map_window_function as map_window_func,
+)
+from snowflake.snowpark_connect.expression.literal import get_literal_field_and_name
+from snowflake.snowpark_connect.expression.map_cast import map_cast
+from snowflake.snowpark_connect.expression.map_sql_expression import map_sql_expr
+from snowflake.snowpark_connect.expression.typer import ExpressionTyper
+from snowflake.snowpark_connect.type_mapping import map_simple_types
+from snowflake.snowpark_connect.typed_column import TypedColumn
+from snowflake.snowpark_connect.utils.context import (
+    gen_sql_plan_id,
+    is_function_argument_being_resolved,
+    is_lambda_being_resolved,
+)
+from snowflake.snowpark_connect.utils.telemetry import (
+    SnowparkConnectNotImplementedError,
+)
+
+
+def map_alias(
+    alias: expressions_proto.Expression.Alias,
+    column_mapping: ColumnNameMap,
+    typer: ExpressionTyper,
+) -> tuple[list[str], TypedColumn]:
+    """
+    Map an alias expression to a Snowpark expression.
+    - Single column: Returns ([alias_name], TypedColumn)
+    - Multi-column: Returns ([alias1, alias2, ...], TypedColumn)
+
+    Args:
+        alias (expressions_proto.Expression.Alias): The alias expression to map.
+    """
+    if len(list(alias.name)) > 1:
+        # Multi-column case: handle like explode("map").alias("key", "value")
+        col_names, col = map_expression(alias.expr, column_mapping, typer)
+        if len(col_names) != len(list(alias.name)):
+            raise ValueError(
+                f"Found the unresolved operator: 'Project [{col_names} AS ({', '.join(list(alias.name))})]. Number of aliases ({len(list(alias.name))}) does not match number of columns ({len(col_names)})"
+            )
+        return list(alias.name), col
+
+    name, col = map_single_column_expression(alias.expr, column_mapping, typer)
+    col_name = alias.name[0]
+    if is_function_argument_being_resolved() or is_lambda_being_resolved():
+        # Function arguments need to be quoted if they contain spaces and require syntax 'expr AS alias' instead of 'alias'
+        col_name = (
+            f"`{col_name.replace('`', '``')}`"
+            if any(char.isspace() or char == "`" for char in col_name)
+            else col_name
+        )
+        col_name = f"{name} AS {col_name}"
+    # Spark passes a list for alias name, but it is unclear why since alias
+    # can only take a single argument.
+    # We need to make sure that the aliased snowpark column has a unique name, so
+    # gen_sql_plan_id is used to suffix the alias.
+    # TODO: do we need to push down the actual plan_id?
+    if is_lambda_being_resolved():
+        return [col_name], col
+    return [col_name], col.alias(f"{alias.name[0]}-{gen_sql_plan_id()}")
+
+
+def map_single_column_expression(
+    exp: expressions_proto.Expression,
+    column_mapping: ColumnNameMap,
+    typer: ExpressionTyper,
+) -> tuple[str, TypedColumn]:
+    col_names, typed_col = map_expression(exp, column_mapping, typer)
+    assert (
+        len(col_names) == 1
+    ), f"Expected exactly single column expression, got {len(col_names)}"
+    return col_names[0], typed_col
+
+
+def map_expression(
+    exp: expressions_proto.Expression,
+    column_mapping: ColumnNameMap,
+    typer: ExpressionTyper,
+) -> tuple[list[str], TypedColumn]:
+    """
+    Map an expression to a Snowpark expression.
+
+    Args:
+        exp (expressions_proto.Expression): The expression to map.
+        column_mapping (ColumnNameMapper): The mapping from column names to Snowpark
+            column objects.
+    """
+
+    expr_type = exp.WhichOneof("expr_type")
+    match expr_type:
+        case "alias":
+            return map_alias(exp.alias, column_mapping, typer)
+        case "call_function":
+            new_expression = expressions_proto.Expression(
+                unresolved_function=expressions_proto.Expression.UnresolvedFunction(
+                    function_name=exp.call_function.function_name,
+                    arguments=exp.call_function.arguments,
+                )
+            )
+            return map_func.map_unresolved_function(
+                new_expression, column_mapping, typer
+            )
+        case "cast":
+            return map_cast(exp, column_mapping, typer)
+        case "common_inline_user_defined_function":
+            name, col = map_udf.map_common_inline_user_defined_udf(
+                exp, column_mapping, typer
+            )
+            return [name], col
+        case "expression_string":
+            return map_sql_expr(exp, column_mapping, typer)
+        case "extension":
+            return map_extension.map_extension(exp, column_mapping, typer)
+        case "lambda_function":
+            lambda_name, lambda_body = map_single_column_expression(
+                exp.lambda_function.function, column_mapping, typer
+            )
+            args = [a.name_parts[0] for a in exp.lambda_function.arguments]
+            args_str = ", ".join(args)
+            analyzer = Session.get_active_session()._analyzer
+            body_str = analyzer.analyze(lambda_body.col._expression, defaultdict())
+            result_exp = snowpark_fn.sql_expr(f"({args_str}) -> {body_str}")
+            args_name = ", ".join(["namedlambdavariable()"] * len(args))
+            return (
+                [f"lambdafunction({lambda_name}, {args_name})"],
+                TypedColumn(
+                    result_exp,
+                    # It's not accurate - TypeColumn holds lambda expression, so "type of the lambda" should be returned here.
+                    # Instead, we return type of lambda body expression. But it's ok - since no one ever should need "type of the lambda"
+                    lambda: lambda_body.types,
+                ),
+            )
+        case "literal":
+            lit_value, lit_name = get_literal_field_and_name(exp.literal)
+            lit_type_str = str(exp.literal.WhichOneof("literal_type"))
+            # this is a hack until we would have an interval type supported in snowflake, for now
+            # this will use the interval expression instead of literal expression to solve this usecase.
+            if isinstance(lit_value, datetime.timedelta):
+                return [lit_name], TypedColumn(
+                    snowpark_fn.make_interval(
+                        days=lit_value.days,
+                        seconds=lit_value.seconds,
+                        microseconds=lit_value.microseconds,
+                    ),
+                    lambda: [map_simple_types(lit_type_str)],
+                )
+
+            # Decimal needs further processing to get the precision and scale properly.
+            if lit_type_str == "decimal":
+                # Precision and scale are optional in the proto.
+                precision = 38
+                scale = 0
+                decimal_msg = exp.literal.decimal
+                if decimal_msg.HasField("precision"):
+                    precision = decimal_msg.precision
+                if decimal_msg.HasField("scale"):
+                    scale = decimal_msg.scale
+                if "." in decimal_msg.value and precision == 10 and scale == 0:
+                    # Spark Connect protobuf will sometimes give the default precision and scale for Decimals
+                    # so we manually determine what the precision and scale actually are.
+                    # decimal {
+                    #    value: "123.45"
+                    #    precision: 10
+                    #    scale: 0
+                    # }
+                    precision = len(decimal_msg.value) - 1
+                    scale = len(decimal_msg.value.split(".")[1])
+
+                return_type = snowpark.types.DecimalType(precision, scale)
+                return [lit_name], TypedColumn(
+                    snowpark_fn.lit(lit_value, return_type), lambda: [return_type]
+                )
+
+            return [lit_name], TypedColumn(
+                snowpark_fn.lit(lit_value), lambda: [map_simple_types(lit_type_str)]
+            )
+        case "sort_order":
+            child_name, child_column = map_single_column_expression(
+                exp.sort_order.child, column_mapping, typer
+            )
+            match exp.sort_order.direction:
+                case (
+                    exp.sort_order.SORT_DIRECTION_UNSPECIFIED
+                    | exp.sort_order.SORT_DIRECTION_ASCENDING
+                ):
+                    if exp.sort_order.null_ordering == exp.sort_order.SORT_NULLS_LAST:
+                        return [child_name], snowpark_fn.asc_nulls_last(child_column)
+                    else:
+                        # If nulls are not specified or null_ordering is FIRST in the sort order, Spark defaults to nulls
+                        # first in the case of ascending sort order.
+                        return [child_name], snowpark_fn.asc_nulls_first(child_column)
+                case exp.sort_order.SORT_DIRECTION_DESCENDING:
+                    if exp.sort_order.null_ordering == exp.sort_order.SORT_NULLS_FIRST:
+                        return [child_name], snowpark_fn.desc_nulls_first(child_column)
+                    else:
+                        # If nulls are not specified or null_ordering is LAST in the sort order, Spark defaults to nulls
+                        # last in the case of descending sort order.
+                        return [child_name], snowpark_fn.desc_nulls_last(child_column)
+                case _:
+                    raise ValueError(
+                        f"Invalid sort direction {exp.sort_order.direction}"
+                    )
+        case "unresolved_attribute":
+            col_name, col = map_att.map_unresolved_attribute(exp, column_mapping, typer)
+            # Check if this is a multi-column regex expansion
+            matched_cols = getattr(col, "_regex_matched_columns", list())
+            if matched_cols:
+                # Create expressions for all matched columns
+                snowpark_cols = []
+                for matched_col in matched_cols:
+                    snowpark_name = (
+                        column_mapping.get_snowpark_column_name_from_spark_column_name(
+                            matched_col
+                        )
+                    )
+                    snowpark_cols.append(snowpark_name)
+
+                # Create a combined expression for all columns
+                col_expr = snowpark_fn.sql_expr(", ".join(snowpark_cols))
+                return (
+                    matched_cols,
+                    TypedColumn(
+                        col_expr,
+                        lambda: [
+                            typer.type(snowpark_fn.col(sc))[0] for sc in snowpark_cols
+                        ],
+                    ),
+                )
+            return [col_name], col
+        case "unresolved_extract_value":
+            col_name, col = map_unresolved_extract_value.map_unresolved_extract_value(
+                exp, column_mapping, typer
+            )
+            return [col_name], col
+        case "unresolved_function":
+            return map_func.map_unresolved_function(exp, column_mapping, typer)
+        case "unresolved_named_lambda_variable":
+            col = snowpark_fn.Column(
+                UnresolvedAttribute(exp.unresolved_named_lambda_variable.name_parts[0])
+            )
+            for child_name in exp.unresolved_named_lambda_variable.name_parts[1:]:
+                col = col.getItem(child_name)
+            return ["namedlambdavariable()"], TypedColumn(col, lambda: typer.type(col))
+        case "unresolved_regex":
+            p = exp.unresolved_regex.col_name
+            pattern_str = p[1:-1] if p.startswith("`") and p.endswith("`") else p
+
+            mapping = column_mapping.spark_to_snowpark_for_pattern(pattern_str)
+            spark_cols, snowpark_cols = (
+                [spark_name for spark_name, _ in mapping],
+                [snowpark_name for _, snowpark_name in mapping],
+            )
+
+            col_expr = snowpark_fn.sql_expr(", ".join(snowpark_cols))
+            return (
+                spark_cols,
+                TypedColumn(col_expr, lambda: typer.type(col_expr))
+                if snowpark_cols
+                else TypedColumn.empty(),
+            )
+        case "unresolved_star":
+            return map_unresolved_star.map_unresolved_star(exp, column_mapping, typer)
+        case "window":
+            col_name, col = map_window_func.map_window_function(
+                exp, column_mapping, typer
+            )
+            return [col_name], col
+        case "update_fields":
+            return map_update_fields.map_update_fields(exp, column_mapping, typer)
+        case _:
+            raise SnowparkConnectNotImplementedError(
+                f"Unsupported expression type {expr_type}"
+            )