veritas-optimizer 0.0.3

data/lib/veritas/optimizer/logic/predicate/greater_than.rb

@@ -0,0 +1,54 @@
+# encoding: utf-8
+
+module Veritas
+  class Optimizer
+    module Logic
+      class Predicate
+
+        # Abstract base class representing GreaterThan optimizations
+        class GreaterThan < self
+          include Comparable
+
+          # Optimize when the operands are a contradiction
+          class Contradiction < self
+            include Predicate::Contradiction
+
+            # Test if the operands are a contradiction
+            #
+            # @return [Boolean]
+            #
+            # @api private
+            def optimizable?
+              left.equal?(right) ||
+              GreaterThanOrEqualTo::Contradiction.new(operation).optimizable?
+            end
+
+          end # class Contradiction
+
+          # Optimize when the operands are a tautology
+          class Tautology < self
+            include Predicate::Tautology
+
+            # Test if the operands are a tautology
+            #
+            # @return [Boolean]
+            #
+            # @api private
+            def optimizable?
+              operation.class.call(Predicate::Util.min(left), Predicate::Util.max(right))
+            end
+
+          end # class Tautology
+
+          Veritas::Logic::Predicate::GreaterThan.optimizer = chain(
+            ConstantOperands,
+            Contradiction,
+            Tautology,
+            NormalizableOperands
+          )
+
+        end # class GreaterThan
+      end # class Predicate
+    end # module Logic
+  end # class Optimizer
+end # module Veritas

data/lib/veritas/optimizer/logic/predicate/greater_than_or_equal_to.rb

@@ -0,0 +1,56 @@
+# encoding: utf-8
+
+module Veritas
+  class Optimizer
+    module Logic
+      class Predicate
+
+        # Abstract base class representing GreaterThanOrEqualTo optimizations
+        class GreaterThanOrEqualTo < self
+          include Comparable
+
+          # Optimize when the operands are a contradiction
+          class Contradiction < self
+            include Comparable::NeverComparable
+            include Predicate::Contradiction
+
+            # Test if the operands are a contradiction
+            #
+            # @return [Boolean]
+            #
+            # @api private
+            def optimizable?
+              super || LessThan::Tautology.new(operation.inverse).optimizable?
+            end
+
+          end # class Contradiction
+
+          # Optimize when the operands are a tautology
+          class Tautology < self
+            include Predicate::Tautology
+
+            # Test if the operands are a tautology
+            #
+            # @return [Boolean]
+            #
+            # @api private
+            def optimizable?
+              operation = self.operation
+              GreaterThan::Tautology.new(operation).optimizable? ||
+              Equality::Tautology.new(operation).optimizable?
+            end
+
+          end # class Tautology
+
+          Veritas::Logic::Predicate::GreaterThanOrEqualTo.optimizer = chain(
+            ConstantOperands,
+            Contradiction,
+            Tautology,
+            NormalizableOperands
+          )
+
+        end # class GreaterThanOrEqualTo
+      end # class Predicate
+    end # module Logic
+  end # class Optimizer
+end # module Veritas

data/lib/veritas/optimizer/logic/predicate/inclusion.rb

@@ -0,0 +1,53 @@
+# encoding: utf-8
+
+module Veritas
+  class Optimizer
+    module Logic
+      class Predicate
+
+        # Abstract base class representing Inclusion optimizations
+        class Inclusion < self
+          include Enumerable
+
+          # Optimize when the right operand is empty
+          class EmptyRightOperand < self
+            include Enumerable::EmptyRightOperand
+
+            # An Inclusion with an empty right operand matches nothing
+            #
+            # @return [Contradiction]
+            #
+            # @api private
+            def optimize
+              Veritas::Logic::Proposition::Contradiction.instance
+            end
+
+          end # class EmptyRightOperand
+
+          # Optimize when the right operand has one entry
+          class OneRightOperand < self
+            include Enumerable::OneRightOperand
+
+            # An Inclusion with a single right operand is equivalent to an Equality
+            #
+            # @return [Equality]
+            #
+            # @api private
+            def optimize
+              Veritas::Logic::Predicate::Equality.new(left, right.first)
+            end
+
+          end # class OneRightOperand
+
+          Veritas::Logic::Predicate::Inclusion.optimizer = chain(
+            ConstantOperands,
+            EmptyRightOperand,
+            OneRightOperand,
+            UnoptimizedOperand
+          )
+
+        end # class Inclusion
+      end # class Predicate
+    end # module Logic
+  end # class Optimizer
+end # module Veritas

