iris-vector-graph 1.55.2__tar.gz → 1.56.0__tar.gz

{iris_vector_graph-1.55.2 → iris_vector_graph-1.56.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: iris-vector-graph
-Version: 1.55.2
+Version: 1.56.0
 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
@@ -556,6 +556,22 @@ anchors = engine.get_kg_anchors(icd_codes=["J18.0", "E11.9"])
 
 ## Changelog
 
+### v1.56.0 (2026-04-19)
+- feat: `CALL ivg.shortestPath.weighted(from, to, weightProp, maxCost, maxHops) YIELD path, totalCost` — Dijkstra minimum-cost path in pure ObjectScript
+- Uses edge weights from `^KG("out",0,...)` globals (set by create_edge WriteAdjacency)
+- Falls back to unit weight 1.0 when weightProp not found
+- Supports directed ("out") and undirected ("both") traversal
+- 4 E2E tests: prefer lower-cost longer path, no path, same source/target, unit weight fallback
+
+
+### v1.55.3 (2026-04-19)
+- fix: Bug 6 final — SQLCODE -400 on rdf_edges CREATE INDEX now debug-level (ALTER TABLE fallback handles it)
+- fix: type(r) now returns edge predicate column (e.p) not node_id
+- fix: id(n) now returns actual node_id column
+- feat: =~ regex match operator — translates to IRIS %MATCHES
+- fix: N-Quads import captures graph URI from quad's 4th element as graph_id
+
+
 ### v1.55.2 (2026-04-19)
 - fix: Bug 6 (final) — SQLCODE -400 on rdf_edges index creation now falls back to ALTER TABLE ADD INDEX; all standard indexes created even when Graph.KG.Edge class was never compiled
 

{iris_vector_graph-1.55.2 → iris_vector_graph-1.56.0}/README.md

@@ -484,6 +484,22 @@ anchors = engine.get_kg_anchors(icd_codes=["J18.0", "E11.9"])
 
 ## Changelog
 
+### v1.56.0 (2026-04-19)
+- feat: `CALL ivg.shortestPath.weighted(from, to, weightProp, maxCost, maxHops) YIELD path, totalCost` — Dijkstra minimum-cost path in pure ObjectScript
+- Uses edge weights from `^KG("out",0,...)` globals (set by create_edge WriteAdjacency)
+- Falls back to unit weight 1.0 when weightProp not found
+- Supports directed ("out") and undirected ("both") traversal
+- 4 E2E tests: prefer lower-cost longer path, no path, same source/target, unit weight fallback
+
+
+### v1.55.3 (2026-04-19)
+- fix: Bug 6 final — SQLCODE -400 on rdf_edges CREATE INDEX now debug-level (ALTER TABLE fallback handles it)
+- fix: type(r) now returns edge predicate column (e.p) not node_id
+- fix: id(n) now returns actual node_id column
+- feat: =~ regex match operator — translates to IRIS %MATCHES
+- fix: N-Quads import captures graph URI from quad's 4th element as graph_id
+
+
 ### v1.55.2 (2026-04-19)
 - fix: Bug 6 (final) — SQLCODE -400 on rdf_edges index creation now falls back to ALTER TABLE ADD INDEX; all standard indexes created even when Graph.KG.Edge class was never compiled
 

{iris_vector_graph-1.55.2 → iris_vector_graph-1.56.0}/iris_src/src/Graph/KG/Traversal.cls

@@ -494,4 +494,150 @@ ClassMethod BacktrackPath(srcId As %String, dstId As %String, depth As %Integer)
 	Return path
 }
 
