[SPARK-54442][SQL] Add numeric conversion functions for TIME type

### What changes were proposed in this pull request?

This PR adds six numeric conversion functions for the TIME type, mirroring the existing pattern for TIMESTAMP:

Constructor Functions (Numeric → TIME):

- time_from_seconds(seconds) - Supports fractional seconds via NumericType
- time_from_millis(millis) - IntegralType input
- time_from_micros(micros) - IntegralType input

Extractor Functions (TIME → Numeric):
- time_to_seconds(time) - Returns DECIMAL(14,6) to preserve fractional seconds
- time_to_millis(time) - Returns BIGINT
- time_to_micros(time) - Returns BIGINT

eg
```
-- Constructor functions (Numeric → TIME)
SELECT time_from_seconds(52200);           -- 14:30:00
SELECT time_from_seconds(52200.123456);    -- 14:30:00.123456
SELECT time_from_millis(52200123);         -- 14:30:00.123
SELECT time_from_micros(52200123456);      -- 14:30:00.123456

-- Extractor functions (TIME → Numeric)
SELECT time_to_seconds(TIME'14:30:00.123456');  -- 52200.123456
SELECT time_to_millis(TIME'14:30:00.123');      -- 52200123
SELECT time_to_micros(TIME'14:30:00.123456');   -- 52200123456
```
### Why are the changes needed?

The TIME type lacks numeric conversion functions, making it difficult to:

- Create TIME values from numeric representations (common in data ingestion)
- Extract numeric values for calculations or external system integration

TIMESTAMP has equivalent functions (timestamp_seconds(), unix_seconds(), etc.), and TIME should achieve feature parity.

### Does this PR introduce _any_ user-facing change?

Yes,  adds six new SQL functions:

### How was this patch tested?

Unit Tests (TimeExpressionsSuite.scala):
SQL Integration Tests (time.sql)

### Was this patch authored or co-authored using generative AI tooling?

Yes.
Generated-by:  Claude 3.5 Sonnet

 AI assistance was used for:
- Code pattern analysis and design discussions
- Implementation guidance following Spark conventions
- Test case generation and organization
- Documentation and examples

### Additional context
Q: Why does time_to_seconds() return DECIMAL(14,6) instead of BIGINT?
A: To preserve fractional seconds and enable exact round-trip conversions:
```
SELECT time_to_seconds(time_from_seconds(52200.123456));
-- Returns: 52200.123456 (exact match) ✓
```
If we returned BIGINT, fractional seconds would be lost.

Q: Why does time_from_seconds() accept NumericType instead of just IntegralType?
A: To support fractional seconds for maximum flexibility:
```
SELECT time_from_seconds(52200.5);      -- DECIMAL: 14:30:00.5
SELECT time_from_seconds(52200.5::float);  -- FLOAT: 14:30:00.5
```
This mirrors timestamp_seconds() which also accepts NumericType.

Closes apache#53147 from vinodkc/br_time_numeric_conversion.

Authored-by: vinodkc <[email protected]>
Signed-off-by: Dongjoon Hyun <[email protected]>

Author: vinodkc

python/pyspark/sql/connect/functions/builtin.py

