veritas-optimizer 0.0.3

data/lib/veritas/optimizer/relation/operation/unary.rb

@@ -0,0 +1,88 @@
+# encoding: utf-8
+
+module Veritas
+  class Optimizer
+    module Relation
+      module Operation
+
+        # Abstract base class representing Unary relation optimizations
+        class Unary < Optimizer
+
+          # The optimized operand
+          #
+          # @return [Relation]
+          #
+          # @api private
+          attr_reader :operand
+
+          # Initialize a Unary optimizer
+          #
+          # @return [undefined]
+          #
+          # @api private
+          def initialize(*)
+            super
+            @operand = optimize_operand
+          end
+
+        private
+
+          # Optimize the operand
+          #
+          # @return [Relation]
+          #
+          # @api private
+          def optimize_operand
+            operation.operand.optimize
+          end
+
+          # Optimize when the operand is Empty
+          class EmptyOperand < self
+
+            # Test if the operand is empty
+            #
+            # @return [Boolean]
+            #
+            # @api private
+            def optimizable?
+              operand.kind_of?(Veritas::Relation::Empty)
+            end
+
+            # A Unary operation on an empty operand is empty
+            #
+            # @return [Relation::Empty]
+            #
+            # @api private
+            def optimize
+              operand
+            end
+
+          end # class EmptyOperand
+
+          # Optimize when the operand is Materialized
+          class MaterializedOperand < self
+
+            # Test if the operand is materialized
+            #
+            # @return [Boolean]
+            #
+            # @api private
+            def optimizable?
+              operand.kind_of?(Veritas::Relation::Materialized)
+            end
+
+            # Return the materialized operation
+            #
+            # @return [Relation::Materialized]
+            #
+            # @api private
+            def optimize
+              operation.materialize
+            end
+
+          end # class MaterializedOperand
+        end # class Unary
+      end # module Operation
+    end # module Relation
+  end # class Optimizer
+end # module Veritas

data/lib/veritas/optimizer/version.rb

@@ -0,0 +1,7 @@
+# encoding: utf-8
+
+module Veritas
+  class Optimizer
+    VERSION = '0.0.3'
+  end # class Optimizer
+end # module Veritas

data/lib/veritas/optimizer.rb