+ClassMethod DijkstraJson(srcId As %String, dstId As %String, weightProp As %String = "", maxCost As %Double = 9999, maxHops As %Integer = 10, direction As %String = "out") As %String
+{
+	Kill ^||Dij.pq, ^||Dij.parent, ^||Dij.seen, ^||Dij.dist
+
+	Set srcId = $Get(srcId, "")
+	Set dstId = $Get(dstId, "")
+	Set weightProp = $Get(weightProp, "")
+
+	If srcId = "" || (dstId = "") {
+		Kill ^||Dij.pq, ^||Dij.parent, ^||Dij.seen, ^||Dij.dist
+		Return "{}"
+	}
+
+	If srcId = dstId {
+		Set result = ##class(%DynamicObject).%New()
+		Set nodes = ##class(%DynamicArray).%New()
+		Do nodes.%Push(srcId)
+		Do result.%Set("nodes", nodes)
+		Do result.%Set("rels", ##class(%DynamicArray).%New())
+		Do result.%Set("costs", ##class(%DynamicArray).%New())
+		Do result.%Set("length", 0)
+		Do result.%Set("totalCost", 0)
+		Kill ^||Dij.pq, ^||Dij.parent, ^||Dij.seen, ^||Dij.dist
+		Return result.%ToJSON()
+	}
+
+	Set ^||Dij.pq(0, srcId) = ""
+	Set ^||Dij.dist(srcId) = 0
+
+	For {
+		Set minCost = $Order(^||Dij.pq(""))
+		Quit:minCost=""
+		Set curNode = $Order(^||Dij.pq(minCost, ""))
+		Quit:curNode=""
+		Kill ^||Dij.pq(minCost, curNode)
+
+		If $Data(^||Dij.seen(curNode)) Continue
+		Set ^||Dij.seen(curNode) = ""
+
+		If curNode = dstId {
+			Set result = ..DijkstraBacktrack(srcId, dstId, +minCost)
+			Kill ^||Dij.pq, ^||Dij.parent, ^||Dij.seen, ^||Dij.dist
+			Return result
+		}
+
+		If minCost >= maxCost Continue
+
+		If direction = "out" || (direction = "both") {
+			Set p = ""
+			For {
+				Set p = $Order(^KG("out", 0, curNode, p))
+				Quit:p=""
+				Set neighbor = ""
+				For {
+					Set neighbor = $Order(^KG("out", 0, curNode, p, neighbor))
+					Quit:neighbor=""
+					If $Data(^||Dij.seen(neighbor)) Continue
+					Set rawW = $Get(^KG("out", 0, curNode, p, neighbor), 1)
+					Set edgeW = +rawW
+					If edgeW <= 0 Set edgeW = 1.0
+					Set newCost = minCost + edgeW
+					If newCost > maxCost Continue
+					If '$Data(^||Dij.seen(neighbor)) {
+						If '$Data(^||Dij.dist(neighbor)) || (newCost < ^||Dij.dist(neighbor)) {
+							Set ^||Dij.dist(neighbor) = newCost
+							Set ^||Dij.pq(newCost, neighbor) = ""
+							Set ^||Dij.parent(neighbor) = $ListBuild(curNode, p, edgeW)
+						}
+					}
+				}
+			}
+		}
+
+		If direction = "both" {
+			Set p = ""
+			For {
+				Set p = $Order(^KG("in", 0, curNode, p))
+				Quit:p=""
+				Set neighbor = ""
+				For {
+					Set neighbor = $Order(^KG("in", 0, curNode, p, neighbor))
+					Quit:neighbor=""
+					If $Data(^||Dij.seen(neighbor)) Continue
+					Set rawW = $Get(^KG("in", 0, curNode, p, neighbor), 1)
+					Set edgeW = +rawW
+					If edgeW <= 0 Set edgeW = 1.0
+					Set newCost = minCost + edgeW
+					If newCost > maxCost Continue
+					If '$Data(^||Dij.dist(neighbor)) || (newCost < ^||Dij.dist(neighbor)) {
+						Set ^||Dij.dist(neighbor) = newCost
+						Set ^||Dij.pq(newCost, neighbor) = ""
+						Set ^||Dij.parent(neighbor) = $ListBuild(curNode, p, edgeW)
+					}
+				}
+			}
+		}
+	}
+
+	Kill ^||Dij.pq, ^||Dij.parent, ^||Dij.seen, ^||Dij.dist
+	Return "{}"
+}
+
+ClassMethod DijkstraBacktrack(srcId As %String, dstId As %String, totalCost As %Double) As %String [ Private ]
+{
+	Set nodeStack = $ListBuild(dstId)
+	Set relStack = ""
+	Set costStack = ""
+	Set cur = dstId
+
+	While cur '= srcId {
+		Set lb = $Get(^||Dij.parent(cur))
+		If lb = "" Quit
+		Set parentNode = $ListGet(lb, 1)
+		Set relType = $ListGet(lb, 2)
+		Set edgeCost = +$ListGet(lb, 3)
+		Set nodeStack = $ListBuild(parentNode) _ nodeStack
+		Set relStack = $ListBuild(relType) _ relStack
+		Set costStack = $ListBuild(edgeCost) _ costStack
+		Set cur = parentNode
+	}
+
+	Set nodes = ##class(%DynamicArray).%New()
+	Set rels = ##class(%DynamicArray).%New()
+	Set costs = ##class(%DynamicArray).%New()
+
+	Set ptr = 0
+	While $ListNext(nodeStack, ptr, n) { Do nodes.%Push(n) }
+	Set ptr = 0
+	While $ListNext(relStack, ptr, r) { Do rels.%Push(r) }
+	Set ptr = 0
+	While $ListNext(costStack, ptr, c) { Do costs.%Push(+c) }
+
+	Set result = ##class(%DynamicObject).%New()
+	Do result.%Set("nodes", nodes)
+	Do result.%Set("rels", rels)
+	Do result.%Set("costs", costs)
+	Do result.%Set("length", nodes.%Size() - 1)
+	Do result.%Set("totalCost", totalCost)
+	Return result.%ToJSON()
+}
+
+ClassMethod DijkstraProc(srcId As %String, dstId As %String, weightProp As %String = "", maxCost As %Double = 9999, maxHops As %Integer = 10, direction As %String = "out") As %String [ SqlProc, SqlName = DijkstraPath ]
+{
+	Quit ..DijkstraJson(srcId, dstId, weightProp, maxCost, maxHops, direction)
+}
+
 }

