iris-pgwire 1.5.4__tar.gz → 1.5.6__tar.gz

{iris_pgwire-1.5.4 → iris_pgwire-1.5.6}/PKG-INFO

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

{iris_pgwire-1.5.4 → iris_pgwire-1.5.6}/src/iris_pgwire/iris_executor.py

@@ -627,6 +627,7 @@ class IRISExecutor:
         params: list | None,
         execution_path: str,
         session_id: str | None = None,
+        original_sql: str | None = None,
     ) -> tuple[str, list | None, "ReturningPlan", float]:
         """
         Shared pre-execution pipeline (steps 1–7) used by both embedded and external paths.
@@ -678,8 +679,12 @@ class IRISExecutor:
         t_opt_elapsed = (time.perf_counter() - t_opt_start) * 1000
 
         # 5. RETURNING / ON CONFLICT parsing
+        # Use original_sql (pre-translation) for RETURNING detection when available.
+        # translated sql (optimized_sql) has the RETURNING clause stripped because IRIS
+        # doesn't support it natively — so ReturningPlan must inspect the original.
+        _sql_for_plan = original_sql if original_sql else optimized_sql
         plan = ReturningPlan.from_sql(
-            optimized_sql,
+            _sql_for_plan,
             metadata_cache=self.metadata_cache,
             executor=self,
         )
@@ -998,10 +1003,14 @@ class IRISExecutor:
                 )
                 if self.embedded_mode:
                     logger.warning("🔍 DEBUG: Taking EMBEDDED path → _execute_embedded_async()")
-                    result = await self._execute_embedded_async(sql, params, session_id)
+                    result = await self._execute_embedded_async(
+                        sql, params, session_id, original_sql=kwargs.get("original_sql")
+                    )
                 else:
                     logger.warning("🔍 DEBUG: Taking EXTERNAL path → _execute_external_async()")
-                    result = await self._execute_external_async(sql, params, session_id)
+                    result = await self._execute_external_async(
+                        sql, params, session_id, original_sql=kwargs.get("original_sql")
+                    )
 
                 # Feature 026: Handle DDL idempotency (IF NOT EXISTS)
                 # Check both for raised exceptions and for success=False results
@@ -2292,7 +2301,11 @@ class IRISExecutor:
         return rows, columns
 
     async def _execute_embedded_async(
-        self, sql: str, params: list | None = None, session_id: str | None = None
+        self,
+        sql: str,
+        params: list | None = None,
+        session_id: str | None = None,
+        original_sql: str | None = None,
     ) -> dict[str, Any]:
         """Execute query in IRIS embedded Python environment (async wrapper)"""
 
@@ -2354,7 +2367,11 @@ class IRISExecutor:
 
                 # Steps 1-7: Shared pre-execution pipeline
                 optimized_sql, optimized_params, plan, t_opt_elapsed = self._prepare_sql(
-                    sql, params, execution_path="direct", session_id=session_id
+                    sql,
+                    params,
+                    execution_path="direct",
+                    session_id=session_id,
+                    original_sql=original_sql,
                 )
                 optimized_sql_upper = optimized_sql.upper()
                 returning_operation = plan.operation
@@ -2883,7 +2900,11 @@ class IRISExecutor:
         return rows, columns
 
     async def _execute_external_async(
-        self, sql: str, params: list | None = None, session_id: str | None = None
+        self,
+        sql: str,
+        params: list | None = None,
+        session_id: str | None = None,
+        original_sql: str | None = None,
     ) -> dict[str, Any]:
         """
         Execute SQL using external IRIS connection with proper async threading
@@ -2910,7 +2931,11 @@ class IRISExecutor:
 
                 # Steps 1-7: Shared pre-execution pipeline
                 optimized_sql, optimized_params, plan, t_opt_elapsed = self._prepare_sql(
-                    sql, params, execution_path="external", session_id=session_id
+                    sql,
+                    params,
+                    execution_path="external",
+                    session_id=session_id,
+                    original_sql=original_sql,
                 )
                 optimized_sql_upper = optimized_sql.upper()
 

{iris_pgwire-1.5.4 → iris_pgwire-1.5.6}/src/iris_pgwire/protocol.py

@@ -2930,10 +2930,14 @@ class PGWireProtocol:
                 # For SELECT/SHOW statements, send RowDescription with column metadata
                 # For DDL/DML statements, send NoData
                 query = stmt.get("translated_query", stmt.get("query", ""))
+                # Use original_query for RETURNING detection: the translation pipeline
+                # strips RETURNING before storing translated_query (IRIS doesn't support it
+                # natively), so has_returning would always be False if we use translated_query.
+                original_query = stmt.get("original_query", query)
                 query_upper = query.strip().upper()
 
                 plan = ReturningPlan.from_sql(
-                    query,
+                    original_query,
                     metadata_cache=self.iris_executor.metadata_cache,
                     executor=self.iris_executor,
                 )
@@ -3081,10 +3085,13 @@ class PGWireProtocol:
 
                 stmt = self.prepared_statements[statement_name]
                 query = stmt.get("translated_query", stmt.get("query", ""))
+                # Use original_query for RETURNING detection: translated_query has the
+                # RETURNING clause stripped (IRIS doesn't support it natively).
+                original_query = stmt.get("original_query", query)
                 query_upper = query.strip().upper()
 
                 plan = ReturningPlan.from_sql(
-                    query,
+                    original_query,
                     metadata_cache=self.iris_executor.metadata_cache,
                     executor=self.iris_executor,
                 )
@@ -3305,6 +3312,9 @@ class PGWireProtocol:
 
             # Use translated query for execution
             query = stmt.get("translated_query", stmt.get("query", stmt.get("original_query", "")))
+            # Use original_query for RETURNING detection: translated_query has RETURNING stripped.
+            # has_returning check below decides whether to fast-batch (DML without RETURNING).
+            original_query = stmt.get("original_query", query)
 
             # Log execution of prepared statement with translation metadata
             translation_metadata = stmt.get("translation_metadata", {})
@@ -3387,7 +3397,11 @@ class PGWireProtocol:
             # Standard PostgreSQL clients (psycopg3) send Sync every 5 rows, which is slow.
             # We buffer parameters and send synthetic CommandComplete to keep client pipe full.
             is_dml = self.iris_executor.sql_parser.is_dml_statement(query)
-            has_returning = self.iris_executor.sql_parser.has_returning_clause(query)
+            # Use original_query for RETURNING detection: translated_query has RETURNING stripped.
+            # If we used query (translated) here, INSERT...RETURNING would be fast-batched
+            # (because has_returning=False on translated_query), INSERT would execute but
+            # zero DataRows would be returned to the client.
+            has_returning = self.iris_executor.sql_parser.has_returning_clause(original_query)
 
             if is_dml and not has_returning:
                 # Store SQL if first row in batch
@@ -3425,6 +3439,7 @@ class PGWireProtocol:
                 session_id=self.connection_id,
                 in_transaction=in_txn,
                 autocommit=autocommit,
+                original_sql=original_query,
             )
 
             if result["success"]: