veritas-optimizer 0.0.3

data/spec/integration/veritas/logic/predicate/less_than/optimize_spec.rb

@@ -0,0 +1,100 @@
+require 'spec_helper'
+
+describe Logic::Predicate::LessThan, '#optimize' do
+  subject { object.optimize }
+
+  let(:attribute) { Attribute::Integer.new(:id, :required => false) }
+  let(:left)      { attribute                                       }
+  let(:right)     { attribute                                       }
+  let(:object)    { described_class.new(left, right)                }
+
+  context 'left and right are attributes' do
+    context 'and equivalent' do
+      it { should equal(Logic::Proposition::Contradiction.instance) }
+
+      it_should_behave_like 'an optimize method'
+    end
+
+    context 'and are not comparable' do
+      let(:right) { Attribute::Float.new(:float) }
+
+      it { should equal(Logic::Proposition::Contradiction.instance) }
+
+      it_should_behave_like 'an optimize method'
+    end
+
+    context 'and left is always less than right' do
+      let(:left)  { attribute                                             }
+      let(:right) { Attribute::Integer.new(:right, :size => 2**31..2**31) }
+
+      it { should equal(Logic::Proposition::Tautology.instance) }
+
+      it_should_behave_like 'an optimize method'
+    end
+
+    context 'and left is always greater than or equal to right' do
+      let(:left)  { attribute                                     }
+      let(:right) { Attribute::Integer.new(:right, :size => 0..0) }
+
+      it { should equal(Logic::Proposition::Contradiction.instance) }
+
+      it_should_behave_like 'an optimize method'
+    end
+  end
+
+  context 'left is an attribute' do
+    context 'right is a valid value' do
+      let(:right) { 1 }
+
+      it { should equal(object) }
+
+      it_should_behave_like 'an optimize method'
+    end
+
+    context 'right is an invalid primitive' do
+      let(:right) { nil }
+
+      it { should equal(Logic::Proposition::Contradiction.instance) }
+
+      it_should_behave_like 'an optimize method'
+    end
+  end
+
+  context 'right is an attribute' do
+    context 'left is a valid value' do
+      let(:left) { 1 }
+
+      it { should eql(Logic::Predicate::GreaterThan.new(attribute, 1)) }
+
+      it_should_behave_like 'an optimize method'
+    end
+
+    context 'left is an invalid primitive' do
+      let(:left) { nil }
+
+      it { should equal(Logic::Proposition::Contradiction.instance) }
+
+      it_should_behave_like 'an optimize method'
+    end
+  end
+
+  context 'left and right are constants' do
+    context 'that will evaluate to a tautology' do
+      let(:left)  { 1 }
+      let(:right) { 2 }
+
+      it { should equal(Logic::Proposition::Tautology.instance) }
+
+      it_should_behave_like 'an optimize method'
+    end
+
+    context 'that will evaluate to a contradiction' do
+      let(:left)  { 1 }
+      let(:right) { 1 }
+
+      it { should equal(Logic::Proposition::Contradiction.instance) }
+
+      it_should_behave_like 'an optimize method'
+    end
+  end
+end

data/spec/integration/veritas/logic/predicate/less_than_or_equal_to/optimize_spec.rb

