axiom-optimizer 0.1.0 → 0.1.1

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

@@ -5,24 +5,24 @@ require 'spec_helper'
 describe Algebra::Difference, '#optimize' do
   subject { object.optimize }
 
-  let(:header)         { [ [ :id, Integer ] ]             }
-  let(:left_body)      { LazyEnumerable.new([ [ 1 ] ])    }
-  let(:right_body)     { LazyEnumerable.new([ [ 2 ] ])    }
+  let(:header)         { [[:id, Integer]]                 }
+  let(:left_body)      { LazyEnumerable.new([[1]])        }
+  let(:right_body)     { LazyEnumerable.new([[2]])        }
   let(:original_left)  { Relation.new(header, left_body)  }
   let(:original_right) { Relation.new(header, right_body) }
   let(:object)         { described_class.new(left, right) }
 
   before do
     # skip dup of the left and right body to avoid clearing the method stubs
-    left_body.stub!(:frozen?).and_return(true)
-    right_body.stub!(:frozen?).and_return(true)
+    left_body.stub(:frozen?).and_return(true)
+    right_body.stub(:frozen?).and_return(true)
   end
 
   context 'left is an empty relation' do
     let(:left)  { Relation::Empty.new(header) }
     let(:right) { original_right              }
 
-    it { should equal(left) }
+    it { should be(left) }
 
     it 'returns an equivalent relation to the unoptimized operation' do
       should == object
@@ -40,7 +40,7 @@ describe Algebra::Difference, '#optimize' do
     let(:left)  { original_left               }
     let(:right) { Relation::Empty.new(header) }
 
-    it { should equal(left) }
+    it { should be(left) }
 
     it 'returns an equivalent relation to the unoptimized operation' do
       should == object
@@ -81,7 +81,7 @@ describe Algebra::Difference, '#optimize' do
     let(:left)  { original_left                                                                           }
     let(:right) { Algebra::Restriction.new(original_right, Function::Proposition::Contradiction.instance) }
 
-    it { should equal(left) }
+    it { should be(left) }
 
     it 'returns an equivalent relation to the unoptimized operation' do
       should == object
@@ -102,9 +102,9 @@ describe Algebra::Difference, '#optimize' do
 
   unless defined?(JRUBY_VERSION) && JRUBY_VERSION < '1.6'
     context 'left and right are equivalent relations' do
-      let(:right_body) { LazyEnumerable.new([ [ 1 ] ]) }
-      let(:left)       { original_left                 }
-      let(:right)      { original_right                }
+      let(:right_body) { LazyEnumerable.new([[1]]) }
+      let(:left)       { original_left             }
+      let(:right)      { original_right            }
 
       it { should eql(Relation::Empty.new(header)) }
 
@@ -130,7 +130,7 @@ describe Algebra::Difference, '#optimize' do
     let(:left)  { original_left  }
     let(:right) { original_right }
 
-    it { should equal(object) }
+    it { should be(object) }
 
     it 'executes left_body#each' do
       left_body.should_receive(:each)
@@ -146,10 +146,10 @@ describe Algebra::Difference, '#optimize' do
   end
 
   context 'left and right are materialized relations' do
-    let(:left)  { Relation.new(header, [ [ 1 ], [ 2 ] ]) }
-    let(:right) { Relation.new(header, [ [ 1 ] ])        }
+    let(:left)  { Relation.new(header, [[1], [2]]) }
+    let(:right) { Relation.new(header, [[1]])      }
 
-    it { should eql(Relation::Materialized.new(header, [ [ 2 ] ])) }
+    it { should eql(Relation::Materialized.new(header, [[2]])) }
 
     it 'returns an equivalent relation to the unoptimized operation' do
       should == object

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

@@ -5,24 +5,24 @@ require 'spec_helper'
 describe Algebra::Intersection, '#optimize' do
   subject { object.optimize }
 
-  let(:header)         { [ [ :id, Integer ] ]             }
-  let(:left_body)      { LazyEnumerable.new([ [ 1 ] ])    }
-  let(:right_body)     { LazyEnumerable.new([ [ 2 ] ])    }
+  let(:header)         { [[:id, Integer]]                 }
+  let(:left_body)      { LazyEnumerable.new([[1]])        }
+  let(:right_body)     { LazyEnumerable.new([[2]])        }
   let(:original_left)  { Relation.new(header, left_body)  }
   let(:original_right) { Relation.new(header, right_body) }
   let(:object)         { described_class.new(left, right) }
 
   before do
     # skip dup of the left and right body to avoid clearing the method stubs
