SNOW-2346552: added testing

Author: sfc-gh-fhe

src/snowflake/snowpark/dataframe.py

@@ -212,11 +212,11 @@
     StringType,
     StructField,
     StructType,
-    YearMonthIntervalType,
     _NumericType,
     _FractionalType,
     TimestampType,
     TimestampTimeZone,
+    YearMonthIntervalType,
 )
 
 # Python 3.8 needs to use typing.Iterable because collections.abc.Iterable is not subscriptable
@@ -5240,24 +5240,65 @@ def format_day_time_interval(total_seconds_float: float) -> str:
                             return f"{sign}{days}"
                         elif start_field == DayTimeIntervalType.HOUR:
                             total_hours = int(abs_total_seconds) // 3600
-                            return f"{sign}{total_hours:02d}"
+                            return (
+                                f"{sign}{total_hours:02d}"
+                                if total_hours < 10
+                                else f"{sign}{total_hours}"
+                            )
                         elif start_field == DayTimeIntervalType.MINUTE:
                             total_minutes = int(abs_total_seconds) // 60
-                            return f"{sign}{total_minutes}"
+                            return (
+                                f"{sign}{total_minutes:02d}"
+                                if total_minutes < 10
+                                else f"{sign}{total_minutes}"
+                            )
                         elif start_field == DayTimeIntervalType.SECOND:
                             # Handle fractional seconds - use total seconds, not just remainder
                             if abs_total_seconds == int(abs_total_seconds):
-                                return f"{sign}{int(abs_total_seconds)}"
+                                total_secs_int = int(abs_total_seconds)
+                                return (
+                                    f"{sign}{total_secs_int:02d}"
+                                    if total_secs_int < 10
+                                    else f"{sign}{total_secs_int}"
+                                )
                             else:
-                                return f"{sign}{abs_total_seconds:g}"
+                                # For fractional seconds, format with leading zero if < 10
+                                if abs_total_seconds < 10:
+                                    # Format with leading zero: split into integer and fractional parts
+                                    integer_part = int(abs_total_seconds)
+                                    fractional_part = abs_total_seconds - integer_part
+                                    if fractional_part == 0:
+                                        return f"{sign}{integer_part:02d}"
+                                    else:
+                                        # Format fractional part and remove leading '0.'
+                                        frac_str = f"{fractional_part:.6f}"[2:].rstrip(
+                                            "0"
+                                        )
+                                        return f"{sign}{integer_part:02d}.{frac_str}"
+                                else:
+                                    return f"{sign}{abs_total_seconds:g}"
 
                     # For multi-field intervals, format based on start/end fields
                     if start_field == DayTimeIntervalType.DAY:
-                        # DAY TO X format: "D HH:MM:SS"
-                        if seconds == int(seconds):
-                            return f"{sign}{days} {hours:02d}:{minutes:02d}:{int(seconds):02d}"
+                        # DAY TO X format: truncate based on end_field
+                        if end_field == DayTimeIntervalType.HOUR:
+                            # DAY TO HOUR: "D HH"
+                            return (
+                                f"{sign}{days} {hours:02d}"
+                                if hours < 10
+                                else f"{sign}{days} {hours}"
+                            )
+                        elif end_field == DayTimeIntervalType.MINUTE:
+                            # DAY TO MINUTE: "D HH:MM"
+                            hours_str = f"{hours:02d}" if hours < 10 else f"{hours}"
+                            return f"{sign}{days} {hours_str}:{minutes:02d}"
                         else:
-                            return f"{sign}{days} {hours:02d}:{minutes:02d}:{seconds:06.3f}"
+                            # DAY TO SECOND: "D HH:MM:SS"
+                            hours_str = f"{hours:02d}" if hours < 10 else f"{hours}"
+                            if seconds == int(seconds):
+                                return f"{sign}{days} {hours_str}:{minutes:02d}:{int(seconds):02d}"
+                            else:
+                                return f"{sign}{days} {hours_str}:{minutes:02d}:{seconds:06.3f}"
                     elif start_field == DayTimeIntervalType.HOUR:
                         # HOUR TO X format: "HH:MM:SS" (no days)
                         total_hours = int(abs_total_seconds) // 3600

tests/integ/test_dataframe.py

@@ -2536,6 +2536,179 @@ def assert_show_string_equals(actual: str, expected: str):
         )
 
 
