veritas-optimizer 0.0.4 → 0.0.5

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

@@ -137,6 +137,152 @@ module Veritas
 
         end # class RestrictionOperand
 
+        # Optimize when the operand is a combine operation
+        class CombinationOperand < self
+
+          # Test if the restriction is commutative
+          #
+          # @return [Boolean]
+          #
+          # @api private
+          def optimizable?
+            restriction_commutative?
+          end
+
+          # Distribute the restriction across the operation and apply to the operands
+          #
+          # @return [Restriction]
+          #
+          # @api private
+          def optimize
+            left_restriction.send(relation_method, right_restriction).restrict { partition.remainder }
+          end
+
+        private
+
+          # Return a predicate partition for the restriction and operand headers
+          #
+          # @return [PredicatePartition]
+          #
+          # @api private
+          def partition
+            operand = self.operand
+            PredicatePartition.new(predicate, operand.left.header, operand.right.header)
+          end
+
+          # Test if the restriction can be distributed over the operation
+          #
+          # If the predicates for the left and right operands would match
+          # everything, there is no point in distributing the restriction
+          # across the operation, since it will not affect the result.
+          #
+          # @return [Boolean]
+          #
+          # @api private
+          def restriction_commutative?
+            !(partition_left_tautology? && partition_right_tautology?)
+          end
+
+          # Test if the predicate for the left operand would match everything
+          #
+          # @return [Boolean]
+          #
+          # @api private
+          def partition_left_tautology?
+            partition.left.equal?(Veritas::Function::Proposition::Tautology.instance)
+          end
+
+          # Test if the predicate for the right operand would match everything
+          #
+          # @return [Boolean]
+          #
+          # @api private
+          def partition_right_tautology?
+            partition.right.equal?(Veritas::Function::Proposition::Tautology.instance)
+          end
+
+          # Abstract method to return the relation method name
+          #
+          # @raise [NotImplementedError]
+          #   raised when the subclass does not implement the method
+          #
+          # @api private
+          def relation_method
+            raise NotImplementedError, "#{self.class}#relation_method must be implemented"
+          end
+
+          # Restrict the left operand with the left predicate partition
+          #
+          # @return [Restriction]
+          #
+          # @api private
+          def left_restriction
+            operand.left.restrict { partition.left }
+          end
+
+          # Restrict the right operand with the right predicate partition
+          #
+          # @return [Restriction]
+          #
+          # @api private
+          def right_restriction
+            operand.right.restrict { partition.right }
+          end
+
+          memoize :partition
+        end
+
+        # Optimize when the operand is a Join
+        class JoinOperand < CombinationOperand
+
+          # Test if the operand is a Join and the restriction is commutative
+          #
+          # @return [Boolean]
+          #
+          # @api private
+          def optimizable?
+            operand.kind_of?(Veritas::Algebra::Join) && super
+          end
+
+        private
+
+          # Return the relation method name for a Join operation
+          #
+          # @return [Symbol]
+          #
+          # @api private
+          def relation_method
+            :join
+          end
+
+        end # class JoinOperand
+
+        # Optimize when the operand is a Product
+        class ProductOperand < CombinationOperand
+
+          # Test if the operand is a Join and the restriction is commutative
+          #
+          # @return [Boolean]
+          #
+          # @api private
+          def optimizable?
+            operand.kind_of?(Veritas::Algebra::Product) && super
+          end
+
+        private
+
+          # Return the relation method name for a Product operation
+          #
+          # @return [Symbol]
+          #
+          # @api private
+
+          def relation_method
+            :product
+          end
+
+        end # class ProductOperand
+
         # Optimize when the operand is a Set
         class SetOperand < self
 
@@ -213,6 +359,8 @@ module Veritas
           Tautology,
           Contradiction,
           RestrictionOperand,
+          JoinOperand,
+          ProductOperand,
           SetOperand,
           OrderOperand,
           EmptyOperand,

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

@@ -58,7 +58,7 @@ module Veritas
           EmptyLeft,
           LeftOrderOperand,
           RightOrderOperand,
-          MaterializedOperand,
+          MaterializedOperands,
           UnoptimizedOperands
         )
 

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

@@ -11,27 +11,27 @@ module Veritas
 
         private
 
