gqlite 1.5.0 → 1.7.0

data/ext/gqlitedb/src/store/sqlbase/sqlmetadata.rs

@@ -7,6 +7,7 @@ pub(crate) trait SqlMetaDataQueries
 {
   fn metadata_get_query() -> Result<String>;
   fn metadata_set_query() -> Result<String>;
+  fn metadata_delete_query() -> Result<String>;
 }
 
 pub(crate) trait SqlMetaDataStore: super::SqlStore
@@ -61,6 +62,15 @@ pub(crate) trait SqlMetaDataStore: super::SqlStore
     let v = self.get_optional_metadata_value::<String>(transaction, key)?;
     v.map_or_else(|| Ok(f()), |x| Ok(serde_json::from_str(&x)?))
   }
+  fn get_metadata_value_json_or_default<T: for<'a> Deserialize<'a> + Default>(
+    &self,
+    transaction: &mut Self::TransactionBox,
+    key: impl Into<String>,
+  ) -> Result<T>
+  {
+    let v = self.get_optional_metadata_value::<String>(transaction, key)?;
+    v.map_or(Ok(Default::default()), |x| Ok(serde_json::from_str(&x)?))
+  }
   fn set_metadata_value<'a>(
     &self,
     transaction: &mut Self::TransactionBox,
@@ -77,6 +87,12 @@ pub(crate) trait SqlMetaDataStore: super::SqlStore
   {
     self.set_metadata_value(transaction, key, &serde_json::to_string(value)?)
   }
+  /// Delete a metadata entry by key.
+  fn delete_metadata(
+    &self,
+    transaction: &mut Self::TransactionBox,
+    key: impl Into<String>,
+  ) -> Result<()>;
 }
 
 impl<TStore> SqlMetaDataStore for TStore
@@ -114,4 +130,16 @@ where
       (&key.into(), value.into()),
     )
   }
+  fn delete_metadata(
+    &self,
+    transaction: &mut Self::TransactionBox,
+    key: impl Into<String>,
+  ) -> Result<()>
+  {
+    self
+      .execute(transaction, Self::metadata_delete_query()?, (&key.into(),))
+      .map_err(|e| {
+        InternalError::MigrationError(format!("Failed to delete metadata: {}", e)).into()
+      })
+  }
 }

data/ext/gqlitedb/src/store/sqlbase/sqlstore.rs

@@ -52,4 +52,107 @@ pub(crate) trait SqlStore
     bindings: impl IntoBindings<'a>,
     f: impl for<'b> FnMut(&Self::Row<'b>) -> Result<()>,
   ) -> Result<()>;
+
+  /// Helper for backend-specific vector index creation
+  fn create_vector_index_impl(
+    &self,
+    transaction: &mut Self::TransactionBox,
+    graph_name: &str,
+    spec: &crate::store::VectorIndexSpec,
+  ) -> Result<()>
+  {
+    let _ = (transaction, graph_name, spec);
+    Err(InternalError::Unimplemented("Vector indexes are not supported in this backend").into())
+  }
+
+  /// Helper for backend-specific vector-index listing
+  fn list_vector_indexes_impl(
+    &self,
+    transaction: &mut Self::TransactionBox,
+    graph_name: &str,
+  ) -> Result<Vec<crate::store::VectorIndexSpec>>
+  {
+    let _ = (transaction, graph_name);
+    Err(InternalError::Unimplemented("Vector indexes are not supported in this backend").into())
+  }
+
+  /// Helper for backend-specific vector upsert
+  fn upsert_vector_impl(
+    &self,
+    transaction: &mut Self::TransactionBox,
+    graph_name: &str,
+    index_name: &str,
+    node_id: crate::graph::Key,
+    tensor: &crate::value::Tensor,
+  ) -> Result<()>
+  {
+    let _ = (transaction, graph_name, index_name, node_id, tensor);
+    Err(InternalError::Unimplemented("Vector operations are not supported in this backend").into())
+  }
+
+  /// Helper for backend-specific vector search
+  fn vector_search_impl(
+    &self,
+    transaction: &mut Self::TransactionBox,
+    graph_name: &str,
+    index_name: &str,
+    query: &crate::value::Tensor,
+    k: usize,
+  ) -> Result<Vec<crate::store::VectorSearchResult>>
+  {
+    let _ = (transaction, graph_name, index_name, query, k);
+    Err(InternalError::Unimplemented("Vector search is not supported in this backend").into())
+  }
+
+  /// Helper for backend-specific vector index removal
+  fn drop_vector_index_impl(
+    &self,
+    transaction: &mut Self::TransactionBox,
+    graph_name: &str,
+    index_name: &str,
+  ) -> Result<()>
+  {
+    let _ = (transaction, graph_name, index_name);
+    Err(InternalError::Unimplemented("Vector indexes are not supported in this backend").into())
+  }
+
+  /// Helper for backend-specific graph vector-index cleanup before graph deletion
+  fn drop_graph_vector_indices_impl(
+    &self,
+    transaction: &mut Self::TransactionBox,
+    graph_name: &str,
+  ) -> Result<()>
+  {
+    let _ = (transaction, graph_name);
+    Ok(())
+  }
+
+  /// Helper for getting vector indices that apply to a property
+  fn get_vector_indices_for_property_impl(
+    &self,
+    transaction: &mut Self::TransactionBox,
+    graph_name: &str,
+    label: &str,
+    property: &str,
+  ) -> Result<Vec<(String, usize, crate::store::VectorMetric)>>
+  {
+    let _ = (transaction, graph_name, label, property);
+    Err(InternalError::Unimplemented("Vector metadata is not supported in this backend").into())
+  }
+
+  /// Helper for applying vector indices to a node
+  fn apply_vector_indices_for_node_impl(
+    &self,
+    transaction: &mut Self::TransactionBox,
+    graph_name: &str,
+    node: &crate::graph::Node,
+  ) -> Result<()>;
+
+  /// Helper for deleting vectors for deleted nodes
+  fn delete_vectors_for_nodes_impl(
+    &self,
+    transaction: &mut Self::TransactionBox,
+    graph_name: &str,
+    node_ids: &[String],
+  ) -> Result<()>;
 }