-    left_body.stub!(:frozen?).and_return(true)
-    right_body.stub!(:frozen?).and_return(true)
+    left_body.stub(:frozen?).and_return(true)
+    right_body.stub(:frozen?).and_return(true)
   end
 
   context 'left is an empty relation' do
     let(:left)  { Relation::Empty.new(header) }
     let(:right) { original_right              }
 
-    it { should equal(left) }
+    it { should be(left) }
 
     it 'returns an equivalent relation to the unoptimized operation' do
       should == object
@@ -40,7 +40,7 @@ describe Algebra::Intersection, '#optimize' do
     let(:left)  { original_left               }
     let(:right) { Relation::Empty.new(header) }
 
-    it { should equal(right) }
+    it { should be(right) }
 
     it 'returns an equivalent relation to the unoptimized operation' do
       should == object
@@ -102,11 +102,11 @@ describe Algebra::Intersection, '#optimize' do
 
   unless defined?(JRUBY_VERSION) && JRUBY_VERSION < '1.6'
     context 'left and right are equivalent relations' do
-      let(:right_body) { LazyEnumerable.new([ [ 1 ] ]) }
-      let(:left)       { original_left                 }
-      let(:right)      { original_right                }
+      let(:right_body) { LazyEnumerable.new([[1]]) }
+      let(:left)       { original_left             }
+      let(:right)      { original_right            }
 
-      it { should equal(left) }
+      it { should be(left) }
 
       it 'returns an equivalent relation to the unoptimized operation' do
         should == object
@@ -130,7 +130,7 @@ describe Algebra::Intersection, '#optimize' do
     let(:left)  { original_left  }
     let(:right) { original_right }
 
-    it { should equal(object) }
+    it { should be(object) }
 
     it 'executed left_body#each' do
       left_body.should_receive(:each)
@@ -146,10 +146,10 @@ describe Algebra::Intersection, '#optimize' do
   end
 
   context 'left and right are materialized relations' do
-    let(:left)  { Relation.new(header, [ [ 1 ], [ 2 ] ]) }
-    let(:right) { Relation.new(header, [ [ 1 ] ])        }
+    let(:left)  { Relation.new(header, [[1], [2]]) }
+    let(:right) { Relation.new(header, [[1]])      }
 
-    it { should eql(Relation::Materialized.new(header, [ [ 1 ] ])) }
+    it { should eql(Relation::Materialized.new(header, [[1]])) }
 
     it 'returns an equivalent relation to the unoptimized operation' do
       should == object

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

@@ -5,13 +5,13 @@ require 'spec_helper'
 describe Algebra::Join, '#optimize' do
   subject { object.optimize }
 
-  let(:left_body)      { LazyEnumerable.new([ [ 1 ], [ 2 ] ])                              }
-  let(:right_body)     { LazyEnumerable.new([ [ 2, 'Dan Kubb' ] ])                         }
-  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)                                  }
+  let(:left_body)      { LazyEnumerable.new([[1], [2]])                              }
+  let(:right_body)     { LazyEnumerable.new([[2, 'Dan Kubb']])                       }
+  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) }
@@ -82,7 +82,7 @@ describe Algebra::Join, '#optimize' do
   end
 
   context 'left and right are not empty relations' do
-    it { should equal(object) }
+    it { should be(object) }
 
     it 'does not execute left_body#each' do
       left_body.should_not_receive(:each)
@@ -98,10 +98,10 @@ describe Algebra::Join, '#optimize' do
   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' ] ]) }
+    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 { should eql(Relation::Materialized.new([[:id, Integer], [:name, String]], [[2, 'Dan Kubb']])) }
 
     it 'returns an equivalent relation to the unoptimized operation' do
       should == object

data/spec/integration/axiom/algebra/product/optimize_spec.rb

@@ -5,11 +5,11 @@ require 'spec_helper'
 describe Algebra::Product, '#optimize' do
   subject { object.optimize }
 
