Fix/python udf refcount leak

CMakeLists.txt

@@ -6,6 +6,7 @@ project(duckdb_py LANGUAGES CXX)
 set(CMAKE_CXX_STANDARD 11)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 set(CMAKE_CXX_EXTENSIONS OFF)
+set(CMAKE_MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>")
 
 # Set the library name
 set(DUCKDB_PYTHON_LIB_NAME "_duckdb")

_duckdb-stubs/__init__.pyi

@@ -461,7 +461,9 @@ class DuckDBPyRelation:
     def __getattr__(self, name: str) -> DuckDBPyRelation: ...
     def __getitem__(self, name: str) -> DuckDBPyRelation: ...
     def __len__(self) -> int: ...
-    def aggregate(self, aggr_expr: Expression | str, group_expr: Expression | str = "") -> DuckDBPyRelation: ...
+    def aggregate(
+        self, aggr_expr: Expression | str | list[Expression], group_expr: Expression | str = ""
+    ) -> DuckDBPyRelation: ...
     def any_value(
         self, column: str, groups: str = "", window_spec: str = "", projected_columns: str = ""
     ) -> DuckDBPyRelation: ...

cmake/duckdb_loader.cmake

@@ -114,21 +114,18 @@ function(_duckdb_validate_jemalloc_config)
     return()
   endif()
 
-  # jemalloc is only allowed in linux and osx debug builds
-  set(supported_os
-      CMAKE_SYSTEM_NAME
-      STREQUAL
-      "Darwin"
-      OR
-      CMAKE_SYSTEM_NAME
-      STREQUAL
-      "Linux")
-  set(jemalloc_allowed CMAKE_BUILD_TYPE STREQUAL "Debug" AND supported_os)
+  # jemalloc is only enabled on 64bit x86 linux builds
+  if(CMAKE_SIZEOF_VOID_P EQUAL 8
+     AND CMAKE_SYSTEM_NAME STREQUAL "Linux"
+     AND NOT BSD)
+    set(jemalloc_allowed TRUE)
+  else()
+    set(jemalloc_allowed FALSE)
+  endif()
+
   if(NOT jemalloc_allowed)
-    message(
-      WARNING
-        "jemalloc extension is only supported on Linux and OSX in Debug builds.\n"
-        "Removing jemalloc from extension list.")
+    message(WARNING "jemalloc extension is only supported on Linux.\n"
+                    "Removing jemalloc from extension list.")
     # Remove jemalloc from the extension list
     string(REPLACE "jemalloc" "" BUILD_EXTENSIONS_FILTERED
                    "${BUILD_EXTENSIONS}")
@@ -183,19 +180,17 @@ function(_duckdb_create_interface_target target_name)
   if(CMAKE_SYSTEM_NAME STREQUAL "Windows")
     target_compile_options(
       ${target_name}
-      INTERFACE
-        /wd4244 # suppress Conversion from 'type1' to 'type2', possible loss of
-                # data
-        /wd4267 # suppress Conversion from ‘size_t’ to ‘type’, possible loss of
-                # data
-        /wd4200 # suppress Nonstandard extension used: zero-sized array in
-                # struct/union
-        /wd26451
-        /wd26495 # suppress Code Analysis
-        /D_CRT_SECURE_NO_WARNINGS # suppress warnings about unsafe functions
-        /D_DISABLE_CONSTEXPR_MUTEX_CONSTRUCTOR # see
-                                               # https://github.com/duckdblabs/duckdb-internal/issues/5151
-        /utf-8 # treat source files as UTF-8 encoded
+      INTERFACE /wd4244 # suppress Conversion from 'type1' to 'type2', possible
+                        # loss of data
+                /wd4267 # suppress Conversion from ‘size_t’ to ‘type’, possible
+                        # loss of data
+                /wd4200 # suppress Nonstandard extension used: zero-sized array
+                        # in struct/union
+                /wd26451
+                /wd26495 # suppress Code Analysis
+                /D_CRT_SECURE_NO_WARNINGS # suppress warnings about unsafe
+                                          # functions
+                /utf-8 # treat source files as UTF-8 encoded
     )
   elseif(CMAKE_SYSTEM_NAME STREQUAL "Darwin")
     target_compile_options(
@@ -247,6 +242,11 @@ function(duckdb_add_library target_name)
 
   # Create clean interface target
   _duckdb_create_interface_target(${target_name})
+
+  # Propagate BUILD_EXTENSIONS back to caller scope in case it was modified
+  set(BUILD_EXTENSIONS
+      "${BUILD_EXTENSIONS}"
+      PARENT_SCOPE)
 endfunction()
 
 function(duckdb_link_extensions target_name)

src/duckdb_py/pyrelation.cpp

@@ -153,7 +153,7 @@ unique_ptr<DuckDBPyRelation> DuckDBPyRelation::ProjectFromTypes(const py::object
 			if (!projection.empty()) {
 				projection += ", ";
 			}
-			projection += names[i];
+			projection += KeywordHelper::WriteOptionallyQuoted(names[i]);
 		}
 	}
 	if (projection.empty()) {

src/duckdb_py/python_udf.cpp

@@ -326,7 +326,7 @@ static scalar_function_t CreateNativeFunction(PyObject *function, PythonExceptio
 			}
 
 			// Call the function
-			auto ret = PyObject_CallObject(function, bundled_parameters.ptr());
+			auto ret = py::reinterpret_steal<py::object>(PyObject_CallObject(function, bundled_parameters.ptr()));
 			if (ret == nullptr && PyErr_Occurred()) {
 				if (exception_handling == PythonExceptionHandling::FORWARD_ERROR) {
 					auto exception = py::error_already_set();

tests/fast/adbc/test_connection_get_info.py

@@ -28,8 +28,9 @@ def test_connection_get_info_all(self):
                 "duckdb",
                 "v" + duckdb.__duckdb_version__,  # don't hardcode this, as it will change every version
                 "ADBC DuckDB Driver",
+                "v" + duckdb.__duckdb_version__,  # don't hardcode this, as it will change every version
                 "(unknown)",
-                "(unknown)",
+                None,
             ],
             type=pa.string(),
         )
@@ -58,7 +59,7 @@ def test_unrecognized_codes(self):
         table = reader.read_all()
         values = table["info_value"]
 
-        expected_result = pa.array(["duckdb", "(unknown)"], type=pa.string())
+        expected_result = pa.array(["duckdb"], type=pa.string())
 
         assert values.num_chunks == 1
         chunk = values.chunk(0)

tests/fast/test_relation.py

@@ -688,3 +688,10 @@ def create_view(con, view_name: str) -> None:
 
         res = con.sql("select * from vw").fetchall()
         assert res == expected
+
+    def test_relation_select_dtypes_quotes_identifiers_with_spaces(self, duckdb_cursor):
+        df = pd.DataFrame({"na me": ["alice", "bob"], "x": [1, 2]})
+        rel = duckdb_cursor.from_df(df)
+        out = rel.select_dtypes([duckdb.sqltypes.VARCHAR]).fetchdf()
+        assert list(out.columns) == ["na me"]
+        assert out["na me"].tolist() == ["alice", "bob"]

tests/fast/udf/test_udf_refcount_leak.py

@@ -0,0 +1,40 @@
+import gc
+import platform
+import sys
+
+import pytest
+
+import duckdb
+
+
+@pytest.mark.parametrize(("rows", "iters"), [(1000, 20)])
+def test_python_scalar_udf_return_value_refcount_does_not_leak(rows, iters):
+    if platform.python_implementation() != "CPython":
+        pytest.skip("refcount-based test requires CPython")
+
+    payload = b"processed_data_" + b"x" * 8192  # large-ish bytes to mimic the reported issue
+
+    def udf_bytes(_):
+        return payload  # Always return the exact same object so we can track its refcount.
+
+    # Baseline refcount (note: getrefcount adds a temporary ref)
+    baseline = sys.getrefcount(payload)
+
+    con = duckdb.connect()
+    con.create_function("udf_bytes", udf_bytes, ["BIGINT"], "VARCHAR")
+
+    for _ in range(iters):
+        con.execute(f"SELECT udf_bytes(range) FROM range({rows})")
+        res = con.fetchall()
+        # Drop the result ASAP so we don't keep any refs alive in Python
+        del res
+        gc.collect()
+
+    # Re-check refcount. In the buggy version this grows by rows*iters (huge).
+    after = sys.getrefcount(payload)
+
+    # Allow a tiny tolerance for transient references/caches.
+    # In the presence of the leak, this will be thousands+ higher.
+    assert after <= baseline + 10, (baseline, after)
+
+    con.close()