feat: feat: add to_time, to_local_time, to_date functions

python/datafusion/functions.py

@@ -42,7 +42,6 @@
 
 if TYPE_CHECKING:
     from datafusion.context import SessionContext
-
 __all__ = [
     "abs",
     "acos",
@@ -268,13 +267,18 @@
     "sum",
     "tan",
     "tanh",
+    "to_char",
+    "to_date",
     "to_hex",
+    "to_local_time",
+    "to_time",
     "to_timestamp",
     "to_timestamp_micros",
     "to_timestamp_millis",
     "to_timestamp_nanos",
     "to_timestamp_seconds",
     "to_unixtime",
+    "today",
     "translate",
     "trim",
     "trunc",
@@ -1010,67 +1014,111 @@ def now() -> Expr:
     return Expr(f.now())
 
 
+def to_char(arg: Expr, formatter: Expr) -> Expr:
+    """Returns a string representation of a date, time, timestamp or duration.
+
+    For usage of ``formatter`` see the rust chrono package ``strftime`` package.
+
+    [Documentation here.](https://docs.rs/chrono/latest/chrono/format/strftime/index.html)
+    """
+    return Expr(f.to_char(arg.expr, formatter.expr))
+
+
+def _unwrap_exprs(args: tuple[Expr, ...]) -> list:
+    return [arg.expr for arg in args]
+
+
+def to_date(arg: Expr, *formatters: Expr) -> Expr:
+    """Converts a value to a date (YYYY-MM-DD).
+
+    Supports strings, numeric and timestamp types as input.
+    Integers and doubles are interpreted as days since the unix epoch.
+    Strings are parsed as YYYY-MM-DD (e.g. '2023-07-20')
+    if ``formatters`` are not provided.
+
+    For usage of ``formatters`` see the rust chrono package ``strftime`` package.
+
+    [Documentation here.](https://docs.rs/chrono/latest/chrono/format/strftime/index.html)
+    """
+    return Expr(f.to_date(arg.expr, *_unwrap_exprs(formatters)))
+
+
+def to_local_time(*args: Expr) -> Expr:
+    """Converts a timestamp with a timezone to a timestamp without a timezone.
+
+    This function handles daylight saving time changes.
+    """
+    return Expr(f.to_local_time(*_unwrap_exprs(args)))
+
+
+def to_time(arg: Expr, *formatters: Expr) -> Expr:
+    """Converts a value to a time. Supports strings and timestamps as input.
+
+    If ``formatters`` is not provided strings are parsed as HH:MM:SS, HH:MM or
+    HH:MM:SS.nnnnnnnnn;
+
+    For usage of ``formatters`` see the rust chrono package ``strftime`` package.
+
+    [Documentation here.](https://docs.rs/chrono/latest/chrono/format/strftime/index.html)
+    """
+    return Expr(f.to_time(arg.expr, *_unwrap_exprs(formatters)))
+
+
 def to_timestamp(arg: Expr, *formatters: Expr) -> Expr:
     """Converts a string and optional formats to a ``Timestamp`` in nanoseconds.
 
     For usage of ``formatters`` see the rust chrono package ``strftime`` package.
 
     [Documentation here.](https://docs.rs/chrono/latest/chrono/format/strftime/index.html)
     """
-    if formatters is None:
-        return f.to_timestamp(arg.expr)
-
-    formatters = [f.expr for f in formatters]
-    return Expr(f.to_timestamp(arg.expr, *formatters))
+    return Expr(f.to_timestamp(arg.expr, *_unwrap_exprs(formatters)))
 
 
 def to_timestamp_millis(arg: Expr, *formatters: Expr) -> Expr:
     """Converts a string and optional formats to a ``Timestamp`` in milliseconds.
 
     See :py:func:`to_timestamp` for a description on how to use formatters.
     """
-    formatters = [f.expr for f in formatters]
-    return Expr(f.to_timestamp_millis(arg.expr, *formatters))
+    return Expr(f.to_timestamp_millis(arg.expr, *_unwrap_exprs(formatters)))
 
 
 def to_timestamp_micros(arg: Expr, *formatters: Expr) -> Expr:
     """Converts a string and optional formats to a ``Timestamp`` in microseconds.
 
     See :py:func:`to_timestamp` for a description on how to use formatters.
     """
-    formatters = [f.expr for f in formatters]
-    return Expr(f.to_timestamp_micros(arg.expr, *formatters))
+    return Expr(f.to_timestamp_micros(arg.expr, *_unwrap_exprs(formatters)))
 
 
 def to_timestamp_nanos(arg: Expr, *formatters: Expr) -> Expr:
     """Converts a string and optional formats to a ``Timestamp`` in nanoseconds.
 
     See :py:func:`to_timestamp` for a description on how to use formatters.
     """
-    formatters = [f.expr for f in formatters]
-    return Expr(f.to_timestamp_nanos(arg.expr, *formatters))
+    return Expr(f.to_timestamp_nanos(arg.expr, *_unwrap_exprs(formatters)))
 
 
 def to_timestamp_seconds(arg: Expr, *formatters: Expr) -> Expr:
     """Converts a string and optional formats to a ``Timestamp`` in seconds.
 
     See :py:func:`to_timestamp` for a description on how to use formatters.
     """
-    formatters = [f.expr for f in formatters]
-    return Expr(f.to_timestamp_seconds(arg.expr, *formatters))
+    return Expr(f.to_timestamp_seconds(arg.expr, *_unwrap_exprs(formatters)))
 
 
 def to_unixtime(string: Expr, *format_arguments: Expr) -> Expr:
     """Converts a string and optional formats to a Unixtime."""
-    args = [f.expr for f in format_arguments]
-    return Expr(f.to_unixtime(string.expr, *args))
+    return Expr(f.to_unixtime(string.expr, *_unwrap_exprs(format_arguments)))
 
 
 def current_date() -> Expr:
     """Returns current UTC date as a Date32 value."""
     return Expr(f.current_date())
 
 
+today = current_date
+
+
 def current_time() -> Expr:
     """Returns current UTC time as a Time64 value."""
     return Expr(f.current_time())

python/tests/test_functions.py

@@ -15,7 +15,7 @@
 # specific language governing permissions and limitations
 # under the License.
 import math
-from datetime import datetime, timezone
+from datetime import date, datetime, time, timezone
 
 import numpy as np
 import pyarrow as pa
@@ -952,6 +952,12 @@ def test_temporal_functions(df):
         f.to_timestamp_nanos(
             literal("2023-09-07 05:06:14.523952000"), literal("%Y-%m-%d %H:%M:%S.%f")
         ),
+        f.to_time(literal("12:30:45")),
+        f.to_time(literal("12-30-45"), literal("%H-%M-%S")),
+        f.to_date(literal("2017-05-31")),
+        f.to_date(literal("2017-05-31"), literal("%Y-%m-%d")),
+        f.to_local_time(column("d")),
+        f.to_char(column("d"), literal("%d-%m-%Y")),
     )
     result = df.collect()
     assert len(result) == 1
