arangorb3 0.0.10

data/lib/AQL.rb

@@ -0,0 +1,155 @@
+# === AQL ===
+
+module Arango
+  class AQL
+    include Arango::Helper_Error
+    include Arango::Helper_Return
+    include Arango::Database_Return
+
+    def initialize(query:, database:, count: nil, batchSize: nil, cache: nil,
+      memoryLimit: nil, ttl: nil, bindVars: nil, failOnWarning: nil,
+      profile: nil, maxTransactionSize: nil, skipInaccessibleCollections: nil,
+      maxWarningCount: nil, intermediateCommitCount: nil,
+      satelliteSyncWait: nil, fullCount: nil, intermediateCommitSize: nil,
+      optimizer_rules: nil, maxPlans: nil)
+      satisfy_class?(query, [String])
+      @query = query
+      assign_database(database)
+
+      @count       = count
+      @batchSize   = batchSize
+      @cache       = cache
+      @memoryLimit = memoryLimit
+      @ttl         = ttl
+      @bindVars    = bindVars
+
+      @quantity = nil
+      @hasMore  = false
+      @id       = ""
+      @result   = []
+      @options  = {}
+      # DEFINE
+      ["failOnWarning", "profile", "maxTransactionSize",
+      "skipInaccessibleCollections", "maxWarningCount", "intermediateCommitCount",
+      "satelliteSyncWait", "fullCount", "intermediateCommitSize",
+      "optimizer_rules", "maxPlans"].each do |param_name|
+        param = eval(param_name)
+        set_option(param, param_name)
+        define_singleton_method("#{param_name}=") do |value|
+          set_option(value, param_name)
+        end
+      end
+    end
+
+# === DEFINE ===
+
+    attr_accessor :count, :query, :batchSize, :ttl, :cache, :options, :bindVars, :quantity
+    attr_reader :hasMore, :id, :result, :idCache, :failOnWarning, :profile,
+      :maxTransactionSize, :skipInaccessibleCollections, :maxWarningCount,
+      :intermediateCommitCount, :satelliteSyncWait, :fullCount, :server, :cached, :extra,
+      :intermediateCommitSize, :optimizer_rules, :maxPlans, :database
+    alias size batchSize
+    alias size= batchSize=
+
+    def set_option(attrs, name)
+      @options ||= {}
+      instance_variable_set("@#{name}", attrs)
+      unless attrs
+        name = "optimizer.rules" if name == "optimizer_rules"
+        @options[name] = attrs
+      end
+      @options.delete_if{|k,v| v.nil?}
+      @options = nil if @options.empty?
+    end
+    private :set_option
+
+  # === TO HASH ===
+
+    def to_h
+      {
+        "query":       @query,
+        "result":      @result,
+        "count":       @count,
+        "quantity":    @quantity,
+        "ttl":         @ttl,
+        "cache":       @cache,
+        "batchSize":   @batchSize,
+        "bindVars":    @bindVars,
+        "options":     @options,
+        "idCache":     @idCache,
+        "memoryLimit": @memoryLimit,
+        "database":    @database.name
+      }.delete_if{|k,v| v.nil?}
+    end
+
+# === REQUEST ===
+
+    def return_aql(result)
+      return result if @server.async != false
+      @extra    = result[:extra]
+      @cached   = result[:cached]
+      @quantity = result[:count]
+      @hasMore  = result[:hasMore]
+      @id       = result[:id]
+      if(result[:result][0].nil? || !result[:result][0].is_a?(Hash) || !result[:result][0].key?(:_key))
+        @result = result[:result]
+      else
+        @result = result[:result].map do |x|
+          collection = Arango::Collection.new(name: x[:_id].split("/")[0], database: @database)
+          Arango::Document.new(name: x[:_key], collection: collection, body: x)
+        end
+      end
+      return return_directly?(result) ? result: self
+    end
+    private :return_aql
+
+  # === EXECUTE QUERY ===
+
+    def execute
+      body = {
+        "query":       @query,
+        "count":       @count,
+        "batchSize":   @batchSize,
+        "ttl":         @ttl,
+        "cache":       @cache,
+        "options":     @options,
+        "bindVars":    @bindVars,
+        "memoryLimit": @memoryLimit
+      }
+      result = @database.request("POST", "_api/cursor", body: body)
+      return_aql(result)
+    end
+
+    def next
+      if @hasMore
+        result = @database.request("PUT", "_api/cursor/#{@id}")
+        return_aql(result)
+      else
+        raise Arango::Error.new err::no_other_aql_next, data: {"hasMore": false}
+      end
+    end
+
+    def destroy
+      @database.request("DELETE", "_api/cursor/#{@id}")
+    end
+
+    def kill
+      @database.request("DELETE", "_api/query/#{@id}")
+    end
+
+# === PROPERTY QUERY ===
+
+    def explain
+      body = {
+        "query":    @query,
+        "options":  @options,
+        "bindVars": @bindVars
+      }
+      @database.request("POST", "_api/explain", body: body)
+    end
+
+    def parse
+      @database.request("POST", "_api/query", body: {"query": @query})
+    end
+  end
+end

