veritas-optimizer 0.0.3

data/spec/unit/veritas/optimizer/algebra/rename/unchanged_header/optimizable_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+describe Optimizer::Algebra::Rename::UnchangedHeader, '#optimizable?' do
+  subject { object.optimizable? }
+
+  let(:header)   { Relation::Header.new([ [ :id, Integer ], [ :name, String ] ]) }
+  let(:base)     { Relation.new(header, [ [ 1, 'Dan Kubb' ] ].each)              }
+  let(:relation) { base.rename(new_aliases)                                      }
+  let(:object)   { described_class.new(relation)                                 }
+
+  before do
+    object.operation.should be_kind_of(Algebra::Rename)
+  end
+
+  context 'when the header is not changed' do
+    let(:new_aliases) { {} }
+
+    it { should be(true) }
+  end
+
+  context 'when the header is changed' do
+    let(:new_aliases) { { :id => :other_id } }
+
+    it { should be(false) }
+  end
+end

data/spec/unit/veritas/optimizer/algebra/rename/unchanged_header/optimize_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe Optimizer::Algebra::Rename::UnchangedHeader, '#optimize' do
+  subject { object.optimize }
+
+  let(:header)   { Relation::Header.new([ [ :id, Integer ], [ :name, String ] ]) }
+  let(:base)     { Relation.new(header, [ [ 1, 'Dan Kubb' ] ].each)              }
+  let(:relation) { base.rename({})                                               }
+  let(:object)   { described_class.new(relation)                                 }
+
+  before do
+    object.should be_optimizable
+  end
+
+  it { should equal(base) }
+end

data/spec/unit/veritas/optimizer/algebra/rename/unoptimized_operand/optimizable_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+describe Optimizer::Algebra::Rename::UnoptimizedOperand, '#optimizable?' do
+  subject { object.optimizable? }
+
+  let(:header)   { Relation::Header.new([ [ :id, Integer ] ]) }
+  let(:base)     { Relation.new(header, [ [ 1 ] ].each)       }
+  let(:relation) { operand.rename(aliases)                    }
+  let(:object)   { described_class.new(relation)              }
+
+  before do
+    object.operation.should be_kind_of(Algebra::Rename)
+  end
+
+  context 'when the operand and aliases are optimizable' do
+    let(:aliases) { { :other_id => :another_id }                  }
+    let(:operand) { base.project(header).rename(:id => :other_id) }
+
+    it { should be(true) }
+  end
+
+  context 'when the operand is optimizable, but the aliases are not optimizable' do
+    let(:aliases) { { :id => :other_id } }
+    let(:operand) { base.project(header) }
+
+    it { should be(true) }
+  end
+
+  context 'when the operand is not optimizable, but the aliases are optimizable' do
+    let(:aliases) { { :other_id => :another_id }  }
+    let(:operand) { base.rename(:id => :other_id) }
+
+    it { should be(true) }
+  end
+
+  context 'when the operand and aliases are not optimizable' do
+    let(:aliases) { { :id => :other_id } }
+    let(:operand) { base                 }
+
+    it { should be(false) }
+  end
+end

data/spec/unit/veritas/optimizer/algebra/rename/unoptimized_operand/optimize_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+describe Optimizer::Algebra::Rename::UnoptimizedOperand, '#optimize' do
+  subject { object.optimize }
+
+  let(:base)     { Relation.new([ [ :id, Integer ] ], [ [ 1 ] ].each) }
+  let(:relation) { base.rename({}).rename(:id => :other_id)           }
+  let(:object)   { described_class.new(relation)                      }
+
+  before do
+    object.should be_optimizable
+  end
+
+  it { should be_kind_of(Algebra::Rename) }
+
+  it { should_not equal(relation) }
+
+  its(:operand) { should equal(base) }
+
+  its(:aliases) { should equal(relation.aliases) }
+end

