veritas-optimizer 0.0.4 → 0.0.5

data/spec/unit/veritas/optimizer/predicate_partition/remainder_spec.rb

@@ -0,0 +1,149 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Optimizer::PredicatePartition, '#remainder' do
+  subject { object.remainder }
+
+  let(:left_header)  { Relation::Header.new([ [ :id, Integer ], [ :user_name,     String ], Attribute::Boolean.new(:active_user),     Attribute::Boolean.new(:active) ]) }
+  let(:right_header) { Relation::Header.new([ [ :id, Integer ], [ :employee_name, String ], Attribute::Boolean.new(:active_employee), Attribute::Boolean.new(:active) ]) }
+  let(:object)       { described_class.new(predicate, left_header, right_header)                                                                                         }
+
+  context 'when the predicate is a tautology' do
+    let(:predicate) { Function::Proposition::Tautology.instance }
+
+    it 'partitions the predicate to the remainder' do
+      should equal(Function::Proposition::Tautology.instance)
+    end
+  end
+
+  context 'when the predicate is a contradiction' do
+    let(:predicate) { Function::Proposition::Contradiction.instance }
+
+    it 'partitions the predicate to the remainder' do
+      should equal(Function::Proposition::Contradiction.instance)
+    end
+  end
+
+  context 'when the predicate is an attribute' do
+    context 'with an attribute from the left header, but not the right header' do
+      let(:predicate) { left_header[:active_user] }
+
+      it 'does not partition the predicate to the remainder' do
+        should equal(Function::Proposition::Tautology.instance)
+      end
+    end
+
+    context 'with an attribute from the right header, but not the left header' do
+      let(:predicate) { right_header[:active_employee] }
+
+      it 'does not partition the predicate to the remainder' do
+        should equal(Function::Proposition::Tautology.instance)
+      end
+    end
+
+    context 'with an attribute from the left and right header' do
+      let(:predicate) { left_header[:active] }
+
+      it 'does not partition the predicate to the remainder' do
+        should equal(Function::Proposition::Tautology.instance)
+      end
+    end
+  end
+
+  context 'when the predicate is a binary predicate' do
+    context 'with an attribute from the left header, but not the right header' do
+      let(:predicate) { left_header[:user_name].eq('Dan Kubb') }
+
+      it 'does not partition the predicate to the remainder' do
+        should equal(Function::Proposition::Tautology.instance)
+      end
+    end
+
+    context 'with an attribute from the right header, but not the left header' do
+      let(:predicate) { right_header[:employee_name].eq('Dan Kubb') }
+
+      it 'does not partition the predicate to the remainder' do
+        should equal(Function::Proposition::Tautology.instance)
+      end
+    end
+
+    context 'with an attribute from the left and right header' do
+      let(:predicate) { left_header[:id].eq(1) }
+
+      it 'does not partition the predicate to the remainder' do
+        should equal(Function::Proposition::Tautology.instance)
+      end
+    end
+
+    context 'with an attribute from the left header, and an attribute from the left and right header' do
+      let(:predicate) { left_header[:active_user].eq(left_header[:active]) }
+
+      it 'does not partition the predicate to the remainder' do
+        should equal(Function::Proposition::Tautology.instance)
+      end
+    end
+
+    context 'with an attribute from the right header, and an attribute from the left and right header' do
+      let(:predicate) { right_header[:active_employee].eq(left_header[:active]) }
+
+      it 'does not partition the predicate to the remainder' do
+        should equal(Function::Proposition::Tautology.instance)
+      end
+    end
+
+    context 'with disjoint attributes from the left and right header' do
+      let(:predicate) { left_header[:user_name].eq(right_header[:employee_name]) }
+
+      it 'partitions the predicate to the remainder' do
+        should equal(predicate)
+      end
+    end
+  end
+
+  context 'when the predicate is a negation' do
+    context 'with an attribute from the left header, but not the right header' do
+      let(:predicate) { Function::Connective::Negation.new(left_header[:active_user]) }
+
+      it 'does not partition the predicate to the remainder' do
+        should equal(Function::Proposition::Tautology.instance)
+      end
+    end
+
+    context 'with an attribute from the right header, but not the left header' do
+      let(:predicate) { Function::Connective::Negation.new(right_header[:active_employee]) }
+
+      it 'does not partition the predicate to the remainder' do
+        should equal(Function::Proposition::Tautology.instance)
+      end
+    end
+
+    context 'with an attribute from the left and right header' do
+      let(:predicate) { Function::Connective::Negation.new(left_header[:active]) }
+
+      it 'does not partition the predicate to the remainder' do
+        should equal(Function::Proposition::Tautology.instance)
+      end
+    end
+  end
+
+  context 'when the predicate is a conjunction' do
+    let(:left_predicate)  { left_header[:user_name].eq('Dan Kubb')      }
+    let(:right_predicate) { right_header[:employee_name].eq('Dan Kubb') }
+    let(:predicate)       { left_predicate.and(right_predicate)         }
+
+    it 'does not partition the predicate to the remainder' do
+      should equal(Function::Proposition::Tautology.instance)
+    end
+  end
+
+  context 'when the predicate is a disjunction' do
+    let(:left_predicate)  { left_header[:user_name].eq('Dan Kubb')      }
+    let(:right_predicate) { right_header[:employee_name].eq('Dan Kubb') }
+    let(:predicate)       { left_predicate.or(right_predicate)          }
+
+    it 'does not partition the predicate to the remainder' do
+      should equal(Function::Proposition::Tautology.instance)
+    end
+  end
+end

