gqlite 1.2.3 → 1.3.0

data/ext/{gqliterb/vendor/gqlitedb → gqlitedb}/src/connection.rs

@@ -1,6 +1,6 @@
 use std::path::Path;
 
-use crate::prelude::*;
+use crate::{prelude::*, QueryResult};
 use value::ValueTryIntoRef;
 
 /// Backend
@@ -74,7 +74,7 @@ impl ConnectionBuilder
 
 trait ConnectionTrait: Sync + Send
 {
-  fn execute_query(&self, query: String, parameters: value::ValueMap) -> Result<value::Value>;
+  fn execute_oc_query(&self, query: &str, parameters: value::ValueMap) -> Result<QueryResult>;
 }
 
 struct ConnectionImpl<TStore>
@@ -89,31 +89,24 @@ impl<TStore> ConnectionTrait for ConnectionImpl<TStore>
 where
   TStore: store::Store + Sync + Send,
 {
-  fn execute_query(&self, query: String, parameters: value::ValueMap) -> Result<value::Value>
+  fn execute_oc_query(&self, query: &str, parameters: value::ValueMap) -> Result<QueryResult>
   {
-    let query_txt: String = query.into();
-    let queries = parser::parse(query_txt.as_str())?;
-    let mut results = Vec::<value::Value>::default();
+    let queries = parser::parse(query)?;
+    let mut results = Vec::<QueryResult>::default();
     for query in queries
     {
       let program = compiler::compile(&self.function_manager, query)?;
-      let v = interpreter::evaluators::eval_program(&self.store, &program, &parameters)?;
-      if !v.is_null()
-      {
-        results.push(v);
-      }
+      results.push(interpreter::evaluators::eval_program(
+        &self.store,
+        &program,
+        &parameters,
+      )?)
     }
     match results.len()
     {
-      0 => Ok(value::Value::Null),
-      1 => Ok(results.into_iter().next().unwrap()),
-      _ =>
-      {
-        let mut map = value::ValueMap::new();
-        map.insert("type".into(), "results".into());
-        map.insert("results".into(), results.into());
-        Ok(map.into())
-      }
+      0 => Ok(QueryResult::Empty),
+      1 => Ok(results.into_iter().next().unwrap()), // Guarantee to pass since we check for length
+      _ => Ok(QueryResult::Array(results)),
     }
   }
 }
@@ -129,37 +122,26 @@ where
 }
 
 /// Connection is the interface to the database, and allow to execute new queries.
-/// New connection are created with [Connection::open] and queried with [Connection::execute_query].
-/// As shown in the example bellow:
+/// New connection are created with [Connection::create] or [Connection::builder] and queried with
+/// [Connection::execute_oc_query]. As shown in the example bellow:
 ///
 /// ```rust
-/// # use gqlitedb::{Connection, Value};
+/// # use gqlitedb::{Backend, Connection, QueryResult};
 /// # fn example() -> gqlitedb::Result<()> {
-/// let connection = Connection::open("filename.db", gqlitedb::map!("backend" => "redb"))?;
-/// let value = connection.execute_query("MATCH (a) RETURN a", Default::default())?;
+/// let connection = Connection::builder().path("filename.db").backend(Backend::Redb).create()?;
+/// let value = connection.execute_oc_query("MATCH (a) RETURN a", Default::default())?;
 /// match value
 /// {
-///   Value::Array(arr) =>
+///   QueryResult::Table(table) =>
 ///   {
-///     arr.iter().for_each(|row| match row
-///     {
-///       Value::Array(arr) =>
-///       {
-///         println!("{:?}", arr);
-///       }
-///       _ =>
-///       {
-///         panic!("Unexpected: {}", row);
-///       }
-///     });
+///     println!("{:?}", table);
 ///   },
 ///   _ => {
-///     panic!("Query result should be an array, got {}!", value);
+///     panic!("Query result should be a table!");
 ///   }
 /// }
 /// # Ok(()) }
 /// ```
