veritas-optimizer 0.0.3

data/spec/unit/veritas/optimizer/logic/predicate/util/class_methods/min_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe Optimizer::Logic::Predicate::Util, '.min' do
+  subject { object.min(operand) }
+
+  let(:object) { Optimizer::Logic::Predicate::Util }
+
+  context 'with an attribute' do
+    let(:operand) { Attribute::Integer.new(:id, :size => 1..10) }
+
+    it { should == 1 }
+  end
+
+  context 'with a constant' do
+    let(:operand) { 1 }
+
+    it { should == 1 }
+  end
+end

data/spec/unit/veritas/optimizer/operation_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe Optimizer, '#operation' do
+  subject { object.operation }
+
+  let(:described_class) { Class.new(Optimizer)           }
+  let(:operation)       { mock('Operation')              }
+  let(:object)          { described_class.new(operation) }
+
+  it { should equal(operation) }
+end

data/spec/unit/veritas/optimizer/optimizable/class_methods/optimizer_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+describe Optimizer::Optimizable::ClassMethods, '#optimizer' do
+  subject { object.optimizer }
+
+  let(:object) { Class.new { include Optimizer::Optimizable, Immutable } }
+
+  context 'when the optimizer is not set' do
+    it { should be_nil }
+  end
+
+  context 'when the optimizer is set' do
+    let(:optimizer) { mock('Optimizer') }
+
+    before do
+      object.optimizer = optimizer
+    end
+
+    it { should equal(optimizer) }
+  end
+end
+
+describe Optimizer::Optimizable::ClassMethods, '#optimizer=' do
+  subject { object.optimizer = optimizer }
+
+  let(:optimizer) { mock('Optimizer')                                       }
+  let(:object)    { Class.new { include Optimizer::Optimizable, Immutable } }
+
+  it 'sets the optimizer' do
+    expect { subject }.to change { object.optimizer }.from(nil).to(optimizer)
+  end
+end

data/spec/unit/veritas/optimizer/optimizable/optimize_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+describe Optimizer::Optimizable, '#optimize' do
+  subject { object.optimize }
+
+  let(:described_class) { Class.new { include Optimizer::Optimizable, Immutable } }
+  let(:object)          { described_class.new                                     }
+
+  context 'when there is no optimizer for the class' do
+    it { should equal(object) }
+
+    it_should_behave_like 'an optimize method'
+  end
+
+  context 'when there is an optimizer for the class' do
+    let(:optimized) { mock('Optimized')                     }
+    let(:optimizer) { mock('Optimizer', :call => optimized) }
+
+    before do
+      described_class.optimizer = optimizer
+      optimized.stub!(:optimize).and_return(optimized)
+    end
+
+    it { should equal(optimized) }
+
+    it 'calls the optimizer with the object' do
+      optimizer.should_receive(:call).with(object).and_return(optimized)
+      should equal(optimized)
+    end
+
+    it '#optimize the optimized object' do
+      optimized.should_receive(:optimize).with(no_args).and_return(optimized)
+      should equal(optimized)
+    end
+  end
+end

data/spec/unit/veritas/optimizer/optimizable_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe Optimizer, '#optimizable?' do
+  subject { object.optimizable? }
+
+  let(:described_class) { Class.new(Optimizer)           }
+  let(:operation)       { mock('Operation')              }
+  let(:object)          { described_class.new(operation) }
+
+  before do
+    described_class.stub!(:to_s).and_return('Optimizer')
+  end
+
+  specify { expect { subject }.to raise_error(NotImplementedError, 'Optimizer#optimizable? must be implemented') }
+end

data/spec/unit/veritas/optimizer/optimize_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe Optimizer, '#optimize' do
+  subject { object.optimize }
+
+  let(:described_class) { Class.new(Optimizer)           }
+  let(:operation)       { mock('Operation')              }
+  let(:object)          { described_class.new(operation) }
+
+  before do
+    described_class.stub!(:to_s).and_return('Optimizer')
+  end
+
+  specify { expect { subject }.to raise_error(NotImplementedError, 'Optimizer#optimize must be implemented') }
+end

data/spec/unit/veritas/optimizer/relation/materialized/empty_operand/optimizable_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe Optimizer::Relation::Materialized::EmptyOperand, '#optimizable?' do
+  subject { object.optimizable? }
+
+  let(:relation) { Relation.new([ [ :id, Integer ] ], body) }
+  let(:object)   { described_class.new(relation)            }
+
+  context 'with a body containing no entries' do
+    let(:body) { [] }
+
+    it { should be(true) }
+  end
+
+  context 'with a body containing an entry' do
+    let(:body) { [ [ 1 ] ] }
+
+    it { should be(false) }
+  end
+end

