gqlite 1.5.0 → 1.7.0

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

@@ -0,0 +1,56 @@
+use crate::value::Value;
+
+/// Extract a flat Vec<f32> from a Value.
+/// Handles Value::Tensor (new) and Value::Array (legacy).
+pub(crate) fn extract_f32_vec(value: &Value) -> Option<Vec<f32>>
+{
+  match value
+  {
+    Value::Tensor(t) => Some(t.to_f32_vec()),
+    Value::Array(arr) => arr
+      .iter()
+      .map(|v| match v
+      {
+        Value::Float(f) => Some(*f as f32),
+        Value::Integer(i) => Some(*i as f32),
+        _ => None,
+      })
+      .collect(),
+    _ => None,
+  }
+}
+
+#[cfg(any(feature = "sqlite", feature = "postgres", feature = "_pgrx"))]
+fn extract_f32_from_json_value(val: &serde_json::Value) -> Option<Vec<f32>>
+{
+  match val
+  {
+    serde_json::Value::Array(arr) => arr.iter().map(|e| e.as_f64().map(|f| f as f32)).collect(),
+    serde_json::Value::Object(map)
+      if map.get("__gql_type").and_then(|v| v.as_str()) == Some("tensor") =>
+    {
+      let arr = map.get("data")?.as_array()?;
+      arr.iter().map(|v| v.as_f64().map(|f| f as f32)).collect()
+    }
+    _ => None,
+  }
+}
+
+/// Extract a flat Vec<f32> from a raw JSON string.
+/// Handles:
+///   - legacy form: plain JSON array [1.0, 0.0, ...]
+///   - new form:    {"__gql_type":"tensor","dtype":"F32","shape":[...],"data":[...]}
+#[cfg(any(feature = "sqlite", feature = "postgres", feature = "_pgrx"))]
+pub(crate) fn extract_f32_vec_from_json(json_str: &str) -> Option<Vec<f32>>
+{
+  let val: serde_json::Value = serde_json::from_str(json_str).ok()?;
+  extract_f32_from_json_value(&val)
+}
+
+/// Same as extract_f32_vec_from_json but for callers that already hold a serde_json::Value
+/// (PostgreSQL retroactive population, where properties is a JSONB column).
+#[cfg(any(feature = "postgres", feature = "_pgrx"))]
+pub(crate) fn extract_f32_vec_from_serde_value(val: &serde_json::Value) -> Option<Vec<f32>>
+{
+  extract_f32_from_json_value(val)
+}

data/ext/gqlitedb/src/store.rs

@@ -10,6 +10,8 @@ pub(crate) mod redb;
 #[cfg(feature = "sqlite")]
 pub(crate) mod sqlite;
 
+pub(crate) mod vector_extract;
+
 use crate::prelude::*;
 
 //  ____  _        _   _     _   _
@@ -103,6 +105,64 @@ where
 //  ___) | || (_) | | |  __/
 // |____/ \__\___/|_|  \___|
 
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Default, serde::Serialize, serde::Deserialize)]
+pub(crate) enum VectorMetric
+{
+  #[default]
+  Cosine,
+  L2,
+  DotProduct,
+}
+
+impl VectorMetric
+{
+  pub(crate) fn from_debug_str(s: &str) -> Self
+  {
+    match s
+    {
+      "Cosine" => Self::Cosine,
+      "L2" => Self::L2,
+      "DotProduct" => Self::DotProduct,
+      _ => Self::Cosine,
+    }
+  }
+}
+
+#[derive(Debug, Clone)]
+pub(crate) struct VectorIndexSpec
+{
+  pub name: String,
+  pub label: Option<String>,
+  pub property: Option<String>,
+  pub dimension: usize,
+  pub metric: VectorMetric,
+  pub hnsw_params: redb::HnswParams,
+  pub dtype: value::DType,
+}
+
+impl Default for VectorIndexSpec
+{
+  fn default() -> Self
+  {
+    Self {
+      name: String::new(),
+      label: None,
+      property: None,
+      dimension: 0,
+      metric: VectorMetric::Cosine,
+      hnsw_params: Default::default(),
+      dtype: value::DType::F32,
+    }
+  }
+}
+
+#[derive(Debug, Clone)]
+pub(crate) struct VectorSearchResult
+{
+  pub node_id: graph::Key,
+  pub score: f32,
+}
+
 pub(crate) trait Store
 {
   type TransactionBox: TransactionBoxable;
@@ -153,6 +213,7 @@ pub(crate) trait Store
     graph_name: impl AsRef<str>,
     query: SelectNodeQuery,
   ) -> Result<Vec<crate::graph::Node>>;
