Fwd ports of:

* #18749 Fixing lazy polars execution on query result
* #18682 Make sure parse errors are wrapped in ErrorData

Author: evertlammerts

src/duckdb_py/include/duckdb_python/pyrelation.hpp

@@ -28,7 +28,7 @@ namespace duckdb {
 struct DuckDBPyRelation {
 public:
 	explicit DuckDBPyRelation(shared_ptr<Relation> rel);
-	explicit DuckDBPyRelation(unique_ptr<DuckDBPyResult> result);
+	explicit DuckDBPyRelation(shared_ptr<DuckDBPyResult> result);
 	~DuckDBPyRelation();
 
 public:
@@ -288,7 +288,7 @@ struct DuckDBPyRelation {
 	shared_ptr<Relation> rel;
 	vector<LogicalType> types;
 	vector<string> names;
-	unique_ptr<DuckDBPyResult> result;
+	shared_ptr<DuckDBPyResult> result;
 	std::string rendered_result;
 };
 

src/duckdb_py/include/duckdb_python/pyresult.hpp

@@ -59,6 +59,8 @@ struct DuckDBPyResult {
 	const vector<string> &GetNames();
 	const vector<LogicalType> &GetTypes();
 
+	ClientProperties GetClientProperties();
+
 private:
 	void FillNumpy(py::dict &res, idx_t col_idx, NumpyResultConversion &conversion, const char *name);
 

src/duckdb_py/pyconnection.cpp

@@ -614,17 +614,17 @@ unique_ptr<QueryResult> DuckDBPyConnection::PrepareAndExecuteInternal(unique_ptr
 }
 
 vector<unique_ptr<SQLStatement>> DuckDBPyConnection::GetStatements(const py::object &query) {
-	vector<unique_ptr<SQLStatement>> result;
-	auto &connection = con.GetConnection();
-
 	shared_ptr<DuckDBPyStatement> statement_obj;
 	if (py::try_cast(query, statement_obj)) {
+		vector<unique_ptr<SQLStatement>> result;
 		result.push_back(statement_obj->GetStatement());
 		return result;
 	}
 	if (py::isinstance<py::str>(query)) {
+		auto &connection = con.GetConnection();
 		auto sql_query = std::string(py::str(query));
-		return connection.ExtractStatements(sql_query);
+		auto statements = connection.ExtractStatements(sql_query);
+		return std::move(statements);
 	}
 	throw InvalidInputException("Please provide either a DuckDBPyStatement or a string representing the query");
 }

src/duckdb_py/pyrelation.cpp

@@ -66,7 +66,7 @@ DuckDBPyRelation::~DuckDBPyRelation() {
 	rel.reset();
 }
 
-DuckDBPyRelation::DuckDBPyRelation(unique_ptr<DuckDBPyResult> result_p) : rel(nullptr), result(std::move(result_p)) {
+DuckDBPyRelation::DuckDBPyRelation(shared_ptr<DuckDBPyResult> result_p) : rel(nullptr), result(std::move(result_p)) {
 	if (!result) {
 		throw InternalException("DuckDBPyRelation created without a result");
 	}
@@ -984,7 +984,14 @@ PolarsDataFrame DuckDBPyRelation::ToPolars(idx_t batch_size, bool lazy) {
 	ArrowSchema arrow_schema;
 	auto result_names = names;
 	QueryResult::DeduplicateColumns(result_names);
-	auto client_properties = rel->context->GetContext()->GetClientProperties();
+	ClientProperties client_properties;
+	if (rel) {
+		client_properties = rel->context->GetContext()->GetClientProperties();
+	} else if (result) {
+		client_properties = result->GetClientProperties();
+	} else {
+		throw InternalException("DuckDBPyRelation To Polars must have a valid relation or result");
+	}
 	ArrowConverter::ToArrowSchema(&arrow_schema, types, result_names, client_properties);
 	py::list batches;
 	// Now we create an empty arrow table

src/duckdb_py/pyresult.cpp

@@ -41,6 +41,10 @@ DuckDBPyResult::~DuckDBPyResult() {
 	}
 }
 
+ClientProperties DuckDBPyResult::GetClientProperties() {
+	return result->client_properties;
+}
+
 const vector<string> &DuckDBPyResult::GetNames() {
 	if (!result) {
 		throw InternalException("Calling GetNames without a result object");

tests/fast/arrow/test_polars.py

@@ -101,6 +101,14 @@ def test_polars_from_json_error(self, duckdb_cursor):
         my_res = duckdb.query("select my_str from my_table where my_str != 'y'")
         assert my_res.fetchall() == [('x',)]
 
+    def test_polars_lazy_from_conn(self, duckdb_cursor):
+        duckdb_conn = duckdb.connect()
+
+        result = duckdb_conn.execute("SELECT 42 as bla")
+
+        lazy_df = result.pl(lazy=True)
+        assert lazy_df.collect().to_dicts() == [{'bla': 42}]
+
     def test_polars_lazy(self, duckdb_cursor):
         con = duckdb.connect()
         con.execute("Create table names (a varchar, b integer)")

tests/fast/test_json_logging.py

@@ -0,0 +1,48 @@
+import json
+
+import duckdb
+import pytest
+
+
+def _parse_json_func(error_prefix: str):
+    """Helper to check that the error message is indeed parsable json"""
+
+    def parse_func(exception):
+        msg = exception.args[0]
+        assert msg.startswith(error_prefix)
+        json_str = msg.split(error_prefix, 1)[1]
+        try:
+            json.loads(json_str)
+        except:
+            return False
+        return True
+
+    return parse_func
+
+
+def test_json_syntax_error():
+    conn = duckdb.connect()
+    conn.execute("SET errors_as_json='true'")
+    with pytest.raises(duckdb.ParserException, match="SYNTAX_ERROR", check=_parse_json_func("Parser Error: ")):
+        conn.execute("syntax error")
+
+
+def test_json_catalog_error():
+    conn = duckdb.connect()
+    conn.execute("SET errors_as_json='true'")
+    with pytest.raises(duckdb.CatalogException, match="MISSING_ENTRY", check=_parse_json_func("Catalog Error: ")):
+        conn.execute("SELECT * FROM nonexistent_table")
+
+
+def test_json_syntax_error_extract_statements():
+    conn = duckdb.connect()
+    conn.execute("SET errors_as_json='true'")
+    with pytest.raises(duckdb.ParserException, match="SYNTAX_ERROR", check=_parse_json_func("Parser Error: ")):
+        conn.extract_statements("syntax error")
+
+
+def test_json_syntax_error_get_table_names():
+    conn = duckdb.connect()
+    conn.execute("SET errors_as_json='true'")
+    with pytest.raises(duckdb.ParserException, match="SYNTAX_ERROR", check=_parse_json_func("Parser Error: ")):
+        conn.get_table_names("syntax error")