gqlite 1.2.0 → 1.2.2

data/ext/gqliterb/vendor/gqlitedb/src/aggregators/containers.rs

@@ -0,0 +1,33 @@
+use super::AggregatorState;
+
+use crate::{value::Value, Result};
+
+#[derive(Debug)]
+struct CollectState
+{
+  value: Vec<Value>,
+}
+
+impl CollectState
+{
+  fn new() -> Result<Self>
+  {
+    Ok(Self {
+      value: Default::default(),
+    })
+  }
+}
+impl AggregatorState for CollectState
+{
+  fn next(&mut self, value: Value) -> crate::Result<()>
+  {
+    self.value.push(value);
+    Ok(())
+  }
+  fn finalise(self: Box<Self>) -> crate::Result<crate::value::Value>
+  {
+    Ok(self.value.into())
+  }
+}
+
+super::declare_aggregator!(collect, Collect, CollectState, () -> i64);

data/ext/gqliterb/vendor/gqlitedb/src/aggregators/count.rs

@@ -0,0 +1,35 @@
+use super::AggregatorState;
+
+use crate::Result;
+
+#[derive(Debug)]
+struct CountState
+{
+  count: i64,
+}
+
+impl CountState
+{
+  fn new() -> Result<Self>
+  {
+    Ok(Self { count: 0 })
+  }
+}
+
+impl AggregatorState for CountState
+{
+  fn next(&mut self, value: crate::value::Value) -> crate::Result<()>
+  {
+    if !value.is_null()
+    {
+      self.count += 1;
+    }
+    Ok(())
+  }
+  fn finalise(self: Box<Self>) -> crate::Result<crate::value::Value>
+  {
+    Ok(self.count.into())
+  }
+}
+
+super::declare_aggregator!(count, Count, CountState, () -> i64);

data/ext/gqliterb/vendor/gqlitedb/src/aggregators/stats.rs

@@ -0,0 +1,168 @@
+use std::fmt::Debug;
+
+use super::AggregatorState;
+
+use crate::{
+  error::{InternalError, RunTimeError},
+  value::Value,
+  Result,
+};
+
+#[derive(Debug)]
+struct AvgState
+{
+  value: Value,
+  count: usize,
+}
+
+impl AvgState
+{
+  fn new() -> Result<Self>
+  {
+    Ok(Self {
+      value: Value::Null,
+      count: 0,
+    })
+  }
+}
+
+impl AggregatorState for AvgState
+{
+  fn next(&mut self, value: Value) -> crate::Result<()>
+  {
+    if self.value.is_null()
+    {
+      self.value = value;
+    }
+    else
+    {
+      match value
+      {
+        Value::Null =>
+        {}
+        Value::Integer(i) =>
+        {
+          self.count += 1;
+          match self.value
+          {
+            Value::Integer(vi) => self.value = (vi + i).into(),
+            Value::Float(vf) => self.value = (vf + i as f64).into(),
+            _ => Err(InternalError::InvalidAggregationState)?,
+          }
+        }
+        Value::Float(f) =>
+        {
+          self.count += 1;
+          match self.value
+          {
+            Value::Integer(vi) => self.value = (vi as f64 + f).into(),
+            Value::Float(vf) => self.value = (vf + f).into(),
+            _ => Err(InternalError::InvalidAggregationState)?,
+          }
+        }
+        _ => Err(RunTimeError::InvalidArgumentType)?,
+      }
+    }
+    Ok(())
+  }
+  fn finalise(self: Box<Self>) -> crate::Result<crate::value::Value>
+  {
+    match self.value
+    {
+      Value::Null => Ok(Value::Null),
+      Value::Integer(vi) => Ok((vi / self.count as i64).into()),
+      Value::Float(vf) => Ok((vf / self.count as f64).into()),
+      _ => Err(InternalError::InvalidAggregationState)?,
+    }
+  }
+}
+
+super::declare_aggregator!(avg, Avg, AvgState, () -> Value);
+
+#[derive(Debug)]
+struct MinState
+{
+  value: Value,
+}
+
+impl MinState
+{
+  fn new() -> Result<Self>
+  {
+    Ok(Self { value: Value::Null })
+  }
+}
+
+impl AggregatorState for MinState
+{
+  fn next(&mut self, value: Value) -> crate::Result<()>
+  {
+    if self.value.is_null()
+    {
+      self.value = value;
+    }
+    else if !value.is_null()
+    {
+      match value.orderability(&self.value)
+      {
+        std::cmp::Ordering::Less =>
+        {
+          self.value = value;
+        }
+        _ =>
+        {}
+      }
+    }
+    Ok(())
+  }
+  fn finalise(self: Box<Self>) -> crate::Result<crate::value::Value>
+  {
+    Ok(self.value)
+  }
+}
+
+super::declare_aggregator!(min, Min, MinState, () -> i64);
+
+#[derive(Debug)]
+struct MaxState
+{
+  value: Value,
+}
+
+impl MaxState
+{
+  fn new() -> Result<Self>
+  {
+    Ok(Self { value: Value::Null })
+  }
+}
+
+impl AggregatorState for MaxState
+{
+  fn next(&mut self, value: Value) -> crate::Result<()>
+  {
+    if self.value.is_null()
+    {
+      self.value = value;
+    }
+    else if !value.is_null()
+    {
+      match value.orderability(&self.value)
+      {
+        std::cmp::Ordering::Greater =>
+        {
+          self.value = value;
+        }
+        _ =>
+        {}
+      }
+    }
+    Ok(())
+  }
+  fn finalise(self: Box<Self>) -> crate::Result<crate::value::Value>
+  {
+    Ok(self.value)
+  }
+}
+
+super::declare_aggregator!(max, Max, MaxState, () -> i64);

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

