axiom-optimizer 0.1.0

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

@@ -0,0 +1,70 @@
+# encoding: utf-8
+
+module Axiom
+  class Optimizer
+    module Algebra
+
+      # Abstract base class representing Product optimizations
+      class Product < Relation::Operation::Combination
+
+        # Optimize when left operand is a TABLE DEE
+        class TableDeeLeft < self
+
+          # Test if the left operand is a TABLE DEE
+          #
+          # @return [Boolean]
+          #
+          # @api private
+          def optimizable?
+            left.header.empty? && ! left.kind_of?(Axiom::Relation::Empty)
+          end
+
+          # A Product with a left TABLE DEE is equivalent to the right operand
+          #
+          # @return [Relation]
+          #
+          # @api private
+          def optimize
+            right
+          end
+
+        end # class TableDeeLeft
+
+        # Optimize when right operand is a TABLE DEE
+        class TableDeeRight < self
+
+          # Test if the right operand is a TABLE DEE
+          #
+          # @return [Boolean]
+          #
+          # @api private
+          def optimizable?
+            right.header.empty? && ! right.kind_of?(Axiom::Relation::Empty)
+          end
+
+          # A Product with a right TABLE DEE is equivalent to the left operand
+          #
+          # @return [Relation]
+          #
+          # @api private
+          def optimize
+            left
+          end
+
+        end # class TableDeeRight
+
+        Axiom::Algebra::Product.optimizer = chain(
+          TableDeeLeft,
+          TableDeeRight,
+          EmptyLeft,
+          EmptyRight,
+          OrderLeft,
+          OrderRight,
+          MaterializedOperands,
+          UnoptimizedOperands
+        )
+
+      end # class Product
+    end # module Algebra
+  end # class Optimizer
+end # module Axiom

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

@@ -0,0 +1,212 @@
+# encoding: utf-8
+
+module Axiom
+  class Optimizer
+    module Algebra
+
+      # Abstract base class representing Projection optimizations
+      class Projection < Relation::Operation::Unary
+
+      private
+
+        # Wrap the operand's operand in a Projection
+        #
+        # @return [Projection]
+        #
+        # @api private
+        def wrap_operand(operand = operand.operand)
+          operand.project(header)
+        end
+
+        # Optimize when the operand is a Projection
+        class ProjectionOperand < self
+
+          # Test if the operand is a Projection
+          #
+          # @return [Boolean]
+          #
+          # @api private
+          def optimizable?
+            operand.kind_of?(operation.class)
+          end
+
+          # Flatten nested Projections into a single Projection
+          #
+          # @return [Projection]
+          #
+          # @api private
+          def optimize
+            wrap_operand
+          end
+
+        end # class ProjectionOperand
+
+        # Optimize when the operand is an Extension
+        class ExtensionOperand < self
+
+          # Test if the operand is an Extension
+          #
+          # @return [Boolean]
+          #
+          # @api private
+          def optimizable?
+            operand.kind_of?(Axiom::Algebra::Extension) &&
+            operand.extensions != new_extensions
+          end
+
+          # Extend the operand with the attributes not projected away
+          #
+          # This avoid performing an extension when the new attributes are
+          # immediately removed.
+          #
+          # @return [Projection]
+          #
+          # @api private
+          def optimize
+            extend_operand.project(operation.header)
+          end
+
+        private
+
+          # Extend the operand with only the new extensions
+          #
+          # @return [Extension]
+          #
+          # @api private
+          def extend_operand
+            unwrap_operand.extend(new_extensions)
+          end
+
+          # Unwrap the operand from the Extension
+          #
+          # @return [Relation]
+          #
+          # @api private
+          def unwrap_operand
+            operand.operand
+          end
+
+          # Extensions minus the removed attributes
+          #
+          # @return [Hash{Attribute => Function}]
+          #
+          # @api private
+          def new_extensions
+            extensions = operand.extensions
+            attributes = extensions.keys - removed_attributes
+            Hash[attributes.zip(extensions.values_at(*attributes))]
+          end
+
+          # Attributes removed by the projection
+          #
+          # @return [Header]
+          #
+          # @api private
+          def removed_attributes
+            operand.header - operation.header
+          end
+
+          memoize :new_extensions, :removed_attributes
+        end
+
+        # Optimize when the operand is a Union
+        class UnionOperand < self
+
+          # Test if the operand is a Union
+          #
+          # @return [Boolean]
+          #
+          # @api private
+          def optimizable?
+            operand.kind_of?(Axiom::Algebra::Union)
+          end
+
+          # Wrap each operand in the Union in a Projection
+          #
+          # @return [Set]
+          #
+          # @api private
+          def optimize
+            wrap_left.union(wrap_right)
+          end
+
+        private
+
+          # Utility method to wrap the left operand in a Projection
+          #
+          # @return [Projection]
+          #
+          # @api private
+          def wrap_left
+            wrap_operand(operand.left)
+          end
+
+          # Utility method to wrap the right operand in a Projection
+          #
+          # @return [Projection]
+          #
+          # @api private
+          def wrap_right
+            wrap_operand(operand.right)
+          end
+
+        end # class UnionOperand
+
+        # Optimize when the operand is an Order
+        class OrderOperand < self
+          include Relation::Operation::Unary::OrderOperand
+        end # class OrderOperand
+
+        # 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
+
+          # Return a new Empty relation with the operation's headers
+          #
+          # @return [Empty]
+          #
+          # @api private
+          def optimize
+            Axiom::Relation::Empty.new(header, operation)
+          end
+
+        end # class EmptyOperand
+
+        # Optimize when operand is optimizable
+        class UnoptimizedOperand < self
+          include Function::Unary::UnoptimizedOperand
+
+          # Return a Projection with an optimized operand
+          #
+          # @return [Projection]
+          #
+          # @api private
+          def optimize
+            wrap_operand(operand)
+          end
+
+        end # class UnoptimizedOperand
+
+        Axiom::Algebra::Projection.optimizer = chain(
+          UnchangedHeader,
+          ProjectionOperand,
+          ExtensionOperand,
+          UnionOperand,
+          OrderOperand,
+          EmptyOperand,
+          MaterializedOperand,
+          UnoptimizedOperand
+        )
+
+      end # class Projection
+    end # module Algebra
+  end # class Optimizer
+end # module Axiom

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

