axiom-optimizer 0.1.0

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

@@ -0,0 +1,106 @@
+# encoding: utf-8
+
+module Axiom
+  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
+              operand.operand.drop(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
+            include Function::Unary::UnoptimizedOperand
+
+            # Return an Offset with an optimized operand
+            #
+            # @return [Offset]
+            #
+            # @api private
+            def optimize
+              operand.drop(offset)
+            end
+
+          end # class UnoptimizedOperand
+
+          Axiom::Relation::Operation::Offset.optimizer = chain(
+            ZeroOffset,
+            OffsetOperand,
+            EmptyOperand,
+            MaterializedOperand,
+            UnoptimizedOperand
+          )
+
+        end # class Offset
+      end # module Operation
+    end # module Relation
+  end # class Optimizer
+end # module Axiom

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

@@ -0,0 +1,85 @@
+# encoding: utf-8
+
+module Axiom
+  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
+              operand.operand.sort_by { 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.kind_of?(Axiom::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
+            include Function::Unary::UnoptimizedOperand
+
+            # Return an Order with an optimized operand
+            #
+            # @return [Offset]
+            #
+            # @api private
+            def optimize
+              operand.sort_by { operation.directions }
+            end
+
+          end # class UnoptimizedOperand
+
+          Axiom::Relation::Operation::Order.optimizer = chain(
+            OrderOperand,
+            OneLimitOperand,
+            EmptyOperand,
+            MaterializedOperand,
+            UnoptimizedOperand
+          )
+
+        end # class Order
+      end # module Operation
+    end # module Relation
+  end # class Optimizer
+end # module Axiom

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

@@ -0,0 +1,85 @@
+# encoding: utf-8
+
+module Axiom
+  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?(Axiom::Relation::Operation::Order)
+            end
+
+            # Flatten Reverse operation and Order operand into an Order
+            #
+            # @return [Order]
+            #
+            # @api private
+            def optimize
+              operand.operand.sort_by { operation.directions }
+            end
+
+          end # class OrderOperand
+
+          # Optimize when operand is optimizable
+          class UnoptimizedOperand < self
+            include Function::Unary::UnoptimizedOperand
+
+            # Return an Reverse with an optimized operand
+            #
+            # @return [Reverse]
+            #
+            # @api private
+            def optimize
+              operand.reverse
+            end
+
+          end # class UnoptimizedOperand
+
+          Axiom::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 Axiom

data/lib/axiom/optimizer/relation/operation/unary.rb

@@ -0,0 +1,124 @@
+# encoding: utf-8
+
+module Axiom
+  class Optimizer
+    module Relation
+      module Operation
+
+        # Abstract base class representing Unary relation optimizations
+        class Unary < Optimizer
+          include Function::Unary
+
+          # The operation header
+          #
+          # @return [Header]
+          #
+          # @api private
+          attr_reader :header
+
+          # Initialize a Unary optimizer
+          #
+          # @return [undefined]
+          #
+          # @api private
+          def initialize(*)
+            super
+            @header = operation.header
+          end
+
+          # Optimize when the operand is an Order
+          module OrderOperand
+
+            # Test if the operand is an Order
+            #
+            # @return [Boolean]
+            #
+            # @api private
+            def optimizable?
+              operand.kind_of?(Axiom::Relation::Operation::Order)
+            end
+
+            # Drop the Order and wrap the operand
+            #
+            # @return [Order]
+            #
+            # @api private
+            def optimize
+              wrap_operand
+            end
+
+          end # module OrderOperand
+
+          # Optimize when the header is not changed
+          class UnchangedHeader < self
+
+            # Test if the operation header are the same as the operand's
+            #
+            # @return [Boolean]
+            #
+            # @api private
+            def optimizable?
+              header == operand.header
+            end
+
+            # A Projection, Rename or Extension with an unchanged header is a noop
+            #
+            # @return [Relation]
+            #
+            # @api private
+            def optimize
+              operand
+            end
+
+          end # class UnchangedHeader
+
+          # Optimize when the operand is Empty
+          class EmptyOperand < self
+
+            # Test if the operand is empty
+            #
+            # @return [Boolean]
+            #
+            # @api private
+            def optimizable?
+              operand.kind_of?(Axiom::Relation::Empty)
+            end
+
+            # A Unary operation on an empty operand is empty
+            #
+            # @return [Relation::Empty]
+            #
+            # @api private
+            def optimize
+              operand
+            end
+
+          end # class EmptyOperand
+
+          # Optimize when the operand is Materialized
+          class MaterializedOperand < self
+
+            # Test if the operand is materialized
+            #
+            # @return [Boolean]
+            #
+            # @api private
+            def optimizable?
+              operand.kind_of?(Axiom::Relation::Materialized)
+            end
+
+            # Return the materialized operation
+            #
+            # @return [Relation::Materialized]
+            #
+            # @api private
+            def optimize
+              operation.materialize
+            end
+
+          end # class MaterializedOperand
+        end # class Unary
+      end # module Operation
+    end # module Relation
+  end # class Optimizer
+end # module Axiom

data/lib/axiom/optimizer/support/predicate_partition.rb

@@ -0,0 +1,184 @@
+# encoding: utf-8
+
+module Axiom
+  class Optimizer
+
+    # Partition a predicate to distribute it over binary operations
+    class PredicatePartition
+      include Adamantium
+
+      TAUTOLOGY = Axiom::Function::Proposition::Tautology.instance
+
+      # Returns the predicate for the left header
+      #
+      # @return [Function]
+      #
+      # @api private
+      attr_reader :left
+
+      # Returns the predicate for the right header
+      #
+      # @return [Function]
+      #
+      # @api private
+      attr_reader :right
+
+      # Returns the remainder predicate
+      #
+      # @return [Function]
+      #
+      # @api private
+      attr_reader :remainder
+
+      # Initialize a Predication Partition
+      #
+      # @example
+      #   partition = PredicatePartition.new(predicate, left_header, right_header)
+      #
+      # @param [Function] predicate
+      #
+      # @param [Header] left_header
+      #
+      # @param [Header] right_header
+      #
+      # @return [undefined]
+      #
+      # @api private
+      def initialize(predicate, left_header, right_header)
+        @left      = TAUTOLOGY
+        @right     = TAUTOLOGY
+        @remainder = TAUTOLOGY
+
+        @left_header  = left_header
+        @right_header = right_header
+
+        partition!(predicate)
+      end
+
+    private
+
+      # Partition the predicate into a left, right and remainder predicates
+      #
+      # @param [Function] predicate
+      #
+      # @return [undefined]
+      #
+      # @api private
+      def partition!(predicate)
+        each_operand(predicate) do |operand|
+          case operand
+          when Axiom::Function::Binary   then partition_binary!(operand)
+          when Axiom::Function::Unary    then partition_unary!(operand)
+          when Axiom::Attribute::Boolean then partition_attribute!(operand)
+          else
+            partition_proposition!(operand)
+          end
+        end
+      end
+
+      # Partition the binary function up into a left, right and remainder predicates
+      #
+      # @param [Function::Binary] function
+      #
+      # @return [undefined]
+      #
+      # @api private
+      def partition_binary!(function)
+        operands = [ function.left, function.right ].select do |operand|
+          operand.kind_of?(Axiom::Attribute)
+        end
+
+        left_operands  = @left_header  & operands
+        right_operands = @right_header & operands
+
+        if (left_operands - right_operands).empty? || (right_operands - left_operands).empty?
+          @left  &= function if left_operands.any?
+          @right &= function if right_operands.any?
+        else
+          @remainder &= function
+        end
+      end
+
+      # Partition the unary function up into the left and right predicates
+      #
+      # @param [Function::Unary] function
+      #
+      # @return [undefined]
+      #
+      # @api private
+      def partition_unary!(function)
+        operand = function.operand
+        @left  &= function if @left_header.include?(operand)
+        @right &= function if @right_header.include?(operand)
+      end
+
+      # Partition the attribute up into the left and right predicates
+      #
+      # @param [Attribute] attribute
+      #
+      # @return [undefined]
+      #
+      # @api private
+      def partition_attribute!(attribute)
+        @left  &= attribute if @left_header.include?(attribute)
+        @right &= attribute if @right_header.include?(attribute)
+      end
+
+      # Partition the proposition up into the left, right and remainder predicates
+      #
+      # @param [Function::Proposition] proposition
+      #
+      # @return [undefined]
+      #
+      # @api private
+      def partition_proposition!(proposition)
+        @remainder &= proposition
+        @left      &= proposition
+        @right     &= proposition
+      end
+
+      # Yield each operand in the predicate recursively
+      #
+      # @param [Function] predicate
+      #
+      # @yield [operand]
+      #
+      # @yieldparam [Function] operand
+      #   each operand in the predicate
+      #
+      # @yieldreturn [undefined]
+      #
+      # @return [undefined]
+      #
+      # @api private
+      def each_operand(predicate, &block)
+        case predicate
+        when Axiom::Function::Connective::Disjunction then each_operand(predicate.inverse.optimize, &block)
+        when Axiom::Function::Connective::Conjunction then each_conjunction(predicate, &block)
+        else
+          block.call(predicate)
+        end
+      end
+
+      # Yield each operand of the conjunction
+      #
+      # @param [Function::Connective::Conjunction] conjunction
+      #
+      # @yield [operand]
+      #
+      # @yieldparam [Function] operand
+      #   each operand in the conjunction
+      #
+      # @yieldreturn [undefined]
+      #
+      # @return [undefined]
+      #
+      # @api private
+      def each_conjunction(conjunction, &block)
+        each_operand(conjunction.left,  &block)
+        each_operand(conjunction.right, &block)
+      end
+
+    end # class PredicatePartition
+  end # class Optimizer
+end # module Axiom