arango-driver 3.5.0.alpha0

data/lib/arango/database.rb

@@ -0,0 +1,188 @@
+# === DATABASE ===
+
+module Arango
+  class Database
+    include Arango::Helper::Satisfaction
+    include Arango::Helper::Return
+
+    include Arango::Database::AQLFunctions
+    include Arango::Database::Collections
+    include Arango::Database::FoxxServices
+    include Arango::Database::GraphAccess
+    include Arango::Database::HTTPRoute
+    include Arango::Database::AQLQueries
+    include Arango::Database::AQLQueryCache
+    include Arango::Database::Replication
+    include Arango::Database::StreamTransactions
+    include Arango::Database::Tasks
+    include Arango::Database::Transactions
+    include Arango::Database::ViewAccess
+
+    class << self
+      # Retrieves all databases.
+      # @param server [Arango::Server]
+      # @return [Array<Arango::Database>]
+      def all(server:)
+        result = server.request(get: '_api/database').result
+        result.map{ |db| Arango::Database.new(db, server: server).reload }
+      end
+
+      # Retrieves all databases the current user can access.
+      # @param server [Arango::Server]
+      # @return [Array<Arango::Database>]
+      def all_user_databases(server:)
+        result = server.request(get: '_api/database/user').result
+        result.map{ |db| Arango::Database.new(db, server: server).reload }
+      end
+
+      # Get database from server.
+      # @param name [String] The name of the database
+      # @param server [Arango::Server]
+      # @return [Arango::Database] The instance of the database.
+      def get(name, server:)
+        Arango::Database.new(name, server: server).reload
+      end
+      alias fetch get
+      alias retrieve get
+
+      # Retrieves a list of all databases.
+      # @param server [Arango::Server]
+      # @return [Array<String>] List of database names.
+      def list(server:)
+        server.request(get: '_api/database').result
+      end
+
+      # Retrieves a list of all databases the current user can access.
+      # @param server [Arango::Server]
+      # @return [Array<String>] List of database names.
+      def list_user_databases(server:)
+        server.request(get: '_api/database/user').result
+      end
+
+      # Removes a database.
+      # @param name [String] The name of the database
+      # @param server [Arango::Server]
+      # @return nil
+      def drop(name, server:)
+        server.request(delete: "_api/database/#{name}")
+        nil
+      end
+      alias delete drop
+      alias destroy drop
+
+      # Check if database exists.
+      # @param name [String] Name of the database.
+      # @param server [Arango::Server]
+      # @return [Boolean]
+      def exist?(name, server:)
+        list(server: server).include?(name)
+      end
+    end
+
+    # Instantiate a new database. All params except name and server are optional.
+    # @param name [String]
+    # @param server [Arango::Server]
+    # @param id
+    # @param is_system
+    # @param path
+    # @return [Arango::Database]
+    def initialize(name, id: nil, is_system: false, path: '', server: Arango.current_server)
+      send(:arango_server=, server)
+      @name = name
+      @is_system = is_system
+      @path = path
+      @id = id
+    end
+
+    # Whether or not the current database is the _system database
+    # @return [Boolean]
+    attr_reader :is_system
+
+    # The name of the database
+    # @return [String]
+    attr_reader :name
+
+    # The filesystem path of the current database
+    # @return [String]
+    attr_reader :path
+
+    attr_accessor :arango_server
+
+    # Creates the database on the server.
+    # @return [Arango::Database] self
+    def create
+      # TODO users: users
+      body = { name: @name }
+      @arango_server.request(post: '_api/database', body: body)
+      self
+    end
+
+    # Reload database properties.
+    # @return [Arango::Database] self
+    def reload
+      result = request(get: '_api/database/current')
+      _update_attributes(result.result)
+      self
+    end
+    alias refresh reload
+    alias retrieve reload
+
+    # Remove database from the server.
+    # @return nil
+    def drop
+      self.class.drop(@name, server: @arango_server)
+      nil
+    end
+    alias delete drop
+    alias destroy drop
+
+    # Returns the database version that this server requires.
+    # @return [String]
+    def target_version
+      request(get: '_admin/database/target-version').version
+    end
+
+    def request(get: nil, head: nil, patch: nil, post: nil, put: nil, delete: nil, body: nil, headers: nil, query: nil, block: nil)
+      @arango_server.request(get: get, head: head, patch: patch, post: post, put: put, delete: delete,
+                             db: @name, body: body, headers: headers, query: query, block: block)
+    end
+
+    def execute_request(get: nil, head: nil, patch: nil, post: nil, put: nil, delete: nil, body: nil, headers: nil, query: nil, block: nil)
+      @arango_server.request(get: get, head: head, patch: patch, post: post, put: put, delete: delete,
+                             db: @name, body: body, headers: headers, query: query, block: block)
+    end
+
+    def execute_requests(requests)
+      batch = Arango::RequestBatch.new(database: self)
+      requests.each { |request_h| batch.add_request(**request_h) }
+      batch.execute
+    end
+
+    def batch_request(request_hash)
+      promise = Promise.new
+      request_hash[:promise] = promise
+      batch = _promise_batch
+      batch.add_request(**request_hash)
+      promise
+    end
+
+    def execute_batched_requests
+      batch = @_promise_batch
+      @_promise_batch = nil
+      batch.execute
+      nil
+    end
+
+    private
+
+    def _promise_batch
+      @_promise_batch ||= Arango::RequestBatch.new(database: self)
+    end
+
+    def _update_attributes(result)
+      %i[id isSystem name path].each do |key|
+        instance_variable_set("@#{key.to_s.underscore}", result[key]) if result.key?(key)
+      end
+    end
+  end
+end

