iris-vector-graph 1.91.1__tar.gz → 1.91.3__tar.gz

{iris_vector_graph-1.91.1 → iris_vector_graph-1.91.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: iris-vector-graph
-Version: 1.91.1
+Version: 1.91.3
 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

{iris_vector_graph-1.91.1 → iris_vector_graph-1.91.3}/iris_vector_graph/embedded.py

@@ -111,6 +111,64 @@ def _require_iris_sql():
         ) from exc
 
 
+def _is_ddtab_error(exc: Exception) -> bool:
+    s = str(exc)
+    return "<UNIMPLEMENTED>" in s or "ddtab" in s
+
+
+def _sql_statement_execute(sql: str, params=None):
+    import iris
+    stmt = iris.cls("%SQL.Statement")._New()
+    sc = stmt._Prepare(sql)
+    if not sc:
+        raise RuntimeError(f"%%SQL.Statement._Prepare failed sc={sc}")
+    if params:
+        rs = stmt._Execute(*params)
+    else:
+        rs = stmt._Execute()
+    return _SqlStatementResultSet(rs)
+
+
+class _SqlStatementResultSet:
+
+    def __init__(self, rs):
+        self._rs = rs
+        self._done = False
+
+    def columnCount(self):
+        try:
+            return int(self._rs._GetProperty("ColCount")) if self._rs else 0
+        except Exception:
+            return 0
+
+    def columnName(self, i):
+        try:
+            return str(self._rs._GetProperty("MetaData")._GetProperty("columns")._GetAt(i)._GetProperty("colName"))
+        except Exception:
+            return f"col{i}"
+
+    def __iter__(self):
+        if self._rs is None or self._done:
+            return
+        try:
+            while True:
+                sc = int(str(self._rs._Next()))
+                if sc == 0:
+                    break
+                row = []
+                col_count = self.columnCount()
+                for i in range(1, col_count + 1):
+                    try:
+                        val = self._rs._GetData(i)
+                        row.append(None if val is None else val)
+                    except Exception:
+                        row.append(None)
+                yield tuple(row)
+        except Exception:
+            pass
+        self._done = True
+
+
 class EmbeddedCursor:
 
     def __init__(self, iris_sql=None):
@@ -143,10 +201,23 @@ class EmbeddedCursor:
                 self._rs = stmt.execute(*params)
             else:
                 self._rs = stmt.execute()
-        except Exception as exc:
-            if "<UNIMPLEMENTED>" not in str(exc) and "ddtab" not in str(exc):
+        except Exception as exc1:
+            if not _is_ddtab_error(exc1):
                 raise
-            self._rs = iris_sql.exec(_inline_params(sql, params or []))
+            try:
+                self._rs = iris_sql.exec(_inline_params(sql, params or []))
+            except Exception as exc2:
+                if not _is_ddtab_error(exc2):
+                    raise
+                try:
+                    self._rs = _sql_statement_execute(sql, params)
+                except Exception as exc3:
+                    raise RuntimeError(
+                        f"All three embedded SQL paths failed.\n"
+                        f"  prepare: {exc1}\n"
+                        f"  exec: {exc2}\n"
+                        f"  %%SQL.Statement: {exc3}"
+                    ) from exc3
 
         self._rows = None
         self._pos = 0
@@ -174,11 +245,16 @@ class EmbeddedCursor:
                 stmt.execute(*params)
                 count += 1
         except Exception as exc:
-            if "<UNIMPLEMENTED>" not in str(exc) and "ddtab" not in str(exc):
+            if not _is_ddtab_error(exc):
                 raise
             count = 0
             for params in seq:
-                iris_sql.exec(_inline_params(sql, list(params)))
+                try:
+                    iris_sql.exec(_inline_params(sql, list(params)))
+                except Exception as exc2:
+                    if not _is_ddtab_error(exc2):
+                        raise
+                    _sql_statement_execute(sql, list(params))
                 count += 1
         self.rowcount = count
         self._rs = None

{iris_vector_graph-1.91.1 → iris_vector_graph-1.91.3}/iris_vector_graph/engine.py

@@ -97,7 +97,10 @@ class IRISGraphEngine:
         self._connection_params: Optional[Dict[str, Any]] = None
         self._nkg_dirty: bool = False
         self._index_registry: Dict[str, str] = self._build_index_registry()
