gqlite 1.5.0 → 1.7.0

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

@@ -1,13 +1,14 @@
 use std::collections::HashMap;
 
-use crate::prelude::*;
+use gqlparser::oc::ast;
+
+use crate::{planner::LogicalPlan, prelude::*};
 
 use compiler::expression_analyser::{self, ExpressionType};
-use parser::ast;
 
 fn unknown_variable_error(name: &ast::VariableIdentifier) -> ErrorType
 {
-  InternalError::UnknownVariable {
+  CompileTimeError::UndefinedVariable {
     name: name.name().clone(),
   }
   .into()
@@ -77,7 +78,8 @@ impl Variable
             labels: ast::LabelExpression::None,
             properties: None,
           },
-          directivity: crate::graph::EdgeDirectivity::Directed,
+          directivity: graphcore::EdgeDirectivity::Directed,
+          recursive_range: None,
         }),
         variable_type: ExpressionType::Edge,
         col_id,
@@ -253,7 +255,7 @@ impl VariablesManager
               }
             }
             _ => Err(
-              InternalError::ExpectedNode {
+              CompileTimeError::ExpectedNode {
                 context: "validate_node",
               }
               .into(),
@@ -358,7 +360,7 @@ impl VariablesManager
               }
             }
             _ => Err(
-              InternalError::ExpectedNode {
+              CompileTimeError::ExpectedNode {
                 context: "is_valid_existing_node",
               }
               .into(),
@@ -413,7 +415,7 @@ impl VariablesManager
               }
             }
             _ => Err(
-              InternalError::ExpectedEdge {
+              CompileTimeError::ExpectedEdge {
                 context: "is_valid_existing_edge",
               }
               .into(),
@@ -459,7 +461,7 @@ impl VariablesManager
   fn analyse_edge_path(
     &mut self,
     path_variable: Option<ast::VariableIdentifier>,
-    edge: &crate::parser::ast::EdgePattern,
+    edge: &gqlparser::oc::ast::EdgePattern,
     is_create: bool,
   ) -> Result<()>
   {
@@ -538,7 +540,7 @@ impl VariablesManager
     self.variables = new_variables;
     Ok(())
   }
-  pub(crate) fn analyse(&mut self, statement: &ast::Statement) -> Result<()>
+  pub(crate) fn analyse(&mut self, logical_plan: &LogicalPlan) -> Result<()>
   {
     if self.variables.iter().any(|(_, var)| !var.is_set)
     {
@@ -559,58 +561,122 @@ impl VariablesManager
         .into(),
       );
     }
-    match statement
+    match logical_plan
     {
-      ast::Statement::CreateGraph(..) =>
+      LogicalPlan::CreateGraph { .. } =>
       {}
-      ast::Statement::DropGraph(..) =>
+      LogicalPlan::DropGraph { .. } =>
       {}
-      ast::Statement::UseGraph(..) =>
+      LogicalPlan::UseGraph { .. } =>
       {}
-      ast::Statement::Create(create) =>
+      LogicalPlan::Create { patterns } =>
       {
-        for pattern in create.patterns.iter()
+        for pattern in patterns.iter()
         {
           if let ast::Pattern::Node(n) = &pattern
+            && self.has_variable(&n.variable)
           {
-            if self.has_variable(&n.variable)
-            {
-              return Err(
-                CompileTimeError::VariableAlreadyBound {
-                  name: n.variable.clone().unwrap().name().clone(),
-                }
-                .into(),
-              );
-            }
+            return Err(
+              CompileTimeError::VariableAlreadyBound {
+                name: n.variable.clone().unwrap().name().clone(),
+              }
+              .into(),
+            );
           }
           self.analyse_pattern(pattern, true)?;
         }
       }
-      ast::Statement::Match(match_statement) =>
+      LogicalPlan::NodeScan { patterns, .. } =>
       {
-        for pattern in match_statement.patterns.iter()
+        for pattern in patterns.iter()
         {
           self.analyse_pattern(pattern, false)?;
         }
       }
-      ast::Statement::Return(..) =>
-      {}
-      ast::Statement::Call(..) =>
+      LogicalPlan::Filter { source, .. }
+      | LogicalPlan::Sort { source, .. }
+      | LogicalPlan::Skip { source, .. }
+      | LogicalPlan::Limit { source, .. } => self.analyse(source.as_ref())?,
+      LogicalPlan::Projection { .. } =>
       {}
-      ast::Statement::With(..) =>
+      LogicalPlan::Call { .. } =>
       {}
-      ast::Statement::Unwind(unwind) =>
+      LogicalPlan::Unwind { identifier, .. } =>
       {
-        self.declare_variable(
-          &unwind.identifier.to_owned(),
-          expression_analyser::ExpressionType::Variant,
-        )?;
-        self.mark_variables_as_set(&unwind.identifier)?;
+        self.declare_variable(identifier, expression_analyser::ExpressionType::Variant)?;
+        self.mark_variables_as_set(identifier)?;
       }
-      ast::Statement::Delete(..) =>
+      LogicalPlan::Delete { .. } =>
       {}
-      ast::Statement::Update(..) =>
+      LogicalPlan::Update { .. } =>
       {}
+      LogicalPlan::Merge { patterns, .. } =>
+      {
+        for pattern in patterns.iter()
+        {
+          match pattern
+          {
+            ast::Pattern::Node(n) =>
+            {
+              if self.has_variable(&n.variable)
+              {
+                return Err(
+                  CompileTimeError::VariableAlreadyBound {
+                    name: n.variable.as_ref().unwrap().name().clone(),
+                  }
+                  .into(),
+                );
+              }
+            }
+            ast::Pattern::Edge(e) =>
+            {
+              if self.has_variable(&e.variable)
+              {
+                return Err(
+                  CompileTimeError::VariableAlreadyBound {
+                    name: e.variable.as_ref().unwrap().name().clone(),
+                  }
+                  .into(),
+                );
+              }
+            }
+            ast::Pattern::Path(p) =>
+            {
+              if self.has_variable(&Some(p.variable.clone()))
+              {
+                return Err(
+                  CompileTimeError::VariableAlreadyBound {
+                    name: p.variable.name().clone(),
+                  }
+                  .into(),
+                );
+              }
+            }
+          }
+          self.analyse_pattern(pattern, false)?;
+        }
+      }
+      LogicalPlan::VectorSearch {
+        result_var,
+        score_var,
+        ..
+      } =>
+      {
+        // Declare the result variable as a Node
+        self.declare_variable(result_var, expression_analyser::ExpressionType::Node)?;
+        self.mark_variables_as_set(result_var)?;
+
+        // Declare the score variable if present
+        if let Some(score_var_id) = score_var
+        {
+          self.declare_variable(score_var_id, expression_analyser::ExpressionType::Float)?;
+          self.mark_variables_as_set(score_var_id)?;
+        }
+      }
+      LogicalPlan::CreateVectorIndex { .. } =>
+      {
+        // Schema operation - no variable analysis needed
+      }
     }
     Ok(())
   }