gqlite 1.5.0 → 1.7.0

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

@@ -7,6 +7,10 @@ mod redb;
 #[cfg(feature = "sqlite")]
 pub(crate) mod sqlite;
 
+mod vector_index;
+
+use graphcore::Edge;
+
 use crate::{
   prelude::*,
   store::{SelectNodeQuery, TransactionBoxable},
@@ -95,11 +99,13 @@ where
   // Add two nodes
   let nodes = [
     graph::Node::new(
+      Some("default".to_string()),
       graph::Key::default(),
       graph::labels!("hello", "world"),
       value::value_map!("key" => 42i64),
     ),
     graph::Node::new(
+      Some("default".to_string()),
       graph::Key::default(),
       graph::labels!("not"),
       Default::default(),
@@ -139,12 +145,58 @@ where
   assert_eq!(nodes[1], selected_nodes[0]);
 }
 
+fn test_select_nodes_by_uuids<TStore>(store: TStore)
+where
+  TStore: store::Store,
+{
+  let nodes = [
+    graph::Node::new(
+      Some("default".to_string()),
+      graph::Key::default(),
+      graph::labels!("node", "a"),
+      value::value_map!("name" => "Alice", "age" => 30i64),
+    ),
+    graph::Node::new(
+      Some("default".to_string()),
+      graph::Key::default(),
+      graph::labels!("node", "b"),
+      value::value_map!("name" => "Bob", "age" => 25i64),
+    ),
+    graph::Node::new(
+      Some("default".to_string()),
+      graph::Key::default(),
+      graph::labels!("node", "c"),
+      value::value_map!("name" => "Charlie", "age" => 35i64),
+    ),
+  ];
+
+  let mut tx = store.begin_write().unwrap();
+  store
+    .create_nodes(tx.borrow_mut(), "default", nodes.iter())
+    .unwrap();
+  tx.close().unwrap();
+
+  let selected_nodes = store
+    .select_nodes(
+      store.begin_read().unwrap().borrow_mut(),
+      "default",
+      store::SelectNodeQuery::select_keys(vec![nodes[0].key(), nodes[2].key()]),
+    )
+    .unwrap();
+
+  assert_eq!(selected_nodes.len(), 2);
+  assert!(selected_nodes.contains(&nodes[0]));
+  assert!(selected_nodes.contains(&nodes[2]));
+  assert!(!selected_nodes.contains(&nodes[1]));
+}
+
 fn test_update_nodes<TStore>(store: TStore)
 where
   TStore: store::Store,
 {
   // Add a node
   let node = graph::Node::new(
+    None,
     graph::Key::default(),
     graph::labels!("hello", "world"),
     value::value_map!("key" => 42i64),
@@ -162,6 +214,7 @@ where
 
   // Modify node
   let modified_node = graph::Node::new(
+    Some("default".to_string()),
     node.key(),
     graph::labels!("world"),
     value::value_map!("key" => 12i64),
@@ -204,20 +257,25 @@ where
   TStore: store::Store,
 {
   let source_node = graph::Node::new(
+    Some("default".to_string()),
     graph::Key::default(),
     graph::labels!("hello"),
     value::value_map!("key" => 42i64),
   );
   let destination_node = graph::Node::new(
+    Some("default".to_string()),
     graph::Key::default(),
     graph::labels!("world"),
     value::value_map!("key" => 12i64),
   );
   let edge = graph::SinglePath::new(
-    graph::Key::default(),
     source_node.clone(),
-    vec!["!".into()],
-    value::value_map!("existence" => true),
+    Edge::new(
+      Some("default".to_string()),
+      Default::default(),
+      vec!["!".into()],
+      value::value_map!("existence" => true),
+    ),
     destination_node.clone(),
   );
 
@@ -248,7 +306,7 @@ where
       store.begin_read().unwrap().borrow_mut(),
       "default",
       store::SelectEdgeQuery::select_keys([edge.key()]),
-      graph::EdgeDirectivity::Directed,
+      graphcore::EdgeDirectivity::Directed,
     )
     .unwrap();
 
@@ -266,7 +324,7 @@ where
         Default::default(),
         store::SelectNodeQuery::select_all(),
       ),
-      graph::EdgeDirectivity::Directed,
+      graphcore::EdgeDirectivity::Directed,
     )
     .unwrap();
 
@@ -284,7 +342,7 @@ where
         Default::default(),
         store::SelectNodeQuery::select_labels_properties(vec![], Default::default()),
       ),
-      graph::EdgeDirectivity::Directed,
+      graphcore::EdgeDirectivity::Directed,
     )
     .unwrap();
 
@@ -303,7 +361,7 @@ where
         Default::default(),
         store::SelectNodeQuery::select_keys(vec![edge.source().key()]),
       ),
