iris-vector-graph 1.59.0__tar.gz → 1.59.2__tar.gz

{iris_vector_graph-1.59.0 → iris_vector_graph-1.59.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: iris-vector-graph
-Version: 1.59.0
+Version: 1.59.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
@@ -655,6 +655,14 @@ anchors = engine.get_kg_anchors(icd_codes=["J18.0", "E11.9"])
 
 ## Changelog
 
+### v1.59.2 (2026-04-24)
+- fix: Cypher `WHERE x IN $param` and `WHERE x IN [list]` now correctly emit `IN (?,?,?)` — previously emitted `IN ?` which IRIS DBAPI can't expand. Enables batch multi-node queries like `MATCH (a)-[r]-(b) WHERE a.id IN $node_ids RETURN ...` (20× speedup for 2-hop expansion vs N sequential queries).
+
+
+### v1.59.1 (2026-04-21)
+- perf: `embed_nodes()` and `embed_edges()` — 4–10x speedup for SentenceTransformer embedders: batch `model.encode(texts_list)` replaces N serial calls; `executemany()` replaces N per-row INSERTs; batch `DELETE WHERE id IN (...)` replaces N individual DELETEs. Estimated 94min → 10–25min for 205K nodes. Falls back gracefully for non-SentenceTransformer embedders and IRIS EMBEDDING() path.
+
+
 ### v1.59.0 (2026-04-21)
 - feat: `embed_edges(model, text_fn, where, batch_size, force, progress_callback)` — embed every `(s, p, o_id)` triple into `kg_EdgeEmbeddings(VECTOR(DOUBLE))` (spec 065)
 - feat: `edge_vector_search(query_embedding, top_k, score_threshold)` — cosine similarity search over edge embeddings

{iris_vector_graph-1.59.0 → iris_vector_graph-1.59.2}/README.md

@@ -583,6 +583,14 @@ anchors = engine.get_kg_anchors(icd_codes=["J18.0", "E11.9"])
 
 ## Changelog
 
+### v1.59.2 (2026-04-24)
+- fix: Cypher `WHERE x IN $param` and `WHERE x IN [list]` now correctly emit `IN (?,?,?)` — previously emitted `IN ?` which IRIS DBAPI can't expand. Enables batch multi-node queries like `MATCH (a)-[r]-(b) WHERE a.id IN $node_ids RETURN ...` (20× speedup for 2-hop expansion vs N sequential queries).
+
+
+### v1.59.1 (2026-04-21)
+- perf: `embed_nodes()` and `embed_edges()` — 4–10x speedup for SentenceTransformer embedders: batch `model.encode(texts_list)` replaces N serial calls; `executemany()` replaces N per-row INSERTs; batch `DELETE WHERE id IN (...)` replaces N individual DELETEs. Estimated 94min → 10–25min for 205K nodes. Falls back gracefully for non-SentenceTransformer embedders and IRIS EMBEDDING() path.
+
+
 ### v1.59.0 (2026-04-21)
 - feat: `embed_edges(model, text_fn, where, batch_size, force, progress_callback)` — embed every `(s, p, o_id)` triple into `kg_EdgeEmbeddings(VECTOR(DOUBLE))` (spec 065)
 - feat: `edge_vector_search(query_embedding, top_k, score_threshold)` — cosine similarity search over edge embeddings

{iris_vector_graph-1.59.0 → iris_vector_graph-1.59.2}/iris_vector_graph/cypher/translator.py

@@ -2026,6 +2026,21 @@ def translate_boolean_expression(expr, context) -> str:
         return f"{left} IS NULL"
     if op == ast.BooleanOperator.IS_NOT_NULL:
         return f"{left} IS NOT NULL"
+    if op == ast.BooleanOperator.IN:
+        if isinstance(right_expr, ast.Literal) and isinstance(right_expr.value, list):
+            items = right_expr.value
+            placeholders = ", ".join(
+                context.add_where_param(
+                    item.value if isinstance(item, ast.Literal) else item
+                )
+                for item in items
+            )
+            return f"{left} IN ({placeholders})"
+        if isinstance(right_expr, ast.Variable) and right_expr.name in context.input_params:
+            val = context.input_params[right_expr.name]
+            if isinstance(val, list):
+                placeholders = ", ".join(context.add_where_param(v) for v in val)
+                return f"{left} IN ({placeholders})"
     right = translate_expression(right_expr, context, segment="where")
     if op in (
         ast.BooleanOperator.LESS_THAN,

{iris_vector_graph-1.59.0 → iris_vector_graph-1.59.2}/iris_vector_graph/engine.py

@@ -3425,6 +3425,8 @@ class IRISGraphEngine:
                     node_id, key, val = row[0], row[1], row[2]
                     props_by_node.setdefault(node_id, {})[key] = val
 
+                texts: List[str] = []
+                valid_ids: List[str] = []
                 for node_id in batch_ids:
                     props = props_by_node.get(node_id, {})
                     if text_fn is not None:
@@ -3443,24 +3445,77 @@ class IRISGraphEngine:
                         skipped += 1
                         continue
 
-                    try:
-                        emb = self.embed_text(text)
-                        emb_str = ",".join(str(x) for x in emb)
+                    texts.append(text)
+                    valid_ids.append(node_id)
+
+                if not texts:
+                    self.conn.commit()
+                    n_done = batch_start + len(batch_ids)
+                    if progress_callback:
+                        progress_callback(n_done, n_to_embed)
+                    continue
+
+                try:
+                    use_batch = False
+                    if not self.embedding_config and self.embedder is not None:
                         try:
-                            cursor.execute(
-                                f"DELETE FROM {_table('kg_NodeEmbeddings')} WHERE id = ?",
-                                [node_id],
-                            )
-                        except Exception:
+                            from sentence_transformers import SentenceTransformer as _ST
+                            use_batch = isinstance(self.embedder, _ST)
+                        except ImportError:
                             pass
+                    if use_batch:
+                        raw = self.embedder.encode(
+                            texts, batch_size=min(64, len(texts)), show_progress_bar=False
+                        )
+                        embeddings = [row.tolist() for row in raw]
+                    else:
+                        embeddings = [self.embed_text(t) for t in texts]
+                except Exception as ex:
+                    logger.warning(f"embed_nodes: batch encode failed, falling back per-node: {ex}")
+                    embeddings = []
+                    for t in texts:
+                        try:
+                            embeddings.append(self.embed_text(t))
+                        except Exception as ex2:
+                            logger.warning(f"embed_nodes: embed_text failed: {ex2}")
+                            embeddings.append(None)
+
+                insert_params = []
+                for node_id, emb in zip(valid_ids, embeddings):
+                    if emb is None:
+                        errors += 1
+                        continue
+                    emb_str = ",".join(str(x) for x in emb)
+                    insert_params.append((node_id, emb_str))
+
+                if insert_params:
+                    ids_to_delete = [p[0] for p in insert_params]
+                    del_placeholders = ", ".join("?" * len(ids_to_delete))
+                    try:
                         cursor.execute(
+                            f"DELETE FROM {_table('kg_NodeEmbeddings')} WHERE id IN ({del_placeholders})",
+                            ids_to_delete,
+                        )
+                    except Exception:
+                        pass
+                    try:
+                        cursor.executemany(
                             f"INSERT INTO {_table('kg_NodeEmbeddings')} (id, emb) VALUES (?, TO_VECTOR(?))",
-                            [node_id, emb_str],
+                            insert_params,
                         )
-                        embedded += 1
+                        embedded += len(insert_params)
                     except Exception as ex:
-                        logger.warning(f"embed_nodes: failed to embed {node_id}: {ex}")
-                        errors += 1
+                        logger.warning(f"embed_nodes: executemany failed, falling back per-row: {ex}")
+                        for node_id, emb_str in insert_params:
+                            try:
+                                cursor.execute(
+                                    f"INSERT INTO {_table('kg_NodeEmbeddings')} (id, emb) VALUES (?, TO_VECTOR(?))",
+                                    [node_id, emb_str],
+                                )
+                                embedded += 1
+                            except Exception as ex2:
+                                logger.warning(f"embed_nodes: insert failed for {node_id}: {ex2}")
+                                errors += 1
 
                 self.conn.commit()
                 n_done = batch_start + len(batch_ids)
@@ -3531,6 +3586,8 @@ class IRISGraphEngine:
             for batch_start in range(0, n_to_embed, batch_size):
                 batch = to_embed[batch_start : batch_start + batch_size]
 
+                texts: List[str] = []
+                valid_edges: List[tuple] = []
                 for s, p, o_id in batch:
                     if text_fn is not None:
                         try:
@@ -3549,29 +3606,84 @@ class IRISGraphEngine:
                         skipped += 1
                         continue
 
-                    try:
-                        emb = self.embed_text(text)
-                        emb_str = ",".join(str(x) for x in emb)
+                    texts.append(text)
+                    valid_edges.append((s, p, o_id))
+
+                if not texts:
+                    self.conn.commit()
+                    n_done = batch_start + len(batch)
+                    if progress_callback:
+                        progress_callback(n_done, n_to_embed)
+                    continue
+
+                try:
+                    use_batch = False
+                    if not self.embedding_config and self.embedder is not None:
                         try:
-                            cursor.execute(
-                                f"DELETE FROM {_table('kg_EdgeEmbeddings')} "
-                                "WHERE s=? AND p=? AND o_id=?",
-                                [s, p, o_id],
-                            )
-                        except Exception:
+                            from sentence_transformers import SentenceTransformer as _ST
+                            use_batch = isinstance(self.embedder, _ST)
+                        except ImportError:
                             pass
-                        cursor.execute(
+                    if use_batch:
+                        raw = self.embedder.encode(texts, batch_size=min(64, len(texts)), show_progress_bar=False)
+                        embeddings = [row.tolist() for row in raw]
+                    else:
+                        embeddings = [self.embed_text(t) for t in texts]
+                except Exception as ex:
+                    logger.warning(f"embed_edges: batch encode failed, falling back per-edge: {ex}")
+                    embeddings = []
+                    for t in texts:
+                        try:
+                            embeddings.append(self.embed_text(t))
+                        except Exception as ex2:
+                            logger.warning(f"embed_edges: embed_text failed: {ex2}")
+                            embeddings.append(None)
+
+                insert_params = []
+                for (s, p, o_id), emb in zip(valid_edges, embeddings):
+                    if emb is None:
+                        errors += 1
+                        continue
+                    emb_str = ",".join(str(x) for x in emb)
+                    insert_params.append((s, p, o_id, emb_str))
+
+                if insert_params:
+                    try:
+                        del_params = [(p[0], p[1], p[2]) for p in insert_params]
+                        for s, p, o_id in del_params:
+                            try:
+                                cursor.execute(
+                                    f"DELETE FROM {_table('kg_EdgeEmbeddings')} "
+                                    "WHERE s=? AND p=? AND o_id=?",
+                                    [s, p, o_id],
+                                )
+                            except Exception:
+                                pass
+                    except Exception:
+                        pass
+                    try:
+                        cursor.executemany(
                             f"INSERT INTO {_table('kg_EdgeEmbeddings')} "
                             "(s, p, o_id, emb) VALUES (?, ?, ?, TO_VECTOR(?))",
-                            [s, p, o_id, emb_str],
+                            insert_params,
                         )
-                        embedded += 1
+                        embedded += len(insert_params)
                     except Exception as ex:
-                        logger.warning(
-                            "embed_edges: failed to embed (%s, %s, %s): %s",
-                            s, p, o_id, ex,
-                        )
-                        errors += 1
+                        logger.warning(f"embed_edges: executemany failed, falling back per-row: {ex}")
+                        for s, p, o_id, emb_str in insert_params:
+                            try:
+                                cursor.execute(
+                                    f"INSERT INTO {_table('kg_EdgeEmbeddings')} "
+                                    "(s, p, o_id, emb) VALUES (?, ?, ?, TO_VECTOR(?))",
+                                    [s, p, o_id, emb_str],
+                                )
+                                embedded += 1
+                            except Exception as ex2:
+                                logger.warning(
+                                    "embed_edges: insert failed for (%s, %s, %s): %s",
+                                    s, p, o_id, ex2,
+                                )
+                                errors += 1
 
                 self.conn.commit()
                 n_done = batch_start + len(batch)

{iris_vector_graph-1.59.0 → iris_vector_graph-1.59.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "iris-vector-graph"
-version = "1.59.0"
+version = "1.59.2"
 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.59.0 → iris_vector_graph-1.59.2}/tests/unit/test_cypher_translator.py

@@ -151,3 +151,33 @@ def test_anonymous_both_nodes_pattern():
     """MATCH ()-[r]->(b) works without crashing."""
     sql = translate_to_sql(parse_query("MATCH ()-[r]->(b) RETURN b.id LIMIT 3"))
     assert "rdf_edges" in sql.sql or "MatchEdges" in sql.sql
+
+
+def test_in_list_param_expands_placeholders():
+    """WHERE a.id IN $ids with a list param must produce IN (?,?,?) not IN ?."""
+    q = "MATCH (a)-[r]-(b) WHERE a.id IN $node_ids RETURN a.id AS src, type(r) AS rel, b.id AS dst LIMIT 100"
+    result = translate_to_sql(parse_query(q), {"node_ids": ["node1", "node2", "node3"]})
+    assert "IN (?, ?, ?)" in result.sql or "IN (?,?,?)" in result.sql.replace(" ", ""), \
+        f"Expected IN (?,?,?) expansion, got: {result.sql}"
+    params = result.parameters[0] if result.parameters else []
+    assert "node1" in params and "node2" in params and "node3" in params, \
+        f"Expected list values as individual params, got: {params}"
+    assert not any(isinstance(p, list) for p in params), \
+        f"No nested list should appear in params after expansion, got: {params}"
+
+
+def test_in_literal_list_expands_placeholders():
+    """WHERE a.id IN ['x','y','z'] must produce IN (?,?,?) not IN [literal]."""
+    q = "MATCH (a) WHERE a.id IN ['python','rust','go'] RETURN a.id"
+    result = translate_to_sql(parse_query(q), {})
+    assert "IN (?, ?, ?)" in result.sql or "IN (?,?,?)" in result.sql.replace(" ", ""), \
+        f"Expected IN (?,?,?) expansion for literal list, got: {result.sql}"
+    params = result.parameters[0] if result.parameters else []
+    assert "python" in params and "rust" in params and "go" in params
+
+
+def test_in_param_empty_list_handled():
+    """WHERE a.id IN $ids with empty list should not crash (returns no results)."""
+    q = "MATCH (a) WHERE a.id IN $ids RETURN a.id"
+    result = translate_to_sql(parse_query(q), {"ids": []})
+    assert result.sql is not None