veritas 0.0.1

data/lib/veritas/algebra/join.rb

@@ -0,0 +1,198 @@
+module Veritas
+  module Algebra
+
+    # The join between relations
+    class Join < Relation
+      include Relation::Operation::Combine
+
+      # Instantiate a new Join
+      #
+      # @example
+      #   join = Join.new(left, right)
+      #
+      # @param [Relation] left
+      # @param [Relation] right
+      #
+      # @return [Join]
+      #
+      # @api public
+      def self.new(left, right)
+        assert_joinable_headers(left, right)
+        super
+      end
+
+      # Assert the headers have common attributes
+      #
+      # @param [Relation] left
+      # @param [Relation] right
+      #
+      # @return [undefined]
+      #
+      # @raise [InvalidHeaderError]
+      #   raised if there are no common attributes between the headers
+      #
+      # @api private
+      def self.assert_joinable_headers(left, right)
+        if (left.header & right.header).empty?
+          raise InvalidHeaderError, "the headers must have common attributes for #{name}.new"
+        end
+      end
+
+      private_class_method :assert_joinable_headers
+
+      # 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
+        @remainder_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)
+        index = build_index
+
+        left.each do |tuple|
+          right_tuples = index[join_tuple(tuple)]
+          if right_tuples
+            Relation::Operation::Combine.combine_tuples(header, tuple, right_tuples, &block)
+          end
+        end
+
+        self
+      end
+
+    private
+
+      # Build an index using every tuple in the right relation
+      #
+      # @return [Hash]
+      #
+      # @api private
+      def build_index
+        index = {}
+
+        right.each do |tuple|
+          (index[join_tuple(tuple)] ||= Set.new) << remainder_tuple(tuple)
+        end
+
+        index
+      end
+
+      # Generate a tuple with only the common attributes used for the join
+      #
+      # @return [Tuple]
+      #
+      # @api private
+      def join_tuple(tuple)
+        tuple.project(@join_header)
+      end
+
+      # Generate a tuple with the disjoint attributes to use in the join
+      #
+      # @return [Tuple]
+      #
+      # @api private
+      def remainder_tuple(tuple)
+        tuple.project(@remainder_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 predicate
+        #   join = relation.join(other, relation[:a].gte(other[:b]))
+        #
+        # @example theta-join using a block
+        #   join = relation.join(other) { |r| r[:a].gte(r[:b]) }
+        #
+        # @param [Relation] other
+        #   the other relation to join
+        # @param [Expression, #call] predicate
+        #   the predicate to restrict the tuples with
+        #
+        # @yield [relation]
+        #   optional block to restrict the tuples with
+        #
+        # @yieldparam [Relation] relation
+        #   the context to evaluate the restriction with
+        #
+        # @return [Join, Restriction]
+        #
+        # @api public
+        def join(other, predicate = nil, &block)
+          if predicate || block_given?
+            theta_join(other, predicate, &block)
+          else
+            natural_join(other)
+          end
+        end
+
+      private
+
+        # Return a relation that is the natural join
+        #
+        # @param [Relation] other
+        #   the other relation to join
+        #
+        # @return [Join]
+        #
+        # @api private
+        def natural_join(other)
+          Join.new(self, other)
+        end
+
+        # Return a relation that is a restricted cartesian product
+        #
+        # @param [Relation] other
+        #   the other relation to join
+        # @param [Array] *args
+        #   optional arguments to pass to Relation#restrict
+        #
+        # @yield [relation]
+        #   optional block to restrict the tuples with
+        #
+        # @yieldparam [Relation] relation
+        #   the context to evaluate the restriction with
+        #
+        # @return [Restriction]
+        #
+        # @api private
+        def theta_join(other, *args, &block)
+          product(other).restrict(*args.compact, &block)
+        end
+
+      end # module Methods
+
+      Relation.class_eval { include Methods }
+
+    end # class Join
+  end # module Algebra
+end # module Veritas

data/lib/veritas/algebra/product.rb

@@ -0,0 +1,90 @@
+module Veritas
+  module Algebra
+
+    # The cartesian product between relations
+    class Product < Relation
+      include Relation::Operation::Combine
+
+      # Instantiate a new Product
+      #
+      # @example
+      #   product = Product.new(left, right)
+      #
+      # @param [Relation] left
+      # @param [Relation] right
+      #
+      # @return [Join]
+      #
+      # @api public
+      def self.new(left, right)
+        assert_disjointed_headers(left, right)
+        super
+      end
+
+      # Assert the headers do not have common attributes
+      #
+      # @param [Relation] left
+      # @param [Relation] right
+      #
+      # @return [undefined]
+      #
+      # @raise [InvalidHeaderError]
+      #   raised if there are common attributes between the headers
+      #
+      # @api private
+      def self.assert_disjointed_headers(left, right)
+        if (left.header & right.header).any?
+          raise InvalidHeaderError, "the headers must be disjointed for #{name}.new"
+        end
+      end
+
+      private_class_method :assert_disjointed_headers
+
+      # Iterate over each tuple in the set
+      #
+      # @example
+      #   product = Product.new(left, right)
+      #   product.each { |tuple| ... }
+      #
+      # @yield [tuple]
+      #
+      # @yieldparam [Tuple] tuple
+      #   each tuple in the set
+      #
+      # @return [self]
+      #
+      # @api public
+      def each(&block)
+        left.each do |tuple|
+          Relation::Operation::Combine.combine_tuples(header, tuple, right, &block)
+        end
+        self
+      end
+
+      module Methods
+        extend Aliasable
+
+        inheritable_alias(:* => :product)
+
+        # Return a relation that is the cartesian product of two relations
+        #
+        # @example
+        #   product = relation.product(other)
+        #
+        # @param [Relation] other
+        #   the other relation to find the product with
+        #
+        # @return [Product]
+        #
+        # @api public
+        def product(other)
+          Product.new(self, other)
+        end
+
+      end # module Methods
+
+      Relation.class_eval { include Methods }
+
+    end # class Product
+  end # module Algebra
+end # module Veritas

data/lib/veritas/algebra/projection.rb

@@ -0,0 +1,113 @@
+module Veritas
+  module Algebra
+
+    # Specify only specific attributes to keep in the relation
+    class Projection < Relation
+      include Relation::Operation::Unary
+
+      # Initialize a Projection
+      #
+      # @param [Relation] operand
+      #   the relation to project
+      # @param [#to_ary] attributes
+      #   the attributes to keep in the header
+      #
+      # @return [undefined]
+      #
+      # @api private
+      def initialize(operand, attributes)
+        super(operand)
+        @header     = @header.project(attributes.to_ary)
+        @directions = @directions.project(@header)
+      end
+
+      # Iterate over each tuple in the set
+      #
+      # @example
+      #   projection = Projection.new(operand, attributes)
+      #   projection.each { |tuple| ... }
+      #
+      # @yield [tuple]
+      #
+      # @yieldparam [Tuple] tuple
+      #   each tuple in the set
+      #
+      # @return [self]
+      #
+      # @api public
+      def each
+        seen = {}
+        operand.each do |tuple|
+          tuple = tuple.project(header)
+          yield(seen[tuple] = tuple) unless seen.key?(tuple)
+        end
+        self
+      end
+
+      module Methods
+
+        # Return a relation with only the attributes specified
+        #
+        # @example
+        #   projection = relation.project([ :a, :b, :c ])
+        #
+        # @param [#to_ary] attributes
+        #   the attributes to keep in the header
+        #
+        # @return [Projection]
+        #
+        # @api public
+        def project(attributes)
+          project_relation(self, attributes)
+        end
+
+        # Return a relation with attributes not specified
+        #
+        # @example
+        #   projection = relation.remove([ :a, b, c ])
+        #
+        # @param [#to_ary] attributes
+        #   the attributes to remove from the header
+        #
+        # @return [Projection]
+        #
+        # @api public
+        def remove(attributes)
+          project(header - project_header(attributes))
+        end
+
+      private
+
+        # Return a header with only the attributes specified
+        #
+        # @param [#to_ary] attributes
+        #   the attributes to keep in the header
+        #
+        # @return [Header]
+        #
+        # @api private
+        def project_header(attributes)
+          header.project(attributes)
+        end
+
+        # Return a relation with only the attribtues specified
+        #
+        # @param [Relation] operand
+        #   the relation to project
+        # @param [#to_ary] attributes
+        #   optional attributes to keep in the projection
+        #
+        # @return [Projection]
+        #
+        # @api private
+        def project_relation(operand, attributes = header)
+          Projection.new(operand, attributes)
+        end
+
+      end # module Methods
+
+      Relation.class_eval { include Methods }
+
+    end # class Projection
+  end # module Algebra
+end # module Veritas

data/lib/veritas/algebra/rename/aliases.rb

@@ -0,0 +1,199 @@
+module Veritas
+  module Algebra
+    class Rename
+
+      # Aliases that map old attributes to new renamed attributes
+      class Aliases
+        extend Aliasable
+        include Immutable, Enumerable
+
+        inheritable_alias(:| => :union)
+
+        # Initialize rename aliases
+        #
+        # @param [#to_hash] aliases
+        #   the old and new attributes
+        #
+        # @return [undefined]
+        #
+        # @api public
+        def initialize(aliases)
+          @aliases = Immutable.freeze_object(aliases.to_hash)
+        end
+
+        # Lookup the new attribute given the old attribute
+        #
+        # @example
+        #   new_attribute = aliases[old_attribute]
+        #
+        # @param [Attribute] attribute
+        #   the old attribute
+        #
+        # @return [Attribute]
+        #
+        # @api public
+        def [](attribute)
+          @aliases.fetch(attribute, attribute)
+        end
+
+        # Union the aliases with another set of aliases
+        #
+        # @example
+        #   new_aliases = aliases.union(other)
+        #
+        # @param [Aliases] other
+        #   the aliases to union with
+        #
+        # @return [Aliases]
+        #
+        # @api public
+        def union(other)
+          other_aliases = other.to_hash.dup
+          inverted      = other_aliases.invert
+
+          each do |old_attribute, new_attribute|
+            old_attribute = inverted.fetch(old_attribute, old_attribute)
+
+            if old_attribute.eql?(new_attribute)
+              other_aliases.delete(new_attribute)
+            else
+              other_aliases[old_attribute] = new_attribute
+            end
+          end
+
+          self.class.new(other_aliases)
+        end
+
+        # Iterate over each old and new attribute
+        #
+        # @example
+        #   aliases = Aliases.new(old => new)
+        #   aliases.each { |old, new| ... }
+        #
+        # @yield [old, new]
+        #
+        # @yieldparam [Attribute] old
+        #   the old attribute
+        # @yieldparam [Attribute] new
+        #   the new attribute
+        #
+        # @return [self]
+        #
+        # @api public
+        def each(&block)
+          @aliases.each(&block)
+          self
+        end
+
+        # Test if there are no aliases
+        #
+        # @example
+        #   aliases.empty?  # => true or false
+        #
+        # @return [Boolean]
+        #
+        # @api public
+        def empty?
+          @aliases.empty?
+        end
+
+        # Compare the aliases with other aliases for equivalency
+        #
+        # @example
+        #   aliases == other  # => true or false
+        #
+        # @param [Aliases] other
+        #   the other aliases to compare with
+        #
+        # @return [Boolean]
+        #
+        # @api public
+        def ==(other)
+          (kind_of?(other.class) || other.kind_of?(self.class)) &&
+          to_hash == other.to_hash
+        end
+
+        # Compare the aliases with other aliases for equality
+        #
+        # @example
+        #   aliases.eql?(other)  # => true or false
+        #
+        # @param [Aliases] other
+        #   the other aliases to compare with
+        #
+        # @return [Boolean]
+        #
+        # @api public
+        def eql?(other)
+          instance_of?(other.class) &&
+          to_hash.eql?(other.to_hash)
+        end
+
+        # Return the hash of the aliases
+        #
+        # @example
+        #   numeric_hash = aliases.hash
+        #
+        # @return [Integer]
+        #
+        # @api public
+        def hash
+          @aliases.hash
+        end
+
+        # Convert the aliases to a Hash
+        #
+        # @example
+        #   hash = aliases.to_hash
+        #
+        # @return [Hash]
+        #
+        # @api public
+        def to_hash
+          @aliases
+        end
+
+        # Coerce a Hash of old and new attributes into Aliases
+        #
+        # @param [Header] attributes
+        #   the header containing the old attributes
+        # @param [Aliases, #map] aliases
+        #   the aliases to coerce
+        #
+        # @return [Aliases]
+        #
+        # @api private
+        def self.coerce(attributes, aliases)
+          return aliases if aliases.kind_of?(Aliases)
+          renames = aliases.map do |old_attr, new_attr|
+            coerce_alias_pair(attributes, old_attr, new_attr)
+          end
+          new(Hash[renames].freeze)
+        end
+
+        # Coerce old and new attributes into Attribute objects
+        #
+        # @param [Header] attributes
+        #   the header containing the old attributes
+        # @param [Symbol, Attribute] old_attr
+        #   the old attribute name or Attribute object
+        # @param [Symbol, Attribute] new_attr
+        #   the new attribute name or Attribute object
+        #
+        # @return [Array(Attribute, Attribute)]
+        #
+        # @api private
+        def self.coerce_alias_pair(attributes, old_attr, new_attr)
+          old_attr = attributes[old_attr]      if old_attr.kind_of?(Symbol)
+          new_attr = old_attr.rename(new_attr) if new_attr.kind_of?(Symbol)
+          [ old_attr, new_attr ]
+        end
+
+        private_class_method :coerce_alias_pair
+
+        memoize :hash
+
+      end # class Aliases
+    end # class Rename
+  end # module Algebra
+end # module Veritas

data/lib/veritas/algebra/rename.rb

@@ -0,0 +1,91 @@
+module Veritas
+  module Algebra
+
+    # Rename attributes in the header
+    class Rename < Relation
+      include Relation::Operation::Unary
+
+      # The aliases for the relation
+      #
+      # @return [Aliases]
+      #
+      # @api private
+      attr_reader :aliases
+
+      # Initialize a Rename
+      #
+      # @param [Relation] operand
+      #   the relation to rename
+      # @param [Hash, Aliases] aliases
+      #   the old and new attribute names
+      #
+      # @return [undefined]
+      #
+      # @api private
+      def initialize(operand, aliases)
+        super(operand)
+        @aliases    = Aliases.coerce(@header, aliases)
+        @header     = @header.rename(@aliases)
+        @directions = @directions.rename(@aliases)
+      end
+
+      # Iterate over each tuple in the set
+      #
+      # @example
+      #   rename = Rename.new(operand, aliases)
+      #   rename.each { |tuple| ... }
+      #
+      # @yield [tuple]
+      #
+      # @yieldparam [Tuple] tuple
+      #   each tuple in the set
+      #
+      # @return [self]
+      #
+      # @api public
+      def each(&block)
+        operand.each { |tuple| yield Tuple.new(header, tuple.to_ary) }
+        self
+      end
+
+      # Compare the Rename with other relation for equality
+      #
+      # @example
+      #   rename.eql?(other)  # => true or false
+      #
+      # @param [Relation] other
+      #   the other relation to compare with
+      #
+      # @return [Boolean]
+      #
+      # @api public
+      def eql?(other)
+        super && aliases.eql?(other.aliases)
+      end
+
+      module Methods
+
+        # Return a relation with the header renamed
+        #
+        # @example
+        #   rename = relation.rename(:a => :b, :c => :d)
+        #
+        # @param [Hash, Aliases] aliases
+        #   the old and new attribute names
+        #
+        # @return [Rename]
+        #
+        # @api public
+        def rename(aliases)
+          Rename.new(self, aliases)
+        end
+
+      end # module Methods
+
+      Relation.class_eval { include Methods }
+
+    end # class Rename
+  end # module Algebra
+end # module Veritas
+
+require 'veritas/algebra/rename/aliases'