veritas-optimizer 0.0.3

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

@@ -0,0 +1,259 @@
+# encoding: utf-8
+
+module Veritas
+  class Optimizer
+    module Algebra
+
+      # Abstract base class representing Restriction optimizations
+      class Restriction < Relation::Operation::Unary
+
+        # The optimized predicate
+        #
+        # @return [Expression]
+        #
+        # @api private
+        attr_reader :predicate
+
+        # Initialize an Restriction optimizer
+        #
+        # @return [undefined]
+        #
+        # @api private
+        def initialize(*)
+          super
+          @predicate = self.class.optimize_predicate(operation.predicate)
+        end
+
+      private
+
+        # Wrap the operand's operand in a Restriction
+        #
+        # @return [Restriction]
+        #
+        # @api private
+        def wrap_operand
+          operation.class.new(operand.operand, predicate)
+        end
+
+        # Optimize the predicate if possible
+        #
+        # @param [Expression] predicate
+        #
+        # @return [Expression]
+        #
+        # @api private
+        def self.optimize_predicate(predicate)
+          predicate.respond_to?(:optimize) ? predicate.optimize : predicate
+        end
+
+        # Optimize when the predicate is a tautology
+        class Tautology < self
+
+          # Test if the predicate is a tautology
+          #
+          # @return [Boolean]
+          #
+          # @api private
+          def optimizable?
+            predicate.equal?(Veritas::Logic::Proposition::Tautology.instance)
+          end
+
+          # A Restriction with a tautology is a noop
+          #
+          # @return [Relation]
+          #
+          # @api private
+          def optimize
+            operand
+          end
+
+        end # class Tautology
+
+        # Optimize when the predicate is a contradiction
+        class Contradiction < self
+
+          # Test if the predicate is a contradiction
+          #
+          # @return [Boolean]
+          #
+          # @api private
+          def optimizable?
+            predicate.equal?(Veritas::Logic::Proposition::Contradiction.instance)
+          end
+
+          # A Restriction with a contradiction matches nothing
+          #
+          # @return [Relation]
+          #
+          # @api private
+          def optimize
+            Veritas::Relation::Empty.new(operation.header)
+          end
+
+        end # class Contradiction
+
+        # Optimize when the operand is a Restriction
+        class RestrictionOperand < self
+
+          # Test if the operand is a Restriction
+          #
+          # @return [Boolean]
+          #
+          # @api private
+          def optimizable?
+            operand.kind_of?(operation.class)
+          end
+
+          # Flatten nested Restrictions into a single Restriction
+          #
+          # @return [Projection]
+          #
+          # @api private
+          def optimize
+            operation.class.new(operand.operand, optimized_predicate)
+          end
+
+        private
+
+          # Join the operand and operation predicates and optimize them
+          #
+          # @return [Expression]
+          #
+          # @api private
+          def optimized_predicate
+            Veritas::Logic::Connective::Conjunction.new(operand.predicate, predicate).optimize
+          end
+
+        end # class RestrictionOperand
+
+        # Optimize when the operand is a Set
+        class SetOperand < self
+
+          # Test if the operand is a Restriction
+          #
+          # @return [Boolean]
+          #
+          # @api private
+          def optimizable?
+            operand.kind_of?(Veritas::Relation::Operation::Set)
+          end
+
+          # Wrap each operand in the Set in a Restriction
+          #
+          # @return [Set]
+          #
+          # @api private
+          def optimize
+            operand.class.new(wrap_left, wrap_right)
+          end
+
+        private
+
+          # Utility method to wrap the left operand in a Restriction
+          #
+          # @return [Restriction]
+          #
+          # @api private
+          def wrap_left
+            operation.class.new(operand.left, predicate)
+          end
+
+          # Utility method to wrap the right operand in a Restriction
+          #
+          # @return [Restriction]
+          #
+          # @api private
+          def wrap_right
+            operation.class.new(operand.right, predicate)
+          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
+
+        end # class OrderOperand
+
+        # 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) ||
+            !predicate.equal?(operation.predicate)
+          end
+
+          # Return a Restriction with an optimized operand
+          #
+          # @return [Rename]
+          #
+          # @api private
+          def optimize
+            operation.class.new(operand, predicate)
+          end
+
+        end # class UnoptimizedOperand
+
+        Veritas::Algebra::Restriction.optimizer = chain(
+          Tautology,
+          Contradiction,
+          RestrictionOperand,
+          SetOperand,
+          ReverseOperand,
+          OrderOperand,
+          EmptyOperand,
+          MaterializedOperand,
+          UnoptimizedOperand
+        )
+
+      end # class Restriction
+    end # module Algebra
+  end # class Optimizer
+end # module Veritas

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

