axiom-optimizer 0.1.0

data/spec/integration/axiom/algebra/restriction/optimize_spec.rb

@@ -0,0 +1,218 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Algebra::Restriction, '#optimize' do
+  subject { object.optimize }
+
+  let(:body)     { LazyEnumerable.new([ [ 1 ] ])            }
+  let(:relation) { Relation.new([ [ :id, Integer ] ], body) }
+  let(:operand)  { relation                                 }
+  let(:object)   { described_class.new(operand, predicate)  }
+
+  context 'with a tautology' do
+    let(:predicate) { Function::Proposition::Tautology.instance }
+
+    it { should equal(relation) }
+
+    it 'does not execute body#each' do
+      body.should_not_receive(:each)
+      subject
+    end
+
+    it_should_behave_like 'an optimize method'
+  end
+
+  context 'with a contradiction' do
+    let(:predicate) { Function::Proposition::Contradiction.instance }
+
+    it { should eql(Relation::Empty.new(relation.header)) }
+
+    it 'returns an equivalent relation to the unoptimized operation' do
+      should == object
+    end
+
+    it 'does not execute body#each' do
+      body.should_not_receive(:each)
+      subject
+    end
+
+    it_should_behave_like 'an optimize method'
+  end
+
+  context 'with a predicate' do
+    let(:predicate) { relation[:id].eq(1) }
+
+    it { should equal(object) }
+
+    it 'does not execute body#each' do
+      body.should_not_receive(:each)
+      subject
+    end
+
+    it_should_behave_like 'an optimize method'
+  end
+
+  context 'with an optimizable predicate' do
+    let(:predicate) { relation[:id].eq(1).and(Function::Proposition::Tautology.instance) }
+
+    it { should_not equal(object) }
+
+    it { should be_kind_of(described_class) }
+
+    its(:predicate) { should eql(relation[:id].eq(1)) }
+
+    its(:operand) { should equal(relation) }
+
+    it 'returns an equivalent relation to the unoptimized operation' do
+      should == object
+    end
+
+    it 'does not execute body#each' do
+      body.should_not_receive(:each)
+      subject
+    end
+
+    it_should_behave_like 'an optimize method'
+  end
+
+  context 'with an optimizable operand' do
+    let(:operand)    { relation.project(relation.header) }
+    let(:predicate)  { relation[:id].eq(1)               }
+
+    it { should_not equal(object) }
+
+    it { should be_kind_of(described_class) }
+
+    its(:predicate) { should equal(predicate) }
+
+    its(:operand) { should equal(relation) }
+
+    it 'returns an equivalent relation to the unoptimized operation' do
+      should == object
+    end
+
+    it 'does not execute body#each' do
+      body.should_not_receive(:each)
+      subject
+    end
+
+    it_should_behave_like 'an optimize method'
+  end
+
+  context 'with an empty relation' do
+    let(:operand)   { Relation::Empty.new([ [ :id, Integer ] ]) }
+    let(:predicate) { operand[:id].gte(1)                       }
+
+    it { should equal(operand) }
+
+    it 'returns an equivalent relation to the unoptimized operation' do
+      should == object
+    end
+
+    it 'does not execute body#each' do
+      body.should_not_receive(:each)
+      subject
+    end
+
+    it_should_behave_like 'an optimize method'
+  end
+
+  context 'with an empty relation when optimized' do
+    let(:operand)   { described_class.new(relation, Function::Proposition::Contradiction.instance) }
+    let(:predicate) { operand[:id].gte(1)                                                          }
+
+    it { should eql(Relation::Empty.new(relation.header)) }
+
+    it 'returns an equivalent relation to the unoptimized operation' do
+      should == object
+    end
+
+    it 'does not execute body#each' do
+      body.should_not_receive(:each)
+      subject
+    end
+
+    it_should_behave_like 'an optimize method'
+  end
+
+  context 'with a restriction' do
+    let(:other_predicate) { relation[:id].lt(2)                            }
+    let(:operand)         { described_class.new(relation, other_predicate) }
+    let(:predicate)       { operand[:id].gte(1)                            }
+
+    it { should_not equal(object) }
+
+    it { should be_kind_of(described_class) }
+
+    its(:predicate) { should eql(other_predicate & predicate) }
+
+    its(:operand) { should equal(relation) }
+
+    it 'returns an equivalent relation to the unoptimized operation' do
+      should == object
+    end
+
+    it 'does not execute body#each' do
+      body.should_not_receive(:each)
+      subject
+    end
+
+    it_should_behave_like 'an optimize method'
+  end
+
+  context 'with a set operation' do
+    let(:left)      { Relation.new([ [ :id, Integer ] ], LazyEnumerable.new([ [ 1 ] ])) }
+    let(:right)     { Relation.new([ [ :id, Integer ] ], LazyEnumerable.new([ [ 2 ] ])) }
+    let(:operand)   { left.union(right)                                                 }
+    let(:predicate) { operand[:id].gte(1)                                               }
+
+    it 'pushes the object to each relation' do
+      should eql(left.restrict { |r| r.id.gte(1) }.union(right.restrict { |r| r.id.gte(1) }))
+    end
+
+    it 'returns an equivalent relation to the unoptimized operation' do
+      should == object
+    end
+
+    it 'does not execute body#each' do
+      body.should_not_receive(:each)
+      subject
+    end
+
+    it_should_behave_like 'an optimize method'
+  end
+
+  context 'with an order operation' do
+    let(:operand)   { relation.sort_by { |r| r.id } }
+    let(:predicate) { operand[:id].gte(1)           }
+
+    it 'cancels out the order' do
+      should eql(relation.restrict { predicate })
+    end
+
+    it 'returns an equivalent relation to the unoptimized operation' do
+      should == object
+    end
+
+    it 'does not execute body#each' do
+      body.should_not_receive(:each)
+      subject
+    end
+
+    it_should_behave_like 'an optimize method'
+  end
+
+  context 'containing a materialized relation' do
+    let(:operand)   { Relation.new([ [ :id, Integer ] ], [ [ 1 ], [ 2 ] ]) }
+    let(:predicate) { operand[:id].eq(1)                                   }
+
+    it { should eql(Relation::Materialized.new([ [ :id, Integer ] ], [ [ 1 ] ])) }
+
+    it 'returns an equivalent relation to the unoptimized operation' do
+      should == object
+    end
+
+    it_should_behave_like 'an optimize method'
+  end
+end