@@ -0,0 +1,381 @@
+# encoding: utf-8
+
+module Axiom
+  class Optimizer
+    module Algebra
+
+      # Abstract base class representing Rename optimizations
+      class Rename < Relation::Operation::Unary
+
+        # The optimized aliases
+        #
+        # @return [Rename::Aliases]
+        #
+        # @api private
+        attr_reader :aliases
+
+        # Initialize an Rename optimizer
+        #
+        # @param [Relation] operation
+        #
+        # @return [undefined]
+        #
+        # @api private
+        def initialize(operation)
+          super
+          @aliases = operation.aliases
+        end
+
+      private
+
+        # Wrap the operand's operand in a Rename
+        #
+        # @return [Rename]
+        #
+        # @api private
+        def wrap_operand(operand = operand.operand)
+          operand.rename(aliases)
+        end
+
+        # Optimize when the operand is a Rename
+        class RenameOperand < self
+
+          # Test if the operand is a Rename
+          #
+          # @return [Boolean]
+          #
+          # @api private
+          def optimizable?
+            operand.kind_of?(operation.class)
+          end
+
+          # Flatten nested Renames into a single Rename
+          #
+          # @return [Projection]
+          #
+          # @api private
+          def optimize
+            wrap_operand
+          end
+
+        private
+
+          # The optimized aliases
+          #
+          # @return [Rename::Aliases]
+          #
+          # @api private
+          def aliases
+            super.union(operand.aliases)
+          end
+
+        end # class RenameOperand
+
+        # Optimize when the operand is a Rename with aliases that cancel out
+        class RenameOperandAndEmptyAliases < RenameOperand
+
+          # Test if the operand is a Rename with aliases that cancel out
+          #
+          # @return [Boolean]
+          #
+          # @api private
+          def optimizable?
+            super && aliases.empty?
+          end
+
+          # A Rename wrapping a Rename with aliases that cancel out is a noop
+          #
+          # @return [Relation]
+          #
+          # @api private
+          def optimize
+            operand.operand
+          end
+
+        end # class RenameOperandAndEmptyAliases
+
+        # Optimize when the operand is a Projection
+        class ProjectionOperand < self
+
+          # Test if the operand is a Projection
+          #
+          # @return [Boolean]
+          #
+          # @api private
+          def optimizable?
+            operand.kind_of?(Axiom::Algebra::Projection) && distributive?
+          end
+
+          # Wrap the Rename in a Projection
+          #
+          # @return [Projection]
+          #
+          # @api private
+          def optimize
+            wrap_operand.project(header)
+          end
+
+        private
+
+          # Test if the rename can be distributed over the projection
+          #
+          # @return [Boolean]
+          #
+          # @api private
+          def distributive?
+            names = alias_names
+            removed_attributes.none? do |attribute|
+              names.include?(attribute.name)
+            end
+          end
+
+          # Return the aliases as an inverted Hash
+          #
+          # @return [Hash]
+          #
+          # @api private
+          def alias_names
+            aliases.to_hash.values.map { |attribute| attribute.name }
+          end
+
+          # Returns the attributes removed from the projection
+          #
+          # @return [#all?]
+          #
+          # @api private
+          def removed_attributes
+            operand.operand.header - operand.header
+          end
+
+        end # class ProjectionOperand
+
+        # Optimize when the operand is a Restriction
+        class RestrictionOperand < self
+
+          # Test if the operand is a Restriction
+          #
+          # @return [Boolean]
+          #
+          # @api private
+          def optimizable?
+            operand.kind_of?(Axiom::Algebra::Restriction)
+          end
+
+          # Wrap the Rename in a Restriction
+          #
+          # @return [Restriction]
+          #
+          # @api private
+          def optimize
+            wrap_operand.restrict(rename_predicate)
+          end
+
+        private
+
+          # Rename the operand predicate
+          #
+          # @return [Function]
+          #
+          # @api private
+          def rename_predicate
+            operand.predicate.rename(aliases)
+          end
+
+        end # class RestrictionOperand
+
+        # Optimize when the operand is a Set
+        class SetOperand < self
+
+          # Test if the operand is a Set
+          #
+          # @return [Boolean]
+          #
+          # @api private
+          def optimizable?
+            operand.kind_of?(Axiom::Relation::Operation::Set)
+          end
+
+          # Wrap each operand in the Set in a Rename
+          #
+          # @return [Set]
+          #
+          # @api private
+          def optimize
+            operand.class.new(wrap_left, wrap_right)
+          end
+
+        private
+
+          # Utility method to wrap the left operand in a Rename
+          #
+          # @return [Rename]
+          #
+          # @api private
+          def wrap_left
+            wrap_operand(operand.left)
+          end
+
+          # Utility method to wrap the right operand in a Rename
+          #
+          # @return [Rename]
+          #
+          # @api private
+          def wrap_right
+            wrap_operand(operand.right)
+          end
+
+        end # class SetOperand
+
+        # 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?(Axiom::Relation::Operation::Reverse)
+          end
+
+          # Wrap the Rename in a Reverse
+          #
+          # @return [Reverse]
+          #
+          # @api private
+          def optimize
+            wrap_operand.reverse
+          end
+
+        end # class ReverseOperand
+
+        # Optimize when the operand is an Order
+        class OrderOperand < self
+          include Relation::Operation::Unary::OrderOperand
+
+          # Wrap the Rename in an Order
+          #
+          # @return [Order]
+          #
+          # @api private
+          def optimize
+            wrap_operand.sort_by { directions }
+          end
+
+        private
+
+          # Return the renamed directions
+          #
+          # @return [Relation::Operation::Order::DirectionSet]
+          #
+          # @api private
+          def directions
+            operand.directions.rename(aliases)
+          end
+
+        end # class OrderOperand
+
+        # 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?(Axiom::Relation::Operation::Limit)
+          end
+
+          # Wrap the Rename in a Limit
+          #
+          # @return [Limit]
+          #
+          # @api private
+          def optimize
+            wrap_operand.take(operand.limit)
+          end
+
+        end # class LimitOperand
+
+        # 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?(Axiom::Relation::Operation::Offset)
+          end
+
+          # Wrap the Rename in an Offset
+          #
+          # @return [Offset]
+          #
+          # @api private
+          def optimize
+            wrap_operand.drop(operand.offset)
+          end
+
+        end # class OffsetOperand
+
+        # 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
+
+          # Return a new Empty relation with the operation's headers
+          #
+          # @return [Empty]
+          #
+          # @api private
+          def optimize
+            Axiom::Relation::Empty.new(header, operation)
+          end
+
+        end # class EmptyOperand
+
+        # Optimize when operand is optimizable
+        class UnoptimizedOperand < self
+          include Function::Unary::UnoptimizedOperand
+
+          # Return a Rename with an optimized operand
+          #
+          # @return [Rename]
+          #
+          # @api private
+          def optimize
+            wrap_operand(operand)
+          end
+
+        end # class UnoptimizedOperand
+
+        Axiom::Algebra::Rename.optimizer = chain(
+          UnchangedHeader,
+          RenameOperandAndEmptyAliases,
+          RenameOperand,
+          ProjectionOperand,
+          RestrictionOperand,
+          SetOperand,
+          ReverseOperand,
+          OrderOperand,
+          LimitOperand,
+          OffsetOperand,
+          EmptyOperand,
+          MaterializedOperand,
+          UnoptimizedOperand
+        )
+
+      end # class Rename
+    end # module Algebra
+  end # class Optimizer
+end # module Axiom