gqlite 1.1.0 → 1.2.2

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

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

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

@@ -0,0 +1,8 @@
+pub(crate) use crate::{
+  aggregators, compiler, consts,
+  error::{self, CompileTimeError, InternalError, RunTimeError, StoreError},
+  functions, graph, interpreter, parser, serialize_with, store, utils, value, value_table, Error,
+  Result,
+};
+
+pub(crate) use error::export::Error as ErrorType;

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

@@ -0,0 +1,94 @@
+use serde::de::{self, Visitor};
+use serde::{Deserializer, Serializer};
+use std::fmt;
+
+const NAN: f64 = std::f64::NAN;
+
+pub fn serialize_float<S>(x: &f64, serializer: S) -> Result<S::Ok, S::Error>
+where
+  S: Serializer,
+{
+  if x.is_nan()
+  {
+    serializer.serialize_str("NaN")
+  }
+  else
+  {
+    serializer.serialize_f64(*x)
+  }
+}
+
+struct FloatDeserializeVisitor;
+
+impl<'de> Visitor<'de> for FloatDeserializeVisitor
+{
+  type Value = f64;
+
+  fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result
+  {
+    formatter.write_str("a float or the string \"NaN\"")
+  }
+
+  fn visit_i32<E>(self, v: i32) -> Result<Self::Value, E>
+  where
+    E: de::Error,
+  {
+    Ok(v as f64)
+  }
+
+  fn visit_i64<E>(self, v: i64) -> Result<Self::Value, E>
+  where
+    E: de::Error,
+  {
+    Ok(v as f64)
+  }
+
+  fn visit_u32<E>(self, v: u32) -> Result<Self::Value, E>
+  where
+    E: de::Error,
+  {
+    Ok(v as f64)
+  }
+
+  fn visit_u64<E>(self, v: u64) -> Result<Self::Value, E>
+  where
+    E: de::Error,
+  {
+    Ok(v as f64)
+  }
+
+  fn visit_f32<E>(self, v: f32) -> Result<Self::Value, E>
+  where
+    E: de::Error,
+  {
+    Ok(v as f64)
+  }
+
+  fn visit_f64<E>(self, v: f64) -> Result<Self::Value, E>
+  where
+    E: de::Error,
+  {
+    Ok(v as f64)
+  }
+
+  fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
+  where
+    E: de::Error,
+  {
+    if v == "NaN"
+    {
+      Ok(NAN)
+    }
+    else
+    {
+      Err(E::invalid_value(de::Unexpected::Str(v), &self))
+    }
+  }
+}
+
+pub fn deserialize_float<'de, D>(deserializer: D) -> Result<f64, D::Error>
+where
+  D: Deserializer<'de>,
+{
+  deserializer.deserialize_any(FloatDeserializeVisitor)
+}

data/ext/gqliterb/vendor/gqlitedb/src/store/pgql.rs

@@ -0,0 +1,121 @@
+use crate::{graph, Result};
+
+//  _____                               _   _
+// |_   _| __ __ _ _ __  ___  __ _  ___| |_(_) ___  _ __
+//   | || '__/ _` | '_ \/ __|/ _` |/ __| __| |/ _ \| '_ \
+//   | || | | (_| | | | \__ \ (_| | (__| |_| | (_) | | | |
+//   |_||_|  \__,_|_| |_|___/\__,_|\___|\__|_|\___/|_| |_|
+//
+
+pub(crate) struct Transaction {}
+
+impl Transaction
+{
+  pub(crate) fn commit(&self) -> Result<()>
+  {
+    Ok(())
+  }
+}
+
+//  ____  _
+// / ___|| |_ ___  _ __ ___
+// \___ \| __/ _ \| '__/ _ \
+//  ___) | || (_) | | |  __/
+// |____/ \__\___/|_|  \___|
+
+pub(crate) struct Store {}
+
+impl Store
+{
+  pub(crate) fn new() -> Result<Store>
+  {
+    Ok(Store {})
+  }
+  pub(crate) fn create_graph(&self, name: impl Into<String>) -> Result<()>
+  {
+    Err(InternalError::Unimplemented("pgql"))
+  }
+  pub(crate) fn begin(&self) -> Result<Transaction>
+  {
+    Ok(Transaction {})
+  }
+  pub(crate) fn add_nodes<'a, T: Iterator<Item = &'a crate::graph::Node>>(
+    &self,
+    _: &Transaction,
+    graph_name: impl Into<String>,
+    nodes_iter: T,
+  ) -> Result<()>
+  {
+    Err(InternalError::Unimplemented("pgql"))
+  }
+  /// Select nodes according to a given query
+  pub(crate) fn select_nodes<'a, TKeys, TLabels, TProperties>(
+    &self,
+    _: &Transaction,
+    graph_name: impl Into<String>,
+    query: super::SelectNodeQuery<'a, TKeys, TLabels, TProperties>,
+  ) -> Result<Vec<crate::graph::Node>>
+  where
+    TKeys: Iterator<Item = &'a crate::graph::Key>,
+    TLabels: Iterator<Item = &'a String>,
+    TProperties: Iterator<Item = (&'a String, &'a value::Value)>,
+  {
+    Err(InternalError::Unimplemented("pgql"))
+  }
+  /// Add edge
+  pub(crate) fn add_edges<'a, T: Iterator<Item = &'a crate::graph::Edge>>(
+    &self,
+    _: &Transaction,
+    graph_name: impl Into<String>,
+    edges_iter: T,
+  ) -> Result<()>
+  {
+    Err(InternalError::Unimplemented("pgql"))
+  }
+  /// Select edges
+  pub(crate) fn select_edges<
+    'a,
+    TSourceKeys,
+    TSourceLabels,
+    TSourceProperties,
+    TKeys,
+    TLabels,
+    TProperties,
+    TDestinationKeys,
+    TDestinationLabels,
+    TDestinationProperties,
+  >(
+    &self,
+    _: &Transaction,
+    graph_name: impl Into<String>,
+    query: super::SelectEdgeQuery<
+      'a,
+      TSourceKeys,
+      TSourceLabels,
+      TSourceProperties,
+      TKeys,
+      TLabels,
+      TProperties,
+      TDestinationKeys,
+      TDestinationLabels,
+      TDestinationProperties,
+    >,
+  ) -> Result<Vec<crate::graph::Edge>>
+  where
+    TSourceKeys: Iterator<Item = &'a crate::graph::Key>,
+    TSourceLabels: Iterator<Item = &'a String>,
+    TSourceProperties: Iterator<Item = (&'a String, &'a value::Value)>,
+    TKeys: Iterator<Item = &'a crate::graph::Key>,
+    TLabels: Iterator<Item = &'a String>,
+    TProperties: Iterator<Item = (&'a String, &'a value::Value)>,
+    TDestinationKeys: Iterator<Item = &'a crate::graph::Key>,
+    TDestinationLabels: Iterator<Item = &'a String>,
+    TDestinationProperties: Iterator<Item = (&'a String, &'a value::Value)>,
+  {
+    Err(InternalError::Unimplemented("pgql"))
+  }
+  pub(crate) fn compute_statistics(&self, _: &Transaction) -> Result<super::Statistics>
+  {
+    Err(InternalError::Unimplemented("pgql"))
+  }
+}