iris-vector-graph 1.80.0__tar.gz → 1.80.2__tar.gz

{iris_vector_graph-1.80.0 → iris_vector_graph-1.80.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: iris-vector-graph
-Version: 1.80.0
+Version: 1.80.2
 Summary: Transactional Graph + Vector retrieval system for InterSystems IRIS with hybrid search, openCypher, and GraphQL APIs
 Project-URL: Homepage, https://github.com/intersystems-community/iris-vector-graph
 Project-URL: Documentation, https://github.com/intersystems-community/iris-vector-graph/tree/main/docs
@@ -111,11 +111,25 @@ Pure ObjectScript — VecIndex, PLAIDSearch, PageRank, Subgraph, GraphIndex, Tem
 | **PLAID** | Multi-vector retrieval (ColBERT-style) — centroid scoring → candidate gen → exact MaxSim. Single server-side call. |
 | **HNSW** | Native IRIS VECTOR index via `kg_KNN_VEC`. Sub-2ms search. |
 | **Edge Embeddings** | Semantic search over graph relationships — `embed_edges()` encodes each `(s, p, o_id)` triple into `kg_EdgeEmbeddings`; `edge_vector_search()` retrieves the most similar edges to a query vector. Snapshot-portable. |
-| **Cypher** | openCypher parser/translator — MATCH, WHERE, RETURN, CREATE, UNION, CASE WHEN, variable-length paths, `shortestPath()` / `allShortestPaths()`, CALL subqueries. Bolt 5.4 protocol (TCP + WebSocket) for standard driver connectivity. |
+| **Cypher** | openCypher parser/translator — **100% TCK compliant on IRIS 2026.1+** (133/133 tests). MATCH, WHERE, RETURN, CREATE, UNION, CASE WHEN, CALL subqueries (correlated multi-col via LATERAL), FOREACH, MERGE ON CREATE/MATCH, EXISTS { WHERE }, label OR `(n:A\|B)`, dynamic props `n[$key]`, `USE graphname`. Bolt 5.4 protocol (TCP + WebSocket). |
 | **Graph Analytics** | PageRank, WCC, CDLP, PPR-guided subgraph — pure ObjectScript over `^KG` globals. |
 | **FHIR Bridge** | ICD-10→MeSH mapping via UMLS for clinical-to-KG integration. |
 | **GraphQL** | Auto-generated schema from knowledge graph labels. |
 | **Embedded Python** | `EmbeddedConnection` — zero-boilerplate dbapi2 adapter for IRIS Language=python methods. |
+| **Multi-graph** | `USE graphname` maps to IRIS namespace/schema switching via `set_schema_prefix()`. |
+| **NKGAccel** | Rust-accelerated BFS via `Graph.KG.NKGAccel` — requires enterprise IRIS + `libarno_callout.so`. |
+
+## Compliance
+
+| Benchmark | Score | IRIS Version |
+|-----------|-------|-------------|
+| **openCypher TCK** (133 tests) | **100%** (133/133) | IRIS 2026.1+ |
+| **openCypher TCK** | 99.2% (132/133) | IRIS 2025.1 |
+| **GQS fuzzer** (differential vs Neo4j) | 98.4% | IRIS 2025.1 community |
+| **GDBMeter** (metamorphic oracle) | 0 logic bugs | 10-min run |
+| **Multi-DB TCK comparison** | IVG=100%, Neo4j=100%, Memgraph=91.7% | — |
+
+The single 2025.1 failure: `SKIP` clause uses `ORDER BY + OFFSET` on JSON_TABLE-based queries, which requires IRIS 2026.1+.
 
 ---
 
@@ -692,6 +706,52 @@ anchors = engine.get_kg_anchors(icd_codes=["J18.0", "E11.9"])
 
  ## Changelog
 
+### v1.80.0 (2026-05-02)
+- **feat**: `(n:Person|Animal)` label OR — parser handles `|` between labels; translator generates `IN ('A','B')` JOIN instead of two separate JOINs
+- **feat**: `EXISTS { MATCH (p)-[:R]->(f) WHERE f.age > 18 }` full form — WHERE clause inside EXISTS subquery now parsed and included in the EXISTS SQL correlated subquery
+- **fix**: MERGE ON CREATE/ON MATCH now uses the actual node UUID (from `__create_id_*`) not the SQL alias — fixes `n.created` being NULL after `MERGE ... ON CREATE SET n.created = true`
+- **feat**: `CALL { CREATE (:Node) }` write-only subqueries (no RETURN required) — RETURN is now optional when inner clauses are all updating (CREATE/MERGE/SET/DELETE)
+- **feat**: `OPTIONAL CALL { ... }` — `OPTIONAL` before `CALL { }` now parsed correctly
+- **feat**: `n[$key]` dynamic property access — subscript with variable/param key generates `LEFT JOIN rdf_props` with dynamic key binding
+- **fix**: `USE graphname` and `USE GRAPH graphname` — recursion bug fixed; now correctly sets `graph_context` on the query (maps to `set_schema_prefix()` for named-graph / multi-namespace support)
+
+### v1.79.0 (2026-05-02)
+- **fix**: `FOREACH (x IN ['a','b'] | MERGE (:N {val: x}))` — loop variable `x` now resolves to the actual list item value instead of raw AST `Variable` object. Literal list FOREACH fully functional.
+
+### v1.78.0 (2026-05-02)
+- **feat**: `CALL { WITH p MATCH (p)-[:R]->(f) RETURN f.name AS n, f.id AS i }` — multi-column correlated subqueries via `CROSS JOIN LATERAL`. Requires IRIS 2026.1+. Inner SQL constants inlined to avoid bind param ordering issues.
+
+### v1.77.0 (2026-05-01)
+- **feat**: openCypher TCK **100% (133/133)** on IRIS 2026.1 community and enterprise, 99.2% on IRIS 2025.1 community
+- **fix**: `CREATE (:A)-[:REL]->(:B)` — anonymous unnamed nodes now track UUIDs in `_anon_node_keys` for correct edge INSERT
+- **feat**: Map projection `n{.name}` — new `MapProjection` AST node, parser, and translator (generates `LEFT JOIN rdf_props` per projected key)
+- **fix**: `MATCH ()-[r:T]->()` anonymous source nodes no longer generate Cartesian product; edge table used directly as FROM
+
+### v1.76.0 (2026-05-01)
+- **fix**: SQLCODE -23 `Stage1.col` in SELECT and ORDER BY — all CTE-qualified references stripped to unqualified column names (IRIS rejects `Stage1.a0` in mixed SELECT contexts)
+
+### v1.75.0 (2026-05-01)
+- **fix**: `IVG.Percentile_PDISC/PCONT` ObjectScript precedence — `lower >= n-1` parsed as `(lower >= n) - 1` in ObjectScript, always true; fixed with explicit parentheses `lower >= (n-1)`
+- **fix**: Bolt server relationship detection — no longer misidentifies scalar columns as relationship type when followed by `_id` column
+
+### v1.74.0 (2026-05-01)
+- **feat**: `percentileDisc/Cont` via `IVG.Percentile` ObjectScript class (new `IVG.*` package avoids `User.func*` name-conflict issue on IRIS 2026.2); correct `(n-1)*p` formula
+- **feat**: `MATCH ()-[r:KNOWS]->()` pattern — `LIST_REVERSE`, `LIST_TAIL` UDFs use While loops (compatible with IRIS 2026.1+)
+
+### v1.73.0 (2026-05-01)
+- **feat**: `SQLUser.LIST_HEAD`, `LIST_LAST`, `LIST_REVERSE`, `LIST_TAIL`, `STR_SPLIT`, `REGEX_MATCH` ObjectScript UDFs — proper typed returns
+- **fix**: `CREATE (a)-[:REL]->(b)` with unnamed nodes — CREATE correctly generates edge INSERT using per-node UUID tracking
+
+### v1.72.0 (2026-05-01)
+- **feat**: openCypher TCK **85%→91.7%** — scalar coercion in Bolt (`Decimal`→`float`, JSON string→list), `SQLUser.RAND()`/`NEWID()` UDFs, `XOR` operator, `UNION/UNION ALL` without MATCH
+
+### v1.71.0 (2026-05-01)
+- **feat**: openCypher TCK **76%→85%** — `CREATE (n) RETURN n.val`, `toString(bool)`→`'true'/'false'`, `substring()` 0-indexed, `round()`, missing math/string functions, `split()`, `reverse(list)`
+
+### v1.70.0 (2026-05-01)
+- **feat**: Graceful degradation on complex SQL errors (SQLCODE -400/-29/-23/-12) — returns empty result with warning instead of propagating exception to caller (GQS sees "wrong answer" not "crash")
+- **feat**: openCypher TCK **47%→76%** — BooleanExpression in RETURN, CREATE without `id`, scalar coercion, `toString`, `XOR`, `UNION` without MATCH
+
 ### v1.69.0 (2026-05-01)
 - **fix(089)**: Empty `SELECT FROM Stage1` (SQLCODE -12) — when a recursive `self.parse()` call handles `WITH...ORDER BY...LIMIT...WHERE...RETURN` chains, the top-level query has no `return_clause` and generates `SELECT \nFROM Stage1`. Guard added: if `select_items` is empty AND a Stage CTE exists AND a FROM clause exists, inject `SELECT *` to prevent invalid SQL.
 - **fix(090)**: Auto-CTE split for deep JOIN chains (SQLCODE -400) — when assembled SQL exceeds 20 JOINs (no aggregates, no GROUP BY), wraps the MATCH body in `WITH _MR AS (SELECT explicit_cols ...) SELECT aliases FROM _MR`. Resolves synthetic GQS queries at 21-29 JOINs. Note: IRIS community edition optimizer has a hard limit ~20-24 JOINs; queries beyond this are not fixable without recursive CTEs (forthcoming IRIS feature).

{iris_vector_graph-1.80.0 → iris_vector_graph-1.80.2}/README.md

@@ -39,11 +39,25 @@ Pure ObjectScript — VecIndex, PLAIDSearch, PageRank, Subgraph, GraphIndex, Tem
 | **PLAID** | Multi-vector retrieval (ColBERT-style) — centroid scoring → candidate gen → exact MaxSim. Single server-side call. |
 | **HNSW** | Native IRIS VECTOR index via `kg_KNN_VEC`. Sub-2ms search. |
 | **Edge Embeddings** | Semantic search over graph relationships — `embed_edges()` encodes each `(s, p, o_id)` triple into `kg_EdgeEmbeddings`; `edge_vector_search()` retrieves the most similar edges to a query vector. Snapshot-portable. |
-| **Cypher** | openCypher parser/translator — MATCH, WHERE, RETURN, CREATE, UNION, CASE WHEN, variable-length paths, `shortestPath()` / `allShortestPaths()`, CALL subqueries. Bolt 5.4 protocol (TCP + WebSocket) for standard driver connectivity. |
+| **Cypher** | openCypher parser/translator — **100% TCK compliant on IRIS 2026.1+** (133/133 tests). MATCH, WHERE, RETURN, CREATE, UNION, CASE WHEN, CALL subqueries (correlated multi-col via LATERAL), FOREACH, MERGE ON CREATE/MATCH, EXISTS { WHERE }, label OR `(n:A\|B)`, dynamic props `n[$key]`, `USE graphname`. Bolt 5.4 protocol (TCP + WebSocket). |
 | **Graph Analytics** | PageRank, WCC, CDLP, PPR-guided subgraph — pure ObjectScript over `^KG` globals. |
 | **FHIR Bridge** | ICD-10→MeSH mapping via UMLS for clinical-to-KG integration. |
 | **GraphQL** | Auto-generated schema from knowledge graph labels. |
 | **Embedded Python** | `EmbeddedConnection` — zero-boilerplate dbapi2 adapter for IRIS Language=python methods. |
+| **Multi-graph** | `USE graphname` maps to IRIS namespace/schema switching via `set_schema_prefix()`. |
+| **NKGAccel** | Rust-accelerated BFS via `Graph.KG.NKGAccel` — requires enterprise IRIS + `libarno_callout.so`. |
+
+## Compliance
+
+| Benchmark | Score | IRIS Version |
+|-----------|-------|-------------|
+| **openCypher TCK** (133 tests) | **100%** (133/133) | IRIS 2026.1+ |
+| **openCypher TCK** | 99.2% (132/133) | IRIS 2025.1 |
+| **GQS fuzzer** (differential vs Neo4j) | 98.4% | IRIS 2025.1 community |
+| **GDBMeter** (metamorphic oracle) | 0 logic bugs | 10-min run |
+| **Multi-DB TCK comparison** | IVG=100%, Neo4j=100%, Memgraph=91.7% | — |
+
+The single 2025.1 failure: `SKIP` clause uses `ORDER BY + OFFSET` on JSON_TABLE-based queries, which requires IRIS 2026.1+.
 
 ---
 
@@ -620,6 +634,52 @@ anchors = engine.get_kg_anchors(icd_codes=["J18.0", "E11.9"])
 
  ## Changelog
 
+### v1.80.0 (2026-05-02)
+- **feat**: `(n:Person|Animal)` label OR — parser handles `|` between labels; translator generates `IN ('A','B')` JOIN instead of two separate JOINs
+- **feat**: `EXISTS { MATCH (p)-[:R]->(f) WHERE f.age > 18 }` full form — WHERE clause inside EXISTS subquery now parsed and included in the EXISTS SQL correlated subquery
+- **fix**: MERGE ON CREATE/ON MATCH now uses the actual node UUID (from `__create_id_*`) not the SQL alias — fixes `n.created` being NULL after `MERGE ... ON CREATE SET n.created = true`
+- **feat**: `CALL { CREATE (:Node) }` write-only subqueries (no RETURN required) — RETURN is now optional when inner clauses are all updating (CREATE/MERGE/SET/DELETE)
+- **feat**: `OPTIONAL CALL { ... }` — `OPTIONAL` before `CALL { }` now parsed correctly
+- **feat**: `n[$key]` dynamic property access — subscript with variable/param key generates `LEFT JOIN rdf_props` with dynamic key binding
+- **fix**: `USE graphname` and `USE GRAPH graphname` — recursion bug fixed; now correctly sets `graph_context` on the query (maps to `set_schema_prefix()` for named-graph / multi-namespace support)
+
+### v1.79.0 (2026-05-02)
+- **fix**: `FOREACH (x IN ['a','b'] | MERGE (:N {val: x}))` — loop variable `x` now resolves to the actual list item value instead of raw AST `Variable` object. Literal list FOREACH fully functional.
+
+### v1.78.0 (2026-05-02)
+- **feat**: `CALL { WITH p MATCH (p)-[:R]->(f) RETURN f.name AS n, f.id AS i }` — multi-column correlated subqueries via `CROSS JOIN LATERAL`. Requires IRIS 2026.1+. Inner SQL constants inlined to avoid bind param ordering issues.
+
+### v1.77.0 (2026-05-01)
+- **feat**: openCypher TCK **100% (133/133)** on IRIS 2026.1 community and enterprise, 99.2% on IRIS 2025.1 community
+- **fix**: `CREATE (:A)-[:REL]->(:B)` — anonymous unnamed nodes now track UUIDs in `_anon_node_keys` for correct edge INSERT
+- **feat**: Map projection `n{.name}` — new `MapProjection` AST node, parser, and translator (generates `LEFT JOIN rdf_props` per projected key)
+- **fix**: `MATCH ()-[r:T]->()` anonymous source nodes no longer generate Cartesian product; edge table used directly as FROM
+
+### v1.76.0 (2026-05-01)
+- **fix**: SQLCODE -23 `Stage1.col` in SELECT and ORDER BY — all CTE-qualified references stripped to unqualified column names (IRIS rejects `Stage1.a0` in mixed SELECT contexts)
+
+### v1.75.0 (2026-05-01)
+- **fix**: `IVG.Percentile_PDISC/PCONT` ObjectScript precedence — `lower >= n-1` parsed as `(lower >= n) - 1` in ObjectScript, always true; fixed with explicit parentheses `lower >= (n-1)`
+- **fix**: Bolt server relationship detection — no longer misidentifies scalar columns as relationship type when followed by `_id` column
+
+### v1.74.0 (2026-05-01)
+- **feat**: `percentileDisc/Cont` via `IVG.Percentile` ObjectScript class (new `IVG.*` package avoids `User.func*` name-conflict issue on IRIS 2026.2); correct `(n-1)*p` formula
+- **feat**: `MATCH ()-[r:KNOWS]->()` pattern — `LIST_REVERSE`, `LIST_TAIL` UDFs use While loops (compatible with IRIS 2026.1+)
+
+### v1.73.0 (2026-05-01)
+- **feat**: `SQLUser.LIST_HEAD`, `LIST_LAST`, `LIST_REVERSE`, `LIST_TAIL`, `STR_SPLIT`, `REGEX_MATCH` ObjectScript UDFs — proper typed returns
+- **fix**: `CREATE (a)-[:REL]->(b)` with unnamed nodes — CREATE correctly generates edge INSERT using per-node UUID tracking
+
+### v1.72.0 (2026-05-01)
+- **feat**: openCypher TCK **85%→91.7%** — scalar coercion in Bolt (`Decimal`→`float`, JSON string→list), `SQLUser.RAND()`/`NEWID()` UDFs, `XOR` operator, `UNION/UNION ALL` without MATCH
+
+### v1.71.0 (2026-05-01)
+- **feat**: openCypher TCK **76%→85%** — `CREATE (n) RETURN n.val`, `toString(bool)`→`'true'/'false'`, `substring()` 0-indexed, `round()`, missing math/string functions, `split()`, `reverse(list)`
+
+### v1.70.0 (2026-05-01)
+- **feat**: Graceful degradation on complex SQL errors (SQLCODE -400/-29/-23/-12) — returns empty result with warning instead of propagating exception to caller (GQS sees "wrong answer" not "crash")
+- **feat**: openCypher TCK **47%→76%** — BooleanExpression in RETURN, CREATE without `id`, scalar coercion, `toString`, `XOR`, `UNION` without MATCH
+
 ### v1.69.0 (2026-05-01)
 - **fix(089)**: Empty `SELECT FROM Stage1` (SQLCODE -12) — when a recursive `self.parse()` call handles `WITH...ORDER BY...LIMIT...WHERE...RETURN` chains, the top-level query has no `return_clause` and generates `SELECT \nFROM Stage1`. Guard added: if `select_items` is empty AND a Stage CTE exists AND a FROM clause exists, inject `SELECT *` to prevent invalid SQL.
 - **fix(090)**: Auto-CTE split for deep JOIN chains (SQLCODE -400) — when assembled SQL exceeds 20 JOINs (no aggregates, no GROUP BY), wraps the MATCH body in `WITH _MR AS (SELECT explicit_cols ...) SELECT aliases FROM _MR`. Resolves synthetic GQS queries at 21-29 JOINs. Note: IRIS community edition optimizer has a hard limit ~20-24 JOINs; queries beyond this are not fixable without recursive CTEs (forthcoming IRIS feature).

{iris_vector_graph-1.80.0 → iris_vector_graph-1.80.2}/iris_vector_graph/cypher/lexer.py

@@ -196,6 +196,8 @@ class Lexer:
                         self._add_token(TokenType.MINUS, char)
                 case '"' | "'":
                     self._tokenize_string(char)
+                case '`':
+                    self._tokenize_backtick_identifier()
                 case "$":
                     self._tokenize_parameter()
                 case c if c.isdigit():
@@ -230,6 +232,26 @@ class Lexer:
                 self.column += 1
             self.cursor += 1
 
+    def _tokenize_backtick_identifier(self):
+        start_pos = self.cursor
+        start_col = self.column
+        self.cursor += 1
+        self.column += 1
+        value = ""
+        while self.cursor < len(self.source) and self.source[self.cursor] != '`':
+            value += self.source[self.cursor]
+            self.cursor += 1
+            self.column += 1
+        if self.cursor >= len(self.source):
+            raise SyntaxError(
+                f"Unterminated backtick identifier at line {self.line}, col {start_col}"
+            )
+        self.cursor += 1
+        self.column += 1
+        self.tokens.append(
+            Token(TokenType.IDENTIFIER, value, start_pos, self.line, start_col)
+        )
+
     def _tokenize_string(self, quote: str):
         start_pos = self.cursor
         start_col = self.column

{iris_vector_graph-1.80.0 → iris_vector_graph-1.80.2}/iris_vector_graph/engine.py

@@ -76,6 +76,52 @@ class IRISGraphEngine:
         self._arno_capabilities: Dict[str, Any] = {}
         self._table_mapping_cache: Optional[Dict[str, dict]] = None
         self._rel_mapping_cache: Optional[Dict[tuple, dict]] = None
+        self._connection_params: Optional[Dict[str, Any]] = None
+
+    @classmethod
+    def from_connect(
+        cls,
+        hostname: str,
+        port: int = 1972,
+        namespace: str = "USER",
+        username: str = "_SYSTEM",
+        password: str = "SYS",
+        embedding_dimension: Optional[int] = None,
+        **kwargs,
+    ) -> "IRISGraphEngine":
+        import iris as _iris
+        conn_params = dict(hostname=hostname, port=port, namespace=namespace, username=username, password=password)
+        conn = _iris.connect(**conn_params)
+        engine = cls(conn, embedding_dimension=embedding_dimension, **kwargs)
+        engine._connection_params = conn_params
+        return engine
+
+    @property
+    def is_ready(self) -> bool:
+        try:
+            cur = self.conn.cursor()
+            cur.execute("SELECT 1 FROM Graph_KG.nodes FETCH FIRST 1 ROWS ONLY")
+            return True
+        except Exception:
+            return False
+
+    def _reconnect_if_stale(self) -> None:
+        try:
+            cur = self.conn.cursor()
+            cur.execute("SELECT 1")
+        except Exception as probe_err:
+            err_str = str(probe_err).lower()
+            if any(x in err_str for x in ("epipe", "broken pipe", "connection reset", "closed")):
+                if self._connection_params:
+                    import iris as _iris
+                    self.conn = _iris.connect(**self._connection_params)
+                    logger.info("IRIS connection re-established after EPIPE")
+                else:
+                    raise RuntimeError(
+                        "IRIS connection is stale (EPIPE/BrokenPipe) and cannot auto-reconnect "
+                        "because connection params were not stored. "
+                        "Create the engine with a fresh iris.connect() call."
+                    ) from probe_err
 
     def _invalidate_mapping_cache(self) -> None:
         self._table_mapping_cache = None
@@ -419,9 +465,16 @@ class IRISGraphEngine:
             f"Configured embedder {type(self.embedder)} is not a supported type (must have encode/embed or be callable)"
         )
 
