add connection and dbapi tests

Author: Eugene Shershen

psqlpy_sqlalchemy/connection.py

@@ -84,10 +84,6 @@ async def _prepare_execute(
 
             if casting_matches:
                 # This is a known limitation: SQLAlchemy can't handle named parameters with explicit PostgreSQL casting
-                import logging
-
-                logging.getLogger(__name__)
-
                 raise RuntimeError(
                     f"Named parameters with explicit PostgreSQL casting are not supported. "
                     f"Found casting parameters: {casting_matches} in query: {converted_query[:100]}... "
@@ -199,18 +195,7 @@ def _convert_named_params_with_casting(
 
         And converts the parameters dict to a list in the correct order.
         """
-        # Add debugging logging for CI troubleshooting
-        import logging
-
-        logger = logging.getLogger(__name__)
-
-        logger.debug(
-            f"Parameter conversion called - Query: {querystring!r}, "
-            f"Parameters: {parameters!r}, Parameters type: {type(parameters)}"
-        )
-
         if parameters is None or not isinstance(parameters, dict):
-            logger.debug("Parameters is None or not dict, returning as-is")
             return querystring, parameters
 
         import re
@@ -222,14 +207,7 @@ def _convert_named_params_with_casting(
         # Find all parameter references in the query
         matches = list(re.finditer(param_pattern, querystring))
 
-        logger.debug(f"Found {len(matches)} parameter matches in query")
-        for i, match in enumerate(matches):
-            logger.debug(
-                f"  Match {i + 1}: '{match.group(0)}' -> param='{match.group(1)}', cast='{match.group(2)}'"
-            )
-
         if not matches:
-            logger.debug("No parameter matches found, returning as-is")
             return querystring, parameters
 
         # Build the conversion mapping and new parameter list
@@ -249,28 +227,8 @@ def _convert_named_params_with_casting(
 
         # Defensive check: ensure all parameters found in query are available
         if missing_params:
-            # Enhanced error message with more debugging information
-            available_params = list(parameters.keys()) if parameters else []
-            found_params = [m.group(1) for m in matches]
-
-            # Log additional debugging information for CI troubleshooting
-            import logging
-
-            logger = logging.getLogger(__name__)
-            logger.error(
-                f"Parameter conversion error - Missing parameters: {missing_params}. "
-                f"Query: {querystring!r}. "
-                f"Found in query: {found_params}. "
-                f"Available in dict: {available_params}. "
-                f"Parameters dict: {parameters!r}"
-            )
-
             # Instead of raising an error, return the original query and parameters
             # This prevents partial conversion which can cause SQL syntax errors
-            logger.warning(
-                "Returning original query due to missing parameters. "
-                "This may indicate a parameter processing issue."
-            )
             return querystring, parameters
 
         # Convert the query string by replacing each parameter with its positional equivalent
@@ -334,16 +292,6 @@ def _convert_named_params_with_casting(
                 f"Converted query: {converted_query}, Original query: {querystring}"
             )
 
-        # Log final conversion results for debugging
-        logger.debug(
-            f"Parameter conversion completed - "
-            f"Original query: {querystring!r}, "
-            f"Converted query: {converted_query!r}, "
-            f"Original params: {parameters!r}, "
-            f"Converted params: {converted_params!r}, "
-            f"Parameter order: {param_order}"
-        )
-
         return converted_query, converted_params
 
     @property
@@ -481,7 +429,6 @@ def fetchall(self):
             return []
 
     def __iter__(self):
-        """Enhanced async iteration with better error handling"""
         if self._closed or self._cursor is None:
             return
 
@@ -490,15 +437,10 @@ def __iter__(self):
             try:
                 result = self.await_(iterator.__anext__())
                 rows = self._convert_result(result=result)
-                if rows:
-                    yield from rows
-                else:
-                    break
+                # Yield individual rows, not the entire result
+                yield from rows
             except StopAsyncIteration:
                 break
-            except Exception:
-                # Stop iteration on any error
-                break
 
 
 class AsyncAdapt_psqlpy_connection(AsyncAdapt_dbapi_connection):

psqlpy_sqlalchemy/dbapi.py

@@ -12,16 +12,18 @@ def __init__(self, psqlpy) -> None:
         self.apilevel = "2.0"
         self.threadsafety = 2  # Threads may share the module and connections
 
-        self.Warning = psqlpy.Error
-        self.Error = psqlpy.Error
-        self.InterfaceError = psqlpy.Error
-        self.DatabaseError = psqlpy.Error
-        self.DataError = psqlpy.Error
-        self.OperationalError = psqlpy.Error
-        self.IntegrityError = psqlpy.Error
-        self.InternalError = psqlpy.Error
-        self.ProgrammingError = psqlpy.Error
-        self.NotSupportedError = psqlpy.Error
+        # Single reusable exception class for all error types
+        _error_class = psqlpy.Error
+        self.Warning = _error_class
+        self.Error = _error_class
+        self.InterfaceError = _error_class
+        self.DatabaseError = _error_class
+        self.DataError = _error_class
+        self.OperationalError = _error_class
+        self.IntegrityError = _error_class
+        self.InternalError = _error_class
+        self.ProgrammingError = _error_class
+        self.NotSupportedError = _error_class
 
         for k, v in self.psqlpy.__dict__.items():
             if k != "connect":
@@ -39,34 +41,36 @@ def connect(self, *arg, **kw):
             # Add other server_settings mappings as needed
 
         # Filter out any other unsupported parameters that SQLAlchemy might pass
-        supported_params = {
-            "dsn",
-            "username",
-            "password",
-            "host",
-            "hosts",
-            "port",
-            "ports",
-            "db_name",
-            "target_session_attrs",
-            "options",
-            "application_name",
-            "connect_timeout_sec",
-            "connect_timeout_nanosec",
-            "tcp_user_timeout_sec",
-            "tcp_user_timeout_nanosec",
-            "keepalives",
-            "keepalives_idle_sec",
-            "keepalives_idle_nanosec",
-            "keepalives_interval_sec",
-            "keepalives_interval_nanosec",
-            "keepalives_retries",
-            "load_balance_hosts",
-            "max_db_pool_size",
-            "conn_recycling_method",
-            "ssl_mode",
-            "ca_file",
-        }
+        supported_params = frozenset(
+            {
+                "dsn",
+                "username",
+                "password",
+                "host",
+                "hosts",
+                "port",
+                "ports",
+                "db_name",
+                "target_session_attrs",
+                "options",
+                "application_name",
+                "connect_timeout_sec",
+                "connect_timeout_nanosec",
+                "tcp_user_timeout_sec",
+                "tcp_user_timeout_nanosec",
+                "keepalives",
+                "keepalives_idle_sec",
+                "keepalives_idle_nanosec",
+                "keepalives_interval_sec",
+                "keepalives_interval_nanosec",
+                "keepalives_retries",
+                "load_balance_hosts",
+                "max_db_pool_size",
+                "conn_recycling_method",
+                "ssl_mode",
+                "ca_file",
+            }
+        )
 
         filtered_kw = {k: v for k, v in kw.items() if k in supported_params}
 
@@ -90,17 +94,18 @@ def __init__(self):
 
         self._adapt_dbapi = PSQLPyAdaptDBAPI(psqlpy)
 
-        # Copy attributes from psqlpy for compatibility
-        self.Warning = psqlpy.Error
-        self.Error = psqlpy.Error
-        self.InterfaceError = psqlpy.Error
-        self.DatabaseError = psqlpy.Error
-        self.DataError = psqlpy.Error
-        self.OperationalError = psqlpy.Error
-        self.IntegrityError = psqlpy.Error
-        self.InternalError = psqlpy.Error
-        self.ProgrammingError = psqlpy.Error
-        self.NotSupportedError = psqlpy.Error
+        # Single reusable exception class for all error types
+        _error_class = psqlpy.Error
+        self.Warning = _error_class
+        self.Error = _error_class
+        self.InterfaceError = _error_class
+        self.DatabaseError = _error_class
+        self.DataError = _error_class
+        self.OperationalError = _error_class
+        self.IntegrityError = _error_class
+        self.InternalError = _error_class
+        self.ProgrammingError = _error_class
+        self.NotSupportedError = _error_class
 
     # Type constructors
     def Date(self, year, month, day):

pyproject.toml

@@ -39,7 +39,7 @@ dev = [
     "greenlet>=1.0.0",
     "ruff>=0.1.0",
     "mypy>=1.0.0",
-    "sqlmodel>=0.0.8",
+    "sqlmodel>=0.0.14",
     "pytest-cov",
     "fastapi>=0.68.0",
     "starlette>=0.14.0",