-          # Test if the operands are equality predicates for the same attribute
+          # Test if the operands are equality/inclusion predicates for the same attribute
           #
           # @return [Boolean]
           #
           # @api private
           def equality_with_same_attributes?
-            left.kind_of?(Veritas::Function::Predicate::Equality)  &&
-            right.kind_of?(Veritas::Function::Predicate::Equality) &&
-            same_attribute?                                        &&
+            left_equality?  &&
+            right_equality? &&
+            same_attribute? &&
             constant_value?
           end
 
-          # Test if the operands are inequality predicates for the same attribute
+          # Test if the operands are inequality/exclusion predicates for the same attribute
           #
           # @return [Boolean]
           #
           # @api private
           def inequality_with_same_attributes?
-            left.kind_of?(Veritas::Function::Predicate::Inequality)  &&
-            right.kind_of?(Veritas::Function::Predicate::Inequality) &&
-            same_attribute?                                          &&
+            left_inequality?  &&
+            right_inequality? &&
+            same_attribute?   &&
             constant_value?
           end
 
@@ -54,6 +54,50 @@ module Veritas
             util.constant?(left.right) && util.constant?(right.right)
           end
 
+          # Test if the left is an equality or inclusion
+          #
+          # @return [Boolean]
+          #
+          # @api private
+          def left_equality?
+            util = Veritas::Function::Predicate
+            left = self.left
+            left.kind_of?(util::Equality) || left.kind_of?(util::Inclusion)
+          end
+
+          # Test if the right is an equality or inclusion
+          #
+          # @return [Boolean]
+          #
+          # @api private
+          def right_equality?
+            util  = Veritas::Function::Predicate
+            right = self.right
+            right.kind_of?(util::Equality) || right.kind_of?(util::Inclusion)
+          end
+
+          # Test if the left is an inequality or exclusion
+          #
+          # @return [Boolean]
+          #
+          # @api private
+          def left_inequality?
+            util = Veritas::Function::Predicate
+            left = self.left
+            left.kind_of?(util::Inequality) || left.kind_of?(util::Exclusion)
+          end
+
+          # Test if the right is an inequality or exclusion
+          #
+          # @return [Boolean]
+          #
+          # @api private
+          def right_inequality?
+            util  = Veritas::Function::Predicate
+            right = self.right
+            right.kind_of?(util::Inequality) || right.kind_of?(util::Exclusion)
+          end
+
           # Test if the left is a tautology
           #
           # @return [Boolean]
@@ -103,6 +147,15 @@ module Veritas
             left.inverse.eql?(right)
           end
 
+          # Merge the right enumerables from the operands
+          #
+          # @return [Array]
+          #
+          # @api private
+          def merged_right_enumerables
+            [ left.right, right.right ].flatten
+          end
+
           # Optimize when the operands are constants
           class ConstantOperands < self
             include Function::Binary::ConstantOperands

data/lib/veritas/optimizer/function/connective/conjunction.rb

@@ -73,7 +73,7 @@ module Veritas
             # @api private
             def optimize
               left = self.left
-              Veritas::Function::Predicate::Exclusion.new(left.left, [ left.right, right.right ]).optimize
+              Veritas::Function::Predicate::Exclusion.new(left.left, merged_right_enumerables).optimize
             end
 
           end # class OptimizableToExclusion

data/lib/veritas/optimizer/function/connective/disjunction.rb

@@ -73,7 +73,7 @@ module Veritas
             # @api private
             def optimize
               left = self.left
-              Veritas::Function::Predicate::Inclusion.new(left.left, [ left.right, right.right ]).optimize
+              Veritas::Function::Predicate::Inclusion.new(left.left, merged_right_enumerables).optimize
             end
 
           end # class OptimizableToInclusion

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

@@ -45,7 +45,7 @@ module Veritas
               if    util.constant?(left)  then left_invalid_constant?
               elsif util.constant?(right) then right_invalid_constant?
               else
-                not_joinable?
+                !joinable?
               end
             end
 
@@ -69,14 +69,14 @@ module Veritas
               !left.valid_value?(right)
             end
 
-            # Test if the left and right operand are not joinable
+            # Test if the left and right operand are joinable
             #
             # @return [Boolean]
             #
             # @api private
-            def not_joinable?
+            def joinable?
               left = self.left
