gqlite 1.5.1 → 1.7.0

data/ext/gqlitedb/src/connection.rs

@@ -1,6 +1,7 @@
 use std::path::Path;
 
-use crate::{prelude::*, QueryResult};
+use crate::{QueryResult, planner, prelude::*};
+use substring::Substring;
 use value::ValueTryIntoRef;
 
 /// Backend
@@ -104,16 +105,126 @@ where
 {
   fn execute_oc_query(&self, query: &str, parameters: value::ValueMap) -> Result<QueryResult>
   {
-    let queries = parser::parse(query)?;
+    use gqlparser::oc::ErrorKind;
+    let queries = gqlparser::oc::parse_oc_query(query).map_err(|e| match e.error_kind()
+    {
+      ErrorKind::IntegerOverflow => error::CompileTimeError::IntegerOverflow {
+        text: query.substring(e.span().start, e.span().end).to_string(),
+      },
+      ErrorKind::FloatingPointOverflow => error::CompileTimeError::FloatingPointOverflow {
+        text: query.substring(e.span().start, e.span().end).to_string(),
+      },
+      ErrorKind::RequiresDirectedEdge => error::CompileTimeError::RequiresDirectedRelationship {
+        text: query.substring(e.span().start, e.span().end).to_string(),
+        span: e.span().clone(),
+      },
+      ErrorKind::NoSingleRelationshipType => error::CompileTimeError::NoSingleRelationshipType {
+        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(),
+        span: e.span().clone(),
+      },
+    })?;
+    if consts::SHOW_AST
+    {
+      log::debug!("ast = {:#?}", queries);
+    }
     let mut results = Vec::<QueryResult>::default();
     for query in queries
     {
-      let program = compiler::compile(&self.function_manager, query)?;
-      results.push(interpreter::evaluators::eval_program(
-        &self.store,
-        &program,
-        &parameters,
-      )?)
+      match query
+      {
+        gqlparser::oc::ast::Query::Statements(stmts) =>
+        {
+          let logical_plans: Result<Vec<_>> = stmts.into_iter().map(planner::plan).collect();
+          let program = compiler::compile(&self.function_manager, logical_plans?)?;
+          results.push(interpreter::evaluators::eval_program(
+            &self.store,
+            &program,
+            &parameters,
+          )?)
+        }
+        gqlparser::oc::ast::Query::Union { branches, all } =>
+        {
+          // Evaluate each branch independently
+          let branch_results: Result<Vec<_>> = branches
+            .into_iter()
+            .map(|stmts| {
+              let logical_plans: Result<Vec<_>> = stmts.into_iter().map(planner::plan).collect();
+              let program = compiler::compile(&self.function_manager, logical_plans?)?;
+              interpreter::evaluators::eval_program(&self.store, &program, &parameters)
+            })
+            .collect();
+
+          // Extract tables from results and validate headers
+          let branch_results = branch_results?;
+          let mut tables: Vec<graphcore::Table> = Vec::new();
+          let mut has_empty = false;
+
+          for result in branch_results
+          {
+            match result
+            {
+              QueryResult::Table(t) => tables.push(t),
+              QueryResult::Empty => has_empty = true,
+              _ => return Err(CompileTimeError::DifferentColumnsInUnion.into()),
+            }
+          }
+
+          // If all branches are empty, return Empty
+          if tables.is_empty()
+          {
+            results.push(QueryResult::Empty);
+            continue;
+          }
+
+          // Validate that all tables have identical headers
+          let headers = tables[0].headers().clone();
+          for t in &tables[1..]
+          {
+            if t.headers() != &headers
+            {
+              return Err(CompileTimeError::DifferentColumnsInUnion.into());
+            }
+          }
+
+          // If any branch was empty, that's a header mismatch
+          if has_empty
+          {
+            return Err(CompileTimeError::DifferentColumnsInUnion.into());
+          }
+
+          // Concatenate all row data
+          let mut data: Vec<graphcore::Value> = tables
+            .into_iter()
+            .flat_map(|t| t.into_row_iter().flatten())
+            .collect();
+
+          // UNION (distinct): deduplicate rows
+          if !all
+          {
+            let col_count = headers.len();
+            let mut result_rows: Vec<Vec<graphcore::Value>> = Vec::new();
+
+            for row_chunk in data.chunks(col_count)
+            {
+              let row = row_chunk.to_vec();
+              // Check if row is already in result
+              if !result_rows.iter().any(|r| r == &row)
+              {
+                result_rows.push(row);
+              }
+            }
+
+            data = result_rows.into_iter().flatten().collect();
+          }
+
+          results.push(QueryResult::Table(graphcore::Table::new(headers, data)?));
+        }
+      }
     }
     match results.len()
     {
@@ -160,6 +271,14 @@ pub struct Connection
   connection: Box<dyn ConnectionTrait>,
 }
 
+impl std::fmt::Debug for Connection
+{
+  fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result
+  {
+    f.write_str("Connection")
+  }
+}
+
 ccutils::assert_impl_all!(Connection: Sync, Send);
 
 impl Connection
@@ -180,9 +299,9 @@ impl Connection
   /// ```rust
   /// # use gqlitedb::Connection;
   /// # fn example() -> gqlitedb::Result<()> {
-  /// let connection = Connection::create(gqlitedb::value_map!("backend" => "redb"))?;
+  /// let connection = Connection::create(gqlitedb::value_map!("backend" => "sqlite"))?;
   /// # Ok(()) }
-  /// ```  
+  /// ```
   pub fn create(options: value::ValueMap) -> Result<Connection>
   {
     let backend = options.get("backend").map_or_else(
@@ -303,7 +422,7 @@ impl Connection
   /// Example of use:
   /// ```no_run
   /// # use gqlitedb::{Connection, Backend};
-  /// let connection = Connection::builder().path("path/to/file").backend(Backend::SQLite).create().unwrap();
+  /// let connection = Connection::builder().path("path/to/file").backend(Backend::Redb).create().unwrap();
   /// ```
   pub fn builder() -> ConnectionBuilder
   {
@@ -345,3 +464,22 @@ impl Connection
     self.connection.execute_oc_query(query.as_ref(), parameters)
   }
 }
+
+impl graphcore::OpenCypherQueryExecutor for Connection
+{
+  fn execute_oc_query(
+    &self,
+    query: &str,
+    parameters: graphcore::ValueMap,
+  ) -> Result<Option<graphcore::Table>, graphcore::Error>
+  {
+    let qr = self
+      .execute_oc_query(query, parameters)
+      .map_err(|e| graphcore::Error::QueryExecutionError(e.to_string()))?;
+    match qr
+    {
+      QueryResult::Table(tbl) => Ok(Some(tbl)),
+      _ => Ok(None),
+    }
+  }
+}

data/ext/gqlitedb/src/consts.rs

@@ -1,10 +1,9 @@
-pub(crate) const SHOW_PARSE_TREE: bool = false;
 pub(crate) const SHOW_AST: bool = false;
 pub(crate) const SHOW_PROGRAM: bool = false;
 pub(crate) const SHOW_EVALUATOR_STATE: bool = false;
 
 pub(crate) const GQLITE_VERSION: crate::utils::Version = crate::utils::Version {
   major: 1,
-  minor: 2,
+  minor: 8,
   patch: 0,
 };

data/ext/gqlitedb/src/error.rs

@@ -20,8 +20,22 @@ pub enum CompileTimeError
     text: String
   },
   /// Parse error
-  #[error("ParseError: '{0}'")]
-  ParseError(#[from] Box<pest::error::Error<crate::parser::parser_impl::Rule>>),
+  #[error("ParseError: {error_kind:?}: '{text}' at {span:?}.")]
+  ParseError
+  {
+    error_kind: gqlparser::oc::ErrorKind,
+    text: String,
+    span: std::ops::Range<usize>,
+  },
+  /// Unexpected syntax encountered at compile time (used to match TCK expectations)
+  #[error("UnexpectedSyntax: Expected token {expected} got {got} at ({line}, {col}).")]
+  UnexpectedSyntax
+  {
+    expected: String,
+    got: String,
+    line: usize,
+    col: usize,
+  },
   /// Variable is not defined
   #[error("UndefinedVariable: Unknown variable '{name}'.")]
   UndefinedVariable
@@ -43,13 +57,20 @@ pub enum CompileTimeError
     name: String
   },
   /// ()-[]-() is not accepted in this context
-  #[error("RequiresDirectedRelationship: edges need to be directed in this context: '{context}'.")]
+  #[error("RequiresDirectedRelationship: edges need to be directed at: '{text}' at {span:?}.")]
   RequiresDirectedRelationship
   {
-    context: &'static str
+    text: String,
+    span: std::ops::Range<usize>,
+  },
+  #[error(
+    "NoSingleRelationshipType: a single edge type need to be specified at: '{text}' at {span:?}."
+  )]
+  NoSingleRelationshipType
+  {
+    text: String,
+    span: std::ops::Range<usize>,
   },