-      graph::EdgeDirectivity::Directed,
+      graphcore::EdgeDirectivity::Directed,
     )
     .unwrap();
 
@@ -319,7 +377,7 @@ where
         Default::default(),
         store::SelectNodeQuery::select_keys(vec![edge.source().key()]),
       ),
-      graph::EdgeDirectivity::Undirected,
+      graphcore::EdgeDirectivity::Undirected,
     )
     .unwrap();
 
@@ -333,20 +391,25 @@ where
   TStore: store::Store,
 {
   let source_node = graph::Node::new(
+    None,
     graph::Key::default(),
     graph::labels!("hello"),
     value::value_map!("key" => 42i64),
   );
   let destination_node = graph::Node::new(
+    None,
     graph::Key::default(),
     graph::labels!("world"),
     value::value_map!("key" => 12i64),
   );
   let edge = graph::SinglePath::new(
-    graph::Key::default(),
     source_node.clone(),
-    vec!["!".into()],
-    value::value_map!("existence" => true),
+    graph::Edge::new(
+      None,
+      Default::default(),
+      vec!["!".into()],
+      value::value_map!("existence" => true),
+    ),
     destination_node.clone(),
   );
 
@@ -376,6 +439,7 @@ where
   // Modify edge
 
   let modified_edge = graph::Edge::new(
+    Some("default".to_string()),
     edge.key(),
     graph::labels!("?"),
     value::value_map!("existence" => false),
@@ -392,7 +456,7 @@ where
       store.begin_read().unwrap().borrow_mut(),
       "default",
       store::SelectEdgeQuery::select_all(),
-      graph::EdgeDirectivity::Directed,
+      graphcore::EdgeDirectivity::Directed,
     )
     .unwrap();
 
@@ -410,7 +474,7 @@ where
       &mut tx,
       "default",
       store::SelectEdgeQuery::select_all(),
-      graph::EdgeDirectivity::Directed,
+      graphcore::EdgeDirectivity::Directed,
     )
     .unwrap();
   tx.close().unwrap();
@@ -421,7 +485,7 @@ where
       store.begin_read().unwrap().borrow_mut(),
       "default",
       store::SelectEdgeQuery::select_all(),
-      graph::EdgeDirectivity::Directed,
+      graphcore::EdgeDirectivity::Directed,
     )
     .unwrap();
 

data/ext/gqlitedb/src/tests/templates/ast.rs

@@ -1,4 +1,4 @@
-use crate::{graph::EdgeDirectivity, parser::ast::*};
+use gqlparser::oc::ast::*;
 
 fn return_statement(var_id: VariableIdentifier) -> Statement
 {
@@ -20,14 +20,16 @@ fn return_statement(var_id: VariableIdentifier) -> Statement
 
 pub(crate) fn simple_create_node() -> Statements
 {
-  vec![Create {
-    patterns: vec![Pattern::Node(NodePattern {
-      variable: None,
-      labels: LabelExpression::None,
-      properties: None,
-    })],
-  }
-  .into()]
+  vec![
+    Create {
+      patterns: vec![Pattern::Node(NodePattern {
+        variable: None,
+        labels: LabelExpression::None,
+        properties: None,
+      })],
+    }
+    .into(),
+  ]
 }
 
 /// AST for `CREATE (n {name: 'foo'}) RETURN n.name AS p`
@@ -234,10 +236,12 @@ pub(crate) fn match_loop() -> Statements
         },
         labels: LabelExpression::None,
         properties: None,