data/lib/arango/database/analyzer.rb

@@ -0,0 +1,21 @@
+module Arango
+  class Database
+    module Analyzer
+      def create_analyzer
+
+      end
+
+      def analyzer
+
+      end
+
+      def analyzers
+
+      end
+
+      def delete_analyzer
+
+      end
+    end
+  end
+end

data/lib/arango/database/aql_functions.rb

@@ -0,0 +1,54 @@
+module Arango
+  class Database
+    module AQLFunctions
+
+      def list_aql_functions(namespace: nil)
+        query = nil
+        query = { namespace: namespace } unless namespace.nil?
+        result = execute_request(get: "_api/aqlfunction", query: query)
+        result.result.map { |r| Arango::Result.new(r) }
+      end
+
+      def create_aql_function(name, code: nil, is_deterministic: nil, &block)
+        if block_given?
+          source_block = Parser::CurrentRuby.parse(block.source).children.last
+          source_block = source_block.children.last if source_block.type == :block
+          source_code = Unparser.unparse(source_block)
+          ruby_header = <<~RUBY
+          args = `original_arguments`
+          RUBY
+          compiled_ruby= Opal.compile(ruby_header + source_code, parse_comments: false)
+          if compiled_ruby.start_with?('/*')
+            start_of_code = compiled_ruby.index('*/') + 3
+            compiled_ruby = compiled_ruby[start_of_code..-1]
+          end
+          code = <<~JAVASCRIPT
+          function() {
+            "use strict";
+            require('opal');
+            var original_arguments = Array.prototype.slice.call(arguments);
+            for (var i=0; i<original_arguments.length; i++) {
+              if (typeof original_arguments[i] === "object" && !(original_arguments[i] instanceof Array)) {
+                original_arguments[i] = Opal.Hash.$new(original_arguments[i]);
+              }
+            }
+            var result = #{compiled_ruby}
+            if (typeof result['$to_n'] === "function") { result = result['$to_n'](); }
+            return result;
+          }
+          JAVASCRIPT
+        end
+        body = { code: code, name: name, isDeterministic: is_deterministic }
+        result = execute_request(post: "_api/aqlfunction", body: body)
+        result.response_code == 200 || result.response_code == 201
+      end
+
+      def drop_aql_function(name, group: nil)
+        query = nil
+        query = { group: group } unless group.nil?
+        result = request(delete: "_api/aqlfunction/#{name}", query: query)
+        result.response_code == 200
+      end
+    end
+  end
+end

data/lib/arango/database/aql_queries.rb

