fix pandas

Author: evertlammerts

src/duckdb_py/native/python_conversion.cpp

@@ -61,7 +61,9 @@ vector<Identifier> TransformStructKeys(py::handle keys, idx_t size, const Logica
 	vector<Identifier> res;
 	res.reserve(size);
 	for (idx_t i = 0; i < size; i++) {
-		res.emplace_back(Identifier(py::cast<std::string>(keys.attr("__getitem__")(i))));
+		// Stringify via str() so non-string keys (e.g. the integer keys of a hashable-key MAP, which DuckDB
+		// produces as a plain {1: 10} dict) are accepted -- nanobind's nb::cast<std::string> rejects non-str.
+		res.emplace_back(Identifier(py::cast<std::string>(py::str(keys.attr("__getitem__")(i)))));
 	}
 	return res;
 }
@@ -1037,8 +1039,12 @@ void TransformPythonObjectInternal(optional_ptr<ClientContext> context, py::hand
 		break;
 	}
 	case PythonObjectType::Bytes: {
-		const string &ele_string = py::cast<string>(ele);
-		OP::HandleBlob(result, param, const_data_ptr_t(ele_string.data()), ele_string.size());
+		// Read the buffer directly (mirrors the ByteArray branch above): nanobind's nb::cast<std::string> rejects
+		// a bytes object (pybind11 accepted it), so go through the CPython API instead.
+		char *bytes_buffer;
+		Py_ssize_t bytes_length;
+		PyBytes_AsStringAndSize(ele.ptr(), &bytes_buffer, &bytes_length); // NOLINT
+		OP::HandleBlob(result, param, const_data_ptr_cast(bytes_buffer), idx_t(bytes_length));
 		break;
 	}
 	case PythonObjectType::NdArray:

src/duckdb_py/pandas/analyzer.cpp

@@ -337,8 +337,10 @@ LogicalType PandasAnalyzer::DictToStruct(const PyDictionary &dict, bool &can_con
 	for (idx_t i = 0; i < dict.len; i++) {
 		auto dict_key = dict.keys.attr("__getitem__")(i);
 
-		//! Have to already transform here because the child_list needs a string as key
-		auto key = Identifier(py::cast<std::string>(dict_key));
+		//! Have to already transform here because the child_list needs a string as key. Stringify via str() so
+		//! non-string keys (e.g. the integer keys of a hashable-key MAP, produced as a plain {1: 10} dict) are
+		//! accepted -- nanobind's nb::cast<std::string> rejects non-str objects, whereas pybind11 stringified them.
+		auto key = Identifier(py::cast<std::string>(py::str(dict_key)));
 
 		auto dict_val = dict.values.attr("__getitem__")(i);
 		auto val = GetItemType(dict_val, can_convert);

src/duckdb_py/pandas/bind.cpp

@@ -63,10 +63,19 @@ static LogicalType BindColumn(ClientContext &context, PandasBindColumn &column_p
 		D_ASSERT(py::hasattr(column.attr("cat"), "categories"));
 		NumpyArray categories(column.attr("cat").attr("categories"));
 		auto categories_pd_type = ConvertNumpyType(categories.GetArray().attr("dtype"));
-		if (categories_pd_type.type == NumpyNullableType::OBJECT) {
+		// Legacy categories are backed by an `object` dtype; pandas >= 3.0 backs string categories with the new
+		// StringDtype (reported as "str"), so treat both as string categories -> ENUM.
+		if (categories_pd_type.type == NumpyNullableType::OBJECT ||
+		    categories_pd_type.type == NumpyNullableType::STRING) {
 			// Let's hope the object type is a string.
 			bind_data.numpy_type.type = NumpyNullableType::CATEGORY;
-			vector<string> enum_entries = py::cast<vector<string>>(categories.GetArray());
+			// str()-ify each category individually: pandas >= 3.0 categories are a StringArray whose elements are
+			// numpy str scalars, which nanobind's vector<string>/string casters reject (py::cast<vector<string>>
+			// on the array throws). Iterating + py::str handles both that and the legacy object[str] case.
+			vector<string> enum_entries;
+			for (auto category : categories.GetArray()) {
+				enum_entries.push_back(py::cast<std::string>(py::str(category)));
+			}
 			idx_t size = enum_entries.size();
 			Vector enum_entries_vec(LogicalType::VARCHAR, size);
 			auto enum_entries_ptr = FlatVector::GetDataMutable<string_t>(enum_entries_vec);
@@ -75,8 +84,11 @@ static LogicalType BindColumn(ClientContext &context, PandasBindColumn &column_p
 			}
 			D_ASSERT(py::hasattr(column.attr("cat"), "codes"));
 			column_type = LogicalType::ENUM(enum_entries_vec, size);
-			NumpyArray pandas_col(column.attr("cat").attr("codes"));
-			bind_data.internal_categorical_type = py::cast<std::string>(py::str(pandas_col.GetArray().attr("dtype")));
+			// .to_numpy(): pandas >= 3.0 returns cat.codes as a Series (no .strides/.ctypes), but the scan needs a
+			// real ndarray backing buffer; materialize it. (Older pandas returned an ndarray here directly.)
+			NumpyArray pandas_col(column.attr("cat").attr("codes").attr("to_numpy")());
+			bind_data.internal_categorical_type =
+			    py::cast<std::string>(py::str(py::object(pandas_col.GetArray().attr("dtype"))));
 			bind_data.pandas_col = std::make_unique<PandasNumpyColumn>(std::move(pandas_col));
 		} else {
 			NumpyArray pandas_col(column.attr("to_numpy")());