axiom-optimizer 0.1.0

data/spec/unit/axiom/optimizer/algebra/summarization/summarize_per_spec.rb

@@ -0,0 +1,29 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Optimizer::Algebra::Summarization, '#summarize_per' do
+  subject { object.summarize_per }
+
+  let(:base)     { Relation.new([ [ :id, Integer ] ], [ [ 1 ] ]) }
+  let(:relation) { base.summarize(summarize_per) {}              }
+  let(:object)   { described_class.new(relation)                 }
+
+  before do
+    object.operation.should be_kind_of(Algebra::Summarization)
+  end
+
+  context 'when summarize_per is optimized' do
+    let(:summarize_per) { TABLE_DEE }
+
+    it { should equal(summarize_per) }
+  end
+
+  context 'when summarize_per is not not optimized' do
+   let(:summarize_per) { TABLE_DEE.rename({}) }
+
+    it { should_not equal(summarize_per) }
+
+    it { should equal(TABLE_DEE) }
+  end
+end

data/spec/unit/axiom/optimizer/algebra/summarization/summarizers_spec.rb

@@ -0,0 +1,31 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Optimizer::Algebra::Summarization, '#summarizers' do
+  subject { object.summarizers }
+
+  let(:base)          { Relation.new([ [ :id, Integer ] ], [ [ 1 ] ])                    }
+  let(:attribute)     { Attribute::Object.new(:test)                                     }
+  let(:summarize_per) { TABLE_DEE                                                        }
+  let(:relation)      { base.summarize(summarize_per) { |r| r.add(attribute, function) } }
+  let(:object)        { described_class.new(relation)                                    }
+
+  before do
+    object.operation.should be_kind_of(Algebra::Summarization)
+  end
+
+  context 'when summarizers are optimized' do
+    let(:function) { base[:id].sum }
+
+    it { should eql(relation.summarizers) }
+  end
+
+  context 'when summarizers are not optimized' do
+    let(:function) { Aggregate::Sum.new(Function::Numeric::Absolute.new(1)) }
+
+    it { should_not equal(relation.summarizers) }
+
+    it { should eql(attribute => Aggregate::Sum.new(1)) }
+  end
+end

data/spec/unit/axiom/optimizer/algebra/summarization/unoptimized_operand/optimizable_predicate_spec.rb

@@ -0,0 +1,49 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Optimizer::Algebra::Summarization::UnoptimizedOperand, '#optimizable?' do
+  subject { object.optimizable? }
+
+  let(:header)    { Relation::Header.coerce([ [ :id, Integer ], [ :name, String ] ])    }
+  let(:base)      { Relation.new(header, LazyEnumerable.new([ [ 1, 'Dan Kubb' ] ]))     }
+  let(:attribute) { Attribute::Object.new(:test)                                        }
+  let(:relation)  { operand.summarize(summarize_per) { |r| r.add(attribute, function) } }
+  let(:object)    { described_class.new(relation)                                       }
+
+  before do
+    object.operation.should be_kind_of(Algebra::Summarization)
+  end
+
+  context 'when the operand is optimizable' do
+    let(:operand)       { base.rename({})       }
+    let(:summarize_per) { TABLE_DEE             }
+    let(:function)      { Aggregate::Sum.new(1) }
+
+    it { should be(true) }
+  end
+
+  context 'when summarize_per is optimizable' do
+    let(:operand)       { base                  }
+    let(:summarize_per) { TABLE_DEE.rename({})  }
+    let(:function)      { Aggregate::Sum.new(1) }
+
+    it { should be(true) }
+  end
+
+  context 'when summarizers are optimizable' do
+    let(:operand)       { base                                                   }
+    let(:summarize_per) { TABLE_DEE.rename({})                                   }
+    let(:function)      { Aggregate::Sum.new(Function::Numeric::Absolute.new(1)) }
+
+    it { should be(true) }
+  end
+
+  context 'when the operand, summarize_per and summarizers are not optimizable' do
+    let(:operand)       { base                  }
+    let(:summarize_per) { TABLE_DEE             }
+    let(:function)      { Aggregate::Sum.new(1) }
+
+    it { should be(false) }
+  end
+end

data/spec/unit/axiom/optimizer/algebra/summarization/unoptimized_operand/optimize_spec.rb

@@ -0,0 +1,30 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Optimizer::Algebra::Summarization::UnoptimizedOperand, '#optimize' do
+  subject { object.optimize }
+
+  let(:header)        { Relation::Header.coerce([ [ :id, Integer ] ])                       }
+  let(:base)          { Relation.new(header, LazyEnumerable.new([ [ 1 ] ]))                 }
+  let(:attribute)     { Attribute::Object.new(:text)                                        }
+  let(:function)      { Aggregate::Sum.new(Function::Numeric::Absolute.new(1))              }
+  let(:operand)       { base.rename({})                                                     }
+  let(:summarize_per) { TABLE_DEE.project([])                                               }
+  let(:relation)      { operand.summarize(summarize_per) { |r| r.add(attribute, function) } }
+  let(:object)        { described_class.new(relation)                                       }
+
+  before do
+    object.should be_optimizable
+  end
+
+  it { should be_kind_of(Algebra::Summarization) }
+
+  it { should_not equal(operand) }
+
+  its(:operand) { should equal(base) }
+
+  its(:summarize_per) { should equal(TABLE_DEE) }
+
+  its(:summarizers) { should == { attribute => Aggregate::Sum.new(1) } }
+end