-
 pub struct Connection
 {
   connection: Box<dyn ConnectionTrait>,
@@ -176,7 +158,7 @@ impl Connection
   /// - `path` a path to a file, if not present, an in-memory database is created
   /// - `backend` for instance `redb` or `sqlite` (the [Self::available_backends] function contains the list of compiled backends)
   ///
-  /// If the `backend` is not specified, the `open` function will attempt to guess it
+  /// If the `backend` is not specified, the `create` function will attempt to guess it
   /// for existing databases. For new database, depending on availability, it will
   /// create a `sqlite` database, or a `redb` database.
   ///
@@ -185,7 +167,7 @@ impl Connection
   /// ```rust
   /// # use gqlitedb::Connection;
   /// # fn example() -> gqlitedb::Result<()> {
-  /// let connection = Connection::create(gqlitedb::map!("backend" => "redb"))?;
+  /// let connection = Connection::create(gqlitedb::value_map!("backend" => "redb"))?;
   /// # Ok(()) }
   /// ```  
   pub fn create(options: value::ValueMap) -> Result<Connection>
@@ -206,7 +188,7 @@ impl Connection
         };
         #[cfg(not(feature = "sqlite"))]
         let sq_e = Err(error::StoreError::UnavailableBackend { backend: "sqlite" }.into());
-        let sq_r = match sq_e
+        match sq_e
         {
           Ok(sq) => Ok(sq),
           Err(sq_e) =>
@@ -222,13 +204,12 @@ impl Connection
 
             sq_r.map_err(|rb_e| {
               StoreError::OpeningError {
-                errors: error::vec_to_error::<ErrorType>(&vec![sq_e, rb_e]),
+                errors: error::vec_to_error(&vec![sq_e, rb_e]),
               }
               .into()
             })
           }
-        };
-        sq_r
+        }
       }
       #[cfg(feature = "sqlite")]
       "sqlite" =>
@@ -275,8 +256,9 @@ impl Connection
   }
   /// Create a builder, with a high-level API to set the options.
   /// Example of use:
-  /// ```
-  /// let connection = Connection::builder().path("path/to/file").backend(Backend::SQLite).create()?;
+  /// ```no_run
+  /// # use gqlitedb::{Connection, Backend};
+  /// let connection = Connection::builder().path("path/to/file").backend(Backend::SQLite).create().unwrap();
   /// ```
   pub fn builder() -> ConnectionBuilder
   {
@@ -287,56 +269,32 @@ impl Connection
   /// List of available backends
   pub fn available_backends() -> Vec<String>
   {
-    let mut backends = vec![];
-    #[cfg(feature = "sqlite")]
-    backends.push("sqlite".to_string());
-    #[cfg(feature = "redb")]
-    backends.push("redb".to_string());
-    backends
+    vec![
+      #[cfg(feature = "sqlite")]
+      "sqlite".to_string(),
+      #[cfg(feature = "redb")]
+      "redb".to_string(),
+    ]
   }
 
-  /// Open a `path` that contains a `GQLite` database. The `options` parameter can
-  /// be used to select the backend, and configure the backend.
-  ///
-  /// Supported parameters:
-  /// - `backend` can be `redb` or `sqlite`
-  ///
-  /// If the `backend` is not specified, the `open` function will attempt to guess it
-  /// for existing databases. For new database, depending on availability, it will
-  /// create a `sqlite` database, or a `redb` database.
-  ///
-  /// Example of use:
-  ///
-  /// ```rust
-  /// # use gqlitedb::Connection;
-  /// # fn example() -> gqlitedb::Result<()> {
-  /// let connection = Connection::open("filename.db", gqlitedb::map!("backend" => "redb"))?;
-  /// # Ok(()) }
-  /// ```  
-  #[cfg(any(feature = "redb", feature = "sqlite"))]
-  #[deprecated = "Use create or builder instead."]
-  pub fn open<P: AsRef<std::path::Path>>(path: P, options: value::ValueMap) -> Result<Connection>
-  {
-    Self::builder().options(options).path(path).create()
-  }
   /// Execute the `query` (using OpenCypher), given the query `parameters` (sometimes
   /// also referred as binding).
   ///
   /// Example:
   ///
   /// ```rust
-  /// # use gqlitedb::{Connection, Value};
+  /// # use gqlitedb::{Backend, Connection, Value};
   /// # fn example() -> gqlitedb::Result<()> {
-  /// # let connection = gqlitedb::Connection::open("filename.db", gqlitedb::map!("backend" => "redb"))?;
-  /// let result = connection.execute_query("MATCH (a { name: $name }) RETURN a", gqlitedb::map!("name" => "Joe"))?;
+  /// # let connection = Connection::builder().path("filename.db").backend(Backend::Redb).create()?;
+  /// let result = connection.execute_oc_query("MATCH (a { name: $name }) RETURN a", gqlitedb::value_map!("name" => "Joe"))?;
   /// # Ok(()) }
   /// ```
-  pub fn execute_query(
+  pub fn execute_oc_query(
     &self,
-    query: impl Into<String>,
+    query: impl AsRef<str>,
     parameters: value::ValueMap,
-  ) -> Result<value::Value>
+  ) -> Result<QueryResult>
   {
-    self.connection.execute_query(query.into(), parameters)
+    self.connection.execute_oc_query(query.as_ref(), parameters)
   }
 }

