axiom 0.1.0

data/lib/axiom/algebra/extension.rb

@@ -0,0 +1,174 @@
+# encoding: utf-8
+
+module Axiom
+  module Algebra
+
+    # Extend a relation to include calculated attributes
+    class Extension < Relation
+      include Relation::Operation::Unary
+      include Equalizer.new(:operand, :extensions)
+
+      # The extensions for the relation
+      #
+      # @return [Hash]
+      #
+      # @api private
+      attr_reader :extensions
+
+      # Initialize an Extension
+      #
+      # @param [Relation] operand
+      #   the relation to extend
+      # @param [Hash] extensions
+      #   the extensions to add
+      #
+      # @return [undefined]
+      #
+      # @api private
+      def initialize(operand, extensions)
+        super(operand)
+        keys        = extensions.keys
+        @header     = @header.extend(keys)
+        @extensions = Hash[@header.project(keys).zip(extensions.values)]
+      end
+
+      # Iterate over each tuple in the set
+      #
+      # @example
+      #   extension = Extension.new(operand, extensions)
+      #   extension.each { |tuple| ... }
+      #
+      # @yield [tuple]
+      #
+      # @yieldparam [Tuple] tuple
+      #   each tuple in the set
+      #
+      # @return [self]
+      #
+      # @api public
+      def each
+        return to_enum unless block_given?
+        extensions = self.extensions.values
+        operand.each { |operand_tuple| yield operand_tuple.extend(header, extensions) }
+        self
+      end
+
+      # Insert a relation into the Extension
+      #
+      # The other relation must be a matching extension.
+      #
+      # @example
+      #   new_relation = extension.insert(other)
+      #
+      # @param [Relation] other
+      #
+      # @return [Extension]
+      #
+      # @raise [ExtensionMismatchError]
+      #   raised when inserting with a mismatching extension
+      #
+      # @api public
+      def insert(other)
+        assert_matching_extensions(other, INSERTED)
+        operand.insert(other.operand).extend(extensions)
+      end
+
+      # Delete a relation from the Extension
+      #
+      # The other relation must be a matching extension.
+      #
+      # @example
+      #   new_relation = extension.delete(other)
+      #
+      # @param [Relation] other
+      #
+      # @return [Extension]
+      #
+      # @raise [ExtensionMismatchError]
+      #   raised when deleting with a mismatching extension
+      #
+      # @api public
+      def delete(other)
+        assert_matching_extensions(other, DELETED)
+        operand.delete(other.operand).extend(extensions)
+      end
+
+    private
+
+      # Assert that the other relation has matching extensions
+      #
+      # @param [Relation] other
+      #
+      # @param [String] event
+      #
+      # @return [undefined]
+      #
+      # @raise [ExtensionMismatchError]
+      #   raised when inserting a relation does not have matching extensions
+      #
+      # @api private
+      def assert_matching_extensions(other, event)
+        unless other.kind_of?(self.class) && extensions.eql?(other.extensions)
+          raise ExtensionMismatchError, "other relation must have matching extensions to be #{event}"
+        end
+      end
+
+      module Methods
+
+        # Return an extended relation
+        #
+        # @example with extensions
+        #  extension = relation.extend(extensions)
+        #
+        # @example with a context block
+        #   extension = relation.extend do |context|
+        #     context.add(:total, context[:unit_price] * context[:quantity])
+        #   end
+        #
+        # @param [Array] args
+        #   optional arguments
+        #
+        # @yield [function]
+        #   Evaluate an extension function
+        #
+        # @yieldparam [Evaluator::Context] context
+        #   the context to evaluate the function within
+        #
+        # @return [Extension]
+        #
+        # @api public
+        def extend(*args, &block)
+          Extension.new(self, coerce_to_extensions(*args, &block))
+        end
+
+      private
+
+        # Coerce the arguments and block into a extensions
+        #
+        # @param [#to_hash] extensions
+        #   optional extensions with attribute keys and function/literal values
+        #
+        # @yield [function]
+        #   Evaluate an extension function
+        #
+        # @yieldparam [Evaluator::Context] context
+        #   the context to evaluate the function within
+        #
+        # @return [Extension]
+        #
+        # @api private
+        def coerce_to_extensions(extensions = Undefined)
+          if extensions.equal?(Undefined)
+            Evaluator::Context.new(header) { |context| yield context }.functions
+          else
+            extensions
+          end
+        end
+
+      end # module Methods
+
+      Relation.class_eval { include Methods }
+
+    end # class Extension
+  end # module Algebra
+end # module Axiom

data/lib/axiom/algebra/intersection.rb