@@ -0,0 +1,114 @@
+module Arango
+  class Database
+    module AQLQueries
+      def new_aql(query:, batch_size: nil, bind_vars: nil, cache: nil, count: nil, fail_on_warning: nil, full_count: nil,
+                  intermediate_commit_count: nil, intermediate_commit_size: nil, max_plans: nil, max_transaction_size: nil,
+                  max_warning_count: nil, memory_limit: nil, optimizer_rules: nil, profile: nil, satellite_sync_wait: nil,
+                  skip_inaccessible_collections: nil, ttl: nil, block: nil, &ruby_block)
+        Arango::AQL.new(database: self, query: query, batch_size: batch_size, bind_vars: bind_vars, cache: cache, count: count,
+                        fail_on_warning: fail_on_warning, full_count: full_count, intermediate_commit_count: intermediate_commit_count,
+                        intermediate_commit_size: intermediate_commit_size, max_plans: max_plans, max_transaction_size: max_transaction_size,
+                        max_warning_count: max_warning_count, memory_limit: memory_limit, optimizer_rules: optimizer_rules, profile: profile,
+                        satellite_sync_wait: satellite_sync_wait, skip_inaccessible_collections: skip_inaccessible_collections, ttl: ttl,
+                        block: block, &ruby_block)
+      end
+
+      def new_query(query, batch_size: nil, bind_vars: nil, cache: nil, count: nil, fail_on_warning: nil, full_count: nil,
+                    intermediate_commit_count: nil, intermediate_commit_size: nil, max_plans: nil, max_transaction_size: nil,
+                    max_warning_count: nil, memory_limit: nil, optimizer_rules: nil, profile: nil, satellite_sync_wait: nil,
+                    skip_inaccessible_collections: nil, ttl: nil, block: nil, &ruby_block)
+        Arango::AQL.new(database: self, query: query, batch_size: batch_size, bind_vars: bind_vars, cache: cache, count: count,
+                        fail_on_warning: fail_on_warning, full_count: full_count, intermediate_commit_count: intermediate_commit_count,
+                        intermediate_commit_size: intermediate_commit_size, max_plans: max_plans, max_transaction_size: max_transaction_size,
+                        max_warning_count: max_warning_count, memory_limit: memory_limit, optimizer_rules: optimizer_rules, profile: profile,
+                        satellite_sync_wait: satellite_sync_wait, skip_inaccessible_collections: skip_inaccessible_collections, ttl: ttl,
+                        block: block, &ruby_block)
+      end
+
+      def execute_aql(query:, batch_size: nil, bind_vars: nil, cache: nil, count: nil, fail_on_warning: nil, full_count: nil,
+                      intermediate_commit_count: nil, intermediate_commit_size: nil, max_plans: nil, max_transaction_size: nil,
+                      max_warning_count: nil, memory_limit: nil, optimizer_rules: nil, profile: nil, satellite_sync_wait: nil,
+                      skip_inaccessible_collections: nil, ttl: nil, block: nil, &ruby_block)
+        aql = Arango::AQL.new(database: self, query: query, batch_size: batch_size, bind_vars: bind_vars, cache: cache, count: count,
+                              fail_on_warning: fail_on_warning, full_count: full_count, intermediate_commit_count: intermediate_commit_count,
+                              intermediate_commit_size: intermediate_commit_size, max_plans: max_plans, max_transaction_size: max_transaction_size,
+                              max_warning_count: max_warning_count, memory_limit: memory_limit, optimizer_rules: optimizer_rules, profile: profile,
+                              satellite_sync_wait: satellite_sync_wait, skip_inaccessible_collections: skip_inaccessible_collections, ttl: ttl,
+                              block: block, &ruby_block)
+        aql.execute
+      end
+
+      def execute_query(query, batch_size: nil, bind_vars: nil, cache: nil, count: nil, fail_on_warning: nil, full_count: nil,
+                        intermediate_commit_count: nil, intermediate_commit_size: nil, max_plans: nil, max_transaction_size: nil,
+                        max_warning_count: nil, memory_limit: nil, optimizer_rules: nil, profile: nil, satellite_sync_wait: nil,
+                        skip_inaccessible_collections: nil, ttl: nil, block: nil, &ruby_block)
+        aql = Arango::AQL.new(database: self, query: query, batch_size: batch_size, bind_vars: bind_vars, cache: cache, count: count,
+                              fail_on_warning: fail_on_warning, full_count: full_count, intermediate_commit_count: intermediate_commit_count,
+                              intermediate_commit_size: intermediate_commit_size, max_plans: max_plans, max_transaction_size: max_transaction_size,
+                              max_warning_count: max_warning_count, memory_limit: memory_limit, optimizer_rules: optimizer_rules, profile: profile,
+                              satellite_sync_wait: satellite_sync_wait, skip_inaccessible_collections: skip_inaccessible_collections, ttl: ttl,
+                              block: block, &ruby_block)
+        aql.execute
+      end
+
+      def batch_execute_aql(query:, batch_size: nil, bind_vars: nil, cache: nil, count: nil, fail_on_warning: nil, full_count: nil,
+                            intermediate_commit_count: nil, intermediate_commit_size: nil, max_plans: nil, max_transaction_size: nil,
+                            max_warning_count: nil, memory_limit: nil, optimizer_rules: nil, profile: nil, satellite_sync_wait: nil,
+                            skip_inaccessible_collections: nil, ttl: nil, block: nil, &ruby_block)
+        aql = Arango::AQL.new(database: self, query: query, batch_size: batch_size, bind_vars: bind_vars, cache: cache, count: count,
+                              fail_on_warning: fail_on_warning, full_count: full_count, intermediate_commit_count: intermediate_commit_count,
+                              intermediate_commit_size: intermediate_commit_size, max_plans: max_plans, max_transaction_size: max_transaction_size,
+                              max_warning_count: max_warning_count, memory_limit: memory_limit, optimizer_rules: optimizer_rules, profile: profile,
+                              satellite_sync_wait: satellite_sync_wait, skip_inaccessible_collections: skip_inaccessible_collections, ttl: ttl,
+                              block: block, &ruby_block)
+        aql.batch_execute
+      end
+
+      def batch_execute_query(query, batch_size: nil, bind_vars: nil, cache: nil, count: nil, fail_on_warning: nil, full_count: nil,
+                            intermediate_commit_count: nil, intermediate_commit_size: nil, max_plans: nil, max_transaction_size: nil,
+                            max_warning_count: nil, memory_limit: nil, optimizer_rules: nil, profile: nil, satellite_sync_wait: nil,
+                            skip_inaccessible_collections: nil, ttl: nil, block: nil, &ruby_block)
+        aql = Arango::AQL.new(database: self, query: query, batch_size: batch_size, bind_vars: bind_vars, cache: cache, count: count,
+                              fail_on_warning: fail_on_warning, full_count: full_count, intermediate_commit_count: intermediate_commit_count,
+                              intermediate_commit_size: intermediate_commit_size, max_plans: max_plans, max_transaction_size: max_transaction_size,
+                              max_warning_count: max_warning_count, memory_limit: memory_limit, optimizer_rules: optimizer_rules, profile: profile,
+                              satellite_sync_wait: satellite_sync_wait, skip_inaccessible_collections: skip_inaccessible_collections, ttl: ttl,
+                              block: block, &ruby_block)
+        aql.batch_execute
+      end
+
+      def query_tracking_properties
+        execute_request(get: "_api/query/properties")
+      end
+
+      def set_query_tracking_properties(props)
+        body = props.to_h
+        body.transform_keys! { |k| k.to_s.camelize(:lower).to_sym }
+        execute_request(put: "_api/query/properties", body: props.to_h)
+      end
+
+      def running_queries
+        result = execute_request(get: "_api/query/current")
+        result.map { |query_hash| Arango::AQL.from_result(query_hash) }
+      end
+
+      def slow_queries
+        result = execute_request(get: "_api/query/slow")
+        result.map { |query_hash| Arango::AQL.from_result(query_hash) }
+      end
+
+      def clear_slow_queries_list
+        result = execute_request(delete: "_api/query/slow")
+        result.response_code == 200
+      end
+
+      def kill_query(aql_id)
+        id = if id.class == String then id
+             elsif id.class == Arango::AQL then id.id
+             end
+        result = execute_request(delete: "_api/query/#{id}")
+        result == 200
+      end
+    end
+  end
+end

