veritas-optimizer 0.0.4 → 0.0.5

data/spec/unit/veritas/optimizer/algebra/restriction/product_operand/optimizable_spec.rb

@@ -0,0 +1,44 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Optimizer::Algebra::Restriction::ProductOperand, '#optimizable?' do
+  subject { object.optimizable? }
+
+  let(:left)     { Relation.new([ [ :user_id,     Integer ], [ :user_name,     String ] ], [ [ 1, 'Dan Kubb' ] ].each) }
+  let(:right)    { Relation.new([ [ :employee_id, Integer ], [ :employee_name, String ] ], [ [ 2, 'Dan Kubb' ] ].each) }
+  let(:relation) { operand.restrict { predicate }                                                                      }
+  let(:object)   { described_class.new(relation)                                                                       }
+
+  before do
+    object.operation.should be_kind_of(Algebra::Restriction)
+  end
+
+  context 'when the operand is a product operation and the predicate distributes to the left' do
+    let(:operand)   { left.product(right)             }
+    let(:predicate) { left[:user_name].eq('Dan Kubb') }
+
+    it { should be(true) }
+  end
+
+  context 'when the operand is a product operation and the predicate distributes to the right' do
+    let(:operand)   { left.product(right)                  }
+    let(:predicate) { right[:employee_name].eq('Dan Kubb') }
+
+    it { should be(true) }
+  end
+
+  context 'when the operand is a product operation and the predicate does not distribute to the left or right' do
+    let(:operand)   { left.product(right)                        }
+    let(:predicate) { left[:user_name].eq(right[:employee_name]) }
+
+    it { should be(false) }
+  end
+
+  context 'when the operand is not a product operation' do
+    let(:operand)   { left }
+    let(:predicate) { true }
+
+    it { should be(false) }
+  end
+end

data/spec/unit/veritas/optimizer/algebra/restriction/product_operand/optimize_spec.rb

@@ -0,0 +1,48 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Optimizer::Algebra::Restriction::ProductOperand, '#optimize' do
+  subject { object.optimize }
+
+  let(:left)                { Relation.new([ [ :user_id,     Integer ], [ :user_name,     String ] ], [ [ 1, 'Dan Kubb' ] ].each) }
+  let(:right)               { Relation.new([ [ :employee_id, Integer ], [ :employee_name, String ] ], [ [ 2, 'Dan Kubb' ] ].each) }
+  let(:operand)             { left.product(right)                                                                                 }
+  let(:left_predicate)      { left[:user_name].eq('Dan Kubb')                                                                     }
+  let(:right_predicate)     { right[:employee_name].eq('Dan Kubb')                                                                }
+  let(:remainder_predicate) { left[:user_name].eq(right[:employee_name])                                                          }
+  let(:predicate)           { left_predicate.and(right_predicate).and(remainder_predicate)                                        }
+  let(:relation)            { operand.restrict { predicate }                                                                      }
+  let(:object)              { described_class.new(relation)                                                                       }
+
+  before do
+    object.should be_optimizable
+  end
+
+  it { should be_kind_of(Algebra::Restriction) }
+
+  its(:operand) { should be_kind_of(Algebra::Product) }
+
+  it 'wraps the left operand of the product in a restriction' do
+    left_operand = subject.operand.left
+    left_operand.operand.should equal(left)
+    left_operand.should be_kind_of(Algebra::Restriction)
+  end
+
+  it 'wraps the right operand of the product in a restriction' do
+    right_operand = subject.operand.right
+    right_operand.operand.should equal(right)
+    right_operand.should be_kind_of(Algebra::Restriction)
+  end
+
+  it 'distributes the applicable part of the predicate to the left' do
+    subject.operand.left.predicate.should equal(left_predicate)
+  end
+
+  it 'distributes the applicable part of the predicate to the right' do
+    subject.operand.right.predicate.should equal(right_predicate)
+  end
+
+  # keeps the remainder that applies to the left and right
+  its(:predicate) { should equal(remainder_predicate) }
+end

data/spec/unit/veritas/optimizer/algebra/restriction/unoptimized_operand/optimize_spec.rb

@@ -5,10 +5,10 @@ require 'spec_helper'
 describe Optimizer::Algebra::Restriction::UnoptimizedOperand, '#optimize' do
   subject { object.optimize }
 
