gqlite 1.2.2 → 1.2.3

data/ext/gqliterb/vendor/gqlitedb/src/connection.rs

@@ -1,6 +1,77 @@
+use std::path::Path;
+
 use crate::prelude::*;
 use value::ValueTryIntoRef;
 
+/// Backend
+pub enum Backend
+{
+  /// Select the first available backend.
+  Automatic,
+  /// SQLite backend.
+  #[cfg(feature = "sqlite")]
+  SQLite,
+  /// Redb backend.
+  #[cfg(feature = "redb")]
+  Redb,
+}
+
+/// Builder with high-level API for creating connection.
+pub struct ConnectionBuilder
+{
+  map: value::ValueMap,
+}
+
+impl ConnectionBuilder
+{
+  /// Merge options. This might overwrite value from the builder
+  pub fn options(mut self, options: value::ValueMap) -> Self
+  {
+    for (k, v) in options.into_iter()
+    {
+      self.map.insert(k, v);
+    }
+    self
+  }
+  /// Set path
+  pub fn path<P: AsRef<Path>>(mut self, p: P) -> Self
+  {
+    self.map.insert(
+      "path".to_string(),
+      p.as_ref().to_string_lossy().as_ref().into(),
+    );
+    self
+  }
+  /// Set backend
+  pub fn backend(mut self, backend: Backend) -> Self
+  {
+    let key = "backend".into();
+    match backend
+    {
+      Backend::Automatic =>
+      {
+        self.map.insert(key, "automatic".into());
+      }
+      #[cfg(feature = "sqlite")]
+      Backend::SQLite =>
+      {
+        self.map.insert(key, "sqlite".into());
+      }
+      #[cfg(feature = "redb")]
+      Backend::Redb =>
+      {
+        self.map.insert(key, "redb".into());
+      }
+    }
+    self
+  }
+  /// Create the connection
+  pub fn create(self) -> Result<Connection>
+  {
+    Connection::create(self.map)
+  }
+}
+
 trait ConnectionTrait: Sync + Send
 {
   fn execute_query(&self, query: String, parameters: value::ValueMap) -> Result<value::Value>;
@@ -98,92 +169,155 @@ ccutils::assert_impl_all!(Connection: Sync, Send);
 
 impl Connection
 {
-  /// Open a `path` that contains a `GQLite` database. The `options` parameter can
+  /// Create a new connection to 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`
+  /// - `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
   /// for existing databases. For new database, depending on availability, it will
   /// create a `sqlite` database, or a `redb` database.
   ///
-  /// Example of use:
+  /// Example of use, this will create an in-memory database:
   ///
   /// ```rust
   /// # use gqlitedb::Connection;
   /// # fn example() -> gqlitedb::Result<()> {
-  /// let connection = Connection::open("filename.db", gqlitedb::map!("backend" => "redb"))?;
+  /// let connection = Connection::create(gqlitedb::map!("backend" => "redb"))?;
   /// # Ok(()) }
   /// ```  
-  #[cfg(any(feature = "redb", feature = "sqlite"))]
-  pub fn open<P: AsRef<std::path::Path>>(path: P, options: value::ValueMap) -> Result<Connection>
+  pub fn create(options: value::ValueMap) -> Result<Connection>
   {
-    if let Some(backend) = options.get("backend")
+    let backend = options.get("backend").map_or_else(
+      || Ok("automatic".to_string()),
+      |x| x.try_into_ref().map(|x: &String| x.to_owned()),
+    )?;
+    match backend.as_str()
     {
-      let backend: &String = backend.try_into_ref()?;
-      match backend.as_str()
+      "automatic" =>
       {
-        "sqlite" => Self::open_sqlite(path),
-        "redb" => Self::open_redb(path),
-        _ => Err(
-          StoreError::UnknownBackend {
-            backend: backend.to_owned(),
+        #[cfg(feature = "sqlite")]
+        let sq_e = {
+          let mut options = options.clone();
+          options.insert("backend".into(), "sqlite".into());
+          Self::create(options)
+        };
+        #[cfg(not(feature = "sqlite"))]
+        let sq_e = Err(error::StoreError::UnavailableBackend { backend: "sqlite" }.into());
+        let sq_r = match sq_e
+        {
+          Ok(sq) => Ok(sq),
+          Err(sq_e) =>
+          {
+            #[cfg(feature = "redb")]
+            let sq_r = {
+              let mut options = options;
+              options.insert("backend".into(), "redb".into());
+              Self::create(options)
+            };
+            #[cfg(not(feature = "redb"))]
+            let sq_r = Err(error::StoreError::UnavailableBackend { backend: "redb" }.into());
+
+            sq_r.map_err(|rb_e| {
+              StoreError::OpeningError {
+                errors: error::vec_to_error::<ErrorType>(&vec![sq_e, rb_e]),
+              }
+              .into()
+            })
           }
-          .into(),
-        ),
+        };
+        sq_r
       }
-    }
-    else
-    {
-      Self::open_sqlite(path.as_ref().to_owned()).or_else(|sq_e| {
-        Self::open_redb(path).map_err(|rb_e| {
-          StoreError::OpeningError {
-            errors: error::vec_to_error::<ErrorType>(&vec![sq_e, rb_e]),
+      #[cfg(feature = "sqlite")]
+      "sqlite" =>
+      {
+        let store = if let Some(path) = options.get("path")
+        {
+          let path: &String = path.try_into_ref()?;
+          store::sqlite::Store::open(path)?
+        }
+        else
+        {
+          store::sqlite::Store::in_memory()?
+        };
+        Ok(Connection {
+          connection: ConnectionImpl {
+            store,
+            function_manager: functions::Manager::new(),
           }
-          .into()
+          .boxed(),
         })
-      })
-    }
-  }
-  #[cfg(feature = "sqlite")]
-  fn open_sqlite<P: AsRef<std::path::Path>>(path: P) -> Result<Connection>
-  {
-    Ok(Connection {
-      connection: ConnectionImpl {
-        store: store::sqlite::Store::new(path)?,
-        function_manager: functions::Manager::new(),
       }
-      .boxed(),
-    })
-  }
-  #[cfg(not(feature = "sqlite"))]
-  fn open_sqlite<P: AsRef<std::path::Path>>(_: P) -> Result<Connection>
-  {
-    Err(error::ConnectionError::UnavailableBackend { backend: "sqlite" }.into())
+      #[cfg(feature = "redb")]
+      "redb" =>
+      {
+        let store = if let Some(path) = options.get("path")
+        {
+          let path: &String = path.try_into_ref()?;
+          store::redb::Store::open(path)?
+        }
+        else
+        {
+          store::redb::Store::in_memory()?
+        };
+        Ok(Connection {
+          connection: ConnectionImpl {
+            store,
+            function_manager: functions::Manager::new(),
+          }
+          .boxed(),
+        })
+      }
+      _ => Err(StoreError::UnknownBackend { backend }.into()),
+    }
   }
-  #[cfg(feature = "redb")]
-  fn open_redb<P: AsRef<std::path::Path>>(path: P) -> Result<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()?;
+  /// ```
+  pub fn builder() -> ConnectionBuilder
   {
-    Ok(Connection {
-      connection: ConnectionImpl {
-        store: store::redb::Store::new(path)?,
-        function_manager: functions::Manager::new(),
-      }
-      .boxed(),
-    })
+    ConnectionBuilder {
+      map: Default::default(),
+    }
   }
-  #[cfg(not(feature = "redb"))]
-  fn open_redb<P: AsRef<std::path::Path>>(_: P) -> Result<Connection>
+  /// List of available backends
+  pub fn available_backends() -> Vec<String>
   {
-    Err(error::StoreError::UnavailableBackend { backend: "redb" }.into())
+    let mut backends = vec![];
+    #[cfg(feature = "sqlite")]
+    backends.push("sqlite".to_string());
+    #[cfg(feature = "redb")]
+    backends.push("redb".to_string());
+    backends
   }
-  #[cfg(feature = "_pgql")]
-  pub fn create() -> Result<Connection>
+
+  /// 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>
   {
-    Ok(Connection {
-      store: store::Store::new()?,
-    })
+    Self::builder().options(options).path(path).create()
   }
   /// Execute the `query` (using OpenCypher), given the query `parameters` (sometimes
   /// also referred as binding).

data/ext/gqliterb/vendor/gqlitedb/src/error.rs

@@ -52,7 +52,7 @@ pub enum CompileTimeError
   NoSingleRelationshipType,
   #[error("NotComparable: values are not comparable.")]
   NotComparable,
-  #[error("UnknownFunction: {name}")]
+  #[error("UnknownFunction: {name}.")]
   UnknownFunction
   {
     name: String
@@ -120,7 +120,7 @@ pub enum RunTimeError
   /// Edge has no label
   #[error("MissingEdgeLabel")]
   MissingEdgeLabel,
-  #[error("UnknownFunction: {name}")]
+  #[error("UnknownFunction: {name}.")]
   UnknownFunction
   {
     name: String
@@ -372,11 +372,7 @@ pub enum Error
   Internal(#[from] InternalError),
 }
 
-fn assert_send_sync<T: Send + Sync>() {}
-fn _check_error_send_sync()
-{
-  assert_send_sync::<Error>();
-}
+ccutils::assert_impl_all!(Error: Send, Sync);
 
 impl Error
 {
@@ -402,12 +398,14 @@ impl Error
 // |_____|_|  |_|  \___/|_|    \_/\_/  |_|\__|_| |_|____/ \__,_|\___|_|\_\\__|_|  \__,_|\___\___|
 
 #[derive(Debug)]
+#[cfg(feature = "_backtrace")]
 pub struct ErrorWithBacktrace
 {
   error: Error,
   backtrace: std::backtrace::Backtrace,
 }
 
+#[cfg(feature = "_backtrace")]
 impl ErrorWithBacktrace
 {
   /// Return the underlying error
@@ -425,6 +423,7 @@ impl ErrorWithBacktrace
   }
 }
 
+#[cfg(feature = "_backtrace")]
 impl std::fmt::Display for ErrorWithBacktrace
 {
   fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result
@@ -432,6 +431,8 @@ impl std::fmt::Display for ErrorWithBacktrace
     self.error.fmt(f)
   }
 }
+
+#[cfg(feature = "_backtrace")]
 impl<T> From<T> for ErrorWithBacktrace
 where
   T: Into<Error>,
@@ -579,7 +580,6 @@ impl From<std::convert::Infallible> for Error
 pub(crate) trait GenericErrors: Into<Error>
 {
   fn unknown_function(name: impl Into<String>) -> Self;
-  fn not_comparable() -> Self;
 }
 
 impl GenericErrors for CompileTimeError
@@ -588,10 +588,6 @@ impl GenericErrors for CompileTimeError
   {
     Self::UnknownFunction { name: name.into() }
   }
-  fn not_comparable() -> Self
-  {
-    Self::NotComparable
-  }
 }
 
 impl GenericErrors for RunTimeError
@@ -600,10 +596,6 @@ impl GenericErrors for RunTimeError
   {
     Self::UnknownFunction { name: name.into() }
   }
-  fn not_comparable() -> Self
-  {
-    Self::NotComparable
-  }
 }
 
 /// GQLite Result

data/ext/gqliterb/vendor/gqlitedb/src/functions/edge.rs

@@ -1,6 +1,6 @@
 use crate::prelude::*;
 
-use super::{FResult, FunctionTypeTrait};
+use super::FResult;
 
 #[derive(Debug, Default)]
 pub(super) struct Type {}

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

@@ -2,7 +2,7 @@ use rand::Rng;
 
 use crate::prelude::*;
 
-use super::{FResult, FunctionTypeTrait};
+use super::FResult;
 
 #[derive(Debug, Default)]
 pub(super) struct Rand {}

data/ext/gqliterb/vendor/gqlitedb/src/functions/node.rs

@@ -1,6 +1,6 @@
 use crate::prelude::*;
 
-use super::{FResult, FunctionTypeTrait};
+use super::FResult;
 
 #[derive(Debug, Default)]
 pub(super) struct Labels {}

data/ext/gqliterb/vendor/gqlitedb/src/functions/path.rs

@@ -1,5 +1,5 @@
 use super::ExpressionType;
-use crate::prelude::*;
+use crate::{functions::FResult, prelude::*};
 
 #[derive(Debug, Default)]
 pub(super) struct Length {}
@@ -46,3 +46,35 @@ impl super::FunctionTrait for Length
 }
 
 super::declare_function!(length, Length, custom_trait);
+
+#[derive(Debug, Default)]
+pub(super) struct Nodes {}
+
+impl Nodes
+{
+  fn call_impl(path: &graph::Path) -> FResult<Vec<graph::Node>>
+  {
+    Ok(vec![path.source.clone(), path.destination.clone()])
+  }
+}
+
+super::declare_function!(nodes, Nodes, call_impl(crate::graph::Path) -> Vec<graph::Node>);
+
+#[derive(Debug, Default)]
+pub(super) struct Edges {}
+
+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(),
+    }])
+  }
+}
+
+super::declare_function!(edges, Edges, call_impl(crate::graph::Path) -> Vec<graph::Edge>);