data/spec/integration/axiom/algebra/summarization/optimize_spec.rb

@@ -0,0 +1,49 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Algebra::Summarization, '#optimize' do
+  subject { object.optimize }
+
+  let(:header)        { [ [ :id, Integer ], [ :name, String ], [ :age, Integer ] ]           }
+  let(:body)          { LazyEnumerable.new([ [ 1, 'Dan Kubb', 35 ], [ 2, 'Jane Doe', 24 ] ]) }
+  let(:relation)      { Relation.new(header, body)                                           }
+  let(:operand)       { relation                                                             }
+  let(:summarize_per) { relation.project([ :id ])                                            }
+  let(:summarizers)   { { Attribute.coerce(:count) => lambda { |acc, tuple| acc.to_i + 1 } } }
+  let(:object)        { described_class.new(operand, summarize_per, summarizers)             }
+
+  context 'when the operand is empty' do
+    let(:operand) { relation.restrict { false } }
+
+    it { should eql(summarize_per.extend { |r| r.add(:count, nil) }) }
+
+    it 'returns an equivalent relation to the unoptimized operation' do
+      should == object
+    end
+
+    it 'does not execute body#each' do
+      body.should_not_receive(:each)
+      subject
+    end
+
+    it_should_behave_like 'an optimize method'
+  end
+
+  context 'when the summarize_per is empty' do
+    let(:summarize_per) { relation.project([ :id ]).restrict { false } }
+
+    it { should eql(Relation::Empty.new(object.header)) }
+
+    it 'returns an equivalent relation to the unoptimized operation' do
+      should == object
+    end
+
+    it 'does not execute body#each' do
+      body.should_not_receive(:each)
+      subject
+    end
+
+    it_should_behave_like 'an optimize method'
+  end
+end

data/spec/integration/axiom/algebra/union/optimize_spec.rb