@@ -0,0 +1,83 @@
+# encoding: utf-8
+
+module Axiom
+  module Algebra
+
+    # The intersection between relations
+    class Intersection < Relation
+      include Relation::Operation::Set
+
+      # Iterate over each tuple in the set
+      #
+      # @example
+      #   intersection = Intersection.new(left, right)
+      #   intersection.each { |tuple| ... }
+      #
+      # @yield [tuple]
+      #
+      # @yieldparam [Tuple] tuple
+      #   each tuple in the set
+      #
+      # @return [self]
+      #
+      # @api public
+      def each
+        return to_enum unless block_given?
+        left.each { |tuple| yield tuple if right.include?(tuple) }
+        self
+      end
+
+      # Insert a relation into the Intersection
+      #
+      # @example
+      #   new_relation = intersection.insert(other)
+      #
+      # @param [Relation] other
+      #
+      # @return [Intersection]
+      #
+      # @api public
+      def insert(other)
+        left.insert(other).intersect(right.insert(other))
+      end
+
+      # Delete a relation from the Intersection
+      #
+      # @example
+      #   new_relation = intersection.delete(other)
+      #
+      # @param [Relation] other
+      #
+      # @return [Intersection]
+      #
+      # @api public
+      def delete(other)
+        left.delete(other).intersect(right.delete(other))
+      end
+
+      module Methods
+        extend Aliasable
+
+        inheritable_alias(:& => :intersect)
+
+        # Return the intersection between relations
+        #
+        # @example
+        #   intersection = relation.intersect(other)
+        #
+        # @param [Relation] other
+        #
+        # @return [Intersection]
+        #
+        # @api public
+        def intersect(other)
+          Intersection.new(self, other)
+        end
+
+      end # module Methods
+
+      Relation.class_eval { include Methods }
+
+    end # class Intersection
+  end # module Algebra
+end # module Axiom

data/lib/axiom/algebra/join.rb

@@ -0,0 +1,204 @@
+# encoding: utf-8
+
+module Axiom
+  module Algebra
+
+    # The join between relations
+    class Join < Relation
+      include Relation::Operation::Combination
+
+      # The common headers between the operands
+      #
+      # @return [Header]
+      #
+      # @api private
+      attr_reader :join_header
+
+      # Initialize a Join
+      #
+      # @param [Relation] _left
+      # @param [Relation] _right
+      #
+      # @return [undefined]
+      #
+      # @api private
+      def initialize(_left, _right)
+        super
+        right_header     = right.header
+        @join_header     = left.header  & right_header
+        @disjoint_header = right_header - join_header
+      end
+
+      # Iterate over each tuple in the set
+      #
+      # @example
+      #   join = Join.new(left, right)
+      #   join.each { |tuple| ... }
+      #
+      # @yield [tuple]
+      #
+      # @yieldparam [Tuple] tuple
+      #   each tuple in the set
+      #
+      # @return [self]
+      #
+      # @api public
+      def each(&block)
+        return to_enum unless block_given?
+        util  = Relation::Operation::Combination
+        index = build_index
+
+        left.each do |left_tuple|
+          right_tuples = index[join_tuple(left_tuple)]
+          util.combine_tuples(header, left_tuple, right_tuples, &block)
+        end
+
+        self
+      end
+
+      # Insert a relation into the Join
+      #
+      # @example
+      #   new_relation = join.insert(other)
+      #
+      # @param [Relation] other
+      #
+      # @return [Join]
+      #
+      # @api public
+      def insert(other)
+        other = coerce(other)
+        insert_left(other).join(insert_right(other))
+      end
+
+      # Delete a relation from the Join
+      #
+      # @example
+      #   new_relation = join.delete(other)
+      #
+      # @param [Relation] other
+      #
+      # @return [Join]
+      #
+      # @api public
+      def delete(other)
+        other = coerce(other)
+        delete_left(other).join(delete_right(other))
+      end
+
+    private
+
+      # Build an index using every tuple in the right relation
+      #
+      # @return [Hash]
+      #
+      # @api private
+      def build_index
+        index = Hash.new { |hash, tuple| hash[tuple] = Set.new }
+        right.each { |tuple| index[join_tuple(tuple)] << disjoint_tuple(tuple) }
+        index
+      end
+
+      # Generate a tuple with the join attributes between relations
+      #
+      # @return [Tuple]
+      #
+      # @api private
+      def join_tuple(tuple)
+        tuple.project(join_header)
+      end
+
+      # Generate a tuple with the disjoint attributes between relations
+      #
+      # @return [Tuple]
+      #
+      # @api private
+      def disjoint_tuple(tuple)
+        tuple.project(@disjoint_header)
+      end
+
+      # Insert the other relation into the left operand
+      #
+      # @param [Relation] other
+      #
+      # @return [Relation::Operation::Insertion]
+      #
+      # @api private
+      def insert_left(other)
+        left.insert(other.project(left.header))
+      end
+
+      # Insert the other relation into the right operand
+      #
+      # @param [Relation] other
+      #
+      # @return [Relation::Operation::Insertion]
+      #
+      # @api private
+      def insert_right(other)
+        right.insert(other.project(right.header))
+      end
+
+      # Delete the other relation from the left operand
+      #
+      # @param [Relation] other
+      #
+      # @return [Relation::Operation::Deletion]
+      #
+      # @api private
+      def delete_left(other)
+        left.delete(other.project(left.header))
+      end
+
+      # Delete the other relation from the right operand
+      #
+      # @param [Relation] other
+      #
+      # @return [Relation::Operation::Deletion]
+      #
+      # @api private
+      def delete_right(other)
+        right.delete(other.project(right.header))
+      end
+
+      module Methods
+        extend Aliasable
+
+        inheritable_alias(:+ => :join)
+
+        # 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 [Join, Restriction]
+        #
+        # @api public
+        def join(other)
+          relation = Join.new(self, other)
+          relation = relation.restrict { |context| yield context } if block_given?
+          relation
+        end
+
+      end # module Methods
+
+      Relation.class_eval { include Methods }
+
+    end # class Join
+  end # module Algebra
+end # module Axiom