gqlite 1.2.2 → 1.3.0

data/ext/gqlitedb/src/connection.rs

@@ -0,0 +1,300 @@
+use std::path::Path;
+
+use crate::{prelude::*, QueryResult};
+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_oc_query(&self, query: &str, parameters: value::ValueMap) -> Result<QueryResult>;
+}
+
+struct ConnectionImpl<TStore>
+where
+  TStore: store::Store + Sync + Send,
+{
+  store: TStore,
+  function_manager: functions::Manager,
+}
+
+impl<TStore> ConnectionTrait for ConnectionImpl<TStore>
+where
+  TStore: store::Store + Sync + Send,
+{
+  fn execute_oc_query(&self, query: &str, parameters: value::ValueMap) -> Result<QueryResult>
+  {
+    let queries = parser::parse(query)?;
+    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 results.len()
+    {
+      0 => Ok(QueryResult::Empty),
+      1 => Ok(results.into_iter().next().unwrap()), // Guarantee to pass since we check for length
+      _ => Ok(QueryResult::Array(results)),
+    }
+  }
+}
+
+impl<TStore: store::Store> ConnectionImpl<TStore>
+where
+  TStore: store::Store + Sync + Send,
+{
+  fn boxed(self) -> Box<Self>
+  {
+    Box::new(self)
+  }
+}
+
+/// Connection is the interface to the database, and allow to execute new queries.
+/// 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::{Backend, Connection, QueryResult};
+/// # fn example() -> gqlitedb::Result<()> {
+/// 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
+/// {
+///   QueryResult::Table(table) =>
+///   {
+///     println!("{:?}", table);
+///   },
+///   _ => {
+///     panic!("Query result should be a table!");
+///   }
+/// }
+/// # Ok(()) }
+/// ```
+pub struct Connection
+{
+  connection: Box<dyn ConnectionTrait>,
+}
+
+ccutils::assert_impl_all!(Connection: Sync, Send);
+
+impl Connection
+{
+  /// Create a new connection to a `GQLite` database. The `options` parameter can
+  /// be used to select the backend, and configure the backend.
+  ///
+  /// Supported parameters:
+  /// - `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 `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.
+  ///
+  /// Example of use, this will create an in-memory database:
+  ///
+  /// ```rust
+  /// # use gqlitedb::Connection;
+  /// # fn example() -> gqlitedb::Result<()> {
+  /// let connection = Connection::create(gqlitedb::value_map!("backend" => "redb"))?;
+  /// # Ok(()) }
+  /// ```  
+  pub fn create(options: value::ValueMap) -> Result<Connection>
+  {
+    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()
+    {
+      "automatic" =>
+      {
+        #[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());
+        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(&vec![sq_e, rb_e]),
+              }
+              .into()
+            })
+          }
+        }
+      }
+      #[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(),
+          }
+          .boxed(),
+        })
+      }
+      #[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()),
+    }
+  }
+  /// Create a builder, with a high-level API to set the options.
+  /// Example of use:
+  /// ```no_run
+  /// # use gqlitedb::{Connection, Backend};
+  /// let connection = Connection::builder().path("path/to/file").backend(Backend::SQLite).create().unwrap();
+  /// ```
+  pub fn builder() -> ConnectionBuilder
+  {
+    ConnectionBuilder {
+      map: Default::default(),
+    }
+  }
+  /// List of available backends
+  pub fn available_backends() -> Vec<String>
+  {
+    vec![
+      #[cfg(feature = "sqlite")]
+      "sqlite".to_string(),
+      #[cfg(feature = "redb")]
+      "redb".to_string(),
+    ]
+  }
+
+  /// Execute the `query` (using OpenCypher), given the query `parameters` (sometimes
+  /// also referred as binding).
+  ///
+  /// Example:
+  ///
+  /// ```rust
+  /// # use gqlitedb::{Backend, Connection, Value};
+  /// # fn example() -> gqlitedb::Result<()> {
+  /// # 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_oc_query(
+    &self,
+    query: impl AsRef<str>,
+    parameters: value::ValueMap,
+  ) -> Result<QueryResult>
+  {
+    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
@@ -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
@@ -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
@@ -372,11 +390,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
 {
@@ -385,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(),
+    }
+  }
+}
+
 //  _____                   __        ___ _   _     ____             _    _
 // | ____|_ __ _ __ ___  _ _\ \      / (_) |_| |__ | __ )  __ _  ___| | __ |_ _ __ __ _  ___ ___
 // |  _| | '__| '__/ _ \| '__\ \ /\ / /| | __| '_ \|  _ \ / _` |/ __| |/ / __| '__/ _` |/ __/ _ \
@@ -402,12 +437,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 +462,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 +470,8 @@ impl std::fmt::Display for ErrorWithBacktrace
     self.error.fmt(f)
   }
 }
+
+#[cfg(feature = "_backtrace")]
 impl<T> From<T> for ErrorWithBacktrace
 where
   T: Into<Error>,
@@ -459,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()
   }
 }
 
@@ -480,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
 {
@@ -549,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),
@@ -579,7 +651,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 +659,6 @@ impl GenericErrors for CompileTimeError
   {
     Self::UnknownFunction { name: name.into() }
   }
-  fn not_comparable() -> Self
-  {
-    Self::NotComparable
-  }
 }
 
 impl GenericErrors for RunTimeError
@@ -600,10 +667,6 @@ impl GenericErrors for RunTimeError
   {
     Self::UnknownFunction { name: name.into() }
   }
-  fn not_comparable() -> Self
-  {
-    Self::NotComparable
-  }
 }
 
 /// GQLite Result