fix the 'description' attribute, using DuckDBPyType

Author: Tishj

duckdb/__init__.py

@@ -18,6 +18,26 @@ def version():
     "functional"
 ])
 
+class DBAPITypeObject:
+    def __init__(self, name, types):
+        self.name = name
+        self.types = list(types)
+
+    def __eq__(self, other):
+        if isinstance(other, typing.DuckDBPyType):
+            return other in self.types
+        return False
+
+    def __repr__(self):
+        return f"<DBAPITypeObject {self.name}>"
+
+# Define the standard DBAPI sentinels
+STRING   = DBAPITypeObject("STRING", {"VARCHAR", "CHAR", "TEXT"})
+NUMBER   = DBAPITypeObject("NUMBER", {"INTEGER", "BIGINT", "DECIMAL", "DOUBLE"})
+DATETIME = DBAPITypeObject("DATETIME", {"DATE", "TIME", "TIMESTAMP"})
+BINARY   = DBAPITypeObject("BINARY", {"BLOB"})
+ROWID    = None
+
 # Classes
 from _duckdb import (
     DuckDBPyRelation,

src/duckdb_py/pyresult.cpp

@@ -579,7 +579,7 @@ py::list DuckDBPyResult::GetDescription(const vector<string> &names, const vecto
 
 	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;

src/duckdb_py/typing/pytype.cpp

@@ -325,8 +325,17 @@ static LogicalType FromObject(const py::object &object) {
 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("__repr__", &DuckDBPyType::ToString, "Stringified representation of the type object")
+        .def("__eq__", [](const DuckDBPyType &self, py::handle other) -> py::object {
+            if (py::isinstance<DuckDBPyType>(other)) {
+                return py::bool_(self.Equals(other.cast<shared_ptr<DuckDBPyType>>()));
+            } 
+            else if (py::isinstance<py::str>(other)) {
+                return py::bool_(self.EqualsString(other.cast<string>()));
+            }
+            // Return NotImplemented for unsupported types
+            return py::reinterpret_borrow<py::object>(Py_NotImplemented);
+        });
 	type_module.def("__eq__", &DuckDBPyType::EqualsString, "Compare two types for equality", py::arg("other"));
 	type_module.def_property_readonly("id", &DuckDBPyType::GetId);
 	type_module.def_property_readonly("children", &DuckDBPyType::Children);

tests/fast/api/test_duckdb_connection.py

@@ -1,4 +1,5 @@
 import duckdb
+import duckdb.typing
 import pytest
 from conftest import NumpyPandas, ArrowPandas
 
@@ -113,9 +114,28 @@ 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_description(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_execute(self):
         assert [([4, 2],)] == duckdb.execute("select [4,2]").fetchall()