axiom-optimizer 0.1.0

data/lib/axiom/optimizer/version.rb

@@ -0,0 +1,10 @@
+# encoding: utf-8
+
+module Axiom
+  class Optimizer
+
+    # Gem version
+    VERSION = '0.1.0'.freeze
+
+  end # class Optimizer
+end # module Axiom

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

@@ -0,0 +1,160 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Algebra::Difference, '#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(left) }
+
+    it 'returns an equivalent relation to the unoptimized operation' do
+      should == object
+    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_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 eql(Relation::Empty.new(left.header | right.header)) }
+
+    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
+
+  unless defined?(JRUBY_VERSION) && JRUBY_VERSION < '1.6'
+    context 'left and right are equivalent relations' do
+      let(:right_body) { LazyEnumerable.new([ [ 1 ] ]) }
+      let(:left)       { original_left                 }
+      let(:right)      { original_right                }
+
+      it { should eql(Relation::Empty.new(header)) }
+
+      it 'returns an equivalent relation to the unoptimized operation' do
+        should == object
+      end
+
+      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
+  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, [ [ 2 ] ])) }
+
+    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/intersection/optimize_spec.rb

@@ -0,0 +1,160 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Algebra::Intersection, '#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(left) }
+
+    it 'returns an equivalent relation to the unoptimized operation' do
+      should == object
+    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(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_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 eql(Relation::Empty.new(left.header | right.header)) }
+
+    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 eql(Relation::Empty.new(left.header | right.header)) }
+
+    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
+
+  unless defined?(JRUBY_VERSION) && JRUBY_VERSION < '1.6'
+    context 'left and right are equivalent relations' do
+      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 '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
+  end
+
+  context 'left and right are not empty relations' do
+    let(:left)  { original_left  }
+    let(:right) { original_right }
+
+    it { should equal(object) }
+
+    it 'executed left_body#each' do
+      left_body.should_receive(:each)
+      subject
+    end
+
+    it 'executed 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 ] ])) }
+
+    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/join/optimize_spec.rb

@@ -0,0 +1,112 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Algebra::Join, '#optimize' do
+  subject { object.optimize }
+
+  let(:left_body)      { LazyEnumerable.new([ [ 1 ], [ 2 ] ])                              }
+  let(:right_body)     { LazyEnumerable.new([ [ 2, 'Dan Kubb' ] ])                         }
+  let(:original_left)  { Relation.new([ [ :id, Integer ] ],                    left_body)  }
+  let(:original_right) { Relation.new([ [ :id, Integer ], [ :name, String ] ], right_body) }
+  let(:left)           { original_left                                                     }
+  let(:right)          { original_right                                                    }
+  let(:object)         { described_class.new(left, right)                                  }
+
+  context 'left is an empty relation' do
+    let(:left) { Relation::Empty.new(original_left.header) }
+
+    it { should eql(Relation::Empty.new(right.header)) }
+
+    it 'returns an equivalent relation to the unoptimized operation' do
+      should == object
+    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(:right) { Relation::Empty.new(original_right.header) }
+
+    it { should eql(Relation::Empty.new(right.header)) }
+
+    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_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) }
+
+    it { should eql(Relation::Empty.new(right.header)) }
+
+    it 'returns an equivalent relation to the unoptimized operation' do
+      should == object
+    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(:right) { Algebra::Restriction.new(original_right, Function::Proposition::Contradiction.instance) }
+
+    it { should eql(Relation::Empty.new(right.header)) }
+
+    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_should_behave_like 'an optimize method'
+  end
+
+  context 'left and right are not empty relations' do
+    it { should equal(object) }
+
+    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 materialized relations' do
+    let(:left)  { Relation.new([ [ :id, Integer ] ],                    [ [ 1 ], [ 2 ] ])      }
+    let(:right) { Relation.new([ [ :id, Integer ], [ :name, String ] ], [ [ 2, 'Dan Kubb' ] ]) }
+
+    it { should eql(Relation::Materialized.new([ [ :id, Integer ], [ :name, String ] ], [ [ 2, 'Dan Kubb' ] ])) }
+
+    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/product/optimize_spec.rb

@@ -0,0 +1,178 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Algebra::Product, '#optimize' do
+  subject { object.optimize }
+
+  let(:left_body)  { LazyEnumerable.new([ [ 1 ] ])                    }
+  let(:right_body) { LazyEnumerable.new([ [ 'Dan Kubb' ] ])           }
+  let(:left)       { Relation.new([ [ :id,   Integer ] ], left_body)  }
+  let(:right)      { Relation.new([ [ :name, String  ] ], right_body) }
+  let(:object)     { described_class.new(left, right)                 }
+
+  context 'left is a TABLE_DUM' do
+    let(:left) { TABLE_DUM }
+
+    it { should eql(Relation::Empty.new(right.header)) }
+
+    it 'returns an equivalent relation to the unoptimized operation' do
+      should == object
+    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 a TABLE_DUM' do
+    let(:right) { TABLE_DUM }
+
+    it { should eql(Relation::Empty.new(left.header)) }
+
+    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_should_behave_like 'an optimize method'
+  end
+
+  context 'left is a TABLE_DUM when optimized' do
+    let(:left) { TABLE_DUM.project([]) }
+
+    it { should eql(Relation::Empty.new(right.header)) }
+
+    it 'returns an equivalent relation to the unoptimized operation' do
+      should == object
+    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 a TABLE_DUM when optimized' do
+    let(:right) { TABLE_DUM.project([]) }
+
+    it { should eql(Relation::Empty.new(left.header)) }
+
+    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_should_behave_like 'an optimize method'
+  end
+
+  context 'left is a TABLE_DEE' do
+    let(:left) { TABLE_DEE }
+
+    it { should equal(right) }
+
+    it 'returns an equivalent relation to the unoptimized operation' do
+      should == object
+    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 a TABLE_DEE' do
+    let(:right) { TABLE_DEE }
+
+    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_should_behave_like 'an optimize method'
+  end
+
+  context 'left is a TABLE_DEE when optimized' do
+    let(:left) { TABLE_DEE.project([]) }
+
+    it { should equal(right) }
+
+    it 'returns an equivalent relation to the unoptimized operation' do
+      should == object
+    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 a TABLE_DEE when optimized' do
+    let(:right) { TABLE_DEE.project([]) }
+
+    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_should_behave_like 'an optimize method'
+  end
+
+  context 'left and right are normal relations' do
+    it { should equal(object) }
+
+    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 materialized relations' do
+    let(:left)  { Relation.new([ [ :id,   Integer ] ], [ [ 1 ] ])          }
+    let(:right) { Relation.new([ [ :name, String  ] ], [ [ 'Dan Kubb' ] ]) }
+
+    it { should eql(Relation::Materialized.new([ [ :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