+
   /// Add edge
   fn create_edges<'a, T: IntoIterator<Item = &'a crate::graph::SinglePath>>(
     &self,
@@ -172,7 +233,7 @@ pub(crate) trait Store
     transaction: &mut Self::TransactionBox,
     graph_name: impl AsRef<str>,
     query: SelectEdgeQuery,
-    directivity: graph::EdgeDirectivity,
+    directivity: graphcore::EdgeDirectivity,
   ) -> Result<()>;
   /// Select edges
   fn select_edges(
@@ -180,10 +241,63 @@ pub(crate) trait Store
     transaction: &mut Self::TransactionBox,
     graph_name: impl AsRef<str>,
     query: SelectEdgeQuery,
-    directivity: graph::EdgeDirectivity,
+    directivity: graphcore::EdgeDirectivity,
   ) -> Result<Vec<EdgeResult>>;
   /// Compute store statistics
   fn compute_statistics(&self, transaction: &mut Self::TransactionBox) -> Result<Statistics>;
+
+  // Vector search API
+  /// Create a vector index for a graph
+  fn create_vector_index(
+    &self,
+    transaction: &mut Self::TransactionBox,
+    graph_name: impl AsRef<str>,
+    spec: VectorIndexSpec,
+  ) -> Result<()>;
+
+  /// List vector indices for a graph
+  #[allow(dead_code)]
+  fn list_vector_indexes(
+    &self,
+    transaction: &mut Self::TransactionBox,
+    graph_name: impl AsRef<str>,
+  ) -> Result<Vec<VectorIndexSpec>>;
+
+  /// Insert or update a node vector embedding
+  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<()>;
+
+  /// Perform top-K similarity search over a vector index
+  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<VectorSearchResult>>;
+
+  /// Drop a vector index from a graph
+  fn drop_vector_index(
+    &self,
+    transaction: &mut Self::TransactionBox,
+    graph_name: impl AsRef<str>,
+    index_name: impl AsRef<str>,
+  ) -> Result<()>;
+
+  /// Apply vector indices to a node (upsert vectors into applicable indices)
+  fn apply_vector_indices_for_node(
+    &self,
+    transaction: &mut Self::TransactionBox,
+    graph_name: impl AsRef<str>,
+    node: &graph::Node,
+  ) -> Result<()>;
 }
 
 //  _____    _            ____                 _ _
@@ -286,27 +400,21 @@ impl SelectNodeQuery
       return true;
     }
     if let Some(keys) = &self.keys
+      && !keys.iter().any(|x| node.key() == *x)
     {
-      if !keys.iter().any(|x| node.key() == *x)
-      {
-        return false;
-      }
+      return false;
     }
     if let Some(labels) = &self.labels
+      && !labels.iter().all(|x| node.labels().contains(x))
     {
-      if !labels.iter().all(|x| node.labels().contains(x))
-      {
-        return false;
-      }
+      return false;
     }
     if let Some(properties) = &self.properties
-    {
-      if !properties
+      && !properties
         .iter()
         .all(|(k, v)| node.properties().get(k) == Some(v))
-      {
-        return false;
-      }
+    {
+      return false;
     }
     true
   }
@@ -341,6 +449,12 @@ impl SelectEdgeQuery
       && self.destination.select_all
   }
 
+  // expose source selector for callers that need start nodes (e.g., recursive traversals)
+  pub(crate) fn source_query(&self) -> SelectNodeQuery
+  {
+    self.source.clone()
+  }
+
   pub(crate) fn select_all() -> Self
   {
     Self {
@@ -411,31 +525,28 @@ impl SelectEdgeQuery
       destination: destination_query,
     }
   }
-  pub(crate) fn is_match(&self, edge: &graph::Path) -> bool
+  pub(crate) fn is_match(&self, edge: &graph::SinglePath) -> bool
   {
     if let Some(keys) = &self.keys
+      && !keys.iter().any(|x| edge.key() == *x)
     {
-      if !keys.iter().any(|x| edge.key() == *x)
-      {
-        return false;
-      }
+      return false;
     }
+
     if let Some(labels) = &self.labels
+      && !labels.iter().all(|x| edge.labels().contains(x))
     {
-      if !labels.iter().all(|x| edge.labels().contains(x))
-      {
-        return false;
-      }
+      return false;
     }
+
     if let Some(properties) = &self.properties
-    {
-      if !properties
+      && !properties
         .iter()
         .all(|(k, v)| edge.properties().get(k) == Some(v))
-      {
-        return false;
-      }
+    {
+      return false;
     }
+
     self.source.is_match(edge.source()) && self.destination.is_match(edge.destination())
   }
 }

