gqlite 1.8.0 → 1.8.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 69d9620b19310b76b69a9bb2373cde64cfd94133e73b4197c51d59b0b5463c3d
-  data.tar.gz: 80af6abeddd183326704ae95cb5b00f2e41317e5a104d2a0c4d77c95cc4cdd5b
+  metadata.gz: 4af74e4cc44046fee49a1e9573a876066a80ddc6eaaf2def11f5af0002b89ff2
+  data.tar.gz: c105b94002e5c43a74e8f7b418ba45d8d17c47bab1a68dc32c914e18c3a3e1cb
 SHA512:
-  metadata.gz: 1f14ae08b820f1e5e48960220912e01f74a41b83610571eec99e46647de2ebd48eed5925e280bf45f728973a7826b1da63cff2e526382bf5d0399b347043a247
-  data.tar.gz: 9de4b0738781537c2657c90bad7e1831064f8e783387973503971de741c2b861f651efc64733ecc406b0741dba2ba19cfb5f32fab83692b24f2be6a62b6057a2
+  metadata.gz: 885b3a13b70473a45cdad51df3fe04f1aebd98828a6211445bf1907c44f88ff543e78ffbf86b5afa971f76482e0b190ed76a7212cbf8b520a20b6e5505a58081
+  data.tar.gz: d784d78413e35a708b204a557ef0e1d54236adae193679205b522d788529277c2f183824c87e57946733dd68e36013aea2e0cca6f42fe774d92ce6eccb8d4aed

data/ext/db-index/Cargo.toml

@@ -2,10 +2,10 @@
 name = "db-index"
 description = "Reusable indexing algorithms for key-value storage engines"
 readme = "README.md"
-license = "MIT"
+license.workspace = true
 homepage.workspace = true
 repository.workspace = true
-version = "0.11.0"
+version.workspace = true
 edition = "2021"
 
 [dependencies]

data/ext/gqlitedb/src/aggregators.rs

@@ -22,6 +22,34 @@ pub(crate) trait AggregatorTrait: Debug + Sync + Send
 
 pub(crate) type Aggregator = Arc<Box<dyn AggregatorTrait>>;
 
+#[derive(Debug)]
+pub(crate) struct DistinctAggregatorState
+{
+  pub(crate) inner: Box<dyn AggregatorState>,
+  pub(crate) seen: Vec<value::Value>,
+}
+
+impl AggregatorState for DistinctAggregatorState
+{
+  fn next(&mut self, expression: value::Value) -> Result<()>
+  {
+    if self.seen.iter().any(|v| v == &expression)
+    {
+      Ok(())
+    }
+    else
+    {
+      self.seen.push(expression.clone());
+      self.inner.next(expression)
+    }
+  }
+
+  fn finalise(self: Box<Self>) -> Result<value::Value>
+  {
+    self.inner.finalise()
+  }
+}
+
 macro_rules! declare_aggregator {
   ($function_name: ident, $type_name: ident, $state_type_name: tt, (  $( $arg_type: ty $(,)? )* ) -> $ret_type: ty) => {
     #[derive(Debug)]

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

@@ -256,6 +256,15 @@ impl<'b> Analyser<'b>
       )),
       ast::Expression::FunctionCall(call) =>
       {
+        if call.distinct && !self.functions_manager.is_aggregate(&call.name)?
+        {
+          return Err(
+            error::CompileTimeError::DistinctOnNonAggregateFunction {
+              name: call.name.clone(),
+            }
+            .into(),
+          );
+        }
         let arguments = (call.arguments.iter(), validators::any).analyse(self)?;
         Ok(ExpressionInfo::new(
           self.functions_manager.validate_arguments(
@@ -438,6 +447,30 @@ impl<'b> Analyser<'b>
         false,
         false,
       )),
+      ast::Expression::Contains(contains) => Ok(ExpressionInfo::new_type(
+        ExpressionType::Boolean,
+        (
+          [&contains.left, &contains.right].into_iter(),
+          validators::string_or_null,
+        )
+          .analyse(self)?,
+      )),
+      ast::Expression::StartsWith(starts_with) => Ok(ExpressionInfo::new_type(
+        ExpressionType::Boolean,
+        (
+          [&starts_with.left, &starts_with.right].into_iter(),
+          validators::string_or_null,
+        )
+          .analyse(self)?,
+      )),
+      ast::Expression::EndsWith(ends_with) => Ok(ExpressionInfo::new_type(
+        ExpressionType::Boolean,
+        (
+          [&ends_with.left, &ends_with.right].into_iter(),
+          validators::string_or_null,
+        )
+          .analyse(self)?,
+      )),
     }
   }
 }

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

