gqlite 0.9 → 1.1.0

data/ext/gqlite/gqlite-c.h

@@ -80,6 +80,11 @@ void gqlite_value_destroy(gqlite_api_context_t, gqlite_value_t);
  */
 const char* gqlite_value_to_json(gqlite_api_context_t, gqlite_value_t);
 
+/**
+ * Create value from json.
+ */
+gqlite_value_t gqlite_value_from_json(gqlite_api_context_t, const char*);
+
 /**
  * Check if the value is valid.
  */

data/ext/gqlite/gqlite.h

@@ -10,44 +10,35 @@ namespace gqlite
 {
   class backend;
   struct debug_stats;
+  enum class exception_stage;
+  enum class exception_code;
+  struct exception_maker;
+  struct exception_reader;
   /**
    * Represents an error that occurs during the execution of a query.
    */
   class exception : public std::exception
   {
+    friend class exception_maker;
+    friend class exception_reader;
   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(exception&& _rhs);
     exception(const exception& _rhs);
     exception& operator=(const exception& _rhs);
+    ~exception();
     /**
      * @return the error message
      */
-    const char* what() const throw() override
-    {
-      return m_c_error;
-    }
+    const char* what() const throw() override;
   private:
-    std::string m_error;
-    const char* m_c_error;
+    struct data;
+    exception(data* _d);
+    data* const d;
   };
   /**
    * Represent the value type.
    */
-  enum class value_type
-  {
-    invalid,
-    boolean,
-    integer,
-    number, ///< aka float
-    string,
-    map,
-    vector
-  };
+  enum class value_type;
   class value;
   using value_map = std::unordered_map<std::string, value>;
   using value_vector = std::vector<value>;
@@ -62,8 +53,10 @@ namespace gqlite
     value& operator=(const value& _rhs);
     ~value();
   public:
-    value(int _v);
+    value(bool _v);
+    value(int64_t _v);
     value(double _v);
+    value(const char* _v);
     value(const std::string& _v);
     value(const value_map& _v);
     /// not part of the public API
@@ -74,6 +67,7 @@ namespace gqlite
     template<typename _T_>
     value(const std::vector<_T_>& _v);
     bool operator==(const value& _rhs) const;
+    bool operator<(const value& _rhs) const;
   public:
     /**
      * @return the type hold by this value
@@ -86,7 +80,7 @@ namespace gqlite
     /**
      * Attempt to return an integer. Throw an exception if not possible.
      */
-    int to_integer() const;
+    int64_t to_integer() const;
     /**
      * Attempt to return a double. Throw an exception if not possible.
      */
@@ -135,11 +129,6 @@ namespace gqlite
      * 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.

data/lib/gqlite.rb

@@ -2,12 +2,22 @@ require 'ffi'
 require 'objspace'
 require 'json'
 
-module Gqlite
+module GQLite
   class Error < StandardError
   end
   module CApi
     extend FFI::Library
-    ffi_lib 'gqlite'
+
+    # 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
@@ -19,13 +29,14 @@ module Gqlite
     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
-    ApiError = CApi.gqlite_api_context_create()
+    ApiContext = 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
+      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
@@ -44,11 +55,18 @@ module Gqlite
       }
     end
     def execute_oc_query(query, bindings: nil)
-      ret = CApi.call_function :gqlite_connection_oc_query, @dbhandle, query, 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
+        val = JSON.parse(CApi.call_function :gqlite_value_to_json, ret)
       else
-        ret = nil
+        val = nil
       end
       CApi.call_function :gqlite_value_destroy, ret
       return val

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: gqlite
 version: !ruby/object:Gem::Version
-  version: '0.9'
+  version: 1.1.0
 platform: ruby
 authors:
 - Cyrille Berger
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-09-14 00:00:00.000000000 Z
+date: 2024-05-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi
@@ -24,11 +24,26 @@ dependencies:
     - - "~>"
       - !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: 
+description: "GQLite is a C++-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
+  '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
+  () 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"
+email:
 executables: []
 extensions:
 - ext/gqlite/extconf.rb
@@ -39,11 +54,11 @@ files:
 - ext/gqlite/gqlite-c.h
 - ext/gqlite/gqlite.h
 - lib/gqlite.rb
-homepage: https://gitlab.com/cyloncore/gqlite
+homepage: https://gitlab.com/gqlite/gqlite
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -58,8 +73,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.5
-signing_key: 
+rubygems_version: 3.4.20
+signing_key:
 specification_version: 4
 summary: Ruby bindings for GQLite, a Graph Query library.
 test_files: []