fix asan issues

Author: evertlammerts

CMakeLists.txt

@@ -80,6 +80,22 @@ target_include_directories(
 # link time. No-op on non-Windows.
 target_compile_definitions(_duckdb_dependencies INTERFACE DUCKDB_STATIC_BUILD)
 
+# Optional AddressSanitizer instrumentation of the Python binding objects ONLY.
+# Every binding object library consumes _duckdb_dependencies (for headers) and
+# _duckdb links it, so adding the flag here instruments the bindings and links
+# the ASAN runtime, while the engine target (duckdb_target, which does NOT
+# consume this) stays uninstrumented and keeps hitting the sccache cache. ASAN's
+# allocator is process-global, so heap errors involving the instrumented binding
+# code are still caught. OFF by default; enable with -DDUCKDB_PY_ASAN=ON.
+option(DUCKDB_PY_ASAN
+       "Instrument the Python binding objects with AddressSanitizer" OFF)
+if(DUCKDB_PY_ASAN)
+  target_compile_options(
+    _duckdb_dependencies INTERFACE -fsanitize=address -fno-omit-frame-pointer
+                                   -g)
+  target_link_options(_duckdb_dependencies INTERFACE -fsanitize=address)
+endif()
+
 # ────────────────────────────────────────────
 # Descend into the real DuckDB‑Python sources
 # ────────────────────────────────────────────

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

@@ -108,6 +108,25 @@ bool try_cast(const handle &object, T &result) {
 	return true;
 }
 
+// pybind11's std::string caster accepted str (as-is) and bytes (decoded UTF-8) and stringified scalars; nanobind's
+// nb::cast<std::string> is stricter and surfaces a raw std::bad_cast for non-str input. This helper restores the
+// lenient behavior for the identifier / parameter-key / separator sites that relied on it:
+//   str   -> the string as-is
+//   bytes -> UTF-8 decoded (so read_csv(sep=b"|") and byte-string identifiers keep working)
+//   else  -> str(obj) (so e.g. an int parameter-dict key stringifies to "1", matching pybind11)
+// It never throws std::bad_cast.
+inline std::string cast_to_string(handle obj) {
+	// Use check_ directly: an unqualified isinstance<> here is ambiguous between this namespace's override and
+	// nanobind's (pulled in by the using-directive above).
+	if (bytes::check_(obj)) {
+		return cast<std::string>(obj.attr("decode")("utf-8"));
+	}
+	if (str::check_(obj)) {
+		return cast<std::string>(obj);
+	}
+	return cast<std::string>(str(obj));
+}
+
 // pybind11 compatibility shim: pybind11's py::register_exception<T>(scope, name[, base]) maps to nanobind's
 // nb::exception<T>(scope, name[, base]) (which both creates the Python exception type and registers a C++->Python
 // translator). Returns the exception object so callers can set .attr()/.doc().

src/duckdb_py/pyconnection.cpp

@@ -573,7 +573,7 @@ py::list TransformNamedParameters(const case_insensitive_map_t<idx_t> &named_par
 	}
 
 	for (auto item : params) {
-		const std::string &item_name = py::cast<std::string>(item.first);
+		const std::string &item_name = py::cast_to_string(item.first);
 		auto entry = named_param_map.find(item_name);
 		if (entry == named_param_map.end()) {
 			throw InvalidInputException(
@@ -1297,9 +1297,9 @@ std::unique_ptr<DuckDBPyRelation> DuckDBPyConnection::ReadCSV(const py::object &
 		throw InvalidInputException("read_csv takes either 'delimiter' or 'sep', not both");
 	}
 	if (has_sep) {
-		bind_parameters["delim"] = Value(py::cast<std::string>(sep));
+		bind_parameters["delim"] = Value(py::cast_to_string(sep));
 	} else if (has_delimiter) {
-		bind_parameters["delim"] = Value(py::cast<std::string>(delimiter));
+		bind_parameters["delim"] = Value(py::cast_to_string(delimiter));
 	}
 
 	if (!py::none().is(files_to_sniff)) {
@@ -2317,7 +2317,7 @@ identifier_map_t<BoundParameterData> DuckDBPyConnection::TransformPythonParamDic
 	for (auto pair : params) {
 		auto &key = pair.first;
 		auto &value = pair.second;
-		args[Identifier(py::cast<std::string>(key))] =
+		args[Identifier(py::cast_to_string(key))] =
 		    BoundParameterData(TransformPythonValue(context, value, LogicalType::UNKNOWN, false));
 	}
 	return args;

src/duckdb_py/pyconnection/type_creation.cpp

@@ -37,7 +37,7 @@ static child_list_t<LogicalType> GetChildList(const py::object &container) {
 		for (auto item : fields) {
 			auto name_p = item.first;
 			auto type_p = item.second;
-			auto name = Identifier(py::cast<std::string>(name_p));
+			auto name = Identifier(py::cast_to_string(name_p));
 			std::unique_ptr<DuckDBPyType> pytype;
 			if (!DuckDBPyType::TryConvert(py::borrow<py::object>(type_p), pytype)) {
 				string actual_type = py::cast<std::string>(py::str((type_p).type()));

src/duckdb_py/pyexpression.cpp

@@ -352,6 +352,10 @@ bool DuckDBPyExpression::TryToExpression(py::handle obj, std::unique_ptr<DuckDBP
 		} else if (py::isinstance<py::str>(obj)) {
 			// A str becomes a column reference, mirrors the registered str constructor.
 			result = ColumnExpression(py::cast<py::args>(py::make_tuple(obj)));
+		} else if (py::isinstance<py::bytes>(obj)) {
+			// pybind11 decoded bytes as UTF-8 and (like str) treated them as a column reference; preserve that
+			// so e.g. rel.project(b"col") references column "col" instead of silently building a BLOB constant.
+			result = ColumnExpression(py::cast<py::args>(py::make_tuple(obj.attr("decode")("utf-8"))));
 		} else {
 			// Anything else, including None, becomes a constant -- mirrors the registered object constructor
 			// (None -> NULL constant; TransformPythonValue throws on genuinely unsupported types).

src/duckdb_py/typing/pytype.cpp

@@ -292,7 +292,7 @@ static LogicalType FromDictionary(const py::object &obj) {
 	for (auto item : dict) {
 		auto &name_p = item.first;
 		auto type_p = py::borrow<py::object>(item.second);
-		auto name = Identifier(py::cast<std::string>(name_p));
+		auto name = Identifier(py::cast_to_string(name_p));
 		auto type = FromObject(type_p);
 		children.push_back(std::make_pair(name, std::move(type)));
 	}

tests/fast/test_expression_implicit_conversion.py

@@ -177,6 +177,18 @@ def test_binary_operator_str_rhs(rel):
     assert result == [(True,)]
 
 
+def test_binary_operator_bytes_rhs(rel):
+    """Bytes on the RHS is decoded as UTF-8 and (like str) becomes a ColumnExpression (column reference)."""
+    expr = ColumnExpression("i") == b"i"
+    assert isinstance(expr, duckdb.Expression)
+    assert rel.select(expr).fetchall() == [(True,)]
+
+
+def test_project_with_bytes_column_name(rel):
+    """rel.select(b'col') references the column (bytes decoded), not a silent BLOB constant (regression guard)."""
+    assert rel.select(b"i").fetchall() == [(42,)]
+
+
 # ---------------------------------------------------------------------------
 # 3. Reflected operators: <value> + col
 # ---------------------------------------------------------------------------

tests/fast/test_string_coercion.py

@@ -0,0 +1,53 @@
+"""String coercion at identifier / parameter-key / separator sites.
+
+nanobind's nb::cast<std::string> is stricter than pybind11's: it rejects bytes and non-str scalars and surfaces a
+raw ``RuntimeError: std::bad_cast`` instead of pybind11's lenient conversion. The ``cast_to_string`` helper restores
+the lenient behavior (str as-is, bytes UTF-8 decoded, anything else stringified via str()). These guard the
+std::bad_cast regression and confirm the realistic cases still match pybind11.
+"""
+
+import platform
+
+import pytest
+
+import duckdb
+
+pytestmark = pytest.mark.skipif(
+    platform.system() == "Emscripten",
+    reason="Extensions are not supported on Emscripten",
+)
+
+
+def test_execute_int_param_key():
+    """An int parameter-dict key stringifies (so {1: v} fills positional $1), matching pybind11."""
+    con = duckdb.connect()
+    assert con.execute("SELECT $1 AS a", {1: 5}).fetchall() == [(5,)]
+
+
+def test_execute_str_param_key():
+    con = duckdb.connect()
+    assert con.execute("SELECT $name AS a", {"name": 7}).fetchall() == [(7,)]
+
+
+def test_struct_type_int_field_key():
+    """An int struct field-name key stringifies to "1" (matching pybind11), not a raw std::bad_cast."""
+    assert str(duckdb.struct_type({1: "INTEGER"})) == 'STRUCT("1" INTEGER)'
+
+
+def test_struct_type_str_field_key():
+    assert str(duckdb.struct_type({"a": "INTEGER"})) == "STRUCT(a INTEGER)"
+
+
+def test_bytes_param_key_decodes():
+    """A bytes param-dict key is UTF-8 decoded (b'1' -> '1'); bytes consistently decode at coercion sites."""
+    con = duckdb.connect()
+    assert con.execute("SELECT $1 AS a", {b"1": 5}).fetchall() == [(5,)]
+
+
+def test_bytes_struct_field_key_decodes():
+    """A bytes struct field-name key is UTF-8 decoded (b'a' -> 'a'); bytes consistently decode at coercion sites.
+
+    These coercion sites previously surfaced a raw 'std::bad_cast' for non-str input; each test here asserting a
+    concrete result also guards that regression (a std::bad_cast would raise and fail the assertion).
+    """
+    assert str(duckdb.struct_type({b"a": "INTEGER"})) == "STRUCT(a INTEGER)"