gqlite 1.5.0 → 1.7.0

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

@@ -83,11 +83,20 @@ pub(crate) enum Instruction
 
 pub(crate) type Instructions = Vec<Instruction>;
 
+#[derive(Debug, Default)]
+pub(crate) struct CreateActionVariable
+{
+  /// For node/edge
+  pub(crate) element: Option<ColId>,
+  /// For edges, an optional path variable
+  pub(crate) path: Option<ColId>,
+}
+
 #[derive(Debug)]
 pub(crate) struct CreateAction
 {
   pub(crate) instructions: Instructions,
-  pub(crate) variables: Vec<Option<ColId>>,
+  pub(crate) variables: Vec<CreateActionVariable>,
 }
 
 #[derive(Debug)]
@@ -107,7 +116,8 @@ pub(crate) enum BlockMatch
     right_variable: Option<ColId>,
     path_variable: Option<ColId>,
     filter: Instructions,
-    directivity: graph::EdgeDirectivity,
+    directivity: graphcore::EdgeDirectivity,
+    recursive_range: Option<std::ops::Range<usize>>,
   },
 }
 
@@ -265,4 +275,31 @@ pub(crate) enum Block
     updates: Vec<UpdateOne>,
     variables_size: VariablesSizes,
   },
+  Merge
+  {
+    match_blocks: Vec<BlockMatch>,
+    match_filter: Instructions,
+    create_actions: Vec<CreateAction>,
+    on_create_updates: Vec<UpdateOne>,
+    on_match_updates: Vec<UpdateOne>,
+    variables_size: VariablesSizes,
+  },
+  VectorSearch
+  {
+    index: String,
+    query_instructions: Instructions,
+    k: usize,
+    out_node_col_id: ColId,
+    out_score_col_id: Option<ColId>,
+    variables_size: VariablesSizes,
+  },
+  CreateVectorIndex
+  {
+    name: String,
+    label: String,
+    property: String,
+    dimension: Option<usize>,
+    metric: Option<gqlparser::oc::ast::Metric>,
+    if_not_exists: bool,
+  },
 }

data/ext/gqlitedb/src/lib.rs

@@ -19,7 +19,7 @@ mod error;
 mod functions;
 mod graph;
 mod interpreter;
-mod parser;
+mod planner;
 mod prelude;
 mod query_result;
 mod store;
@@ -33,12 +33,13 @@ pub(crate) mod tests;
 pub use {
   connection::{Backend, Connection},
   error::{CompileTimeError, Error, RunTimeError, StoreError},
-  graph::{labels, Edge, Node, Path},
+  graph::{Edge, Node, Path, SinglePath, labels},
+  planner::{LogicalPlan, LogicalPlans, ProjectionKind},
   query_result::QueryResult,
-  value::{array, value_map, TimeStamp, Value, ValueMap, ValueTryIntoRef},
+  value::{TimeStamp, Value, ValueMap, ValueTryIntoRef, array, value_map},
 };
 
-pub use graphcore::{table, Table};
+pub use graphcore::{Table, table};
 
 /// GQLite Result alias. Usable as a standard `Result<T, E>` or default to gqlite::Error with `Result<T>`
 pub type Result<T, E = error::export::Error> = std::result::Result<T, E>;

data/ext/gqlitedb/src/parser/gql.pest

@@ -1,4 +1,4 @@
-WHITESPACE     = _{ " " | "\t" | "\n" }
+WHITESPACE     = _{ " " | "\t" | "\n" | "\r\n" }
 COMMENT        = _{ ("//" ~ (!"\n" ~ ANY)*) | ("/*" ~ (!"*/" ~ ANY)* ~ "*/") }
 ident          = @{ ASCII_ALPHA ~ (ASCII_ALPHANUMERIC | "_")* }
 parameter_name = @{ (ASCII_ALPHANUMERIC | "_")* }

data/ext/gqlitedb/src/planner.rs

