gqlite 0.9

data/ext/gqlite/gqlite-c.h

@@ -0,0 +1,90 @@
+#pragma once
+
+#include <stdbool.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * The context is needed for most call to the API, it currently is mainly used to handle error reporting.
+ * It also manage the memory for any string value returned by the API.
+ */
+typedef struct gqlite_api_context* gqlite_api_context_t;
+
+/**
+ * Connection to the database.
+ */
+typedef struct gqlite_connection* gqlite_connection_t;
+
+/**
+ * Represent a value (integer, double, string, map, array).
+ */
+typedef struct gqlite_value* gqlite_value_t;
+
+/**
+ * Create a new context.
+ */
+gqlite_api_context_t gqlite_api_context_create();
+/**
+ * Free context memory.
+ */
+void gqlite_api_context_destroy(gqlite_api_context_t);
+/**
+ * Return the error message. The memory is owned by the context,
+ * it will be cleared when the context is freed or after the next function call.
+ */
+const char* gqlite_api_context_get_message(gqlite_api_context_t);
+/**
+ * Return true if an error has occured in the last call.
+ */
+bool gqlite_api_context_has_error(gqlite_api_context_t);
+/**
+ * Clear the error message.
+ */
+void gqlite_api_context_clear_error(gqlite_api_context_t);
+
+/**
+ * Create a connection, using the sqlite backend. Expect as argument an handle to a sqlite connection.
+ */
+gqlite_connection_t gqlite_connection_create_from_sqlite(gqlite_api_context_t, void* _handle, gqlite_value_t _options);
+
+/**
+ * Create a connection, using the sqlite backend. Using the database specified by the filename.
+ */
+gqlite_connection_t gqlite_connection_create_from_sqlite_file(gqlite_api_context_t, const char* _filename, gqlite_value_t _options);
+
+/**
+ * Destroy the connection. Does not delete any connection handle passed as an argument.
+ */
+void gqlite_connection_destroy(gqlite_api_context_t, gqlite_connection_t);
+
+/**
+ * Execute an OpenCypher query on the connection.
+ * Return a null value if an error has occured during execution.
+ */
+gqlite_value_t gqlite_connection_oc_query(gqlite_api_context_t, gqlite_connection_t, const char*, gqlite_value_t);
+
+/**
+ * Create a value object to use in a query.
+ */
+gqlite_value_t gqlite_value_create(gqlite_api_context_t);
+
+/**
+ * Destroy a value.
+ */
+void gqlite_value_destroy(gqlite_api_context_t, gqlite_value_t);
+
+/**
+ * Convert value to json. The returned string is only valid until the next API call with the given context.
+ */
+const char* gqlite_value_to_json(gqlite_api_context_t, gqlite_value_t);
+
+/**
+ * Check if the value is valid.
+ */
+bool gqlite_value_is_valid(gqlite_api_context_t, gqlite_value_t);
+
+#ifdef __cplusplus
+}
+#endif

data/ext/gqlite/gqlite.h