data/ext/gqliterb/vendor/gqlitedb/src/functions/scalar.rs

@@ -59,7 +59,7 @@ impl ToInteger
   }
 }
 
-super::declare_function!(toInteger, ToInteger, call_impl(crate::value::Value) -> i64);
+super::declare_function!(tointeger, ToInteger, call_impl(crate::value::Value) -> i64);
 
 #[derive(Debug, Default)]
 pub(super) struct Properties {}

data/ext/gqliterb/vendor/gqlitedb/src/functions/string.rs

@@ -25,4 +25,4 @@ impl ToString
   }
 }
 
-super::declare_function!(toString, ToString, call_impl(crate::value::Value) -> String, validate_args(ExpressionType::Boolean | ExpressionType::Integer | ExpressionType::Float | ExpressionType::String | ExpressionType::Null));
+super::declare_function!(tostring, ToString, call_impl(crate::value::Value) -> String, validate_args(ExpressionType::Boolean | ExpressionType::Integer | ExpressionType::Float | ExpressionType::String | ExpressionType::Null));

data/ext/gqliterb/vendor/gqlitedb/src/functions/value.rs

@@ -1,6 +1,6 @@
 use crate::prelude::*;
 
-use super::{ExpressionType, FResult, FunctionTypeTrait};
+use super::{ExpressionType, FResult};
 
 #[derive(Debug, Default)]
 pub(super) struct HasLabel {}

