gqlite 1.2.2 → 1.3.0

data/ext/gqliterb/vendor/gqlitedb/Cargo.toml

@@ -1,132 +0,0 @@
-# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO
-#
-# When uploading crates to the registry Cargo will automatically
-# "normalize" Cargo.toml files for maximal compatibility
-# with all versions of Cargo and also rewrite `path` dependencies
-# to registry (e.g., crates.io) dependencies.
-#
-# If you are reading this file be aware that the original Cargo.toml
-# will likely look very different (and much more reasonable).
-# See Cargo.toml.orig for the original contents.
-
-[package]
-edition = "2021"
-name = "gqlitedb"
-version = "0.5.2"
-build = false
-autolib = false
-autobins = false
-autoexamples = false
-autotests = false
-autobenches = false
-description = "GQLite is a Rust-language library, with a C interface, that implements a small, fast, self-contained, high-reliability, full-featured, Graph Query database engine."
-homepage = "https://gqlite.org"
-readme = "README.md"
-license = "MIT"
-repository = "https://gitlab.com/gqlite/gqlite"
-
-[features]
-_backtrace = []
-_pg13 = ["pgrx/pg13"]
-_pg14 = ["pgrx/pg14"]
-_pg15 = ["pgrx/pg15"]
-_pg16 = ["pgrx/pg16"]
-_pg17 = ["pgrx/pg17"]
-_pgql = ["dep:pgrx"]
-capi = []
-default = [
-    "redb",
-    "capi",
-    "sqlite",
-]
-redb = ["dep:redb"]
-sqlite = [
-    "dep:rusqlite",
-    "dep:askama",
-]
-
-[lib]
-name = "gqlitedb"
-crate-type = [
-    "cdylib",
-    "lib",
-]
-path = "src/lib.rs"
-
-[[bench]]
-name = "pokec_divan"
-path = "benches/pokec_divan.rs"
-harness = false
-
-[[bench]]
-name = "pokec_iai"
-path = "benches/pokec_iai.rs"
-harness = false
-
-[dependencies.askama]
-version = "0.14"
-optional = true
-
-[dependencies.ccutils]
-version = "0.3"
-features = [
-    "sync",
-    "pool",
-]
-
-[dependencies.ciborium]
-version = "0.2"
-
-[dependencies.itertools]
-version = "0.14"
-
-[dependencies.pest]
-version = "2"
-
-[dependencies.pest_derive]
-version = "2"
-
-[dependencies.pgrx]
-version = "0.15"
-optional = true
-
-[dependencies.rand]
-version = "0.9"
-
-[dependencies.redb]
-version = "2"
-optional = true
-
-[dependencies.rusqlite]
-version = "0.37"
-features = [
-    "functions",
-    "uuid",
-]
-optional = true
-
-[dependencies.serde]
-version = "1"
-
-[dependencies.serde_json]
-version = "1"
-
-[dependencies.thiserror]
-version = "2"
-
-[dependencies.uuid]
-version = "1"
-features = ["v4"]
-
-[dev-dependencies.ccutils]
-version = "0.3"
-features = ["temporary"]
-
-[dev-dependencies.divan]
-version = "0.1"
-
-[dev-dependencies.iai-callgrind]
-version = "0.16"
-
-[dev-dependencies.regex]
-version = "1"

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

