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

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

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

{iris_vector_graph-1.91.1 → iris_vector_graph-1.91.2}/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.2}/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:
@@ -6755,3 +6787,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.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "iris-vector-graph"
-version = "1.91.1"
+version = "1.91.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.91.1 → iris_vector_graph-1.91.2}/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}"

{iris_vector_graph-1.91.1 → iris_vector_graph-1.91.2}/tests/unit/test_embedded_wgproto.py

@@ -443,3 +443,212 @@ class TestWgprotoJobSimulation:
         calls = [c[0][0] for c in mock_sql.exec.call_args_list]
         assert "1" in calls[0]
         assert "2" in calls[1]
+
+
+class TestSqlStatementFallback:
+
+    def _make_ddtab(self):
+        return RuntimeError("<UNIMPLEMENTED>ddtab+83^%qaqpsq")
+
+    def test_third_level_fallback_triggered_when_exec_also_fails(self):
+        from iris_vector_graph.embedded import EmbeddedCursor
+        cursor = EmbeddedCursor()
+        mock_sql = MagicMock()
+        mock_sql.prepare.side_effect = self._make_ddtab()
+        mock_sql.exec.side_effect = self._make_ddtab()
+
+        mock_rs = MagicMock()
+        mock_rs.__iter__ = MagicMock(return_value=iter([(42,)]))
+        mock_rs.columnCount.return_value = 1
+        mock_rs.columnName.side_effect = lambda i: "n"
+
+        with patch("iris_vector_graph.embedded._require_iris_sql", return_value=mock_sql), \
+             patch("iris_vector_graph.embedded._sql_statement_execute", return_value=mock_rs) as mock_stmt:
+            cursor.execute("SELECT node_id FROM Graph_KG.nodes WHERE node_id = ?", ["abc"])
+
+        mock_stmt.assert_called_once_with(
+            "SELECT node_id FROM Graph_KG.nodes WHERE node_id = ?", ["abc"]
+        )
+
+    def test_all_three_fail_raises_runtime_error(self):
+        from iris_vector_graph.embedded import EmbeddedCursor
+        cursor = EmbeddedCursor()
+        mock_sql = MagicMock()
+        mock_sql.prepare.side_effect = self._make_ddtab()
+        mock_sql.exec.side_effect = self._make_ddtab()
+
+        with patch("iris_vector_graph.embedded._require_iris_sql", return_value=mock_sql), \
+             patch("iris_vector_graph.embedded._sql_statement_execute",
+                   side_effect=RuntimeError("stmt also failed")):
+            with pytest.raises(RuntimeError, match="All three embedded SQL paths failed"):
+                cursor.execute("SELECT * FROM t", [])
+
+    def test_sql_statement_result_set_iterable(self):
+        from iris_vector_graph.embedded import _SqlStatementResultSet
+        mock_rs = MagicMock()
+        mock_rs._Next.side_effect = ["1", "1", "0"]
+        mock_rs._GetProperty.side_effect = lambda k: (
+            2 if k == "ColCount" else MagicMock()
+        )
+        mock_rs._GetData.side_effect = lambda i: "val_a" if i == 1 else "val_b"
+
+        rs = _SqlStatementResultSet(mock_rs)
+        rows = list(rs)
+        assert len(rows) == 2
+        assert rows[0] == ("val_a", "val_b")
+
+    def test_second_level_exec_failure_escalates_to_third(self):
+        from iris_vector_graph.embedded import EmbeddedCursor
+        cursor = EmbeddedCursor()
+        mock_sql = MagicMock()
+        mock_sql.prepare.side_effect = self._make_ddtab()
+        mock_sql.exec.side_effect = self._make_ddtab()
+
+        mock_rs = MagicMock()
+        mock_rs.__iter__ = MagicMock(return_value=iter([]))
+        mock_rs.columnCount.return_value = 0
+
+        with patch("iris_vector_graph.embedded._require_iris_sql", return_value=mock_sql), \
+             patch("iris_vector_graph.embedded._sql_statement_execute",
+                   return_value=mock_rs) as mock_stmt:
+            cursor.execute("SELECT s, o_id FROM Graph_KG.rdf_edges")
+
+        mock_stmt.assert_called_once()
+
+    def test_non_ddtab_on_exec_propagates_not_escalates(self):
+        from iris_vector_graph.embedded import EmbeddedCursor
+        cursor = EmbeddedCursor()
+        mock_sql = MagicMock()
+        mock_sql.prepare.side_effect = self._make_ddtab()
+        mock_sql.exec.side_effect = RuntimeError("permission denied")
+
+        with patch("iris_vector_graph.embedded._require_iris_sql", return_value=mock_sql), \
+             patch("iris_vector_graph.embedded._sql_statement_execute") as mock_stmt:
+            with pytest.raises(RuntimeError, match="permission denied"):
+                cursor.execute("SELECT 1")
+
+        mock_stmt.assert_not_called()
+
+
+class TestNewEngineAPIs:
+
+    def _make_engine(self):
+        from iris_vector_graph.engine import IRISGraphEngine
+        from iris_vector_graph.engine import IRISCapabilities
+        eng = IRISGraphEngine.__new__(IRISGraphEngine)
+        eng.conn = MagicMock()
+        eng.embedding_dimension = 4
+        eng._arno_available = False
+        eng._arno_capabilities = {}
+        eng._index_registry = {}
+        eng.vector_dtype = "DOUBLE"
+        eng.capabilities = IRISCapabilities()
+        return eng
+
+    def test_get_node_name_returns_name_property(self):
+        eng = self._make_engine()
+        eng.get_node = MagicMock(return_value={
+            "id": "n1", "labels": ["Gene"],
+            "properties": {"name": "TP53", "symbol": "tp53"}
+        })
+        assert eng.get_node_name("n1") == "TP53"
+
+    def test_get_node_name_falls_back_to_label(self):
+        eng = self._make_engine()
+        eng.get_node = MagicMock(return_value={
+            "id": "n1", "labels": [],
+            "properties": {"label": "MyLabel"}
+        })
+        assert eng.get_node_name("n1") == "MyLabel"
+
+    def test_get_node_name_none_when_missing(self):
+        eng = self._make_engine()
+        eng.get_node = MagicMock(return_value=None)
+        assert eng.get_node_name("nonexistent") is None
+
+    def test_get_node_properties_returns_dict(self):
+        eng = self._make_engine()
+        eng.get_node = MagicMock(return_value={
+            "id": "n1", "properties": {"name": "Alice", "age": "30"}
+        })
+        props = eng.get_node_properties("n1")
+        assert props == {"name": "Alice", "age": "30"}
+
+    def test_get_nodes_by_ids_delegates_to_get_nodes(self):
+        eng = self._make_engine()
+        expected = [{"id": "a"}, {"id": "b"}]
+        eng.get_nodes = MagicMock(return_value=expected)
+        result = eng.get_nodes_by_ids(["a", "b"])
+        eng.get_nodes.assert_called_once_with(["a", "b"])
+        assert result == expected
+
+    def test_get_nodes_by_ids_empty_returns_empty(self):
+        eng = self._make_engine()
+        eng.get_nodes = MagicMock()
+        assert eng.get_nodes_by_ids([]) == []
+        eng.get_nodes.assert_not_called()
+
+    def test_node_count_calls_execute_cypher(self):
+        eng = self._make_engine()
+        eng.execute_cypher = MagicMock(return_value={"rows": [(42,)]})
+        assert eng.node_count() == 42
+        eng.execute_cypher.assert_called_once()
+        assert "count" in eng.execute_cypher.call_args[0][0].lower()
+
+    def test_edge_count_calls_execute_cypher(self):
+        eng = self._make_engine()
+        eng.execute_cypher = MagicMock(return_value={"rows": [(100,)]})
+        assert eng.edge_count() == 100
+
+    def test_embedding_count_queries_table(self):
+        eng = self._make_engine()
+        mock_cursor = MagicMock()
+        mock_cursor.fetchone.return_value = (205000,)
+        eng.conn.cursor.return_value = mock_cursor
+        assert eng.embedding_count() == 205000
+
+    def test_embedding_count_returns_zero_on_error(self):
+        eng = self._make_engine()
+        mock_cursor = MagicMock()
+        mock_cursor.execute.side_effect = Exception("table not found")
+        eng.conn.cursor.return_value = mock_cursor
+        assert eng.embedding_count() == 0
+
+
+class TestDetectStoredVectorDtype:
+
+    def _make_engine(self):
+        from iris_vector_graph.engine import IRISGraphEngine, IRISCapabilities
+        eng = IRISGraphEngine.__new__(IRISGraphEngine)
+        eng.conn = MagicMock()
+        eng.embedding_dimension = 4
+        eng._arno_available = False
+        eng._arno_capabilities = {}
+        eng._index_registry = {}
+        eng.vector_dtype = "DOUBLE"
+        eng.capabilities = IRISCapabilities()
+        return eng
+
+    def test_returns_float_when_float_works(self):
+        eng = self._make_engine()
+        float_cursor = MagicMock()
+        float_cursor.fetchone.return_value = ("0.1,0.2",)
+        float_cursor2 = MagicMock()
+        float_cursor2.fetchone.return_value = (0.99,)
+        float_cursor3 = MagicMock()
+        float_cursor3.fetchone.return_value = (0.99,)
+        eng.conn.cursor.side_effect = [float_cursor, float_cursor2]
+        result = eng._detect_stored_vector_dtype()
+        assert result in ("FLOAT", "DOUBLE")
+
+    def test_returns_double_when_no_embeddings(self):
+        eng = self._make_engine()
+        mock_cursor = MagicMock()
+        mock_cursor.fetchone.return_value = None
+        eng.conn.cursor.return_value = mock_cursor
+        assert eng._detect_stored_vector_dtype() == "DOUBLE"
+
+    def test_returns_double_on_exception(self):
+        eng = self._make_engine()
+        eng.conn.cursor.side_effect = Exception("connection failed")
+        assert eng._detect_stored_vector_dtype() == "DOUBLE"