data/ext/{gqliterb/vendor/gqlitedb → gqlitedb}/src/error.rs

@@ -21,7 +21,7 @@ pub enum CompileTimeError
   },
   /// Parse error
   #[error("ParseError: '{0}'")]
-  ParseError(#[from] pest::error::Error<crate::parser::parser::Rule>),
+  ParseError(#[from] Box<pest::error::Error<crate::parser::parser_impl::Rule>>),
   /// Variable is not defined
   #[error("UndefinedVariable: Unknown variable '{name}'.")]
   UndefinedVariable
@@ -129,6 +129,12 @@ pub enum RunTimeError
   InvalidBinaryOperands,
   #[error("InvalidNegationOperands: operands for negation operation are not compatible.")]
   InvalidNegationOperands,
+  #[error("Invalid value cast, cannot cast {value} to {typename}.")]
+  InvalidValueCast
+  {
+    value: Box<crate::Value>,
+    typename: &'static str,
+  },
   #[error("InvalidDelete: invalid delete argument, expected node or edge.")]
   InvalidDelete,
   #[error("DeleteConnectedNode: node is still connected and cannot be deleted.")]
@@ -149,6 +155,13 @@ pub enum RunTimeError
   {
     graph_name: String
   },
+  #[error("Key {key} cannot be found in a path in a ValueMap.")]
+  MissingKeyInPath
+  {
+    key: String
+  },
+  #[error("Path cannot have null key.")]
+  MissingKey,
 }
 
 /// Internal errors, should be treated as bugs.
@@ -214,12 +227,6 @@ pub enum InternalError
   },
   #[error("Empty stack.")]
   EmptyStack,
