axiom-optimizer 0.1.0

data/spec/unit/axiom/optimizer/relation/operation/binary/right_spec.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Optimizer::Relation::Operation::Binary, '#right' do
+  subject { object.right }
+
+  let(:optimized) { mock('Optimized')                                }
+  let(:left)      { mock('Left')                                     }
+  let(:right)     { mock('Right', :optimize => optimized)            }
+  let(:relation)  { mock('Relation', :left => left, :right => right) }
+  let(:object)    { described_class.new(relation)                    }
+
+  it { should equal(optimized) }
+end

data/spec/unit/axiom/optimizer/relation/operation/binary/unoptimized_operands/optimizable_predicate_spec.rb

@@ -0,0 +1,40 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Optimizer::Relation::Operation::Binary::UnoptimizedOperands, '#optimizable?' do
+  subject { object.optimizable? }
+
+  let(:optimized)   { Relation.new([ [ :id, Integer ] ], [ [ 1 ] ]) }
+  let(:unoptimized) { optimized.project(optimized.header)           }
+  let(:relation)    { left.union(right)                             }
+  let(:object)      { described_class.new(relation)                 }
+
+  context 'when the left and right operands are optimized' do
+    let(:left)  { optimized }
+    let(:right) { optimized }
+
+    it { should be(false) }
+  end
+
+  context 'when the left operand is not optimized and the right operand is optimized' do
+    let(:left)  { unoptimized }
+    let(:right) { optimized   }
+
+    it { should be(true) }
+  end
+
+  context 'when the left operand is optimized and the right operand is not optimized' do
+    let(:left)  { optimized   }
+    let(:right) { unoptimized }
+
+    it { should be(true) }
+  end
+
+  context 'when the left and right operands are not optimized' do
+    let(:left)  { unoptimized }
+    let(:right) { unoptimized }
+
+    it { should be(true) }
+  end
+end

data/spec/unit/axiom/optimizer/relation/operation/binary/unoptimized_operands/optimize_spec.rb

@@ -0,0 +1,24 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Optimizer::Relation::Operation::Binary::UnoptimizedOperands, '#optimize' do
+  subject { object.optimize }
+
+  let(:left)     { Relation.new([ [ :id, Integer ] ], LazyEnumerable.new([ [ 1 ] ])) }
+  let(:right)    { Relation.new([ [ :id, Integer ] ], LazyEnumerable.new([ [ 2 ] ])) }
+  let(:relation) { left.rename({}).union(right.rename({}))                           }
+  let(:object)   { described_class.new(relation)                                     }
+
+  before do
+    object.should be_optimizable
+  end
+
+  it { should be_kind_of(Algebra::Union) }
+
+  it { should_not equal(relation) }
+
+  its(:left) { should equal(left) }
+
+  its(:right) { should equal(right) }
+end

data/spec/unit/axiom/optimizer/relation/operation/combination/optimize_spec.rb

@@ -0,0 +1,18 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Optimizer::Relation::Operation::Combination, '#optimize' do
+  subject { object.optimize }
+
+  let(:left)     { Relation.new([ [ :id, Integer ] ], []) }
+  let(:right)    { Relation.new([ [ :id, Integer ] ], []) }
+  let(:relation) { left.join(right)                       }
+  let(:object)   { described_class.new(relation)          }
+
+  it { should be_kind_of(Relation::Empty) }
+
+  its(:header) { should equal(relation.header) }
+
+  its(:tuples) { should equal(relation) }
+end

data/spec/unit/axiom/optimizer/relation/operation/limit/equal_limit_operand/optimizable_predicate_spec.rb

@@ -0,0 +1,33 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Optimizer::Relation::Operation::Limit::EqualLimitOperand, '#optimizable?' do
+  subject { object.optimizable? }
+
+  let(:base)     { Relation.new([ [ :id, Integer ] ], LazyEnumerable.new([ [ 1 ] ])).sort_by { |r| r.id } }
+  let(:relation) { operand.take(1)                                                                        }
+  let(:object)   { described_class.new(relation)                                                          }
+
+  before do
+    object.operation.should be_kind_of(Relation::Operation::Limit)
+  end
+
+  context 'when the operand is limited and not equal to the operation' do
+    let(:operand) { base.take(2) }
+
+    it { should be(false) }
+  end
+
+  context 'when the operand is limited and equal to the operation' do
+    let(:operand) { base.take(1) }
+
+    it { should be(true) }
+  end
+
+  context 'when the operand is not limited' do
+    let(:operand) { base }
+
+    it { should be(false) }
+  end
+end

data/spec/unit/axiom/optimizer/relation/operation/limit/equal_limit_operand/optimize_spec.rb

@@ -0,0 +1,18 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Optimizer::Relation::Operation::Limit::EqualLimitOperand, '#optimize' do
+  subject { object.optimize }
+
+  let(:order)    { Relation.new([ [ :id, Integer ] ], LazyEnumerable.new([ [ 1 ] ])).sort_by { |r| r.id } }
+  let(:limit)    { order.take(1)                                                                          }
+  let(:relation) { limit.take(1)                                                                          }
+  let(:object)   { described_class.new(relation)                                                          }
+
+  before do
+    object.should be_optimizable
+  end
+
+  it { should equal(limit) }
+end

