axiom-optimizer 0.1.1 → 0.2.0

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

@@ -56,8 +56,8 @@ module Axiom
           EqualOperands,
           EmptyLeft,
           EmptyRight,
-          OrderLeft,
-          OrderRight,
+          SortedLeft,
+          SortedRight,
           MaterializedOperands,
           UnoptimizedOperands
         )

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

@@ -88,7 +88,7 @@ module Axiom
           #
           # @api private
           def optimizable?
-            left.materialized? && ! right_matching_left?
+            left.materialized? && !right_matching_left?
           end
 
           # Return the join of the left and right with the right restricted
@@ -131,7 +131,7 @@ module Axiom
           #
           # @api private
           def optimizable?
-            right.materialized? && ! left_matching_right?
+            right.materialized? && !left_matching_right?
           end
 
           # Return the join of the left and right with the left restricted
@@ -170,8 +170,8 @@ module Axiom
           EmptyRight,
           EqualHeaders,
           DisjointHeaders,
-          OrderLeft,
-          OrderRight,
+          SortedLeft,
+          SortedRight,
           MaterializedOperands,
           MaterializedLeft,
           MaterializedRight,

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

@@ -16,7 +16,7 @@ module Axiom
           #
           # @api private
           def optimizable?
-            left.header.empty? && ! left.kind_of?(Axiom::Relation::Empty)
+            left.header.empty? && !left.kind_of?(Axiom::Relation::Empty)
           end
 
           # A Product with a left TABLE DEE is equivalent to the right operand
@@ -39,7 +39,7 @@ module Axiom
           #
           # @api private
           def optimizable?
-            right.header.empty? && ! right.kind_of?(Axiom::Relation::Empty)
+            right.header.empty? && !right.kind_of?(Axiom::Relation::Empty)
           end
 
           # A Product with a right TABLE DEE is equivalent to the left operand
@@ -58,8 +58,8 @@ module Axiom
           TableDeeRight,
           EmptyLeft,
           EmptyRight,
-          OrderLeft,
-          OrderRight,
+          SortedLeft,
+          SortedRight,
           MaterializedOperands,
           UnoptimizedOperands
         )

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

@@ -152,10 +152,10 @@ module Axiom
 
         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 an Sorted
+        class SortedOperand < self
+          include Relation::Operation::Unary::SortedOperand
+        end # class SortedOperand
 
         # Optimize when the operand is Empty
         class EmptyOperand < self
@@ -200,7 +200,7 @@ module Axiom
           ProjectionOperand,
           ExtensionOperand,
           UnionOperand,
-          OrderOperand,
+          SortedOperand,
           EmptyOperand,
           MaterializedOperand,
           UnoptimizedOperand

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

@@ -135,7 +135,7 @@ module Axiom
           #
           # @api private
           def alias_names
-            aliases.to_hash.values.map { |attribute| attribute.name }
+            aliases.to_hash.values.map(&:name)
           end
 
           # Returns the attributes removed from the projection
@@ -249,31 +249,31 @@ module Axiom
 
         end # class ReverseOperand
 
-        # Optimize when the operand is an Order
-        class OrderOperand < self
-          include Relation::Operation::Unary::OrderOperand
+        # Optimize when the operand is an Sorted
+        class SortedOperand < self
+          include Relation::Operation::Unary::SortedOperand
 
-          # Wrap the Rename in an Order
+          # Wrap the Rename in an Sorted
           #
-          # @return [Order]
+          # @return [Sorted]
           #
           # @api private
           def optimize
-            wrap_operand.sort_by { directions }
+            wrap_operand.sort_by(directions)
           end
 
         private
 
           # Return the renamed directions
           #
-          # @return [Relation::Operation::Order::DirectionSet]
+          # @return [Relation::Operation::Sorted::DirectionSet]
           #
           # @api private
           def directions
             operand.directions.rename(aliases)
           end
 
-        end # class OrderOperand
+        end # class SortedOperand
 
         # Optimize when the operand is a Limit
         class LimitOperand < self
@@ -367,7 +367,7 @@ module Axiom
           RestrictionOperand,
           SetOperand,
           ReverseOperand,
-          OrderOperand,
+          SortedOperand,
           LimitOperand,
           OffsetOperand,
           EmptyOperand,

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

@@ -6,6 +6,7 @@ module Axiom
 
       # Abstract base class representing Restriction optimizations
       class Restriction < Relation::Operation::Unary
+        include AbstractType
 
         # The optimized predicate
         #