-  #[error("NoSingleRelationshipType: an edge type need to be specified.")]
-  NoSingleRelationshipType,
   #[error("NotComparable: values are not comparable.")]
   NotComparable,
   #[error("UnknownFunction: {name}.")]
@@ -67,7 +88,9 @@ pub enum CompileTimeError
   #[error("InvalidDelete: invalid delete argument, expected node or edge.")]
   InvalidDelete,
   /// Too few or too many arguments
-  #[error("InvalidNumberOfArguments: Invalid number of arguments for function '{function_name}' got {got} expected {expected}.")]
+  #[error(
+    "InvalidNumberOfArguments: Invalid number of arguments for function '{function_name}' got {got} expected {expected}."
+  )]
   InvalidNumberOfArguments
   {
     function_name: &'static str,
@@ -78,6 +101,35 @@ pub enum CompileTimeError
   NonConstantExpression,
   #[error("InvalidArgumentType: invalid argument type.")]
   InvalidArgumentType,
+  #[error("NegativeIntegerArgument: statement expect a positive integer.")]
+  NegativeIntegerArgument,
+  #[error("CreatingVarLength: attempt at creating a variable length edge.")]
+  CreatingVarLength,
+  #[error("InvalidVectorInput: Expected vector or tensor for SEARCH.")]
+  InvalidVectorInput,
+  #[error(
+    "InvalidVectorElement: Array element must be numeric (Integer or Float), got {type_name}."
+  )]
+  InvalidVectorElement
+  {
+    type_name: String
+  },
+  #[error("NestedArrayNotSupported: Nested arrays are not supported in vector inputs.")]
+  NestedArrayNotSupported,
+  #[error("EmptyVector: Vector cannot be empty.")]
+  EmptyVector,
+  #[error("ExpectedNode: Expected a value to be a node in {context}.")]
+  ExpectedNode
+  {
+    context: &'static str
+  },
+  #[error("ExpectedEdge: Expected a value to be an edge in {context}.")]
+  ExpectedEdge
+  {
+    context: &'static str
+  },
+  #[error("DifferentColumnsInUnion: All sub-queries in a UNION must have the same column names.")]
+  DifferentColumnsInUnion,
 }
 
 /// Runtime errors.