data/spec/unit/axiom/optimizer/relation/operation/limit/limit_operand/optimizable_predicate_spec.rb

@@ -0,0 +1,27 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Optimizer::Relation::Operation::Limit::LimitOperand, '#optimizable?' do
+  subject { object.optimizable? }
+
+  let(:base)     { Relation.new([ [ :id, Integer ] ], LazyEnumerable.new([ [ 1 ] ])).sort_by { |r| r.id } }
+  let(:relation) { operand.take(1)                                                                        }
+  let(:object)   { described_class.new(relation)                                                          }
+
+  before do
+    object.operation.should be_kind_of(Relation::Operation::Limit)
+  end
+
+  context 'when the operand is limited' do
+    let(:operand) { base.take(2) }
+
+    it { should be(true) }
+  end
+
+  context 'when the operand is not limited' do
+    let(:operand) { base }
+
+    it { should be(false) }
+  end
+end

data/spec/unit/axiom/optimizer/relation/operation/limit/limit_operand/optimize_spec.rb

@@ -0,0 +1,35 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Optimizer::Relation::Operation::Limit::LimitOperand, '#optimize' do
+  subject { object.optimize }
+
+  let(:order)  { Relation.new([ [ :id, Integer ] ], LazyEnumerable.new([ [ 1 ] ])).sort_by { |r| r.id } }
+  let(:limit)  { order.take(2)                                                                          }
+  let(:object) { described_class.new(relation)                                                          }
+
+  before do
+    object.should be_optimizable
+  end
+
+  context 'when the operand has a larger limit than the operation' do
+    let(:relation) { limit.take(1) }
+
+    it { should be_kind_of(Relation::Operation::Limit) }
+
+    its(:operand) { should equal(order) }
+
+    its(:limit) { should == 1 }
+  end
+
+  context 'when the operand has a smaller limit than the operation' do
+    let(:relation) { limit.take(3) }
+
+    it { should be_kind_of(Relation::Operation::Limit) }
+
+    its(:operand) { should equal(order) }
+
+    its(:limit) { should == 2 }
+  end
+end

data/spec/unit/axiom/optimizer/relation/operation/limit/unoptimized_operand/optimizable_predicate_spec.rb

@@ -0,0 +1,28 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Optimizer::Relation::Operation::Limit::UnoptimizedOperand, '#optimizable?' do
+  subject { object.optimizable? }
+
+  let(:header)   { Relation::Header.coerce([ [ :id, Integer ] ])                            }
+  let(:base)     { Relation.new(header, LazyEnumerable.new([ [ 1 ] ])).sort_by { |r| r.id } }
+  let(:relation) { operand.take(1)                                                          }
+  let(:object)   { described_class.new(relation)                                            }
+
+  before do
+    object.operation.should be_kind_of(Relation::Operation::Limit)
+  end
+
+  context 'when the operand is optimizable' do
+    let(:operand) { base.rename({}) }
+
+    it { should be(true) }
+  end
+
+  context 'when the operand is not optimizable' do
+    let(:operand) { base }
+
+    it { should be(false) }
+  end
+end

data/spec/unit/axiom/optimizer/relation/operation/limit/unoptimized_operand/optimize_spec.rb

@@ -0,0 +1,22 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Optimizer::Relation::Operation::Limit::UnoptimizedOperand, '#optimize' do
+  subject { object.optimize }
+
+  let(:header)   { Relation::Header.coerce([ [ :id, Integer ] ])                            }
+  let(:order)    { Relation.new(header, LazyEnumerable.new([ [ 1 ] ])).sort_by { |r| r.id } }
+  let(:relation) { order.rename({}).take(1)                                                 }
+  let(:object)   { described_class.new(relation)                                            }
+
+  before do
+    object.should be_optimizable
+  end
+
+  it { should be_kind_of(Relation::Operation::Limit) }
+
+  its(:operand) { should equal(order) }
+
+  its(:limit) { should == 1 }
+end

data/spec/unit/axiom/optimizer/relation/operation/limit/zero_limit/optimizable_predicate_spec.rb

@@ -0,0 +1,27 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Optimizer::Relation::Operation::Limit::ZeroLimit, '#optimizable?' do
+  subject { object.optimizable? }
+
+  let(:base)     { Relation.new([ [ :id, Integer ] ], LazyEnumerable.new([ [ 1 ] ])).sort_by { |r| r.id } }
+  let(:relation) { base.take(limit)                                                                       }
+  let(:object)   { described_class.new(relation)                                                          }
+
+  before do
+    object.operation.should be_kind_of(Relation::Operation::Limit)
+  end
+
+  context 'when the operation limit is 0' do
+    let(:limit) { 0 }
+
+    it { should be(true) }
+  end
+
+  context 'when the operation limit is not 0' do
+    let(:limit) { 1 }
+
+    it { should be(false) }
+  end
+end

data/spec/unit/axiom/optimizer/relation/operation/limit/zero_limit/optimize_spec.rb

