axiom-optimizer 0.1.0

data/spec/integration/axiom/relation/operation/limit/optimize_spec.rb

@@ -0,0 +1,142 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Relation::Operation::Limit, '#optimize' do
+  subject { object.optimize }
+
+  let(:body)       { LazyEnumerable.new([ [ 1 ], [ 2 ], [ 3 ] ]) }
+  let(:relation)   { Relation.new([ [ :id, Integer ] ], body)    }
+  let(:directions) { [ relation[:id] ]                           }
+  let(:order)      { relation.sort_by { directions }             }
+  let(:operand)    { order                                       }
+  let(:limit)      { 1                                           }
+  let(:object)     { described_class.new(operand, limit)         }
+
+  context 'when the limit is 0' do
+    let(:limit) { 0 }
+
+    it { should be_kind_of(Relation::Empty) }
+
+    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 an order operation' do
+    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 'containing an optimizable order operation' do
+    let(:operand) { order.rename({}) }
+
+    it { should be_kind_of(described_class) }
+
+    its(:operand) { should equal(order) }
+
+    its(:limit) { should == 1 }
+
+    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 more restrictive object operation' do
+    let(:operand) { order.take(5) }
+    let(:limit)   { 10            }
+
+    it { should be_kind_of(described_class) }
+
+    its(:operand) { should equal(order) }
+
+    it 'uses the more restrictive object' do
+      subject.limit.should == 5
+    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 less restrictive object operation' do
+    let(:operand) { order.take(10) }
+    let(:limit)   { 5              }
+
+    it { should be_kind_of(described_class) }
+
+    its(:operand) { should equal(order) }
+
+    it 'uses the more restrictive object' do
+      subject.limit.should == 5
+    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 similar object operation' do
+    let(:operand) { order.take(10) }
+    let(:limit)   { 10             }
+
+    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 'containing a materialized relation' do
+    let(:relation) { Relation.new([ [ :id, Integer ] ], [ [ 1 ], [ 2 ], [ 3 ] ]) }
+
+    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/relation/operation/offset/optimize_spec.rb

@@ -0,0 +1,100 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Relation::Operation::Offset, '#optimize' do
+  subject { object.optimize }
+
+  let(:body)       { LazyEnumerable.new([ [ 1 ], [ 2 ], [ 3 ] ]) }
+  let(:relation)   { Relation.new([ [ :id, Integer ] ], body)    }
+  let(:directions) { [ relation[:id] ]                           }
+  let(:order)      { relation.sort_by { directions }             }
+  let(:operand)    { order                                       }
+  let(:offset)     { 1                                           }
+  let(:object)     { described_class.new(operand, offset)        }
+
+  context 'with an object of 0' do
+    let(:offset) { 0 }
+
+    it { should equal(order) }
+
+    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 an order operation' do
+    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 'containing an optimizable order operation' do
+    let(:operand) { order.rename({}) }
+
+    it { should be_kind_of(described_class) }
+
+    its(:operand) { should equal(order) }
+
+    its(:offset) { should == 1 }
+
+    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 an object operation' do
+    let(:operand) { order.drop(5) }
+    let(:offset)  { 10            }
+
+    it { should be_kind_of(described_class) }
+
+    its(:operand) { should equal(order) }
+
+    it 'adds the object of the operations' do
+      subject.offset.should == 15
+    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(:relation) { Relation.new([ [ :id, Integer ] ], [ [ 1 ], [ 2 ], [ 3 ] ]) }
+
+    it { should eql(Relation::Materialized.new([ [ :id, Integer ] ], [ [ 2 ], [ 3 ] ])) }
+
+    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/relation/operation/order/optimize_spec.rb

@@ -0,0 +1,105 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Relation::Operation::Order, '#optimize' do
+  subject { object.optimize }
+
+  let(:body)       { LazyEnumerable.new([ [ 1 ], [ 2 ], [ 3 ] ]) }
+  let(:relation)   { Relation.new([ [ :id, Integer ] ], body)    }
+  let(:operand)    { relation                                    }
+  let(:directions) { [ relation[:id] ]                           }
+  let(:object)     { described_class.new(operand, directions)    }
+
+  context 'containing a relation' do
+    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 'containing an optimizable relation' do
+    let(:operand) { relation.project(relation.header) }
+
+    it { should eql(relation.sort_by { directions }) }
+
+    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 an object operation' do
+    let(:operand) { relation.sort_by { |r| [ r.id.desc ] } }
+
+    it { should eql(relation.sort_by { directions }) }
+
+    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 reverse operation' do
+    let(:operand) { relation.sort_by { |r| r.id }.reverse }
+
+    it { should eql(relation.sort_by { |r| r.id }) }
+
+    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 limit(1) operation' do
+    let(:operand) { relation.sort_by { |r| r.id }.take(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 'containing a materialized relation' do
+    let(:relation) { Relation.new([ [ :id, Integer ] ], [ [ 1 ], [ 2 ], [ 3 ] ]) }
+    let(:object)   { described_class.new(relation, directions)                   }
+
+    it { should eql(Relation::Materialized.new([ [ :id, Integer ] ], [ [ 1 ], [ 2 ], [ 3 ] ])) }
+
+    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/relation/operation/reverse/optimize_spec.rb

@@ -0,0 +1,115 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Relation::Operation::Reverse, '#optimize' do
+  subject { object.optimize }
+
+  let(:body)     { LazyEnumerable.new([ [ 1 ], [ 2 ], [ 3 ] ]) }
+  let(:relation) { Relation.new([ [ :id, Integer ] ], body)    }
+  let(:order)    { relation.sort_by { |r| r.id }               }
+  let(:operand)  { order                                       }
+  let(:object)   { described_class.new(operand)                }
+
+  context 'with a object operation' do
+    let(:limit)   { order.take(2) }
+    let(:operand) { limit.reverse }
+
+    it 'cancels out the operations and return the contained operation' do
+      should equal(limit)
+    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 a object operation when optimized' do
+    let(:limit)   { order.take(2)            }
+    let(:operand) { limit.reverse.rename({}) }
+
+    it 'cancels out the operations and return the contained operation' do
+      should equal(limit)
+    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
+    it { should eql(relation.sort_by { object.directions }) }
+
+    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 when optimized' do
+    let(:operand) { order.rename({}) }
+
+    it { should eql(relation.sort_by { object.directions }) }
+
+    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 operation' do
+    let(:limit)   { order.take(2)    }
+    let(:operand) { limit.rename({}) }
+
+    it { should eql(order.take(2).reverse) }
+
+    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(:relation) { Relation.new([ [ :id, Integer ] ], [ [ 1 ], [ 2 ], [ 3 ] ]) }
+
+    it { should eql(Relation::Materialized.new([ [ :id, Integer ] ], [ [ 3 ], [ 2 ], [ 1 ] ])) }
+
+    it 'returns an equivalent relation to the unoptimized operation' do
+      should == object
+    end
+
+    it_should_behave_like 'an optimize method'
+  end
+end