gqlite 1.8.0 → 1.8.2

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.
@@ -122,6 +122,18 @@ where
         text: query.substring(e.span().start, e.span().end).to_string(),
         span: e.span().clone(),
       },
+      ErrorKind::CreatingWithPredicate => error::CompileTimeError::CreatingWithPredicate {
+        text: query.substring(e.span().start, e.span().end).to_string(),
+        span: e.span().clone(),
+      },
+      ErrorKind::ConflictingQuantifiers => error::CompileTimeError::ConflictingQuantifiers {
+        text: query.substring(e.span().start, e.span().end).to_string(),
+        span: e.span().clone(),
+      },
+      ErrorKind::EmptyQuantifiedGroup => error::CompileTimeError::EmptyQuantifiedGroup {
+        text: query.substring(e.span().start, e.span().end).to_string(),
+        span: e.span().clone(),
+      },
       _ => error::CompileTimeError::ParseError {
         error_kind: e.error_kind().clone(),
         text: query.substring(e.span().start, e.span().end).to_string(),

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: 2,
 };

data/ext/gqlitedb/src/error.rs

@@ -71,6 +71,30 @@ pub enum CompileTimeError
     text: String,
     span: std::ops::Range<usize>,
   },
+  #[error(
+    "CreatingWithPredicate: CREATE patterns cannot use an inline WHERE predicate at: '{text}' at {span:?}."
+  )]
+  CreatingWithPredicate
+  {
+    text: String,
+    span: std::ops::Range<usize>,
+  },
+  #[error(
+    "ConflictingQuantifiers: cannot specify both a legacy `[*min..max]` range and a `{{min,max}}`/`*`/`+` quantifier on the same relationship at: '{text}' at {span:?}."
+  )]
+  ConflictingQuantifiers
+  {
+    text: String,
+    span: std::ops::Range<usize>,
+  },
+  #[error(
+    "EmptyQuantifiedGroup: a quantified group must contain at least one relationship at: '{text}' at {span:?}."
+  )]
+  EmptyQuantifiedGroup
+  {
+    text: String,
+    span: std::ops::Range<usize>,
+  },
   #[error("NotComparable: values are not comparable.")]
   NotComparable,
   #[error("UnknownFunction: {name}.")]
