gqlite 1.8.1 → 1.8.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4af74e4cc44046fee49a1e9573a876066a80ddc6eaaf2def11f5af0002b89ff2
-  data.tar.gz: c105b94002e5c43a74e8f7b418ba45d8d17c47bab1a68dc32c914e18c3a3e1cb
+  metadata.gz: c6ebd6bd26d6614d8d3edd02d592c4bfd125a5dc3bf8170cb69c3f7e22dd48a7
+  data.tar.gz: 1c9f08c8d98976a104166ddc321e23a81e3a66d36fa16c97dcff0aa81adc735f
 SHA512:
-  metadata.gz: 885b3a13b70473a45cdad51df3fe04f1aebd98828a6211445bf1907c44f88ff543e78ffbf86b5afa971f76482e0b190ed76a7212cbf8b520a20b6e5505a58081
-  data.tar.gz: d784d78413e35a708b204a557ef0e1d54236adae193679205b522d788529277c2f183824c87e57946733dd68e36013aea2e0cca6f42fe774d92ce6eccb8d4aed
+  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/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/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(
@@ -617,7 +703,7 @@ impl VariablesManager
         {
           match pattern
           {
-            ast::Pattern::Node(n) =>
+            planner::PlannedPattern::Node(n) =>
             {
               if self.has_variable(&n.variable)
               {
@@ -629,7 +715,7 @@ impl VariablesManager
                 );
               }
             }
-            ast::Pattern::Edge(e) =>
+            planner::PlannedPattern::Edge(e) =>
             {
               if self.has_variable(&e.variable)
               {
@@ -641,7 +727,7 @@ impl VariablesManager
                 );
               }
             }
-            ast::Pattern::Path(p) =>
+            planner::PlannedPattern::Path(p) =>
             {
               if self.has_variable(&Some(p.variable.clone()))
               {
@@ -653,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)?;
         }