data/spec/unit/veritas/optimizer/algebra/restriction/class_methods/optimize_predicate_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe Optimizer::Algebra::Restriction, '.optimize_predicate' do
+  subject { object.optimize_predicate(predicate) }
+
+  let(:attribute) { Attribute::Integer.new(:id)     }
+  let(:predicate) { attribute.eq(1)                 }
+  let(:object)    { Optimizer::Algebra::Restriction }
+
+  context 'when the predicate is optimizable' do
+    let(:predicate) { Logic::Connective::Negation.new(attribute.eq(1)) }
+
+    it { should be_kind_of(Logic::Predicate::Inequality) }
+
+    its(:left) { should equal(attribute) }
+
+    its(:right) { should == 1 }
+  end
+
+  context 'when the predicate is optimizable, but already optimized' do
+    let(:predicate) { attribute.eq(1) }
+
+    it { should equal(predicate) }
+  end
+
+  context 'when the predicate is not optimizable' do
+    let(:predicate) { lambda { |tuple| tuple[:id] == 1 } }
+
+    it { should equal(predicate) }
+  end
+end

data/spec/unit/veritas/optimizer/algebra/restriction/contradiction/optimizable_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+describe Optimizer::Algebra::Restriction::Contradiction, '#optimizable?' do
+  subject { object.optimizable? }
+
+  let(:header)   { Relation::Header.new([ [ :id, Integer ] ]) }
+  let(:base)     { Relation.new(header, [ [ 1 ] ].each)       }
+  let(:relation) { base.restrict(predicate)                   }
+  let(:object)   { described_class.new(relation)              }
+
+  before do
+    object.operation.should be_kind_of(Algebra::Restriction)
+  end
+
+  context 'when the predicate is a contradiction' do
+    let(:predicate) { Logic::Proposition::Contradiction.instance }
+
+    it { should be(true) }
+  end
+
+  context 'when the predicate is not a contradiction' do
+    let(:predicate) { Logic::Proposition::Tautology.instance }
+
+    it { should be(false) }
+  end
+end

data/spec/unit/veritas/optimizer/algebra/restriction/contradiction/optimize_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe Optimizer::Algebra::Restriction::Contradiction, '#optimize' do
+  subject { object.optimize }
+
+  let(:header)    { Relation::Header.new([ [ :id, Integer ] ]) }
+  let(:base)      { Relation.new(header, [ [ 1 ] ].each)       }
+  let(:predicate) { Logic::Proposition::Contradiction.instance }
+  let(:relation)  { base.restrict(predicate)                   }
+  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/algebra/restriction/order_operand/optimizable_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+describe Optimizer::Algebra::Restriction::OrderOperand, '#optimizable?' do
+  subject { object.optimizable? }
+
+  let(:base)      { Relation.new([ [ :id, Integer ] ], [ [ 1 ] ].each) }
+  let(:predicate) { base[:id].eq(1)                                    }
+  let(:relation)  { operand.restrict(predicate)                        }
+  let(:object)    { described_class.new(relation)                      }
+
+  before do
+    object.operation.should be_kind_of(Algebra::Restriction)
+  end
+
+  context 'when the operand is an order operation' do
+    let(:operand) { base.order }
+
+    it { should be(true) }
+  end
+
+  context 'when the operand is not an order operation' do
+    let(:operand) { base }
+
+    it { should be(false) }
+  end
+end

data/spec/unit/veritas/optimizer/algebra/restriction/order_operand/optimize_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+describe Optimizer::Algebra::Restriction::OrderOperand, '#optimize' do
+  subject { object.optimize }
+
+  let(:base)      { Relation.new([ [ :id, Integer ] ], [ [ 1 ] ].each) }
+  let(:predicate) { base[:id].eq(1)                                    }
+  let(:relation)  { base.order.restrict(predicate)                     }
+  let(:object)    { described_class.new(relation)                      }
+
+  before do
+    object.should be_optimizable
+  end
+
+  it { should be_kind_of(Relation::Operation::Order) }
+
+  its(:operand) { should eql(base.restrict(predicate)) }
+end