data/spec/unit/axiom/optimizer/algebra/union/empty_left/optimize_spec.rb

@@ -0,0 +1,19 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Optimizer::Algebra::Union::EmptyLeft, '#optimize' do
+  subject { object.optimize }
+
+  let(:header)   { Relation::Header.coerce([ [ :id, Integer ] ])       }
+  let(:left)     { Relation::Empty.new(header)                         }
+  let(:right)    { Relation.new(header, LazyEnumerable.new([ [ 2 ] ])) }
+  let(:relation) { left.union(right)                                   }
+  let(:object)   { described_class.new(relation)                       }
+
+  before do
+    object.should be_optimizable
+  end
+
+  it { should equal(right) }
+end

data/spec/unit/axiom/optimizer/algebra/union/empty_right/optimize_spec.rb

@@ -0,0 +1,19 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Optimizer::Algebra::Union::EmptyRight, '#optimize' do
+  subject { object.optimize }
+
+  let(:header)   { Relation::Header.coerce([ [ :id, Integer ] ])       }
+  let(:left)     { Relation.new(header, LazyEnumerable.new([ [ 1 ] ])) }
+  let(:right)    { Relation::Empty.new(header)                         }
+  let(:relation) { left.union(right)                                   }
+  let(:object)   { described_class.new(relation)                       }
+
+  before do
+    object.should be_optimizable
+  end
+
+  it { should equal(left) }
+end

data/spec/unit/axiom/optimizer/algebra/union/equal_operands/optimize_spec.rb

@@ -0,0 +1,19 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Optimizer::Algebra::Union::EqualOperands, '#optimize' do
+  subject { object.optimize }
+
+  let(:header)   { Relation::Header.coerce([ [ :id, Integer ] ])       }
+  let(:left)     { Relation.new(header, LazyEnumerable.new([ [ 1 ] ])) }
+  let(:right)    { Relation.new(header, LazyEnumerable.new([ [ 1 ] ])) }
+  let(:relation) { left.union(right)                                   }
+  let(:object)   { described_class.new(relation)                       }
+
+  before do
+    object.should be_optimizable
+  end
+
+  it { should equal(left) }
+end

data/spec/unit/axiom/optimizer/class_methods/chain_spec.rb

@@ -0,0 +1,56 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Optimizer, '.chain' do
+  let(:operation)       { mock('Operation')    }
+  let(:object)          { Optimizer            }
+  let(:identity)        { object::Identity     }
+  let(:optimizer_class) { Class.new(Optimizer) }
+
+  context 'with no optimizers' do
+    subject { object.chain }
+
+    it { should equal(identity) }
+
+    it 'returns a block that returns the operation' do
+      subject.call(operation).should equal(operation)
+    end
+  end
+
+  context 'with an optimizer that can optimize the operation' do
+    subject { object.chain(optimizer_class) }
+
+    let(:optimized) { mock('Optimized') }
+
+    before do
+      optimized = self.optimized
+      optimizer_class.send(:define_method, :optimizable?) { true      }
+      optimizer_class.send(:define_method, :optimize)     { optimized }
+    end
+
+    it { should_not equal(identity) }
+
+    it { should be_kind_of(Proc) }
+
+    it 'returns a block that optimizes the operation' do
+      subject.call(operation).should equal(optimized)
+    end
+  end
+
+  context 'with an optimizer that cannot optimize the operation' do
+    subject { object.chain(optimizer_class) }
+
+    before do
+      optimizer_class.send(:define_method, :optimizable?) { false }
+    end
+
+    it { should_not equal(identity) }
+
+    it { should be_kind_of(Proc) }
+
+    it 'returns a block that calls the successor (Identity) with the operation' do
+      subject.call(operation).should equal(operation)
+    end
+  end
+end

data/spec/unit/axiom/optimizer/function/binary/constant_operands/optimizable_predicate_spec.rb

@@ -0,0 +1,36 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Optimizer::Function::Binary::ConstantOperands, '#optimizable?' do
+  subject { object.optimizable? }
+
+  let(:described_class) { Class.new(Optimizer) { include Optimizer::Function::Binary }       }
+  let(:function)        { Class.new(Function)  { include Function::Binary }.new(left, right) }
+  let(:object)          { described_class.new(function)                                      }
+
+  before do
+    described_class.class_eval { include Optimizer::Function::Binary::ConstantOperands }
+  end
+
+  context 'when left and right are constants' do
+    let(:left)  { 1 }
+    let(:right) { 1 }
+
+    it { should be(true) }
+  end
+
+  context 'when left is a constant, and right is not a constant' do
+    let(:left)  { 1       }
+    let(:right) { proc {} }
+
+    it { should be(false) }
+  end
+
+  context 'when left is not a constant, and right is a constant' do
+    let(:left)  { proc {} }
+    let(:right) { 1       }
+
+    it { should be(false) }
+  end
+end