@@ -0,0 +1,136 @@
+# encoding: utf-8
+
+require 'veritas'
+
+module Veritas
+
+  # A optimization for an operation
+  class Optimizer
+    include AbstractClass, Immutable
+
+    # A noop optimizer that returns the operation as-is
+    Noop = lambda { |operation| operation }.freeze
+
+    # The operation to optimize
+    #
+    # @return [Optimizable]
+    #
+    # @api private
+    attr_reader :operation
+
+    # Initialize an Optimizer
+    #
+    # @param [Optimizable] operation
+    #   the operation to optimize
+    #
+    # @return [undefined]
+    #
+    # @api private
+    def initialize(operation)
+      @operation = operation
+    end
+
+    # Abstract method that tests if the optimization should be applied
+    #
+    # @example
+    #   optimizer.optimizable?  # => true or false
+    #
+    # @return [Boolean]
+    #
+    # @api public
+    def optimizable?
+      raise NotImplementedError, "#{self.class}#optimizable? must be implemented"
+    end
+
+    # Abstract method that executes the optimization for the operation
+    #
+    # @example
+    #   optimized = optimizer.optimize
+    #
+    # @return [Optimizable]
+    #
+    # @api public
+    def optimize
+      raise NotImplementedError, "#{self.class}#optimize must be implemented"
+    end
+
+    # Chain together a list of optimizer classes into a callable object
+    #
+    # @example
+    #   Optimizer.chain(Optimizer::Foo, Optimizer::Bar)
+    #
+    # @param [Array<Class<Optimizer>>] *optimizers
+    #   a list of optimizer classes to apply
+    #
+    # @return [#call]
+    #
+    # @api public
+    def self.chain(*optimizers)
+      optimizers.reverse_each.reduce(Noop) do |successor, optimizer|
+        link_optimizers(optimizer, successor)
+      end
+    end
+
+    # Link an optimizer to a successor
+    #
+    # @param [Class<Optimizer>] optimizer
+    #   the optimizer to link to the successor
+    # @param [#proc] successor
+    #   the next optimizer to call if the current optimizer is not applied
+    #
+    # @return [#call]
+    #
+    # @api private
+    def self.link_optimizers(optimizer, successor)
+      lambda do |operation|
+        op = optimizer.new(operation)
+        op.optimizable? ? op.optimize : successor.call(operation)
+      end
+    end
+
+    private_class_method :link_optimizers
+
+  end # class Optimizer
+end # module Veritas
+
+require 'veritas/optimizer/version'
+
+require 'veritas/optimizer/optimizable'
+
+require 'veritas/optimizer/relation/materialized'
+
+require 'veritas/optimizer/relation/operation/binary'
+require 'veritas/optimizer/relation/operation/unary'
+require 'veritas/optimizer/relation/operation/combination'
+require 'veritas/optimizer/relation/operation/limit'
+require 'veritas/optimizer/relation/operation/offset'
+require 'veritas/optimizer/relation/operation/order'
+require 'veritas/optimizer/relation/operation/reverse'
+
+require 'veritas/optimizer/algebra/difference'
+require 'veritas/optimizer/algebra/extension'
+require 'veritas/optimizer/algebra/intersection'
+require 'veritas/optimizer/algebra/join'
+require 'veritas/optimizer/algebra/product'
+require 'veritas/optimizer/algebra/projection'
+require 'veritas/optimizer/algebra/rename'
+require 'veritas/optimizer/algebra/restriction'
+require 'veritas/optimizer/algebra/summarization'
+require 'veritas/optimizer/algebra/union'
+
+require 'veritas/optimizer/logic/connective/binary'
+require 'veritas/optimizer/logic/connective/conjunction'
+require 'veritas/optimizer/logic/connective/disjunction'
+require 'veritas/optimizer/logic/connective/negation'
+
+require 'veritas/optimizer/logic/predicate'
+require 'veritas/optimizer/logic/predicate/comparable'
+require 'veritas/optimizer/logic/predicate/enumerable'
+require 'veritas/optimizer/logic/predicate/equality'
+require 'veritas/optimizer/logic/predicate/exclusion'
+require 'veritas/optimizer/logic/predicate/greater_than'
+require 'veritas/optimizer/logic/predicate/greater_than_or_equal_to'
+require 'veritas/optimizer/logic/predicate/inequality'
+require 'veritas/optimizer/logic/predicate/inclusion'
+require 'veritas/optimizer/logic/predicate/less_than'
+require 'veritas/optimizer/logic/predicate/less_than_or_equal_to'

data/lib/veritas-optimizer.rb

@@ -0,0 +1,3 @@
+# encoding: utf-8
+
+require 'veritas/optimizer'

data/spec/integration/veritas/algebra/difference/optimize_spec.rb