@@ -596,7 +596,8 @@ impl VariablesManager
       LogicalPlan::Filter { source, .. }
       | LogicalPlan::Sort { source, .. }
       | LogicalPlan::Skip { source, .. }
-      | LogicalPlan::Limit { source, .. } => self.analyse(source.as_ref())?,
+      | LogicalPlan::Limit { source, .. }
+      | LogicalPlan::Distinct { source } => self.analyse(source.as_ref())?,
       LogicalPlan::Projection { .. } =>
       {}
       LogicalPlan::Call { .. } =>

data/ext/gqlitedb/src/compiler.rs

@@ -132,6 +132,7 @@ impl Compiler
                   init_instructions,
                   aggregator,
                   argument_instructions,
+                  distinct: function_call.distinct,
                 },
               ));
             Instruction::GetVariable { col_id: var_col_id }
@@ -317,6 +318,21 @@ impl Compiler
         instructions.push(Instruction::IsNullUnaryOperator);
         Instruction::NotUnaryOperator
       }
+      ast::Expression::Contains(contains) =>
+      {
+        compile_binary_op!(self, contains, instructions, aggregations);
+        Instruction::StringContainsOperator
+      }
+      ast::Expression::StartsWith(starts_with) =>
+      {
+        compile_binary_op!(self, starts_with, instructions, aggregations);
+        Instruction::StringStartsWithOperator
+      }
+      ast::Expression::EndsWith(ends_with) =>
+      {
+        compile_binary_op!(self, ends_with, instructions, aggregations);
+        Instruction::StringEndsWithOperator
+      }
     };
     instructions.push(expr);
     Ok(())