data/lib/Batch.rb

@@ -0,0 +1,97 @@
+module Arango
+  class Batch
+    include Arango::Helper_Error
+    include Arango::Helper_Return
+    include Arango::Server_Return
+
+    def initialize(server:, boundary: "XboundaryX", queries: [])
+      @id = 1
+      assign_server(server)
+      assign_queries(queries)
+      @headers = {
+        "Content-Type": "multipart/form-data",
+        "boundary":     boundary
+      }
+      @boundary = boundary
+    end
+
+# === DEFINE ===
+
+    attr_reader :server, :boundary, :queries
+
+    def boundary=(boundary)
+      @boundary = boundary
+      @headers[:boundary] = boundary
+    end
+
+    def queries=(queries)
+      queries = [queries] unless queries.is_a?(Array)
+      @queries = {}
+      queries.each do |query|
+        begin
+          query.keys.each do |key|
+            query[(key.to_sym rescue key) || key] = query.delete(key)
+          end
+        rescue
+          raise Arango::Error.new(err: :batch_query_not_valid,
+            data: {wrong_query: query})
+        end
+        satisfy_class?(query, [Hash])
+        if query[:id].nil?
+          query[:id] = @id.to_s
+          @id += 1
+        end
+        @queries[query[:id]] = query
+      end
+      return @queries
+    end
+    alias assign_queries queries=
+
+# === TO HASH ===
+
+    def to_h
+      {
+        "boundary": @boundary,
+        "queries":  @queries,
+        "database": @database.name
+      }.delete_if{|k,v| v.nil?}
+    end
+
+# === QUERY ===
+
+    def addQuery(id: @id, method:, address:, body: nil)
+      id = id.to_s
+      @queries[id] = {
+        "id":      id,
+        "method":  method,
+        "address": address,
+        "body":    body
+      }.delete_if{|k,v| v.nil?}
+      @id += 1
+      return @queries
+    end
+    alias modifyQuery addQuery
+
+    def removeQuery(id:)
+      @queries.delete(id)
+      return @queries
+    end
+
+# === EXECUTE ===
+
+    def execute
+      body = ""
+      @queries.each do |id, query|
+        body += "--#{@boundary}\n"
+        body += "Content-Type: application/x-arango-batchpart\n"
+        body += "Content-Id: #{query[:id]}\n\n"
+        body += "#{query[:method]} "
+        body += "#{query[:address]} HTTP/1.1\n"
+        body += "\n#{Oj.dump(query[:body])}\n" unless query[:body].nil?
+      end
+      body += "--#{@boundary}--\n" if @queries.length > 0
+      @server.request("POST", "_api/batch", body: body, skip_to_json: true,
+        headers: @headers, skip_parsing: true)
+    end
+  end
+end

data/lib/Cache.rb

@@ -0,0 +1,71 @@
+module Arango
+  class Cache
+    def initialize
+      @max  = {
+        database: 10,
+        collection: 20,
+        document: 200,
+        graph: 10,
+        index: 20,
+        user: 20,
+        task: 20,
+        view: 20,
+        foxx: 20
+      }
+
+      @cache = {
+        database: {},
+        collection: {},
+        document: {},
+        graph: {},
+        index: {},
+        aql: {},
+        user: {},
+        task: {},
+        view: {},
+        foxx: {}
+      }
+    end
+
+    attr_reader :cache, :max
+
+    def to_h
+      hash = {
+        "max": @max,
+        "cache": {}
+      }
+      @cache.each do |key, hash2|
+        next if hash2.empty?
+        hash[:cache][key] = hash2.keys
+      end
+      hash
+    end
+
+    def save(type, id, obj)
+      while @cache[type].length >= @max[type]
+        @cache[type].shift
+      end
+      @cache[type][id] = obj
+    end
+
+    def destroy(type, id)
+      @cache[type].delete(id)
+    end
+
+    def clear
+      @cache.each_key{|k| @cache[k] = {}}
+    end
+
+    def updateMax(type:, val:)
+      type = type.to_sym rescue type = :error
+      unless @max.has_key?(type.to_sym)
+        ArangoDB::Error.new :element_in_cache_does_not_exist,
+          {wrong_attribute: :type, wrong_value: type}
+      end
+      while @cache[type].length > val
+        @cache[type].shift
+      end
+      @max[type] = val
+    end
+  end
+end