@@ -0,0 +1,152 @@
+require 'spec_helper'
+
+describe Algebra::Difference, '#optimize' do
+  subject { object.optimize }
+
+  let(:header)         { [ [ :id, Integer ] ]             }
+  let(:left_body)      { [ [ 1 ] ].each                   }
+  let(:right_body)     { [ [ 2 ] ].each                   }
+  let(:original_left)  { Relation.new(header, left_body)  }
+  let(:original_right) { Relation.new(header, right_body) }
+  let(:object)         { described_class.new(left, right) }
+
+  context 'left is an empty relation' do
+    let(:left)  { Relation::Empty.new(header) }
+    let(:right) { original_right              }
+
+    it { should equal(left) }
+
+    it 'returns an equivalent relation to the unoptimized operation' do
+      should == object
+    end
+
+    it 'does not execute right_body#each' do
+      right_body.should_not_receive(:each)
+      subject
+    end
+
+    it_should_behave_like 'an optimize method'
+  end
+
+  context 'right is an empty relation' do
+    let(:left)  { original_left               }
+    let(:right) { Relation::Empty.new(header) }
+
+    it { should equal(left) }
+
+    it 'returns an equivalent relation to the unoptimized operation' do
+      should == object
+    end
+
+    it 'does not execute left_body#each' do
+      left_body.should_not_receive(:each)
+      subject
+    end
+
+    it_should_behave_like 'an optimize method'
+  end
+
+  context 'left is an empty relation when optimized' do
+    let(:left)  { Algebra::Restriction.new(original_left, Logic::Proposition::Contradiction.instance) }
+    let(:right) { original_right                                                                      }
+
+    it { should eql(Relation::Empty.new(left.header | right.header)) }
+
+    it 'returns an equivalent relation to the unoptimized operation' do
+      should == object
+    end
+
+    it 'does not execute left_body#each' do
+      left_body.should_not_receive(:each)
+      subject
+    end
+
+    it 'does not execute right_body#each' do
+      right_body.should_not_receive(:each)
+      subject
+    end
+
+    it_should_behave_like 'an optimize method'
+  end
+
+  context 'right is an empty relation when optimized' do
+    let(:left)  { original_left                                                                        }
+    let(:right) { Algebra::Restriction.new(original_right, Logic::Proposition::Contradiction.instance) }
+
+    it { should equal(left) }
+
+    it 'returns an equivalent relation to the unoptimized operation' do
+      should == object
+    end
+
+    it 'does not execute left_body#each' do
+      left_body.should_not_receive(:each)
+      subject
+    end
+
+    it 'does not execute right_body#each' do
+      right_body.should_not_receive(:each)
+      subject
+    end
+
+    it_should_behave_like 'an optimize method'
+  end
+
+  unless defined?(JRUBY_VERSION) && JRUBY_VERSION < '1.6'
+    context 'left and right are equivalent relations' do
+      let(:right_body) { left_body.dup  }
+      let(:left)       { original_left  }
+      let(:right)      { original_right }
+
+      it { should eql(Relation::Empty.new(header)) }
+
+      it 'returns an equivalent relation to the unoptimized operation' do
+        should == object
+      end
+
+      it 'executes left_body#each' do
+        left_body.should_receive(:each)
+        subject
+      end
+
+      it 'executes right_body#each' do
+        right_body.should_receive(:each)
+        subject
+      end
+
+      it_should_behave_like 'an optimize method'
+    end
+  end
+
+  context 'left and right are not empty relations' do
+    let(:left)  { original_left  }
+    let(:right) { original_right }
+
+    it { should equal(object) }
+
+    it 'executes left_body#each' do
+      left_body.should_receive(:each)
+      subject
+    end
+
+    it 'executes right_body#each' do
+      right_body.should_receive(:each)
+      subject
+    end
+
+    it_should_behave_like 'an optimize method'
+  end
+
+  context 'left and right are materialized relations' do
+    let(:left)  { Relation.new(header, [ [ 1 ], [ 2 ] ]) }
+    let(:right) { Relation.new(header, [ [ 1 ] ])        }
+
+    it { should eql(Relation::Materialized.new(header, [ [ 2 ] ])) }
+
+    it 'returns an equivalent relation to the unoptimized operation' do
+      should == object
+    end
+
+    it_should_behave_like 'an optimize method'
+  end
+end

data/spec/integration/veritas/algebra/intersection/optimize_spec.rb