-        directivity: EdgeDirectivity::Directed,
+        directivity: graphcore::EdgeDirectivity::Directed,
+        recursive_range: None,
       })],
       where_expression: None,
       optional: false,
+      search: None,
     }
     .into(),
     return_statement(var_ids.create_variable_from_name("n")),
@@ -257,6 +261,7 @@ pub(crate) fn optional_match() -> Statements
       })],
       where_expression: None,
       optional: true,
+      search: None,
     }
     .into(),
     return_statement(var_ids.create_variable_from_name("a")),
@@ -276,6 +281,7 @@ pub(crate) fn match_count() -> Statements
       })],
       where_expression: None,
       optional: false,
+      search: None,
     }
     .into(),
     Return {
@@ -312,6 +318,7 @@ pub(crate) fn aggregation() -> Statements
       })],
       where_expression: None,
       optional: false,
+      search: None,
     }
     .into(),
     Return {
@@ -332,14 +339,16 @@ pub(crate) fn aggregation() -> Statements
           identifier: var_ids.create_variable_from_name("count(n.num)"),
           expression: FunctionCall {
             name: "count".into(),
-            arguments: vec![MemberAccess {
-              left: Variable {
-                identifier: var_ids.create_variable_from_name("n"),
+            arguments: vec![
+              MemberAccess {
+                left: Variable {
+                  identifier: var_ids.create_variable_from_name("n"),
+                }
+                .into(),
+                path: vec!["num".into()],
               }
               .into(),
-              path: vec!["num".into()],
-            }
-            .into()],
+            ],
           }
           .into(),
         },
@@ -354,3 +363,70 @@ pub(crate) fn aggregation() -> Statements
     .into(),
   ]
 }
+
+/// AST for `CREATE VECTOR INDEX idx ON :Doc (embedding) OPTIONS { dimension: 3, metric: "cosine" }`
+pub(crate) fn create_vector_index(name: &str) -> Statements
+{
+  vec![
+    CreateVectorIndex {
+      name: name.to_string(),
+      label: "Doc".to_string(),
+      property: "embedding".to_string(),
+      dimension: Some(3),
+      metric: Some(Metric::Cosine),
+      if_not_exists: false,
+    }
+    .into(),
+  ]
+}
+
+/// AST for `MATCH (n:Doc) SEARCH n IN (VECTOR INDEX idx FOR [0.1, 0.2, 0.3] LIMIT 2) RETURN n.title`
+pub(crate) fn match_with_vector_search(index_name: &str) -> Statements
+{
+  let var_ids = VariableIdentifiers::default();
+  let n = var_ids.create_variable_from_name("n");
+  vec![
+    Match {
+      patterns: vec![Pattern::Node(NodePattern {
+        variable: Some(n.clone()),
+        labels: LabelExpression::String("Doc".to_string()),
+        properties: None,
+      })],
+      where_expression: None,
+      optional: false,
+      search: Some(Search {
+        variable: n.clone(),
+        index: index_name.to_string(),
+        query: Array {
+          array: vec![
+            Value { value: 0.1.into() }.into(),
+            Value { value: 0.2.into() }.into(),
+            Value { value: 0.3.into() }.into(),
+          ],
+        }
+        .into(),
+        limit: 2,
+        score_alias: None,
+      }),
+    }
+    .into(),
+    Return {
+      all: false,
+      expressions: vec![NamedExpression {
+        identifier: var_ids.create_variable_from_name("p"),
+        expression: MemberAccess {
+          left: Variable { identifier: n }.into(),
+          path: vec!["title".into()],
+        }
+        .into(),
+      }],
+      modifiers: Modifiers {
+        skip: None,
+        limit: None,
+        order_by: None,
+      },
+      where_expression: None,
+    }
+    .into(),
+  ]
+}