-              !(left.respond_to?(:joinable?) && left.joinable?(right))
+              left.respond_to?(:joinable?) && left.joinable?(right)
             end
 
           end # module NeverEquivalent

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

@@ -100,7 +100,7 @@ module Veritas
           end # class RightOrderOperand
 
           # Optimize when the operands are Materialized
-          class MaterializedOperand < self
+          class MaterializedOperands < self
 
             # Test if the operands are materialized
             #

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

@@ -0,0 +1,182 @@
+# encoding: utf-8
+
+module Veritas
+  class Optimizer
+
+    # Partition a predicate to distribute it over binary operations
+    class PredicatePartition
+      include Immutable
+
+      TAUTOLOGY = Veritas::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 Veritas::Function::Binary   then partition_binary!(operand)
+          when Veritas::Function::Unary    then partition_unary!(operand)
+          when Veritas::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 ]
+
+        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 Veritas::Function::Connective::Disjunction then each_operand(predicate.inverse.optimize, &block)
+        when Veritas::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 Veritas

data/lib/veritas/optimizer/version.rb

@@ -2,6 +2,6 @@
 
 module Veritas
   class Optimizer
-    VERSION = '0.0.4'
+    VERSION = '0.0.5'
   end # class Optimizer
 end # module Veritas

data/lib/veritas/optimizer.rb

@@ -95,6 +95,8 @@ end # module Veritas
 
 require 'veritas/optimizer/version'
 
+require 'veritas/optimizer/support/predicate_partition'
+
 require 'veritas/optimizer/optimizable'
 
 require 'veritas/optimizer/function'

data/spec/integration/veritas/algebra/rename/optimize_spec.rb

@@ -183,7 +183,7 @@ describe Algebra::Rename, '#optimize' do
   end
 
   context 'containing a restriction' do
-    let(:operand) { relation.restrict { |r| r[:id].eq(1) } }
+    let(:operand) { relation.restrict { |r| r.id.eq(1) } }
 
     it { should be_kind_of(Algebra::Restriction) }
 
@@ -204,11 +204,11 @@ describe Algebra::Rename, '#optimize' do
   end
 
   context 'containing a restriction, containing a object that cancels out' do
-    let(:operand) { relation.rename(:id => :other_id).restrict { |r| r[:other_id].eq(1) } }
-    let(:aliases) { { :other_id => :id }                                                  }
+    let(:operand) { relation.rename(:id => :other_id).restrict { |r| r.other_id.eq(1) } }
+    let(:aliases) { { :other_id => :id }                                                }
 
     it 'pushes the object before the restriction, and then cancel it out' do
-      should eql(relation.restrict { |r| r[:id].eq(1) })
+      should eql(relation.restrict { |r| r.id.eq(1) })
     end
 
     it 'returns an equivalent relation to the unoptimized operation' do
@@ -267,11 +267,11 @@ describe Algebra::Rename, '#optimize' do
   end
 
   context 'containing a reverse operation' do
-    let(:limit)   { relation.order.take(2) }
-    let(:operand) { limit.reverse          }
+    let(:limit)   { relation.sort_by { |r| [ r.id, r.name ] }.take(2) }
+    let(:operand) { limit.reverse                                     }
 
     it 'pushes the object under the order, limit and reverse' do
-      should eql(relation.rename(aliases).order.take(2).reverse)
+      should eql(relation.rename(aliases).sort_by { |r| [ r.other_id, r.name ] }.take(2).reverse)
     end
 
     it 'returns an equivalent relation to the unoptimized operation' do
@@ -287,12 +287,12 @@ describe Algebra::Rename, '#optimize' do
   end
 
   context 'containing a reverse operation, containing a object that cancels out' do
-    let(:limit)   { relation.order.take(2)                 }
-    let(:operand) { limit.rename(:id => :other_id).reverse }
-    let(:aliases) { { :other_id => :id }                   }
+    let(:limit)   { relation.sort_by { |r| [ r.id, r.name ] }.take(2) }
+    let(:operand) { limit.rename(:id => :other_id).reverse            }
+    let(:aliases) { { :other_id => :id }                              }
 
     it 'pushes the object under the order, limit and reverse, and then cancel it out' do
-      should eql(relation.order.take(2).reverse)
+      should eql(relation.sort_by { |r| [ r.id, r.name ] }.take(2).reverse)
     end
 
     it 'returns an equivalent relation to the unoptimized operation' do
