gqlite 1.1.0 → 1.2.0

data/ext/gqliterb/Cargo.toml

@@ -0,0 +1,46 @@
+# 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 = "gqliterb"
+version = "0.5.0"
+build = false
+autolib = false
+autobins = false
+autoexamples = false
+autotests = false
+autobenches = false
+homepage = "https://gqlite.org"
+readme = false
+license = "MIT"
+repository = "https://gitlab.com/gqlite/gqlite"
+
+[package.metadata.release]
+release = false
+
+[lib]
+name = "gqliterb"
+crate-type = ["cdylib"]
+path = "src/lib.rs"
+
+[dependencies.gqlitedb]
+version = "0.5.0"
+features = [
+    "_connection_server",
+    "_backtrace",
+]
+
+[dependencies.magnus]
+version = "0.7"
+
+[build-dependencies.rb-sys-env]
+version = "0.2"

data/ext/gqliterb/extconf.rb

@@ -0,0 +1,4 @@
+require "mkmf"
+require "rb_sys/mkmf"
+
+create_rust_makefile "gqliterb"

data/ext/gqliterb/src/lib.rs

@@ -0,0 +1,260 @@
+#![deny(warnings)]
+
+use magnus::{
+  function, method,
+  prelude::*,
+  r_array,
+  r_hash::{self, ForEach},
+  scan_args,
+  value::Lazy,
+  Error, ExceptionClass, Integer, IntoValue, RModule, Ruby, Symbol,
+};
+
+static MODULE: Lazy<RModule> = Lazy::new(|ruby| ruby.define_module("GQLite").unwrap());
+
+static ERROR: Lazy<ExceptionClass> = Lazy::new(|ruby| {
+  ruby
+    .get_inner(&MODULE)
+    .define_error("Error", ruby.exception_standard_error())
+    .unwrap()
+});
+
+fn from_rvalue(ruby: &Ruby, value: magnus::Value) -> Result<gqlitedb::Value, Error>
+{
+  if value.is_nil()
+  {
+    Ok(gqlitedb::Value::Null)
+  }
+  else if value.is_kind_of(ruby.class_integer())
+  {
+    Ok(i64::try_convert(value)?.into())
+  }
+  else if value.is_kind_of(ruby.class_true_class())
+  {
+    Ok(true.into())
+  }
+  else if value.is_kind_of(ruby.class_false_class())
+  {
+    Ok(false.into())
+  }
+  else if value.is_kind_of(ruby.class_float())
+  {
+    Ok(f64::try_convert(value)?.into())
+  }
+  else if value.is_kind_of(ruby.class_string())
+  {
+    Ok(String::try_convert(value)?.into())
+  }
+  else if value.is_kind_of(ruby.class_hash())
+  {
+    Ok(from_rhash(ruby, r_hash::RHash::try_convert(value)?)?.into())
+  }
+  else if value.is_kind_of(ruby.class_array())
+  {
+    Ok(from_rarray(ruby, r_array::RArray::try_convert(value)?)?.into())
+  }
+  else
+  {
+    Err(Error::new(
+      ruby.get_inner(&ERROR),
+      format!(
+        "Cannot convert a value of type '{}' to a GQLite value.",
+        value.class()
+      ),
+    ))
+  }
+}
+
+fn from_rarray(ruby: &Ruby, array: r_array::RArray) -> Result<Vec<gqlitedb::Value>, Error>
+{
+  array
+    .into_iter()
+    .map(|value| from_rvalue(ruby, value))
+    .collect()
+}
+
+fn from_rhash(ruby: &Ruby, hash: r_hash::RHash) -> Result<gqlitedb::ValueMap, Error>
+{
+  let mut vmap = gqlitedb::ValueMap::new();
+  hash.foreach(|key: magnus::Value, value: magnus::Value| {
+    let key = if key.is_kind_of(ruby.class_symbol())
+    {
+      Symbol::try_convert(key)?.name()?.into()
+    }
+    else
+    {
+      String::try_convert(key)?
+    };
+
+    vmap.insert(key, from_rvalue(ruby, value)?);
+    Ok(ForEach::Continue)
+  })?;
+
+  Ok(vmap)
+}
+
+fn integer_from_u128(ruby: &Ruby, i: u128) -> Result<Integer, Error>
+{
+  if i <= u64::MAX as u128
+  {
+    Ok(ruby.integer_from_u64(i as u64))
+  }
+  else
+  {
+    ruby.module_kernel().funcall("Integer", (i.to_string(),))
+  }
+}
+
+fn node_to_rhash(ruby: &Ruby, node: gqlitedb::Node) -> Result<magnus::Value, Error>
+{
+  let r_hash = ruby.hash_new();
+  let (key, labels, properties) = node.unpack();
+  r_hash.aset("type", "node")?;
+  r_hash.aset("key", integer_from_u128(ruby, key.into())?)?;
+  r_hash.aset("labels", labels)?;
+  r_hash.aset("properties", to_rhash(ruby, properties)?)?;
+  Ok(r_hash.into_value())
+}
+
+fn edge_to_rhash(ruby: &Ruby, edge: gqlitedb::Edge) -> Result<magnus::Value, Error>
+{
+  let r_hash = ruby.hash_new();
+  let (key, labels, properties) = edge.unpack();
+  r_hash.aset("type", "edge")?;
+  r_hash.aset("key", integer_from_u128(ruby, key.into())?)?;
+  r_hash.aset("labels", labels)?;
+  r_hash.aset("properties", to_rhash(ruby, properties)?)?;
+  Ok(r_hash.into_value())
+}
+
+fn path_to_rhash(ruby: &Ruby, path: gqlitedb::Path) -> Result<magnus::Value, Error>
+{
+  let r_hash = ruby.hash_new();
+  let (key, source, labels, properties, destination) = path.unpack();
+  r_hash.aset("type", "path")?;
+  r_hash.aset("key", integer_from_u128(ruby, key.into())?)?;
+  r_hash.aset("labels", labels)?;
+  r_hash.aset("properties", to_rhash(ruby, properties)?)?;
+  r_hash.aset("source", node_to_rhash(ruby, source)?)?;
+  r_hash.aset("destination", node_to_rhash(ruby, destination)?)?;
+  Ok(r_hash.into_value())
+}
+
+fn to_rvalue(ruby: &Ruby, val: gqlitedb::Value) -> Result<magnus::Value, Error>
+{
+  match val
+  {
+    gqlitedb::Value::Array(arr) => Ok(to_rarray(ruby, arr)?.into_value()),
+    gqlitedb::Value::Boolean(b) => Ok(b.into_value()),
+    gqlitedb::Value::Integer(i) => Ok(i.into_value()),
+    gqlitedb::Value::Float(f) => Ok(f.into_value()),
+    gqlitedb::Value::String(s) => Ok(s.into_value()),
+    gqlitedb::Value::Map(m) => Ok(to_rhash(ruby, m)?.into_value()),
+    gqlitedb::Value::Null => Ok(ruby.qnil().into_value()),
+    gqlitedb::Value::Edge(e) => Ok(edge_to_rhash(ruby, e)?),
+    gqlitedb::Value::Node(n) => Ok(node_to_rhash(ruby, n)?),
+    gqlitedb::Value::Path(p) => Ok(path_to_rhash(ruby, p)?),
+  }
+}
+
+fn to_rhash(ruby: &Ruby, map: gqlitedb::ValueMap) -> Result<r_hash::RHash, Error>
+{
+  let r_hash = ruby.hash_new();
+  for (key, value) in map.into_iter()
+  {
+    r_hash.aset(key, to_rvalue(ruby, value)?)?;
+  }
+  Ok(r_hash)
+}
+
+fn to_rarray(ruby: &Ruby, arr: Vec<gqlitedb::Value>) -> Result<r_array::RArray, Error>
+{
+  let r_arr = r_array::RArray::with_capacity(arr.len());
+
+  for value in arr.into_iter()
+  {
+    r_arr.push(to_rvalue(ruby, value)?)?;
+  }
+
+  Ok(r_arr)
+}
+
+fn map_err<T>(ruby: &Ruby, result: gqlitedb::Result<T>) -> Result<T, Error>
+{
+  result.map_err(|e| Error::new(ruby.get_inner(&ERROR), format!("{}", e)))
+}
+
+#[magnus::wrap(class = "GQLite::Connection")]
+struct Connection
+{
+  dbhandle: gqlitedb::ConnectionServer,
+}
+
+impl Connection
+{
+  fn new(ruby: &Ruby, args: &[magnus::Value]) -> Result<Self, Error>
+  {
+    let args = scan_args::scan_args::<(), (), (), (), _, ()>(args)?;
+
+    let options = from_rhash(ruby, args.keywords)?;
+
+    let filename: String = map_err(
+      ruby,
+      options
+        .get("filename".into())
+        .ok_or_else(|| Error::new(ruby.get_inner(&ERROR), "Missing filename."))?
+        .to_owned()
+        .try_into(),
+    )?;
+    let dbhandle = map_err(ruby, gqlitedb::ConnectionServer::open(filename, options))?;
+    Ok(Self { dbhandle })
+  }
+  fn execute_oc_query(
+    ruby: &Ruby,
+    rb_self: &Self,
+    args: &[magnus::Value],
+  ) -> Result<magnus::Value, Error>
+  {
+    let args = scan_args::scan_args::<_, (), (), (), _, ()>(args)?;
+    let (query,): (String,) = args.required;
+
+    let kw = scan_args::get_kwargs::<_, (), (Option<magnus::Value>,), ()>(
+      args.keywords,
+      &[],
+      &["bindings"],
+    )?;
+    let (bindings,) = kw.optional;
+
+    let bindings = bindings
+      .map(|bindings| {
+        if bindings.is_nil()
+        {
+          Ok(Default::default())
+        }
+        else
+        {
+          from_rhash(ruby, r_hash::RHash::try_convert(bindings)?)
+        }
+      })
+      .transpose()?
+      .unwrap_or_default();
+    let result = map_err(ruby, rb_self.dbhandle.execute_query(query, bindings))?;
+
+    to_rvalue(ruby, result)
+  }
+}
+
+#[magnus::init]
+fn init(ruby: &Ruby) -> Result<(), Error>
+{
+  Lazy::force(&ERROR, ruby);
+
+  let module = ruby.get_inner(&MODULE);
+  let class = module.define_class("Connection", ruby.class_object())?;
+  class.define_singleton_method("new", function!(Connection::new, -1))?;
+  class.define_method(
+    "execute_oc_query",
+    method!(Connection::execute_oc_query, -1),
+  )?;
+  Ok(())
+}