data/lib/veritas/optimizer/logic/predicate/inequality.rb

@@ -0,0 +1,44 @@
+# encoding: utf-8
+
+module Veritas
+  class Optimizer
+    module Logic
+      class Predicate
+
+        # Abstract base class representing Inequality optimizations
+        class Inequality < self
+          include Comparable
+
+          # Optimize when the operand are a contradiction
+          class Contradiction < self
+            include Predicate::Contradiction
+
+            # Test if the operands are a contradiction
+            #
+            # @return [Boolean]
+            #
+            # @api private
+            def optimizable?
+              left.equal?(right)
+            end
+
+          end # class Contradiction
+
+          # Optimize when the operand are a tautology
+          class Tautology < self
+            include Comparable::NeverEquivalent
+            include Predicate::Tautology
+          end # class Tautology
+
+          Veritas::Logic::Predicate::Inequality.optimizer = chain(
+            ConstantOperands,
+            Contradiction,
+            Tautology,
+            NormalizableOperands
+          )
+
+        end # class Inequality
+      end # class Predicate
+    end # module Logic
+  end # class Optimizer
+end # module Veritas

data/lib/veritas/optimizer/logic/predicate/less_than.rb

@@ -0,0 +1,54 @@
+# encoding: utf-8
+
+module Veritas
+  class Optimizer
+    module Logic
+      class Predicate
+
+        # Abstract base class representing LessThan optimizations
+        class LessThan < self
+          include Comparable
+
+          # Optimize when the operands are a contradiction
+          class Contradiction < self
+            include Predicate::Contradiction
+
+            # Test if the operands are a contradiction
+            #
+            # @return [Boolean]
+            #
+            # @api private
+            def optimizable?
+              left.equal?(right) ||
+              LessThanOrEqualTo::Contradiction.new(operation).optimizable?
+            end
+
+          end # class Contradiction
+
+          # Optimize when the operands are a tautology
+          class Tautology < self
+            include Predicate::Tautology
+
+            # Test if the operands are a tautology
+            #
+            # @return [Boolean]
+            #
+            # @api private
+            def optimizable?
+              operation.class.call(Predicate::Util.max(left), Predicate::Util.min(right))
+            end
+
+          end # class Tautology
+
+          Veritas::Logic::Predicate::LessThan.optimizer = chain(
+            ConstantOperands,
+            Contradiction,
+            Tautology,
+            NormalizableOperands
+          )
+
+        end # class LessThan
+      end # class Predicate
+    end # module Logic
+  end # class Optimizer
+end # module Veritas

data/lib/veritas/optimizer/logic/predicate/less_than_or_equal_to.rb

@@ -0,0 +1,56 @@
+# encoding: utf-8
+
+module Veritas
+  class Optimizer
+    module Logic
+      class Predicate
+
+        # Abstract base class representing LessThanOrEqualTo optimizations
+        class LessThanOrEqualTo < self
+          include Comparable
+
+          # Optimize when the operands are a contradiction
+          class Contradiction < self
+            include Comparable::NeverComparable
+            include Predicate::Contradiction
+
+            # Test if the operands are a contradiction
+            #
+            # @return [Boolean]
+            #
+            # @api private
+            def optimizable?
+              super || GreaterThan::Tautology.new(operation.inverse).optimizable?
+            end
+
+          end # class Contradiction
+
+          # Optimize when the operands are a tautology
+          class Tautology < self
+            include Predicate::Tautology
+
+            # Test if the operands are a tautology
+            #
+            # @return [Boolean]
+            #
+            # @api private
+            def optimizable?
+              operation = self.operation
+              LessThan::Tautology.new(operation).optimizable? ||
+              Equality::Tautology.new(operation).optimizable?
+            end
+
+          end # class Tautology
+
+          Veritas::Logic::Predicate::LessThanOrEqualTo.optimizer = chain(
+            ConstantOperands,
+            Contradiction,
+            Tautology,
+            NormalizableOperands
+          )
+
+        end # class LessThanOrEqualTo
+      end # class Predicate
+    end # module Logic
+  end # class Optimizer
+end # module Veritas

