axiom 0.1.0

data/lib/axiom/algebra/summarization/summary.rb

@@ -0,0 +1,83 @@
+# encoding: utf-8
+
+module Axiom
+  module Algebra
+    class Summarization
+
+      # The summary for an aggregate function grouped by tuple
+      class Summary
+
+        # Initialize a Summary
+        #
+        # @param [#call] summarizer
+        #
+        # @return [undefined]
+        #
+        # @api private
+        def initialize(summarizer)
+          @summarizer = summarizer
+          @summary    = Hash.new(summary_default)
+        end
+
+        # Summarize the aggregate function by a tuple
+        #
+        # @example
+        #   summary = summary.summarize_by(projection, tuple)
+        #
+        # @param [Tuple] projection
+        #   the tuple projection to summarize the results by
+        # @param [Tuple] tuple
+        #   the tuple to execute the aggregate function with
+        #
+        # @return [self]
+        #
+        # @api public
+        def summarize_by(projection, tuple)
+          @summary[projection] = @summarizer.call(@summary[projection], tuple)
+          self
+        end
+
+        # Return the finalized summary for a tuple
+        #
+        # @example
+        #   object = summary.call(tuple)
+        #
+        # @param [Tuple] tuple
+        #
+        # @return [Object]
+        #
+        # @api public
+        def call(tuple)
+          summary_finalize(@summary[tuple])
+        end
+
+      private
+
+        # Return the summary default
+        #
+        # @return [Object]
+        #
+        # @api private
+        def summary_default
+          @summarizer.default if @summarizer.respond_to?(:default)
+        end
+
+        # Finalize the summary value if possible
+        #
+        # @param [Object] value
+        #
+        # @return [Object]
+        #
+        # @api private
+        def summary_finalize(value)
+          if @summarizer.respond_to?(:finalize)
+            @summarizer.finalize(value)
+          else
+            value
+          end
+        end
+
+      end # class Summary
+    end # class Summarization
+  end # module Algebra
+end # module Axiom

data/lib/axiom/algebra/union.rb

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

data/lib/axiom/attribute.rb

@@ -0,0 +1,207 @@
+# encoding: utf-8
+
+module Axiom
+
+  # Abstract base class representing a type of data in a relation tuple
+  class Attribute
+    extend Aliasable, DescendantsTracker
+    include AbstractType, ::Comparable, Visitable
+    include Equalizer.new(:name, :required?)
+
+    # The attribute name
+    #
+    # @return [Symbol]
+    #
+    # @api private
+    attr_reader :name
+
+    # The attribute options
+    #
+    # @return [Hash]
+    #
+    # @api private
+    attr_reader :options
+    private :options
+
+    # Coerce an object into an Attribute
+    #
+    # @param [Attribute, #to_ary, #to_sym] object
+    #   the object to coerce
+    #
+    # @return [Attribute]
+    #
+    # @api private
+    def self.coerce(object)
+      if object.kind_of?(Attribute)
+        object
+      else
+        name, type, options = object
+        klass = equal?(Attribute) ? Object : self
+        klass = const_get(type.name) if type
+        klass.new(name, options || EMPTY_HASH)
+      end
+    end
+
+    # Extract the attribute name from the object
+    #
+    # @param [#name, #to_ary, #to_a] object
+    #   the object to extract a name from
+    #
+    # @return [Symbol]
+    #
+    # @api private
+    def self.name_from(object)
+      if object.respond_to?(:name)
+        object.name
+      else
+        Array(object).first.to_sym
+      end
+    end
+
+    # Infer the Attribute type from the operand
+    #
+    # @param [Object] operand
+    #
+    # @return [Class<Attribute>]
+    #
+    # @api private
+    def self.infer_type(operand)
+      case operand
+      when Attribute, Function, Aggregate then operand.type
+      when FalseClass                     then Boolean
+      else
+        type = operand.class
+        descendants.detect { |descendant| type <= descendant.primitive }
+      end
+    end
+
+    # Initialize an Attribute
+    #
+    # @param [#to_sym] name
+    #   the attribute name
+    # @param [Hash] options
+    #   the options for the attribute
+    # @option options [Boolean] :required (true)
+    #   if true, then the value cannot be nil
+    #
+    # @return [undefined]
+    #
+    # @api private
+    def initialize(name, options = EMPTY_HASH)
+      @name     = name.to_sym
+      @options  = freeze_object(options)
+      @required = @options.fetch(:required, true)
+    end
+
+    # Extract the value corresponding to this attribute from a tuple
+    #
+    # @example
+    #   value = attribute.call(tuple)
+    #
+    # @param [Tuple] tuple
+    #   the tuple to extract the value from
+    #
+    # @return [Object]
+    #
+    # @api public
+    def call(tuple)
+      tuple.call(self)
+    end
+
+    # Rename an attribute
+    #
+    # @example
+    #   new_attribute = attribute.rename(new_name)
+    #
+    # @param [Symbol] new_name
+    #   the new name to rename the attribute to
+    #
+    # @return [Attribute]
+    #
+    # @todo Make this have the same API as functions
+    #
+    # @api public
+    def rename(new_name)
+      name.equal?(new_name) ? self : self.class.new(new_name, options)
+    end
+
+    # Return the type returned from #call
+    #
+    # @return [Class<Attribute>]
+    #
+    # @api public
+    def type
+      self.class
+    end
+
+    # Test if the attribute is required
+    #
+    # @example
+    #   attribute.required?  # => true or false
+    #
+    # @return [Boolean]
+    #
+    # @api public
+    def required?
+      @required
+    end
+
+    # Test if a value is the correct primitive type
+    #
+    # @example
+    #   attribute.valid_primitive?(value)  # => true or false
+    #
+    # @param [Object] value
+    #   the value to test
+    #
+    # @return [Boolean]
+    #
+    # @api public
+    def valid_primitive?(value)
+      value.kind_of?(self.class.primitive)
+    end
+
+    # Test if the value matches the attribute constraints
+    #
+    # @example
+    #   attribute.valid_value?(value)  # => true or false
+    #
+    # @param [Object] value
+    #   the value to test
+    #
+    # @return [Boolean]
+    #
+    # @api public
+    def valid_value?(value)
+      valid_or_optional?(value) { valid_primitive?(value) }
+    end
+
+  private
+
+    # Test that the value is either valid or optional
+    #
+    # @param [Object] value
+    #   the value to test
+    #
+    # @yield [] block representing attribute constraint
+    #
+    # @return [Boolean]
+    #
+    # @api private
+    def valid_or_optional?(value)
+      value.nil? ? ! required? : yield
+    end
+
+    # Coerce the object into an Attribute
+    #
+    # @param [Array] args
+    #
+    # @return [Attribute]
+    #
+    # @api private
+    def coerce(*args)
+      self.class.coerce(*args)
+    end
+
+  end # class Attribute
+end # module Axiom

