fix: return pd.Timestamp or pd.Series[datetime64] for date.to_pandas()

ibis/backends/dask/convert.py

@@ -74,7 +74,7 @@ def convert_Date(cls, s, dtype, pandas_type):
         else:
             s = dd.to_datetime(s)
 
-        return s.dt.normalize()
+        return s
 
     @classmethod
     def convert_String(cls, s, dtype, pandas_type):

ibis/backends/dask/tests/test_cast.py

@@ -146,13 +146,16 @@ def test_timestamp_with_timezone_is_inferred_correctly(t):
 def test_cast_date(t, df, column):
     expr = t[column].cast("date")
     result = expr.execute()
+
     expected = (
         df[column]
-        .dt.normalize()
-        .map(lambda x: x.date())
         .compute()
         .rename(expr.get_name())
     )
+    if expected.dt.tz:
+        expected = expected.dt.tz_convert("UTC")
+    expected = expected.dt.tz_localize(None).astype(result.dtype)
+
     tm.assert_series_equal(result, expected, check_index=False)
 
 

ibis/backends/dask/tests/test_temporal.py

@@ -66,8 +66,12 @@ def test_timestamp_functions(con, case_func, expected_func):
 def test_cast_datetime_strings_to_date(t, df, column):
     expr = t[column].cast("date")
     result = expr.execute()
+
     df_computed = df.compute()
-    expected = pd.to_datetime(df_computed[column]).map(lambda x: x.date())
+    expected = pd.to_datetime(df_computed[column])
+    if expected.dt.tz:
+        expected = expected.dt.tz_convert("UTC")
+    expected = expected.dt.tz_localize(None).astype(result.dtype)
 
     tm.assert_series_equal(
         result.reset_index(drop=True).rename("tmp"),
@@ -114,10 +118,10 @@ def test_cast_integer_to_date(t, pandas_df):
     expr = t.plain_int64.cast("date")
     result = expr.execute()
     expected = pd.Series(
-        pd.to_datetime(pandas_df.plain_int64.values, unit="D").date,
+        pd.to_datetime(pandas_df.plain_int64.values, unit="D"),
         index=pandas_df.index,
         name="plain_int64",
-    )
+    ).astype(result.dtype)
     tm.assert_series_equal(result, expected, check_names=False)
 
 

ibis/backends/duckdb/tests/test_datatypes.py

@@ -114,3 +114,13 @@ def test_cast_to_floating_point_type(con, snapshot, typ):
 
     sql = str(ibis.to_sql(expr, dialect="duckdb"))
     snapshot.assert_match(sql, "out.sql")
+
+
+def test_date_to_pandas_type():
+    table = ibis.memtable({"date": ["2024-01-01", "2024-01-02"]}).cast({"date": "date"}).date
+
+    df = table.to_pandas()
+    print(f"df= \n{df.to_string()}")
+    print(type(df[0]))
+
+    import pdb; pdb.set_trace()

ibis/backends/oracle/converter.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import datetime
+import pandas as pd
 
 from ibis.formats.pandas import PandasData
 
@@ -12,7 +13,11 @@ def convert_Timestamp_element(cls, dtype):
 
     @classmethod
     def convert_Date_element(cls, dtype):
-        return datetime.date.fromisoformat
+        # TODO (mehmet): Not sure if we should modify this... Could
+        # not run the tests on this backend. If we do, should we also
+        # modify `convert_Timestamp_element()` and
+        # `convert_Time_element()` similarly?
+        return pd.Timestamp.fromisoformat
 
     @classmethod
     def convert_Time_element(cls, dtype):

ibis/backends/pandas/tests/test_cast.py

@@ -163,7 +163,7 @@ def test_timestamp_with_timezone_is_inferred_correctly(t, df):
 def test_cast_date(t, df, column):
     expr = t[column].cast("date")
     result = expr.execute()
-    expected = df[column].dt.normalize().dt.tz_localize(None).dt.date
+    expected = df[column].dt.normalize().dt.tz_localize(None).astype(result.dtype)
     tm.assert_series_equal(result, expected)
 
 

ibis/backends/pandas/tests/test_temporal.py

@@ -67,7 +67,10 @@ def test_timestamp_functions(case_func, expected_func):
 def test_cast_datetime_strings_to_date(t, df, column):
     expr = t[column].cast("date")
     result = expr.execute()
