axiom-arango-adapter 0.0.1

data/lib/axiom/adapter/arango/adapter.rb

@@ -0,0 +1,68 @@
+module Axiom
+  module Adapter
+    module Arango
+
+      # Adapter to read tuples from remote ArangoDB
+      class Adapter
+        include Adamantium::Flat, Concord.new(:database, :logger)
+
+        # Return new adapter
+        #
+        # @param [Ashikawa::Core::Database] _database
+        # @param [NullLogger] _logger
+        #
+        # @return [undefined]
+        #
+        # @example
+        #
+        #   database = Ashikawa::Core::Database.new('http://localhost:8529')
+        #   adapter = Axiom::Adapter::Arango::Adapter.new(database, Logger.new($stderr, :debug))
+        #
+        # @api public
+        #
+        def self.new(_database, _logger = NullLogger.instance)
+          super
+        end
+
+        # Return reader for base relation
+        #
+        # @param [Relation::Base] base_relation
+        #   the relation to read from
+        #
+        # @return [Reader]
+        #   the reader
+        #
+        # @api private
+        #
+        def reader(base_relation)
+          Reader.new(self, base_relation)
+        end
+
+        # Return gateway for the ArangoDB adapter
+        #
+        # @param [Relation::Base] base_relation
+        #
+        # @return [Gateway]
+        #
+        # @example 
+        #   
+        #   gateway = adapter.gateway(base_relation)
+        #
+        #   # Perform restriction on gateway
+        #   relation = gateway.restrict { |r| r.foo.eql('bar') }
+        #
+        #   # Enumerate tuples
+        #   relation.each do |tuple|
+        #     p tuple.to_ary
+        #   end
+        #
+        # @api public
+        #
+        def gateway(base_relation)
+          Gateway.new(self, base_relation)
+        end
+
+      end
+    end
+  end
+end

data/lib/axiom/adapter/arango/gateway.rb