data/lib/veritas/optimizer/logic/predicate/match.rb

@@ -0,0 +1,19 @@
+# encoding: utf-8
+
+module Veritas
+  class Optimizer
+    module Logic
+      class Predicate
+
+        # Abstract base class representing Match optimizations
+        class Match < self
+
+          Veritas::Logic::Predicate::Match.optimizer = chain(
+            ConstantOperands
+          )
+
+        end # class Match
+      end # class Predicate
+    end # module Logic
+  end # class Optimizer
+end # module Veritas

data/lib/veritas/optimizer/logic/predicate/no_match.rb

@@ -0,0 +1,19 @@
+# encoding: utf-8
+
+module Veritas
+  class Optimizer
+    module Logic
+      class Predicate
+
+        # Abstract base class representing NoMatch optimizations
+        class NoMatch < self
+
+          Veritas::Logic::Predicate::NoMatch.optimizer = chain(
+            ConstantOperands
+          )
+
+        end # class NoMatch
+      end # class Predicate
+    end # module Logic
+  end # class Optimizer
+end # module Veritas

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

@@ -0,0 +1,177 @@
+# encoding: utf-8
+
+module Veritas
+  class Optimizer
+    module Logic
+
+      # Abstract base class representing Predicate optimizations
+      class Predicate < Optimizer
+
+        # The optimized left operand
+        #
+        # @return [Object]
+        #
+        # @api private
+        attr_reader :left
+
+        # The optimized right operand
+        #
+        # @return [Object]
+        #
+        # @api private
+        attr_reader :right
+
+        # Initialize an Predicate optimizer
+        #
+        # @return [undefined]
+        #
+        # @api private
+        def initialize(*)
+          super
+          @left  = optimize_left
+          @right = optimize_right
+        end
+
+      private
+
+        # Optimize the left operand
+        #
+        # @return [Object]
+        #
+        # @api private
+        def optimize_left
+          self.class.optimize_operand(operation.left)
+        end
+
+        # Optimize the right operand
+        #
+        # @return [Object]
+        #
+        # @api private
+        def optimize_right
+          self.class.optimize_operand(operation.right)
+        end
+
+        # Optimize the operand if possible
+        #
+        # @param [#optimize, Object] operand
+        #
+        # @return [Object]
+        #
+        # @api private
+        def self.optimize_operand(operand)
+          operand.respond_to?(:optimize) ? operand.optimize : operand
+        end
+
+        # Optimize when the operands are constants
+        class ConstantOperands < self
+
+          # Test if the operands are constants
+          #
+          # @return [Boolean]
+          #
+          # @api private
+          def optimizable?
+            util = Util
+            util.constant?(left) && util.constant?(right)
+          end
+
+          # A Predicate with constant values is equivalent to a Proposition
+          #
+          # @return [Proposition]
+          #
+          # @api private
+          def optimize
+            Veritas::Logic::Proposition.new(operation.class.call(left, right))
+          end
+
+        end # class ConstantOperands
+
+        # Optimize when the operands are a contradiction
+        module Contradiction
+
+          # Return a contradiction
+          #
+          # @return [Contradiction]
+          #
+          # @api private
+          def optimize
+            Veritas::Logic::Proposition::Contradiction.instance
+          end
+
+        end # module Contradiction
+
+        # Optimize when the operands are a tautology
+        module Tautology
+
+          # Return a tautology
+          #
+          # @return [Tautology]
+          #
+          # @api private
+          def optimize
+            Veritas::Logic::Proposition::Tautology.instance
+          end
+
+        end # module Tautology
+
+        # Utility methods for Predicate optimization
+        module Util
+
+          # Test if the operand is a constant
+          #
+          # @return [Boolean]
+          #
+          # @api private
+          def self.constant?(operand)
+            !operand.respond_to?(:call)
+          end
+
+          # Test if the operand is an attribute
+          #
+          # @return [Boolean]
+          #
+          # @api private
+          def self.attribute?(operand)
+            operand.kind_of?(Attribute)
+          end
+
+          # Return the minimum value for the operand
+          #
+          # @return [Object]
+          #
+          # @api private
+          def self.min(operand)
+            range_or_operand(operand, :first)
+          end
+
+          # Return the maximum value for the operand
+          #
+          # @return [Object]
+          #
+          # @api private
+          def self.max(operand)
+            range_or_operand(operand, :last)
+          end
+
+          # Return the minimum/maximum of the operand range, or the operand
+          #
+          # @param [Object] operand
+          #   the object to extract the minimum/maximum value from
+          # @param [Symbol] method
+          #   the method to execute on the operand range, if any
+          #
+          # @return [Object]
+          #
+          # @api private
+          def self.range_or_operand(operand, method)
+            operand.respond_to?(:range) ? operand.range.send(method) : operand
+          end
+
+          private_class_method :range_or_operand
+
+        end # module Util
+      end # class Predicate
+    end # module Logic
+  end # class Optimizer
+end # module Veritas