+@pytest.mark.skipif(
+    "config.getoption('local_testing_mode', default=False)",
+    reason="FEAT: Interval types not fully supported in local testing",
+)
+def test_show_interval_formatting(session):
+    df = session.sql("SELECT INTERVAL '1' HOUR as hour_single")
+    assert df._show_string_spark(truncate=False) == dedent(
+        """\
+        +------------------+
+        |"HOUR_SINGLE"     |
+        +------------------+
+        |INTERVAL '01' HOUR|
+        +------------------+
+        """
+    )
+
+    df = session.sql("SELECT INTERVAL '5' MINUTE as minute_single")
+    assert df._show_string_spark(truncate=False) == dedent(
+        """\
+        +--------------------+
+        |"MINUTE_SINGLE"     |
+        +--------------------+
+        |INTERVAL '05' MINUTE|
+        +--------------------+
+        """
+    )
+
+    df = session.sql("SELECT INTERVAL '5' SECOND as second_integer")
+    assert df._show_string_spark(truncate=False) == dedent(
+        """\
+        +--------------------+
+        |"SECOND_INTEGER"    |
+        +--------------------+
+        |INTERVAL '05' SECOND|
+        +--------------------+
+        """
+    )
+
+    df = session.sql("SELECT INTERVAL '1.000001' SECOND as second_microseconds")
+    assert df._show_string_spark(truncate=False) == dedent(
+        """\
+        +---------------------------+
+        |"SECOND_MICROSECONDS"      |
+        +---------------------------+
+        |INTERVAL '01.000001' SECOND|
+        +---------------------------+
+        """
+    )
+
+    df = session.sql("SELECT INTERVAL '24' HOUR as hour_full_day")
+    assert df._show_string_spark(truncate=False) == dedent(
+        """\
+        +------------------+
+        |"HOUR_FULL_DAY"   |
+        +------------------+
+        |INTERVAL '24' HOUR|
+        +------------------+
+        """
+    )
+
+    df = session.sql("SELECT INTERVAL '90' MINUTE as minute_over_hour")
+    assert df._show_string_spark(truncate=False) == dedent(
+        """\
+        +--------------------+
+        |"MINUTE_OVER_HOUR"  |
+        +--------------------+
+        |INTERVAL '90' MINUTE|
+        +--------------------+
+        """
+    )
+
+    df = session.sql("SELECT INTERVAL '0' SECOND as zero_second")
+    assert df._show_string_spark(truncate=False) == dedent(
+        """\
+        +--------------------+
+        |"ZERO_SECOND"       |
+        +--------------------+
+        |INTERVAL '00' SECOND|
+        +--------------------+
+        """
+    )
+
+    df = session.sql("SELECT INTERVAL '0.000001' SECOND as microsecond")
+    assert df._show_string_spark(truncate=False) == dedent(
+        """\
+        +---------------------------+
+        |"MICROSECOND"              |
+        +---------------------------+
+        |INTERVAL '00.000001' SECOND|
+        +---------------------------+
+        """
+    )
+
+    df = session.sql("SELECT INTERVAL '2 12' DAY TO HOUR as day_to_hour")
+    assert df._show_string_spark(truncate=False) == dedent(
+        """\
+        +---------------------------+
+        |"DAY_TO_HOUR"              |
+        +---------------------------+
+        |INTERVAL '2 12' DAY TO HOUR|
+        +---------------------------+
+        """
+    )
+
+    df = session.sql("SELECT INTERVAL '1 08:30' DAY TO MINUTE as day_to_minute")
+    assert df._show_string_spark(truncate=False) == dedent(
+        """\
+        +--------------------------------+
+        |"DAY_TO_MINUTE"                 |
+        +--------------------------------+
+        |INTERVAL '1 08:30' DAY TO MINUTE|
+        +--------------------------------+
+        """
+    )
+
+    df = session.sql("SELECT INTERVAL '08:30' HOUR TO MINUTE as hour_to_minute")
+    assert df._show_string_spark(truncate=False) == dedent(
+        """\
+        +-------------------------------+
+        |"HOUR_TO_MINUTE"               |
+        +-------------------------------+
+        |INTERVAL '08:30' HOUR TO MINUTE|
+        +-------------------------------+
+        """
+    )
+
+    df = session.sql(
+        "SELECT INTERVAL '01:00:00.456' HOUR TO SECOND as hour_to_second_fractional"
+    )
+    assert df._show_string_spark(truncate=False) == dedent(
+        """\
+        +--------------------------------------+
+        |"HOUR_TO_SECOND_FRACTIONAL"           |
+        +--------------------------------------+
+        |INTERVAL '01:00:00.456' HOUR TO SECOND|
+        +--------------------------------------+
+        """
+    )
+
+    df = session.sql("SELECT INTERVAL '-2' HOUR as negative_hour")
+    assert df._show_string_spark(truncate=False) == dedent(
+        """\
+        +-------------------+
+        |"NEGATIVE_HOUR"    |
+        +-------------------+
+        |INTERVAL '-02' HOUR|
+        +-------------------+
+        """
+    )
+
+    df = session.sql("SELECT INTERVAL '-15.5' SECOND as negative_second")
+    assert df._show_string_spark(truncate=False) == dedent(
+        """\
+        +-----------------------+
+        |"NEGATIVE_SECOND"      |
+        +-----------------------+
+        |INTERVAL '-15.5' SECOND|
+        +-----------------------+
+        """
+    )
+
+    df = session.sql("SELECT INTERVAL '999999' SECOND as large_second")
+    assert df._show_string_spark(truncate=False) == dedent(
+        """\
+        +------------------------+
+        |"LARGE_SECOND"          |
+        +------------------------+
+        |INTERVAL '999999' SECOND|
+        +------------------------+
+        """
+    )
+
+
 @pytest.mark.parametrize("data", [[0, 1, 2, 3], ["", "a"], [False, True], [None]])
 def test_create_dataframe_with_single_value(session, data):
     expected_names = ["_1"]