data/spec/unit/veritas/optimizer/predicate_partition/right_spec.rb

@@ -0,0 +1,149 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Optimizer::PredicatePartition, '#right' do
+  subject { object.right }
+
+  let(:left_header)  { Relation::Header.new([ [ :id, Integer ], [ :user_name,     String ], Attribute::Boolean.new(:active_user),     Attribute::Boolean.new(:active) ]) }
+  let(:right_header) { Relation::Header.new([ [ :id, Integer ], [ :employee_name, String ], Attribute::Boolean.new(:active_employee), Attribute::Boolean.new(:active) ]) }
+  let(:object)       { described_class.new(predicate, left_header, right_header)                                                                                         }
+
+  context 'when the predicate is a tautology' do
+    let(:predicate) { Function::Proposition::Tautology.instance }
+
+    it 'partitions the predicate to the right' do
+      should equal(Function::Proposition::Tautology.instance)
+    end
+  end
+
+  context 'when the predicate is a contradiction' do
+    let(:predicate) { Function::Proposition::Contradiction.instance }
+
+    it 'partitions the predicate to the right' do
+      should equal(Function::Proposition::Contradiction.instance)
+    end
+  end
+
+  context 'when the predicate is an attribute' do
+    context 'with an attribute from the left header, but not the right header' do
+      let(:predicate) { left_header[:active_user] }
+
+      it 'does not partition the predicate to the left' do
+        should equal(Function::Proposition::Tautology.instance)
+      end
+    end
+
+    context 'with an attribute from the right header, but not the left header' do
+      let(:predicate) { right_header[:active_employee] }
+
+      it 'partitions the predicate to the right' do
+        should equal(predicate)
+      end
+    end
+
+    context 'with an attribute from the left and right header' do
+      let(:predicate) { right_header[:active] }
+
+      it 'partitions the predicate to the right' do
+        should equal(predicate)
+      end
+    end
+  end
+
+  context 'when the predicate is a binary predicate' do
+    context 'with an attribute from the left header, but not the right header' do
+      let(:predicate) { left_header[:user_name].eq('Dan Kubb') }
+
+      it 'does not partition the predicate to the right' do
+        should equal(Function::Proposition::Tautology.instance)
+      end
+    end
+
+    context 'with an attribute from the right header, but not the left header' do
+      let(:predicate) { right_header[:employee_name].eq('Dan Kubb') }
+
+      it 'partitions the predicate to the right' do
+        should equal(predicate)
+      end
+    end
+
+    context 'with an attribute from the left and right header' do
+      let(:predicate) { right_header[:id].eq(1) }
+
+      it 'partitions the predicate to the right' do
+        should equal(predicate)
+      end
+    end
+
+    context 'with an attribute from the left header, and an attribute from the left and right header' do
+      let(:predicate) { left_header[:active_user].eq(right_header[:active]) }
+
+      it 'partitions the predicate to the right' do
+        should equal(predicate)
+      end
+    end
+
+    context 'with an attribute from the right header, and an attribute from the left and right header' do
+      let(:predicate) { right_header[:active_employee].eq(right_header[:active]) }
+
+      it 'partitions the predicate to the right' do
+        should equal(predicate)
+      end
+    end
+
+    context 'with disjoint attributes from the left and right header' do
+      let(:predicate) { left_header[:user_name].eq(right_header[:employee_name]) }
+
+      it 'does not partition the predicate to the right' do
+        should equal(Function::Proposition::Tautology.instance)
+      end
+    end
+  end
+
+  context 'when the predicate is a negation' do
+    context 'with an attribute from the left header, but not the right header' do
+      let(:predicate) { Function::Connective::Negation.new(left_header[:active_user]) }
+
+      it 'does not partition the predicate to the left' do
+        should equal(Function::Proposition::Tautology.instance)
+      end
+    end
+
+    context 'with an attribute from the right header, but not the left header' do
+      let(:predicate) { Function::Connective::Negation.new(right_header[:active_employee]) }
+
+      it 'partitions the predicate to the right' do
+        should equal(predicate)
+      end
+    end
+
+    context 'with an attribute from the left and right header' do
+      let(:predicate) { Function::Connective::Negation.new(right_header[:active]) }
+
+      it 'partitions the predicate to the right' do
+        should equal(predicate)
+      end
+    end
+  end
+
+  context 'when the predicate is a conjunction' do
+    let(:left_predicate)  { left_header[:user_name].eq('Dan Kubb')      }
+    let(:right_predicate) { right_header[:employee_name].eq('Dan Kubb') }
+    let(:predicate)       { left_predicate.and(right_predicate)         }
+
+    it 'partitions the predicate to the right that reference the right header' do
+      should equal(right_predicate)
+    end
+  end
+
+  context 'when the predicate is a disjunction' do
+    let(:left_predicate)  { left_header[:user_name].eq('Dan Kubb')      }
+    let(:right_predicate) { right_header[:employee_name].eq('Dan Kubb') }
+    let(:predicate)       { left_predicate.or(right_predicate)          }
+
+    it 'partitions the predicate to the right that reference the right header, transforming it with De Morgan\'s Law' do
+      should eql(right_header[:employee_name].ne('Dan Kubb'))
+    end
+  end
+end