data/lib/gqlite.rb

@@ -1,75 +1 @@
-require 'ffi'
-require 'objspace'
-require 'json'
-
-module GQLite
-  class Error < StandardError
-  end
-  module CApi
-    extend FFI::Library
-
-    # Attempt to find the gqlite build that is shipped with gem
-    def CApi.get_lib_name()
-      path = "#{File.dirname __FILE__}/#{FFI::Platform::LIBPREFIX}gqlite.#{FFI::Platform::LIBSUFFIX}"
-      return path if File.exist?(path)
-      path = "#{File.dirname __FILE__}/gqlite.#{FFI::Platform::LIBSUFFIX}"
-      return path if File.exist?(path)
-      return "gqlite"
-    end
-
-    ffi_lib CApi.get_lib_name()
-    attach_function :gqlite_api_context_create, [], :pointer
-    attach_function :gqlite_api_context_destroy, [:pointer], :void
-    attach_function :gqlite_api_context_clear_error, [:pointer], :void
-    attach_function :gqlite_api_context_has_error, [:pointer], :bool
-    attach_function :gqlite_api_context_get_message, [:pointer], :string
-    attach_function :gqlite_connection_create_from_sqlite_file, [:pointer, :string, :pointer], :pointer
-    attach_function :gqlite_connection_destroy, [:pointer, :pointer], :void
-    attach_function :gqlite_connection_oc_query, [:pointer, :pointer, :string, :pointer], :pointer
-    attach_function :gqlite_value_create, [:pointer], :pointer
-    attach_function :gqlite_value_destroy, [:pointer, :pointer], :void
-    attach_function :gqlite_value_to_json, [:pointer, :pointer], :string
-    attach_function :gqlite_value_from_json, [:pointer, :string], :pointer
-    attach_function :gqlite_value_is_valid, [:pointer, :pointer], :bool
-    ApiContext = CApi.gqlite_api_context_create()
-    def CApi.call_function(fname, *args)
-      r = CApi.send fname, ApiContext, *args
-      if CApi.gqlite_api_context_has_error(ApiContext)
-        err = CApi.gqlite_api_context_get_message ApiContext
-        CApi.gqlite_api_context_clear_error ApiContext
-        raise Error.new err
-      end
-      return r
-    end
-  end
-  class Connection
-    attr_reader :dbhandle
-    def initialize(sqlite_filename: nil)
-      if sqlite_filename != nil
-        @dbhandle = CApi.call_function :gqlite_connection_create_from_sqlite_file, sqlite_filename, nil
-      else
-        raise Error.new "No connection backend was selected."
-      end
-      ObjectSpace.define_finalizer @dbhandle, proc {|id|
-        CApi.call_function :gqlite_connection_destroy, @dbhandle
-      }
-    end
-    def execute_oc_query(query, bindings: nil)
-      b = nil
-      if bindings
-        b = CApi.call_function :gqlite_value_from_json, bindings.to_json 
-      end
-      ret = CApi.call_function :gqlite_connection_oc_query, @dbhandle, query, b
-      if b
-        CApi.call_function :gqlite_value_destroy, b
-      end
-      if CApi.call_function(:gqlite_value_is_valid, ret)
-        val = JSON.parse(CApi.call_function :gqlite_value_to_json, ret)
-      else
-        val = nil
-      end
-      CApi.call_function :gqlite_value_destroy, ret
-      return val
-    end
-  end
-end
+require 'gqliterb'