data/lib/arango/database/aql_query_cache.rb

@@ -0,0 +1,27 @@
+module Arango
+  class Database
+    module AQLQueryCache
+
+      def clear_query_cache
+        result = execute_request(delete: "_api/query-cache")
+        result.response_code == 200
+      end
+
+      def get_query_cache
+        result = execute_request(get: "_api/query-cache/entries")
+        result.map { |entry| Arango::Result.new(entry) }
+      end
+
+      def query_cache_properties
+        execute_request(get: "_api/query-cache/properties")
+      end
+
+      def set_query_cache_properties(props)
+        body = props.to_h
+        body.transform_keys! { |k| k.to_s.camelize(:lower).to_sym }
+        result = execute_request(put: "_api/query-cache/properties", body: body)
+        result.response_code == 200
+      end
+    end
+  end
+end

data/lib/arango/database/collections.rb

@@ -0,0 +1,100 @@
+module Arango
+  class Database
+    module Collections
+      # Retrieves all collections from the database.
+      # @param exclude_system [Boolean] Optional, default true, exclude system collections.
+      # @return [Array<Arango::Collection>]
+      def all_collections(exclude_system: true)
+        Arango::Collection.all(exclude_system: exclude_system, database: self)
+      end
+      def batch_all_collections(exclude_system: true)
+        Arango::Collection.batch_all(exclude_system: exclude_system, database: self)
+      end
+
+      # Creates a new collection.
+      # @param name [String] The name of the collection.
+      # @param type [Symbol] One of :document or :edge, the collection type, optional, default: :document.
+      # @return [Arango::Collection] The instance of the collection created.
+      def create_collection(name, type: :document, is_system: false)
+        Arango::Collection.new(name, type: type, database: self, is_system: is_system).create
+      end
+      def batch_create_collection(name, type: :document, is_system: false)
+        Arango::Collection.new(name, type: type, database: self, is_system: is_system).batch_create
+      end
+
+      # Creates a new edge collection.
+      # @param name [String] The name of the collection.
+      # @return [Arango::Collection] The instance of the collection created.
+      def create_edge_collection(name)
+        Arango::Collection.new(name, type: :edge, database: self).create
+      end
+      def batch_create_edge_collection(name)
+        Arango::Collection.new(name, type: :edge, database: self).batch_create
+      end
+
+      # Get collection from the database.
+      # @param name [String] The name of the collection.
+      # @return [Arango::Database]
+      def get_collection(name)
+        Arango::Collection.get(name, database: self)
+      end
+      def batch_get_collection(name)
+        Arango::Collection.batch_get(name, database: self)
+      end
+      alias fetch_collection get_collection
+      alias retrieve_collection get_collection
+      alias batch_fetch_collection batch_get_collection
+      alias batch_retrieve_collection batch_get_collection
+
+      # Instantiates a new collection.
+      # @param name [String] The name of the collection.
+      # @param type [Symbol] One of :document or :edge, the collection type, optional, default: :document.
+      # @return [Arango::Collection]
+      def new_collection(name, type: :document)
+        Arango::Collection.new(name, type: type, database: self)
+      end
+
+      # Instantiates a new edge collection.
+      # @param name [String] The name of the collection.
+      # @return [Arango::Collection]
+      def new_edge_collection(name)
+        Arango::Collection.new(name, type: :edge, database: self)
+      end
+
+      # Retrieves a list of all collections.
+      # @param exclude_system [Boolean] Optional, default true, exclude system collections.
+      # @return [Array<String>] List of collection names.
+      def list_collections(exclude_system: true)
+        Arango::Collection.list(exclude_system: exclude_system, database: self)
+      end
+      def batch_list_collections(exclude_system: true)
+        Arango::Collection.batch_list(exclude_system: exclude_system, database: self)
+      end
+
+      # Removes a collection.
+      # @param name [String] The name of the collection.
+      # @return nil
+      def drop_collection(name)
+        Arango::Collection.drop(name, database: self)
+      end
+      def batch_drop_collection(name)
+        Arango::Collection.batch_drop(name, database: self)
+      end
+      alias delete_collection drop_collection
+      alias destroy_collection drop_collection
+      alias batch_delete_collection batch_drop_collection
+      alias batch_destroy_collection batch_drop_collection
+
+      # Check if collection exists.
+      # @param name [String] Name of the collection
+      # @return [Boolean]
+      def exist_collection?(name, exclude_system: true)
+        Arango::Collection.exist?(name, database: self, exclude_system: exclude_system)
+      end
+      def batch_exist_collection?(name, exclude_system: true)
+        Arango::Collection.batch_exist?(name, database: self, exclude_system: exclude_system)
+      end
+      alias collection_exist? exist_collection?
+    end
+  end
+end