data/ext/gqlitedb/src/store/sqlbase.rs

@@ -75,6 +75,7 @@ where
     let mut graphs_list = self.graphs_list(transaction)?;
     if graphs_list.iter().any(|s| s == graph_name)
     {
+      <Self as SqlStore>::drop_graph_vector_indices_impl(self, transaction, graph_name)?;
       self.execute_batch(transaction, Self::graph_delete(graph_name)?)?;
       graphs_list.retain(|x| x != graph_name);
       self.set_metadata_value_json(transaction, "graphs", &graphs_list)?;
@@ -102,17 +103,25 @@ where
     nodes_iter: T,
   ) -> Result<()>
   {
-    for x in nodes_iter
+    let graph_name_str = graph_name.as_ref();
+    for node in nodes_iter
     {
       self.execute(
         transaction,
-        Self::node_create_query(&graph_name)?.as_str(),
+        Self::node_create_query(graph_name_str)?.as_str(),
         (
-          &x.key(),
-          LabelsRef(x.labels()),
-          PropertiesRef(x.properties()),
+          &node.key(),
+          LabelsRef(node.labels()),
+          PropertiesRef(node.properties()),
         ),
       )?;
+      // Apply vector indices for this node
+      <Self as crate::store::sqlbase::SqlStore>::apply_vector_indices_for_node_impl(
+        self,
+        transaction,
+        graph_name_str,
+        node,
+      )?;
     }
     Ok(())
   }
@@ -154,9 +163,13 @@ where
     }
     self.execute(
       transaction,
-      Self::node_delete_query(graph_name, nodes_keys)?,
+      Self::node_delete_query(graph_name, nodes_keys.clone())?,
       (),
     )?;
