SNOW-2296280: Add interval_day_time_from_parts function

CHANGELOG.md

@@ -9,6 +9,7 @@
 - Added a new datatype `YearMonthIntervalType` that allows users to create intervals for datetime operations.
 - Added a new function `interval_year_month_from_parts` that allows users to easily create `YearMonthIntervalType` without using SQL.
 - Added a new datatype `DayTimeIntervalType` that allows users to create intervals for datetime operations.
+- Added a new function `interval_day_time_from_parts` that allows users to easily create `DayTimeIntervalType` without using SQL.
 - Added support for `FileOperation.list` to list files in a stage with metadata.
 - Added support for `FileOperation.remove` to remove files in a stage.
 - Added a new function `snowflake.snowpark.functions.vectorized` that allows users to mark a function as vectorized UDF.

docs/source/snowpark/functions.rst

@@ -235,6 +235,7 @@ Functions
     initcap
     insert
     instr
+    interval_day_time_from_parts
     interval_year_month_from_parts
     invoker_role
     invoker_share

src/snowflake/snowpark/functions.py

@@ -11000,11 +11000,10 @@ def interval_year_month_from_parts(
     """
     ast = None
     if _emit_ast:
+        # Always include both parameters to match the actual function execution
         args = []
-        if years is not None:
-            args.append(years)
-        if months is not None:
-            args.append(months)
+        args.append(years if years is not None else lit(0))
+        args.append(months if months is not None else lit(0))
         ast = build_function_expr("interval_year_month_from_parts", args)
 
     years_col = (
@@ -11042,6 +11041,153 @@ def get_col_name(col):
     return res
 
 
+@private_preview(
+    version="1.38.0",
+    extra_doc_string="Type DayTimeIntervalType is currently in private preview and needs to be enabled by setting parameter `FEATURE_INTERVAL_TYPES` to `ENABLED`.",
+)
+@publicapi
+def interval_day_time_from_parts(
+    days: Optional[ColumnOrName] = None,
+    hours: Optional[ColumnOrName] = None,
+    mins: Optional[ColumnOrName] = None,
+    secs: Optional[ColumnOrName] = None,
+    _emit_ast: bool = True,
+) -> Column:
+    """
+    Creates a day-time interval expression using with specified days, hours, mins and seconds.
+
+    This DayTime is not to be confused with the interval created by make_interval.
+    You can define a table column to be of data type DayTimeIntervalType.
+
+    Args:
+        days: The number of days, positive or negative
+        hours: The number of hours, positive or negative
+        mins: The number of minutes, positive or negative
+        secs: The number of seconds, positive or negative
+
+    Returns:
+        A Column representing a day-time interval
+
+    Example::
+
+        >>> from snowflake.snowpark.functions import interval_day_time_from_parts
+        >>>
+        >>> _ = session.sql("ALTER SESSION SET FEATURE_INTERVAL_TYPES=ENABLED;").collect()
+        >>> df = session.create_dataframe([[1, 12, 30, 01.001001]], ['day', 'hour', 'min', 'sec'])
+        >>> df.select(interval_day_time_from_parts(col("day"), col("hour"), col("min"), col("sec")).alias("interval")).show()
+        --------------------------
+        |"INTERVAL"              |
+        --------------------------
+        |1 day, 12:30:01.001000  |
+        --------------------------
+        <BLANKLINE>
+
+    """
+    # Handle AST emission
+    ast = None
+    if _emit_ast:
+        # Create AST for this custom function using build_function_expr
+        # Always include all 4 parameters to match the actual function execution
+        args = []
+        args.append(days if days is not None else lit(0))
+        args.append(hours if hours is not None else lit(0))
+        args.append(mins if mins is not None else lit(0))
+        args.append(secs if secs is not None else lit(0))
+        ast = build_function_expr("interval_day_time_from_parts", args)
+
+    days_col = (
+        lit(0) if days is None else _to_col_if_str(days, "interval_day_time_from_parts")
+    )
+    hours_col = (
+        lit(0)
+        if hours is None
+        else _to_col_if_str(hours, "interval_day_time_from_parts")
+    )
+    mins_col = (
+        lit(0) if mins is None else _to_col_if_str(mins, "interval_day_time_from_parts")
+    )
+    secs_col = (
+        lit(0) if secs is None else _to_col_if_str(secs, "interval_day_time_from_parts")
+    )
+
+    total_seconds = (
+        days_col * lit(86400) + hours_col * lit(3600) + mins_col * lit(60) + secs_col
+    )
+
+    is_negative = total_seconds < lit(0)
+    abs_total_seconds = abs(total_seconds)
+
+    days_part = cast(floor(abs_total_seconds / lit(86400)), "int")
+    remaining_after_days = abs_total_seconds % lit(86400)
+
+    hours_part = cast(floor(remaining_after_days / lit(3600)), "int")
+    remaining_after_hours = remaining_after_days % lit(3600)
+
+    mins_part = cast(floor(remaining_after_hours / lit(60)), "int")
+    secs_part = remaining_after_hours % lit(60)
+
+    hours_str = iff(
+        hours_part < lit(10),
+        concat(lit("0"), cast(hours_part, "str")),
+        cast(hours_part, "str"),
+    )
+
+    mins_str = iff(
+        mins_part < lit(10),
+        concat(lit("0"), cast(mins_part, "str")),
+        cast(mins_part, "str"),
+    )
+
+    secs_int = cast(floor(secs_part), "int")
+    secs_str = iff(
+        secs_int < lit(10),
+        concat(lit("0"), cast(secs_int, "str")),
+        cast(secs_int, "str"),
+    )
+
+    has_fraction = abs(secs_part - cast(secs_int, "double")) > 1e-10
+    fractional_part = secs_part - cast(secs_int, "double")
+
+    fraction_str = iff(
+        has_fraction,
+        concat(
+            lit("."),
+            lpad(
+                cast(round(fractional_part * lit(1000), 0), "str"),
+                3,
+                lit("0"),
+            ),
+        ),
+        lit(""),
+    )
+
+    secs_formatted = concat(secs_str, fraction_str)
+
+    sign_prefix = iff(is_negative, lit("-"), lit(""))
+    interval_value = concat(
+        sign_prefix,
+        cast(days_part, "str"),
+        lit(" "),
+        hours_str,
+        lit(":"),
+        mins_str,
+        lit(":"),
+        secs_formatted,
+    )
+
+    def get_col_name(col):
+        if isinstance(col._expr1, Literal):
+            return str(col._expr1.value)
+        else:
+            return str(col._expr1)
+
+    alias_name = f"interval_day_time_from_parts({get_col_name(days_col)}, {get_col_name(hours_col)}, {get_col_name(mins_col)}, {get_col_name(secs_col)})"
+
+    res = cast(interval_value, "INTERVAL DAY TO SECOND").alias(alias_name)
+    res._ast = ast
+    return res
+
+
 @publicapi
 @deprecated(
     version="1.28.0",

tests/ast/data/functions2.test

@@ -450,6 +450,8 @@ df351 = df.select(function("avg")("B"))
 
 df352 = df.select(interval_year_month_from_parts("A", "B"))
 
+df353 = df.select(interval_day_time_from_parts("A", "B", "C", "D"))
+
 ## EXPECTED UNPARSER OUTPUT
 
 df = session.table("table1")
@@ -900,6 +902,8 @@ df351 = df.select(call_function("avg", "B"))
 
 df352 = df.select(interval_year_month_from_parts("A", "B"))
 
+df353 = df.select(interval_day_time_from_parts("A", "B", "C", "D"))
+
 ## EXPECTED ENCODED AST
 
 interned_value_table {
@@ -29253,6 +29257,104 @@ body {
     uid: 224
   }
 }
+body {
+  bind {
+    expr {
+      dataframe_select {
+        cols {
+          args {
+            apply_expr {
+              fn {
+                builtin_fn {
+                  name {
+                    name {
+                      name_flat {
+                        name: "interval_day_time_from_parts"
+                      }
+                    }
+                  }
+                }
+              }
+              pos_args {
+                string_val {
+                  src {
+                    end_column: 74
+                    end_line: 475
+                    file: 2
+                    start_column: 26
+                    start_line: 475
+                  }
+                  v: "A"
+                }
+              }
+              pos_args {
+                string_val {
+                  src {
+                    end_column: 74
+                    end_line: 475
+                    file: 2
+                    start_column: 26
+                    start_line: 475
+                  }
+                  v: "B"
+                }
+              }
+              pos_args {
+                string_val {
+                  src {
+                    end_column: 74
+                    end_line: 475
+                    file: 2
+                    start_column: 26
+                    start_line: 475
+                  }
+                  v: "C"
+                }
+              }
+              pos_args {
+                string_val {
+                  src {
+                    end_column: 74
+                    end_line: 475
+                    file: 2
+                    start_column: 26
+                    start_line: 475
+                  }
+                  v: "D"
+                }
+              }
+              src {
+                end_column: 74
+                end_line: 475
+                file: 2
+                start_column: 26
+                start_line: 475
+              }
+            }
+          }
+          variadic: true
+        }
+        df {
+          dataframe_ref {
+            id: 1
+          }
+        }
+        src {
+          end_column: 75
+          end_line: 475
+          file: 2
+          start_column: 16
+          start_line: 475
+        }
+      }
+    }
+    first_request_id: "\003U\"\366q\366P\346\260\261?\234\303\254\316\353"
+    symbol {
+      value: "df353"
+    }
+    uid: 225
+  }
+}
 client_ast_version: 1
 client_language {
   python_language {

tests/integ/conftest.py

@@ -274,7 +274,7 @@ def session(
         .config("local_testing", local_testing_mode)
         .config(
             "session_parameters",
-            {"feature_interval_types": "ENABLED", "enable_interval_subtypes": "true"},
+            {"feature_interval_types": "ENABLED"},
         )
         .create()
     )