data/spec/unit/veritas/optimizer/relation/operation/binary/left_order_operand/optimizable_spec.rb

@@ -10,7 +10,7 @@ describe Optimizer::Relation::Operation::Binary::LeftOrderOperand, '#optimizable
   let(:object)   { described_class.new(relation)                    }
 
   context 'when left is an order' do
-    let(:left) { Relation.new([ [ :id, Integer ] ], [].each).order }
+    let(:left) { Relation.new([ [ :id, Integer ] ], [].each).sort_by { |r| r.id } }
 
     it { should be(true) }
   end

data/spec/unit/veritas/optimizer/relation/operation/binary/left_order_operand/optimize_spec.rb

@@ -6,7 +6,7 @@ describe Optimizer::Relation::Operation::Binary::LeftOrderOperand, '#optimize' d
   subject { object.optimize }
 
   let(:base)     { Relation.new([ [ :id, Integer ] ], [].each) }
-  let(:left)     { base.order                                  }
+  let(:left)     { base.sort_by { |r| r.id }                   }
   let(:right)    { base                                        }
   let(:relation) { left.union(right)                           }
   let(:object)   { described_class.new(relation)               }

data/spec/unit/veritas/optimizer/relation/operation/binary/{materialized_operand → materialized_operands}/optimizable_spec.rb

@@ -2,7 +2,7 @@
 
 require 'spec_helper'
 
-describe Optimizer::Relation::Operation::Binary::MaterializedOperand, '#optimizable?' do
+describe Optimizer::Relation::Operation::Binary::MaterializedOperands, '#optimizable?' do
   subject { object.optimizable? }
 
   let(:materialized)     { Relation::Materialized.new([ [ :id, Integer ] ], [ [ 1 ] ]) }

data/spec/unit/veritas/optimizer/relation/operation/binary/{materialized_operand → materialized_operands}/optimize_spec.rb

@@ -2,7 +2,7 @@
 
 require 'spec_helper'
 
-describe Optimizer::Relation::Operation::Binary::MaterializedOperand, '#optimize' do
+describe Optimizer::Relation::Operation::Binary::MaterializedOperands, '#optimize' do
   subject { object.optimize }
 
   let(:left)     { Relation.new([ [ :id, Integer ] ], [ [ 1 ] ]) }

data/spec/unit/veritas/optimizer/relation/operation/binary/right_order_operand/optimizable_spec.rb

