axiom-optimizer 0.1.0

data/lib/axiom/optimizer/aggregate/mean.rb

@@ -0,0 +1,17 @@
+# encoding: utf-8
+
+module Axiom
+  class Optimizer
+    class Aggregate
+
+      # Abstract base class representing Mean optimizations
+      class Mean < self
+
+        Axiom::Aggregate::Mean.optimizer = chain(
+          UnoptimizedOperand
+        )
+
+      end # class Mean
+    end # class Aggregate
+  end # class Optimizer
+end # module Axiom

data/lib/axiom/optimizer/aggregate/minimum.rb

@@ -0,0 +1,17 @@
+# encoding: utf-8
+
+module Axiom
+  class Optimizer
+    class Aggregate
+
+      # Abstract base class representing Minimum optimizations
+      class Minimum < self
+
+        Axiom::Aggregate::Minimum.optimizer = chain(
+          UnoptimizedOperand
+        )
+
+      end # class Minimum
+    end # class Aggregate
+  end # class Optimizer
+end # module Axiom

data/lib/axiom/optimizer/aggregate/standard_deviation.rb

@@ -0,0 +1,17 @@
+# encoding: utf-8
+
+module Axiom
+  class Optimizer
+    class Aggregate
+
+      # Abstract base class representing StandardDeviation optimizations
+      class StandardDeviation < self
+
+        Axiom::Aggregate::StandardDeviation.optimizer = chain(
+          UnoptimizedOperand
+        )
+
+      end # class StandardDeviation
+    end # class Aggregate
+  end # class Optimizer
+end # module Axiom

data/lib/axiom/optimizer/aggregate/sum.rb

@@ -0,0 +1,17 @@
+# encoding: utf-8
+
+module Axiom
+  class Optimizer
+    class Aggregate
+
+      # Abstract base class representing Sum optimizations
+      class Sum < self
+
+        Axiom::Aggregate::Sum.optimizer = chain(
+          UnoptimizedOperand
+        )
+
+      end # class Sum
+    end # class Aggregate
+  end # class Optimizer
+end # module Axiom

data/lib/axiom/optimizer/aggregate/variance.rb

@@ -0,0 +1,17 @@
+# encoding: utf-8
+
+module Axiom
+  class Optimizer
+    class Aggregate
+
+      # Abstract base class representing Variance optimizations
+      class Variance < self
+
+        Axiom::Aggregate::Variance.optimizer = chain(
+          UnoptimizedOperand
+        )
+
+      end # class Variance
+    end # class Aggregate
+  end # class Optimizer
+end # module Axiom

data/lib/axiom/optimizer/algebra/difference.rb

@@ -0,0 +1,68 @@
+# encoding: utf-8
+
+module Axiom
+  class Optimizer
+    module Algebra
+
+      # Abstract base class representing Difference optimizations
+      class Difference < Relation::Operation::Binary
+
+        # Optimize when operands are equal
+        class EqualOperands < self
+          include Relation::Operation::Binary::EqualOperands
+
+          # A Difference with equal operands is empty
+          #
+          # @return [Relation::Empty]
+          #
+          # @api private
+          def optimize
+            Axiom::Relation::Empty.new(operation.header, operation)
+          end
+
+        end # class EqualOperands
+
+        # Optimize when the left operand is empty
+        class EmptyLeft < self
+          include Relation::Operation::Binary::EmptyLeft
+
+          # A Difference with an empty left operand is empty
+          #
+          # @return [Relation::Empty]
+          #
+          # @api private
+          def optimize
+            left
+          end
+
+        end # class EmptyLeft
+
+        # Optimize when the right operand is empty
+        class EmptyRight < self
+          include Relation::Operation::Binary::EmptyRight
+
+          # A Difference with an empty right operand is equivalent to the left
+          #
+          # @return [Relation]
+          #
+          # @api private
+          def optimize
+            left
+          end
+
+        end # class EmptyRight
+
+        Axiom::Algebra::Difference.optimizer = chain(
+          EqualOperands,
+          EmptyLeft,
+          EmptyRight,
+          OrderLeft,
+          OrderRight,
+          MaterializedOperands,
+          UnoptimizedOperands
+        )
+
+      end # class Difference
+    end # module Algebra
+  end # class Optimizer
+end # module Axiom