-        logger.debug("IRISGraphEngine initialized (dim=%s)", embedding_dimension or "auto")
+        if vector_dtype == "DOUBLE":
+            self.vector_dtype = self._detect_stored_vector_dtype()
+        logger.debug("IRISGraphEngine initialized (dim=%s dtype=%s)",
+                     embedding_dimension or "auto", self.vector_dtype)
 
     @classmethod
     def from_connect(
@@ -3074,6 +3077,35 @@ class IRISGraphEngine:
                         f"bulk_create_edges BuildKG failed (^KG may be stale): {e}"
                     )
 
+    def _detect_stored_vector_dtype(self) -> str:
+        try:
+            cursor = self.conn.cursor()
+            cursor.execute(
+                f"SELECT TOP 1 emb FROM {_table('kg_NodeEmbeddings')} WHERE emb IS NOT NULL"
+            )
+            row = cursor.fetchone()
+            cursor.close()
+            if row is None:
+                return "DOUBLE"
+            emb_csv = str(row[0])
+            sample = ",".join(emb_csv.split(",")[:2])
+            for dtype in ("FLOAT", "DOUBLE"):
+                try:
+                    c2 = self.conn.cursor()
+                    c2.execute(
+                        f"SELECT VECTOR_COSINE(emb, TO_VECTOR(?, {dtype})) FROM {_table('kg_NodeEmbeddings')} WHERE emb IS NOT NULL LIMIT 1",
+                        [sample],
+                    )
+                    c2.fetchone()
+                    c2.close()
+                    logger.info("Auto-detected stored vector dtype: %s", dtype)
+                    return dtype
+                except Exception:
+                    pass
+        except Exception:
+            pass
+        return "DOUBLE"
+
     def _build_index_registry(self) -> Dict[str, str]:
         registry: Dict[str, str] = {}
         try:
@@ -5059,69 +5091,89 @@ class IRISGraphEngine:
     def _kg_KNN_VEC_python_optimized(
         self, query_vector: str, k: int = 50, label_filter: Optional[str] = None
     ) -> List[Tuple[str, float]]:
-        """
-        Fallback Python implementation using CSV parsing
-        Performance: ~5.8s for 20K vectors (when HNSW not available)
-        """
+        _dtype = getattr(self, 'vector_dtype', 'DOUBLE')
+        emb_table = _table("kg_NodeEmbeddings")
+        labels_table = _table("rdf_labels")
+
+        if label_filter:
+            sql = (
+                f"SELECT TOP {int(k)} n.id, VECTOR_COSINE(n.emb, TO_VECTOR(?, {_dtype})) AS score"
+                f" FROM {emb_table} n"
+                f" LEFT JOIN {labels_table} L ON L.s = n.id"
+                f" WHERE L.label = ?"
+                f" ORDER BY score DESC"
+            )
+            params = [query_vector, label_filter]
+        else:
+            sql = (
+                f"SELECT TOP {int(k)} n.id, VECTOR_COSINE(n.emb, TO_VECTOR(?, {_dtype})) AS score"
+                f" FROM {emb_table} n"
+                f" ORDER BY score DESC"
+            )
+            params = [query_vector]
+
+        try:
+            from iris_vector_graph.embedded import _sql_statement_execute, _is_ddtab_error
+            rs = _sql_statement_execute(sql, params)
+            results = [(row[0], float(row[1])) for row in rs if row[0] is not None]
+            return results
+        except Exception:
+            pass
+
+        try:
+            cursor = self.conn.cursor()
+            cursor.execute(sql, params)
+            results = [(row[0], float(row[1])) for row in cursor.fetchall()]
+            cursor.close()
+            return results
+        except Exception:
+            pass
+
+        return self._kg_KNN_VEC_client_side(query_vector, k, label_filter)
+
+    def _kg_KNN_VEC_client_side(
+        self, query_vector: str, k: int = 50, label_filter: Optional[str] = None
+    ) -> List[Tuple[str, float]]:
         cursor = self.conn.cursor()
         try:
             import numpy as np
 
             query_array = np.array(json.loads(query_vector))
 
-            # Get embeddings with optional label filter (optimized query)
             emb_table = _table("kg_NodeEmbeddings")
             labels_table = _table("rdf_labels")
             if label_filter is None:
-                sql = f"""
-                    SELECT n.id, n.emb
-                    FROM {emb_table} n
-                    WHERE n.emb IS NOT NULL
-                """
-                cursor.execute(sql)
+                cursor.execute(f"SELECT n.id, n.emb FROM {emb_table} n WHERE n.emb IS NOT NULL")
             else:
