iris-pgwire 1.4.2__tar.gz → 1.5.1__tar.gz

{iris_pgwire-1.4.2 → iris_pgwire-1.5.1}/PKG-INFO

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

iris_pgwire-1.5.1/src/iris_pgwire/_column_naming.py

@@ -0,0 +1,123 @@
+"""Column name normalization from IRIS conventions to PostgreSQL conventions.
+
+IRIS generates generic names like HostVar_1, Expression_1, Aggregate_1
+when no explicit alias is provided. PostgreSQL uses different conventions
+(e.g., ?column? for unnamed expressions). This module handles the mapping.
+"""
+
+from __future__ import annotations
+
+import re
+
+import structlog
+
+logger = structlog.get_logger()
+
+# IRIS type names → PostgreSQL short type names
+_POSTGRES_TYPE_MAP: dict[str, str] = {
+    "integer": "int4",
+    "bigint": "int8",
+    "smallint": "int2",
+    "real": "float4",
+    "double": "float8",
+    "double precision": "float8",
+    "character varying": "varchar",
+    "character": "char",
+}
+
+# Cast pattern: (sql_upper_fragment, cast_keyword, pg_type_name)
+_CAST_PATTERNS: list[tuple[str, str, str]] = [
+    ("::INT", "AS INTEGER", "int4"),
+    ("::BIGINT", "AS BIGINT", "int8"),
+    ("::SMALLINT", "AS SMALLINT", "int2"),
+    ("::TEXT", "AS TEXT", "text"),
+    ("::VARCHAR", "AS VARCHAR", "varchar"),
+    ("::BOOL", "AS BIT", "bool"),
+    ("::DATE", "AS DATE", "date"),
+]
+
+_GENERIC_COLUMN_NAMES = frozenset(f"column{suffix}" for suffix in ("", "1", "2", "3", "4", "5"))
+
+
+def normalize_iris_column_name(iris_name: str, sql: str, iris_type: str | int) -> str:
+    """Normalize IRIS-generated column names to PostgreSQL-compatible names.
+
+    Args:
+        iris_name: Original column name from IRIS.
+        sql: Original SQL query for context.
+        iris_type: IRIS type code for type-specific naming.
+
+    Returns:
+        PostgreSQL-compatible column name.
+    """
+    normalized = iris_name.lower()
+    sql_upper = sql.upper()
+    sql_lower = sql.lower()
+
+    def _find_explicit_alias(literal_val: str) -> str | None:
+        """Check if SQL contains 'literal_val AS alias' and return the alias."""
+        if literal_val.replace(".", "").replace("-", "").isdigit():
+            # Numeric literal: match "1 AS id", "2.5 AS score"
+            pattern = rf"\b{re.escape(literal_val)}\s+AS\s+(\w+)"
+            match = re.search(pattern, sql, re.IGNORECASE)
+            if match:
+                return match.group(1).lower()
+        else:
+            # String literal: match "'first' AS name" or '"hello" AS greeting'
+            match = re.search(
+                rf"'{re.escape(literal_val)}'\s+AS\s+(\w+)", sql, re.IGNORECASE
+            ) or re.search(rf'"{re.escape(literal_val)}"\s+AS\s+(\w+)', sql, re.IGNORECASE)
+            if match:
+                return match.group(1).lower()
+        return None
+
+    # --- Numeric literal column names (e.g., '1', '42', '3.14', '-5') ---
+    try:
+        float(normalized)
+        explicit_alias = _find_explicit_alias(normalized)
+        if explicit_alias:
+            logger.debug(
+                "numeric literal with explicit alias",
+                iris_name=iris_name,
+                alias=explicit_alias,
+            )
+            return explicit_alias
+        return "?column?"
+    except ValueError:
+        pass
+
+    # --- SELECT without FROM: generic names → ?column? ---
+    if "SELECT" in sql_upper and "FROM" not in sql_upper:
+        if normalized in _GENERIC_COLUMN_NAMES:
+            if f" as {normalized}" not in sql_lower and f' as "{normalized}"' not in sql_lower:
+                return "?column?"
+
+        # String literal used as column name → ?column?
+        unquoted = normalized.replace("'", "").replace('"', "").strip()
+        if f"'{unquoted}'" in sql_lower or f'"{unquoted}"' in sql_lower:
+            return "?column?"
+
+    # --- HostVar_N (unnamed literals) → ?column? ---
+    if normalized.startswith("hostvar_"):
+        return "?column?"
+
+    # --- Expression_N (casts/expressions) → type name or ?column? ---
+    if normalized.startswith("expression_"):
+        for shorthand, cast_keyword, pg_type in _CAST_PATTERNS:
+            if shorthand in sql_upper or ("CAST" in sql_upper and cast_keyword in sql_upper):
+                return pg_type
+        return "?column?"
+
+    # --- Aggregate_N (aggregate functions) → function name ---
+    if normalized.startswith("aggregate_"):
+        for func in ("COUNT", "SUM", "AVG", "MIN", "MAX"):
+            if f"{func}(" in sql_upper:
+                return func.lower()
+        return normalized
+
+    # --- PostgreSQL type name mapping (INTEGER → int4, etc.) ---
+    if normalized in _POSTGRES_TYPE_MAP:
+        return _POSTGRES_TYPE_MAP[normalized]
+
+    # --- Named columns: keep lowercased ---
+    return normalized