data/spec/unit/veritas/optimizer/relation/materialized/empty_operand/optimize_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe Optimizer::Relation::Materialized::EmptyOperand, '#optimize' do
+  subject { object.optimize }
+
+  let(:header)   { Relation::Header.new([ [ :id, Integer ] ]) }
+  let(:relation) { Relation.new(header, [].each)              }
+  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) }
+end

data/spec/unit/veritas/optimizer/relation/operation/binary/empty_left/optimizable_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+describe Optimizer::Relation::Operation::Binary::EmptyLeft, '#optimizable?' do
+  subject { object.optimizable? }
+
+  let(:described_class) { Class.new(Optimizer::Relation::Operation::Binary) }
+  let(:relation)        { mock('Relation', :left => left, :right => right)  }
+  let(:right)           { mock('Right')                                     }
+  let(:object)          { described_class.new(relation)                     }
+
+  before do
+    described_class.class_eval { include superclass::EmptyLeft }
+  end
+
+  before do
+    right.stub!(:optimize).and_return(right)
+  end
+
+  context 'when left is empty' do
+    let(:left) { Relation::Empty.new([ [ :id, Integer ] ]) }
+
+    it { should be(true) }
+  end
+
+  context 'when left is not empty' do
+    let(:left) { Relation.new([ [ :id, Integer ] ], [ [ 1 ] ]) }
+
+    it { should be(false) }
+  end
+end

data/spec/unit/veritas/optimizer/relation/operation/binary/empty_right/optimizable_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+describe Optimizer::Relation::Operation::Binary::EmptyRight, '#optimizable?' do
+  subject { object.optimizable? }
+
+  let(:described_class) { Class.new(Optimizer::Relation::Operation::Binary) }
+  let(:relation)        { mock('Relation', :left => left, :right => right)  }
+  let(:left)            { mock('Left')                                      }
+  let(:object)          { described_class.new(relation)                     }
+
+  before do
+    described_class.class_eval { include superclass::EmptyRight }
+  end
+
+  before do
+    left.stub!(:optimize).and_return(left)
+  end
+
+  context 'when right is empty' do
+    let(:right) { Relation::Empty.new([ [ :id, Integer ] ]) }
+
+    it { should be(true) }
+  end
+
+  context 'when right is not empty' do
+    let(:right) { Relation.new([ [ :id, Integer ] ], [ [ 1 ] ]) }
+
+    it { should be(false) }
+  end
+end

data/spec/unit/veritas/optimizer/relation/operation/binary/equal_operands/optimizable_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+describe Optimizer::Relation::Operation::Binary::EqualOperands, '#optimizable?' do
+  subject { object.optimizable? }
+
+  let(:described_class)  { Class.new(Optimizer::Relation::Operation::Binary) }
+  let(:relation)         { mock('Relation', :left => left, :right => right)  }
+  let(:materialized)     { mock('Materialized')                              }
+  let(:not_materialized) { mock('Not Materialized')                          }
+  let(:object)           { described_class.new(relation)                     }
+
+  before do
+    described_class.class_eval { include superclass::EqualOperands }
+  end
+
+  before do
+    left.stub!(:optimize).and_return(left)
+    right.stub!(:optimize).and_return(right)
+  end
+
+  context 'when left and right are equal' do
+    let(:left)  { not_materialized }
+    let(:right) { not_materialized }
+
+    it { should be(true) }
+  end
+
+  context 'when left and right are not equal' do
+    let(:left)  { not_materialized }
+    let(:right) { materialized     }
+
+    it { should be(false) }
+  end
+end

data/spec/unit/veritas/optimizer/relation/operation/binary/left_spec.rb

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

data/spec/unit/veritas/optimizer/relation/operation/binary/materialized_operand/optimizable_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+describe Optimizer::Relation::Operation::Binary::MaterializedOperand, '#optimizable?' do
+  subject { object.optimizable? }
+
+  let(:materialized)     { Relation::Materialized.new([ [ :id, Integer ] ], [ [ 1 ] ]) }
+  let(:not_materialized) { Relation.new([ [ :id, Integer ] ], [ [ 1 ] ].each)          }
+  let(:left)             { not_materialized                                            }
+  let(:right)            { not_materialized                                            }
+  let(:relation)         { left.union(right)                                           }
+  let(:object)           { described_class.new(relation)                               }
+
+  context 'when the right and right are materialized' do
+    let(:left)  { materialized }
+    let(:right) { materialized }
+
+    it { should be(true) }
+  end
+
+  context 'when the left is materialized' do
+    let(:left) { materialized }
+
+    it { should be(false) }
+  end
+
+  context 'when the right is materialized' do
+    let(:right) { materialized }
+
+    it { should be(false) }
+  end
+
+  context 'when the left and right are not materialized' do
+    it { should be(false) }
+  end
+end