-  let(:header)   { Relation::Header.new([ [ :id, Integer ] ])    }
-  let(:base)     { Relation.new(header, [ [ 1 ] ].each)          }
-  let(:relation) { base.rename({}).restrict { |r| r[:id].eq(1) } }
-  let(:object)   { described_class.new(relation)                 }
+  let(:header)   { Relation::Header.new([ [ :id, Integer ] ])  }
+  let(:base)     { Relation.new(header, [ [ 1 ] ].each)        }
+  let(:relation) { base.rename({}).restrict { |r| r.id.eq(1) } }
+  let(:object)   { described_class.new(relation)               }
 
   before do
     object.should be_optimizable

data/spec/unit/veritas/optimizer/algebra/summarization/empty_operand/optimize_spec.rb

@@ -13,7 +13,7 @@ describe Optimizer::Algebra::Summarization::EmptyOperand, '#optimize' do
   let(:object)        { described_class.new(relation)              }
 
   context 'when the function has a default' do
-    let(:relation) { operand.summarize(summarize_per) { |r| r.add(attribute, r[:id].count) } }
+    let(:relation) { operand.summarize(summarize_per) { |r| r.add(attribute, r.id.count) } }
 
     before do
       object.should be_optimizable

data/spec/unit/veritas/optimizer/algebra/summarization/empty_summarize_per/optimize_spec.rb

@@ -5,13 +5,13 @@ require 'spec_helper'
 describe Optimizer::Algebra::Summarization::EmptySummarizePer, '#optimize' do
   subject { object.optimize }
 
-  let(:header)        { Relation::Header.new([ [ :id, Integer ], [ :name, String ] ])             }
-  let(:base)          { Relation.new(header, [ [ 1, 'Dan Kubb' ] ].each)                          }
-  let(:attribute)     { Attribute::Object.new(:test)                                              }
-  let(:operand)       { base                                                                      }
-  let(:summarize_per) { base.project([ :id ]).restrict { false }                                  }
-  let(:relation)      { operand.summarize(summarize_per) { |r| r.add(attribute, r[:name].count) } }
-  let(:object)        { described_class.new(relation)                                             }
+  let(:header)        { Relation::Header.new([ [ :id, Integer ], [ :name, String ] ])           }
+  let(:base)          { Relation.new(header, [ [ 1, 'Dan Kubb' ] ].each)                        }
+  let(:attribute)     { Attribute::Object.new(:test)                                            }
+  let(:operand)       { base                                                                    }
+  let(:summarize_per) { base.project([ :id ]).restrict { false }                                }
+  let(:relation)      { operand.summarize(summarize_per) { |r| r.add(attribute, r.name.count) } }
+  let(:object)        { described_class.new(relation)                                           }
 
   before do
     object.should be_optimizable

data/spec/unit/veritas/optimizer/algebra/summarization/order_operand/optimizable_spec.rb

@@ -10,7 +10,7 @@ describe Optimizer::Algebra::Summarization::OrderOperand, '#optimizable?' do
   let(:object)   { described_class.new(relation)               }
 
   context 'when operand is an order' do
-    let(:operand) { base.order }
+    let(:operand) { base.sort_by { |r| r.id } }
 
     it { should be(true) }
   end

data/spec/unit/veritas/optimizer/algebra/summarization/order_operand/optimize_spec.rb

@@ -6,7 +6,7 @@ describe Optimizer::Algebra::Summarization::OrderOperand, '#optimize' do
   subject { object.optimize }
 
   let(:base)     { Relation.new([ [ :id, Integer ] ], [].each) }
-  let(:operand)  { base.order                                  }
+  let(:operand)  { base.sort_by { |r| r.id }                   }
   let(:relation) { operand.summarize([]) {}                    }
   let(:object)   { described_class.new(relation)               }
 

data/spec/unit/veritas/optimizer/function/connective/conjunction/optimizable_to_exclusion/optimizable_spec.rb

@@ -14,16 +14,48 @@ describe Optimizer::Function::Connective::Conjunction::OptimizableToExclusion, '
   end
 
   context 'when the operands are optimizable' do
-    let(:left)  { attribute.ne(2) }
-    let(:right) { attribute.ne(1) }
+    context 'when the left and right are equality predicates' do
+      let(:left)  { attribute.ne(2) }
+      let(:right) { attribute.ne(1) }
 