@@ -1026,6 +1032,73 @@ def test_temporal_functions(df):
         [datetime(2023, 9, 7, 5, 6, 14, 523952, tzinfo=DEFAULT_TZ)] * 3,
         type=pa.timestamp("ns"),
     )
+    assert result.column(17) == pa.array(
+        [time(12, 30, 45)] * 3,
+        type=pa.time64("ns"),
+    )
+    assert result.column(18) == pa.array(
+        [time(12, 30, 45)] * 3,
+        type=pa.time64("ns"),
+    )
+    assert result.column(19) == pa.array(
+        [date(2017, 5, 31)] * 3,
+        type=pa.date32(),
+    )
+    assert result.column(20) == pa.array(
+        [date(2017, 5, 31)] * 3,
+        type=pa.date32(),
+    )
+    assert result.column(21) == pa.array(
+        [
+            datetime(2022, 12, 31, tzinfo=DEFAULT_TZ),
+            datetime(2027, 6, 26, tzinfo=DEFAULT_TZ),
+            datetime(2020, 7, 2, tzinfo=DEFAULT_TZ),
+        ],
+        type=pa.timestamp("us"),
+    )
+
+    assert result.column(22) == pa.array(
+        [
+            "31-12-2022",
+            "26-06-2027",
+            "02-07-2020",
+        ],
+        type=pa.string(),
+    )
+
+
+def test_to_time_invalid_input(df):
+    with pytest.raises(Exception, match=r"Error parsing 'not-a-time' as time"):
+        df.select(f.to_time(literal("not-a-time"))).collect()
+
+
+def test_to_time_mismatched_formatter(df):
+    with pytest.raises(Exception, match=r"Error parsing '12:30:45' as time"):
+        df.select(f.to_time(literal("12:30:45"), literal("%Y-%m-%d"))).collect()
+
+
+def test_to_date_invalid_input(df):
+    with pytest.raises(Exception, match=r"Date32"):
+        df.select(f.to_date(literal("not-a-date"))).collect()
+
+
+def test_temporal_formatter_requires_expr():
+    with pytest.raises(AttributeError, match="'str' object has no attribute 'expr'"):
+        f.to_time(literal("12:30:45"), "not-an-expr")
+
+
+def test_today_returns_date32(df):
+    result = df.select(f.today().alias("today")).collect()[0]
+    assert result.column(0).type == pa.date32()
+
+
+def test_today_alias_matches_current_date(df):
+    result = df.select(
+        f.current_date().alias("current_date"),
+        f.today().alias("today"),
+    ).collect()[0]
+
+    assert result.column(0) == result.column(1)
 
 
 def test_arrow_cast(df):

src/functions.rs

@@ -601,6 +601,9 @@ expr_fn!(
     "Converts the number to its equivalent hexadecimal representation."
 );
 expr_fn!(now);
+expr_fn_vec!(to_date);
+expr_fn_vec!(to_local_time);
+expr_fn_vec!(to_time);
 expr_fn_vec!(to_timestamp);
 expr_fn_vec!(to_timestamp_millis);
 expr_fn_vec!(to_timestamp_nanos);
@@ -613,6 +616,7 @@ expr_fn!(date_part, part date);
 expr_fn!(date_trunc, part date);
 expr_fn!(date_bin, stride source origin);
 expr_fn!(make_date, year month day);
+expr_fn!(to_char, datetime format);
 
 expr_fn!(translate, string from to, "Replaces each character in string that matches a character in the from set with the corresponding character in the to set. If from is longer than to, occurrences of the extra characters in from are deleted.");
 expr_fn_vec!(
@@ -1045,6 +1049,10 @@ pub(crate) fn init_module(m: &Bound<'_, PyModule>) -> PyResult<()> {
     m.add_wrapped(wrap_pyfunction!(tan))?;
     m.add_wrapped(wrap_pyfunction!(tanh))?;
     m.add_wrapped(wrap_pyfunction!(to_hex))?;
+    m.add_wrapped(wrap_pyfunction!(to_char))?;
+    m.add_wrapped(wrap_pyfunction!(to_date))?;
+    m.add_wrapped(wrap_pyfunction!(to_local_time))?;
+    m.add_wrapped(wrap_pyfunction!(to_time))?;
     m.add_wrapped(wrap_pyfunction!(to_timestamp))?;
     m.add_wrapped(wrap_pyfunction!(to_timestamp_millis))?;
     m.add_wrapped(wrap_pyfunction!(to_timestamp_nanos))?;