veritas 0.0.1

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

@@ -0,0 +1,17 @@
+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,187 @@
+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 always false
+        module AlwaysFalse
+
+          # Return false
+          #
+          # @return [False]
+          #
+          # @api private
+          def optimize
+            Veritas::Logic::Proposition::False.instance
+          end
+
+        end # module AlwaysFalse
+
+        # Optimize when the operands are always true
+        module AlwaysTrue
+
+          # Return true
+          #
+          # @return [True]
+          #
+          # @api private
+          def optimize
+            Veritas::Logic::Proposition::True.instance
+          end
+
+        end # module AlwaysTrue
+
+        # 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
+
+require 'veritas/optimizer/logic/predicate/comparable'
+require 'veritas/optimizer/logic/predicate/enumerable'
+
+require 'veritas/optimizer/logic/predicate/equality'
+require 'veritas/optimizer/logic/predicate/exclusion'
+require 'veritas/optimizer/logic/predicate/greater_than'
+require 'veritas/optimizer/logic/predicate/greater_than_or_equal_to'
+require 'veritas/optimizer/logic/predicate/inequality'
+require 'veritas/optimizer/logic/predicate/inclusion'
+require 'veritas/optimizer/logic/predicate/less_than'
+require 'veritas/optimizer/logic/predicate/less_than_or_equal_to'

data/lib/veritas/optimizer/logic.rb

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

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

@@ -0,0 +1,38 @@
+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

data/lib/veritas/optimizer/relation/operation/binary.rb

@@ -0,0 +1,166 @@
+module Veritas
+  class Optimizer
+    module Relation
+      module Operation
+
+        # Abstract base class representing Binary relation optimizations
+        class Binary < Optimizer
+
+          # The optimized left operand
+          #
+          # @return [Relation]
+          #
+          # @api private
+          attr_reader :left
+
+          # The optimized right operand
+          #
+          # @return [Relation]
+          #
+          # @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 [Relation]
+          #
+          # @api private
+          def optimize_left
+            operation.left.optimize
+          end
+
+          # Optimize the right operand
+          #
+          # @return [Relation]
+          #
+          # @api private
+          def optimize_right
+            operation.right.optimize
+          end
+
+          # Optimize when operands are equal
+          module EqualOperands
+
+            # Test if the operands are equal
+            #
+            # @return [Boolean]
+            #
+            # @api private
+            def optimizable?
+              left.eql?(right)
+            end
+
+          end # module EqualOperands
+
+          # Optimize when the left operand is Empty
+          module EmptyLeft
+
+            # Test if the left operand is empty
+            #
+            # @return [Boolean]
+            #
+            # @api private
+            def optimizable?
+              left.kind_of?(Veritas::Relation::Empty)
+            end
+
+          end # module EmptyLeft
+
+          # Optimize when the right operand is Empty
+          module EmptyRight
+
+            # Test if the right operand is empty
+            #
+            # @return [Boolean]
+            #
+            # @api private
+            def optimizable?
+              right.kind_of?(Veritas::Relation::Empty)
+            end
+
+          end # module EmptyRight
+
+          # Optimize when the operands are Materialized
+          class MaterializedOperand < self
+
+            # Test if the operands are materialized
+            #
+            # @return [Boolean]
+            #
+            # @api private
+            def optimizable?
+              left.kind_of?(Veritas::Relation::Materialized) &&
+              right.kind_of?(Veritas::Relation::Materialized)
+            end
+
+            # Return the materialized operation
+            #
+            # @return [Relation::Materialized]
+            #
+            # @api private
+            def optimize
+              operation.materialize
+            end
+
+          end # class MaterializedOperand
+
+          # 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 Relation with optimized operands
+            #
+            # @return [Relation]
+            #
+            # @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 Operation
+    end # module Relation
+  end # class Optimizer
+end # module Veritas

data/lib/veritas/optimizer/relation/operation/combine.rb

@@ -0,0 +1,31 @@
+module Veritas
+  class Optimizer
+    module Relation
+      module Operation
+
+        # Abstract base class representing combinations of relations
+        class Combine < Binary
+
+          # Any relation combined with an empty relation is an empty relation
+          #
+          # @return [Relation::Empty]
+          #
+          # @api private
+          def optimize
+            Veritas::Relation::Empty.new(operation.header)
+          end
+
+          # Optimize when the left operand is Empty
+          class EmptyLeft < self
+            include Binary::EmptyLeft
+          end # class EmptyLeft
+
+          # Optimize when the right operand is Empty
+          class EmptyRight < self
+            include Binary::EmptyRight
+          end # class EmptyRight
+        end # class Combine
+      end # module Operation
+    end # module Relation
+  end # class Optimizer
+end # module Veritas

data/lib/veritas/optimizer/relation/operation/limit.rb