-  let(:left_body)  { LazyEnumerable.new([ [ 1 ] ])                    }
-  let(:right_body) { LazyEnumerable.new([ [ 'Dan Kubb' ] ])           }
-  let(:left)       { Relation.new([ [ :id,   Integer ] ], left_body)  }
-  let(:right)      { Relation.new([ [ :name, String  ] ], right_body) }
-  let(:object)     { described_class.new(left, right)                 }
+  let(:left_body)  { LazyEnumerable.new([[1]])                   }
+  let(:right_body) { LazyEnumerable.new([['Dan Kubb']])          }
+  let(:left)       { Relation.new([[:id, Integer]], left_body)   }
+  let(:right)      { Relation.new([[:name, String]], right_body) }
+  let(:object)     { described_class.new(left, right)            }
 
   context 'left is a TABLE_DUM' do
     let(:left) { TABLE_DUM }
@@ -82,7 +82,7 @@ describe Algebra::Product, '#optimize' do
   context 'left is a TABLE_DEE' do
     let(:left) { TABLE_DEE }
 
-    it { should equal(right) }
+    it { should be(right) }
 
     it 'returns an equivalent relation to the unoptimized operation' do
       should == object
@@ -99,7 +99,7 @@ describe Algebra::Product, '#optimize' do
   context 'right is a TABLE_DEE' do
     let(:right) { TABLE_DEE }
 
-    it { should equal(left) }
+    it { should be(left) }
 
     it 'returns an equivalent relation to the unoptimized operation' do
       should == object
@@ -116,7 +116,7 @@ describe Algebra::Product, '#optimize' do
   context 'left is a TABLE_DEE when optimized' do
     let(:left) { TABLE_DEE.project([]) }
 
-    it { should equal(right) }
+    it { should be(right) }
 
     it 'returns an equivalent relation to the unoptimized operation' do
       should == object
@@ -133,7 +133,7 @@ describe Algebra::Product, '#optimize' do
   context 'right is a TABLE_DEE when optimized' do
     let(:right) { TABLE_DEE.project([]) }
 
-    it { should equal(left) }
+    it { should be(left) }
 
     it 'returns an equivalent relation to the unoptimized operation' do
       should == object
@@ -148,7 +148,7 @@ describe Algebra::Product, '#optimize' do
   end
 
   context 'left and right are normal relations' do
-    it { should equal(object) }
+    it { should be(object) }
 
     it 'does not execute left_body#each' do
       left_body.should_not_receive(:each)
@@ -164,10 +164,10 @@ describe Algebra::Product, '#optimize' do
   end
 
   context 'left and right are materialized relations' do
-    let(:left)  { Relation.new([ [ :id,   Integer ] ], [ [ 1 ] ])          }
-    let(:right) { Relation.new([ [ :name, String  ] ], [ [ 'Dan Kubb' ] ]) }
+    let(:left)  { Relation.new([[:id, Integer]], [[1]])           }
+    let(:right) { Relation.new([[:name, String]], [['Dan Kubb']]) }
 
-    it { should eql(Relation::Materialized.new([ [ :id, Integer ], [ :name, String ] ], [ [ 1, 'Dan Kubb' ] ])) }
+    it { should eql(Relation::Materialized.new([[:id, Integer], [:name, String]], [[1, 'Dan Kubb']])) }
 
     it 'returns an equivalent relation to the unoptimized operation' do
       should == object

data/spec/integration/axiom/algebra/projection/optimize_spec.rb

@@ -5,21 +5,21 @@ require 'spec_helper'
 describe Algebra::Projection, '#optimize' do
   subject { object.optimize }
 
-  let(:header)   { [ [ :id, Integer ], [ :name, String ], [ :age, Integer ] ] }
-  let(:body)     { LazyEnumerable.new([ [ 1, 'Dan Kubb', 35 ] ])              }
-  let(:relation) { Relation.new(header, body)                                 }
-  let(:operand)  { relation                                                   }
-  let(:object)   { described_class.new(operand, attributes)                   }
+  let(:header)   { [[:id, Integer], [:name, String], [:age, Integer]] }
+  let(:body)     { LazyEnumerable.new([[1, 'Dan Kubb', 35]])          }
+  let(:relation) { Relation.new(header, body)                         }
+  let(:operand)  { relation                                           }
+  let(:object)   { described_class.new(operand, attributes)           }
 
   before do
     # skip dup of the body to avoid clearing the method stubs
