veritas 0.0.3 → 0.0.4

data/lib/veritas/aggregate/variance.rb

@@ -0,0 +1,81 @@
+# encoding: utf-8
+
+module Veritas
+  class Aggregate
+
+    # The variance of a sequence of numbers
+    class Variance < Aggregate
+
+      DEFAULT = [ 0, nil, 0.0 ].freeze
+
+      # Return the count, mean, and sum of squares for a sequence of numbers
+      #
+      # @example
+      #   count, mean, sum_of_squares = Variance.call(accumulator, value)
+      #
+      # @param [Array(Integer, Numeric, Float)] accumulator
+      #
+      # @param [Numeric] value
+      #
+      # @return [Array(Integer, Numeric, Numeric)]
+      #
+      # @api public
+      def self.call(accumulator, value)
+        return accumulator if value.nil?
+        mean, sum_of_squares  = accumulator.last(2)
+        delta                 = mean.nil? ? value : value - mean
+        count, new_mean       = Mean.call(accumulator, value)
+        sum_of_squares       += delta * (value - new_mean)
+        [ count, new_mean, sum_of_squares ]
+      end
+
+      # Calculate the variance from the accumulator
+      #
+      # @example
+      #   variance = Variance.finalize(accumulator)
+      #
+      # @param [Array(Numeric, Integer, Float)] accumulator
+      #
+      # @return [Float]
+      #   returned for a non-empty set
+      # @return [nil]
+      #   returned for an empty set
+      #
+      # @api public
+      def self.finalize(accumulator)
+        sum_of_squares, count = accumulator.values_at(2, 0)
+        sum_of_squares / count unless count.zero?
+      end
+
+      # Return the type returned from #call
+      #
+      # @return [Class<Attribute::Float>]
+      #
+      # @api public
+      def type
+        Attribute::Float
+      end
+
+      module Methods
+        extend Aliasable
+
+        inheritable_alias(:var => :variance)
+
+        # Return a variance aggregate function
+        #
+        # @example
+        #   variance = attribute.variance
+        #
+        # @param [Attribute]
+        #
+        # @return [Variance]
+        #
+        # @api public
+        def variance
+          Variance.new(self)
+        end
+
+      end # module Methods
+    end # class Variance
+  end # class Aggregate
+end # module Veritas

data/lib/veritas/aggregate.rb

@@ -0,0 +1,116 @@
+# encoding: utf-8
+
+module Veritas
+
+  # Abstract class for aggregate functions
+  class Aggregate
+    include AbstractClass, Immutable, Visitable, Operation::Unary
+
+    # Return the default accumulator
+    #
+    # @example
+    #   default = Aggregate.default
+    #
+    # @return [Object]
+    #
+    # @api public
+    def self.default
+      self::DEFAULT
+    end
+
+    # Evaluate the aggregate using the operands
+    #
+    # @example
+    #   Aggregate.call  # => raises NotImplementedError
+    #
+    # @return [Object]
+    #
+    # @api public
+    def self.call(*)
+      raise NotImplementedError, "#{name}.call must be implemented"
+    end
+
+    # Returns the value extracted from the accumulator
+    #
+    # Default behaviour is to pass-through the accumulator
+    #
+    # @example
+    #   value = Aggregate.finalize(accumulator)
+    #
+    # @return [Object]
+    #
+    # @api public
+    def self.finalize(accumulator)
+      accumulator
+    end
+
+    # Return the default for this aggregate
+    #
+    # @example
+    #   default = aggregate.default
+    #
+    # @return [Object]
+    #
+    # @api public
+    def default
+      self.class.default
+    end
+
+    # Evaluate the aggregate using the provided Tuple
+    #
+    # @example
+    #   accumulator = aggregate.call(accumulator, tuple)
+    #
+    # @param [Object] accumulator
+    #
+    # @param [Tuple] tuple
+    #
+    # @return [Object]
+    #
+    # @api public
+    def call(accumulator, tuple)
+      self.class.call(accumulator, value(tuple))
+    end
+
+    # Finalize the accumulator value
+    #
+    # @example
+    #   value = aggregate.finalize(accumulator)
+    #
+    # @return [Object]
+    #
+    # @api public
+    def finalize(accumulator)
+      self.class.finalize(accumulator)
+    end
+
+    # Return the type returned from #call
+    #
+    # @return [Class<Attribute>]
+    #
+    # @api public
+    def type
+      raise NotImplementedError, "#{self.class}#type must be implemented"
+    end
+
+  private
+
+    # Extract the value from the operand or tuple
+    #
+    # @param [Object, #call] operand
+    #   the operand to extract the value from
+    # @param [Tuple] tuple
+    #   the tuple to pass in to the operand if it responds to #call
+    #
+    # @return [Object]
+    #
+    # @todo Aggregate will inherit from Function, then use as Function.value
+    #
+    # @api private
+    def value(tuple)
+      operand = self.operand
+      operand.respond_to?(:call) ? operand.call(tuple) : operand
+    end
+
+  end # class Aggregate
+end # module Veritas

