veritas-optimizer 0.0.3 → 0.0.4

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

@@ -7,13 +7,6 @@ module Veritas
       # Abstract base class representing Rename optimizations
       class Rename < Relation::Operation::Unary
 
-        # The renamed header
-        #
-        # @return [Header]
-        #
-        # @api private
-        attr_reader :header
-
         # The optimized aliases
         #
         # @return [Rename::Aliases]
@@ -30,8 +23,7 @@ module Veritas
         # @api private
         def initialize(operation)
           super
-          @header  = operation.header
-          @aliases = self.class.union_aliases(operation.aliases, operand)
+          @aliases = operation.aliases
         end
 
       private
@@ -41,53 +33,46 @@ module Veritas
         # @return [Rename]
         #
         # @api private
-        def wrap_operand
-          operation.class.new(operand.operand, aliases)
+        def wrap_operand(operand = operand.operand)
+          operation.class.new(operand, aliases)
         end
 
-        # Union the operation aliases with any operand aliases
-        #
-        # @param [Rename::Aliases]
-        #   the original aliases
-        # @param [Relation]
-        #   the operand
-        #
-        # @return [Rename::Aliases]
-        #
-        # @api private
-        def self.union_aliases(aliases, operand)
-          if operand.respond_to?(:aliases)
-            aliases.union(operand.aliases)
-          else
-            aliases
-          end
-        end
-
-        # Optimize when the headers are not changed
-        class UnchangedHeader < self
+        # Optimize when the operand is a Rename
+        class RenameOperand < self
 
-          # Test if the renamed headers are the same as the operand's
+          # Test if the operand is a Rename
           #
           # @return [Boolean]
           #
           # @api private
           def optimizable?
-            header.to_a == operand.header.to_a
+            operand.kind_of?(operation.class)
           end
 
-          # A Rename with unchanged headers is a noop
+          # Flatten nested Renames into a single Rename
           #
-          # @return [Relation]
+          # @return [Projection]
           #
           # @api private
           def optimize
-            operand
+            wrap_operand
           end
 
-        end # class UnchangedHeader
+        private
+
+          # The optimized aliases
+          #
+          # @return [Rename::Aliases]
+          #
+          # @api private
+          def aliases
+            super.union(operand.aliases)
+          end
+
+        end # class RenameOperand
 
         # Optimize when the operand is a Rename with aliases that cancel out
-        class RenameOperandAndEmptyAliases < self
+        class RenameOperandAndEmptyAliases < RenameOperand
 
           # Test if the operand is a Rename with aliases that cancel out
           #
@@ -95,7 +80,7 @@ module Veritas
           #
           # @api private
           def optimizable?
-            operand.kind_of?(operation.class) && aliases.empty?
+            super && aliases.empty?
           end
 
           # A Rename wrapping a Rename with aliases that cancel out is a noop
@@ -109,48 +94,56 @@ module Veritas
 
         end # class RenameOperandAndEmptyAliases
 
-        # Optimize when the operand is a Rename
-        class RenameOperand < self
+        # Optimize when the operand is a Projection
+        class ProjectionOperand < self
 
-          # Test if the operand is a Rename
+          # Test if the operand is a Projection
           #
           # @return [Boolean]
           #
           # @api private
           def optimizable?
-            operand.kind_of?(operation.class)
+            operand.kind_of?(Veritas::Algebra::Projection) && distributive?
           end
 
-          # Flatten nested Renames into a single Rename
+          # Wrap the Rename in a Projection
           #
           # @return [Projection]
           #
           # @api private
           def optimize
-            operation.class.new(operand.operand, aliases)
+            operand.class.new(wrap_operand, header)
           end
 
-        end # class RenameOperand
-
-        # Optimize when the operand is a Projection
-        class ProjectionOperand < self
+        private
 
-          # Test if the operand is a Projection
+          # Test if the rename can be distributed over the projection
           #
           # @return [Boolean]
           #
           # @api private
-          def optimizable?
-            operand.kind_of?(Veritas::Algebra::Projection)
+          def distributive?
+            names = alias_names
+            removed_attributes.all? { |attribute| !names.include?(attribute.name) }
           end
 
-          # Wrap the Rename in a Projection
+          # Return the aliases as an inverted Hash
           #
