veritas 0.0.2 → 0.0.3

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

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

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

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

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

@@ -1,92 +0,0 @@
-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).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?
-              !operand.equal?(operation.operand)
-            end
-
-            # Return an Reverse with an optimized operand
-            #
-            # @return [Reverse]
-            #
-            # @api private
-            def optimize
-              operation.class.new(operand).optimize
-            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