data/ext/gqlitedb/src/tests/compiler.rs

@@ -1,6 +1,12 @@
 use crate::{
   compiler::compile,
-  interpreter::Program,
+  interpreter::{
+    Program,
+    instructions::{
+      Block, BlockMatch, Instruction, Modifiers, OrderBy, RWExpression, VariablesSizes,
+    },
+  },
+  planner::{self, LogicalPlan, ProjectionKind},
   prelude::*,
   tests::templates::{ast, programs},
 };
@@ -10,12 +16,28 @@ fn compare_program(actual: Program, expected: Program)
   assert_eq!(format!("{:?}", actual), format!("{:?}", expected));
 }
 
+fn compile_statements(
+  function_manager: &functions::Manager,
+  statements: gqlparser::oc::ast::Statements,
+) -> Program
+{
+  compile(
+    function_manager,
+    statements
+      .into_iter()
+      .map(planner::plan)
+      .collect::<Result<Vec<_>, _>>()
+      .unwrap(),
+  )
+  .unwrap()
+}
+
 #[test]
 fn test_compile_simple_create_node()
 {
   let function_manager = functions::Manager::new();
 
-  let program = compile(&function_manager, ast::simple_create_node()).unwrap();
+  let program = compile_statements(&function_manager, ast::simple_create_node());
   compare_program(program, programs::simple_create())
 }
 
@@ -24,7 +46,7 @@ fn test_compile_create_named_node()
 {
   let function_manager = functions::Manager::new();
 
-  let program = compile(&function_manager, ast::create_named_node()).unwrap();
+  let program = compile_statements(&function_manager, ast::create_named_node());
   compare_program(program, programs::create_named_node())
 }
 
@@ -33,7 +55,7 @@ fn test_compile_create_named_node_double_return()
 {
   let function_manager = functions::Manager::new();
 
-  let program = compile(&function_manager, ast::create_named_node_double_return()).unwrap();
+  let program = compile_statements(&function_manager, ast::create_named_node_double_return());
   compare_program(program, programs::create_named_node_double_return())
 }
 
@@ -42,7 +64,7 @@ fn test_compile_double_with_return()
 {
   let function_manager = functions::Manager::new();
 
-  let program = compile(&function_manager, ast::double_with_return()).unwrap();
+  let program = compile_statements(&function_manager, ast::double_with_return());
   compare_program(program, programs::double_with_return())
 }
 
@@ -51,7 +73,7 @@ fn test_compile_unwind()
 {
   let function_manager = functions::Manager::new();
 
-  let program = compile(&function_manager, ast::unwind()).unwrap();
+  let program = compile_statements(&function_manager, ast::unwind());
   compare_program(program, programs::unwind())
 }
 
@@ -60,7 +82,7 @@ fn test_compile_match_loop()
 {
   let function_manager = functions::Manager::new();
 
-  let program = compile(&function_manager, ast::match_loop()).unwrap();
+  let program = compile_statements(&function_manager, ast::match_loop());
   compare_program(program, programs::match_loop())
 }
 
@@ -69,7 +91,7 @@ fn test_compile_optional_match()
 {
   let function_manager = functions::Manager::new();
 
-  let program = compile(&function_manager, ast::optional_match()).unwrap();
+  let program = compile_statements(&function_manager, ast::optional_match());
   compare_program(program, programs::optional_match())
 }
 
@@ -78,7 +100,7 @@ fn test_compile_match_count()
 {
   let function_manager = functions::Manager::new();
 
-  let program = compile(&function_manager, ast::match_count()).unwrap();
+  let program = compile_statements(&function_manager, ast::match_count());
   compare_program(program, programs::match_count(&function_manager))
 }
 
@@ -87,6 +109,181 @@ fn test_compile_aggregation()
 {
   let function_manager = functions::Manager::new();
 
-  let program = compile(&function_manager, ast::aggregation()).unwrap();
+  let program = compile_statements(&function_manager, ast::aggregation());
   compare_program(program, programs::aggregation(&function_manager))
 }