{iris_vector_graph-1.55.2 → iris_vector_graph-1.56.0}/iris_vector_graph/cypher/ast.py

@@ -42,6 +42,7 @@ class BooleanOperator(Enum):
     STARTS_WITH = "STARTS WITH"
     ENDS_WITH = "ENDS WITH"
     CONTAINS = "CONTAINS"
+    REGEX_MATCH = "=~"
 
 
 # ==============================================================================

{iris_vector_graph-1.55.2 → iris_vector_graph-1.56.0}/iris_vector_graph/cypher/lexer.py

@@ -77,6 +77,8 @@ class TokenType(enum.Enum):
     MINUS = "-"
     STAR = "*"
     SLASH = "/"
+    TILDE = "~"
+    REGEX_MATCH = "=~"
     PERCENT = "%"
     CARET = "^"
     FOREACH = "FOREACH"
@@ -148,7 +150,12 @@ class Lexer:
                 case "^":
                     self._add_token(TokenType.CARET, char)
                 case "=":
-                    self._add_token(TokenType.EQUALS, char)
+                    if self._peek() == "~":
+                        self.cursor += 1
+                        self.column += 1
+                        self._add_token(TokenType.REGEX_MATCH, "=~")
+                    else:
+                        self._add_token(TokenType.EQUALS, char)
                 case "<":
                     if self._peek() == ">":
                         self.cursor += 1

{iris_vector_graph-1.55.2 → iris_vector_graph-1.56.0}/iris_vector_graph/cypher/parser.py