@@ -0,0 +1,356 @@
+# encoding: utf-8
+
+module Axiom
+  module Adapter
+    module Arango
+      # A relation backed by an adapter
+      class Gateway < Relation
+        include Concord.new(:adapter, :relation)
+
+        DECORATED_CLASS = superclass
+
+        # remove methods so they can be proxied
+        undef_method *DECORATED_CLASS.public_instance_methods(false).map(&:to_s) - %w[ materialize ]
+        undef_method :project, :remove, :extend, :rename, :restrict, :sort_by, :reverse, :drop, :take
+
+        # Iterate over each row in the results
+        #
+        # @example
+        #   gateway = Gateway.new(adapter, relation)
+        #   gateway.each { |tuple| ... }
+        #
+        # @yield [tuple]
+        #
+        # @yieldparam [Tuple] tuple
+        #   each tuple in the results
+        #
+        # @return [self]
+        #
+        # @api public
+        def each
+          return to_enum unless block_given?
+          tuples.each { |tuple| yield tuple }
+          self
+        end
+
+        # Return a relation that is the join of two relations
+        #
+        # @example natural join
+        #   join = relation.join(other)
+        #
+        # @example theta-join using a block
+        #   join = relation.join(other) { |r| r.a.gte(r.b) }
+        #
+        # @param [Relation] other
+        #   the other relation to join
+        #
+        # @yield [relation]
+        #   optional block to restrict the tuples with
+        #
+        # @yieldparam [Relation] relation
+        #   the context to evaluate the restriction with
+        #
+        # @yieldreturn [Function, #call]
+        #   predicate to restrict the tuples with
+        #
+        # @return [Gateway]
+        #   return a gateway if the adapters are equal
+        # @return [Algebra::Join]
+        #   return a normal join when the adapters are not equal
+        # @return [Algebra::Restriction]
+        #   return a normal restriction when the adapters are not equal
+        #   for a theta-join
+        #
+        # @api public
+        def join(other)
+          if block_given?
+            super
+          else
+            binary_operation(__method__, other, Algebra::Join)
+          end
+        end
+
+        # Return a relation that is the Cartesian product of two relations
+        #
+        # @example
+        #   product = gateway.product(other)
+        #
+        # @param [Relation] other
+        #   the other relation to find the product with
+        #
+        # @return [Gateway]
+        #   return a gateway if the adapters are equal
+        # @return [Algebra::Product]
+        #   return a normal product when the adapters are not equal
+        #
+        # @api public
+        def product(other)
+          binary_operation(__method__, other, Algebra::Product)
+        end
+
+        # Return the union between relations
+        #
+        # @example
+        #   union = gateway.union(other)
+        #
+        # @param [Relation] other
+        #   the other relation to find the union with
+        #
+        # @return [Gateway]
+        #   return a gateway if the adapters are equal
+        # @return [Algebra::Union]
+        #   return a normal union when the adapters are not equal
+        #
+        # @api public
+        def union(other)
+          binary_operation(__method__, other, Algebra::Union)
+        end
+
+        # Return the intersection between relations
+        #
+        # @example
+        #   intersect = gateway.intersect(other)
+        #
+        # @param [Relation] other
+        #   the other relation to find the intersect with
+        #
+        # @return [Gateway]
+        #   return a gateway if the adapters are equal
+        # @return [Algebra::Intersection]
+        #   return a normal intersection when the adapters are not equal
+        #
+        # @api public
+        def intersect(other)
+          binary_operation(__method__, other, Algebra::Intersection)
+        end
+
+        # Return the difference between relations
+        #
+        # @example
+        #   difference = gateway.difference(other)
+        #
+        # @param [Relation] other
+        #   the other relation to find the difference with
+        #
+        # @return [Gateway]
+        #   return a gateway if the adapters are equal
+        # @return [Algebra::Difference]
+        #   return a normal dfference when the adapters are not equal
+        #
+        # @api public
+        def difference(other)
+          binary_operation(__method__, other, Algebra::Difference)
+        end
+
+        # Return a summarized relation
+        #
+        # @example with no arguments
+        #   summarization = gateway.summarize do |context|
+        #     context.add(:count, context[:id].count)
+        #   end
+        #
+        # @example with a relation
+        #   summarization = gateway.summarize(relation) do |context|
+        #     context.add(:count, context[:id].count)
+        #   end
+        #
+        # @example with a header
+        #   summarization = gateway.summarize([ :name ]) do |context|
+        #     context.add(:count, context[:id].count)
+        #   end
+        #
+        # @example with another gateway
+        #   summarization = gateway.summarize(other_gateway) do |context|
+        #     context.add(:count, context[:id].count)
+        #   end
+        #
+        # @param [Gateway, Relation, Header, #to_ary] summarize_with
+        #
+        # @yield [function]
+        #   Evaluate a summarization function
+        #
+        # @yieldparam [Evaluator::Context] context
+        #   the context to evaluate the function within
+        #
+        # @return [Gateway]
+        #   return a gateway if the adapters are equal, or there is no adapter
+        # @return [Algebra::Summarization]
+        #   return a normal summarization when the adapters are not equal
+        #
+        # @api public
+        def summarize(summarize_with = TABLE_DEE, &block)
+          if summarize_merge?(summarize_with)
+            summarize_merge(summarize_with, &block)
+          else
+            summarize_split(summarize_with, &block)
+          end
+        end
+
+        # Test if the method is supported on this object
+        #
+        # @param [Symbol] method
+        #
+        # @return [Boolean]
+        #
+        # @api private
+        def respond_to?(method, *)
+          super || forwardable?(method)
+        end
+
+      private
+
+        # Proxy the message to the relation
+        #
+        # @param [Symbol] method
+        #
+        # @param [Array] args
+        #
+        # @return [self]
+        #   return self for all command methods
+        # @return [Object]
+        #   return response from all query methods
+        #
+        # @api private
+        def method_missing(method, *args, &block)
+          forwardable?(method) ? forward(method, *args, &block) : super
+        end
+
+        # Test if the method can be forwarded to the relation
+        #
+        # @param [Symbol] method
+        #
+        # @return [Boolean]
+        #
+        # @api private
+        def forwardable?(method)
+          relation.respond_to?(method)
+        end
+
+        # Forward the message to the relation
+        #
+        # @param [Array] args
+        #
+        # @return [self]
+        #   return self for all command methods
+        # @return [Object]
+        #   return response from all query methods
+        #
+        # @api private
+        def forward(*args, &block)
+          inner_relation = relation
+          response = inner_relation.public_send(*args, &block)
+          if response.equal?(inner_relation)
+            self
+          elsif response.kind_of?(DECORATED_CLASS)
+            self.class.new(adapter, response)
+          else
+            response
+          end
+        end
+
+        # Return a list of tuples to iterate over
+        #
+        # @return [#each]
+        #
+        # @api private
+        def tuples
+          inner_relation = relation
+          if materialized?
+            inner_relation
+          else
+            read_tuples
+          end
+        end
+
+        # Return a tuple reader
+        #
+        # @return [Enumerable<Tuple>]
+        #
+        # @api private
+        #
+        def read_tuples
+          adapter.reader(relation)
+        end
+
+        # Return a binary relation
+        #
+        # @param [Relation] other
+        #
+        # @return [Gateway]
+        #   return a gateway if the adapters are equal
+        # @return [Relation]
+        #   return a binary relation when the adapters are not equal
+        #
+        # @api private
+        def binary_operation(method, other, factory)
+          if same_adapter?(other)
+            forward(method, other.relation)
+          else
+            factory.new(self, other)
+          end
+        end
+
+        # Test if the other object is a Gateway
+        #
+        # @param [Gateway, Relation] other
+        #
+        # @return [Boolean]
+        #
+        # @api private
+        def gateway?(other)
+          other.kind_of?(Gateway)
+        end
+
+        # Test if the other object uses the same adapter
+        #
+        # @param [Gateway, Relation] other
+        #
+        # @return [Boolean]
+        #
+        # @api private
+        def same_adapter?(other)
+          gateway?(other) && adapter.eql?(other.adapter)
+        end
+
+        # Test if the summarize_with object can be merged into the summarization
+        #
+        # @param [Gateway, Relation, Header] summarize_with
+        #
+        # @return [Boolean]
+        #
+        # @api private
+        def summarize_merge?(summarize_with)
+          !summarize_with.respond_to?(:header) ||
+          summarize_with.equal?(TABLE_DEE)     ||
+          same_adapter?(summarize_with)
+        end
+
+        # Merge the summarize_with into the summarization
+        #
+        # @param [Gateway, Relation, Header] summarize_with
+        #
+        # @return [Gateway]
+        #
+        # @api private
+        def summarize_merge(summarize_with, &block)
+          summarize_with = summarize_with.relation if gateway?(summarize_with)
+          forward(:summarize, summarize_with, &block)
+        end
+
+        # Split the summarize_with into a separate relation, wrapped in a summarization
+        #
+        # @param [Gateway, Relation, Header] summarize_with
+        #
+        # @return [Algebra::Summarization]
+        #
+        # @api private
+        def summarize_split(summarize_with, &block)
+          # evaluate the gateway, then summarize with the provided relation
+          context = Evaluator::Context.new(header - summarize_with.header, &block)
+          Algebra::Summarization.new(self, summarize_with, context.functions)
+        end
+
+      end
+    end
+  end
+end