data/spec/unit/axiom/optimizer/function/binary/constant_operands/optimize_spec.rb

@@ -0,0 +1,18 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Optimizer::Function::Binary::ConstantOperands, '#optimize' do
+  subject { object.optimize }
+
+  let(:described_class) { Class.new(Optimizer) { include Optimizer::Function::Binary } }
+  let(:function)        { Function::Numeric::Addition.new(2, 2)                        }
+  let(:object)          { described_class.new(function)                                }
+
+  before do
+    described_class.class_eval { include Optimizer::Function::Binary::ConstantOperands }
+    object.should be_optimizable
+  end
+
+  it { should be(4) }
+end

data/spec/unit/axiom/optimizer/function/binary/left_spec.rb

@@ -0,0 +1,28 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Optimizer::Function::Binary, '#left' do
+  subject { object.left }
+
+  let(:described_class) { Class.new(Optimizer) { include Optimizer::Function::Binary }      }
+  let(:right)           { 'Right'                                                           }
+  let(:function)        { Class.new(Function) { include Function::Binary }.new(left, right) }
+  let(:object)          { described_class.new(function)                                     }
+
+  context 'when left operand is frozen' do
+    let(:left) { 'Left'.freeze }
+
+    it { should equal(left) }
+  end
+
+  context 'when left operand is not frozen' do
+    let(:left) { 'Left' }
+
+    it { should_not equal(left) }
+
+    it { should be_frozen }
+
+    it { should == left }
+  end
+end

data/spec/unit/axiom/optimizer/function/binary/right_spec.rb

@@ -0,0 +1,28 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Optimizer::Function::Binary, '#right' do
+  subject { object.right }
+
+  let(:described_class) { Class.new(Optimizer) { include Optimizer::Function::Binary }      }
+  let(:left)            { 'Left'                                                            }
+  let(:function)        { Class.new(Function) { include Function::Binary }.new(left, right) }
+  let(:object)          { described_class.new(function)                                     }
+
+  context 'when right operand is frozen' do
+    let(:right) { 'Right'.freeze }
+
+    it { should equal(right) }
+  end
+
+  context 'when right operand is not frozen' do
+    let(:right) { 'Right' }
+
+    it { should_not equal(right) }
+
+    it { should be_frozen }
+
+    it { should == right }
+  end
+end

data/spec/unit/axiom/optimizer/function/binary/unoptimized_operands/optimizable_predicate_spec.rb

@@ -0,0 +1,37 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Optimizer::Function::Binary::UnoptimizedOperands, '#optimizable?' do
+  subject { object.optimizable? }
+
+  let(:attribute)       { Attribute::Integer.new(:id)                                       }
+  let(:described_class) { Class.new(Optimizer) { include Optimizer::Function::Binary }      }
+  let(:function)        { Class.new(Function) { include Function::Binary }.new(left, right) }
+  let(:object)          { described_class.new(function)                                     }
+
+  before do
+    described_class.class_eval { include Optimizer::Function::Binary::UnoptimizedOperands }
+  end
+
+  context 'when left is optimizable' do
+    let(:left)  { attribute.include([ 1 ]) }
+    let(:right) { attribute.ne(2)          }
+
+    it { should be(true) }
+  end
+
+  context 'when right is optimizable' do
+    let(:left)  { attribute.eq(1)          }
+    let(:right) { attribute.exclude([ 2 ]) }
+
+    it { should be(true) }
+  end
+
+  context 'when left and right are not optimizable' do
+    let(:left)  { attribute.eq(1) }
+    let(:right) { attribute.ne(2) }
+
+    it { should be(false) }
+  end
+end

data/spec/unit/axiom/optimizer/function/binary/unoptimized_operands/optimize_spec.rb

@@ -0,0 +1,23 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Optimizer::Function::Binary::UnoptimizedOperands, '#optimize' do
+  subject { object.optimize }
+
+  let(:described_class) { Class.new(Optimizer) { include Optimizer::Function::Binary }      }
+  let(:attribute)       { Attribute::Integer.new(:id)                                       }
+  let(:left)            { attribute.include([ 1 ])                                          }
+  let(:right)           { attribute.exclude([ 2 ])                                          }
+  let(:function)        { Class.new(Function) { include Function::Binary }.new(left, right) }
+  let(:object)          { described_class.new(function)                                     }
+
+  before do
+    described_class.class_eval { include Optimizer::Function::Binary::UnoptimizedOperands }
+    object.should be_optimizable
+  end
+
+  its(:left) { should eql(attribute.eq(1)) }
+
+  its(:right) { should eql(attribute.ne(2)) }
+end