data/lib/axiom/attribute/boolean.rb

@@ -0,0 +1,41 @@
+# encoding: utf-8
+
+module Axiom
+  class Attribute
+
+    # Represents a Boolean value in a relation tuple
+    class Boolean < Object
+      include Function::Connective::Conjunction::Methods,
+              Function::Connective::Disjunction::Methods,
+              Function::Connective::Negation::Methods
+
+      # The Boolean primitive
+      #
+      # @example
+      #   Boolean.primitive  # => TrueClass
+      #
+      # @return [Class<TrueClass>]
+      #
+      # @api public
+      def self.primitive
+        TrueClass
+      end
+
+      # Test if the value is a boolean
+      #
+      # @example
+      #   boolean.valid_value?(value)  # => true or false
+      #
+      # @param [Object] value
+      #   the value to test
+      #
+      # @return [Boolean]
+      #
+      # @api public
+      def valid_value?(value)
+        valid_or_optional?(value) { super || value.kind_of?(FalseClass) }
+      end
+
+    end # class Boolean
+  end # class Attribute
+end # module Axiom

data/lib/axiom/attribute/class.rb

@@ -0,0 +1,23 @@
+# encoding: utf-8
+
+module Axiom
+  class Attribute
+
+    # Represents a Class value in a relation tuple
+    class Class < Object
+
+      # The Class primitive
+      #
+      # @example
+      #   Class.primitive  # => ::Class
+      #
+      # @return [Class<::Class>]
+      #
+      # @api public
+      def self.primitive
+        ::Class
+      end
+
+    end # class Class
+  end # class Attribute
+end # module Axiom

data/lib/axiom/attribute/comparable.rb

@@ -0,0 +1,44 @@
+# encoding: utf-8
+
+module Axiom
+  class Attribute
+
+    # A mixin for attributes that have comparable values
+    module Comparable
+      include Function::Predicate::GreaterThan::Methods,
+              Function::Predicate::GreaterThanOrEqualTo::Methods,
+              Function::Predicate::LessThan::Methods,
+              Function::Predicate::LessThanOrEqualTo::Methods,
+              Aggregate::Minimum::Methods,
+              Aggregate::Maximum::Methods,
+              Aggregate::Mean::Methods,
+              Aggregate::Variance::Methods,
+              Aggregate::StandardDeviation::Methods
+
+      # Sort the attribute in ascending order
+      #
+      # @example
+      #   ascending = attribute.asc
+      #
+      # @return [Relation::Operation::Order::Ascending]
+      #
+      # @api public
+      def asc
+        Relation::Operation::Order::Ascending.new(self)
+      end
+
+      # Sort the attribute in descending order
+      #
+      # @example
+      #   descending = attribute.desc
+      #
+      # @return [Relation::Operation::Order::Descending]
+      #
+      # @api public
+      def desc
+        Relation::Operation::Order::Descending.new(self)
+      end
+
+    end # module Comparable
+  end # class Attribute
+end # module Axiom