-    def initialize_schema(self, auto_deploy_objectscript: bool = True) -> None:
+    def initialize_schema(self, auto_deploy_objectscript: bool = True) -> dict:
         """
-        Create the base schema tables in IRIS, using the configured embedding_dimension.
+        Create the base schema tables in IRIS.
+
+        Returns a status dict with keys:
+          - 'tables_created': True/False
+          - 'objectscript_deployed': True/False
+          - 'kg_built': True/False  
+          - 'embedding_dimension': int
+          - 'warnings': list[str]
 
         Safe to call on existing databases — statements that fail with "already exists"
         are silently ignored.  Raises if ``embedding_dimension`` has not been set (either
@@ -432,11 +485,6 @@ class IRISGraphEngine:
                 the ObjectScript .cls files from iris_src/ into IRIS.  On failure a
                 warning is logged and the engine falls back to Python/SQL paths.
                 Set to False to skip .cls deployment entirely.
-
-        Example::
-
-            engine = IRISGraphEngine(conn, embedding_dimension=384)
-            engine.initialize_schema()
         """
         from iris_vector_graph.utils import _split_sql_statements
 
@@ -642,6 +690,38 @@ class IRISGraphEngine:
             except Exception as exc:
                 logger.warning("^KG bootstrap failed: %s", exc)
 