+
+#[test]
+fn test_compile_logicalplan_nodescan_filter()
+{
+  let function_manager = functions::Manager::new();
+  let identifiers = gqlparser::oc::ast::VariableIdentifiers::default();
+  let node_identifier = identifiers.create_variable_from_name("n");
+
+  let program = compile(
+    &function_manager,
+    vec![LogicalPlan::Filter {
+      source: Box::new(LogicalPlan::NodeScan {
+        patterns: vec![gqlparser::oc::ast::Pattern::Node(
+          gqlparser::oc::ast::NodePattern {
+            variable: Some(node_identifier.clone()),
+            labels: gqlparser::oc::ast::LabelExpression::None,
+            properties: None,
+          },
+        )],
+        optional: false,
+      }),
+      expression: gqlparser::oc::ast::Variable {
+        identifier: node_identifier,
+      }
+      .into(),
+    }],
+  )
+  .unwrap();
+
+  compare_program(
+    program,
+    vec![Block::Match {
+      blocks: vec![BlockMatch::MatchNode {
+        instructions: vec![
+          Instruction::Push {
+            value: crate::ValueMap::default().into(),
+          },
+          Instruction::CreateNodeQuery { labels: vec![] },
+        ],
+        variable: Some(0),
+        filter: vec![],
+      }],
+      filter: vec![Instruction::GetVariable { col_id: 0 }],
+      optional: false,
+      variables_size: VariablesSizes {
+        persistent_variables: 1,
+        temporary_variables: 0,
+      },
+    }],
+  );
+}
+
+#[test]
+fn test_compile_logicalplan_projection_modifiers()
+{
+  let function_manager = functions::Manager::new();
+  let identifiers = gqlparser::oc::ast::VariableIdentifiers::default();
+  let item_identifier = identifiers.create_variable_from_name("i");
+
+  let program = compile(
+    &function_manager,
+    vec![
+      LogicalPlan::Unwind {
+        identifier: item_identifier.clone(),
+        expression: gqlparser::oc::ast::Array {
+          array: vec![gqlparser::oc::ast::Value { value: 0.into() }.into()],
+        }
+        .into(),
+      },
+      LogicalPlan::Limit {
+        source: Box::new(LogicalPlan::Skip {
+          source: Box::new(LogicalPlan::Sort {
+            source: Box::new(LogicalPlan::Filter {
+              source: Box::new(LogicalPlan::Projection {
+                kind: ProjectionKind::Return,
+                all: false,
+                expressions: vec![gqlparser::oc::ast::NamedExpression {
+                  identifier: item_identifier.clone(),
+                  expression: gqlparser::oc::ast::Variable {
+                    identifier: item_identifier.clone(),
+                  }
+                  .into(),
+                }],
+              }),
+              expression: gqlparser::oc::ast::Variable {
+                identifier: item_identifier.clone(),
+              }
+              .into(),
+            }),
+            expressions: vec![gqlparser::oc::ast::OrderByExpression {
+              asc: false,
+              expression: gqlparser::oc::ast::Variable {
+                identifier: item_identifier.clone(),
+              }
+              .into(),
+            }],
+          }),
+          expression: gqlparser::oc::ast::Value { value: 0.into() }.into(),
+        }),
+        expression: gqlparser::oc::ast::Value { value: 1.into() }.into(),
+      },
+    ],
+  )
+  .unwrap();
+
+  compare_program(
+    program,
+    vec![
+      Block::Unwind {
+        col_id: 0,
+        instructions: vec![
+          Instruction::Push { value: 0.into() },
+          Instruction::CreateArray { length: 1 },
+        ],
+        variables_size: VariablesSizes {
+          persistent_variables: 1,
+          temporary_variables: 0,
+        },
+      },
+      Block::Return {
+        variables: vec![(
+          "i".into(),
+          RWExpression {
+            col_id: 0,
+            instructions: vec![Instruction::GetVariable { col_id: 0 }],
+            aggregations: vec![],
+          },
+        )],
+        filter: vec![Instruction::GetVariable { col_id: 0 }],
+        modifiers: Modifiers {
+          limit: Some(vec![Instruction::Push { value: 1.into() }]),
+          skip: Some(vec![Instruction::Push { value: 0.into() }]),
+          order_by: vec![OrderBy {
+            asc: false,
+            instructions: vec![Instruction::GetVariable { col_id: 0 }],
+          }],
+        },
+        variables_sizes: VariablesSizes {
+          persistent_variables: 1,
+          temporary_variables: 0,
+        },
+      },
+    ],
+  );
+}
+
+#[test]
+fn test_compile_match_with_vector_search()
+{
+  let function_manager = functions::Manager::new();
+  let program = compile_statements(&function_manager, ast::match_with_vector_search("idx"));
+  // At this stage (pre-WI-3), Block::VectorSearch still carries `graph`.
+  // This test only asserts compilation succeeds without error and produces
+  // a VectorSearch block referencing the correct index name -- it does not
+  // assert on the (currently wrong, always "default") graph value, since
+  // that assertion belongs to the evaluator-level regression test below,
+  // where the wrongness is actually observable as a behavioral failure.
+  let has_vector_search_block = format!("{:?}", program).contains("VectorSearch");
+  assert!(
+    has_vector_search_block,
+    "expected a VectorSearch block in the compiled program"
+  );
+}
+
+#[test]
+fn test_compile_multiple_vector_indexes_produces_distinct_instructions()
+{
+  let function_manager = functions::Manager::new();
+  let mut statements = ast::create_vector_index("idx1");
+  statements.extend(ast::create_vector_index("idx2"));
+  let program = compile_statements(&function_manager, statements);
+  let debug = format!("{:?}", program);
+  assert!(debug.contains("\"idx1\""));
+  assert!(debug.contains("\"idx2\""));
+}

