snowpark-connect 0.29.0__tar.gz → 0.30.1__tar.gz

{snowpark_connect-0.29.0/src/snowpark_connect.egg-info → snowpark_connect-0.30.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: snowpark-connect
-Version: 0.29.0
+Version: 0.30.1
 Summary: Snowpark Connect for Spark
 Author: Snowflake, Inc
 License: Apache License, Version 2.0

{snowpark_connect-0.29.0 → snowpark_connect-0.30.1}/src/snowflake/snowpark_connect/analyze_plan/map_tree_string.py

@@ -5,6 +5,9 @@
 import pyspark.sql.connect.proto.base_pb2 as proto_base
 
 from snowflake.snowpark_connect.relation.map_relation import map_relation
+from snowflake.snowpark_connect.relation.read.metadata_utils import (
+    filter_metadata_columns,
+)
 from snowflake.snowpark_connect.type_mapping import (
     SNOWPARK_TYPE_NAME_TO_PYSPARK_TYPE_NAME,
 )
@@ -16,12 +19,13 @@ def map_tree_string(
     # TODO: tracking the difference with pyspark in SNOW-1853347
     tree_string = request.tree_string
     snowpark_df_container = map_relation(tree_string.plan.root)
-    snowpark_df = snowpark_df_container.dataframe
-    column_map = snowpark_df_container.column_map
+    filtered_container = filter_metadata_columns(snowpark_df_container)
+    display_df = filtered_container.dataframe
+    filtered_column_mapping = filtered_container.column_map.snowpark_to_spark_map()
 
-    snowpark_tree_string = snowpark_df._format_schema(
+    snowpark_tree_string = display_df._format_schema(
         level=tree_string.level if tree_string.HasField("level") else None,
-        translate_columns=column_map.snowpark_to_spark_map(),
+        translate_columns=filtered_column_mapping,
         translate_types=SNOWPARK_TYPE_NAME_TO_PYSPARK_TYPE_NAME,
     )
     # workaround for the capitalization of nullable boolean value.

snowpark_connect-0.30.1/src/snowflake/snowpark_connect/client.py

@@ -0,0 +1,65 @@
+#
+# Copyright (c) 2012-2025 Snowflake Computing Inc. All rights reserved.
+#
+
+import zlib
+
+from pyspark.sql import DataFrame, SparkSession
+
+SQL_PASS_THROUGH_MARKER = "PRIVATE-SNOWFLAKE-SQL"
+
+
+def calculate_checksum(data: str) -> str:
+    checksum = zlib.crc32(data.encode("utf-8"))
+    return format(checksum, "08X")
+
+
+class SnowflakeSession:
+    """
+    Provides a wrapper around SparkSession to enable Snowflake SQL pass-through functionality.
+    Also provides helper methods to switch to different database, schema, role, warehouse, etc.
+    """
+
+    def __init__(self, spark_session: SparkSession) -> None:
+        self.spark_session = spark_session
+
+    def sql(self, sql_stmt: str) -> DataFrame:
+        """
+        Execute Snowflake specific SQL directly against Snowflake.
+        """
+        checksum = calculate_checksum(sql_stmt)
+        return self.spark_session.sql(
+            f"{SQL_PASS_THROUGH_MARKER} {checksum} {sql_stmt}"
+        )
+
+    def use_database(self, database: str, preserve_case: bool = False) -> DataFrame:
+        """
+        Switch to the database specified by `database`.
+        """
+        if preserve_case:
+            database = f'"{database}"'
+        return self.sql(f"USE DATABASE {database}")
+
+    def use_schema(self, schema: str, preserve_case: bool = False) -> DataFrame:
+        """
+        Switch to the schema specified by `schema`.
+        """
+        if preserve_case:
+            schema = f'"{schema}"'
+        return self.sql(f"USE SCHEMA {schema}")
+
+    def use_role(self, role: str, preserve_case: bool = False) -> DataFrame:
+        """
+        Switch to the role specified by `role`.
+        """
+        if preserve_case:
+            role = f'"{role}"'
+        return self.sql(f"USE ROLE {role}")
+
+    def use_warehouse(self, warehouse: str, preserve_case: bool = False) -> DataFrame:
+        """
+        Switch to the warehouse specified by `warehouse`.
+        """
+        if preserve_case:
+            warehouse = f'"{warehouse}"'
+        return self.sql(f"USE WAREHOUSE {warehouse}")

{snowpark_connect-0.29.0 → snowpark_connect-0.30.1}/src/snowflake/snowpark_connect/column_name_handler.py

@@ -75,7 +75,13 @@ def make_column_names_snowpark_compatible(
         In this case the function call should be `make_column_names_snowpark_compatible(['a', 'b'], 5, 2)`,
         to avoid naming conflicts between the new columns and the old columns.
     """
+    from snowflake.snowpark_connect.relation.read.metadata_utils import (
+        METADATA_FILENAME_COLUMN,
+    )
+
     return [
+        # Skip METADATA$FILENAME - preserve original name without quoting
+        name if name == METADATA_FILENAME_COLUMN else
         # Use `-` in the name to force df.column to return double-quoted names
         quote_name(f"{unquote_if_quoted(name)}-{plan_id:08x}-{i + offset}")
         for i, name in enumerate(names)

{snowpark_connect-0.29.0 → snowpark_connect-0.30.1}/src/snowflake/snowpark_connect/config.py

@@ -143,6 +143,9 @@ class GlobalConfig:
         # Control whether repartition(n) on a DataFrame forces splitting into n files during writes
         # This matches spark behavior more closely, but introduces overhead.
         "snowflake.repartition.for.writes": "false",
+        "snowpark.connect.structured_types.fix": str(
+            snowpark.context._enable_fix_2360274
+        ).lower(),
     }
 
     boolean_config_list = [
@@ -263,9 +266,10 @@ SESSION_CONFIG_KEY_WHITELIST = {
     "snowpark.connect.sql.identifiers.auto-uppercase",
     "snowpark.connect.udtf.compatibility_mode",
     "snowpark.connect.views.duplicate_column_names_handling_mode",
-    "enable_snowflake_extension_behavior",
+    "snowpark.connect.enable_snowflake_extension_behavior",
     "spark.hadoop.fs.s3a.server-side-encryption.key",
     "spark.hadoop.fs.s3a.assumed.role.arn",
+    "snowpark.connect.describe_cache_ttl_seconds",
 }
 AZURE_ACCOUNT_KEY = re.compile(
     r"^fs\.azure\.sas\.[^\.]+\.[^\.]+\.blob\.core\.windows\.net$"
@@ -294,7 +298,8 @@ class SessionConfig:
         "snowpark.connect.views.duplicate_column_names_handling_mode": "rename",
         "spark.sql.execution.pythonUDTF.arrow.enabled": "false",
         "spark.sql.tvf.allowMultipleTableArguments.enabled": "true",
-        "enable_snowflake_extension_behavior": "false",
+        "snowpark.connect.enable_snowflake_extension_behavior": "false",
+        "snowpark.connect.describe_cache_ttl_seconds": "300",
     }
 
     def __init__(self) -> None:
@@ -607,6 +612,21 @@ def get_cte_optimization_enabled() -> bool:
     return get_boolean_session_config_param("snowpark.connect.cte.optimization_enabled")
 
 
+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()]
+    default_ttl: str = SessionConfig.default_session_config[
+        "snowpark.connect.describe_cache_ttl_seconds"
+    ]
+    try:
+        ttl_str = session_config.get(
+            "snowpark.connect.describe_cache_ttl_seconds", default_ttl
+        )
+        return int(ttl_str)
+    except ValueError:  # fallback to default ttl
+        return int(default_ttl)
+
+
 def auto_uppercase_column_identifiers() -> bool:
     session_config = sessions_config[get_session_id()]
     return session_config[
@@ -710,7 +730,9 @@ def check_table_supports_operation(table_identifier: str, operation: str) -> boo
     session_id = get_session_id()
     session_config = sessions_config[session_id]
     enable_extensions = str_to_bool(
-        session_config.get("enable_snowflake_extension_behavior", "false")
+        session_config.get(
+            "snowpark.connect.enable_snowflake_extension_behavior", "false"
+        )
     )
 
     if enable_extensions:

{snowpark_connect-0.29.0 → snowpark_connect-0.30.1}/src/snowflake/snowpark_connect/execute_plan/map_execution_root.py

@@ -26,6 +26,9 @@ from snowflake.snowpark_connect.execute_plan.utils import (
     pandas_to_arrow_batches_bytes,
 )
 from snowflake.snowpark_connect.relation.map_relation import map_relation
+from snowflake.snowpark_connect.relation.read.metadata_utils import (
+    filter_metadata_columns,
+)
 from snowflake.snowpark_connect.type_mapping import (
     map_snowpark_types_to_pyarrow_types,
     snowpark_to_proto_type,
@@ -92,14 +95,19 @@ def map_execution_root(
 ) -> Iterator[proto_base.ExecutePlanResponse | QueryResult]:
     result: DataFrameContainer | pandas.DataFrame = map_relation(request.plan.root)
     if isinstance(result, pandas.DataFrame):
-        result_df = result
+        pandas_df = result
+        data_bytes = pandas_to_arrow_batches_bytes(pandas_df)
+        row_count = len(pandas_df)
+        schema = None
+        yield _build_execute_plan_response(row_count, data_bytes, schema, request)
     else:
-        result_df = result.dataframe
-
-    if isinstance(result_df, snowpark.DataFrame):
-        snowpark_schema = result_df.schema
-        schema = snowpark_to_proto_type(snowpark_schema, result.column_map, result_df)
-        spark_columns = result.column_map.get_spark_columns()
+        filtered_result = filter_metadata_columns(result)
+        filtered_result_df = filtered_result.dataframe
+        snowpark_schema = filtered_result_df.schema
+        schema = snowpark_to_proto_type(
+            snowpark_schema, filtered_result.column_map, filtered_result_df
+        )
+        spark_columns = filtered_result.column_map.get_spark_columns()
         if tcm.TCM_MODE:
             # TCM result handling:
             # - small result (only one batch): just return the executePlanResponse
@@ -108,22 +116,22 @@ def map_execution_root(
             is_large_result = False
             second_batch = False
             first_arrow_table = None
-            with result_df.session.query_history() as qh:
-                for arrow_table in to_arrow_batch_iter(result_df):
+            with filtered_result_df.session.query_history() as qh:
+                for arrow_table in to_arrow_batch_iter(filtered_result_df):
                     if second_batch:
                         is_large_result = True
                         break
                     first_arrow_table = arrow_table
                     second_batch = True
                 queries_cnt = len(
-                    result_df._plan.execution_queries[PlanQueryType.QUERIES]
+                    filtered_result_df._plan.execution_queries[PlanQueryType.QUERIES]
                 )
                 # get query uuid from the last query; this may not be the last queries in query history because snowpark
                 # may run some post action queries, e.g., drop temp table.
                 query_id = qh.queries[queries_cnt - 1].query_id
             if first_arrow_table is None:
                 # empty arrow batch iterator
-                pandas_df = result_df.to_pandas()
+                pandas_df = filtered_result_df.to_pandas()
                 data_bytes = pandas_to_arrow_batches_bytes(pandas_df)
                 yield _build_execute_plan_response(0, data_bytes, schema, request)
             elif not tcm.TCM_RETURN_QUERY_ID_FOR_SMALL_RESULT and not is_large_result:
@@ -150,7 +158,7 @@ def map_execution_root(
                     spark_schema.SerializeToString(),
                 )
         else:
-            arrow_table_iter = to_arrow_batch_iter(result_df)
+            arrow_table_iter = to_arrow_batch_iter(filtered_result_df)
             batch_count = 0
             for arrow_table in arrow_table_iter:
                 if arrow_table.num_rows > 0:
@@ -166,12 +174,6 @@ def map_execution_root(
 
             # Empty result needs special processing
             if batch_count == 0:
-                pandas_df = result_df.to_pandas()
+                pandas_df = filtered_result_df.to_pandas()
                 data_bytes = pandas_to_arrow_batches_bytes(pandas_df)
                 yield _build_execute_plan_response(0, data_bytes, schema, request)
-    else:
-        pandas_df = result_df
-        data_bytes = pandas_to_arrow_batches_bytes(pandas_df)
-        row_count = len(pandas_df)
-        schema = None
-        yield _build_execute_plan_response(row_count, data_bytes, schema, request)

snowpark_connect-0.30.1/src/snowflake/snowpark_connect/expression/map_extension.py

@@ -0,0 +1,391 @@
+#
+# Copyright (c) 2012-2025 Snowflake Computing Inc. All rights reserved.
+#
+
+import pyspark.sql.connect.proto.expressions_pb2 as expressions_proto
+
+import snowflake.snowpark.functions as snowpark_fn
+import snowflake.snowpark_connect.proto.snowflake_expression_ext_pb2 as snowflake_proto
+from snowflake.snowpark.types import (
+    BooleanType,
+    DayTimeIntervalType,
+    StringType,
+    YearMonthIntervalType,
+)
+from snowflake.snowpark_connect.column_name_handler import ColumnNameMap
+from snowflake.snowpark_connect.expression.typer import ExpressionTyper
+from snowflake.snowpark_connect.typed_column import TypedColumn
+from snowflake.snowpark_connect.utils.context import (
+    push_evaluating_sql_scope,
+    push_outer_dataframe,
+)
+from snowflake.snowpark_connect.utils.telemetry import (
+    SnowparkConnectNotImplementedError,
+)
+
+# Formatting constants for interval display
+_TWO_DIGIT_FORMAT = (
+    "{:02d}"  # Zero-padded 2-digit format for hours, minutes, and whole seconds
+)
+_THREE_DIGIT_FORMAT = (
+    "{:03d}"  # Zero-padded 3-digit format for hours/minutes and whole seconds
+)
+_SECONDS_PRECISION_FORMAT = (
+    "{:09.6f}"  # 6 decimal places with leading zeros for seconds
+)
+
+
+def _format_time_component(value: int, is_negative: bool = False) -> str:
+    """Format a time component (hours, minutes, whole seconds) with proper zero-padding."""
+    if is_negative:
+        return _THREE_DIGIT_FORMAT.format(value)
+    else:
+        return _TWO_DIGIT_FORMAT.format(value)
+
+
+def _format_seconds_precise(seconds: float) -> str:
+    """Format seconds with full precision, stripping trailing zeros."""
+    return _SECONDS_PRECISION_FORMAT.format(seconds).rstrip("0").rstrip(".")
+
+
+def map_extension(
+    exp: expressions_proto.Expression,
+    column_mapping: ColumnNameMap,
+    typer: ExpressionTyper,
+) -> tuple[list[str], TypedColumn]:
+    """
+    The Extension relation type contains any extensions we use for adding new
+    functionality to Spark Connect.
+
+    The extension will require new protobuf messages to be defined in the
+    snowflake_connect_server/proto directory.
+    """
+    extension = snowflake_proto.ExpExtension()
+    exp.extension.Unpack(extension)
+    match extension.WhichOneof("op"):
+        case "named_argument":
+            from snowflake.snowpark_connect.expression.map_expression import (
+                map_expression,
+            )
+
+            named_argument = extension.named_argument
+            key = named_argument.key
+            value = named_argument.value
+
+            exp_name, typed_col = map_expression(value, column_mapping, typer)
+            if value.HasField("literal"):
+                name = key
+            elif value.HasField("unresolved_attribute"):
+                name = "__" + key + "__" + exp_name[0]
+            else:
+                raise SnowparkConnectNotImplementedError(
+                    "Named argument not supported yet for this input."
+                )
+            return [name], typed_col
+
+        case "interval_literal":
+            interval_ext = extension.interval_literal
+            literal = interval_ext.literal
+            start_field = (
+                interval_ext.start_field
+                if interval_ext.HasField("start_field")
+                else None
+            )
+            end_field = (
+                interval_ext.end_field if interval_ext.HasField("end_field") else None
+            )
+
+            # Format interval with proper context-aware formatting
+            if literal.HasField("year_month_interval"):
+                total_months = literal.year_month_interval
+                lit_value, lit_name = _format_year_month_interval(
+                    total_months, start_field, end_field
+                )
+                if start_field is not None and end_field is not None:
+                    interval_data_type = YearMonthIntervalType(start_field, end_field)
+                else:
+                    interval_data_type = YearMonthIntervalType()
+
+                # Create column using SQL expression with context-aware formatting
+                col = snowpark_fn.sql_expr(lit_value)
+
+            elif literal.HasField("day_time_interval"):
+                total_microseconds = literal.day_time_interval
+                lit_value, lit_name = _format_day_time_interval(
+                    total_microseconds, start_field, end_field
+                )
+                if start_field is not None and end_field is not None:
+                    interval_data_type = DayTimeIntervalType(start_field, end_field)
+                else:
+                    interval_data_type = DayTimeIntervalType()
+
+                # Create column using SQL expression to get proper interval type (same as year-month)
+                col = snowpark_fn.sql_expr(lit_value)
+
+            else:
+                # Fallback - shouldn't happen
+                lit_value = str(literal)
+                lit_name = str(literal)
+                interval_data_type = StringType()
+                col = snowpark_fn.lit(lit_value)
+
+            typed_col = TypedColumn(col, lambda: [interval_data_type])
+
+            return [lit_name], typed_col
+
+        case "subquery_expression":
+            from snowflake.snowpark_connect.dataframe_container import (
+                DataFrameContainer,
+            )
+            from snowflake.snowpark_connect.expression.map_expression import (
+                map_expression,
+            )
+            from snowflake.snowpark_connect.relation.map_relation import map_relation
+
+            current_outer_df = DataFrameContainer(
+                dataframe=typer.df, column_map=column_mapping
+            )
+
+            with push_evaluating_sql_scope(), push_outer_dataframe(current_outer_df):
+                df_container = map_relation(extension.subquery_expression.input)
+                df = df_container.dataframe
+
+            queries = df.queries["queries"]
+            if len(queries) != 1:
+                raise SnowparkConnectNotImplementedError(
+                    f"Unexpected number of queries: {len(queries)}"
+                )
+            query = f"({queries[0]})"
+
+            match extension.subquery_expression.subquery_type:
+                case snowflake_proto.SubqueryExpression.SUBQUERY_TYPE_SCALAR:
+                    name = "scalarsubquery()"
+                    result_exp = snowpark_fn.expr(query)
+                    result_type = df.schema[0].datatype
+                case snowflake_proto.SubqueryExpression.SUBQUERY_TYPE_EXISTS:
+                    name = "exists()"
+                    result_exp = snowpark_fn.expr(f"(EXISTS {query})")
+                    result_type = BooleanType()
+                case snowflake_proto.SubqueryExpression.SUBQUERY_TYPE_TABLE_ARG:
+                    # TODO: Currently, map_sql.py handles this, so we never end up here.
+                    raise SnowparkConnectNotImplementedError("Unexpected table arg")
+                case snowflake_proto.SubqueryExpression.SUBQUERY_TYPE_IN:
+                    cols = [
+                        map_expression(e, column_mapping, typer)
+                        for e in extension.subquery_expression.in_subquery_values
+                    ]
+                    col_names_str = ", ".join(
+                        col_name for col_names, _ in cols for col_name in col_names
+                    )
+                    # TODO: Figure out how to make a named_struct(...) here to match Spark.
+                    name = f"({col_names_str}) in (listquery())"
+                    result_exp = snowpark_fn.in_(
+                        [col.col for _, col in cols], snowpark_fn.expr(query)
+                    )
+                    result_type = BooleanType()
+                case other:
+                    raise SnowparkConnectNotImplementedError(
+                        f"Unexpected subquery type: {other}"
+                    )
+
+            return [name], TypedColumn(result_exp, lambda: [result_type])
+
+        case other:
+            raise SnowparkConnectNotImplementedError(f"Unexpected extension {other}")
+
+
+def _format_year_month_interval(
+    total_months: int, start_field: int | None, end_field: int | None
+) -> tuple[str, str]:
+    """Format year-month interval with context-aware precision."""
+
+    # Calculate years and months from absolute value
+    is_negative = total_months < 0
+    abs_months = abs(total_months)
+    years = abs_months // 12
+    months = abs_months % 12
+
+    # Determine interval type
+    is_year_only = (
+        start_field == YearMonthIntervalType.YEAR
+        and end_field == YearMonthIntervalType.YEAR
+    )
+    is_month_only = (
+        start_field == YearMonthIntervalType.MONTH
+        and end_field == YearMonthIntervalType.MONTH
+    )
+
+    # Format based on type and sign
+    if is_year_only:
+        sign = "-" if is_negative else ""
+        str_value = f"INTERVAL '{sign}{years}' YEAR"
+    elif is_month_only:
+        str_value = f"INTERVAL '{total_months}' MONTH"  # Keep original sign
+    else:  # YEAR TO MONTH (default)
+        if is_negative:
+            str_value = f"INTERVAL '-{years}-{months}' YEAR TO MONTH"
+        else:
+            str_value = f"INTERVAL '{years}-{months}' YEAR TO MONTH"
+
+    return str_value, str_value
+
+
+def _format_day_time_interval(
+    total_microseconds: int, start_field: int | None, end_field: int | None
+) -> tuple[str, str]:
+    """Format day-time interval with context-aware precision."""
+    total_seconds = total_microseconds / 1_000_000
+
+    # Handle negative intervals correctly
+    is_negative = total_seconds < 0
+
+    # Work with integer microseconds to preserve precision
+    abs_total_microseconds = abs(total_microseconds)
+
+    # Convert to components using integer arithmetic
+    days = int(abs_total_microseconds // (86400 * 1_000_000))
+    remaining_microseconds = abs_total_microseconds % (86400 * 1_000_000)
+    hours = int(remaining_microseconds // (3600 * 1_000_000))
+    remaining_microseconds = remaining_microseconds % (3600 * 1_000_000)
+    minutes = int(remaining_microseconds // (60 * 1_000_000))
+    remaining_microseconds = remaining_microseconds % (60 * 1_000_000)
+
+    # Convert final microseconds to seconds with full precision
+    seconds = remaining_microseconds / 1_000_000
+
+    # Apply negative sign back to days if needed
+    if is_negative:
+        days = -days
+
+    # Format based on the specific start/end field context
+    if (
+        start_field == DayTimeIntervalType.DAY and end_field == DayTimeIntervalType.DAY
+    ):  # DAY only
+        str_value = f"INTERVAL '{days}' DAY"
+    elif (
+        start_field == DayTimeIntervalType.HOUR
+        and end_field == DayTimeIntervalType.HOUR
+    ):  # HOUR only
+        # For HOUR-only intervals, calculate total hours (don't break down into days)
+        total_hours = int(abs(total_microseconds) // (3600 * 1_000_000))
+        if total_microseconds < 0:
+            total_hours = -total_hours
+        if total_hours >= 0:
+            str_value = f"INTERVAL '{_TWO_DIGIT_FORMAT.format(total_hours)}' HOUR"
+        else:
+            str_value = f"INTERVAL '{_THREE_DIGIT_FORMAT.format(total_hours)}' HOUR"
+    elif (
+        start_field == DayTimeIntervalType.MINUTE
+        and end_field == DayTimeIntervalType.MINUTE
+    ):  # MINUTE only
+        # For MINUTE-only intervals, calculate total minutes (don't break down into hours/days)
+        total_minutes = int(abs(total_microseconds) // (60 * 1_000_000))
+        if total_microseconds < 0:
+            total_minutes = -total_minutes
+        if total_minutes >= 0:
+            str_value = f"INTERVAL '{_TWO_DIGIT_FORMAT.format(total_minutes)}' MINUTE"
+        else:
+            str_value = f"INTERVAL '{_THREE_DIGIT_FORMAT.format(total_minutes)}' MINUTE"
+    elif (
+        start_field == DayTimeIntervalType.SECOND
+        and end_field == DayTimeIntervalType.SECOND
+    ):  # SECOND only
+        # For SECOND-only intervals, use total seconds (don't break down into minutes/hours/days)
+        total_seconds_precise = total_microseconds / 1_000_000
+        if total_seconds_precise == int(total_seconds_precise):
+            if total_seconds_precise >= 0:
+                str_value = f"INTERVAL '{_TWO_DIGIT_FORMAT.format(int(total_seconds_precise))}' SECOND"
+            else:
+                str_value = f"INTERVAL '{_THREE_DIGIT_FORMAT.format(int(total_seconds_precise))}' SECOND"
+        else:
+            seconds_str = _format_seconds_precise(total_seconds_precise)
+            str_value = f"INTERVAL '{seconds_str}' SECOND"
+    elif (
+        start_field == DayTimeIntervalType.MINUTE
+        and end_field == DayTimeIntervalType.SECOND
+    ):  # MINUTE TO SECOND
+        # For MINUTE TO SECOND intervals, calculate total minutes and remaining seconds
+        total_minutes = int(abs_total_microseconds // (60 * 1_000_000))
+        remaining_microseconds_for_minutes = abs_total_microseconds % (60 * 1_000_000)
+        remaining_seconds_for_minutes = remaining_microseconds_for_minutes / 1_000_000
+
+        # Format seconds appropriately (whole or fractional)
+        if remaining_seconds_for_minutes == int(remaining_seconds_for_minutes):
+            seconds_str = _TWO_DIGIT_FORMAT.format(int(remaining_seconds_for_minutes))
+        else:
+            seconds_str = _format_seconds_precise(remaining_seconds_for_minutes)
+
+        # Apply sign and format
+        if is_negative:
+            str_value = f"INTERVAL '-{_TWO_DIGIT_FORMAT.format(total_minutes)}:{seconds_str}' MINUTE TO SECOND"
+        else:
+            str_value = f"INTERVAL '{_TWO_DIGIT_FORMAT.format(total_minutes)}:{seconds_str}' MINUTE TO SECOND"
+    elif (
+        start_field == DayTimeIntervalType.HOUR
+        and end_field == DayTimeIntervalType.MINUTE
+    ):  # HOUR TO MINUTE
+        str_value = f"INTERVAL '{_TWO_DIGIT_FORMAT.format(hours)}:{_TWO_DIGIT_FORMAT.format(minutes)}' HOUR TO MINUTE"
+    elif (
+        start_field == DayTimeIntervalType.HOUR
+        and end_field == DayTimeIntervalType.SECOND
+    ):  # HOUR TO SECOND
+        if seconds == int(seconds):
+            str_value = f"INTERVAL '{_format_time_component(hours)}:{_format_time_component(minutes)}:{_format_time_component(int(seconds))}' HOUR TO SECOND"
+        else:
+            seconds_str = _format_seconds_precise(seconds)
+            str_value = f"INTERVAL '{_format_time_component(hours)}:{_format_time_component(minutes)}:{seconds_str}' HOUR TO SECOND"
+    elif (
+        start_field == DayTimeIntervalType.DAY and end_field == DayTimeIntervalType.HOUR
+    ):  # DAY TO HOUR
+        str_value = f"INTERVAL '{days} {_format_time_component(hours)}' DAY TO HOUR"
+    elif (
+        start_field == DayTimeIntervalType.DAY
+        and end_field == DayTimeIntervalType.MINUTE
+    ):  # DAY TO MINUTE
+        str_value = f"INTERVAL '{days} {_format_time_component(hours)}:{_format_time_component(minutes)}' DAY TO MINUTE"
+    elif (
+        start_field == DayTimeIntervalType.DAY
+        and end_field == DayTimeIntervalType.SECOND
+    ):  # DAY TO SECOND
+        if seconds == int(seconds):
+            str_value = f"INTERVAL '{days} {_format_time_component(hours)}:{_format_time_component(minutes)}:{_format_time_component(int(seconds))}' DAY TO SECOND"
+        else:
+            seconds_str = _format_seconds_precise(seconds)
+            str_value = f"INTERVAL '{days} {_format_time_component(hours)}:{_format_time_component(minutes)}:{seconds_str}' DAY TO SECOND"
+    else:
+        # Fallback - use smart formatting like the original literal.py logic
+        if days > 0:
+            if hours == 0 and minutes == 0 and seconds == 0:
+                str_value = f"INTERVAL '{int(days)}' DAY"
+            else:
+                if seconds == int(seconds):
+                    str_value = f"INTERVAL '{days} {_format_time_component(hours)}:{_format_time_component(minutes)}:{_format_time_component(int(seconds))}' DAY TO SECOND"
+                else:
+                    seconds_str = _format_seconds_precise(seconds)
+                    str_value = f"INTERVAL '{days} {_format_time_component(hours)}:{_format_time_component(minutes)}:{seconds_str}' DAY TO SECOND"
+        elif hours > 0:
+            if minutes == 0 and seconds == 0:
+                str_value = f"INTERVAL '{_format_time_component(hours)}' HOUR"
+            else:
+                if seconds == int(seconds):
+                    str_value = f"INTERVAL '{_format_time_component(hours)}:{_format_time_component(minutes)}:{_format_time_component(int(seconds))}' HOUR TO SECOND"
+                else:
+                    seconds_str = _format_seconds_precise(seconds)
+                    str_value = f"INTERVAL '{_format_time_component(hours)}:{_format_time_component(minutes)}:{seconds_str}' HOUR TO SECOND"
+        elif minutes > 0:
+            if seconds == 0:
+                str_value = f"INTERVAL '{_format_time_component(minutes)}' MINUTE"
+            else:
+                if seconds == int(seconds):
+                    str_value = f"INTERVAL '{_format_time_component(minutes)}:{_format_time_component(int(seconds))}' MINUTE TO SECOND"
+                else:
+                    seconds_str = _format_seconds_precise(seconds)
+                    str_value = f"INTERVAL '{_format_time_component(minutes)}:{seconds_str}' MINUTE TO SECOND"
+        else:
+            if seconds == int(seconds):
+                str_value = f"INTERVAL '{_format_time_component(int(seconds))}' SECOND"
+            else:
+                seconds_str = _format_seconds_precise(seconds)
+                str_value = f"INTERVAL '{seconds_str}' SECOND"
+
+    return str_value, str_value