@@ -1,208 +0,0 @@
-use crate::prelude::*;
-use value::ValueTryIntoRef;
-
-trait ConnectionTrait: Sync + Send
-{
-  fn execute_query(&self, query: String, parameters: value::ValueMap) -> Result<value::Value>;
-}
-
-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_query(&self, query: String, parameters: value::ValueMap) -> Result<value::Value>
-  {
-    let query_txt: String = query.into();
-    let queries = parser::parse(query_txt.as_str())?;
-    let mut results = Vec::<value::Value>::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);
-      }
-    }
-    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())
-      }
-    }
-  }
-}
-
-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::open] and queried with [Connection::execute_query].
-/// As shown in the example bellow:
-///
-/// ```rust
-/// # use gqlitedb::{Connection, Value};
-/// # 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())?;
-/// match value
-/// {
-///   Value::Array(arr) =>
-///   {
-///     arr.iter().for_each(|row| match row
-///     {
-///       Value::Array(arr) =>
-///       {
-///         println!("{:?}", arr);
-///       }
-///       _ =>
-///       {
-///         panic!("Unexpected: {}", row);
-///       }
-///     });
-///   },
-///   _ => {
-///     panic!("Query result should be an array, got {}!", value);
-///   }
-/// }
-/// # Ok(()) }
-/// ```
-
-pub struct Connection
-{
-  connection: Box<dyn ConnectionTrait>,
-}
-
-ccutils::assert_impl_all!(Connection: Sync, Send);
-
-impl 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"))]
-  pub fn open<P: AsRef<std::path::Path>>(path: P, options: value::ValueMap) -> Result<Connection>
-  {
-    if let Some(backend) = options.get("backend")
-    {
-      let backend: &String = backend.try_into_ref()?;
-      match backend.as_str()
-      {
-        "sqlite" => Self::open_sqlite(path),
-        "redb" => Self::open_redb(path),
-        _ => Err(
-          StoreError::UnknownBackend {
-            backend: backend.to_owned(),
-          }
-          .into(),
-        ),
-      }
-    }
-    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]),
-          }
-          .into()
-        })
-      })
-    }
-  }
-  #[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")]
-  fn open_redb<P: AsRef<std::path::Path>>(path: P) -> Result<Connection>
-  {
-    Ok(Connection {
-      connection: ConnectionImpl {
-        store: store::redb::Store::new(path)?,
-        function_manager: functions::Manager::new(),
-      }
-      .boxed(),
-    })
-  }
-  #[cfg(not(feature = "redb"))]
-  fn open_redb<P: AsRef<std::path::Path>>(_: P) -> Result<Connection>
-  {
-    Err(error::StoreError::UnavailableBackend { backend: "redb" }.into())
-  }
-  #[cfg(feature = "_pgql")]
-  pub fn create() -> Result<Connection>
-  {
-    Ok(Connection {
-      store: store::Store::new()?,
-    })
-  }
-  /// Execute the `query` (using OpenCypher), given the query `parameters` (sometimes
-  /// also referred as binding).
-  ///
-  /// Example:
-  ///
-  /// ```rust
-  /// # use gqlitedb::{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"))?;
-  /// # Ok(()) }
-  /// ```
-  pub fn execute_query(
-    &self,
-    query: impl Into<String>,
-    parameters: value::ValueMap,
-  ) -> Result<value::Value>
-  {
-    self.connection.execute_query(query.into(), parameters)
-  }
-}

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

@@ -1,48 +0,0 @@
-use super::ExpressionType;
-use crate::prelude::*;
-
-#[derive(Debug, Default)]
-pub(super) struct Length {}
-
-impl super::FunctionTrait for Length
-{
-  fn call(&self, arguments: Vec<value::Value>) -> crate::Result<value::Value>
-  {
-    let container = arguments
-      .first()
-      .ok_or_else(|| RunTimeError::InvalidNumberOfArguments {
-        function_name: "length",
-        got: arguments.len(),
-        expected: 1,
-      })?;
-
-    match container
-    {
-      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(),
-        )
-      }
-    }
-  }
-  fn validate_arguments(&self, _: Vec<ExpressionType>) -> crate::Result<ExpressionType>
-  {
-    Ok(ExpressionType::Variant)
-  }
-  fn is_deterministic(&self) -> bool
-  {
-    true
-  }
-}
-
-super::declare_function!(length, Length, custom_trait);

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

@@ -1,4 +0,0 @@
-pub(crate) mod ast;
-pub(crate) mod parser;
-
-pub(crate) use parser::parse;