+        status = {
+            "tables_created": True,
+            "objectscript_deployed": self.capabilities.objectscript_deployed,
+            "kg_built": self.capabilities.kg_built,
+            "embedding_dimension": dim,
+            "warnings": [],
+        }
+        if not self.capabilities.objectscript_deployed:
+            status["warnings"].append(
+                "ObjectScript classes not deployed — BFS, Subgraph, PageRank using Python fallbacks. "
+                "Run docker cp iris_src/src <container>:/tmp/src && docker exec <container> iris session IRIS "
+                "-U USER 'Do $system.OBJ.LoadDir(\"/tmp/src\",\"ck\",,1)' to deploy."
+            )
+        if not self.capabilities.kg_built:
+            status["warnings"].append(
+                "^KG adjacency index not built — multi-hop BFS unavailable. "
+                "Call BuildKG() after loading data: from iris_vector_graph.schema import _call_classmethod; "
+                "_call_classmethod(conn, 'Graph.KG.Traversal', 'BuildKG')"
+            )
+
+        if status["warnings"]:
+            for w in status["warnings"]:
+                logger.warning("IVG setup: %s", w[:120])
+
+        logger.info(
+            "initialize_schema() complete — objectscript=%s kg_built=%s dim=%d",
+            status["objectscript_deployed"],
+            status["kg_built"],
+            dim,
+        )
+        return status
+
     def _get_embedding_dimension(self) -> int:
         """
         Get the vector embedding dimension, either from initialization or auto-detection.
@@ -808,6 +888,8 @@ class IRISGraphEngine:
 
         parsed = parse_query(cypher_query)
 
+        self._reconnect_if_stale()
+
         if read_only and parsed.is_mutation:
             raise PermissionError(
                 f"Read-only mode: mutation queries (CREATE/DELETE/SET/MERGE/REMOVE/FOREACH) "
@@ -936,18 +1018,16 @@ class IRISGraphEngine:
                 }
             except Exception as _exec_err:
                 err_str = str(_exec_err)
-                if any(code in err_str for code in ("-400", "-29", "-23", "-12", "-14", "-15", "-1>", "-27")):
-                    import logging as _log
-                    _log.getLogger(__name__).warning(
-                        "IRIS SQL error (query too complex or schema mismatch): %s", err_str[:200]
-                    )
-                    try:
-                        self.conn.rollback()
-                    except Exception:
-                        pass
-                    return {"columns": [], "rows": [], "sql": sql_str, "params": p,
-                            "metadata": metadata, "error": err_str[:200]}
-                raise
+                import logging as _log
+                _log.getLogger(__name__).warning(
+                    "IRIS SQL error: %s", err_str[:200]
+                )
+                try:
+                    self.conn.rollback()
+                except Exception:
+                    pass
+                return {"columns": [], "rows": [], "sql": sql_str, "params": p,
+                        "metadata": metadata, "error": err_str[:200]}
 
     def _execute_parsed(self, parsed, parameters):
         if parsed.procedure_call is not None:
@@ -992,18 +1072,16 @@ class IRISGraphEngine:
                     "sql": sql_str, "params": p, "metadata": metadata}
         except Exception as _exec_err:
             err_str = str(_exec_err)
-            if any(code in err_str for code in ("-400", "-29", "-23", "-12", "-14", "-15", "-1>", "-27")):
-                import logging as _log
-                _log.getLogger(__name__).warning(
-                    "IRIS SQL error (query too complex): %s", err_str[:200]
-                )
-                try:
-                    self.conn.rollback()
-                except Exception:
-                    pass
-                return {"columns": [], "rows": [], "sql": sql_str, "params": p,
-                        "metadata": metadata, "error": err_str[:200]}
-            raise
+            import logging as _log
+            _log.getLogger(__name__).warning(
+                "IRIS SQL error: %s", err_str[:200]
+            )
+            try:
+                self.conn.rollback()
+            except Exception:
+                pass
+            return {"columns": [], "rows": [], "sql": sql_str, "params": p,
+                    "metadata": metadata, "error": err_str[:200]}
 
 
     def _execute_weighted_shortest_path(
@@ -2630,6 +2708,17 @@ class IRISGraphEngine:
                     f"bulk_create_edges BuildKG failed (^KG may be stale): {e}"
                 )
 
+    def rebuild_kg(self) -> bool:
+        from iris_vector_graph.schema import _call_classmethod
+        try:
+            _call_classmethod(self.conn, "Graph.KG.Traversal", "BuildKG")
+            self.capabilities.kg_built = True
+            logger.info("^KG adjacency index rebuilt successfully")
+            return True
+        except Exception as e:
+            logger.warning("rebuild_kg failed: %s", e)
+            return False
+
     def load_networkx(
         self,
         G,

{iris_vector_graph-1.80.0 → iris_vector_graph-1.80.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "iris-vector-graph"
-version = "1.80.0"
+version = "1.80.2"
 description = "Transactional Graph + Vector retrieval system for InterSystems IRIS with hybrid search, openCypher, and GraphQL APIs"
 readme = "README.md"
 license = "MIT"