iris-pgwire 1.2.31__tar.gz → 1.2.33__tar.gz

{iris_pgwire-1.2.31 → iris_pgwire-1.2.33}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: iris-pgwire
-Version: 1.2.31
+Version: 1.2.33
 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.2.31 → iris_pgwire-1.2.33}/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.2.31"
+__version__ = "1.2.33"
 __author__ = "Thomas Dyar <thomas.dyar@intersystems.com>"
 
 # Don't import server/protocol in __init__ to avoid sys.modules conflicts

{iris_pgwire-1.2.31 → iris_pgwire-1.2.33}/src/iris_pgwire/dbapi_connection_pool.py

@@ -339,9 +339,9 @@ class IRISConnectionPool:
             self._total_created += 1
 
             logger.info(
-                "Removing idle overflow connection",
+                "Created new IRIS connection",
                 connection_id=conn_wrapper.connection_id,
-                idle_seconds=round(conn_wrapper.idle_seconds, 1),
+                idle_seconds=round(getattr(conn_wrapper, "idle_seconds", 0.0), 1),
             )
 
             return conn_wrapper

{iris_pgwire-1.2.31 → iris_pgwire-1.2.33}/src/iris_pgwire/dbapi_executor.py

@@ -87,6 +87,35 @@ class DBAPIExecutor:
         """
         return re.sub(r"\$\d+", "?", sql)
 
+    def _convert_params_for_iris(self, params: Any) -> Any:
+        """
+        Convert parameters to IRIS-compatible formats.
+        Specifically handles ISO 8601 timestamps.
+        """
+        if params is None:
+            return None
+
+        if isinstance(params, (list, tuple)):
+            return [self._convert_value_for_iris(v) for v in params]
+
+        return self._convert_value_for_iris(params)
+
+    def _convert_value_for_iris(self, value: Any) -> Any:
+        """Helper to convert a single value."""
+        if isinstance(value, str):
+            # FR-004: Normalize ISO 8601 timestamp strings for IRIS
+            # Handles: YYYY-MM-DD[T ]HH:MM:SS[.fff][Z|[+-]HH:MM]
+            # IRIS rejects the 'T' and 'Z' or offset in %PosixTime/TIMESTAMP
+            import re
+
+            ts_match = re.match(
+                r"^(\d{4}-\d{2}-\d{2})[T ](\d{2}:\d{2}:\d{2}(?:\.\d+)?)(?:Z|[+-]\d{2}:?(\d{2})?)?$",
+                value,
+            )
+            if ts_match:
+                return f"{ts_match.group(1)} {ts_match.group(2)}"
+        return value
+
     async def execute_query(
         self, sql: str, params: tuple | None = None, session_id: str | None = None, **kwargs
     ) -> dict[str, Any]:
@@ -116,6 +145,9 @@ class DBAPIExecutor:
             # Translate placeholders ($1 -> ?)
             sql = self._translate_placeholders(sql)
 
+            # Convert parameters for IRIS (e.g., ISO 8601 timestamps)
+            converted_params = self._convert_params_for_iris(params)
+
             # Acquire connection from pool
             conn_wrapper = await self.pool.acquire()
 
@@ -134,8 +166,8 @@ class DBAPIExecutor:
                         # For now, we log it.
                         logger.debug(f"Session {session_id} using namespace {ns}")
 
-                    if params:
-                        cursor.execute(clean_sql, params)
+                    if converted_params:
+                        cursor.execute(clean_sql, converted_params)
                     else:
                         cursor.execute(clean_sql)
 
@@ -256,9 +288,12 @@ class DBAPIExecutor:
                     # Pre-process parameters (e.g. convert lists to IRIS vector strings)
                     final_params_list = []
                     for p_set in params_list:
+                        # Convert ISO 8601 timestamps and other formats
+                        converted_p_set = self._convert_params_for_iris(p_set)
+
                         processed_params = [
                             "[" + ",".join(map(str, p)) + "]" if isinstance(p, list) else p
-                            for p in p_set
+                            for p in converted_p_set
                         ]
                         final_params_list.append(tuple(processed_params))
 

{iris_pgwire-1.2.31 → iris_pgwire-1.2.33}/src/iris_pgwire/iris_executor.py

@@ -1211,11 +1211,14 @@ class IRISExecutor:
 
                 rows_affected = 0
                 for row_params in params_list:
+                    # Normalize parameters for IRIS (e.g. ISO timestamps)
+                    normalized_row_params = self._normalize_parameters(row_params)
+
                     inline_sql = "N/A"
                     try:
                         # Build inline SQL by replacing ? placeholders with actual values
                         inline_sql = normalized_sql
-                        for param_value in row_params:
+                        for param_value in normalized_row_params:
                             # Convert value to SQL literal
                             if param_value is None:
                                 sql_literal = "NULL"
@@ -4384,3 +4387,34 @@ class IRISExecutor:
         except Exception as e:
             logger.warning("Vector query translation failed", error=str(e), sql=sql[:100])
             return sql  # Return original if translation fails
+
+    def _convert_params_for_iris(self, params: Any) -> Any:
+        """
+        Convert parameters to IRIS-compatible formats.
+        Specifically handles ISO 8601 timestamps.
+        """
+        if params is None:
+            return None
+
+        if isinstance(params, (list, tuple)):
+            return [self._convert_value_for_iris(v) for v in params]
+
+        return self._convert_value_for_iris(params)
+
+    def _convert_value_for_iris(self, value: Any) -> Any:
+        """Helper to convert a single value."""
+        if isinstance(value, str):
+            # Check for ISO 8601 timestamp: 2026-01-29T21:27:38.111Z
+            # or 2026-01-29T21:27:38.111+00:00
+            # IRIS rejects the 'T' and 'Z' or offset in %PosixTime/TIMESTAMP
+            if len(value) >= 19 and value[10] == "T":
+                # Replace 'T' with space
+                converted = value.replace("T", " ")
+                # Remove 'Z' if present
+                if converted.endswith("Z"):
+                    converted = converted[:-1]
+                # Remove timezone offset if present (e.g., +00:00)
+                if "+" in converted:
+                    converted = converted.split("+")[0]
+                return converted
+        return value

{iris_pgwire-1.2.31 → iris_pgwire-1.2.33}/src/iris_pgwire/models/dbapi_connection.py

@@ -79,6 +79,7 @@ class DBAPIConnection(BaseModel):
     pool_recycle_seconds: int = Field(
         ge=60, description="Maximum connection lifetime before recycling"
     )
+    is_overflow: bool = Field(default=False, description="Whether this is an overflow connection")
 
     # Pydantic v2 configuration
     model_config = ConfigDict(
@@ -101,10 +102,28 @@ class DBAPIConnection(BaseModel):
                 "iris_port": 1972,
                 "iris_namespace": "USER",
                 "pool_recycle_seconds": 3600,
+                "is_overflow": False,
             }
         },
     )
 
+    @property
+    def idle_seconds(self) -> float:
+        """
+        Calculate connection idle time in seconds.
+
+        Returns:
+            Seconds since last usage, or since creation if never used.
+        """
+        reference_time = self.last_used_at or self.created_at
+        now = datetime.now(UTC)
+
+        if now < reference_time:
+            # Handle potential clock skew
+            return 0.0
+
+        return (now - reference_time).total_seconds()
+
     def age_seconds(self) -> float:
         """
         Calculate connection age in seconds.