-                sql = f"""
-                    SELECT n.id, n.emb
-                    FROM {emb_table} n
-                    LEFT JOIN {labels_table} L ON L.s = n.id
-                    WHERE n.emb IS NOT NULL
-                      AND L.label = ?
-                """
-                cursor.execute(sql, [label_filter])
-
-            # Compute similarities efficiently
-            similarities = []
-            batch_size = 1000  # Process in batches for memory efficiency
+                cursor.execute(
+                    f"SELECT n.id, n.emb FROM {emb_table} n"
+                    f" LEFT JOIN {labels_table} L ON L.s = n.id"
+                    f" WHERE n.emb IS NOT NULL AND L.label = ?",
+                    [label_filter],
+                )
 
+            similarities = []
             while True:
-                batch = cursor.fetchmany(batch_size)
+                batch = cursor.fetchmany(1000)
                 if not batch:
                     break
-
                 for entity_id, emb_csv in batch:
                     try:
-                        # Fast CSV parsing to numpy array
-                        emb_array = np.fromstring(emb_csv, dtype=float, sep=",")
-
-                        # Compute cosine similarity efficiently
+                        emb_array = np.fromstring(str(emb_csv), dtype=float, sep=",")
                         dot_product = np.dot(query_array, emb_array)
                         query_norm = np.linalg.norm(query_array)
                         emb_norm = np.linalg.norm(emb_array)
-
                         if query_norm > 0 and emb_norm > 0:
                             cos_sim = dot_product / (query_norm * emb_norm)
                             similarities.append((entity_id, float(cos_sim)))
-
                     except Exception:
-                        # Skip problematic embeddings
                         continue
 
-            # Sort by similarity and return top k
             similarities.sort(key=lambda x: x[1], reverse=True)
             return similarities[:k]
 
         except Exception as e:
-            logger.error(f"Python optimized kg_KNN_VEC failed: {e}")
+            logger.error(f"Client-side kg_KNN_VEC failed: {e}")
             raise
         finally:
             cursor.close()
@@ -6755,3 +6807,78 @@ class IRISGraphEngine:
     def kg_RERANK(self, top_n: int, query_vector: str, query_text: str):
         return self.kg_RRF_FUSE(k=top_n, k1=top_n * 2, k2=top_n * 2, c=60,
                                  query_vector=query_vector, query_text=query_text)
+
+    def get_node_properties(self, node_id: str) -> Dict[str, Any]:
+        node = self.get_node(node_id)
+        return node.get("properties", {}) if node else {}
+
+    def get_node_name(self, node_id: str) -> Optional[str]:
+        props = self.get_node_properties(node_id)
+        return props.get("name") or props.get("label") or props.get("title")
+
+    def get_nodes_by_ids(self, node_ids: List[str]) -> List[Dict[str, Any]]:
+        if not node_ids:
+            return []
+        return self.get_nodes(node_ids)
+
+    def node_count(self) -> int:
+        result = self.execute_cypher("MATCH (n) RETURN count(n) AS c")
+        rows = result.get("rows") or []
+        return int(rows[0][0]) if rows else 0
+
+    def edge_count(self) -> int:
+        result = self.execute_cypher("MATCH ()-[r]->() RETURN count(r) AS c")
+        rows = result.get("rows") or []
+        return int(rows[0][0]) if rows else 0
+
+    def embedding_count(self) -> int:
+        cursor = self.conn.cursor()
+        try:
+            cursor.execute(f"SELECT COUNT(*) FROM {_table('kg_NodeEmbeddings')}")
+            row = cursor.fetchone()
+            return int(row[0]) if row else 0
+        except Exception:
+            return 0
+        finally:
+            cursor.close()
+
+    def store_node(self, node_id: str, properties: Optional[Dict[str, Any]] = None,
+                   labels: Optional[List[str]] = None) -> bool:
+        cursor = self.conn.cursor()
+        try:
+            cursor.execute(
+                f"INSERT OR IGNORE INTO {_table('nodes')} (node_id) VALUES (?)", [node_id]
+            )
+            self.conn.commit()
+        except Exception:
+            pass
+        finally:
+            cursor.close()
+        if properties:
+            for k, v in (properties or {}).items():
+                val_str = json.dumps(v) if isinstance(v, (dict, list)) else str(v)
+                cursor2 = self.conn.cursor()
+                try:
+                    cursor2.execute(
+                        f"INSERT OR REPLACE INTO {_table('rdf_props')} (s, \"key\", val) VALUES (?, ?, ?)",
+                        [node_id, k, val_str]
+                    )
+                    self.conn.commit()
+                except Exception:
+                    pass
+                finally:
+                    cursor2.close()
+        if labels:
+            for lbl in labels:
+                cursor3 = self.conn.cursor()
+                try:
+                    cursor3.execute(
+                        f"INSERT OR IGNORE INTO {_table('rdf_labels')} (s, label) VALUES (?, ?)",
+                        [node_id, lbl]
+                    )
+                    self.conn.commit()
+                except Exception:
+                    pass
+                finally:
+                    cursor3.close()
+        return True