-    body.stub!(:frozen?).and_return(true)
+    body.stub(:frozen?).and_return(true)
   end
 
   context 'when the attributes are equivalent to the relation headers, and in the same order' do
     let(:attributes) { header }
 
-    it { should equal(operand) }
+    it { should be(operand) }
 
     it 'returns an equivalent relation to the unoptimized operation' do
       should == object
@@ -34,10 +34,10 @@ describe Algebra::Projection, '#optimize' do
   end
 
   context 'when the attributes are equivalent to the relation headers, and not in the same order' do
-    let(:attributes) { [ :name, :id ] }
+    let(:attributes) { [:name, :id] }
 
     it 'does not factor out the object, because tuple order is currently significant' do
-      should equal(object)
+      should be(object)
     end
 
     it 'does not execute body#each' do
@@ -49,9 +49,9 @@ describe Algebra::Projection, '#optimize' do
   end
 
   context 'when the attributes are different from the relation headers' do
-    let(:attributes) { [ :id ] }
+    let(:attributes) { [:id] }
 
-    it { should equal(object) }
+    it { should be(object) }
 
     it 'does not execute body#each' do
       body.should_not_receive(:each)
@@ -63,7 +63,7 @@ describe Algebra::Projection, '#optimize' do
 
   context 'containing an empty relation' do
     let(:operand)    { Relation::Empty.new(header) }
-    let(:attributes) { [ :id ]                     }
+    let(:attributes) { [:id]                       }
 
     it { should eql(Relation::Empty.new(object.header)) }
 
@@ -76,7 +76,7 @@ describe Algebra::Projection, '#optimize' do
 
   context 'containing an empty relation when optimized' do
     let(:operand)    { Algebra::Restriction.new(relation, Function::Proposition::Contradiction.instance) }
-    let(:attributes) { [ :id ]                                                                           }
+    let(:attributes) { [:id]                                                                             }
 
     it { should eql(Relation::Empty.new(object.header)) }
 
@@ -94,13 +94,13 @@ describe Algebra::Projection, '#optimize' do
 
   context 'containing an optimizable relation' do
     let(:operand)    { Algebra::Restriction.new(relation, Function::Proposition::Tautology.instance) }
-    let(:attributes) { [ :id ]                                                                       }
+    let(:attributes) { [:id]                                                                         }
 
-    it { should_not equal(object) }
+    it { should_not be(object) }
 
     it { should be_kind_of(described_class) }
 
-    its(:operand) { should equal(relation) }
+    its(:operand) { should be(relation) }
 
     its(:header) { should == object.header }
 
@@ -117,14 +117,14 @@ describe Algebra::Projection, '#optimize' do
   end
 
   context 'containing a projection' do
-    let(:operand)    { relation.project([ :id, :name ]) }
-    let(:attributes) { [ :id ]                          }
+    let(:operand)    { relation.project([:id, :name]) }
+    let(:attributes) { [:id]                          }
 
-    it { should_not equal(object) }
+    it { should_not be(object) }
 
     it { should be_kind_of(described_class) }
 
-    its(:operand) { should equal(relation) }
+    its(:operand) { should be(relation) }
 
     its(:header) { should == object.header }
 
@@ -141,14 +141,14 @@ describe Algebra::Projection, '#optimize' do
   end
 
   context 'containing a set operation' do
-    let(:left)       { Relation.new([ [ :id, Integer ], [ :name, String ] ], LazyEnumerable.new([ [ 1, 'Dan Kubb' ] ])) }
-    let(:right)      { Relation.new([ [ :id, Integer ], [ :name, String ] ], LazyEnumerable.new([ [ 2, 'Dan Kubb' ] ])) }
-    let(:operand)    { left.union(right)                                                                                }
-    let(:attributes) { [ :name ]                                                                                        }
+    let(:left)       { Relation.new([[:id, Integer], [:name, String]], LazyEnumerable.new([[1, 'Dan Kubb']])) }
+    let(:right)      { Relation.new([[:id, Integer], [:name, String]], LazyEnumerable.new([[2, 'Dan Kubb']])) }
+    let(:operand)    { left.union(right)                                                                      }
+    let(:attributes) { [:name]                                                                                }
 
     it 'pushes the object to each relation' do
       should eql(Algebra::Union.new(
-         described_class.new(left,  object.header),
+         described_class.new(left, object.header),
          described_class.new(right, object.header)
       ))
     end
