veritas-optimizer 0.0.4 → 0.0.5

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

@@ -168,7 +168,7 @@ describe Algebra::Restriction, '#optimize' do
     let(:predicate) { operand[:id].gte(1)                                }
 
     it 'pushes the object to each relation' do
-      should eql(left.restrict { |r| r[:id].gte(1) }.union(right.restrict { |r| r[:id].gte(1) }))
+      should eql(left.restrict { |r| r.id.gte(1) }.union(right.restrict { |r| r.id.gte(1) }))
     end
 
     it 'returns an equivalent relation to the unoptimized operation' do
@@ -184,8 +184,8 @@ describe Algebra::Restriction, '#optimize' do
   end
 
   context 'with an order operation' do
-    let(:operand)   { relation.order      }
-    let(:predicate) { operand[:id].gte(1) }
+    let(:operand)   { relation.sort_by { |r| r.id } }
+    let(:predicate) { operand[:id].gte(1)           }
 
     it 'cancels out the order' do
       should eql(relation.restrict { predicate })

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

@@ -8,7 +8,7 @@ describe Relation::Operation::Limit, '#optimize' do
   let(:body)       { [ [ 1 ], [ 2 ], [ 3 ] ].each             }
   let(:relation)   { Relation.new([ [ :id, Integer ] ], body) }
   let(:directions) { [ relation[:id] ]                        }
-  let(:order)      { relation.order { directions }            }
+  let(:order)      { relation.sort_by { directions }          }
   let(:operand)    { order                                    }
   let(:limit)      { 1                                        }
   let(:object)     { described_class.new(operand, limit)      }

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

@@ -8,7 +8,7 @@ describe Relation::Operation::Offset, '#optimize' do
   let(:body)       { [ [ 1 ], [ 2 ], [ 3 ] ].each             }
   let(:relation)   { Relation.new([ [ :id, Integer ] ], body) }
   let(:directions) { [ relation[:id] ]                        }
-  let(:order)      { relation.order { directions }            }
+  let(:order)      { relation.sort_by { directions }          }
   let(:operand)    { order                                    }
   let(:offset)     { 1                                        }
   let(:object)     { described_class.new(operand, offset)     }

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

@@ -25,7 +25,7 @@ describe Relation::Operation::Order, '#optimize' do
   context 'containing an optimizable relation' do
     let(:operand) { relation.project(relation.header) }
 
-    it { should eql(relation.order { directions }) }
+    it { should eql(relation.sort_by { directions }) }
 
     it 'returns an equivalent relation to the unoptimized operation' do
       should == object
@@ -40,9 +40,9 @@ describe Relation::Operation::Order, '#optimize' do
   end
 
   context 'containing an object operation' do
-    let(:operand) { relation.order { |r| [ r[:id].desc ] } }
+    let(:operand) { relation.sort_by { |r| [ r.id.desc ] } }
 
-    it { should eql(relation.order { directions }) }
+    it { should eql(relation.sort_by { directions }) }
 
     it 'returns an equivalent relation to the unoptimized operation' do
       should == object
@@ -57,9 +57,9 @@ describe Relation::Operation::Order, '#optimize' do
   end
 
   context 'containing a reverse operation' do
-    let(:operand) { relation.order.reverse }
+    let(:operand) { relation.sort_by { |r| r.id }.reverse }
 
-    it { should eql(relation.order) }
+    it { should eql(relation.sort_by { |r| r.id }) }
 
     it 'returns an equivalent relation to the unoptimized operation' do
       should == object
@@ -74,7 +74,7 @@ describe Relation::Operation::Order, '#optimize' do
   end
 
   context 'containing a limit(1) operation' do
-    let(:operand) { relation.order.take(1) }
+    let(:operand) { relation.sort_by { |r| r.id }.take(1) }
 
     it { should equal(operand) }
 

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

@@ -7,7 +7,7 @@ describe Relation::Operation::Reverse, '#optimize' do
 
   let(:body)     { [ [ 1 ], [ 2 ], [ 3 ] ].each             }
   let(:relation) { Relation.new([ [ :id, Integer ] ], body) }