@@ -206,9 +207,7 @@ module Axiom
           #   raised when the subclass does not implement the method
           #
           # @api private
-          def relation_method
-            raise NotImplementedError, "#{self.class}#relation_method must be implemented"
-          end
+          abstract_method :relation_method
 
           # Restrict the left operand with the left predicate partition
           #
@@ -325,10 +324,10 @@ module Axiom
 
         end # class SetOperand
 
-        # Optimize when the operand is an Order
-        class OrderOperand < self
-          include Relation::Operation::Unary::OrderOperand
-        end # class OrderOperand
+        # Optimize when the operand is an Sorted
+        class SortedOperand < self
+          include Relation::Operation::Unary::SortedOperand
+        end # class SortedOperand
 
         # Optimize when operand is optimizable
         class UnoptimizedOperand < self
@@ -340,7 +339,7 @@ module Axiom
           #
           # @api private
           def optimizable?
-            super || ! predicate.equal?(operation.predicate)
+            super || !predicate.equal?(operation.predicate)
           end
 
           # Return a Restriction with an optimized operand
@@ -361,7 +360,7 @@ module Axiom
           JoinOperand,
           ProductOperand,
           SetOperand,
-          OrderOperand,
+          SortedOperand,
           EmptyOperand,
           MaterializedOperand,
           UnoptimizedOperand

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

@@ -135,10 +135,10 @@ module Axiom
 
         end # class EmptySummarizePer
 
-        # Optimize when the operand is an Order
-        class OrderOperand < self
-          include Relation::Operation::Unary::OrderOperand
-        end # class OrderOperand
+        # Optimize when the operand is an Sorted
+        class SortedOperand < self
+          include Relation::Operation::Unary::SortedOperand
+        end # class SortedOperand
 
         # Optimize when operand is optimizable
         class UnoptimizedOperand < self
@@ -172,7 +172,7 @@ module Axiom
           #
           # @api private
           def summarize_per_optimizable?
-            ! summarize_per.equal?(operation.summarize_per)
+            !summarize_per.equal?(operation.summarize_per)
           end
 
           # Test if the summarizers are optimizable
@@ -181,7 +181,7 @@ module Axiom
           #
           # @api private
           def summarizers_optimizable?
-            ! summarizers.eql?(operation.summarizers)
+            !summarizers.eql?(operation.summarizers)
           end
 
         end # class UnoptimizedOperand
@@ -189,7 +189,7 @@ module Axiom
         Axiom::Algebra::Summarization.optimizer = chain(
           EmptyOperand,
           EmptySummarizePer,
-          OrderOperand,
+          SortedOperand,
           MaterializedOperand,
           UnoptimizedOperand
         )

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

@@ -56,8 +56,8 @@ module Axiom
           EqualOperands,
           EmptyRight,
           EmptyLeft,
-          OrderLeft,
-          OrderRight,
+          SortedLeft,
+          SortedRight,
           MaterializedOperands,
           UnoptimizedOperands
         )

data/lib/axiom/optimizer/function.rb

@@ -59,9 +59,8 @@ module Axiom
         #
         # @api private
         def self.min(operand)
-          case operand
-          when Attribute::String  then operand.min_length
-          when Attribute::Numeric then operand.range.first
+          if operand.respond_to?(:range)
+            operand.range.first
           else
             operand
           end
@@ -73,9 +72,8 @@ module Axiom
         #
         # @api private
         def self.max(operand)
-          case operand
-          when Attribute::String  then operand.max_length
-          when Attribute::Numeric then operand.range.last
+          if operand.respond_to?(:range)
+            operand.range.last
           else
             operand
           end

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

@@ -105,7 +105,7 @@ module Axiom
           #
           # @api private
           def left_optimizable?
-            ! left.equal?(operation.left)
+            !left.equal?(operation.left)
           end
 
           # Test if the right operand is optimizable
@@ -114,7 +114,7 @@ module Axiom
           #
           # @api private
           def right_optimizable?
-            ! right.equal?(operation.right)
+            !right.equal?(operation.right)
           end
 
         end # module UnoptimizedOperands

data/lib/axiom/optimizer/function/connective/binary.rb

@@ -160,7 +160,7 @@ module Axiom
             #
             # @api private
             def optimize
-              Axiom::Function::Proposition.new(super)
+              Axiom::Function::Proposition.coerce(super)
             end
 
           end # class ConstantOperands

data/lib/axiom/optimizer/function/connective/negation.rb

@@ -42,7 +42,7 @@ module Axiom
             #
             # @api private
             def optimize