@@ -838,6 +838,8 @@ class Parser:
                 already_consumed = True
             case TokenType.CONTAINS:
                 op = ast.BooleanOperator.CONTAINS
+            case TokenType.REGEX_MATCH:
+                op = ast.BooleanOperator.REGEX_MATCH
             case TokenType.IN:
                 op = ast.BooleanOperator.IN
             case TokenType.IS:

{iris_vector_graph-1.55.2 → iris_vector_graph-1.56.0}/iris_vector_graph/cypher/translator.py

@@ -247,10 +247,11 @@ def translate_procedure_call(
 
     Supported procedures:
     - ivg.vector.search(label, property, query_input, limit [, options])
-    - ivg.neighbors(source_node_or_list, predicate, direction)
-    - ivg.ppr(seed_node_or_list, alpha, max_iterations)
-    - ivg.bm25.search(name, query, k)
-    - ivg.ivf.search(name, query_vec, k, nprobe)
+     - ivg.neighbors(source_node_or_list, predicate, direction)
+     - ivg.ppr(seed_node_or_list, alpha, max_iterations)
+     - ivg.bm25.search(name, query, k)
+     - ivg.ivf.search(name, query_vec, k, nprobe)
+     - ivg.shortestPath.weighted(from, to, weightProp, maxCost, maxHops)
     """
     name = proc.procedure_name
     if name == "ivg.vector.search":
@@ -263,9 +264,11 @@ def translate_procedure_call(
         _translate_bm25_search(proc, context)
     elif name == "ivg.ivf.search":
         _translate_ivf_search(proc, context)
+    elif name == "ivg.shortestpath.weighted" or name == "ivg.shortestPath.weighted":
+        _translate_weighted_shortest_path(proc, context)
     else:
         raise ValueError(
-            f"Unknown procedure: {name!r}. Supported: ivg.vector.search, ivg.neighbors, ivg.ppr, ivg.bm25.search, ivg.ivf.search"
+            f"Unknown procedure: {name!r}. Supported: ivg.vector.search, ivg.neighbors, ivg.ppr, ivg.bm25.search, ivg.ivf.search, ivg.shortestPath.weighted"
         )
 
 
@@ -653,6 +656,66 @@ def _translate_ivf_search(
         context.scalar_variables.add("score")
 
 
+def _translate_weighted_shortest_path(
+    proc: ast.CypherProcedureCall, context: TranslationContext
+) -> None:
+    args = proc.arguments
+    if len(args) < 2:
+        raise ValueError(
+            "ivg.shortestPath.weighted requires at least 2 arguments: from, to"
+        )
+
+    from_id = _resolve_arg(args[0], context, "ivg.shortestPath.weighted")
+    to_id = _resolve_arg(args[1], context, "ivg.shortestPath.weighted")
+    weight_prop = (
+        str(_resolve_arg(args[2], context, "ivg.shortestPath.weighted"))
+        if len(args) > 2
+        else "weight"
+    )
+    max_cost = (
+        float(_resolve_arg(args[3], context, "ivg.shortestPath.weighted"))
+        if len(args) > 3
+        else 9999.0
+    )
+    max_hops = (
+        int(_resolve_arg(args[4], context, "ivg.shortestPath.weighted"))
+        if len(args) > 4
+        else 10
+    )
+    direction = (
+        str(_resolve_arg(args[5], context, "ivg.shortestPath.weighted"))
+        if len(args) > 5
+        else "out"
+    )
+
+    if not isinstance(from_id, str) or not isinstance(to_id, str):
+        raise ValueError(
+            "ivg.shortestPath.weighted: from and to must be string literals or $param"
+        )
+
+    context.var_length_paths.append(
+        {
+            "weighted": True,
+            "src_id_param": from_id
+            if not isinstance(from_id, str) or from_id.startswith("$")
+            else f"'{from_id}'",
+            "dst_id_param": to_id
+            if not isinstance(to_id, str) or to_id.startswith("$")
+            else f"'{to_id}'",
+            "weight_prop": weight_prop,
+            "max_cost": max_cost,
+            "max_hops": max_hops,
+            "direction": direction,
+            "return_path_funcs": list(proc.yield_items),
+        }
+    )
+
+    for item in proc.yield_items:
+        if item in ("path", "totalCost", "totalcost", "node"):
+            context.variable_aliases[item] = "WS"
+            context.scalar_variables.add(item)
+
+
 _TEMPORAL_TS_OPS = {
     ast.BooleanOperator.GREATER_THAN_OR_EQUAL,
     ast.BooleanOperator.LESS_THAN_OR_EQUAL,
@@ -1979,6 +2042,8 @@ def translate_boolean_expression(expr, context) -> str:
         return f"{left} LIKE ('%' || {right})"
     if op == ast.BooleanOperator.CONTAINS:
         return f"{left} LIKE ('%' || {right} || '%')"
+    if op == ast.BooleanOperator.REGEX_MATCH:
+        return f"{left} %MATCHES {right}"
     if op == ast.BooleanOperator.IN:
         return f"{left} IN {right}"
     raise ValueError(f"Unsupported operator: {op}")
@@ -2310,8 +2375,22 @@ def translate_expression(expr, context, segment="select") -> str:
         fn, args_exprs = expr.function_name.lower(), expr.arguments
         args = [translate_expression(a, context, segment=segment) for a in args_exprs]
 
-        if fn in ("id", "type"):
+        if fn == "type":
+            if args_exprs and isinstance(args_exprs[0], ast.Variable):
+                var_name = args_exprs[0].name
+                alias = context.variable_aliases.get(var_name, "")
+                if alias:
+                    return f"{alias}.p"
+            return args[0] if args else "NULL"
+
+        if fn == "id":
+            if args_exprs and isinstance(args_exprs[0], ast.Variable):
+                var_name = args_exprs[0].name
+                alias = context.variable_aliases.get(var_name, "")
+                if alias:
+                    return f"{alias}.node_id"
             return args[0] if args else "NULL"
+
         if fn == "labels":
             return labels_subquery(args[0] if args else "NULL")
         if fn == "properties":

{iris_vector_graph-1.55.2 → iris_vector_graph-1.56.0}/iris_vector_graph/engine.py

@@ -469,10 +469,28 @@ class IRISGraphEngine:
                     and "already has a" not in err
                     and "already has index" not in err
                 ):
-                    if any(
-                        p in err or p in stmt.lower() for p in _OPTIONAL_DDL_PATTERNS
+                    import re as _re_ddl
+
+                    _sqlcode = _re_ddl.search(
+                        r"sqlcode.*?<(-?\d+)>", err
+                    ) or _re_ddl.search(r"<(-\d+)>", err)
+                    _sqlcode_val = _sqlcode.group(1) if _sqlcode else ""
+                    is_index_on_rdf_edges = (
+                        _sqlcode_val == "-400"
+                        and "rdf_edges" in stmt.lower()
+                        and "create index" in stmt.lower()
+                    )
+                    if (
+                        any(
+                            p in err or p in stmt.lower()
+                            for p in _OPTIONAL_DDL_PATTERNS
+                        )
+                        or is_index_on_rdf_edges
                     ):
-                        logger.debug("Optional DDL skipped: %s", stmt[:80])
+                        logger.debug(
+                            "Optional DDL skipped (will retry via ALTER TABLE): %s",
+                            stmt[:80],
+                        )
                     else:
                         logger.warning(
                             "Schema setup warning: %s | Statement: %.100s", e, stmt
@@ -782,6 +800,8 @@ class IRISGraphEngine:
 
         if sql_query.var_length_paths:
             vl0 = sql_query.var_length_paths[0]
+            if vl0.get("weighted"):
+                return self._execute_weighted_shortest_path(sql_query, parameters)
             if vl0.get("shortest") or vl0.get("all_shortest"):
                 return self._execute_shortest_path_cypher(sql_query, parameters)
             return self._execute_var_length_cypher(sql_query, parameters)
@@ -847,6 +867,109 @@ class IRISGraphEngine:
                 "metadata": metadata,
             }
 
+    def _execute_weighted_shortest_path(
+        self, sql_query, parameters=None
+    ) -> Dict[str, Any]:
+        import json as _json
+
+        vl = sql_query.var_length_paths[0]
+
+        def _resolve(param_ref):
+            if param_ref is None:
+                return None
+            s = str(param_ref)
+            if s.startswith("'") and s.endswith("'"):
+                return s[1:-1]
+            if s.startswith("$"):
+                name = s[1:]
+                if parameters and name in parameters:
+                    return str(parameters[name])
+                return None
+            return s
+
+        source_id = _resolve(vl.get("src_id_param"))
+        target_id = _resolve(vl.get("dst_id_param"))
+
+        if source_id is None or target_id is None:
+            raise ValueError(
+                "ivg.shortestPath.weighted requires both from and to to be bound IDs"
+            )
+
+        weight_prop = vl.get("weight_prop", "weight") or "weight"
+        max_cost = float(vl.get("max_cost", 9999))
+        max_hops = int(vl.get("max_hops", 10))
+        direction = vl.get("direction", "out") or "out"
+
+        try:
+            raw = _call_classmethod(
+                self.conn,
+                "Graph.KG.Traversal",
+                "DijkstraJson",
+                source_id,
+                target_id,
+                weight_prop,
+                max_cost,
+                max_hops,
+                direction,
+            )
+            result_str = str(raw) if raw else "{}"
+        except Exception as e:
+            logger.warning(f"DijkstraJson failed: {e}")
+            return {
+                "columns": ["path", "totalCost"],
+                "rows": [],
+                "sql": "",
+                "params": [],
+                "metadata": sql_query.query_metadata,
+            }
+
+        if not result_str or result_str == "{}":
+            return {
+                "columns": ["path", "totalCost"],
+                "rows": [],
+                "sql": "",
+                "params": [],
+                "metadata": sql_query.query_metadata,
+            }
+
+        try:
+            path_obj = _json.loads(result_str)
+        except Exception:
+            return {
+                "columns": ["path", "totalCost"],
+                "rows": [],
+                "sql": "",
+                "params": [],
+                "metadata": sql_query.query_metadata,
+            }
+
+        total_cost = float(path_obj.get("totalCost", 0))
+        return_funcs = vl.get("return_path_funcs", [])
+
+        row = []
+        cols = []
+        if not return_funcs or "path" in return_funcs:
+            row.append(result_str)
+            cols.append("path")
+        if "totalCost" in return_funcs or "totalcost" in return_funcs:
+            row.append(total_cost)
+            cols.append("totalCost")
+        if "node" in return_funcs:
+            nodes = path_obj.get("nodes", [])
+            row.append(nodes[-1] if nodes else None)
+            cols.append("node")
+        if not cols:
+            row = [result_str, total_cost]
+            cols = ["path", "totalCost"]
+
+        return {
+            "columns": cols,
+            "rows": [row],
+            "sql": f"DijkstraJson({source_id}, {target_id})",
+            "params": [],
+            "metadata": sql_query.query_metadata,
+        }
+
     def _execute_shortest_path_cypher(
         self, sql_query, parameters=None
     ) -> Dict[str, Any]:
@@ -1142,6 +1265,62 @@ class IRISGraphEngine:
     def _try_system_procedure(self, proc) -> Optional[Dict[str, Any]]:
         name = proc.procedure_name.lower()
 
+        if name in ("ivg.shortestpath.weighted", "ivg.shortestpath.weighted"):
+            args = proc.arguments
+            from iris_vector_graph.cypher import ast as cypher_ast
+
+            def _arg_str(a, params=None):
+                if isinstance(a, cypher_ast.Literal):
+                    return str(a.value)
+                if isinstance(a, cypher_ast.Variable):
+                    if params and a.name in params:
+                        return str(params[a.name])
+                    return a.name
+                return str(a)
+
+            source_id = _arg_str(args[0]) if len(args) > 0 else None
+            target_id = _arg_str(args[1]) if len(args) > 1 else None
+            weight_prop = _arg_str(args[2]) if len(args) > 2 else "weight"
+            max_cost = float(_arg_str(args[3])) if len(args) > 3 else 9999.0
+            max_hops = int(float(_arg_str(args[4]))) if len(args) > 4 else 10
+            direction = _arg_str(args[5]) if len(args) > 5 else "out"
+
+            if not source_id or not target_id:
+                return {"columns": ["path", "totalCost"], "rows": []}
+
+            import json as _json
+
+            try:
+                raw = _call_classmethod(
+                    self.conn,
+                    "Graph.KG.Traversal",
+                    "DijkstraJson",
+                    source_id,
+                    target_id,
+                    weight_prop,
+                    max_cost,
+                    max_hops,
+                    direction,
+                )
+                result_str = str(raw) if raw else "{}"
+            except Exception as e:
+                logger.warning(f"DijkstraJson failed: {e}")
+                return {"columns": ["path", "totalCost"], "rows": []}
+
+            if not result_str or result_str == "{}":
+                return {"columns": ["path", "totalCost"], "rows": []}
+
+            try:
+                path_obj = _json.loads(result_str)
+            except Exception:
+                return {"columns": ["path", "totalCost"], "rows": []}
+
+            total_cost = float(path_obj.get("totalCost", 0))
+            return {
+                "columns": ["path", "totalCost"],
+                "rows": [[result_str, total_cost]],
+            }
+
         if name == "db.labels":
             cursor = self.conn.cursor()
             cursor.execute(
@@ -2203,12 +2382,12 @@ class IRISGraphEngine:
             for nid in batch_nodes:
                 if _ensure_node(nid):
                     nodes_inserted += 1
-            for s, p, o in batch_edges:
+            for s, p, o, edge_graph in batch_edges:
                 try:
-                    if graph:
+                    if edge_graph:
                         cursor.execute(
                             f"INSERT INTO {_table('rdf_edges')} (s, p, o_id, graph_id) SELECT ?, ?, ?, ? WHERE NOT EXISTS (SELECT 1 FROM {_table('rdf_edges')} WHERE s = ? AND p = ? AND o_id = ? AND graph_id = ?)",
-                            [s, p, o, graph, s, p, o, graph],
+                            [s, p, o, edge_graph, s, p, o, edge_graph],
                         )
                     else:
                         cursor.execute(
@@ -2243,6 +2422,12 @@ class IRISGraphEngine:
             p_str = _node_id(p)
             batch_nodes.add(s_id)
 
+            effective_graph = graph
+            if graph_ctx is not None:
+                ctx_str = str(graph_ctx)
+                if ctx_str and ctx_str not in ("", "DEFAULT", "urn:x-rdflib:default"):
+                    effective_graph = ctx_str
+
             if isinstance(o, RDFLiteral):
                 key = p_str.rsplit("/", 1)[-1].rsplit("#", 1)[-1][:128]
                 val = str(o)
@@ -2256,7 +2441,7 @@ class IRISGraphEngine:
             elif isinstance(o, (URIRef, BNode)):
                 o_id = _node_id(o)
                 batch_nodes.add(o_id)
-                batch_edges.append((s_id, p_str, o_id))
+                batch_edges.append((s_id, p_str, o_id, effective_graph))
             else:
                 batch_props.append((s_id, p_str[:128], str(o)[:64000]))
 

{iris_vector_graph-1.55.2 → iris_vector_graph-1.56.0}/pyproject.toml

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