data/spec/unit/veritas/optimizer/algebra/restriction/predicate_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe Optimizer::Algebra::Restriction, '#predicate' do
+  subject { object.predicate }
+
+  let(:base)      { Relation.new([ [ :id, Integer ] ], [ [ 1 ] ]) }
+  let(:predicate) { base[:id].eq(1)                               }
+  let(:relation)  { base.restrict(predicate)                      }
+  let(:object)    { described_class.new(relation)                 }
+
+  before do
+    object.operation.should be_kind_of(Algebra::Restriction)
+  end
+
+  it { should equal(predicate) }
+end

data/spec/unit/veritas/optimizer/algebra/restriction/restriction_operand/optimizable_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+describe Optimizer::Algebra::Restriction::RestrictionOperand, '#optimizable?' do
+  subject { object.optimizable? }
+
+  let(:header)    { Relation::Header.new([ [ :id, Integer ] ]) }
+  let(:base)      { Relation.new(header, [ [ 1 ] ].each)       }
+  let(:predicate) { header[:id].eq(1)                          }
+  let(:relation)  { operand.restrict(predicate)                }
+  let(:object)    { described_class.new(relation)              }
+
+  before do
+    object.operation.should be_kind_of(Algebra::Restriction)
+  end
+
+  context 'when the operand is an restriction operation' do
+    let(:other_predicate) { header[:id].include([ 1 ])     }
+    let(:operand)         { base.restrict(other_predicate) }
+
+    it { should be(true) }
+  end
+
+  context 'when the operand is not a restriction operation' do
+    let(:operand) { base }
+
+    it { should be(false) }
+  end
+end

data/spec/unit/veritas/optimizer/algebra/restriction/restriction_operand/optimize_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe Optimizer::Algebra::Restriction::RestrictionOperand, '#optimize' do
+  subject { object.optimize }
+
+  let(:header)          { Relation::Header.new([ [ :id, Integer ] ])         }
+  let(:base)            { Relation.new(header, [ [ 1 ] ].each)               }
+  let(:predicate)       { header[:id].eq(1)                                  }
+  let(:other_predicate) { header[:id].include([ 1 ])                         }
+  let(:relation)        { base.restrict(predicate).restrict(other_predicate) }
+  let(:object)          { described_class.new(relation)                      }
+
+  before do
+    object.should be_optimizable
+  end
+
+  it { should be_kind_of(Algebra::Restriction) }
+
+  its(:operand) { should equal(base) }
+
+  its(:predicate) { should equal(predicate) }
+end

data/spec/unit/veritas/optimizer/algebra/restriction/reverse_operand/optimizable_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+describe Optimizer::Algebra::Restriction::ReverseOperand, '#optimizable?' do
+  subject { object.optimizable? }
+
+  let(:base)      { Relation.new([ [ :id, Integer ] ], [ [ 1 ] ].each).order }
+  let(:predicate) { base[:id].eq(1)                                          }
+  let(:relation)  { operand.restrict(predicate)                              }
+  let(:object)    { described_class.new(relation)                            }
+
+  before do
+    object.operation.should be_kind_of(Algebra::Restriction)
+  end
+
+  context 'when the operand is a reverse operation' do
+    let(:operand) { base.take(2).reverse }
+
+    it { should be(true) }
+  end
+
+  context 'when the operand is not a reverse operation' do
+    let(:operand) { base }
+
+    it { should be(false) }
+  end
+end

data/spec/unit/veritas/optimizer/algebra/restriction/reverse_operand/optimize_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+describe Optimizer::Algebra::Restriction::ReverseOperand, '#optimize' do
+  subject { object.optimize }
+
+  let(:order)     { Relation.new([ [ :id, Integer ] ], [ [ 1 ] ].each).order }
+  let(:predicate) { order[:id].eq(1)                                         }
+  let(:relation)  { order.take(2).reverse.restrict(predicate)                }
+  let(:object)    { described_class.new(relation)                            }
+
+  before do
+    object.should be_optimizable
+  end
+
+  it { should be_kind_of(Relation::Operation::Reverse) }
+
+  its(:operand) { should eql(order.take(2).restrict(predicate)) }
+end