@@ -166,21 +166,21 @@ describe Algebra::Projection, '#optimize' do
   end
 
   context 'containing a set operation containing a projection of relations' do
-    let(:left_body)  { LazyEnumerable.new([ [ 1, 'Dan Kubb', 35 ] ])                     }
-    let(:right_body) { LazyEnumerable.new([ [ 2, 'Dan Kubb', 35 ] ])                     }
-    let(:left)       { Relation.new(header, left_body)                                   }
-    let(:right)      { Relation.new(header, right_body)                                  }
-    let(:operand)    { left.project([ :id, :name ]).union(right.project([ :id, :name ])) }
-    let(:attributes) { [ :name ]                                                         }
+    let(:left_body)  { LazyEnumerable.new([[1, 'Dan Kubb', 35]])                     }
+    let(:right_body) { LazyEnumerable.new([[2, 'Dan Kubb', 35]])                     }
+    let(:left)       { Relation.new(header, left_body)                               }
+    let(:right)      { Relation.new(header, right_body)                              }
+    let(:operand)    { left.project([:id, :name]).union(right.project([:id, :name])) }
+    let(:attributes) { [:name]                                                       }
 
     before do
       # skip dup of the left and right body to avoid clearing the method stubs
-      left_body.stub!(:frozen?).and_return(true)
-      right_body.stub!(:frozen?).and_return(true)
+      left_body.stub(:frozen?).and_return(true)
+      right_body.stub(:frozen?).and_return(true)
     end
 
     it 'pushes the object to each relation, and combine the nested objects' do
-      should eql(left.project([ :name ]).union(right.project([ :name ])))
+      should eql(left.project([:name]).union(right.project([:name])))
     end
 
     it 'returns an equivalent relation to the unoptimized operation' do
@@ -205,15 +205,15 @@ describe Algebra::Projection, '#optimize' do
   end
 
   context 'containing a set operation containing a projection of materialized relations' do
-    let(:left_body)  { [ [ 1, 'Dan Kubb', 35 ] ]                                         }
-    let(:right_body) { [ [ 2, 'Dan Kubb', 35 ] ]                                         }
-    let(:left)       { Relation.new(header, left_body)                                   }
-    let(:right)      { Relation.new(header, right_body)                                  }
-    let(:operand)    { left.project([ :id, :name ]).union(right.project([ :id, :name ])) }
-    let(:attributes) { [ :name ]                                                         }
+    let(:left_body)  { [[1, 'Dan Kubb', 35]]                                         }
+    let(:right_body) { [[2, 'Dan Kubb', 35]]                                         }
+    let(:left)       { Relation.new(header, left_body)                               }
+    let(:right)      { Relation.new(header, right_body)                              }
+    let(:operand)    { left.project([:id, :name]).union(right.project([:id, :name])) }
+    let(:attributes) { [:name]                                                       }
 
     it 'pushes the object to each relation, and combine the nested objects, then materializes' do
-      should eql(Relation.new([ [ :name, String ] ], [ [ 'Dan Kubb' ] ]))
+      should eql(Relation.new([[:name, String]], [['Dan Kubb']]))
     end
 
     it 'returns an equivalent relation to the unoptimized operation' do
@@ -236,10 +236,10 @@ describe Algebra::Projection, '#optimize' do
   end
 
   context 'containing a materialized relation' do
-    let(:operand)    { Relation.new(header, [ [ 1, 'Dan Kubb', 35 ] ]) }
-    let(:attributes) { [ :id ]                                         }
+    let(:operand)    { Relation.new(header, [[1, 'Dan Kubb', 35]]) }
+    let(:attributes) { [:id]                                       }
 
-    it { should eql(Relation::Materialized.new([ [ :id, Integer ] ], [ [ 1 ] ])) }
+    it { should eql(Relation::Materialized.new([[:id, Integer]], [[1]])) }
 
     it 'returns an equivalent relation to the unoptimized operation' do
       should == object