data/ext/gqlitedb/src/tests/connection/postgres.rs

@@ -1,8 +1,43 @@
 #[test]
-fn testconnection()
+fn test_create_match_return()
 {
   let db = crate::tests::postgres::create_tmp_db(10);
-  let builder = crate::Connection::builder().set_option("uri", db.connection_uri());
+  let builder = crate::Connection::builder()
+    .set_option("url", db.connection_uri())
+    .backend(crate::Backend::Postgres);
   let connection = builder.create().unwrap();
-  super::test_connection(connection);
+  super::test_create_match_return(connection);
+}
+
+#[test]
+fn test_create_return()
+{
+  let db = crate::tests::postgres::create_tmp_db(11);
+  let builder = crate::Connection::builder()
+    .set_option("url", db.connection_uri())
+    .backend(crate::Backend::Postgres);
+  let connection = builder.create().unwrap();
+  super::test_create_return(connection);
+}
+
+#[test]
+fn test_create_edge_return()
+{
+  let db = crate::tests::postgres::create_tmp_db(12);
+  let builder = crate::Connection::builder()
+    .set_option("url", db.connection_uri())
+    .backend(crate::Backend::Postgres);
+  let connection = builder.create().unwrap();
+  super::test_create_edge_return(connection);
+}
+
+#[test]
+fn test_vector_search_dimension_mismatch()
+{
+  let db = crate::tests::postgres::create_tmp_db(13);
+  let builder = crate::Connection::builder()
+    .set_option("url", db.connection_uri())
+    .backend(crate::Backend::Postgres);
+  let connection = builder.create().unwrap();
+  super::test_vector_search_dimension_mismatch(connection);
 }

data/ext/gqlitedb/src/tests/connection/redb.rs

@@ -0,0 +1,23 @@
+#[test]
+fn test_create_match_return()
+{
+  let builder = crate::Connection::builder().backend(crate::Backend::Redb);
+  let connection = builder.create().unwrap();
+  super::test_create_match_return(connection);
+}
+
+#[test]
+fn test_create_return()
+{
+  let builder = crate::Connection::builder().backend(crate::Backend::Redb);
+  let connection = builder.create().unwrap();
+  super::test_create_return(connection);
+}
+
+#[test]
+fn test_create_edge_return()
+{
+  let builder = crate::Connection::builder().backend(crate::Backend::Redb);
+  let connection = builder.create().unwrap();
+  super::test_create_edge_return(connection);
+}

data/ext/gqlitedb/src/tests/connection/sqlite.rs

@@ -0,0 +1,31 @@
+#[test]
+fn test_create_match_return()
+{
+  let builder = crate::Connection::builder().backend(crate::Backend::SQLite);
+  let connection = builder.create().unwrap();
+  super::test_create_match_return(connection);
+}
+
+#[test]
+fn test_create_return()
+{
+  let builder = crate::Connection::builder().backend(crate::Backend::SQLite);
+  let connection = builder.create().unwrap();
+  super::test_create_return(connection);
+}
+
+#[test]
+fn test_create_edge_return()
+{
+  let builder = crate::Connection::builder().backend(crate::Backend::SQLite);
+  let connection = builder.create().unwrap();
+  super::test_create_edge_return(connection);
+}
+
+#[test]
+fn test_vector_search_dimension_mismatch()
+{
+  let builder = crate::Connection::builder().backend(crate::Backend::SQLite);
+  let connection = builder.create().unwrap();
+  super::test_vector_search_dimension_mismatch(connection);
+}