@@ -0,0 +1,152 @@
+#pragma once
+
+#include <exception>
+#include <memory>
+#include <string>
+#include <unordered_map>
+#include <vector>
+
+namespace gqlite
+{
+  class backend;
+  struct debug_stats;
+  /**
+   * Represents an error that occurs during the execution of a query.
+   */
+  class exception : public std::exception
+  {
+  public:
+    exception(const std::string& _error) : m_error(_error), m_c_error(m_error.c_str()) {}
+    exception(const char* _error) : m_c_error(_error) {}
+    template<typename _T_, typename... _TOther_>
+    inline exception(const char* _format, const _T_& _value, const _TOther_&... _other);
+    template<typename _T_, typename... _TOther_>
+    inline exception(const std::string& _format, const _T_& _value, const _TOther_&... _other);
+    exception(const exception& _rhs);
+    exception& operator=(const exception& _rhs);
+    /**
+     * @return the error message
+     */
+    const char* what() const throw() override
+    {
+      return m_c_error;
+    }
+  private:
+    std::string m_error;
+    const char* m_c_error;
+  };
+  /**
+   * Represent the value type.
+   */
+  enum class value_type
+  {
+    invalid,
+    boolean,
+    integer,
+    number, ///< aka float
+    string,
+    map,
+    vector
+  };
+  class value;
+  using value_map = std::unordered_map<std::string, value>;
+  using value_vector = std::vector<value>;
+  /**
+   * Represent a value (boolean, integer, number, string, map or vector)
+   */
+  class value
+  {
+  public:
+    value();
+    value(const value& _rhs);
+    value& operator=(const value& _rhs);
+    ~value();
+  public:
+    value(int _v);
+    value(double _v);
+    value(const std::string& _v);
+    value(const value_map& _v);
+    /// not part of the public API
+    template<typename _T_>
+    value(const std::initializer_list<typename std::unordered_map<std::string, _T_>::value_type>& _v);
+    value(const value_vector& _v);
+    /// not part of the public API
+    template<typename _T_>
+    value(const std::vector<_T_>& _v);
+    bool operator==(const value& _rhs) const;
+  public:
+    /**
+     * @return the type hold by this value
+     */
+    value_type get_type() const;
+    /**
+     * Attempt to return a bool. Throw an exception if not possible.
+     */
+    bool to_bool() const;
+    /**
+     * Attempt to return an integer. Throw an exception if not possible.
+     */
+    int to_integer() const;
+    /**
+     * Attempt to return a double. Throw an exception if not possible.
+     */
+    double to_double() const;
+    /**
+     * Attempt to return a string. Throw an exception if not possible.
+     */
+    std::string to_string() const;
+    /**
+     * Attempt to return a map. Throw an exception if not possible.
+     */
+    value_map to_map() const;
+    /**
+     * Attempt to return a vector. Throw an exception if not possible.
+     */
+    value_vector to_vector() const;
+  public:
+    /**
+     * Attempt to return a json string to represent a value.
+     */
+    std::string to_json() const;
+    /**
+     * Construct a value from a json string. Throw an exception if not possible.
+     */
+    static value from_json(const std::string& _json);
+  private:
+    struct data;
+    std::shared_ptr<data> d;
+  };
+  /**
+   * Main class for connecting to a gqlite database.
+   */
+  class connection
+  {
+    connection(backend* _backend);
+  public:
+    connection();
+    connection(const connection& _rhs);
+    connection& operator=(const connection& _rhs);
+    ~connection();
+    /**
+     * Create a sqlite connection from a \p _pointer to a valid sqlite handle.
+     */
+    static connection create_from_sqlite(void* _pointer, const value& _options = value());
+    /**
+     * Create a sqlite connection from a file.
+     */
+    static connection create_from_sqlite_file(const std::string& _filename, const value& _options = value());
+    /**
+     * @internal
+     * Part of the private API, what is returned by this function may change at any time.
+     */
+    gqlite::value get_debug_stats() const;
+  public:
+    /**
+     * Execute a query.
+     */
+    value execute_oc_query(const std::string& _string, const value_map& _variant = {});
+  private:
+    struct data;
+    std::shared_ptr<data> d;
+  };
+}

data/lib/gqlite.rb

@@ -0,0 +1,57 @@
+require 'ffi'
+require 'objspace'
+require 'json'
+
+module Gqlite
+  class Error < StandardError
+  end
+  module CApi
+    extend FFI::Library
+    ffi_lib 'gqlite'
+    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_is_valid, [:pointer, :pointer], :bool
+    ApiError = CApi.gqlite_api_context_create()
+    def CApi.call_function(fname, *args)
+      r = CApi.send fname, ApiError, *args
+      if CApi.gqlite_api_context_has_error(ApiError)
+        err = CApi.gqlite_api_context_get_message ApiError
+        CApi.gqlite_api_context_clear_error ApiError
+        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)
+      ret = CApi.call_function :gqlite_connection_oc_query, @dbhandle, query, nil
+      if CApi.call_function(:gqlite_value_is_valid, ret)
+        val = JSON.parse CApi.call_function :gqlite_value_to_json, ret
+      else
+        ret = nil
+      end
+      CApi.call_function :gqlite_value_destroy, ret
+      return val
+    end
+  end
+end

metadata

@@ -0,0 +1,65 @@
+--- !ruby/object:Gem::Specification
+name: gqlite
+version: !ruby/object:Gem::Version
+  version: '0.9'
+platform: ruby
+authors:
+- Cyrille Berger
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2023-09-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ffi
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+description: |2
+    GQLite aims to be the equivalent to SQLite for graph database: an easy to embedd query engine, with the data stored in a single file. To achieve that, GQLite uses SQLite to store data, and come as a library implementing a translation between graph query languages and SQL.
+
+    This is an experimental release.
+email: 
+executables: []
+extensions:
+- ext/gqlite/extconf.rb
+extra_rdoc_files: []
+files:
+- ext/gqlite/extconf.rb
+- ext/gqlite/gqlite-amalgamate.cpp
+- ext/gqlite/gqlite-c.h
+- ext/gqlite/gqlite.h
+- lib/gqlite.rb
+homepage: https://gitlab.com/cyloncore/gqlite
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.5
+signing_key: 
+specification_version: 4
+summary: Ruby bindings for GQLite, a Graph Query library.
+test_files: []