-  let(:order)    { relation.order                           }
+  let(:order)    { relation.sort_by { |r| r.id }            }
   let(:operand)  { order                                    }
   let(:object)   { described_class.new(operand)             }
 
@@ -52,7 +52,7 @@ describe Relation::Operation::Reverse, '#optimize' do
   end
 
   context 'with an order operation' do
-    it { should eql(relation.order { object.directions }) }
+    it { should eql(relation.sort_by { object.directions }) }
 
     it 'returns an equivalent relation to the unoptimized operation' do
       should == object
@@ -69,7 +69,7 @@ describe Relation::Operation::Reverse, '#optimize' do
   context 'with an order operation when optimized' do
     let(:operand) { order.rename({}) }
 
-    it { should eql(relation.order { object.directions }) }
+    it { should eql(relation.sort_by { object.directions }) }
 
     it 'returns an equivalent relation to the unoptimized operation' do
       should == object

data/spec/spec_helper.rb

@@ -2,7 +2,8 @@
 
 require 'rubygems'
 require 'backports'
-require 'veritas/optimizer'
+require 'backports/basic_object'
+require 'veritas-optimizer'
 require 'spec'
 require 'spec/autorun'
 

data/spec/unit/veritas/optimizer/algebra/extension/order_operand/optimizable_spec.rb

@@ -10,7 +10,7 @@ describe Optimizer::Algebra::Extension::OrderOperand, '#optimizable?' do
   let(:object)   { described_class.new(relation)               }
 
   context 'when operand is an order' do
-    let(:operand) { base.order }
+    let(:operand) { base.sort_by { |r| r.id } }
 
     it { should be(true) }
   end

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

@@ -6,7 +6,7 @@ describe Optimizer::Algebra::Extension::OrderOperand, '#optimize' do
   subject { object.optimize }
 
   let(:base)     { Relation.new([ [ :id, Integer ] ], [].each) }
-  let(:operand)  { base.order                                  }
+  let(:operand)  { base.sort_by { |r| r.id }                   }
   let(:relation) { operand.extend {}                           }
   let(:object)   { described_class.new(relation)               }
 

data/spec/unit/veritas/optimizer/algebra/join/left_materialized_operand/optimizable_spec.rb

@@ -0,0 +1,42 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Optimizer::Algebra::Join::LeftMaterializedOperand, '#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 the left is materialized and right is not a restriction' do
+    let(:left)  { Relation.new([ [ :id, Integer ], [ :name, String  ] ], [ [ 1, 'Dan Kubb' ] ])      }
+    let(:right) { Relation.new([ [ :id, Integer ], [ :age,  Integer ] ], [ [ 1, 35         ] ].each) }
+
+    it { should be(true) }
+  end
+
+  context 'when the left is materialized and right is a restriction not matching the left' do
+    let(:left)  { Relation.new([ [ :id, Integer ], [ :name, String  ] ], [ [ 1, 'Dan Kubb' ] ])                                    }
+    let(:right) { Relation.new([ [ :id, Integer ], [ :age,  Integer ] ], [ [ 1, 35         ] ].each).restrict { |r| r.age.eq(35) } }
+
+    it { should be(true) }
+  end
+
+  context 'when the left is materialized and right is a restriction matching the left' do
+    let(:left)  { Relation.new([ [ :id, Integer ], [ :name, String  ] ], [ [ 1, 'Dan Kubb' ] ])                                  }
+    let(:right) { Relation.new([ [ :id, Integer ], [ :age,  Integer ] ], [ [ 1, 35         ] ].each).restrict { |r| r.id.eq(1) } }
+
+    it { should be(false) }
+  end
+
+  context 'when the left is not materialized' do
+    let(:left)  { Relation.new([ [ :id, Integer ], [ :name, String  ] ], [ [ 1, 'Dan Kubb' ] ].each) }
+    let(:right) { Relation.new([ [ :id, Integer ], [ :age,  Integer ] ], [ [ 1, 35         ] ].each) }
+
+    it { should be(false) }
+  end
+end

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