metadata

@@ -1,60 +1,73 @@
 --- !ruby/object:Gem::Specification
 name: gqlite
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.2.0
 platform: ruby
 authors:
 - Cyrille Berger
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-05-18 00:00:00.000000000 Z
+date: 2025-07-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: ffi
+  name: rb_sys
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.15'
+        version: 0.9.39
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.15'
-description: "GQLite is a C++-language library, with a C interface, that implements
+        version: 0.9.39
+- !ruby/object:Gem::Dependency
+  name: rake-compiler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.2.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.2.0
+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. The data is stored in a SQLite database, which the fasted and most used
-  SQL database. This enable to achieve high performance and for application to combine
-  Graph queries with traditional SQL queries.\n\nGQLite source code is license under
-  the [MIT License](LICENSE) and is free to everyone to use for any purpose. \n\nThe
-  official repositories contains bindings/APIs for C, C++, Python, Ruby and Crystal.\n\nThe
-  library is still in its early stage, but it is now fully functional. Development
-  effort has now slowed down and new features are added on a by-need basis. It supports
-  a subset of [OpenCypher](https://opencypher.org/), and the intent is to also support
-  ISO GQL in the future when it become available.\n  \nExample of use\n--------------\n\n```ruby\nrequire
+  engine.\nGQLite support multiple database backends, such as SQLite and redb.\nThis
+  enable to achieve high performance and for application to combine Graph queries
+  with traditional SQL queries.\n\nGQLite source code is license under the [MIT License](LICENSE)
+  and is free to everyone to use for any purpose. \n\nThe official repositories contains
+  bindings/APIs for C, C++, Python, Ruby and Crystal.\n\nThe library is still in its
+  early stage, but it is now fully functional. Development effort has now slowed down
+  and new features are added on a by-need basis. It supports a subset of OpenCypher,
+  with some ISO GQL extensions.\n  \nExample of use\n--------------\n\n```ruby\nrequire
   'gqlite'\n\nbegin\n  # Create a database on the file \"test.db\"\n  connection =
-  GQLite::Connection.new sqlite_filename: \"test.db\"\n\n  # Execute a simple query
-  to create a node and return all the nodes\n  value = connection.execute_oc_query(\"CREATE
+  GQLite::Connection.new filename: \"test.db\"\n\n  # Execute a simple query to create
+  a node and return all the nodes\n  value = connection.execute_oc_query(\"CREATE
   () MATCH (n) RETURN n\")\n\n  # Print the result\n  if value.nil?\n    puts \"Empty
   results\"\n  else\n    puts \"Results are #{value.to_s}\"\n  end\nrescue GQLite::Error
   => ex\n  # Report any error\n  puts \"An error has occured: #{ex.message}\"\nend\n\n```\n\nThe
-  documentation for the openCypher query language can found in [openCypher](https://gitlab.com/gqlite/GQLite/-/blob/docs/opencypher.md)
-  and for the [API](https://gitlab.com/gqlite/GQLite/-/blob/docs/api.md).\n\n"
+  documentation for the GQL query language can found in [OpenCypher](https://auksys.org/documentation/5/libraries/gqlite/opencypher/)
+  and for the [API](https://auksys.org/documentation/5/libraries/gqlite/api/).\n\n"
 email:
 executables: []
 extensions:
-- ext/gqlite/extconf.rb
+- ext/gqliterb/extconf.rb
 extra_rdoc_files: []
 files:
-- ext/gqlite/extconf.rb
-- ext/gqlite/gqlite-amalgamate.cpp
-- ext/gqlite/gqlite-c.h
-- ext/gqlite/gqlite.h
+- ext/gqliterb/Cargo.lock
+- ext/gqliterb/Cargo.toml
+- ext/gqliterb/extconf.rb
+- ext/gqliterb/src/lib.rs
 - lib/gqlite.rb
-homepage: https://gitlab.com/gqlite/gqlite
+homepage: https://gitlab.com/auksys/gqlite
 licenses:
 - MIT
 metadata: {}

data/ext/gqlite/extconf.rb

@@ -1,21 +0,0 @@
-require "mkmf"
-
-# Build the gqlite library
-
-# Platforms check
-IS_MSWIN = !RbConfig::CONFIG['host_os'].match(/mswin/).nil?
-IS_MINGW = !RbConfig::CONFIG['host_os'].match(/mingw/).nil?
-IS_DARWIN = !RbConfig::CONFIG['host_os'].match(/darwin/).nil?
-
-# gqlite
-if IS_MSWIN
-  $CXXFLAGS += " /std:c++20 /EHsc /permissive- /bigobj"
-elsif IS_MINGW
-  $CXXFLAGS += " -std=c++20 -Wa,-mbig-obj"
-  $LDFLAGS += " -lsqlite3 "
-else
-  $CXXFLAGS += " -std=c++20"
-  $LDFLAGS += " -lsqlite3 "
-end
-
-create_makefile "gqlite"