gqlite 1.8.0 → 1.8.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 69d9620b19310b76b69a9bb2373cde64cfd94133e73b4197c51d59b0b5463c3d
-  data.tar.gz: 80af6abeddd183326704ae95cb5b00f2e41317e5a104d2a0c4d77c95cc4cdd5b
+  metadata.gz: c6ebd6bd26d6614d8d3edd02d592c4bfd125a5dc3bf8170cb69c3f7e22dd48a7
+  data.tar.gz: 1c9f08c8d98976a104166ddc321e23a81e3a66d36fa16c97dcff0aa81adc735f
 SHA512:
-  metadata.gz: 1f14ae08b820f1e5e48960220912e01f74a41b83610571eec99e46647de2ebd48eed5925e280bf45f728973a7826b1da63cff2e526382bf5d0399b347043a247
-  data.tar.gz: 9de4b0738781537c2657c90bad7e1831064f8e783387973503971de741c2b861f651efc64733ecc406b0741dba2ba19cfb5f32fab83692b24f2be6a62b6057a2
+  metadata.gz: b524bcae9534be01d0d7b5ba78430058c736314c2f57770ca5774edb888b9192653fa23f1664bd62833c27745b29004dc1d78d280c769def4819e54ba5ff8a41
+  data.tar.gz: 73f5e717c9e6dc74c19389c939a2c5933c16b4a47da74756fab937e4ece53922e8fe25c8b4979a1d60e6be0d5a7c2701b4747bc5ff803789fa54b3b56132874e

data/ext/Cargo.toml

@@ -3,26 +3,26 @@ resolver = "3"
 members = ["gqliterb", "gqlitedb", "graphcore"]
 
 [workspace.package]
-version = "0.11.0"
+version = "0.13.0"
 edition = "2024"
 license = "MIT"
 homepage = "https://gqlite.org"
 repository = "https://gitlab.com/gqlite/gqlite"
 
 [workspace.dependencies]
-graphcore = { version = "0.11.0", path = "graphcore" }
-gqlitedb = { version = "0.11.0", path = "gqlitedb" }
-gqlparser = { version = "0.11.0", path = "gqlparser" }
-db-index = { version = "0.11.0", path = "db-index" }
+graphcore = { version = "0.13.0", path = "graphcore" }
+gqlitedb = { version = "0.13.0", path = "gqlitedb" }
+gqlparser = { version = "0.13.0", path = "gqlparser" }
+db-index = { version = "0.13.0", path = "db-index" }
 
-askama = { version = "0.15" }
+askama = { version = "0.16" }
 ccutils = { version = "0.4" }
 ciborium = "0.2"
 divan = "0.1"
 indexmap = "2"
-itertools = "0.14"
+itertools = "0.15"
 log = "0.4"
-rusqlite = { version = "0.38", features = ["load_extension"] }
+rusqlite = { version = "0.40", features = ["load_extension"] }
 serde = "1"
 thiserror = "2"
 uuid = { version = "1", features = ["v4"] }

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/Cargo.toml

@@ -38,8 +38,6 @@ db-index = { workspace = true, optional = true }
 indexmap = { version = "2", features = ["serde"] }
 itertools = { workspace = true }
 log = { workspace = true }
-pest = "2"
-pest_derive = "2"
 pgrx = { version = "0.18", optional = true }
 postgres = { version = "0.19", optional = true, features = [
   "with-uuid-1",

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

@@ -2,7 +2,10 @@ use std::collections::HashMap;
 
 use gqlparser::oc::ast;
 
-use crate::{planner::LogicalPlan, prelude::*};
+use crate::{
+  planner::{self, LogicalPlan},
+  prelude::*,
+};
 
 use compiler::expression_analyser::{self, ExpressionType};
 
@@ -72,14 +75,17 @@ impl Variable
             variable: None,
             labels: ast::LabelExpression::None,
             properties: None,
+            predicate: None,
           },
           destination: ast::NodePattern {
             variable: None,
             labels: ast::LabelExpression::None,
             properties: None,
+            predicate: None,
           },
           directivity: graphcore::EdgeDirectivity::Directed,
-          recursive_range: None,
+
+          predicate: None,
         }),
         variable_type: ExpressionType::Edge,
         col_id,
@@ -90,6 +96,8 @@ impl Variable
           variable: None,
           labels: ast::LabelExpression::None,
           properties: None,
+
+          predicate: None,
         }),
         variable_type: ExpressionType::Node,
         col_id,
@@ -484,23 +492,101 @@ impl VariablesManager
     Ok(())
   }
 
