Merge branch 'v1.4-andium' into pyexpression_is_operator

evertlammerts · web-flow · commit 864f40d65f11 · 2025-09-15T14:17:43.000+02:00
diff --git a/.github/workflows/packaging.yml b/.github/workflows/packaging.yml
@@ -68,7 +68,7 @@ jobs:
       testsuite: all
       duckdb-python-sha: ${{ inputs.duckdb-python-sha != '' && inputs.duckdb-python-sha || github.sha }}
       duckdb-sha: ${{ inputs.duckdb-sha }}
-      set-version: ${{ inputs.stable-version }}
+      set-version: ${{ inputs.set-version }}
 
   build_wheels:
     name: Build and test releases
@@ -78,4 +78,4 @@ jobs:
       testsuite: all
       duckdb-python-sha: ${{ inputs.duckdb-python-sha != '' && inputs.duckdb-python-sha || github.sha }}
       duckdb-sha: ${{ inputs.duckdb-sha }}
-      set-version: ${{ inputs.stable-version }}
+      set-version: ${{ inputs.set-version }}
diff --git a/.github/workflows/packaging_wheels.yml b/.github/workflows/packaging_wheels.yml
@@ -73,6 +73,7 @@ jobs:
 
       # Make sure that OVERRIDE_GIT_DESCRIBE is propagated to cibuildwhel's env, also when it's running linux builds
       - name: Set OVERRIDE_GIT_DESCRIBE
+        shell: bash
         if: ${{ inputs.set-version != '' }}
         run: echo "CIBW_ENVIRONMENT=OVERRIDE_GIT_DESCRIBE=${{ inputs.set-version }}" >> $GITHUB_ENV
 
diff --git a/duckdb/__init__.py b/duckdb/__init__.py
@@ -18,6 +18,49 @@ def version():
     "functional"
 ])
 