data/spec/unit/veritas/optimizer/algebra/restriction/set_operand/optimizable_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+describe Optimizer::Algebra::Restriction::SetOperand, '#optimizable?' do
+  subject { object.optimizable? }
+
+  let(:header)    { Relation::Header.new([ [ :id, Integer ] ]) }
+  let(:left)      { Relation.new(header, [ [ 1 ] ].each)       }
+  let(:right)     { Relation.new(header, [ [ 2 ] ].each)       }
+  let(:predicate) { header[:id].eq(1)                          }
+  let(:relation)  { operand.restrict(predicate)                }
+  let(:object)    { described_class.new(relation)              }
+
+  before do
+    object.operation.should be_kind_of(Algebra::Restriction)
+  end
+
+  context 'when the operand is a set operation' do
+    let(:operand) { left.union(right) }
+
+    it { should be(true) }
+  end
+
+  context 'when the operand is not a set operation' do
+    let(:operand) { left }
+
+    it { should be(false) }
+  end
+end

data/spec/unit/veritas/optimizer/algebra/restriction/set_operand/optimize_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe Optimizer::Algebra::Restriction::SetOperand, '#optimize' do
+  subject { object.optimize }
+
+  let(:header)    { Relation::Header.new([ [ :id, Integer ] ]) }
+  let(:left)      { Relation.new(header, [ [ 1 ] ].each)       }
+  let(:right)     { Relation.new(header, [ [ 2 ] ].each)       }
+  let(:predicate) { header[:id].eq(1)                          }
+  let(:relation)  { left.union(right).restrict(predicate)      }
+  let(:object)    { described_class.new(relation)              }
+
+  before do
+    object.should be_optimizable
+  end
+
+  it { should be_kind_of(Relation::Operation::Set) }
+
+  its(:left) { should eql(left.restrict(predicate)) }
+
+  its(:right) { should eql(right.restrict(predicate)) }
+end

data/spec/unit/veritas/optimizer/algebra/restriction/tautology/optimizable_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe Optimizer::Algebra::Restriction::Tautology, '#optimizable?' do
+  subject { object.optimizable? }
+
+  let(:base)     { Relation.new([ [ :id, Integer ] ], [ [ 1 ] ].each) }
+  let(:relation) { base.restrict(predicate)                           }
+  let(:object)   { described_class.new(relation)                      }
+
+  before do
+    object.operation.should be_kind_of(Algebra::Restriction)
+  end
+
+  context 'when the predicate is a tautology' do
+    let(:predicate) { Logic::Proposition::Tautology.instance }
+
+    it { should be(true) }
+  end
+
+  context 'when the predicate is not a tautology' do
+    let(:predicate) { Logic::Proposition::Contradiction.instance }
+
+    it { should be(false) }
+  end
+end

data/spec/unit/veritas/optimizer/algebra/restriction/tautology/optimize_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe Optimizer::Algebra::Restriction::Tautology, '#optimize' do
+  subject { object.optimize }
+
+  let(:header)    { Relation::Header.new([ [ :id, Integer ] ]) }
+  let(:base)      { Relation.new(header, [ [ 1 ] ].each)       }
+  let(:predicate) { Logic::Proposition::Tautology.instance     }
+  let(:relation)  { base.restrict(predicate)                   }
+  let(:object)    { described_class.new(relation)              }
+
+  before do
+    object.should be_optimizable
+  end
+
+  it { should equal(base) }
+end