-  #[error("Invalid value cast, cannot cast {value} to {typename}.")]
-  InvalidValueCast
-  {
-    value: crate::Value,
-    typename: &'static str,
-  },
   #[error("Code is not reachable in {context}.")]
   Unreachable
   {
@@ -263,19 +270,13 @@ pub enum InternalError
   #[error("Invalid aggregation state")]
   InvalidAggregationState,
 
+  #[error("Invalid query result cast")]
+  InvalidQueryResultCast,
+
   // Third-party
   #[error("Missing element in iterator.")]
   MissingElementIterator,
 
-  #[cfg(feature = "redb")]
-  #[error("redb: {0}")]
-  RedbError(#[from] redb::Error),
-
-  // Errors from sqlite
-  #[cfg(feature = "sqlite")]
-  #[error("Sqlite: {0}")]
-  SqliteError(#[from] rusqlite::Error),
-
   // Errors from askama
   #[cfg(feature = "sqlite")]
   #[error("Askama: {0}")]
@@ -310,6 +311,8 @@ pub enum InternalError
   Infallible(#[from] std::convert::Infallible),
   #[error("Poison error {0}.")]
   Poison(String),
+  #[error("IOError: {0}.")]
+  IOError(#[from] std::io::Error),
 }
 
 /// Error in the store backend.
@@ -318,6 +321,19 @@ pub enum InternalError
 #[non_exhaustive]
 pub enum StoreError
 {
+  // Errors from sqlite
+  #[cfg(feature = "sqlite")]
+  #[error("Sqlite: {0}")]
+  SqliteError(#[from] rusqlite::Error),
+
+  #[cfg(feature = "redb")]
+  #[error("redb: {0}")]
+  RedbError(#[from] redb::Error),
+
+  #[cfg(feature = "redb")]
+  #[error("redb: {0}")]
+  Redb2Error(#[from] redb2::Error),
+
   #[error("UnknownBackend: backend '{backend}' is unknown.")]
   UnknownBackend
   {
@@ -351,6 +367,8 @@ pub enum StoreError
     actual: utils::Version,
     expected: utils::Version,
   },
+  #[error("Invalid database format: {0}.")]
+  InvalidFormat(String),
 }
 
 /// GQLite errors
@@ -381,16 +399,37 @@ impl Error
   {
     self
   }
+  #[cfg(not(feature = "_backtrace"))]
   pub(crate) fn split_error(self) -> (Error, ())
   {
     (self, ())
   }
+  #[cfg(not(feature = "_backtrace"))]
   pub(crate) fn make_error(error: Error, _: ()) -> Error
   {
     error
   }
 }
 
+impl From<graphcore::Error> for Error
+{
+  fn from(value: graphcore::Error) -> Self
+  {
+    match value
+    {
+      graphcore::Error::InvalidBinaryOperands => RunTimeError::InvalidBinaryOperands.into(),
+      graphcore::Error::InvalidNegationOperands => RunTimeError::InvalidNegationOperands.into(),
+      graphcore::Error::InvalidValueCast { value, typename } =>
+      {
+        RunTimeError::InvalidValueCast { value, typename }.into()
+      }
+      graphcore::Error::MissingKey => RunTimeError::MissingKey.into(),
+      graphcore::Error::MissingKeyInPath { key } => RunTimeError::MissingKeyInPath { key }.into(),
+      _ => InternalError::Unimplemented("From graphcore::Error to graphcore::Error.").into(),
+    }
+  }
+}
+
 //  _____                   __        ___ _   _     ____             _    _
 // | ____|_ __ _ __ ___  _ _\ \      / (_) |_| |__ | __ )  __ _  ___| | __ |_ _ __ __ _  ___ ___
 // |  _| | '__| '__/ _ \| '__\ \ /\ / /| | __| '_ \|  _ \ / _` |/ __| |/ / __| '__/ _` |/ __/ _ \
@@ -460,11 +499,11 @@ impl<T> From<std::sync::PoisonError<T>> for Error
   }
 }
 
-impl From<pest::error::Error<crate::parser::parser::Rule>> for Error
+impl From<pest::error::Error<crate::parser::parser_impl::Rule>> for Error
 {
-  fn from(value: pest::error::Error<crate::parser::parser::Rule>) -> Self
+  fn from(value: pest::error::Error<crate::parser::parser_impl::Rule>) -> Self
   {
-    CompileTimeError::from(value).into()
+    CompileTimeError::from(Box::new(value)).into()
   }
 }
 
@@ -481,52 +520,83 @@ macro_rules! error_as_internal {
   };
 }
 
+pub(crate) use error_as_internal;
+
+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()
+      }
+    }
+  };
+}
+
+pub(crate) use error_as_store;
+
 error_as_internal! {ciborium::ser::Error<std::io::Error>}
 error_as_internal! {ciborium::de::Error<std::io::Error>}
 error_as_internal! {serde_json::Error}
 error_as_internal! {std::num::ParseFloatError}
 
