Fix something

Author: Peng Ren

.coveragerc

@@ -40,7 +40,7 @@ jobs:
       uses: actions/cache@v3
       with:
         path: ~/.cache/pip
-        key: ${{ runner.os }}-py${{ matrix.python-version }}-mongo${{ matrix.mongodb-version }}-pip-${{ hashFiles('**/requirements-test.txt') }}
+        key: ${{ runner.os }}-py${{ matrix.python-version }}-mongo${{ matrix.mongodb-version }}-pip-${{ hashFiles('**/requirements-test.txt', 'pyproject.toml') }}
         restore-keys: |
           ${{ runner.os }}-py${{ matrix.python-version }}-mongo${{ matrix.mongodb-version }}-pip-
 
@@ -83,7 +83,7 @@ jobs:
 
     - name: Run tests with coverage
       run: |
-        python -m pytest tests/ --cov=pymongosql --cov-report=term-missing --cov-report=xml --cov-config=.coveragerc
+        python -m pytest tests/ --cov=pymongosql --cov-report=term-missing --cov-report=xml
 
     - name: Upload coverage reports
       uses: codecov/codecov-action@v4

.flake8

@@ -41,9 +41,7 @@ def execute(
         raise NotImplementedError  # pragma: no cover
 
     @abstractmethod
-    def executemany(
-        self, operation: str, seq_of_parameters: List[Optional[Dict[str, Any]]]
-    ) -> None:
+    def executemany(self, operation: str, seq_of_parameters: List[Optional[Dict[str, Any]]]) -> None:
         raise NotImplementedError  # pragma: no cover
 
     @abstractmethod
@@ -82,9 +80,7 @@ def arraysize(self, value: int) -> None:
         if value <= 0:
             raise ValueError("arraysize must be positive")
         if value > self.DEFAULT_FETCH_SIZE:
-            raise ProgrammingError(
-                f"MaxResults is more than maximum allowed length {self.DEFAULT_FETCH_SIZE}."
-            )
+            raise ProgrammingError(f"MaxResults is more than maximum allowed length {self.DEFAULT_FETCH_SIZE}.")
         self._arraysize = value
 
     @property

.github/workflows/ci.yml

@@ -74,9 +74,7 @@ def _connect(self) -> None:
         try:
             # Build connection string
             if self._username and self._password:
-                auth_string = (
-                    f"{quote_plus(self._username)}:{quote_plus(self._password)}@"
-                )
+                auth_string = f"{quote_plus(self._username)}:{quote_plus(self._password)}@"
             else:
                 auth_string = ""
 
@@ -107,9 +105,7 @@ def _connect(self) -> None:
             if self._database_name:
                 self._database = self._client[self._database_name]
 
-            _logger.info(
-                f"Successfully connected to MongoDB at {self._host}:{self._port}"
-            )
+            _logger.info(f"Successfully connected to MongoDB at {self._host}:{self._port}")
 
         except ConnectionFailure as e:
             _logger.error(f"Failed to connect to MongoDB: {e}")
@@ -258,9 +254,7 @@ def commit(self) -> None:
         self._autocommit = True
 
     def rollback(self) -> None:
-        raise NotSupportedError(
-            "MongoDB doesn't support rollback in the traditional SQL sense"
-        )
+        raise NotSupportedError("MongoDB doesn't support rollback in the traditional SQL sense")
 
     def test_connection(self) -> bool:
         """Test if the connection is alive"""

pymongosql/common.py

@@ -111,23 +111,17 @@ def _execute_query_plan(self, query_plan: QueryPlan) -> None:
             find_projection = None
             if query_plan.projection_stage:
                 # Convert {"field": "alias"} to {"field": 1} for MongoDB
-                find_projection = {
-                    field: 1 for field in query_plan.projection_stage.keys()
-                }
+                find_projection = {field: 1 for field in query_plan.projection_stage.keys()}
 
-            _logger.debug(
-                f"Executing MongoDB query: filter={find_filter}, projection={find_projection}"
-            )
+            _logger.debug(f"Executing MongoDB query: filter={find_filter}, projection={find_projection}")
 
             # Execute find query
             self._mongo_cursor = collection.find(find_filter, find_projection)
 
             # Apply sort if specified
             if query_plan.sort_stage:
                 sort_spec = [
-                    (field, direction)
-                    for sort_dict in query_plan.sort_stage
-                    for field, direction in sort_dict.items()
+                    (field, direction) for sort_dict in query_plan.sort_stage for field, direction in sort_dict.items()
                 ]
                 self._mongo_cursor = self._mongo_cursor.sort(sort_spec)
 
@@ -144,9 +138,7 @@ def _execute_query_plan(self, query_plan: QueryPlan) -> None:
                 mongo_cursor=self._mongo_cursor, query_plan=query_plan, **self._kwargs
             )
 
-            _logger.info(
-                f"Query executed successfully on collection '{query_plan.collection}'"
-            )
+            _logger.info(f"Query executed successfully on collection '{query_plan.collection}'")
 
         except PyMongoError as e:
             _logger.error(f"MongoDB query execution failed: {e}")
