sqlitegraph 0.1.1__tar.gz → 0.3.0__tar.gz

{sqlitegraph-0.1.1 → sqlitegraph-0.3.0}/Cargo.lock

@@ -1387,7 +1387,7 @@ checksum = "67b1b7a3b5fe4f1376887184045fcf45c69e92af734b7aaddc05fb777b6fbd03"
 
 [[package]]
 name = "sqlitegraph"
-version = "2.2.5"
+version = "2.4.0"
 dependencies = [
  "ahash",
  "arc-swap",
@@ -1428,7 +1428,7 @@ dependencies = [
 
 [[package]]
 name = "sqlitegraph-py"
-version = "0.1.1"
+version = "0.3.0"
 dependencies = [
  "ndarray 0.16.1",
  "numpy",

{sqlitegraph-0.1.1 → sqlitegraph-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlitegraph
-Version: 0.1.1
+Version: 0.3.0
 Classifier: Development Status :: 3 - Alpha
 Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
 Classifier: Programming Language :: Python :: 3

{sqlitegraph-0.1.1 → sqlitegraph-0.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "sqlitegraph"
-version = "0.1.1"
+version = "0.3.0"
 description = "Embedded graph database with HNSW vector search — Python bindings to the sqlitegraph Rust crate."
 license = { text = "GPL-3.0-only" }
 authors = [{ name = "Luiz Spies" }]

{sqlitegraph-0.1.1 → sqlitegraph-0.3.0}/sqlitegraph-core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "sqlitegraph"
-version = "2.2.5"
+version = "2.4.0"
 edition = "2024"
 description = "Embedded graph database with full ACID transactions, HNSW vector search, dual backend support, and comprehensive graph algorithms library"
 license = "GPL-3.0"

{sqlitegraph-0.1.1 → sqlitegraph-0.3.0}/sqlitegraph-core/src/backend/native/v3/backend.rs

@@ -1237,6 +1237,33 @@ impl GraphBackend for V3Backend {
         self.k_hop(_snapshot_id, _start, _depth, _direction)
     }
 
+    fn bfs_filtered(
+        &self,
+        snapshot_id: SnapshotId,
+        start: i64,
+        depth: u32,
+        _direction: BackendDirection,
+        _allowed_edge_types: &[&str],
+    ) -> Result<Vec<i64>, SqliteGraphError> {
+        // TODO: Implement edge type filtering for V3 backend.
+        // V3's edge_store exposes `neighbors_filtered`, but typed-edge traversal
+        // is not yet wired into the BFS path. Tracked alongside `k_hop_filtered`.
+        // For now, delegate to unfiltered bfs to match the existing stub pattern.
+        self.bfs(snapshot_id, start, depth)
+    }
+
+    fn shortest_path_filtered(
+        &self,
+        snapshot_id: SnapshotId,
+        start: i64,
+        end: i64,
+        _allowed_edge_types: &[&str],
+    ) -> Result<Option<Vec<i64>>, SqliteGraphError> {
+        // TODO: Implement edge type filtering for V3 backend.
+        // See note on `bfs_filtered`.
+        self.shortest_path(snapshot_id, start, end)
+    }
+
     fn chain_query(
         &self,
         _snapshot_id: SnapshotId,

{sqlitegraph-0.1.1 → sqlitegraph-0.3.0}/sqlitegraph-core/src/backend/sqlite/impl_.rs

@@ -10,7 +10,7 @@ use crate::{
     SqliteGraphError,
     backend::sqlite::types::{BackendDirection, EdgeSpec, NeighborQuery, NodeSpec},
     backend::{PubSubEvent, SubscriptionFilter},
-    bfs::{bfs_neighbors, shortest_path},
+    bfs::{bfs_neighbors, bfs_neighbors_filtered, shortest_path, shortest_path_filtered},
     graph::{GraphEdge, GraphEntity, SqliteGraph},
     multi_hop,
     pattern::{self, PatternMatch, PatternQuery},
@@ -296,6 +296,62 @@ impl crate::backend::GraphBackend for SqliteGraphBackend {
         Ok(id)
     }
 
+    fn insert_nodes_bulk(&self, nodes: &[NodeSpec]) -> Result<Vec<i64>, SqliteGraphError> {
+        let entities: Vec<GraphEntity> = nodes
+            .iter()
+            .map(|node| GraphEntity {
+                id: 0,
+                kind: node.kind.clone(),
+                name: node.name.clone(),
+                file_path: node.file_path.clone(),
+                data: node.data.clone(),
+            })
+            .collect();
+        let ids = self.graph.insert_entities_bulk(&entities)?;
+
+        // Emit per-row events after the commit, matching single-insert
+        // observer semantics.
+        let pub_guard = self.publisher.read();
+        if let Some(ref publisher) = *pub_guard {
+            for id in &ids {
+                publisher.emit(PubSubEvent::NodeChanged {
+                    node_id: *id,
+                    snapshot_id: 0,
+                });
+            }
+        }
+
+        Ok(ids)
+    }
+
+    fn insert_edges_bulk(&self, edges: &[EdgeSpec]) -> Result<Vec<i64>, SqliteGraphError> {
+        let graph_edges: Vec<GraphEdge> = edges
+            .iter()
+            .map(|edge| GraphEdge {
+                id: 0,
+                from_id: edge.from,
+                to_id: edge.to,
+                edge_type: edge.edge_type.clone(),
+                data: edge.data.clone(),
+            })
+            .collect();
+        let ids = self.graph.insert_edges_bulk(&graph_edges)?;
+
+        let pub_guard = self.publisher.read();
+        if let Some(ref publisher) = *pub_guard {
+            for (id, edge) in ids.iter().zip(edges.iter()) {
+                publisher.emit(PubSubEvent::EdgeChanged {
+                    from_node: edge.from,
+                    to_node: edge.to,
+                    edge_id: *id,
+                    snapshot_id: 0,
+                });
+            }
+        }
+
+        Ok(ids)
+    }
+
     fn delete_entity(&self, id: i64) -> Result<(), SqliteGraphError> {
         self.graph.delete_entity(id)
     }
@@ -427,6 +483,29 @@ impl crate::backend::GraphBackend for SqliteGraphBackend {
         Ok(result)
     }
 
+    fn bfs_filtered(
+        &self,
+        snapshot_id: crate::snapshot::SnapshotId,
+        start: i64,
+        depth: u32,
+        direction: BackendDirection,
+        allowed_edge_types: &[&str],
+    ) -> Result<Vec<i64>, SqliteGraphError> {
+        validate_snapshot_for_sqlite(snapshot_id)?;
+        bfs_neighbors_filtered(&self.graph, start, depth, allowed_edge_types, direction)
+    }
+
+    fn shortest_path_filtered(
+        &self,
+        snapshot_id: crate::snapshot::SnapshotId,
+        start: i64,
+        end: i64,
+        allowed_edge_types: &[&str],
+    ) -> Result<Option<Vec<i64>>, SqliteGraphError> {
+        validate_snapshot_for_sqlite(snapshot_id)?;
+        shortest_path_filtered(&self.graph, start, end, allowed_edge_types)
+    }
+
     fn chain_query(
         &self,
         snapshot_id: crate::snapshot::SnapshotId,

{sqlitegraph-0.1.1 → sqlitegraph-0.3.0}/sqlitegraph-core/src/backend.rs

@@ -117,6 +117,35 @@ pub trait GraphBackend {
     fn insert_node(&self, node: NodeSpec) -> Result<i64, SqliteGraphError>;
     fn insert_edge(&self, edge: EdgeSpec) -> Result<i64, SqliteGraphError>;
 
+    /// Insert many nodes atomically.
+    ///
+    /// Default implementation loops single-insert for each item; backends
+    /// override with a single-transaction path. Returns the new node IDs in
+    /// the same order as `nodes`. All-or-nothing: if any insert fails the
+    /// caller should assume nothing was committed.
+    fn insert_nodes_bulk(&self, nodes: &[NodeSpec]) -> Result<Vec<i64>, SqliteGraphError> {
+        let mut ids = Vec::with_capacity(nodes.len());
+        for n in nodes {
+            ids.push(self.insert_node(n.clone())?);
+        }
+        Ok(ids)
+    }
+
+    /// Insert many edges atomically.
+    ///
+    /// Default implementation loops single-insert for each item; backends
+    /// override with a single-transaction path. Returns the new edge IDs in
+    /// the same order as `edges`. All-or-nothing semantics on the bulk path;
+    /// the default fallback inherits whatever atomicity the single
+    /// `insert_edge` provides.
+    fn insert_edges_bulk(&self, edges: &[EdgeSpec]) -> Result<Vec<i64>, SqliteGraphError> {
+        let mut ids = Vec::with_capacity(edges.len());
+        for e in edges {
+            ids.push(self.insert_edge(e.clone())?);
+        }
+        Ok(ids)
+    }
+
     /// Update an existing node in place without allocating a new node ID
     ///
     /// This modifies the data associated with an existing node while preserving
@@ -250,6 +279,21 @@ pub trait GraphBackend {
         direction: BackendDirection,
         allowed_edge_types: &[&str],
     ) -> Result<Vec<i64>, SqliteGraphError>;
+    fn bfs_filtered(
+        &self,
+        snapshot_id: SnapshotId,
+        start: i64,
+        depth: u32,
+        direction: BackendDirection,
+        allowed_edge_types: &[&str],
+    ) -> Result<Vec<i64>, SqliteGraphError>;
+    fn shortest_path_filtered(
+        &self,
+        snapshot_id: SnapshotId,
+        start: i64,
+        end: i64,
+        allowed_edge_types: &[&str],
+    ) -> Result<Option<Vec<i64>>, SqliteGraphError>;
     fn chain_query(
         &self,
         snapshot_id: SnapshotId,
@@ -550,6 +594,14 @@ where
         (*self).entity_ids()
     }
 
+    fn insert_nodes_bulk(&self, nodes: &[NodeSpec]) -> Result<Vec<i64>, SqliteGraphError> {
+        (*self).insert_nodes_bulk(nodes)
+    }
+
+    fn insert_edges_bulk(&self, edges: &[EdgeSpec]) -> Result<Vec<i64>, SqliteGraphError> {
+        (*self).insert_edges_bulk(edges)
+    }
+
     fn neighbors(
         &self,
         snapshot_id: SnapshotId,
@@ -606,6 +658,27 @@ where
         (*self).k_hop_filtered(snapshot_id, start, depth, direction, allowed_edge_types)
     }
 
+    fn bfs_filtered(
+        &self,
+        snapshot_id: SnapshotId,
+        start: i64,
+        depth: u32,
+        direction: BackendDirection,
+        allowed_edge_types: &[&str],
+    ) -> Result<Vec<i64>, SqliteGraphError> {
+        (*self).bfs_filtered(snapshot_id, start, depth, direction, allowed_edge_types)
+    }
+
+    fn shortest_path_filtered(
+        &self,
+        snapshot_id: SnapshotId,
+        start: i64,
+        end: i64,
+        allowed_edge_types: &[&str],
+    ) -> Result<Option<Vec<i64>>, SqliteGraphError> {
+        (*self).shortest_path_filtered(snapshot_id, start, end, allowed_edge_types)
+    }
+
     fn chain_query(
         &self,
         snapshot_id: SnapshotId,

sqlitegraph-0.3.0/sqlitegraph-core/src/bfs.rs

@@ -0,0 +1,171 @@
+use std::collections::VecDeque;
+
+use ahash::{AHashMap, AHashSet};
+
+use crate::{
+    backend::BackendDirection,
+    errors::SqliteGraphError,
+    graph::SqliteGraph,
+    multi_hop::{build_lookup, typed_adjacency},
+};
+
+pub fn bfs_neighbors(
+    graph: &SqliteGraph,
+    start: i64,
+    max_depth: u32,
+) -> Result<Vec<i64>, SqliteGraphError> {
+    graph.get_entity(start)?;
+    let mut visited = Vec::new();
+    let mut seen = AHashSet::new();
+    let mut queue = VecDeque::new();
+    queue.push_back((start, 0));
+    seen.insert(start);
+    while let Some((node, depth)) = queue.pop_front() {
+        visited.push(node);
+        if depth >= max_depth {
+            continue;
+        }
+        for next in graph.fetch_outgoing(node)? {
+            if seen.insert(next) {
+                queue.push_back((next, depth + 1));
+            }
+        }
+    }
+    Ok(visited)
+}
+
+pub fn bfs_neighbors_filtered(
+    graph: &SqliteGraph,
+    start: i64,
+    max_depth: u32,
+    allowed_edge_types: &[&str],
+    direction: BackendDirection,
+) -> Result<Vec<i64>, SqliteGraphError> {
+    graph.get_entity(start)?;
+    if allowed_edge_types.is_empty() {
+        return Ok(Vec::new());
+    }
+    let lookup = build_lookup(allowed_edge_types);
+    let mut visited = Vec::new();
+    let mut seen = AHashSet::new();
+    let mut queue = VecDeque::new();
+    queue.push_back((start, 0));
+    seen.insert(start);
+    while let Some((node, depth)) = queue.pop_front() {
+        visited.push(node);
+        if depth >= max_depth {
+            continue;
+        }
+        for next in typed_adjacency(graph, node, direction, Some(&lookup))? {
+            if seen.insert(next) {
+                queue.push_back((next, depth + 1));
+            }
+        }
+    }
+    Ok(visited)
+}
+
+pub fn shortest_path(
+    graph: &SqliteGraph,
+    start: i64,
+    end: i64,
+) -> Result<Option<Vec<i64>>, SqliteGraphError> {
+    graph.get_entity(start)?;
+    graph.get_entity(end)?;
+    if start == end {
+        return Ok(Some(vec![start]));
+    }
+    let mut queue = VecDeque::new();
+    let mut parents = AHashMap::new();
+    let mut seen = AHashSet::new();
+    queue.push_back(start);
+    seen.insert(start);
+    let mut found = false;
+    while let Some(node) = queue.pop_front() {
+        for next in graph.fetch_outgoing(node)? {
+            if seen.insert(next) {
+                parents.insert(next, node);
+                if next == end {
+                    found = true;
+                    break;
+                }
+                queue.push_back(next);
+            }
+        }
+        if found {
+            break;
+        }
+    }
+    if !found {
+        return Ok(None);
+    }
+    let mut path = vec![end];
+    let mut current = end;
+    while let Some(&parent) = parents.get(&current) {
+        path.push(parent);
+        if parent == start {
+            break;
+        }
+        current = parent;
+    }
+    if path.last().map(|last| *last != start).unwrap_or(true) {
+        return Ok(None);
+    }
+    path.reverse();
+    Ok(Some(path))
+}
+
+pub fn shortest_path_filtered(
+    graph: &SqliteGraph,
+    start: i64,
+    end: i64,
+    allowed_edge_types: &[&str],
+) -> Result<Option<Vec<i64>>, SqliteGraphError> {
+    graph.get_entity(start)?;
+    graph.get_entity(end)?;
+    if start == end {
+        return Ok(Some(vec![start]));
+    }
+    if allowed_edge_types.is_empty() {
+        return Ok(None);
+    }
+    let lookup = build_lookup(allowed_edge_types);
+    let mut queue = VecDeque::new();
+    let mut parents = AHashMap::new();
+    let mut seen = AHashSet::new();
+    queue.push_back(start);
+    seen.insert(start);
+    let mut found = false;
+    while let Some(node) = queue.pop_front() {
+        for next in typed_adjacency(graph, node, BackendDirection::Outgoing, Some(&lookup))? {
+            if seen.insert(next) {
+                parents.insert(next, node);
+                if next == end {
+                    found = true;
+                    break;
+                }
+                queue.push_back(next);
+            }
+        }
+        if found {
+            break;
+        }
+    }
+    if !found {
+        return Ok(None);
+    }
+    let mut path = vec![end];
+    let mut current = end;
+    while let Some(&parent) = parents.get(&current) {
+        path.push(parent);
+        if parent == start {
+            break;
+        }
+        current = parent;
+    }
+    if path.last().map(|last| *last != start).unwrap_or(true) {
+        return Ok(None);
+    }
+    path.reverse();
+    Ok(Some(path))
+}

sqlitegraph-0.3.0/sqlitegraph-core/src/graph/edge_ops.rs

@@ -0,0 +1,118 @@
+//! Edge CRUD operations for SqliteGraph.
+
+use rusqlite::params;
+
+use crate::errors::SqliteGraphError;
+
+use super::{
+    SqliteGraph,
+    types::{GraphEdge, row_to_edge, validate_edge},
+};
+
+impl SqliteGraph {
+    pub fn insert_edge(&self, edge: &GraphEdge) -> Result<i64, SqliteGraphError> {
+        validate_edge(edge)?;
+        if !self.entity_exists(edge.from_id)? || !self.entity_exists(edge.to_id)? {
+            return Err(SqliteGraphError::invalid_input(
+                "edge endpoints must reference existing entities",
+            ));
+        }
+        let data = serde_json::to_string(&edge.data)
+            .map_err(|e| SqliteGraphError::invalid_input(e.to_string()))?;
+        self.connection()
+            .execute(
+                "INSERT INTO graph_edges(from_id, to_id, edge_type, data) VALUES(?1, ?2, ?3, ?4)",
+                params![edge.from_id, edge.to_id, edge.edge_type.as_str(), data],
+            )
+            .map_err(|e| SqliteGraphError::query(e.to_string()))?;
+        self.invalidate_caches();
+        Ok(self.connection().last_insert_rowid())
+    }
+
+    /// Insert many edges atomically inside a single transaction.
+    ///
+    /// Returns the rowids of the inserted edges in the same order as the
+    /// input. Empty input returns an empty vector without opening a
+    /// transaction. On any error, the transaction is rolled back and the
+    /// database is left untouched.
+    pub fn insert_edges_bulk(&self, edges: &[GraphEdge]) -> Result<Vec<i64>, SqliteGraphError> {
+        if edges.is_empty() {
+            return Ok(Vec::new());
+        }
+        for edge in edges {
+            validate_edge(edge)?;
+            if !self.entity_exists(edge.from_id)? || !self.entity_exists(edge.to_id)? {
+                return Err(SqliteGraphError::invalid_input(
+                    "edge endpoints must reference existing entities",
+                ));
+            }
+        }
+        let conn = self.connection();
+        conn.underlying()
+            .execute_batch("BEGIN")
+            .map_err(|e| SqliteGraphError::query(e.to_string()))?;
+
+        let mut ids = Vec::with_capacity(edges.len());
+        let insert_result: Result<(), SqliteGraphError> = (|| {
+            let mut stmt = conn
+                .prepare_cached(
+                    "INSERT INTO graph_edges(from_id, to_id, edge_type, data) VALUES(?1, ?2, ?3, ?4)",
+                )
+                .map_err(|e| SqliteGraphError::query(e.to_string()))?;
+            for edge in edges {
+                let data = serde_json::to_string(&edge.data)
+                    .map_err(|e| SqliteGraphError::invalid_input(e.to_string()))?;
+                stmt.execute(params![
+                    edge.from_id,
+                    edge.to_id,
+                    edge.edge_type.as_str(),
+                    data,
+                ])
+                .map_err(|e| SqliteGraphError::query(e.to_string()))?;
+                ids.push(conn.last_insert_rowid());
+            }
+            Ok(())
+        })();
+
+        match insert_result {
+            Ok(()) => {
+                conn.underlying()
+                    .execute_batch("COMMIT")
+                    .map_err(|e| SqliteGraphError::query(e.to_string()))?;
+                self.invalidate_caches();
+                Ok(ids)
+            }
+            Err(err) => {
+                let _ = conn.underlying().execute_batch("ROLLBACK");
+                Err(err)
+            }
+        }
+    }
+
+    pub fn get_edge(&self, id: i64) -> Result<GraphEdge, SqliteGraphError> {
+        self.connection()
+            .query_row(
+                "SELECT id, from_id, to_id, edge_type, data FROM graph_edges WHERE id=?1",
+                params![id],
+                row_to_edge,
+            )
+            .map_err(|err| match err {
+                rusqlite::Error::QueryReturnedNoRows => {
+                    SqliteGraphError::not_found(format!("edge {id}"))
+                }
+                other => SqliteGraphError::query(other.to_string()),
+            })
+    }
+
+    pub fn delete_edge(&self, id: i64) -> Result<(), SqliteGraphError> {
+        let affected = self
+            .connection()
+            .execute("DELETE FROM graph_edges WHERE id=?1", params![id])
+            .map_err(|e| SqliteGraphError::query(e.to_string()))?;
+        if affected == 0 {
+            return Err(SqliteGraphError::not_found(format!("edge {id}")));
+        }
+        self.invalidate_caches();
+        Ok(())
+    }
+}

{sqlitegraph-0.1.1 → sqlitegraph-0.3.0}/sqlitegraph-core/src/graph/entity_ops.rs

@@ -28,6 +28,63 @@ impl SqliteGraph {
         Ok(self.connection().last_insert_rowid())
     }
 
+    /// Insert many entities atomically inside a single transaction.
+    ///
+    /// Returns the rowids of the inserted entities in the same order as the
+    /// input. Empty input returns an empty vector without opening a
+    /// transaction. On any error, the transaction is rolled back and the
+    /// database is left untouched.
+    pub fn insert_entities_bulk(
+        &self,
+        entities: &[GraphEntity],
+    ) -> Result<Vec<i64>, SqliteGraphError> {
+        if entities.is_empty() {
+            return Ok(Vec::new());
+        }
+        for entity in entities {
+            validate_entity(entity)?;
+        }
+        let conn = self.connection();
+        conn.underlying()
+            .execute_batch("BEGIN")
+            .map_err(|e| SqliteGraphError::query(e.to_string()))?;
+
+        let mut ids = Vec::with_capacity(entities.len());
+        let insert_result: Result<(), SqliteGraphError> = (|| {
+            let mut stmt = conn
+                .prepare_cached(
+                    "INSERT INTO graph_entities(kind, name, file_path, data) VALUES(?1, ?2, ?3, ?4)",
+                )
+                .map_err(|e| SqliteGraphError::query(e.to_string()))?;
+            for entity in entities {
+                let data = serde_json::to_string(&entity.data)
+                    .map_err(|e| SqliteGraphError::invalid_input(e.to_string()))?;
+                stmt.execute(params![
+                    entity.kind.as_str(),
+                    entity.name.as_str(),
+                    entity.file_path.as_deref(),
+                    data,
+                ])
+                .map_err(|e| SqliteGraphError::query(e.to_string()))?;
+                ids.push(conn.last_insert_rowid());
+            }
+            Ok(())
+        })();
+
+        match insert_result {
+            Ok(()) => {
+                conn.underlying()
+                    .execute_batch("COMMIT")
+                    .map_err(|e| SqliteGraphError::query(e.to_string()))?;
+                Ok(ids)
+            }
+            Err(err) => {
+                let _ = conn.underlying().execute_batch("ROLLBACK");
+                Err(err)
+            }
+        }
+    }
+
     pub fn get_entity(&self, id: i64) -> Result<GraphEntity, SqliteGraphError> {
         self.connection()
             .query_row(

{sqlitegraph-0.1.1 → sqlitegraph-0.3.0}/sqlitegraph-core/src/multi_hop.rs

@@ -139,6 +139,15 @@ fn adjacency_for(
     node: i64,
     direction: BackendDirection,
     allowed_types: Option<&AHashSet<&str>>,
+) -> Result<Vec<i64>, SqliteGraphError> {
+    typed_adjacency(graph, node, direction, allowed_types)
+}
+
+pub(crate) fn typed_adjacency(
+    graph: &SqliteGraph,
+    node: i64,
+    direction: BackendDirection,
+    allowed_types: Option<&AHashSet<&str>>,
 ) -> Result<Vec<i64>, SqliteGraphError> {
     match allowed_types {
         Some(set) => filter_neighbors(graph, node, direction, set),
@@ -183,7 +192,7 @@ fn filter_neighbors(
     Ok(result)
 }
 
-fn build_lookup<'a>(types: &'a [&'a str]) -> AHashSet<&'a str> {
+pub(crate) fn build_lookup<'a>(types: &'a [&'a str]) -> AHashSet<&'a str> {
     let mut lookup = AHashSet::with_capacity(types.len());
     for ty in types {
         lookup.insert(*ty);