@@ -10,7 +10,7 @@ describe Optimizer::Relation::Operation::Binary::RightOrderOperand, '#optimizabl
   let(:object)   { described_class.new(relation)                    }
 
   context 'when right is an order' do
-    let(:right) { Relation.new([ [ :id, Integer ] ], [].each).order }
+    let(:right) { Relation.new([ [ :id, Integer ] ], [].each).sort_by { |r| r.id } }
 
     it { should be(true) }
   end

data/spec/unit/veritas/optimizer/relation/operation/binary/right_order_operand/optimize_spec.rb

@@ -7,7 +7,7 @@ describe Optimizer::Relation::Operation::Binary::RightOrderOperand, '#optimize'
 
   let(:base)     { Relation.new([ [ :id, Integer ] ], [].each) }
   let(:left)     { base                                        }
-  let(:right)    { base.order                                  }
+  let(:right)    { base.sort_by { |r| r.id }                   }
   let(:relation) { left.union(right)                           }
   let(:object)   { described_class.new(relation)               }
 

data/spec/unit/veritas/optimizer/relation/operation/limit/equal_limit_operand/optimizable_spec.rb

@@ -5,9 +5,9 @@ require 'spec_helper'
 describe Optimizer::Relation::Operation::Limit::EqualLimitOperand, '#optimizable?' do
   subject { object.optimizable? }
 
-  let(:base)     { Relation.new([ [ :id, Integer ] ], [ [ 1 ] ].each).order }
-  let(:relation) { operand.take(1)                                          }
-  let(:object)   { described_class.new(relation)                            }
+  let(:base)     { Relation.new([ [ :id, Integer ] ], [ [ 1 ] ].each).sort_by { |r| r.id } }
+  let(:relation) { operand.take(1)                                                         }
+  let(:object)   { described_class.new(relation)                                           }
 
   before do
     object.operation.should be_kind_of(Relation::Operation::Limit)

data/spec/unit/veritas/optimizer/relation/operation/limit/equal_limit_operand/optimize_spec.rb

@@ -5,10 +5,10 @@ require 'spec_helper'
 describe Optimizer::Relation::Operation::Limit::EqualLimitOperand, '#optimize' do
   subject { object.optimize }
 
-  let(:order)    { Relation.new([ [ :id, Integer ] ], [ [ 1 ] ].each).order }
-  let(:limit)    { order.take(1)                                            }
-  let(:relation) { limit.take(1)                                            }
-  let(:object)   { described_class.new(relation)                            }
+  let(:order)    { Relation.new([ [ :id, Integer ] ], [ [ 1 ] ].each).sort_by { |r| r.id } }
+  let(:limit)    { order.take(1)                                                           }
+  let(:relation) { limit.take(1)                                                           }
+  let(:object)   { described_class.new(relation)                                           }
 
   before do
     object.should be_optimizable

data/spec/unit/veritas/optimizer/relation/operation/limit/limit_operand/optimizable_spec.rb

@@ -5,9 +5,9 @@ require 'spec_helper'
 describe Optimizer::Relation::Operation::Limit::LimitOperand, '#optimizable?' do
   subject { object.optimizable? }
 
-  let(:base)     { Relation.new([ [ :id, Integer ] ], [ [ 1 ] ].each).order }
-  let(:relation) { operand.take(1)                                          }
-  let(:object)   { described_class.new(relation)                            }
+  let(:base)     { Relation.new([ [ :id, Integer ] ], [ [ 1 ] ].each).sort_by { |r| r.id } }
+  let(:relation) { operand.take(1)                                                         }
+  let(:object)   { described_class.new(relation)                                           }
 
   before do
     object.operation.should be_kind_of(Relation::Operation::Limit)

data/spec/unit/veritas/optimizer/relation/operation/limit/limit_operand/optimize_spec.rb

@@ -5,9 +5,9 @@ require 'spec_helper'
 describe Optimizer::Relation::Operation::Limit::LimitOperand, '#optimize' do
   subject { object.optimize }
 
-  let(:order)  { Relation.new([ [ :id, Integer ] ], [ [ 1 ] ].each).order }
-  let(:limit)  { order.take(2)                                            }
-  let(:object) { described_class.new(relation)                            }
+  let(:order)  { Relation.new([ [ :id, Integer ] ], [ [ 1 ] ].each).sort_by { |r| r.id } }
+  let(:limit)  { order.take(2)                                                           }
+  let(:object) { described_class.new(relation)                                           }
 
   before do
     object.should be_optimizable