data/lib/veritas/optimizer/optimizable.rb

@@ -0,0 +1,59 @@
+# encoding: utf-8
+
+module Veritas
+  class Optimizer
+
+    # Allow operations to be optimizable
+    module Optimizable
+      include Immutable
+
+      # Hook called when module is included
+      #
+      # @param [Module] descendant
+      #   the module or class including Optimizable
+      #
+      # @return [self]
+      #
+      # @api private
+      def self.included(descendant)
+        descendant.extend ClassMethods
+        self
+      end
+
+      # Optimize the operation
+      #
+      # @example
+      #   optimized = operation.optimize
+      #
+      # @param [Optimizer] optimizer
+      #   optional optimizer
+      #
+      # @return [Optimizable]
+      #   the optimized operation
+      #
+      # @api public
+      #
+      # @todo simplify by setting a default Noop optimizer for all relations
+      def optimize(optimizer = self.class.optimizer || Optimizer::Noop)
+        optimized = optimizer.call(self)
+        equal?(optimized) ? self : optimized.optimize
+      end
+
+      memoize :optimize
+
+      module ClassMethods
+
+        # The Optimizer for the operation
+        #
+        # @return [Optimizable]
+        #
+        # @api private
+        attr_accessor :optimizer
+
+      end # module ClassMethods
+    end # module Optimizable
+  end # class Optimizer
+end # module Veritas
+
+Veritas::Relation.class_eval          { include Veritas::Optimizer::Optimizable }
+Veritas::Logic::Expression.class_eval { include Veritas::Optimizer::Optimizable }

data/lib/veritas/optimizer/relation/materialized.rb

@@ -0,0 +1,40 @@
+# encoding: utf-8
+
+module Veritas
+  class Optimizer
+    module Relation
+
+      # Abstract base class representing Materialized optimizations
+      class Materialized < Optimizer
+
+        # Optimize when the operand is Empty
+        class EmptyOperand < self
+
+          # Test if the operand is empty
+          #
+          # @return [Boolean]
+          #
+          # @api private
+          def optimizable?
+            operation.empty?
+          end
+
+          # Return a new Empty relation with the operation's headers
+          #
+          # @return [Empty]
+          #
+          # @api private
+          def optimize
+            Veritas::Relation::Empty.new(operation.header)
+          end
+
+        end # class EmptyOperand
+
+        Veritas::Relation::Materialized.optimizer = chain(
+          EmptyOperand
+        )
+
+      end # class Materialized
+    end # module Relation
+  end # class Optimizer
+end # module Veritas