data/lib/axiom/adapter/arango/reader.rb

@@ -0,0 +1,98 @@
+module Axiom
+  module Adapter
+    module Arango
+      # A reader to read tuples from the database
+      class Reader
+        include Adamantium::Flat, Enumerable, Concord.new(:adapter, :relation)
+
+        # Enumerate tuples
+        #
+        # @return [self]
+        #   if block given
+        #
+        # @return [Enumerable<Tuple>]
+        #   otherwise
+        #
+        # @api private
+        #
+        def each
+          return to_enum unless block_given?
+
+          cursor.each do |document|
+            yield tuple(document)
+          end
+
+          self
+        end
+
+      private
+
+        # Coerce document to tuple
+        #
+        # @param [Ashikawa::Core::Document] document
+        #
+        # @return [Tuple]
+        #
+        # @api private
+        #
+        def tuple(document)
+          Tuple.new(header, document.to_hash.values_at(*document_keys))
+        end
+
+        # Return header
+        #
+        # @return [Relation::Header]
+        #
+        # @api private
+        #
+        def header
+          relation.header
+        end
+
+        # Return attribute names
+        #
+        # @return [Enumerable<Symbol>]
+        #
+        # @api private
+        #
+        def attribute_names
+          header.map(&:name)
+        end
+
+        # Return document keys
+        #
+        # @return [Enumerable<String>]
+        #
+        # @api private
+        #
+        def document_keys
+          attribute_names.map(&:to_s)
+        end
+        memoize :document_keys
+
+        # Return cursor
+        #
+        # @return [Ashikawa::Core::Cursor]
+        #
+        # @api private
+        #
+        def cursor
+          adapter.database.query.execute(aql)
+        end
+
+        # Return AQL to query with
+        #
+        # @return [String]
+        #
+        # @api private
+        #
+        def aql
+          aql = Visitor.run(relation).aql
+          adapter.logger.debug { "AQL: #{aql}" }
+          aql
+        end
+
+      end
+    end
+  end
+end