iris_pgwire-1.5.1/src/iris_pgwire/_noop_cursor.py

@@ -0,0 +1,21 @@
+"""No-op cursor for skipped or idempotent DDL statements."""
+
+
+class NoopCursor:
+    """Cursor that returns no results. Used for skipped/comment-only/idempotent DDL."""
+
+    def __init__(self):
+        self.description = None
+        self.rowcount = 0
+
+    def close(self):
+        pass
+
+    def fetchall(self):
+        return []
+
+    def fetchone(self):
+        return None
+
+    def __iter__(self):
+        return iter([])

iris_pgwire-1.5.1/src/iris_pgwire/_result_processing.py

@@ -0,0 +1,217 @@
+"""
+Row/column post-processing for IRIS result sets.
+
+Extracted from duplicated logic in iris_executor._sync_execute (embedded)
+and iris_executor._sync_external_execute (external) to provide a single
+implementation for date/timestamp conversion and IRIS type OID overrides.
+"""
+
+from __future__ import annotations
+
+import datetime as dt
+from typing import Any
+
+import structlog
+
+from .conversions import horolog_to_pg
+
+logger = structlog.get_logger(__name__)
+
+# IRIS POSIXTIME constants (canonical source: iris_executor module-level)
+POSIXTIME_OFFSET: int = 1152921504606846976
+POSIXTIME_MAX: int = POSIXTIME_OFFSET + 7258118400000000  # ~2200-01-01
+
+# PostgreSQL J2000 epoch
+_PG_EPOCH = dt.date(2000, 1, 1)
+
+
+def serialize_value(value: Any, type_oid: int) -> Any:
+    """Serialize a single cell value for PostgreSQL wire protocol compatibility.
+
+    Converts IRIS-specific types (POSIXTIME microsecond integers, datetime
+    objects, digit-string timestamps) into the PostgreSQL text wire format
+    expected by client drivers such as psycopg.
+
+    Returns the value unchanged when no conversion applies.
+    """
+    if value is None:
+        return None
+
+    # OID 1114 = TIMESTAMP
+    # PostgreSQL text wire format: "YYYY-MM-DD HH:MM:SS.ffffff"
+    # (space separator, no trailing Z/timezone -- psycopg TimestampLoader requires this)
+    if type_oid == 1114:
+        if isinstance(value, int):
+            try:
+                if value >= POSIXTIME_OFFSET:
+                    # IRIS POSIXTIME (microseconds since 1970-01-01)
+                    unix_us = value - POSIXTIME_OFFSET
+                    ts_obj = dt.datetime(1970, 1, 1) + dt.timedelta(microseconds=unix_us)
+                else:
+                    # PostgreSQL legacy/IRIS microsecond integer (microseconds since 2000-01-01)
+                    ts_obj = dt.datetime(2000, 1, 1) + dt.timedelta(microseconds=value)
+                return ts_obj.strftime("%Y-%m-%d %H:%M:%S.%f")
+            except Exception:
+                return value
+
+        if isinstance(value, dt.datetime):
+            return value.strftime("%Y-%m-%d %H:%M:%S.%f")
+
+        if isinstance(value, str):
+            stripped = value.strip()
+            if stripped.isdigit():
+                # POSIXTIME encoded as digit string
+                unix_us = int(stripped) - POSIXTIME_OFFSET
+                ts_obj = dt.datetime(1970, 1, 1) + dt.timedelta(microseconds=unix_us)
+                return ts_obj.strftime("%Y-%m-%d %H:%M:%S.%f")
+
+            # Pre-decoded datetime string from IRIS driver -- parse and reformat
+            for fmt in (
+                "%Y-%m-%d %H:%M:%S.%f",
+                "%Y-%m-%d %H:%M:%S",
+                "%Y-%m-%dT%H:%M:%S.%f",
+                "%Y-%m-%dT%H:%M:%S",
+            ):
+                try:
+                    ts_obj = dt.datetime.strptime(stripped.rstrip("Z"), fmt)
+                    return ts_obj.strftime("%Y-%m-%d %H:%M:%S.%f")
+                except ValueError:
+                    continue
+            return value  # unrecognised format -- pass through unchanged
+
+    # OID 1082 = DATE (integer Horolog already converted elsewhere; safety passthrough)
+    if type_oid == 1082 and isinstance(value, int):
+        return value
+
+    return value
+
+
+# ---------------------------------------------------------------------------
+# Row / column post-processing
+# ---------------------------------------------------------------------------
+
+
+def convert_rows_dates_and_timestamps(
+    rows: list[list[Any]],
+    columns: list[dict[str, Any]],
+) -> None:
+    """Convert IRIS date/timestamp values in *rows* to PostgreSQL wire format.
+
+    Mutates *rows* and *columns* in-place:
+
+    1. Builds a ``column_type_oids`` lookup from *columns*.
+    2. For integer columns (OID 20/23) whose value falls within the POSIXTIME
+       range, reclassifies the column as TIMESTAMP (OID 1114) and serializes
+       the value accordingly.
+    3. Runs :func:`serialize_value` on every cell for TIMESTAMP formatting.
+    4. Converts DATE (OID 1082) ISO strings (``YYYY-MM-DD``) to PostgreSQL
+       integer days since 2000-01-01.
+    5. Converts Horolog integer dates to PostgreSQL days via
+       :func:`~iris_pgwire.conversions.horolog_to_pg`.
+    """
+    if not rows or not columns:
+        return
+
+    column_type_oids = [col["type_oid"] for col in columns]
+
+    for row_idx, row in enumerate(rows):
+        for col_idx, value in enumerate(row):
+            if col_idx >= len(column_type_oids):
+                continue
+
+            type_oid = column_type_oids[col_idx]
+
+            # Detect POSIXTIME integers masquerading as INT8/INT4
+            if type_oid in (20, 23) and isinstance(value, int):
+                if POSIXTIME_OFFSET <= value <= POSIXTIME_MAX:
+                    type_oid = 1114
+                    if row_idx == 0:
+                        columns[col_idx]["type_oid"] = 1114
+
+            # Robust serialization (TIMESTAMP, etc.)
+            rows[row_idx][col_idx] = serialize_value(rows[row_idx][col_idx], type_oid)
+            value = rows[row_idx][col_idx]
+
+            # OID 1082 = DATE
+            if type_oid == 1082 and value is not None:
+                try:
+                    if isinstance(value, str):
+                        # IRIS returns dates as ISO strings (YYYY-MM-DD)
+                        date_obj = dt.datetime.strptime(value, "%Y-%m-%d").date()
+                        pg_days = (date_obj - _PG_EPOCH).days
+                        rows[row_idx][col_idx] = pg_days
+                        logger.debug(
+                            "Converted date string to PostgreSQL format",
+                            row=row_idx,
+                            col=col_idx,
+                            iris_string=value,
+                            pg_days=pg_days,
+                            date_obj=str(date_obj),
+                        )
+                    elif isinstance(value, int):
+                        pg_date = horolog_to_pg(value)
+                        rows[row_idx][col_idx] = pg_date
+                        logger.debug(
+                            "Converted Horolog date to PostgreSQL format",
+                            row=row_idx,
+                            col=col_idx,
+                            iris_horolog=value,
+                            pg_days=pg_date,
+                        )
+                except Exception as date_err:
+                    logger.warning(
+                        "Failed to convert date value",
+                        row=row_idx,
+                        col=col_idx,
+                        value=value,
+                        value_type=type(value).__name__,
+                        error=str(date_err),
+                    )
+                    # Keep original value if conversion fails
+
+
+# ---------------------------------------------------------------------------
+# IRIS type OID overrides
+# ---------------------------------------------------------------------------
+
+
+def override_iris_type_oid(iris_type: int, type_oid: int, sql_upper: str) -> int:
+    """Apply IRIS-specific type OID corrections for PostgreSQL compatibility.
+
+    Handles two cases where IRIS returns an incorrect or sub-optimal type OID:
+
+    * **IRIS type code 2 (NUMERIC)** -- decimal literals like ``3.14`` are
+      reported as NUMERIC.  For client drivers that distinguish NUMERIC from
+      FLOAT (e.g. node-postgres), we override to FLOAT8 (OID 701) unless the
+      SQL contains an explicit ``CAST … AS NUMERIC`` / ``AS DECIMAL`` / ``AS
+      INTEGER`` / ``AS INT``.  An explicit ``AS INTEGER`` / ``AS INT`` cast
+      produces INT4 (OID 23).
+
+    * **CURRENT_TIMESTAMP** -- IRIS returns OID 25 (TEXT) or 1043 (VARCHAR)
+      for ``CURRENT_TIMESTAMP``.  Both are overridden to 1114 (TIMESTAMP) so
+      that client drivers (Npgsql, psycopg) handle the value correctly.
+
+    Returns the (possibly corrected) *type_oid*.
+    """
+    if iris_type == 2:
+        if "AS INTEGER" in sql_upper or "AS INT" in sql_upper:
+            logger.debug(
+                "Overriding IRIS type code 2 (NUMERIC) to INT4 for explicit INTEGER cast",
+                original_oid=type_oid,
+            )
+            return 23  # INT4
+        if "AS NUMERIC" not in sql_upper and "AS DECIMAL" not in sql_upper:
+            logger.debug(
+                "Overriding IRIS type code 2 (NUMERIC) to FLOAT8 for decimal literal",
+                original_oid=type_oid,
+            )
+            return 701  # FLOAT8
+
+    if "CURRENT_TIMESTAMP" in sql_upper and type_oid in (25, 1043):
+        logger.debug(
+            "Overriding CURRENT_TIMESTAMP type to TIMESTAMP",
+            original_oid=type_oid,
+        )
+        return 1114  # TIMESTAMP
+
+    return type_oid