@@ -0,0 +1,22 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Optimizer::Relation::Operation::Limit::ZeroLimit, '#optimize' do
+  subject { object.optimize }
+
+  let(:header)   { Relation::Header.coerce([ [ :id, Integer ] ])                            }
+  let(:order)    { Relation.new(header, LazyEnumerable.new([ [ 1 ] ])).sort_by { |r| r.id } }
+  let(:relation) { order.take(0)                                                            }
+  let(:object)   { described_class.new(relation)                                            }
+
+  before do
+    object.should be_optimizable
+  end
+
+  it { should be_kind_of(Relation::Empty) }
+
+  its(:header) { should equal(header) }
+
+  its(:tuples) { should equal(relation) }
+end

data/spec/unit/axiom/optimizer/relation/operation/offset/offset_operand/optimizable_predicate_spec.rb

@@ -0,0 +1,27 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Optimizer::Relation::Operation::Offset::OffsetOperand, '#optimizable?' do
+  subject { object.optimizable? }
+
+  let(:base)     { Relation.new([ [ :id, Integer ] ], LazyEnumerable.new([ [ 1 ] ])).sort_by { |r| r.id } }
+  let(:relation) { operand.drop(1)                                                                        }
+  let(:object)   { described_class.new(relation)                                                          }
+
+  before do
+    object.operation.should be_kind_of(Relation::Operation::Offset)
+  end
+
+  context 'when the operand is an offset' do
+    let(:operand) { base.drop(1) }
+
+    it { should be(true) }
+  end
+
+  context 'when the operand is not an offset' do
+    let(:operand) { base }
+
+    it { should be(false) }
+  end
+end

data/spec/unit/axiom/optimizer/relation/operation/offset/offset_operand/optimize_spec.rb

@@ -0,0 +1,21 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Optimizer::Relation::Operation::Offset::OffsetOperand, '#optimize' do
+  subject { object.optimize }
+
+  let(:order)    { Relation.new([ [ :id, Integer ] ], LazyEnumerable.new([ [ 1 ] ])).sort_by { |r| r.id } }
+  let(:relation) { order.drop(1).drop(2)                                                                  }
+  let(:object)   { described_class.new(relation)                                                          }
+
+  before do
+    object.should be_optimizable
+  end
+
+  it { should be_kind_of(Relation::Operation::Offset) }
+
+  its(:operand) { should equal(order) }
+
+  its(:offset) { should == 3 }
+end

data/spec/unit/axiom/optimizer/relation/operation/offset/unoptimized_operand/optimizable_predicate_spec.rb

@@ -0,0 +1,28 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Optimizer::Relation::Operation::Offset::UnoptimizedOperand, '#optimizable?' do
+  subject { object.optimizable? }
+
+  let(:header)   { Relation::Header.coerce([ [ :id, Integer ] ])                            }
+  let(:base)     { Relation.new(header, LazyEnumerable.new([ [ 1 ] ])).sort_by { |r| r.id } }
+  let(:relation) { operand.drop(1)                                                          }
+  let(:object)   { described_class.new(relation)                                            }
+
+  before do
+    object.operation.should be_kind_of(Relation::Operation::Offset)
+  end
+
+  context 'when the operand is optimizable' do
+    let(:operand) { base.rename({}) }
+
+    it { should be(true) }
+  end
+
+  context 'when the operand is not optimizable' do
+    let(:operand) { base }
+
+    it { should be(false) }
+  end
+end

data/spec/unit/axiom/optimizer/relation/operation/offset/unoptimized_operand/optimize_spec.rb

@@ -0,0 +1,22 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Optimizer::Relation::Operation::Offset::UnoptimizedOperand, '#optimize' do
+  subject { object.optimize }
+
+  let(:header)   { Relation::Header.coerce([ [ :id, Integer ] ])                            }
+  let(:order)    { Relation.new(header, LazyEnumerable.new([ [ 1 ] ])).sort_by { |r| r.id } }
+  let(:relation) { order.rename({}).drop(1)                                                 }
+  let(:object)   { described_class.new(relation)                                            }
+
+  before do
+    object.should be_optimizable
+  end
+
+  it { should be_kind_of(Relation::Operation::Offset) }
+
+  its(:operand) { should equal(order) }
+
+  its(:offset) { should == 1 }
+end

data/spec/unit/axiom/optimizer/relation/operation/offset/zero_offset/optimizable_predicate_spec.rb

@@ -0,0 +1,27 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Optimizer::Relation::Operation::Offset::ZeroOffset, '#optimizable?' do
+  subject { object.optimizable? }
+
+  let(:base)     { Relation.new([ [ :id, Integer ] ], LazyEnumerable.new([ [ 1 ] ])).sort_by { |r| r.id } }
+  let(:relation) { base.drop(offset)                                                                      }
+  let(:object)   { described_class.new(relation)                                                          }
+
+  before do
+    object.operation.should be_kind_of(Relation::Operation::Offset)
+  end
+
+  context 'when the operation offset is 0' do
+    let(:offset) { 0 }
+
+    it { should be(true) }
+  end
+
+  context 'when the operation offset is not 0' do
+    let(:offset) { 1 }
+
+    it { should be(false) }
+  end
+end