data/spec/unit/veritas/optimizer/relation/operation/limit/unoptimized_operand/optimizable_spec.rb

@@ -5,10 +5,10 @@ require 'spec_helper'
 describe Optimizer::Relation::Operation::Limit::UnoptimizedOperand, '#optimizable?' do
   subject { object.optimizable? }
 
-  let(:header)   { Relation::Header.new([ [ :id, Integer ] ]) }
-  let(:base)     { Relation.new(header, [ [ 1 ] ].each).order }
-  let(:relation) { operand.take(1)                            }
-  let(:object)   { described_class.new(relation)              }
+  let(:header)   { Relation::Header.new([ [ :id, Integer ] ])                }
+  let(:base)     { Relation.new(header, [ [ 1 ] ].each).sort_by { |r| r.id } }
+  let(:relation) { operand.take(1)                                           }
+  let(:object)   { described_class.new(relation)                             }
 
   before do
     object.operation.should be_kind_of(Relation::Operation::Limit)

data/spec/unit/veritas/optimizer/relation/operation/limit/unoptimized_operand/optimize_spec.rb

@@ -5,10 +5,10 @@ require 'spec_helper'
 describe Optimizer::Relation::Operation::Limit::UnoptimizedOperand, '#optimize' do
   subject { object.optimize }
 
-  let(:header)   { Relation::Header.new([ [ :id, Integer ] ]) }
-  let(:order)    { Relation.new(header, [ [ 1 ] ].each).order }
-  let(:relation) { order.rename({}).take(1)                   }
-  let(:object)   { described_class.new(relation)              }
+  let(:header)   { Relation::Header.new([ [ :id, Integer ] ])                }
+  let(:order)    { Relation.new(header, [ [ 1 ] ].each).sort_by { |r| r.id } }
+  let(:relation) { order.rename({}).take(1)                                  }
+  let(:object)   { described_class.new(relation)                             }
 
   before do
     object.should be_optimizable

data/spec/unit/veritas/optimizer/relation/operation/limit/zero_limit/optimizable_spec.rb

@@ -5,9 +5,9 @@ require 'spec_helper'
 describe Optimizer::Relation::Operation::Limit::ZeroLimit, '#optimizable?' do
   subject { object.optimizable? }
 
-  let(:base)     { Relation.new([ [ :id, Integer ] ], [ [ 1 ] ].each).order }
-  let(:relation) { base.take(limit)                                         }
-  let(:object)   { described_class.new(relation)                            }
+  let(:base)     { Relation.new([ [ :id, Integer ] ], [ [ 1 ] ].each).sort_by { |r| r.id } }
+  let(:relation) { base.take(limit)                                                        }
+  let(:object)   { described_class.new(relation)                                           }
 
   before do
     object.operation.should be_kind_of(Relation::Operation::Limit)

data/spec/unit/veritas/optimizer/relation/operation/limit/zero_limit/optimize_spec.rb

@@ -5,10 +5,10 @@ require 'spec_helper'
 describe Optimizer::Relation::Operation::Limit::ZeroLimit, '#optimize' do
   subject { object.optimize }
 
-  let(:header)   { Relation::Header.new([ [ :id, Integer ] ]) }
-  let(:order)    { Relation.new(header, [ [ 1 ] ].each).order }
-  let(:relation) { order.take(0)                              }
-  let(:object)   { described_class.new(relation)              }
+  let(:header)   { Relation::Header.new([ [ :id, Integer ] ])                }
+  let(:order)    { Relation.new(header, [ [ 1 ] ].each).sort_by { |r| r.id } }
+  let(:relation) { order.take(0)                                             }
+  let(:object)   { described_class.new(relation)                             }
 
   before do
     object.should be_optimizable

data/spec/unit/veritas/optimizer/relation/operation/offset/offset_operand/optimizable_spec.rb

@@ -5,9 +5,9 @@ require 'spec_helper'
 describe Optimizer::Relation::Operation::Offset::OffsetOperand, '#optimizable?' do
   subject { object.optimizable? }
 