-    it { should be(true) }
+      it { should be(true) }
+    end
+
+    context 'when the left is an equality predicate and the right is an inclusion predicate' do
+      let(:left)  { attribute.ne(2)             }
+      let(:right) { attribute.exclude([ 1, 3 ]) }
+
+      it { should be(true) }
+    end
+
+    context 'when the left is an inclusion predicate and the right is an equality predicate' do
+      let(:left)  { attribute.exclude([ 2, 3 ]) }
+      let(:right) { attribute.ne(1)             }
+
+      it { should be(true) }
+    end
+
+    context 'when the left and right are inclusion predicatess' do
+      let(:left)  { attribute.exclude([ 2, 3 ]) }
+      let(:right) { attribute.exclude([ 1, 3 ]) }
+
+      it { should be(true) }
+    end
   end
 
   context 'when the operands are not optimizable' do
-    let(:left)  { attribute.ne(1) }
-    let(:right) { attribute.eq(2) }
+    context 'when the left is an inequality predicate and the right is an equality predicate' do
+      let(:left)  { attribute.ne(1) }
+      let(:right) { attribute.eq(2) }
+
+      it { should be(false) }
+    end
+
+    context 'when the left is an exclusion predicate and the right is an equality predicate' do
+      let(:left)  { attribute.exclude([ 1, 3 ]) }
+      let(:right) { attribute.eq(2)             }
 
-    it { should be(false) }
+      it { should be(false) }
+    end
   end
 end

data/spec/unit/veritas/optimizer/function/connective/conjunction/optimizable_to_exclusion/optimize_spec.rb

@@ -14,15 +14,53 @@ describe Optimizer::Function::Connective::Conjunction::OptimizableToExclusion, '
   end
 
   context 'when the right operands are optimizable' do
-    let(:left)  { attribute.ne(2) }
-    let(:right) { attribute.ne(1) }
+    context 'when the left and right are equality predicates' do
+      let(:left)  { attribute.ne(2) }
+      let(:right) { attribute.ne(1) }
 
-    it { should be_kind_of(Function::Predicate::Exclusion) }
+      it { should be_kind_of(Function::Predicate::Exclusion) }
 
-    its(:left) { should equal(attribute) }
+      its(:left) { should equal(attribute) }
 
-    # enumerable order is normalized
-    its(:right) { should == [ 1, 2 ] }
+      # enumerable order is normalized
+      its(:right) { should == [ 1, 2 ] }
+    end
+
+    context 'when the left is an equality predicate and the right is an inclusion predicate' do
+      let(:left)  { attribute.ne(2)          }
+      let(:right) { attribute.exclude([ 1 ]) }
+
+      it { should be_kind_of(Function::Predicate::Exclusion) }
+
+      its(:left) { should equal(attribute) }
+
+      # enumerable order is normalized
+      its(:right) { should == [ 1, 2 ] }
+    end
+
+    context 'when the left is an inclusion predicate and the right is an equality predicate' do
+      let(:left)  { attribute.exclude([ 2 ]) }
+      let(:right) { attribute.ne(1)          }
+
+      it { should be_kind_of(Function::Predicate::Exclusion) }
+
+      its(:left) { should equal(attribute) }
+
+      # enumerable order is normalized
+      its(:right) { should == [ 1, 2 ] }
+    end
+
+    context 'when the left and right are inclusion predicatess' do
+      let(:left)  { attribute.exclude([ 2 ]) }
+      let(:right) { attribute.exclude([ 1 ]) }
+
+      it { should be_kind_of(Function::Predicate::Exclusion) }
+
+      its(:left) { should equal(attribute) }
+
+      # enumerable order is normalized
+      its(:right) { should == [ 1, 2 ] }
+    end
   end
 
   context 'when the right operands are not optimizable' do

data/spec/unit/veritas/optimizer/function/connective/disjunction/optimizable_to_inclusion/optimizable_spec.rb

@@ -14,16 +14,48 @@ describe Optimizer::Function::Connective::Disjunction::OptimizableToInclusion, '
   end
 
   context 'when the operands are optimizable' do
-    let(:left)  { attribute.eq(2) }
-    let(:right) { attribute.eq(1) }
+    context 'when the left and right are equality predicates' do
+      let(:left)  { attribute.eq(2) }
+      let(:right) { attribute.eq(1) }
 