@@ -0,0 +1,329 @@
+//! Logical planning layer between parsing and bytecode compilation.
+
+use crate::Result;
+use gqlparser::oc::ast;
+
+/// Ordered list of logical plans.
+pub type LogicalPlans = Vec<LogicalPlan>;
+
+/// Logical representation of a statement.
+#[derive(Debug)]
+#[allow(clippy::large_enum_variant)]
+pub enum LogicalPlan
+{
+  /// Create a graph.
+  CreateGraph
+  {
+    /// Name of the graph to create.
+    name: String,
+    /// Whether the operation should be ignored when the graph already exists.
+    if_not_exists: bool,
+  },
+  /// Drop a graph.
+  DropGraph
+  {
+    /// Name of the graph to drop.
+    name: String,
+    /// Whether the operation should be ignored when the graph does not exist.
+    if_exists: bool,
+  },
+  /// Select the active graph.
+  UseGraph
+  {
+    /// Name of the graph to select.
+    name: String,
+  },
+  /// Create nodes and edges.
+  Create
+  {
+    /// Patterns to create.
+    patterns: Vec<ast::Pattern>,
+  },
+  /// Direct node scan produced from a MATCH clause.
+  NodeScan
+  {
+    /// Patterns to match, including any label constraints present in the AST.
+    patterns: Vec<ast::Pattern>,
+    /// Whether the scan is optional.
+    optional: bool,
+  },
+  /// Filter rows from another logical operator.
+  Filter
+  {
+    /// Input operator.
+    source: Box<LogicalPlan>,
+    /// Filter expression.
+    expression: ast::Expression,
+  },
+  /// Project rows for RETURN or WITH.
+  Projection
+  {
+    /// Kind of projection.
+    kind: ProjectionKind,
+    /// Whether all currently bound variables are projected.
+    all: bool,
+    /// Explicit expressions to project.
+    expressions: Vec<ast::NamedExpression>,
+  },
+  /// Sort rows from another logical operator.
+  Sort
+  {
+    /// Input operator.
+    source: Box<LogicalPlan>,
+    /// Sort expressions.
+    expressions: Vec<ast::OrderByExpression>,
+  },
+  /// Skip rows from another logical operator.
+  Skip
+  {
+    /// Input operator.
+    source: Box<LogicalPlan>,
+    /// Skip expression.
+    expression: ast::Expression,
+  },
+  /// Limit rows from another logical operator.
+  Limit
+  {
+    /// Input operator.
+    source: Box<LogicalPlan>,
+    /// Limit expression.
+    expression: ast::Expression,
+  },
+  /// Invoke a callable.
+  Call
+  {
+    /// Name of the callable.
+    name: String,
+    /// Call arguments.
+    arguments: Vec<ast::Expression>,
+  },
+  /// Expand a list into rows.
+  Unwind
+  {
+    /// Variable receiving each value.
+    identifier: ast::VariableIdentifier,
+    /// Expression producing the input list.
+    expression: ast::Expression,
+  },
+  /// Delete matched entities.
+  Delete
+  {
+    /// Whether connected relationships should also be deleted.
+    detach: bool,
+    /// Expressions resolving to entities to delete.
+    expressions: Vec<ast::Expression>,
+  },
+  /// Update matched entities.
+  Update
+  {
+    /// Update operations to apply.
+    updates: Vec<ast::OneUpdate>,
+  },
+  /// Merge matched or create entities with conditional updates.
+  Merge
+  {
+    /// Patterns to match or create.
+    patterns: Vec<ast::Pattern>,
+    /// Updates applied when entities are created.
+    on_create: Vec<ast::OneUpdate>,
+    /// Updates applied when entities are matched.
+    on_match: Vec<ast::OneUpdate>,
+  },
+  /// Vector similarity search for ranked result retrieval.
+  VectorSearch
+  {
+    /// Name of the vector index.
+    index: String,
+    /// Query vector.
+    query: ast::Expression,
+    /// Top-K results to return.
+    k: usize,
+    /// Variable to bind result nodes to.
+    result_var: ast::VariableIdentifier,
+    /// Optional variable to bind similarity scores to.
+    score_var: Option<ast::VariableIdentifier>,
+  },
+  /// Create a vector index (schema operation).
+  CreateVectorIndex
+  {
+    /// Index name.
+    name: String,
+    /// Label name (without colon).
+    label: String,
+    /// Property name.
+    property: String,
+    /// Vector dimension.
+    dimension: Option<usize>,
+    /// Distance metric.
+    metric: Option<ast::Metric>,
+    /// If not exists
+    if_not_exists: bool,
+  },
+}
+
+/// Type of projection.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum ProjectionKind
+{
+  /// Final output projection.
+  Return,
+  /// Intermediate projection.
+  With,
+}
+
+fn wrap_filter(plan: LogicalPlan, where_expression: Option<ast::Expression>) -> LogicalPlan
+{
+  match where_expression
+  {
+    Some(expression) => LogicalPlan::Filter {
+      source: Box::new(plan),
+      expression,
+    },
+    None => plan,
+  }
+}
+
+fn wrap_modifiers(plan: LogicalPlan, modifiers: ast::Modifiers) -> LogicalPlan
+{
+  let mut plan = plan;
+
+  if let Some(order_by) = modifiers.order_by
+  {
+    plan = LogicalPlan::Sort {
+      source: Box::new(plan),
+      expressions: order_by.expressions,
+    };
+  }
+
+  if let Some(skip) = modifiers.skip
+  {
+    plan = LogicalPlan::Skip {
+      source: Box::new(plan),
+      expression: skip,
+    };
+  }
+
+  if let Some(limit) = modifiers.limit
+  {
+    plan = LogicalPlan::Limit {
+      source: Box::new(plan),
+      expression: limit,
+    };
+  }
+
+  plan
+}
+
+fn plan_projection(
+  kind: ProjectionKind,
+  all: bool,
+  expressions: Vec<ast::NamedExpression>,
+  modifiers: ast::Modifiers,
+  where_expression: Option<ast::Expression>,
+) -> LogicalPlan
+{
+  let plan = LogicalPlan::Projection {
+    kind,
+    all,
+    expressions,
+  };
+
+  wrap_modifiers(wrap_filter(plan, where_expression), modifiers)
+}
+
+/// Build a logical plan for a single parsed statement.
+pub fn plan(statement: ast::Statement) -> Result<LogicalPlan>
+{
+  plan_impl(statement)
+}
+
+fn plan_impl(statement: ast::Statement) -> Result<LogicalPlan>
+{
+  match statement
+  {
+    ast::Statement::CreateGraph(create_graph) => Ok(LogicalPlan::CreateGraph {
+      name: create_graph.name,
+      if_not_exists: create_graph.if_not_exists,
+    }),
+    ast::Statement::DropGraph(drop_graph) => Ok(LogicalPlan::DropGraph {
+      name: drop_graph.name,
+      if_exists: drop_graph.if_exists,
+    }),
+    ast::Statement::UseGraph(use_graph) => Ok(LogicalPlan::UseGraph {
+      name: use_graph.name,
+    }),
+    ast::Statement::Create(create) => Ok(LogicalPlan::Create {
+      patterns: create.patterns,
+    }),
+    ast::Statement::Match(match_statement) =>
+    {
+      // If SEARCH clause exists, emit VectorSearch instead of NodeScan
+      if let Some(search) = match_statement.search
+      {
+        Ok(wrap_filter(
+          LogicalPlan::VectorSearch {
+            index: search.index,
+            query: search.query,
+            k: search.limit,
+            result_var: search.variable,
+            score_var: search.score_alias,
+          },
+          match_statement.where_expression,
+        ))
+      }
+      else
+      {
+        // Standard node scan when no SEARCH
+        Ok(wrap_filter(
+          LogicalPlan::NodeScan {
+            patterns: match_statement.patterns,
+            optional: match_statement.optional,
+          },
+          match_statement.where_expression,
+        ))
+      }
+    }
+    ast::Statement::Return(return_statement) => Ok(plan_projection(
+      ProjectionKind::Return,
+      return_statement.all,
+      return_statement.expressions,
+      return_statement.modifiers,
+      return_statement.where_expression,
+    )),
+    ast::Statement::Call(call) => Ok(LogicalPlan::Call {
+      name: call.name,
+      arguments: call.arguments,
+    }),
+    ast::Statement::With(with) => Ok(plan_projection(
+      ProjectionKind::With,
+      with.all,
+      with.expressions,
+      with.modifiers,
+      with.where_expression,
+    )),
+    ast::Statement::Unwind(unwind) => Ok(LogicalPlan::Unwind {
+      identifier: unwind.identifier,
+      expression: unwind.expression,
+    }),
+    ast::Statement::Delete(delete_statement) => Ok(LogicalPlan::Delete {
+      detach: delete_statement.detach,
+      expressions: delete_statement.expressions,
+    }),
+    ast::Statement::Update(update_statement) => Ok(LogicalPlan::Update {
+      updates: update_statement.updates,
+    }),
+    ast::Statement::Merge(merge_statement) => Ok(LogicalPlan::Merge {
+      patterns: merge_statement.patterns,
+      on_create: merge_statement.on_create,
+      on_match: merge_statement.on_match,
+    }),
+    ast::Statement::CreateVectorIndex(create_vector_index) => Ok(LogicalPlan::CreateVectorIndex {
+      name: create_vector_index.name,
+      label: create_vector_index.label,
+      property: create_vector_index.property,
+      dimension: create_vector_index.dimension,
+      metric: create_vector_index.metric,
+      if_not_exists: create_vector_index.if_not_exists,
+    }),
+  }
+}

data/ext/gqlitedb/src/prelude.rs

@@ -1,9 +1,9 @@
 pub(crate) use crate::{
-  aggregators, compiler, consts,
+  Error, Result, aggregators, compiler, consts,
   error::{self, CompileTimeError, InternalError, RunTimeError, StoreError},
-  functions, graph, interpreter, parser, query_result, store, utils, value,
+  functions, graph, interpreter, query_result, store, utils, value,
   value::ValueExt as _,
-  value_table, Error, Result,
+  value_table,
 };
 
 pub(crate) use error::export::Error as ErrorType;

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

@@ -1,4 +1,4 @@
-use crate::{graph, Result};
+use crate::{Result, graph};
 
 impl SqlParams for &[&(dyn tokio_postgres::types::ToSql + Sync)] {}