@@ -0,0 +1,55 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Optimizer::Algebra::Join::LeftMaterializedOperand, '#optimize' do
+  subject { object.optimize }
+
+  let(:relation) { left.join(right)              }
+  let(:object)   { described_class.new(relation) }
+
+  before do
+    object.should be_optimizable
+  end
+
+  context 'with no joined tuples' do
+    let(:left)  { Relation.new([ [ :id, Integer ],                    ], [])      }
+    let(:right) { Relation.new([ [ :id, Integer ], [ :age,  Integer ] ], [].each) }
+
+    it { should be_kind_of(Algebra::Join) }
+
+    its(:left) { should eql(Relation::Empty.new(left.header)) }
+
+    its(:right) { should eql(right.restrict { Function::Proposition::Contradiction.instance }) }
+  end
+
+  context 'with one joined tuple' do
+    let(:left)  { Relation.new([ [ :id, Integer ],                    ], [ [ 1,    ] ])      }
+    let(:right) { Relation.new([ [ :id, Integer ], [ :age,  Integer ] ], [ [ 1, 35 ] ].each) }
+
+    it { should be_kind_of(Algebra::Join) }
+
+    its(:left) { should equal(left) }
+
+    its(:right) { should eql(right.restrict { |r| r.id.eq(1) }) }
+
+    it 'is not further optimizable' do
+      described_class.new(subject).should_not be_optimizable
+    end
+  end
+
+  context 'with two or more joined tuples' do
+    let(:left)  { Relation.new([ [ :id, Integer ],                    ], [ [ 1,    ], [ 2,    ] ])      }
+    let(:right) { Relation.new([ [ :id, Integer ], [ :age,  Integer ] ], [ [ 1, 35 ], [ 2, 25 ] ].each) }
+
+    it { should be_kind_of(Algebra::Join) }
+
+    its(:left) { should equal(left) }
+
+    its(:right) { should eql(right.restrict { |r| r.id.include([ 1, 2 ]) }) }
+
+    it 'is not further optimizable' do
+      described_class.new(subject).should_not be_optimizable
+    end
+  end
+end

data/spec/unit/veritas/optimizer/algebra/join/right_materialized_operand/optimizable_spec.rb

@@ -0,0 +1,42 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Optimizer::Algebra::Join::RightMaterializedOperand, '#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 the right is materialized and left is not a restriction' do
+    let(:left)  { Relation.new([ [ :id, Integer ], [ :name, String  ] ], [ [ 1, 'Dan Kubb' ] ].each) }
+    let(:right) { Relation.new([ [ :id, Integer ], [ :age,  Integer ] ], [ [ 1, 35         ] ])      }
+
+    it { should be(true) }
+  end
+
+  context 'when the right is materialized and left is a restriction not matching the right' do
+    let(:left)  { Relation.new([ [ :id, Integer ], [ :name, String  ] ], [ [ 1, 'Dan Kubb' ] ].each).restrict { |r| r.name.eq('Dan Kubb') } }
+    let(:right) { Relation.new([ [ :id, Integer ], [ :age,  Integer ] ], [ [ 1, 35         ] ])                                             }
+
+    it { should be(true) }
+  end
+
+  context 'when the right is materialized and left is a restriction matching the right' do
+    let(:left)  { Relation.new([ [ :id, Integer ], [ :name, String  ] ], [ [ 1, 'Dan Kubb' ] ].each).restrict { |r| r.id.eq(1) } }
+    let(:right) { Relation.new([ [ :id, Integer ], [ :age,  Integer ] ], [ [ 1, 35         ] ])                                  }
+
+    it { should be(false) }
+  end
+
+  context 'when the left is not materialized' do
+    let(:left)  { Relation.new([ [ :id, Integer ], [ :name, String  ] ], [ [ 1, 'Dan Kubb' ] ].each) }
+    let(:right) { Relation.new([ [ :id, Integer ], [ :age,  Integer ] ], [ [ 1, 35         ] ].each) }
+
+    it { should be(false) }
+  end
+end

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