data/lib/veritas/algebra/difference.rb

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 module Veritas
   module Algebra
 
@@ -22,7 +24,7 @@ module Veritas
       def each
         return to_enum unless block_given?
         right_set = right.to_set
-        left.each { |tuple| yield(tuple) unless right_set.include?(tuple) }
+        left.each { |tuple| yield tuple unless right_set.include?(tuple) }
         self
       end
 

data/lib/veritas/algebra/extension.rb

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 module Veritas
   module Algebra
 
@@ -46,7 +48,7 @@ module Veritas
         return to_enum unless block_given?
         header     = self.header
         extensions = self.extensions.values
-        operand.each { |tuple| yield tuple.extend(header, extensions) }
+        operand.each { |operand_tuple| yield operand_tuple.extend(header, extensions) }
         self
       end
 
@@ -82,22 +84,22 @@ module Veritas
         # Return an extended relation
         #
         # @example
-        #   extension = relation.extend do |expression|
-        #     expression.add(:total, expression[:unit_price] * expression[:quantity])
+        #   extension = relation.extend do |context|
+        #     context.add(:total, context[:unit_price] * context[:quantity])
         #   end
         #
-        # @yield [expression]
-        #   Evaluate an extension expression
+        # @yield [function]
+        #   Evaluate an extension function
         #
-        # @yieldparam [Evaluator::Expression] expression
-        #   the context to evaluate the extension with
+        # @yieldparam [Evaluator::Context] context
+        #   the context to evaluate the function within
         #
         # @return [Extension]
         #
         # @api public
-        def extend(&block)
-          evaluator = Evaluator::Expression.new(&block)
-          Extension.new(self, evaluator.expressions)
+        def extend
+          context = Evaluator::Context.new(header) { |context| yield context }
+          Extension.new(self, context.functions)
         end
 
       end # module Methods

data/lib/veritas/algebra/intersection.rb

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 module Veritas
   module Algebra
 
@@ -22,7 +24,7 @@ module Veritas
       def each
         return to_enum unless block_given?
         right_set = right.to_set
-        left.each { |tuple| yield(tuple) if right_set.include?(tuple) }
+        left.each { |tuple| yield tuple if right_set.include?(tuple) }
         self
       end
 

data/lib/veritas/algebra/join.rb

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 module Veritas
   module Algebra
 
@@ -72,11 +74,12 @@ module Veritas
       def each(&block)
         return to_enum unless block_given?
         index = build_index
+        util  = Relation::Operation::Combination
 
-        left.each do |tuple|
-          right_tuples = index[join_tuple(tuple)]
+        left.each do |left_tuple|
+          right_tuples = index[join_tuple(left_tuple)]
           if right_tuples
-            Relation::Operation::Combination.combine_tuples(header, tuple, right_tuples, &block)
+            util.combine_tuples(header, left_tuple, right_tuples, &block)
           end
         end
 
@@ -128,16 +131,11 @@ module Veritas
         # @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
@@ -145,12 +143,15 @@ module Veritas
         # @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, predicate = nil, &block)
-          if predicate || block_given?
-            theta_join(other, predicate, &block)
+        def join(other)
+          if block_given?
+            theta_join(other) { |relation| yield relation }
           else
             natural_join(other)
           end
@@ -174,8 +175,6 @@ module Veritas
         #
         # @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
@@ -183,11 +182,14 @@ module Veritas
         # @yieldparam [Relation] relation
         #   the context to evaluate the restriction with
         #
+        # @yieldreturn [Function, #call]
+        #   predicate to restrict the tuples with
+        #
         # @return [Restriction]
         #
         # @api private
-        def theta_join(other, *args, &block)
-          product(other).restrict(*args.compact, &block)
+        def theta_join(other)
+          product(other).restrict { |relation| yield relation }
         end
 
       end # module Methods

data/lib/veritas/algebra/product.rb

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 module Veritas
   module Algebra
 
@@ -56,8 +58,8 @@ module Veritas
       # @api public
       def each(&block)
         return to_enum unless block_given?
-        left.each do |tuple|
-          Relation::Operation::Combination.combine_tuples(header, tuple, right, &block)
+        left.each do |left_tuple|
+          Relation::Operation::Combination.combine_tuples(header, left_tuple, right, &block)
         end
         self
       end

data/lib/veritas/algebra/projection.rb

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 module Veritas
   module Algebra
 
@@ -17,8 +19,7 @@ module Veritas
       # @api private
       def initialize(operand, attributes)
         super(operand)
-        @header     = @header.project(attributes.to_ary)
-        @directions = Relation::Operation::Order::DirectionSet::EMPTY
+        @header = @header.project(attributes.to_ary)
       end
 
       # Iterate over each tuple in the set
@@ -40,7 +41,7 @@ module Veritas
         seen = {}
         operand.each do |tuple|
           tuple = tuple.project(header)
-          yield(seen[tuple] = tuple) unless seen.key?(tuple)
+          yield seen[tuple] = tuple unless seen.key?(tuple)
         end
         self
       end

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

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 module Veritas
   module Algebra
     class Rename
