snowpark-connect 0.31.0__py3-none-any.whl → 0.33.0__py3-none-any.whl

snowflake/snowpark_connect/expression/map_unresolved_function.py

@@ -20,11 +20,10 @@ 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
-import pyspark.sql.functions as pyspark_functions
 from google.protobuf.message import Message
 from pyspark.errors.exceptions.base import (
     AnalysisException,
@@ -66,6 +65,7 @@ from snowflake.snowpark.types import (
     TimestampType,
     VariantType,
     YearMonthIntervalType,
+    _AnsiIntervalType,
     _FractionalType,
     _IntegralType,
     _NumericType,
@@ -74,6 +74,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,
@@ -99,6 +100,7 @@ from snowflake.snowpark_connect.expression.map_unresolved_star import (
 )
 from snowflake.snowpark_connect.expression.typer import ExpressionTyper
 from snowflake.snowpark_connect.relation.catalogs.utils import CURRENT_CATALOG_NAME
+from snowflake.snowpark_connect.relation.utils import is_aggregate_function
 from snowflake.snowpark_connect.type_mapping import (
     map_json_schema_to_snowpark,
     map_pyspark_types_to_snowpark_types,
@@ -148,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")
 
@@ -272,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,
@@ -300,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():
@@ -355,11 +398,10 @@ 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:"):
-        # Used by the GROUP BY ALL implementation. Far from ideal, but it seems to work...
+    # Check if this is an aggregate function (used by GROUP BY ALL implementation)
+    if is_aggregate_function(function_name):
         add_sql_aggregate_function()
 
     def _type_with_typer(col: Column) -> TypedColumn:
@@ -513,9 +555,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]
@@ -616,12 +666,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]
@@ -662,7 +787,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]
@@ -685,6 +817,35 @@ def map_unresolved_function(
                         )
                         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:
                         exception = AnalysisException(
@@ -736,6 +897,99 @@ def map_unresolved_function(
                     )
                     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()
+                    raise_error = _raise_error_helper(StringType(), AnalysisException)
+                    if isinstance(snowpark_typed_args[0].typ, StringType):
+                        # Try to cast string to double, if it fails (returns null), raise exception
+                        cast_result = snowpark_fn.try_cast(snowpark_args[0], "double")
+                        result_exp = snowpark_fn.when(
+                            cast_result.is_null(),
+                            raise_error(
+                                snowpark_fn.lit(
+                                    f'The value \'{snowpark_args[0]}\' of the type {snowpark_typed_args[0].typ} 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.'
+                                )
+                            ),
+                        ).otherwise(cast_result + snowpark_args[1])
+                    else:
+                        cast_result = snowpark_fn.try_cast(snowpark_args[1], "double")
+                        result_exp = snowpark_fn.when(
+                            cast_result.is_null(),
+                            raise_error(
+                                snowpark_fn.lit(
+                                    f'The value \'{snowpark_args[0]}\' of the type {snowpark_typed_args[0].typ} 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.'
+                                )
+                            ),
+                        ).otherwise(snowpark_args[0] + cast_result)
+                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,
@@ -781,7 +1035,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 (
@@ -799,6 +1057,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()
@@ -870,6 +1145,16 @@ def map_unresolved_function(
                     )
                     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,
@@ -968,9 +1253,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(
@@ -2027,11 +2360,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(
@@ -2049,11 +2377,6 @@ def map_unresolved_function(
             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()])
@@ -2232,7 +2555,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])
@@ -2670,16 +2993,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)
-            ):
-                exception = NotImplementedError(
-                    f"{function_name} with interval types is not supported"
-                )
-                attach_custom_error_code(exception, ErrorCodes.UNSUPPORTED_OPERATION)
-                raise exception
-
             field_lit: str | None = unwrap_literal(exp.unresolved_function.arguments[0])
 
             if field_lit is None:
@@ -2724,16 +3037,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)
@@ -3565,8 +3913,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
@@ -3710,7 +4056,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
@@ -4504,6 +4851,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)
@@ -4557,6 +4915,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"
@@ -5211,7 +5578,11 @@ 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)
@@ -5236,6 +5607,8 @@ def map_unresolved_function(
             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":
@@ -5616,9 +5989,33 @@ def map_unresolved_function(
         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()]
@@ -5627,7 +6024,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)
@@ -5767,7 +6165,11 @@ 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:
@@ -5790,17 +6192,23 @@ def map_unresolved_function(
             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 "pow":
-            result_exp = snowpark_fn.pow(snowpark_args[0], snowpark_args[1])
-            result_type = DoubleType()
-        case "power":
-            spark_function_name = (
-                f"POWER({snowpark_arg_names[0]}, {snowpark_arg_names[1]})"
-            )
-            result_exp = snowpark_fn.pow(snowpark_args[0], snowpark_args[1])
+        case "pow" | "power":
+            spark_function_name = f"{function_name if function_name == 'pow' else function_name.upper()}({snowpark_arg_names[0]}, {snowpark_arg_names[1]})"
+            if not spark_sql_ansi_enabled:
+                snowpark_args = _validate_numeric_args(
+                    function_name, snowpark_typed_args, snowpark_args
+                )
+            result_exp = snowpark_fn.when(
+                snowpark_fn.equal_nan(snowpark_fn.cast(snowpark_args[0], FloatType()))
+                | snowpark_fn.equal_nan(
+                    snowpark_fn.cast(snowpark_args[1], FloatType())
+                ),
+                NAN,
+            ).otherwise(snowpark_fn.pow(snowpark_args[0], snowpark_args[1]))
             result_type = DoubleType()
         case "product":
             col = snowpark_args[0]
@@ -6660,11 +7068,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]})"
@@ -6909,7 +7349,16 @@ def map_unresolved_function(
                     )
                     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]})"