@@ -155,9 +147,7 @@ def _execute_query_plan(self, query_plan: QueryPlan) -> None:
             _logger.error(f"Unexpected error during query execution: {e}")
             raise OperationalError(f"Query execution error: {e}")
 
-    def execute(
-        self: _T, operation: str, parameters: Optional[Dict[str, Any]] = None
-    ) -> _T:
+    def execute(self: _T, operation: str, parameters: Optional[Dict[str, Any]] = None) -> _T:
         """Execute a SQL statement
 
         Args:
@@ -170,9 +160,7 @@ def execute(
         self._check_closed()
 
         if parameters:
-            _logger.warning(
-                "Parameter substitution not yet implemented, ignoring parameters"
-            )
+            _logger.warning("Parameter substitution not yet implemented, ignoring parameters")
 
         try:
             # Parse SQL to QueryPlan
@@ -202,9 +190,7 @@ def executemany(
         self._check_closed()
 
         # For now, just execute once and ignore parameters
-        _logger.warning(
-            "executemany not fully implemented, executing once without parameters"
-        )
+        _logger.warning("executemany not fully implemented, executing once without parameters")
         self.execute(operation)
 
     def execute_transaction(self) -> None:

pymongosql/connection.py

@@ -29,9 +29,7 @@ def __init__(
         self._cached_results: List[Dict[str, Any]] = []
         self._cache_exhausted = False
         self._total_fetched = 0
-        self._description: Optional[
-            List[Tuple[str, str, None, None, None, None, None]]
-        ] = None
+        self._description: Optional[List[Tuple[str, str, None, None, None, None, None]]] = None
         self._errors: List[Dict[str, str]] = []
 
         # Build description from projection
@@ -125,8 +123,7 @@ def description(
                     # Build description from first result
                     first_result = self._cached_results[0]
                     self._description = [
-                        (col_name, "VARCHAR", None, None, None, None, None)
-                        for col_name in first_result.keys()
+                        (col_name, "VARCHAR", None, None, None, None, None) for col_name in first_result.keys()
                     ]
             except Exception as e:
                 _logger.warning(f"Could not build dynamic description: {e}")
@@ -187,9 +184,7 @@ def fetchall(self) -> List[Dict[str, Any]]:
                 remaining_docs = list(self._mongo_cursor)
                 if remaining_docs:
                     # Process results through projection mapping
-                    processed_docs = [
-                        self._process_document(doc) for doc in remaining_docs
-                    ]
+                    processed_docs = [self._process_document(doc) for doc in remaining_docs]
                     all_results.extend(processed_docs)
                     self._total_fetched += len(remaining_docs)
 

pymongosql/cursor.py

@@ -101,9 +101,7 @@ def visitFromClause(self, ctx: PartiQLParser.FromClauseContext) -> Any:
             _logger.warning(f"Error processing FROM clause: {e}")
             return self.visitChildren(ctx)
 
-    def visitWhereClauseSelect(
-        self, ctx: PartiQLParser.WhereClauseSelectContext
-    ) -> Any:
+    def visitWhereClauseSelect(self, ctx: PartiQLParser.WhereClauseSelectContext) -> Any:
         """Handle WHERE clause for filtering"""
         _logger.debug("Processing WHERE clause")
         try:

pymongosql/result_set.py

@@ -38,14 +38,10 @@ def validate(self) -> bool:
         if not self.collection:
             errors.append("Collection name is required")
 
-        if self.limit_stage is not None and (
-            not isinstance(self.limit_stage, int) or self.limit_stage < 0
-        ):
+        if self.limit_stage is not None and (not isinstance(self.limit_stage, int) or self.limit_stage < 0):
             errors.append("Limit must be a non-negative integer")
 
-        if self.skip_stage is not None and (
-            not isinstance(self.skip_stage, int) or self.skip_stage < 0
-        ):
+        if self.skip_stage is not None and (not isinstance(self.skip_stage, int) or self.skip_stage < 0):
             errors.append("Skip must be a non-negative integer")
 
         if errors:
@@ -153,9 +149,7 @@ def where_in(self, field: str, values: List[Any]) -> "MongoQueryBuilder":
         """Add a WHERE field IN (values) condition"""
         return self.filter({field: {"$in": values}})
 
-    def where_between(
-        self, field: str, min_val: Any, max_val: Any
-    ) -> "MongoQueryBuilder":
+    def where_between(self, field: str, min_val: Any, max_val: Any) -> "MongoQueryBuilder":
         """Add a WHERE field BETWEEN min AND max condition"""
         return self.filter({field: {"$gte": min_val, "$lte": max_val}})
 
@@ -165,9 +159,7 @@ def where_like(self, field: str, pattern: str) -> "MongoQueryBuilder":
         regex_pattern = pattern.replace("%", ".*").replace("_", ".")
         return self.filter({field: {"$regex": regex_pattern, "$options": "i"}})
 
-    def _build_condition(
-        self, field: str, operator: str, value: Any
-    ) -> Optional[Dict[str, Any]]:
+    def _build_condition(self, field: str, operator: str, value: Any) -> Optional[Dict[str, Any]]:
         """Build a MongoDB condition from field, operator, and value"""
         operator_map = {
             "=": "$eq",