@@ -105,17 +107,17 @@ module Veritas
         #
         # @yield [old, new]
         #
-        # @yieldparam [Attribute] old
+        # @yieldparam [Attribute] old_attribute
         #   the old attribute
-        # @yieldparam [Attribute] new
+        # @yieldparam [Attribute] new_attribute
         #   the new attribute
         #
         # @return [self]
         #
         # @api public
-        def each(&block)
+        def each
           return to_enum unless block_given?
-          @aliases.each(&block)
+          @aliases.each { |old_attribute, new_attribute| yield old_attribute, new_attribute }
           self
         end
 

data/lib/veritas/algebra/rename.rb

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 module Veritas
   module Algebra
 
@@ -12,6 +14,13 @@ module Veritas
       # @api private
       attr_reader :aliases
 
+      # The relation sort order
+      #
+      # @return [Operation::Order::DirectionSet]
+      #
+      # @api private
+      attr_reader :directions
+
       # Initialize a Rename
       #
       # @param [Relation] operand
@@ -26,7 +35,7 @@ module Veritas
         super(operand)
         @aliases    = Aliases.coerce(@header, aliases)
         @header     = @header.rename(@aliases)
-        @directions = @directions.rename(@aliases)
+        @directions = operand.directions.rename(@aliases)
       end
 
       # Iterate over each tuple in the set
@@ -43,9 +52,9 @@ module Veritas
       # @return [self]
       #
       # @api public
-      def each(&block)
+      def each
         return to_enum unless block_given?
-        operand.each { |tuple| yield Tuple.new(header, tuple.to_ary) }
+        operand.each { |operand_tuple| yield Tuple.new(header, operand_tuple.to_ary) }
         self
       end
 

data/lib/veritas/algebra/restriction.rb

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 module Veritas
   module Algebra
 
@@ -7,7 +9,7 @@ module Veritas
 
       # The predicate for the relation
       #
-      # @return [Expression, #call]
+      # @return [Function, #call]
       #
       # @api private
       attr_reader :predicate
@@ -16,8 +18,8 @@ module Veritas
       #
       # @param [Relation] operand
       #   the relation to restrict
-      # @param [Expression, #call] predicate
-      #   the expression to restrict the tuples with
+      # @param [Function, #call] predicate
+      #   the function to restrict the tuples with
       #
       # @return [undefined]
       #
@@ -43,7 +45,9 @@ module Veritas
       # @api public
       def each
         return to_enum unless block_given?
-        operand.each { |tuple| yield(tuple) if predicate.call(tuple) }
+        operand.each do |tuple|
+          yield tuple if Function.extract_value(predicate, tuple).equal?(true)
+        end
         self
       end
 
@@ -78,26 +82,23 @@ module Veritas
 
         # Return a relation with restricted tuples
         #
-        # @example restriction using a predicate
-        #   restriction = relation.restrict(relation.name.eq('other'))
-        #
         # @example restriction using a block
         #   restriction = relation.restrict { |r| r[:a].eq('other').and(r[:b].gte(42)) }
         #
-        # @param [Expression, #call] predicate
-        #   optional 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
         #
+        # @yieldreturn [Function, #call]
+        #   predicate to restrict the tuples with
+        #
         # @return [Restriction]
         #
         # @api public
-        def restrict(predicate = yield(self))
-          Restriction.new(self, predicate)
+        def restrict
+          Restriction.new(self, yield(self))
         end
 
       end # module Methods

data/lib/veritas/algebra/summarization/summaries.rb

@@ -0,0 +1,59 @@
+# encoding: utf-8
+
+module Veritas
+  module Algebra
+    class Summarization
+
+      # Summaries for all aggregate functions
+      class Summaries
+
+        # Initialize Summaries
+        #
+        # @param [Hash{Symbol => #call}] summarizers
+        #
+        # @return [undefined]
+        #
+        # @api private
+        def initialize(summarizers)
+          @summaries = {}
+          summarizers.each do |name, summarizer|
+            @summaries[name] = Summary.new(summarizer)
+          end
+        end
+
+        # Execute all summarizers with the tuple, summarized by the header
+        #
+        # @example
+        #   summaries = summaries.summarize_by(header, tuple)
+        #
+        # @param [Header] header
+        #
+        # @param [Tuple] tuple
+        #
+        # @return [self]
+        #
+        # @api public
+        def summarize_by(header, tuple)
+          projection = tuple.project(header)
+          @summaries.each_value do |summary|
+            summary.summarize_by(projection, tuple)
+          end
+          self
+        end
+
+        # Return the summaries as a Hash
+        #
+        # @example
+        #   hash = summaries.to_hash
+        #
+        # @return [Hash]
+        #
+        # @api public
+        def to_hash
+          @summaries
+        end
+
+      end # class Summaries
+    end # class Summarization
+  end # module Algebra
+end # module Veritas

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

@@ -0,0 +1,83 @@
+# encoding: utf-8
+
+module Veritas
+  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 Veritas