data/spec/unit/veritas/optimizer/algebra/restriction/unoptimized_operand/optimizable_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+describe Optimizer::Algebra::Restriction::UnoptimizedOperand, '#optimizable?' do
+  subject { object.optimizable? }
+
+  let(:header)   { Relation::Header.new([ [ :id, Integer ] ]) }
+  let(:base)     { Relation.new(header, [ [ 1 ] ].each)       }
+  let(:relation) { operand.restrict(predicate)                }
+  let(:object)   { described_class.new(relation)              }
+
+  before do
+    object.operation.should be_kind_of(Algebra::Restriction)
+  end
+
+  context 'when the operand and predicate is optimizable' do
+    let(:predicate) { Logic::Connective::Negation.new(header[:id].eq(1)) }
+    let(:operand)   { base.rename({})                                    }
+
+    it { should be(true) }
+  end
+
+  context 'when the operand is optimizable, but the predicate is not optimizable' do
+    let(:predicate) { header[:id].eq(1) }
+    let(:operand)   { base.rename({})   }
+
+    it { should be(true) }
+  end
+
+  context 'when the operand is not optimizable, but the predicate is optimizable' do
+    let(:predicate) { Logic::Connective::Negation.new(header[:id].eq(1)) }
+    let(:operand)   { base                                               }
+
+    it { should be(true) }
+  end
+
+  context 'when the operand and predicate are not optimizable' do
+    let(:predicate) { header[:id].eq(1) }
+    let(:operand)   { base              }
+
+    it { should be(false) }
+  end
+end

data/spec/unit/veritas/optimizer/algebra/restriction/unoptimized_operand/optimize_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe Optimizer::Algebra::Restriction::UnoptimizedOperand, '#optimize' do
+  subject { object.optimize }
+
+  let(:header)   { Relation::Header.new([ [ :id, Integer ] ])    }
+  let(:base)     { Relation.new(header, [ [ 1 ] ].each)          }
+  let(:relation) { base.rename({}).restrict { |r| r[:id].eq(1) } }
+  let(:object)   { described_class.new(relation)                 }
+
+  before do
+    object.should be_optimizable
+  end
+
+  it { should be_kind_of(Algebra::Restriction) }
+
+  it { should_not equal(relation) }
+
+  its(:operand) { should equal(base) }
+
+  its(:predicate) { should == base[:id].eq(1) }
+end

data/spec/unit/veritas/optimizer/algebra/summarization/unoptimized_operand/optimizable_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe Optimizer::Algebra::Summarization::UnoptimizedOperand, '#optimizable?' do
+  subject { object.optimizable? }
+
+  let(:header)      { Relation::Header.new([ [ :id, Integer ] ])             }
+  let(:base)        { Relation.new(header, [ [ 1 ] ].each)                   }
+  let(:summarizers) { [ :text, lambda { |acc, tuple| 1 } ]                   }
+  let(:relation)    { operand.summarize(operand) { |r| r.add(*summarizers) } }
+  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({}) }
+
+    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/algebra/summarization/unoptimized_operand/optimize_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe Optimizer::Algebra::Summarization::UnoptimizedOperand, '#optimize' do
+  subject { object.optimize }
+
+  let(:header)    { Relation::Header.new([ [ :id, Integer ] ])                    }
+  let(:base)      { Relation.new(header, [ [ 1 ] ].each)                          }
+  let(:attribute) { Attribute::Object.new(:text)                                  }
+  let(:function)  { lambda { |acc, tuple| 1 }                                     }
+  let(:operand)   { base.rename({})                                               }
+  let(:relation)  { operand.summarize(operand) { |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_by) { should equal(operand) }
+
+  its(:summarizers) { should == { attribute => function } }
+end

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

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe Optimizer::Algebra::Union::EmptyLeft, '#optimize' do
+  subject { object.optimize }
+
+  let(:header)   { Relation::Header.new([ [ :id, Integer ] ]) }
+  let(:left)     { Relation::Empty.new(header)                }
+  let(:right)    { Relation.new(header, [ [ 2 ] ].each)       }
+  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/veritas/optimizer/algebra/union/empty_right/optimize_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe Optimizer::Algebra::Union::EmptyRight, '#optimize' do
+  subject { object.optimize }
+
+  let(:header)   { Relation::Header.new([ [ :id, Integer ] ]) }
+  let(:left)     { Relation.new(header, [ [ 1 ] ].each)       }
+  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/veritas/optimizer/algebra/union/equal_operands/optimize_spec.rb

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