-          # @return [Projection]
+          # @return [Hash]
           #
           # @api private
-          def optimize
-            operand.class.new(wrap_operand, header)
+          def alias_names
+            aliases.to_hash.values.map { |attribute| attribute.name }
+          end
+
+          # Returns the attributes removed from the projection
+          #
+          # @return [#all?]
+          #
+          # @api private
+          def removed_attributes
+            operand = self.operand
+            operand.operand.header - operand.header
           end
 
         end # class ProjectionOperand
@@ -180,7 +173,7 @@ module Veritas
 
           # Rename the operand predicate
           #
-          # @return [Expression]
+          # @return [Function]
           #
           # @api private
           def rename_predicate
@@ -218,7 +211,7 @@ module Veritas
           #
           # @api private
           def wrap_left
-            operation.class.new(operand.left, aliases)
+            wrap_operand(operand.left)
           end
 
           # Utility method to wrap the right operand in a Rename
@@ -227,7 +220,7 @@ module Veritas
           #
           # @api private
           def wrap_right
-            operation.class.new(operand.right, aliases)
+            wrap_operand(operand.right)
           end
 
         end # class SetOperand
@@ -257,15 +250,7 @@ module Veritas
 
         # Optimize when the operand is an Order
         class OrderOperand < self
-
-          # Test if the operand is an Order
-          #
-          # @return [Boolean]
-          #
-          # @api private
-          def optimizable?
-            operand.kind_of?(Veritas::Relation::Operation::Order)
-          end
+          include Relation::Operation::Unary::OrderOperand
 
           # Wrap the Rename in an Order
           #
@@ -351,17 +336,7 @@ module Veritas
 
         # Optimize when operand is optimizable
         class UnoptimizedOperand < self
-
-          # Test if the operand is unoptimized
-          #
-          # @return [Boolean]
-          #
-          # @api private
-          def optimizable?
-            operation = self.operation
-            !operand.equal?(operation.operand) ||
-            !aliases.equal?(operation.aliases)
-          end
+          include Function::Unary::UnoptimizedOperand
 
           # Return a Rename with an optimized operand
           #
@@ -369,7 +344,7 @@ module Veritas
           #
           # @api private
           def optimize
-            operation.class.new(operand, aliases)
+            wrap_operand(operand)
           end
 
         end # class UnoptimizedOperand

data/lib/veritas/optimizer/algebra/restriction.rb

@@ -9,7 +9,7 @@ module Veritas
 
         # The optimized predicate
         #
-        # @return [Expression]
+        # @return [Function]
         #
         # @api private
         attr_reader :predicate
@@ -21,7 +21,7 @@ module Veritas
         # @api private
         def initialize(*)
           super
-          @predicate = self.class.optimize_predicate(operation.predicate)
+          @predicate = Function.optimize_operand(operation.predicate)
         end
 
       private
@@ -31,19 +31,28 @@ module Veritas
         # @return [Restriction]
         #
         # @api private
-        def wrap_operand
-          operation.class.new(operand.operand, predicate)
+        def wrap_operand(operand = operand.operand)
+          operation.class.new(operand, predicate)
         end
 
-        # Optimize the predicate if possible
+        # Return true if the predicate is a true value
         #
-        # @param [Expression] predicate
+        # @return [Boolean]
         #
-        # @return [Expression]
+        # @api private
+        def constant_true_predicate?
+          predicate.equal?(true)
+        end
+
+        # Return true if the predicate is not callable, and not a true value
+        #
+        # In the system anything not a Tautology or true is false.
+        #
+        # @return [Boolean]
         #
         # @api private
-        def self.optimize_predicate(predicate)
-          predicate.respond_to?(:optimize) ? predicate.optimize : predicate
+        def constant_false_predicate?
+          !(predicate.respond_to?(:call) || constant_true_predicate?)
         end
 
         # Optimize when the predicate is a tautology
@@ -55,7 +64,8 @@ module Veritas
           #
           # @api private
           def optimizable?
-            predicate.equal?(Veritas::Logic::Proposition::Tautology.instance)
+            predicate.equal?(Veritas::Function::Proposition::Tautology.instance) ||
+            constant_true_predicate?
           end
 
           # A Restriction with a tautology is a noop
@@ -78,7 +88,8 @@ module Veritas
           #
           # @api private
           def optimizable?
