iris-pgwire 1.5.0__tar.gz → 1.5.2__tar.gz

{iris_pgwire-1.5.0 → iris_pgwire-1.5.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: iris-pgwire
-Version: 1.5.0
+Version: 1.5.2
 Summary: PostgreSQL Wire Protocol Server for InterSystems IRIS - Connect BI tools, Python frameworks, and PostgreSQL clients to IRIS databases
 Project-URL: Homepage, https://github.com/intersystems-community/iris-pgwire
 Project-URL: Documentation, https://github.com/intersystems-community/iris-pgwire#readme

{iris_pgwire-1.5.0 → iris_pgwire-1.5.2}/src/iris_pgwire/__init__.py

@@ -6,7 +6,7 @@ Based on the specification from docs/iris_pgwire_plan.md and proven patterns fro
 caretdev/sqlalchemy-iris.
 """
 
-__version__ = "1.5.0"
+__version__ = "1.5.2"
 __author__ = "Thomas Dyar <thomas.dyar@intersystems.com>"
 
 # Don't import server/protocol in __init__ to avoid sys.modules conflicts

{iris_pgwire-1.5.0 → iris_pgwire-1.5.2}/src/iris_pgwire/backend_selector.py

@@ -265,6 +265,7 @@ class BackendSelector:
             connection_pool_size=config.pool_size,
             connection_pool_timeout=float(config.pool_timeout),
             strict_single_connection=config.strict_single_connection,
+            query_timeout=config.query_timeout,
         )
         # backend_type is now set in IRISExecutor.__init__
         logger.info(

{iris_pgwire-1.5.0 → iris_pgwire-1.5.2}/src/iris_pgwire/bulk_executor.py

@@ -71,10 +71,23 @@ class BulkExecutor:
         total_rows = 0
         batch = []
         actual_column_names = column_names
+        # Lazily resolved from schema when CSV has no header and no column list
+        schema_columns: list[str] | None = None
 
         async for row_dict in rows:
-            # Determine column names from first row if not specified
-            if actual_column_names is None:
+            # When column_names is None and the CSV has no header, the CSV processor
+            # generates placeholder keys (column_0, column_1, …). Detect this on
+            # the first row, fetch real column names from IRIS schema, and re-map.
+            first_key = next(iter(row_dict), None)
+            if first_key is not None and first_key.startswith("column_"):
+                if schema_columns is None:
+                    schema_columns = await self.get_table_columns(table_name)
+                    logger.debug(f"Columns fetched from schema for {table_name}: {schema_columns}")
+                if schema_columns:
+                    actual_column_names = schema_columns
+                    values = list(row_dict.values())
+                    row_dict = dict(zip(schema_columns, values))
+            elif actual_column_names is None:
                 actual_column_names = list(row_dict.keys())
                 logger.debug(f"Columns inferred from data: {actual_column_names}")
 
@@ -321,25 +334,29 @@ class BulkExecutor:
         """
         Get column names for a table using INFORMATION_SCHEMA.
 
+        Bypasses the catalog router (which intercepts INFORMATION_SCHEMA queries
+        for pg_catalog emulation) by calling _execute_external_async directly.
+
         Args:
             table_name: Table name
 
         Returns:
-            List of column names
+            List of column names in ordinal order
 
         Raises:
             Exception: IRIS query error
         """
-        query = f"""
-            SELECT column_name
-            FROM INFORMATION_SCHEMA.COLUMNS
-            WHERE LOWER(table_name) = LOWER('{table_name}')
-            ORDER BY ordinal_position
-        """
+        query = (
+            "SELECT COLUMN_NAME FROM INFORMATION_SCHEMA.COLUMNS "
+            f"WHERE LOWER(TABLE_NAME) = LOWER('{table_name}') "
+            "ORDER BY ORDINAL_POSITION"
+        )
 
-        result = await self.iris_executor.execute_query(query, [])
+        # Bypass iris_executor.execute_query (which routes through the catalog
+        # router and returns empty rows for INFORMATION_SCHEMA queries) by
+        # calling the external execution path directly.
+        result = await self.iris_executor._execute_external_async(query, [])
 
-        # Extract column names from result
         columns = []
         if result and "rows" in result:
             columns = [row[0] for row in result["rows"]]

{iris_pgwire-1.5.0 → iris_pgwire-1.5.2}/src/iris_pgwire/dbapi_executor.py

@@ -202,7 +202,25 @@ class DBAPIExecutor:
                     conn_wrapper.connection, plan, converted_params, session_id, original_sql
                 )
 
-            rows, columns, row_count = await asyncio.to_thread(execute_in_thread)
+            query_timeout = getattr(self.config, "query_timeout", 30.0)
+            try:
+                rows, columns, row_count = await asyncio.wait_for(
+                    asyncio.to_thread(execute_in_thread), timeout=query_timeout
+                )
+            except TimeoutError:
+                logger.error(
+                    "Query timed out — evicting connection from pool",
+                    sql_preview=sql[:120],
+                    timeout_seconds=query_timeout,
+                    session_id=session_id,
+                )
+                # Mark connection unhealthy so it gets evicted, not recycled
+                if conn_wrapper:
+                    conn_wrapper.is_healthy = False
+                raise RuntimeError(
+                    f"Query execution timed out after {query_timeout}s. "
+                    "The IRIS connection is being evicted to prevent pool exhaustion."
+                )
 
             tx_sql_upper = original_sql.strip().upper()
             self._update_transaction_state(session_id, tx_sql_upper)
@@ -1044,7 +1062,10 @@ class DBAPIExecutor:
         for i, col in enumerate(columns):
             if col in ("id", "uuid", "_id"):
                 if params and len(params) > i:
-                    return col, params[i]
+                    # Return UPPERCASE so the WHERE clause matches IRIS's stored column name.
+                    # IRIS stores unquoted column names as uppercase; using "id" (lowercase)
+                    # in a quoted identifier fails silently and returns 0 rows.
+                    return col.upper(), params[i]
                 return None, None
 
         return None, None

{iris_pgwire-1.5.0 → iris_pgwire-1.5.2}/src/iris_pgwire/iris_executor.py

@@ -100,6 +100,7 @@ class IRISExecutor:
         enable_query_cache: bool = True,
         query_cache_size: int = 1000,
         strict_single_connection: bool = False,
+        query_timeout: float = 30.0,
     ):
         self.iris_config = iris_config
         self.server = server  # Reference to server for P4 cancellation
@@ -108,6 +109,7 @@ class IRISExecutor:
         self.enable_query_cache = enable_query_cache
         self.query_cache_size = query_cache_size
         self.strict_single_connection = strict_single_connection
+        self.query_timeout = query_timeout
 
         self.connection = None
         self.session_connections = {}
@@ -1763,7 +1765,10 @@ class IRISExecutor:
         for i, col in enumerate(columns):
             if col in id_col_names:
                 id_col_idx = i
-                id_col_name = col
+                # Return UPPERCASE so the WHERE clause matches IRIS's stored column name.
+                # IRIS stores unquoted column names as uppercase; using "id" (lowercase)
+                # in a quoted identifier fails silently and returns 0 rows.
+                id_col_name = col.upper()
                 break
 
         if id_col_idx is None:
@@ -2884,6 +2889,12 @@ class IRISExecutor:
         Execute SQL using external IRIS connection with proper async threading
         """
 
+        import threading
+
+        # Shared flag: asyncio side sets this True when wait_for times out so the
+        # sync thread knows to close (evict) the connection instead of recycling it.
+        timed_out = threading.Event()
+
         def _sync_external_execute(captured_sql, captured_params, captured_session_id):
             """Synchronous external IRIS execution in thread pool"""
             sql = captured_sql
@@ -3103,13 +3114,40 @@ class IRISExecutor:
                     except Exception:
                         pass
                 if conn:
-                    self._return_connection(conn, session_id=session_id)
+                    if timed_out.is_set():
+                        # Evict — don't return a lock-held connection to the pool
+                        try:
+                            conn.close()
+                        except Exception:
+                            pass
+                        logger.warning(
+                            "Evicted timed-out IRIS connection from pool",
+                            session_id=session_id,
+                        )
+                    else:
+                        self._return_connection(conn, session_id=session_id)
 
-        # Execute in thread pool to avoid blocking event loop
+        # Execute in thread pool to avoid blocking event loop.
+        # Wrap with a per-query timeout to prevent lock-wait cascades from
+        # exhausting the connection pool (PGWIRE_QUERY_TIMEOUT, default 30s).
         loop = asyncio.get_event_loop()
-        return await loop.run_in_executor(
+        future = loop.run_in_executor(
             self._get_executor(session_id), _sync_external_execute, sql, params, session_id
         )
+        try:
+            return await asyncio.wait_for(future, timeout=self.query_timeout)
+        except TimeoutError:
+            timed_out.set()  # Signal the sync thread to evict the connection
+            logger.error(
+                "Query timed out — connection will be evicted from pool",
+                sql_preview=sql[:120],
+                timeout_seconds=self.query_timeout,
+                session_id=session_id,
+            )
+            raise RuntimeError(
+                f"Query execution timed out after {self.query_timeout}s. "
+                "The IRIS connection is being evicted to prevent pool exhaustion."
+            )
 
     def _get_iris_connection(self):
         """

{iris_pgwire-1.5.0 → iris_pgwire-1.5.2}/src/iris_pgwire/models/backend_config.py

@@ -80,6 +80,18 @@ class BackendConfig(BaseModel):
         description="Connection lifetime in seconds (1 hour default)",
     )
 
+    # Per-query execution timeout (separate from pool wait timeout)
+    query_timeout: float = Field(
+        default=30.0,
+        ge=1.0,
+        le=600.0,
+        description=(
+            "Maximum seconds a single query may execute before being cancelled. "
+            "Prevents lock-wait cascades from exhausting the connection pool. "
+            "Set via PGWIRE_QUERY_TIMEOUT env var."
+        ),
+    )
+
     # Protocol Behavior
     strict_single_connection: bool = Field(
         default=False,
@@ -205,6 +217,7 @@ class BackendConfig(BaseModel):
             ("PGWIRE_POOL_MAX_OVERFLOW", "pool_max_overflow", int),
             ("PGWIRE_POOL_TIMEOUT", "pool_timeout", int),
             ("PGWIRE_POOL_RECYCLE", "pool_recycle", int),
+            ("PGWIRE_QUERY_TIMEOUT", "query_timeout", float),
             # Observability
             ("PGWIRE_ENABLE_OTEL", "enable_otel", _as_bool),
             ("PGWIRE_OTEL_ENDPOINT", "otel_endpoint", None),

{iris_pgwire-1.5.0 → iris_pgwire-1.5.2}/src/iris_pgwire/server.py

@@ -75,6 +75,7 @@ class PGWireServer:
         enable_scram: bool = False,
         connection_pool_size: int = 10,
         connection_pool_timeout: float = 5.0,
+        query_timeout: float = 30.0,
         enable_query_cache: bool = True,
         query_cache_size: int = 1000,
         backend_type: str | None = None,
@@ -122,6 +123,7 @@ class PGWireServer:
             iris_namespace=iris_namespace,
             pool_size=connection_pool_size,
             pool_timeout=int(connection_pool_timeout),
+            query_timeout=query_timeout,
             strict_single_connection=strict_single_connection,
         )
 
@@ -300,6 +302,7 @@ def _gather_main_config() -> dict[str, Any]:
         "ssl_key_path": os.getenv("PGWIRE_SSL_KEY"),
         "connection_pool_size": int(os.getenv("PGWIRE_POOL_SIZE", "10")),
         "connection_pool_timeout": float(os.getenv("PGWIRE_POOL_TIMEOUT", "5.0")),
+        "query_timeout": float(os.getenv("PGWIRE_QUERY_TIMEOUT", "30.0")),
         "enable_query_cache": os.getenv("PGWIRE_QUERY_CACHE_ENABLED", "true").lower() == "true",
         "query_cache_size": int(os.getenv("PGWIRE_QUERY_CACHE_SIZE", "1000")),
         "debug": os.getenv("PGWIRE_DEBUG", "false").lower() == "true",
@@ -327,6 +330,7 @@ async def main():
         ssl_key_path=config["ssl_key_path"],
         connection_pool_size=config["connection_pool_size"],
         connection_pool_timeout=config["connection_pool_timeout"],
+        query_timeout=config["query_timeout"],
         enable_query_cache=config["enable_query_cache"],
         query_cache_size=config["query_cache_size"],
     )