gqlite 1.5.0 → 1.7.0

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

@@ -1,22 +1,105 @@
 use std::cell::RefCell;
 
 use ccutils::pool::{self, Pool};
+use serde::{Deserialize, Serialize};
 
 use crate::{
   prelude::*,
   store::{
+    TransactionBoxable, VectorMetric,
     sqlbase::{SqlBindingValue, SqlResultValue},
-    TransactionBoxable,
   },
 };
 
 ccutils::assert_impl_all!(Store: Sync, Send);
 
 use askama::Template;
-use postgres::{types::ToSql, NoTls};
+use postgres::{NoTls, types::ToSql};
 
 const SCHEMA: &str = "public";
 
+/// Generate a vector index table name from graph and index names
+fn vector_index_table_name(graph_name: &str, index_name: &str) -> String
+{
+  format!("{}_{}", graph_name, index_name)
+}
+
+/// Convert hex-formatted u128 string back to UUID string format
+fn format_hex_to_uuid(hex_str: &str) -> String
+{
+  // Convert hex string back to u128, then to UUID
+  if let Ok(val) = u128::from_str_radix(hex_str, 16)
+  {
+    uuid::Uuid::from_u128(val).to_string()
+  }
+  else
+  {
+    // If parsing fails, return the original string (will cause SQL error)
+    hex_str.to_string()
+  }
+}
+
+fn cosine_distance(query: &[f32], stored: &[f32]) -> f32
+{
+  if query.len() != stored.len()
+  {
+    return f32::INFINITY;
+  }
+  let query_norm = query.iter().map(|v| v * v).sum::<f32>().sqrt();
+  let stored_norm = stored.iter().map(|v| v * v).sum::<f32>().sqrt();
+  if query_norm == 0.0 || stored_norm == 0.0
+  {
+    return f32::INFINITY;
+  }
+  let dot = query
+    .iter()
+    .zip(stored.iter())
+    .map(|(a, b)| a * b)
+    .sum::<f32>();
+  let cosine_similarity = (dot / (query_norm * stored_norm)).clamp(-1.0, 1.0);
+  1.0 - cosine_similarity
+}
+
+/// Map VectorMetric to pgvector operators
+fn metric_to_pgvector_operator(metric: Option<&super::VectorMetric>) -> &'static str
+{
+  match metric
+  {
+    Some(super::VectorMetric::Cosine) | None => "<=>",
+    Some(super::VectorMetric::L2) => "<->",
+    Some(super::VectorMetric::DotProduct) => "<#>",
+  }
+}
+
+/// Serialize a vector to pgvector binary format for use with postgres crate
+/// pgvector expects vectors as arrays that can be passed as text
+fn serialize_vector_for_pgvector(vector: &[f32]) -> String
+{
+  format!(
+    "[{}]",
+    vector
+      .iter()
+      .map(|v| v.to_string())
+      .collect::<Vec<_>>()
+      .join(",")
+  )
+}
+
+/// Parse a vector from pgvector result
+fn parse_pgvector_from_string(s: &str) -> Result<Vec<f32>>
+{
+  s.trim_start_matches('[')
+    .trim_end_matches(']')
+    .split(',')
+    .map(|part| {
+      part
+        .trim()
+        .parse::<f32>()
+        .map_err(|e| StoreError::InvalidFormat(format!("Invalid vector component: {}", e)).into())
+    })
+    .collect()
+}
+
 //  _____     _____                    ____        _
 // |_   _|__ |  ___| __ ___  _ __ ___ / ___|  __ _| |
 //   | |/ _ \| |_ | '__/ _ \| '_ ` _ \\___ \ / _` | |
@@ -104,7 +187,28 @@ impl sqlbase::Row for postgres::Row
           .collect(),
       )),
       &Type::JSONB => Ok(SqlResultValue::JsonValue(self.try_get(index)?)),