@@ -0,0 +1,100 @@
+require 'spec_helper'
+
+describe Logic::Predicate::LessThanOrEqualTo, '#optimize' do
+  subject { object.optimize }
+
+  let(:attribute) { Attribute::Integer.new(:id, :required => false) }
+  let(:left)      { attribute                                       }
+  let(:right)     { attribute                                       }
+  let(:object)    { described_class.new(left, right)                }
+
+  context 'left and right are attributes' do
+    context 'and equivalent' do
+      it { should equal(Logic::Proposition::Tautology.instance) }
+
+      it_should_behave_like 'an optimize method'
+    end
+
+    context 'and are not comparable' do
+      let(:right) { Attribute::Float.new(:float) }
+
+      it { should equal(Logic::Proposition::Contradiction.instance) }
+
+      it_should_behave_like 'an optimize method'
+    end
+
+    context 'and left is always less than right' do
+      let(:left)  { attribute                                             }
+      let(:right) { Attribute::Integer.new(:right, :size => 2**31..2**31) }
+
+      it { should equal(Logic::Proposition::Tautology.instance) }
+
+      it_should_behave_like 'an optimize method'
+    end
+
+    context 'and left is always greater than right' do
+      let(:left)  { attribute                                       }
+      let(:right) { Attribute::Integer.new(:right, :size => -1..-1) }
+
+      it { should equal(Logic::Proposition::Contradiction.instance) }
+
+      it_should_behave_like 'an optimize method'
+    end
+  end
+
+  context 'left is an attribute' do
+    context 'right is a valid value' do
+      let(:right) { 1 }
+
+      it { should equal(object) }
+
+      it_should_behave_like 'an optimize method'
+    end
+
+    context 'right is an invalid primitive' do
+      let(:right) { nil }
+
+      it { should equal(Logic::Proposition::Contradiction.instance) }
+
+      it_should_behave_like 'an optimize method'
+    end
+  end
+
+  context 'right is an attribute' do
+    context 'left is a valid value' do
+      let(:left) { 1 }
+
+      it { should eql(Logic::Predicate::GreaterThanOrEqualTo.new(attribute, 1)) }
+
+      it_should_behave_like 'an optimize method'
+    end
+
+    context 'left is an invalid primitive' do
+      let(:left) { nil }
+
+      it { should equal(Logic::Proposition::Contradiction.instance) }
+
+      it_should_behave_like 'an optimize method'
+    end
+  end
+
+  context 'left and right are constants' do
+    context 'that will evaluate to a tautology' do
+      let(:left)  { 1 }
+      let(:right) { 1 }
+
+      it { should equal(Logic::Proposition::Tautology.instance) }
+
+      it_should_behave_like 'an optimize method'
+    end
+
+    context 'that will evaluate to a contradiction' do
+      let(:left)  { 2 }
+      let(:right) { 1 }
+
+      it { should equal(Logic::Proposition::Contradiction.instance) }
+
+      it_should_behave_like 'an optimize method'
+    end
+  end
+end

data/spec/integration/veritas/relation/empty/optimize_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe Relation::Empty, '#optimize' do
+  subject { object.optimize }
+
+  let(:object) { described_class.new([ [ :id, Integer ] ]) }
+
+  it { should equal(object) }
+
+  it_should_behave_like 'an optimize method'
+end

data/spec/integration/veritas/relation/materialized/optimize_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+describe Relation::Materialized, '#optimize' do
+  subject { object.optimize }
+
+  let(:object) { described_class.new([ [ :id, Integer ] ], body) }
+
+  context 'with an empty Array' do
+    let(:body) { [] }
+
+    it { should eql(Relation::Empty.new(object.header)) }
+
+    it 'returns an equivalent object 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 nonempty Array' do
+    let(:body) { [ [ 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
+end

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

@@ -0,0 +1,140 @@
+require 'spec_helper'
+
+describe Relation::Operation::Limit, '#optimize' do
+  subject { object.optimize }
+
+  let(:body)       { [ [ 1 ], [ 2 ], [ 3 ] ].each             }
+  let(:relation)   { Relation.new([ [ :id, Integer ] ], body) }
+  let(:directions) { [ relation[:id] ]                        }
+  let(:order)      { relation.order(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/veritas/relation/operation/offset/optimize_spec.rb

@@ -0,0 +1,98 @@
+require 'spec_helper'
+
+describe Relation::Operation::Offset, '#optimize' do
+  subject { object.optimize }
+
+  let(:body)       { [ [ 1 ], [ 2 ], [ 3 ] ].each             }
+  let(:relation)   { Relation.new([ [ :id, Integer ] ], body) }
+  let(:directions) { [ relation[:id] ]                        }
+  let(:order)      { relation.order(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/veritas/relation/operation/order/optimize_spec.rb

@@ -0,0 +1,103 @@
+require 'spec_helper'
+
+describe Relation::Operation::Order, '#optimize' do
+  subject { object.optimize }
+
+  let(:body)       { [ [ 1 ], [ 2 ], [ 3 ] ].each             }
+  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.order(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.order { |r| [ r[:id].desc ] } }
+
+    it { should eql(relation.order(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.order.reverse }
+
+    it { should eql(relation.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 a limit(1) operation' do
+    let(:operand) { relation.order.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/veritas/relation/operation/reverse/optimize_spec.rb

@@ -0,0 +1,113 @@
+require 'spec_helper'
+
+describe Relation::Operation::Reverse, '#optimize' do
+  subject { object.optimize }
+
+  let(:body)     { [ [ 1 ], [ 2 ], [ 3 ] ].each             }
+  let(:relation) { Relation.new([ [ :id, Integer ] ], body) }
+  let(:order)    { relation.order                           }
+  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.order(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.order(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