Add timedelta[s|ms|us|ns] numpy types

Author: evertlammerts

src/duckdb_py/include/duckdb_python/numpy/numpy_type.hpp

@@ -18,25 +18,28 @@ namespace duckdb {
 // Pandas Specific Types (e.g., categorical, datetime_tz,...)
 enum class NumpyNullableType : uint8_t {
 	//! NumPy dtypes
-	BOOL,        //! bool_, bool8
-	INT_8,       //! byte, int8
-	UINT_8,      //! ubyte, uint8
-	INT_16,      //! int16, short
-	UINT_16,     //! uint16, ushort
-	INT_32,      //! int32, intc
-	UINT_32,     //! uint32, uintc,
-	INT_64,      //! int64, int0, int_, intp, matrix
-	UINT_64,     //! uint64, uint, uint0, uintp
-	FLOAT_16,    //! float16, half
-	FLOAT_32,    //! float32, single
-	FLOAT_64,    //! float64, float_, double
-	OBJECT,      //! object
-	UNICODE,     //! <U1, unicode_, str_, str0
-	DATETIME_S,  //! datetime64[s], <M8[s]
-	DATETIME_MS, //! datetime64[ms], <M8[ms]
-	DATETIME_NS, //! datetime64[ns], <M8[ns]
-	DATETIME_US, //! datetime64[us], <M8[us]
-	TIMEDELTA,   //! timedelta64[D], timedelta64
+	BOOL,         //! bool_, bool8
+	INT_8,        //! byte, int8
+	UINT_8,       //! ubyte, uint8
+	INT_16,       //! int16, short
+	UINT_16,      //! uint16, ushort
+	INT_32,       //! int32, intc
+	UINT_32,      //! uint32, uintc,
+	INT_64,       //! int64, int0, int_, intp, matrix
+	UINT_64,      //! uint64, uint, uint0, uintp
+	FLOAT_16,     //! float16, half
+	FLOAT_32,     //! float32, single
+	FLOAT_64,     //! float64, float_, double
+	OBJECT,       //! object
+	UNICODE,      //! <U1, unicode_, str_, str0
+	DATETIME_S,   //! datetime64[s], <M8[s]
+	DATETIME_MS,  //! datetime64[ms], <M8[ms]
+	DATETIME_NS,  //! datetime64[ns], <M8[ns]
+	DATETIME_US,  //! datetime64[us], <M8[us]
+	TIMEDELTA_NS, //! timedelta64[ns]
+	TIMEDELTA_US, //! timedelta64[us]
+	TIMEDELTA_MS, //! timedelta64[ms]
+	TIMEDELTA_S,  //! timedelta64[s]
 
 	//! ------------------------------------------------------------
 	//! Extension Types

src/duckdb_py/numpy/array_wrapper.cpp

@@ -112,7 +112,7 @@ struct IntervalConvert {
 	template <class DUCKDB_T, class NUMPY_T>
 	static int64_t ConvertValue(interval_t val, NumpyAppendData &append_data) {
 		(void)append_data;
-		return Interval::GetNanoseconds(val);
+		return Interval::GetMicro(val);
 	}
 
 	template <class NUMPY_T, bool PANDAS>

src/duckdb_py/numpy/numpy_scan.cpp

@@ -302,7 +302,10 @@ void NumpyScan::Scan(PandasColumnBindData &bind_data, idx_t count, idx_t offset,
 		}
 		break;
 	}
-	case NumpyNullableType::TIMEDELTA: {
+	case NumpyNullableType::TIMEDELTA_NS:
+	case NumpyNullableType::TIMEDELTA_US:
+	case NumpyNullableType::TIMEDELTA_MS:
+	case NumpyNullableType::TIMEDELTA_S: {
 		auto src_ptr = reinterpret_cast<const int64_t *>(array.data());
 		auto tgt_ptr = FlatVector::GetData<interval_t>(out);
 		auto &mask = FlatVector::Validity(out);
@@ -314,7 +317,25 @@ void NumpyScan::Scan(PandasColumnBindData &bind_data, idx_t count, idx_t offset,
 				mask.SetInvalid(row);
 				continue;
 			}
-			int64_t micro = src_ptr[source_idx] / 1000;
+
+			int64_t micro;
+			switch (bind_data.numpy_type.type) {
+			case NumpyNullableType::TIMEDELTA_NS:
+				micro = src_ptr[source_idx] / 1000; // ns -> us
+				break;
+			case NumpyNullableType::TIMEDELTA_US:
+				micro = src_ptr[source_idx]; // already us
+				break;
+			case NumpyNullableType::TIMEDELTA_MS:
+				micro = src_ptr[source_idx] * 1000; // ms -> us
+				break;
+			case NumpyNullableType::TIMEDELTA_S:
+				micro = src_ptr[source_idx] * 1000000; // s -> us
+				break;
+			default:
+				throw InternalException("Unexpected timedelta type");
+			}
+
 			int64_t days = micro / Interval::MICROS_PER_DAY;
 			micro = micro % Interval::MICROS_PER_DAY;
 			int64_t months = days / Interval::DAYS_PER_MONTH;

src/duckdb_py/numpy/raw_array_wrapper.cpp

@@ -108,7 +108,7 @@ string RawArrayWrapper::DuckDBToNumpyDtype(const LogicalType &type) {
 	case LogicalTypeId::DATE:
 		return "datetime64[us]";
 	case LogicalTypeId::INTERVAL:
-		return "timedelta64[ns]";
+		return "timedelta64[us]";
 	case LogicalTypeId::TIME:
 	case LogicalTypeId::TIME_TZ:
 	case LogicalTypeId::VARCHAR:

src/duckdb_py/numpy/type.cpp

@@ -65,7 +65,16 @@ static NumpyNullableType ConvertNumpyTypeInternal(const string &col_type_str) {
 		return NumpyNullableType::OBJECT;
 	}
 	if (col_type_str == "timedelta64[ns]") {
-		return NumpyNullableType::TIMEDELTA;
+		return NumpyNullableType::TIMEDELTA_NS;
+	}
+	if (col_type_str == "timedelta64[us]") {
+		return NumpyNullableType::TIMEDELTA_US;
+	}
+	if (col_type_str == "timedelta64[ms]") {
+		return NumpyNullableType::TIMEDELTA_MS;
+	}
+	if (col_type_str == "timedelta64[s]") {
+		return NumpyNullableType::TIMEDELTA_S;
 	}
 	// We use 'StartsWith' because it might have ', tz' at the end, indicating timezone
 	if (StringUtil::StartsWith(col_type_str, "datetime64[ns")) {
@@ -143,7 +152,10 @@ LogicalType NumpyToLogicalType(const NumpyType &col_type) {
 		return LogicalType::VARCHAR;
 	case NumpyNullableType::OBJECT:
 		return LogicalType::VARCHAR;
-	case NumpyNullableType::TIMEDELTA:
+	case NumpyNullableType::TIMEDELTA_NS:
+	case NumpyNullableType::TIMEDELTA_US:
+	case NumpyNullableType::TIMEDELTA_MS:
+	case NumpyNullableType::TIMEDELTA_S:
 		return LogicalType::INTERVAL;
 	case NumpyNullableType::DATETIME_MS: {
 		if (col_type.has_timezone) {

tests/fast/pandas/test_df_object_resolution.py

@@ -9,9 +9,9 @@
 import numpy as np
 import pandas as pd
 import pytest
+from conftest import is_string_dtype
 
 import duckdb
-from tests.conftest import is_string_dtype
 
 standard_vector_size = duckdb.__standard_vector_size__
 

tests/fast/pandas/test_stride.py

@@ -57,7 +57,9 @@ def test_stride_timedelta(self, duckdb_cursor):
                 ]
             }
         )
-        pd.testing.assert_frame_equal(roundtrip, expected)
+        # DuckDB INTERVAL type stores in microseconds, so output is always timedelta64[us]
+        # Check values match without strict dtype comparison
+        pd.testing.assert_frame_equal(roundtrip, expected, check_dtype=False)
 
     def test_stride_fp64(self, duckdb_cursor):
         expected_df = pd.DataFrame(np.arange(20, dtype="float64").reshape(5, 4), columns=["a", "b", "c", "d"])

tests/fast/pandas/test_timestamp.py

@@ -65,7 +65,9 @@ def test_timestamp_timedelta(self):
             }
         )
         df_from_duck = duckdb.from_df(df).df()
-        assert df_from_duck.equals(df)
+        # DuckDB INTERVAL type stores in microseconds, so output is always timedelta64[us]
+        # Check values match without strict dtype comparison
+        pd.testing.assert_frame_equal(df_from_duck, df, check_dtype=False)
 
     @pytest.mark.xfail(
         condition=platform.system() == "Emscripten" and os.environ.get("TZ") != "UTC",