snowpark-connect 0.30.1__py3-none-any.whl → 0.32.0__py3-none-any.whl

snowflake/snowpark_connect/expression/map_unresolved_function.py

@@ -20,7 +20,7 @@ from contextlib import suppress
 from decimal import ROUND_HALF_EVEN, ROUND_HALF_UP, Context, Decimal
 from functools import partial, reduce
 from pathlib import Path
-from typing import List, Optional, Union
+from typing import List, Optional
 from urllib.parse import quote, unquote
 
 import pyspark.sql.connect.proto.expressions_pb2 as expressions_proto
@@ -66,6 +66,7 @@ from snowflake.snowpark.types import (
     TimestampType,
     VariantType,
     YearMonthIntervalType,
+    _AnsiIntervalType,
     _FractionalType,
     _IntegralType,
     _NumericType,
@@ -74,6 +75,7 @@ from snowflake.snowpark_connect.column_name_handler import (
     ColumnNameMap,
     set_schema_getter,
 )
+from snowflake.snowpark_connect.column_qualifier import ColumnQualifier
 from snowflake.snowpark_connect.config import (
     get_boolean_session_config_param,
     get_timestamp_type,
@@ -83,6 +85,8 @@ from snowflake.snowpark_connect.constants import (
     DUPLICATE_KEY_FOUND_ERROR_TEMPLATE,
     STRUCTURED_TYPES_ENABLED,
 )
+from snowflake.snowpark_connect.error.error_codes import ErrorCodes
+from snowflake.snowpark_connect.error.error_utils import attach_custom_error_code
 from snowflake.snowpark_connect.expression.function_defaults import (
     inject_function_defaults,
 )
@@ -146,7 +150,11 @@ from snowflake.snowpark_connect.utils.xxhash64 import (
 MAX_UINT64 = 2**64 - 1
 MAX_INT64 = 2**63 - 1
 MIN_INT64 = -(2**63)
-MAX_ARRAY_SIZE = 2_147_483_647
+MAX_32BIT_SIGNED_INT = 2_147_483_647
+
+# Interval arithmetic precision limits
+MAX_DAY_TIME_DAYS = 106751991  # Maximum days for day-time intervals
+MAX_10_DIGIT_LIMIT = 1000000000  # 10-digit limit (1 billion) for interval operands
 
 NAN, INFINITY = float("nan"), float("inf")
 
@@ -188,7 +196,9 @@ def _validate_numeric_args(
         TypeError: If arguments cannot be converted to numeric types
     """
     if len(typed_args) < 2:
-        raise ValueError(f"{function_name} requires at least 2 arguments")
+        exception = ValueError(f"{function_name} requires at least 2 arguments")
+        attach_custom_error_code(exception, ErrorCodes.INVALID_FUNCTION_ARGUMENT)
+        raise exception
 
     modified_args = list(snowpark_args)
 
@@ -204,9 +214,11 @@ def _validate_numeric_args(
                 # https://github.com/apache/spark/blob/master/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/analysis/TypeCoercion.scala#L204
                 modified_args[i] = snowpark_fn.try_cast(snowpark_args[i], DoubleType())
             case _:
-                raise TypeError(
+                exception = TypeError(
                     f"Data type mismatch: {function_name} requires numeric types, but got {typed_args[0].typ} and {typed_args[1].typ}."
                 )
+                attach_custom_error_code(exception, ErrorCodes.TYPE_MISMATCH)
+                raise exception
 
     return modified_args
 
@@ -266,6 +278,40 @@ def _coerce_for_comparison(
         return left_col, right_col
 
 
+def _preprocess_not_equals_expression(exp: expressions_proto.Expression) -> str:
+    """
+    Transform NOT(col1 = col2) expressions to col1 != col2 for Snowflake compatibility.
+
+    Snowflake has issues with NOT (col1 = col2) in subqueries, so we rewrite
+    not(==(a, b)) to a != b by modifying the protobuf expression early.
+
+    Returns:
+        The (potentially modified) function name as a lowercase string.
+    """
+    function_name = exp.unresolved_function.function_name.lower()
+
+    # Snowflake has issues with NOT (col1 = col2) in subqueries.
+    # Transform not(==(a, b)) to a!=b by modifying the protobuf early.
+    if (
+        function_name in ("not", "!")
+        and len(exp.unresolved_function.arguments) == 1
+        and exp.unresolved_function.arguments[0].WhichOneof("expr_type")
+        == "unresolved_function"
+        and exp.unresolved_function.arguments[0].unresolved_function.function_name
+        == "=="
+    ):
+        inner_eq_func = exp.unresolved_function.arguments[0].unresolved_function
+        inner_args = list(inner_eq_func.arguments)
+
+        exp.unresolved_function.function_name = "!="
+        exp.unresolved_function.ClearField("arguments")
+        exp.unresolved_function.arguments.extend(inner_args)
+
+        function_name = "!="
+
+    return function_name
+
+
 def map_unresolved_function(
     exp: expressions_proto.Expression,
     column_mapping: ColumnNameMap,
@@ -294,6 +340,9 @@ def map_unresolved_function(
     # Inject default parameters for functions that need them (especially for Scala clients)
     inject_function_defaults(exp.unresolved_function)
 
+    # Transform NOT(col = col) to col != col for Snowflake compatibility
+    function_name = _preprocess_not_equals_expression(exp)
+
     def _resolve_args_expressions(exp: expressions_proto.Expression):
         def _resolve_fn_arg(exp):
             with resolving_fun_args():
@@ -349,7 +398,7 @@ def map_unresolved_function(
     function_name = exp.unresolved_function.function_name.lower()
     telemetry.report_function_usage(function_name)
     result_type: Optional[DataType | List[DateType]] = None
-    qualifiers: List[str] = []
+    qualifier_parts: List[str] = []
 
     pyspark_func = getattr(pyspark_functions, function_name, None)
     if pyspark_func and pyspark_func.__doc__.lstrip().startswith("Aggregate function:"):
@@ -407,9 +456,11 @@ def map_unresolved_function(
                 expected_arity = str(valid_arity)
 
         if invalid:
-            raise AnalysisException(
+            exception = AnalysisException(
                 f"[WRONG_NUM_ARGS.WITHOUT_SUGGESTION] The `{function_name}` requires {expected_arity} parameters but the actual number is {arity}."
             )
+            attach_custom_error_code(exception, ErrorCodes.INVALID_FUNCTION_ARGUMENT)
+            raise exception
 
     def _like_util(column, patterns, mode, negate=False):
         """
@@ -422,9 +473,13 @@ def map_unresolved_function(
         :return: A Snowpark condition.
         """
         if len(patterns) == 0:
-            raise ParseException("Expected something between '(' and ')'")
+            exception = ParseException("Expected something between '(' and ')'")
+            attach_custom_error_code(exception, ErrorCodes.INVALID_SQL_SYNTAX)
+            raise exception
         if mode not in ["any", "all"]:
-            raise ValueError("Mode must be 'any' or 'all'.")
+            exception = ValueError("Mode must be 'any' or 'all'.")
+            attach_custom_error_code(exception, ErrorCodes.INVALID_FUNCTION_ARGUMENT)
+            raise exception
 
         if mode == "any":
             condition = snowpark_fn.lit(False)
@@ -446,9 +501,13 @@ def map_unresolved_function(
     def _check_percentile_percentage(exp: expressions_proto.Expression) -> Column:
         perc = unwrap_literal(exp)
         if perc is None:
-            raise AnalysisException("The percentage must not be null.")
+            exception = AnalysisException("The percentage must not be null.")
+            attach_custom_error_code(exception, ErrorCodes.INVALID_INPUT)
+            raise exception
         if not 0.0 <= perc <= 1.0:
-            raise AnalysisException("The percentage must be between [0.0, 1.0].")
+            exception = AnalysisException("The percentage must be between [0.0, 1.0].")
+            attach_custom_error_code(exception, ErrorCodes.INVALID_INPUT)
+            raise exception
         return snowpark_fn.lit(perc)
 
     def _handle_structured_aggregate_result(
@@ -497,9 +556,17 @@ def map_unresolved_function(
             )
             result_type = [f.datatype for f in udtf.output_schema]
         case "!=":
-            result_exp = TypedColumn(
-                snowpark_args[0] != snowpark_args[1], lambda: [BooleanType()]
+            _check_interval_string_comparison(
+                "!=", snowpark_typed_args, snowpark_arg_names
+            )
+            # Make the function name same as spark connect. a != b translate's to not(a=b)
+            spark_function_name = (
+                f"(NOT ({snowpark_arg_names[0]} = {snowpark_arg_names[1]}))"
+            )
+            left, right = _coerce_for_comparison(
+                snowpark_typed_args[0], snowpark_typed_args[1]
             )
+            result_exp = TypedColumn(left != right, lambda: [BooleanType()])
         case "%" | "mod":
             if spark_sql_ansi_enabled:
                 result_exp = snowpark_args[0] % snowpark_args[1]
@@ -548,9 +615,11 @@ def map_unresolved_function(
                     result_exp = snowpark_fn.lit(None)
                 case (StringType(), StringType()):
                     if spark_sql_ansi_enabled:
-                        raise AnalysisException(
+                        exception = 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".'
                         )
+                        attach_custom_error_code(exception, ErrorCodes.TYPE_MISMATCH)
+                        raise exception
                     else:
                         result_type = DoubleType()
                         result_exp = snowpark_args[0].try_cast(
@@ -598,12 +667,87 @@ def map_unresolved_function(
                         result_exp = snowpark_args[0] * snowpark_args[1].try_cast(
                             result_type
                         )
-                case (_NumericType() as t, NullType()) | (
-                    NullType(),
-                    _NumericType() as t,
+                case (StringType(), t) | (t, StringType()) if isinstance(
+                    t, _AnsiIntervalType
+                ):
+                    if isinstance(snowpark_typed_args[0].typ, StringType):
+                        result_type = type(
+                            t
+                        )()  # YearMonthIntervalType() or DayTimeIntervalType()
+                        result_exp = snowpark_args[1] * snowpark_args[0].try_cast(
+                            LongType()
+                        )
+                        spark_function_name = (
+                            f"({snowpark_arg_names[1]} * {snowpark_arg_names[0]})"
+                        )
+                    else:
+                        result_type = type(
+                            t
+                        )()  # YearMonthIntervalType() or DayTimeIntervalType()
+                        result_exp = snowpark_args[0] * snowpark_args[1].try_cast(
+                            LongType()
+                        )
+                        spark_function_name = (
+                            f"({snowpark_arg_names[0]} * {snowpark_arg_names[1]})"
+                        )
+                case (
+                    (_NumericType() as t, NullType())
+                    | (NullType(), _NumericType() as t)
                 ):
                     result_type = t
                     result_exp = snowpark_fn.lit(None)
+                case (NullType(), t) | (t, NullType()) if isinstance(
+                    t, _AnsiIntervalType
+                ):
+                    result_type = (
+                        YearMonthIntervalType()
+                        if isinstance(t, YearMonthIntervalType)
+                        else DayTimeIntervalType()
+                    )
+                    result_exp = snowpark_fn.lit(None)
+                    if isinstance(snowpark_typed_args[0].typ, NullType):
+                        spark_function_name = (
+                            f"({snowpark_arg_names[1]} * {snowpark_arg_names[0]})"
+                        )
+                    else:
+                        spark_function_name = (
+                            f"({snowpark_arg_names[0]} * {snowpark_arg_names[1]})"
+                        )
+                case (DecimalType(), t) | (t, DecimalType()) if isinstance(
+                    t, _AnsiIntervalType
+                ):
+                    result_type = (
+                        YearMonthIntervalType()
+                        if isinstance(t, YearMonthIntervalType)
+                        else DayTimeIntervalType()
+                    )
+                    if isinstance(snowpark_typed_args[0].typ, DecimalType):
+                        result_exp = snowpark_args[1] * snowpark_args[0]
+                        spark_function_name = (
+                            f"({snowpark_arg_names[1]} * {snowpark_arg_names[0]})"
+                        )
+                    else:
+                        result_exp = snowpark_args[0] * snowpark_args[1]
+                        spark_function_name = (
+                            f"({snowpark_arg_names[0]} * {snowpark_arg_names[1]})"
+                        )
+                case (t, _NumericType()) if isinstance(t, _AnsiIntervalType):
+                    result_type = (
+                        YearMonthIntervalType()
+                        if isinstance(t, YearMonthIntervalType)
+                        else DayTimeIntervalType()
+                    )
+                    result_exp = snowpark_args[0] * snowpark_args[1]
+                case (_NumericType(), t) if isinstance(t, _AnsiIntervalType):
+                    result_type = (
+                        YearMonthIntervalType()
+                        if isinstance(t, YearMonthIntervalType)
+                        else DayTimeIntervalType()
+                    )
+                    result_exp = snowpark_args[1] * snowpark_args[0]
+                    spark_function_name = (
+                        f"({snowpark_arg_names[1]} * {snowpark_arg_names[0]})"
+                    )
                 case (_NumericType(), _NumericType()):
                     result_type = _find_common_type(
                         [arg.typ for arg in snowpark_typed_args]
@@ -612,9 +756,11 @@ def map_unresolved_function(
                         1
                     ].cast(result_type)
                 case _:
-                    raise AnalysisException(
+                    exception = 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}").'
                     )
+                    attach_custom_error_code(exception, ErrorCodes.TYPE_MISMATCH)
+                    raise exception
         case "+":
             spark_function_name = _get_spark_function_name(
                 snowpark_typed_args[0],
@@ -642,7 +788,14 @@ def map_unresolved_function(
                         result_type = DateType()
                         result_exp = snowpark_args[0] + snowpark_args[1]
                     elif isinstance(t, (DayTimeIntervalType, YearMonthIntervalType)):
-                        result_type = TimestampType()
+                        result_type = (
+                            TimestampType()
+                            if isinstance(
+                                snowpark_typed_args[t_param_index].typ,
+                                DayTimeIntervalType,
+                            )
+                            else DateType()
+                        )
                         result_exp = (
                             snowpark_args[date_param_index]
                             + snowpark_args[t_param_index]
@@ -660,14 +813,47 @@ def map_unresolved_function(
                             + snowpark_args[t_param_index]
                         )
                     else:
-                        raise AnalysisException(
+                        exception = 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}".',
                         )
+                        attach_custom_error_code(exception, ErrorCodes.TYPE_MISMATCH)
+                        raise exception
+                case (TimestampType(), t) | (t, TimestampType()):
+                    timestamp_param_index = (
+                        0
+                        if isinstance(snowpark_typed_args[0].typ, TimestampType)
+                        else 1
+                    )
+                    t_param_index = 1 - timestamp_param_index
+                    if isinstance(t, (DayTimeIntervalType, YearMonthIntervalType)):
+                        result_type = TimestampType()
+                        result_exp = (
+                            snowpark_args[timestamp_param_index]
+                            + snowpark_args[t_param_index]
+                        )
+                    elif (
+                        hasattr(
+                            snowpark_typed_args[t_param_index].col._expr1, "pretty_name"
+                        )
+                        and "INTERVAL"
+                        == snowpark_typed_args[t_param_index].col._expr1.pretty_name
+                    ):
+                        result_type = TimestampType()
+                        result_exp = (
+                            snowpark_args[timestamp_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 ("INTERVAL") type for timestamp operations, however "{snowpark_arg_names[t_param_index]}" has the type "{t}".',
+                        )
                 case (StringType(), StringType()):
                     if spark_sql_ansi_enabled:
-                        raise AnalysisException(
+                        exception = 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".'
                         )
+                        attach_custom_error_code(exception, ErrorCodes.TYPE_MISMATCH)
+                        raise exception
                     else:
                         result_type = DoubleType()
                         result_exp = snowpark_fn.try_cast(
@@ -707,9 +893,91 @@ def map_unresolved_function(
                 case (DecimalType(), t) | (t, DecimalType()) if isinstance(
                     t, (BinaryType, TimestampType)
                 ):
-                    raise AnalysisException(
+                    exception = 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}").'
                     )
+                    attach_custom_error_code(exception, ErrorCodes.TYPE_MISMATCH)
+                    raise exception
+                case (t1, t2) | (t2, t1) if isinstance(
+                    t1, _AnsiIntervalType
+                ) and isinstance(t2, _AnsiIntervalType) and type(t1) == type(t2):
+                    # Both operands are the same interval type
+                    result_type = type(t1)(
+                        min(t1.start_field, t2.start_field),
+                        max(t1.end_field, t2.end_field),
+                    )
+                    result_exp = snowpark_args[0] + snowpark_args[1]
+                case (StringType(), t) | (t, StringType()) if isinstance(
+                    t, YearMonthIntervalType
+                ):
+                    # String + YearMonthInterval: Spark tries to cast string to double first, throws error if it fails
+                    result_type = StringType()
+                    if isinstance(snowpark_typed_args[0].typ, StringType):
+                        result_exp = (
+                            snowpark_fn.cast(snowpark_args[0], "double")
+                            + snowpark_args[1]
+                        )
+                    else:
+                        result_exp = snowpark_args[0] + snowpark_fn.cast(
+                            snowpark_args[1], "double"
+                        )
+                case (StringType(), t) | (t, StringType()) if isinstance(
+                    t, DayTimeIntervalType
+                ):
+                    # String + DayTimeInterval: try to parse string as timestamp, return NULL if it fails
+                    # For time-only strings (like '10:00:00'), prepend current date to make it a full timestamp
+                    result_type = StringType()
+                    if isinstance(snowpark_typed_args[0].typ, StringType):
+                        # Check if string looks like time-only (HH:MM:SS or HH:MM pattern)
+                        # If so, prepend current date; otherwise use as-is
+                        time_only_pattern = snowpark_fn.function("regexp_like")(
+                            snowpark_args[0], r"^\d{1,2}:\d{2}(:\d{2})?$"
+                        )
+                        timestamp_expr = snowpark_fn.when(
+                            time_only_pattern,
+                            snowpark_fn.function("try_to_timestamp_ntz")(
+                                snowpark_fn.function("concat")(
+                                    snowpark_fn.function("to_char")(
+                                        snowpark_fn.function("current_date")(),
+                                        "YYYY-MM-DD",
+                                    ),
+                                    snowpark_fn.lit(" "),
+                                    snowpark_args[0],
+                                )
+                            ),
+                        ).otherwise(
+                            snowpark_fn.function("try_to_timestamp_ntz")(
+                                snowpark_args[0]
+                            )
+                        )
+                        result_exp = timestamp_expr + snowpark_args[1]
+                    else:
+                        # interval + string case
+                        time_only_pattern = snowpark_fn.function("regexp_like")(
+                            snowpark_args[1], r"^\d{1,2}:\d{2}(:\d{2})?$"
+                        )
+                        timestamp_expr = snowpark_fn.when(
+                            time_only_pattern,
+                            snowpark_fn.function("try_to_timestamp_ntz")(
+                                snowpark_fn.function("concat")(
+                                    snowpark_fn.function("to_char")(
+                                        snowpark_fn.function("current_date")(),
+                                        "'YYYY-MM-DD'",
+                                    ),
+                                    snowpark_fn.lit(" "),
+                                    snowpark_args[1],
+                                )
+                            ),
+                        ).otherwise(
+                            snowpark_fn.function("try_to_timestamp_ntz")(
+                                snowpark_args[1]
+                            )
+                        )
+                        result_exp = snowpark_args[0] + timestamp_expr
+                    spark_function_name = (
+                        f"{snowpark_arg_names[0]} + {snowpark_arg_names[1]}"
+                    )
+
                 case _:
                     result_type, overflow_possible = _get_add_sub_result_type(
                         snowpark_typed_args[0].typ,
@@ -755,7 +1023,11 @@ def map_unresolved_function(
                     DateType(),
                     YearMonthIntervalType(),
                 ):
-                    result_type = TimestampType()
+                    result_type = (
+                        TimestampType()
+                        if isinstance(snowpark_typed_args[1].typ, DayTimeIntervalType)
+                        else DateType()
+                    )
                     result_exp = snowpark_args[0] - snowpark_args[1]
                 case (DateType(), StringType()):
                     if (
@@ -773,6 +1045,23 @@ def map_unresolved_function(
                         result_exp = snowpark_args[0] - snowpark_args[1].cast(
                             input_type
                         )
+                case (TimestampType(), DayTimeIntervalType()) | (
+                    TimestampType(),
+                    YearMonthIntervalType(),
+                ):
+                    result_type = TimestampType()
+                    result_exp = snowpark_args[0] - snowpark_args[1]
+                case (TimestampType(), StringType()):
+                    if (
+                        hasattr(snowpark_typed_args[1].col._expr1, "pretty_name")
+                        and "INTERVAL" == snowpark_typed_args[1].col._expr1.pretty_name
+                    ):
+                        result_type = TimestampType()
+                        result_exp = snowpark_args[0] - snowpark_args[1]
+                    else:
+                        raise AnalysisException(
+                            f'[DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE] Cannot resolve "{spark_function_name}" due to data type mismatch: Parameter 2 requires the ("INTERVAL") type for timestamp operations, however "{snowpark_arg_names[1]}" has the type "{snowpark_typed_args[1].typ}".',
+                        )
                 case (StringType(), DateType()):
                     # TODO SNOW-2034420: resolve return type (it should be INTERVAL DAY)
                     result_type = LongType()
@@ -782,18 +1071,24 @@ def map_unresolved_function(
                     result_type = DateType()
                     result_exp = snowpark_args[0] - snowpark_args[1]
                 case (DateType(), _):
-                    raise AnalysisException(
+                    exception = 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}".',
                     )
+                    attach_custom_error_code(exception, ErrorCodes.TYPE_MISMATCH)
+                    raise exception
                 case (_, DateType()):
-                    raise AnalysisException(
+                    exception = 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}".',
                     )
+                    attach_custom_error_code(exception, ErrorCodes.TYPE_MISMATCH)
+                    raise exception
                 case (StringType(), StringType()):
                     if spark_sql_ansi_enabled:
-                        raise AnalysisException(
+                        exception = 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".'
                         )
+                        attach_custom_error_code(exception, ErrorCodes.TYPE_MISMATCH)
+                        raise exception
                     else:
                         result_type = DoubleType()
                         result_exp = snowpark_fn.try_cast(
@@ -833,9 +1128,21 @@ def map_unresolved_function(
                 case (DecimalType(), t) | (t, DecimalType()) if isinstance(
                     t, (BinaryType, TimestampType)
                 ):
-                    raise AnalysisException(
+                    exception = 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}").'
                     )
+                    attach_custom_error_code(exception, ErrorCodes.TYPE_MISMATCH)
+                    raise exception
+                case (StringType(), t) if isinstance(t, _AnsiIntervalType):
+                    # String - Interval: try to parse string as timestamp, return NULL if it fails
+                    result_type = StringType()
+                    result_exp = (
+                        snowpark_fn.function("try_to_timestamp")(snowpark_args[0])
+                        - snowpark_args[1]
+                    )
+                    spark_function_name = (
+                        f"{snowpark_arg_names[0]} - {snowpark_arg_names[1]}"
+                    )
                 case _:
                     result_type, overflow_possible = _get_add_sub_result_type(
                         snowpark_typed_args[0].typ,
@@ -879,9 +1186,11 @@ def map_unresolved_function(
                     result_exp = snowpark_fn.lit(None)
                 case (StringType(), StringType()):
                     if spark_sql_ansi_enabled:
-                        raise AnalysisException(
+                        exception = 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".'
                         )
+                        attach_custom_error_code(exception, ErrorCodes.TYPE_MISMATCH)
+                        raise exception
                     else:
                         result_type = DoubleType()
                         result_exp = _divnull(
@@ -932,9 +1241,57 @@ def map_unresolved_function(
                         result_exp = _divnull(
                             snowpark_args[0], snowpark_args[1].try_cast(result_type)
                         )
+                case (t, StringType()) if isinstance(t, _AnsiIntervalType):
+                    result_type = (
+                        YearMonthIntervalType()
+                        if isinstance(t, YearMonthIntervalType)
+                        else DayTimeIntervalType()
+                    )
+                    result_exp = snowpark_args[0] / snowpark_args[1].try_cast(
+                        LongType()
+                    )
+                    spark_function_name = (
+                        f"({snowpark_arg_names[0]} / {snowpark_arg_names[1]})"
+                    )
                 case (_NumericType(), NullType()) | (NullType(), _NumericType()):
                     result_type = DoubleType()
                     result_exp = snowpark_fn.lit(None)
+                case (t, NullType()) if isinstance(t, _AnsiIntervalType):
+                    # Only allow interval / null, not null / interval
+                    result_type = (
+                        YearMonthIntervalType()
+                        if isinstance(t, YearMonthIntervalType)
+                        else DayTimeIntervalType()
+                    )
+                    result_exp = snowpark_fn.lit(None)
+                    spark_function_name = (
+                        f"({snowpark_arg_names[0]} / {snowpark_arg_names[1]})"
+                    )
+                case (DecimalType(), t) | (t, DecimalType()) if isinstance(
+                    t, _AnsiIntervalType
+                ):
+                    result_type = (
+                        YearMonthIntervalType()
+                        if isinstance(t, YearMonthIntervalType)
+                        else DayTimeIntervalType()
+                    )
+                    if isinstance(snowpark_typed_args[0].typ, DecimalType):
+                        result_exp = snowpark_args[1] / snowpark_args[0]
+                        spark_function_name = (
+                            f"({snowpark_arg_names[1]} / {snowpark_arg_names[0]})"
+                        )
+                    else:
+                        result_exp = snowpark_args[0] / snowpark_args[1]
+                        spark_function_name = (
+                            f"({snowpark_arg_names[0]} / {snowpark_arg_names[1]})"
+                        )
+                case (t, _NumericType()) if isinstance(t, _AnsiIntervalType):
+                    result_type = (
+                        YearMonthIntervalType()
+                        if isinstance(t, YearMonthIntervalType)
+                        else DayTimeIntervalType()
+                    )
+                    result_exp = snowpark_args[0] / snowpark_args[1]
                 case (_NumericType(), _NumericType()):
                     result_type = DoubleType()
                     result_exp = _divnull(
@@ -942,9 +1299,11 @@ def map_unresolved_function(
                         snowpark_args[1].cast(result_type),
                     )
                 case _:
-                    raise AnalysisException(
+                    exception = 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}").'
                     )
+                    attach_custom_error_code(exception, ErrorCodes.TYPE_MISMATCH)
+                    raise exception
         case "~":
             result_exp = TypedColumn(
                 snowpark_fn.bitnot(snowpark_args[0]),
@@ -958,9 +1317,11 @@ def map_unresolved_function(
                 or isinstance(snowpark_typed_args[0].typ, BooleanType)
                 and isinstance(snowpark_typed_args[1].typ, DecimalType)
             ):
-                raise AnalysisException(
+                exception = 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}").;'
                 )
+                attach_custom_error_code(exception, ErrorCodes.TYPE_MISMATCH)
+                raise exception
             # Check for interval-string comparisons
             _check_interval_string_comparison(
                 "<", snowpark_typed_args, snowpark_arg_names
@@ -976,9 +1337,11 @@ def map_unresolved_function(
                 or isinstance(snowpark_typed_args[0].typ, BooleanType)
                 and isinstance(snowpark_typed_args[1].typ, DecimalType)
             ):
-                raise AnalysisException(
+                exception = 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}").;'
                 )
+                attach_custom_error_code(exception, ErrorCodes.TYPE_MISMATCH)
+                raise exception
             # Check for interval-string comparisons
             _check_interval_string_comparison(
                 "<=", snowpark_typed_args, snowpark_arg_names
@@ -1017,9 +1380,11 @@ def map_unresolved_function(
                 or isinstance(snowpark_typed_args[0].typ, BooleanType)
                 and isinstance(snowpark_typed_args[1].typ, DecimalType)
             ):
-                raise AnalysisException(
+                exception = 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}").;'
                 )
+                attach_custom_error_code(exception, ErrorCodes.TYPE_MISMATCH)
+                raise exception
             # Check for interval-string comparisons
             _check_interval_string_comparison(
                 ">", snowpark_typed_args, snowpark_arg_names
@@ -1035,9 +1400,11 @@ def map_unresolved_function(
                 or isinstance(snowpark_typed_args[0].typ, BooleanType)
                 and isinstance(snowpark_typed_args[1].typ, DecimalType)
             ):
-                raise AnalysisException(
+                exception = 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}").;'
                 )
+                attach_custom_error_code(exception, ErrorCodes.TYPE_MISMATCH)
+                raise exception
             # Check for interval-string comparisons
             _check_interval_string_comparison(
                 ">=", snowpark_typed_args, snowpark_arg_names
@@ -1134,9 +1501,11 @@ def map_unresolved_function(
             )
         case "any":
             if not isinstance(snowpark_typed_args[0].typ, (BooleanType, NullType)):
-                raise AnalysisException(
+                exception = AnalysisException(
                     f'[DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE] Cannot resolve "{spark_function_name}" due to data type mismatch: Parameter 1 requires the "BOOLEAN" type, however "{snowpark_arg_names[0]}" has the type "{snowpark_typed_args[0].typ.simpleString().upper()}".'
                 )
+                attach_custom_error_code(exception, ErrorCodes.TYPE_MISMATCH)
+                raise exception
             result_exp = TypedColumn(
                 snowpark_fn.max(snowpark_args[0]),
                 lambda: [BooleanType()],
@@ -1151,9 +1520,13 @@ def map_unresolved_function(
                 case [col]:
                     result_exp = snowpark_fn.any_value(col)
                 case _:
-                    raise ValueError(
+                    exception = ValueError(
                         f"Unexpected number of args for function any_value. Expected 1 or 2, received {len(snowpark_args)}"
                     )
+                    attach_custom_error_code(
+                        exception, ErrorCodes.INVALID_FUNCTION_ARGUMENT
+                    )
+                    raise exception
 
             spark_function_name = f"any_value({snowpark_arg_names[0]})"
             result_exp = _type_with_typer(result_exp)
@@ -1165,9 +1538,13 @@ def map_unresolved_function(
                         lambda: [LongType()],
                     )
                 case [_, _]:
-                    raise SnowparkConnectNotImplementedError(
+                    exception = SnowparkConnectNotImplementedError(
                         "'rsd' parameter is not supported"
                     )
+                    attach_custom_error_code(
+                        exception, ErrorCodes.UNSUPPORTED_OPERATION
+                    )
+                    raise exception
         case "approx_percentile" | "percentile_approx":
             # SNOW-1955784: Support accuracy parameter
             # Use percentile_disc to return actual values from dataset (matches PySpark behavior)
@@ -1184,7 +1561,11 @@ def map_unresolved_function(
                 # Even though the Spark function accepts a Column for percentage, it will fail unless it's a literal.
                 # Therefore, we can do error checking right here.
                 if not 0.0 <= percentage <= 1.0:
-                    raise AnalysisException("percentage must be between [0.0, 1.0]")
+                    exception = AnalysisException(
+                        "percentage must be between [0.0, 1.0]"
+                    )
+                    attach_custom_error_code(exception, ErrorCodes.INVALID_INPUT)
+                    raise exception
 
                 result = snowpark_fn.function("percentile_disc")(
                     snowpark_fn.lit(percentage)
@@ -1251,9 +1632,11 @@ def map_unresolved_function(
         case "array_contains":
             array_type = snowpark_typed_args[0].typ
             if not isinstance(array_type, ArrayType):
-                raise AnalysisException(
+                exception = AnalysisException(
                     f"Expected argument '{snowpark_arg_names[0]}' to have an ArrayType."
                 )
+                attach_custom_error_code(exception, ErrorCodes.TYPE_MISMATCH)
+                raise exception
 
             def _compatible_types(type1: DataType, type2: DataType) -> bool:
                 if type1 == type2:
@@ -1273,9 +1656,11 @@ def map_unresolved_function(
             if not _compatible_types(
                 array_type.element_type, snowpark_typed_args[1].typ
             ):
-                raise AnalysisException(
+                exception = AnalysisException(
                     '[DATATYPE_MISMATCH.ARRAY_FUNCTION_DIFF_TYPES] Cannot resolve "array_contains(arr, val)" due to data type mismatch: Input to `array_contains` should have been "ARRAY" followed by a value with same element type'
                 )
+                attach_custom_error_code(exception, ErrorCodes.TYPE_MISMATCH)
+                raise exception
             value = (
                 snowpark_fn.cast(snowpark_args[1], array_type.element_type)
                 if array_type.structured
@@ -1345,7 +1730,13 @@ def map_unresolved_function(
                     )
                     result_exp = snowpark_fn.array_to_string(data, delimiter)
                 case _:
-                    raise ValueError(f"Invalid number of arguments to {function_name}")
+                    exception = ValueError(
+                        f"Invalid number of arguments to {function_name}"
+                    )
+                    attach_custom_error_code(
+                        exception, ErrorCodes.INVALID_FUNCTION_ARGUMENT
+                    )
+                    raise exception
             result_exp = TypedColumn(result_exp, lambda: [StringType()])
         case "array_max":
             result_exp = TypedColumn(
@@ -1437,9 +1828,11 @@ def map_unresolved_function(
         case "array_size":
             array_type = snowpark_typed_args[0].typ
             if not isinstance(array_type, ArrayType):
-                raise AnalysisException(
+                exception = AnalysisException(
                     f"Expected argument '{snowpark_arg_names[0]}' to have an ArrayType."
                 )
+                attach_custom_error_code(exception, ErrorCodes.TYPE_MISMATCH)
+                raise exception
             result_exp = TypedColumn(
                 snowpark_fn.array_size(*snowpark_args), lambda: [LongType()]
             )
@@ -1450,9 +1843,11 @@ def map_unresolved_function(
                     snowpark_fn.size(*snowpark_args), lambda: [LongType()]
                 )
             else:
-                raise AnalysisException(
+                exception = AnalysisException(
                     f"Expected argument '{snowpark_arg_names[0]}' to have an ArrayType or MapType, but got {arg_type.simpleString()}."
                 )
+                attach_custom_error_code(exception, ErrorCodes.TYPE_MISMATCH)
+                raise exception
         case "array_sort":
             result_exp = TypedColumn(
                 snowpark_fn.array_sort(*snowpark_args),
@@ -1538,9 +1933,13 @@ def map_unresolved_function(
                         expr, snowpark_fn.lit(None)
                     ).otherwise(raise_error(snowpark_fn.cast(message, StringType())))
                 case _:
-                    raise AnalysisException(
+                    exception = AnalysisException(
                         f"[WRONG_NUM_ARGS.WITHOUT_SUGGESTION] The `assert_true` requires 1 or 2 parameters but the actual number is {len(snowpark_args)}."
                     )
+                    attach_custom_error_code(
+                        exception, ErrorCodes.INVALID_FUNCTION_ARGUMENT
+                    )
+                    raise exception
         case "atan":
             spark_function_name = f"ATAN({snowpark_arg_names[0]})"
             result_exp = TypedColumn(
@@ -1578,9 +1977,11 @@ def map_unresolved_function(
             # Validate that input is StringType or BinaryType
             input_type = snowpark_typed_args[0].typ
             if not isinstance(input_type, (StringType, BinaryType)):
-                raise AnalysisException(
+                exception = AnalysisException(
                     f'[DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE] Cannot resolve "base64({snowpark_arg_names[0]})" due to data type mismatch: Parameter 1 requires the "BINARY" type, however "{snowpark_arg_names[0]}" has the type "{input_type.simpleString().upper()}".'
                 )
+                attach_custom_error_code(exception, ErrorCodes.TYPE_MISMATCH)
+                raise exception
 
             base64_encoding_function = snowpark_fn.function("base64_encode")
             result_exp = TypedColumn(
@@ -1613,9 +2014,11 @@ def map_unresolved_function(
             if not isinstance(
                 snowpark_typed_args[0].typ, (_IntegralType, BooleanType, NullType)
             ):
-                raise AnalysisException(
+                exception = AnalysisException(
                     f'[DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE] Cannot resolve "{spark_function_name}" due to data type mismatch: Parameter 1 requires the ("INTEGRAL" or "BOOLEAN") type, however "{snowpark_arg_names[0]}" has the type "{snowpark_typed_args[0].typ.simpleString().upper()}"'
                 )
+                attach_custom_error_code(exception, ErrorCodes.TYPE_MISMATCH)
+                raise exception
 
             @cached_udf(
                 input_types=[VariantType()],
@@ -1780,9 +2183,11 @@ def map_unresolved_function(
             result_type = BinaryType()
         case "bool_and" | "every":
             if not isinstance(snowpark_typed_args[0].typ, (BooleanType, NullType)):
-                raise AnalysisException(
+                exception = AnalysisException(
                     f'[DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE] Cannot resolve "{spark_function_name}" due to data type mismatch: Parameter 1 requires the \'BOOLEAN\' type, however "{snowpark_arg_names[0]}" has the type "{snowpark_typed_args[0].typ.simpleString().upper()}".'
                 )
+                attach_custom_error_code(exception, ErrorCodes.TYPE_MISMATCH)
+                raise exception
             bool_and_agg_function = snowpark_fn.function("booland_agg")
             result_exp = TypedColumn(
                 bool_and_agg_function(*snowpark_args), lambda: [BooleanType()]
@@ -1790,9 +2195,11 @@ def map_unresolved_function(
 
         case "bool_or" | "some":
             if not isinstance(snowpark_typed_args[0].typ, (BooleanType, NullType)):
-                raise AnalysisException(
+                exception = AnalysisException(
                     f'[DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE] Cannot resolve "{spark_function_name}" due to data type mismatch: Parameter 1 requires the "BOOLEAN" type, however "{snowpark_arg_names[0]}" has the type "{snowpark_typed_args[0].typ.simpleString().upper()}".'
                 )
+                attach_custom_error_code(exception, ErrorCodes.TYPE_MISMATCH)
+                raise exception
             bool_or_agg_function = snowpark_fn.function("boolor_agg")
             result_exp = TypedColumn(
                 bool_or_agg_function(*snowpark_args), lambda: [BooleanType()]
@@ -1825,9 +2232,11 @@ def map_unresolved_function(
                     ),
                     snowpark_typed_args[0].typ,
                 ):
-                    raise ArithmeticException(
+                    exception = ArithmeticException(
                         '[ARITHMETIC_OVERFLOW] Overflow. If necessary set "spark.sql.ansi.enabled" to "false" to bypass this error.'
                     )
+                    attach_custom_error_code(exception, ErrorCodes.ARITHMETIC_ERROR)
+                    raise exception
 
             match snowpark_typed_args[0].typ:
                 case DecimalType():
@@ -1892,9 +2301,11 @@ def map_unresolved_function(
                 if not isinstance(
                     snowpark_typed_args[1].typ, IntegerType
                 ) and not isinstance(snowpark_typed_args[1].typ, LongType):
-                    raise AnalysisException(
+                    exception = AnalysisException(
                         f"The 'scale' parameter of function '{function_name}' needs to be a int literal."
                     )
+                    attach_custom_error_code(exception, ErrorCodes.INVALID_INPUT)
+                    raise exception
                 spark_function_name = (
                     f"{fn_name}({snowpark_arg_names[0]}, {snowpark_arg_names[1]})"
                 )
@@ -1911,9 +2322,13 @@ def map_unresolved_function(
                 else:
                     result_exp = TypedColumn(result_exp, lambda: [result_type])
             else:
-                raise AnalysisException(
+                exception = AnalysisException(
                     f"[WRONG_NUM_ARGS.WITHOUT_SUGGESTION] The `{function_name}` requires 2 parameters but the actual number is {len(snowpark_args)}."
                 )
+                attach_custom_error_code(
+                    exception, ErrorCodes.INVALID_FUNCTION_ARGUMENT
+                )
+                raise exception
         case "chr" | "char":
             result_exp = snowpark_fn.when(
                 (snowpark_args[0] > 256), snowpark_fn.char(snowpark_args[0] % 256)
@@ -1933,11 +2348,6 @@ def map_unresolved_function(
                     result_exp = snowpark_fn.coalesce(
                         *[col.cast(result_type) for col in snowpark_args]
                     )
-        case "col":
-            # TODO: assign type
-            result_exp = snowpark_fn.col(*snowpark_args)
-            result_exp = _type_with_typer(result_exp)
-            qualifiers = snowpark_args[0].get_qualifiers()
         case "collect_list" | "array_agg":
             # TODO: SNOW-1967177 - Support structured types in array_agg
             result_exp = snowpark_fn.array_agg(
@@ -1949,20 +2359,12 @@ def map_unresolved_function(
             spark_function_name = f"collect_list({snowpark_arg_names[0]})"
         case "collect_set":
             # Convert to a semi-structured type. TODO SNOW-1953065 - Support structured types in array_unique_agg.
-            result_exp = snowpark_fn.cast(
-                snowpark_fn.array_unique_agg(
-                    snowpark_typed_args[0].column(to_semi_structure=True)
-                ),
-                ArrayType(snowpark_typed_args[0].typ),
+            result_exp = snowpark_fn.array_unique_agg(
+                snowpark_typed_args[0].column(to_semi_structure=True)
             )
-            result_exp = TypedColumn(
-                result_exp, lambda: [ArrayType(snowpark_typed_args[0].typ)]
+            result_exp = _resolve_aggregate_exp(
+                result_exp, ArrayType(snowpark_typed_args[0].typ)
             )
-        case "column":
-            # TODO: assign type
-            result_exp = snowpark_fn.column(*snowpark_args)
-            result_exp = _type_with_typer(result_exp)
-            qualifiers = snowpark_args[0].get_qualifiers()
         case "concat":
             if len(snowpark_args) == 0:
                 result_exp = TypedColumn(snowpark_fn.lit(""), lambda: [StringType()])
@@ -2040,9 +2442,11 @@ def map_unresolved_function(
                     ),
                     ULongLong(),
                 ):
-                    raise ArithmeticException(
+                    exception = ArithmeticException(
                         '[ARITHMETIC_OVERFLOW] Overflow in function conv(). If necessary set "spark.sql.ansi.enabled" to "false" to bypass this error.'
                     )
+                    attach_custom_error_code(exception, ErrorCodes.ARITHMETIC_ERROR)
+                    raise exception
 
             @cached_udf(
                 input_types=[
@@ -2139,7 +2543,7 @@ def map_unresolved_function(
                         snowpark_fn.col("*", _is_qualified_name=True)
                     )
                 else:
-                    result_exp = snowpark_fn.count(*snowpark_args)
+                    result_exp = snowpark_fn.call_function("COUNT", *snowpark_args)
             result_exp = TypedColumn(result_exp, lambda: [LongType()])
         case "count_if":
             result_exp = snowpark_fn.call_function("COUNT_IF", snowpark_args[0])
@@ -2190,9 +2594,11 @@ def map_unresolved_function(
                     seed = literal_value
 
             if column is None or eps is None or confidence is None or seed is None:
-                raise ValueError(
+                exception = ValueError(
                     "The required parameters for count_min_sketch have not been set."
                 )
+                attach_custom_error_code(exception, ErrorCodes.INVALID_INPUT)
+                raise exception
 
             # Calculate depth and width based on eps and confidence
             depth = math.ceil(math.log(1.0 / (1.0 - confidence)))
@@ -2290,10 +2696,12 @@ def map_unresolved_function(
             if not isinstance(col1_type, _NumericType) or not isinstance(
                 col2_type, _NumericType
             ):
-                raise TypeError(
+                exception = TypeError(
                     f"Data type mismatch: covar_pop requires numeric types, "
                     f"but got {col1_type} and {col2_type}."
                 )
+                attach_custom_error_code(exception, ErrorCodes.TYPE_MISMATCH)
+                raise exception
             result_exp = snowpark_fn.covar_pop(
                 snowpark_args[0],
                 snowpark_args[1],
@@ -2305,10 +2713,12 @@ def map_unresolved_function(
             if not isinstance(col1_type, _NumericType) or not isinstance(
                 col2_type, _NumericType
             ):
-                raise TypeError(
+                exception = TypeError(
                     f"Data type mismatch: covar_samp requires numeric types, "
                     f"but got {col1_type} and {col2_type}."
                 )
+                attach_custom_error_code(exception, ErrorCodes.TYPE_MISMATCH)
+                raise exception
             result_exp = snowpark_fn.covar_samp(snowpark_args[0], snowpark_args[1])
             result_type = DoubleType()
         case "crc32":
@@ -2317,9 +2727,11 @@ def map_unresolved_function(
                 and not isinstance(snowpark_typed_args[0].typ, StringType)
                 and not isinstance(snowpark_typed_args[0].typ, VariantType)
             ):
-                raise AnalysisException(
+                exception = AnalysisException(
                     f"[DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE] Cannot resolve crc32({snowpark_args[0]}) due to data type mismatch: Input requires the BINARY type, however {snowpark_args[0]} has the type {snowpark_typed_args[0].typ}."
                 )
+                attach_custom_error_code(exception, ErrorCodes.TYPE_MISMATCH)
+                raise exception
 
             # UDF to calculate the unsigned CRC32 value of data in bytes. Returns the CRC32 value
             # as a 32-bit INT, or None if the input is None.
@@ -2369,9 +2781,13 @@ def map_unresolved_function(
             spark_function_name = "current_database()"
         case "current_date" | "curdate":
             if len(snowpark_args) > 0:
-                raise AnalysisException(
+                exception = AnalysisException(
                     f"[WRONG_NUM_ARGS.WITHOUT_SUGGESTION] The `{function_name}` requires 0 parameters but the actual number is {len(snowpark_args)}."
                 )
+                attach_custom_error_code(
+                    exception, ErrorCodes.INVALID_FUNCTION_ARGUMENT
+                )
+                raise exception
             result_exp = TypedColumn(snowpark_fn.current_date(), lambda: [DateType()])
             spark_function_name = "current_date()"
         case "current_timestamp" | "now":
@@ -2387,7 +2803,11 @@ def map_unresolved_function(
             if len(snowpark_args) != 2:
                 # SQL supports a 3-argument call that gets mapped to timestamp_add -
                 # however, if the first argument is invalid, we end up here.
-                raise AnalysisException("date_add takes 2 arguments")
+                exception = AnalysisException("date_add takes 2 arguments")
+                attach_custom_error_code(
+                    exception, ErrorCodes.INVALID_FUNCTION_ARGUMENT
+                )
+                raise exception
             arg_2 = snowpark_typed_args[1].typ
             if isinstance(arg_2, StringType):
                 with suppress(Exception):
@@ -2395,9 +2815,11 @@ def map_unresolved_function(
                         arg_2 = IntegerType()
 
             if not isinstance(arg_2, (_IntegralType, NullType)):
-                raise AnalysisException(
+                exception = AnalysisException(
                     f'[DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE] Cannot resolve "date_add({snowpark_arg_names[0]}, {snowpark_arg_names[1]})" due to data type mismatch: Parameter 2 requires the ("INT" or "SMALLINT" or "TINYINT" or "NULL") type, however "{snowpark_arg_names[1]}" has the type "{str(arg_2)}".'
                 )
+                attach_custom_error_code(exception, ErrorCodes.TYPE_MISMATCH)
+                raise exception
 
             result_exp = _try_to_cast(
                 "try_to_date",
@@ -2412,7 +2834,11 @@ def map_unresolved_function(
             if len(snowpark_args) != 2:
                 # SQL supports a 3-argument call that gets mapped to timestamp_diff -
                 # however, if the first argument is invalid, we end up here.
-                raise AnalysisException("date_diff takes 2 arguments")
+                exception = AnalysisException("date_diff takes 2 arguments")
+                attach_custom_error_code(
+                    exception, ErrorCodes.INVALID_FUNCTION_ARGUMENT
+                )
+                raise exception
             result_exp = _try_to_cast(
                 "try_to_date",
                 snowpark_fn.datediff("day", snowpark_args[1], snowpark_args[0]),
@@ -2469,9 +2895,11 @@ def map_unresolved_function(
                         arg_2 = IntegerType()
 
             if not isinstance(arg_2, (_IntegralType, NullType)):
-                raise AnalysisException(
+                exception = AnalysisException(
                     f'[DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE] Cannot resolve "date_sub({snowpark_arg_names[0]}, {snowpark_arg_names[1]})" due to data type mismatch: Parameter 2 requires the ("INT" or "SMALLINT" or "TINYINT" or "NULL") type, however "{snowpark_arg_names[1]}" has the type "{str(arg_2)}".'
                 )
+                attach_custom_error_code(exception, ErrorCodes.TYPE_MISMATCH)
+                raise exception
             result_exp = _try_to_cast(
                 "try_to_date",
                 snowpark_fn.to_date(
@@ -2553,14 +2981,6 @@ def map_unresolved_function(
                 )
             result_type = LongType()
         case "date_part" | "datepart" | "extract":
-            # Check for interval types and throw NotImplementedError
-            if isinstance(
-                snowpark_typed_args[1].typ, (YearMonthIntervalType, DayTimeIntervalType)
-            ):
-                raise NotImplementedError(
-                    f"{function_name} with interval types is not supported"
-                )
-
             field_lit: str | None = unwrap_literal(exp.unresolved_function.arguments[0])
 
             if field_lit is None:
@@ -2605,16 +3025,51 @@ def map_unresolved_function(
         case "div":
             # Only called from SQL, either as `a div b` or `div(a, b)`
             # Convert it into `(a - a % b) / b`.
-            result_exp = snowpark_fn.cast(
-                (snowpark_args[0] - snowpark_args[0] % snowpark_args[1])
-                / snowpark_args[1],
-                LongType(),
-            )
-            if not spark_sql_ansi_enabled:
-                result_exp = snowpark_fn.when(
-                    snowpark_args[1] == 0, snowpark_fn.lit(None)
-                ).otherwise(result_exp)
-            result_type = LongType()
+            if isinstance(snowpark_typed_args[0].typ, YearMonthIntervalType):
+                if isinstance(snowpark_typed_args[1].typ, YearMonthIntervalType):
+                    dividend_total = _calculate_total_months(snowpark_args[0])
+                    divisor_total = _calculate_total_months(snowpark_args[1])
+
+                    # Handle division by zero interval
+                    if not spark_sql_ansi_enabled:
+                        result_exp = snowpark_fn.when(
+                            divisor_total == 0, snowpark_fn.lit(None)
+                        ).otherwise(snowpark_fn.trunc(dividend_total / divisor_total))
+                    else:
+                        result_exp = snowpark_fn.trunc(dividend_total / divisor_total)
+                    result_type = LongType()
+                else:
+                    raise AnalysisException(
+                        f"""[DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES] Cannot resolve "({snowpark_arg_names[0]} div {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[0].typ, DayTimeIntervalType):
+                if isinstance(snowpark_typed_args[1].typ, DayTimeIntervalType):
+                    dividend_total = _calculate_total_seconds(snowpark_args[0])
+                    divisor_total = _calculate_total_seconds(snowpark_args[1])
+
+                    # Handle division by zero interval
+                    if not spark_sql_ansi_enabled:
+                        result_exp = snowpark_fn.when(
+                            divisor_total == 0, snowpark_fn.lit(None)
+                        ).otherwise(snowpark_fn.trunc(dividend_total / divisor_total))
+                    else:
+                        result_exp = snowpark_fn.trunc(dividend_total / divisor_total)
+                    result_type = LongType()
+                else:
+                    raise AnalysisException(
+                        f"""[DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES] Cannot resolve "({snowpark_arg_names[0]} div {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}).;"""
+                    )
+            else:
+                result_exp = snowpark_fn.cast(
+                    (snowpark_args[0] - snowpark_args[0] % snowpark_args[1])
+                    / snowpark_args[1],
+                    LongType(),
+                )
+                if not spark_sql_ansi_enabled:
+                    result_exp = snowpark_fn.when(
+                        snowpark_args[1] == 0, snowpark_fn.lit(None)
+                    ).otherwise(result_exp)
+                result_type = LongType()
         case "e":
             spark_function_name = "E()"
             result_exp = snowpark_fn.lit(math.e)
@@ -2637,9 +3092,13 @@ def map_unresolved_function(
                     result_exp = snowpark_fn.element_at(data, spark_index)
                     result_type = typ.value_type
                 case _:
-                    raise SnowparkConnectNotImplementedError(
+                    exception = SnowparkConnectNotImplementedError(
                         f"Unsupported type {typ} for element_at function"
                     )
+                    attach_custom_error_code(
+                        exception, ErrorCodes.UNSUPPORTED_OPERATION
+                    )
+                    raise exception
         case "elt":
             n = snowpark_args[0]
             values = snowpark_fn.array_construct(*snowpark_args[1:])
@@ -2725,9 +3184,11 @@ def map_unresolved_function(
                         result_type = [input_type.key_type, input_type.value_type]
                     else:
                         # Throw proper error for types without key_type/value_type attributes
-                        raise AnalysisException(
+                        exception = AnalysisException(
                             f'[DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE] Cannot resolve "{function_name}({snowpark_arg_names[0]})" due to data type mismatch: Parameter 1 requires the ("ARRAY" or "MAP") type, however "{snowpark_arg_names[0]}" has the type "{str(input_type)}".'
                         )
+                        attach_custom_error_code(exception, ErrorCodes.TYPE_MISMATCH)
+                        raise exception
         case "expm1":
             spark_function_name = f"EXPM1({snowpark_arg_names[0]})"
             result_exp = snowpark_fn.exp(*snowpark_args) - 1
@@ -2848,9 +3309,11 @@ def map_unresolved_function(
                 if not isinstance(
                     snowpark_typed_args[1].typ, IntegerType
                 ) and not isinstance(snowpark_typed_args[1].typ, LongType):
-                    raise AnalysisException(
+                    exception = AnalysisException(
                         "The 'scale' parameter of function 'floor' needs to be a int literal."
                     )
+                    attach_custom_error_code(exception, ErrorCodes.INVALID_INPUT)
+                    raise exception
                 spark_function_name = (
                     f"floor({snowpark_arg_names[0]}, {snowpark_arg_names[1]})"
                 )
@@ -2867,17 +3330,23 @@ def map_unresolved_function(
                 else:
                     result_exp = TypedColumn(result_exp, lambda: [result_type])
             else:
-                raise AnalysisException(
+                exception = AnalysisException(
                     f"[WRONG_NUM_ARGS.WITHOUT_SUGGESTION] The `floor` requires 2 parameters but the actual number is {len(snowpark_args)}."
                 )
+                attach_custom_error_code(
+                    exception, ErrorCodes.INVALID_FUNCTION_ARGUMENT
+                )
+                raise exception
         case "format_number":
             col, scale = snowpark_args
             col_type = snowpark_typed_args[0].typ
 
             if not isinstance(col_type, _NumericType):
-                raise TypeError(
+                exception = TypeError(
                     f'Data type mismatch: Parameter 1 of format_number requires  the "NUMERIC" type, however was {col_type}.'
                 )
+                attach_custom_error_code(exception, ErrorCodes.TYPE_MISMATCH)
+                raise exception
 
             @cached_udf(
                 input_types=[StringType(), LongType()],
@@ -2953,7 +3422,7 @@ def map_unresolved_function(
                 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."
+                            "[snowpark_connect::invalid_input] [INVALID_OPTIONS.NON_MAP_FUNCTION] Invalid options: Must use the `map()` function for options."
                         )
 
                     max_chars_per_column = options.get(
@@ -2970,7 +3439,7 @@ def map_unresolved_function(
                                 type(v).__name__, type(v).__name__.upper()
                             )
                             raise TypeError(
-                                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}>".'
+                                f'[snowpark_connect::type_mismatch] [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}>".'
                             )
 
                 csv_data = csv_data.split(sep)
@@ -2993,7 +3462,7 @@ def map_unresolved_function(
                         and len(str(csv_data[i])) > max_chars_per_column
                     ):
                         raise ValueError(
-                            f"Max chars per column exceeded {max_chars_per_column}: {str(csv_data[i])}"
+                            f"[snowpark_connect::invalid_input] Max chars per column exceeded {max_chars_per_column}: {str(csv_data[i])}"
                         )
 
                 return results
@@ -3004,9 +3473,11 @@ def map_unresolved_function(
             if len(snowpark_arg_names) > 2 and snowpark_arg_names[2].startswith(
                 "named_struct"
             ):
-                raise TypeError(
+                exception = TypeError(
                     "[INVALID_OPTIONS.NON_MAP_FUNCTION] Invalid options: Must use the `map()` function for options."
                 )
+                attach_custom_error_code(exception, ErrorCodes.INVALID_INPUT)
+                raise exception
 
             match snowpark_args:
                 case [csv_data, schemas]:
@@ -3020,7 +3491,11 @@ def map_unresolved_function(
                         snowpark_fn.cast(csv_data, StringType()), schemas, options
                     )
                 case _:
-                    raise ValueError("Unrecognized from_csv parameters")
+                    exception = ValueError("Unrecognized from_csv parameters")
+                    attach_custom_error_code(
+                        exception, ErrorCodes.INVALID_FUNCTION_ARGUMENT
+                    )
+                    raise exception
 
             result_exp = snowpark_fn.when(
                 snowpark_args[0].is_null(), snowpark_fn.lit(None)
@@ -3029,15 +3504,19 @@ def map_unresolved_function(
             # TODO: support options.
             if len(snowpark_args) > 2:
                 if not isinstance(snowpark_typed_args[2].typ, MapType):
-                    raise AnalysisException(
+                    exception = AnalysisException(
                         "[INVALID_OPTIONS.NON_MAP_FUNCTION] Invalid options: Must use the `map()` function for options."
                     )
+                    attach_custom_error_code(exception, ErrorCodes.INVALID_INPUT)
+                    raise exception
                 if not isinstance(
                     snowpark_typed_args[2].typ.key_type, StringType
                 ) or not isinstance(snowpark_typed_args[2].typ.value_type, StringType):
-                    raise AnalysisException(
+                    exception = AnalysisException(
                         f"""[INVALID_OPTIONS.NON_STRING_TYPE] Invalid options: A type of keys and values in `map()` must be string, but got "{snowpark_typed_args[2].typ.simpleString().upper()}"."""
                     )
+                    attach_custom_error_code(exception, ErrorCodes.TYPE_MISMATCH)
+                    raise exception
 
             spark_function_name = f"from_json({snowpark_arg_names[0]})"
             lit_schema = unwrap_literal(exp.unresolved_function.arguments[1])
@@ -3172,9 +3651,11 @@ def map_unresolved_function(
                 input_arg_type: DataType,
                 format: str = "yyyy-MM-dd HH:mm:ss",
             ):
-                raise AnalysisException(
+                exception = AnalysisException(
                     f'[DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE] Cannot resolve "from_unixtime({input_arg_name}, {format})" due to data type mismatch: Parameter 1 requires the "BIGINT" type, however "{input_arg_name}" has the type "{input_arg_type}"'
                 )
+                attach_custom_error_code(exception, ErrorCodes.TYPE_MISMATCH)
+                raise exception
 
             # Strip decimal part of the number to ensure proper result after calling snowflake counterparts
             match snowpark_typed_args[0].typ:
@@ -3240,15 +3721,20 @@ def map_unresolved_function(
                             timestamp_format,
                         )
                     except AnalysisException as e:
+                        attach_custom_error_code(e, ErrorCodes.INVALID_INPUT)
                         raise e
                     except Exception:
                         # The second argument must either be a string or none. It can't be a column.
                         # So if it's anything that isn't a literal, we catch the error and just return NULL
                         result_exp = snowpark_fn.lit(None)
                 case _:
-                    raise AnalysisException(
+                    exception = AnalysisException(
                         f"[WRONG_NUM_ARGS.WITHOUT_SUGGESTION] The `from_unixtime` requires [1, 2] parameters but the actual number is {len(snowpark_args)}."
                     )
+                    attach_custom_error_code(
+                        exception, ErrorCodes.INVALID_FUNCTION_ARGUMENT
+                    )
+                    raise exception
             result_type = StringType()
         case "from_utc_timestamp":
             target_tz = _map_from_spark_tz(snowpark_args[1])
@@ -3323,10 +3809,12 @@ def map_unresolved_function(
                         for sp_col in snowpark_args
                     ]
                     if current_grouping_cols != spark_col_args:
-                        raise AnalysisException(
+                        exception = AnalysisException(
                             f"[GROUPING_ID_COLUMN_MISMATCH] Columns of grouping_id: {spark_col_args} doesnt match "
                             f"Grouping columns: {current_grouping_cols}"
                         )
+                        attach_custom_error_code(exception, ErrorCodes.INTERNAL_ERROR)
+                        raise exception
             if function_name == "grouping_id":
                 result_exp = snowpark_fn.grouping_id(*snowpark_args)
             else:
@@ -3344,12 +3832,14 @@ def map_unresolved_function(
             if not snowflake_compat and not spark_sql_legacy_allow_hash_on_map_type:
                 for arg in snowpark_typed_args:
                     if any(isinstance(t, MapType) for t in arg.types):
-                        raise AnalysisException(
+                        exception = AnalysisException(
                             '[DATATYPE_MISMATCH.HASH_MAP_TYPE] Cannot resolve "hash(value)" due to data type mismatch: '
                             'Input to the function `hash` cannot contain elements of the "MAP" type. '
                             'In Spark, same maps may have different hashcode, thus hash expressions are prohibited on "MAP" elements. '
                             'To restore previous behavior set "spark.sql.legacy.allowHashOnMapType" to "true".'
                         )
+                        attach_custom_error_code(exception, ErrorCodes.TYPE_MISMATCH)
+                        raise exception
             result_exp = snowpark_fn.hash(*snowpark_args)
             result_type = LongType()
         case "hex":
@@ -3388,9 +3878,11 @@ def map_unresolved_function(
             if isinstance(aggregate_input_typ, DecimalType):
                 # mimic bug from Spark 3.5.3.
                 # In 3.5.5 it's fixed and this exception shouldn't be thrown
-                raise ValueError(
+                exception = ValueError(
                     "class org.apache.spark.sql.types.Decimal cannot be cast to class java.lang.Number (org.apache.spark.sql.types.Decimal is in unnamed module of loader 'app'; java.lang.Number is in module java.base of loader 'bootstrap')"
                 )
+                attach_custom_error_code(exception, ErrorCodes.INVALID_CAST)
+                raise exception
 
             histogram_return_type = ArrayType(
                 StructType(
@@ -3409,8 +3901,6 @@ def map_unresolved_function(
                 result should be either way good enough.
                 """
 
-                from datetime import date, datetime, time, timedelta
-
                 def __init__(self) -> None:
 
                     # init the RNG for breaking ties in histogram merging. A fixed seed is specified here
@@ -3554,7 +4044,8 @@ def map_unresolved_function(
                     # just increment 'bin'. This is not done now because we don't want to make any
                     # assumptions about the range of numeric data being analyzed.
                     if bin < self.n_used_bins and self.bins[bin][0] == v:
-                        self.bins[bin][1] += 1
+                        bin_x, bin_y = self.bins[bin]
+                        self.bins[bin] = (bin_x, bin_y + 1)
                     else:
                         self.bins.insert(bin + 1, (v, 1.0))
                         self.n_used_bins += 1
@@ -3604,13 +4095,12 @@ def map_unresolved_function(
                 input_types=[aggregate_input_typ, IntegerType()],
             )
 
-            result_exp = snowpark_fn.cast(
+            result_exp = _resolve_aggregate_exp(
                 _histogram_numeric_udaf(
                     snowpark_args[0], snowpark_fn.lit(snowpark_args[1])
                 ),
                 histogram_return_type,
             )
-            result_type = histogram_return_type
         case "hll_sketch_agg":
             # check if input type is correct
             if type(snowpark_typed_args[0].typ) not in [
@@ -3620,9 +4110,11 @@ def map_unresolved_function(
                 BinaryType,
             ]:
                 type_str = snowpark_typed_args[0].typ.simpleString().upper()
-                raise AnalysisException(
+                exception = AnalysisException(
                     f'[DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE] Cannot resolve "{spark_function_name}" due to data type mismatch: Parameter 1 requires the ("INT" or "BIGINT" or "STRING" or "BINARY") type, however "{snowpark_arg_names[0]}" has the type "{type_str}".'
                 )
+                attach_custom_error_code(exception, ErrorCodes.TYPE_MISMATCH)
+                raise exception
 
             match snowpark_args:
                 case [sketch]:
@@ -3761,10 +4253,12 @@ def map_unresolved_function(
                 type_mismatched = True
 
             if type_mismatched:
-                raise AnalysisException(
+                exception = AnalysisException(
                     f'[DATATYPE_MISMATCH.DATA_DIFF_TYPES] Cannot resolve "{spark_function_name}" due to data type mismatch: '
                     f'Input to `in` should all be the same type, but it\'s [{", ".join(type_names)}].'
                 )
+                attach_custom_error_code(exception, ErrorCodes.TYPE_MISMATCH)
+                raise exception
 
             try:
                 result_exp = snowpark_args[0].in_(snowpark_args[1:])
@@ -3797,9 +4291,11 @@ def map_unresolved_function(
                 except Exception:
                     type_str = str(input_type)
 
-                raise AnalysisException(
+                exception = AnalysisException(
                     f'[DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE] Cannot resolve "inline({snowpark_arg_names[0]})" due to data type mismatch: Parameter 1 requires the "ARRAY<STRUCT>" type, however "{snowpark_arg_names[0]}" has the type {type_str}.'
                 )
+                attach_custom_error_code(exception, ErrorCodes.TYPE_MISMATCH)
+                raise exception
 
             is_outer = function_name == "inline_outer"
 
@@ -3891,11 +4387,13 @@ def map_unresolved_function(
                 if arg_type not in allowed_arg_types:
                     spark_type = map_snowpark_to_pyspark_types(arg_type)
 
-                    raise AnalysisException(
+                    exception = AnalysisException(
                         f"""[DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE] Cannot resolve "{spark_function_name}" due to data type mismatch: """
                         f"""Parameter {arg_idx+3} requires the ("BOOLEAN" or "TINYINT" or "SMALLINT" or "INT" or "BIGINT" or "FLOAT" or "DOUBLE" or "STRING") type, """
                         f"""however "{snowpark_arg_names[arg_idx+2]}" has the type "{spark_type.simpleString()}"."""
                     )
+                    attach_custom_error_code(exception, ErrorCodes.TYPE_MISMATCH)
+                    raise exception
 
             arg_values = snowpark_fn.cast(
                 snowpark_fn.array_construct(
@@ -3924,9 +4422,11 @@ def map_unresolved_function(
             if not isinstance(
                 snowpark_typed_args[0].typ, StringType
             ) and not isinstance(snowpark_typed_args[0].typ, NullType):
-                raise AnalysisException(
+                exception = AnalysisException(
                     f"""[DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE] Cannot resolve "json_array_length({",".join(snowpark_arg_names)})" due to data type mismatch: Parameter 1 requires the "STRING" type, however "{snowpark_arg_names[0]}" has the type "{snowpark_typed_args[0].typ.simpleString().upper()}"."""
                 )
+                attach_custom_error_code(exception, ErrorCodes.TYPE_MISMATCH)
+                raise exception
             arr_exp = snowpark_fn.function("TRY_PARSE_JSON")(snowpark_args[0])
             result_exp = snowpark_fn.array_size(arr_exp)
             result_type = LongType()
@@ -3934,9 +4434,11 @@ def map_unresolved_function(
             if not isinstance(
                 snowpark_typed_args[0].typ, StringType
             ) and not isinstance(snowpark_typed_args[0].typ, NullType):
-                raise AnalysisException(
+                exception = AnalysisException(
                     f"""[DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE] Cannot resolve "json_object_keys({",".join(snowpark_arg_names)})" due to data type mismatch: Parameter 1 requires the "STRING" type, however "{snowpark_arg_names[0]}" has the type "{snowpark_typed_args[0].typ.simpleString().upper()}"."""
                 )
+                attach_custom_error_code(exception, ErrorCodes.TYPE_MISMATCH)
+                raise exception
             obj_exp = snowpark_fn.function("TRY_PARSE_JSON")(
                 snowpark_args[0], snowpark_fn.lit("d")
             )
@@ -4080,9 +4582,11 @@ def map_unresolved_function(
                         else snowpark_fn.builtin("try_to_date")(*snowpark_args)
                     )
                 case _:
-                    raise AnalysisException(
+                    exception = AnalysisException(
                         f'[DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE] Cannot resolve "last_day({snowpark_arg_names[0]}" due to data type mismatch: Parameter 1 requires the "DATE" type, however "{snowpark_arg_names[0]}" has the type "{snowpark_typed_args[0]}".'
                     )
+                    attach_custom_error_code(exception, ErrorCodes.TYPE_MISMATCH)
+                    raise exception
 
             result_exp = snowpark_fn.last_day(result_exp)
             result_type = DateType()
@@ -4156,7 +4660,13 @@ def map_unresolved_function(
                             snowpark_fn.lit(None),
                         ).otherwise(snowpark_fn.lit(-1))
                 case _:
-                    raise ValueError(f"Invalid number of arguments to {function_name}")
+                    exception = ValueError(
+                        f"Invalid number of arguments to {function_name}"
+                    )
+                    attach_custom_error_code(
+                        exception, ErrorCodes.INVALID_FUNCTION_ARGUMENT
+                    )
+                    raise exception
             result_type = LongType()
         case "like":
             result_exp = snowpark_fn.call_function("like", *snowpark_args)
@@ -4329,6 +4839,17 @@ def map_unresolved_function(
             date_str_exp = snowpark_fn.concat(y, dash, m, dash, d)
             result_exp = snowpark_fn.builtin(snowpark_function)(date_str_exp)
             result_type = DateType()
+        case "make_dt_interval":
+            # Pad argument names for display purposes
+            padded_arg_names = snowpark_arg_names.copy()
+            while len(padded_arg_names) < 3:  # days, hours, minutes are integers
+                padded_arg_names.append("0")
+            if len(padded_arg_names) < 4:  # seconds can be decimal
+                padded_arg_names.append("0.000000")
+
+            spark_function_name = f"make_dt_interval({', '.join(padded_arg_names)})"
+            result_exp = snowpark_fn.interval_day_time_from_parts(*snowpark_args)
+            result_type = DayTimeIntervalType()
         case "make_timestamp" | "make_timestamp_ltz" | "make_timestamp_ntz":
             y, m, d, h, mins = map(lambda col: col.cast(LongType()), snowpark_args[:5])
             y_abs = snowpark_fn.abs(y)
@@ -4382,6 +4903,15 @@ def map_unresolved_function(
             result_exp = snowpark_fn.when(
                 snowpark_fn.is_null(parsed_str_exp), snowpark_fn.lit(None)
             ).otherwise(make_timestamp_res)
+        case "make_ym_interval":
+            # Pad argument names for display purposes
+            padded_arg_names = snowpark_arg_names.copy()
+            while len(padded_arg_names) < 2:  # years, months
+                padded_arg_names.append("0")
+
+            spark_function_name = f"make_ym_interval({', '.join(padded_arg_names)})"
+            result_exp = snowpark_fn.interval_year_month_from_parts(*snowpark_args)
+            result_type = YearMonthIntervalType()
         case "map":
             allow_duplicate_keys = (
                 global_config.spark_sql_mapKeyDedupPolicy == "LAST_WIN"
@@ -4400,13 +4930,21 @@ def map_unresolved_function(
                 )
                 result_type = MapType(NullType(), NullType())
             elif (num_args % 2) == 1:
-                raise AnalysisException(
+                exception = AnalysisException(
                     f"[WRONG_NUM_ARGS.WITHOUT_SUGGESTION] The `map` requires 2n (n > 0) parameters but the actual number is {num_args}"
                 )
+                attach_custom_error_code(
+                    exception, ErrorCodes.INVALID_FUNCTION_ARGUMENT
+                )
+                raise exception
             elif key_type is None or isinstance(key_type, NullType):
-                raise SparkRuntimeException(
+                exception = SparkRuntimeException(
                     "[NULL_MAP_KEY] Cannot use null as map key."
                 )
+                attach_custom_error_code(
+                    exception, ErrorCodes.INVALID_FUNCTION_ARGUMENT
+                )
+                raise exception
             else:
                 value_type = value_type if value_type else NullType()
 
@@ -4452,7 +4990,7 @@ def map_unresolved_function(
                     for key, value in m.items():
                         if key in new_map and not allow_dups:
                             raise ValueError(
-                                DUPLICATE_KEY_FOUND_ERROR_TEMPLATE.format(key=key)
+                                f"[snowpark_connect::invalid_operation] {DUPLICATE_KEY_FOUND_ERROR_TEMPLATE.format(key=key)}"
                             )
                         else:
                             new_map[key] = value
@@ -4483,13 +5021,17 @@ def map_unresolved_function(
             result_type = MapType(key_type, value_type)
         case "map_contains_key":
             if isinstance(snowpark_typed_args[0].typ, NullType):
-                raise AnalysisException(
+                exception = AnalysisException(
                     f"""[DATATYPE_MISMATCH.MAP_FUNCTION_DIFF_TYPES] Cannot resolve "map_contains_key({snowpark_arg_names[0]}, {snowpark_arg_names[1]})" due to data type mismatch: Input to `map_contains_key` should have been "MAP" followed by a value with same key type, but it's ["VOID", "INT"]."""
                 )
+                attach_custom_error_code(exception, ErrorCodes.TYPE_MISMATCH)
+                raise exception
             if isinstance(snowpark_typed_args[1].typ, NullType):
-                raise AnalysisException(
+                exception = AnalysisException(
                     f"""[DATATYPE_MISMATCH.NULL_TYPE] Cannot resolve "map_contains_key({snowpark_arg_names[0]}, {snowpark_arg_names[1]})" due to data type mismatch: Null typed values cannot be used as arguments of `map_contains_key`."""
                 )
+                attach_custom_error_code(exception, ErrorCodes.TYPE_MISMATCH)
+                raise exception
             args = (
                 [snowpark_args[1], snowpark_args[0]]
                 if isinstance(snowpark_typed_args[0].typ, MapType)
@@ -4499,23 +5041,29 @@ def map_unresolved_function(
             result_type = BooleanType()
         case "map_entries":
             if not isinstance(snowpark_typed_args[0].typ, MapType):
-                raise AnalysisException(
+                exception = AnalysisException(
                     f"""[DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE] Cannot resolve "map_entries({snowpark_arg_names[0]})" due to data type mismatch: Parameter 1 requires the "MAP" type, however "{snowpark_arg_names[0]}" has the type "{snowpark_typed_args[0].typ}".;"""
                 )
+                attach_custom_error_code(exception, ErrorCodes.TYPE_MISMATCH)
+                raise exception
             key_type = snowpark_typed_args[0].typ.key_type
             value_type = snowpark_typed_args[0].typ.value_type
 
             # SNOW-2040715
             def _map_entries(obj: dict):
                 if obj is None:
-                    raise TypeError(f"Expected MapType but received {obj} instead.")
+                    raise TypeError(
+                        f"[snowpark_connect::type_mismatch] Expected MapType but received {obj} instead."
+                    )
                 return [{"key": key, "value": value} for key, value in obj.items()]
 
             arg_type = snowpark_typed_args[0].typ
             if not isinstance(arg_type, MapType):
-                raise TypeError(
+                exception = TypeError(
                     f"map_entries requires a MapType argument, got {arg_type}"
                 )
+                attach_custom_error_code(exception, ErrorCodes.TYPE_MISMATCH)
+                raise exception
 
             map_entries = snowpark_fn.udf(
                 _map_entries,
@@ -4545,9 +5093,11 @@ def map_unresolved_function(
             if not isinstance(keys_type, ArrayType) or not isinstance(
                 values_type, ArrayType
             ):
-                raise TypeError(
+                exception = TypeError(
                     f"map_from_arrays requires two arguments of type ArrayType, got {keys_type} and {values_type}"
                 )
+                attach_custom_error_code(exception, ErrorCodes.TYPE_MISMATCH)
+                raise exception
             key_type = keys_type.element_type if keys_type.structured else VariantType()
             value_type = (
                 values_type.element_type if values_type.structured else VariantType()
@@ -4562,7 +5112,7 @@ def map_unresolved_function(
                     return None
                 if len(keys) != len(values):
                     raise ValueError(
-                        "The key array and value array of must have the same length"
+                        "[snowpark_connect::internal_error] The key array and value array of must have the same length"
                     )
 
                 if not allow_dups and len(set(keys)) != len(keys):
@@ -4570,7 +5120,7 @@ def map_unresolved_function(
                     for key in keys:
                         if key in seen:
                             raise ValueError(
-                                DUPLICATE_KEY_FOUND_ERROR_TEMPLATE.format(key=key)
+                                f"[snowpark_connect::invalid_operation] {DUPLICATE_KEY_FOUND_ERROR_TEMPLATE.format(key=key)}"
                             )
                         seen.add(key)
                 # will overwrite the last occurrence if there are duplicates.
@@ -4592,9 +5142,11 @@ def map_unresolved_function(
             result_type = MapType(key_type, value_type)
         case "map_from_entries":
             if not isinstance(snowpark_typed_args[0].typ, ArrayType):
-                raise TypeError(
+                exception = TypeError(
                     f"map_from_entries requires an argument of type ArrayType, got {snowpark_typed_args[0].typ}"
                 )
+                attach_custom_error_code(exception, ErrorCodes.TYPE_MISMATCH)
+                raise exception
 
             entry_type = snowpark_typed_args[0].typ.element_type
 
@@ -4613,9 +5165,11 @@ def map_unresolved_function(
                     value_type = entry_type.fields[1].datatype
                     [key_field, value_field] = entry_type.names
                 case _:
-                    raise TypeError(
+                    exception = TypeError(
                         f"map_from_entries requires an array of StructType, got array of {entry_type}"
                     )
+                    attach_custom_error_code(exception, ErrorCodes.TYPE_MISMATCH)
+                    raise exception
 
             last_win_dedup = global_config.spark_sql_mapKeyDedupPolicy == "LAST_WIN"
 
@@ -4656,7 +5210,11 @@ def map_unresolved_function(
         case "map_keys":
             arg_type = snowpark_typed_args[0].typ
             if not isinstance(arg_type, MapType):
-                raise TypeError(f"map_keys requires a MapType argument, got {arg_type}")
+                exception = TypeError(
+                    f"map_keys requires a MapType argument, got {arg_type}"
+                )
+                attach_custom_error_code(exception, ErrorCodes.TYPE_MISMATCH)
+                raise exception
 
             if arg_type.structured:
                 result_exp = snowpark_fn.map_keys(snowpark_args[0])
@@ -4669,9 +5227,11 @@ def map_unresolved_function(
             # technically this could be done with a lateral join, but it's probably not worth the effort
             arg_type = snowpark_typed_args[0].typ
             if not isinstance(arg_type, (MapType, NullType)):
-                raise AnalysisException(
+                exception = AnalysisException(
                     f"map_values requires a MapType argument, got {arg_type}"
                 )
+                attach_custom_error_code(exception, ErrorCodes.TYPE_MISMATCH)
+                raise exception
 
             def _map_values(obj: dict) -> list:
                 if obj is None:
@@ -4770,20 +5330,30 @@ def map_unresolved_function(
                 ):
                     pass
                 elif not isinstance(arg_type, StringType):
-                    raise AnalysisException(
+                    exception = AnalysisException(
                         f"""[DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE] Cannot resolve "{spark_function_name}" due to data type mismatch: Parameter {i + 1} requires the "STRING" type, however "{arg_name}" has the type "{arg_type.simpleString().upper()}".;"""
                     )
+                    attach_custom_error_code(exception, ErrorCodes.TYPE_MISMATCH)
+                    raise exception
                 elif (
                     exp.unresolved_function.arguments[i].WhichOneof("expr_type")
                     != "literal"
                 ):
-                    raise AnalysisException(
+                    exception = AnalysisException(
                         f"""[DATATYPE_MISMATCH.NON_FOLDABLE_INPUT] Cannot resolve "{spark_function_name}" due to data type mismatch: the input {col_arg_names[i]} should be a foldable "STRING" expression; however, got "{arg_name}"."""
                     )
+                    attach_custom_error_code(
+                        exception, ErrorCodes.INVALID_FUNCTION_ARGUMENT
+                    )
+                    raise exception
                 elif len(arg_name) != 1:
-                    raise AnalysisException(
+                    exception = AnalysisException(
                         f"""[DATATYPE_MISMATCH.INPUT_SIZE_NOT_ONE] Cannot resolve "{spark_function_name}" due to data type mismatch: Length of {col_arg_names[i]} should be 1."""
                     )
+                    attach_custom_error_code(
+                        exception, ErrorCodes.INVALID_FUNCTION_ARGUMENT
+                    )
+                    raise exception
 
             random_tag_suffix = "".join(random.sample(string.ascii_uppercase, 6))
             tags = [
@@ -4823,17 +5393,17 @@ def map_unresolved_function(
             # MD5 in Spark only accepts BinaryType or types that can be implicitly cast to it (StringType)
             if not snowflake_compat:
                 if not isinstance(snowpark_typed_args[0].typ, (BinaryType, StringType)):
-                    raise AnalysisException(
+                    exception = AnalysisException(
                         f'[DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE] Cannot resolve "md5({snowpark_arg_names[0]})" due to data type mismatch: '
                         f'Parameter 1 requires the "BINARY" type, however "{snowpark_arg_names[0]}" has the type "{snowpark_typed_args[0].typ}".'
                     )
+                    attach_custom_error_code(exception, ErrorCodes.TYPE_MISMATCH)
+                    raise exception
             result_exp = snowpark_fn.md5(snowpark_args[0])
             result_type = StringType(32)
         case "median":
-            result_exp = snowpark_fn.median(snowpark_args[0])
-            # TODO SNOW-2034495: can we resolve the result type?
-            result_exp = TypedColumn(
-                snowpark_fn.cast(result_exp, FloatType()), lambda: [DoubleType()]
+            result_exp = _resolve_aggregate_exp(
+                snowpark_fn.median(snowpark_args[0]), DoubleType()
             )
         case "min":
             result_exp = _handle_structured_aggregate_result(
@@ -4924,9 +5494,13 @@ def map_unresolved_function(
                     expanded_args.append(arg_typed_column.col)
 
             if len(expanded_args) % 2 != 0:
-                raise ValueError(
+                exception = ValueError(
                     "Number of arguments must be even (a list of key-value pairs)."
                 )
+                attach_custom_error_code(
+                    exception, ErrorCodes.INVALID_FUNCTION_ARGUMENT
+                )
+                raise exception
 
             # field types for the schema
             field_names = []
@@ -4992,27 +5566,37 @@ def map_unresolved_function(
                 spark_function_name = f"(- {snowpark_arg_names[0]})"
             else:
                 spark_function_name = f"negative({snowpark_arg_names[0]})"
-            if isinstance(arg_type, _NumericType):
+            if (
+                isinstance(arg_type, _NumericType)
+                or isinstance(arg_type, YearMonthIntervalType)
+                or isinstance(arg_type, DayTimeIntervalType)
+            ):
                 # Instead of using snowpark_fn.negate which can generate invalid SQL for nested minus operations,
                 # use a direct multiplication by -1 which generates cleaner SQL
                 result_exp = snowpark_args[0] * snowpark_fn.lit(-1)
             elif isinstance(arg_type, StringType):
                 if spark_sql_ansi_enabled:
-                    raise NumberFormatException(
+                    exception = NumberFormatException(
                         f'The value \'{snowpark_args[0]}\' of the type {arg_type} cannot be cast to "DOUBLE" 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.'
                     )
+                    attach_custom_error_code(exception, ErrorCodes.INVALID_CAST)
+                    raise exception
                 else:
                     result_exp = snowpark_fn.lit(None)
             elif isinstance(arg_type, NullType):
                 result_exp = snowpark_fn.lit(None)
             else:
-                raise AnalysisException(
+                exception = AnalysisException(
                     f"[DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE] Cannot resolve {spark_function_name} due to data type mismatch: "
                     f'Parameter 1 requires the ("NUMERIC") type, however "{snowpark_arg_names[0]}" has the type "{snowpark_typed_args[0]}".'
                 )
+                attach_custom_error_code(exception, ErrorCodes.TYPE_MISMATCH)
+                raise exception
             result_type = (
                 snowpark_typed_args[0].types
                 if isinstance(arg_type, _NumericType)
+                or isinstance(arg_type, YearMonthIntervalType)
+                or isinstance(arg_type, DayTimeIntervalType)
                 else DoubleType()
             )
         case "next_day":
@@ -5020,9 +5604,11 @@ def map_unresolved_function(
             date = unwrap_literal(exp.unresolved_function.arguments[1])
             if date is None or date.lower() not in dates:
                 if spark_sql_ansi_enabled:
-                    raise IllegalArgumentException(
+                    exception = IllegalArgumentException(
                         """Illegal input for day of week. If necessary set "spark.sql.ansi.enabled" to false to bypass this error."""
                     )
+                    attach_custom_error_code(exception, ErrorCodes.INVALID_INPUT)
+                    raise exception
                 else:
                     result_exp = snowpark_fn.lit(None)
             else:
@@ -5081,9 +5667,11 @@ def map_unresolved_function(
             )
         case "octet_length":
             if isinstance(snowpark_typed_args[0].typ, (ArrayType, MapType)):
-                raise AnalysisException(
+                exception = AnalysisException(
                     f"""[DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE] Cannot resolve "octet_length({snowpark_arg_names[0]})" due to data type mismatch: Parameter 1 requires the ("STRING" or "BINARY") type, however "{snowpark_arg_names[0]}" has the type "{snowpark_typed_args[0].typ}"."""
                 )
+                attach_custom_error_code(exception, ErrorCodes.TYPE_MISMATCH)
+                raise exception
             result_exp = snowpark_fn.octet_length(snowpark_args[0])
             if isinstance(snowpark_typed_args[0].typ, _FractionalType):
                 # All decimal types have to have 3 characters at a minimum.
@@ -5215,9 +5803,11 @@ def map_unresolved_function(
             )
 
             if not isinstance(snowpark_typed_args[0].typ, (_NumericType, StringType)):
-                raise AnalysisException(
+                exception = AnalysisException(
                     f"""[DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE] Cannot resolve "{function_name}({snowpark_arg_names[0]}, {snowpark_arg_names[1]}, {snowpark_arg_names[2]})" due to data type mismatch: Parameter 1 requires the "NUMERIC" type, however "value" has the type "{snowpark_typed_args[0].typ}".;"""
                 )
+                attach_custom_error_code(exception, ErrorCodes.TYPE_MISMATCH)
+                raise exception
             elif len(snowpark_args) == 3:
 
                 class PercentileUDAF:
@@ -5237,7 +5827,9 @@ def map_unresolved_function(
                     def accumulate(self, value, percentages, frequency: int):
 
                         if frequency < 0:
-                            raise ValueError(f"Negative values found in {frequency}")
+                            raise ValueError(
+                                f"[snowpark_connect::invalid_input] Negative values found in {frequency}"
+                            )
 
                         if not self.percentages:
                             self.percentages = percentages
@@ -5247,7 +5839,7 @@ def map_unresolved_function(
                                 for percentage in self.percentages
                             ):
                                 raise ValueError(
-                                    "The percentage must be between [0.0, 1.0]"
+                                    "[snowpark_connect::invalid_input] The percentage must be between [0.0, 1.0]"
                                 )
 
                         if value is None:
@@ -5293,7 +5885,9 @@ def map_unresolved_function(
                         Algorithm based on Spark code: https://github.com/apache/spark/blob/master/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/expressions/aggregate/percentiles.scala#L194
                         """
                         if not accumulated_counts:
-                            raise ValueError("accumulated_counts cannot be empty")
+                            raise ValueError(
+                                "[snowpark_connect::internal_error] accumulated_counts cannot be empty"
+                            )
 
                         total_count = accumulated_counts[-1][1]
                         position = (total_count - 1) * percentile
@@ -5353,7 +5947,7 @@ def map_unresolved_function(
                     )
                     result_type = DoubleType()
 
-                result_exp = snowpark_fn.cast(
+                result_exp = _resolve_aggregate_exp(
                     _percentile_udaf(column_value, percentage, snowpark_args[2]),
                     result_type,
                 )
@@ -5371,26 +5965,45 @@ def map_unresolved_function(
                         for arg in array_func.arguments
                     ]
                 )
-                result_exp = snowpark_fn.cast(
-                    result_exp,
-                    ArrayType(element_type=FloatType(), contains_null=False),
-                )
                 result_type = ArrayType(element_type=DoubleType(), contains_null=False)
+                result_exp = _resolve_aggregate_exp(result_exp, result_type)
                 spark_function_name = f"{function_name}({snowpark_arg_names[0]}, {snowpark_arg_names[1]}, 1)"
             else:
                 result_exp = snowpark_fn.function("percentile_cont")(
                     _check_percentile_percentage(exp.unresolved_function.arguments[1])
                 ).within_group(column_value)
-                result_exp = TypedColumn(
-                    snowpark_fn.cast(result_exp, FloatType()), lambda: [DoubleType()]
-                )
+                result_exp = _resolve_aggregate_exp(result_exp, DoubleType())
                 spark_function_name = f"{function_name}({snowpark_arg_names[0]}, {snowpark_arg_names[1]}, 1)"
         case "percentile_cont" | "percentiledisc":
             if function_name == "percentiledisc":
                 function_name = "percentile_disc"
+            order_by_col = snowpark_args[0]
+            args = exp.unresolved_function.arguments
+            if len(args) != 3:
+                exception = AssertionError(
+                    f"{function_name} expected 3 args but got {len(args)}"
+                )
+                attach_custom_error_code(exception, ErrorCodes.INTERNAL_ERROR)
+                raise exception
+            # literal value 0.0 - 1.0
+            percentage_arg = args[1]
+            sort_direction = args[2].sort_order.direction
+            direction_str = ""  # defaultValue
+            if (
+                sort_direction
+                == expressions_proto.Expression.SortOrder.SORT_DIRECTION_DESCENDING
+            ):
+                direction_str = "DESC"
+
+            # Apply sort direction to the order_by column
+            if direction_str == "DESC":
+                order_by_col_with_direction = order_by_col.desc()
+            else:
+                order_by_col_with_direction = order_by_col.asc()
+
             result_exp = snowpark_fn.function(function_name)(
-                _check_percentile_percentage(exp.unresolved_function.arguments[1])
-            ).within_group(snowpark_args[0])
+                _check_percentile_percentage(percentage_arg)
+            ).within_group(order_by_col_with_direction)
             result_exp = (
                 TypedColumn(
                     snowpark_fn.cast(result_exp, FloatType()), lambda: [DoubleType()]
@@ -5399,7 +6012,8 @@ def map_unresolved_function(
                 else TypedColumnWithDeferredCast(result_exp, lambda: [DoubleType()])
             )
 
-            spark_function_name = f"{function_name}({unwrap_literal(exp.unresolved_function.arguments[1])}) WITHIN GROUP (ORDER BY {snowpark_arg_names[0]})"
+            direction_part = f" {direction_str}" if direction_str else ""
+            spark_function_name = f"{function_name}({unwrap_literal(percentage_arg)}) WITHIN GROUP (ORDER BY {snowpark_arg_names[0]}{direction_part})"
         case "pi":
             spark_function_name = "PI()"
             result_exp = snowpark_fn.lit(math.pi)
@@ -5428,9 +6042,11 @@ def map_unresolved_function(
                 result_exp = snowpark_fn.cast(result_exp, result_type)
                 result_exp = TypedColumn(result_exp, lambda: [result_type])
             else:
-                raise AnalysisException(
+                exception = AnalysisException(
                     f"""pyspark.errors.exceptions.captured.AnalysisException: [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 ("{dividend_type}" and "{divisor_type}")."""
                 )
+                attach_custom_error_code(exception, ErrorCodes.TYPE_MISMATCH)
+                raise exception
         case "posexplode" | "posexplode_outer":
             input_type = snowpark_typed_args[0].typ
             is_nullable = function_name == "posexplode_outer"
@@ -5510,9 +6126,11 @@ def map_unresolved_function(
                     input_type.value_type,
                 ]
             else:
-                raise TypeError(
+                exception = TypeError(
                     f"Data type mismatch: {function_name} requires an array or map input, but got {input_type}."
                 )
+                attach_custom_error_code(exception, ErrorCodes.TYPE_MISMATCH)
+                raise exception
             result_exp = snowpark_fn.call_table_function(
                 posexplode_udtf.name, snowpark_args[0], snowpark_fn.lit(function_name)
             )
@@ -5535,25 +6153,35 @@ def map_unresolved_function(
         case "positive":
             arg_type = snowpark_typed_args[0].typ
             spark_function_name = f"(+ {snowpark_arg_names[0]})"
-            if isinstance(arg_type, _NumericType):
+            if (
+                isinstance(arg_type, _NumericType)
+                or isinstance(arg_type, YearMonthIntervalType)
+                or isinstance(arg_type, DayTimeIntervalType)
+            ):
                 result_exp = snowpark_args[0]
             elif isinstance(arg_type, StringType):
                 if spark_sql_ansi_enabled:
-                    raise NumberFormatException(
+                    exception = NumberFormatException(
                         f'The value \'{snowpark_args[0]}\' of the type {arg_type} cannot be cast to "DOUBLE" 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.'
                     )
+                    attach_custom_error_code(exception, ErrorCodes.INVALID_CAST)
+                    raise exception
                 else:
                     result_exp = snowpark_fn.lit(None)
             elif isinstance(arg_type, NullType):
                 result_exp = snowpark_fn.lit(None)
             else:
-                raise AnalysisException(
+                exception = AnalysisException(
                     f'[DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE] Cannot resolve "(+ {snowpark_arg_names[0]}" due to data type mismatch: '
                     f'Parameter 1 requires the ("NUMERIC") type, however "{snowpark_arg_names[0]}" has the type "{snowpark_typed_args[0]}".'
                 )
+                attach_custom_error_code(exception, ErrorCodes.TYPE_MISMATCH)
+                raise exception
             result_type = (
                 snowpark_typed_args[0].types
                 if isinstance(arg_type, _NumericType)
+                or isinstance(arg_type, YearMonthIntervalType)
+                or isinstance(arg_type, DayTimeIntervalType)
                 else DoubleType()
             )
 
@@ -5616,9 +6244,11 @@ def map_unresolved_function(
                 if not isinstance(
                     snowpark_typed_args[0].typ, (IntegerType, LongType, NullType)
                 ):
-                    raise AnalysisException(
+                    exception = AnalysisException(
                         f"""[DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE] Cannot resolve "{spark_function_name}" due to data type mismatch: Parameter 1 requires the ("INT" or "BIGINT") type, however {snowpark_arg_names[0]} has the type "{snowpark_typed_args[0].typ}"""
                     )
+                    attach_custom_error_code(exception, ErrorCodes.TYPE_MISMATCH)
+                    raise exception
                 result_exp = snowpark_fn.random(unwrap_literal(args[0]))
             else:
                 result_exp = snowpark_fn.random()
@@ -6006,9 +6636,11 @@ def map_unresolved_function(
                     ),
                     snowpark_typed_args[0].typ,
                 ):
-                    raise ArithmeticException(
+                    exception = ArithmeticException(
                         '[ARITHMETIC_OVERFLOW] Overflow. If necessary set "spark.sql.ansi.enabled" to "false" to bypass this error.'
                     )
+                    attach_custom_error_code(exception, ErrorCodes.ARITHMETIC_ERROR)
+                    raise exception
             if len(snowpark_args) == 1:
                 spark_function_name = f"{function_name}({snowpark_arg_names[0]}, 0)"
                 result_exp = snowpark_fn.round(snowpark_args[0], snowpark_fn.lit(0))
@@ -6063,21 +6695,25 @@ def map_unresolved_function(
                 exp.unresolved_function.arguments[0].WhichOneof("expr_type")
                 != "literal"
             ):
-                raise AnalysisException(
+                exception = AnalysisException(
                     "[DATATYPE_MISMATCH.NON_FOLDABLE_INPUT] Cannot resolve "
                     f'"schema_of_csv({snowpark_arg_names[0]})" due to data type mismatch: '
                     'the input csv should be a foldable "STRING" expression; however, '
                     f'got "{snowpark_arg_names[0]}".'
                 )
+                attach_custom_error_code(exception, ErrorCodes.INVALID_INPUT)
+                raise exception
 
             if isinstance(snowpark_typed_args[0].typ, StringType):
                 if exp.unresolved_function.arguments[0].literal.string == "":
-                    raise AnalysisException(
+                    exception = AnalysisException(
                         "[DATATYPE_MISMATCH.NON_FOLDABLE_INPUT] Cannot resolve "
                         f'"schema_of_csv({snowpark_arg_names[0]})" due to data type mismatch: '
                         'the input csv should be a foldable "STRING" expression; however, '
                         f'got "{snowpark_arg_names[0]}".'
                     )
+                    attach_custom_error_code(exception, ErrorCodes.INVALID_INPUT)
+                    raise exception
 
             snowpark_args = [
                 typed_arg.column(to_semi_structure=True)
@@ -6132,7 +6768,11 @@ def map_unresolved_function(
                 case [csv_data, options]:
                     result_exp = _schema_of_csv(csv_data, options)
                 case _:
-                    raise ValueError("Unrecognized from_csv parameters")
+                    exception = ValueError("Unrecognized from_csv parameters")
+                    attach_custom_error_code(
+                        exception, ErrorCodes.INVALID_FUNCTION_ARGUMENT
+                    )
+                    raise exception
             result_type = StringType()
         case "schema_of_json":
 
@@ -6250,15 +6890,19 @@ def map_unresolved_function(
                     obj = json.loads(json_str)
                     return _infer_pyspark_type(obj)
                 except json.JSONDecodeError as e:
-                    raise ValueError(f"Invalid JSON: {e}")
+                    raise ValueError(
+                        f"[snowpark_connect::invalid_input] Invalid JSON: {e}"
+                    )
 
             if (
                 exp.unresolved_function.arguments[0].WhichOneof("expr_type")
                 != "literal"
             ):
-                raise AnalysisException(
+                exception = AnalysisException(
                     f"""[DATATYPE_MISMATCH.NON_FOLDABLE_INPUT] Cannot resolve "schema_of_json({",".join(snowpark_arg_names)})" due to data type mismatch: the input json should be a foldable "STRING" expression; however, got "{",".join(snowpark_arg_names)}"."""
                 )
+                attach_custom_error_code(exception, ErrorCodes.INVALID_INPUT)
+                raise exception
             result_exp = _infer_schema(snowpark_args[0])
             result_type = StringType()
         case "sec":
@@ -6299,12 +6943,14 @@ def map_unresolved_function(
                 not isinstance(snowpark_typed_args[0].typ, _IntegralType)
                 or not isinstance(snowpark_typed_args[1].typ, _IntegralType)
             ):
-                raise AnalysisException(
+                exception = AnalysisException(
                     f"""[DATATYPE_MISMATCH.SEQUENCE_WRONG_INPUT_TYPES] Cannot resolve "sequence({snowpark_arg_names[0]}, {snowpark_arg_names[1]})" due to data type mismatch: `sequence` uses the wrong parameter type. The parameter type must conform to:
                         1. The start and stop expressions must resolve to the same type.
                         2. Otherwise, if start and stop expressions resolve to the "INTEGRAL" type, then the step expression must resolve to the same type.
                     """
                 )
+                attach_custom_error_code(exception, ErrorCodes.TYPE_MISMATCH)
+                raise exception
             result_exp = snowpark_fn.cast(
                 snowpark_fn.sequence(*snowpark_args),
                 ArrayType(LongType(), contains_null=False),
@@ -6322,15 +6968,21 @@ def map_unresolved_function(
             num_bits = unwrap_literal(exp.unresolved_function.arguments[1])
             if num_bits is None:
                 if spark_sql_ansi_enabled:
-                    raise NumberFormatException(
+                    exception = NumberFormatException(
                         f"""[CAST_INVALID_INPUT] The value {snowpark_arg_names[0]} of the type "{snowpark_typed_args[0].typ}" cannot be cast to "INT" because it is malformed. Correct the value as per the syntax, or change its target type."""
                     )
+                    attach_custom_error_code(exception, ErrorCodes.INVALID_CAST)
+                    raise exception
                 result_exp = snowpark_fn.lit(None)
                 result_type = StringType()
             elif num_bits not in bit_values:
-                raise IllegalArgumentException(
+                exception = IllegalArgumentException(
                     f"""requirement failed: numBits {num_bits} is not in the permitted values (0, 224, 256, 384, 512)"""
                 )
+                attach_custom_error_code(
+                    exception, ErrorCodes.INVALID_FUNCTION_ARGUMENT
+                )
+                raise exception
             else:
                 # 0 equivalent to 256 in PySpark, but is not allowed in Snowpark
                 num_bits = 256 if num_bits == 0 else num_bits
@@ -6400,11 +7052,43 @@ def map_unresolved_function(
                 fn_name = "sign"
 
             spark_function_name = f"{fn_name}({snowpark_arg_names[0]})"
-            result_exp = snowpark_fn.when(
-                snowpark_args[0] == NAN, snowpark_fn.lit(NAN)
-            ).otherwise(
-                snowpark_fn.cast(snowpark_fn.sign(snowpark_args[0]), DoubleType())
-            )
+
+            if isinstance(snowpark_typed_args[0].typ, YearMonthIntervalType):
+                # Use SQL expression for zero year-month interval comparison
+                result_exp = (
+                    snowpark_fn.when(
+                        snowpark_args[0]
+                        > snowpark_fn.sql_expr("INTERVAL '0-0' YEAR TO MONTH"),
+                        snowpark_fn.lit(1.0),
+                    )
+                    .when(
+                        snowpark_args[0]
+                        < snowpark_fn.sql_expr("INTERVAL '0-0' YEAR TO MONTH"),
+                        snowpark_fn.lit(-1.0),
+                    )
+                    .otherwise(snowpark_fn.lit(0.0))
+                )
+            elif isinstance(snowpark_typed_args[0].typ, DayTimeIntervalType):
+                # Use SQL expression for zero day-time interval comparison
+                result_exp = (
+                    snowpark_fn.when(
+                        snowpark_args[0]
+                        > snowpark_fn.sql_expr("INTERVAL '0 0:0:0' DAY TO SECOND"),
+                        snowpark_fn.lit(1.0),
+                    )
+                    .when(
+                        snowpark_args[0]
+                        < snowpark_fn.sql_expr("INTERVAL '0 0:0:0' DAY TO SECOND"),
+                        snowpark_fn.lit(-1.0),
+                    )
+                    .otherwise(snowpark_fn.lit(0.0))
+                )
+            else:
+                result_exp = snowpark_fn.when(
+                    snowpark_args[0] == NAN, snowpark_fn.lit(NAN)
+                ).otherwise(
+                    snowpark_fn.cast(snowpark_fn.sign(snowpark_args[0]), DoubleType())
+                )
             result_type = DoubleType()
         case "sin":
             spark_function_name = f"SIN({snowpark_arg_names[0]})"
@@ -6504,9 +7188,11 @@ def map_unresolved_function(
             if len(snowpark_args) == 2 and not isinstance(
                 snowpark_typed_args[1].typ, BooleanType
             ):
-                raise AnalysisException(
+                exception = AnalysisException(
                     f'[DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE] Cannot resolve "{spark_function_name}" due to data type mismatch: Parameter 2 requires the "BOOLEAN" type, however "{snowpark_arg_names[1]}" has the type "{snowpark_typed_args[1].typ.simpleString().upper()}"'
                 )
+                attach_custom_error_code(exception, ErrorCodes.TYPE_MISMATCH)
+                raise exception
             sort_asc = (
                 unwrap_literal(exp.unresolved_function.arguments[1])
                 if len(snowpark_args) == 2
@@ -6557,10 +7243,10 @@ def map_unresolved_function(
                 import re
 
                 try:
-                    re.compile(pattern)
+                    compiled_pattern = re.compile(pattern)
                 except re.error:
                     raise ValueError(
-                        f"Failed to split string, provided pattern: {pattern} is invalid"
+                        f"[snowpark_connect::invalid_input] Failed to split string, provided pattern: {pattern} is invalid"
                     )
 
                 if limit == 1:
@@ -6579,7 +7265,7 @@ def map_unresolved_function(
 
                 match pattern:
                     case "|":
-                        split_result = re.split(pattern, input, 0)
+                        split_result = compiled_pattern.split(input, 0)
                         input_limit = limit + 1 if limit > 0 else len(split_result)
                         return (
                             split_result
@@ -6591,7 +7277,7 @@ def map_unresolved_function(
                     case "^":
                         return [input]
                     case _:
-                        return re.split(pattern, input, maxsplit)
+                        return compiled_pattern.split(input, maxsplit)
 
             def split_string(str_: Column, pattern: Column, limit: Column):
                 native_split = _split(str_, pattern, limit)
@@ -6639,9 +7325,24 @@ def map_unresolved_function(
                 case [str_, pattern, limit]:  # noqa: F841
                     result_exp = split_string(str_, pattern, limit)
                 case _:
-                    raise ValueError(f"Invalid number of arguments to {function_name}")
+                    exception = ValueError(
+                        f"Invalid number of arguments to {function_name}"
+                    )
+                    attach_custom_error_code(
+                        exception, ErrorCodes.INVALID_FUNCTION_ARGUMENT
+                    )
+                    raise exception
         case "split_part":
-            result_exp = snowpark_fn.call_function("split_part", *snowpark_args)
+            # Check for index 0 and throw error to match PySpark behavior
+            raise_error = _raise_error_helper(StringType(), SparkRuntimeException)
+            result_exp = snowpark_fn.when(
+                snowpark_args[2] == 0,
+                raise_error(
+                    snowpark_fn.lit(
+                        "[INVALID_INDEX_OF_ZERO] The index 0 is invalid. An index shall be either < 0 or > 0 (the first element has index 1)."
+                    )
+                ),
+            ).otherwise(snowpark_fn.call_function("split_part", *snowpark_args))
             result_type = StringType()
         case "sqrt":
             spark_function_name = f"SQRT({snowpark_arg_names[0]})"
@@ -6649,9 +7350,11 @@ def map_unresolved_function(
             if isinstance(snowpark_typed_args[0].typ, StringType):
                 sqrt_arg = snowpark_fn.try_cast(snowpark_args[0], DoubleType())
             elif not isinstance(snowpark_typed_args[0].typ, _NumericType):
-                raise AnalysisException(
+                exception = AnalysisException(
                     f"""[DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE] Cannot resolve "SQRT({snowpark_arg_names[0]})" due to data type mismatch: Parameter 1 requires the "DOUBLE" type, however "{snowpark_arg_names[0]}" has the type "{snowpark_typed_args[0].typ}"."""
                 )
+                attach_custom_error_code(exception, ErrorCodes.TYPE_MISMATCH)
+                raise exception
             result_exp = (
                 snowpark_fn.when(sqrt_arg < 0, NAN)
                 .when(sqrt_arg.isNull(), snowpark_fn.lit(None))
@@ -6663,16 +7366,22 @@ def map_unresolved_function(
             # will depend on the input specified. All arguments in the input (apart from the first one that specifies
             # `num_rows`) must be the same type.
             if len(exp.unresolved_function.arguments) <= 1:
-                raise AnalysisException(
+                exception = AnalysisException(
                     f"""
                     [WRONG_NUM_ARGS.WITHOUT_SUGGESTION] The `stack` requires > 1 parameters but the actual number is {len(exp.unresolved_function.arguments)}.
                     """
                 )
+                attach_custom_error_code(
+                    exception, ErrorCodes.INVALID_FUNCTION_ARGUMENT
+                )
+                raise exception
             num_rows = unwrap_literal(exp.unresolved_function.arguments[0])
             if not isinstance(snowpark_typed_args[0].typ, IntegerType):
-                raise AnalysisException(
+                exception = AnalysisException(
                     f"""[DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE] Cannot resolve "{snowpark_arg_names[0]}" due to data type mismatch: Parameter 1 requires the "INT" type, however "{num_rows}" has the type "{snowpark_typed_args[0].typ}"."""
                 )
+                attach_custom_error_code(exception, ErrorCodes.TYPE_MISMATCH)
+                raise exception
 
             num_arguments = len(snowpark_args) - 1
             num_cols = math.ceil(num_arguments / num_rows)
@@ -6683,9 +7392,11 @@ def map_unresolved_function(
                 if arg != spark_col_types[i % num_cols] and not isinstance(
                     arg, NullType
                 ):
-                    raise AnalysisException(
+                    exception = AnalysisException(
                         f"""[DATATYPE_MISMATCH.STACK_COLUMN_DIFF_TYPES] Cannot resolve "stack({snowpark_arg_names[0]})" due to data type mismatch: The data type of the column ({snowpark_arg_names[0]}) do not have the same type."""
                     )
+                    attach_custom_error_code(exception, ErrorCodes.TYPE_MISMATCH)
+                    raise exception
                 if isinstance(arg, NullType):
                     spark_col_types[i] = VariantType()
                     snowpark_args[i + 1] = snowpark_fn.cast(
@@ -6742,9 +7453,11 @@ def map_unresolved_function(
                         snowpark_args[0], DoubleType()
                     )
                 else:
-                    raise AnalysisException(
+                    exception = AnalysisException(
                         f"""AnalysisException: [DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE] Cannot resolve "stddev({snowpark_arg_names[0]}" due to data type mismatch: Parameter 1 requires the "DOUBLE" type, however "{snowpark_arg_names[0]}" has the type "{snowpark_typed_args[0].typ}".;"""
                     )
+                    attach_custom_error_code(exception, ErrorCodes.TYPE_MISMATCH)
+                    raise exception
             result_exp = snowpark_fn.stddev(stddev_argument)
             result_type = DoubleType()
         case "stddev_pop":
@@ -6755,9 +7468,11 @@ def map_unresolved_function(
                         snowpark_args[0], DoubleType()
                     )
                 else:
-                    raise AnalysisException(
+                    exception = AnalysisException(
                         f"""AnalysisException: [DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE] Cannot resolve "stddev_pop({snowpark_arg_names[0]}" due to data type mismatch: Parameter 1 requires the "DOUBLE" type, however "{snowpark_arg_names[0]}" has the type "{snowpark_typed_args[0].typ}".;"""
                     )
+                    attach_custom_error_code(exception, ErrorCodes.TYPE_MISMATCH)
+                    raise exception
             result_exp = snowpark_fn.stddev_pop(stddev_pop_argument)
             result_type = DoubleType()
         case "stddev_samp" | "std":
@@ -6768,9 +7483,11 @@ def map_unresolved_function(
                         snowpark_args[0], DoubleType()
                     )
                 else:
-                    raise AnalysisException(
+                    exception = AnalysisException(
                         f"""AnalysisException: [DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE] Cannot resolve "stddev_samp({snowpark_arg_names[0]}" due to data type mismatch: Parameter 1 requires the "DOUBLE" type, however "{snowpark_arg_names[0]}" has the type "{snowpark_typed_args[0].typ}".;"""
                     )
+                    attach_custom_error_code(exception, ErrorCodes.TYPE_MISMATCH)
+                    raise exception
             result_exp = snowpark_fn.stddev_samp(stddev_samp_argument)
             result_type = DoubleType()
         case "str_to_map":
@@ -6818,7 +7535,7 @@ def map_unresolved_function(
 
                     if key in result_map and not allow_dups:
                         raise ValueError(
-                            DUPLICATE_KEY_FOUND_ERROR_TEMPLATE.format(key=key)
+                            f"[snowpark_connect::invalid_input] {DUPLICATE_KEY_FOUND_ERROR_TEMPLATE.format(key=key)}"
                         )
 
                     result_map[key] = val
@@ -6957,9 +7674,11 @@ def map_unresolved_function(
             result_type = TimestampType(snowpark.types.TimestampTimeZone.LTZ)
         case "timestamp_millis":
             if not isinstance(snowpark_typed_args[0].typ, _IntegralType):
-                raise AnalysisException(
+                exception = AnalysisException(
                     f'[DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE] Cannot resolve "timestamp_millis({snowpark_arg_names[0]}" due to data type mismatch: Parameter 1 requires the "INTEGRAL" type, however "{snowpark_arg_names[0]}" has the type "{snowpark_typed_args[0].typ}".'
                 )
+                attach_custom_error_code(exception, ErrorCodes.TYPE_MISMATCH)
+                raise exception
             result_exp = snowpark_fn.cast(
                 snowpark_fn.to_timestamp(snowpark_args[0] * 1_000, 6),
                 TimestampType(snowpark.types.TimestampTimeZone.LTZ),
@@ -6970,9 +7689,11 @@ def map_unresolved_function(
             # even though the documentation explicitly says that it does.
             # As a workaround, use integer milliseconds instead of fractional seconds.
             if not isinstance(snowpark_typed_args[0].typ, _NumericType):
-                raise AnalysisException(
+                exception = AnalysisException(
                     f"""AnalysisException: [DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE] Cannot resolve "{function_name}({snowpark_arg_names[0]})" due to data type mismatch: Parameter 1 requires the "NUMERIC" type, however "{snowpark_arg_names[0]}" has the type "{snowpark_typed_args[0].typ}".;"""
                 )
+                attach_custom_error_code(exception, ErrorCodes.TYPE_MISMATCH)
+                raise exception
             result_exp = snowpark_fn.cast(
                 snowpark_fn.to_timestamp(
                     snowpark_fn.cast(snowpark_args[0] * 1_000_000, LongType()), 6
@@ -7145,7 +7866,7 @@ def map_unresolved_function(
                 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."
+                            "[snowpark_connect::invalid_input] [INVALID_OPTIONS.NON_MAP_FUNCTION] Invalid options: Must use the `map()` function for options."
                         )
 
                     python_to_snowflake_type = {
@@ -7164,7 +7885,7 @@ def map_unresolved_function(
                                 type(v).__name__, type(v).__name__.upper()
                             )
                             raise TypeError(
-                                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}>".'
+                                f'[snowpark_connect::type_mismatch] [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 {}
@@ -7302,7 +8023,7 @@ def map_unresolved_function(
                                 result.append(escape_and_quote_string(str_value))
                             case _:
                                 raise ValueError(
-                                    f"Unable to determine type for value: {python_type}"
+                                    f"[snowpark_connect::type_mismatch] Unable to determine type for value: {python_type}"
                                 )
                     elif isinstance(value, str):
                         strip_value = (
@@ -7335,9 +8056,11 @@ def map_unresolved_function(
             if len(snowpark_arg_names) > 1 and snowpark_arg_names[1].startswith(
                 "named_struct"
             ):
-                raise TypeError(
+                exception = TypeError(
                     "[INVALID_OPTIONS.NON_MAP_FUNCTION] Invalid options: Must use the `map()` function for options."
                 )
+                attach_custom_error_code(exception, ErrorCodes.INVALID_INPUT)
+                raise exception
 
             def get_snowpark_type_name(snowpark_type: DataType) -> str:
                 return (
@@ -7370,7 +8093,11 @@ def map_unresolved_function(
                 case [csv_data, options]:
                     result_exp = _to_csv(csv_data, field_names, field_types, options)
                 case _:
-                    raise ValueError("Unrecognized from_csv parameters")
+                    exception = ValueError("Unrecognized from_csv parameters")
+                    attach_custom_error_code(
+                        exception, ErrorCodes.INVALID_FUNCTION_ARGUMENT
+                    )
+                    raise exception
             result_type = StringType()
         case "to_date":
             if not spark_sql_ansi_enabled:
@@ -7397,23 +8124,29 @@ def map_unresolved_function(
                 case NullType():
                     result_exp = snowpark_fn.lit(None)
                 case _:
-                    raise AnalysisException(
+                    exception = AnalysisException(
                         f'[DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE] Cannot resolve "to_date({snowpark_arg_names[0]}" due to data type mismatch: Parameter 1 requires the ("STRING" or "DATE" or "TIMESTAMP" or "TIMESTAMP_NTZ") type, however "{snowpark_arg_names[0]}" has the type "{snowpark_typed_args[0].typ}".'
                     )
+                    attach_custom_error_code(exception, ErrorCodes.TYPE_MISMATCH)
+                    raise exception
 
             result_type = DateType()
         case "to_json":
             if len(snowpark_args) > 1:
                 if not isinstance(snowpark_typed_args[1].typ, MapType):
-                    raise AnalysisException(
+                    exception = AnalysisException(
                         "[INVALID_OPTIONS.NON_MAP_FUNCTION] Invalid options: Must use the `map()` function for options."
                     )
+                    attach_custom_error_code(exception, ErrorCodes.INVALID_INPUT)
+                    raise exception
                 if not isinstance(
                     snowpark_typed_args[1].typ.key_type, StringType
                 ) or not isinstance(snowpark_typed_args[1].typ.value_type, StringType):
-                    raise AnalysisException(
+                    exception = AnalysisException(
                         f"""[INVALID_OPTIONS.NON_STRING_TYPE] Invalid options: A type of keys and values in `map()` must be string, but got "{snowpark_typed_args[1].typ.simpleString().upper()}"."""
                     )
+                    attach_custom_error_code(exception, ErrorCodes.TYPE_MISMATCH)
+                    raise exception
             result_exp = snowpark_fn.to_json(snowpark_fn.to_variant(snowpark_args[0]))
             result_type = StringType()
         case "to_number":
@@ -7468,7 +8201,13 @@ def map_unresolved_function(
                         )
                     )
                 case _:
-                    raise ValueError(f"Invalid number of arguments to {function_name}")
+                    exception = ValueError(
+                        f"Invalid number of arguments to {function_name}"
+                    )
+                    attach_custom_error_code(
+                        exception, ErrorCodes.INVALID_FUNCTION_ARGUMENT
+                    )
+                    raise exception
             result_exp = snowpark_fn.cast(result_exp, get_timestamp_type())
             result_type = get_timestamp_type()
 
@@ -7486,7 +8225,13 @@ def map_unresolved_function(
                         ),
                     )
                 case _:
-                    raise ValueError(f"Invalid number of arguments to {function_name}")
+                    exception = ValueError(
+                        f"Invalid number of arguments to {function_name}"
+                    )
+                    attach_custom_error_code(
+                        exception, ErrorCodes.INVALID_FUNCTION_ARGUMENT
+                    )
+                    raise exception
             result_exp = snowpark_fn.cast(
                 result_exp, TimestampType(snowpark.types.TimestampTimeZone.LTZ)
             )
@@ -7511,7 +8256,13 @@ def map_unresolved_function(
                         ),
                     )
                 case _:
-                    raise ValueError(f"Invalid number of arguments to {function_name}")
+                    exception = ValueError(
+                        f"Invalid number of arguments to {function_name}"
+                    )
+                    attach_custom_error_code(
+                        exception, ErrorCodes.INVALID_FUNCTION_ARGUMENT
+                    )
+                    raise exception
             result_exp = snowpark_fn.cast(
                 result_exp, TimestampType(snowpark.types.TimestampTimeZone.NTZ)
             )
@@ -7553,9 +8304,13 @@ def map_unresolved_function(
                         snowpark_fn.lit("YYYY-MM-DD HH24:MI:SS"),
                     )
                 case _:
-                    raise SnowparkConnectNotImplementedError(
+                    exception = SnowparkConnectNotImplementedError(
                         "to_unix_timestamp expected 1 or 2 arguments."
                     )
+                    attach_custom_error_code(
+                        exception, ErrorCodes.INVALID_FUNCTION_ARGUMENT
+                    )
+                    raise exception
 
             if len(exp.unresolved_function.arguments) == 1:
                 spark_function_name = f"to_unix_timestamp({snowpark_arg_names[0]}, {'yyyy-MM-dd HH:mm:ss'})"
@@ -7617,14 +8372,123 @@ def map_unresolved_function(
                 )
             result_type = DateType()
         case "try_add":
-            # Check for interval types and throw NotImplementedError
-            for arg in snowpark_typed_args:
-                if isinstance(arg.typ, (YearMonthIntervalType, DayTimeIntervalType)):
-                    raise NotImplementedError(
-                        "try_add with interval types is not supported"
+            # Handle interval arithmetic with overflow detection
+            match (snowpark_typed_args[0].typ, snowpark_typed_args[1].typ):
+                case (DateType(), t) | (t, DateType()) if isinstance(
+                    t, YearMonthIntervalType
+                ):
+                    result_type = DateType()
+                    result_exp = snowpark_args[0] + snowpark_args[1]
+                case (DateType(), t) | (t, DateType()) if isinstance(
+                    t, DayTimeIntervalType
+                ):
+                    result_type = TimestampType()
+                    result_exp = snowpark_args[0] + snowpark_args[1]
+                case (TimestampType(), t) | (t, TimestampType()) if isinstance(
+                    t, (DayTimeIntervalType, YearMonthIntervalType)
+                ):
+                    result_type = (
+                        snowpark_typed_args[0].typ
+                        if isinstance(snowpark_typed_args[0].typ, TimestampType)
+                        else snowpark_typed_args[1].typ
                     )
-            result_exp = _try_arithmetic_helper(snowpark_typed_args, snowpark_args, 0)
-            result_exp = _type_with_typer(result_exp)
+                    result_exp = snowpark_args[0] + snowpark_args[1]
+                case (t1, t2) if (
+                    isinstance(t1, YearMonthIntervalType)
+                    and isinstance(t2, (_NumericType, StringType))
+                ) or (
+                    isinstance(t2, YearMonthIntervalType)
+                    and isinstance(t1, (_NumericType, StringType))
+                ):
+                    # YearMonthInterval + numeric/string or numeric/string + YearMonthInterval should throw error
+                    exception = AnalysisException(
+                        f'[DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES] Cannot resolve "try_add({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}").'
+                    )
+                    attach_custom_error_code(exception, ErrorCodes.TYPE_MISMATCH)
+                    raise exception
+                case (t1, t2) if isinstance(t1, YearMonthIntervalType) and isinstance(
+                    t2, YearMonthIntervalType
+                ):
+                    result_type = YearMonthIntervalType(
+                        min(t1.start_field, t2.start_field),
+                        max(t1.end_field, t2.end_field),
+                    )
+
+                    # For year-month intervals, throw ArithmeticException if operands reach 10+ digits OR result exceeds 9 digits
+                    total1 = _calculate_total_months(snowpark_args[0])
+                    total2 = _calculate_total_months(snowpark_args[1])
+                    ten_digit_limit = snowpark_fn.lit(MAX_10_DIGIT_LIMIT)
+
+                    precision_violation = (
+                        # Check if either operand already reaches 10 digits (parsing limit)
+                        (snowpark_fn.abs(total1) >= ten_digit_limit)
+                        | (snowpark_fn.abs(total2) >= ten_digit_limit)
+                        | (
+                            (total1 > 0)
+                            & (total2 > 0)
+                            & (total1 >= ten_digit_limit - total2)
+                        )
+                        | (
+                            (total1 < 0)
+                            & (total2 < 0)
+                            & (total1 <= -ten_digit_limit - total2)
+                        )
+                    )
+
+                    raise_error = _raise_error_helper(result_type, ArithmeticException)
+                    result_exp = snowpark_fn.when(
+                        precision_violation,
+                        raise_error(
+                            snowpark_fn.lit(
+                                "Year-Month Interval result exceeds Snowflake interval precision limit"
+                            )
+                        ),
+                    ).otherwise(snowpark_args[0] + snowpark_args[1])
+                case (t1, t2) if isinstance(t1, DayTimeIntervalType) and isinstance(
+                    t2, DayTimeIntervalType
+                ):
+                    result_type = DayTimeIntervalType(
+                        min(t1.start_field, t2.start_field),
+                        max(t1.end_field, t2.end_field),
+                    )
+                    # Check for Snowflake's day limit (106751991 days is the cutoff)
+                    days1 = snowpark_fn.date_part("day", snowpark_args[0])
+                    days2 = snowpark_fn.date_part("day", snowpark_args[1])
+                    max_days = snowpark_fn.lit(
+                        MAX_DAY_TIME_DAYS
+                    )  # Snowflake's actual limit
+                    min_days = snowpark_fn.lit(-MAX_DAY_TIME_DAYS)
+
+                    # Check if either operand exceeds the day limit - throw error like Spark does
+                    operand_limit_violation = (snowpark_fn.abs(days1) > max_days) | (
+                        snowpark_fn.abs(days2) > max_days
+                    )
+
+                    # Check if result would exceed day limit (but operands are valid) - return NULL
+                    result_overflow = (
+                        # Check if result would exceed day limit (positive overflow)
+                        ((days1 > 0) & (days2 > 0) & (days1 > max_days - days2))
+                        | ((days1 < 0) & (days2 < 0) & (days1 < min_days - days2))
+                    )
+
+                    raise_error = _raise_error_helper(result_type, ArithmeticException)
+                    result_exp = (
+                        snowpark_fn.when(
+                            operand_limit_violation,
+                            raise_error(
+                                snowpark_fn.lit(
+                                    "Day-Time Interval operand exceeds Snowflake interval precision limit"
+                                )
+                            ),
+                        )
+                        .when(result_overflow, snowpark_fn.lit(None))
+                        .otherwise(snowpark_args[0] + snowpark_args[1])
+                    )
+                case _:
+                    result_exp = _try_arithmetic_helper(
+                        snowpark_typed_args, snowpark_args, 0
+                    )
+                    result_exp = _type_with_typer(result_exp)
         case "try_aes_decrypt":
             result_exp = _aes_helper(
                 "TRY_DECRYPT",
@@ -7676,13 +8540,49 @@ def map_unresolved_function(
                         DoubleType(), cleaned, calculating_avg=True
                     )
         case "try_divide":
-            # Check for interval types and throw NotImplementedError
-            for arg in snowpark_typed_args:
-                if isinstance(arg.typ, (YearMonthIntervalType, DayTimeIntervalType)):
-                    raise NotImplementedError(
-                        "try_divide with interval types is not supported"
-                    )
+            # Handle interval division with overflow detection
             match (snowpark_typed_args[0].typ, snowpark_typed_args[1].typ):
+                case (t1, t2) if isinstance(t1, _AnsiIntervalType) and isinstance(
+                    t2, (_NumericType, StringType)
+                ):
+                    # Interval / numeric/string
+                    result_type = t1
+                    interval_arg = snowpark_args[0]
+                    divisor = (
+                        snowpark_args[1]
+                        if isinstance(t2, _NumericType)
+                        else snowpark_fn.cast(snowpark_args[1], "double")
+                    )
+
+                    # Check for division by zero first
+                    zero_check = divisor == 0
+
+                    if isinstance(result_type, YearMonthIntervalType):
+                        # For year-month intervals, check if result exceeds 32-bit signed integer limit
+                        result_type = YearMonthIntervalType()
+                        total_months = _calculate_total_months(interval_arg)
+                        max_months = snowpark_fn.lit(MAX_32BIT_SIGNED_INT)
+                        overflow_check = (
+                            snowpark_fn.abs(total_months / divisor) > max_months
+                        )
+                        result_exp = (
+                            snowpark_fn.when(zero_check, snowpark_fn.lit(None))
+                            .when(overflow_check, snowpark_fn.lit(None))
+                            .otherwise(interval_arg / divisor)
+                        )
+                    else:  # DayTimeIntervalType
+                        # For day-time intervals, check if result exceeds day limit
+                        result_type = DayTimeIntervalType()
+                        total_days = _calculate_total_days(interval_arg)
+                        max_days = snowpark_fn.lit(MAX_DAY_TIME_DAYS)
+                        overflow_check = (
+                            snowpark_fn.abs(total_days / divisor) > max_days
+                        )
+                        result_exp = (
+                            snowpark_fn.when(zero_check, snowpark_fn.lit(None))
+                            .when(overflow_check, snowpark_fn.lit(None))
+                            .otherwise(interval_arg / divisor)
+                        )
                 case (NullType(), t) | (t, NullType()):
                     result_exp = snowpark_fn.lit(None)
                     result_type = FloatType()
@@ -7742,9 +8642,11 @@ def map_unresolved_function(
                     ).otherwise(cleaned_left / cleaned_right)
                     result_exp = _type_with_typer(result_exp)
                 case (_, _):
-                    raise AnalysisException(
+                    exception = AnalysisException(
                         f"Incompatible types: {snowpark_typed_args[0].typ}, {snowpark_typed_args[1].typ}"
                     )
+                    attach_custom_error_code(exception, ErrorCodes.TYPE_MISMATCH)
+                    raise exception
 
         case "try_element_at":
             # For structured ArrayType and MapType columns, Snowflake raises an error when an index is out of bounds or a key does not exist.
@@ -7786,17 +8688,82 @@ def map_unresolved_function(
                 case _:
                     # Currently we do not handle VariantType columns as the first argument here.
                     # Spark will not support VariantType until 4.0.0, revisit this when the support is added.
-                    raise AnalysisException(
+                    exception = AnalysisException(
                         f"Expected either (ArrayType, IntegralType) or (MapType, StringType), got {snowpark_typed_args[0].typ}, {snowpark_typed_args[1].typ}."
                     )
+                    attach_custom_error_code(exception, ErrorCodes.TYPE_MISMATCH)
+                    raise exception
         case "try_multiply":
-            # Check for interval types and throw NotImplementedError
-            for arg in snowpark_typed_args:
-                if isinstance(arg.typ, (YearMonthIntervalType, DayTimeIntervalType)):
-                    raise NotImplementedError(
-                        "try_multiply with interval types is not supported"
-                    )
             match (snowpark_typed_args[0].typ, snowpark_typed_args[1].typ):
+                case (t1, t2) if isinstance(t1, _AnsiIntervalType) and isinstance(
+                    t2, (_NumericType, StringType)
+                ):
+                    # Interval * numeric/string
+                    result_type = t1
+                    interval_arg = snowpark_args[0]
+                    multiplier = (
+                        snowpark_args[1]
+                        if isinstance(t2, _NumericType)
+                        else snowpark_fn.cast(snowpark_args[1], "double")
+                    )
+
+                    if isinstance(result_type, YearMonthIntervalType):
+                        # For year-month intervals, check if result exceeds 32-bit signed integer limit
+                        result_type = YearMonthIntervalType()
+                        total_months = _calculate_total_months(interval_arg)
+                        max_months = snowpark_fn.lit(MAX_32BIT_SIGNED_INT)
+                        overflow_check = (
+                            snowpark_fn.abs(total_months * multiplier) > max_months
+                        )
+                        result_exp = snowpark_fn.when(
+                            overflow_check, snowpark_fn.lit(None)
+                        ).otherwise(interval_arg * multiplier)
+                    else:  # DayTimeIntervalType
+                        # For day-time intervals, check if result exceeds day limit
+                        result_type = DayTimeIntervalType()
+                        total_days = _calculate_total_days(interval_arg)
+                        max_days = snowpark_fn.lit(MAX_DAY_TIME_DAYS)
+                        overflow_check = (
+                            snowpark_fn.abs(total_days * multiplier) > max_days
+                        )
+                        result_exp = snowpark_fn.when(
+                            overflow_check, snowpark_fn.lit(None)
+                        ).otherwise(interval_arg * multiplier)
+
+                case (t1, t2) if isinstance(t2, _AnsiIntervalType) and isinstance(
+                    t1, (_NumericType, StringType)
+                ):
+                    # numeric/string * Interval
+                    result_type = t2
+                    interval_arg = snowpark_args[1]
+                    multiplier = (
+                        snowpark_args[0]
+                        if isinstance(t1, _NumericType)
+                        else snowpark_fn.cast(snowpark_args[0], "double")
+                    )
+
+                    if isinstance(result_type, YearMonthIntervalType):
+                        # For year-month intervals, check if result exceeds 32-bit signed integer limit
+                        result_type = YearMonthIntervalType()
+                        total_months = _calculate_total_months(interval_arg)
+                        max_months = snowpark_fn.lit(MAX_32BIT_SIGNED_INT)
+                        overflow_check = (
+                            snowpark_fn.abs(total_months * multiplier) > max_months
+                        )
+                        result_exp = snowpark_fn.when(
+                            overflow_check, snowpark_fn.lit(None)
+                        ).otherwise(interval_arg * multiplier)
+                    else:  # DayTimeIntervalType
+                        # For day-time intervals, check if result exceeds day limit
+                        result_type = DayTimeIntervalType()
+                        total_days = _calculate_total_days(interval_arg)
+                        max_days = snowpark_fn.lit(MAX_DAY_TIME_DAYS)
+                        overflow_check = (
+                            snowpark_fn.abs(total_days * multiplier) > max_days
+                        )
+                        result_exp = snowpark_fn.when(
+                            overflow_check, snowpark_fn.lit(None)
+                        ).otherwise(interval_arg * multiplier)
                 case (NullType(), t) | (t, NullType()):
                     result_exp = snowpark_fn.lit(None)
                     match t:
@@ -7870,9 +8837,11 @@ def map_unresolved_function(
                     result_exp = cleaned_left * cleaned_right
                     result_exp = _type_with_typer(result_exp)
                 case (_, _):
-                    raise AnalysisException(
+                    exception = AnalysisException(
                         f"Incompatible types: {snowpark_typed_args[0].typ}, {snowpark_typed_args[1].typ}"
                     )
+                    attach_custom_error_code(exception, ErrorCodes.TYPE_MISMATCH)
+                    raise exception
         case "try_sum":
             # Snowflake raises an error when a value that cannot be cast into a numeric is passed to SUM. Spark treats these as NULL values and
             # does not throw an error. Additionally, Spark returns NULL when this calculation results in an overflow, whereas Snowflake raises a "TypeError".
@@ -7894,14 +8863,112 @@ def map_unresolved_function(
                     snowpark_typed_args[0].typ, snowpark_args[0]
                 )
         case "try_subtract":
-            # Check for interval types and throw NotImplementedError
-            for arg in snowpark_typed_args:
-                if isinstance(arg.typ, (YearMonthIntervalType, DayTimeIntervalType)):
-                    raise NotImplementedError(
-                        "try_subtract with interval types is not supported"
+            # Handle interval arithmetic with overflow detection
+            match (snowpark_typed_args[0].typ, snowpark_typed_args[1].typ):
+                case (DateType(), t) if isinstance(t, YearMonthIntervalType):
+                    result_type = DateType()
+                    result_exp = snowpark_args[0] - snowpark_args[1]
+                case (DateType(), t) if isinstance(t, DayTimeIntervalType):
+                    result_type = TimestampType()
+                    result_exp = snowpark_args[0] - snowpark_args[1]
+                case (TimestampType(), t) if isinstance(
+                    t, (DayTimeIntervalType, YearMonthIntervalType)
+                ):
+                    result_type = snowpark_typed_args[0].typ
+                    result_exp = snowpark_args[0] - snowpark_args[1]
+                case (t1, t2) if (
+                    isinstance(t1, YearMonthIntervalType)
+                    and isinstance(t2, (_NumericType, StringType))
+                ) or (
+                    isinstance(t2, YearMonthIntervalType)
+                    and isinstance(t1, (_NumericType, StringType))
+                ):
+                    # YearMonthInterval - numeric/string or numeric/string - YearMonthInterval should throw error
+                    exception = AnalysisException(
+                        f'[DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES] Cannot resolve "try_subtract({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}").'
+                    )
+                    attach_custom_error_code(exception, ErrorCodes.TYPE_MISMATCH)
+                    raise exception
+                case (t1, t2) if isinstance(t1, YearMonthIntervalType) and isinstance(
+                    t2, YearMonthIntervalType
+                ):
+                    result_type = YearMonthIntervalType(
+                        min(t1.start_field, t2.start_field),
+                        max(t1.end_field, t2.end_field),
+                    )
+                    # Check for Snowflake's precision limits: 10+ digits for operands, 9+ digits for results
+                    total1 = _calculate_total_months(snowpark_args[0])
+                    total2 = _calculate_total_months(snowpark_args[1])
+                    ten_digit_limit = snowpark_fn.lit(MAX_10_DIGIT_LIMIT)
+
+                    precision_violation = (
+                        # Check if either operand already reaches 10 digits (parsing limit)
+                        (snowpark_fn.abs(total1) >= ten_digit_limit)
+                        | (snowpark_fn.abs(total2) >= ten_digit_limit)
+                        | (
+                            (total1 > 0)
+                            & (total2 < 0)
+                            & (total1 >= ten_digit_limit + total2)
+                        )
+                        | (
+                            (total1 < 0)
+                            & (total2 > 0)
+                            & (total1 <= -ten_digit_limit + total2)
+                        )
                     )
-            result_exp = _try_arithmetic_helper(snowpark_typed_args, snowpark_args, 1)
-            result_exp = _type_with_typer(result_exp)
+
+                    raise_error = _raise_error_helper(result_type, ArithmeticException)
+                    result_exp = snowpark_fn.when(
+                        precision_violation,
+                        raise_error(
+                            snowpark_fn.lit(
+                                "Year-Month Interval result exceeds Snowflake interval precision limit"
+                            )
+                        ),
+                    ).otherwise(snowpark_args[0] - snowpark_args[1])
+                case (t1, t2) if isinstance(t1, DayTimeIntervalType) and isinstance(
+                    t2, DayTimeIntervalType
+                ):
+                    result_type = DayTimeIntervalType(
+                        min(t1.start_field, t2.start_field),
+                        max(t1.end_field, t2.end_field),
+                    )
+                    # Check for Snowflake's day limit (106751991 days is the cutoff)
+                    days1 = snowpark_fn.date_part("day", snowpark_args[0])
+                    days2 = snowpark_fn.date_part("day", snowpark_args[1])
+                    max_days = snowpark_fn.lit(
+                        MAX_DAY_TIME_DAYS
+                    )  # Snowflake's actual limit
+                    min_days = snowpark_fn.lit(-MAX_DAY_TIME_DAYS)
+
+                    # Check if either operand exceeds the day limit - throw error like Spark does
+                    operand_limit_violation = (snowpark_fn.abs(days1) > max_days) | (
+                        snowpark_fn.abs(days2) > max_days
+                    )
+
+                    # Check if result would exceed day limit (but operands are valid) - return NULL
+                    result_overflow = (
+                        (days1 > 0) & (days2 < 0) & (days1 > max_days + days2)
+                    ) | ((days1 < 0) & (days2 > 0) & (days1 < min_days + days2))
+
+                    raise_error = _raise_error_helper(result_type, ArithmeticException)
+                    result_exp = (
+                        snowpark_fn.when(
+                            operand_limit_violation,
+                            raise_error(
+                                snowpark_fn.lit(
+                                    "Day-Time Interval operand exceeds day limit"
+                                )
+                            ),
+                        )
+                        .when(result_overflow, snowpark_fn.lit(None))
+                        .otherwise(snowpark_args[0] - snowpark_args[1])
+                    )
+                case _:
+                    result_exp = _try_arithmetic_helper(
+                        snowpark_typed_args, snowpark_args, 1
+                    )
+                    result_exp = _type_with_typer(result_exp)
         case "try_to_number":
             try_to_number = snowpark_fn.function("try_to_number")
             precision, scale = resolve_to_number_precision_and_scale(exp)
@@ -7924,7 +8991,13 @@ def map_unresolved_function(
                         ),
                     )
                 case _:
-                    raise ValueError(f"Invalid number of arguments to {function_name}")
+                    exception = ValueError(
+                        f"Invalid number of arguments to {function_name}"
+                    )
+                    attach_custom_error_code(
+                        exception, ErrorCodes.INVALID_FUNCTION_ARGUMENT
+                    )
+                    raise exception
             result_type = get_timestamp_type()
             result_exp = snowpark_fn.cast(result_exp, result_type)
         case "typeof":
@@ -8036,9 +9109,13 @@ def map_unresolved_function(
                             snowpark_fn.lit("YYYY-MM-DD HH24:MI:SS"),
                         )
                 case _:
-                    raise SnowparkConnectNotImplementedError(
+                    exception = SnowparkConnectNotImplementedError(
                         "unix_timestamp expected 0, 1 or 2 arguments."
                     )
+                    attach_custom_error_code(
+                        exception, ErrorCodes.INVALID_FUNCTION_ARGUMENT
+                    )
+                    raise exception
             result_type = LongType()
         case "unwrap_udt":
             snowpark_col_name = snowpark_args[0].get_name()
@@ -8055,9 +9132,11 @@ def map_unresolved_function(
             )
 
             if "__udt_info__" not in metadata:
-                raise AnalysisException(
+                exception = AnalysisException(
                     f"[DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE] Cannot resolve '{spark_function_name})' due to data type mismatch: Parameter 1 requires the 'USERDEFINEDTYPE' type"
                 )
+                attach_custom_error_code(exception, ErrorCodes.TYPE_MISMATCH)
+                raise exception
 
             result_type = map_json_schema_to_snowpark(
                 metadata["__udt_info__"]["sqlType"]
@@ -8113,9 +9192,11 @@ def map_unresolved_function(
                         snowpark_args[0], DoubleType()
                     )
                 else:
-                    raise AnalysisException(
+                    exception = AnalysisException(
                         f"""AnalysisException: [DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE] Cannot resolve "{function_name}({snowpark_arg_names[0]})" due to data type mismatch: Parameter 1 requires the "DOUBLE" type, however "{snowpark_arg_names[0]}" has the type "{snowpark_typed_args[0].typ}".;"""
                     )
+                    attach_custom_error_code(exception, ErrorCodes.TYPE_MISMATCH)
+                    raise exception
             result_type = DoubleType()
             result_exp = _resolve_aggregate_exp(
                 snowpark_fn.var_pop(var_pop_argument), result_type
@@ -8128,9 +9209,11 @@ def map_unresolved_function(
                         snowpark_args[0], DoubleType()
                     )
                 else:
-                    raise AnalysisException(
+                    exception = AnalysisException(
                         f"""AnalysisException: [DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE] Cannot resolve "{function_name}({snowpark_arg_names[0]})" due to data type mismatch: Parameter 1 requires the "DOUBLE" type, however "{snowpark_arg_names[0]}" has the type "{snowpark_typed_args[0].typ}".;"""
                     )
+                    attach_custom_error_code(exception, ErrorCodes.TYPE_MISMATCH)
+                    raise exception
             result_type = DoubleType()
             result_exp = _resolve_aggregate_exp(
                 snowpark_fn.var_samp(var_samp_argument), result_type
@@ -8163,10 +9246,12 @@ def map_unresolved_function(
             if len(snowpark_typed_args) > 0:
                 condition_type = snowpark_typed_args[0].typ
                 if not isinstance(condition_type, BooleanType):
-                    raise AnalysisException(
+                    exception = AnalysisException(
                         f"[DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE] Cannot resolve CASE WHEN condition due to data type mismatch: "
                         f"Parameter 1 requires the 'BOOLEAN' type, however got '{condition_type}'"
                     )
+                    attach_custom_error_code(exception, ErrorCodes.TYPE_MISMATCH)
+                    raise exception
 
             name_components = ["CASE"]
             name_components.append("WHEN")
@@ -8189,10 +9274,12 @@ def map_unresolved_function(
                     # Validate each WHEN condition
                     condition_type = snowpark_typed_args[i].typ
                     if not isinstance(condition_type, BooleanType):
-                        raise AnalysisException(
+                        exception = AnalysisException(
                             f"[DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE] Cannot resolve CASE WHEN condition due to data type mismatch: "
                             f"Parameter {i + 1} requires the 'BOOLEAN' type, however got '{condition_type}'"
                         )
+                        attach_custom_error_code(exception, ErrorCodes.TYPE_MISMATCH)
+                        raise exception
                     result_exp = result_exp.when(snowpark_args[i], snowpark_args[i + 1])
                     result_type_indexes.append(i + 1)
             name_components.append("END")
@@ -8429,9 +9516,11 @@ def map_unresolved_function(
             # TODO: Add more here as we come across them.
             # Unfortunately the scope of function names are not documented in
             # the proto file.
-            raise SnowparkConnectNotImplementedError(
+            exception = SnowparkConnectNotImplementedError(
                 f"Unsupported function name {other}"
             )
+            attach_custom_error_code(exception, ErrorCodes.UNSUPPORTED_OPERATION)
+            raise exception
 
     def _to_typed_column(
         res: Column | TypedColumn,
@@ -8446,9 +9535,11 @@ def map_unresolved_function(
             # 1. Static type: Assign directly to `result_type` when type is known at resolve time
             # 2. Dynamic type based on function arguments types: Use `snowpark_typed_args` to determine type
             # 3. Use _type_with_typer() as last resort - it calls GS to determine the type
-            raise SnowparkConnectNotImplementedError(
+            exception = SnowparkConnectNotImplementedError(
                 f"Result type of function {function_name} not implemented"
             )
+            attach_custom_error_code(exception, ErrorCodes.UNSUPPORTED_OPERATION)
+            raise exception
         elif type(res_type) is list:
             tc = TypedColumn(res, lambda: res_type)
         else:
@@ -8460,7 +9551,7 @@ def map_unresolved_function(
         spark_col_names if len(spark_col_names) > 0 else [spark_function_name]
     )
     typed_col = _to_typed_column(result_exp, result_type, function_name)
-    typed_col.set_qualifiers(qualifiers)
+    typed_col.set_qualifiers({ColumnQualifier(tuple(qualifier_parts))})
     return spark_col_names, typed_col
 
 
@@ -8534,15 +9625,19 @@ def _extract_window_args(fn: expressions_proto.Expression) -> (str, str):
     args = fn.unresolved_function.arguments
     match args:
         case [_, _, _]:
-            raise SnowparkConnectNotImplementedError(
+            exception = SnowparkConnectNotImplementedError(
                 "the slide_duration parameter is not supported"
             )
+            attach_custom_error_code(exception, ErrorCodes.UNSUPPORTED_OPERATION)
+            raise exception
         case [_, window_duration, slide_duration, _] if unwrap_literal(
             window_duration
         ) != unwrap_literal(slide_duration):
-            raise SnowparkConnectNotImplementedError(
+            exception = SnowparkConnectNotImplementedError(
                 "the slide_duration parameter is not supported"
             )
+            attach_custom_error_code(exception, ErrorCodes.UNSUPPORTED_OPERATION)
+            raise exception
         case [_, window_duration, _, start_time]:
             return unwrap_literal(window_duration), unwrap_literal(start_time)
         case [_, window_duration]:
@@ -8610,7 +9705,9 @@ def _find_common_type(
                 typ = _common(type1.element_type, type2.element_type)
                 return ArrayType(typ)
             case (ArrayType(), _) | (_, ArrayType()) if func_name == "concat":
-                raise AnalysisException(exception_base_message)
+                exception = AnalysisException(exception_base_message)
+                attach_custom_error_code(exception, ErrorCodes.TYPE_MISMATCH)
+                raise exception
             case (NullType(), t) | (t, NullType()):
                 return t
             case (BinaryType(), BinaryType()):
@@ -8639,7 +9736,9 @@ def _find_common_type(
                 if [field.name for field in fields1] != [
                     field.name for field in fields2
                 ]:
-                    raise AnalysisException(exception_base_message)
+                    exception = AnalysisException(exception_base_message)
+                    attach_custom_error_code(exception, ErrorCodes.TYPE_MISMATCH)
+                    raise exception
                 fields = []
                 for idx, field in enumerate(fields1):
                     typ = _common(field.datatype, fields2[idx].datatype)
@@ -8649,8 +9748,24 @@ def _find_common_type(
                 key_type = _common(type1.key_type, type2.key_type)
                 value_type = _common(type1.value_type, type2.value_type)
                 return MapType(key_type, value_type)
+            case (_, _) if isinstance(type1, YearMonthIntervalType) and isinstance(
+                type2, YearMonthIntervalType
+            ):
+                return YearMonthIntervalType(
+                    min(type1.start_field, type2.start_field),
+                    max(type1.end_field, type2.end_field),
+                )
+            case (_, _) if isinstance(type1, DayTimeIntervalType) and isinstance(
+                type2, DayTimeIntervalType
+            ):
+                return DayTimeIntervalType(
+                    min(type1.start_field, type2.start_field),
+                    max(type1.end_field, type2.end_field),
+                )
             case _:
-                raise AnalysisException(exception_base_message)
+                exception = AnalysisException(exception_base_message)
+                attach_custom_error_code(exception, ErrorCodes.TYPE_MISMATCH)
+                raise exception
 
     types = list(filter(lambda tp: tp is not None, types))
     if not types:
@@ -8663,7 +9778,9 @@ def _find_common_type(
             func_name_message = f" to `{func_name}`" if func_name else ""
             types_message = " or ".join([f'"{type}"' for type in types])
             exception_message = f"{exception_base_message} Cannot resolve expression due to data type mismatch: Input{func_name_message} should all be the same type, but it's ({types_message})."
-            raise AnalysisException(exception_message)
+            exception = AnalysisException(exception_message)
+            attach_custom_error_code(exception, ErrorCodes.TYPE_MISMATCH)
+            raise exception
         else:
             raise
 
@@ -8821,7 +9938,9 @@ def _resolve_function_with_lambda(
             case ArrayType():
                 return VariantType()
             case t:
-                raise ValueError(f"Expected array, got {t}")
+                exception = ValueError(f"Expected array, got {t}")
+                attach_custom_error_code(exception, ErrorCodes.TYPE_MISMATCH)
+                raise exception
 
     def _get_map_types(tc: TypedColumn):
         match tc.typ:
@@ -8830,9 +9949,11 @@ def _resolve_function_with_lambda(
             case MapType():
                 return VariantType(), VariantType()
             case t:
-                raise AnalysisException(
+                exception = AnalysisException(
                     f'[DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE] Parameter 1 requires the "MAP" type, however "id" has the type "{t}".'
                 )
+                attach_custom_error_code(exception, ErrorCodes.TYPE_MISMATCH)
+                raise exception
 
     def _map_to_array(m: dict) -> Optional[list]:
         # confirm that m is a dict and not a sqlNullWrapper
@@ -8898,9 +10019,13 @@ def _resolve_function_with_lambda(
                     result_type = arg4_tc.typ  # it's type of 'finish' lambda body
                     result_exp = snowpark_fn.get(result_exp, snowpark_fn.lit(0))
                 case _:
-                    raise SnowparkConnectNotImplementedError(
+                    exception = SnowparkConnectNotImplementedError(
                         f"{function_name} function requires 3 or 4 arguments"
                     )
+                    attach_custom_error_code(
+                        exception, ErrorCodes.INVALID_FUNCTION_ARGUMENT
+                    )
+                    raise exception
 
             snowpark_arg_names = [
                 arg1_name,
@@ -9124,9 +10249,13 @@ def _resolve_function_with_lambda(
                         f"lambdafunction({lambda_body_name}, namedlambdavariable(), namedlambdavariable())",
                     ]
                 case _:
-                    raise SnowparkConnectNotImplementedError(
+                    exception = SnowparkConnectNotImplementedError(
                         f"{function_name} function requires lambda function with 1 or 2 arguments"
                     )
+                    attach_custom_error_code(
+                        exception, ErrorCodes.INVALID_FUNCTION_ARGUMENT
+                    )
+                    raise exception
         case "transform_keys":
             _map_to_array_udf = cached_udf(
                 _map_to_array,
@@ -9280,9 +10409,11 @@ def _resolve_function_with_lambda(
             result_exp = TypedColumn(result_exp, lambda: [ArrayType(fn_body.typ)])
         case other:
             # TODO: Add more here as we come across them.
-            raise SnowparkConnectNotImplementedError(
+            exception = SnowparkConnectNotImplementedError(
                 f"Unsupported function name {other}"
             )
+            attach_custom_error_code(exception, ErrorCodes.UNSUPPORTED_OPERATION)
+            raise exception
 
     spark_function_name = f"{function_name}({', '.join(snowpark_arg_names)})"
     if not isinstance(result_exp, TypedColumn):
@@ -9847,9 +10978,11 @@ def _try_arithmetic_helper(
                 ) or (
                     isinstance(arg2, DateType) and not isinstance(arg1, _IntegralType)
                 ):
-                    raise AnalysisException(
+                    exception = AnalysisException(
                         '[DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE] Cannot resolve "date_add(dt, add)" due to data type mismatch: Parameter 2 requires the ("INT" or "SMALLINT" or "TINYINT") type'
                     )
+                    attach_custom_error_code(exception, ErrorCodes.TYPE_MISMATCH)
+                    raise exception
                 args = (
                     snowpark_args[::-1]
                     if isinstance(arg1, _IntegralType)
@@ -9872,9 +11005,11 @@ def _try_arithmetic_helper(
                 elif isinstance(arg1, DateType) and isinstance(arg2, DateType):
                     return snowpark_fn.daydiff(snowpark_args[0], snowpark_args[1])
                 else:
-                    raise AnalysisException(
+                    exception = AnalysisException(
                         '[DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE] Cannot resolve "date_sub(dt, sub)" due to data type mismatch: Parameter 1 requires the "DATE" type and parameter 2 requires the ("INT" or "SMALLINT" or "TINYINT") type'
                     )
+                    attach_custom_error_code(exception, ErrorCodes.TYPE_MISMATCH)
+                    raise exception
         case (DecimalType(), _IntegralType()) | (_IntegralType(), DecimalType()) | (
             DecimalType(),
             DecimalType(),
@@ -9926,9 +11061,11 @@ def _try_arithmetic_helper(
                 return updated_args[0] - updated_args[1]
 
         case (BooleanType(), _) | (_, BooleanType()):
-            raise AnalysisException(
+            exception = AnalysisException(
                 f"Incompatible types: {typed_args[0].typ}, {typed_args[1].typ}"
             )
+            attach_custom_error_code(exception, ErrorCodes.TYPE_MISMATCH)
+            raise exception
         case _:
             # Return NULL for incompatible types
             return snowpark_fn.lit(None)
@@ -9968,21 +11105,23 @@ def _get_add_sub_result_type(
                     )
                 case _:
                     if global_config.spark_sql_ansi_enabled:
-                        raise AnalysisException(
+                        exception = 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".',
                         )
+                        attach_custom_error_code(exception, ErrorCodes.TYPE_MISMATCH)
+                        raise exception
                     else:
                         result_type = DoubleType()
         case BooleanType():
-            raise AnalysisException(
+            exception = 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".',
             )
+            attach_custom_error_code(exception, ErrorCodes.TYPE_MISMATCH)
+            raise exception
     return result_type, overflow_possible
 
 
-def _get_interval_type_name(
-    interval_type: Union[YearMonthIntervalType, DayTimeIntervalType]
-) -> str:
+def _get_interval_type_name(interval_type: _AnsiIntervalType) -> str:
     """Get the formatted interval type name for error messages."""
     if isinstance(interval_type, YearMonthIntervalType):
         if interval_type.start_field == 0 and interval_type.end_field == 0:
@@ -10009,21 +11148,15 @@ def _check_interval_string_comparison(
 ) -> None:
     """Check for invalid interval-string comparisons and raise AnalysisException if found."""
     if (
-        isinstance(
-            snowpark_typed_args[0].typ, (YearMonthIntervalType, DayTimeIntervalType)
-        )
+        isinstance(snowpark_typed_args[0].typ, _AnsiIntervalType)
         and isinstance(snowpark_typed_args[1].typ, StringType)
         or isinstance(snowpark_typed_args[0].typ, StringType)
-        and isinstance(
-            snowpark_typed_args[1].typ, (YearMonthIntervalType, DayTimeIntervalType)
-        )
+        and isinstance(snowpark_typed_args[1].typ, _AnsiIntervalType)
     ):
         # Format interval type name for error message
         interval_type = (
             snowpark_typed_args[0].typ
-            if isinstance(
-                snowpark_typed_args[0].typ, (YearMonthIntervalType, DayTimeIntervalType)
-            )
+            if isinstance(snowpark_typed_args[0].typ, _AnsiIntervalType)
             else snowpark_typed_args[1].typ
         )
         interval_name = _get_interval_type_name(interval_type)
@@ -10039,9 +11172,11 @@ def _check_interval_string_comparison(
             else interval_name
         )
 
-        raise AnalysisException(
+        exception = AnalysisException(
             f'[DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES] Cannot resolve "({snowpark_arg_names[0]} {operator} {snowpark_arg_names[1]})" due to data type mismatch: the left and right operands of the binary operator have incompatible types ("{left_type}" and "{right_type}").;'
         )
+        attach_custom_error_code(exception, ErrorCodes.TYPE_MISMATCH)
+        raise exception
 
 
 def _get_spark_function_name(
@@ -10088,12 +11223,18 @@ def _get_spark_function_name(
         case (DateType(), DayTimeIntervalType()) | (
             DateType(),
             YearMonthIntervalType(),
+        ) | (TimestampType(), DayTimeIntervalType()) | (
+            TimestampType(),
+            YearMonthIntervalType(),
         ):
             date_param_name1 = _get_literal_param_name(exp, 0, snowpark_arg_names[0])
             return f"{date_param_name1} {operation_op} {snowpark_arg_names[1]}"
         case (DayTimeIntervalType(), DateType()) | (
             YearMonthIntervalType(),
             DateType(),
+        ) | (DayTimeIntervalType(), TimestampType()) | (
+            YearMonthIntervalType(),
+            TimestampType(),
         ):
             date_param_name2 = _get_literal_param_name(exp, 1, snowpark_arg_names[1])
             if function_name == "+":
@@ -10177,12 +11318,18 @@ def _timestamp_format_sanity_check(ts_value: str, ts_format: str) -> None:
     This is a basic validation to ensure the format matches the string.
     """
     if "yyyyyyy" in ts_format:
-        raise DateTimeException(
+        exception = DateTimeException(
             f"Fail to recognize '{ts_format}' pattern in the DateTimeFormatter."
         )
+        attach_custom_error_code(exception, ErrorCodes.INVALID_INPUT)
+        raise exception
     if ts_format == "yy":
         if len(ts_value) != 2:
-            raise DateTimeException(f"Fail to parse '{ts_value}' in DateTimeFormatter.")
+            exception = DateTimeException(
+                f"Fail to parse '{ts_value}' in DateTimeFormatter."
+            )
+            attach_custom_error_code(exception, ErrorCodes.INVALID_INPUT)
+            raise exception
 
     # For parsing, the acceptable fraction length can be [1, the number of contiguous 'S']
     s_contiguous = 0
@@ -10199,7 +11346,11 @@ def _timestamp_format_sanity_check(ts_value: str, ts_format: str) -> None:
             char_count += 1
 
     if s_contiguous + sum(x.isalnum() for x in ts_value) < char_count:
-        raise DateTimeException(f"Fail to parse '{ts_value}' in DateTimeFormatter.")
+        exception = DateTimeException(
+            f"Fail to parse '{ts_value}' in DateTimeFormatter."
+        )
+        attach_custom_error_code(exception, ErrorCodes.INVALID_INPUT)
+        raise exception
 
 
 def _bounded_long_floor_expr(expr):
@@ -10326,17 +11477,21 @@ def _validate_number_format_string(format_str: str) -> None:
     """
 
     def _unexpected_char(char):
-        raise AnalysisException(
+        exception = AnalysisException(
             f"[INVALID_FORMAT.UNEXPECTED_TOKEN] The format is invalid: '{original_format}'. "
             f"Found the unexpected character '{char}' in the format string; "
             "the structure of the format string must match: "
             "`[MI|S]` `[$]` `[0|9|G|,]*` `[.|D]` `[0|9]*` `[$]` `[PR|MI|S]`."
         )
+        attach_custom_error_code(exception, ErrorCodes.INVALID_INPUT)
+        raise exception
 
     if not format_str:
-        raise AnalysisException(
+        exception = AnalysisException(
             "[INVALID_FORMAT.EMPTY] The format is invalid: ''. The number format string cannot be empty."
         )
+        attach_custom_error_code(exception, ErrorCodes.INVALID_INPUT)
+        raise exception
 
     # Create a working copy of the format string
     remaining = format_str
@@ -10412,9 +11567,11 @@ def _validate_number_format_string(format_str: str) -> None:
                 _unexpected_char(char)
 
         # If no invalid character found but no digits, it's still invalid
-        raise AnalysisException(
+        exception = AnalysisException(
             f"[INVALID_FORMAT.WRONG_NUM_DIGIT] The format is invalid: '{format_str}'. The format string requires at least one number digit."
         )
+        attach_custom_error_code(exception, ErrorCodes.INVALID_INPUT)
+        raise exception
 
 
 def _trim_helper(value: Column, trim_value: Column, trim_type: Column) -> Column:
@@ -10465,3 +11622,30 @@ def _map_from_spark_tz(value: Column) -> Column:
         .when(value == "VST", snowpark_fn.lit("Asia/Ho_Chi_Minh"))
         .otherwise(value)  # Return original timezone if no mapping found
     )
+
+
+def _calculate_total_months(interval_arg):
+    """Calculate total months from a year-month interval."""
+    years = snowpark_fn.date_part("year", interval_arg)
+    months = snowpark_fn.date_part("month", interval_arg)
+    return years * 12 + months
+
+
+def _calculate_total_days(interval_arg):
+    """Calculate total days from a day-time interval."""
+    days = snowpark_fn.date_part("day", interval_arg)
+    hours = snowpark_fn.date_part("hour", interval_arg)
+    minutes = snowpark_fn.date_part("minute", interval_arg)
+    seconds = snowpark_fn.date_part("second", interval_arg)
+    # Convert hours, minutes, seconds to fractional days
+    fractional_days = (hours * 3600 + minutes * 60 + seconds) / 86400
+    return days + fractional_days
+
+
+def _calculate_total_seconds(interval_arg):
+    """Calculate total seconds from a day-time interval."""
+    days = snowpark_fn.date_part("day", interval_arg)
+    hours = snowpark_fn.date_part("hour", interval_arg)
+    minutes = snowpark_fn.date_part("minute", interval_arg)
+    seconds = snowpark_fn.date_part("second", interval_arg)
+    return days * 86400 + hours * 3600 + minutes * 60 + seconds