@@ -3945,6 +3945,48 @@ def make_time(hour: "ColumnOrName", minute: "ColumnOrName", second: "ColumnOrNam
 make_time.__doc__ = pysparkfuncs.make_time.__doc__
 
 
+def time_from_seconds(col: "ColumnOrName") -> Column:
+    return _invoke_function_over_columns("time_from_seconds", col)
+
+
+time_from_seconds.__doc__ = pysparkfuncs.time_from_seconds.__doc__
+
+
+def time_from_millis(col: "ColumnOrName") -> Column:
+    return _invoke_function_over_columns("time_from_millis", col)
+
+
+time_from_millis.__doc__ = pysparkfuncs.time_from_millis.__doc__
+
+
+def time_from_micros(col: "ColumnOrName") -> Column:
+    return _invoke_function_over_columns("time_from_micros", col)
+
+
+time_from_micros.__doc__ = pysparkfuncs.time_from_micros.__doc__
+
+
+def time_to_seconds(col: "ColumnOrName") -> Column:
+    return _invoke_function_over_columns("time_to_seconds", col)
+
+
+time_to_seconds.__doc__ = pysparkfuncs.time_to_seconds.__doc__
+
+
+def time_to_millis(col: "ColumnOrName") -> Column:
+    return _invoke_function_over_columns("time_to_millis", col)
+
+
+time_to_millis.__doc__ = pysparkfuncs.time_to_millis.__doc__
+
+
+def time_to_micros(col: "ColumnOrName") -> Column:
+    return _invoke_function_over_columns("time_to_micros", col)
+
+
+time_to_micros.__doc__ = pysparkfuncs.time_to_micros.__doc__
+
+
 @overload
 def make_timestamp(
     years: "ColumnOrName",

python/pyspark/sql/functions/__init__.py

@@ -249,6 +249,12 @@
     "timestamp_millis",
     "timestamp_seconds",
     "time_diff",
+    "time_from_micros",
+    "time_from_millis",
+    "time_from_seconds",
+    "time_to_micros",
+    "time_to_millis",
+    "time_to_seconds",
     "time_trunc",
     "to_date",
     "to_time",

python/pyspark/sql/functions/builtin.py

@@ -24958,6 +24958,162 @@ def make_time(hour: "ColumnOrName", minute: "ColumnOrName", second: "ColumnOrNam
     return _invoke_function_over_columns("make_time", hour, minute, second)
 
 
+@_try_remote_functions
+def time_from_seconds(col: "ColumnOrName") -> Column:
+    """
+    Creates a TIME value from seconds since midnight (supports fractional seconds).
+
+    .. versionadded:: 4.2.0
+
+    Parameters
+    ----------
+    col : :class:`~pyspark.sql.Column` or column name
+        Seconds since midnight (0 to 86399.999999).
+
+    Examples
+    --------
+    >>> from pyspark.sql import functions as sf
+    >>> df = spark.createDataFrame([(52200.5,)], ['seconds'])
+    >>> df.select(sf.time_from_seconds('seconds')).show()
+    +--------------------------+
+    |time_from_seconds(seconds)|
+    +--------------------------+
+    |                14:30:00.5|
+    +--------------------------+
+    """
+    return _invoke_function_over_columns("time_from_seconds", col)
+
+
+@_try_remote_functions
+def time_from_millis(col: "ColumnOrName") -> Column:
+    """
+    Creates a TIME value from milliseconds since midnight.
+
+    .. versionadded:: 4.2.0
+
+    Parameters
+    ----------
+    col : :class:`~pyspark.sql.Column` or column name
+        Milliseconds since midnight (0 to 86399999).
+
+    Examples
+    --------
+    >>> from pyspark.sql import functions as sf
+    >>> df = spark.createDataFrame([(52200500,)], ['millis'])
+    >>> df.select(sf.time_from_millis('millis')).show()
+    +------------------------+
+    |time_from_millis(millis)|
+    +------------------------+
+    |              14:30:00.5|
+    +------------------------+
+    """
+    return _invoke_function_over_columns("time_from_millis", col)
+
+
+@_try_remote_functions
+def time_from_micros(col: "ColumnOrName") -> Column:
+    """
+    Creates a TIME value from microseconds since midnight.
+
+    .. versionadded:: 4.2.0
+
+    Parameters
+    ----------
+    col : :class:`~pyspark.sql.Column` or column name
+        Microseconds since midnight (0 to 86399999999).
+
+    Examples
+    --------
+    >>> from pyspark.sql import functions as sf
+    >>> df = spark.createDataFrame([(52200500000,)], ['micros'])
+    >>> df.select(sf.time_from_micros('micros')).show()
+    +------------------------+
+    |time_from_micros(micros)|
+    +------------------------+
+    |              14:30:00.5|
+    +------------------------+
+    """
+    return _invoke_function_over_columns("time_from_micros", col)
+
+
+@_try_remote_functions
+def time_to_seconds(col: "ColumnOrName") -> Column:
+    """
+    Extracts seconds from TIME value (returns DECIMAL to preserve fractional seconds).
+
+    .. versionadded:: 4.2.0
+
+    Parameters
+    ----------
+    col : :class:`~pyspark.sql.Column` or column name
+        TIME value to convert.
+
+    Examples
+    --------
+    >>> from pyspark.sql import functions as sf
+    >>> df = spark.sql("SELECT TIME'14:30:00.5' as time")
+    >>> df.select(sf.time_to_seconds('time')).show()
+    +---------------------+
+    |time_to_seconds(time)|
+    +---------------------+
+    |         52200.500000|
+    +---------------------+
+    """
+    return _invoke_function_over_columns("time_to_seconds", col)
+
+
+@_try_remote_functions
+def time_to_millis(col: "ColumnOrName") -> Column:
+    """
+    Extracts milliseconds from TIME value.
+
+    .. versionadded:: 4.2.0
+
+    Parameters
+    ----------
+    col : :class:`~pyspark.sql.Column` or column name
+        TIME value to convert.
+
+    Examples
+    --------
+    >>> from pyspark.sql import functions as sf
+    >>> df = spark.sql("SELECT TIME'14:30:00.5' as time")
+    >>> df.select(sf.time_to_millis('time')).show()
+    +--------------------+
+    |time_to_millis(time)|
+    +--------------------+
+    |            52200500|
+    +--------------------+
+    """
+    return _invoke_function_over_columns("time_to_millis", col)
+
+
+@_try_remote_functions
+def time_to_micros(col: "ColumnOrName") -> Column:
+    """
+    Extracts microseconds from TIME value.
+
+    .. versionadded:: 4.2.0
+
+    Parameters
+    ----------
+    col : :class:`~pyspark.sql.Column` or column name
+        TIME value to convert.
+
+    Examples
+    --------
+    >>> from pyspark.sql import functions as sf
+    >>> df = spark.sql("SELECT TIME'14:30:00.5' as time")
+    >>> df.select(sf.time_to_micros('time')).show()
+    +--------------------+
+    |time_to_micros(time)|
+    +--------------------+
+    |         52200500000|
+    +--------------------+
+    """
+    return _invoke_function_over_columns("time_to_micros", col)
+
+
 @overload
 def make_timestamp(
     years: "ColumnOrName",

sql/api/src/main/scala/org/apache/spark/sql/functions.scala

@@ -6910,6 +6910,55 @@ object functions {
     Column.fn("time_trunc", unit, time)
   }
 
+  /**
+   * Creates a TIME from the number of seconds since midnight.
+   *
+   * @group datetime_funcs
+   * @since 4.2.0
+   */
+  def time_from_seconds(e: Column): Column = Column.fn("time_from_seconds", e)
+
+  /**
+   * Creates a TIME from the number of milliseconds since midnight.
+   *
+   * @group datetime_funcs
+   * @since 4.2.0
+   */
+  def time_from_millis(e: Column): Column = Column.fn("time_from_millis", e)
+
+  /**
+   * Creates a TIME from the number of microseconds since midnight.
+   *
+   * @group datetime_funcs
+   * @since 4.2.0
+   */
+  def time_from_micros(e: Column): Column = Column.fn("time_from_micros", e)
+
+  /**
+   * Extracts the number of seconds (including fractional seconds) from a TIME value. Returns a
+   * DECIMAL(14,6) to preserve microsecond precision.
+   *
+   * @group datetime_funcs
+   * @since 4.2.0
+   */
+  def time_to_seconds(e: Column): Column = Column.fn("time_to_seconds", e)
+
+  /**
+   * Extracts the number of milliseconds since midnight from a TIME value.
+   *
+   * @group datetime_funcs
+   * @since 4.2.0
+   */
+  def time_to_millis(e: Column): Column = Column.fn("time_to_millis", e)
+
+  /**
+   * Extracts the number of microseconds since midnight from a TIME value.
+   *
+   * @group datetime_funcs
+   * @since 4.2.0
+   */
+  def time_to_micros(e: Column): Column = Column.fn("time_to_micros", e)
+
   /**
    * Parses the `timestamp` expression with the `format` expression to a timestamp without time
    * zone. Returns null with invalid input.

sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/analysis/FunctionRegistry.scala

@@ -701,6 +701,12 @@ object FunctionRegistry {
     expression[MakeDate]("make_date"),
     expression[MakeTime]("make_time"),
     expression[TimeTrunc]("time_trunc"),
+    expression[TimeFromSeconds]("time_from_seconds"),
+    expression[TimeFromMillis]("time_from_millis"),
+    expression[TimeFromMicros]("time_from_micros"),
+    expression[TimeToSeconds]("time_to_seconds"),
+    expression[TimeToMillis]("time_to_millis"),
+    expression[TimeToMicros]("time_to_micros"),
     expressionBuilder("make_timestamp", MakeTimestampExpressionBuilder),
     expressionBuilder("try_make_timestamp", TryMakeTimestampExpressionBuilder),
     expression[MonthName]("monthname"),