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

snowflake/snowpark_connect/expression/map_sql_expression.py

@@ -15,6 +15,7 @@ from pyspark.sql.connect import functions as pyspark_functions
 
 import snowflake.snowpark_connect.proto.snowflake_expression_ext_pb2 as snowflake_proto
 from snowflake.snowpark._internal.analyzer.analyzer_utils import unquote_if_quoted
+from snowflake.snowpark.types import DayTimeIntervalType, YearMonthIntervalType
 from snowflake.snowpark_connect.column_name_handler import ColumnNameMap
 from snowflake.snowpark_connect.config import global_config
 from snowflake.snowpark_connect.typed_column import TypedColumn
@@ -33,6 +34,24 @@ from .typer import ExpressionTyper
 
 DECIMAL_RE = re.compile(r"decimal\((\d+), *(\d+)\)")
 
+_INTERVAL_YEARMONTH_PATTERN_RE = re.compile(r"interval (year|month)( to (year|month))?")
+_INTERVAL_DAYTIME_PATTERN_RE = re.compile(
+    r"interval (day|hour|minute|second)( to (day|hour|minute|second))?"
+)
+
+# Interval field mappings using proper constants
+_YEAR_MONTH_FIELD_MAP = {
+    "year": YearMonthIntervalType.YEAR,
+    "month": YearMonthIntervalType.MONTH,
+}
+
+_DAY_TIME_FIELD_MAP = {
+    "day": DayTimeIntervalType.DAY,
+    "hour": DayTimeIntervalType.HOUR,
+    "minute": DayTimeIntervalType.MINUTE,
+    "second": DayTimeIntervalType.SECOND,
+}
+
 _window_specs = ContextVar[dict[str, any]]("_window_specs", default={})
 
 
@@ -388,8 +407,94 @@ def map_logical_plan_expression(exp: jpype.JObject) -> expressions_proto.Express
                 type_value = types_proto.DataType()
             elif type_name == "binary":
                 type_value = bytes(type_value)