@@ -0,0 +1,152 @@
+require 'spec_helper'
+
+describe Algebra::Intersection, '#optimize' do
+  subject { object.optimize }
+
+  let(:header)         { [ [ :id, Integer ] ]             }
+  let(:left_body)      { [ [ 1 ] ].each                   }
+  let(:right_body)     { [ [ 2 ] ].each                   }
+  let(:original_left)  { Relation.new(header, left_body)  }
+  let(:original_right) { Relation.new(header, right_body) }
+  let(:object)         { described_class.new(left, right) }
+
+  context 'left is an empty relation' do
+    let(:left)  { Relation::Empty.new(header) }
+    let(:right) { original_right              }
+
+    it { should equal(left) }
+
+    it 'returns an equivalent relation to the unoptimized operation' do
+      should == object
+    end
+
+    it 'does not execute right_body#each' do
+      right_body.should_not_receive(:each)
+      subject
+    end
+
+    it_should_behave_like 'an optimize method'
+  end
+
+  context 'right is an empty relation' do
+    let(:left)  { original_left               }
+    let(:right) { Relation::Empty.new(header) }
+
+    it { should equal(right) }
+
+    it 'returns an equivalent relation to the unoptimized operation' do
+      should == object
+    end
+
+    it 'does not execute left_body#each' do
+      left_body.should_not_receive(:each)
+      subject
+    end
+
+    it_should_behave_like 'an optimize method'
+  end
+
+  context 'left is an empty relation when optimized' do
+    let(:left)  { Algebra::Restriction.new(original_left, Logic::Proposition::Contradiction.instance) }
+    let(:right) { original_right                                                                      }
+
+    it { should eql(Relation::Empty.new(left.header | right.header)) }
+
+    it 'returns an equivalent relation to the unoptimized operation' do
+      should == object
+    end
+
+    it 'does not execute left_body#each' do
+      left_body.should_not_receive(:each)
+      subject
+    end
+
+    it 'does not execute right_body#each' do
+      right_body.should_not_receive(:each)
+      subject
+    end
+
+    it_should_behave_like 'an optimize method'
+  end
+
+  context 'right is an empty relation when optimized' do
+    let(:left)  { original_left                                                                        }
+    let(:right) { Algebra::Restriction.new(original_right, Logic::Proposition::Contradiction.instance) }
+
+    it { should eql(Relation::Empty.new(left.header | right.header)) }
+
+    it 'returns an equivalent relation to the unoptimized operation' do
+      should == object
+    end
+
+    it 'does not execute left_body#each' do
+      left_body.should_not_receive(:each)
+      subject
+    end
+
+    it 'does not execute right_body#each' do
+      right_body.should_not_receive(:each)
+      subject
+    end
+
+    it_should_behave_like 'an optimize method'
+  end
+
+  unless defined?(JRUBY_VERSION) && JRUBY_VERSION < '1.6'
+    context 'left and right are equivalent relations' do
+      let(:right_body) { left_body.dup  }
+      let(:left)       { original_left  }
+      let(:right)      { original_right }
+
+      it { should equal(left) }
+
+      it 'returns an equivalent relation to the unoptimized operation' do
+        should == object
+      end
+
+      it 'executes left_body#each' do
+        left_body.should_receive(:each)
+        subject
+      end
+
+      it 'executes right_body#each' do
+        right_body.should_receive(:each)
+        subject
+      end
+
+      it_should_behave_like 'an optimize method'
+    end
+  end
+
+  context 'left and right are not empty relations' do
+    let(:left)  { original_left  }
+    let(:right) { original_right }
+
+    it { should equal(object) }
+
+    it 'executed left_body#each' do
+      left_body.should_receive(:each)
+      subject
+    end
+
+    it 'executed right_body#each' do
+      right_body.should_receive(:each)
+      subject
+    end
+
+    it_should_behave_like 'an optimize method'
+  end
+
+  context 'left and right are materialized relations' do
+    let(:left)  { Relation.new(header, [ [ 1 ], [ 2 ] ]) }
+    let(:right) { Relation.new(header, [ [ 1 ] ])        }
+
+    it { should eql(Relation::Materialized.new(header, [ [ 1 ] ])) }
+
+    it 'returns an equivalent relation to the unoptimized operation' do
+      should == object
+    end
+
+    it_should_behave_like 'an optimize method'
+  end
+end