@@ -980,6 +996,7 @@ impl Compiler
       },
     )?;
     Ok(instructions::Modifiers {
+      distinct: modifiers.distinct,
       limit,
       skip,
       order_by,
@@ -1100,6 +1117,12 @@ impl Compiler
         projection.modifiers.limit = Some(expression);
         Ok(projection)
       }
+      LogicalPlan::Distinct { source } =>
+      {
+        let mut projection = Self::unpack_projection_plan(*source)?;
+        projection.modifiers.distinct = true;
+        Ok(projection)
+      }
       _ => Err(
         InternalError::Unreachable {
           context: "compile/unpack_projection_plan",
@@ -1239,7 +1262,8 @@ pub(crate) fn compile(
         | LogicalPlan::Sort { .. }
         | LogicalPlan::Skip { .. }
         | LogicalPlan::Limit { .. }
-        | LogicalPlan::Filter { .. } => compiler.compile_projection_plan(logical_plan),
+        | LogicalPlan::Filter { .. }
+        | LogicalPlan::Distinct { .. } => compiler.compile_projection_plan(logical_plan),
         LogicalPlan::Call { name, arguments } =>
         {
           let mut instructions = Instructions::new();

data/ext/gqlitedb/src/connection.rs

@@ -32,8 +32,8 @@ impl ConnectionBuilder
   /// Merge options. This might overwrite value from the builder
   pub fn options(mut self, options: impl Into<value::ValueMap>) -> Self
   {
-    let mut options = options.into();
-    self.map.extend(options.drain());
+    let options = options.into();
+    self.map.extend(options);
     self
   }
   /// Set the option value for the given key.

data/ext/gqlitedb/src/consts.rs

@@ -5,5 +5,5 @@ pub(crate) const SHOW_EVALUATOR_STATE: bool = false;
 pub(crate) const GQLITE_VERSION: crate::utils::Version = crate::utils::Version {
   major: 1,
   minor: 8,
-  patch: 0,
+  patch: 1,
 };

data/ext/gqlitedb/src/error.rs

@@ -78,6 +78,13 @@ pub enum CompileTimeError
   {
     name: String
   },
+  #[error(
+    "DistinctOnNonAggregateFunction: DISTINCT can only be used with aggregate functions, got '{name}'."
+  )]
+  DistinctOnNonAggregateFunction
+  {
+    name: String
+  },
   #[error("InvalidAggregation: aggregation is not accepted in this expression.")]
   InvalidAggregation,
   #[error("ColumnNameConflict: Column '{name}' is duplicated.")]

data/ext/gqlitedb/src/interpreter/evaluators.rs

@@ -1,4 +1,4 @@
-use std::collections::HashMap;
+use std::collections::{HashMap, HashSet};
 
 use rustc_hash::FxHashSet;
 
@@ -333,6 +333,27 @@ fn execute_binary_operator<T: Into<crate::value::Value>>(
   Ok(())
 }
 
+fn execute_string_operator(
+  stack: &mut Stack,
+  operand: impl FnOnce(String, String) -> bool,
+) -> Result<()>
+{
+  let a: Value = stack.try_pop()?;
+  let b: Value = stack.try_pop()?;
+
+  let a: graphcore::Value = a.try_into()?;
+  let b: graphcore::Value = b.try_into()?;
+
+  let a = a.try_into();
+  let b = b.try_into();
+  match (a, b)
+  {
+    (Ok(a), Ok(b)) => stack.push(operand(a, b)),
+    _ => stack.push(graphcore::Value::Null),
+  }
+  Ok(())
+}
+
 fn eval_instructions(
   stack: &mut Stack,
   row: &impl value_table::RowInterface,
@@ -807,6 +828,18 @@ fn eval_instructions(
       {
         execute_binary_operator(stack, |a, b| a.pow(b))?;
       }
+      &instructions::Instruction::StringContainsOperator =>
+      {
+        execute_string_operator(stack, |a, b| a.contains(&b))?;
+      }
+      &instructions::Instruction::StringStartsWithOperator =>
+      {
+        execute_string_operator(stack, |a, b| a.starts_with(&b))?;
+      }
+      &instructions::Instruction::StringEndsWithOperator =>
+      {
+        execute_string_operator(stack, |a, b| a.ends_with(&b))?;
+      }
     }
   }
   Ok(())
@@ -921,13 +954,20 @@ fn create_aggregations_states(
             &agg.init_instructions,
             parameters,
           )?;
-          let state = agg.aggregator.create(
+          let mut state = agg.aggregator.create(
             stack
               .into_vec()
               .into_iter()
               .map(|v| v.try_into())
               .collect::<Result<_>>()?,
           )?;
+          if agg.distinct
+          {
+            state = Box::new(aggregators::DistinctAggregatorState {
+              inner: state,
+              seen: Vec::new(),
+            });
+          }
 
           Ok((name.to_owned(), state))
         })
@@ -1059,7 +1099,6 @@ fn compute_return_with_table(
   {
     output_table = filter_rows(output_table.into_row_iter(), filter, parameters)?.try_into()?;
   }
-  // Apply modifiers
   // Sort the table according to order_by
   if !modifiers.order_by.is_empty()
   {
@@ -1125,7 +1164,7 @@ fn compute_return_with_table(
     }
   }
 
-  output_table
+  let output_table_iter = output_table
     .into_row_iter()
     .map(|mut row| {
       Ok(Row::new(
@@ -1136,8 +1175,25 @@ fn compute_return_with_table(
         0,
       ))
     })
-    .map(value_table::RowResult)
-    .collect()
+    .map(value_table::RowResult);
+
+  // Apply modifiers
+  if modifiers.distinct
+  {
+    let mut seen = HashSet::new();
+
+    output_table_iter
+      .filter(|row| match &row.0
+      {
+        Ok(row) => seen.insert(RowKey(row.clone())),
+        Err(_) => true,
+      })
+      .collect()
+  }
+  else
+  {
+    output_table_iter.collect()
+  }
 }
 
 fn filter_rows(

data/ext/gqlitedb/src/interpreter/instructions.rs

@@ -79,6 +79,9 @@ pub(crate) enum Instruction
   DivisionBinaryOperator,
   ModuloBinaryOperator,
   ExponentBinaryOperator,
+  StringContainsOperator,
+  StringStartsWithOperator,
+  StringEndsWithOperator,
 }
 
 pub(crate) type Instructions = Vec<Instruction>;
@@ -127,6 +130,7 @@ pub(crate) struct RWAggregation
   pub(crate) init_instructions: Instructions,
   pub(crate) argument_instructions: Instructions,
   pub(crate) aggregator: aggregators::Aggregator,
+  pub(crate) distinct: bool,
 }
 
 /// R(eturn)W(ith)Expression are expressions computed in Return or With blocks.
@@ -189,6 +193,7 @@ pub(crate) struct OrderBy
 #[derive(Debug)]
 pub(crate) struct Modifiers
 {
+  pub distinct: bool,
   pub limit: Option<Instructions>,
   pub skip: Option<Instructions>,
   pub order_by: Vec<OrderBy>,

data/ext/gqlitedb/src/planner.rs

@@ -89,6 +89,12 @@ pub enum LogicalPlan
     /// Limit expression.
     expression: ast::Expression,
   },
+  /// Make sure values only appear onces.
+  Distinct
+  {
+    /// Input operator.
+    source: Box<LogicalPlan>,
+  },
   /// Invoke a callable.
   Call
   {
@@ -211,6 +217,13 @@ fn wrap_modifiers(plan: LogicalPlan, modifiers: ast::Modifiers) -> LogicalPlan
     };
   }
 
+  if modifiers.distinct
+  {
+    plan = LogicalPlan::Distinct {
+      source: Box::new(plan),
+    }
+  }
+
   plan
 }
 

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