@@ -93,7 +145,9 @@ pub enum RunTimeError
     name: String
   },
   /// Too few or too many arguments
-  #[error("InvalidNumberOfArguments: Invalid number of arguments for function '{function_name}' got {got} expected {expected}.")]
+  #[error(
+    "InvalidNumberOfArguments: Invalid number of arguments for function '{function_name}' got {got} expected {expected}."
+  )]
   InvalidNumberOfArguments
   {
     function_name: &'static str,
@@ -150,6 +204,11 @@ pub enum RunTimeError
   {
     graph_name: String
   },
+  #[error("DuplicatedVectorIndex: vector index '{index_name}' already exists.")]
+  DuplicatedVectorIndex
+  {
+    index_name: String
+  },
   #[error("UnknownGraph: {graph_name} does not exists.")]
   UnknownGraph
   {
@@ -167,6 +226,13 @@ pub enum RunTimeError
   {
     value: f64, min: f64, max: f64
   },
+  #[error("ExpectedEdge: Expected a value to be an edge in {context}.")]
+  ExpectedEdge
+  {
+    context: &'static str
+  },
+  #[error("MergeReadOwnWrites: Cannot merge node using null property value, which is not allowed.")]
+  MergeReadOwnWrites,
 }
 
 /// Internal errors, should be treated as bugs.
@@ -180,16 +246,6 @@ pub enum InternalError
   MissingAggregationArgument,
   #[error("Aggregations are missing.")]
   MissingAggregations,
-  #[error("Expected a value to be a node in {context}.")]
-  ExpectedNode
-  {
-    context: &'static str
-  },
-  #[error("Expected a value to be an edge in {context}.")]
-  ExpectedEdge
-  {
-    context: &'static str
-  },
   #[error("Missing a pair from pest parsing in {context}.")]
   MissingPair
   {
@@ -205,11 +261,6 @@ pub enum InternalError
   {
     context: &'static str
   },
-  #[error("Path pattern was used in create expression in {context}.")]
-  PathPatternInCreateExpression
-  {
-    context: &'static str
-  },
   #[error("Invalid create labels expression {context}.")]
   InvalidCreateLabels
   {
@@ -257,7 +308,9 @@ pub enum InternalError
   {
     got: usize, expected: usize
   },
-  #[error("Some variables were declared, but not set. Set variables are {set_variables:?}, all variables are {all_variables:?}")]
+  #[error(
+    "Some variables were declared, but not set. Set variables are {set_variables:?}, all variables are {all_variables:?}"
+  )]
   NotAllVariablesAreSet
   {
     set_variables: Vec<String>,
@@ -275,6 +328,9 @@ pub enum InternalError
   #[error("Invalid aggregation state")]
   InvalidAggregationState,
 
+  #[error("Migration error: {0}")]
+  MigrationError(String),
+
   #[error("Invalid query result cast")]
   InvalidQueryResultCast,
 
@@ -285,7 +341,7 @@ pub enum InternalError
   // Errors from askama
   #[cfg(feature = "sqlite")]
   #[error("Askama: {0}")]
-  AskamaError(#[from] askama::Error),
+  AskamaError(askama::Error),
 
   // Serialization errors
   #[error("An error occured while serialization to Cbor: {0}")]
@@ -310,6 +366,8 @@ pub enum InternalError
   UnknownNode,
   #[error("Unknown edge")]
   UnknownEdge,
+  #[error("UnsupportedRecursivePatternInMerge")]
+  UnsupportedRecursivePatternInMerge,
   #[error("Unimplemented error at {0}")]
   Unimplemented(&'static str),
   #[error("Infallible.")]
@@ -367,7 +425,9 @@ pub enum StoreError
   {
     backend: &'static str
   },
-  #[error("OpeningError: could not open database, got the following error messages from the backends: {errors}.")]
+  #[error(
+    "OpeningError: could not open database, got the following error messages from the backends: {errors}."
+  )]
   OpeningError
   {
     errors: String
@@ -377,6 +437,11 @@ pub enum StoreError
   {
     graph_name: String
   },
+  #[error("DuplicatedVectorIndex: vector index '{index_name}' already exists.")]
+  DuplicatedVectorIndex
+  {
+    index_name: String
+  },
   #[error("UnknownGraph: {graph_name} is not known.")]
   UnknownGraph
   {
@@ -390,6 +455,10 @@ pub enum StoreError
     actual: utils::Version,
     expected: utils::Version,
   },
+  #[error(
+    "MissingVersionMetadata: database has no version metadata; refusing to open an unrecognized or corrupted database file."
+  )]
+  MissingVersionMetadata,
   #[error("Invalid database format: {0}.")]
   InvalidFormat(String),
 }