+class DBAPITypeObject:
+    def __init__(self, types: list[typing.DuckDBPyType]) -> None:
+        self.types = types
+
+    def __eq__(self, other):
+        if isinstance(other, typing.DuckDBPyType):
+            return other in self.types
+        return False
+
+    def __repr__(self):
+        return f"<DBAPITypeObject [{','.join(str(x) for x in self.types)}]>"
+
+# Define the standard DBAPI sentinels
+STRING   = DBAPITypeObject([typing.VARCHAR])
+NUMBER   = DBAPITypeObject([
+    typing.TINYINT,
+    typing.UTINYINT,
+    typing.SMALLINT,
+    typing.USMALLINT,
+    typing.INTEGER,
+    typing.UINTEGER,
+    typing.BIGINT,
+    typing.UBIGINT,
+    typing.HUGEINT,
+    typing.UHUGEINT,
+    typing.DuckDBPyType("BIGNUM"),
+    typing.DuckDBPyType("DECIMAL"),
+    typing.FLOAT,
+    typing.DOUBLE
+])
+DATETIME = DBAPITypeObject([
+    typing.DATE,
+    typing.TIME,
+    typing.TIME_TZ,
+    typing.TIMESTAMP,
+    typing.TIMESTAMP_TZ,
+    typing.TIMESTAMP_NS,
+    typing.TIMESTAMP_MS,
+    typing.TIMESTAMP_S
+])
+BINARY   = DBAPITypeObject([typing.BLOB])
+ROWID    = None
+
 # Classes
 from _duckdb import (
     DuckDBPyRelation,
diff --git a/external/duckdb b/external/duckdb
@@ -1 +1 @@
-Subproject commit 166716352edf482a378ade0f2990abb7237ae841
+Subproject commit b3edbac8519f8ed04f58a6f30ec349112bdc7d6c
diff --git a/src/duckdb_py/pyconnection.cpp b/src/duckdb_py/pyconnection.cpp
@@ -465,6 +465,9 @@ shared_ptr<DuckDBPyConnection> DuckDBPyConnection::ExecuteMany(const py::object
 
 unique_ptr<QueryResult> DuckDBPyConnection::CompletePendingQuery(PendingQueryResult &pending_query) {
 	PendingExecutionResult execution_result;
+	if (pending_query.HasError()) {
+		pending_query.ThrowError();
+	}
 	while (!PendingQueryResult::IsResultReady(execution_result = pending_query.ExecuteTask())) {
 		{
 			py::gil_scoped_acquire gil;
diff --git a/src/duckdb_py/pyresult.cpp b/src/duckdb_py/pyresult.cpp
@@ -514,72 +514,12 @@ py::object DuckDBPyResult::FetchArrowCapsule(idx_t rows_per_batch) {
 	return py::capsule(stream, "arrow_array_stream", ArrowArrayStreamPyCapsuleDestructor);
 }
 
-py::str GetTypeToPython(const LogicalType &type) {
-	switch (type.id()) {
-	case LogicalTypeId::BOOLEAN:
-		return py::str("bool");
-	case LogicalTypeId::TINYINT:
-	case LogicalTypeId::SMALLINT:
-	case LogicalTypeId::INTEGER:
-	case LogicalTypeId::BIGINT:
-	case LogicalTypeId::UTINYINT:
-	case LogicalTypeId::USMALLINT:
-	case LogicalTypeId::UINTEGER:
-	case LogicalTypeId::UBIGINT:
-	case LogicalTypeId::HUGEINT:
-	case LogicalTypeId::UHUGEINT:
-	case LogicalTypeId::FLOAT:
-	case LogicalTypeId::DOUBLE:
-	case LogicalTypeId::DECIMAL: {
-		return py::str("NUMBER");
-	}
-	case LogicalTypeId::VARCHAR: {
-		if (type.HasAlias() && type.GetAlias() == "JSON") {
-			return py::str("JSON");
-		} else {
-			return py::str("STRING");
-		}
-	}
-	case LogicalTypeId::BLOB:
-	case LogicalTypeId::BIT:
-		return py::str("BINARY");
-	case LogicalTypeId::TIMESTAMP:
-	case LogicalTypeId::TIMESTAMP_TZ:
-	case LogicalTypeId::TIMESTAMP_MS:
-	case LogicalTypeId::TIMESTAMP_NS:
-	case LogicalTypeId::TIMESTAMP_SEC: {
-		return py::str("DATETIME");
-	}
-	case LogicalTypeId::TIME:
-	case LogicalTypeId::TIME_TZ: {
-		return py::str("Time");
-	}
-	case LogicalTypeId::DATE: {
-		return py::str("Date");
-	}
-	case LogicalTypeId::STRUCT:
-	case LogicalTypeId::MAP:
-		return py::str("dict");
-	case LogicalTypeId::LIST: {
-		return py::str("list");
-	}
-	case LogicalTypeId::INTERVAL: {
-		return py::str("TIMEDELTA");
-	}
-	case LogicalTypeId::UUID: {
-		return py::str("UUID");
-	}
-	default:
-		return py::str(type.ToString());
-	}
-}
-
 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]);
-		auto py_type = GetTypeToPython(types[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()));
 	}
 	return desc;
diff --git a/src/duckdb_py/typing/pytype.cpp b/src/duckdb_py/typing/pytype.cpp
@@ -326,8 +326,8 @@ void DuckDBPyType::Initialize(py::handle &m) {
 	auto type_module = py::class_<DuckDBPyType, shared_ptr<DuckDBPyType>>(m, "DuckDBPyType", py::module_local());
 
 	type_module.def("__repr__", &DuckDBPyType::ToString, "Stringified representation of the type object");
-	type_module.def("__eq__", &DuckDBPyType::Equals, "Compare two types for equality", py::arg("other"));
-	type_module.def("__eq__", &DuckDBPyType::EqualsString, "Compare two types for equality", py::arg("other"));
+	type_module.def("__eq__", &DuckDBPyType::Equals, "Compare two types for equality", py::arg("other"), py::is_operator());
+	type_module.def("__eq__", &DuckDBPyType::EqualsString, "Compare two types for equality", py::arg("other"), py::is_operator());
 	type_module.def_property_readonly("id", &DuckDBPyType::GetId);
 	type_module.def_property_readonly("children", &DuckDBPyType::Children);
 	type_module.def(py::init<>([](const string &type_str, shared_ptr<DuckDBPyConnection> connection = nullptr) {
@@ -347,7 +347,7 @@ void DuckDBPyType::Initialize(py::handle &m) {
 		return make_shared_ptr<DuckDBPyType>(ltype);
 	}));
 	type_module.def("__getattr__", &DuckDBPyType::GetAttribute, "Get the child type by 'name'", py::arg("name"));
-	type_module.def("__getitem__", &DuckDBPyType::GetAttribute, "Get the child type by 'name'", py::arg("name"));
+	type_module.def("__getitem__", &DuckDBPyType::GetAttribute, "Get the child type by 'name'", py::arg("name"), py::is_operator());
 
 	py::implicitly_convertible<py::object, DuckDBPyType>();
 	py::implicitly_convertible<py::str, DuckDBPyType>();
diff --git a/tests/fast/api/test_3728.py b/tests/fast/api/test_3728.py
@@ -14,6 +14,6 @@ def test_3728_describe_enum(self, duckdb_cursor):
 
         # This fails with "RuntimeError: Not implemented Error: unsupported type: mood"
         assert cursor.table("person").execute().description == [
-            ('name', 'STRING', None, None, None, None, None),
+            ('name', 'VARCHAR', None, None, None, None, None),
             ('current_mood', "ENUM('sad', 'ok', 'happy')", None, None, None, None, None),
         ]
diff --git a/tests/fast/api/test_dbapi10.py b/tests/fast/api/test_dbapi10.py
@@ -1,19 +1,20 @@
 # cursor description
 from datetime import datetime, date
 from pytest import mark
+import duckdb
 
 
 class TestCursorDescription(object):
     @mark.parametrize(
         "query,column_name,string_type,real_type",
         [
-            ["SELECT * FROM integers", "i", "NUMBER", int],
-            ["SELECT * FROM timestamps", "t", "DATETIME", datetime],
-            ["SELECT DATE '1992-09-20' AS date_col;", "date_col", "Date", date],
-            ["SELECT '\\xAA'::BLOB AS blob_col;", "blob_col", "BINARY", bytes],
-            ["SELECT {'x': 1, 'y': 2, 'z': 3} AS struct_col", "struct_col", "dict", dict],
-            ["SELECT [1, 2, 3] AS list_col", "list_col", "list", list],
-            ["SELECT 'Frank' AS str_col", "str_col", "STRING", str],
+            ["SELECT * FROM integers", "i", "INTEGER", int],
+            ["SELECT * FROM timestamps", "t", "TIMESTAMP", datetime],
+            ["SELECT DATE '1992-09-20' AS date_col;", "date_col", "DATE", date],
+            ["SELECT '\\xAA'::BLOB AS blob_col;", "blob_col", "BLOB", bytes],
+            ["SELECT {'x': 1, 'y': 2, 'z': 3} AS struct_col", "struct_col", "STRUCT(x INTEGER, y INTEGER, z INTEGER)", dict],
+            ["SELECT [1, 2, 3] AS list_col", "list_col", "INTEGER[]", list],
+            ["SELECT 'Frank' AS str_col", "str_col", "VARCHAR", str],
             ["SELECT [1, 2, 3]::JSON AS json_col", "json_col", "JSON", str],
             ["SELECT union_value(tag := 1) AS union_col", "union_col", "UNION(tag INTEGER)", int],
         ],
@@ -23,6 +24,24 @@ def test_description(self, query, column_name, string_type, real_type, duckdb_cu
         assert duckdb_cursor.description == [(column_name, string_type, None, None, None, None, None)]
         assert isinstance(duckdb_cursor.fetchone()[0], real_type)
 
+    def test_description_comparisons(self):
+        duckdb.execute("select 42 a, 'test' b, true c")
+        types = [x[1] for x in duckdb.description()]
+
+        STRING = duckdb.STRING
+        NUMBER = duckdb.NUMBER
+        DATETIME = duckdb.DATETIME
+
+        assert(types[1] == STRING)
+        assert(STRING == types[1])
+        assert(types[0] != STRING)
+        assert((types[1] != STRING) == False)
+        assert((STRING != types[1]) == False)
+
+        assert(types[1] in [STRING])
+        assert(types[1] in [STRING, NUMBER])
+        assert(types[1] not in [NUMBER, DATETIME])
+
     def test_none_description(self, duckdb_empty_cursor):
         assert duckdb_empty_cursor.description is None
 
diff --git a/tests/fast/api/test_duckdb_connection.py b/tests/fast/api/test_duckdb_connection.py
@@ -1,4 +1,5 @@
 import duckdb
+import duckdb.typing
 import pytest
 from conftest import NumpyPandas, ArrowPandas
 
@@ -113,7 +114,7 @@ def test_readonly_properties(self):
         duckdb.execute("select 42")
         description = duckdb.description()
         rowcount = duckdb.rowcount()
-        assert description == [('42', 'NUMBER', None, None, None, None, None)]
+        assert description == [('42', 'INTEGER', None, None, None, None, None)]
         assert rowcount == -1
 
     def test_execute(self):
@@ -349,9 +350,6 @@ def test_view(self):
         assert [([0, 1, 2, 3, 4],)] == duckdb.view("vw").fetchall()
         duckdb.execute("drop view vw")
 
-    def test_description(self):
-        assert None != duckdb.description
-
     def test_close(self):
         assert None != duckdb.close
 
diff --git a/tests/fast/relational_api/test_rapi_description.py b/tests/fast/relational_api/test_rapi_description.py
@@ -9,7 +9,8 @@ def test_rapi_description(self, duckdb_cursor):
         names = [x[0] for x in desc]
         types = [x[1] for x in desc]
         assert names == ['a', 'b']
-        assert types == ['NUMBER', 'NUMBER']
+        assert types == ['INTEGER', 'BIGINT']
+        assert (all([x == duckdb.NUMBER for x in types]))
 
     def test_rapi_describe(self, duckdb_cursor):
         np = pytest.importorskip("numpy")
diff --git a/tests/fast/test_map.py b/tests/fast/test_map.py
@@ -154,9 +154,9 @@ def cast_to_string(df):
 
         con = duckdb.connect()
         rel = con.sql('select i from range (10) tbl(i)')
-        assert rel.types[0] == int
+        assert rel.types[0] == duckdb.NUMBER
         mapped_rel = rel.map(cast_to_string, schema={'i': str})
-        assert mapped_rel.types[0] == str
+        assert mapped_rel.types[0] == duckdb.STRING
 
     def test_explicit_schema_returntype_mismatch(self):
         def does_nothing(df):
diff --git a/tests/fast/test_result.py b/tests/fast/test_result.py
@@ -31,9 +31,9 @@ def test_result_describe_types(self, duckdb_cursor):
         rel = connection.table("test")
         res = rel.execute()
         assert res.description == [
-            ('i', 'bool', None, None, None, None, None),
-            ('j', 'Time', None, None, None, None, None),
-            ('k', 'STRING', None, None, None, None, None),
+            ('i', 'BOOLEAN', None, None, None, None, None),
+            ('j', 'TIME', None, None, None, None, None),
+            ('k', 'VARCHAR', None, None, None, None, None),
         ]
 
     def test_result_timestamps(self, duckdb_cursor):
@@ -64,7 +64,7 @@ def test_result_interval(self):
 
         rel = connection.table("intervals")
         res = rel.execute()
-        assert res.description == [('ivals', 'TIMEDELTA', None, None, None, None, None)]
+        assert res.description == [('ivals', 'INTERVAL', None, None, None, None, None)]
         assert res.fetchall() == [
             (datetime.timedelta(days=1.0),),
             (datetime.timedelta(seconds=2.0),),
diff --git a/tests/fast/udf/test_remove_function.py b/tests/fast/udf/test_remove_function.py
@@ -52,7 +52,7 @@ def func(x: int) -> int:
             Error: Catalog Error: Scalar Function with name func does not exist!
         """
         with pytest.raises(
-            duckdb.InvalidInputException, match='Attempting to execute an unsuccessful or closed pending query result'
+            duckdb.CatalogException, match='Scalar Function with name func does not exist!'
         ):
             res = rel.fetchall()
 
@@ -72,7 +72,7 @@ def also_func(x: int) -> int:
             return x
 
         con.create_function('func', also_func)
-        with pytest.raises(duckdb.InvalidInputException, match='No function matches the given name'):
+        with pytest.raises(duckdb.BinderException, match='No function matches the given name'):
             res = rel2.fetchall()
 
     def test_overwrite_name(self):
@@ -98,7 +98,7 @@ def other_func(x):
         con.remove_function('func')
 
         with pytest.raises(
-            duckdb.InvalidInputException, match='Catalog Error: Scalar Function with name func does not exist!'
+            duckdb.CatalogException, match='Catalog Error: Scalar Function with name func does not exist!'
         ):
             # Attempted to execute the relation using the 'func' function, but it was deleted
             rel1.fetchall()

Original file line number	Diff line number	Diff line change
`@@ -465,6 +465,9 @@ shared_ptr<DuckDBPyConnection> DuckDBPyConnection::ExecuteMany(const py::object`
`465`	`465`
`466`	`466`	`unique_ptr<QueryResult> DuckDBPyConnection::CompletePendingQuery(PendingQueryResult &pending_query) {`
`467`	`467`	`PendingExecutionResult execution_result;`
	`468`	`+ if (pending_query.HasError()) {`
	`469`	`+ pending_query.ThrowError();`
	`470`	`+ }`
`468`	`471`	`while (!PendingQueryResult::IsResultReady(execution_result = pending_query.ExecuteTask())) {`
`469`	`472`	`{`
`470`	`473`	`py::gil_scoped_acquire gil;`
Original file line number	Diff line number	Diff line change
`@@ -14,6 +14,6 @@ def test_3728_describe_enum(self, duckdb_cursor):`
`14`	`14`
`15`	`15`	`# This fails with "RuntimeError: Not implemented Error: unsupported type: mood"`
`16`	`16`	`assert cursor.table("person").execute().description == [`
`17`		`- ('name', 'STRING', None, None, None, None, None),`
	`17`	`+ ('name', 'VARCHAR', None, None, None, None, None),`
`18`	`18`	`('current_mood', "ENUM('sad', 'ok', 'happy')", None, None, None, None, None),`
`19`	`19`	`]`