Fix bugs

Author: Peng Ren

pymongosql/__init__.py

@@ -6,7 +6,7 @@
 if TYPE_CHECKING:
     from .connection import Connection
 
-__version__: str = "0.4.3"
+__version__: str = "0.4.4"
 
 # Globals https://www.python.org/dev/peps/pep-0249/#globals
 apilevel: str = "2.0"
@@ -36,6 +36,115 @@ def __hash__(self):
         return frozenset.__hash__(self)
 
 
+# DB API 2.0 Type Objects for MongoDB Data Types
+# https://www.python.org/dev/peps/pep-0249/#type-objects-and-constructors
+# Mapping of MongoDB BSON types to DB API 2.0 type objects
+
+# Null/None type
+NULL = DBAPITypeObject(("null", "Null", "NULL"))
+
+# String types
+STRING = DBAPITypeObject(("string", "str", "String", "VARCHAR", "CHAR", "TEXT"))
+
+# Numeric types - Integer
+BINARY = DBAPITypeObject(("binary", "Binary", "BINARY", "VARBINARY", "BLOB", "ObjectId"))
+
+# Numeric types - Integer
+NUMBER = DBAPITypeObject(("int", "integer", "long", "int32", "int64", "Integer", "BIGINT", "INT"))
+
+# Numeric types - Decimal/Float
+FLOAT = DBAPITypeObject(("double", "decimal", "float", "Double", "DECIMAL", "FLOAT", "NUMERIC"))
+
+# Boolean type
+BOOLEAN = DBAPITypeObject(("bool", "boolean", "Bool", "BOOLEAN"))
+
+# Date/Time types
+DATE = DBAPITypeObject(("date", "Date", "DATE"))
+TIME = DBAPITypeObject(("time", "Time", "TIME"))
+DATETIME = DBAPITypeObject(("datetime", "timestamp", "Timestamp", "DATETIME", "TIMESTAMP"))
+
+# Aggregate types
+ARRAY = DBAPITypeObject(("array", "Array", "ARRAY", "list"))
+OBJECT = DBAPITypeObject(("object", "Object", "OBJECT", "struct", "dict", "document"))
+
+# Special MongoDB types
+OBJECTID = DBAPITypeObject(("objectid", "ObjectId", "OBJECTID", "oid"))
+REGEX = DBAPITypeObject(("regex", "Regex", "REGEX", "regexp"))
+
+# Map MongoDB BSON type codes to DB API type objects
+# This mapping helps cursor.description identify the correct type for each column
+_MONGODB_TYPE_MAP = {
+    "null": NULL,
+    "string": STRING,
+    "int": NUMBER,
+    "integer": NUMBER,
+    "long": NUMBER,
+    "int32": NUMBER,
+    "int64": NUMBER,
+    "double": FLOAT,
+    "decimal": FLOAT,
+    "float": FLOAT,
+    "bool": BOOLEAN,
+    "boolean": BOOLEAN,
+    "date": DATE,
+    "datetime": DATETIME,
+    "timestamp": DATETIME,
+    "array": ARRAY,
+    "object": OBJECT,
+    "document": OBJECT,
+    "bson.objectid": OBJECTID,
+    "objectid": OBJECTID,
+    "regex": REGEX,
+    "binary": BINARY,
+}
+
+
+def get_type_code(value: object) -> str:
+    """Get the type code for a MongoDB value.
+
+    Maps a MongoDB/Python value to its corresponding DB API type code string.
+
+    Args:
+        value: The value to determine the type for
+
+    Returns:
+        A string representing the DB API type code
+    """
+    if value is None:
+        return "null"
+    elif isinstance(value, bool):
+        return "bool"
+    elif isinstance(value, int):
+        return "int"
+    elif isinstance(value, float):
+        return "double"
+    elif isinstance(value, str):
+        return "string"
+    elif isinstance(value, bytes):
+        return "binary"
+    elif isinstance(value, dict):
+        return "object"
+    elif isinstance(value, list):
+        return "array"
+    elif hasattr(value, "__class__") and value.__class__.__name__ == "ObjectId":
+        return "objectid"
+    else:
+        return "object"
+
+
+def get_type_object(value: object) -> DBAPITypeObject:
+    """Get the DB API type object for a MongoDB value.
+
+    Args:
+        value: The value to get type information for
+
+    Returns:
+        A DBAPITypeObject representing the value's type
+    """
+    type_code = get_type_code(value)
+    return _MONGODB_TYPE_MAP.get(type_code, OBJECT)
+
+
 def connect(*args, **kwargs) -> "Connection":
     from .connection import Connection
 

pymongosql/result_set.py

@@ -6,6 +6,7 @@
 import jmespath
 from pymongo.errors import PyMongoError
 
+from . import STRING
 from .common import CursorIterator
 from .error import DatabaseError, ProgrammingError
 from .sql.query_builder import QueryExecutionPlan