@@ -7939,18 +8388,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)):
-                    exception = 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
                     )
-                    attach_custom_error_code(
-                        exception, ErrorCodes.UNSUPPORTED_OPERATION
+                    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
-            result_exp = _try_arithmetic_helper(snowpark_typed_args, snowpark_args, 0)
-            result_exp = _type_with_typer(result_exp)
+                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",
@@ -8002,17 +8556,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)):
-                    exception = NotImplementedError(
-                        "try_divide with interval types is not supported"
-                    )
-                    attach_custom_error_code(
-                        exception, ErrorCodes.UNSUPPORTED_OPERATION
-                    )
-                    raise exception
+            # 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()
@@ -8124,17 +8710,76 @@ def map_unresolved_function(
                     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)):
-                    exception = NotImplementedError(
-                        "try_multiply with interval types is not supported"
-                    )
-                    attach_custom_error_code(
-                        exception, ErrorCodes.UNSUPPORTED_OPERATION
-                    )
-                    raise exception
             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:
@@ -8234,18 +8879,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)):
-                    exception = NotImplementedError(
-                        "try_subtract with interval types is not supported"
-                    )
-                    attach_custom_error_code(
-                        exception, ErrorCodes.UNSUPPORTED_OPERATION
+            # 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
-            result_exp = _try_arithmetic_helper(snowpark_typed_args, snowpark_args, 1)
-            result_exp = _type_with_typer(result_exp)
+                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)
+                        )
+                    )
+
+                    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)
@@ -8735,15 +9474,21 @@ def map_unresolved_function(
                 result_exp = snowpark_fn.year(snowpark_fn.to_date(snowpark_args[0]))
             result_type = LongType()
         case binary_method if binary_method in ("to_binary", "try_to_binary"):
-            binary_format = "hex"
+            binary_format = snowpark_fn.lit("hex")
+            arg_str = snowpark_fn.cast(snowpark_args[0], StringType())
             if len(snowpark_args) > 1:
                 binary_format = snowpark_args[1]
             result_exp = snowpark_fn.when(
                 snowpark_args[0].isNull(), snowpark_fn.lit(None)
             ).otherwise(
                 snowpark_fn.function(binary_method)(
-                    snowpark_fn.cast(snowpark_args[0], StringType()), binary_format
-                ),
+                    snowpark_fn.when(
+                        (snowpark_fn.length(arg_str) % 2 == 1)
+                        & (snowpark_fn.lower(binary_format) == snowpark_fn.lit("hex")),
+                        snowpark_fn.concat(snowpark_fn.lit("0"), arg_str),
+                    ).otherwise(arg_str),
+                    binary_format,
+                )
             )
             result_type = BinaryType()
         case udtf_name if udtf_name.lower() in session._udtfs:
@@ -8828,7 +9573,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
 
 
@@ -9025,6 +9770,20 @@ 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 _:
                 exception = AnalysisException(exception_base_message)
                 attach_custom_error_code(exception, ErrorCodes.TYPE_MISMATCH)
@@ -9968,12 +10727,18 @@ def _try_sum_helper(
                     return snowpark_fn.lit(None), new_type
                 else:
                     non_null_rows = snowpark_fn.count(col_name)
-                    return aggregate_sum / non_null_rows, new_type
+                    # Use _divnull to handle case when non_null_rows is 0
+                    return _divnull(aggregate_sum, non_null_rows), new_type
             else:
                 new_type = DecimalType(
                     precision=min(38, arg_type.precision + 10), scale=arg_type.scale
                 )
-                return aggregate_sum, new_type
+                # Return NULL when there are no non-null values (i.e., all values are NULL); this is handled using case/when to check for non-null values for both SUM and the sum component of AVG calculations.
+                non_null_rows = snowpark_fn.count(col_name)
+                result = snowpark_fn.when(
+                    non_null_rows == 0, snowpark_fn.lit(None)
+                ).otherwise(aggregate_sum)
+                return result, new_type
 
         case _:
             # If the input column is floating point (double and float are synonymous in Snowflake per
@@ -9991,9 +10756,16 @@ def _try_sum_helper(
                     return snowpark_fn.lit(None), DoubleType()
                 else:
                     non_null_rows = snowpark_fn.count(col_name)
-                    return aggregate_sum / non_null_rows, DoubleType()
+                    # Use _divnull to handle case when non_null_rows is 0
+                    return _divnull(aggregate_sum, non_null_rows), DoubleType()
             else:
-                return aggregate_sum, DoubleType()
+                # When all values are NULL, SUM should return NULL (not 0)
+                # Use case/when to return NULL when there are no non-null values (i.e., all values are NULL)
+                non_null_rows = snowpark_fn.count(col_name)
+                result = snowpark_fn.when(
+                    non_null_rows == 0, snowpark_fn.lit(None)
+                ).otherwise(aggregate_sum)
+                return result, DoubleType()
 
 
 def _get_type_precision(typ: DataType) -> tuple[int, int]:
@@ -10384,9 +11156,7 @@ def _get_add_sub_result_type(
     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:
@@ -10413,21 +11183,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)
@@ -10494,12 +11258,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 == "+":
@@ -10887,3 +11657,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