@@ -0,0 +1,42 @@
+# encoding: utf-8
+
+module Veritas
+  class Optimizer
+    module Algebra
+
+      # Abstract base class representing Summarization optimizations
+      class Summarization < Relation::Operation::Unary
+
+        # Optimize when operand is optimizable
+        class UnoptimizedOperand < self
+
+          # Test if the operand is unoptimized
+          #
+          # @return [Boolean]
+          #
+          # @api private
+          def optimizable?
+            !operand.equal?(operation.operand)
+          end
+
+          # Return a Summarization with an optimized operand
+          #
+          # @return [Rename]
+          #
+          # @api private
+          def optimize
+            operation = self.operation
+            operation.class.new(operand, operation.summarize_by, operation.summarizers)
+          end
+
+        end # class UnoptimizedOperand
+
+        Veritas::Algebra::Summarization.optimizer = chain(
+          MaterializedOperand,
+          UnoptimizedOperand
+        )
+
+      end # class Summarization
+    end # module Algebra
+  end # class Optimizer
+end # module Veritas

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

@@ -0,0 +1,66 @@
+# encoding: utf-8
+
+module Veritas
+  class Optimizer
+    module Algebra
+
+      # Abstract base class representing Difference optimizations
+      class Union < Relation::Operation::Binary
+
+        # Optimize when operands are equal
+        class EqualOperands < self
+          include Relation::Operation::Binary::EqualOperands
+
+          # A Union with equal operands is a noop
+          #
+          # @return [Relation]
+          #
+          # @api private
+          def optimize
+            left
+          end
+
+        end # class EqualOperands
+
+        # Optimize when the left operand is empty
+        class EmptyLeft < self
+          include Relation::Operation::Binary::EmptyLeft
+
+          # A Union with an empty left operand is equivalent to the right
+          #
+          # @return [Relation]
+          #
+          # @api private
+          def optimize
+            right
+          end
+
+        end # class EmptyLeft
+
+        # Optimize when the right operand is empty
+        class EmptyRight < self
+          include Relation::Operation::Binary::EmptyRight
+
+          # A Union with an empty right operand is equivalent to the left
+          #
+          # @return [Relation]
+          #
+          # @api private
+          def optimize
+            left
+          end
+
+        end # class EmptyRight
+
+        Veritas::Algebra::Union.optimizer = chain(
+          EqualOperands,
+          EmptyRight,
+          EmptyLeft,
+          MaterializedOperand,
+          UnoptimizedOperand
+        )
+
+      end # class Union
+    end # module Algebra
+  end # class Optimizer
+end # module Veritas

data/lib/veritas/optimizer/logic/connective/binary.rb

