veritas-optimizer 0.0.3

data/spec/integration/veritas/relation/optimize_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+describe Relation, '#optimize' do
+  subject { object.optimize(*args) }
+
+  let(:object) { described_class.new([ [ :id, Integer ] ], [ [ 1 ] ].each) }
+
+  before do
+    object.should be_instance_of(described_class)
+  end
+
+  context 'with no optimizer' do
+    let(:args) { [] }
+
+    it 'calls self.class.optimizer' do
+      described_class.should_receive(:optimizer).and_return(nil)
+      subject
+    end
+
+    it { should equal(object) }
+
+    it_should_behave_like 'an optimize method'
+  end
+
+  context 'with an optimizer' do
+    let(:optimized) { described_class.new([ [ :id, Integer ] ], [ [ 1 ] ].each) }
+    let(:args)      { [ lambda { |relation| optimized } ]                       }
+
+    it { should equal(optimized) }
+
+    it_should_behave_like 'an optimize method'
+  end
+end

data/spec/rcov.opts

@@ -0,0 +1,6 @@
+--exclude-only "spec/,^/"
+--sort coverage
+--callsites
+--xrefs
+--profile
+--text-summary

data/spec/shared/idempotent_method_behavior.rb

@@ -0,0 +1,5 @@
+shared_examples_for 'an idempotent method' do
+  it 'is idempotent' do
+    should equal(instance_eval(&self.class.subject))
+  end
+end

data/spec/shared/logic_connective_binary_optimize_behavior.rb

@@ -0,0 +1,100 @@
+shared_examples_for 'Logic::Connective::Binary#optimize' do
+  context 'left and right are the same' do
+    let(:left)  { attribute.gt(1) }
+    let(:right) { attribute.gt(1) }
+
+    it { should equal(left) }
+
+    it_should_behave_like 'an optimize method'
+  end
+
+  context 'left and right are the same, after optimizing the left' do
+    let(:original_left) { attribute.gt(1)                                           }
+    let(:left)          { original_left.and(Logic::Proposition::Tautology.instance) }
+    let(:right)         { attribute.gt(1)                                           }
+
+    it { should equal(original_left) }
+
+    it_should_behave_like 'an optimize method'
+  end
+
+  context 'left and right are the same, after optimizing the right' do
+    let(:left)  { attribute.gt(1)                                             }
+    let(:right) { attribute.gt(1).and(Logic::Proposition::Tautology.instance) }
+
+    it { should equal(left) }
+
+    it_should_behave_like 'an optimize method'
+  end
+
+  context 'left and right are different' do
+    let(:left)  { attribute.gt(1) }
+    let(:right) { attribute.lt(1) }
+
+    it { should equal(object) }
+
+    it_should_behave_like 'an optimize method'
+  end
+
+  context 'left and right are different, after optimizing the left' do
+    let(:original_left) { attribute.gt(1)                                           }
+    let(:left)          { original_left.and(Logic::Proposition::Tautology.instance) }
+    let(:right)         { attribute.lt(1)                                           }
+
+    add_method_missing
+
+    it { should_not equal(object) }
+
+    it { should be_kind_of(described_class) }
+
+    its(:left) { should equal(original_left) }
+
+    its(:right) { should equal(right) }
+
+    it_should_behave_like 'an optimize method'
+  end
+
+  context 'left and right are different, after optimizing the right' do
+    let(:original_right) { attribute.lt(1)                                            }
+    let(:left)           { attribute.gt(1)                                            }
+    let(:right)          { original_right.and(Logic::Proposition::Tautology.instance) }
+
+    add_method_missing
+
+    it { should_not equal(object) }
+
+    it { should be_kind_of(described_class) }
+
+    its(:left) { should equal(left) }
+
+    its(:right) { should equal(original_right) }
+
+    it_should_behave_like 'an optimize method'
+  end
+
+  context 'self and right are the same, and left and right.left are the same' do
+    let(:left)  { attribute.eq(1)                                                               }
+    let(:right) { mock('Binary', :class => described_class, :left => left, :optimized? => true) }
+
+    before do
+      right.stub!(:optimize => right, :frozen? => true, :memoize => right, :memoized => right)
+    end
+
+    it { should equal(right) }
+
+    it_should_behave_like 'an optimize method'
+  end
+
+  context 'self and left are the same, and right and left.right are the same' do
+    let(:left)  { mock('Binary', :class => described_class, :right => right, :optimized? => true) }
+    let(:right) { attribute.eq(1)                                                                 }
+
+    before do
+      left.stub!(:optimize => left, :frozen? => true, :memoize => left, :memoized => left)
+    end
+
+    it { should equal(left) }
+
+    it_should_behave_like 'an optimize method'
+  end
+end