@@ -570,7 +570,7 @@ impl Store
   /// database forward exactly one step; the function recurses until `from` matches current.
   fn upgrade_database(&self, from: utils::Version, tx: &mut TransactionBox) -> Result<()>
   {
-    if from == consts::GQLITE_VERSION
+    if from.major == consts::GQLITE_VERSION.major && from.minor == consts::GQLITE_VERSION.minor
     {
       return Ok(());
     }

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

@@ -248,6 +248,7 @@ fn test_compile_logicalplan_projection_modifiers()
             asc: false,
             instructions: vec![Instruction::GetVariable { col_id: 0 }],
           }],
+          distinct: false,
         },
         variables_sizes: VariablesSizes {
           persistent_variables: 1,

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

@@ -41,3 +41,25 @@ fn test_vector_search_dimension_mismatch()
   let connection = builder.create().unwrap();
   super::test_vector_search_dimension_mismatch(connection);
 }
+
+#[test]
+fn test_not_wraps_comparison_at_runtime()
+{
+  let db = crate::tests::postgres::create_tmp_db(14);
+  let builder = crate::Connection::builder()
+    .set_option("url", db.connection_uri())
+    .backend(crate::Backend::Postgres);
+  let connection = builder.create().unwrap();
+  super::test_not_wraps_comparison_at_runtime(connection);
+}
+
+#[test]
+fn test_count_distinct_end_to_end()
+{
+  let db = crate::tests::postgres::create_tmp_db(15);
+  let builder = crate::Connection::builder()
+    .set_option("url", db.connection_uri())
+    .backend(crate::Backend::Postgres);
+  let connection = builder.create().unwrap();
+  super::test_count_distinct_end_to_end(connection);
+}

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

@@ -21,3 +21,19 @@ fn test_create_edge_return()
   let connection = builder.create().unwrap();
   super::test_create_edge_return(connection);
 }
+
+#[test]
+fn test_not_wraps_comparison_at_runtime()
+{
+  let builder = crate::Connection::builder().backend(crate::Backend::Redb);
+  let connection = builder.create().unwrap();
+  super::test_not_wraps_comparison_at_runtime(connection);
+}
+
+#[test]
+fn test_count_distinct_end_to_end()
+{
+  let builder = crate::Connection::builder().backend(crate::Backend::Redb);
+  let connection = builder.create().unwrap();
+  super::test_count_distinct_end_to_end(connection);
+}

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

@@ -29,3 +29,19 @@ fn test_vector_search_dimension_mismatch()
   let connection = builder.create().unwrap();
   super::test_vector_search_dimension_mismatch(connection);
 }
+
+#[test]
+fn test_not_wraps_comparison_at_runtime()
+{
+  let builder = crate::Connection::builder().backend(crate::Backend::SQLite);
+  let connection = builder.create().unwrap();
+  super::test_not_wraps_comparison_at_runtime(connection);
+}
+
+#[test]
+fn test_count_distinct_end_to_end()
+{
+  let builder = crate::Connection::builder().backend(crate::Backend::SQLite);
+  let connection = builder.create().unwrap();
+  super::test_count_distinct_end_to_end(connection);
+}

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

@@ -77,3 +77,67 @@ fn test_vector_search_dimension_mismatch(connection: crate::Connection)
   );
   assert!(result.is_err(), "dimension mismatch should raise an error");
 }
