more fixes

Author: evertlammerts

external/duckdb

@@ -122,7 +122,7 @@ cmake.build-type = "Debug"
 [[tool.scikit-build.overrides]]
 if.state = "editable"
 if.env.COVERAGE = false
-if.platform-system = "Darwin"
+if.platform-system = "(?i)darwin"
 inherit.cmake.define = "append"
 cmake.define.DISABLE_UNITY = "1"
 

pyproject.toml

@@ -189,7 +189,7 @@ struct PyArrowBackend : public FilterBackend {
 
 	py::object MakeColumnRef(const vector<Identifier> &path) override {
 		vector<string> str_path;
-		std::transform(path.begin(), path.end(), str_path.begin(),
+		std::transform(path.begin(), path.end(), std::back_inserter(str_path),
 		               [](const Identifier &segment) { return segment.GetIdentifierName(); });
 		return field_factory(py::tuple(py::cast(str_path)));
 	}

src/duckdb_py/arrow/pyarrow_filter_pushdown.cpp

@@ -0,0 +1,29 @@
+#pragma once
+#include "duckdb_python/pybind11/pybind_wrapper.hpp"
+#include "duckdb/common/identifier.hpp"
+
+namespace py = pybind11;
+
+namespace PYBIND11_NAMESPACE {
+namespace detail {
+template <>
+class type_caster<duckdb::Identifier> {
+	PYBIND11_TYPE_CASTER(duckdb::Identifier, const_name("str"));
+
+	// Python str -> Identifier
+	bool load(handle src, bool) {
+		if (!PyUnicode_Check(src.ptr())) {
+			return false;
+		}
+		value = duckdb::Identifier(src.cast<std::string>());
+		return true;
+	}
+
+	// Identifier -> Python str
+	static handle cast(const duckdb::Identifier &id, return_value_policy, handle) {
+		auto &str_value = id.GetIdentifierName();
+		return PyUnicode_FromStringAndSize(str_value.data(), py::ssize_t(str_value.size()));
+	}
+};
+} // namespace detail
+} // namespace PYBIND11_NAMESPACE

src/duckdb_py/include/duckdb_python/pybind11/conversions/identifier.hpp

@@ -11,6 +11,7 @@
 #include <pybind11/pybind11.h>
 #include <pybind11/numpy.h>
 #include <pybind11/stl.h>
+#include "duckdb_python/pybind11/conversions/identifier.hpp"
 #include "duckdb/common/vector.hpp"
 #include "duckdb/common/assert.hpp"
 #include "duckdb/common/helper.hpp"

src/duckdb_py/include/duckdb_python/pybind11/pybind_wrapper.hpp

@@ -289,7 +289,7 @@ struct DuckDBPyRelation {
 	bool executed;
 	shared_ptr<Relation> rel;
 	vector<LogicalType> types;
-	vector<Identifier> names;
+	vector<string> names;
 	shared_ptr<DuckDBPyResult> result;
 	std::string rendered_result;
 };

src/duckdb_py/include/duckdb_python/pyrelation.hpp

@@ -48,7 +48,7 @@ struct DuckDBPyResult {
 	duckdb::pyarrow::RecordBatchReader FetchRecordBatchReader(idx_t rows_per_batch = 1000000);
 	py::object FetchArrowCapsule(idx_t rows_per_batch = 1000000);
 
-	static py::list GetDescription(const vector<Identifier> &names, const vector<LogicalType> &types);
+	static py::list GetDescription(const vector<string> &names, const vector<LogicalType> &types);
 
 	void Close();
 

src/duckdb_py/include/duckdb_python/pyresult.hpp

@@ -29,7 +29,7 @@ DuckDBPyRelation::DuckDBPyRelation(shared_ptr<Relation> rel_p) : rel(std::move(r
 	this->executed = false;
 	auto &columns = rel->Columns();
 	for (auto &col : columns) {
-		names.push_back(col.GetName());
+		names.push_back(col.Name().GetIdentifierName());
 		types.push_back(col.GetType());
 	}
 }
@@ -69,9 +69,7 @@ DuckDBPyRelation::DuckDBPyRelation(shared_ptr<DuckDBPyResult> result_p) : rel(nu
 	}
 	this->executed = true;
 	this->types = result->GetTypes();
-	auto names_str = result->GetNames();
-	std::transform(names_str.begin(), names_str.end(), this->names.begin(),
-	               [](const std::string &name) { return Identifier(name); });
+	this->names = result->GetNames();
 }
 
 unique_ptr<DuckDBPyRelation> DuckDBPyRelation::ProjectFromExpression(const string &expression) {
@@ -1026,9 +1024,6 @@ PolarsDataFrame DuckDBPyRelation::ToPolars(idx_t batch_size, bool lazy) {
 	ArrowSchema arrow_schema;
 	auto result_names = names;
 	QueryResult::DeduplicateColumns(result_names);
-	vector<std::string> string_names(result_names.size());
-	std::transform(result_names.begin(), result_names.end(), string_names.begin(),
-	               [](const Identifier &name) { return name.GetIdentifierName(); });
 	ClientProperties client_properties;
 	if (rel) {
 		client_properties = rel->context->GetContext()->GetClientProperties();
@@ -1037,10 +1032,10 @@ PolarsDataFrame DuckDBPyRelation::ToPolars(idx_t batch_size, bool lazy) {
 	} else {
 		throw InternalException("DuckDBPyRelation To Polars must have a valid relation or result");
 	}
-	ArrowConverter::ToArrowSchema(&arrow_schema, types, string_names, client_properties);
+	ArrowConverter::ToArrowSchema(&arrow_schema, types, result_names, client_properties);
 	py::list batches;
 	// Now we create an empty arrow table
-	auto empty_table = pyarrow::ToArrowTable(types, string_names, batches, client_properties);
+	auto empty_table = pyarrow::ToArrowTable(types, result_names, batches, client_properties);
 
 	// And we extract the polars schema from the arrow table
 	auto polars_df = py::cast<PolarsDataFrame>(pybind11::module_::import("polars").attr("DataFrame")(empty_table));
@@ -1077,8 +1072,8 @@ void DuckDBPyRelation::Close() {
 }
 
 bool DuckDBPyRelation::ContainsColumnByName(const string &name) const {
-	return std::find_if(names.begin(), names.end(), [&](const Identifier &item) { return name == item; }) !=
-	       names.end();
+	return std::find_if(names.begin(), names.end(),
+	                    [&](const string &item) { return StringUtil::CIEquals(name, item); }) != names.end();
 }
 
 void DuckDBPyRelation::SetConnectionOwner(py::object owner) {
@@ -1122,7 +1117,7 @@ unique_ptr<DuckDBPyRelation> DuckDBPyRelation::GetAttribute(const string &name)
 		// e.g 'rel['my_struct']['my_field']:
 		// first 'my_struct' is selected by the bottom condition
 		// then 'my_field' is accessed on the result of this
-		column_names.push_back(names[0]);
+		column_names.push_back(Identifier(names[0]));
 		column_names.push_back(Identifier(name));
 	} else if (ContainsColumnByName(name)) {
 		column_names.push_back(Identifier(name));

src/duckdb_py/pyrelation.cpp

@@ -793,11 +793,11 @@ py::object DuckDBPyResult::FetchArrowCapsule(idx_t rows_per_batch) {
 	return py::capsule(stream, "arrow_array_stream", ArrowArrayStreamPyCapsuleDestructor);
 }
 
-py::list DuckDBPyResult::GetDescription(const vector<Identifier> &names, const vector<LogicalType> &types) {
+py::list DuckDBPyResult::GetDescription(const vector<string> &names, const vector<LogicalType> &types) {
 	py::list desc;
 
 	for (idx_t col_idx = 0; col_idx < names.size(); col_idx++) {
-		auto py_name = py::str(names[col_idx].GetIdentifierName());
+		auto py_name = py::str(names[col_idx]);
 		auto py_type = DuckDBPyType(types[col_idx]);
 		desc.append(py::make_tuple(py_name, py_type, py::none(), py::none(), py::none(), py::none(), py::none()));
 	}

src/duckdb_py/pyresult.cpp

@@ -37,7 +37,7 @@ py::set DuckDBPyStatement::NamedParameters() const {
 	py::set result;
 	auto &named_parameters = statement->named_param_map;
 	for (auto &param : named_parameters) {
-		result.add(param.first);
+		result.add(param.first.GetIdentifierName());
 	}
 	return result;
 }