@@ -522,37 +591,27 @@ impl<T> From<std::sync::PoisonError<T>> for Error
   }
 }
 
-impl From<pest::error::Error<crate::parser::parser_impl::Rule>> for Error
-{
-  fn from(value: pest::error::Error<crate::parser::parser_impl::Rule>) -> Self
-  {
-    CompileTimeError::from(Box::new(value)).into()
-  }
-}
-
-macro_rules! error_as_internal {
-  ($err_type:ty) => {
+macro_rules! error_as_ {
+  ($err_type:ty, $enum_name: ident) => {
     impl From<$err_type> for crate::prelude::ErrorType
     {
       fn from(value: $err_type) -> Self
       {
-        let err: crate::error::InternalError = value.into();
+        let err: crate::error::$enum_name = value.into();
         err.into()
       }
     }
   };
 }
+macro_rules! error_as_internal {
+  ($err_type:ty) => {
+    error_as_! {$err_type, InternalError}
+  };
+}
 
 macro_rules! error_as_store {
   ($err_type:ty) => {
-    impl From<$err_type> for crate::prelude::ErrorType
-    {
-      fn from(value: $err_type) -> Self
-      {
-        let err: crate::error::StoreError = value.into();
-        err.into()
-      }
-    }
+    error_as_! {$err_type, StoreError}
   };
 }
 
@@ -563,6 +622,7 @@ error_as_internal! {ciborium::de::Error<std::io::Error>}
 error_as_internal! {serde_json::Error}
 error_as_internal! {std::num::ParseFloatError}
 error_as_internal! {std::str::Utf8Error}
+error_as_internal! {std::io::Error}
 
 #[cfg(feature = "redb")]
 mod _trait_impl_redb
@@ -618,6 +678,13 @@ mod _trait_impl_postgres
 #[cfg(any(feature = "postgres", feature = "sqlite"))]
 mod _trait_impl_askama
 {
+  impl From<askama::Error> for crate::error::InternalError
+  {
+    fn from(err: askama::Error) -> Self
+    {
+      crate::error::InternalError::GenericStdError(Box::new(err))
+    }
+  }
   error_as_internal! {askama::Error}
 }
 
@@ -628,22 +695,6 @@ pub(crate) fn vec_to_error(errs: &[ErrorType]) -> String
   errs.join(", ")
 }
 
-pub(crate) fn parse_int_error_to_compile_error(
-  text: &str,
-  e: std::num::ParseIntError,
-) -> crate::prelude::ErrorType
-{
-  use std::num::IntErrorKind;
-  match e.kind()
-  {
-    IntErrorKind::PosOverflow | IntErrorKind::NegOverflow => CompileTimeError::IntegerOverflow {
-      text: text.to_owned(),
-    }
-    .into(),
-    _ => InternalError::ParseIntError(e).into(),
-  }
-}
-
 /// Convenient macro for mapping errors, for instance, from internal error to runtime error:
 ///
 /// ```notest
@@ -675,6 +726,17 @@ impl From<std::convert::Infallible> for Error
   }
 }
 