+
+    // Clean up vector indices for deleted nodes
+    let _ = self.delete_vectors_for_nodes_impl(transaction, graph_name, &nodes_keys);
+
     Ok(())
   }
   fn update_node(
@@ -166,15 +179,23 @@ where
     node: &crate::graph::Node,
   ) -> Result<()>
   {
+    let graph_name_str = graph_name.as_ref();
     self.execute(
       transaction,
-      Self::node_update_query(graph_name)?,
+      Self::node_update_query(graph_name_str)?,
       (
         &node.key(),
         LabelsRef(node.labels()),
         PropertiesRef(node.properties()),
       ),
     )?;
+    // Apply vector indices for this node (update case)
+    <Self as crate::store::sqlbase::SqlStore>::apply_vector_indices_for_node_impl(
+      self,
+      transaction,
+      graph_name_str,
+      node,
+    )?;
     Ok(())
   }
   fn select_nodes(
@@ -184,6 +205,7 @@ where
     query: store::SelectNodeQuery,
   ) -> Result<Vec<crate::graph::Node>>
   {
+    let graph_name = graph_name.as_ref();
     let mut query_bindings = Vec::<SqlBindingValue>::new();
     let keys_var = query.keys.as_ref().map(|keys| {
       query_bindings.push(keys.into());
@@ -206,7 +228,12 @@ where
         let key: graph::Key = row.get::<graph::Key>(0)?;
         let labels = row.get::<Labels>(1)?;
         let properties = row.get::<Properties>(2)?;
-        nodes.push(graph::Node::new(key, labels.0, properties.0));
+        nodes.push(graph::Node::new(
+          Some(graph_name.to_string()),
+          key,
+          labels.0,
+          properties.0,
+        ));
         Ok(())
       },
     )?;
@@ -241,7 +268,7 @@ where
     transaction: &mut Self::TransactionBox,
     graph_name: impl AsRef<str>,
     query: store::SelectEdgeQuery,
-    directivity: crate::graph::EdgeDirectivity,
+    directivity: graphcore::EdgeDirectivity,
   ) -> Result<()>
   {
     let graph_name = graph_name.as_ref();
@@ -280,17 +307,18 @@ where
     transaction: &mut Self::TransactionBox,
     graph_name: impl AsRef<str>,
     query: store::SelectEdgeQuery,
-    directivity: crate::graph::EdgeDirectivity,
+    directivity: graphcore::EdgeDirectivity,
   ) -> Result<Vec<store::EdgeResult>>
   {
+    let graph_name = graph_name.as_ref();
     if query.source.is_select_none() || query.destination.is_select_none()
     {
       return Ok(Default::default());
     }
     let (is_undirected, table_suffix) = match directivity
     {
-      graph::EdgeDirectivity::Directed => (false, ""),
-      graph::EdgeDirectivity::Undirected => (true, "_undirected"),
+      graphcore::EdgeDirectivity::Directed => (false, ""),
+      graphcore::EdgeDirectivity::Undirected => (true, "_undirected"),
     };
 
     let mut query_bindings = Vec::<SqlBindingValue>::new();
@@ -378,8 +406,18 @@ where
         let n_right_labels = row.get::<Labels>(8)?.0;
         let n_right_properties = row.get::<Properties>(9)?.0;
 
-        let source = graph::Node::new(n_left_key, n_left_labels, n_left_properties);
-        let destination = graph::Node::new(n_right_key, n_right_labels, n_right_properties);
+        let source = graph::Node::new(
+          Some(graph_name.to_string()),
+          n_left_key,
+          n_left_labels,
+          n_left_properties,
+        );
+        let destination = graph::Node::new(
+          Some(graph_name.to_string()),
+          n_right_key,
+          n_right_labels,
+          n_right_properties,
+        );
         let reversed = row.get::<u32>(3)? == 1;
         let (source, destination) = if reversed
         {
@@ -391,7 +429,12 @@ where
         };
 
         edges.push(EdgeResult {
-          path: graph::Path::new(edge_key, source, edge_labels, edge_properties, destination),
+          path: graph::SinglePath::new(
+            source,
+            graph::Edge::new(None, edge_key, edge_labels, edge_properties),
+            destination,
+          )
+          .with_graph_name(graph_name.to_string()),
           reversed,
         });
         Ok(())
@@ -401,7 +444,7 @@ where
     Ok(edges)
   }
   fn compute_statistics(&self, transaction: &mut Self::TransactionBox)
-    -> Result<store::Statistics>
+  -> Result<store::Statistics>
   {
     let (nodes_count, edges_count, labels_nodes_count, properties_count) = self.query_row(
       transaction,
@@ -416,4 +459,91 @@ where
       properties_count,
     })
   }
+
+  fn create_vector_index(
+    &self,
+    transaction: &mut Self::TransactionBox,
+    graph_name: impl AsRef<str>,
+    spec: store::VectorIndexSpec,
+  ) -> Result<()>
+  {
+    <Self as SqlStore>::create_vector_index_impl(self, transaction, graph_name.as_ref(), &spec)
+  }
+
+  fn list_vector_indexes(
+    &self,
+    transaction: &mut Self::TransactionBox,
+    graph_name: impl AsRef<str>,
+  ) -> Result<Vec<store::VectorIndexSpec>>
+  {
+    <Self as SqlStore>::list_vector_indexes_impl(self, transaction, graph_name.as_ref())
+  }
+
+  fn upsert_vector(
+    &self,
+    transaction: &mut Self::TransactionBox,
+    graph_name: impl AsRef<str>,
+    index_name: impl AsRef<str>,
+    node_id: graph::Key,
+    tensor: &value::Tensor,
+  ) -> Result<()>
+  {
+    <Self as SqlStore>::upsert_vector_impl(
+      self,
+      transaction,
+      graph_name.as_ref(),
+      index_name.as_ref(),
+      node_id,
+      tensor,
+    )
+  }
+
+  fn vector_search(
+    &self,
+    transaction: &mut Self::TransactionBox,
+    graph_name: impl AsRef<str>,
+    index_name: impl AsRef<str>,
+    query: &value::Tensor,
+    k: usize,
+  ) -> Result<Vec<store::VectorSearchResult>>
+  {
+    <Self as SqlStore>::vector_search_impl(
+      self,
+      transaction,
+      graph_name.as_ref(),
+      index_name.as_ref(),
+      query,
+      k,
+    )
+  }
+
+  fn drop_vector_index(
+    &self,
+    transaction: &mut Self::TransactionBox,
+    graph_name: impl AsRef<str>,
+    index_name: impl AsRef<str>,
+  ) -> Result<()>
+  {
+    <Self as SqlStore>::drop_vector_index_impl(
+      self,
+      transaction,
+      graph_name.as_ref(),
+      index_name.as_ref(),
+    )
+  }
+
+  fn apply_vector_indices_for_node(
+    &self,
+    transaction: &mut Self::TransactionBox,
+    graph_name: impl AsRef<str>,
+    node: &crate::graph::Node,
+  ) -> Result<()>
+  {
+    <Self as SqlStore>::apply_vector_indices_for_node_impl(
+      self,
+      transaction,
+      graph_name.as_ref(),
+      node,
+    )
+  }
 }