@@ -308,10 +308,10 @@ describe Algebra::Rename, '#optimize' do
   end
 
   context 'containing an order operation' do
-    let(:operand) { relation.order }
+    let(:operand) { relation.sort_by { |r| [ r.id, r.name ] } }
 
     it 'pushes the object under the order' do
-      should eql(relation.rename(aliases).order)
+      should eql(relation.rename(aliases).sort_by { |r| [ r.other_id, r.name ] })
     end
 
     it 'returns an equivalent relation to the unoptimized operation' do
@@ -327,11 +327,11 @@ describe Algebra::Rename, '#optimize' do
   end
 
   context 'containing an order operation, containing a object that cancels out' do
-    let(:operand) { relation.rename(:id => :other_id).order }
-    let(:aliases) { { :other_id => :id }                    }
+    let(:operand) { relation.rename(:id => :other_id).sort_by { |r| [ r.other_id, r.name ] } }
+    let(:aliases) { { :other_id => :id }                                                     }
 
     it 'pushes the object under the order, and then cancel it out' do
-      should eql(relation.order)
+      should eql(relation.sort_by { |r| [ r.id, r.name ] })
     end
 
     it 'returns an equivalent relation to the unoptimized operation' do
@@ -347,11 +347,11 @@ describe Algebra::Rename, '#optimize' do
   end
 
   context 'containing a limit operation' do
-    let(:order)   { relation.order }
-    let(:operand) { order.take(2)  }
+    let(:order)   { relation.sort_by { |r| [ r.id, r.name ] } }
+    let(:operand) { order.take(2)                             }
 
     it 'pushes the object under the limit and order' do
-      should eql(relation.rename(aliases).order.take(2))
+      should eql(relation.rename(aliases).sort_by { |r| [ r.other_id, r.name ] }.take(2))
     end
 
     it 'returns an equivalent relation to the unoptimized operation' do
@@ -367,12 +367,12 @@ describe Algebra::Rename, '#optimize' do
   end
 
   context 'containing a limit operation, containing a object that cancels out' do
-    let(:order)   { relation.order                         }
-    let(:operand) { order.rename(:id => :other_id).take(2) }
-    let(:aliases) { { :other_id => :id }                   }
+    let(:order)   { relation.sort_by { |r| [ r.id, r.name ] } }
+    let(:operand) { order.rename(:id => :other_id).take(2)    }
+    let(:aliases) { { :other_id => :id }                      }
 
     it 'pushes the object under the limit and order, and then cancel it out' do
-      should eql(relation.order.take(2))
+      should eql(relation.sort_by { |r| [ r.id, r.name ] }.take(2))
     end
 
     it 'returns an equivalent relation to the unoptimized operation' do
@@ -388,11 +388,11 @@ describe Algebra::Rename, '#optimize' do
   end
 
   context 'containing an offset operation' do
-    let(:order)   { relation.order }
-    let(:operand) { order.drop(1)  }
+    let(:order)   { relation.sort_by { |r| [ r.id, r.name ] } }
+    let(:operand) { order.drop(1)                             }
 
     it 'pushes the object under the offset and order' do
-      should eql(relation.rename(aliases).order.drop(1))
+      should eql(relation.rename(aliases).sort_by { |r| [ r.other_id, r.name ] }.drop(1))
     end
 
     it 'returns an equivalent relation to the unoptimized operation' do
@@ -408,12 +408,12 @@ describe Algebra::Rename, '#optimize' do
   end
 
   context 'containing an offset operation, containing a object that cancels out' do
-    let(:order)   { relation.order                         }
-    let(:operand) { order.rename(:id => :other_id).drop(1) }
-    let(:aliases) { { :other_id => :id }                   }
+    let(:order)   { relation.sort_by { |r| [ r.id, r.name ] } }
+    let(:operand) { order.rename(:id => :other_id).drop(1)    }
+    let(:aliases) { { :other_id => :id }                      }
 
     it 'pushes the object under the offset and order, and then cancel it out' do
-      should eql(relation.order.drop(1))
+      should eql(relation.sort_by { |r| [ r.id, r.name ] }.drop(1))
     end
 
     it 'returns an equivalent relation to the unoptimized operation' do