iris_pgwire-1.5.1/src/iris_pgwire/_type_mapping.py

@@ -0,0 +1,246 @@
+"""Internal type-mapping helpers for IRIS ↔ PostgreSQL OID conversion.
+
+Pure functions with no logging or external dependencies beyond stdlib + Decimal.
+"""
+
+from __future__ import annotations
+
+import datetime as dt
+import re
+from decimal import Decimal
+from typing import Any
+
+# IRIS POSIXTIME: microseconds since 1970-01-01 with a large offset added.
+POSIXTIME_OFFSET = 1152921504606846976
+POSIXTIME_MAX = POSIXTIME_OFFSET + 7258118400000000  # ~2200-01-01
+
+# ---------------------------------------------------------------------------
+# Integer type-code → OID  (IRIS JDBC / ODBC codes)
+# ---------------------------------------------------------------------------
+_INT_TYPE_TO_OID: dict[int, int] = {
+    -7: 16,  # BIT → bool
+    -6: 21,  # TINYINT → int2
+    -5: 20,  # BIGINT → int8
+    1: 1042,  # CHAR → bpchar
+    2: 1700,  # NUMERIC
+    3: 20,  # → int8
+    4: 23,  # → int4
+    5: 701,  # → float8
+    8: 701,  # IRIS DOUBLE → float8
+    9: 1082,  # → date
+    10: 1114,  # → timestamp
+    12: 1043,  # → varchar
+    16: 16,  # → bool
+    17: 17,  # → bytea
+    # JDBC standard codes
+    91: 1082,  # JDBC DATE
+    92: 1083,  # JDBC TIME
+    93: 1114,  # JDBC TIMESTAMP
+    # IRIS extended codes (returned for TIMESTAMP/POSIXTIME columns)
+    1091: 1082,
+    1092: 1083,
+    1093: 1114,
+}
+
+# ---------------------------------------------------------------------------
+# String type-name → OID  (union of both original mappings)
+# ---------------------------------------------------------------------------
+_STR_TYPE_TO_OID: dict[str, int] = {
+    "INT": 23,
+    "INTEGER": 23,
+    "BIGINT": 20,
+    "SMALLINT": 21,
+    "VARCHAR": 1043,
+    "CHAR": 1042,
+    "TEXT": 25,
+    "DATE": 1082,
+    "TIME": 1083,
+    "TIMESTAMP": 1114,
+    "DOUBLE": 701,
+    "FLOAT": 700,
+    "NUMERIC": 1700,
+    "DECIMAL": 1700,
+    "BIT": 1560,
+    "BOOLEAN": 16,
+    "BINARY": 17,
+    "VARBINARY": 17,
+    "VECTOR": 16388,
+}
+
+_DEFAULT_OID = 1043  # VARCHAR
+
+
+def iris_type_to_pg_oid(iris_type: str | int) -> int:
+    """Convert an IRIS type (integer code or string name) to a PostgreSQL OID.
+
+    Handles both JDBC/ODBC integer type codes and SQL string type names
+    such as ``"VARCHAR"`` or ``"INTEGER(10)"``.  Unknown types default to
+    VARCHAR (1043).
+    """
+    if isinstance(iris_type, int):
+        return _INT_TYPE_TO_OID.get(iris_type, _DEFAULT_OID)
+
+    # Strip size/precision suffix: "VARCHAR(255)" → "VARCHAR"
+    normalized = str(iris_type).upper().split("(")[0].strip()
+    return _STR_TYPE_TO_OID.get(normalized, _DEFAULT_OID)
+
+
+# ---------------------------------------------------------------------------
+# Value-based type inference
+# ---------------------------------------------------------------------------
+
+_INT4_MIN = -(2**31)
+_INT4_MAX = 2**31 - 1
+_ID_HINTS = ("id", "key")
+
+
+def infer_type_from_value(value: Any, column_name: str | None = None) -> int:
+    """Infer a PostgreSQL OID from a Python value.
+
+    Uses POSIXTIME range detection for large integers and column-name hints
+    (``id`` / ``key``) to choose BIGINT over INTEGER.
+    """
+    if value is None:
+        return 1043  # VARCHAR — most flexible for NULL
+
+    if isinstance(value, bool):
+        return 16  # BOOL
+
+    if isinstance(value, int):
+        if POSIXTIME_OFFSET <= value <= POSIXTIME_MAX:
+            return 1114  # TIMESTAMP
+        if column_name and any(k in column_name.lower() for k in _ID_HINTS):
+            return 20  # BIGINT
+        if _INT4_MIN <= value <= _INT4_MAX:
+            return 23  # INTEGER
+        return 20  # BIGINT
+
+    if isinstance(value, float):
+        return 701  # FLOAT8
+
+    if isinstance(value, Decimal):
+        return 1700  # NUMERIC
+
+    if isinstance(value, bytes):
+        return 17  # BYTEA
+
+    if isinstance(value, dt.datetime):
+        return 1114  # TIMESTAMP
+
+    if isinstance(value, dt.date):
+        return 1082  # DATE
+
+    return 1043  # VARCHAR (default for str and everything else)
+
+
+# ---------------------------------------------------------------------------
+# Value serialisation
+# ---------------------------------------------------------------------------
+
+_TIMESTAMP_PARSE_FORMATS = (
+    "%Y-%m-%d %H:%M:%S.%f",
+    "%Y-%m-%d %H:%M:%S",
+    "%Y-%m-%dT%H:%M:%S.%f",
+    "%Y-%m-%dT%H:%M:%S",
+)
+
+_PG_TIMESTAMP_FMT = "%Y-%m-%d %H:%M:%S.%f"
+
+_EPOCH_1970 = dt.datetime(1970, 1, 1)
+_EPOCH_2000 = dt.datetime(2000, 1, 1)
+
+
+def serialize_value(value: Any, type_oid: int) -> Any:
+    """Serialize a Python value for the PostgreSQL wire protocol.
+
+    Converts IRIS-specific representations (e.g. POSIXTIME microsecond
+    integers) into the text format PostgreSQL clients expect.
+    """
+    if value is None:
+        return None
+
+    if type_oid == 1114:  # TIMESTAMP
+        return _serialize_timestamp(value)
+
+    return value
+
+
+def _serialize_timestamp(value: Any) -> Any:
+    """Convert various timestamp representations to PG text format."""
+    if isinstance(value, int):
+        try:
+            if value >= POSIXTIME_OFFSET:
+                unix_us = value - POSIXTIME_OFFSET
+                ts = _EPOCH_1970 + dt.timedelta(microseconds=unix_us)
+            else:
+                # Legacy: microseconds since 2000-01-01
+                ts = _EPOCH_2000 + dt.timedelta(microseconds=value)
+            return ts.strftime(_PG_TIMESTAMP_FMT)
+        except Exception:
+            return value
+
+    if isinstance(value, dt.datetime):
+        return value.strftime(_PG_TIMESTAMP_FMT)
+
+    if isinstance(value, str):
+        stripped = value.strip()
+        if stripped.isdigit():
+            unix_us = int(stripped) - POSIXTIME_OFFSET
+            ts = _EPOCH_1970 + dt.timedelta(microseconds=unix_us)
+            return ts.strftime(_PG_TIMESTAMP_FMT)
+
+        # Try known datetime string formats
+        for fmt in _TIMESTAMP_PARSE_FORMATS:
+            try:
+                ts = dt.datetime.strptime(stripped.rstrip("Z"), fmt)
+                return ts.strftime(_PG_TIMESTAMP_FMT)
+            except ValueError:
+                continue
+
+    return value  # unrecognised — pass through
+
+
+# ---------------------------------------------------------------------------
+# SQL CAST detection
+# ---------------------------------------------------------------------------
+
+_CAST_TYPE_MAP: dict[str, int] = {
+    "bool": 16,
+    "boolean": 16,
+    "bit": 16,  # IRIS uses BIT for boolean
+    "int": 23,
+    "integer": 23,
+    "bigint": 20,
+    "smallint": 21,
+    "text": 25,
+    "varchar": 1043,
+    "date": 1082,
+    "timestamp": 1114,
+    "float": 701,
+    "double": 701,
+}
+
+
+def detect_cast_type_oid(sql: str, column_name: str) -> int | None:
+    """Detect a PostgreSQL OID from CAST expressions targeting *column_name*.
+
+    Recognises two patterns:
+    - ``$1::bool AS column_name``   (PostgreSQL-style cast)
+    - ``CAST(? AS BIT) AS column_name``  (SQL-standard cast)
+
+    Returns ``None`` if no matching cast is found.
+    """
+    sql_upper = sql.upper()
+    col_escaped = re.escape(column_name.upper())
+
+    # Pattern 1: $N::type AS column
+    match = re.search(rf"\$\d+::(\w+)\s+AS\s+{col_escaped}", sql_upper)
+    if match:
+        return _CAST_TYPE_MAP.get(match.group(1).lower())
+
+    # Pattern 2: CAST(? AS type) AS column
+    match = re.search(rf"CAST\(\?\s+AS\s+(\w+)\)\s+AS\s+{col_escaped}", sql_upper)
+    if match:
+        return _CAST_TYPE_MAP.get(match.group(1).lower())
+
+    return None