@@ -0,0 +1,55 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Optimizer::Algebra::Join::RightMaterializedOperand, '#optimize' do
+  subject { object.optimize }
+
+  let(:relation) { left.join(right)              }
+  let(:object)   { described_class.new(relation) }
+
+  before do
+    object.should be_optimizable
+  end
+
+  context 'with no joined tuples' do
+    let(:left)  { Relation.new([ [ :id, Integer ],                    ], [].each) }
+    let(:right) { Relation.new([ [ :id, Integer ], [ :age,  Integer ] ], [])      }
+
+    it { should be_kind_of(Algebra::Join) }
+
+    its(:left) { should eql(left.restrict { Function::Proposition::Contradiction.instance }) }
+
+    its(:right) { should eql(Relation::Empty.new(right.header)) }
+  end
+
+  context 'with one joined tuple' do
+    let(:left)  { Relation.new([ [ :id, Integer ],                    ], [ [ 1,    ] ].each) }
+    let(:right) { Relation.new([ [ :id, Integer ], [ :age,  Integer ] ], [ [ 1, 35 ] ])      }
+
+    it { should be_kind_of(Algebra::Join) }
+
+    its(:left) { should eql(left.restrict { |r| r.id.eq(1) }) }
+
+    its(:right) { should equal(right) }
+
+    it 'is not further optimizable' do
+      described_class.new(subject).should_not be_optimizable
+    end
+  end
+
+  context 'with two or more joined tuples' do
+    let(:left)  { Relation.new([ [ :id, Integer ],                    ], [ [ 1,    ], [ 2,    ] ].each) }
+    let(:right) { Relation.new([ [ :id, Integer ], [ :age,  Integer ] ], [ [ 1, 35 ], [ 2, 25 ] ])      }
+
+    it { should be_kind_of(Algebra::Join) }
+
+    its(:left) { should eql(left.restrict { |r| r.id.include([ 1, 2 ]) }) }
+
+    its(:right) { should equal(right) }
+
+    it 'is not further optimizable' do
+      described_class.new(subject).should_not be_optimizable
+    end
+  end
+end

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

@@ -15,7 +15,7 @@ describe Optimizer::Algebra::Rename::LimitOperand, '#optimizable?' do
   end
 
   context 'when the operand is an limit operation' do
-    let(:operand) { base.order.take(1) }
+    let(:operand) { base.sort_by { |r| r.id }.take(1) }
 
     it { should be(true) }
   end

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

@@ -7,7 +7,7 @@ describe Optimizer::Algebra::Rename::LimitOperand, '#optimize' do
 
   let(:header)   { Relation::Header.new([ [ :id, Integer ] ]) }
   let(:base)     { Relation.new(header, [ [ 1 ] ].each)       }
-  let(:order)    { base.order                                 }
+  let(:order)    { base.sort_by { |r| r.id }                  }
   let(:relation) { order.take(2).rename(:id => :other_id)     }
   let(:object)   { described_class.new(relation)              }
 

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

@@ -15,7 +15,7 @@ describe Optimizer::Algebra::Rename::OffsetOperand, '#optimizable?' do
   end
 
   context 'when the operand is an offset operation' do
-    let(:operand) { base.order.drop(1) }
+    let(:operand) { base.sort_by { |r| r.id }.drop(1) }
 
     it { should be(true) }
   end

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

@@ -7,7 +7,7 @@ describe Optimizer::Algebra::Rename::OffsetOperand, '#optimize' do
 
   let(:header)   { Relation::Header.new([ [ :id, Integer ] ]) }
   let(:base)     { Relation.new(header, [ [ 1 ] ].each)       }
-  let(:order)    { base.order                                 }
+  let(:order)    { base.sort_by { |r| r.id }                  }
   let(:relation) { order.drop(1).rename(:id => :other_id)     }
   let(:object)   { described_class.new(relation)              }
 

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

@@ -15,7 +15,7 @@ describe Optimizer::Algebra::Rename::OrderOperand, '#optimizable?' do
   end
 
   context 'when the operand is an order operation' do
-    let(:operand) { base.order }
+    let(:operand) { base.sort_by { |r| r.id } }
 
     it { should be(true) }
   end

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

@@ -6,7 +6,7 @@ describe Optimizer::Algebra::Rename::OrderOperand, '#optimize' do
   subject { object.optimize }
 
   let(:base)     { Relation.new([ [ :id, Integer ] ], [ [ 1 ] ].each) }