-  fn analyse_pattern(&mut self, pattern: &ast::Pattern, is_create: bool) -> Result<()>
+  fn analyse_pattern(&mut self, pattern: &planner::PlannedPattern, is_create: bool) -> Result<()>
   {
     match pattern
     {
-      ast::Pattern::Node(node) =>
+      planner::PlannedPattern::Node(node) =>
       {
         self.validate_node(node)?;
       }
-      ast::Pattern::Edge(edge) =>
+      planner::PlannedPattern::Edge(edge) =>
       {
         self.analyse_edge_path(None, edge, is_create)?;
       }
-      ast::Pattern::Path(path) =>
+      planner::PlannedPattern::Path(path) =>
       {
         self.analyse_edge_path(None, &path.edge, is_create)?;
         self.declare_variable(&path.variable, ExpressionType::Path)?;
       }
+      planner::PlannedPattern::QuantifiedPath { pattern: qp, .. } =>
+      {
+        if qp.group.len() != 1
+        {
+          // Multi-element groups: declare path variable and outer anchors
+          if let Some(path_variable) = &qp.variable
+          {
+            self.declare_variable(path_variable, ExpressionType::Path)?;
+          }
+          if !self.is_valid_existing_node(&qp.source)?
+          {
+            self.validate_node(&qp.source)?;
+          }
+          if !self.is_valid_existing_node(&qp.destination)?
+          {
+            self.validate_node(&qp.destination)?;
+          }
+          // Multi-element groups: analyze all patterns in the group
+          for pattern in &qp.group
+          {
+            match pattern
+            {
+              ast::Pattern::Node(node) =>
+              {
+                self.validate_node(node)?;
+              }
+              ast::Pattern::Edge(edge) =>
+              {
+                self.validate_edge(edge)?;
+              }
+              ast::Pattern::Path(path) =>
+              {
+                self.declare_variable(&path.variable, ExpressionType::Path)?;
+                self.validate_edge(&path.edge)?;
+              }
+              ast::Pattern::QuantifiedPath(_) =>
+              {
+                return Err(InternalError::Unimplemented("nested quantified path patterns").into());
+              }
+            }
+          }
+        }
+        else
+        {
+          if let Some(edge) = super::as_plain_quantifier(qp)
+          {
+            self.analyse_edge_path(qp.variable.clone(), edge, is_create)?;
+          }
+          else
+          {
+            // Explicit group: outer anchors differ from inner nodes
+            // Need to declare the outer anchors
+            if let Some(path_variable) = &qp.variable
+            {
+              self.declare_variable(path_variable, ExpressionType::Path)?;
+            }
+            if !self.is_valid_existing_node(&qp.source)?
+            {
+              self.validate_node(&qp.source)?;
+            }
+            if !self.is_valid_existing_node(&qp.destination)?
+            {
+              self.validate_node(&qp.destination)?;
+            }
+            // Validate every inner edge, not just the first - group.len() may be
+            // > 1 for multi-element groups (e.g. ((n)-[r1]->(x)-[r2]->(m))), and
+            // only checking group[0] would silently skip every subsequent edge's
+            // label/property/predicate constraints.
+            for pattern in &qp.group
+            {
+              if let ast::Pattern::Edge(edge) = pattern
+              {
+                self.validate_edge(edge)?;
+              }
+            }
+          }
+        }
+      }
     }
     Ok(())
   }
@@ -573,7 +659,7 @@ impl VariablesManager
       {
         for pattern in patterns.iter()
         {
-          if let ast::Pattern::Node(n) = &pattern
+          if let planner::PlannedPattern::Node(n) = pattern
             && self.has_variable(&n.variable)
           {
             return Err(
@@ -596,7 +682,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 { .. } =>
@@ -616,7 +703,7 @@ impl VariablesManager
         {
           match pattern
           {
-            ast::Pattern::Node(n) =>
+            planner::PlannedPattern::Node(n) =>
             {
               if self.has_variable(&n.variable)
               {
@@ -628,7 +715,7 @@ impl VariablesManager
                 );
               }
             }
-            ast::Pattern::Edge(e) =>
+            planner::PlannedPattern::Edge(e) =>
             {
               if self.has_variable(&e.variable)
               {
@@ -640,7 +727,7 @@ impl VariablesManager
                 );
               }
             }
-            ast::Pattern::Path(p) =>
+            planner::PlannedPattern::Path(p) =>
             {
               if self.has_variable(&Some(p.variable.clone()))
               {
@@ -652,6 +739,19 @@ impl VariablesManager
                 );
               }
             }
+            planner::PlannedPattern::QuantifiedPath { pattern: qp, .. } =>
+            {
+              if let Some(var) = &qp.variable
+                && self.has_variable(&Some(var.clone()))
+              {
+                return Err(
+                  CompileTimeError::VariableAlreadyBound {
+                    name: var.name().clone(),
+                  }
+                  .into(),
+                );
+              }
+            }
           }
           self.analyse_pattern(pattern, false)?;
         }