@@ -0,0 +1,156 @@
+module Veritas
+  class Optimizer
+    module Relation
+      module Operation
+
+        # Abstract base class representing Limit optimizations
+        class Limit < Unary
+
+        private
+
+          # Return the operation limit
+          #
+          # @return [Integer]
+          #
+          # @api private
+          def limit
+            operation.to_i
+          end
+
+          # Optimize when the limit is zero
+          class ZeroLimit < self
+
+            # Test if the limit is zero
+            #
+            # @return [Boolean]
+            #
+            # @api private
+            def optimizable?
+              limit.zero?
+            end
+
+            # A Limit with a limit of zero is empty
+            #
+            # @return [Relation::Empty]
+            #
+            # @api private
+            def optimize
+              Veritas::Relation::Empty.new(operation.header)
+            end
+
+          end # class ZeroLimit
+
+          # Optimize when the operand is a Limit and the limits are equal
+          class EqualLimitOperand < self
+
+            # Test if the operand is a Limit and the limits are equal
+            #
+            # @return [Boolean]
+            #
+            # @api private
+            def optimizable?
+              operand.kind_of?(operation.class) && equal_limit?
+            end
+
+            # Flatten equal Limit relations into a single relation
+            #
+            # @return [Projection]
+            #
+            # @api private
+            def optimize
+              operand
+            end
+
+          private
+
+            # Test if the operation and operand limits are equal
+            #
+            # @return [Boolean]
+            #
+            # @api private
+            def equal_limit?
+              limit == operand.to_i
+            end
+
+          end # class EqualLimitOperand
+
+          # Optimize when the operand is a Limit
+          class InequalLimitOperand < self
+
+            # Test if the operand is a Limit
+            #
+            # @return [Boolean]
+            #
+            # @api private
+            def optimizable?
+              operand.kind_of?(operation.class) && inequal_limit?
+            end
+
+            # Flatten Limit operations using the minimum limit
+            #
+            # @return [Boolean]
+            #
+            # @api private
+            def optimize
+              operation.class.new(operand.operand, min_limit)
+            end
+
+          private
+
+            # Test if the operation and operand limits are not equal
+            #
+            # @return [Boolean]
+            #
+            # @api private
+            def inequal_limit?
+              limit != operand.to_i
+            end
+
+            # Return the minimum limit between the operation and operand
+            #
+            # @return [Integer]
+            #
+            # @api private
+            def min_limit
+              [ limit, operand.to_i ].min
+            end
+
+          end # class InequalLimitOperand
+
+          # 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 Limit with an optimized operand
+            #
+            # @return [Limit]
+            #
+            # @api private
+            def optimize
+              operation.class.new(operand, limit)
+            end
+
+          end # class UnoptimizedOperand
+
+          Veritas::Relation::Operation::Limit.optimizer = chain(
+            ZeroLimit,
+            EqualLimitOperand,
+            InequalLimitOperand,
+            EmptyOperand,
+            MaterializedOperand,
+            UnoptimizedOperand
+          )
+
+        end # class Limit
+      end # module Operation
+    end # module Relation
+  end # class Optimizer
+end # module Veritas

data/lib/veritas/optimizer/relation/operation/offset.rb

@@ -0,0 +1,112 @@
+module Veritas
+  class Optimizer
+    module Relation
+      module Operation
+
+        # Abstract base class representing Offset optimizations
+        class Offset < Unary
+
+        private
+
+          # Return the operation offset
+          #
+          # @return [Integer]
+          #
+          # @api private
+          def offset
+            operation.to_i
+          end
+
+          # Optimize when the offset is zero
+          class ZeroOffset < self
+
+            # Test if the offset is zero
+            #
+            # @return [Boolean]
+            #
+            # @api private
+            def optimizable?
+              offset.zero?
+            end
+
+            # An Offset with an offset of zero is a noop
+            #
+            # @return [Relation]
+            #
+            # @api private
+            def optimize
+              operand
+            end
+
+          end # class ZeroOffset
+
+          # Optimize when the operand is an Offset
+          class OffsetOperand < self
+
+            # Test if the operand is an Offset
+            #
+            # @return [Boolean]
+            #
+            # @api private
+            def optimizable?
+              operand.kind_of?(operation.class)
+            end
+
+            # Flatten Offset operations using the sum of the offsets
+            #
+            # @return [Boolean]
+            #
+            # @api private
+            def optimize
+              operation.class.new(operand.operand, sum_offset)
+            end
+
+          private
+
+            # Return the sum of the operation and operand offsets
+            #
+            # @return [Integer]
+            #
+            # @api private
+            def sum_offset
+              offset + operand.to_i
+            end
+
+          end # class OffsetOperand
+
+          # 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 an Offset with an optimized operand
+            #
+            # @return [Offset]
+            #
+            # @api private
+            def optimize
+              operation.class.new(operand, offset)
+            end
+
+          end # class UnoptimizedOperand
+
+          Veritas::Relation::Operation::Offset.optimizer = chain(
+            ZeroOffset,
+            OffsetOperand,
+            EmptyOperand,
+            MaterializedOperand,
+            UnoptimizedOperand
+          )
+
+        end # class Offset
+      end # module Operation
+    end # module Relation
+  end # class Optimizer
+end # module Veritas