Fix parameter passing, SQLUser casing, and DDL case sensitivity (v1.0.9)

Author: tom-dyar

CHANGELOG.md

@@ -5,6 +5,13 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.0.9] - 2026-01-17
+
+### Fixed
+- **Parameter Passing Bug**: Fixed `iris_executor.py` to correctly pass parameters to `iris.sql.exec(*params)`, enabling parameterized queries in embedded mode.
+- **Schema Case Sensitivity**: Fixed normalizer to preserve `SQLUser` casing (instead of `SQLUSER`), satisfying case-sensitive package requirements in IRIS.
+- **DDL Case Sensitivity**: Fixed `IdentifierNormalizer` to respect quoted identifier casing in `CREATE TABLE` statements, preventing "Class not found" errors during subsequent queries.
+
 ## [1.0.8] - 2026-01-17
 
 ### Added

src/iris_pgwire/__init__.py

@@ -6,7 +6,7 @@
 caretdev/sqlalchemy-iris.
 """
 
-__version__ = "1.0.8"
+__version__ = "1.0.9"
 __author__ = "IRIS PGWire Team"
 
 # Don't import server/protocol in __init__ to avoid sys.modules conflicts

src/iris_pgwire/iris_executor.py

@@ -1223,9 +1223,7 @@ def _split_multi_row_insert(self, sql: str) -> list[str]:
 
         return statements
 
-    def _safe_execute(
-        self, sql: str, params: list | None = None, is_embedded: bool = True
-    ) -> Any:
+    def _safe_execute(self, sql: str, params: list | None = None, is_embedded: bool = True) -> Any:
         """Execute SQL with DDL idempotency handling."""
         import iris
 
@@ -1266,7 +1264,10 @@ def __iter__(self):
         try:
             if is_embedded:
                 # Embedded mode - return cursor-like object
+                if params is not None and len(params) > 0:
+                    return iris.sql.exec(sql, *params)
                 return iris.sql.exec(sql)
+
             else:
                 # External mode - use DBAPI cursor
                 connection = self._get_pooled_connection()
@@ -2917,7 +2918,7 @@ def _sync_execute():
                     optimized_params = tuple(self._normalize_parameters(optimized_params))
 
                 # Replace "public"."tablename" with SQLUser."tablename" (preserve quotes on tablename)
-                # Replace "public"."tablename" with SQLUser."tablename" (preserve quotes on tablename)
+                # Ensure we use the correct SQLUser casing
                 optimized_sql = re.sub(
                     r'"public"\s*\.\s*"(\w+)"', r'SQLUser."\1"', optimized_sql, flags=re.IGNORECASE
                 )

src/iris_pgwire/schema_mapper.py

@@ -68,20 +68,31 @@ def translate_input_schema(sql: str) -> str:
         flags=re.IGNORECASE,
     )
 
-    # Pattern 2: Schema-qualified table names (e.g., public.tablename)
-    # Match public. followed by identifier (word chars) but not inside single quotes
-    # This is a simplified approach - we process the SQL outside of string literals
+    # Pattern 2: Schema-qualified table names (e.g., public.tablename or public."tablename")
+    # Match public. followed by identifier (word chars) or quoted identifier
     result = re.sub(
-        r'\bpublic\.(\w+)',
-        rf'{IRIS_SCHEMA}.\1',
+        r'\bpublic\s*\.\s*"(\w+)"',
+        rf'{IRIS_SCHEMA}."\1"',
+        result,
+        flags=re.IGNORECASE,
+    )
+    result = re.sub(
+        r"\bpublic\s*\.\s*(\w+)",
+        rf"{IRIS_SCHEMA}.\1",
         result,
         flags=re.IGNORECASE,
     )
 
-    # Pattern 3: Double-quoted schema (e.g., "public".tablename)
+    # Pattern 3: Double-quoted schema (e.g., "public".tablename or "public"."tablename")
+    result = re.sub(
+        r'"public"\s*\.\s*"(\w+)"',
+        rf'{IRIS_SCHEMA}."\1"',
+        result,
+        flags=re.IGNORECASE,
+    )
     result = re.sub(
-        r'"public"\.(\w+)',
-        rf'{IRIS_SCHEMA}.\1',
+        r'"public"\s*\.\s*(\w+)',
+        rf"{IRIS_SCHEMA}.\1",
         result,
         flags=re.IGNORECASE,
     )

src/iris_pgwire/sql_translator/identifier_normalizer.py

@@ -275,7 +275,12 @@ def _normalize_chunk(self, chunk: str, current_count: int) -> tuple[str, int]:
             # Process CREATE TABLE specially to preserve column name case
             before_create = chunk[: create_match.start()]
             create_prefix = create_match.group(1).upper()  # CREATE TABLE keywords
-            table_name = create_match.group(2).upper()  # Uppercase table name
+            # Fix: Respect quoted identifier case for table name
+            table_name_raw = create_match.group(2)
+            if table_name_raw.startswith('"') and table_name_raw.endswith('"'):
+                table_name = table_name_raw  # Quoted: preserve exact case
+            else:
+                table_name = table_name_raw.upper()  # Unquoted: uppercase for IRIS
             opening_paren = create_match.group(3)
 
             # CRITICAL FIX: Find the matching closing paren for the table definition
@@ -387,13 +392,18 @@ def replace_identifier(match):
                 return f'"{quoted}"'  # Return as-is
             elif unquoted is not None:
                 # Unquoted identifier - check if it's a keyword
-                if unquoted.upper() in self._sql_keywords:
+                upper_unquoted = unquoted.upper()
+                if upper_unquoted in self._sql_keywords:
                     # SQL keyword - uppercase but don't count as user identifier
-                    return unquoted.upper()
+                    return upper_unquoted
+                elif upper_unquoted == "SQLUSER":
+                    # Feature 036 Fix: Preserve SQLUser case (IRIS is case-sensitive for schema names)
+                    identifier_count += 1
+                    return "SQLUser"
                 else:
                     # User identifier - uppercase and count
                     identifier_count += 1
-                    return unquoted.upper()
+                    return upper_unquoted
 
             return match.group(0)  # Shouldn't reach here