data/lib/axiom/optimizer/algebra/extension.rb

@@ -0,0 +1,97 @@
+# encoding: utf-8
+
+module Axiom
+  class Optimizer
+    module Algebra
+
+      # Abstract base class representing Extension optimizations
+      class Extension < Relation::Operation::Unary
+
+        # The optimized extensions
+        #
+        # @return [Hash{Attribute => Function}]
+        #
+        # @api private
+        attr_reader :extensions
+
+        # Initialize a Summarization optimizer
+        #
+        # @return [undefined]
+        #
+        # @api private
+        def initialize(*)
+          super
+          @extensions = optimize_extensions
+        end
+
+      private
+
+        # Optimize the extensions
+        #
+        # @return [Hash{Attribute => Function}]
+        #
+        # @api private
+        def optimize_extensions
+          Function.optimize_functions(operation.extensions)
+        end
+
+        # Wrap the operand's operand in an Extension
+        #
+        # @return [Extension]
+        #
+        # @api private
+        def wrap_operand(operand = operand.operand)
+          operand.extend(extensions)
+        end
+
+        # Optimize when the operand is an Order
+        class OrderOperand < self
+          include Relation::Operation::Unary::OrderOperand
+        end # class OrderOperand
+
+        # Optimize when operands are optimizable
+        class UnoptimizedOperand < self
+          include Function::Unary::UnoptimizedOperand
+
+          # Test if the operand is unoptimized
+          #
+          # @return [Boolean]
+          #
+          # @api private
+          def optimizable?
+            super || extensions_optimizable?
+          end
+
+          # Return an Extension with an optimized operand
+          #
+          # @return [Algebra::Extension]
+          #
+          # @api private
+          def optimize
+            wrap_operand(operand)
+          end
+
+        private
+
+          # Test if the extensions are optimizable
+          #
+          # @return [Boolean]
+          #
+          # @api private
+          def extensions_optimizable?
+            ! extensions.eql?(operation.extensions)
+          end
+
+        end # class UnoptimizedOperand
+
+        Axiom::Algebra::Extension.optimizer = chain(
+          UnchangedHeader,
+          MaterializedOperand,
+          OrderOperand,
+          UnoptimizedOperand
+        )
+
+      end # class Extension
+    end # module Algebra
+  end # class Optimizer
+end # module Axiom

data/lib/axiom/optimizer/algebra/intersection.rb

@@ -0,0 +1,68 @@
+# encoding: utf-8
+
+module Axiom
+  class Optimizer
+    module Algebra
+
+      # Abstract base class representing Intersection optimizations
+      class Intersection < Relation::Operation::Binary
+
+        # Optimize when operands are equal
+        class EqualOperands < self
+          include Relation::Operation::Binary::EqualOperands
+
+          # An Intersection with equal operands is equivalent to either operand
+          #
+          # @return [Relation]
+          #
+          # @api private
+          def optimize
+            left
+          end
+
+        end # class EqualOperands
+
+        # Optimize when the left operand is empty
+        class EmptyLeft < self
+          include Relation::Operation::Binary::EmptyLeft
+
+          # An Intersection with an empty left operand is empty
+          #
+          # @return [Relation::Empty]
+          #
+          # @api private
+          def optimize
+            left
+          end
+
+        end # class EmptyLeft
+
+        # Optimize when the right operand is empty
+        class EmptyRight < self
+          include Relation::Operation::Binary::EmptyRight
+
+          # An Intersection with an empty right operand is empty
+          #
+          # @return [Relation::Empty]
+          #
+          # @api private
+          def optimize
+            right
+          end
+
+        end # class EmptyRight
+
+        Axiom::Algebra::Intersection.optimizer = chain(
+          EqualOperands,
+          EmptyLeft,
+          EmptyRight,
+          OrderLeft,
+          OrderRight,
+          MaterializedOperands,
+          UnoptimizedOperands
+        )
+
+      end # class Intersection
+    end # module Algebra
+  end # class Optimizer
+end # module Axiom

data/lib/axiom/optimizer/algebra/join.rb