-              Axiom::Function::Proposition.new(super)
+              Axiom::Function::Proposition.coerce(super)
             end
 
           end # class ConstantOperand

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

@@ -18,7 +18,7 @@ module Axiom
           #
           # @api private
           def optimize
-            Axiom::Function::Proposition.new(super)
+            Axiom::Function::Proposition.coerce(super)
           end
 
         end # class ConstantOperands

data/lib/axiom/optimizer/function/predicate/comparable.rb

@@ -46,7 +46,7 @@ module Axiom
               elsif util.constant?(left)  then left_invalid_constant?
               elsif util.constant?(right) then right_invalid_constant?
               else
-                ! joinable?
+                !joinable?
               end
             end
 
@@ -67,7 +67,7 @@ module Axiom
             #
             # @api private
             def left_invalid_constant?
-              ! right.valid_value?(left)
+              !right.include?(left)
             end
 
             # Test if the right operand is an invalid constant
@@ -76,7 +76,7 @@ module Axiom
             #
             # @api private
             def right_invalid_constant?
-              ! left.valid_value?(right)
+              !left.include?(right)
             end
 
             # Test if the left and right operand are joinable
@@ -103,7 +103,7 @@ module Axiom
               if    util.constant?(left)  then left_invalid_constant?
               elsif util.constant?(right) then right_invalid_constant?
               else
-                ! comparable?
+                !comparable?
               end
             end
 
@@ -115,7 +115,8 @@ module Axiom
             #
             # @api private
             def left_invalid_constant?
-              ! right.valid_primitive?(left)
+              type = right.type
+              !type.infer(left.class).equal?(type)
             end
 
             # Test if the right operand is an invalid constant
@@ -124,7 +125,8 @@ module Axiom
             #
             # @api private
             def right_invalid_constant?
-              ! left.valid_primitive?(right)
+              type = left.type
+              !type.infer(right.class).equal?(type)
             end
 
             # Test if the left and right operand are comparable

data/lib/axiom/optimizer/function/predicate/enumerable.rb

@@ -72,9 +72,9 @@ module Axiom
           #
           # @api private
           def normalized_right_enumerable
-            enumerable = operation.right.select { |value| left.valid_value?(value) }
+            enumerable = operation.right.select(&left.method(:include?))
             enumerable.uniq!
-            enumerable.sort_by! { |value| Enumerable.sort_by_value(value) }
+            enumerable.sort_by!(&Enumerable.method(:sort_by_value))
           end
 
           # Optimize when the right operand is empty

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

@@ -67,7 +67,7 @@ module Axiom
           #
           # @api private
           def optimizable?
-            ! operand.equal?(operation.operand)
+            !operand.equal?(operation.operand)
           end
 
           # Return a Aggregate with an optimized operand

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

@@ -53,19 +53,19 @@ module Axiom
 
           end # module EmptyRight
 
-          # Optimize when the left operand is an Order
-          class OrderLeft < self
+          # Optimize when the left operand is an Sorted
+          class SortedLeft < self
 
-            # Test if the left operand is an Order
+            # Test if the left operand is an Sorted
             #
             # @return [Boolean]
             #
             # @api private
             def optimizable?
-              left.kind_of?(Axiom::Relation::Operation::Order)
+              left.kind_of?(Axiom::Relation::Operation::Sorted)
             end
 
-            # Drop the Order and wrap the left operand
+            # Drop the Sorted and wrap the left operand
             #
             # @return [Binary]
             #
@@ -74,21 +74,21 @@ module Axiom
               operation.class.new(left.operand, right)
             end
 
-          end # class OrderLeft
+          end # class SortedLeft
 
-          # Optimize when the right operand is an Order
-          class OrderRight < self
+          # Optimize when the right operand is an Sorted
+          class SortedRight < self
 
-            # Test if the right operand is an Order
+            # Test if the right operand is an Sorted
             #
             # @return [Boolean]
             #
             # @api private
             def optimizable?
-              right.kind_of?(Axiom::Relation::Operation::Order)
+              right.kind_of?(Axiom::Relation::Operation::Sorted)
             end
 
-            # Drop the Order and wrap the right operand
+            # Drop the Sorted and wrap the right operand
             #
             # @return [Binary]
             #
@@ -97,7 +97,7 @@ module Axiom
               operation.class.new(left, right.operand)
             end
 
-          end # class OrderRight
+          end # class SortedRight
 
           # Optimize when the operands are Materialized
           class MaterializedOperands < self