veritas-optimizer 0.0.3

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

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

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

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

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

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+describe Optimizer::Algebra::Projection::UnoptimizedOperand, '#optimizable?' do
+  subject { object.optimizable? }
+
+  let(:header)   { Relation::Header.new([ [ :id, Integer ], [ :name, String ] ]) }
+  let(:base)     { Relation.new(header, [ [ 1, 'Dan Kubb' ] ].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 optimizable' do
+    let(:operand) { base.restrict(Logic::Proposition::Tautology.instance) }
+
+    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/projection/unoptimized_operand/optimize_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe Optimizer::Algebra::Projection::UnoptimizedOperand, '#optimize' do
+  subject { object.optimize }
+
+  let(:header)   { Relation::Header.new([ [ :id, Integer ], [ :name, String ] ])          }
+  let(:base)     { Relation.new(header, [ [ 1, 'Dan Kubb' ] ].each)                       }
+  let(:relation) { base.restrict(Logic::Proposition::Tautology.instance).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/rename/aliases_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe Optimizer::Algebra::Rename, '#aliases' do
+  subject { object.aliases }
+
+  let(:attribute) { Attribute::Integer.new(:id)          }
+  let(:header)    { Relation::Header.new([ attribute ])  }
+  let(:base)      { Relation.new(header, [ [ 1 ] ].each) }
+  let(:aliases)   { { :id => :other_id }                 }
+  let(:object)    { described_class.new(relation)        }
+
+  before do
+    object.operation.should be_kind_of(Algebra::Rename)
+  end
+
+  context 'when the operand is a rename' do
+    let(:relation) { base.rename(aliases).rename(:other_id => :another_id) }
+
+    it { should be_kind_of(Algebra::Rename::Aliases) }
+
+    it { should == { attribute => attribute.rename(:another_id) } }
+  end
+
+  context 'when the operand is not a rename' do
+    let(:relation) { base.rename(aliases) }
+
+    it { should be_kind_of(Algebra::Rename::Aliases) }
+
+    it { should == { attribute => attribute.rename(:other_id) } }
+  end
+end

data/spec/unit/veritas/optimizer/algebra/rename/class_methods/union_aliases_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe Optimizer::Algebra::Rename, '.union_aliases' do
+  subject { object.union_aliases(aliases, operand) }
+
+  let(:attribute) { Attribute::Integer.new(:id)                }
+  let(:header)    { Relation::Header.new([ [ :id, Integer ] ]) }
+  let(:base)      { Relation.new(header, [ [ 1 ] ].each)       }
+  let(:aliases)   { relation.aliases                           }
+  let(:object)    { Optimizer::Algebra::Rename                 }
+
+  context 'when the operand is a rename' do
+    let(:operand)  { base.rename(:id => :other_id)            }
+    let(:relation) { operand.rename(:other_id => :another_id) }
+
+    it { should be_kind_of(Algebra::Rename::Aliases) }
+
+    it { should == { attribute => attribute.rename(:another_id) } }
+  end
+
+  context 'when the operand is not a rename' do
+    let(:operand)  { base                             }
+    let(:relation) { operand.rename(:id => :other_id) }
+
+    it { should equal(aliases) }
+  end
+end

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

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

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

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe Optimizer::Algebra::Rename::EmptyOperand, '#optimize' do
+  subject { object.optimize }
+
+  let(:operand)  { Relation::Empty.new([ [ :id, Integer ] ]) }
+  let(:relation) { operand.rename(:id => :other_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/rename/header_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe Optimizer::Algebra::Rename, '#header' do
+  subject { object.header }
+
+  let(:header)   { Relation::Header.new([ [ :id, Integer ] ]) }
+  let(:base)     { Relation.new(header, [ [ 1 ] ].each)       }
+  let(:aliases)  { { :id => :other_id }                       }
+  let(:relation) { base.rename(aliases)                       }
+  let(:object)   { described_class.new(relation)              }
+
+  before do
+    object.operation.should be_kind_of(Algebra::Rename)
+  end
+
+  it { should be_kind_of(Relation::Header) }
+
+  it { should == [ [ :other_id, Integer ] ] }
+end

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

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+describe Optimizer::Algebra::Rename::LimitOperand, '#optimizable?' do
+  subject { object.optimizable? }
+
+  let(:base)     { Relation.new([ [ :id, Integer ] ], [ [ 1 ] ].each) }
+  let(:aliases)  { { :id => :other_id }                               }
+  let(:relation) { operand.rename(aliases)                            }
+  let(:object)   { described_class.new(relation)                      }
+
+  before do
+    object.operation.should be_kind_of(Algebra::Rename)
+  end
+
+  context 'when the operand is an limit operation' do
+    let(:operand) { base.order.take(1) }
+
+    it { should be(true) }
+  end
+
+  context 'when the operand is not an limit operation' do
+    let(:operand) { base }
+
+    it { should be(false) }
+  end
+end

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

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+describe Optimizer::Algebra::Rename::LimitOperand, '#optimize' do
+  subject { object.optimize }
+
+  let(:header)   { Relation::Header.new([ [ :id, Integer ] ]) }
+  let(:base)     { Relation.new(header, [ [ 1 ] ].each)       }
+  let(:order)    { base.order                                 }
+  let(:relation) { order.take(2).rename(:id => :other_id)     }
+  let(:object)   { described_class.new(relation)              }
+
+  before do
+    object.should be_optimizable
+  end
+
+  it { should be_kind_of(Relation::Operation::Limit) }
+
+  its(:operand) { should eql(order.rename(:id => :other_id)) }
+
+  its(:limit) { should == 2 }
+end

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

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+describe Optimizer::Algebra::Rename::OffsetOperand, '#optimizable?' do
+  subject { object.optimizable? }
+
+  let(:base)     { Relation.new([ [ :id, Integer ] ], [ [ 1 ] ].each) }
+  let(:aliases)  { { :id => :other_id }                               }
+  let(:relation) { operand.rename(aliases)                            }
+  let(:object)   { described_class.new(relation)                      }
+
+  before do
+    object.operation.should be_kind_of(Algebra::Rename)
+  end
+
+  context 'when the operand is an offset operation' do
+    let(:operand) { base.order.drop(1) }
+
+    it { should be(true) }
+  end
+
+  context 'when the operand is not an offset operation' do
+    let(:operand) { base }
+
+    it { should be(false) }
+  end
+end

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

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+describe Optimizer::Algebra::Rename::OffsetOperand, '#optimize' do
+  subject { object.optimize }
+
+  let(:header)   { Relation::Header.new([ [ :id, Integer ] ]) }
+  let(:base)     { Relation.new(header, [ [ 1 ] ].each)       }
+  let(:order)    { base.order                                 }
+  let(:relation) { order.drop(1).rename(:id => :other_id)     }
+  let(:object)   { described_class.new(relation)              }
+
+  before do
+    object.should be_optimizable
+  end
+
+  it { should be_kind_of(Relation::Operation::Offset) }
+
+  its(:operand) { should eql(order.rename(:id => :other_id)) }
+
+  its(:offset) { should == 1 }
+end

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

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+describe Optimizer::Algebra::Rename::OrderOperand, '#optimizable?' do
+  subject { object.optimizable? }
+
+  let(:base)     { Relation.new([ [ :id, Integer ] ], [ [ 1 ] ].each) }
+  let(:aliases)  { { :id => :other_id }                               }
+  let(:relation) { operand.rename(aliases)                            }
+  let(:object)   { described_class.new(relation)                      }
+
+  before do
+    object.operation.should be_kind_of(Algebra::Rename)
+  end
+
+  context 'when the operand is an order operation' do
+    let(:operand) { base.order }
+
+    it { should be(true) }
+  end
+
+  context 'when the operand is not an order operation' do
+    let(:operand) { base }
+
+    it { should be(false) }
+  end
+end

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

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe Optimizer::Algebra::Rename::OrderOperand, '#optimize' do
+  subject { object.optimize }
+
+  let(:base)     { Relation.new([ [ :id, Integer ] ], [ [ 1 ] ].each) }
+  let(:operand)  { base.order                                         }
+  let(:relation) { operand.rename(:id => :other_id)                   }
+  let(:object)   { described_class.new(relation)                      }
+
+  before do
+    object.should be_optimizable
+  end
+
+  it { should be_kind_of(Relation::Operation::Order) }
+
+  its(:operand) { should eql(base.rename(:id => :other_id)) }
+
+  its(:directions) { should == [ relation[:other_id].asc ] }
+end

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

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+describe Optimizer::Algebra::Rename::ProjectionOperand, '#optimizable?' do
+  subject { object.optimizable? }
+
+  let(:header)   { Relation::Header.new([ [ :id, Integer ], [ :name, String ] ]) }
+  let(:base)     { Relation.new(header, [ [ 1, 'Dan Kubb' ] ].each)              }
+  let(:relation) { operand.rename(:id => :other_id)                              }
+  let(:object)   { described_class.new(relation)                                 }
+
+  before do
+    object.operation.should be_kind_of(Algebra::Rename)
+  end
+
+  context 'when the operand is a projection' do
+    let(:operand) { base.project([ :id ]) }
+
+    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/rename/projection_operand/optimize_spec.rb

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

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

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+describe Optimizer::Algebra::Rename::RenameOperand, '#optimizable?' do
+  subject { object.optimizable? }
+
+  let(:header)   { Relation::Header.new([ [ :id, Integer ], [ :name, String ] ]) }
+  let(:base)     { Relation.new(header, [ [ 1, 'Dan Kubb' ] ].each)              }
+  let(:relation) { operand.rename(aliases)                                       }
+  let(:object)   { described_class.new(relation)                                 }
+
+  before do
+    object.operation.should be_kind_of(Algebra::Rename)
+  end
+
+  context 'when the operand is a rename' do
+    let(:aliases) { { :id => :other_id }              }
+    let(:operand) { base.rename(:name => :other_name) }
+
+    it { should be(true) }
+  end
+
+  context 'when the operand is not a rename' do
+    let(:aliases) { { :id => :other_id } }
+    let(:operand) { base                 }
+
+    it { should be(false) }
+  end
+end

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

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

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

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+describe Optimizer::Algebra::Rename::RenameOperandAndEmptyAliases, '#optimizable?' do
+  subject { object.optimizable? }
+
+  let(:header)   { Relation::Header.new([ [ :id, Integer ], [ :name, String ] ]) }
+  let(:base)     { Relation.new(header, [ [ 1, 'Dan Kubb' ] ].each)              }
+  let(:relation) { operand.rename(aliases)                                       }
+  let(:object)   { described_class.new(relation)                                 }
+
+  before do
+    object.operation.should be_kind_of(Algebra::Rename)
+  end
+
+  context 'when the operand is a rename and there are aliases' do
+    let(:aliases) { { :id => :other_id }              }
+    let(:operand) { base.rename(:name => :other_name) }
+
+    it { should be(false) }
+  end
+
+  context 'when the operand is a rename and there no aliases' do
+    let(:aliases) { { :other_id => :id }          }
+    let(:operand) { base.rename(:id => :other_id) }
+
+    it { should be(true) }
+  end
+
+  context 'when the operand is not a rename' do
+    let(:aliases) { { :id => :other_id } }
+    let(:operand) { base                 }
+
+    it { should be(false) }
+  end
+end

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

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe Optimizer::Algebra::Rename::RenameOperandAndEmptyAliases, '#optimize' do
+  subject { object.optimize }
+
+  let(:header)   { Relation::Header.new([ [ :id, Integer ], [ :name, String ] ]) }
+  let(:base)     { Relation.new(header, [ [ 1, 'Dan Kubb' ] ].each)              }
+  let(:relation) { base.rename(:id => :other_id).rename(:other_id => :id)        }
+  let(:object)   { described_class.new(relation)                                 }
+
+  before do
+    object.should be_optimizable
+  end
+
+  it { should equal(base) }
+end

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

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe Optimizer::Algebra::Rename::RestrictionOperand, '#optimizable?' do
+  subject { object.optimizable? }
+
+  let(:header)    { Relation::Header.new([ [ :id, Integer ] ]) }
+  let(:base)      { Relation.new(header, [ [ 1 ] ].each)       }
+  let(:predicate) { base[:id].eq(1)                            }
+  let(:relation)  { operand.rename(:id => :other_id)           }
+  let(:object)    { described_class.new(relation)              }
+
+  before do
+    object.operation.should be_kind_of(Algebra::Rename)
+  end
+
+  context 'when the operand is a restriction' do
+    let(:operand) { base.restrict(predicate) }
+
+    it { should be(true) }
+  end
+
+  context 'when the operand is not a restriction' do
+    let(:operand) { base }
+
+    it { should be(false) }
+  end
+end

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

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+describe Optimizer::Algebra::Rename::RestrictionOperand, '#optimize' do
+  subject { object.optimize }
+
+  let(:header)    { Relation::Header.new([ [ :id, Integer ] ])        }
+  let(:base)      { Relation.new(header, [ [ 1 ] ].each)              }
+  let(:predicate) { base[:id].eq(1)                                   }
+  let(:relation)  { base.restrict(predicate).rename(:id => :other_id) }
+  let(:object)    { described_class.new(relation)                     }
+
+  before do
+    object.should be_optimizable
+  end
+
+  it { should be_kind_of(Algebra::Restriction) }
+
+  its(:operand) { should eql(base.rename(:id => :other_id)) }
+
+  its(:predicate) { should == header[:id].rename(:other_id).eq(1) }
+end

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

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe Optimizer::Algebra::Rename::ReverseOperand, '#optimizable?' do
+  subject { object.optimizable? }
+
+  let(:base)     { Relation.new([ [ :id, Integer ] ], [ [ 1 ] ].each) }
+  let(:relation) { operand.rename(:id => :other_id)                   }
+  let(:object)   { described_class.new(relation)                      }
+
+  before do
+    object.operation.should be_kind_of(Algebra::Rename)
+  end
+
+  context 'when the operand is an reverse operation' do
+    let(:operand) { base.order.take(2).reverse }
+
+    it { should be(true) }
+  end
+
+  context 'when the operand is not an reverse operation' do
+    let(:operand) { base }
+
+    it { should be(false) }
+  end
+end

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

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+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(:operand)  { limit.rename({}).reverse                           }
+  let(:relation) { operand.rename(:id => :other_id)                   }
+  let(:object)   { described_class.new(relation)                      }
+
+  before do
+    object.should be_optimizable
+  end
+
+  it { should be_kind_of(Relation::Operation::Reverse) }
+
+  its(:operand) { should eql(limit.rename(:id => :other_id)) }
+
+  its(:directions) { should == [ relation[:other_id].desc ] }
+end

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

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

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+describe Optimizer::Algebra::Rename::SetOperand, '#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.union(right).rename(:id => :other_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(left.rename(:id => :other_id)) }
+
+  its(:right) { should eql(right.rename(:id => :other_id)) }
+end