+#[cfg(feature = "redb")]
+impl From<db_index::hnsw::Error> for Error
+{
+  fn from(value: db_index::hnsw::Error) -> Self
+  {
+    let error_msg = format!("HNSW error: {:?}", value);
+    log::error!("{}", error_msg);
+    InternalError::Unimplemented("HNSW operation error").into()
+  }
+}
+
 //   ____                      _      _____
 //  / ___| ___ _ __   ___ _ __(_) ___| ____|_ __ _ __ ___  _ __ ___
 // | |  _ / _ \ '_ \ / _ \ '__| |/ __|  _| | '__| '__/ _ \| '__/ __|

data/ext/gqlitedb/src/functions/common.rs

@@ -13,7 +13,6 @@ impl Size
       value::Value::String(str) => Ok(str.len() as i64),
       value::Value::Array(arr) => Ok(arr.len() as i64),
       value::Value::Map(obj) => Ok(obj.len() as i64),
-      value::Value::Path(..) => Ok(1.into()),
       _ => Err(RunTimeError::InvalidArgument {
         function_name: "size",
         index: 0,
@@ -24,4 +23,42 @@ impl Size
   }
 }
 
-super::declare_function!(size, Size, call_impl(graphcore::Value) -> i64, null_handling(null_returns_null));
+impl super::FunctionTrait for Size
+{
+  fn call(&self, mut arguments: Vec<value::Value>) -> crate::Result<value::Value>
+  {
+    let arg = arguments
+      .first()
+      .ok_or(RunTimeError::InvalidNumberOfArguments {
+        function_name: "size",
+        got: arguments.len(),
+        expected: 1,
+      })?;
+    if arg.is_null()
+    {
+      return Ok(value::Value::Null);
+    }
+    let val = arguments.remove(0);
+    Self::call_impl(val).map(|r| r.into()).map_err(Into::into)
+  }
+
+  fn validate_arguments(
+    &self,
+    args: Vec<crate::compiler::expression_analyser::ExpressionType>,
+  ) -> crate::Result<crate::compiler::expression_analyser::ExpressionType>
+  {
+    use crate::compiler::expression_analyser::ExpressionType;
+    if args.iter().any(|t| matches!(t, ExpressionType::Path))
+    {
+      return Err(crate::error::CompileTimeError::InvalidArgumentType.into());
+    }
+    Ok(ExpressionType::Integer)
+  }
+
+  fn is_deterministic(&self) -> bool
+  {
+    true
+  }
+}
+
+super::declare_function!(size, Size, custom_trait);

data/ext/gqlitedb/src/functions/math.rs

@@ -1,4 +1,4 @@
-use rand::Rng;
+use rand::RngExt;
 
 use crate::prelude::*;
 
@@ -48,7 +48,7 @@ impl Rand
   }
 }
 
-super::declare_function!(rand, Rand, call_impl() -> Vec<f64>);
+super::declare_function!(rand, Rand, call_impl() -> Vec<f64>, non_deterministic);
 
 macro_rules! define_f64_function {
     ($name: ident, $class_name: ident, $rust_func: ident $(, $arg0: expr)*) => {
@@ -102,10 +102,15 @@ super::declare_function!(atan2, Atan2, call_impl(f64, f64) -> f64);
 #[cfg(test)]
 mod test
 {
-  use crate::functions::math::Extra as _;
+  use crate::functions::math::{Extra as _, Rand};
   #[test]
   fn test_cot()
   {
     assert_eq!(0.5_f64.cot(), 1.830487721712452);
   }
+  #[test]
+  fn test_rand()
+  {
+    assert!(!Rand::create().1.is_deterministic());
+  }
 }