-  let(:operand)  { base.order                                         }
+  let(:operand)  { base.sort_by { |r| r.id }                          }
   let(:relation) { operand.rename(:id => :other_id)                   }
   let(:object)   { described_class.new(relation)                      }
 

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

@@ -14,7 +14,7 @@ describe Optimizer::Algebra::Rename::ReverseOperand, '#optimizable?' do
   end
 
   context 'when the operand is an reverse operation' do
-    let(:operand) { base.order.take(2).reverse }
+    let(:operand) { base.sort_by { |r| r.id }.take(2).reverse }
 
     it { should be(true) }
   end

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

@@ -6,7 +6,7 @@ describe Optimizer::Algebra::Rename::ReverseOperand, '#optimize' do
   subject { object.optimize }
 
   let(:base)     { Relation.new([ [ :id, Integer ] ], [ [ 1 ] ].each) }
-  let(:limit)    { base.order.take(2)                                 }
+  let(:limit)    { base.sort_by { |r| r.id }.take(2)                  }
   let(:operand)  { limit.rename({}).reverse                           }
   let(:relation) { operand.rename(:id => :other_id)                   }
   let(:object)   { described_class.new(relation)                      }

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

@@ -0,0 +1,41 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Optimizer::Algebra::Restriction::CombinationOperand, '#optimizable?' do
+  subject { object.optimizable? }
+
+  let(:left)      { Relation.new([ [ :id, Integer ], [ :user_name,     String ] ], [ [ 1, 'Dan Kubb' ] ].each) }
+  let(:right)     { Relation.new([ [ :id, Integer ], [ :employee_name, String ] ], [ [ 2, 'Dan Kubb' ] ].each) }
+  let(:operand)   { left.join(right)                                                                           }
+  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 predicate distributes to the left' do
+    let(:predicate) { left[:user_name].eq('Dan Kubb') }
+
+    it { should be(true) }
+  end
+
+  context 'when the predicate distributes to the right' do
+    let(:predicate) { right[:employee_name].eq('Dan Kubb') }
+
+    it { should be(true) }
+  end
+
+  context 'when the predicate distributes to the left and right' do
+    let(:predicate) { left[:id].eq(1) }
+
+    it { should be(true) }
+  end
+
+  context 'when the predicate does not distribute to the left or right' do
+    let(:predicate) { left[:user_name].eq(right[:employee_name]) }
+
+    it { should be(false) }
+  end
+end

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

