snowpark-connect 0.33.0__tar.gz → 1.0.0__tar.gz

{snowpark_connect-0.33.0/src/snowpark_connect.egg-info → snowpark_connect-1.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: snowpark-connect
-Version: 0.33.0
+Version: 1.0.0
 Summary: Snowpark Connect for Spark
 Author: Snowflake, Inc
 License: Apache License, Version 2.0
@@ -18,7 +18,7 @@ Requires-Dist: jpype1
 Requires-Dist: protobuf<6.32.0,>=4.25.3
 Requires-Dist: s3fs>=2025.3.0
 Requires-Dist: snowflake.core<2,>=1.0.5
-Requires-Dist: snowflake-snowpark-python[pandas]<1.41.0,==1.40.0
+Requires-Dist: snowflake-snowpark-python[pandas]<1.43.0,==1.42.0
 Requires-Dist: snowflake-connector-python<4.0.0,>=3.18.0
 Requires-Dist: sqlglot>=26.3.8
 Requires-Dist: jaydebeapi

{snowpark_connect-0.33.0 → snowpark_connect-1.0.0}/setup.py

@@ -47,7 +47,7 @@ setup(
         "protobuf>=4.25.3,<6.32.0",
         "s3fs>=2025.3.0",  # prod-297255-inc0132291
         "snowflake.core>=1.0.5,<2",
-        "snowflake-snowpark-python[pandas]==1.40.0,<1.41.0",
+        "snowflake-snowpark-python[pandas]==1.42.0,<1.43.0",
         "snowflake-connector-python>=3.18.0,<4.0.0",
         "sqlglot>=26.3.8",
         "jaydebeapi",

{snowpark_connect-0.33.0 → snowpark_connect-1.0.0}/src/snowflake/snowpark_connect/column_name_handler.py

@@ -98,7 +98,7 @@ def make_unique_snowpark_name(spark_name: str) -> str:
     Returns a snowpark column name that's guaranteed to be unique in this session,
     by appending "#<unique number>" to the given spark name.
     """
-    return quote_name(f"{spark_name}#{next_unique_num()}")
+    return quote_name(f"{spark_name}-{next_unique_num():x}")
 
 
 @dataclass(frozen=True)
@@ -621,55 +621,59 @@ class ColumnNameMap:
             return spark_name.upper()
 
     def get_columns_after_join(
-        self, other: ColumnNameMap, join_columns: list[str]
+        self, right: ColumnNameMap, join_columns: list[str], join_type: str
     ) -> list[ColumnNames]:
         """
         Returns a list of columns (names and qualifiers) after a using_columns join with the given column map
         """
 
-        join_column_names = {self._normalized_spark_name(c) for c in join_columns}
-        other_join_columns: dict[str, ColumnNames] = {}
-        other_remaining_columns: list[ColumnNames] = []
-        for oc in other.columns:
+        # first, let's gather right-side join columns for qualifier lookup
+        # and the remaining columns to append them to the result
+        join_column_names = [self._normalized_spark_name(c) for c in join_columns]
+        right_join_columns: dict[str, ColumnNames] = {}
+        right_remaining_columns: list[ColumnNames] = []
+        for oc in right.columns:
             col_name = self._normalized_spark_name(oc.spark_name)
             # only take the first matching column
-            if col_name in join_column_names and col_name not in other_join_columns:
-                other_join_columns[col_name] = oc
+            if col_name in join_column_names and col_name not in right_join_columns:
+                right_join_columns[col_name] = oc
             else:
-                other_remaining_columns.append(oc)
+                right_remaining_columns.append(oc)
 
-        joined_columns: list[ColumnNames] = []
-        visited: set[str] = set()
-        # add local columns first, we're in the left side of the join
+        # now gather left-side columns
+        left_join_columns: dict[str, ColumnNames] = {}
+        left_remaining_columns: list[ColumnNames] = []
         for c in self.columns:
             col_name = self._normalized_spark_name(c.spark_name)
-            if col_name in join_column_names and col_name not in visited:
-                visited.add(col_name)
-                qualifiers = c.qualifiers | other_join_columns[col_name].qualifiers
-                joined_columns.append(
-                    ColumnNames(c.spark_name, c.snowpark_name, qualifiers)
+            if col_name in join_column_names and col_name not in left_join_columns:
+                # only assign join-side qualifier for outer joins
+                match join_type:
+                    case "left":
+                        qualifiers = c.qualifiers
+                    case "right":
+                        qualifiers = right_join_columns[col_name].qualifiers
+                    case _:
+                        qualifiers = (
+                            c.qualifiers | right_join_columns[col_name].qualifiers
+                        )
+                left_join_columns[col_name] = ColumnNames(
+                    c.spark_name, c.snowpark_name, qualifiers
                 )
             else:
-                joined_columns.append(c)
-
-        # add other columns, excluding join columns
-        return joined_columns + other_remaining_columns
-
-    def get_column_indexes(self, spark_names: list[str]) -> list[int]:
-        """
-        Returns the first positions of the given spark_names in this column mapping.
-        Used to reorder columns after a using_columns join.
-        """
-        # mapping from normalized spark name ot the first index of the column in the mapping
-        column_indexes = {}
-
-        for i, c in enumerate(self.columns):
-            col_name = self._normalized_spark_name(c.spark_name)
-            if col_name not in column_indexes:
-                column_indexes[col_name] = i
-
-        # return indexes for given columns
-        return [column_indexes[self._normalized_spark_name(c)] for c in spark_names]
+                left_remaining_columns.append(c)
+
+        # join columns go first in the user-given order,
+        # then the remaining left-side columns, then remaining right-side columns
+        match join_type:
+            case "right":
+                ordered_join_columns = [
+                    right_join_columns[name] for name in join_column_names
+                ]
+            case _:
+                ordered_join_columns = [
+                    left_join_columns[name] for name in join_column_names
+                ]
+        return ordered_join_columns + left_remaining_columns + right_remaining_columns
 
     def get_conflicting_snowpark_columns(self, other: ColumnNameMap) -> set[str]:
         conflicting_columns = set()
@@ -737,19 +741,6 @@ class JoinColumnNameMap(ColumnNameMap):
             else snowpark_column_name_in_left
         )
 
-        # this means that the reference is for the column in right dataframe but same snowpark name exist in left dataframe as well
-        # or vice versa, so we need to append _left or _right to the snowpark name
-        if (
-            snowpark_name in self.left_column_mapping.get_snowpark_columns()
-            and snowpark_column_name_in_right is not None
-        ):
-            snowpark_name = quote_name(f"{unquote_if_quoted(snowpark_name)}_right")
-        elif (
-            snowpark_name in self.right_column_mapping.get_snowpark_columns()
-            and snowpark_column_name_in_left is not None
-        ):
-            snowpark_name = quote_name(f"{unquote_if_quoted(snowpark_name)}_left")
-
         return snowpark_name
 
     def get_snowpark_column_names_from_spark_column_names(
@@ -855,13 +846,8 @@ class JoinColumnNameMap(ColumnNameMap):
         return qualifiers_right if len(qualifiers_left) == 0 else qualifiers_left
 
     def get_columns_after_join(
-        self, other: ColumnNameMap, join_columns: list[str]
+        self, right: ColumnNameMap, join_columns: list[str], join_type: str
     ) -> list[ColumnNames]:
         exception = NotImplementedError("Method not implemented!")
         attach_custom_error_code(exception, ErrorCodes.INTERNAL_ERROR)
         raise exception
-
-    def get_column_indexes(self, spark_names: list[str]) -> list[int]:
-        exception = NotImplementedError("Method not implemented!")
-        attach_custom_error_code(exception, ErrorCodes.INTERNAL_ERROR)
-        raise exception

{snowpark_connect-0.33.0 → snowpark_connect-1.0.0}/src/snowflake/snowpark_connect/config.py

@@ -275,6 +275,7 @@ SESSION_CONFIG_KEY_WHITELIST = {
     "spark.hadoop.fs.s3a.server-side-encryption.key",
     "spark.hadoop.fs.s3a.assumed.role.arn",
     "snowpark.connect.describe_cache_ttl_seconds",
+    "mapreduce.fileoutputcommitter.marksuccessfuljobs",
 }
 AZURE_ACCOUNT_KEY = re.compile(
     r"^fs\.azure\.sas\.[^\.]+\.[^\.]+\.blob\.core\.windows\.net$"
@@ -304,6 +305,7 @@ class SessionConfig:
         "spark.sql.tvf.allowMultipleTableArguments.enabled": "true",
         "snowpark.connect.enable_snowflake_extension_behavior": "false",
         "snowpark.connect.describe_cache_ttl_seconds": "300",
+        "mapreduce.fileoutputcommitter.marksuccessfuljobs": "false",
     }
 
     def __init__(self) -> None:
@@ -639,6 +641,13 @@ def get_cte_optimization_enabled() -> bool:
     return get_boolean_session_config_param("snowpark.connect.cte.optimization_enabled")
 
 
+def get_success_file_generation_enabled() -> bool:
+    """Get the _SUCCESS file generation configuration setting."""
+    return get_boolean_session_config_param(
+        "mapreduce.fileoutputcommitter.marksuccessfuljobs"
+    )
+
+
 def get_describe_cache_ttl_seconds() -> int:
     """Get the describe query cache TTL from session config, with a default fallback."""
     session_config: SessionConfig = sessions_config[get_session_id()]

{snowpark_connect-0.33.0 → snowpark_connect-1.0.0}/src/snowflake/snowpark_connect/expression/literal.py

@@ -12,7 +12,6 @@ from tzlocal import get_localzone
 from snowflake.snowpark_connect.config import global_config
 from snowflake.snowpark_connect.error.error_codes import ErrorCodes
 from snowflake.snowpark_connect.error.error_utils import attach_custom_error_code
-from snowflake.snowpark_connect.utils.context import get_is_evaluating_sql
 from snowflake.snowpark_connect.utils.telemetry import (
     SnowparkConnectNotImplementedError,
 )
@@ -55,20 +54,21 @@ def get_literal_field_and_name(literal: expressions_proto.Expression.Literal):
                 microseconds = literal.timestamp
             else:
                 microseconds = literal.timestamp_ntz
-            lit_dt = datetime.datetime.fromtimestamp(
-                microseconds // 1_000_000
-            ) + datetime.timedelta(microseconds=microseconds % 1_000_000)
-            tz_dt = datetime.datetime.fromtimestamp(
-                microseconds // 1_000_000, tz=local_tz
+
+            dt_utc = datetime.datetime.fromtimestamp(
+                microseconds // 1_000_000, tz=datetime.timezone.utc
             ) + datetime.timedelta(microseconds=microseconds % 1_000_000)
+
             if t == "timestamp_ntz":
-                lit_dt = lit_dt.astimezone(datetime.timezone.utc)
-                tz_dt = tz_dt.astimezone(datetime.timezone.utc)
-            elif not get_is_evaluating_sql():
+                # For timestamp_ntz, display in UTC
+                lit_dt = dt_utc.replace(tzinfo=None)
+                tz_dt = dt_utc
+            else:
+                # For timestamp_ltz, always display in session timezone
                 config_tz = global_config.spark_sql_session_timeZone
-                config_tz = ZoneInfo(config_tz) if config_tz else local_tz
-                tz_dt = tz_dt.astimezone(config_tz)
-                lit_dt = lit_dt.astimezone(local_tz)
+                display_tz = ZoneInfo(config_tz) if config_tz else local_tz
+                tz_dt = dt_utc.astimezone(display_tz)
+                lit_dt = tz_dt.replace(tzinfo=None)
 
             def _format_timestamp(dt) -> str:
                 without_micros = f"{dt.year:04d}-{dt.month:02d}-{dt.day:02d} {dt.hour:02d}:{dt.minute:02d}:{dt.second:02d}"

{snowpark_connect-0.33.0 → snowpark_connect-1.0.0}/src/snowflake/snowpark_connect/expression/map_sql_expression.py

@@ -67,10 +67,16 @@ def sql_parser():
     """
 
     ts_type = global_config.spark_sql_timestampType
+    session_tz = global_config.spark_sql_session_timeZone
 
     if ts_type is not None:
         _get_sql_conf().get().setConfString("spark.sql.timestampType", str(ts_type))
 
+    if session_tz is not None:
+        _get_sql_conf().get().setConfString(
+            "spark.sql.session.timeZone", str(session_tz)
+        )
+
     return _get_sql_parser()
 
 

{snowpark_connect-0.33.0 → snowpark_connect-1.0.0}/src/snowflake/snowpark_connect/expression/map_unresolved_attribute.py

@@ -70,6 +70,143 @@ def _get_catalog_database_from_column_map(
     return catalog_database_info
 
 
+def _try_resolve_column_in_scopes(
+    column_name: str, column_mapping: ColumnNameMap
+) -> tuple[str | None, Any]:
+    """
+    Try to resolve a column name in current and outer scopes.
+
+    Args:
+        column_name: The column name to resolve
+        column_mapping: The column mapping for the current scope
+
+    Returns:
+        Tuple of (snowpark_name, found_column_map) or (None, None) if not found
+    """
+    # Try current scope
+    snowpark_name = column_mapping.get_snowpark_column_name_from_spark_column_name(
+        column_name, allow_non_exists=True
+    )
+    if snowpark_name is not None:
+        return snowpark_name, column_mapping
+
+    # Try outer scopes
+    for outer_df in get_outer_dataframes():
+        snowpark_name = (
+            outer_df.column_map.get_snowpark_column_name_from_spark_column_name(
+                column_name, allow_non_exists=True
+            )
+        )
+        if snowpark_name is not None:
+            return snowpark_name, outer_df.column_map
+
+    return None, None
+
+
+def _find_column_with_qualifier_match(
+    name_parts: list[str],
+    column_mapping: ColumnNameMap,
+) -> tuple[int, str | None, Any]:
+    """
+    Find the column position in name_parts where the prefix matches a qualifier.
+
+    In Spark, table qualifiers have at most 3 parts:
+    - 1 part: table only (e.g., 't1') → ColumnQualifier(('t1',))
+    - 2 parts: database.table (e.g., 'mydb.t5') → ColumnQualifier(('mydb', 't5'))
+    - 3 parts: catalog.database.table (e.g., 'cat.mydb.t5') → ColumnQualifier(('cat', 'mydb', 't5'))
+
+    Examples of how this works (suffix matching):
+    1) Input: "mydb1.t5.t5.i1" with qualifier ('mydb1', 't5')
+       - At i=2: prefix=['mydb1','t5'], matches qualifier suffix ('mydb1', 't5') → Column found!
+       - Remaining ['i1'] is treated as field access
+
+    2) Input: "t5.t5.i1" with qualifier ('mydb1', 't5')
+       - At i=1: prefix=['t5'], matches qualifier suffix ('t5',) → Column found!
+       - Remaining ['i1'] is treated as field access
+
+    3) Input: "cat.mydb.t5.t5.i1" with qualifier ('cat', 'mydb', 't5')
+       - At i=3: prefix=['cat','mydb','t5'], matches qualifier suffix → Column found!
+       - Remaining ['i1'] is treated as field access
+
+    The key insight: if the prefix before a candidate matches the END (suffix) of a qualifier,
+    then that position is the column reference. This allows partial qualification (e.g., just table
+    name instead of full database.table)
+
+    Args:
+        name_parts: The parts of the qualified name (e.g., ['mydb1', 't5', 't5', 'i1'])
+        column_mapping: The column mapping to resolve columns against
+
+    Returns:
+        Tuple of (column_part_index, snowpark_name, found_column_map)
+        Returns (0, None, None) if no valid column found
+
+    Raises:
+        AnalysisException: If a column is found but with invalid qualifier (scope violation)
+    """
+    # Track if we found a column but with wrong qualifier (scope violation)
+    scope_violation = None
+
+    for i in range(len(name_parts)):
+        candidate_column = name_parts[i]
+        snowpark_name, found_column_map = _try_resolve_column_in_scopes(
+            candidate_column, column_mapping
+        )
+
+        if snowpark_name is not None:
+            candidate_qualifiers = found_column_map.get_qualifiers_for_spark_column(
+                candidate_column
+            )
+            prefix_parts = name_parts[:i]
+
+            # Check if this is a valid column reference position
+            # A valid position is where the prefix exactly matches one of the qualifiers
+            is_valid_reference = False
+
+            if i == 0:
+                # No prefix (unqualified access)
+                # Always valid - Spark allows unqualified access to any column
+                # The remaining parts (name_parts[1:]) will be treated as
+                # struct/map/array field access (e.g., "person.address.city" where
+                # person is the column and address.city is the field path)
+                is_valid_reference = True
+            else:
+                # Has prefix - check if it matches the end (suffix) of any qualifier
+                # Spark allows partial qualification, so for qualifier ('mydb1', 't5'):
+                # - Can access as mydb1.t5.t5.i1 (full qualifier match)
+                # - Can access as t5.t5.i1 (suffix match - just table part)
+                # e.g., for "t5.t5.i1", when i=1, prefix=['t5'] matches suffix of ('mydb1', 't5')
+                # If valid, the remaining parts (name_parts[i+1:]) will be treated as
+                # struct/map/array field access (e.g., ['i1'] is a field in column t5)
+                for qual in candidate_qualifiers:
+                    if len(qual.parts) >= len(prefix_parts) and qual.parts[
+                        -len(prefix_parts) :
+                    ] == tuple(prefix_parts):
+                        is_valid_reference = True
+                        break
+
+            if is_valid_reference:
+                # This is the actual column reference
+                return (i, snowpark_name, found_column_map)
+            elif i > 0:
+                # Found column but qualifier doesn't match - this is a scope violation
+                # e.g., SELECT nt1.k where k exists but nt1 is not its qualifier
+                attr_name = ".".join(name_parts)
+                scope_violation = (attr_name, ".".join(prefix_parts))
+
+    # If we detected a scope violation, throw error
+    if scope_violation:
+        attr_name, invalid_qualifier = scope_violation
+        exception = AnalysisException(
+            f'[UNRESOLVED_COLUMN] Column "{attr_name}" cannot be resolved. '
+            f'The table or alias "{invalid_qualifier}" is not in scope or does not exist.'
+        )
+        attach_custom_error_code(exception, ErrorCodes.COLUMN_NOT_FOUND)
+        raise exception
+
+    # No valid column found
+    return (0, None, None)
+
+
 def map_unresolved_attribute(
     exp: expressions_proto.Expression,
     column_mapping: ColumnNameMap,
@@ -276,29 +413,10 @@ def map_unresolved_attribute(
     else:
         quoted_attr_name = name_parts[0]
 
-    # Helper function to try finding a column in current and outer scopes
-    def try_resolve_column(column_name: str) -> tuple[str | None, Any]:
-        # Try current scope
-        snowpark_name = column_mapping.get_snowpark_column_name_from_spark_column_name(
-            column_name, allow_non_exists=True
-        )
-        if snowpark_name is not None:
-            return snowpark_name, column_mapping
-
-        # Try outer scopes
-        for outer_df in get_outer_dataframes():
-            snowpark_name = (
-                outer_df.column_map.get_snowpark_column_name_from_spark_column_name(
-                    column_name, allow_non_exists=True
-                )
-            )
-            if snowpark_name is not None:
-                return snowpark_name, outer_df.column_map
-
-        return None, None
-
     # Try to resolve the full qualified name first
-    snowpark_name, found_column_map = try_resolve_column(quoted_attr_name)
+    snowpark_name, found_column_map = _try_resolve_column_in_scopes(
+        quoted_attr_name, column_mapping
+    )
 
     if snowpark_name is not None:
         col = get_col(snowpark_name)
@@ -313,47 +431,13 @@ def map_unresolved_attribute(
             original_attr_name, column_mapping
         )
 
-        # Try to find the column name in different parts of the name_parts array
-        # For qualified names like "table.column.field", we need to find the column part
-        for i in range(len(name_parts)):
-            candidate_column = name_parts[i]
-            snowpark_name, found_column_map = try_resolve_column(candidate_column)
-
-            if snowpark_name is not None:
-                column_part_index = i
-                break
-
-        # Validate qualifier scope: if we found a column but skipped prefix parts,
-        # those prefix parts could be valid qualifiers for the column
-        # We have prefix parts like 'nt1' in 'nt1.k' that were skipped
-        maybe_qualified = column_part_index > 0
-        if (
-            snowpark_name is not None
-            and maybe_qualified
-            and found_column_map is not None
-        ):
-            prefix_parts = name_parts[:column_part_index]
-            found_col_qualifiers = found_column_map.get_qualifiers_for_spark_column(
-                candidate_column
-            )
-
-            # Check if any qualifier matches the prefix
-            has_matching_qualifier = False
-            for qual in found_col_qualifiers:
-                if not qual.is_empty and len(qual.parts) >= len(prefix_parts):
-                    if qual.parts[-len(prefix_parts) :] == tuple(prefix_parts):
-                        has_matching_qualifier = True
-                        break
-
-            # If no matching qualifier, it's a scope violation
-            if not has_matching_qualifier:
-                # The prefix is not a valid qualifier for this column - scope violation!
-                exception = AnalysisException(
-                    f'[UNRESOLVED_COLUMN] Column "{attr_name}" cannot be resolved. '
-                    f'The table or alias "{".".join(prefix_parts)}" is not in scope or does not exist.'
-                )
-                attach_custom_error_code(exception, ErrorCodes.COLUMN_NOT_FOUND)
-                raise exception
+        # Find the column by matching qualifiers with the prefix parts
+        # Note: This may raise AnalysisException if a scope violation is detected
+        (
+            column_part_index,
+            snowpark_name,
+            found_column_map,
+        ) = _find_column_with_qualifier_match(name_parts, column_mapping)
 
         if snowpark_name is None:
             # Attempt LCA fallback.

{snowpark_connect-0.33.0 → snowpark_connect-1.0.0}/src/snowflake/snowpark_connect/expression/map_unresolved_function.py

@@ -119,7 +119,6 @@ from snowflake.snowpark_connect.utils.context import (
     get_is_evaluating_sql,
     get_is_in_udtf_context,
     get_spark_version,
-    is_in_pivot,
     is_window_enabled,
     push_udtf_context,
     resolving_fun_args,
@@ -411,10 +410,7 @@ def map_unresolved_function(
     def _resolve_aggregate_exp(
         result_exp: Column, default_result_type: DataType
     ) -> TypedColumn:
-        if is_in_pivot():
-            # it's not possible to cast the result in pivot
-            return _type_with_typer(result_exp)
-        elif is_window_enabled():
+        if is_window_enabled():
             # defer casting to capture whole window expression
             return TypedColumnWithDeferredCast(
                 result_exp, lambda: [default_result_type]
@@ -517,7 +513,6 @@ def map_unresolved_function(
         STRUCTURED_INCOMPATIBLE_AGGREGATES = {"min", "max"}
         if (
             aggregate_func.__name__ in STRUCTURED_INCOMPATIBLE_AGGREGATES
-            and not is_in_pivot()
             and not is_window_enabled()
             and isinstance(typed_arg.typ, (ArrayType, MapType, StructType))
         ):
@@ -525,12 +520,7 @@ def map_unresolved_function(
             variant_arg = snowpark_fn.to_variant(typed_arg.col)
             result = aggregate_func(variant_arg)
 
-            if is_in_pivot():
-                # In PIVOT context, casting is not allowed, so return VARIANT type
-                return _type_with_typer(result)
-            else:
-                # Cast back to the original type to maintain the expected schema
-                return TypedColumn(result.cast(typed_arg.typ), lambda: expected_types)
+            return TypedColumn(result.cast(typed_arg.typ), lambda: expected_types)
         else:
             # No structured type conversion needed
             result = aggregate_func(typed_arg.col)
@@ -1028,9 +1018,12 @@ def map_unresolved_function(
                     result_exp = snowpark_args[0] - snowpark_args[1]
                     result_exp = result_exp.cast(result_type)
                 case (DateType(), DateType()):
-                    # TODO SNOW-2034420: resolve return type (it should be INTERVAL DAY)
-                    result_type = LongType()
-                    result_exp = snowpark_args[0] - snowpark_args[1]
+                    result_type = DayTimeIntervalType(
+                        DayTimeIntervalType.DAY, DayTimeIntervalType.DAY
+                    )
+                    result_exp = snowpark_fn.interval_day_time_from_parts(
+                        snowpark_args[0] - snowpark_args[1]
+                    )
                 case (DateType(), DayTimeIntervalType()) | (
                     DateType(),
                     YearMonthIntervalType(),
@@ -1049,14 +1042,22 @@ def map_unresolved_function(
                         result_type = TimestampType()
                         result_exp = snowpark_args[0] - snowpark_args[1]
                     else:
-                        # TODO SNOW-2034420: resolve return type (it should be INTERVAL DAY)
-                        result_type = LongType()
                         input_type = (
                             DateType() if spark_sql_ansi_enabled else DoubleType()
                         )
-                        result_exp = snowpark_args[0] - snowpark_args[1].cast(
-                            input_type
-                        )
+                        if isinstance(input_type, DateType):
+                            result_type = DayTimeIntervalType(
+                                DayTimeIntervalType.DAY, DayTimeIntervalType.DAY
+                            )
+                            result_exp = snowpark_fn.interval_day_time_from_parts(
+                                snowpark_args[0] - snowpark_args[1].cast(input_type)
+                            )
+                        else:
+                            # If ANSI is disabled, cast to DoubleType and return long (legacy behavior)
+                            result_type = LongType()
+                            result_exp = snowpark_args[0] - snowpark_args[1].cast(
+                                input_type
+                            )
                 case (TimestampType(), DayTimeIntervalType()) | (
                     TimestampType(),
                     YearMonthIntervalType(),
@@ -1075,10 +1076,12 @@ def map_unresolved_function(
                             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()
-                    input_type = DateType()
-                    result_exp = snowpark_args[0].cast(input_type) - snowpark_args[1]
+                    result_type = DayTimeIntervalType(
+                        DayTimeIntervalType.DAY, DayTimeIntervalType.DAY
+                    )
+                    result_exp = snowpark_fn.interval_day_time_from_parts(
+                        snowpark_args[0].cast(DateType()) - snowpark_args[1]
+                    )
                 case (DateType(), (IntegerType() | ShortType() | ByteType())):
                     result_type = DateType()
                     result_exp = snowpark_args[0] - snowpark_args[1]
@@ -6955,10 +6958,10 @@ def map_unresolved_function(
             )
             result_type = ArrayType(ArrayType(StringType()))
         case "sequence":
-            if snowpark_typed_args[0].typ != snowpark_typed_args[1].typ or (
-                not isinstance(snowpark_typed_args[0].typ, _IntegralType)
-                or not isinstance(snowpark_typed_args[1].typ, _IntegralType)
-            ):
+            both_integral = isinstance(
+                snowpark_typed_args[0].typ, _IntegralType
+            ) and isinstance(snowpark_typed_args[1].typ, _IntegralType)
+            if not both_integral:
                 exception = AnalysisException(
                     f"""[DATATYPE_MISMATCH.SEQUENCE_WRONG_INPUT_TYPES] Cannot resolve "sequence({snowpark_arg_names[0]}, {snowpark_arg_names[1]})" due to data type mismatch: `sequence` uses the wrong parameter type. The parameter type must conform to:
                         1. The start and stop expressions must resolve to the same type.