axiom-optimizer 0.1.0

data/lib/axiom/optimizer/function/string/length.rb

@@ -0,0 +1,31 @@
+# encoding: utf-8
+
+module Axiom
+  class Optimizer
+    module Function
+      module String
+
+        # Abstract base class representing Length optimizations
+        class Length < Optimizer
+          include Unary
+
+          # Optimize when the operand is constant
+          class ConstantOperand < self
+            include Unary::ConstantOperand
+          end # class ConstantOperand
+
+          # Optimize when the operand is unoptimized
+          class UnoptimizedOperand < self
+            include Unary::UnoptimizedOperand
+          end # class UnoptimizedOperand
+
+          Axiom::Function::String::Length.optimizer = chain(
+            ConstantOperand,
+            UnoptimizedOperand
+          )
+
+        end # class Length
+      end # module String
+    end # module Function
+  end # class Optimizer
+end # module Axiom

data/lib/axiom/optimizer/function/unary.rb

@@ -0,0 +1,86 @@
+# encoding: utf-8
+
+module Axiom
+  class Optimizer
+    module Function
+
+      # Mixin for optimizations to Unary functions
+      module Unary
+
+        # The optimized operand
+        #
+        # @return [Relation]
+        #
+        # @api private
+        attr_reader :operand
+
+        # Initialize a Unary optimizer
+        #
+        # @return [undefined]
+        #
+        # @api private
+        def initialize(*)
+          super
+          @operand = optimize_operand
+        end
+
+      private
+
+        # Optimize the operand
+        #
+        # @return [Relation]
+        #
+        # @api private
+        def optimize_operand
+          Function.optimize_operand(operation.operand)
+        end
+
+        # Optimize when the operand is constant
+        module ConstantOperand
+
+          # Test if the operand is constant
+          #
+          # @return [Boolean]
+          #
+          # @api private
+          def optimizable?
+            Util.constant?(operand)
+          end
+
+          # Evaluate the operand and return the constant
+          #
+          # @return [Object]
+          #
+          # @api private
+          def optimize
+            operation.class.call(operand)
+          end
+
+        end # module ConstantOperand
+
+        # Optimize when the operand is unoptimized
+        module UnoptimizedOperand
+
+          # Test if the operand is unoptimized
+          #
+          # @return [Boolean]
+          #
+          # @api private
+          def optimizable?
+            ! operand.equal?(operation.operand)
+          end
+
+          # Return a Aggregate with an optimized operand
+          #
+          # @return [Aggregate]
+          #
+          # @api private
+          def optimize
+            operation.class.new(operand)
+          end
+
+        end # module UnoptimizedOperand
+      end # class Unary
+    end # module Function
+  end # class Optimizer
+end # module Axiom

data/lib/axiom/optimizer/optimizable.rb

@@ -0,0 +1,60 @@
+# encoding: utf-8
+
+module Axiom
+  class Optimizer
+
+    # Allow operations to be optimizable
+    module Optimizable
+      include Adamantium
+
+      # 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
+      #
+      # @return [Optimizable]
+      #   the optimized operation
+      #
+      # @api public
+      #
+      # @todo simplify by setting a default Identity optimizer for all relations
+      def optimize
+        optimizer = self.class.optimizer || Optimizer::Identity
+        optimized = optimizer.call(self)
+        equal?(optimized)                ? self               :
+        optimized.respond_to?(:optimize) ? optimized.optimize :
+                                           optimized
+      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 Axiom
+
+Axiom::Aggregate.class_eval { include Axiom::Optimizer::Optimizable }
+Axiom::Function.class_eval  { include Axiom::Optimizer::Optimizable }
+Axiom::Relation.class_eval  { include Axiom::Optimizer::Optimizable }

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

@@ -0,0 +1,40 @@
+# encoding: utf-8
+
+module Axiom
+  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
+            Axiom::Relation::Empty.new(operation.header, operation)
+          end
+
+        end # class EmptyOperand
+
+        Axiom::Relation::Materialized.optimizer = chain(
+          EmptyOperand
+        )
+
+      end # class Materialized
+    end # module Relation
+  end # class Optimizer
+end # module Axiom

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