data/spec/integration/veritas/algebra/join/optimize_spec.rb

@@ -0,0 +1,110 @@
+require 'spec_helper'
+
+describe Algebra::Join, '#optimize' do
+  subject { object.optimize }
+
+  let(:left_body)      { [ [ 1 ], [ 2 ] ].each                                             }
+  let(:right_body)     { [ [ 2, 'Dan Kubb' ] ].each                                        }
+  let(:original_left)  { Relation.new([ [ :id, Integer ] ],                    left_body)  }
+  let(:original_right) { Relation.new([ [ :id, Integer ], [ :name, String ] ], right_body) }
+  let(:left)           { original_left                                                     }
+  let(:right)          { original_right                                                    }
+  let(:object)         { described_class.new(left, right)                                  }
+
+  context 'left is an empty relation' do
+    let(:left) { Relation::Empty.new(original_left.header) }
+
+    it { should eql(Relation::Empty.new(right.header)) }
+
+    it 'returns an equivalent relation to the unoptimized operation' do
+      should == object
+    end
+
+    it 'does not execute right_body#each' do
+      right_body.should_not_receive(:each)
+      subject
+    end
+
+    it_should_behave_like 'an optimize method'
+  end
+
+  context 'right is an empty relation' do
+    let(:right) { Relation::Empty.new(original_right.header) }
+
+    it { should eql(Relation::Empty.new(right.header)) }
+
+    it 'returns an equivalent relation to the unoptimized operation' do
+      should == object
+    end
+
+    it 'does not execute left_body#each' do
+      left_body.should_not_receive(:each)
+      subject
+    end
+
+    it_should_behave_like 'an optimize method'
+  end
+
+  context 'left is an empty relation when optimized' do
+    let(:left) { Algebra::Restriction.new(original_left, Logic::Proposition::Contradiction.instance) }
+
+    it { should eql(Relation::Empty.new(right.header)) }
+
+    it 'returns an equivalent relation to the unoptimized operation' do
+      should == object
+    end
+
+    it 'does not execute right_body#each' do
+      right_body.should_not_receive(:each)
+      subject
+    end
+
+    it_should_behave_like 'an optimize method'
+  end
+
+  context 'right is an empty relation when optimized' do
+    let(:right) { Algebra::Restriction.new(original_right, Logic::Proposition::Contradiction.instance) }
+
+    it { should eql(Relation::Empty.new(right.header)) }
+
+    it 'returns an equivalent relation to the unoptimized operation' do
+      should == object
+    end
+
+    it 'does not execute left_body#each' do
+      left_body.should_not_receive(:each)
+      subject
+    end
+
+    it_should_behave_like 'an optimize method'
+  end
+
+  context 'left and right are not empty relations' do
+    it { should equal(object) }
+
+    it 'does not execute left_body#each' do
+      left_body.should_not_receive(:each)
+      subject
+    end
+
+    it 'does not execute right_body#each' do
+      right_body.should_not_receive(:each)
+      subject
+    end
+
+    it_should_behave_like 'an optimize method'
+  end
+
+  context 'left and right are materialized relations' do
+    let(:left)  { Relation.new([ [ :id, Integer ] ],                    [ [ 1 ], [ 2 ] ])      }
+    let(:right) { Relation.new([ [ :id, Integer ], [ :name, String ] ], [ [ 2, 'Dan Kubb' ] ]) }
+
+    it { should eql(Relation::Materialized.new([ [ :id, Integer ], [ :name, String ] ], [ [ 2, 'Dan Kubb' ] ])) }
+
+    it 'returns an equivalent relation to the unoptimized operation' do
+      should == object
+    end
+
+    it_should_behave_like 'an optimize method'
+  end
+end