sqlitegraph 0.4.0__tar.gz → 0.4.1__tar.gz

{sqlitegraph-0.4.0 → sqlitegraph-0.4.1}/Cargo.lock

@@ -1387,7 +1387,7 @@ checksum = "67b1b7a3b5fe4f1376887184045fcf45c69e92af734b7aaddc05fb777b6fbd03"
 
 [[package]]
 name = "sqlitegraph"
-version = "3.0.0"
+version = "3.0.1"
 dependencies = [
  "ahash",
  "arc-swap",
@@ -1419,7 +1419,7 @@ dependencies = [
 
 [[package]]
 name = "sqlitegraph-cli"
-version = "3.0.0"
+version = "3.0.1"
 dependencies = [
  "anyhow",
  "clap",
@@ -1429,7 +1429,7 @@ dependencies = [
 
 [[package]]
 name = "sqlitegraph-py"
-version = "0.4.0"
+version = "0.4.1"
 dependencies = [
  "ndarray 0.16.1",
  "numpy",

{sqlitegraph-0.4.0 → sqlitegraph-0.4.1}/PKG-INFO

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

{sqlitegraph-0.4.0 → sqlitegraph-0.4.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "sqlitegraph"
-version = "0.4.0"
+version = "0.4.1"
 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.4.0 → sqlitegraph-0.4.1}/sqlitegraph-core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "sqlitegraph"
-version = "3.0.0"
+version = "3.0.1"
 edition = "2024"
 rust-version = "1.89"
 description = "Embedded graph database with full ACID transactions, HNSW vector search, dual backend support, and comprehensive graph algorithms library"

{sqlitegraph-0.4.0 → sqlitegraph-0.4.1}/sqlitegraph-core/src/graph/entity_ops.rs

@@ -14,18 +14,31 @@ impl SqliteGraph {
         validate_entity(entity)?;
         let data = serde_json::to_string(&entity.data)
             .map_err(|e| SqliteGraphError::invalid_input(e.to_string()))?;
-        self.connection()
-            .execute(
-                "INSERT INTO graph_entities(kind, name, file_path, data) VALUES(?1, ?2, ?3, ?4)",
-                params![
-                    entity.kind.as_str(),
-                    entity.name.as_str(),
-                    entity.file_path.as_deref(),
-                    data,
-                ],
+        let conn = self.connection();
+        conn.execute(
+            "INSERT INTO graph_entities(kind, name, file_path, data) VALUES(?1, ?2, ?3, ?4)",
+            params![
+                entity.kind.as_str(),
+                entity.name.as_str(),
+                entity.file_path.as_deref(),
+                data,
+            ],
+        )
+        .map_err(|e| SqliteGraphError::query(e.to_string()))?;
+        let id = conn.last_insert_rowid();
+        // Auto-register `kind` as a label so `match_triples` can answer
+        // label-filtered edge queries (e.g. `(a:User)-[:KNOWS]->(b:User)`)
+        // without callers having to call `index::add_label` separately.
+        // `INSERT OR IGNORE` is safe against duplicates if the row already
+        // exists (e.g. re-running migrations or future kind/label sync).
+        if !entity.kind.is_empty() {
+            conn.execute(
+                "INSERT OR IGNORE INTO graph_labels(entity_id, label) VALUES(?1, ?2)",
+                params![id, entity.kind.as_str()],
             )
             .map_err(|e| SqliteGraphError::query(e.to_string()))?;
-        Ok(self.connection().last_insert_rowid())
+        }
+        Ok(id)
     }
 
     /// Insert many entities atomically inside a single transaction.
@@ -51,22 +64,34 @@ impl SqliteGraph {
 
         let mut ids = Vec::with_capacity(entities.len());
         let insert_result: Result<(), SqliteGraphError> = (|| {
-            let mut stmt = conn
+            let mut entity_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()))?;
+            let mut label_stmt = conn
+                .prepare_cached(
+                    "INSERT OR IGNORE INTO graph_labels(entity_id, label) VALUES(?1, ?2)",
+                )
+                .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());
+                entity_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()))?;
+                let id = conn.last_insert_rowid();
+                if !entity.kind.is_empty() {
+                    label_stmt
+                        .execute(params![id, entity.kind.as_str()])
+                        .map_err(|e| SqliteGraphError::query(e.to_string()))?;
+                }
+                ids.push(id);
             }
             Ok(())
         })();

{sqlitegraph-0.4.0 → sqlitegraph-0.4.1}/sqlitegraph-core/src/schema.rs

@@ -74,6 +74,19 @@ const MIGRATION_STEPS: &[MigrationStep] = &[
             "INSERT INTO graph_meta_history(version) VALUES(4)",
         ],
     },
+    MigrationStep {
+        target_version: 5,
+        // Enforce label uniqueness so `INSERT OR IGNORE INTO graph_labels`
+        // actually dedupes (the original base schema had no UNIQUE
+        // constraint, so duplicates silently accumulated). The DELETE step
+        // collapses any existing duplicates by keeping the lowest rowid
+        // per (entity_id, label).
+        statements: &[
+            "DELETE FROM graph_labels WHERE rowid NOT IN (SELECT MIN(rowid) FROM graph_labels GROUP BY entity_id, label)",
+            "CREATE UNIQUE INDEX IF NOT EXISTS uq_graph_labels_entity_label ON graph_labels(entity_id, label)",
+            "INSERT INTO graph_meta_history(version) VALUES(5)",
+        ],
+    },
 ];
 
 pub const SCHEMA_VERSION: i64 = BASE_SCHEMA_VERSION + MIGRATION_STEPS.len() as i64;

{sqlitegraph-0.4.0 → sqlitegraph-0.4.1}/sqlitegraph-core/tests/cypher_tests.rs