@@ -0,0 +1,134 @@
+# encoding: utf-8
+
+module Axiom
+  class Optimizer
+    module Relation
+      module Operation
+
+        # Abstract base class representing Binary relation optimizations
+        class Binary < Optimizer
+          include Function::Binary
+
+          # Optimize when operands are equal
+          module EqualOperands
+
+            # Test if the operands are equal
+            #
+            # @return [Boolean]
+            #
+            # @todo do not materialize the operands to compare them
+            #
+            # @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?(Axiom::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?(Axiom::Relation::Empty)
+            end
+
+          end # module EmptyRight
+
+          # Optimize when the left operand is an Order
+          class OrderLeft < self
+
+            # Test if the left operand is an Order
+            #
+            # @return [Boolean]
+            #
+            # @api private
+            def optimizable?
+              left.kind_of?(Axiom::Relation::Operation::Order)
+            end
+
+            # Drop the Order and wrap the left operand
+            #
+            # @return [Binary]
+            #
+            # @api private
+            def optimize
+              operation.class.new(left.operand, right)
+            end
+
+          end # class OrderLeft
+
+          # Optimize when the right operand is an Order
+          class OrderRight < self
+
+            # Test if the right operand is an Order
+            #
+            # @return [Boolean]
+            #
+            # @api private
+            def optimizable?
+              right.kind_of?(Axiom::Relation::Operation::Order)
+            end
+
+            # Drop the Order and wrap the right operand
+            #
+            # @return [Binary]
+            #
+            # @api private
+            def optimize
+              operation.class.new(left, right.operand)
+            end
+
+          end # class OrderRight
+
+          # Optimize when the operands are Materialized
+          class MaterializedOperands < self
+
+            # Test if the operands are materialized
+            #
+            # @return [Boolean]
+            #
+            # @api private
+            def optimizable?
+              left.kind_of?(Axiom::Relation::Materialized) &&
+              right.kind_of?(Axiom::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 UnoptimizedOperands < self
+            include Function::Binary::UnoptimizedOperands
+          end # class UnoptimizedOperands
+        end # class Binary
+      end # module Operation
+    end # module Relation
+  end # class Optimizer
+end # module Axiom

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

@@ -0,0 +1,33 @@
+# encoding: utf-8
+
+module Axiom
+  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
+            Axiom::Relation::Empty.new(operation.header, operation)
+          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 Axiom

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

@@ -0,0 +1,20 @@
+# encoding: utf-8
+
+module Axiom
+  class Optimizer
+    module Relation
+      module Operation
+
+        # Abstract base class representing Difference optimizations
+        class Deletion < Relation::Operation::Binary
+
+          Axiom::Relation::Operation::Deletion.optimizer = chain(
+            MaterializedOperands,
+            UnoptimizedOperands
+          )
+
+        end # class Deletion
+      end # module Operation
+    end # module Relation
+  end # class Optimizer
+end # module Axiom

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

@@ -0,0 +1,20 @@
+# encoding: utf-8
+
+module Axiom
+  class Optimizer
+    module Relation
+      module Operation
+
+        # Abstract base class representing Difference optimizations
+        class Insertion < Relation::Operation::Binary
+
+          Axiom::Relation::Operation::Insertion.optimizer = chain(
+            MaterializedOperands,
+            UnoptimizedOperands
+          )
+
+        end # class Insertion
+      end # module Operation
+    end # module Relation
+  end # class Optimizer
+end # module Axiom

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

@@ -0,0 +1,141 @@
+# encoding: utf-8
+
+module Axiom
+  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
+              Axiom::Relation::Empty.new(operation.header, operation)
+            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
+              operand.operand.take(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
+            include Function::Unary::UnoptimizedOperand
+
+            # Return a Limit with an optimized operand
+            #
+            # @return [Limit]
+            #
+            # @api private
+            def optimize
+              operand.take(limit)
+            end
+
+          end # class UnoptimizedOperand
+
+          Axiom::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 Axiom