data/ext/gqlitedb/src/tests/templates/programs.rs

@@ -1,8 +1,8 @@
+use graphcore::EdgeDirectivity;
+
 use crate::{
-  error, functions,
-  graph::EdgeDirectivity,
-  interpreter::{instructions::*, Program},
-  ValueMap,
+  ValueMap, error, functions,
+  interpreter::{Program, instructions::*},
 };
 
 fn create_variable_size(persistent_variables: usize, temporary_variables: usize) -> VariablesSizes
@@ -25,7 +25,7 @@ pub(crate) fn simple_create() -> Program
           labels: Default::default(),
         },
       ],
-      variables: vec![None],
+      variables: vec![CreateActionVariable::default()],
     }],
     variables_size: create_variable_size(0, 0),
   }]
@@ -47,7 +47,10 @@ pub(crate) fn create_named_node() -> Program
             labels: Default::default(),
           },
         ],
-        variables: vec![Some(0)],
+        variables: vec![CreateActionVariable {
+          element: Some(0),
+          path: None,
+        }],
       }],
       variables_size: create_variable_size(1, 0),
     },
@@ -94,7 +97,10 @@ pub(crate) fn create_named_node_double_return() -> Program
             labels: Default::default(),
           },
         ],
-        variables: vec![Some(0)],
+        variables: vec![CreateActionVariable {
+          element: Some(0),
+          path: None,
+        }],
       }],
       variables_size: create_variable_size(1, 0),
     },
@@ -265,6 +271,7 @@ pub(crate) fn match_loop() -> Program
         path_variable: None,
         filter: vec![],
         directivity: EdgeDirectivity::Directed,
+        recursive_range: None,
       }],
       filter: vec![],
       optional: false,

data/ext/gqlitedb/src/tests.rs

@@ -2,14 +2,15 @@ mod compiler;
 mod connection;
 mod evaluators;
 mod parser;