-            elif type_name.startswith("interval "):
-                type_name = "day_time_interval"  # TODO
+            elif year_month_match := _INTERVAL_YEARMONTH_PATTERN_RE.match(type_name):
+                # Extract start and end fields for year-month intervals
+                start_field_name = year_month_match.group(1)  # 'year' or 'month'
+                end_field_name = (
+                    year_month_match.group(3)
+                    if year_month_match.group(3)
+                    else start_field_name
+                )
+
+                # Validate field names exist in mapping
+                start_field = _YEAR_MONTH_FIELD_MAP.get(start_field_name)
+                end_field = _YEAR_MONTH_FIELD_MAP.get(end_field_name)
+
+                if start_field is None:
+                    raise AnalysisException(
+                        f"Invalid year-month interval start field: '{start_field_name}'. Expected 'year' or 'month'."
+                    )
+                if end_field is None:
+                    raise AnalysisException(
+                        f"Invalid year-month interval end field: '{end_field_name}'. Expected 'year' or 'month'."
+                    )
+
+                # Validate field ordering (start_field should be <= end_field)
+                if start_field > end_field:
+                    raise AnalysisException(
+                        f"Invalid year-month interval: start field '{start_field_name}' must come before or equal to end field '{end_field_name}'."
+                    )
+
+                # Use extension for year-month intervals to preserve start/end field info
+                literal = expressions_proto.Expression.Literal(
+                    year_month_interval=type_value
+                )
+                any_proto = Any()
+                any_proto.Pack(
+                    snowflake_proto.ExpExtension(
+                        interval_literal=snowflake_proto.IntervalLiteralExpression(
+                            literal=literal,
+                            start_field=start_field,
+                            end_field=end_field,
+                        )
+                    )
+                )
+                return expressions_proto.Expression(extension=any_proto)
+            elif day_time_match := _INTERVAL_DAYTIME_PATTERN_RE.match(type_name):
+                # Extract start and end fields for day-time intervals
+                start_field_name = day_time_match.group(
+                    1
+                )  # 'day', 'hour', 'minute', 'second'
+                end_field_name = (
+                    day_time_match.group(3)
+                    if day_time_match.group(3)
+                    else start_field_name
+                )
+
+                # Validate field names exist in mapping
+                start_field = _DAY_TIME_FIELD_MAP.get(start_field_name)
+                end_field = _DAY_TIME_FIELD_MAP.get(end_field_name)
+
+                if start_field is None:
+                    raise AnalysisException(
+                        f"Invalid day-time interval start field: '{start_field_name}'. Expected 'day', 'hour', 'minute', or 'second'."
+                    )
+                if end_field is None:
+                    raise AnalysisException(
+                        f"Invalid day-time interval end field: '{end_field_name}'. Expected 'day', 'hour', 'minute', or 'second'."
+                    )
+
+                # Validate field ordering (start_field should be <= end_field)
+                if start_field > end_field:
+                    raise AnalysisException(
+                        f"Invalid day-time interval: start field '{start_field_name}' must come before or equal to end field '{end_field_name}'."
+                    )
+
+                # Use extension for day-time intervals to preserve start/end field info
+                literal = expressions_proto.Expression.Literal(
+                    day_time_interval=type_value
+                )
+                any_proto = Any()
+                any_proto.Pack(
+                    snowflake_proto.ExpExtension(
+                        interval_literal=snowflake_proto.IntervalLiteralExpression(
+                            literal=literal,
+                            start_field=start_field,
+                            end_field=end_field,
+                        )
+                    )
+                )
+                return expressions_proto.Expression(extension=any_proto)
             elif m := DECIMAL_RE.fullmatch(type_name):
                 type_name = "decimal"
                 type_value = expressions_proto.Expression.Literal.Decimal(

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
+from typing import List, Optional, Union
 from urllib.parse import quote, unquote
 
 import pyspark.sql.connect.proto.expressions_pb2 as expressions_proto
@@ -50,6 +50,7 @@ from snowflake.snowpark.types import (
     ByteType,
     DataType,
     DateType,
+    DayTimeIntervalType,
     DecimalType,
     DoubleType,
     FloatType,
@@ -64,6 +65,7 @@ from snowflake.snowpark.types import (
     TimestampTimeZone,
     TimestampType,
     VariantType,
+    YearMonthIntervalType,
     _FractionalType,
     _IntegralType,
     _NumericType,
@@ -639,8 +641,17 @@ def map_unresolved_function(
                     if isinstance(t, (IntegerType, ShortType, ByteType)):
                         result_type = DateType()
                         result_exp = snowpark_args[0] + snowpark_args[1]
+                    elif isinstance(t, (DayTimeIntervalType, YearMonthIntervalType)):
+                        result_type = TimestampType()
+                        result_exp = (
+                            snowpark_args[date_param_index]
+                            + snowpark_args[t_param_index]
+                        )
                     elif (
-                        "INTERVAL"
+                        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()
@@ -740,6 +751,12 @@ def map_unresolved_function(
                     # TODO SNOW-2034420: resolve return type (it should be INTERVAL DAY)
                     result_type = LongType()
                     result_exp = snowpark_args[0] - snowpark_args[1]
+                case (DateType(), DayTimeIntervalType()) | (
+                    DateType(),
+                    YearMonthIntervalType(),
+                ):
+                    result_type = TimestampType()
+                    result_exp = snowpark_args[0] - snowpark_args[1]
                 case (DateType(), StringType()):
                     if (
                         hasattr(snowpark_typed_args[1].col._expr1, "pretty_name")
@@ -944,6 +961,10 @@ def map_unresolved_function(
                 raise AnalysisException(
                     f'[DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES] Cannot resolve "{snowpark_arg_names[0]} < {snowpark_arg_names[1]}" due to data type mismatch: the left and right operands of the binary operator have incompatible types ("{snowpark_typed_args[0].typ}" and "{snowpark_typed_args[1].typ}").;'
                 )
+            # Check for interval-string comparisons
+            _check_interval_string_comparison(
+                "<", snowpark_typed_args, snowpark_arg_names
+            )
             left, right = _coerce_for_comparison(
                 snowpark_typed_args[0], snowpark_typed_args[1]
             )
@@ -958,6 +979,10 @@ def map_unresolved_function(
                 raise AnalysisException(
                     f'[DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES] Cannot resolve "{snowpark_arg_names[0]} <= {snowpark_arg_names[1]}" due to data type mismatch: the left and right operands of the binary operator have incompatible types ("{snowpark_typed_args[0].typ}" and "{snowpark_typed_args[1].typ}").;'
                 )
+            # Check for interval-string comparisons
+            _check_interval_string_comparison(
+                "<=", snowpark_typed_args, snowpark_arg_names
+            )
             left, right = _coerce_for_comparison(
                 snowpark_typed_args[0], snowpark_typed_args[1]
             )
@@ -976,6 +1001,10 @@ def map_unresolved_function(
             )
             result_exp = TypedColumn(left.eqNullSafe(right), lambda: [BooleanType()])
         case "==" | "=":
+            # Check for interval-string comparisons
+            _check_interval_string_comparison(
+                "=", snowpark_typed_args, snowpark_arg_names
+            )
             spark_function_name = f"({snowpark_arg_names[0]} = {snowpark_arg_names[1]})"
             left, right = _coerce_for_comparison(
                 snowpark_typed_args[0], snowpark_typed_args[1]
@@ -991,6 +1020,10 @@ def map_unresolved_function(
                 raise AnalysisException(
                     f'[DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES] Cannot resolve "{snowpark_arg_names[0]} > {snowpark_arg_names[1]}" due to data type mismatch: the left and right operands of the binary operator have incompatible types ("{snowpark_typed_args[0].typ}" and "{snowpark_typed_args[1].typ}").;'
                 )
+            # Check for interval-string comparisons
+            _check_interval_string_comparison(
+                ">", snowpark_typed_args, snowpark_arg_names
+            )
             left, right = _coerce_for_comparison(
                 snowpark_typed_args[0], snowpark_typed_args[1]
             )
@@ -1005,6 +1038,10 @@ def map_unresolved_function(
                 raise AnalysisException(
                     f'[DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES] Cannot resolve "{snowpark_arg_names[0]} >= {snowpark_arg_names[1]}" due to data type mismatch: the left and right operands of the binary operator have incompatible types ("{snowpark_typed_args[0].typ}" and "{snowpark_typed_args[1].typ}").;'
                 )
+            # Check for interval-string comparisons
+            _check_interval_string_comparison(
+                ">=", snowpark_typed_args, snowpark_arg_names
+            )
             left, right = _coerce_for_comparison(
                 snowpark_typed_args[0], snowpark_typed_args[1]
             )
@@ -1135,9 +1172,7 @@ def map_unresolved_function(
             # SNOW-1955784: Support accuracy parameter
             # Use percentile_disc to return actual values from dataset (matches PySpark behavior)
 
-            def _pyspark_approx_percentile(
-                column: Column, percentage: float, original_type: DataType
-            ) -> Column:
+            def _pyspark_approx_percentile(column: Column, percentage: float) -> Column:
                 """
                 PySpark-compatible percentile that returns actual values from dataset.
                 - PySpark's approx_percentile returns the "smallest value in the ordered col values
@@ -1154,7 +1189,7 @@ def map_unresolved_function(
                 result = snowpark_fn.function("percentile_disc")(
                     snowpark_fn.lit(percentage)
                 ).within_group(column)
-                return snowpark_fn.cast(result, original_type)
+                return result
 
             column_type = snowpark_typed_args[0].typ
 
@@ -1165,26 +1200,18 @@ def map_unresolved_function(
                 assert array_func.function_name == "array", array_func
 
                 percentile_results = [
-                    _pyspark_approx_percentile(
-                        snowpark_args[0], unwrap_literal(arg), column_type
-                    )
+                    _pyspark_approx_percentile(snowpark_args[0], unwrap_literal(arg))
                     for arg in array_func.arguments
                 ]
 
                 result_type = ArrayType(element_type=column_type, contains_null=False)
-                result_exp = snowpark_fn.cast(
-                    snowpark_fn.array_construct(*percentile_results),
-                    result_type,
-                )
+                result_exp = snowpark_fn.array_construct(*percentile_results)
+                result_exp = _resolve_aggregate_exp(result_exp, result_type)
             else:
                 # Handle single percentile
                 percentage = unwrap_literal(exp.unresolved_function.arguments[1])
-                result_exp = TypedColumn(
-                    _pyspark_approx_percentile(
-                        snowpark_args[0], percentage, column_type
-                    ),
-                    lambda: [column_type],
-                )
+                result_exp = _pyspark_approx_percentile(snowpark_args[0], percentage)
+                result_exp = _resolve_aggregate_exp(result_exp, column_type)
         case "array":
             if len(snowpark_args) == 0:
                 result_exp = snowpark_fn.cast(
@@ -1358,27 +1385,55 @@ def map_unresolved_function(
                 result_exp = snowpark_fn.cast(result_exp, array_type)
             result_exp = TypedColumn(result_exp, lambda: snowpark_typed_args[0].types)
         case "array_repeat":
+            elem, count = snowpark_args[0], snowpark_args[1]
+            elem_type = snowpark_typed_args[0].typ
+            result_type = ArrayType(elem_type)
 
-            @cached_udf(
-                input_types=[VariantType(), LongType()],
-                return_type=ArrayType(),
-            )
-            def _array_repeat(elem, n):
-                if n is None:
-                    return None
-                if n < 0:
-                    return []
-                return [elem] * n
+            fallback_to_udf = True
 
-            result_exp = snowpark_fn.cast(
-                _array_repeat(
-                    snowpark_fn.cast(snowpark_args[0], VariantType()), snowpark_args[1]
-                ),
-                ArrayType(snowpark_typed_args[0].typ),
-            )
-            result_exp = TypedColumn(
-                result_exp, lambda: [ArrayType(snowpark_typed_args[0].typ)]
-            )
+            if isinstance(count._expression, Literal):
+                count_value = count._expression.value
+                fallback_to_udf = False
+
+                if count_value is None:
+                    result_exp = snowpark_fn.lit(None).cast(result_type)
+                elif count_value <= 0:
+                    result_exp = snowpark_fn.array_construct().cast(result_type)
+                elif count_value <= 16:
+                    # count_value is small enough to initialize the array directly in memory
+                    elem_variant = snowpark_fn.cast(elem, VariantType())
+                    result_exp = snowpark_fn.array_construct(
+                        *([elem_variant] * count_value)
+                    ).cast(result_type)
+                else:
+                    fallback_to_udf = True
+
+            if fallback_to_udf:
+
+                @cached_udf(
+                    input_types=[VariantType(), LongType()],
+                    return_type=ArrayType(),
+                )
+                def _array_repeat(elem, n):
+                    if n is None:
+                        return None
+                    if n < 0:
+                        return []
+                    return [elem] * n
+
+                elem_variant = snowpark_fn.cast(elem, VariantType())
+
+                result_exp = (
+                    snowpark_fn.when(
+                        count.is_null(), snowpark_fn.lit(None).cast(result_type)
+                    )
+                    .when(count <= 0, snowpark_fn.array_construct().cast(result_type))
+                    .otherwise(
+                        snowpark_fn.cast(
+                            _array_repeat(elem_variant, count), result_type
+                        )
+                    )
+                )
         case "array_size":
             array_type = snowpark_typed_args[0].typ
             if not isinstance(array_type, ArrayType):
@@ -1578,7 +1633,7 @@ def map_unresolved_function(
             result_exp = TypedColumn(result_exp, lambda: [LongType()])
         case "bit_get" | "getbit":
             snowflake_compat = get_boolean_session_config_param(
-                "enable_snowflake_extension_behavior"
+                "snowpark.connect.enable_snowflake_extension_behavior"
             )
             col, pos = snowpark_args
             if snowflake_compat:
@@ -1885,14 +1940,11 @@ def map_unresolved_function(
             qualifiers = snowpark_args[0].get_qualifiers()
         case "collect_list" | "array_agg":
             # TODO: SNOW-1967177 - Support structured types in array_agg
-            result_exp = snowpark_fn.cast(
-                snowpark_fn.array_agg(
-                    snowpark_typed_args[0].column(to_semi_structure=True)
-                ),
-                ArrayType(snowpark_typed_args[0].typ),
+            result_exp = snowpark_fn.array_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)
             )
             spark_function_name = f"collect_list({snowpark_arg_names[0]})"
         case "collect_set":
@@ -2379,15 +2431,30 @@ def map_unresolved_function(
                 # If format is NULL, return NULL for all rows
                 result_exp = snowpark_fn.lit(None)
             else:
+                format_lit = snowpark_fn.lit(
+                    map_spark_timestamp_format_expression(
+                        exp.unresolved_function.arguments[1],
+                        snowpark_typed_args[0].typ,
+                    )
+                )
                 result_exp = snowpark_fn.date_format(
                     snowpark_args[0],
-                    snowpark_fn.lit(
-                        map_spark_timestamp_format_expression(
-                            exp.unresolved_function.arguments[1],
-                            snowpark_typed_args[0].typ,
-                        )
-                    ),
+                    format_lit,
                 )
+
+                if format_literal == "EEEE":
+                    # TODO: SNOW-2356874, for weekday, Snowflake only supports abbreviated name, e.g. "Fri". Patch spark "EEEE" until
+                    #  snowflake supports full weekday name.
+                    result_exp = (
+                        snowpark_fn.when(result_exp == "Mon", "Monday")
+                        .when(result_exp == "Tue", "Tuesday")
+                        .when(result_exp == "Wed", "Wednesday")
+                        .when(result_exp == "Thu", "Thursday")
+                        .when(result_exp == "Fri", "Friday")
+                        .when(result_exp == "Sat", "Saturday")
+                        .when(result_exp == "Sun", "Sunday")
+                        .otherwise(result_exp)
+                    )
             result_exp = TypedColumn(result_exp, lambda: [StringType()])
         case "date_from_unix_date":
             result_exp = snowpark_fn.date_add(
@@ -2486,6 +2553,14 @@ 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:
@@ -3261,7 +3336,7 @@ def map_unresolved_function(
             # TODO: See the spark-compatibility-issues.md explanation, this is quite different from Spark.
             # MapType columns as input should raise an exception as they are not hashable.
             snowflake_compat = get_boolean_session_config_param(
-                "enable_snowflake_extension_behavior"
+                "snowpark.connect.enable_snowflake_extension_behavior"
             )
             # Snowflake's hash function does allow MAP types, but Spark does not. Therefore, if we have the expansion flag enabled
             # we want to let it pass through and hash MAP types.
@@ -3768,10 +3843,21 @@ def map_unresolved_function(
                 snowpark_fn.lit(is_outer),
             )
         case "input_file_name":
-            # TODO: Use METADATA$FILENAME to get an actual file name, but this requires a refactor, because this is not possible straightaway here.
-            raise SnowparkConnectNotImplementedError(
-                "input_file_name is not yet supported."
+            # Return the filename metadata column for file-based DataFrames
+            # If METADATA$FILENAME doesn't exist (e.g., for DataFrames created from local data),
+            # return empty string to match Spark's behavior
+            from snowflake.snowpark_connect.relation.read.metadata_utils import (
+                METADATA_FILENAME_COLUMN,
             )
+
+            available_columns = column_mapping.get_snowpark_columns()
+            if METADATA_FILENAME_COLUMN in available_columns:
+                result_exp = snowpark_fn.col(METADATA_FILENAME_COLUMN)
+            else:
+                # Return empty when METADATA$FILENAME column doesn't exist, matching Spark behavior
+                result_exp = snowpark_fn.lit("").cast(StringType())
+            result_type = StringType()
+            spark_function_name = "input_file_name()"
         case "instr":
             result_exp = snowpark_fn.charindex(snowpark_args[1], snowpark_args[0])
             result_type = LongType()
@@ -4731,7 +4817,7 @@ def map_unresolved_function(
             )
         case "md5":
             snowflake_compat = get_boolean_session_config_param(
-                "enable_snowflake_extension_behavior"
+                "snowpark.connect.enable_snowflake_extension_behavior"
             )
 
             # MD5 in Spark only accepts BinaryType or types that can be implicitly cast to it (StringType)
@@ -5305,9 +5391,14 @@ def map_unresolved_function(
             result_exp = snowpark_fn.function(function_name)(
                 _check_percentile_percentage(exp.unresolved_function.arguments[1])
             ).within_group(snowpark_args[0])
-            result_exp = TypedColumn(
-                snowpark_fn.cast(result_exp, FloatType()), lambda: [DoubleType()]
+            result_exp = (
+                TypedColumn(
+                    snowpark_fn.cast(result_exp, FloatType()), lambda: [DoubleType()]
+                )
+                if not is_window_enabled()
+                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]})"
         case "pi":
             spark_function_name = "PI()"
@@ -7526,6 +7617,12 @@ 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"
+                    )
             result_exp = _try_arithmetic_helper(snowpark_typed_args, snowpark_args, 0)
             result_exp = _type_with_typer(result_exp)
         case "try_aes_decrypt":
@@ -7579,6 +7676,12 @@ 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"
+                    )
             match (snowpark_typed_args[0].typ, snowpark_typed_args[1].typ):
                 case (NullType(), t) | (t, NullType()):
                     result_exp = snowpark_fn.lit(None)
@@ -7687,6 +7790,12 @@ def map_unresolved_function(
                         f"Expected either (ArrayType, IntegralType) or (MapType, StringType), got {snowpark_typed_args[0].typ}, {snowpark_typed_args[1].typ}."
                     )
         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 (NullType(), t) | (t, NullType()):
                     result_exp = snowpark_fn.lit(None)
@@ -7785,6 +7894,12 @@ 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"
+                    )
             result_exp = _try_arithmetic_helper(snowpark_typed_args, snowpark_args, 1)
             result_exp = _type_with_typer(result_exp)
         case "try_to_number":
@@ -9865,6 +9980,70 @@ def _get_add_sub_result_type(
     return result_type, overflow_possible
 
 
+def _get_interval_type_name(
+    interval_type: Union[YearMonthIntervalType, DayTimeIntervalType]
+) -> 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:
+            return "INTERVAL YEAR"
+        elif interval_type.start_field == 1 and interval_type.end_field == 1:
+            return "INTERVAL MONTH"
+        else:
+            return "INTERVAL YEAR TO MONTH"
+    else:  # DayTimeIntervalType
+        if interval_type.start_field == 0 and interval_type.end_field == 0:
+            return "INTERVAL DAY"
+        elif interval_type.start_field == 1 and interval_type.end_field == 1:
+            return "INTERVAL HOUR"
+        elif interval_type.start_field == 2 and interval_type.end_field == 2:
+            return "INTERVAL MINUTE"
+        elif interval_type.start_field == 3 and interval_type.end_field == 3:
+            return "INTERVAL SECOND"
+        else:
+            return "INTERVAL DAY TO SECOND"
+
+
+def _check_interval_string_comparison(
+    operator: str, snowpark_typed_args: List[TypedColumn], snowpark_arg_names: List[str]
+) -> None:
+    """Check for invalid interval-string comparisons and raise AnalysisException if found."""
+    if (
+        isinstance(
+            snowpark_typed_args[0].typ, (YearMonthIntervalType, DayTimeIntervalType)
+        )
+        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)
+        )
+    ):
+        # Format interval type name for error message
+        interval_type = (
+            snowpark_typed_args[0].typ
+            if isinstance(
+                snowpark_typed_args[0].typ, (YearMonthIntervalType, DayTimeIntervalType)
+            )
+            else snowpark_typed_args[1].typ
+        )
+        interval_name = _get_interval_type_name(interval_type)
+
+        left_type = (
+            "STRING"
+            if isinstance(snowpark_typed_args[0].typ, StringType)
+            else interval_name
+        )
+        right_type = (
+            "STRING"
+            if isinstance(snowpark_typed_args[1].typ, StringType)
+            else interval_name
+        )
+
+        raise 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}").;'
+        )
+
+
 def _get_spark_function_name(
     col1: TypedColumn,
     col2: TypedColumn,
@@ -9906,6 +10085,21 @@ def _get_spark_function_name(
                 return f"{date_param_name1} {operation_op} {snowpark_arg_names[1]}"
             else:
                 return f"{operation_func}(cast({date_param_name1} as date), cast({snowpark_arg_names[1]} as double))"
+        case (DateType(), DayTimeIntervalType()) | (
+            DateType(),
+            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(),
+        ):
+            date_param_name2 = _get_literal_param_name(exp, 1, snowpark_arg_names[1])
+            if function_name == "+":
+                return f"{date_param_name2} {operation_op} {snowpark_arg_names[0]}"
+            else:
+                return default_spark_function_name
         case (DateType() as dt, _) | (_, DateType() as dt):
             date_param_index = 0 if dt == col1.typ else 1
             date_param_name = _get_literal_param_name(