@@ -0,0 +1,35 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Optimizer::Algebra::Restriction::CombinationOperand, '#optimize' do
+  subject { object.optimize }
+
+  let(:left)     { Relation.new([ [ :id, Integer ], [ :user_name,     String ] ], [ [ 1, 'Dan Kubb' ] ].each) }
+  let(:right)    { Relation.new([ [ :id, Integer ], [ :employee_name, String ] ], [ [ 2, 'Dan Kubb' ] ].each) }
+  let(:operand)  { left.join(right)                                                                           }
+  let(:relation) { operand.restrict { false }                                                                 }
+  let(:object)   { described_class.new(relation)                                                              }
+
+  before do
+    object.should be_optimizable
+  end
+
+  specify { expect { subject }.to raise_error(NotImplementedError, 'Veritas::Optimizer::Algebra::Restriction::CombinationOperand#relation_method must be implemented') }
+
+  context 'with a defined relation_method' do
+    let(:described_class) { Class.new(Optimizer::Algebra::Restriction::CombinationOperand) }
+
+    before do
+      described_class.class_eval do
+        def relation_method
+          :join
+        end
+      end
+    end
+
+    it 'returns an join with a distributed restriction' do
+      should eql(left.restrict { false }.join(right.restrict { false }).restrict { false })
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Optimizer::Algebra::Restriction::JoinOperand, '#optimizable?' do
+  subject { object.optimizable? }
+
+  let(:left)     { Relation.new([ [ :id, Integer ], [ :user_name,     String ] ], [ [ 1, 'Dan Kubb' ] ].each) }
+  let(:right)    { Relation.new([ [ :id, Integer ], [ :employee_name, String ] ], [ [ 2, 'Dan Kubb' ] ].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 is a join operation and the predicate distributes to the left' do
+    let(:operand)   { left.join(right)                }
+    let(:predicate) { left[:user_name].eq('Dan Kubb') }
+
+    it { should be(true) }
+  end
+
+  context 'when the operand is a join operation and the predicate distributes to the right' do
+    let(:operand)   { left.join(right)                     }
+    let(:predicate) { right[:employee_name].eq('Dan Kubb') }
+
+    it { should be(true) }
+  end
+
+  context 'when the operand is a join operation and the predicate distributes to the left and right' do
+    let(:operand)   { left.join(right) }
+    let(:predicate) { left[:id].eq(1)  }
+
+    it { should be(true) }
+  end
+
+  context 'when the operand is a join operation and the predicate does not distribute to the left or right' do
+    let(:operand)   { left.join(right)                           }
+    let(:predicate) { left[:user_name].eq(right[:employee_name]) }
+
+    it { should be(false) }
+  end
+
+  context 'when the operand is not a join operation' do
+    let(:operand)   { left }
+    let(:predicate) { true }
+
+    it { should be(false) }
+  end
+end

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

@@ -0,0 +1,48 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Optimizer::Algebra::Restriction::JoinOperand, '#optimize' do
+  subject { object.optimize }
+
+  let(:left)                { Relation.new([ [ :id, Integer ], [ :user_name,     String ] ], [ [ 1, 'Dan Kubb' ] ].each) }
+  let(:right)               { Relation.new([ [ :id, Integer ], [ :employee_name, String ] ], [ [ 2, 'Dan Kubb' ] ].each) }
+  let(:operand)             { left.join(right)                                                                           }
+  let(:left_predicate)      { left[:user_name].eq('Dan Kubb')                                                            }
+  let(:right_predicate)     { right[:employee_name].eq('Dan Kubb')                                                       }
+  let(:remainder_predicate) { left[:user_name].eq(right[:employee_name])                                                 }
+  let(:predicate)           { left_predicate.and(right_predicate).and(remainder_predicate)                               }
+  let(:relation)            { operand.restrict { predicate }                                                             }
+  let(:object)              { described_class.new(relation)                                                              }
+
+  before do
+    object.should be_optimizable
+  end
+
+  it { should be_kind_of(Algebra::Restriction) }
+
+  its(:operand) { should be_kind_of(Algebra::Join) }
+
+  it 'wraps the left operand of the join in a restriction' do
+    left_operand = subject.operand.left
+    left_operand.operand.should equal(left)
+    left_operand.should be_kind_of(Algebra::Restriction)
+  end
+
+  it 'wraps the right operand of the join in a restriction' do
+    right_operand = subject.operand.right
+    right_operand.operand.should equal(right)
+    right_operand.should be_kind_of(Algebra::Restriction)
+  end
+
+  it 'distributes the applicable part of the predicate to the left' do
+    subject.operand.left.predicate.should equal(left_predicate)
+  end
+
+  it 'distributes the applicable part of the predicate to the right' do
+    subject.operand.right.predicate.should equal(right_predicate)
+  end
+
+  # keeps the remainder that applies to the left and right
+  its(:predicate) { should equal(remainder_predicate) }
+end

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

@@ -15,7 +15,7 @@ describe Optimizer::Algebra::Restriction::OrderOperand, '#optimizable?' do
   end
 
   context 'when the operand is an order operation' do
-    let(:operand) { base.order }
+    let(:operand) { base.sort_by { |r| r.id } }
 
     it { should be(true) }
   end

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

@@ -7,7 +7,7 @@ describe Optimizer::Algebra::Restriction::OrderOperand, '#optimize' do
 
   let(:base)      { Relation.new([ [ :id, Integer ] ], [ [ 1 ] ].each) }
   let(:predicate) { base[:id].eq(1)                                    }
-  let(:relation)  { base.order.restrict { predicate }                  }
+  let(:relation)  { base.sort_by { |r| r.id }.restrict { predicate }   }
   let(:object)    { described_class.new(relation)                      }
 
   before do