@@ -1198,3 +1198,96 @@ fn test_execute_call_unknown_index_errors() {
     let r = cypher::execute(&backend, &q);
     assert!(r.is_err(), "expected error for missing index, got {r:?}");
 }
+
+// ── Regression: label-filtered edge patterns must work after plain
+// `insert_node` without an explicit `add_label` call. Reported against
+// 3.0.0 / py 0.4.0 where the user found that
+//   `MATCH (a:User)-[:KNOWS]->(b:User) RETURN a, b`
+// returned zero rows even though the data was present, because
+// `insert_node` populated `graph_entities.kind` but never registered
+// the kind in `graph_labels` (which `match_triples` joins on).
+
+#[test]
+fn test_label_filtered_edge_match_after_plain_insert_node() {
+    let graph = SqliteGraph::open_in_memory().expect("open");
+    let backend = SqliteGraphBackend::from_graph(graph);
+    let a = backend
+        .insert_node(NodeSpec {
+            kind: "User".into(),
+            name: "Alice".into(),
+            file_path: None,
+            data: serde_json::json!({}),
+        })
+        .unwrap();
+    let b = backend
+        .insert_node(NodeSpec {
+            kind: "User".into(),
+            name: "Bob".into(),
+            file_path: None,
+            data: serde_json::json!({}),
+        })
+        .unwrap();
+    backend
+        .insert_edge(EdgeSpec {
+            from: a,
+            to: b,
+            edge_type: "KNOWS".into(),
+            data: serde_json::json!({}),
+        })
+        .unwrap();
+
+    // No explicit `add_label` calls — `kind` alone must be enough.
+    let q =
+        cypher::parse("MATCH (a:User)-[:KNOWS]->(b:User) RETURN a.name, b.name").expect("parse");
+    let result = cypher::execute(&backend, &q).expect("execute");
+    let rows = result.get("results").unwrap().as_array().unwrap();
+    assert_eq!(
+        rows.len(),
+        1,
+        "label-filtered edge MATCH must find the one edge"
+    );
+    assert_eq!(rows[0].get("a.name").unwrap().as_str(), Some("Alice"));
+    assert_eq!(rows[0].get("b.name").unwrap().as_str(), Some("Bob"));
+}
+
+#[test]
+fn test_label_filtered_edge_match_after_bulk_insert() {
+    use sqlitegraph::GraphBackend;
+
+    let graph = SqliteGraph::open_in_memory().expect("open");
+    let backend = SqliteGraphBackend::from_graph(graph);
+    let ids = backend
+        .insert_nodes_bulk(&[
+            NodeSpec {
+                kind: "User".into(),
+                name: "Alice".into(),
+                file_path: None,
+                data: serde_json::json!({}),
+            },
+            NodeSpec {
+                kind: "User".into(),
+                name: "Bob".into(),
+                file_path: None,
+                data: serde_json::json!({}),
+            },
+        ])
+        .unwrap();
+    backend
+        .insert_edge(EdgeSpec {
+            from: ids[0],
+            to: ids[1],
+            edge_type: "KNOWS".into(),
+            data: serde_json::json!({}),
+        })
+        .unwrap();
+
+    let q =
+        cypher::parse("MATCH (a:User)-[:KNOWS]->(b:User) RETURN a.name, b.name").expect("parse");
+    let result = cypher::execute(&backend, &q).expect("execute");
+    let rows = result.get("results").unwrap().as_array().unwrap();
+    assert_eq!(
+        rows.len(),
+        1,
+        "bulk-inserted nodes must register kind as label too"
+    );
+}

{sqlitegraph-0.4.0 → sqlitegraph-0.4.1}/sqlitegraph-core/tests/instrumentation_tests.rs

@@ -48,7 +48,12 @@ fn test_execute_counter_increments() -> Result<(), SqliteGraphError> {
     graph.insert_entity(&entity)?;
 
     let after = graph.metrics_snapshot();
-    assert_eq!(before.execute_count + 1, after.execute_count);
+    // insert_entity issues two `execute()` calls: one to insert the row
+    // into `graph_entities`, one to auto-register the kind as a label in
+    // `graph_labels` so subsequent `match_triples` label-filtered edge
+    // patterns find the node. The label INSERT is `OR IGNORE` and is
+    // skipped only when `kind` is empty (which is not the case here).
+    assert_eq!(before.execute_count + 2, after.execute_count);
     assert_eq!(before.prepare_count, after.prepare_count);
     Ok(())
 }

{sqlitegraph-0.4.0 → sqlitegraph-0.4.1}/sqlitegraph-py/CHANGELOG.md

@@ -5,6 +5,20 @@ crate of the same name has its own changelog at the repository root.
 
 ## [Unreleased]
 
+## [0.4.1] - 2026-05-18
+
+### Fixed
+
+- **`Graph.query("MATCH (a:User)-[:KNOWS]->(b:User) ...")` returned
+  zero rows** after plain `Graph.add_node(kind="User", ...)` calls.
+  Root cause was in the core `sqlitegraph` crate (fixed in 3.0.1):
+  `insert_entity` only populated `graph_entities.kind` and left
+  `graph_labels` empty, so `match_triples` label joins missed
+  everything. The Python wheel picks up the fix automatically by
+  bumping the bundled core to 3.0.1 — no Python-side code changes
+  beyond the version bump. Workarounds that called the underlying
+  Rust `add_label` helper are no longer necessary.
+
 ## [0.4.0] - 2026-05-18
 
 ### Highlights

{sqlitegraph-0.4.0 → sqlitegraph-0.4.1}/sqlitegraph-py/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "sqlitegraph-py"
-version = "0.4.0"
+version = "0.4.1"
 edition = "2021"
 description = "Python bindings for sqlitegraph via PyO3"
 license = "GPL-3.0-only"