-  let(:base)     { Relation.new([ [ :id, Integer ] ], [ [ 1 ] ].each).order }
-  let(:relation) { operand.drop(1)                                          }
-  let(:object)   { described_class.new(relation)                            }
+  let(:base)     { Relation.new([ [ :id, Integer ] ], [ [ 1 ] ].each).sort_by { |r| r.id } }
+  let(:relation) { operand.drop(1)                                                         }
+  let(:object)   { described_class.new(relation)                                           }
 
   before do
     object.operation.should be_kind_of(Relation::Operation::Offset)

data/spec/unit/veritas/optimizer/relation/operation/offset/offset_operand/optimize_spec.rb

@@ -5,9 +5,9 @@ require 'spec_helper'
 describe Optimizer::Relation::Operation::Offset::OffsetOperand, '#optimize' do
   subject { object.optimize }
 
-  let(:order)    { Relation.new([ [ :id, Integer ] ], [ [ 1 ] ].each).order }
-  let(:relation) { order.drop(1).drop(2)                                    }
-  let(:object)   { described_class.new(relation)                            }
+  let(:order)    { Relation.new([ [ :id, Integer ] ], [ [ 1 ] ].each).sort_by { |r| r.id } }
+  let(:relation) { order.drop(1).drop(2)                                                   }
+  let(:object)   { described_class.new(relation)                                           }
 
   before do
     object.should be_optimizable

data/spec/unit/veritas/optimizer/relation/operation/offset/unoptimized_operand/optimizable_spec.rb

@@ -5,10 +5,10 @@ require 'spec_helper'
 describe Optimizer::Relation::Operation::Offset::UnoptimizedOperand, '#optimizable?' do
   subject { object.optimizable? }
 
-  let(:header)   { Relation::Header.new([ [ :id, Integer ] ]) }
-  let(:base)     { Relation.new(header, [ [ 1 ] ].each).order }
-  let(:relation) { operand.drop(1)                            }
-  let(:object)   { described_class.new(relation)              }
+  let(:header)   { Relation::Header.new([ [ :id, Integer ] ])                }
+  let(:base)     { Relation.new(header, [ [ 1 ] ].each).sort_by { |r| r.id } }
+  let(:relation) { operand.drop(1)                                           }
+  let(:object)   { described_class.new(relation)                             }
 
   before do
     object.operation.should be_kind_of(Relation::Operation::Offset)

data/spec/unit/veritas/optimizer/relation/operation/offset/unoptimized_operand/optimize_spec.rb

@@ -5,10 +5,10 @@ require 'spec_helper'
 describe Optimizer::Relation::Operation::Offset::UnoptimizedOperand, '#optimize' do
   subject { object.optimize }
 
-  let(:header)   { Relation::Header.new([ [ :id, Integer ] ]) }
-  let(:order)    { Relation.new(header, [ [ 1 ] ].each).order }
-  let(:relation) { order.rename({}).drop(1)                   }
-  let(:object)   { described_class.new(relation)              }
+  let(:header)   { Relation::Header.new([ [ :id, Integer ] ])                }
+  let(:order)    { Relation.new(header, [ [ 1 ] ].each).sort_by { |r| r.id } }
+  let(:relation) { order.rename({}).drop(1)                                  }
+  let(:object)   { described_class.new(relation)                             }
 
   before do
     object.should be_optimizable

data/spec/unit/veritas/optimizer/relation/operation/offset/zero_offset/optimizable_spec.rb

@@ -5,9 +5,9 @@ require 'spec_helper'
 describe Optimizer::Relation::Operation::Offset::ZeroOffset, '#optimizable?' do
   subject { object.optimizable? }
 
-  let(:base)     { Relation.new([ [ :id, Integer ] ], [ [ 1 ] ].each).order }
-  let(:relation) { base.drop(offset)                                        }
-  let(:object)   { described_class.new(relation)                            }
+  let(:base)     { Relation.new([ [ :id, Integer ] ], [ [ 1 ] ].each).sort_by { |r| r.id } }
+  let(:relation) { base.drop(offset)                                                       }
+  let(:object)   { described_class.new(relation)                                           }
 
   before do
     object.operation.should be_kind_of(Relation::Operation::Offset)

data/spec/unit/veritas/optimizer/relation/operation/offset/zero_offset/optimize_spec.rb

@@ -5,9 +5,9 @@ require 'spec_helper'
 describe Optimizer::Relation::Operation::Offset::ZeroOffset, '#optimize' do
   subject { object.optimize }
 