@@ -0,0 +1,254 @@
+# encoding: utf-8
+
+module Veritas
+  class Optimizer
+    module Logic
+      module Connective
+
+        # Abstract base class representing Binary connective optimizations
+        class Binary < Optimizer
+
+          # The optimized left operand
+          #
+          # @return [Expression]
+          #
+          # @api private
+          attr_reader :left
+
+          # The optimized right operand
+          #
+          # @return [Expression]
+          #
+          # @api private
+          attr_reader :right
+
+          # Initialize an Binary optimizer
+          #
+          # @return [undefined]
+          #
+          # @api private
+          def initialize(*)
+            super
+            @left  = optimize_left
+            @right = optimize_right
+          end
+
+        private
+
+          # Optimize the left operand
+          #
+          # @return [Expression]
+          #
+          # @api private
+          def optimize_left
+            # TODO: move Predicate.optimize_operand to a better location
+            Predicate.optimize_operand(operation.left)
+          end
+
+          # Optimize the right operand
+          #
+          # @return [Expression]
+          #
+          # @api private
+          def optimize_right
+            # TODO: move Predicate.optimize_operand to a better location
+            Predicate.optimize_operand(operation.right)
+          end
+
+          # Test if the operands are equality predicates for the same attribute
+          #
+          # @return [Boolean]
+          #
+          # @api private
+          def equality_with_same_attributes?
+            left.kind_of?(Veritas::Logic::Predicate::Equality)  &&
+            right.kind_of?(Veritas::Logic::Predicate::Equality) &&
+            same_attribute?                                     &&
+            constant_value?
+          end
+
+          # Test if the operands are inequality predicates for the same attribute
+          #
+          # @return [Boolean]
+          #
+          # @api private
+          def inequality_with_same_attributes?
+            left.kind_of?(Veritas::Logic::Predicate::Inequality)  &&
+            right.kind_of?(Veritas::Logic::Predicate::Inequality) &&
+            same_attribute?                                       &&
+            constant_value?
+          end
+
+          # Test if the left and right predicates are for the same attribute
+          #
+          # @return [Boolean]
+          #
+          # @api private
+          def same_attribute?
+            left.left.equal?(right.left)
+          end
+
+          # Test if the left and right predicates match against constant values
+          #
+          # @return [Boolean]
+          #
+          # @api private
+          def constant_value?
+            util = Predicate::Util
+            util.constant?(left.right) && util.constant?(right.right)
+          end
+
+          # Test if the left is a tautology
+          #
+          # @return [Boolean]
+          #
+          # @api private
+          def left_tautology?
+            left.equal?(Veritas::Logic::Proposition::Tautology.instance)
+          end
+
+          # Test if the right is a tautology
+          #
+          # @return [Boolean]
+          #
+          # @api private
+          def right_tautology?
+            right.equal?(Veritas::Logic::Proposition::Tautology.instance)
+          end
+
+          # Test if the left is a contradiction
+          #
+          # @return [Boolean]
+          #
+          # @api private
+          def left_contradiction?
+            left.equal?(Veritas::Logic::Proposition::Contradiction.instance)
+          end
+
+          # Test if the right is a contradiction
+          #
+          # @return [Boolean]
+          #
+          # @api private
+          def right_contradiction?
+            right.equal?(Veritas::Logic::Proposition::Contradiction.instance)
+          end
+
+          # Optimize when the operands are equal
+          class EqualOperands < self
+
+            # Test if the operands are equal
+            #
+            # @return [Boolean]
+            #
+            # @api private
+            def optimizable?
+              left.eql?(right)
+            end
+
+            # A Binary connective with equal operands is equivalent to the left
+            #
+            # @return [Expression]
+            #
+            # @api private
+            def optimize
+              left
+            end
+
+          end # class EqualOperands
+
+          # Optimize when the left operand is redundant
+          class RedundantLeftOperand < self
+
+            # Test if the left operand is redundant
+            #
+            # @return [Boolean]
+            #
+            # @api private
+            def optimizable?
+              left = self.left
+              operation.kind_of?(left.class) && right.eql?(left.right)
+            end
+
+            # A Binary connective with a redundant left operand is equivalent to the left
+            #
+            # @return [Expression]
+            #
+            # @api private
+            def optimize
+              left
+            end
+
+          end # class RedundantLeftOperand
+
+          # Optimize when the right operand is redundant
+          class RedundantRightOperand < self
+
+            # Test if the right operand is redundant
+            #
+            # @return [Boolean]
+            #
+            # @api private
+            def optimizable?
+              right = self.right
+              operation.kind_of?(right.class) && left.eql?(right.left)
+            end
+
+            # A Binary connective with a redundant right operand is equivalent to the right
+            #
+            # @return [Expression]
+            #
+            # @api private
+            def optimize
+              right
+            end
+
+          end # class RedundantRightOperand
+
+          # Optimize when the operands are unoptimized
+          class UnoptimizedOperand < self
+
+            # Test if the operands are unoptimized
+            #
+            # @return [Boolean]
+            #
+            # @api private
+            def optimizable?
+              left_optimizable? || right_optimizable?
+            end
+
+            # Return a Binary connective with optimized operands
+            #
+            # @return [Binary]
+            #
+            # @api private
+            def optimize
+              operation.class.new(left, right)
+            end
+
+          private
+
+            # Test if the left operand is optimizable
+            #
+            # @return [Boolean]
+            #
+            # @api private
+            def left_optimizable?
+              !left.equal?(operation.left)
+            end
+
+            # Test if the right operand is optimizable
+            #
+            # @return [Boolean]
+            #
+            # @api private
+            def right_optimizable?
+              !right.equal?(operation.right)
+            end
+
+          end # class UnoptimizedOperand
+        end # class Binary
+      end # module Connective
+    end # module Logic
+  end # class Optimizer
+end # module Veritas