@@ -0,0 +1,200 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Algebra::Union, '#optimize' do
+  subject { object.optimize }
+
+  let(:header)         { [ [ :id, Integer ] ]             }
+  let(:left_body)      { LazyEnumerable.new([ [ 1 ] ])    }
+  let(:right_body)     { LazyEnumerable.new([ [ 2 ] ])    }
+  let(:original_left)  { Relation.new(header, left_body)  }
+  let(:original_right) { Relation.new(header, right_body) }
+  let(:object)         { described_class.new(left, right) }
+
+  before do
+    # skip dup of the left and right body to avoid clearing the method stubs
+    left_body.stub!(:frozen?).and_return(true)
+    right_body.stub!(:frozen?).and_return(true)
+  end
+
+  context 'left is an empty relation' do
+    let(:left)  { Relation::Empty.new(header) }
+    let(:right) { original_right              }
+
+    it { should equal(right) }
+
+    it 'returns an equivalent relation to the unoptimized operation' do
+      should == object
+    end
+
+    it 'does not execute left_body#each' do
+      left_body.should_not_receive(:each)
+      subject
+    end
+
+    it 'does not execute right_body#each' do
+      right_body.should_not_receive(:each)
+      subject
+    end
+
+    it_should_behave_like 'an optimize method'
+  end
+
+  context 'right is an empty relation' do
+    let(:left)  { original_left               }
+    let(:right) { Relation::Empty.new(header) }
+
+    it { should equal(left) }
+
+    it 'returns an equivalent relation to the unoptimized operation' do
+      should == object
+    end
+
+    it 'does not execute left_body#each' do
+      left_body.should_not_receive(:each)
+      subject
+    end
+
+    it 'does not execute right_body#each' do
+      right_body.should_not_receive(:each)
+      subject
+    end
+
+    it_should_behave_like 'an optimize method'
+  end
+
+  context 'left is an empty relation when optimized' do
+    let(:left)  { Algebra::Restriction.new(original_left, Function::Proposition::Contradiction.instance) }
+    let(:right) { original_right                                                                         }
+
+    it { should equal(right) }
+
+    it 'returns an equivalent relation to the unoptimized operation' do
+      should == object
+    end
+
+    it 'does not execute left_body#each' do
+      left_body.should_not_receive(:each)
+      subject
+    end
+
+    it 'does not execute right_body#each' do
+      right_body.should_not_receive(:each)
+      subject
+    end
+
+    it_should_behave_like 'an optimize method'
+  end
+
+  context 'right is an empty relation when optimized' do
+    let(:left)  { original_left                                                                           }
+    let(:right) { Algebra::Restriction.new(original_right, Function::Proposition::Contradiction.instance) }
+
+    it { should equal(left) }
+
+    it 'returns an equivalent relation to the unoptimized operation' do
+      should == object
+    end
+
+    it 'does not execute left_body#each' do
+      left_body.should_not_receive(:each)
+      subject
+    end
+
+    it 'does not execute right_body#each' do
+      right_body.should_not_receive(:each)
+      subject
+    end
+
+    it_should_behave_like 'an optimize method'
+  end
+
+  context 'left and right are equivalent relations' do
+    let(:left_body)  { LazyEnumerable.new([ [ 1 ] ]) }
+    let(:right_body) { LazyEnumerable.new([ [ 1 ] ]) }
+    let(:left)       { original_left                 }
+    let(:right)      { original_right                }
+
+    it { should equal(left) }
+
+    it 'returns an equivalent relation to the unoptimized operation' do
+      should == object
+    end
+
+    it 'does not execute left_body#each' do
+      pending 'TODO: should only compare left and right with #eql? if they are materialized' do
+        left_body.should_not_receive(:each)
+        subject
+      end
+    end
+
+    it 'does not execute right_body#each' do
+      pending 'TODO: should only compare left and right with #eql? if they are materialized' do
+        right_body.should_not_receive(:each)
+        subject
+      end
+    end
+
+    it_should_behave_like 'an optimize method'
+  end
+
+  context 'left and right are equivalent materialized relations' do
+    let(:left_body)  { [ [ 1 ] ]      }
+    let(:right_body) { [ [ 1 ] ]      }
+    let(:left)       { original_left  }
+    let(:right)      { original_right }
+
+    it { should equal(left) }
+
+    it 'returns an equivalent relation to the unoptimized operation' do
+      should == object
+    end
+
+    it 'executes left_body#each' do
+      pending 'only receive #each once'
+      left_body.should_receive(:each)
+      subject
+    end
+
+    it 'executes right_body#each' do
+      pending 'only receive #each once'
+      right_body.should_receive(:each)
+      subject
+    end
+
+    it_should_behave_like 'an optimize method'
+  end
+
+  context 'left and right are not empty relations' do
+    let(:left)  { original_left  }
+    let(:right) { original_right }
+
+    it { should equal(object) }
+
+    it 'executes left_body#each' do
+      left_body.should_receive(:each)
+      subject
+    end
+
+    it 'executes right_body#each' do
+      right_body.should_receive(:each)
+      subject
+    end
+
+    it_should_behave_like 'an optimize method'
+  end
+
+  context 'left and right are materialized relations' do
+    let(:left)  { Relation.new(header, [ [ 1 ], [ 2 ] ]) }
+    let(:right) { Relation.new(header, [ [ 1 ] ])        }
+
+    it { should eql(Relation::Materialized.new(header, [ [ 1 ], [ 2 ] ])) }
+
+    it 'returns an equivalent relation to the unoptimized operation' do
+      should == object
+    end
+
+    it_should_behave_like 'an optimize method'
+  end
+end