data/ext/gqliterb/vendor/gqlitedb/src/functions.rs

@@ -143,6 +143,8 @@ impl Manager
           math::Rand::new(),
           node::Labels::new(),
           path::Length::new(),
+          path::Nodes::new(),
+          path::Edges::new(),
           scalar::Coalesce::new(),
           scalar::Properties::new(),
           scalar::ToInteger::new(),
@@ -155,34 +157,29 @@ impl Manager
       .into(),
     }
   }
-  pub(crate) fn get_function<E: error::GenericErrors>(
-    &self,
-    name: impl Into<String>,
-  ) -> Result<Function>
+  pub(crate) fn get_function<E: error::GenericErrors>(&self, name: &str) -> Result<Function>
   {
-    let name = name.into();
     Ok(
       self
         .inner
         .read()?
         .functions
-        .get(&name)
+        .get(&name.to_lowercase())
         .ok_or_else(|| E::unknown_function(name).into())?
         .clone(),
     )
   }
   pub(crate) fn get_aggregator<E: error::GenericErrors>(
     &self,
-    name: impl Into<String>,
+    name: &str,
   ) -> Result<aggregators::Aggregator>
   {
-    let name = name.into();
     Ok(
       self
         .inner
         .read()?
         .aggregators
-        .get(&name)
+        .get(&name.to_lowercase())
         .ok_or_else(|| E::unknown_function(name).into())?
         .clone(),
     )
@@ -190,13 +187,13 @@ impl Manager
   pub(crate) fn is_deterministic(&self, name: impl Into<String>) -> Result<bool>
   {
     let name = name.into();
-    let fun = self.get_function::<crate::error::CompileTimeError>(name.clone());
+    let fun = self.get_function::<crate::error::CompileTimeError>(&name);
     match fun
     {
       Ok(fun) => Ok(fun.is_deterministic()),
       Err(_) =>
       {
-        self.get_aggregator::<crate::error::CompileTimeError>(name)?;
+        self.get_aggregator::<crate::error::CompileTimeError>(&name)?;
         Ok(false)
       }
     }
@@ -213,12 +210,12 @@ impl Manager
   ) -> Result<ExpressionType>
   {
     let name = name.into();
-    let fun = self.get_function::<crate::error::CompileTimeError>(name.clone());
+    let fun = self.get_function::<crate::error::CompileTimeError>(&name);
     match fun
     {
       Ok(fun) => fun.validate_arguments(arguments),
       Err(_) => self
-        .get_aggregator::<crate::error::CompileTimeError>(name)?
+        .get_aggregator::<crate::error::CompileTimeError>(&name)?
         .validate_arguments(arguments),
     }
   }
@@ -288,6 +285,7 @@ macro_rules! default_validate_ {
       -> crate::Result<$crate::compiler::expression_analyser::ExpressionType>
     {
       // TODO
+      use $crate::functions::FunctionTypeTrait;
       Ok(<$ret_type>::result_type())
     }
   };

data/ext/gqliterb/vendor/gqlitedb/src/graph.rs

@@ -99,6 +99,11 @@ impl Node
   {
     (self.key, self.labels, self.properties)
   }
+  /// Convert into value map representation
+  pub fn into_value_map(self) -> value::ValueMap
+  {
+    crate::map!("labels" => self.labels, "properties" => self.properties, "type" => "node")
+  }
 }
 
 impl std::fmt::Display for Node
@@ -159,6 +164,11 @@ impl Edge
   {
     (self.key, self.labels, self.properties)
   }
+  /// Convert into value map representation
+  pub fn into_value_map(self) -> value::ValueMap
+  {
+    crate::map!( "labels" => self.labels, "properties" => self.properties, "type" => "edge")
+  }
 }
 
 impl std::fmt::Display for Edge
@@ -240,6 +250,11 @@ impl Path
       self.destination,
     )
   }
+  /// Convert into value map representation
+  pub fn into_value_map(self) -> value::ValueMap
+  {
+    crate::map!( "source" => self.source, "labels" => self.labels, "properties" => self.properties, "destination" => self.destination, "type" => "path")
+  }
 }
 
 impl std::fmt::Display for Path