-pub(crate) use error_as_internal;
-
 #[cfg(feature = "redb")]
 mod _trait_impl_redb
 {
-  super::error_as_internal! {redb::Error}
-  macro_rules! redb_error_as_internal {
+  super::error_as_store! {redb::Error}
+  macro_rules! redb_error_as_store {
     ($err_type:ty) => {
       impl From<$err_type> for crate::prelude::ErrorType
       {
         fn from(value: $err_type) -> Self
         {
           let redb_err: redb::Error = value.into();
-          let err: crate::error::InternalError = redb_err.into();
+          let err: crate::error::StoreError = redb_err.into();
+          err.into()
+        }
+      }
+    };
+  }
+  super::error_as_store! {redb2::Error}
+  macro_rules! redb2_error_as_store {
+    ($err_type:ty) => {
+      impl From<$err_type> for crate::prelude::ErrorType
+      {
+        fn from(value: $err_type) -> Self
+        {
+          let redb_err: redb2::Error = value.into();
+          let err: crate::error::StoreError = redb_err.into();
           err.into()
         }
       }
     };
   }
-  redb_error_as_internal! {redb::StorageError}
-  redb_error_as_internal! {redb::DatabaseError}
-  redb_error_as_internal! {redb::TransactionError}
-  redb_error_as_internal! {redb::TableError}
-  redb_error_as_internal! {redb::CommitError}
+  redb_error_as_store! {redb::StorageError}
+  redb_error_as_store! {redb::DatabaseError}
+  redb_error_as_store! {redb::TransactionError}
+  redb_error_as_store! {redb::TableError}
+  redb_error_as_store! {redb::CommitError}
+  redb2_error_as_store! {redb2::DatabaseError}
+  redb2_error_as_store! {redb2::UpgradeError}
 }
 #[cfg(feature = "sqlite")]
 mod _trait_impl_sqlite
 {
-  error_as_internal! {rusqlite::Error}
+  error_as_store! {rusqlite::Error}
   error_as_internal! {askama::Error}
 }
 
 /// Merge a list of error into a string error message
-pub(crate) fn vec_to_error<E: std::fmt::Display>(errs: &Vec<ErrorType>) -> String
+pub(crate) fn vec_to_error(errs: &[ErrorType]) -> String
 {
   let errs: Vec<String> = errs.iter().map(|x| format!("'{}'", x)).collect();
   errs.join(", ")
 }
 
-pub(crate) fn parse_int_error_to_compile_error<'a>(
-  text: &'a str,
+pub(crate) fn parse_int_error_to_compile_error(
+  text: &str,
   e: std::num::ParseIntError,
 ) -> crate::prelude::ErrorType
 {
@@ -550,7 +620,8 @@ pub(crate) fn parse_int_error_to_compile_error<'a>(
 macro_rules! map_error {
   ($err:expr, $source:pat => $destination:expr) => {{
     use crate::error::*;
-    let (error, meta) = $err.split_error();
+    let error: crate::prelude::ErrorType = $err;
+    let (error, meta) = error.split_error();
     match error
     {
       $source => ErrorType::make_error($destination.into(), meta),

data/ext/{gqliterb/vendor/gqlitedb → gqlitedb}/src/functions/containers.rs

@@ -6,6 +6,7 @@ pub(super) struct Head {}
 
 impl Head
 {
+  #[allow(clippy::ptr_arg)]
   fn call_impl(array: &Vec<value::Value>) -> FResult<value::Value>
   {
     Ok(
@@ -34,20 +35,17 @@ impl Keys
     match container
     {
       value::Value::Map(obj) => Ok(obj.keys().map(|x| x.to_owned().into()).collect()),
-      value::Value::Node(n) => Ok(n.properties.keys().map(|x| x.to_owned().into()).collect()),
-      value::Value::Edge(e) => Ok(e.properties.keys().map(|x| x.to_owned().into()).collect()),
-      _ =>
-      {
-        return Err(
-          RunTimeError::InvalidArgument {
-            function_name: "keys",
-            index: 0,
-            expected_type: "map, node or relationship",
-            value: format!("{:?}", container),
-          }
-          .into(),
-        )
-      }
+      value::Value::Node(n) => Ok(n.properties().keys().map(|x| x.to_owned().into()).collect()),
+      value::Value::Edge(e) => Ok(e.properties().keys().map(|x| x.to_owned().into()).collect()),
+      _ => Err(
+        RunTimeError::InvalidArgument {
+          function_name: "keys",
+          index: 0,
+          expected_type: "map, node or relationship",
+          value: format!("{:?}", container),
+        }
+        .into(),
+      ),
     }
   }
 }
@@ -88,18 +86,15 @@ impl super::FunctionTrait for Size
       value::Value::Array(arr) => Ok((arr.len() as i64).into()),
       value::Value::Map(obj) => Ok((obj.len() as i64).into()),
       value::Value::Path(..) => Ok(1.into()),
-      _ =>
-      {
-        return Err(
-          RunTimeError::InvalidArgument {
-            function_name: "size",
-            index: 0,
-            expected_type: "array or map",
-            value: format!("{:?}", container),
-          }
-          .into(),
-        )
-      }
+      _ => Err(
+        RunTimeError::InvalidArgument {
+          function_name: "size",
+          index: 0,
+          expected_type: "array or map",
+          value: format!("{:?}", container),
+        }
+        .into(),
+      ),
     }
   }
   fn validate_arguments(&self, _: Vec<ExpressionType>) -> Result<ExpressionType>

data/ext/{gqliterb/vendor/gqlitedb → gqlitedb}/src/functions/edge.rs

@@ -10,9 +10,9 @@ impl Type
   fn call_impl(edge: &graph::Edge) -> FResult<String>
   {
     edge
-      .labels
+      .labels()
       .first()
-      .ok_or_else(|| RunTimeError::MissingEdgeLabel)
+      .ok_or(RunTimeError::MissingEdgeLabel)
       .map(|v| v.to_owned())
   }
 }

data/ext/{gqliterb/vendor/gqlitedb → gqlitedb}/src/functions/math.rs

@@ -24,7 +24,7 @@ impl Ceil
 {
   fn call_impl(value: &f64) -> FResult<f64>
   {
-    Ok(value.ceil() as f64)
+    Ok(value.ceil())
   }
 }
 
@@ -37,7 +37,7 @@ impl Floor
 {
   fn call_impl(value: &f64) -> FResult<f64>
   {
-    Ok(value.floor() as f64)
+    Ok(value.floor())
   }
 }
 

data/ext/{gqliterb/vendor/gqlitedb → gqlitedb}/src/functions/node.rs

@@ -9,7 +9,7 @@ impl Labels
 {
   fn call_impl(node: &graph::Node) -> FResult<Vec<String>>
   {
-    Ok(node.labels.to_owned())
+    Ok(node.labels().to_owned())
   }
 }
 

data/ext/{gqliterb/vendor/gqlitedb → gqlitedb}/src/functions/path.rs

@@ -21,18 +21,15 @@ impl super::FunctionTrait for Length
       value::Value::Array(arr) => Ok((arr.len() as i64).into()),
       value::Value::Map(obj) => Ok((obj.len() as i64).into()),
       value::Value::Path(..) => Ok(1.into()),
-      _ =>
-      {
-        return Err(
-          RunTimeError::InvalidArgument {
-            function_name: "length",
-            index: 0,
-            expected_type: "array or map",
-            value: format!("{:?}", container),
-          }
-          .into(),
-        )
-      }
+      _ => Err(
+        RunTimeError::InvalidArgument {
+          function_name: "length",
+          index: 0,
+          expected_type: "array or map",
+          value: format!("{:?}", container),
+        }
+        .into(),
+      ),
     }
   }
   fn validate_arguments(&self, _: Vec<ExpressionType>) -> crate::Result<ExpressionType>
@@ -54,7 +51,7 @@ impl Nodes
 {
   fn call_impl(path: &graph::Path) -> FResult<Vec<graph::Node>>
   {
-    Ok(vec![path.source.clone(), path.destination.clone()])
+    Ok(vec![path.source().clone(), path.destination().clone()])
   }
 }
 
@@ -67,13 +64,11 @@ impl Edges
 {
   fn call_impl(path: &graph::Path) -> FResult<Vec<graph::Edge>>
   {
-    Ok(vec![graph::Edge {
-      key: path.key.clone(),
-      source: path.source.clone(),
-      destination: path.destination.clone(),
-      properties: path.properties.clone(),
-      labels: path.labels.clone(),
-    }])
+    Ok(vec![graph::Edge::new(
+      path.key(),
+      path.labels().clone(),
+      path.properties().clone(),
+    )])
   }
 }
 

data/ext/{gqliterb/vendor/gqlitedb → gqlitedb}/src/functions/scalar.rs

@@ -70,8 +70,8 @@ impl Properties
   {
     match value
     {
-      value::Value::Node(n) => Ok(n.properties.to_owned()),
-      value::Value::Edge(e) => Ok(e.properties.to_owned()),
+      value::Value::Node(n) => Ok(n.properties().to_owned()),
+      value::Value::Edge(e) => Ok(e.properties().to_owned()),
       value::Value::Map(m) => Ok(m.to_owned()),
       _ => Err(RunTimeError::InvalidArgument {
         function_name: "properties",