-            predicate.equal?(Veritas::Logic::Proposition::Contradiction.instance)
+            predicate.equal?(Veritas::Function::Proposition::Contradiction.instance) ||
+            constant_false_predicate?
           end
 
           # A Restriction with a contradiction matches nothing
@@ -106,22 +117,22 @@ module Veritas
 
           # Flatten nested Restrictions into a single Restriction
           #
-          # @return [Projection]
+          # @return [Restriction]
           #
           # @api private
           def optimize
-            operation.class.new(operand.operand, optimized_predicate)
+            wrap_operand
           end
 
         private
 
           # Join the operand and operation predicates and optimize them
           #
-          # @return [Expression]
+          # @return [Function]
           #
           # @api private
-          def optimized_predicate
-            Veritas::Logic::Connective::Conjunction.new(operand.predicate, predicate).optimize
+          def predicate
+            Veritas::Function::Connective::Conjunction.new(operand.predicate, super).optimize
           end
 
         end # class RestrictionOperand
@@ -155,7 +166,7 @@ module Veritas
           #
           # @api private
           def wrap_left
-            operation.class.new(operand.left, predicate)
+            wrap_operand(operand.left)
           end
 
           # Utility method to wrap the right operand in a Restriction
@@ -164,60 +175,19 @@ module Veritas
           #
           # @api private
           def wrap_right
-            operation.class.new(operand.right, predicate)
+            wrap_operand(operand.right)
           end
 
         end # class SetOperand
 
-        # Optimize when the operand is a Reverse
-        class ReverseOperand < self
-
-          # Test if the operand is a Reverse
-          #
-          # @return [Boolean]
-          #
-          # @api private
-          def optimizable?
-            operand.kind_of?(Veritas::Relation::Operation::Reverse)
-          end
-
-          # Wrap the Restriction in a Reverse
-          #
-          # @return [Reverse]
-          #
-          # @api private
-          def optimize
-            operand.class.new(wrap_operand)
-          end
-
-        end # class ReverseOperand
-
         # Optimize when the operand is an Order
         class OrderOperand < self
-
-          # Test if the operand is an Order
-          #
-          # @return [Boolean]
-          #
-          # @api private
-          def optimizable?
-            operand.kind_of?(Veritas::Relation::Operation::Order)
-          end
-
-          # Wrap the Restriction in an Order
-          #
-          # @return [Order]
-          #
-          # @api private
-          def optimize
-            operand = self.operand
-            operand.class.new(wrap_operand, operand.directions)
-          end
-
+          include Relation::Operation::Unary::OrderOperand
         end # class OrderOperand
 
         # Optimize when operand is optimizable
         class UnoptimizedOperand < self
+          include Function::Unary::UnoptimizedOperand
 
           # Test if the operand is unoptimized
           #
@@ -225,9 +195,7 @@ module Veritas
           #
           # @api private
           def optimizable?
-            operation = self.operation
-            !operand.equal?(operation.operand) ||
-            !predicate.equal?(operation.predicate)
+            super || !predicate.equal?(operation.predicate)
           end
 
           # Return a Restriction with an optimized operand
@@ -236,7 +204,7 @@ module Veritas
           #
           # @api private
           def optimize
-            operation.class.new(operand, predicate)
+            wrap_operand(operand)
           end
 
         end # class UnoptimizedOperand
@@ -246,7 +214,6 @@ module Veritas
           Contradiction,
           RestrictionOperand,
           SetOperand,
-          ReverseOperand,
           OrderOperand,
           EmptyOperand,
           MaterializedOperand,

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

@@ -7,8 +7,142 @@ module Veritas
       # Abstract base class representing Summarization optimizations
       class Summarization < Relation::Operation::Unary
 