-    it { should be(true) }
+      it { should be(true) }
+    end
+
+    context 'when the left is an equality predicate and the right is an inclusion predicate' do
+      let(:left)  { attribute.eq(2)             }
+      let(:right) { attribute.include([ 1, 3 ]) }
+
+      it { should be(true) }
+    end
+
+    context 'when the left is an inclusion predicate and the right is an equality predicate' do
+      let(:left)  { attribute.include([ 2, 3 ]) }
+      let(:right) { attribute.eq(1)             }
+
+      it { should be(true) }
+    end
+
+    context 'when the left and right are inclusion predicatess' do
+      let(:left)  { attribute.include([ 2, 3 ]) }
+      let(:right) { attribute.include([ 1, 3 ]) }
+
+      it { should be(true) }
+    end
   end
 
   context 'when the operands are not optimizable' do
-    let(:left)  { attribute.ne(1) }
-    let(:right) { attribute.eq(2) }
+    context 'when the left is an inequality predicate and the right is an equality predicate' do
+      let(:left)  { attribute.ne(1) }
+      let(:right) { attribute.eq(2) }
+
+      it { should be(false) }
+    end
+
+    context 'when the left is an exclusion predicate and the right is an equality predicate' do
+      let(:left)  { attribute.exclude([ 1, 3 ]) }
+      let(:right) { attribute.eq(2)             }
 
-    it { should be(false) }
+      it { should be(false) }
+    end
   end
 end

data/spec/unit/veritas/optimizer/function/connective/disjunction/optimizable_to_inclusion/optimize_spec.rb

@@ -14,15 +14,53 @@ describe Optimizer::Function::Connective::Disjunction::OptimizableToInclusion, '
   end
 
   context 'when the right operands are optimizable' do
-    let(:left)  { attribute.eq(2) }
-    let(:right) { attribute.eq(1) }
+    context 'when the left and right are equality predicates' do
+      let(:left)  { attribute.eq(2) }
+      let(:right) { attribute.eq(1) }
 
-    it { should be_kind_of(Function::Predicate::Inclusion) }
+      it { should be_kind_of(Function::Predicate::Inclusion) }
 
-    its(:left) { should equal(attribute) }
+      its(:left) { should equal(attribute) }
 
-    # enumerable order is normalized
-    its(:right) { should == [ 1, 2 ] }
+      # enumerable order is normalized
+      its(:right) { should == [ 1, 2 ] }
+    end
+
+    context 'when the left is an equality predicate and the right is an inclusion predicate' do
+      let(:left)  { attribute.eq(2)          }
+      let(:right) { attribute.include([ 1 ]) }
+
+      it { should be_kind_of(Function::Predicate::Inclusion) }
+
+      its(:left) { should equal(attribute) }
+
+      # enumerable order is normalized
+      its(:right) { should == [ 1, 2 ] }
+    end
+
+    context 'when the left is an inclusion predicate and the right is an equality predicate' do
+      let(:left)  { attribute.include([ 2 ]) }
+      let(:right) { attribute.eq(1)          }
+
+      it { should be_kind_of(Function::Predicate::Inclusion) }
+
+      its(:left) { should equal(attribute) }
+
+      # enumerable order is normalized
+      its(:right) { should == [ 1, 2 ] }
+    end
+
+    context 'when the left and right are inclusion predicatess' do
+      let(:left)  { attribute.include([ 2 ]) }
+      let(:right) { attribute.include([ 1 ]) }
+
+      it { should be_kind_of(Function::Predicate::Inclusion) }
+
+      its(:left) { should equal(attribute) }
+
+      # enumerable order is normalized
+      its(:right) { should == [ 1, 2 ] }
+    end
   end
 
   context 'when the right operands are not optimizable' do

data/spec/unit/veritas/optimizer/predicate_partition/left_spec.rb

