veritas-optimizer 0.0.3

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

@@ -0,0 +1,168 @@
+# encoding: utf-8
+
+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/combination.rb

@@ -0,0 +1,33 @@
+# encoding: utf-8
+
+module Veritas
+  class Optimizer
+    module Relation
+      module Operation
+
+        # Abstract base class representing combinations of relations
+        class Combination < 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 Combination
+      end # module Operation
+    end # module Relation
+  end # class Optimizer
+end # module Veritas

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

@@ -0,0 +1,149 @@
+# encoding: utf-8
+
+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.limit
+          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.limit
+            end
+
+          end # class EqualLimitOperand
+
+          # Optimize when the operand is a Limit
+          class LimitOperand < self
+
+            # Test if the operand is a Limit
+            #
+            # @return [Boolean]
+            #
+            # @api private
+            def optimizable?
+              operand.kind_of?(operation.class)
+            end
+
+            # Flatten Limit operations using the minimum limit
+            #
+            # @return [Boolean]
+            #
+            # @api private
+            def optimize
+              operation.class.new(operand.operand, min_limit)
+            end
+
+          private
+
+            # Return the minimum limit between the operation and operand
+            #
+            # @return [Integer]
+            #
+            # @api private
+            def min_limit
+              [ limit, operand.limit ].min
+            end
+
+          end # class LimitOperand
+
+          # 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,
+            LimitOperand,
+            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,114 @@
+# encoding: utf-8
+
+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.offset
+          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.offset
+            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

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

@@ -0,0 +1,96 @@
+# encoding: utf-8
+
+module Veritas
+  class Optimizer
+    module Relation
+      module Operation
+
+        # Abstract base class representing Order optimizations
+        class Order < Unary
+
+          # 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?(operation.class)
+            end
+
+            # Flatten Order operations using the operation directions
+            #
+            # @return [Order]
+            #
+            # @api private
+            def optimize
+              operation = self.operation
+              operation.class.new(operand.operand, operation.directions)
+            end
+
+          end # class OrderOperand
+
+          # Optimize when the operand is a Limit with a limit of 1
+          class OneLimitOperand < self
+
+            # Test if the operand is an Limit with a limit of 1
+            #
+            # @return [Boolean]
+            #
+            # @api private
+            def optimizable?
+              operand = self.operand
+              operand.kind_of?(Veritas::Relation::Operation::Limit) &&
+              operand.limit == 1
+            end
+
+            # An Order of a Limit with a limit of 1 is a noop
+            #
+            # @return [Limit]
+            #
+            # @api private
+            def optimize
+              operand
+            end
+
+          end # class OneLimitOperand
+
+          # 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 Order with an optimized operand
+            #
+            # @return [Offset]
+            #
+            # @api private
+            def optimize
+              operation = self.operation
+              operation.class.new(operand, operation.directions)
+            end
+
+          end # class UnoptimizedOperand
+
+          Veritas::Relation::Operation::Order.optimizer = chain(
+            OrderOperand,
+            OneLimitOperand,
+            EmptyOperand,
+            MaterializedOperand,
+            UnoptimizedOperand
+          )
+
+        end # class Order
+      end # module Operation
+    end # module Relation
+  end # class Optimizer
+end # module Veritas

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

@@ -0,0 +1,94 @@
+# encoding: utf-8
+
+module Veritas
+  class Optimizer
+    module Relation
+      module Operation
+
+        # Abstract base class representing Reverse optimizations
+        class Reverse < Order
+
+          # 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?(operation.class)
+            end
+
+            # A Reverse of a Reverse is a noop
+            #
+            # @return [Relation]
+            #
+            # @api private
+            def optimize
+              operand.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
+
+            # Flatten Reverse operation and Order operand into an Order
+            #
+            # @return [Order]
+            #
+            # @api private
+            def optimize
+              operand = self.operand
+              operand.class.new(operand.operand, operation.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?
+              !operand.equal?(operation.operand)
+            end
+
+            # Return an Reverse with an optimized operand
+            #
+            # @return [Reverse]
+            #
+            # @api private
+            def optimize
+              operation.class.new(operand)
+            end
+
+          end # class UnoptimizedOperand
+
+          Veritas::Relation::Operation::Reverse.optimizer = chain(
+            ReverseOperand,
+            OrderOperand,
+            OneLimitOperand,
+            EmptyOperand,
+            MaterializedOperand,
+            UnoptimizedOperand
+          )
+
+        end # class Reverse
+      end # module Operation
+    end # module Relation
+  end # class Optimizer
+end # module Veritas