data/spec/shared/optimize_method_behavior.rb

@@ -0,0 +1,14 @@
+shared_examples_for 'an optimize method' do
+  it_should_behave_like 'an idempotent method'
+
+  it 'it memoizes itself for #optimize' do
+    optimized = subject
+    optimized.memoized('optimize').should equal(optimized)
+  end
+
+  it 'does not optimize further' do
+    optimized = subject
+    optimized.memoize('optimize', nil)  # clear memoized value
+    optimized.optimize.should eql(optimized)
+  end
+end

data/spec/spec.opts

@@ -0,0 +1,3 @@
+--color
+--loadby random
+--format profile

data/spec/spec_helper.rb

@@ -0,0 +1,16 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'backports'
+require 'veritas/optimizer'
+require 'spec'
+require 'spec/autorun'
+
+include Veritas
+
+# require spec support files and shared behavior
+Dir[File.expand_path('../{support,shared}/**/*.rb', __FILE__)].each { |f| require f }
+
+Spec::Runner.configure do |config|
+  config.extend AddMethodMissing
+end

data/spec/support/add_method_missing.rb

@@ -0,0 +1,13 @@
+module AddMethodMissing
+  def add_method_missing(name = :described_class)
+    before do
+      # when #optimize delegates to super, it would normally
+      # explode, so define method_missing to return self
+      send(name).class_eval do
+        def method_missing(*)
+          self
+        end
+      end
+    end
+  end
+end

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

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

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe Optimizer::Algebra::Difference::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.difference(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/difference/equal_operands/optimize_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe Optimizer::Algebra::Difference::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.difference(right)                     }
+  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/extension/unoptimized_operand/optimizable_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe Optimizer::Algebra::Extension::UnoptimizedOperand, '#optimizable?' do
+  subject { object.optimizable? }
+
+  let(:header)     { Relation::Header.new([ [ :id, Integer ] ]) }
+  let(:base)       { Relation.new(header, [ [ 1 ] ].each)       }
+  let(:extensions) { [ :text, lambda { |tuple| 1 } ]            }
+  let(:relation)   { operand.extend { |r| r.add(*extensions) }  }
+  let(:object)     { described_class.new(relation)              }
+
+  before do
+    object.operation.should be_kind_of(Algebra::Extension)
+  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/extension/unoptimized_operand/optimize_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe Optimizer::Algebra::Extension::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 { |tuple| 1 }                              }
+  let(:operand)   { base.rename({})                                   }
+  let(:relation)  { operand.extend { |r| r.add(attribute, function) } }
+  let(:object)    { described_class.new(relation)                     }
+
+  before do
+    object.should be_optimizable
+  end
+
+  it { should_not equal(operand) }
+
+  it { should be_kind_of(Algebra::Extension) }
+
+  its(:operand) { should equal(base) }
+
+  its(:extensions) { should == { attribute => function } }
+end

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

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

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe Optimizer::Algebra::Intersection::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.intersect(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/intersection/equal_operands/optimize_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe Optimizer::Algebra::Intersection::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.intersect(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/join/equal_headers/optimizable_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe Optimizer::Algebra::Join::EqualHeaders, '#optimizable?' do
+  subject { object.optimizable? }
+
+  let(:relation) { left.join(right)              }
+  let(:object)   { described_class.new(relation) }
+
+  before do
+    object.operation.should be_kind_of(Algebra::Join)
+  end
+
+  context 'when left and right headers are equal' do
+    let(:header) { Relation::Header.new([ [ :id, Integer ] ]) }
+    let(:left)   { Relation.new(header, [ [ 1 ] ].each)       }
+    let(:right)  { Relation.new(header, [ [ 1 ] ].each)       }
+
+    it { should be(true) }
+  end
+
+  context 'when left and right headers are not equal' do
+    let(:left)  { Relation.new([ [ :id, Integer ] ], [ [ 1 ] ].each)                                 }
+    let(:right) { Relation.new([ [ :id, Integer ], [ :name, String  ] ], [ [ 1, 'Dan Kubb' ] ].each) }
+
+    it { should be(false) }
+  end
+end

data/spec/unit/veritas/optimizer/algebra/join/equal_headers/optimize_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+describe Optimizer::Algebra::Join::EqualHeaders, '#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(:relation) { left.join(right)                           }
+  let(:object)   { described_class.new(relation)              }
+
+  before do
+    object.should be_optimizable
+  end
+
+  it { should be_kind_of(Algebra::Intersection) }
+
+  its(:left) { should equal(left) }
+
+  its(:right) { should equal(right) }
+end

data/spec/unit/veritas/optimizer/algebra/product/table_dee_left/optimizable_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe Optimizer::Algebra::Product::TableDeeLeft, '#optimizable?' do
+  subject { object.optimizable? }
+
+  let(:right)    { Relation.new([ [ :id, Integer  ] ], [ [ 1 ] ].each) }
+  let(:relation) { left.product(right)                                 }
+  let(:object)   { described_class.new(relation)                       }
+
+  before do
+    object.operation.should be_kind_of(Algebra::Product)
+  end
+
+  context 'when the left operand is a table dee' do
+    let(:left) { TABLE_DEE }
+
+    it { should be(true) }
+  end
+
+  context 'when the left operand is not table dee' do
+    let(:left) { TABLE_DUM }
+
+    it { should be(false) }
+  end
+end

data/spec/unit/veritas/optimizer/algebra/product/table_dee_left/optimize_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe Optimizer::Algebra::Product::TableDeeLeft, '#optimize' do
+  subject { object.optimize }
+
+  let(:left)     { TABLE_DEE                                           }
+  let(:right)    { Relation.new([ [ :id, Integer  ] ], [ [ 1 ] ].each) }
+  let(:relation) { left.product(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/product/table_dee_right/optimizable_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe Optimizer::Algebra::Product::TableDeeRight, '#optimizable?' do
+  subject { object.optimizable? }
+
+  let(:left)     { Relation.new([ [ :id, Integer  ] ], [ [ 1 ] ].each) }
+  let(:relation) { left.product(right)                                 }
+  let(:object)   { described_class.new(relation)                       }
+
+  before do
+    object.operation.should be_kind_of(Algebra::Product)
+  end
+
+  context 'when the right operand is a table dee' do
+    let(:right) { TABLE_DEE }
+
+    it { should be(true) }
+  end
+
+  context 'when the right operand is not table dee' do
+    let(:right) { TABLE_DUM }
+
+    it { should be(false) }
+  end
+end

data/spec/unit/veritas/optimizer/algebra/product/table_dee_right/optimize_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe Optimizer::Algebra::Product::TableDeeRight, '#optimize' do
+  subject { object.optimize }
+
+  let(:left)     { Relation.new([ [ :id, Integer  ] ], [ [ 1 ] ].each) }
+  let(:right)    { TABLE_DEE                                           }
+  let(:relation) { left.product(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/projection/empty_operand/optimizable_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe Optimizer::Algebra::Projection::EmptyOperand, '#optimizable?' do
+  subject { object.optimizable? }
+
+  let(:header)   { Relation::Header.new([ [ :id, Integer ], [ :name, String ] ]) }
+  let(:relation) { operand.project([ :id ])                                      }
+  let(:object)   { described_class.new(relation)                                 }
+
+  before do
+    object.operation.should be_kind_of(Algebra::Projection)
+  end
+
+  context 'when the operand is empty' do
+    let(:operand) { Relation::Empty.new(header) }
+
+    it { should be(true) }
+  end
+
+  context 'when the operand is not empty' do
+    let(:operand) { Relation.new(header, [ [ 1, 'Dan Kubb' ] ]) }
+
+    it { should be(false) }
+  end
+end

data/spec/unit/veritas/optimizer/algebra/projection/empty_operand/optimize_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+describe Optimizer::Algebra::Projection::EmptyOperand, '#optimize' do
+  subject { object.optimize }
+
+  let(:header)   { Relation::Header.new([ [ :id, Integer ], [ :name, String ] ]) }
+  let(:base)     { Relation::Empty.new(header)                                   }
+  let(:relation) { base.project([ :id ])                                         }
+  let(:object)   { described_class.new(relation)                                 }
+
+  before do
+    object.should be_optimizable
+  end
+
+  it { should be_kind_of(Relation::Empty) }
+
+  its(:header) { should equal(relation.header) }
+end

data/spec/unit/veritas/optimizer/algebra/projection/header_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe Optimizer::Algebra::Projection, '#header' do
+  subject { object.header }
+
+  let(:header)   { Relation::Header.new([ [ :id, Integer ], [ :name, String ] ]) }
+  let(:operand)  { Relation.new(header, [ [ 1, 'Dan Kubb' ] ])                   }
+  let(:relation) { operand.project([ :id ])                                      }
+  let(:object)   { described_class.new(relation)                                 }
+
+  before do
+    object.operation.should be_kind_of(Algebra::Projection)
+  end
+
+  it { should equal(relation.header) }
+end

data/spec/unit/veritas/optimizer/algebra/projection/projection_operand/optimizable_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+describe Optimizer::Algebra::Projection::ProjectionOperand, '#optimizable?' do
+  subject { object.optimizable? }
+
+  let(:header)   { Relation::Header.new([ [ :id, Integer ], [ :name, String ], [ :age, Integer ] ]) }
+  let(:base)     { Relation.new(header, [ [ 1, 'Dan Kubb', 35 ] ].each)                             }
+  let(:relation) { operand.project([ :id ])                                                         }
+  let(:object)   { described_class.new(relation)                                                    }
+
+  before do
+    object.operation.should be_kind_of(Algebra::Projection)
+  end
+
+  context 'when the operand is a projection' do
+    let(:operand) { base.project([ :id, :name ]) }
+
+    it { should be(true) }
+  end
+
+  context 'when the operand is not a projection' do
+    let(:operand) { base }
+
+    it { should be(false) }
+  end
+end

data/spec/unit/veritas/optimizer/algebra/projection/projection_operand/optimize_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe Optimizer::Algebra::Projection::ProjectionOperand, '#optimize' do
+  subject { object.optimize }
+
+  let(:header)   { Relation::Header.new([ [ :id, Integer ], [ :name, String ], [ :age, Integer ] ]) }
+  let(:base)     { Relation.new(header, [ [ 1, 'Dan Kubb', 35 ] ].each)                             }
+  let(:relation) { base.project([ :id, :name ]).project([ :id ])                                    }
+  let(:object)   { described_class.new(relation)                                                    }
+
+  before do
+    object.should be_optimizable
+  end
+
+  it { should be_kind_of(Algebra::Projection) }
+
+  its(:operand) { should equal(base) }
+
+  its(:header) { should == [ header[:id] ] }
+end

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

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe Optimizer::Algebra::Projection::SetOperand, '#optimizable?' do
+  subject { object.optimizable? }
+
+  let(:header)   { Relation::Header.new([ [ :id, Integer ], [ :name, String ] ]) }
+  let(:left)     { Relation.new(header, [ [ 1, 'Dan Kubb', 35 ] ].each)          }
+  let(:right)    { Relation.new(header, [ [ 2, 'Dan Kubb', 35 ] ].each)          }
+  let(:relation) { operand.project([ :id ])                                      }
+  let(:object)   { described_class.new(relation)                                 }
+
+  before do
+    object.operation.should be_kind_of(Algebra::Projection)
+  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/projection/set_operand/optimize_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe Optimizer::Algebra::Projection::SetOperand, '#optimize' do
+  subject { object.optimize }
+
+  let(:header)     { Relation::Header.new([ [ :id, Integer ], [ :name, String ], [ :age, Integer ] ]) }
+  let(:base_left)  { Relation.new(header, [ [ 1, 'Dan Kubb', 35 ] ].each)                             }
+  let(:base_right) { Relation.new(header, [ [ 2, 'Dan Kubb', 35 ] ].each)                             }
+  let(:left)       { base_left.rename({})                                                             }
+  let(:right)      { base_right.rename({})                                                            }
+  let(:relation)   { left.union(right).project([ :id ])                                               }
+  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(base_left.project([ :id ])) }
+
+  its(:right) { should eql(base_right.project([ :id ])) }
+end