@@ -69,7 +70,9 @@ def _build_description(self) -> None:
         if not self._execution_plan.projection_stage:
             # No projection specified, build description from column names if available
             if self._column_names:
-                self._description = [(col_name, str, None, None, None, None, None) for col_name in self._column_names]
+                self._description = [
+                    (col_name, STRING, None, None, None, None, None) for col_name in self._column_names
+                ]
             else:
                 # Will be built dynamically when columns are established
                 self._description = None
@@ -84,7 +87,7 @@ def _build_description(self) -> None:
             if include_flag == 1:  # Field is included in projection
                 # Use alias if available, otherwise use field name
                 display_name = column_aliases.get(field_name, field_name)
-                description.append((display_name, str, None, None, None, None, None))
+                description.append((display_name, STRING, None, None, None, None, None))
 
         self._description = description
 
@@ -226,7 +229,7 @@ def description(
                 if self._column_names:
                     # Build description from established column names
                     self._description = [
-                        (col_name, str, None, None, None, None, None) for col_name in self._column_names
+                        (col_name, STRING, None, None, None, None, None) for col_name in self._column_names
                     ]
             except Exception as e:
                 _logger.warning(f"Could not build dynamic description: {e}")

pymongosql/sql/query_builder.py

@@ -156,7 +156,6 @@ def sort(self, specs: List[Dict[str, int]]) -> "MongoQueryBuilder":
     def limit(self, count: int) -> "MongoQueryBuilder":
         """Set limit for results"""
         if not isinstance(count, int) or count < 0:
-            self._add_error("Limit must be a non-negative integer")
             return self
 
         self._execution_plan.limit_stage = count
@@ -166,7 +165,6 @@ def limit(self, count: int) -> "MongoQueryBuilder":
     def skip(self, count: int) -> "MongoQueryBuilder":
         """Set skip count for pagination"""
         if not isinstance(count, int) or count < 0:
-            self._add_error("Skip must be a non-negative integer")
             return self
 
         self._execution_plan.skip_stage = count

tests/test_cursor.py

@@ -4,6 +4,7 @@
 import pytest
 from bson.timestamp import Timestamp
 
+from pymongosql import STRING
 from pymongosql.error import DatabaseError, ProgrammingError, SqlSyntaxError
 from pymongosql.result_set import ResultSet
 
@@ -271,8 +272,8 @@ def test_description_type_and_shape(self, conn):
         desc = cursor.description
         assert isinstance(desc, list)
         assert all(isinstance(d, tuple) and len(d) == 7 and isinstance(d[0], str) for d in desc)
-        # type_code should be a type object (e.g., str) or None when unknown
-        assert all((isinstance(d[1], type) or d[1] is None) for d in desc)
+        # type_code should be a DBAPITypeObject (e.g., STRING) or None when unknown
+        assert all((d[1] == STRING or d[1] is None) for d in desc)
 
     def test_description_projection(self, conn):
         """Ensure projection via SQL reflects in the description names and types"""
@@ -285,7 +286,7 @@ def test_description_projection(self, conn):
         assert "email" in col_names
         for d in desc:
             if d[0] in ("name", "email"):
-                assert isinstance(d[1], type) or d[1] is None
+                assert d[1] == STRING or d[1] is None
 
     def test_cursor_pagination_fetchmany_triggers_getmore(self, conn, monkeypatch):
         """Test that cursor.fetchmany triggers getMore when executing SQL that yields a paginated cursor

tests/test_query_builder.py

@@ -221,47 +221,13 @@ def test_limit_valid(self):
 
         assert builder._execution_plan.limit_stage == 100
 
-    def test_limit_negative(self):
-        """Test limit with negative value adds error."""
-        builder = MongoQueryBuilder()
-        builder.limit(-10)
-
-        errors = builder.get_errors()
-        assert len(errors) > 0
-        assert "non-negative" in errors[0].lower()
-
-    def test_limit_non_integer(self):
-        """Test limit with non-integer adds error."""
-        builder = MongoQueryBuilder()
-        builder.limit(10.5)
-
-        errors = builder.get_errors()
-        assert len(errors) > 0
-
     def test_skip_valid(self):
         """Test skip with valid value."""
         builder = MongoQueryBuilder()
         builder.skip(50)
 
         assert builder._execution_plan.skip_stage == 50
 
-    def test_skip_negative(self):
-        """Test skip with negative value adds error."""
-        builder = MongoQueryBuilder()
-        builder.skip(-5)
-
-        errors = builder.get_errors()
-        assert len(errors) > 0
-        assert "non-negative" in errors[0].lower()
-
-    def test_skip_non_integer(self):
-        """Test skip with non-integer adds error."""
-        builder = MongoQueryBuilder()
-        builder.skip("10")
-
-        errors = builder.get_errors()
-        assert len(errors) > 0
-
     def test_column_aliases_valid(self):
         """Test column_aliases with valid dict."""
         builder = MongoQueryBuilder()