axiom 0.1.0

data/lib/axiom/relation/materialized.rb

@@ -0,0 +1,71 @@
+# encoding: utf-8
+
+module Axiom
+  class Relation
+
+    # A materialized relation
+    class Materialized < Relation
+
+      # The relation sort order
+      #
+      # @return [Operation::Order::DirectionSet]
+      #
+      # @api private
+      attr_reader :directions
+
+      # Initialize a materialized Relation
+      #
+      # @param [Header, #to_ary] header
+      #   the relation header
+      # @param [Enumerable] tuples
+      #   the relation tuples
+      # @param [Operation::Order::DirectionSet] directions
+      #   optional directions to sort the relation by
+      #
+      # @return [undefined]
+      #
+      # @api private
+      def initialize(header, tuples, directions = Operation::Order::DirectionSet::EMPTY)
+        super(header, tuples)
+        @directions = Operation::Order::DirectionSet.coerce(directions)
+      end
+
+      # A noop for Materialized relations
+      #
+      # @example
+      #   materialized.materialize  # (Always returns self)
+      #
+      # @return [self]
+      #
+      # @api public
+      def materialize
+        self
+      end
+
+      # Return true for a Materialized relation
+      #
+      # @example
+      #   relation.materialized?  # => true
+      #
+      # @return [true]
+      #
+      # @api public
+      def materialized?
+        true
+      end
+
+      # Return the number of tuples
+      #
+      # @example
+      #   materialized.size  # => 10
+      #
+      # @return [Integer]
+      #
+      # @api public
+      def size
+        tuples.size
+      end
+
+    end # class Materialized
+  end # class Relation
+end # module Axiom

data/lib/axiom/relation/operation/binary.rb

@@ -0,0 +1,77 @@
+# encoding: utf-8
+
+module Axiom
+  class Relation
+    module Operation
+
+      # A mixin for Binary relations
+      module Binary
+        include Axiom::Operation::Binary
+
+        # Hook called when module is included
+        #
+        # @param [Module] descendant
+        #   the module or class including Binary
+        #
+        # @return [undefined]
+        #
+        # @api private
+        def self.included(descendant)
+          super
+          descendant.extend(ClassMethods)
+        end
+
+        private_class_method :included
+
+        # Initialize a Binary relation
+        #
+        # @return [undefined]
+        #
+        # @api private
+        def initialize(*)
+          super
+          @header = left.header | right.header
+        end
+
+        module ClassMethods
+
+          # Instantiate a new Binary relation
+          #
+          # @example
+          #   binary = BinaryRelation.new(left, right)
+          #
+          # @param [Relation] left
+          # @param [Relation] right
+          #
+          # @return [Binary]
+          #
+          # @api public
+          def new(left, right)
+            assert_ordered_match(left, right)
+            super
+          end
+
+        private
+
+          # Assert that ordered and unordered relations are not mixed
+          #
+          # @param [Relation] left
+          # @param [Relation] right
+          #
+          # @return [undefined]
+          #
+          # @raise [RelationMismatchError]
+          #   raised if one relation is ordered and the other is not
+          #
+          # @api private
+          def assert_ordered_match(left, right)
+            if left.directions.empty? != right.directions.empty?
+              raise RelationMismatchError, 'both relations must be ordered or neither may be ordered'
+            end
+          end
+
+        end # module ClassMethods
+      end # module Binary
+    end # module Operation
+  end # class Relation
+end # module Axiom

data/lib/axiom/relation/operation/combination.rb