@@ -0,0 +1,74 @@
+mod arithmetic;
+mod containers;
+mod count;
+mod stats;
+
+use std::{fmt::Debug, sync::Arc};
+
+use crate::prelude::*;
+use compiler::expression_analyser::ExpressionType;
+
+pub(crate) trait AggregatorState: Debug
+{
+  fn next(&mut self, expression: value::Value) -> Result<()>;
+  fn finalise(self: Box<Self>) -> Result<value::Value>;
+}
+
+pub(crate) trait AggregatorTrait: Debug + Sync + Send
+{
+  fn create(&self, arguments: Vec<value::Value>) -> Result<Box<dyn AggregatorState>>;
+  fn validate_arguments(&self, arguments: Vec<ExpressionType>) -> Result<ExpressionType>;
+}
+
+pub(crate) type Aggregator = Arc<Box<dyn AggregatorTrait>>;
+
+macro_rules! declare_aggregator {
+  ($function_name: ident, $type_name: ident, $state_type_name: tt, (  $( $arg_type: ty $(,)? )* ) -> $ret_type: ty) => {
+    #[derive(Debug)]
+    pub(super) struct $type_name {}
+    impl $type_name
+    {
+      pub(crate) fn new() -> (String, crate::aggregators::Aggregator)
+      {
+        (
+          stringify!($function_name).to_string(),
+          std::sync::Arc::new(Box::new(Self {})),
+        )
+      }
+    }
+    impl crate::aggregators::AggregatorTrait for $type_name
+    {
+      #[allow(unused_variables)]
+      fn create(&self, arguments: Vec<crate::value::Value>) -> Result<Box<dyn AggregatorState>>
+      {
+        Ok(Box::new($crate::functions::make_function_call!($function_name, $state_type_name::new, arguments, $( $arg_type,)*)?))
+      }
+      #[allow(unused_variables)]
+      fn validate_arguments(
+        &self,
+        arguments: Vec<$crate::compiler::expression_analyser::ExpressionType>,
+      ) -> Result<$crate::compiler::expression_analyser::ExpressionType>
+      {
+        use crate::functions::FunctionTypeTrait;
+        // TODO
+        Ok(<$ret_type>::result_type())
+      }
+
+    }
+  };
+}
+
+pub(crate) use declare_aggregator;
+
+pub(crate) fn init_aggregators() -> std::collections::HashMap<String, Aggregator>
+{
+  [
+    count::Count::new(),
+    arithmetic::Sum::new(),
+    containers::Collect::new(),
+    stats::Avg::new(),
+    stats::Min::new(),
+    stats::Max::new(),
+  ]
+  .into()
+}

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

