main fixes

Author: evertlammerts

src/duckdb_py/arrow/filter_pushdown_visitor.cpp

@@ -159,87 +159,6 @@ py::object TransformExpression(const Expression &expression, const vector<string
 py::object TransformFilter(const TableFilter &filter, vector<string> column_path, FilterBackend &backend,
                            const ArrowType *arrow_type, const string &timezone_config) {
 	switch (filter.filter_type) {
-	case TableFilterType::CONSTANT_COMPARISON: {
-		auto &constant_filter = filter.Cast<ConstantFilter>();
-		auto col = backend.MakeColumnRef(column_path);
-		return EmitCompare(backend, constant_filter.comparison_type, std::move(col), constant_filter.constant,
-		                   arrow_type, timezone_config);
-	}
-	case TableFilterType::IS_NULL: {
-		auto col = backend.MakeColumnRef(column_path);
-		return backend.IsNull(std::move(col));
-	}
-	case TableFilterType::IS_NOT_NULL: {
-		auto col = backend.MakeColumnRef(column_path);
-		return backend.IsNotNull(std::move(col));
-	}
-	case TableFilterType::CONJUNCTION_AND: {
-		auto &and_filter = filter.Cast<ConjunctionAndFilter>();
-		py::object result = py::none();
-		for (idx_t i = 0; i < and_filter.child_filters.size(); i++) {
-			py::object child_expression =
-			    TransformFilter(*and_filter.child_filters[i], column_path, backend, arrow_type, timezone_config);
-			if (child_expression.is(py::none())) {
-				continue;
-			}
-			if (result.is(py::none())) {
-				result = std::move(child_expression);
-			} else {
-				result = backend.And(std::move(result), std::move(child_expression));
-			}
-		}
-		return result;
-	}
-	case TableFilterType::CONJUNCTION_OR: {
-		auto &or_filter = filter.Cast<ConjunctionOrFilter>();
-		py::object result = py::none();
-		for (idx_t i = 0; i < or_filter.child_filters.size(); i++) {
-			py::object child_expression =
-			    TransformFilter(*or_filter.child_filters[i], column_path, backend, arrow_type, timezone_config);
-			if (child_expression.is(py::none())) {
-				continue;
-			}
-			if (result.is(py::none())) {
-				result = std::move(child_expression);
-			} else {
-				result = backend.Or(std::move(result), std::move(child_expression));
-			}
-		}
-		return result;
-	}
-	case TableFilterType::STRUCT_EXTRACT: {
-		auto &struct_filter = filter.Cast<StructFilter>();
-		column_path.push_back(struct_filter.child_name);
-		const ArrowType *child_type = nullptr;
-		if (arrow_type) {
-			child_type = &arrow_type->GetTypeInfo<ArrowStructInfo>().GetChild(struct_filter.child_idx);
-		}
-		return TransformFilter(*struct_filter.child_filter, std::move(column_path), backend, child_type,
-		                       timezone_config);
-	}
-	case TableFilterType::OPTIONAL_FILTER: {
-		auto &optional_filter = filter.Cast<OptionalFilter>();
-		if (!optional_filter.child_filter) {
-			return py::none();
-		}
-		try {
-			return TransformFilter(*optional_filter.child_filter, column_path, backend, arrow_type, timezone_config);
-		} catch (const NotImplementedException &) {
-			return py::none();
-		}
-	}
-	case TableFilterType::IN_FILTER: {
-		auto &in_filter = filter.Cast<InFilter>();
-		auto col = backend.MakeColumnRef(column_path);
-		// The column's logical type for IN comes from the values themselves
-		// (they share the comparison type). Empty IN lists are not produced
-		// by the optimizer so we can safely index values[0].
-		LogicalType col_logical_type =
-		    in_filter.values.empty() ? LogicalType::SQLNULL : in_filter.values.front().type();
-		return backend.IsIn(std::move(col), in_filter.values, col_logical_type, timezone_config);
-	}
-	case TableFilterType::DYNAMIC_FILTER:
-		return py::none();
 	case TableFilterType::EXPRESSION_FILTER: {
 		auto &expression_filter = filter.Cast<ExpressionFilter>();
 		return TransformExpression(*expression_filter.expr, column_path, backend, arrow_type, timezone_config);

src/duckdb_py/pyconnection.cpp

@@ -1937,7 +1937,8 @@ void DuckDBPyConnection::InstallExtension(const string &extension, bool force_in
 
 void DuckDBPyConnection::LoadExtension(const string &extension) {
 	auto &connection = con.GetConnection();
-	ExtensionHelper::LoadExternalExtension(*connection.context, extension);
+	const ExtensionLoadOptions extension_opts = {extension};
+	ExtensionHelper::LoadExternalExtension(*connection.context, extension_opts);
 }
 
 shared_ptr<DuckDBPyConnection> DefaultConnectionHolder::Get() {

tests/fast/arrow/test_polars_filter_pushdown.py

@@ -513,7 +513,7 @@ def test_no_crash_correct_result(self, factory):
             ("price", 100),
         ]
 
-    def test_top_n_nulls_first_includes_min(self):
+    def test_top_n_nulls_first_includes_min(self, factory):
         """ORDER BY x ASC NULLS FIRST LIMIT 1 pushes OPTIONAL(IS_NULL OR DYNAMIC_FILTER) into the scan.
 
         The OR branch must not be partially translated: dropping the