axiom-optimizer 0.1.0

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

@@ -0,0 +1,23 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Relation, '#optimize' do
+  subject { object.optimize(*args) }
+
+  let(:object) { described_class.new([ [ :id, Integer ] ], LazyEnumerable.new([ [ 1 ] ])) }
+  let(:args)   { []                                                                       }
+
+  before do
+    object.should be_instance_of(described_class)
+  end
+
+  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

data/spec/rcov.opts

@@ -0,0 +1,7 @@
+--exclude-only "spec/,^/"
+--sort coverage
+--callsites
+--xrefs
+--profile
+--text-summary
+--failure-threshold 100

data/spec/shared/function_connective_binary_optimize_behavior.rb

@@ -0,0 +1,102 @@
+# encoding: utf-8
+
+shared_examples_for 'Function::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(Function::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(Function::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(Function::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(Function::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,16 @@
+# encoding: utf-8
+
+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_helper.rb

@@ -0,0 +1,38 @@
+# encoding: utf-8
+
+require 'backports'
+require 'backports/basic_object' unless defined?(::BasicObject)
+require 'devtools'
+require 'ice_nine'
+
+Devtools.init_spec_helper
+
+if ENV['COVERAGE'] == 'true'
+  require 'simplecov'
+  require 'coveralls'
+
+  SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
+    SimpleCov::Formatter::HTMLFormatter,
+    Coveralls::SimpleCov::Formatter
+  ]
+
+  SimpleCov.start do
+    command_name     'spec:unit'
+    add_filter       'config'
+    add_filter       'spec'
+    minimum_coverage 100
+  end
+end
+
+require 'axiom-optimizer'
+
+include Axiom
+
+# require spec support files and shared behavior
+Dir[File.expand_path('../{support,shared}/**/*.rb', __FILE__)].each do |file|
+  require file
+end
+
+RSpec.configure do |config|
+  config.extend AddMethodMissing
+end

data/spec/support/add_method_missing.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+
+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/support/config_alias.rb

@@ -0,0 +1,3 @@
+require 'rbconfig'
+
+::Config = RbConfig unless defined?(::Config)

data/spec/support/ice_nine_config.rb

@@ -0,0 +1,6 @@
+module IceNine
+  class Freezer
+    class RSpec < NoFreeze
+    end
+  end
+end

data/spec/support/lazy_enumerable.rb

@@ -0,0 +1,18 @@
+# encoding: utf-8
+
+class LazyEnumerable < BasicObject
+  def initialize(enumerable = [])
+    @enumerable = enumerable
+  end
+
+  def size
+    nil
+  end
+
+private
+
+  def method_missing(*args, &block)
+    @enumerable.__send__(*args, &block)
+  end
+
+end

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

@@ -0,0 +1,19 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Optimizer::Algebra::Difference::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([ [ 1 ] ])) }
+  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/axiom/optimizer/algebra/difference/empty_right/optimize_spec.rb

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

@@ -0,0 +1,23 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Optimizer::Algebra::Difference::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.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) }
+
+  its(:tuples) { should equal(relation) }
+end

data/spec/unit/axiom/optimizer/algebra/extension/extensions_spec.rb

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

data/spec/unit/axiom/optimizer/algebra/extension/order_operand/optimizable_predicate_spec.rb

@@ -0,0 +1,23 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Optimizer::Algebra::Extension::OrderOperand, '#optimizable?' do
+  subject { object.optimizable? }
+
+  let(:base)     { Relation.new([ [ :id, Integer ] ], LazyEnumerable.new) }
+  let(:relation) { operand.extend {}                                      }
+  let(:object)   { described_class.new(relation)                          }
+
+  context 'when operand is an order' do
+    let(:operand) { base.sort_by { |r| r.id } }
+
+    it { should be(true) }
+  end
+
+  context 'when operand is not an order' do
+    let(:operand) { base }
+
+    it { should be(false) }
+  end
+end

data/spec/unit/axiom/optimizer/algebra/extension/order_operand/optimize_spec.rb

@@ -0,0 +1,22 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Optimizer::Algebra::Extension::OrderOperand, '#optimize' do
+  subject { object.optimize }
+
+  let(:base)     { Relation.new([ [ :id, Integer ] ], LazyEnumerable.new) }
+  let(:operand)  { base.sort_by { |r| r.id }                              }
+  let(:relation) { operand.extend {}                                      }
+  let(:object)   { described_class.new(relation)                          }
+
+  before do
+    object.should be_optimizable
+  end
+
+  it { should be_kind_of(Algebra::Extension) }
+
+  its(:operand) { should equal(base) }
+
+  its(:extensions) { should eql(relation.extensions) }
+end

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

@@ -0,0 +1,37 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Optimizer::Algebra::Extension::UnoptimizedOperand, '#optimizable?' do
+  subject { object.optimizable? }
+
+  let(:header)   { Relation::Header.coerce([ [ :id, Integer ] ])       }
+  let(:base)     { Relation.new(header, LazyEnumerable.new([ [ 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({}) }
+    let(:extensions) { [ :text, 1 ]    }
+
+    it { should be(true) }
+  end
+
+  context 'when the extensions are optimizable' do
+    let(:operand)    { base                                          }
+    let(:extensions) { [ :text, Function::Numeric::Absolute.new(1) ] }
+
+    it { should be(true) }
+  end
+
+  context 'when the operand and extensions are not optimizable' do
+    let(:operand)    { base         }
+    let(:extensions) { [ :text, 1 ] }
+
+    it { should be(false) }
+  end
+end

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

@@ -0,0 +1,27 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Optimizer::Algebra::Extension::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)  { Function::Numeric::Absolute.new(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 => 1 } }
+end