veritas 0.0.1

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

@@ -0,0 +1,64 @@
+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/algebra.rb

@@ -0,0 +1,10 @@
+require 'veritas/optimizer/algebra/difference'
+require 'veritas/optimizer/algebra/extension'
+require 'veritas/optimizer/algebra/intersection'
+require 'veritas/optimizer/algebra/join'
+require 'veritas/optimizer/algebra/product'
+require 'veritas/optimizer/algebra/projection'
+require 'veritas/optimizer/algebra/rename'
+require 'veritas/optimizer/algebra/restriction'
+require 'veritas/optimizer/algebra/summarization'
+require 'veritas/optimizer/algebra/union'

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

@@ -0,0 +1,252 @@
+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 true
+          #
+          # @return [Boolean]
+          #
+          # @api private
+          def left_true?
+            left.equal?(Veritas::Logic::Proposition::True.instance)
+          end
+
+          # Test if the right is true
+          #
+          # @return [Boolean]
+          #
+          # @api private
+          def right_true?
+            right.equal?(Veritas::Logic::Proposition::True.instance)
+          end
+
+          # Test if the left is false
+          #
+          # @return [Boolean]
+          #
+          # @api private
+          def left_false?
+            left.equal?(Veritas::Logic::Proposition::False.instance)
+          end
+
+          # Test if the right is false
+          #
+          # @return [Boolean]
+          #
+          # @api private
+          def right_false?
+            right.equal?(Veritas::Logic::Proposition::False.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

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

@@ -0,0 +1,120 @@
+module Veritas
+  class Optimizer
+    module Logic
+      module Connective
+
+        # Abstract base class representing Conjunction optimizations
+        class Conjunction < Binary
+
+          # Optimize when the left operand is true
+          class TrueLeftOperand < self
+
+            # Test if the left operand is true
+            #
+            # @return [Boolean]
+            #
+            # @api private
+            def optimizable?
+              left_true?
+            end
+
+            # A Conjunction with a true left operand is equivalent to the right
+            #
+            # @return [Expression]
+            #
+            # @api private
+            def optimize
+              right
+            end
+
+          end # class TrueLeftOperand
+
+          # Optimize when the right operand is true
+          class TrueRightOperand < self
+
+            # Test if the right operand is true
+            #
+            # @return [Boolean]
+            #
+            # @api private
+            def optimizable?
+              right_true?
+            end
+
+            # A Conjunction with a true right operand is equivalent to the left
+            #
+            # @return [Expression]
+            #
+            # @api private
+            def optimize
+              left
+            end
+
+          end # class TrueRightOperand
+
+          # Optimize when the operands are inequality predicates for the same attribute
+          class OptimizableToExclusion < self
+
+            # Test if the operands are inequality predicates for the same attribute
+            #
+            # @return [Boolean]
+            #
+            # @api private
+            def optimizable?
+              inequality_with_same_attributes?
+            end
+
+            # Return an Exclusion for an attribute against a set of values
+            #
+            # @return [Exclusion]
+            #
+            # @api private
+            def optimize
+              left = self.left
+              Veritas::Logic::Predicate::Exclusion.new(left.left, [ left.right, right.right ]).optimize
+            end
+
+          end # class OptimizableToExclusion
+
+          # Optimize when the operands are always false
+          class AlwaysFalse < self
+
+            # Test if the operands are always false
+            #
+            # @return [Boolean]
+            #
+            # @api private
+            def optimizable?
+              left_false?                    ||
+              right_false?                   ||
+              equality_with_same_attributes? ||
+              left.inverse.eql?(right)
+            end
+
+            # Return false
+            #
+            # @return [False]
+            #
+            # @api private
+            def optimize
+              Veritas::Logic::Proposition::False.instance
+            end
+
+          end # class AlwaysFalse
+
+          Veritas::Logic::Connective::Conjunction.optimizer = chain(
+            TrueLeftOperand,
+            TrueRightOperand,
+            OptimizableToExclusion,
+            EqualOperands,
+            RedundantLeftOperand,
+            RedundantRightOperand,
+            AlwaysFalse,
+            UnoptimizedOperand
+          )
+
+        end # class Conjunction
+      end # module Connective
+    end # module Logic
+  end # class Optimizer
+end # module Veritas

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

@@ -0,0 +1,120 @@
+module Veritas
+  class Optimizer
+    module Logic
+      module Connective
+
+        # Abstract base class representing Disjunction optimizations
+        class Disjunction < Binary
+
+          # Optimize when the left operand is false
+          class FalseLeftOperand < self
+
+            # Test if the left operand is false
+            #
+            # @return [Boolean]
+            #
+            # @api private
+            def optimizable?
+              left_false?
+            end
+
+            # A Disjunction with a false left operand is equivalent to the right
+            #
+            # @return [Expression]
+            #
+            # @api private
+            def optimize
+              right
+            end
+
+          end # class FalseLeftOperand
+
+          # Optimize when the right operand is false
+          class FalseRightOperand < self
+
+            # Test if the right operand is false
+            #
+            # @return [Boolean]
+            #
+            # @api private
+            def optimizable?
+              right_false?
+            end
+
+            # A Disjunction with a false right operand is equivalent to the left
+            #
+            # @return [Expression]
+            #
+            # @api private
+            def optimize
+              left
+            end
+
+          end # class FalseRightOperand
+
+          # Optimize when the operands are equality predicates for the same attribute
+          class OptimizableToInclusion < self
+
+            # Test if the operands are equality predicates for the same attribute
+            #
+            # @return [Boolean]
+            #
+            # @api private
+            def optimizable?
+              equality_with_same_attributes?
+            end
+
+            # Return an Inclusion for an attribute having a set of values
+            #
+            # @return [Inclusion]
+            #
+            # @api private
+            def optimize
+              left = self.left
+              Veritas::Logic::Predicate::Inclusion.new(left.left, [ left.right, right.right ]).optimize
+            end
+
+          end # class OptimizableToInclusion
+
+          # Optimize when the operands are always true
+          class AlwaysTrue < self
+
+            # Test if the operands are always true
+            #
+            # @return [Boolean]
+            #
+            # @api private
+            def optimizable?
+              left_true?                       ||
+              right_true?                      ||
+              inequality_with_same_attributes? ||
+              left.inverse.eql?(right)
+            end
+
+            # Return true
+            #
+            # @return [True]
+            #
+            # @api private
+            def optimize
+              Veritas::Logic::Proposition::True.instance
+            end
+
+          end # class AlwaysTrue
+
+          Veritas::Logic::Connective::Disjunction.optimizer = chain(
+            FalseLeftOperand,
+            FalseRightOperand,
+            OptimizableToInclusion,
+            EqualOperands,
+            RedundantLeftOperand,
+            RedundantRightOperand,
+            AlwaysTrue,
+            UnoptimizedOperand
+          )
+
+        end # class Disjunction
+      end # module Connective
+    end # module Logic
+  end # class Optimizer
+end # module Veritas

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

@@ -0,0 +1,69 @@
+module Veritas
+  class Optimizer
+    module Logic
+      module Connective
+
+        # Abstract base class representing Negation optimizations
+        class Negation < Optimizer
+
+          # The optimized operand
+          #
+          # @return [Expression]
+          #
+          # @api private
+          attr_reader :operand
+
+          # Initialize a Unary optimizer
+          #
+          # @return [undefined]
+          #
+          # @api private
+          def initialize(*)
+            super
+            @operand = optimize_operand
+          end
+
+        private
+
+          # Optimize the operand
+          #
+          # @return [Expression]
+          #
+          # @api private
+          def optimize_operand
+            # TODO: move Predicate.optimize_operand to a better location
+            Predicate.optimize_operand(operation.operand)
+          end
+
+          # Optimzie when the operand can be inverted
+          class InvertibleOperand < self
+
+            # Test if the operand can be inverted
+            #
+            # @return [Boolean]
+            #
+            # @api private
+            def optimizable?
+              operand.respond_to?(:inverse)
+            end
+
+            # A Negation of an Expression is equivalent to the inverted Expression
+            #
+            # @return [Expression]
+            #
+            # @api private
+            def optimize
+              operand.inverse
+            end
+
+          end # class InvertibleOperand
+
+          Veritas::Logic::Connective::Negation.optimizer = chain(
+            InvertibleOperand
+          )
+
+        end # class Negation
+      end # module Connective
+    end # module Logic
+  end # class Optimizer
+end # module Veritas

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

@@ -0,0 +1,5 @@
+require 'veritas/optimizer/logic/connective/binary'
+
+require 'veritas/optimizer/logic/connective/conjunction'
+require 'veritas/optimizer/logic/connective/disjunction'
+require 'veritas/optimizer/logic/connective/negation'