@@ -0,0 +1,37 @@
+# encoding: utf-8
+
+module Axiom
+  class Relation
+    module Operation
+
+      # A mixin for relations that combine their operands
+      module Combination
+        include Binary
+
+        # Combine tuples together and yield the joined tuple
+        #
+        # @param [Header] header
+        #   the header to use for the resulting tuples
+        # @param [Tuple] left_tuple
+        #   the left tuple to join with
+        # @param [Enumerable<Tuple>] right_tuples
+        #   the tuples to join to the left tuple
+        #
+        # @yield [tuple]
+        #
+        # @yieldparam [Tuple] tuple
+        #   each joined tuple
+        #
+        # @return [undefined]
+        #
+        # @api private
+        def self.combine_tuples(header, left_tuple, right_tuples)
+          right_tuples.each do |right_tuple|
+            yield left_tuple.join(header, right_tuple)
+          end
+        end
+
+      end # module Combination
+    end # module Operation
+  end # class Relation
+end # module Axiom

data/lib/axiom/relation/operation/deletion.rb

@@ -0,0 +1,45 @@
+# encoding: utf-8
+
+module Axiom
+  class Relation
+    module Operation
+
+      # A class representing a deletion from a relation
+      class Deletion < Relation
+        include Proxy
+
+        # Initialize a Deletion
+        #
+        # @param [Array(Relation, Relation)] args
+        #
+        # @return [undefined]
+        #
+        # @api private
+        def initialize(*args)
+          @relation = Algebra::Difference.new(*args)
+        end
+
+        module Methods
+
+          # Return a relation that represents a deletion from a relation
+          #
+          # @example
+          #   deletion = relation.delete(other)
+          #
+          # @param [Enumerable] other
+          #
+          # @return [Deletion]
+          #
+          # @api public
+          def delete(other)
+            Deletion.new(self, coerce(other))
+          end
+
+        end # module Methods
+
+        Relation.class_eval { include Methods }
+
+      end # class Deletion
+    end # module Operation
+  end # class Relation
+end # module Axiom

data/lib/axiom/relation/operation/insertion.rb

@@ -0,0 +1,45 @@
+# encoding: utf-8
+
+module Axiom
+  class Relation
+    module Operation
+
+      # A class representing an insertion into a relation
+      class Insertion < Relation
+        include Proxy
+
+        # Initialize an Insertion
+        #
+        # @param [Array(Relation, Relation)] args
+        #
+        # @return [undefined]
+        #
+        # @api private
+        def initialize(*args)
+          @relation = Algebra::Union.new(*args)
+        end
+
+        module Methods
+
+          # Return a relation that represents an insertion into a relation
+          #
+          # @example
+          #   insertion = relation.insert(other)
+          #
+          # @param [Enumerable] other
+          #
+          # @return [Insertion]
+          #
+          # @api public
+          def insert(other)
+            Insertion.new(self, coerce(other))
+          end
+
+        end # module Methods
+
+        Relation.class_eval { include Methods }
+
+      end # class Insertion
+    end # module Operation
+  end # class Relation
+end # module Axiom

data/lib/axiom/relation/operation/limit.rb