-    expected = pd.to_datetime(df[column]).dt.normalize().dt.tz_localize(None).dt.date
+    expected = pd.to_datetime(df[column]).dt.normalize()
+    if expected.dt.tz:
+        expected = expected.dt.tz_convert("UTC")
+    expected = expected.dt.tz_localize(None).astype(result.dtype)
     tm.assert_series_equal(result, expected)
 
 

ibis/backends/snowflake/converter.py

@@ -4,6 +4,7 @@
 import json
 from typing import TYPE_CHECKING
 
+import pandas as pd
 import pyarrow as pa
 
 from ibis.formats.pandas import PandasData
@@ -56,7 +57,11 @@ def convert_Timestamp_element(cls, dtype):
 
     @classmethod
     def convert_Date_element(cls, dtype):
-        return datetime.date.fromisoformat
+        # TODO (mehmet): Not sure if we should modify this... Could
+        # not run the tests on this backend. If we do, should we also
+        # modify `convert_Timestamp_element()` and
+        # `convert_Time_element()` similarly?
+        return pd.Timestamp.fromisoformat
 
     @classmethod
     def convert_Time_element(cls, dtype):

ibis/backends/sqlite/tests/test_types.py

@@ -89,6 +89,9 @@ def test_type_map(db):
     sol = pd.DataFrame(
         {"str_col": ["a"], "date_col": pd.Series([date(2022, 1, 1)], dtype="object")}
     )
+    sol["date_col"] = sol["date_col"].astype(res["date_col"].dtype)
+
+    import pdb; pdb.set_trace()
     assert res.equals(sol)
 
 

ibis/backends/tests/test_aggregation.py

@@ -1257,7 +1257,7 @@ def test_string_quantile(alltypes, func):
 )
 def test_date_quantile(alltypes, func):
     expr = func(alltypes.timestamp_col.date())
-    result = expr.execute()
+    result = expr.execute().to_pydatetime().date()
     assert result == date(2009, 12, 31)
 
 

ibis/backends/tests/test_temporal.py

@@ -688,7 +688,7 @@ def convert_to_offset(x):
         expected = (
             pd.to_datetime(df.date_string_col)
             .add(offset)
-            .map(lambda ts: ts.normalize().date(), na_action="ignore")
+            .astype("datetime64[s]")
         )
 
     expected = backend.default_series_rename(expected)
@@ -2484,10 +2484,8 @@ def test_time_literal_sql(dialect, snapshot, micros):
 )
 def test_date_scalar(con, value, func):
     expr = ibis.date(func(value)).name("tmp")
-
     result = con.execute(expr)
 
-    assert not isinstance(result, datetime.datetime)
-    assert isinstance(result, datetime.date)
-
-    assert result == datetime.date.fromisoformat(value)
+    # TODO (mehmet): Is it appropriate to compute `ibis.date` as `pd.Timestamp`?
+    assert isinstance(result, pd.Timestamp)
+    assert result == pd.Timestamp.fromisoformat(value)

ibis/formats/pandas.py

@@ -228,17 +228,22 @@ def convert_Timestamp(cls, s, dtype, pandas_type):
     def convert_Date(cls, s, dtype, pandas_type):
         if isinstance(s.dtype, pd.DatetimeTZDtype):
             s = s.dt.tz_convert("UTC").dt.tz_localize(None)
+
         try:
-            return s.astype(pandas_type).dt.date
-        except (TypeError, pd._libs.tslibs.OutOfBoundsDatetime):
+            return s.astype(pandas_type)
 
+        except (TypeError, pd._libs.tslibs.OutOfBoundsDatetime):
             def try_date(v):
                 if isinstance(v, datetime.datetime):
-                    return v.date()
+                    return pd.Timestamp(v.date())
+                elif isinstance(v, datetime.date):
+                    return pd.Timestamp(v)
                 elif isinstance(v, str):
                     if v.endswith("Z"):
-                        return datetime.datetime.fromisoformat(v[:-1]).date()
-                    return datetime.date.fromisoformat(v)
+                        datetime_obj = datetime.datetime.fromisoformat(v[:-1])
+                    else:
+                        datetime_obj = datetime.datetime.fromisoformat(v)
+                    return pd.Timestamp(datetime_obj)
                 else:
                     return v