iris-vector-graph 1.62.1__tar.gz → 1.63.1__tar.gz

{iris_vector_graph-1.62.1 → iris_vector_graph-1.63.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: iris-vector-graph
-Version: 1.62.1
+Version: 1.63.1
 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
@@ -23,14 +23,14 @@ Classifier: Topic :: Database
 Classifier: Topic :: Scientific/Engineering
 Classifier: Topic :: Scientific/Engineering :: Bio-Informatics
 Requires-Python: >=3.10
-Requires-Dist: intersystems-irispython>=3.2.0
+Requires-Dist: intersystems-iris>=1.0.0
 Provides-Extra: biodata
 Requires-Dist: biopython>=1.81; extra == 'biodata'
 Requires-Dist: bioservices>=1.11.0; extra == 'biodata'
 Requires-Dist: mygene>=3.2.0; extra == 'biodata'
 Requires-Dist: obonet>=1.0.0; extra == 'biodata'
 Provides-Extra: core
-Requires-Dist: intersystems-irispython>=3.2.0; extra == 'core'
+Requires-Dist: intersystems-iris>=1.0.0; extra == 'core'
 Provides-Extra: demo
 Requires-Dist: python-fasthtml>=0.12.0; extra == 'demo'
 Provides-Extra: dev
@@ -655,6 +655,10 @@ anchors = engine.get_kg_anchors(icd_codes=["J18.0", "E11.9"])
 
 ## Changelog
 
+### v1.63.0 (2026-04-25)
+- feat: Arno/Rust fast path for BFS (`_execute_var_length_cypher`) — when `libarno_callout.so` is loaded with `Graph.KG.NKGAccel.BFSJson`, var-length Cypher queries use Rust BFS over `^NKG` integer adjacency instead of ObjectScript `BFSFastJson`. Projected 128ms → <30ms p50 for 6K+ result BFS at 10K/50K scale. Falls back transparently to `BFSFastJson` when Arno not loaded. (spec 079, arno spec 035)
+
+
 ### v1.62.1 (2026-04-25)
 - fix: `WITH n, count(r) AS cnt WHERE cnt > N` — IRIS SQLCODE -23 fixed; CTEs containing GROUP BY now emit inline subqueries `FROM (...GROUP BY...) Stage1` instead of `WITH Stage1 AS (...GROUP BY...) SELECT ... FROM Stage1` (IRIS 2025.x doesn't support aggregation in CTEs)
 - fix: `WITH HAVING` now uses the full aggregate expression (e.g. `COUNT(e.p) >= 2`) not the alias (`cnt >= 2`) — IRIS doesn't allow column aliases in HAVING

{iris_vector_graph-1.62.1 → iris_vector_graph-1.63.1}/README.md

@@ -583,6 +583,10 @@ anchors = engine.get_kg_anchors(icd_codes=["J18.0", "E11.9"])
 
 ## Changelog
 
+### v1.63.0 (2026-04-25)
+- feat: Arno/Rust fast path for BFS (`_execute_var_length_cypher`) — when `libarno_callout.so` is loaded with `Graph.KG.NKGAccel.BFSJson`, var-length Cypher queries use Rust BFS over `^NKG` integer adjacency instead of ObjectScript `BFSFastJson`. Projected 128ms → <30ms p50 for 6K+ result BFS at 10K/50K scale. Falls back transparently to `BFSFastJson` when Arno not loaded. (spec 079, arno spec 035)
+
+
 ### v1.62.1 (2026-04-25)
 - fix: `WITH n, count(r) AS cnt WHERE cnt > N` — IRIS SQLCODE -23 fixed; CTEs containing GROUP BY now emit inline subqueries `FROM (...GROUP BY...) Stage1` instead of `WITH Stage1 AS (...GROUP BY...) SELECT ... FROM Stage1` (IRIS 2025.x doesn't support aggregation in CTEs)
 - fix: `WITH HAVING` now uses the full aggregate expression (e.g. `COUNT(e.p) >= 2`) not the alias (`cnt >= 2`) — IRIS doesn't allow column aliases in HAVING

{iris_vector_graph-1.62.1 → iris_vector_graph-1.63.1}/iris_vector_graph/bulk_loader.py

@@ -273,8 +273,8 @@ class BulkLoader:
         Must be called after load_edges(use_noindex=True).
         Also rebuilds bitmap extent indexes for correct COUNT(*).
         """
-        import intersystems_iris
-        iris_obj = intersystems_iris.createIRIS(self.conn)
+        import iris
+        iris_obj = iris.createIRIS(self.conn)
         results = {}
 
         for cls in ["Graph.KG.rdfedges", "Graph.KG.rdflabels", "Graph.KG.rdfprops", "Graph.KG.nodes"]:
@@ -301,8 +301,8 @@ class BulkLoader:
         Returns True if successful.
         """
         try:
-            import intersystems_iris
-            iris_obj = intersystems_iris.createIRIS(self.conn)
+            import iris
+            iris_obj = iris.createIRIS(self.conn)
             logger.info("Building ^KG + ^NKG globals from SQL tables...")
             t0 = time.time()
             iris_obj.classMethodVoid("Graph.KG.Traversal", "BuildKG")
@@ -422,7 +422,7 @@ def main():
     logger.info(f"Graph: {G.number_of_nodes():,} nodes, {G.number_of_edges():,} edges")
 
 
-    from intersystems_iris.dbapi._DBAPI import connect
+    from iris.dbapi._DBAPI import connect  # intersystems_iris.dbapi = iris.dbapi
     conn = connect(args.host, args.port, args.namespace, args.user, args.password)
     logger.info(f"Connected to IRIS {args.host}:{args.port}/{args.namespace}")
 

{iris_vector_graph-1.62.1 → iris_vector_graph-1.63.1}/iris_vector_graph/cypher/translator.py

@@ -1744,6 +1744,9 @@ def translate_relationship_pattern(
         def _resolve_id_param(node):
             id_val = node.properties.get("id")
             if id_val is None:
+                if node.variable and node.variable in context.input_params:
+                    val = context.input_params[node.variable]
+                    return f"${node.variable}" if isinstance(val, str) else None
                 return None
             if isinstance(id_val, ast.Variable):
                 return f"${id_val.name}"

{iris_vector_graph-1.62.1 → iris_vector_graph-1.63.1}/iris_vector_graph/engine.py

@@ -1025,6 +1025,31 @@ class IRISGraphEngine:
         source_id = _resolve(vl.get("src_id_param"))
         target_id = _resolve(vl.get("dst_id_param"))
 
+        if source_id is None and parameters:
+            src_var = vl.get("source_var")
+            if src_var and src_var in parameters:
+                source_id = str(parameters[src_var])
+            else:
+                source_id = next(
+                    (str(v) for v in parameters.values() if isinstance(v, str)), None
+                )
+
+        if target_id is None and parameters:
+            dst_var = vl.get("target_var")
+            if dst_var and dst_var in parameters:
+                target_id = str(parameters[dst_var])
+            else:
+                vals = [str(v) for v in parameters.values() if isinstance(v, str)]
+                target_id = vals[1] if len(vals) > 1 else None
+
+        if source_id is None or target_id is None:
+            sql_params = sql_query.parameters[0] if sql_query.parameters else []
+            str_params = [p for p in sql_params if isinstance(p, str) and not p.startswith("Graph_KG")]
+            if source_id is None and len(str_params) >= 1:
+                source_id = str_params[0]
+            if target_id is None and len(str_params) >= 2:
+                target_id = str_params[1]
+
         if source_id is None or target_id is None:
             raise ValueError(
                 "shortestPath requires both source and target node IDs to be bound. "
@@ -1131,7 +1156,11 @@ class IRISGraphEngine:
                 source_id = item
                 break
         if source_id is None and parameters:
-            source_id = next(iter(parameters.values()), None)
+            src_var = vl.get("source_var")
+            if src_var and src_var in parameters:
+                source_id = str(parameters[src_var])
+            else:
+                source_id = next(iter(parameters.values()), None)
 
         if source_id is None:
             return {
@@ -1142,26 +1171,52 @@ class IRISGraphEngine:
                 "metadata": sql_query.query_metadata,
             }
 
-        try:
-            bfs_json = _call_classmethod(
-                self.conn,
-                "Graph.KG.Traversal",
-                "BFSFastJson",
-                source_id,
-                predicates_json,
-                max_hops,
-                "",
-            )
-            bfs_results = _json.loads(str(bfs_json)) if bfs_json else []
-        except Exception as e:
-            logger.warning(f"BFSFastJson failed: {e}")
-            return {
-                "columns": [],
-                "rows": [],
-                "sql": "",
-                "params": [],
-                "metadata": sql_query.query_metadata,
-            }
+        max_results = 0
+        if sql_query.sql:
+            import re as _re
+            sql_str = sql_query.sql if isinstance(sql_query.sql, str) else (sql_query.sql[0] if sql_query.sql else "")
+            m = _re.search(r"\bLIMIT\s+(\d+)", sql_str, _re.IGNORECASE)
+            if m:
+                max_results = int(m.group(1))
+
+        bfs_results = None
+        if self._detect_arno() and self._arno_capabilities.get("bfs"):
+            try:
+                bfs_json = self._arno_call(
+                    "Graph.KG.NKGAccel",
+                    "BFSJson",
+                    source_id,
+                    predicates_json,
+                    max_hops,
+                    max_results,
+                )
+                bfs_results = _json.loads(str(bfs_json)) if bfs_json else []
+                logger.debug("Arno BFSJson: %d results for %s", len(bfs_results), source_id)
+            except Exception as e:
+                logger.warning(f"Arno BFSJson failed, falling back to BFSFastJson: {e}")
+                bfs_results = None
+
+        if bfs_results is None:
+            try:
+                bfs_json = _call_classmethod(
+                    self.conn,
+                    "Graph.KG.Traversal",
+                    "BFSFastJson",
+                    source_id,
+                    predicates_json,
+                    max_hops,
+                    "",
+                )
+                bfs_results = _json.loads(str(bfs_json)) if bfs_json else []
+            except Exception as e:
+                logger.warning(f"BFSFastJson failed: {e}")
+                return {
+                    "columns": [],
+                    "rows": [],
+                    "sql": "",
+                    "params": [],
+                    "metadata": sql_query.query_metadata,
+                }
 
         if min_hops > 1:
             min_step_per_node: dict = {}
@@ -1188,9 +1243,14 @@ class IRISGraphEngine:
                 seen.add(oid)
                 target_ids.append(oid)
 
+        import re as _re
+        sql_str = sql_query.sql if isinstance(sql_query.sql, str) else ""
+        alias_match = _re.search(r'SELECT\s+DISTINCT\s+\S+\s+AS\s+(\w+)|SELECT\s+\S+\s+AS\s+(\w+)', sql_str, _re.IGNORECASE)
+        col_name = (alias_match.group(1) or alias_match.group(2)) if alias_match else "b_id"
+
         if not target_ids:
             return {
-                "columns": ["b_id", "b_labels", "b_props"],
+                "columns": [col_name, "b_labels", "b_props"],
                 "rows": [],
                 "sql": "",
                 "params": [],
@@ -1210,7 +1270,7 @@ class IRISGraphEngine:
             )
 
         return {
-            "columns": ["b_id", "b_labels", "b_props"],
+            "columns": [col_name, "b_labels", "b_props"],
             "rows": [list(r) for r in rows],
             "sql": f"BFSFastJson({source_id}, {predicates_json}, {max_hops})",
             "params": [],
@@ -4890,9 +4950,9 @@ class IRISGraphEngine:
 
             return iris.createIRIS(self.conn)
         except (TypeError, AttributeError):
-            import intersystems_iris
+            import iris
 
-            return intersystems_iris.createIRIS(self.conn)
+            return iris.createIRIS(self.conn)
 
     def vec_create_index(
         self,

{iris_vector_graph-1.62.1 → iris_vector_graph-1.63.1}/iris_vector_graph/schema.py

@@ -17,43 +17,18 @@ logger = logging.getLogger(__name__)
 
 
 def _call_classmethod(conn_or_cursor, class_name: str, method_name: str, *args) -> Any:
-    """Call an IRIS ObjectScript class method using the native API.
-
-    Works with both the ``iris`` package (iris.createIRIS) and the
-    ``intersystems_iris`` package (intersystems_iris.createIRIS).  Tries
-    ``iris.createIRIS`` first because it accepts the connection objects
-    returned by ``iris.connect()`` (the standard test-fixture connection).
-
-    Resolves the connection from either a connection object directly or from
-    ``cursor._connection`` if a cursor is passed.
-
-    Returns the method's return value, or raises if the class/method does not
-    exist or the native API is unavailable.
-    """
-    # Accept either a connection or a cursor
     if hasattr(conn_or_cursor, "cursor"):
-        conn = conn_or_cursor  # it's a connection
+        conn = conn_or_cursor
     elif hasattr(conn_or_cursor, "_connection"):
-        conn = conn_or_cursor._connection  # it's a cursor
+        conn = conn_or_cursor._connection
     else:
-        conn = conn_or_cursor  # best-effort fallback
-
-    # Try iris.createIRIS first (accepts iris.IRISConnection from iris.connect())
-    try:
-        import iris as _iris_pkg  # type: ignore[import]
-
-        iris_obj = _iris_pkg.createIRIS(conn)
-        return iris_obj.classMethodValue(class_name, method_name, *args)
-    except (ImportError, AttributeError, TypeError):
-        pass
-
-    # Fall back to intersystems_iris.createIRIS (accepts intersystems_iris.IRISConnection)
-    import intersystems_iris as _iris_pkg2  # type: ignore[import]
-
-    iris_obj = _iris_pkg2.createIRIS(conn)
+        conn = conn_or_cursor
+    import iris as _iris_pkg
+    iris_obj = _iris_pkg.createIRIS(conn)
     return iris_obj.classMethodValue(class_name, method_name, *args)
 
 
+
 class GraphSchema:
     """Domain-agnostic RDF-style graph schema management"""
 

{iris_vector_graph-1.62.1 → iris_vector_graph-1.63.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "iris-vector-graph"
-version = "1.62.1"
+version = "1.63.1"
 description = "Transactional Graph + Vector retrieval system for InterSystems IRIS with hybrid search, openCypher, and GraphQL APIs"
 readme = "README.md"
 license = "MIT"
@@ -38,12 +38,12 @@ requires-python = ">=3.10"
 
 # Core dependencies
 dependencies = [
-    "intersystems-irispython>=3.2.0",
+    "intersystems-iris>=1.0.0",
 ]
 
 [project.optional-dependencies]
 core = [
-    "intersystems-irispython>=3.2.0",
+    "intersystems-iris>=1.0.0",
 ]
 full = [
     "numpy>=1.24.0",

iris_vector_graph-1.63.1/tests/unit/test_bfs_arno.py

@@ -0,0 +1,249 @@
+import json
+import os
+import uuid
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+SKIP_IRIS_TESTS = os.environ.get("SKIP_IRIS_TESTS", "false").lower() == "true"
+SKIP_ARNO_TESTS = os.environ.get("SKIP_ARNO_TESTS", "true").lower() == "true"
+
+
+class TestBFSArnoUnit:
+
+    def _make_engine(self):
+        from iris_vector_graph.engine import IRISGraphEngine
+        conn = MagicMock()
+        cursor = MagicMock()
+        conn.cursor.return_value = cursor
+        cursor.fetchall.return_value = []
+        engine = IRISGraphEngine(conn, embedding_dimension=4)
+        engine._arno_available = True
+        engine._arno_capabilities = {"nkg_data": True, "bfs": True, "algorithms": ["bfs"]}
+        return engine
+
+    def test_arno_bfs_path_called_when_bfs_capability_present(self):
+        engine = self._make_engine()
+        expected = [{"s": "A", "p": "BINDS", "o": "B", "w": 1.0, "step": 1}]
+
+        with patch.object(engine, "_arno_call", return_value=json.dumps(expected)) as mock_call:
+            with patch.object(engine, "_detect_arno", return_value=True):
+                from iris_vector_graph.cypher.translator import SQLQuery
+                vl = {
+                    "types": ["BINDS"],
+                    "min_hops": 1,
+                    "max_hops": 3,
+                    "properties": {},
+                    "return_path_funcs": [],
+                    "src_id_param": "A",
+                    "dst_id_param": None,
+                    "source_var": "a",
+                    "source_alias": "n0",
+                    "target_var": "b",
+                    "target_alias": "n1",
+                    "direction": "out",
+                    "shortest": False,
+                    "all_shortest": False,
+                }
+                sq = SQLQuery(
+                    sql="",
+                    parameters=[["A"]],
+                    var_length_paths=[vl],
+                )
+                with patch.object(engine, "get_nodes", return_value=[{"id": "B", "labels": ["Gene"]}]):
+                    result = engine._execute_var_length_cypher(sq)
+
+        mock_call.assert_called_once_with(
+            "Graph.KG.NKGAccel", "BFSJson", "A", '["BINDS"]', 3, 0
+        )
+        assert result["rows"] is not None
+
+    def test_fallback_to_bfsfast_when_no_bfs_capability(self):
+        engine = self._make_engine()
+        engine._arno_capabilities = {"nkg_data": True, "algorithms": []}
+
+        fallback_result = [{"s": "A", "p": "BINDS", "o": "B", "w": 1.0, "step": 1}]
+
+        with patch("iris_vector_graph.engine._call_classmethod", return_value=json.dumps(fallback_result)):
+            with patch.object(engine, "_detect_arno", return_value=False):
+                from iris_vector_graph.cypher.translator import SQLQuery
+                vl = {
+                    "types": [], "min_hops": 1, "max_hops": 2, "properties": {},
+                    "return_path_funcs": [], "src_id_param": "A", "dst_id_param": None,
+                    "source_var": "a", "source_alias": "n0", "target_var": "b",
+                    "target_alias": "n1", "direction": "out", "shortest": False, "all_shortest": False,
+                }
+                sq = SQLQuery(sql="", parameters=[["A"]], var_length_paths=[vl])
+                with patch.object(engine, "get_nodes", return_value=[{"id": "B", "labels": []}]):
+                    result = engine._execute_var_length_cypher(sq)
+
+        assert result is not None
+
+    def test_arno_bfs_error_falls_back_to_bfsfast(self):
+        engine = self._make_engine()
+
+        fallback_result = [{"s": "A", "p": "BINDS", "o": "B", "w": 1.0, "step": 1}]
+
+        with patch.object(engine, "_arno_call", side_effect=RuntimeError("Arno not loaded")):
+            with patch.object(engine, "_detect_arno", return_value=True):
+                with patch("iris_vector_graph.engine._call_classmethod", return_value=json.dumps(fallback_result)):
+                    from iris_vector_graph.cypher.translator import SQLQuery
+                    vl = {
+                        "types": [], "min_hops": 1, "max_hops": 2, "properties": {},
+                        "return_path_funcs": [], "src_id_param": "A", "dst_id_param": None,
+                        "source_var": "a", "source_alias": "n0", "target_var": "b",
+                        "target_alias": "n1", "direction": "out", "shortest": False, "all_shortest": False,
+                    }
+                    sq = SQLQuery(sql="", parameters=[["A"]], var_length_paths=[vl])
+                    with patch.object(engine, "get_nodes", return_value=[{"id": "B", "labels": []}]):
+                        result = engine._execute_var_length_cypher(sq)
+
+        assert result is not None
+
+    def test_max_results_derived_from_sql_limit(self):
+        engine = self._make_engine()
+        captured = {}
+
+        def capture_call(cls, method, *args):
+            captured["args"] = args
+            return "[]"
+
+        with patch.object(engine, "_arno_call", side_effect=capture_call):
+            with patch.object(engine, "_detect_arno", return_value=True):
+                from iris_vector_graph.cypher.translator import SQLQuery
+                vl = {
+                    "types": [], "min_hops": 1, "max_hops": 2, "properties": {},
+                    "return_path_funcs": [], "src_id_param": "A", "dst_id_param": None,
+                    "source_var": "a", "source_alias": "n0", "target_var": "b",
+                    "target_alias": "n1", "direction": "out", "shortest": False, "all_shortest": False,
+                }
+                sq = SQLQuery(
+                    sql="SELECT n FROM Stage1 LIMIT 100",
+                    parameters=[["A"]],
+                    var_length_paths=[vl],
+                )
+                engine._execute_var_length_cypher(sq)
+
+        assert captured.get("args") is not None
+        assert captured["args"][-1] == 100
+
+
+@pytest.mark.skipif(SKIP_IRIS_TESTS, reason="SKIP_IRIS_TESTS=true")
+@pytest.mark.skipif(SKIP_ARNO_TESTS, reason="SKIP_ARNO_TESTS=true — Arno .so not loaded")
+class TestBFSArnoE2E:
+
+    @pytest.fixture(autouse=True)
+    def setup(self, iris_connection):
+        from iris_vector_graph.engine import IRISGraphEngine
+        self.conn = iris_connection
+        self.engine = IRISGraphEngine(iris_connection, embedding_dimension=4)
+        self.engine.initialize_schema()
+        self._run = uuid.uuid4().hex[:8]
+        yield
+        cursor = self.conn.cursor()
+        try:
+            cursor.execute(
+                f"DELETE FROM Graph_KG.rdf_edges WHERE s LIKE 'bfs079_{self._run}%' OR o_id LIKE 'bfs079_{self._run}%'"
+            )
+            cursor.execute(f"DELETE FROM Graph_KG.rdf_labels WHERE s LIKE 'bfs079_{self._run}%'")
+            cursor.execute(f"DELETE FROM Graph_KG.nodes WHERE node_id LIKE 'bfs079_{self._run}%'")
+            self.conn.commit()
+        except Exception:
+            self.conn.rollback()
+
+    def _node(self, suffix, label="Gene"):
+        nid = f"bfs079_{self._run}_{suffix}"
+        self.engine.create_node(nid, labels=[label])
+        return nid
+
+    def _edge(self, s, p, o):
+        self.engine.create_edge(s, p, o)
+
+    def test_bfs_arno_correctness(self):
+        a = self._node("A")
+        b = self._node("B")
+        c = self._node("C")
+        d = self._node("D")
+        self._edge(a, "BINDS", b)
+        self._edge(b, "BINDS", c)
+        self._edge(c, "BINDS", d)
+
+        result_arno = self.engine.execute_cypher(
+            "MATCH (x)-[r*1..3]->(y) WHERE x.id = $id RETURN y.id",
+            {"id": a},
+        )
+        arno_ids = {row[0] for row in result_arno["rows"]}
+
+        self.engine._arno_available = False
+        self.engine._arno_capabilities = {}
+
+        result_fallback = self.engine.execute_cypher(
+            "MATCH (x)-[r*1..3]->(y) WHERE x.id = $id RETURN y.id",
+            {"id": a},
+        )
+        fallback_ids = {row[0] for row in result_fallback["rows"]}
+
+        assert arno_ids == fallback_ids, f"Arno result {arno_ids} != fallback {fallback_ids}"
+
+    def test_bfs_arno_perf(self):
+        import time, statistics
+        hub = self._node("hub")
+        for i in range(20):
+            mid = self._node(f"mid{i}")
+            leaf = self._node(f"leaf{i}")
+            self._edge(hub, "BINDS", mid)
+            self._edge(mid, "BINDS", leaf)
+
+        times = []
+        for _ in range(10):
+            t0 = time.perf_counter()
+            self.engine.execute_cypher(
+                "MATCH (x)-[r*1..3]->(y) WHERE x.id = $id RETURN y.id",
+                {"id": hub},
+            )
+            times.append((time.perf_counter() - t0) * 1000)
+
+        med = statistics.median(times)
+        assert med < 30, f"Arno BFS p50={med:.1f}ms exceeds 30ms target"
+
+    def test_bfs_arno_predicate_filter(self):
+        a = self._node("pred_a")
+        b_binds = self._node("pred_b_binds")
+        b_regs = self._node("pred_b_regs")
+        self._edge(a, "BINDS", b_binds)
+        self._edge(a, "REGULATES", b_regs)
+
+        result = self.engine.execute_cypher(
+            "MATCH (x)-[r:BINDS*1..2]->(y) WHERE x.id = $id RETURN y.id",
+            {"id": a},
+        )
+        ids = {row[0] for row in result["rows"]}
+        assert b_binds in ids
+        assert b_regs not in ids
+
+    def test_bfs_arno_fallback(self):
+        a = self._node("fb_a")
+        b = self._node("fb_b")
+        self._edge(a, "BINDS", b)
+
+        self.engine._arno_available = False
+        self.engine._arno_capabilities = {}
+
+        result = self.engine.execute_cypher(
+            "MATCH (x)-[r*1..2]->(y) WHERE x.id = $id RETURN y.id",
+            {"id": a},
+        )
+        ids = {row[0] for row in result["rows"]}
+        assert b in ids
+
+    def test_bfs_arno_max_results(self):
+        hub = self._node("max_hub")
+        for i in range(20):
+            n = self._node(f"max_leaf{i}")
+            self._edge(hub, "BINDS", n)
+
+        result = self.engine.execute_cypher(
+            "MATCH (x)-[r*1..1]->(y) WHERE x.id = $id RETURN y.id LIMIT 5",
+            {"id": hub},
+        )
+        assert len(result["rows"]) <= 5