{iris_vector_graph-1.91.1 → iris_vector_graph-1.91.3}/pyproject.toml

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

{iris_vector_graph-1.91.1 → iris_vector_graph-1.91.3}/tests/e2e/test_embedded_wgproto_e2e.py

@@ -715,3 +715,152 @@ return f"OK inlined={inlined[:50]}"
 """)
         assert "OK inlined=" in out, f"Large param list failed: {out}"
         assert "?" not in out.split("OK inlined=")[-1].split("\n")[0], f"Unresolved ? in inlined: {out}"
+
+
+@requires_enterprise
+class TestNewEngineAPIsRealIRIS:
+
+    def test_node_count_returns_int(self):
+        out = _compile_and_run_py_method(ENTERPRISE_CONTAINER, """
+from iris_vector_graph.embedded import EmbeddedConnection
+from iris_vector_graph.engine import IRISGraphEngine
+conn = EmbeddedConnection()
+engine = IRISGraphEngine(conn, embedding_dimension=4)
+cnt = engine.node_count()
+return f"OK cnt={cnt} type={type(cnt).__name__}"
+""")
+        assert "OK" in out, f"node_count failed: {out}"
+        assert "type=int" in out
+
+    def test_edge_count_returns_int(self):
+        out = _compile_and_run_py_method(ENTERPRISE_CONTAINER, """
+from iris_vector_graph.embedded import EmbeddedConnection
+from iris_vector_graph.engine import IRISGraphEngine
+conn = EmbeddedConnection()
+engine = IRISGraphEngine(conn, embedding_dimension=4)
+cnt = engine.edge_count()
+return f"OK cnt={cnt} type={type(cnt).__name__}"
+""")
+        assert "OK" in out, f"edge_count failed: {out}"
+
+    def test_embedding_count_returns_int(self):
+        out = _compile_and_run_py_method(ENTERPRISE_CONTAINER, """
+from iris_vector_graph.embedded import EmbeddedConnection
+from iris_vector_graph.engine import IRISGraphEngine
+conn = EmbeddedConnection()
+engine = IRISGraphEngine(conn, embedding_dimension=4)
+cnt = engine.embedding_count()
+return f"OK cnt={cnt} type={type(cnt).__name__}"
+""")
+        assert "OK" in out, f"embedding_count failed: {out}"
+
+
+    @pytest.mark.skipif(
+        os.environ.get('RUN_EMBEDDED_WGPROTO_SUITE', 'false').lower() != 'true',
+        reason='Requires full wgproto context; set RUN_EMBEDDED_WGPROTO_SUITE=true'
+    )
+    def test_get_node_properties_returns_dict(self):
+        pfx = f"gprop_{uuid.uuid4().hex[:8]}"
+        out = _compile_and_run_py_method(ENTERPRISE_CONTAINER, f"""
+from iris_vector_graph.embedded import EmbeddedConnection
+from iris_vector_graph.engine import IRISGraphEngine
+conn = EmbeddedConnection()
+engine = IRISGraphEngine(conn, embedding_dimension=4)
+nid = "{pfx}:N1"
+engine.create_node(nid, properties={{"name": "TestNode", "score": "42"}})
+props = engine.get_node_properties(nid)
+name = engine.get_node_name(nid)
+engine.delete_node(nid)
+return f"OK props={{type(props).__name__}} name={{name}}"
+""")
+        assert "OK props=dict" in out, f"get_node_properties failed: {out}"
+        assert "name=TestNode" in out, f"get_node_name failed: {out}"
+
+
+    @pytest.mark.skipif(
+        os.environ.get('RUN_EMBEDDED_WGPROTO_SUITE', 'false').lower() != 'true',
+        reason='Requires full wgproto context; set RUN_EMBEDDED_WGPROTO_SUITE=true'
+    )
+    def test_get_nodes_by_ids_batch(self):
+        pfx = f"gnids_{uuid.uuid4().hex[:8]}"
+        out = _compile_and_run_py_method(ENTERPRISE_CONTAINER, f"""
+from iris_vector_graph.embedded import EmbeddedConnection
+from iris_vector_graph.engine import IRISGraphEngine
+conn = EmbeddedConnection()
+engine = IRISGraphEngine(conn, embedding_dimension=4)
+ids = ["{pfx}:N{{i}}" for i in range(3)]
+for nid in ids:
+    engine.create_node(nid, properties={{"name": f"Node{{nid[-1]}}"}})
+results = engine.get_nodes_by_ids(ids)
+for nid in ids:
+    engine.delete_node(nid)
+return f"OK count={{len(results)}}"
+""")
+        assert "OK count=3" in out, f"get_nodes_by_ids failed: {out}"
+
+
+    @pytest.mark.skipif(
+        os.environ.get('RUN_EMBEDDED_WGPROTO_SUITE', 'false').lower() != 'true',
+        reason='Requires full wgproto context; set RUN_EMBEDDED_WGPROTO_SUITE=true'
+    )
+    def test_store_node_upsert_idempotent(self):
+        pfx = f"snode_{uuid.uuid4().hex[:8]}"
+        out = _compile_and_run_py_method(ENTERPRISE_CONTAINER, f"""
+from iris_vector_graph.embedded import EmbeddedConnection
+from iris_vector_graph.engine import IRISGraphEngine
+conn = EmbeddedConnection()
+engine = IRISGraphEngine(conn, embedding_dimension=4)
+nid = "{pfx}:N1"
+engine.store_node(nid, properties={{"name": "First"}})
+engine.store_node(nid, properties={{"name": "Updated"}})
+props = engine.get_node_properties(nid)
+engine.delete_node(nid)
+return f"OK name={{props.get('name', 'MISSING')}}"
+""")
+        assert "OK name=Updated" in out, f"store_node upsert failed: {out}"
+
+    def test_detect_stored_vector_dtype(self):
+        out = _compile_and_run_py_method(ENTERPRISE_CONTAINER, """
+from iris_vector_graph.embedded import EmbeddedConnection
+from iris_vector_graph.engine import IRISGraphEngine
+conn = EmbeddedConnection()
+engine = IRISGraphEngine(conn, embedding_dimension=4)
+dtype = engine.vector_dtype
+return f"OK dtype={dtype}"
+""")
+        assert "OK dtype=" in out, f"vector_dtype detection failed: {out}"
+        detected = out.split("dtype=")[1].split("\n")[0].strip()
+        assert detected in ("FLOAT", "DOUBLE"), f"Unexpected dtype: {detected}"
+
+
+    @pytest.mark.skipif(
+        os.environ.get('RUN_EMBEDDED_WGPROTO_SUITE', 'false').lower() != 'true',
+        reason='Requires full wgproto context; set RUN_EMBEDDED_WGPROTO_SUITE=true'
+    )
+    def test_sql_statement_fallback_for_vector_tables(self):
+        out = _compile_and_run_py_method(ENTERPRISE_CONTAINER, """
+import iris
+from iris_vector_graph.embedded import _sql_statement_execute
+
+rs = _sql_statement_execute("SELECT TOP 1 1 AS n")
+rows = list(rs)
+return f"OK rows={len(rows)}"
+""")
+        assert "OK" in out, f"_sql_statement_execute failed: {out}"
+
+
+    @pytest.mark.skipif(
+        os.environ.get('RUN_EMBEDDED_WGPROTO_SUITE', 'false').lower() != 'true',
+        reason='Requires full wgproto context; set RUN_EMBEDDED_WGPROTO_SUITE=true'
+    )
+    def test_all_three_fallbacks_transparent_to_execute_cypher(self):
+        out = _compile_and_run_py_method(ENTERPRISE_CONTAINER, """
+from iris_vector_graph.embedded import EmbeddedConnection
+from iris_vector_graph.engine import IRISGraphEngine
+conn = EmbeddedConnection()
+engine = IRISGraphEngine(conn, embedding_dimension=4)
+r1 = engine.execute_cypher("MATCH (n) RETURN count(n) AS c")
+r2 = engine.execute_cypher("MATCH ()-[r]->() RETURN count(r) AS c")
+return f"OK nodes={r1.get('rows',[])} edges={r2.get('rows',[])}"
+""")
+        assert "OK" in out, f"execute_cypher with all fallbacks failed: {out}"