+        # The optimized summarize_per relation
+        #
+        # @return [Relation]
+        #
+        # @api private
+        attr_reader :summarize_per
+
+        # The optimized summarizers
+        #
+        # @return [Hash{Attribute => Function}]
+        #
+        # @api private
+        attr_reader :summarizers
+
+        # Initialize a Summarization optimizer
+        #
+        # @return [undefined]
+        #
+        # @api private
+        def initialize(*)
+          super
+          @summarize_per = optimize_summarize_per
+          @summarizers   = optimize_summarizers
+        end
+
+      private
+
+        # Optimize the summarize per relation
+        #
+        # @return [Relation]
+        #
+        # @api private
+        def optimize_summarize_per
+          operation.summarize_per.optimize
+        end
+
+        # Optimize the summarizers
+        #
+        # @return [Hash{Attribute => Function}]
+        #
+        # @api private
+        def optimize_summarizers
+          Function.optimize_functions(operation.summarizers)
+        end
+
+        # Wrap the operand's operand in a Summarization
+        #
+        # @return [Summarization]
+        #
+        # @api private
+        def wrap_operand(operand = operand.operand)
+          operation.class.new(operand, summarize_per, summarizers)
+        end
+
+        # Optimize when the operand is Empty
+        class EmptyOperand < self
+
+          # Return the default value for a function
+          #
+          # @param [Object] function
+          #
+          # @return [Object]
+          #
+          # @api private
+          def self.extension_default(function)
+            if function.respond_to?(:default)
+              function.finalize(function.default)
+            end
+          end
+
+          # Test if the operand is empty
+          #
+          # @return [Boolean]
+          #
+          # @api private
+          def optimizable?
+            operand.kind_of?(Veritas::Relation::Empty)
+          end
+
+          # Return an extended relation with the same headers
+          #
+          # @return [Extension]
+          #
+          # @api private
+          def optimize
+            Veritas::Algebra::Extension.new(summarize_per, extensions)
+          end
+
+        private
+
+          # Return the extensions for the optimized relation
+          #
+          # @return [Hash{Attribute => #call}]
+          #
+          # @api private
+          def extensions
+            extensions = {}
+            operation.summarizers.each do |attribute, function|
+              extensions[attribute] = self.class.extension_default(function)
+            end
+            extensions
+          end
+
+        end # class EmptyOperand
+
+        # Optimize when the summarize_per is empty
+        class EmptySummarizePer < self
+
+          # Test if summarize_per is empty
+          #
+          # @return [Boolean]
+          #
+          # @api private
+          def optimizable?
+            summarize_per.kind_of?(Veritas::Relation::Empty)
+          end
+
+          # Return an empty relation if there is nothing to summarize over
+          #
+          # @return [Relation::Empty]
+          #
+          # @api private
+          def optimize
+            Veritas::Relation::Empty.new(operation.header)
+          end
+
+        end # class EmptySummarizePer
+
+        # Optimize when the operand is an Order
+        class OrderOperand < self
+          include Relation::Operation::Unary::OrderOperand
+        end # class OrderOperand
+
         # Optimize when operand is optimizable
         class UnoptimizedOperand < self
+          include Function::Unary::UnoptimizedOperand
 
           # Test if the operand is unoptimized
           #
@@ -16,7 +150,9 @@ module Veritas
           #
           # @api private
           def optimizable?
-            !operand.equal?(operation.operand)
+            super                      ||
+            summarize_per_optimizable? ||
+            summarizers_optimizable?
           end
 
           # Return a Summarization with an optimized operand
@@ -25,13 +161,35 @@ module Veritas
           #
           # @api private
           def optimize
-            operation = self.operation
-            operation.class.new(operand, operation.summarize_by, operation.summarizers)
+            wrap_operand(operand)
+          end
+
+        private
+
+          # Test if the summarize_per relation is optimizable
+          #
+          # @return [Boolean]
+          #
+          # @api private
+          def summarize_per_optimizable?
+            !summarize_per.equal?(operation.summarize_per)
+          end
+
+          # Test if the summarizers are optimizable
+          #
+          # @return [Boolean]
+          #
+          # @api private
+          def summarizers_optimizable?
+            !summarizers.eql?(operation.summarizers)
           end
 
         end # class UnoptimizedOperand
 
         Veritas::Algebra::Summarization.optimizer = chain(
+          EmptyOperand,
+          EmptySummarizePer,
+          OrderOperand,
           MaterializedOperand,
           UnoptimizedOperand
         )

data/lib/veritas/optimizer/algebra/union.rb

@@ -56,8 +56,10 @@ module Veritas
           EqualOperands,
           EmptyRight,
           EmptyLeft,
+          LeftOrderOperand,
+          RightOrderOperand,
           MaterializedOperand,
-          UnoptimizedOperand
+          UnoptimizedOperands
         )
 
       end # class Union