@@ -0,0 +1,236 @@
+use std::borrow::Borrow;
+
+fn handle_error<T, E: std::borrow::Borrow<E> + ToString>(
+  context: *mut GqliteApiContextT,
+  result: Result<T, E>,
+) -> Result<T, E>
+{
+  match &result
+  {
+    Ok(_) =>
+    {}
+    Err(e) =>
+    {
+      let mut context = unsafe { Box::from_raw(context) };
+      context.string = std::ffi::CString::new(e.borrow().to_string()).unwrap();
+      context.has_error = true;
+      let _ = Box::into_raw(context);
+    }
+  }
+  result
+}
+
+fn get_value(value: *mut GqliteValueT) -> crate::value::Value
+{
+  if value.is_null()
+  {
+    crate::value::Value::default()
+  }
+  else
+  {
+    let value = unsafe { Box::from_raw(value) };
+    let v = value.value.clone();
+    let _ = Box::into_raw(value);
+    v
+  }
+}
+
+fn check_error(context: *mut GqliteApiContextT)
+{
+  if unsafe { (*context).has_error }
+  {
+    let context = unsafe { Box::from_raw(context) };
+    let stri = context.string.to_str().unwrap();
+    println!("Error message '{stri:?}' was not cleared from context!");
+    let _ = Box::into_raw(context);
+  }
+}
+
+#[repr(C)]
+pub struct GqliteApiContextT
+{
+  string: std::ffi::CString,
+  has_error: bool,
+}
+
+#[repr(C)]
+pub struct GqliteConnectionT
+{
+  connection: crate::Connection,
+}
+
+#[repr(C)]
+pub struct GqliteValueT
+{
+  value: crate::value::Value,
+}
+
+#[no_mangle]
+pub extern "C" fn gqlite_api_context_create() -> *mut GqliteApiContextT
+{
+  Box::into_raw(Box::new(GqliteApiContextT {
+    string: std::ffi::CString::new("").unwrap(),
+    has_error: false,
+  }))
+}
+
+#[no_mangle]
+pub extern "C" fn gqlite_api_context_destroy(context: *mut GqliteApiContextT)
+{
+  unsafe {
+    let _ = Box::from_raw(context);
+  }
+}
+
+#[no_mangle]
+pub extern "C" fn gqlite_api_context_get_message(
+  context: *mut GqliteApiContextT,
+) -> *const std::ffi::c_char
+{
+  unsafe { (*context).string.as_ptr() }
+}
+
+#[no_mangle]
+pub extern "C" fn gqlite_api_context_has_error(context: *mut GqliteApiContextT) -> bool
+{
+  unsafe { (*context).has_error }
+}
+
+#[no_mangle]
+pub extern "C" fn gqlite_api_context_clear_error(context: *mut GqliteApiContextT)
+{
+  let mut context = unsafe { Box::from_raw(context) };
+  context.has_error = false;
+  let _ = Box::into_raw(context);
+}
+
+#[no_mangle]
+pub extern "C" fn gqlite_connection_create_from_file(
+  context: *mut GqliteApiContextT,
+  filename: *const std::ffi::c_char,
+  options: *mut GqliteValueT,
+) -> *mut GqliteConnectionT
+{
+  check_error(context);
+  let options = get_value(options);
+  let path = unsafe { std::ffi::CStr::from_ptr(filename) };
+  if let Ok(path) = handle_error(context, path.to_str())
+  {
+    if let Ok(c) = handle_error(context, crate::Connection::open(path, options.into_map()))
+    {
+      return Box::into_raw(Box::new(GqliteConnectionT { connection: c }));
+    }
+  }
+  std::ptr::null::<GqliteConnectionT>() as *mut GqliteConnectionT
+}
+
+#[no_mangle]
+pub extern "C" fn gqlite_connection_destroy(
+  _context: *mut GqliteApiContextT,
+  connection: *mut GqliteConnectionT,
+)
+{
+  unsafe {
+    let _ = Box::from_raw(connection);
+  }
+}
+
+#[no_mangle]
+pub extern "C" fn gqlite_connection_query(
+  context: *mut GqliteApiContextT,
+  connection: *mut GqliteConnectionT,
+  query: *const std::ffi::c_char,
+  bindings: *mut GqliteValueT,
+) -> *mut GqliteValueT
+{
+  check_error(context);
+  let query = unsafe { std::ffi::CStr::from_ptr(query) };
+  if let Ok(query) = handle_error(context, query.to_str())
+  {
+    let conn = unsafe { Box::from_raw(connection) };
+    let result = conn
+      .connection
+      .execute_query(query, get_value(bindings).into_map());
+    let _ = Box::into_raw(conn);
+    if let Ok(v) = handle_error(context, result)
+    {
+      return Box::into_raw(Box::new(GqliteValueT { value: v }));
+    }
+  }
+  std::ptr::null::<GqliteValueT>() as *mut GqliteValueT
+}
+
+#[no_mangle]
+pub extern "C" fn gqlite_value_create(context: *mut GqliteApiContextT) -> *mut GqliteValueT
+{
+  check_error(context);
+  Box::into_raw(Box::new(GqliteValueT {
+    value: crate::value::Value::default(),
+  }))
+}
+
+#[no_mangle]
+pub extern "C" fn gqlite_value_destroy(context: *mut GqliteApiContextT, value: *mut GqliteValueT)
+{
+  check_error(context);
+  unsafe {
+    let _ = Box::from_raw(value);
+  }
+}
+
+#[no_mangle]
+pub extern "C" fn gqlite_value_to_json(
+  context: *mut GqliteApiContextT,
+  value: *mut GqliteValueT,
+) -> *const std::ffi::c_char
+{
+  check_error(context);
+
+  let value = unsafe { Box::from_raw(value) };
+
+  if let Ok(v) = handle_error(context, serde_json::to_string(value.value.borrow()))
+  {
+    let mut context = unsafe { Box::from_raw(context) };
+    context.string = std::ffi::CString::new(v).unwrap();
+    context.has_error = false;
+    let r = context.string.as_ptr();
+    let _ = Box::into_raw(context);
+    let _ = Box::into_raw(value);
+    return r;
+  }
+  let _ = Box::into_raw(value);
+  return std::ptr::null();
+}
+
+#[no_mangle]
+pub extern "C" fn gqlite_value_from_json(
+  context: *mut GqliteApiContextT,
+  json: *const std::ffi::c_char,
+) -> *mut GqliteValueT
+{
+  check_error(context);
+
+  let json = unsafe { std::ffi::CStr::from_ptr(json) };
+  if let Ok(json) = handle_error(context, json.to_str())
+  {
+    if let Ok(v) = handle_error(context, serde_json::from_str::<crate::value::Value>(json))
+    {
+      return Box::into_raw(Box::new(GqliteValueT { value: v }));
+    }
+  }
+  return std::ptr::null::<GqliteValueT>() as *mut GqliteValueT;
+}
+
+#[no_mangle]
+pub extern "C" fn gqlite_value_is_valid(
+  context: *mut GqliteApiContextT,
+  value: *mut GqliteValueT,
+) -> bool
+{
+  check_error(context);
+  match unsafe { (*value).value.borrow() }
+  {
+    crate::value::Value::Null => false,
+    _ => true,
+  }
+}