-      _ => Err(StoreError::UnsupportedPostgresType(ty.name().to_string()).into()),
+      _ =>
+      {
+        // Try to handle pgvector as a custom type - pgvector values come as text representation
+        if ty.name() == "vector"
+        {
+          let vector_str: String = self.try_get(index)?;
+          let vector = parse_pgvector_from_string(&vector_str)?;
+          // Return as blob since we don't have a dedicated vector type in SqlResultValue
+          // The caller will handle the blob as a vector
+          Ok(SqlResultValue::Blob(
+            vector
+              .iter()
+              .flat_map(|f| f.to_le_bytes())
+              .collect::<Vec<_>>()
+              .leak(),
+          ))
+        }
+        else
+        {
+          Err(StoreError::UnsupportedPostgresType(ty.name().to_string()).into())
+        }
+      }
     }
   }
 }
@@ -126,14 +230,12 @@ impl Drop for TransactionBase
   fn drop(&mut self)
   {
     if *self.active.borrow()
+      && let Err(e) = self.client.query("ROLLBACK", &[])
     {
-      if let Err(e) = self.client.query("ROLLBACK", &[])
-      {
-        println!(
-          "Rollback failed with error {:?}, future use of the connection are likely to fail.",
-          e
-        );
-      }
+      log::error!(
+        "Rollback failed with error {:?}, future use of the connection are likely to fail.",
+        e
+      );
     }
   }
 }
@@ -307,6 +409,16 @@ mod templates
   }
 }
 
+#[derive(Debug, Serialize, Deserialize)]
+struct VectorIndexMetadata
+{
+  name: String,
+  label: Option<String>,
+  property: Option<String>,
+  dimension: usize,
+  metric: VectorMetric,
+}
+
 //  ____  _
 // / ___|| |_ ___  _ __ ___
 // \___ \| __/ _ \| '__/ _ \
@@ -330,16 +442,103 @@ impl Store
       move || Ok(config.connect(NoTls)?),
       pool::Options::default().minimum_pool_size(1).pool_size(3),
     )?;
+    {
+      let mut setup_client = client.get()?;
+      setup_client.execute("CREATE EXTENSION IF NOT EXISTS vector", &[])?;
+    }
 
     let s = Self { client };
     s.initialise()?;
     Ok(s)
   }
-  fn upgrade_database(&self, _transaction: &mut TransactionBox, _from: utils::Version)
-    -> Result<()>
+  fn upgrade_database(&self, transaction: &mut TransactionBox, from: utils::Version) -> Result<()>
   {
-    // No release with postgres, so nothing to upgrade
-    Ok(())
+    match (from.major, from.minor)
+    {
+      (1, 2) =>
+      {
+        // Migrate vector index metadata from the 1.2 dual-key format:
+        //   {graph}/vector_index_list          -> Vec<String>
+        //   {graph}/vector_indices/{name}      -> VectorIndexMetadata (without name field)
+        //   {graph}_{name}/metric              -> VectorMetric  (legacy, may or may not exist)
+        // to the 1.3 unified format:
+        //   {graph}/vector_indices             -> Vec<VectorIndexMetadata> (with name field)
+
+        #[derive(serde::Deserialize)]
+        struct LegacyVectorIndexMetadata
+        {
+          label: Option<String>,
+          property: Option<String>,
+          dimension: usize,
+          metric: VectorMetric,
+        }
+
+        let graphs: Vec<String> = self.get_metadata_value_json_or_default(transaction, "graphs")?;
+
+        for graph_name in &graphs
+        {
+          let list_key = format!("{}/vector_index_list", graph_name);
+          let index_names: Vec<String> =
+            self.get_metadata_value_json_or_default(transaction, &list_key)?;
+
+          let mut new_list: Vec<VectorIndexMetadata> = Vec::new();
+          for index_name in &index_names
+          {
+            let legacy_key = format!("{}/vector_indices/{}", graph_name, index_name);
+            match self
+              .get_metadata_value_json::<LegacyVectorIndexMetadata>(transaction, &legacy_key)
+            {
+              Ok(legacy) =>
+              {
+                new_list.push(VectorIndexMetadata {
+                  name: index_name.clone(),
+                  label: legacy.label,
+                  property: legacy.property,
+                  dimension: legacy.dimension,
+                  metric: legacy.metric,
+                });
+              }
+              Err(e) =>
+              {
+                log::warn!(
+                  "Skipping vector index '{}' in graph '{}' during migration: {}",
+                  index_name,
+                  graph_name,
+                  e
+                );
+              }
+            }
+
+            // Clean up old per-index metadata key
+            self.delete_metadata(transaction, &legacy_key)?;
+
+            // Clean up legacy metric key if it exists
+            let table_name = vector_index_table_name(graph_name, index_name);
+            let metric_key = format!("{}/metric", table_name);
+            self.delete_metadata(transaction, &metric_key)?;
+          }
+
+          // Write consolidated list
+          self.set_metadata_value_json(
+            transaction,
+            format!("{}/vector_indices", graph_name),
+            &new_list,
+          )?;
+
+          // Remove old list key
+          self.delete_metadata(transaction, &list_key)?;
+        }
+
+        Ok(())
+      }
+      _ => Err(
+        StoreError::IncompatibleVersion {
+          expected: consts::GQLITE_VERSION,
+          actual: from,
+        }
+        .into(),
+      ),
+    }
   }
   /// Check if table exists
   pub(crate) fn check_if_table_exists(
@@ -368,6 +567,10 @@ impl super::sqlbase::SqlMetaDataQueries for Store
   {
     Ok(include_str!("../../templates/sql/postgres/metadata_set.sql").to_string())
   }
+  fn metadata_delete_query() -> Result<String>
+  {
+    Ok(include_str!("../../templates/sql/postgres/metadata_delete.sql").to_string())
+  }
 }
 
 impl super::sqlbase::SqlStore for Store