+mod planner;
 mod store;
 mod templates;
 
 #[cfg(all(feature = "postgres", not(windows)))]
 pub(crate) mod postgres
 {
+  use postgres::{Client, NoTls};
   use std::{
-    net::TcpStream,
     process::Command,
     thread::sleep,
     time::{Duration, Instant},
@@ -31,20 +32,25 @@ pub(crate) mod postgres
 
     const MAX_WAIT: Duration = Duration::from_secs(30);
     const INTERVAL: Duration = Duration::from_secs(1);
-    const CONNECT_TIMEOUT: Duration = Duration::from_secs(1);
 
     let deadline = Instant::now() + MAX_WAIT;
 
     while Instant::now() < deadline
     {
-      if TcpStream::connect_timeout(
-        &format!("127.0.0.1:{}", db.db_port()).parse().unwrap(),
-        CONNECT_TIMEOUT,
-      )
-      .is_ok()
+      match Client::connect(&db.connection_string(), NoTls)
       {
-        println!("Port {} is open!", db.db_port());
-        break;
+        Ok(mut client) =>
+        {
+          if client.simple_query("SELECT 1").is_ok()
+          {
+            log::info!("Postgres is ready!");
+            break;
+          }
+        }
+        Err(err) =>
+        {
+          log::debug!("Postgres not ready yet: {}", err);
+        }
       }
       sleep(INTERVAL);
     }

data/ext/gqlitedb/src/utils.rs

@@ -2,9 +2,10 @@ use std::fmt::{Debug, Display};
 
 use serde::{Deserialize, Serialize};
 
+#[cfg(feature = "sqlite")]
 use crate::prelude::*;
 
-#[derive(Serialize, Deserialize)]
+#[derive(Serialize, Deserialize, PartialEq, Eq)]
 pub struct Version
 {
   pub major: u16,
@@ -29,6 +30,7 @@ impl Display for Version
   }
 }
 
+#[cfg(feature = "sqlite")]
 pub(crate) fn hex(key: impl Into<graph::Key>) -> String
 {
   format!("{:032X}", key.into().uuid())
@@ -37,7 +39,10 @@ pub(crate) fn hex(key: impl Into<graph::Key>) -> String
 #[cfg(test)]
 mod tests
 {
+  #[cfg(feature = "sqlite")]
   use crate::prelude::*;
+
+  #[cfg(feature = "sqlite")]
   #[test]
   fn test_hex()
   {

data/ext/gqlitedb/src/value/compare.rs

@@ -73,6 +73,11 @@ fn compare_node(lhs: &graph::Node, rhs: &graph::Node) -> Ordering
   lhs.key().uuid().cmp(&rhs.key().uuid()).into()
 }
 
+fn compare_edge(lhs: &graph::Edge, rhs: &graph::Edge) -> Ordering
+{
+  lhs.key().uuid().cmp(&rhs.key().uuid()).into()
+}
+
 pub(crate) fn compare(lhs: &value::Value, rhs: &value::Value) -> Ordering
 {
   use value::Value;
@@ -117,6 +122,33 @@ pub(crate) fn compare(lhs: &value::Value, rhs: &value::Value) -> Ordering
       Value::Null => Ordering::ComparedNull,
       _ => Ordering::Null,
     },
+    Value::Tensor(al) => match rhs
+    {
+      value::Value::Tensor(ar) => match (al.dtype() as u8).cmp(&(ar.dtype() as u8))
+      {
+        cmp::Ordering::Less => Ordering::Less,
+        cmp::Ordering::Greater => Ordering::Greater,
+        cmp::Ordering::Equal => match al.shape().cmp(ar.shape())
+        {
+          cmp::Ordering::Less => Ordering::Less,
+          cmp::Ordering::Greater => Ordering::Greater,
+          cmp::Ordering::Equal => al.as_bytes().cmp(ar.as_bytes()).into(),
+        },
+      },
+      value::Value::Array(_) =>
+      {
+        let left_arr = value::Value::Array(
+          al.to_f32_vec()
+            .into_iter()
+            .map(|f| value::Value::Float(f as f64))
+            .collect(),
+        );
+        compare(&left_arr, rhs)
+      }
+      value::Value::Null => Ordering::ComparedNull,
+      _ => Ordering::Null,
+    },
+
     Value::Array(al) => match rhs
     {
       Value::Array(ar) =>
@@ -183,12 +215,12 @@ pub(crate) fn compare(lhs: &value::Value, rhs: &value::Value) -> Ordering
     },
     Value::Edge(lhs) => match rhs
     {
-      Value::Edge(rhs) => lhs.key().uuid().cmp(&rhs.key().uuid()).into(),
+      Value::Edge(rhs) => compare_edge(lhs, rhs),
       _ => Ordering::Null,
     },
-    Value::Path(lhs) => match rhs
+    Value::SinglePath(lhs) => match rhs
     {
-      Value::Path(rhs) =>
+      Value::SinglePath(rhs) =>
       {
         let labels_cmp = lhs.labels().cmp(rhs.labels());
         match labels_cmp
@@ -207,5 +239,31 @@ pub(crate) fn compare(lhs: &value::Value, rhs: &value::Value) -> Ordering
       }
       _ => Ordering::Null,
     },
+    Value::Path(lhs) => match rhs
+    {
+      Value::Path(rhs) => match compare_node(lhs.source(), rhs.source())
+      {
+        Ordering::Equal =>
+        {
+          for ((lhs_edge, lhs_destination), (rhs_edge, rhs_destination)) in
+            lhs.elements().iter().zip(rhs.elements().iter())
+          {
+            match compare_edge(lhs_edge, rhs_edge)
+            {
+              Ordering::Equal => match compare_node(lhs_destination, rhs_destination)
+              {
+                Ordering::Equal =>
+                {}
+                o => return o,
+              },
+              o => return o,
+            }
+          }
+          Ordering::Equal
+        }
+        o => o,
+      },
+      _ => Ordering::Null,
+    },
   }
 }