@@ -0,0 +1,211 @@
+# encoding: utf-8
+
+module Axiom
+  class Relation
+    module Operation
+
+      # A class representing a limited relation
+      class Limit < Relation
+        include Unary
+        include Equalizer.new(:operand, :limit)
+
+        # Return the limit
+        #
+        # @example
+        #   limit = limited_relation.limit
+        #
+        # @return [Integer]
+        #
+        # @api public
+        attr_reader :limit
+
+        # The relation sort order
+        #
+        # @return [Operation::Order::DirectionSet]
+        #
+        # @api private
+        attr_reader :directions
+
+        # Instantiate a new Limit
+        #
+        # @example
+        #   limited_relation = Limit.new(operand, limit)
+        #
+        # @param [Relation] operand
+        #   the relation to limit
+        # @param [Integer] limit
+        #   the maximum number of tuples in the limited relation
+        #
+        # @return [Limit]
+        #
+        # @api public
+        def self.new(operand, limit)
+          assert_ordered_operand(operand)
+          assert_valid_limit(limit)
+          super
+        end
+
+        # Assert the operand is ordered
+        #
+        # @param [Relation] operand
+        #
+        # @return [undefined]
+        #
+        # @raise [OrderedRelationRequiredError]
+        #   raised if the operand is unordered
+        #
+        # @api private
+        def self.assert_ordered_operand(operand)
+          if operand.header.to_ary.size != operand.directions.to_ary.size
+            raise OrderedRelationRequiredError, 'can only limit an ordered operand'
+          end
+        end
+
+        # Assert the limit is valid
+        #
+        # @param [Integer] limit
+        #
+        # @return [undefined]
+        #
+        # @raise [InvalidLimitError]
+        #   raised if the limit is less than 0
+        #
+        # @api private
+        def self.assert_valid_limit(limit)
+          if limit.nil? || limit < 0
+            raise InvalidLimitError, "limit must be greater than or equal to 0, but was #{limit.inspect}"
+          end
+        end
+
+        private_class_method :assert_ordered_operand, :assert_valid_limit
+
+        # Initialize a Limit
+        #
+        # @param [Relation] operand
+        #   the relation to limit
+        # @param [Integer] limit
+        #   the maximum number of tuples in the limited relation
+        #
+        # @return [undefined]
+        #
+        # @api private
+        def initialize(operand, limit)
+          super(operand)
+          @limit      = limit
+          @directions = operand.directions
+        end
+
+        # Iterate over each tuple in the set
+        #
+        # @example
+        #   limited_relation = Limit.new(operand, limit)
+        #   limited_relation.each { |tuple| ... }
+        #
+        # @yield [tuple]
+        #
+        # @yieldparam [Tuple] tuple
+        #   each tuple in the set
+        #
+        # @return [self]
+        #
+        # @api public
+        def each
+          return to_enum unless block_given?
+          operand.each_with_index do |tuple, index|
+            break if @limit == index
+            yield tuple
+          end
+          self
+        end
+
+        # Raise an exception when inserting into the Limit
+        #
+        # @example
+        #   limit.insert(other)  # => ImmutableRelationError raised
+        #
+        # @return [undefined]
+        #
+        # @raise [ImmutableRelationError]
+        #   raised when inserting into the limit
+        #
+        # @api public
+        def insert(*)
+          raise ImmutableRelationError, 'inserting into a limit is impossible'
+        end
+
+        # Raise an exception when deleting from the Limit
+        #
+        # @example
+        #   limit.delete(other)  # => ImmutableRelationError raised
+        #
+        # @return [undefined]
+        #
+        # @raise [ImmutableRelationError]
+        #   raised when deleting from the limit
+        #
+        # @api public
+        def delete(*)
+          raise ImmutableRelationError, 'deleting from a limit is impossible'
+        end
+
+        module Methods
+
+          # Return a relation with n tuples
+          #
+          # @example
+          #   limited_relation = relation.take(5)
+          #
+          # @param [Integer] limit
+          #   the maximum number of tuples in the limited relation
+          #
+          # @return [Limit]
+          #
+          # @api public
+          def take(limit)
+            Limit.new(self, limit)
+          end
+
+          # Return a relation with the first n tuples
+          #
+          # @example with no limit
+          #   limited_relation = relation.first
+          #
+          # @example with a limit
+          #   limited_relation = relation.first(5)
+          #
+          # @param [Integer] limit
+          #   optional number of tuples from the beginning of the relation
+          #
+          # @return [Limit]
+          #
+          # @api public
+          def first(limit = 1)
+            take(limit)
+          end
+
+          # Return a relation with the last n tuples
+          #
+          # @example with no limit
+          #   limited_relation = relation.last
+          #
+          # @example with a limit
+          #   limited_relation = relation.last(5)
+          #
+          # @param [Integer] limit
+          #   optional number of tuples from the end of the relation
+          #
+          # @return [Limit]
+          #
+          # @api public
+          def last(limit = 1)
+            reverse.take(limit).reverse
+          end
+
+        end # module Methods
+
+        Relation.class_eval { include Methods }
+
+      end # class Limit
+    end # module Operation
+  end # class Relation
+end # module Axiom