-  let(:order)    { Relation.new([ [ :id, Integer ] ], [ [ 1 ] ].each).order }
-  let(:relation) { order.drop(0)                                            }
-  let(:object)   { described_class.new(relation)                            }
+  let(:order)    { Relation.new([ [ :id, Integer ] ], [ [ 1 ] ].each).sort_by { |r| r.id } }
+  let(:relation) { order.drop(0)                                                           }
+  let(:object)   { described_class.new(relation)                                           }
 
   before do
     object.should be_optimizable

data/spec/unit/veritas/optimizer/relation/operation/order/one_limit_operand/optimizable_spec.rb

@@ -6,7 +6,7 @@ describe Optimizer::Relation::Operation::Order::OneLimitOperand, '#optimizable?'
   subject { object.optimizable? }
 
   let(:base)     { Relation.new([ [ :id, Integer ] ], [ [ 1 ] ].each) }
-  let(:relation) { operand.order                                      }
+  let(:relation) { operand.sort_by { |r| r.id }                       }
   let(:object)   { described_class.new(relation)                      }
 
   before do
@@ -14,13 +14,13 @@ describe Optimizer::Relation::Operation::Order::OneLimitOperand, '#optimizable?'
   end
 
   context 'when the operand is limited to 1' do
-    let(:operand) { base.order.take(1) }
+    let(:operand) { base.sort_by { |r| r.id }.take(1) }
 
     it { should be(true) }
   end
 
   context 'when the operand is not limited to 1' do
-    let(:operand) { base.order.take(2) }
+    let(:operand) { base.sort_by { |r| r.id }.take(2) }
 
     it { should be(false) }
   end

data/spec/unit/veritas/optimizer/relation/operation/order/one_limit_operand/optimize_spec.rb

@@ -6,8 +6,8 @@ describe Optimizer::Relation::Operation::Order::OneLimitOperand, '#optimize' do
   subject { object.optimize }
 
   let(:base)     { Relation.new([ [ :id, Integer ] ], [ [ 1 ] ].each) }
-  let(:limit)    { base.order.take(1)                                 }
-  let(:relation) { limit.order                                        }
+  let(:limit)    { base.sort_by { |r| r.id }.take(1)                  }
+  let(:relation) { limit.sort_by { |r| r.id }                         }
   let(:object)   { described_class.new(relation)                      }
 
   before do

data/spec/unit/veritas/optimizer/relation/operation/order/order_operand/optimizable_spec.rb

@@ -6,7 +6,7 @@ describe Optimizer::Relation::Operation::Order::OrderOperand, '#optimizable?' do
   subject { object.optimizable? }
 
   let(:base)     { Relation.new([ [ :id, Integer ] ], [ [ 1 ] ].each) }
-  let(:relation) { operand.order                                      }
+  let(:relation) { operand.sort_by { |r| r.id }                       }
   let(:object)   { described_class.new(relation)                      }
 
   before do
@@ -14,7 +14,7 @@ describe Optimizer::Relation::Operation::Order::OrderOperand, '#optimizable?' do
   end
 
   context 'when the operand is ordered' do
-    let(:operand) { base.order }
+    let(:operand) { base.sort_by { |r| r.id } }
 
     it { should be(true) }
   end

data/spec/unit/veritas/optimizer/relation/operation/order/order_operand/optimize_spec.rb

@@ -6,8 +6,8 @@ describe Optimizer::Relation::Operation::Order::OrderOperand, '#optimize' do
   subject { object.optimize }
 
   let(:base)     { Relation.new([ [ :id, Integer ] ], [ [ 1 ] ].each) }
-  let(:order)    { base.order                                         }
-  let(:relation) { order.order { |order| order.directions.reverse }   }
+  let(:order)    { base.sort_by { |r| r.id }                          }
+  let(:relation) { order.sort_by { order.directions.reverse }         }
   let(:object)   { described_class.new(relation)                      }
 
   before do

data/spec/unit/veritas/optimizer/relation/operation/order/unoptimized_operand/optimizable_spec.rb

@@ -7,7 +7,7 @@ describe Optimizer::Relation::Operation::Order::UnoptimizedOperand, '#optimizabl
 
   let(:header)   { Relation::Header.new([ [ :id, Integer ] ]) }
   let(:base)     { Relation.new(header, [ [ 1 ] ].each)       }
-  let(:relation) { operand.order                              }
+  let(:relation) { operand.sort_by { |r| r.id }               }
   let(:object)   { described_class.new(relation)              }
 
   before do