@@ -499,6 +702,529 @@ impl super::sqlbase::SqlStore for Store
     }
     Ok(())
   }
+
+  /// Create a vector index in PostgreSQL using pgvector extension
+  fn create_vector_index_impl(
+    &self,
+    transaction: &mut Self::TransactionBox,
+    graph_name: &str,
+    spec: &super::store::VectorIndexSpec,
+  ) -> Result<()>
+  {
+    if !spec.dtype.is_float()
+    {
+      return Err(
+        crate::error::StoreError::InvalidFormat(format!(
+          "PostgreSQL vector index only supports floating-point dtypes (F32 or F64); got {:?}",
+          spec.dtype
+        ))
+        .into(),
+      );
+    }
+
+    // Check if index already exists
+    let mut indices: Vec<VectorIndexMetadata> = self
+      .get_metadata_value_json_or_default(transaction, format!("{}/vector_indices", graph_name))?;
+    if indices.iter().any(|m| m.name == spec.name)
+    {
+      return Err(
+        crate::error::StoreError::DuplicatedVectorIndex {
+          index_name: spec.name.clone(),
+        }
+        .into(),
+      );
+    }
+
+    let table_name = vector_index_table_name(graph_name, &spec.name);
+
+    // Create vector index table with node_id UUID and embedding vector columns
+    let create_table_sql = format!(
+      "CREATE TABLE IF NOT EXISTS {} (node_id UUID PRIMARY KEY, embedding vector({}))",
+      table_name, spec.dimension
+    );
+    transaction.get_client().execute(&create_table_sql, &[])?;
+
+    // Create index based on metric type
+    let (index_type, operator_class) = match spec.metric
+    {
+      super::store::VectorMetric::Cosine => ("hnsw", "vector_cosine_ops"),
+      super::store::VectorMetric::L2 => ("hnsw", "vector_l2_ops"),
+      super::store::VectorMetric::DotProduct => ("hnsw", "vector_ip_ops"),
+    };
+
+    let index_name = format!("idx_{}_{}", graph_name, spec.name);
+    let create_index_sql = format!(
+      "CREATE INDEX IF NOT EXISTS {} ON {} USING {} (embedding {})",
+      index_name, table_name, index_type, operator_class
+    );
+    transaction.get_client().execute(&create_index_sql, &[])?;
+
+    // Append metadata and persist the unified list
+    indices.push(VectorIndexMetadata {
+      name: spec.name.clone(),
+      label: spec.label.clone(),
+      property: spec.property.clone(),
+      dimension: spec.dimension,
+      metric: spec.metric,
+    });
+    self.set_metadata_value_json(
+      transaction,
+      format!("{}/vector_indices", graph_name),
+      &indices,
+    )?;
+
+    if let Some(label) = &spec.label
+      && let Some(property) = &spec.property
+    {
+      let nodes_table = format!("gqlite_{}_nodes", graph_name);
+      let select_nodes_sql = format!(
+        "SELECT node_key, properties FROM {} WHERE labels @> ARRAY[$1]",
+        nodes_table
+      );
+
+      let rows = match transaction.get_client().query(&select_nodes_sql, &[&label])
+      {
+        Ok(rows) => rows,
+        Err(_) => return Ok(()),
+      };
+
+      for row in rows
+      {
+        let node_uuid: uuid::Uuid = row.get(0);
+
+        // Get properties as either String or directly as serde_json::Value
+        let props = match row.try_get::<_, String>(1)
+        {
+          Ok(json_str) => serde_json::from_str::<serde_json::Value>(&json_str).ok(),
+          Err(_) =>
+          {
+            // Try getting as JSON directly
+            row.try_get::<_, serde_json::Value>(1).ok()
+          }
+        };
+
+        if let Some(props) = props
+          && let Some(value) = props.get(property)
+          && let Some(vector) =
+            crate::store::vector_extract::extract_f32_vec_from_serde_value(value)
+          && !vector.is_empty()
+          && !vector.iter().any(|v| !v.is_finite())
+        {
+          let vector_str = serialize_vector_for_pgvector(&vector);
+          let insert_sql = format!(
+            "INSERT INTO {} (node_id, embedding) VALUES ($1, '{}'::vector) ON CONFLICT (node_id) DO UPDATE SET embedding = EXCLUDED.embedding",
+            table_name, vector_str
+          );
+          transaction
+            .get_client()
+            .execute(&insert_sql, &[&node_uuid])?;
+        }
+      }
+    }
+
+    Ok(())
+  }
+
+  /// Upsert a vector embedding in PostgreSQL
+  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 f32_data: std::borrow::Cow<[f32]> = match tensor.dtype()
+    {
+      crate::value::DType::F32 => match tensor.as_f32_slice()
+      {
+        Some(s) => std::borrow::Cow::Borrowed(s),
+        None => std::borrow::Cow::Owned(tensor.to_f32_vec()),
+      },
+      crate::value::DType::F64 => std::borrow::Cow::Owned(tensor.to_f32_vec()),
+      other =>
+      {
+        return Err(
+          StoreError::InvalidFormat(format!(
+            "PostgreSQL vector index only accepts F32 or F64 tensors; got {:?}",
+            other
+          ))
+          .into(),
+        );
+      }
+    };
+
+    if f32_data.iter().any(|v| !v.is_finite())
+    {
+      return Err(
+        StoreError::InvalidFormat("vector contains non-finite value (NaN or Inf)".to_string())
+          .into(),
+      );
+    }
+
+    let table_name = vector_index_table_name(graph_name, index_name);
+    let client = transaction.get_client();
+
+    // Serialize vector to pgvector format
+    let vector_str = serialize_vector_for_pgvector(&f32_data);
+
+    // Convert node_id to UUID
+    let node_uuid = uuid::Uuid::from_u128(node_id.uuid());
+
+    // Use PostgreSQL UPSERT pattern - embed vector in SQL since postgres-rs doesn't support pgvector parameters
+    let upsert_sql = format!(
+      "INSERT INTO {} (node_id, embedding) VALUES ($1, '{}'::vector) \
+       ON CONFLICT (node_id) DO UPDATE SET embedding = EXCLUDED.embedding",
+      table_name, vector_str
+    );
+    let result = client.execute(&upsert_sql, &[&node_uuid]);
+    match result
+    {
+      Err(e) if e.to_string().contains("does not exist") => Err(
+        StoreError::InvalidFormat(format!(
+          "Vector index '{}' does not exist. Create it first with create_vector_index.",
+          index_name
+        ))
+        .into(),
+      ),
+      other => other.map(|_| ()).map_err(Into::into),
+    }
+  }
+
+  fn list_vector_indexes_impl(
+    &self,
+    transaction: &mut Self::TransactionBox,
+    graph_name: &str,
+  ) -> Result<Vec<super::store::VectorIndexSpec>>
+  {
+    let indices: Vec<VectorIndexMetadata> = self
+      .get_metadata_value_json_or_default(transaction, format!("{}/vector_indices", graph_name))?;
+
+    let specs = indices
+      .into_iter()
+      .map(|m| super::store::VectorIndexSpec {
+        name: m.name,
+        label: m.label,
+        property: m.property,
+        dimension: m.dimension,
+        metric: m.metric,
+        ..Default::default()
+      })
+      .collect();
+
+    Ok(specs)
+  }
+
+  /// Search for similar vectors in PostgreSQL
+  fn vector_search_impl(
+    &self,
+    transaction: &mut Self::TransactionBox,
+    graph_name: &str,
+    index_name: &str,
+    query: &crate::value::Tensor,
+    k: usize,
+  ) -> Result<Vec<super::store::VectorSearchResult>>
+  {
+    if k == 0
+    {
+      return Ok(Vec::new());
+    }
+
+    let f32_query: std::borrow::Cow<[f32]> = match query.dtype()
+    {
+      crate::value::DType::F32 => match query.as_f32_slice()
+      {
+        Some(s) => std::borrow::Cow::Borrowed(s),
+        None => std::borrow::Cow::Owned(query.to_f32_vec()),
+      },
+      crate::value::DType::F64 => std::borrow::Cow::Owned(query.to_f32_vec()),
+      other =>
+      {
+        return Err(
+          StoreError::InvalidFormat(format!(
+            "PostgreSQL vector search only accepts F32 or F64 tensors; got {:?}",
+            other
+          ))
+          .into(),
+        );
+      }
+    };
+
+    if f32_query.iter().any(|v| !v.is_finite())
+    {
+      return Err(
+        StoreError::InvalidFormat("vector contains non-finite value (NaN or Inf)".to_string())
+          .into(),
+      );
+    }
+
+    let table_name = vector_index_table_name(graph_name, index_name);
+
+    let indices: Vec<VectorIndexMetadata> = self
+      .get_metadata_value_json_or_default(transaction, format!("{}/vector_indices", graph_name))?;
+    let metadata = indices
+      .into_iter()
+      .find(|m| m.name == index_name)
+      .ok_or_else(|| {
+        StoreError::InvalidFormat(format!(
+          "Vector index '{}' does not exist in graph '{}'",
+          index_name, graph_name
+        ))
+      })?;
+
+    if f32_query.len() != metadata.dimension
+    {
+      return Err(
+        StoreError::InvalidFormat(format!(
+          "Vector dimension {} does not match index dimension {}",
+          f32_query.len(),
+          metadata.dimension
+        ))
+        .into(),
+      );
+    }
+
+    let metric = metadata.metric;
+
+    if metric == super::VectorMetric::Cosine
+    {
+      let full_scan_sql = format!("SELECT node_id, embedding::text FROM {}", table_name);
+      let client = transaction.get_client();
+      let rows = client.query(&full_scan_sql, &[])?;
+
+      let mut results: Vec<super::store::VectorSearchResult> = rows
+        .into_iter()
+        .map(|row| {
+          let node_uuid: uuid::Uuid = row.get(0);
+          let embedding_text: String = row.get(1);
+          let embedding = parse_pgvector_from_string(&embedding_text)?;
+          let score = cosine_distance(&f32_query, &embedding);
+
+          Ok(super::store::VectorSearchResult {
+            node_id: crate::graph::Key::new(node_uuid.as_u128()),
+            score,
+          })
+        })
+        .collect::<Result<_>>()?;
+
+      results.sort_by(|a, b| {
+        a.score
+          .partial_cmp(&b.score)
+          .unwrap_or(std::cmp::Ordering::Equal)
+      });
+      results.truncate(k);
+      return Ok(results);
+    }
+
+    let operator = metric_to_pgvector_operator(Some(&metric));
+
+    let query_str = serialize_vector_for_pgvector(&f32_query);
+    let search_sql = format!(
+      "SELECT node_id, (embedding {} '{}'::vector) AS score FROM {} ORDER BY embedding {} '{}'::vector LIMIT $1",
+      operator, query_str, table_name, operator, query_str,
+    );
+
+    let client = transaction.get_client();
+    let rows = client.query(&search_sql, &[&(k as i64)])?;
+
+    let results: Vec<super::store::VectorSearchResult> = rows
+      .into_iter()
+      .map(|row| {
+        let node_uuid: uuid::Uuid = row.get(0);
+        // The distance value from pgvector might be a different type
+        // Try to get it as a generic value and convert
+        let score: f32 = match row.try_get::<_, f64>(1)
+        {
+          Ok(val) => val as f32,
+          Err(_) =>
+          {
+            // Try as f32 directly
+            match row.try_get::<_, f32>(1)
+            {
+              Ok(val) => val,
+              Err(_) =>
+              {
+                // Try as i32 or i64
+                match row.try_get::<_, i32>(1)
+                {
+                  Ok(val) => val as f32,
+                  Err(_) => match row.try_get::<_, i64>(1)
+                  {
+                    Ok(val) => val as f32,
+                    Err(_) => 0.0,
+                  },
+                }
+              }
+            }
+          }
+        };
+
+        super::store::VectorSearchResult {
+          node_id: crate::graph::Key::new(node_uuid.as_u128()),
+          score,
+        }
+      })
+      .collect();
+
+    Ok(results)
+  }
+
+  fn drop_vector_index_impl(
+    &self,
+    transaction: &mut Self::TransactionBox,
+    graph_name: &str,
+    index_name: &str,
+  ) -> Result<()>
+  {
+    let mut indices: Vec<VectorIndexMetadata> = self
+      .get_metadata_value_json_or_default(transaction, format!("{}/vector_indices", graph_name))?;
+
+    if !indices.iter().any(|m| m.name == index_name)
+    {
+      return Err(
+        StoreError::InvalidFormat(format!(
+          "Vector index '{}' does not exist in graph '{}'",
+          index_name, graph_name
+        ))
+        .into(),
+      );
+    }
+
+    let table_name = vector_index_table_name(graph_name, index_name);
+    let index_table_sql = format!("DROP TABLE IF EXISTS {}", table_name);
+    transaction.get_client().execute(&index_table_sql, &[])?;
+
+    let hnsw_index_name = format!("idx_{}_{}", graph_name, index_name);
+    let drop_hnsw_index_sql = format!("DROP INDEX IF EXISTS {}", hnsw_index_name);
+    transaction
+      .get_client()
+      .execute(&drop_hnsw_index_sql, &[])?;
+
+    indices.retain(|m| m.name != index_name);
+    self.set_metadata_value_json(
+      transaction,
+      format!("{}/vector_indices", graph_name),
+      &indices,
+    )?;
+
+    Ok(())
+  }
+
+  fn drop_graph_vector_indices_impl(
+    &self,
+    transaction: &mut Self::TransactionBox,
+    graph_name: &str,
+  ) -> Result<()>
+  {
+    let indices_key = format!("{}/vector_indices", graph_name);
+    let indices: Vec<VectorIndexMetadata> =
+      self.get_metadata_value_json_or_default(transaction, &indices_key)?;
+
+    for m in &indices
+    {
+      let table_name = vector_index_table_name(graph_name, &m.name);
+      transaction
+        .get_client()
+        .execute(&format!("DROP TABLE IF EXISTS {}", table_name), &[])?;
+      let hnsw_index_name = format!("idx_{}_{}", graph_name, m.name);
+      transaction
+        .get_client()
+        .execute(&format!("DROP INDEX IF EXISTS {}", hnsw_index_name), &[])?;
+    }
+
+    self.delete_metadata(transaction, &indices_key)?;
+    Ok(())
+  }
+
+  fn get_vector_indices_for_property_impl(
+    &self,
+    transaction: &mut Self::TransactionBox,
+    graph_name: &str,
+    label: &str,
+    property: &str,
+  ) -> Result<Vec<(String, usize, super::store::VectorMetric)>>
+  {
+    let indices: Vec<VectorIndexMetadata> = self
+      .get_metadata_value_json_or_default(transaction, format!("{}/vector_indices", graph_name))?;
+
+    let result = indices
+      .into_iter()
+      .filter(|m| m.label.as_deref() == Some(label) && m.property.as_deref() == Some(property))
+      .map(|m| (m.name, m.dimension, m.metric))
+      .collect();
+
+    Ok(result)
+  }
+
+  fn apply_vector_indices_for_node_impl(
+    &self,
+    transaction: &mut Self::TransactionBox,
+    graph_name: &str,
+    node: &crate::graph::Node,
+  ) -> Result<()>
+  {
+    for label in node.labels()
+    {
+      for property in node.properties().keys()
+      {
+        let Ok(indices) =
+          self.get_vector_indices_for_property_impl(transaction, graph_name, label, property)
+        else
+        {
+          continue;
+        };
+
+        for (index_name, dimension, _metric) in indices
+        {
+          if let Some(val) = node.properties().get(property)
+            && let Some(vector) = crate::store::vector_extract::extract_f32_vec(val)
+            && vector.len() == dimension
+          {
+            let tensor = crate::value::Tensor::from_f32_slice(&vector);
+            let _ =
+              self.upsert_vector_impl(transaction, graph_name, &index_name, node.key(), &tensor);
+          }
+        }
+      }
+    }
+
+    Ok(())
+  }
+
+  fn delete_vectors_for_nodes_impl(
+    &self,
+    transaction: &mut Self::TransactionBox,
+    graph_name: &str,
+    node_ids: &[String],
+  ) -> Result<()>
+  {
+    if node_ids.is_empty()
+    {
+      return Ok(());
+    }
+
+    let indices: Vec<VectorIndexMetadata> = self
+      .get_metadata_value_json_or_default(transaction, format!("{}/vector_indices", graph_name))?;
+
+    for m in &indices
+    {
+      let table_name = vector_index_table_name(graph_name, &m.name);
+      let client = transaction.get_client();
+
+      for node_id in node_ids
+      {
+        let node_uuid = uuid::Uuid::parse_str(&format_hex_to_uuid(node_id))
+          .map_err(|_| StoreError::InvalidFormat(format!("invalid node_id: '{}'", node_id)))?;
+        client.execute(
+          &format!("DELETE FROM {} WHERE node_id = $1", table_name),
+          &[&node_uuid],
+        )?;
+      }
+    }
+
+    Ok(())
+  }
 }
 
 impl super::sqlbase::SqlQueries for Store
@@ -559,7 +1285,7 @@ impl super::sqlbase::SqlQueries for Store
   }
 
   fn node_delete_query(graph_name: impl AsRef<str>, keys: impl AsRef<Vec<String>>)
-    -> Result<String>
+  -> Result<String>
   {
     Ok(
       templates::NodeDelete {
@@ -608,7 +1334,7 @@ impl super::sqlbase::SqlQueries for Store
     )
   }
   fn edge_delete_query(graph_name: impl AsRef<str>, keys: impl AsRef<Vec<String>>)
-    -> Result<String>
+  -> Result<String>
   {
     Ok(
       templates::EdgeDelete {