axiom-optimizer 0.1.0

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

@@ -0,0 +1,250 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Algebra::Projection, '#optimize' do
+  subject { object.optimize }
+
+  let(:header)   { [ [ :id, Integer ], [ :name, String ], [ :age, Integer ] ] }
+  let(:body)     { LazyEnumerable.new([ [ 1, 'Dan Kubb', 35 ] ])              }
+  let(:relation) { Relation.new(header, body)                                 }
+  let(:operand)  { relation                                                   }
+  let(:object)   { described_class.new(operand, attributes)                   }
+
+  before do
+    # skip dup of the body to avoid clearing the method stubs
+    body.stub!(:frozen?).and_return(true)
+  end
+
+  context 'when the attributes are equivalent to the relation headers, and in the same order' do
+    let(:attributes) { header }
+
+    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 'when the attributes are equivalent to the relation headers, and not in the same order' do
+    let(:attributes) { [ :name, :id ] }
+
+    it 'does not factor out the object, because tuple order is currently significant' do
+      should equal(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 attributes are different from the relation headers' do
+    let(:attributes) { [ :id ] }
+
+    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 empty relation' do
+    let(:operand)    { Relation::Empty.new(header) }
+    let(:attributes) { [ :id ]                     }
+
+    it { should eql(Relation::Empty.new(object.header)) }
+
+    it 'returns an equivalent relation to the unoptimized operation' do
+      should == object
+    end
+
+    it_should_behave_like 'an optimize method'
+  end
+
+  context 'containing an empty relation when optimized' do
+    let(:operand)    { Algebra::Restriction.new(relation, Function::Proposition::Contradiction.instance) }
+    let(:attributes) { [ :id ]                                                                           }
+
+    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
+
+  context 'containing an optimizable relation' do
+    let(:operand)    { Algebra::Restriction.new(relation, Function::Proposition::Tautology.instance) }
+    let(:attributes) { [ :id ]                                                                       }
+
+    it { should_not equal(object) }
+
+    it { should be_kind_of(described_class) }
+
+    its(:operand) { should equal(relation) }
+
+    its(:header) { should == 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
+
+  context 'containing a projection' do
+    let(:operand)    { relation.project([ :id, :name ]) }
+    let(:attributes) { [ :id ]                          }
+
+    it { should_not equal(object) }
+
+    it { should be_kind_of(described_class) }
+
+    its(:operand) { should equal(relation) }
+
+    its(:header) { should == 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
+
+  context 'containing a set operation' do
+    let(:left)       { Relation.new([ [ :id, Integer ], [ :name, String ] ], LazyEnumerable.new([ [ 1, 'Dan Kubb' ] ])) }
+    let(:right)      { Relation.new([ [ :id, Integer ], [ :name, String ] ], LazyEnumerable.new([ [ 2, 'Dan Kubb' ] ])) }
+    let(:operand)    { left.union(right)                                                                                }
+    let(:attributes) { [ :name ]                                                                                        }
+
+    it 'pushes the object to each relation' do
+      should eql(Algebra::Union.new(
+         described_class.new(left,  object.header),
+         described_class.new(right, object.header)
+      ))
+    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 set operation containing a projection of relations' do
+    let(:left_body)  { LazyEnumerable.new([ [ 1, 'Dan Kubb', 35 ] ])                     }
+    let(:right_body) { LazyEnumerable.new([ [ 2, 'Dan Kubb', 35 ] ])                     }
+    let(:left)       { Relation.new(header, left_body)                                   }
+    let(:right)      { Relation.new(header, right_body)                                  }
+    let(:operand)    { left.project([ :id, :name ]).union(right.project([ :id, :name ])) }
+    let(:attributes) { [ :name ]                                                         }
+
+    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
+
+    it 'pushes the object to each relation, and combine the nested objects' do
+      should eql(left.project([ :name ]).union(right.project([ :name ])))
+    end
+
+    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 'containing a set operation containing a projection of materialized relations' do
+    let(:left_body)  { [ [ 1, 'Dan Kubb', 35 ] ]                                         }
+    let(:right_body) { [ [ 2, 'Dan Kubb', 35 ] ]                                         }
+    let(:left)       { Relation.new(header, left_body)                                   }
+    let(:right)      { Relation.new(header, right_body)                                  }
+    let(:operand)    { left.project([ :id, :name ]).union(right.project([ :id, :name ])) }
+    let(:attributes) { [ :name ]                                                         }
+
+    it 'pushes the object to each relation, and combine the nested objects, then materializes' do
+      should eql(Relation.new([ [ :name, String ] ], [ [ 'Dan Kubb' ] ]))
+    end
+
+    it 'returns an equivalent relation to the unoptimized operation' do
+      should == object
+    end
+
+    it 'executes left_body#each' do
+      pending 'TODO: make sure this is only received once'
+      left_body.should_receive(:each)
+      subject
+    end
+
+    it 'executes right_body#each' do
+      pending 'TODO: make sure this is only received once'
+      right_body.should_receive(:each)
+      subject
+    end
+
+    it_should_behave_like 'an optimize method'
+  end
+
+  context 'containing a materialized relation' do
+    let(:operand)    { Relation.new(header, [ [ 1, 'Dan Kubb', 35 ] ]) }
+    let(:attributes) { [ :id ]                                         }
+
+    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/rename/optimize_spec.rb

@@ -0,0 +1,442 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Algebra::Rename, '#optimize' do
+  subject { object.optimize }
+
+  let(:body)     { LazyEnumerable.new([ [ 1, 'Dan Kubb' ] ])                   }
+  let(:relation) { Relation.new([ [ :id, Integer ], [ :name, String ] ], body) }
+  let(:operand)  { relation                                                    }
+  let(:aliases)  { { :id => :other_id }                                        }
+  let(:object)   { described_class.new(operand, aliases)                       }
+
+  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 empty relation' do
+    let(:operand) { Relation::Empty.new(relation.header) }
+
+    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
+
+  context 'containing an optimizable relation' do
+    let(:operand) { relation.project(relation.header) }
+
+    it { should_not equal(object) }
+
+    it { should be_kind_of(described_class) }
+
+    it 'sets aliases the same as the original object' do
+      subject.aliases.should == object.aliases
+    end
+
+    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 'containing a object operation' do
+    let(:operand) { described_class.new(relation, :id => :other_id) }
+    let(:aliases) { { :name => :other_name }                        }
+
+    it { should_not equal(object) }
+
+    it { should be_kind_of(described_class) }
+
+    it 'sets aliases as a union of both aliases' do
+      subject.aliases.should == described_class::Aliases.coerce(
+        relation.header,
+        :id   => :other_id,
+        :name => :other_name
+      )
+    end
+
+    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 'containing a object operation with overlapping aliases' do
+    let(:operand) { described_class.new(relation, :id => :other_id) }
+    let(:aliases) { { :other_id => :another_id }                    }
+
+    it { should_not equal(object) }
+
+    it { should be_kind_of(described_class) }
+
+    it 'sets aliases as a union of both aliases' do
+      subject.aliases.should == described_class::Aliases.coerce(
+        relation.header,
+        :id => :another_id
+      )
+    end
+
+    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 'containing an inverse object operation' do
+    let(:operand) { described_class.new(relation, :id => :other_id) }
+    let(:aliases) { { :other_id => :id }                            }
+
+    it { 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 'containing a projection' do
+    let(:operand) { relation.project([ :id ]) }
+
+    it { should be_kind_of(Algebra::Projection) }
+
+    its(:operand) { should eql(described_class.new(relation, aliases)) }
+
+    its(:header) { should == [ [ :other_id, Integer ] ] }
+
+    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 projection, containing a object that cancels out' do
+    let(:operand) { relation.rename(:id => :other_id).project([ :other_id ]) }
+    let(:aliases) { { :other_id => :id }                                     }
+
+    it 'pushes the object before the projection, and then cancel it out' do
+      should eql(relation.project([ :id ]))
+    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 restriction' do
+    let(:operand) { relation.restrict { |r| r.id.eq(1) } }
+
+    it { should be_kind_of(Algebra::Restriction) }
+
+    its(:operand) { should eql(described_class.new(relation, aliases)) }
+
+    its(:header) { should == [ [ :other_id, Integer ], [ :name, String ] ] }
+
+    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 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 }                                                }
+
+    it 'pushes the object before the restriction, and then cancel it out' do
+      should eql(relation.restrict { |r| r.id.eq(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 'containing a set operation' do
+    let(:left)    { Relation.new([ [ :id, Integer ], [ :name, String ] ], LazyEnumerable.new([ [ 1, 'Dan Kubb' ] ])) }
+    let(:right)   { Relation.new([ [ :id, Integer ], [ :name, String ] ], LazyEnumerable.new([ [ 2, 'Dan Kubb' ] ])) }
+    let(:operand) { left.union(right)                                                                                }
+
+    it 'pushes the object to each relation' do
+      should eql(left.rename(aliases).union(right.rename(aliases)))
+    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 set operation, containing a object that cancels out' do
+    let(:left)    { Relation.new([ [ :id, Integer ], [ :name, String ] ], LazyEnumerable.new([ [ 1, 'Dan Kubb' ] ])) }
+    let(:right)   { Relation.new([ [ :id, Integer ], [ :name, String ] ], LazyEnumerable.new([ [ 2, 'Dan Kubb' ] ])) }
+    let(:operand) { left.rename(:id => :other_id).union(right.rename(:id => :other_id))                              }
+    let(:aliases) { { :other_id => :id }                                                                             }
+
+    it 'pushes the object to each relation, then cancel it out' do
+      should eql(left.union(right))
+    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 reverse operation' do
+    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).sort_by { |r| [ r.other_id, r.name ] }.take(2).reverse)
+    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 reverse operation, containing a object that cancels out' do
+    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.sort_by { |r| [ r.id, r.name ] }.take(2).reverse)
+    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 an order operation' do
+    let(:operand) { relation.sort_by { |r| [ r.id, r.name ] } }
+
+    it 'pushes the object under the order' do
+      should eql(relation.rename(aliases).sort_by { |r| [ r.other_id, r.name ] })
+    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 an order operation, containing a object that cancels out' do
+    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.sort_by { |r| [ r.id, r.name ] })
+    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 limit operation' do
+    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).sort_by { |r| [ r.other_id, r.name ] }.take(2))
+    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 limit operation, containing a object that cancels out' do
+    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.sort_by { |r| [ r.id, r.name ] }.take(2))
+    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 an offset operation' do
+    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).sort_by { |r| [ r.other_id, r.name ] }.drop(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 'containing an offset operation, containing a object that cancels out' do
+    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.sort_by { |r| [ r.id, r.name ] }.drop(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 'containing a materialized relation' do
+    let(:operand) { Relation.new([ [ :id, Integer ], [ :name, String ] ], [ [ 1, 'Dan Kubb' ] ]) }
+
+    it { should eql(Relation::Materialized.new([ [ :other_id, Integer ], [ :name, String ] ], [ [ 1, 'Dan Kubb' ] ])) }
+
+    it 'returns an equivalent relation to the unoptimized operation' do
+      should == object
+    end
+
+    it_should_behave_like 'an optimize method'
+  end
+end