+
+fn test_not_wraps_comparison_at_runtime(connection: crate::Connection)
+{
+  connection
+    .execute_oc_query("CREATE (:Person {name: \"Alice\"})", Default::default())
+    .unwrap();
+  connection
+    .execute_oc_query("CREATE (:Person {name: \"Bob\"})", Default::default())
+    .unwrap();
+
+  let result = connection
+    .execute_oc_query(
+      r#"MATCH (p:Person) WHERE NOT p.name = "Alice" RETURN count(p) AS n"#,
+      Default::default(),
+    )
+    .unwrap();
+  let table = result.try_into_table().unwrap();
+  assert_eq!(table.rows(), 1);
+  let count: i64 = table.value(0, 0).unwrap().try_into().unwrap();
+  assert_eq!(count, 1, "only Bob should match (NOT Alice)");
+}
+
+fn test_count_distinct_end_to_end(connection: crate::Connection)
+{
+  connection
+    .execute_oc_query("CREATE (:Person {id: 1})", Default::default())
+    .unwrap();
+  connection
+    .execute_oc_query("CREATE (:Person {id: 2})", Default::default())
+    .unwrap();
+  connection
+    .execute_oc_query("CREATE (:Person {id: 3})", Default::default())
+    .unwrap();
+
+  connection
+    .execute_oc_query(
+      "MATCH (p:Person {id: 1}), (f:Person) CREATE (p)-[:KNOWS]->(f)",
+      Default::default(),
+    )
+    .unwrap();
+  connection
+    .execute_oc_query(
+      "MATCH (p:Person {id: 1}), (f:Person {id: 2}) CREATE (p)-[:KNOWS]->(f)",
+      Default::default(),
+    )
+    .unwrap();
+  connection
+    .execute_oc_query(
+      "MATCH (p:Person {id: 1}), (f:Person {id: 3}) CREATE (p)-[:KNOWS]->(f)",
+      Default::default(),
+    )
+    .unwrap();
+
+  let result = connection
+    .execute_oc_query(
+      "MATCH (p:Person {id: 1})-[:KNOWS]->(friend:Person) RETURN count(DISTINCT friend) AS n",
+      Default::default(),
+    )
+    .unwrap();
+  let table = result.try_into_table().unwrap();
+  assert_eq!(table.rows(), 1);
+  let count: i64 = table.value(0, 0).unwrap().try_into().unwrap();
+  assert_eq!(count, 3, "should count distinct friends");
+}

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

@@ -99,6 +99,7 @@ fn test_plan_return_creates_projection_modifier_chain()
         .into(),
       }],
       modifiers: Modifiers {
+        distinct: false,
         skip: Some(Value { value: 2.into() }.into()),
         limit: Some(Value { value: 4.into() }.into()),
         order_by: Some(OrderBy {

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

@@ -9,6 +9,7 @@ fn return_statement(var_id: VariableIdentifier) -> Statement
       expression: Variable { identifier: var_id }.into(),
     }],
     modifiers: Modifiers {
+      distinct: false,
       skip: None,
       limit: None,
       order_by: None,
@@ -70,6 +71,7 @@ pub(crate) fn create_named_node() -> Statements
         .into(),
       }],
       modifiers: Modifiers {
+        distinct: false,
         skip: None,
         limit: None,
         order_by: None,
@@ -134,6 +136,7 @@ pub(crate) fn create_named_node_double_return() -> Statements
         },
       ],
       modifiers: Modifiers {
+        distinct: false,
         skip: None,
         limit: None,
         order_by: None,
@@ -162,6 +165,7 @@ pub(crate) fn double_with_return() -> Statements
         },
       ],
       modifiers: Modifiers {
+        distinct: false,
         skip: None,
         limit: None,
         order_by: None,
@@ -188,6 +192,7 @@ pub(crate) fn double_with_return() -> Statements
         },
       ],
       modifiers: Modifiers {
+        distinct: false,
         skip: None,
         limit: None,
         order_by: None,
@@ -291,10 +296,12 @@ pub(crate) fn match_count() -> Statements
         expression: FunctionCall {
           name: "count".into(),
           arguments: vec![Value { value: 0.into() }.into()],
+          distinct: false,
         }
         .into(),
       }],
       modifiers: Modifiers {
+        distinct: false,
         skip: None,
         limit: None,
         order_by: None,
@@ -349,11 +356,13 @@ pub(crate) fn aggregation() -> Statements
               }
               .into(),
             ],
+            distinct: false,
           }
           .into(),
         },
       ],
       modifiers: Modifiers {
+        distinct: false,
         skip: None,
         limit: None,
         order_by: None,
@@ -421,6 +430,7 @@ pub(crate) fn match_with_vector_search(index_name: &str) -> Statements
         .into(),
       }],
       modifiers: Modifiers {
+        distinct: false,
         skip: None,
         limit: None,
         order_by: None,