snowpark-connect 0.24.0__py3-none-any.whl → 0.25.0__py3-none-any.whl

snowflake/snowpark_connect/expression/map_unresolved_function.py

@@ -73,11 +73,11 @@ from snowflake.snowpark_connect.column_name_handler import (
 )
 from snowflake.snowpark_connect.config import (
     get_boolean_session_config_param,
+    get_timestamp_type,
     global_config,
 )
 from snowflake.snowpark_connect.constants import (
     DUPLICATE_KEY_FOUND_ERROR_TEMPLATE,
-    SPARK_TZ_ABBREVIATIONS_OVERRIDES,
     STRUCTURED_TYPES_ENABLED,
 )
 from snowflake.snowpark_connect.expression.function_defaults import (
@@ -100,7 +100,6 @@ from snowflake.snowpark_connect.type_mapping import (
     map_snowpark_to_pyspark_types,
     map_spark_timestamp_format_expression,
     map_type_string_to_snowpark_type,
-    parse_ddl_string,
 )
 from snowflake.snowpark_connect.typed_column import (
     TypedColumn,
@@ -209,19 +208,6 @@ def _validate_numeric_args(
     return modified_args
 
 
-def get_timestamp_type():
-    match global_config["spark.sql.timestampType"]:
-        case "TIMESTAMP_LTZ":
-            timestamp_type = TimestampType(TimestampTimeZone.LTZ)
-        case "TIMESTAMP_NTZ":
-            timestamp_type = TimestampType(TimestampTimeZone.NTZ)
-        case "TIMESTAMP_TZ":
-            timestamp_type = TimestampType(TimestampTimeZone.TZ)
-        case _:
-            timestamp_type = TimestampType(TimestampTimeZone.DEFAULT)
-    return timestamp_type
-
-
 def unwrap_literal(exp: expressions_proto.Expression):
     """Workaround for Snowpark functions generating invalid SQL when used with fn.lit (SNOW-1871954)"""
     return get_literal_field_and_name(exp.literal)[0]
@@ -522,146 +508,401 @@ def map_unresolved_function(
                 result_exp = snowpark_fn.when(
                     snowpark_args[1] == 0, snowpark_fn.lit(None)
                 ).otherwise(snowpark_args[0] % snowpark_args[1])
-            result_type = _find_common_type([arg.typ for arg in snowpark_typed_args])
-        case "*":
-            # For decimal arithmetic, we need to check for overflow
-            if (
-                isinstance(snowpark_typed_args[0].typ, DecimalType)
-                and isinstance(snowpark_typed_args[1].typ, DecimalType)
-                or isinstance(snowpark_typed_args[0].typ, DecimalType)
-                and isinstance(snowpark_typed_args[1].typ, _IntegralType)
-                or isinstance(snowpark_typed_args[0].typ, _IntegralType)
-                and isinstance(snowpark_typed_args[1].typ, DecimalType)
-            ):
-                result_exp, (
-                    return_type_precision,
-                    return_type_scale,
-                ) = _mul_div_precision_helper(snowpark_typed_args, snowpark_args, 0)
-                result_type = DecimalType(return_type_precision, return_type_scale)
-            else:
-                result_exp = snowpark_args[0] * snowpark_args[1]
-                result_type = _find_common_type(
-                    [arg.typ for arg in snowpark_typed_args]
-                )
-        case "+":
-            if isinstance(snowpark_typed_args[0].typ, DateType) and not isinstance(
-                snowpark_typed_args[1].typ,
-                (_IntegralType, StringType),
-            ):
-                raise AnalysisException(
-                    f'[DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE] Cannot resolve "{snowpark_arg_names[0]} + {snowpark_arg_names[1]}" due to data type mismatch: Parameter 2 requires the ("INT" or "SMALLINT" or "TINYINT") type, however "{snowpark_arg_names[1]}" has the type "{snowpark_typed_args[1].typ}".',
-                )
-            elif (
-                isinstance(snowpark_typed_args[0].typ, BinaryType)
-                and isinstance(snowpark_typed_args[1].typ, DecimalType)
-                or isinstance(snowpark_typed_args[0].typ, DecimalType)
-                and isinstance(snowpark_typed_args[1].typ, BinaryType)
-            ) or (
-                isinstance(snowpark_typed_args[0].typ, DecimalType)
-                and isinstance(snowpark_typed_args[1].typ, TimestampType)
-                or isinstance(snowpark_typed_args[0].typ, TimestampType)
-                and isinstance(snowpark_typed_args[1].typ, DecimalType)
-            ):
-                raise AnalysisException(
-                    f'[DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES] Cannot resolve "({snowpark_arg_names[0]} + {snowpark_arg_names[1]})" due to data type mismatch: the left and right operands of the binary operator have incompatible types ("{snowpark_typed_args[0].typ}" and "{snowpark_typed_args[1].typ}").'
-                )
-            elif isinstance(snowpark_typed_args[1].typ, DateType) and not isinstance(
-                snowpark_typed_args[0].typ,
-                (_IntegralType, StringType),
-            ):
-                raise AnalysisException(
-                    f'[DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE] Cannot resolve "{snowpark_arg_names[0]} + {snowpark_arg_names[1]}" due to data type mismatch: Parameter 1 requires the ("INT" or "SMALLINT" or "TINYINT") type, however "{snowpark_arg_names[0]}" has the type "{snowpark_typed_args[0].typ}".',
-                )
-            elif (
-                isinstance(snowpark_typed_args[0].typ, DecimalType)
-                and isinstance(snowpark_typed_args[1].typ, DecimalType)
-                or isinstance(snowpark_typed_args[0].typ, DecimalType)
-                and isinstance(snowpark_typed_args[1].typ, _IntegralType)
-                or isinstance(snowpark_typed_args[0].typ, _IntegralType)
-                and isinstance(snowpark_typed_args[1].typ, DecimalType)
-            ):
-                result_exp, (
-                    return_type_precision,
-                    return_type_scale,
-                ) = _add_sub_precision_helper(snowpark_typed_args, snowpark_args, 0)
-                result_type = DecimalType(return_type_precision, return_type_scale)
-            else:
-                result_exp = snowpark_args[0] + snowpark_args[1]
-                if any(isinstance(arg.typ, DateType) for arg in snowpark_typed_args):
-                    # TODO SNOW-2034420: resolve return type
-                    result_exp = _type_with_typer(result_exp)
-                else:
+            match (snowpark_typed_args[0].typ, snowpark_typed_args[1].typ):
+                case (NullType(), NullType()):
+                    result_type = DoubleType()
+                case _:
                     result_type = _find_common_type(
                         [arg.typ for arg in snowpark_typed_args]
                     )
-        case "-":
-            if isinstance(snowpark_typed_args[0].typ, DateType) and not isinstance(
-                snowpark_typed_args[1].typ,
-                (_IntegralType, StringType),
-            ):
-                raise AnalysisException(
-                    f'[DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE] Cannot resolve "{snowpark_arg_names[0]} - {snowpark_arg_names[1]}" due to data type mismatch: Parameter 2 requires the ("INT" or "SMALLINT" or "TINYINT") type, however "{snowpark_arg_names[1]}" has the type "{snowpark_typed_args[1].typ}".',
-                )
-            elif (
-                isinstance(snowpark_typed_args[0].typ, BinaryType)
-                and isinstance(snowpark_typed_args[1].typ, DecimalType)
-                or isinstance(snowpark_typed_args[0].typ, DecimalType)
-                and isinstance(snowpark_typed_args[1].typ, BinaryType)
-            ) or (
-                isinstance(snowpark_typed_args[0].typ, DecimalType)
-                and isinstance(snowpark_typed_args[1].typ, TimestampType)
-                or isinstance(snowpark_typed_args[0].typ, TimestampType)
-                and isinstance(snowpark_typed_args[1].typ, DecimalType)
-            ):
-                raise AnalysisException(
-                    f'[DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES] Cannot resolve "({snowpark_arg_names[0]} - {snowpark_arg_names[1]})" due to data type mismatch: the left and right operands of the binary operator have incompatible types ("{snowpark_typed_args[0].typ}" and "{snowpark_typed_args[1].typ}").'
-                )
-            elif isinstance(snowpark_typed_args[1].typ, DateType) and not isinstance(
-                snowpark_typed_args[0].typ,
-                (_IntegralType, StringType),
-            ):
-                raise AnalysisException(
-                    f'[DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE] Cannot resolve "{snowpark_arg_names[0]} - {snowpark_arg_names[1]}" due to data type mismatch: Parameter 1 requires the ("INT" or "SMALLINT" or "TINYINT") type, however "{snowpark_arg_names[0]}" has the type "{snowpark_typed_args[0].typ}".',
-                )
-            elif (
-                isinstance(snowpark_typed_args[0].typ, DecimalType)
-                and isinstance(snowpark_typed_args[1].typ, DecimalType)
-                or isinstance(snowpark_typed_args[0].typ, DecimalType)
-                and isinstance(snowpark_typed_args[1].typ, _IntegralType)
-                or isinstance(snowpark_typed_args[0].typ, _IntegralType)
-                and isinstance(snowpark_typed_args[1].typ, DecimalType)
-            ):
-                result_exp, (
-                    return_type_precision,
-                    return_type_scale,
-                ) = _add_sub_precision_helper(snowpark_typed_args, snowpark_args, 1)
-                result_type = DecimalType(return_type_precision, return_type_scale)
-            else:
-                result_exp = snowpark_args[0] - snowpark_args[1]
-                if any(isinstance(arg.typ, DateType) for arg in snowpark_typed_args):
-                    # TODO SNOW-2034420: resolve return type
-                    result_exp = _type_with_typer(result_exp)
-                else:
+        case "*":
+            match (snowpark_typed_args[0].typ, snowpark_typed_args[1].typ):
+                case (DecimalType() as t, NullType()) | (
+                    NullType(),
+                    DecimalType() as t,
+                ):
+                    p1, s1 = _get_type_precision(t)
+                    result_type = _get_decimal_multiplication_result_type(
+                        p1, s1, p1, s1
+                    )
+                    result_exp = snowpark_fn.lit(None)
+                case (DecimalType(), t) | (t, DecimalType()) if isinstance(
+                    t, (DecimalType, _IntegralType)
+                ):
+                    p1, s1 = _get_type_precision(snowpark_typed_args[0].typ)
+                    p2, s2 = _get_type_precision(snowpark_typed_args[1].typ)
+                    result_type = _get_decimal_multiplication_result_type(
+                        p1, s1, p2, s2
+                    )
+                    result_exp = _get_decimal_multiplication_result_exp(
+                        result_type, t, snowpark_args
+                    )
+                case (NullType(), NullType()):
+                    result_type = DoubleType()
+                    result_exp = snowpark_fn.lit(None)
+                case (StringType(), StringType()):
+                    if spark_sql_ansi_enabled:
+                        raise AnalysisException(
+                            f'[DATATYPE_MISMATCH.BINARY_OP_WRONG_TYPE] Cannot resolve "{spark_function_name}" due to data type mismatch: the binary operator requires the input type ("DOUBLE" or "DECIMAL"), not "STRING".'
+                        )
+                    else:
+                        result_type = DoubleType()
+                        result_exp = snowpark_args[0].try_cast(
+                            result_type
+                        ) * snowpark_args[1].try_cast(result_type)
+                case (StringType(), _IntegralType()):
+                    if spark_sql_ansi_enabled:
+                        result_type = LongType()
+                        result_exp = (
+                            snowpark_args[0].cast(result_type) * snowpark_args[1]
+                        )
+                    else:
+                        result_type = DoubleType()
+                        result_exp = (
+                            snowpark_args[0].try_cast(result_type) * snowpark_args[1]
+                        )
+                case (StringType(), _FractionalType()):
+                    result_type = DoubleType()
+                    if spark_sql_ansi_enabled:
+                        result_exp = (
+                            snowpark_args[0].cast(result_type) * snowpark_args[1]
+                        )
+                    else:
+                        result_exp = (
+                            snowpark_args[0].try_cast(result_type) * snowpark_args[1]
+                        )
+                case (_IntegralType(), StringType()):
+                    if spark_sql_ansi_enabled:
+                        result_type = LongType()
+                        result_exp = snowpark_args[0] * snowpark_args[1].cast(
+                            result_type
+                        )
+                    else:
+                        result_type = DoubleType()
+                        result_exp = snowpark_args[0] * snowpark_args[1].try_cast(
+                            result_type
+                        )
+                case (_FractionalType(), StringType()):
+                    result_type = DoubleType()
+                    if spark_sql_ansi_enabled:
+                        result_exp = snowpark_args[0] * snowpark_args[1].cast(
+                            result_type
+                        )
+                    else:
+                        result_exp = snowpark_args[0] * snowpark_args[1].try_cast(
+                            result_type
+                        )
+                case (_NumericType() as t, NullType()) | (
+                    NullType(),
+                    _NumericType() as t,
+                ):
+                    result_type = t
+                    result_exp = snowpark_fn.lit(None)
+                case (_NumericType(), _NumericType()):
                     result_type = _find_common_type(
                         [arg.typ for arg in snowpark_typed_args]
                     )
-        case "/":
+                    result_exp = snowpark_args[0].cast(result_type) * snowpark_args[
+                        1
+                    ].cast(result_type)
+                case _:
+                    raise AnalysisException(
+                        f'[DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES] Cannot resolve "{spark_function_name}" due to data type mismatch: the left and right operands of the binary operator have incompatible types ("{snowpark_typed_args[0].typ}" and "{snowpark_typed_args[1].typ}").'
+                    )
+        case "+":
+            spark_function_name = _get_spark_function_name(
+                snowpark_typed_args[0],
+                snowpark_typed_args[1],
+                snowpark_arg_names,
+                exp,
+                spark_function_name,
+                "+",
+            )
             match (snowpark_typed_args[0].typ, snowpark_typed_args[1].typ):
+                case (NullType(), _) | (_, NullType()):
+                    result_type = _get_add_sub_result_type(
+                        snowpark_typed_args[0].typ,
+                        snowpark_typed_args[1].typ,
+                        spark_function_name,
+                    )
+                    result_exp = snowpark_args[0] + snowpark_args[1]
+                    result_exp = result_exp.cast(result_type)
+                case (DateType(), t) | (t, DateType()):
+                    date_param_index = (
+                        0 if isinstance(snowpark_typed_args[0].typ, DateType) else 1
+                    )
+                    t_param_index = 1 - date_param_index
+                    if isinstance(t, (IntegerType, ShortType, ByteType)):
+                        result_type = DateType()
+                        result_exp = snowpark_args[0] + snowpark_args[1]
+                    elif (
+                        "INTERVAL"
+                        == snowpark_typed_args[t_param_index].col._expr1.pretty_name
+                    ):
+                        result_type = TimestampType()
+                        result_exp = (
+                            snowpark_args[date_param_index]
+                            + snowpark_args[t_param_index]
+                        )
+                    else:
+                        raise AnalysisException(
+                            f'[DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE] Cannot resolve "{spark_function_name}" due to data type mismatch: Parameter 2 requires the ("INT" or "SMALLINT" or "TINYINT") type, however "{snowpark_arg_names[t_param_index]}" has the type "{t}".',
+                        )
+                case (StringType(), StringType()):
+                    if spark_sql_ansi_enabled:
+                        raise AnalysisException(
+                            f'[DATATYPE_MISMATCH.BINARY_OP_WRONG_TYPE] Cannot resolve "{spark_function_name}" due to data type mismatch: the binary operator requires the input type ("NUMERIC" or "INTERVAL DAY TO SECOND" or "INTERVAL YEAR TO MONTH" or "INTERVAL"), not "STRING".'
+                        )
+                    else:
+                        result_type = DoubleType()
+                        result_exp = snowpark_fn.try_cast(
+                            snowpark_args[0], result_type
+                        ) + snowpark_fn.try_cast(snowpark_args[1], result_type)
+                case (StringType(), _NumericType() as t):
+                    if spark_sql_ansi_enabled:
+                        result_type = (
+                            DoubleType()
+                            if isinstance(t, _FractionalType)
+                            else LongType()
+                        )
+                        result_exp = (
+                            snowpark_args[0].cast(result_type) + snowpark_args[1]
+                        )
+                    else:
+                        result_type = DoubleType()
+                        result_exp = (
+                            snowpark_fn.try_cast(snowpark_args[0], result_type)
+                            + snowpark_args[1]
+                        )
+                case (_NumericType() as t, StringType()):
+                    if spark_sql_ansi_enabled:
+                        result_type = (
+                            DoubleType()
+                            if isinstance(t, _FractionalType)
+                            else LongType()
+                        )
+                        result_exp = snowpark_args[0] + snowpark_args[1].cast(
+                            result_type
+                        )
+                    else:
+                        result_type = DoubleType()
+                        result_exp = snowpark_args[0] + snowpark_fn.try_cast(
+                            snowpark_args[1], result_type
+                        )
                 case (DecimalType(), t) | (t, DecimalType()) if isinstance(
-                    t, DecimalType
-                ) or isinstance(t, _IntegralType) or isinstance(
-                    snowpark_typed_args[1].typ, NullType
+                    t, (BinaryType, TimestampType)
                 ):
-                    result_exp, (
-                        return_type_precision,
-                        return_type_scale,
-                    ) = _mul_div_precision_helper(snowpark_typed_args, snowpark_args, 1)
-                    result_type = DecimalType(return_type_precision, return_type_scale)
+                    raise AnalysisException(
+                        f'[DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES] Cannot resolve "{spark_function_name}" due to data type mismatch: the left and right operands of the binary operator have incompatible types ("{snowpark_typed_args[0].typ}" and "{snowpark_typed_args[1].typ}").'
+                    )
                 case _:
+                    result_type = _get_add_sub_result_type(
+                        snowpark_typed_args[0].typ,
+                        snowpark_typed_args[1].typ,
+                        spark_function_name,
+                    )
+                    result_exp = snowpark_args[0] + snowpark_args[1]
+                    if isinstance(result_type, DecimalType):
+                        result_exp = _cast_helper(result_exp, result_type)
+        case "-":
+            spark_function_name = _get_spark_function_name(
+                snowpark_typed_args[0],
+                snowpark_typed_args[1],
+                snowpark_arg_names,
+                exp,
+                spark_function_name,
+                "-",
+            )
+            match (snowpark_typed_args[0].typ, snowpark_typed_args[1].typ):
+                case (NullType(), _) | (_, NullType()):
+                    result_type = _get_add_sub_result_type(
+                        snowpark_typed_args[0].typ,
+                        snowpark_typed_args[1].typ,
+                        spark_function_name,
+                    )
+                    result_exp = snowpark_args[0] - snowpark_args[1]
+                    result_exp = result_exp.cast(result_type)
+                case (DateType(), DateType()):
+                    # TODO SNOW-2034420: resolve return type (it should be INTERVAL DAY)
+                    result_type = LongType()
+                    result_exp = snowpark_args[0] - snowpark_args[1]
+                case (DateType(), StringType()):
+                    if "INTERVAL" == snowpark_typed_args[1].col._expr1.pretty_name:
+                        result_type = TimestampType()
+                        result_exp = snowpark_args[0] - snowpark_args[1]
+                    else:
+                        # TODO SNOW-2034420: resolve return type (it should be INTERVAL DAY)
+                        result_type = LongType()
+                        input_type = (
+                            DateType() if spark_sql_ansi_enabled else DoubleType()
+                        )
+                        result_exp = snowpark_args[0] - snowpark_args[1].cast(
+                            input_type
+                        )
+                case (StringType(), DateType()):
+                    # TODO SNOW-2034420: resolve return type (it should be INTERVAL DAY)
+                    result_type = LongType()
+                    input_type = DateType()
+                    result_exp = snowpark_args[0].cast(input_type) - snowpark_args[1]
+                case (DateType(), (IntegerType() | ShortType() | ByteType())):
+                    result_type = DateType()
+                    result_exp = snowpark_args[0] - snowpark_args[1]
+                case (DateType(), _):
+                    raise AnalysisException(
+                        f'[DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE] Cannot resolve "{spark_function_name}" due to data type mismatch: Parameter 2 requires the ("INT" or "SMALLINT" or "TINYINT") type, however "{snowpark_arg_names[1]}" has the type "{snowpark_typed_args[1].typ}".',
+                    )
+                case (_, DateType()):
+                    raise AnalysisException(
+                        f'[DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE] Cannot resolve "{spark_function_name}" due to data type mismatch: Parameter 1 requires the "DATE" type, however "{snowpark_arg_names[0]}" has the type "{snowpark_typed_args[0].typ}".',
+                    )
+                case (StringType(), StringType()):
+                    if spark_sql_ansi_enabled:
+                        raise AnalysisException(
+                            f'[DATATYPE_MISMATCH.BINARY_OP_WRONG_TYPE] Cannot resolve "{spark_function_name}" due to data type mismatch: the binary operator requires the input type ("NUMERIC" or "INTERVAL DAY TO SECOND" or "INTERVAL YEAR TO MONTH" or "INTERVAL"), not "STRING".'
+                        )
+                    else:
+                        result_type = DoubleType()
+                        result_exp = snowpark_fn.try_cast(
+                            snowpark_args[0], result_type
+                        ) - snowpark_fn.try_cast(snowpark_args[1], result_type)
+                case (StringType(), _NumericType() as t):
+                    if spark_sql_ansi_enabled:
+                        result_type = (
+                            DoubleType()
+                            if isinstance(t, _FractionalType)
+                            else LongType()
+                        )
+                        result_exp = (
+                            snowpark_args[0].cast(result_type) - snowpark_args[1]
+                        )
+                    else:
+                        result_type = DoubleType()
+                        result_exp = (
+                            snowpark_fn.try_cast(snowpark_args[0], result_type)
+                            - snowpark_args[1]
+                        )
+                case (_NumericType() as t, StringType()):
+                    if spark_sql_ansi_enabled:
+                        result_type = (
+                            DoubleType()
+                            if isinstance(t, _FractionalType)
+                            else LongType()
+                        )
+                        result_exp = snowpark_args[0] - snowpark_args[1].cast(
+                            result_type
+                        )
+                    else:
+                        result_type = DoubleType()
+                        result_exp = snowpark_args[0] - snowpark_fn.try_cast(
+                            snowpark_args[1], result_type
+                        )
+                case (DecimalType(), t) | (t, DecimalType()) if isinstance(
+                    t, (BinaryType, TimestampType)
+                ):
+                    raise AnalysisException(
+                        f'[DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES] Cannot resolve "{spark_function_name}" due to data type mismatch: the left and right operands of the binary operator have incompatible types ("{snowpark_typed_args[0].typ}" and "{snowpark_typed_args[1].typ}").'
+                    )
+                case _:
+                    result_type = _get_add_sub_result_type(
+                        snowpark_typed_args[0].typ,
+                        snowpark_typed_args[1].typ,
+                        spark_function_name,
+                    )
+                    result_exp = snowpark_args[0] - snowpark_args[1]
+                    if isinstance(result_type, DecimalType):
+                        result_exp = _cast_helper(result_exp, result_type)
+        case "/":
+            match (snowpark_typed_args[0].typ, snowpark_typed_args[1].typ):
+                case (DecimalType() as t1, NullType()):
+                    p1, s1 = _get_type_precision(t1)
+                    result_type, _ = _get_decimal_division_result_type(p1, s1, p1, s1)
+                    result_exp = snowpark_fn.lit(None).cast(result_type)
+                case (DecimalType(), t) | (t, DecimalType()) if isinstance(
+                    t, (DecimalType, _IntegralType)
+                ):
+                    p1, s1 = _get_type_precision(snowpark_typed_args[0].typ)
+                    p2, s2 = _get_type_precision(snowpark_typed_args[1].typ)
+                    result_type, overflow_detected = _get_decimal_division_result_type(
+                        p1, s1, p2, s2
+                    )
+                    result_exp = _get_decimal_division_result_exp(
+                        result_type,
+                        t,
+                        overflow_detected,
+                        snowpark_args,
+                        spark_function_name,
+                    )
+                case (NullType(), NullType()):
                     result_type = DoubleType()
-                    dividend = snowpark_args[0].cast(result_type)
-                    divisor = snowpark_args[1].cast(result_type)
-                    result_exp = _divnull(dividend, divisor)
+                    result_exp = snowpark_fn.lit(None)
+                case (StringType(), StringType()):
+                    if spark_sql_ansi_enabled:
+                        raise AnalysisException(
+                            f'[DATATYPE_MISMATCH.BINARY_OP_WRONG_TYPE] Cannot resolve "{spark_function_name}" due to data type mismatch: the binary operator requires the input type ("DOUBLE" or "DECIMAL"), not "STRING".'
+                        )
+                    else:
+                        result_type = DoubleType()
+                        result_exp = _divnull(
+                            snowpark_args[0].try_cast(result_type),
+                            snowpark_args[1].try_cast(result_type),
+                        )
+                case (StringType(), _IntegralType()):
+                    result_type = DoubleType()
+                    if spark_sql_ansi_enabled:
+                        result_exp = _divnull(
+                            snowpark_args[0].cast(LongType()),
+                            snowpark_args[1].cast(result_type),
+                        )
+                    else:
+                        result_exp = _divnull(
+                            snowpark_args[0].try_cast(result_type), snowpark_args[1]
+                        )
+                    result_exp = result_exp.cast(result_type)
+                case (StringType(), _FractionalType()):
+                    result_type = DoubleType()
+                    if spark_sql_ansi_enabled:
+                        result_exp = _divnull(
+                            snowpark_args[0].cast(result_type), snowpark_args[1]
+                        )
+                    else:
+                        result_exp = _divnull(
+                            snowpark_args[0].try_cast(result_type), snowpark_args[1]
+                        )
+                case (_IntegralType(), StringType()):
+                    result_type = DoubleType()
+                    if spark_sql_ansi_enabled:
+                        result_exp = _divnull(
+                            snowpark_args[0].cast(result_type),
+                            snowpark_args[1].cast(LongType()),
+                        )
+                    else:
+                        result_exp = _divnull(
+                            snowpark_args[0], snowpark_args[1].try_cast(result_type)
+                        )
+                    result_exp = result_exp.cast(result_type)
+                case (_FractionalType(), StringType()):
+                    result_type = DoubleType()
+                    if spark_sql_ansi_enabled:
+                        result_exp = _divnull(
+                            snowpark_args[0], snowpark_args[1].cast(result_type)
+                        )
+                    else:
+                        result_exp = _divnull(
+                            snowpark_args[0], snowpark_args[1].try_cast(result_type)
+                        )
+                case (_NumericType(), NullType()) | (NullType(), _NumericType()):
+                    result_type = DoubleType()
+                    result_exp = snowpark_fn.lit(None)
+                case (_NumericType(), _NumericType()):
+                    result_type = DoubleType()
+                    result_exp = _divnull(
+                        snowpark_args[0].cast(result_type),
+                        snowpark_args[1].cast(result_type),
+                    )
+                case _:
+                    raise AnalysisException(
+                        f'[DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES] Cannot resolve "{spark_function_name}" due to data type mismatch: the left and right operands of the binary operator have incompatible types ("{snowpark_typed_args[0].typ}" and "{snowpark_typed_args[1].typ}").'
+                    )
         case "~":
             result_exp = TypedColumn(
                 snowpark_fn.bitnot(snowpark_args[0]),
@@ -1765,9 +2006,11 @@ def map_unresolved_function(
                     snowpark_args[1], snowpark_args[2], snowpark_args[0]
                 )
             else:
+                spark_function_name = f"convert_timezone(current_timezone(), {', '.join(snowpark_arg_names)})"
                 result_exp = snowpark_fn.convert_timezone(*snowpark_args)
 
-            result_exp = TypedColumn(result_exp, lambda: [TimestampType()])
+            result_type = TimestampType(TimestampTimeZone.NTZ)
+            result_exp = result_exp.cast(result_type)
 
         case "corr":
             col1_type = snowpark_typed_args[0].typ
@@ -2055,11 +2298,8 @@ def map_unresolved_function(
             result_exp = TypedColumn(snowpark_fn.current_date(), lambda: [DateType()])
             spark_function_name = "current_date()"
         case "current_timestamp" | "now":
-            result_exp = snowpark_fn.cast(
-                snowpark_fn.current_timestamp(),
-                get_timestamp_type(),
-            )
-            result_exp = TypedColumn(result_exp, lambda: [get_timestamp_type()])
+            result_type = TimestampType(TimestampTimeZone.LTZ)
+            result_exp = snowpark_fn.to_timestamp_ltz(snowpark_fn.current_timestamp())
         case "current_timezone":
             result_exp = snowpark_fn.lit(global_config.spark_sql_session_timeZone)
             result_type = StringType()
@@ -2650,7 +2890,7 @@ def map_unresolved_function(
                 return results
 
             spark_function_name = f"from_csv({snowpark_arg_names[0]})"
-            ddl_schema = parse_ddl_string(snowpark_arg_names[1], True)
+            result_type = map_type_string_to_snowpark_type(snowpark_arg_names[1])
 
             if len(snowpark_arg_names) > 2 and snowpark_arg_names[2].startswith(
                 "named_struct"
@@ -2675,8 +2915,7 @@ def map_unresolved_function(
 
             result_exp = snowpark_fn.when(
                 snowpark_args[0].is_null(), snowpark_fn.lit(None)
-            ).otherwise(snowpark_fn.cast(csv_result, ddl_schema))
-            result_type = ddl_schema
+            ).otherwise(snowpark_fn.cast(csv_result, result_type))
         case "from_json":
             # TODO: support options.
             if len(snowpark_args) > 2:
@@ -2903,21 +3142,15 @@ def map_unresolved_function(
                     )
             result_type = StringType()
         case "from_utc_timestamp":
-
-            @cached_udf(
-                input_types=[StringType()],
-                return_type=StringType(),
-            )
-            def map_from_spark_tz(tz):
-                return SPARK_TZ_ABBREVIATIONS_OVERRIDES.get(tz, tz)
-
-            target_tz = map_from_spark_tz(snowpark_args[1])
+            target_tz = _map_from_spark_tz(snowpark_args[1])
             result_exp = _try_to_cast(
                 "try_to_timestamp",
-                snowpark_fn.from_utc_timestamp(snowpark_args[0], target_tz),
+                snowpark_fn.from_utc_timestamp(snowpark_args[0], target_tz).cast(
+                    TimestampType()
+                ),
                 snowpark_args[0],
             )
-            result_type = TimestampType(TimestampTimeZone.NTZ)
+            result_type = TimestampType()
         case "get":
             if exp.unresolved_function.arguments[1].HasField("literal"):
                 index = unwrap_literal(exp.unresolved_function.arguments[1])
@@ -3823,8 +4056,10 @@ def map_unresolved_function(
             ).otherwise(snowpark_fn.ln(snowpark_args[0]))
             result_type = DoubleType()
         case "localtimestamp":
-            result_exp = snowpark_fn.builtin("localtimestamp")()
-            result_type = TimestampType(TimestampTimeZone.LTZ)
+            result_type = TimestampType(TimestampTimeZone.NTZ)
+            result_exp = snowpark_fn.to_timestamp_ntz(
+                snowpark_fn.builtin("localtimestamp")()
+            )
         case "locate":
             substr = unwrap_literal(exp.unresolved_function.arguments[0])
             value = snowpark_args[1]
@@ -3999,7 +4234,7 @@ def map_unresolved_function(
             match function_name:
                 case "make_timestamp":
                     make_function_name = "timestamp_tz_from_parts"
-                    result_type = TimestampType()
+                    result_type = get_timestamp_type()
                 case "make_timestamp_ltz":
                     make_function_name = "timestamp_ltz_from_parts"
                     result_type = TimestampType(TimestampTimeZone.LTZ)
@@ -6552,15 +6787,22 @@ def map_unresolved_function(
         case "timestamp_add":
             # Added to DataFrame functions in 4.0.0 - but can be called from SQL in 3.5.3.
             spark_function_name = f"timestampadd({snowpark_arg_names[0]}, {snowpark_arg_names[1]}, {snowpark_arg_names[2]})"
+
+            typ = snowpark_typed_args[2].typ
+            result_type = (
+                typ
+                if isinstance(typ, TimestampType)
+                else TimestampType(snowpark.types.TimestampTimeZone.LTZ)
+            )
+
             result_exp = snowpark_fn.cast(
                 snowpark_fn.dateadd(
                     unwrap_literal(exp.unresolved_function.arguments[0]),
                     snowpark_args[1],
                     snowpark_args[2],
                 ),
-                TimestampType(snowpark.types.TimestampTimeZone.NTZ),
+                result_type,
             )
-            result_type = TimestampType(snowpark.types.TimestampTimeZone.NTZ)
         case "timestamp_diff":
             # Added to DataFrame functions in 4.0.0 - but can be called from SQL in 3.5.3.
             spark_function_name = f"timestampdiff({snowpark_arg_names[0]}, {snowpark_arg_names[1]}, {snowpark_arg_names[2]})"
@@ -6573,9 +6815,9 @@ def map_unresolved_function(
         case "timestamp_micros":
             result_exp = snowpark_fn.cast(
                 snowpark_fn.to_timestamp(snowpark_args[0], 6),
-                TimestampType(snowpark.types.TimestampTimeZone.NTZ),
+                TimestampType(snowpark.types.TimestampTimeZone.LTZ),
             )
-            result_type = TimestampType(snowpark.types.TimestampTimeZone.NTZ)
+            result_type = TimestampType(snowpark.types.TimestampTimeZone.LTZ)
         case "timestamp_millis":
             if not isinstance(snowpark_typed_args[0].typ, _IntegralType):
                 raise AnalysisException(
@@ -6583,9 +6825,9 @@ def map_unresolved_function(
                 )
             result_exp = snowpark_fn.cast(
                 snowpark_fn.to_timestamp(snowpark_args[0] * 1_000, 6),
-                TimestampType(snowpark.types.TimestampTimeZone.NTZ),
+                TimestampType(snowpark.types.TimestampTimeZone.LTZ),
             )
-            result_type = TimestampType(snowpark.types.TimestampTimeZone.NTZ)
+            result_type = TimestampType(snowpark.types.TimestampTimeZone.LTZ)
         case "timestamp_seconds":
             # Spark allows seconds to be fractional. Snowflake does not allow that
             # even though the documentation explicitly says that it does.
@@ -6598,9 +6840,9 @@ def map_unresolved_function(
                 snowpark_fn.to_timestamp(
                     snowpark_fn.cast(snowpark_args[0] * 1_000_000, LongType()), 6
                 ),
-                TimestampType(snowpark.types.TimestampTimeZone.NTZ),
+                TimestampType(snowpark.types.TimestampTimeZone.LTZ),
             )
-            result_type = TimestampType(snowpark.types.TimestampTimeZone.NTZ)
+            result_type = TimestampType(snowpark.types.TimestampTimeZone.LTZ)
         case "to_char" | "to_varchar":
             # The structure of the Spark format string must match: [MI|S] [$] [0|9|G|,]* [.|D] [0|9]* [$] [PR|MI|S]
             # Note the grammar above was retrieved from an error message from PySpark, but it is not entirely accurate.
@@ -6746,20 +6988,29 @@ def map_unresolved_function(
                 for typed_arg in snowpark_typed_args
             ]
 
+            timezone_conf = global_config.get("spark.sql.session.timeZone")
+
+            # Objects do not preserve keys order in Snowflake, so we need to pass them in the array
+            # Not all the types are preserved in Snowflake Object, timestamps and dates are converted to strings
+            # to properly format them types have to be passed as argument
             @cached_udf(
-                input_types=[VariantType(), VariantType()],
+                input_types=[VariantType(), ArrayType(), ArrayType(), VariantType()],
                 return_type=StringType(),
+                packages=["jpype1"],
             )
-            def _to_csv(col: dict, options: Optional[dict]) -> str:
-                sep = ","
+            def _to_csv(
+                col: dict, keys: list, types: list, options: Optional[dict]
+            ) -> str:
+                import datetime
+
+                import jpype
+
                 if options is not None:
                     if not isinstance(options, dict):
                         raise TypeError(
                             "[INVALID_OPTIONS.NON_MAP_FUNCTION] Invalid options: Must use the `map()` function for options."
                         )
 
-                    sep = options.get("sep") or sep
-
                     python_to_snowflake_type = {
                         "str": "STRING",
                         "bool": "BOOLEAN",
@@ -6779,22 +7030,166 @@ def map_unresolved_function(
                                 f'[INVALID_OPTIONS.NON_STRING_TYPE] Invalid options: A type of keys and values in `map()` must be string, but got "MAP<{k_type}, {v_type}>".'
                             )
 
+                options = options or {}
+                lowercased_options = {
+                    key.lower(): value for key, value in options.items()
+                }
+
+                sep = lowercased_options.get("sep") or (
+                    lowercased_options.get("delimiter") or ","
+                )
+                quote = lowercased_options.get("quote") or '"'
+                quote_all = lowercased_options.get("quoteall", "false")
+                escape = lowercased_options.get("escape") or "\\"
+
+                ignore_leading_white_space = lowercased_options.get(
+                    "ignoreleadingwhitespace", "true"
+                )
+                ignore_trailing_white_space = lowercased_options.get(
+                    "ignoretrailingwhitespace", "true"
+                )
+                null_value = lowercased_options.get("nullvalue") or ""
+                empty_value = lowercased_options.get("emptyvalue") or '""'
+                char_to_escape_quote_escaping = (
+                    lowercased_options.get("chartoescapequoteescaping") or escape
+                )
+
+                date_format = lowercased_options.get("dateformat") or "yyyy-MM-dd"
+                timestamp_format = (
+                    lowercased_options.get("timestampformat")
+                    or "yyyy-MM-dd'T'HH:mm:ss[.SSS][XXX]"
+                )
+                timestamp_NTZ_format = (
+                    lowercased_options.get("timestampntzformat")
+                    or "yyyy-MM-dd'T'HH:mm:ss[.SSS]"
+                )
+
+                def to_boolean(value: str) -> bool:
+                    return value.lower() == "true"
+
+                quote_all = to_boolean(quote_all)
+                ignore_leading_white_space = to_boolean(ignore_leading_white_space)
+                ignore_trailing_white_space = to_boolean(ignore_trailing_white_space)
+
+                def escape_str(value: str) -> str:
+                    escape_quote = escape + quote if escape != quote else escape
+                    return (
+                        value.replace(escape, char_to_escape_quote_escaping + escape)
+                        .replace(quote, escape_quote)
+                        .replace("\r", "\\r")
+                    )
+
+                def escape_and_quote_string(value) -> str:
+                    if quote_all:
+                        return f"{quote}{escape_str(str(value))}{quote}"
+                    return str(value)
+
+                time_types = ("date", "timestamp", "timestamp_ntz")
+                maps_timestamps = any(
+                    python_type in time_types for python_type in types
+                )
+
+                # Multiple execution of the UDF are done within the same process, that's why we need to check if the JVM was not already started
+                if maps_timestamps and not jpype.isJVMStarted():
+                    jpype.startJVM()
+
+                if maps_timestamps:
+                    ZonedDateTime = jpype.JClass("java.time.ZonedDateTime")
+                    ZoneId = jpype.JClass("java.time.ZoneId")
+                    DateTimeFormatter = jpype.JClass(
+                        "java.time.format.DateTimeFormatter"
+                    )
+                    Instant = jpype.JClass("java.time.Instant")
+                    LocalDate = jpype.JClass("java.time.LocalDate")
+                    LocalDateTime = jpype.JClass("java.time.LocalDateTime")
+                    timestamp_formatter = DateTimeFormatter.ofPattern(timestamp_format)
+                    timestamp_ntz_formatter = DateTimeFormatter.ofPattern(
+                        timestamp_NTZ_format
+                    )
+                    date_formatter = DateTimeFormatter.ofPattern(date_format)
+
                 result = []
-                for _, value in col.items():
+                for key, python_type in zip(keys, types):
+                    value = col.get(key)
                     if value is None:
-                        result.append("")
+                        result.append(escape_and_quote_string(null_value))
+                    elif python_type in ("date", "timestamp", "timestamp_ntz"):
+                        match python_type:
+                            case "date":
+                                value = datetime.datetime.strptime(value, "%Y-%m-%d")
+                                local_date = LocalDate.of(
+                                    value.year, value.month, value.day
+                                )
+                                formatted_date = date_formatter.format(local_date)
+                                result.append(escape_and_quote_string(formatted_date))
+                            case "timestamp":
+                                try:
+                                    value = datetime.datetime.strptime(
+                                        value, "%Y-%m-%d %H:%M:%S.%f %z"
+                                    )
+                                except ValueError:
+                                    # Fallback to the format without microseconds
+                                    value = datetime.datetime.strptime(
+                                        value, "%Y-%m-%d %H:%M:%S %z"
+                                    )
+                                instant = Instant.ofEpochMilli(
+                                    int(value.timestamp() * 1000)
+                                )
+                                zdt = ZonedDateTime.ofInstant(
+                                    instant, ZoneId.of(timezone_conf)
+                                )
+                                str_value = timestamp_formatter.format(zdt)
+                                result.append(escape_and_quote_string(str_value))
+                            case "timestamp_ntz":
+                                try:
+                                    value = datetime.datetime.strptime(
+                                        value, "%Y-%m-%d %H:%M:%S.%f"
+                                    )
+                                except ValueError:
+                                    # Fallback to the format without microseconds
+                                    value = datetime.datetime.strptime(
+                                        value, "%Y-%m-%d %H:%M:%S"
+                                    )
+                                timestamp_ntz = LocalDateTime.of(
+                                    value.year,
+                                    value.month,
+                                    value.day,
+                                    value.hour,
+                                    value.minute,
+                                    value.second,
+                                    value.microsecond * 1000,
+                                )
+                                str_value = timestamp_ntz_formatter.format(
+                                    timestamp_ntz
+                                )
+                                result.append(escape_and_quote_string(str_value))
+                            case _:
+                                raise ValueError(
+                                    f"Unable to determine type for value: {python_type}"
+                                )
                     elif isinstance(value, str):
-                        if value == "" or any(
-                            c in value for c in [",", "\n", "\r", '"', "'"]
+                        strip_value = (
+                            value.lstrip() if ignore_leading_white_space else value
+                        )
+                        strip_value = (
+                            strip_value.rstrip()
+                            if ignore_trailing_white_space
+                            else strip_value
+                        )
+                        if strip_value == "":
+                            result.append(escape_and_quote_string(empty_value))
+                        elif (
+                            any(c in value for c in (sep, "\r", "\n", quote))
+                            or quote_all
                         ):
-                            value = value.replace("\\", "\\\\").replace('"', '\\"')
-                            result.append(f'"{value}"')
+                            strip_value = escape_str(strip_value)
+                            result.append(quote + strip_value + quote)
                         else:
-                            result.append(value)
+                            result.append(escape_and_quote_string(strip_value))
                     elif isinstance(value, bool):
-                        result.append(str(value).lower())
+                        result.append(escape_and_quote_string(str(value).lower()))
                     else:
-                        result.append(str(value))
+                        result.append(escape_and_quote_string(str(value)))
 
                 return sep.join(result)
 
@@ -6807,11 +7202,36 @@ def map_unresolved_function(
                     "[INVALID_OPTIONS.NON_MAP_FUNCTION] Invalid options: Must use the `map()` function for options."
                 )
 
+            def get_snowpark_type_name(snowpark_type: DataType) -> str:
+                return (
+                    (
+                        "timestamp"
+                        if not snowpark_type.tz == snowpark.types.TimestampTimeZone.NTZ
+                        else "timestamp_ntz"
+                    )
+                    if snowpark_type == TimestampType()
+                    else snowpark_type.type_name().lower()
+                )
+
+            field_names = snowpark_fn.array_construct(
+                *[
+                    snowpark_fn.lit(value)
+                    for value in snowpark_typed_args[0].typ.fieldNames
+                ]
+            )
+            field_types = snowpark_fn.array_construct(
+                *[
+                    snowpark_fn.lit(get_snowpark_type_name(value.datatype))
+                    for value in snowpark_typed_args[0].typ.fields
+                ]
+            )
             match snowpark_args:
                 case [csv_data]:
-                    result_exp = _to_csv(csv_data, snowpark_fn.lit(None))
+                    result_exp = _to_csv(
+                        csv_data, field_names, field_types, snowpark_fn.lit(None)
+                    )
                 case [csv_data, options]:
-                    result_exp = _to_csv(csv_data, options)
+                    result_exp = _to_csv(csv_data, field_names, field_types, options)
                 case _:
                     raise ValueError("Unrecognized from_csv parameters")
             result_type = StringType()
@@ -6912,10 +7332,8 @@ def map_unresolved_function(
                     )
                 case _:
                     raise ValueError(f"Invalid number of arguments to {function_name}")
-            result_exp = snowpark_fn.cast(
-                result_exp, TimestampType(snowpark.types.TimestampTimeZone.NTZ)
-            )
-            result_type = TimestampType()
+            result_exp = snowpark_fn.cast(result_exp, get_timestamp_type())
+            result_type = get_timestamp_type()
 
         case "to_timestamp_ltz":
             match (snowpark_typed_args, exp.unresolved_function.arguments):
@@ -6941,7 +7359,12 @@ def map_unresolved_function(
             match (snowpark_typed_args, exp.unresolved_function.arguments):
                 case ([e], _):
                     result_exp = snowpark_fn.builtin("to_timestamp_ntz")(e.col)
-                case ([e, _], _) if type(e.typ) in (DateType, TimestampType):
+                case ([e, _], _) if isinstance(e.typ, DateType):
+                    result_exp = snowpark_fn.convert_timezone(
+                        snowpark_fn.lit("UTC"),
+                        snowpark_fn.builtin("to_timestamp_ntz")(e.col),
+                    )
+                case ([e, _], _) if isinstance(e.typ, TimestampType):
                     result_exp = snowpark_fn.builtin("to_timestamp_ntz")(e.col)
                 case ([e, _], [_, fmt]):
                     result_exp = snowpark_fn.builtin("to_timestamp_ntz")(
@@ -7002,25 +7425,17 @@ def map_unresolved_function(
             result_type = LongType()
 
         case "to_utc_timestamp":
-
-            @cached_udf(
-                input_types=[StringType()],
-                return_type=StringType(),
-            )
-            def map_timezone(short_tz: str) -> str:
-                return SPARK_TZ_ABBREVIATIONS_OVERRIDES.get(short_tz, short_tz)
-
+            result_type = TimestampType()
             result_exp = _try_to_cast(
                 "try_to_timestamp",
                 snowpark_fn.cast(
                     snowpark_fn.to_utc_timestamp(
-                        snowpark_args[0], map_timezone(snowpark_args[1])
+                        snowpark_args[0], _map_from_spark_tz(snowpark_args[1])
                     ),
-                    TimestampType(snowpark.types.TimestampTimeZone.NTZ),
+                    result_type,
                 ),
                 snowpark_args[0],
             )
-            result_type = TimestampType(snowpark.types.TimestampTimeZone.NTZ)
         case "translate":
             src_alphabet = unwrap_literal(exp.unresolved_function.arguments[1])
             target_alphabet = unwrap_literal(exp.unresolved_function.arguments[2])
@@ -7413,8 +7828,8 @@ def map_unresolved_function(
                     )
                 case _:
                     raise ValueError(f"Invalid number of arguments to {function_name}")
-            result_exp = snowpark_fn.cast(result_exp, TimestampType())
-            result_type = TimestampType()
+            result_type = get_timestamp_type()
+            result_exp = snowpark_fn.cast(result_exp, result_type)
         case "typeof":
             col_snowpark_typ = snowpark_typed_args[0].typ
             spark_typ = map_snowpark_to_pyspark_types(col_snowpark_typ)
@@ -7684,14 +8099,10 @@ def map_unresolved_function(
                     result_exp = result_exp.when(snowpark_args[i], snowpark_args[i + 1])
                     result_type_indexes.append(i + 1)
             name_components.append("END")
-            result_exp = TypedColumn(
-                result_exp,
-                lambda: [
-                    _find_common_type(
-                        [snowpark_typed_args[i].typ for i in result_type_indexes]
-                    )
-                ],
+            result_type = _find_common_type(
+                [snowpark_typed_args[i].typ for i in result_type_indexes]
             )
+            result_exp = snowpark_fn.cast(result_exp, result_type)
             spark_function_name = " ".join(name_components)
         case "width_bucket":
             width_bucket_fn = snowpark_fn.function("width_bucket")
@@ -7965,6 +8376,18 @@ def map_unresolved_function(
     return spark_col_names, typed_col
 
 
+def _cast_helper(column: Column, to: DataType) -> Column:
+    if global_config.spark_sql_ansi_enabled:
+        column_mediator = (
+            snowpark_fn.cast(column, StringType())
+            if isinstance(to, DecimalType)
+            else column
+        )
+        return snowpark_fn.cast(column_mediator, to)
+    else:
+        return _try_cast_helper(column, to)
+
+
 def _try_cast_helper(column: Column, to: DataType) -> Column:
     """
     Attempts to cast a given column to a specified data type using the same behaviour as Spark.
@@ -9119,7 +9542,7 @@ def _get_type_precision(typ: DataType) -> tuple[int, int]:
         case LongType():
             return 20, 0  # -9223372036854775808 to 9223372036854775807
         case NullType():
-            return 6, 2  # NULL
+            return 0, 0  # NULL
         case _:
             return 38, 0  # Default to maximum precision for other types
 
@@ -9162,58 +9585,70 @@ def _decimal_add_sub_result_type_helper(p1, s1, p2, s2):
     return result_precision, min_scale, return_type_precision, return_type_scale
 
 
-def _decimal_multiply_result_type_helper(p1, s1, p2, s2):
-    result_precision = p1 + p2 + 1
-    result_scale = s1 + s2
-    return_type_precision, return_type_scale = result_precision, result_scale
-
-    if result_precision <= 38:
-        return result_precision, result_scale, return_type_precision, return_type_scale
+def _get_decimal_multiplication_result_exp(
+    result_type: DecimalType | DataType,
+    other_type: DataType,
+    snowpark_args: list[Column],
+) -> Column:
+    if global_config.spark_sql_ansi_enabled:
+        result_exp = snowpark_args[0] * snowpark_args[1]
     else:
-        return_type_precision = 38
-
-    min_scale = 6
-    while result_scale > min_scale:
-        result_scale -= 1
-        return_type_scale = result_scale
-        result_precision = (p1 - s1) + (p2 - s2) + result_scale + 1
-        if result_precision <= 38:
-            return (
-                result_precision,
-                result_scale,
-                return_type_precision,
-                return_type_scale,
+        if isinstance(other_type, _IntegralType):
+            result_exp = snowpark_args[0].cast(result_type) * snowpark_args[1].cast(
+                result_type
             )
-
-    result_precision = (p1 - s1) + (p2 - s2) + min_scale + 1
-    return result_precision, min_scale, return_type_precision, return_type_scale
+        else:
+            result_exp = snowpark_args[0].cast(DoubleType()) * snowpark_args[1].cast(
+                DoubleType()
+            )
+        result_exp = _try_cast_helper(result_exp, result_type)
+    return result_exp
 
 
-def _decimal_divide_result_type_helper(p1, s1, p2, s2):
-    result_scale = max(6, s1 + p2 + 1)
-    result_precision = p1 - s1 + s2 + result_scale
-    return_type_precision, return_type_scale = result_precision, result_scale
-
-    if result_precision <= 38:
-        return result_precision, result_scale, return_type_precision, return_type_scale
+def _get_decimal_multiplication_result_type(p1, s1, p2, s2) -> DecimalType:
+    result_precision = p1 + p2 + 1
+    result_scale = s1 + s2
+    if result_precision > 38:
+        if result_scale > 6:
+            overflow = result_precision - 38
+            result_scale = max(6, result_scale - overflow)
+        result_precision = 38
+    return DecimalType(result_precision, result_scale)
+
+
+def _get_decimal_division_result_exp(
+    result_type: DecimalType | DataType,
+    other_type: DataType,
+    overflow_detected: bool,
+    snowpark_args: list[Column],
+    spark_function_name: str,
+) -> Column:
+    if isinstance(other_type, DecimalType) and overflow_detected:
+        if global_config.spark_sql_ansi_enabled:
+            raise ArithmeticException(
+                f'[NUMERIC_VALUE_OUT_OF_RANGE] {spark_function_name} cannot be represented as Decimal({result_type.precision}, {result_type.scale}). If necessary set "spark.sql.ansi.enabled" to "false" to bypass this error, and return NULL instead.'
+            )
+        else:
+            result_exp = snowpark_fn.lit(None).cast(result_type)
     else:
-        return_type_precision = 38
+        dividend = snowpark_args[0].cast(DoubleType())
+        divisor = snowpark_args[1]
+        result_exp = _divnull(dividend, divisor)
+        result_exp = _cast_helper(result_exp, result_type)
+    return result_exp
 
-    min_scale = 6
-    while result_scale > min_scale:
-        result_scale -= 1
-        return_type_scale = result_scale
-        result_precision = p1 - s1 + s2 + result_scale
-        if result_precision <= 38:
-            return (
-                result_precision,
-                result_scale,
-                return_type_precision,
-                return_type_scale,
-            )
 
-    result_precision = p1 - s1 + s2 + min_scale
-    return result_precision, min_scale, return_type_precision, return_type_scale
+def _get_decimal_division_result_type(p1, s1, p2, s2) -> tuple[DecimalType, bool]:
+    overflow_detected = False
+    result_scale = max(6, s1 + p2 + 1)
+    result_precision = p1 - s1 + s2 + result_scale
+    if result_precision > 38:
+        if result_precision > 40:
+            overflow_detected = True
+        overflow = result_precision - 38
+        result_scale = max(6, result_scale - overflow)
+        result_precision = 38
+    return DecimalType(result_precision, result_scale), overflow_detected
 
 
 def _try_arithmetic_helper(
@@ -9408,102 +9843,108 @@ def _try_arithmetic_helper(
             return snowpark_fn.lit(None)
 
 
-def _add_sub_precision_helper(
-    typed_args: List[TypedColumn], snowpark_args: List[Column], operation_type: int
-) -> tuple[Column, tuple[int, int]]:
-    p1, s1 = _get_type_precision(typed_args[0].typ)
-    p2, s2 = _get_type_precision(typed_args[1].typ)
-
-    if isinstance(typed_args[0].typ, _IntegralType) and isinstance(
-        typed_args[1].typ, DecimalType
-    ):
-        new_scale = s2
-        new_precision = max(p2, p1 + s2)
-        return_type_precision, return_type_scale = new_precision, new_scale
-    elif isinstance(typed_args[0].typ, DecimalType) and isinstance(
-        typed_args[1].typ, _IntegralType
-    ):
-        new_scale = s1
-        new_precision = max(p1, p2 + s1)
-        return_type_precision, return_type_scale = new_precision, new_scale
-    else:
-        (
-            new_precision,
-            new_scale,
-            return_type_precision,
-            return_type_scale,
-        ) = _decimal_add_sub_result_type_helper(p1, s1, p2, s2)
-
-    if new_precision > 38:
-        if global_config.spark_sql_ansi_enabled:
-            raise ArithmeticException(
-                f'[NUMERIC_VALUE_OUT_OF_RANGE] Precision {new_precision} exceeds maximum allowed precision of 38. If necessary set "spark.sql.ansi.enabled" to "false" to bypass this error, and return NULL instead.'
+def _get_add_sub_result_type(
+    type1: DataType,
+    type2: DataType,
+    spark_function_name: str,
+) -> DataType:
+    result_type = _find_common_type([type1, type2])
+    match result_type:
+        case DecimalType():
+            p1, s1 = _get_type_precision(type1)
+            p2, s2 = _get_type_precision(type2)
+            result_scale = max(s1, s2)
+            result_precision = max(p1 - s1, p2 - s2) + result_scale + 1
+            if result_precision > 38:
+                if result_scale > 6:
+                    overflow = result_precision - 38
+                    result_scale = max(6, result_scale - overflow)
+                result_precision = 38
+            result_type = DecimalType(result_precision, result_scale)
+        case NullType():
+            result_type = DoubleType()
+        case StringType():
+            match (type1, type2):
+                case (_FractionalType(), _) | (_, _FractionalType()):
+                    result_type = DoubleType()
+                case (_IntegralType(), _) | (_, _IntegralType()):
+                    result_type = (
+                        LongType()
+                        if global_config.spark_sql_ansi_enabled
+                        else DoubleType()
+                    )
+                case _:
+                    if global_config.spark_sql_ansi_enabled:
+                        raise AnalysisException(
+                            f'[DATATYPE_MISMATCH.BINARY_OP_WRONG_TYPE] Cannot resolve "{spark_function_name}" due to data type mismatch: the binary operator requires the input type ("NUMERIC" or "INTERVAL DAY TO SECOND" or "INTERVAL YEAR TO MONTH" or "INTERVAL"), not "STRING".',
+                        )
+                    else:
+                        result_type = DoubleType()
+        case BooleanType():
+            raise AnalysisException(
+                f'[DATATYPE_MISMATCH.BINARY_OP_WRONG_TYPE] Cannot resolve "{spark_function_name}" due to data type mismatch: the binary operator requires the input type ("NUMERIC" or "INTERVAL DAY TO SECOND" or "INTERVAL YEAR TO MONTH" or "INTERVAL"), not "BOOLEAN".',
             )
-        return snowpark_fn.lit(None), (return_type_precision, return_type_scale)
+    return result_type
 
-    left_operand, right_operand = snowpark_args[0], snowpark_args[1]
 
-    result = (
-        left_operand + right_operand
-        if operation_type == 0
-        else left_operand - right_operand
-    )
-    return snowpark_fn.cast(result, DecimalType(new_precision, new_scale)), (
-        return_type_precision,
-        return_type_scale,
-    )
+def _get_spark_function_name(
+    col1: TypedColumn,
+    col2: TypedColumn,
+    snowpark_arg_names: list[str],
+    exp: expressions_proto.Expression,
+    default_spark_function_name: str,
+    function_name: str,
+):
+    operation_op = function_name
+    match function_name:
+        case "+":
+            operation_func = "date_add"
+        case "-":
+            operation_func = "date_sub"
+        case _:
+            return default_spark_function_name
+    match (col1.typ, col2.typ):
+        case (DateType(), DateType()):
+            date_param_name1 = _get_literal_param_name(exp, 0, snowpark_arg_names[0])
+            date_param_name2 = _get_literal_param_name(exp, 1, snowpark_arg_names[1])
+            return f"({date_param_name1} {operation_op} {date_param_name2})"
+        case (StringType(), DateType()):
+            date_param_name2 = _get_literal_param_name(exp, 1, snowpark_arg_names[1])
+            if "INTERVAL" == col1.col._expr1.pretty_name:
+                return f"{date_param_name2} {operation_op} {snowpark_arg_names[0]}"
+            elif global_config.spark_sql_ansi_enabled and function_name == "+":
+                return f"{operation_func}(cast({date_param_name2} as date), cast({snowpark_arg_names[0]} as double))"
+            else:
+                return f"({snowpark_arg_names[0]} {operation_op} {date_param_name2})"
+        case (DateType(), StringType()):
+            date_param_name1 = _get_literal_param_name(exp, 0, snowpark_arg_names[0])
+            if (
+                global_config.spark_sql_ansi_enabled
+                or "INTERVAL" == col2.col._expr1.pretty_name
+            ):
+                return f"{date_param_name1} {operation_op} {snowpark_arg_names[1]}"
+            else:
+                return f"{operation_func}(cast({date_param_name1} as date), cast({snowpark_arg_names[1]} as double))"
+        case (DateType() as dt, _) | (_, DateType() as dt):
+            date_param_index = 0 if dt == col1.typ else 1
+            date_param_name = _get_literal_param_name(
+                exp, date_param_index, snowpark_arg_names[date_param_index]
+            )
+            return f"{operation_func}({date_param_name}, {snowpark_arg_names[1 - date_param_index]})"
+        case _:
+            return default_spark_function_name
 
 
-def _mul_div_precision_helper(
-    typed_args: List[TypedColumn], snowpark_args: List[Column], operation_type: int
-) -> Column:
-    p1, s1 = _get_type_precision(typed_args[0].typ)
-    p2, s2 = _get_type_precision(typed_args[1].typ)
-    if operation_type == 0:  # multiplication
-        (
-            new_precision,
-            new_scale,
-            return_type_precision,
-            return_type_scale,
-        ) = _decimal_multiply_result_type_helper(p1, s1, p2, s2)
-    else:  # division
-        (
-            new_precision,
-            new_scale,
-            return_type_precision,
-            return_type_scale,
-        ) = _decimal_divide_result_type_helper(p1, s1, p2, s2)
-
-    if isinstance(typed_args[0].typ, DecimalType) and isinstance(
-        typed_args[1].typ, DecimalType
-    ):
-        # Overflow check for both decimal types
-        if new_precision > 38:
-            if global_config.spark_sql_ansi_enabled:
-                raise ArithmeticException(
-                    f'[NUMERIC_VALUE_OUT_OF_RANGE] Precision {new_precision} exceeds maximum allowed precision of 38. If necessary set "spark.sql.ansi.enabled" to "false" to bypass this error, and return NULL instead.'
-                )
-            return snowpark_fn.lit(None), (return_type_precision, return_type_scale)
-
-    # Overflow check if one operand is an Integral
-    if new_precision > 38:
-        if global_config.spark_sql_ansi_enabled:
-            raise ArithmeticException(
-                f'[NUMERIC_VALUE_OUT_OF_RANGE] Precision {new_precision} exceeds maximum allowed precision of 38. If necessary set "spark.sql.ansi.enabled" to "false" to bypass this error, and return NULL instead.'
-            )
-        new_precision = 38
-    if new_scale > new_precision:
-        new_scale = new_precision
-
-    left_operand, right_operand = snowpark_args[0], snowpark_args[1]
-    if operation_type == 0:  # multiplication
-        result = left_operand * right_operand
-    else:  # division
-        result = _divnull(left_operand, right_operand)
-    return snowpark_fn.cast(result, DecimalType(new_precision, new_scale)), (
-        return_type_precision,
-        return_type_scale,
-    )
+def _get_literal_param_name(exp, arg_index: int, default_param_name: str):
+    try:
+        date_param_name = (
+            exp.unresolved_function.arguments[arg_index]
+            .unresolved_function.arguments[0]
+            .literal.string
+        )
+    except (IndexError, AttributeError):
+        date_param_name = default_param_name
+    return date_param_name
 
 
 def _raise_error_helper(return_type: DataType, error_class=None):
@@ -9818,3 +10259,34 @@ def _trim_helper(value: Column, trim_value: Column, trim_type: Column) -> Column
         return value
 
     return _binary_trim_udf(value, trim_value, trim_type)
+
+
+def _map_from_spark_tz(value: Column) -> Column:
+    return (
+        snowpark_fn.when(value == "ACT", snowpark_fn.lit("Australia/Darwin"))
+        .when(value == "AET", snowpark_fn.lit("Australia/Sydney"))
+        .when(value == "AGT", snowpark_fn.lit("America/Argentina/Buenos_Aires"))
+        .when(value == "ART", snowpark_fn.lit("Africa/Cairo"))
+        .when(value == "AST", snowpark_fn.lit("America/Anchorage"))
+        .when(value == "BET", snowpark_fn.lit("America/Sao_Paulo"))
+        .when(value == "BST", snowpark_fn.lit("Asia/Dhaka"))
+        .when(value == "CAT", snowpark_fn.lit("Africa/Harare"))
+        .when(value == "CNT", snowpark_fn.lit("America/St_Johns"))
+        .when(value == "CST", snowpark_fn.lit("America/Chicago"))
+        .when(value == "CTT", snowpark_fn.lit("Asia/Shanghai"))
+        .when(value == "EAT", snowpark_fn.lit("Africa/Addis_Ababa"))
+        .when(value == "ECT", snowpark_fn.lit("Europe/Paris"))
+        .when(value == "IET", snowpark_fn.lit("America/Indiana/Indianapolis"))
+        .when(value == "IST", snowpark_fn.lit("Asia/Kolkata"))
+        .when(value == "JST", snowpark_fn.lit("Asia/Tokyo"))
+        .when(value == "MIT", snowpark_fn.lit("Pacific/Apia"))
+        .when(value == "NET", snowpark_fn.lit("Asia/Yerevan"))
+        .when(value == "NST", snowpark_fn.lit("Pacific/Auckland"))
+        .when(value == "PLT", snowpark_fn.lit("Asia/Karachi"))
+        .when(value == "PNT", snowpark_fn.lit("America/Phoenix"))
+        .when(value == "PRT", snowpark_fn.lit("America/Puerto_Rico"))
+        .when(value == "PST", snowpark_fn.lit("America/Los_Angeles"))
+        .when(value == "SST", snowpark_fn.lit("Pacific/Guadalcanal"))
+        .when(value == "VST", snowpark_fn.lit("Asia/Ho_Chi_Minh"))
+        .otherwise(value)  # Return original timezone if no mapping found
+    )