veritas 0.0.2 → 0.0.3

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

@@ -1,257 +0,0 @@
-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).optimize
-        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 true
-        class TruePredicate < self
-
-          # Test if the predicate is true
-          #
-          # @return [Boolean]
-          #
-          # @api private
-          def optimizable?
-            predicate.equal?(Veritas::Logic::Proposition::True.instance)
-          end
-
-          # A Restriction with a true predicate is a noop
-          #
-          # @return [Relation]
-          #
-          # @api private
-          def optimize
-            operand
-          end
-
-        end # class TruePredicate
-
-        # Optimize when the predicate is false
-        class FalsePredicate < self
-
-          # Test if the predicate is false
-          #
-          # @return [Boolean]
-          #
-          # @api private
-          def optimizable?
-            predicate.equal?(Veritas::Logic::Proposition::False.instance)
-          end
-
-          # A Restriction with a false predicate matches nothing
-          #
-          # @return [Relation]
-          #
-          # @api private
-          def optimize
-            Veritas::Relation::Empty.new(operation.header)
-          end
-
-        end # class FalsePredicate
-
-        # 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).optimize
-          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).optimize
-          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).optimize
-          end
-
-          # Utility method to wrap the right operand in a Restriction
-          #
-          # @return [Restriction]
-          #
-          # @api private
-          def wrap_right
-            operation.class.new(operand.right, predicate).optimize
-          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).optimize
-          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).optimize
-          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).optimize
-          end
-
-        end # class UnoptimizedOperand
-
-        Veritas::Algebra::Restriction.optimizer = chain(
-          TruePredicate,
-          FalsePredicate,
-          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

@@ -1,40 +0,0 @@
-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).optimize
-          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

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

@@ -1,2 +0,0 @@
-require 'veritas/optimizer/logic/connective'
-require 'veritas/optimizer/logic/predicate'

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

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

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

@@ -1,252 +0,0 @@
-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).optimize
-            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