data/spec/unit/veritas/optimizer/relation/operation/binary/materialized_operand/optimize_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe Optimizer::Relation::Operation::Binary::MaterializedOperand, '#optimize' do
+  subject { object.optimize }
+
+  let(:left)     { Relation.new([ [ :id, Integer ] ], [ [ 1 ] ]) }
+  let(:right)    { Relation.new([ [ :id, Integer ] ], [ [ 1 ] ]) }
+  let(:relation) { left.union(right)                             }
+  let(:object)   { described_class.new(relation)                 }
+
+  before do
+    object.should be_optimizable
+  end
+
+  it { should be_kind_of(Relation::Materialized) }
+
+  its(:header) { should equal(relation.header) }
+
+  it { should == [ [ 1 ] ] }
+end

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

@@ -0,0 +1,17 @@
+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)                    }
+
+  before do
+    left.stub!(:optimize).and_return(left)
+  end
+
+  it { should equal(optimized) }
+end

data/spec/unit/veritas/optimizer/relation/operation/binary/unoptimized_operand/optimizable_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+describe Optimizer::Relation::Operation::Binary::UnoptimizedOperand, '#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/veritas/optimizer/relation/operation/binary/unoptimized_operand/optimize_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe Optimizer::Relation::Operation::Binary::UnoptimizedOperand, '#optimize' do
+  subject { object.optimize }
+
+  let(:left)     { Relation.new([ [ :id, Integer ] ], [ [ 1 ] ].each) }
+  let(:right)    { Relation.new([ [ :id, Integer ] ], [ [ 2 ] ].each) }
+  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/veritas/optimizer/relation/operation/combination/optimize_spec.rb

@@ -0,0 +1,14 @@
+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) }
+end

data/spec/unit/veritas/optimizer/relation/operation/limit/equal_limit_operand/optimizable_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe Optimizer::Relation::Operation::Limit::EqualLimitOperand, '#optimizable?' do
+  subject { object.optimizable? }
+
+  let(:base)     { Relation.new([ [ :id, Integer ] ], [ [ 1 ] ].each).order }
+  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/veritas/optimizer/relation/operation/limit/equal_limit_operand/optimize_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe Optimizer::Relation::Operation::Limit::EqualLimitOperand, '#optimize' do
+  subject { object.optimize }
+
+  let(:order)    { Relation.new([ [ :id, Integer ] ], [ [ 1 ] ].each).order }
+  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/veritas/optimizer/relation/operation/limit/limit_operand/optimizable_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe Optimizer::Relation::Operation::Limit::LimitOperand, '#optimizable?' do
+  subject { object.optimizable? }
+
+  let(:base)     { Relation.new([ [ :id, Integer ] ], [ [ 1 ] ].each).order }
+  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/veritas/optimizer/relation/operation/limit/limit_operand/optimize_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+describe Optimizer::Relation::Operation::Limit::LimitOperand, '#optimize' do
+  subject { object.optimize }
+
+  let(:order)  { Relation.new([ [ :id, Integer ] ], [ [ 1 ] ].each).order }
+  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/veritas/optimizer/relation/operation/limit/unoptimized_operand/optimizable_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+describe Optimizer::Relation::Operation::Limit::UnoptimizedOperand, '#optimizable?' do
+  subject { object.optimizable? }
+
+  let(:header)   { Relation::Header.new([ [ :id, Integer ] ]) }
+  let(:base)     { Relation.new(header, [ [ 1 ] ].each).order }
+  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/veritas/optimizer/relation/operation/limit/unoptimized_operand/optimize_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe Optimizer::Relation::Operation::Limit::UnoptimizedOperand, '#optimize' do
+  subject { object.optimize }
+
+  let(:header)   { Relation::Header.new([ [ :id, Integer ] ]) }
+  let(:order)    { Relation.new(header, [ [ 1 ] ].each).order }
+  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/veritas/optimizer/relation/operation/limit/zero_limit/optimizable_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe Optimizer::Relation::Operation::Limit::ZeroLimit, '#optimizable?' do
+  subject { object.optimizable? }
+
+  let(:base)     { Relation.new([ [ :id, Integer ] ], [ [ 1 ] ].each).order }
+  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/veritas/optimizer/relation/operation/limit/zero_limit/optimize_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+describe Optimizer::Relation::Operation::Limit::ZeroLimit, '#optimize' do
+  subject { object.optimize }
+
+  let(:header)   { Relation::Header.new([ [ :id, Integer ] ]) }
+  let(:order)    { Relation.new(header, [ [ 1 ] ].each).order }
+  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) }
+end

data/spec/unit/veritas/optimizer/relation/operation/offset/offset_operand/optimizable_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe Optimizer::Relation::Operation::Offset::OffsetOperand, '#optimizable?' do
+  subject { object.optimizable? }
+
+  let(:base)     { Relation.new([ [ :id, Integer ] ], [ [ 1 ] ].each).order }
+  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