@@ -78,6 +102,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,9 +1,10 @@
-use std::collections::HashMap;
-
-use rustc_hash::FxHashSet;
+use std::collections::{HashMap, HashSet};
 
 use crate::{
-  interpreter::instructions::{Block, VariablesSizes},
+  interpreter::{
+    instructions::{Block, VariablesSizes},
+    path,
+  },
   prelude::*,
   store::{SelectNodeQuery, TransactionBoxable},
   value_table::{MutableRowInterface, Row, RowInterface},
@@ -12,7 +13,7 @@ use interpreter::instructions;
 
 #[derive(Debug, Clone)]
 #[allow(clippy::enum_variant_names)]
-enum Value
+pub(crate) enum Value
 {
   GraphValue(value::Value),
   NodeQuery(store::SelectNodeQuery),
@@ -157,18 +158,18 @@ macro_rules! contain_to_value {
 }
 
 #[derive(Default, Debug)]
-struct Stack
+pub(crate) struct Stack
 {
   stack: Vec<Value>,
 }
 
 impl Stack
 {
-  fn push(&mut self, value: impl Into<Value>)
+  pub(crate) fn push(&mut self, value: impl Into<Value>)
   {
     self.stack.push(value.into());
   }
-  fn try_pop(&mut self) -> Result<Value>
+  pub(crate) fn try_pop(&mut self) -> Result<Value>
   {
     self.stack.pop().ok_or(InternalError::EmptyStack.into())
   }
@@ -191,7 +192,7 @@ impl Stack
   {
     self.stack
   }
-  fn try_pop_as_boolean(&mut self) -> Result<bool>
+  pub(crate) fn try_pop_as_boolean(&mut self) -> Result<bool>
   {
     let v = self.try_pop()?;
     match v
@@ -205,7 +206,7 @@ impl Stack
   }
 }
 
-trait TryPopInto<T>
+pub(crate) trait TryPopInto<T>
 {
   fn try_pop_into(&mut self) -> Result<T>;
   fn try_drain_into(&mut self, n: usize) -> Result<Vec<T>>;
@@ -333,7 +334,28 @@ fn execute_binary_operator<T: Into<crate::value::Value>>(
   Ok(())
 }
 
-fn eval_instructions(
+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(())
+}
+
+pub(crate) fn eval_instructions(
   stack: &mut Stack,
   row: &impl value_table::RowInterface,
   instructions: &instructions::Instructions,
@@ -807,6 +829,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 +955,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 +1100,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 +1165,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 +1176,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(
@@ -1172,6 +1229,39 @@ fn filter_rows(
     .collect()
 }
 
+/// Executes a chain of `BlockMatch` blocks sequentially against `current_rows`.
+/// Each block transforms the rows for the next block in the sequence.
+///
+/// This is the reusable helper for executing a `Vec<BlockMatch>` chain, used by
+/// `Block::Match` handlers, group-repetition steps (WI4), and similar contexts.
+#[allow(clippy::too_many_arguments)]
+pub(crate) fn execute_block_matches<TStore: store::Store>(
+  blocks: &[instructions::BlockMatch],
+  store: &TStore,
+  tx: &mut TStore::TransactionBox,
+  graph_name: &str,
+  stack: &mut Stack,
+  parameters: &crate::value::ValueMap,
+  mut current_rows: Vec<value_table::Row>,
+  allow_recursive: bool,
+) -> Result<Vec<value_table::Row>>
+{
+  for block in blocks
+  {
+    current_rows = execute_block_match(
+      block,
+      store,
+      tx,
+      graph_name,
+      stack,
+      parameters,
+      current_rows,
+      allow_recursive,
+    )?;
+  }
+  Ok(current_rows)
+}
+
 /// Executes a single `BlockMatch` (node or edge) against every row in `current_rows`,
 /// appending matching rows into `new_rows`.
 ///
@@ -1234,309 +1324,34 @@ fn execute_block_match<TStore: store::Store>(
         }
       }
 
-      instructions::BlockMatch::MatchEdge {
-        instructions,
-        left_variable,
-        edge_variable,
-        right_variable,
-        path_variable,
-        filter,
-        directivity,
-        recursive_range,
-      } =>
+      instructions::BlockMatch::MatchEdge { .. } =>
       {
-        eval_instructions(stack, &row, instructions, parameters)?;
-        let query = stack.try_pop_into()?;
-
-        match recursive_range
-        {
-          None =>
-          {
-            let edges = store.select_edges(tx, graph_name, query, *directivity)?;
-
-            for edge in edges.into_iter()
-            {
-              let mut new_row = row.clone();
-              let (left, right) = if edge.reversed
-              {
-                (edge.path.destination(), edge.path.source())
-              }
-              else
-              {
-                (edge.path.source(), edge.path.destination())
-              };
-
-              if let Some(left_variable) = left_variable
-              {
-                new_row.set(*left_variable, left.to_owned().into())?;
-              }
-              if let Some(right_variable) = right_variable
-              {
-                new_row.set(*right_variable, right.to_owned().into())?;
-              }
-              if let Some(edge_variable) = edge_variable
-              {
-                new_row.set(*edge_variable, edge.path.to_edge().into())?;
-              }
-              if let Some(path_variable) = path_variable
-              {
-                new_row.set(*path_variable, edge.path.to_owned().into())?;
-              }
-
-              let should_add_row = if filter.is_empty()
-              {
-                true
-              }
-              else
-              {
-                let mut stack = Stack::default();
-                stack.push(true);
-                stack.push(edge.path.to_edge());
-                eval_instructions(&mut stack, &new_row, filter, parameters)?;
-                stack.try_pop()?;
-                stack.try_pop_into()?
-              };
-
-              if should_add_row
-              {
-                new_rows.push(new_row);
-              }
-            }
-          }
-
-          Some(recursive_range) =>
-          {
-            if !allow_recursive
-            {
-              return Err(InternalError::UnsupportedRecursivePatternInMerge.into());
-            }
-
-            // Recursive DFS
-            let min_hops = recursive_range.start;
-            let max_hops = recursive_range.end;
-            let capacity = max_hops.min(100);
-
-            let bound_dest_key: Option<graph::Key> = if let Some(right_col) = right_variable
-            {
-              match row.get(*right_col)?
-              {
-                value::Value::Node(node) => Some(node.key()),
-                _ => None,
-              }
-            }
-            else
-            {
-              None
-            };
-
-            let start_nodes: Vec<graph::Node> = {
-              let source_query = query.source_query();
-              store.select_nodes(tx, graph_name, source_query)?
-            };
-
-            struct Frame
-            {
-              node: graph::Node,
-              edges: Vec<store::EdgeResult>,
-              edge_index: usize,
-              depth: usize,
-            }
-
-            for start_node in start_nodes
-            {
-              let mut path_edges: Vec<graph::Edge> = Vec::with_capacity(capacity);
-              let mut used_edges: FxHashSet<graph::Key> =
-                FxHashSet::with_capacity_and_hasher(capacity, Default::default());
-              let mut dedup_set: FxHashSet<(Option<graph::Key>, Option<graph::Key>, usize)> =
-                FxHashSet::with_capacity_and_hasher(capacity, Default::default());
-
-              let initial_edges = {
-                let q = store::SelectEdgeQuery::select_source_keys(
-                  store::SelectNodeQuery::select_keys(vec![start_node.key()]),
-                );
-                store.select_edges(tx, graph_name, q, *directivity)?
-              };
-
-              let mut dfs_stack: Vec<Frame> = vec![Frame {
-                node: start_node.clone(),
-                edges: initial_edges,
-                edge_index: 0,
-                depth: 0,
-              }];
-
-              while !dfs_stack.is_empty()
-              {
-                let mut push_next: Option<Frame> = None;
-                let mut should_pop = false;
-
-                let dfs_intermediate_nodes: Vec<graph::Node> = if dfs_stack.len() >= 2
-                {
-                  dfs_stack[1..dfs_stack.len() - 1]
-                    .iter()
-                    .map(|f| f.node.clone())
-                    .collect()
-                }
-                else
-                {
-                  Vec::new()
-                };
-
-                {
-                  let frame = dfs_stack.last_mut().unwrap();
-
-                  // Emit row
-                  if frame.edge_index == 0 && frame.depth >= min_hops
-                  {
-                    let current_node = &frame.node;
-
-                    let mut new_row = row.clone();
-
-                    if let Some(left_var) = left_variable
-                    {
-                      new_row.set(*left_var, start_node.clone().into())?;
-                    }
-                    if let Some(right_var) = right_variable
-                    {
-                      new_row.set(*right_var, current_node.clone().into())?;
-                    }
-                    if let Some(edge_var) = edge_variable
-                      && let Some(last_edge) = path_edges.last()
-                    {
-                      new_row.set(*edge_var, last_edge.clone().into())?;
-                    }
-                    if let Some(path_var) = path_variable
-                    {
-                      let path = graph::Path::new(
-                        start_node.clone(),
-                        path_edges
-                          .clone()
-                          .into_iter()
-                          .zip(
-                            dfs_intermediate_nodes
-                              .clone()
-                              .into_iter()
-                              .chain(std::iter::once(current_node.clone())),
-                          )
-                          .collect(),
-                      );
-                      new_row.set(*path_var, path.into())?;
-                    }
-
-                    let passes_filter = if filter.is_empty()
-                    {
-                      true
-                    }
-                    else
-                    {
-                      let mut eval_stack = Stack::default();
-                      eval_stack.push(true);
-                      if let Some(last_edge) = path_edges.last()
-                      {
-                        eval_stack.push(last_edge.clone());
-                      }
-                      eval_instructions(&mut eval_stack, &new_row, filter, parameters)?;
-                      eval_stack.try_pop()?;
-                      eval_stack.try_pop_into()?
-                    };
-
-                    let matches_dest = if let Some(dest_key) = bound_dest_key
-                    {
-                      current_node.key() == dest_key
-                    }
-                    else
-                    {
-                      true
-                    };
-
-                    if passes_filter && matches_dest
-                    {
-                      let left_key_opt: Option<graph::Key> = if left_variable.is_some()
-                      {
-                        Some(start_node.key())
-                      }
-                      else
-                      {
-                        None
-                      };
-                      let right_key_opt: Option<graph::Key> = Some(current_node.key());
-                      let path_len = path_edges.len();
-                      let sig = (left_key_opt, right_key_opt, path_len);
-
-                      if !dedup_set.contains(&sig)
-                      {
-                        dedup_set.insert(sig);
-                        new_rows.push(new_row);
-                      }
-                    }
-                  }
-
-                  // Stop for max depth
-                  if frame.depth == max_hops || frame.edge_index >= frame.edges.len()
-                  {
-                    should_pop = true;
-                  }
-                  else
-                  {
-                    // Next hop
-                    let edge_result = &frame.edges[frame.edge_index];
-                    frame.edge_index += 1;
-
-                    let edge = edge_result.path.to_edge();
-                    let edge_key = edge.key();
-
-                    if used_edges.contains(&edge_key)
-                    {
-                      continue;
-                    }
-
-                    let next_node = if edge_result.reversed
-                    {
-                      edge_result.path.source().clone()
-                    }
-                    else
-                    {
-                      edge_result.path.destination().clone()
-                    };
-
-                    used_edges.insert(edge_key);
-                    path_edges.push(edge.clone());
-
-                    let next_edges = {
-                      let q = store::SelectEdgeQuery::select_source_keys(
-                        store::SelectNodeQuery::select_keys(vec![next_node.key()]),
-                      );
-                      store.select_edges(tx, graph_name, q, *directivity)?
-                    };
-
-                    push_next = Some(Frame {
-                      node: next_node,
-                      edges: next_edges,
-                      edge_index: 0,
-                      depth: frame.depth + 1,
-                    });
-                  }
-                }
-
-                // Mutate stack
-                if should_pop
-                {
-                  dfs_stack.pop();
-                  if let Some(last_edge) = path_edges.pop()
-                  {
-                    used_edges.remove(&last_edge.key());
-                  }
-                  continue;
-                }
+        super::path::execute_match_edge(
+          block,
+          store,
+          tx,
+          graph_name,
+          stack,
+          parameters,
+          &row,
+          allow_recursive,
+          &mut new_rows,
+        )?;
+      }
 
-                if let Some(frame) = push_next
-                {
-                  dfs_stack.push(frame);
-                  continue;
-                }
-              }
-            }
-          }
-        }
+      instructions::BlockMatch::MatchQuantifiedPath { .. } =>
+      {
+        path::execute_match_quantified_path(
+          block,
+          store,
+          tx,
+          graph_name,
+          stack,
+          parameters,
+          &row,
+          allow_recursive,
+          &mut new_rows,
+        )?;
       }
     }
   }
@@ -1714,20 +1529,17 @@ pub(crate) fn eval_program<TStore: store::Store>(
         let mut output_table = value_table::ValueTable::new(variables_size.persistent_variables);
         for row in input_table.into_row_iter()
         {
-          let mut current_rows: Vec<_> = vec![row.clone().extended(variables_size.total_size())?];
-          for block in blocks.iter()
-          {
-            current_rows = execute_block_match(
-              block,
-              store,
-              &mut tx,
-              &graph_name,
-              &mut stack,
-              parameters,
-              current_rows,
-              true, // recursive patterns allowed in MATCH
-            )?;
-          }
+          let current_rows: Vec<_> = vec![row.clone().extended(variables_size.total_size())?];
+          let mut current_rows = execute_block_matches(
+            blocks,
+            store,
+            &mut tx,
+            &graph_name,
+            &mut stack,
+            parameters,
+            current_rows,
+            true, // recursive patterns allowed in MATCH
+          )?;
           if !filter.is_empty()
           {
             current_rows = filter_rows(current_rows.into_iter(), filter, parameters)?;
@@ -2384,6 +2196,16 @@ pub(crate) fn eval_program<TStore: store::Store>(
           );
           return Ok(crate::value::Value::Map(res).into());
         }
+        else if name == "gqlite.db.list_graphs"
+        {
+          let mut graphs = store.graphs_list(&mut tx)?;
+          graphs.sort();
+          let list: Vec<crate::value::Value> = graphs
+            .into_iter()
+            .map(crate::value::Value::String)
+            .collect();
+          return Ok(crate::value::Value::Array(list).into());
+        }
         else
         {
           return Err(InternalError::Unimplemented("call for any other function").into());