@@ -0,0 +1,149 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Optimizer::PredicatePartition, '#left' do
+  subject { object.left }
+
+  let(:left_header)  { Relation::Header.new([ [ :id, Integer ], [ :user_name,     String ], Attribute::Boolean.new(:active_user),     Attribute::Boolean.new(:active) ]) }
+  let(:right_header) { Relation::Header.new([ [ :id, Integer ], [ :employee_name, String ], Attribute::Boolean.new(:active_employee), Attribute::Boolean.new(:active) ]) }
+  let(:object)       { described_class.new(predicate, left_header, right_header)                                                                                         }
+
+  context 'when the predicate is a tautology' do
+    let(:predicate) { Function::Proposition::Tautology.instance }
+
+    it 'partitions the predicate to the left' do
+      should equal(Function::Proposition::Tautology.instance)
+    end
+  end
+
+  context 'when the predicate is a contradiction' do
+    let(:predicate) { Function::Proposition::Contradiction.instance }
+
+    it 'partitions the predicate to the left' do
+      should equal(Function::Proposition::Contradiction.instance)
+    end
+  end
+
+  context 'when the predicate is an attribute' do
+    context 'with an attribute from the left header, but not the right header' do
+      let(:predicate) { left_header[:active_user] }
+
+      it 'partitions the predicate to the left' do
+        should equal(predicate)
+      end
+    end
+
+    context 'with an attribute from the right header, but not the left header' do
+      let(:predicate) { right_header[:active_employee] }
+
+      it 'does not partition the predicate to the left' do
+        should equal(Function::Proposition::Tautology.instance)
+      end
+    end
+
+    context 'with an attribute from the left and right header' do
+      let(:predicate) { left_header[:active] }
+
+      it 'partitions the predicate to the left' do
+        should equal(predicate)
+      end
+    end
+  end
+
+  context 'when the predicate is a binary predicate' do
+    context 'with an attribute from the left header, but not the right header' do
+      let(:predicate) { left_header[:user_name].eq('Dan Kubb') }
+
+      it 'partitions the predicate to the left' do
+        should equal(predicate)
+      end
+    end
+
+    context 'with an attribute from the right header, but not the left header' do
+      let(:predicate) { right_header[:employee_name].eq('Dan Kubb') }
+
+      it 'does not partition the predicate to the left' do
+        should equal(Function::Proposition::Tautology.instance)
+      end
+    end
+
+    context 'with an attribute from the left and right header' do
+      let(:predicate) { left_header[:id].eq(1) }
+
+      it 'partitions the predicate to the left' do
+        should equal(predicate)
+      end
+    end
+
+    context 'with an attribute from the left header, and an attribute from the left and right header' do
+      let(:predicate) { left_header[:active_user].eq(left_header[:active]) }
+
+      it 'partitions the predicate to the left' do
+        should equal(predicate)
+      end
+    end
+
+    context 'with an attribute from the right header, and an attribute from the left and right header' do
+      let(:predicate) { right_header[:active_employee].eq(left_header[:active]) }
+
+      it 'partitions the predicate to the left' do
+        should equal(predicate)
+      end
+    end
+
+    context 'with disjoint attributes from the left and right header' do
+      let(:predicate) { left_header[:user_name].eq(right_header[:employee_name]) }
+
+      it 'does not partition the predicate to the left' do
+        should equal(Function::Proposition::Tautology.instance)
+      end
+    end
+  end
+
+  context 'when the predicate is a negation' do
+    context 'with an attribute from the left header, but not the right header' do
+      let(:predicate) { Function::Connective::Negation.new(left_header[:active_user]) }
+
+      it 'partitions the predicate to the left' do
+        should equal(predicate)
+      end
+    end
+
+    context 'with an attribute from the right header, but not the left header' do
+      let(:predicate) { Function::Connective::Negation.new(right_header[:active_employee]) }
+
+      it 'does not partition the predicate to the left' do
+        should equal(Function::Proposition::Tautology.instance)
+      end
+    end
+
+    context 'with an attribute from the left and right header' do
+      let(:predicate) { Function::Connective::Negation.new(left_header[:active]) }
+
+      it 'partitions the predicate to the left' do
+        should equal(predicate)
+      end
+    end
+  end
+
+  context 'when the predicate is a conjunction' do
+    let(:left_predicate)  { left_header[:user_name].eq('Dan Kubb')      }
+    let(:right_predicate) { right_header[:employee_name].eq('Dan Kubb') }
+    let(:predicate)       { left_predicate.and(right_predicate)         }
+
+    it 'partitions the predicate to the left that reference the left header' do
+      should equal(left_predicate)
+    end
+  end
+
+  context 'when the predicate is a disjunction' do
+    let(:left_predicate)  { left_header[:user_name].eq('Dan Kubb')      }
+    let(:right_predicate) { right_header[:employee_name].eq('Dan Kubb') }
+    let(:predicate)       { left_predicate.or(right_predicate)          }
+
+    it 'partitions the predicate to the left that reference the left header, transforming it with De Morgan\'s Law' do
+      should eql(left_header[:user_name].ne('Dan Kubb'))
+    end
+  end
+end