@@ -0,0 +1,184 @@
+# encoding: utf-8
+
+module Axiom
+  class Optimizer
+    module Algebra
+
+      # Abstract base class representing Join optimizations
+      class Join < Relation::Operation::Combination
+
+        CONTRADICTION = Axiom::Function::Proposition::Contradiction.instance
+
+      private
+
+        # Return the key to join the operations with
+        #
+        # @return [Header]
+        #
+        # @todo find a minimal key from the header
+        #
+        # @api private
+        def join_key
+          operation.join_header
+        end
+
+        # Return a predicate that matches every tuple in the materialized operand
+        #
+        # @return [Function]
+        #
+        # @api private
+        def materialized_predicate
+          matching_projection.reduce(CONTRADICTION) { |predicate, tuple| predicate.or(tuple.predicate) }.optimize
+        end
+
+        # Optimize when operands' headers are equal
+        class EqualHeaders < self
+
+          # Test if the operands' headers are equal
+          #
+          # @return [Boolean]
+          #
+          # @api private
+          def optimizable?
+            left.header.eql?(right.header)
+          end
+
+          # A Join with equal headers is an Intersection
+          #
+          # @return [Algebra::Intersection]
+          #
+          # @api private
+          def optimize
+            left.intersect(right)
+          end
+
+        end # class EqualHeaders
+
+        # Optimize when operands' headers are disjoint
+        class DisjointHeaders < self
+
+          # Test if the operands' headers are disjoint
+          #
+          # @return [Boolean]
+          #
+          # @api private
+          def optimizable?
+            (left.header & right.header).none?
+          end
+
+          # A Join with disjoint headers is a Product
+          #
+          # @return [Algebra::Product]
+          #
+          # @api private
+          def optimize
+            left.product(right)
+          end
+
+        end # class EqualHeaders
+
+        # Optimize when the left operand is materialized
+        class MaterializedLeft < self
+
+          # Test if the left operand is materialized
+          #
+          # @return [Boolean]
+          #
+          # @api private
+          def optimizable?
+            left.materialized? && ! right_matching_left?
+          end
+
+          # Return the join of the left and right with the right restricted
+          #
+          # @return [Algebra::Join]
+          #
+          # @api private
+          def optimize
+            left.join(right.restrict(materialized_predicate))
+          end
+
+        private
+
+          # Test if the right operand is a restriction matching the left
+          #
+          # @return [Boolean]
+          #
+          # @api private
+          def right_matching_left?
+            right.kind_of?(Axiom::Algebra::Restriction) && right.predicate.eql?(materialized_predicate)
+          end
+
+          # Return a the matching projection of the materializd relation
+          #
+          # @return [Projection]
+          #
+          # @api private
+          def matching_projection
+            left.project(join_key)
+          end
+
+        end # class MaterializedLeft
+
+        # Optimize when the right operand is materialized
+        class MaterializedRight < self
+
+          # Test if the right operand is materialized
+          #
+          # @return [Boolean]
+          #
+          # @api private
+          def optimizable?
+            right.materialized? && ! left_matching_right?
+          end
+
+          # Return the join of the left and right with the left restricted
+          #
+          # @return [Algebra::Join]
+          #
+          # @api private
+          def optimize
+            left.restrict(materialized_predicate).join(right)
+          end
+
+        private
+
+          # Test if the left operand is a restriction matching the right
+          #
+          # @return [Boolean]
+          #
+          # @api private
+          def left_matching_right?
+            left.kind_of?(Axiom::Algebra::Restriction) && left.predicate.eql?(materialized_predicate)
+          end
+
+          # Return a the matching projection of the materializd relation
+          #
+          # @return [Projection]
+          #
+          # @api private
+          def matching_projection
+            right.project(join_key)
+          end
+
+        end # class MaterializedRight
+
+        Axiom::Algebra::Join.optimizer = chain(
+          EmptyLeft,
+          EmptyRight,
+          EqualHeaders,
+          DisjointHeaders,
+          OrderLeft,
+          OrderRight,
+          MaterializedOperands,
+          MaterializedLeft,
+          MaterializedRight,
+          UnoptimizedOperands
+        )
+
+        memoize :materialized_predicate
+
+      end # class Join
+    end # module Algebra
+  end # class Optimizer
+end # module Axiom