axiom-sql-generator 0.1.0 → 0.2.0

data/lib/axiom/sql/generator/relation/binary.rb

@@ -99,7 +99,7 @@ module Axiom
           #
           # @api private
           def set_name
-            @name = [ @left.name, @right.name ].uniq.join(UNDERSCORE).freeze
+            @name = [@left.name, @right.name].uniq.join(UNDERSCORE).freeze
           end
 
           # Generates an SQL statement for base relation binary operands

data/lib/axiom/sql/generator/relation/insertion.rb

@@ -9,7 +9,7 @@ module Axiom
         class Insertion < Set
           extend Aliasable
 
-          inheritable_alias(:to_subquery => :to_s)
+          inheritable_alias(to_subquery: :to_s)
 
           # Visit an Insertion
           #

data/lib/axiom/sql/generator/relation/unary.rb

@@ -17,21 +17,21 @@ module Axiom
                   Function::String,
                   Function::Numeric
 
-          inheritable_alias(:visit_axiom_relation_operation_reverse => :visit_axiom_relation_operation_order)
+          inheritable_alias(visit_axiom_relation_operation_reverse: :visit_axiom_relation_operation_sorted)
 
           DISTINCT    = 'DISTINCT '.freeze
           NO_ROWS     = ' HAVING FALSE'.freeze
           ANY_ROWS    = ' HAVING COUNT (*) > 0'
           COLLAPSIBLE = {
-            Algebra::Summarization                => Set[                                                                                                                                                                                                                                                               ].freeze,
-            Algebra::Projection                   => Set[ Algebra::Projection,                                      Algebra::Restriction,                                                                                                                                                                               ].freeze,
-            Algebra::Extension                    => Set[ Algebra::Projection,                                      Algebra::Restriction,                         Axiom::Relation::Operation::Order, Axiom::Relation::Operation::Reverse, Axiom::Relation::Operation::Offset, Axiom::Relation::Operation::Limit ].freeze,
-            Algebra::Rename                       => Set[ Algebra::Projection,                                      Algebra::Restriction,                         Axiom::Relation::Operation::Order, Axiom::Relation::Operation::Reverse, Axiom::Relation::Operation::Offset, Axiom::Relation::Operation::Limit ].freeze,
-            Algebra::Restriction                  => Set[ Algebra::Projection,                                                                                    Axiom::Relation::Operation::Order, Axiom::Relation::Operation::Reverse,                                                                           ].freeze,
-            Axiom::Relation::Operation::Order   => Set[ Algebra::Projection, Algebra::Extension, Algebra::Rename, Algebra::Restriction, Algebra::Summarization, Axiom::Relation::Operation::Order, Axiom::Relation::Operation::Reverse,                                                                           ].freeze,
-            Axiom::Relation::Operation::Reverse => Set[ Algebra::Projection, Algebra::Extension, Algebra::Rename, Algebra::Restriction, Algebra::Summarization, Axiom::Relation::Operation::Order, Axiom::Relation::Operation::Reverse,                                                                           ].freeze,
-            Axiom::Relation::Operation::Offset  => Set[ Algebra::Projection, Algebra::Extension, Algebra::Rename, Algebra::Restriction, Algebra::Summarization, Axiom::Relation::Operation::Order, Axiom::Relation::Operation::Reverse,                                                                           ].freeze,
-            Axiom::Relation::Operation::Limit   => Set[ Algebra::Projection, Algebra::Extension, Algebra::Rename, Algebra::Restriction, Algebra::Summarization, Axiom::Relation::Operation::Order, Axiom::Relation::Operation::Reverse, Axiom::Relation::Operation::Offset,                                     ].freeze,
+            Algebra::Summarization              => Set[].freeze,
+            Algebra::Projection                 => Set[Algebra::Projection,                                      Algebra::Restriction].freeze,
+            Algebra::Extension                  => Set[Algebra::Projection,                                      Algebra::Restriction,                         Axiom::Relation::Operation::Sorted, Axiom::Relation::Operation::Reverse, Axiom::Relation::Operation::Offset, Axiom::Relation::Operation::Limit].freeze,
+            Algebra::Rename                     => Set[Algebra::Projection,                                      Algebra::Restriction,                         Axiom::Relation::Operation::Sorted, Axiom::Relation::Operation::Reverse, Axiom::Relation::Operation::Offset, Axiom::Relation::Operation::Limit].freeze,
+            Algebra::Restriction                => Set[Algebra::Projection,                                                                                    Axiom::Relation::Operation::Sorted, Axiom::Relation::Operation::Reverse].freeze,
+            Axiom::Relation::Operation::Sorted  => Set[Algebra::Projection, Algebra::Extension, Algebra::Rename, Algebra::Restriction, Algebra::Summarization, Axiom::Relation::Operation::Sorted, Axiom::Relation::Operation::Reverse].freeze,
+            Axiom::Relation::Operation::Reverse => Set[Algebra::Projection, Algebra::Extension, Algebra::Rename, Algebra::Restriction, Algebra::Summarization, Axiom::Relation::Operation::Sorted, Axiom::Relation::Operation::Reverse].freeze,
+            Axiom::Relation::Operation::Offset  => Set[Algebra::Projection, Algebra::Extension, Algebra::Rename, Algebra::Restriction, Algebra::Summarization, Axiom::Relation::Operation::Sorted, Axiom::Relation::Operation::Reverse].freeze,
+            Axiom::Relation::Operation::Limit   => Set[Algebra::Projection, Algebra::Extension, Algebra::Rename, Algebra::Restriction, Algebra::Summarization, Axiom::Relation::Operation::Sorted, Axiom::Relation::Operation::Reverse, Axiom::Relation::Operation::Offset].freeze,
           }.freeze
 
           # Initialize a Unary relation SQL generator
@@ -52,7 +52,7 @@ module Axiom
           #
           # @api private
           def visit_axiom_relation_base(base_relation)
-            @name    = base_relation.name
+            @name    = base_relation.name.to_s.freeze
             @from    = visit_identifier(@name)
             @header  = base_relation.header
             @columns = columns_for(base_relation)
@@ -141,19 +141,19 @@ module Axiom
             self
           end
 
-          # Visit an Order
+          # Visit a Sorted
           #
-          # @param [Relation::Operation::Order] order
+          # @param [Relation::Operation::Sorted] sorted
           #
           # @return [self]
           #
           # @api private
-          def visit_axiom_relation_operation_order(order)
-            @from      = subquery_for(order)
-            @order     = " ORDER BY #{order_for(order.directions)}"
-            @header    = order.header
-            @columns ||= columns_for(order)
-            scope_query(order)
+          def visit_axiom_relation_operation_sorted(sorted)
+            @from      = subquery_for(sorted)
+            @order     = " ORDER BY #{order_for(sorted.directions)}"
+            @header    = sorted.header
+            @columns ||= columns_for(sorted)
+            scope_query(sorted)
             self
           end
 
@@ -199,7 +199,7 @@ module Axiom
           #
           # @api private
           def generate_sql(columns)
-            [ "SELECT #{columns} FROM #{@from}", @where, @group, @having, @order, @limit, @offset ].join
+            ["SELECT #{columns} FROM #{@from}", @where, @group, @having, @order, @limit, @offset].join
           end
 
           # Return the columns to use in a query

data/lib/axiom/sql/generator/version.rb

@@ -5,7 +5,7 @@ module Axiom
     module Generator
 
       # Gem version
-      VERSION = '0.1.0'.freeze
+      VERSION = '0.2.0'.freeze
 
     end # module Generator
   end # module SQL

data/lib/axiom/sql/generator/visitor.rb

@@ -26,7 +26,7 @@ module Axiom
         #
         # @api private
         def self.handler_for(visitable_class)
-          handlers[visitable_class] or raise UnknownObject, "No handler for #{visitable_class} in #{self}"
+          handlers[visitable_class] or fail UnknownObject, "No handler for #{visitable_class} in #{self}"
         end
 
         # Return the handler cache that maps modules to method names
@@ -84,7 +84,7 @@ module Axiom
         #
         # @api public
         def visit(_visitable)
-          raise NotImplementedError, "#{self.class}#visit must be implemented"
+          fail NotImplementedError, "#{self.class}#visit must be implemented"
         end
 
         # Test if a visitable object has been visited
@@ -96,7 +96,7 @@ module Axiom
         #
         # @api public
         def visited?
-          raise NotImplementedError, "#{self.class}#visited? must be implemented"
+          fail NotImplementedError, "#{self.class}#visited? must be implemented"
         end
 
       private

data/spec/spec_helper.rb

@@ -1,7 +1,5 @@
 # encoding: utf-8
 
-require 'devtools/spec_helper'
-
 if ENV['COVERAGE'] == 'true'
   require 'simplecov'
   require 'coveralls'
@@ -12,22 +10,25 @@ if ENV['COVERAGE'] == 'true'
   ]
 
   SimpleCov.start do
-    command_name     'spec:unit'
-    add_filter       'config'
-    add_filter       'core_ext'
-    add_filter       'spec'
+    command_name 'spec:unit'
+
+    add_filter 'config'
+    add_filter 'spec'
+    add_filter 'vendor'
+
     minimum_coverage 100
   end
 end
 
+require 'devtools/spec_helper'
 require 'axiom-sql-generator'
 
 include Axiom
 
-# require spec support files and shared behavior
-Dir[File.expand_path('../{support,shared}/**/*.rb', __FILE__)].each do |file|
-  require file
-end
+Types.finalize
 
 RSpec.configure do |config|
+  config.expect_with :rspec do |expect_with|
+    expect_with.syntax = :expect
+  end
 end

data/spec/support/config_alias.rb

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 require 'rbconfig'
 
 ::Config = RbConfig unless defined?(::Config)

data/spec/unit/axiom/sql/generator/direction/{visit_axiom_relation_operation_order_ascending_spec.rb → visit_axiom_relation_operation_sorted_ascending_spec.rb}

@@ -2,8 +2,8 @@
 
 require 'spec_helper'
 
-describe SQL::Generator::Direction, '#visit_axiom_relation_operation_order_ascending' do
-  subject { object.visit_axiom_relation_operation_order_ascending(direction) }
+describe SQL::Generator::Direction, '#visit_axiom_relation_operation_sorted_ascending' do
+  subject { object.visit_axiom_relation_operation_sorted_ascending(direction) }
 
   let(:described_class) { Class.new(SQL::Generator::Visitor) { include SQL::Generator::Direction } }
   let(:direction)       { Attribute::Integer.new(:id).asc                                          }

data/spec/unit/axiom/sql/generator/direction/{visit_axiom_relation_operation_order_descending_spec.rb → visit_axiom_relation_operation_sorted_descending_spec.rb}

@@ -2,8 +2,8 @@
 
 require 'spec_helper'
 
-describe SQL::Generator::Direction, '#visit_axiom_relation_operation_order_descending' do
-  subject { object.visit_axiom_relation_operation_order_descending(direction) }
+describe SQL::Generator::Direction, '#visit_axiom_relation_operation_sorted_descending' do
+  subject { object.visit_axiom_relation_operation_sorted_descending(direction) }
 
   let(:described_class) { Class.new(SQL::Generator::Visitor) { include SQL::Generator::Direction } }
   let(:direction)       { Attribute::Integer.new(:id).desc                                         }

data/spec/unit/axiom/sql/generator/function/predicate/visit_axiom_function_predicate_exclusion_spec.rb

@@ -30,7 +30,7 @@ describe SQL::Generator::Function::Predicate, '#visit_axiom_function_predicate_e
   end
 
   context 'when right operand is an Array' do
-    let(:exclusion) { attribute.exclude([ 1, 2 ]) }
+    let(:exclusion) { attribute.exclude([1, 2]) }
 
     it_should_behave_like 'a generated SQL expression'
 

data/spec/unit/axiom/sql/generator/function/predicate/visit_axiom_function_predicate_inclusion_spec.rb

@@ -30,7 +30,7 @@ describe SQL::Generator::Function::Predicate, '#visit_axiom_function_predicate_i
   end
 
   context 'when right operand is an Array' do
-    let(:inclusion) { attribute.include([ 1, 2 ]) }
+    let(:inclusion) { attribute.include([1, 2]) }
 
     it_should_behave_like 'a generated SQL expression'
 

data/spec/unit/axiom/sql/generator/function/predicate/visit_axiom_function_predicate_inequality_spec.rb

@@ -9,8 +9,8 @@ describe SQL::Generator::Function::Predicate, '#visit_axiom_function_predicate_i
   let(:object)          { described_class.new                                                                }
 
   context 'and the left attribute is optional' do
-    let(:attribute)  { Attribute::Integer.new(:age, :required => false) }
-    let(:inequality) { attribute.ne(1)                                  }
+    let(:attribute)  { Attribute::Integer.new(:age, required: false) }
+    let(:inequality) { attribute.ne(1)                               }
 
     it_should_behave_like 'a generated SQL expression'
 
@@ -18,7 +18,7 @@ describe SQL::Generator::Function::Predicate, '#visit_axiom_function_predicate_i
   end
 
   context 'and the right attribute is optional' do
-    let(:attribute)  { Attribute::Integer.new(:age, :required => false)  }
+    let(:attribute)  { Attribute::Integer.new(:age, required: false)     }
     let(:inequality) { Function::Predicate::Inequality.new(1, attribute) }
 
     it_should_behave_like 'a generated SQL expression'

data/spec/unit/axiom/sql/generator/literal/visit_enumerable_spec.rb

@@ -6,7 +6,7 @@ describe SQL::Generator::Literal, '#visit_enumerable' do
   subject { object.visit_enumerable(enumerable) }
 
   let(:described_class) { Class.new(SQL::Generator::Visitor) { include SQL::Generator::Literal } }
-  let(:enumerable)      { [ 1, 2 ].freeze                                                        }
+  let(:enumerable)      { [1, 2].freeze                                                          }
   let(:object)          { described_class.new                                                    }
 
   it_should_behave_like 'a generated SQL expression'

data/spec/unit/axiom/sql/generator/relation/binary/base/to_subquery_spec.rb

@@ -5,13 +5,13 @@ require 'spec_helper'
 describe SQL::Generator::Relation::Binary::Base, '#to_subquery' do
   subject { object.to_subquery }
 
-  let(:id)            { Attribute::Integer.new(:id)                      }
-  let(:name)          { Attribute::String.new(:name)                     }
-  let(:age)           { Attribute::Integer.new(:age, :required => false) }
-  let(:header)        { [ id, name, age ]                                }
-  let(:body)          { [ [ 1, 'Dan Kubb', 35 ] ].each                   }
-  let(:base_relation) { Relation::Base.new('users', header, body)        }
-  let(:object)        { described_class.new                              }
+  let(:id)            { Attribute::Integer.new(:id)                   }
+  let(:name)          { Attribute::String.new(:name)                  }
+  let(:age)           { Attribute::Integer.new(:age, required: false) }
+  let(:header)        { [id, name, age]                               }
+  let(:body)          { [[1, 'Dan Kubb', 35]].each                    }
+  let(:base_relation) { Relation::Base.new('users', header, body)     }
+  let(:object)        { described_class.new                           }
 
   context 'when no object visited' do
     it_should_behave_like 'an idempotent method'

data/spec/unit/axiom/sql/generator/relation/binary/base/visit_axiom_relation_base_spec.rb

@@ -5,14 +5,14 @@ require 'spec_helper'
 describe SQL::Generator::Relation::Binary::Base, '#visit_axiom_relation_base' do
   subject { object.visit_axiom_relation_base(base_relation) }
 
-  let(:relation_name) { 'users'                                          }
-  let(:id)            { Attribute::Integer.new(:id)                      }
-  let(:name)          { Attribute::String.new(:name)                     }
-  let(:age)           { Attribute::Integer.new(:age, :required => false) }
-  let(:header)        { [ id, name, age ]                                }
-  let(:body)          { [ [ 1, 'Dan Kubb', 35 ] ].each                   }
-  let(:base_relation) { Relation::Base.new(relation_name, header, body)  }
-  let(:object)        { described_class.new                              }
+  let(:relation_name) { 'users'                                         }
+  let(:id)            { Attribute::Integer.new(:id)                     }
+  let(:name)          { Attribute::String.new(:name)                    }
+  let(:age)           { Attribute::Integer.new(:age, required: false)   }
+  let(:header)        { [id, name, age]                                 }
+  let(:body)          { [[1, 'Dan Kubb', 35]].each                      }
+  let(:base_relation) { Relation::Base.new(relation_name, header, body) }
+  let(:object)        { described_class.new                             }
 
   it_should_behave_like 'a generated SQL SELECT query'
 

data/spec/unit/axiom/sql/generator/relation/binary/to_s_spec.rb

@@ -5,13 +5,13 @@ require 'spec_helper'
 describe SQL::Generator::Relation::Binary, '#to_s' do
   subject { object.to_s }
 
-  let(:id)            { Attribute::Integer.new(:id)                      }
-  let(:name)          { Attribute::String.new(:name)                     }
-  let(:age)           { Attribute::Integer.new(:age, :required => false) }
-  let(:header)        { [ id, name, age ]                                }
-  let(:body)          { [ [ 1, 'Dan Kubb', 35 ] ].each                   }
-  let(:base_relation) { Relation::Base.new('users', header, body)        }
-  let(:object)        { described_class.new                              }
+  let(:id)            { Attribute::Integer.new(:id)                   }
+  let(:name)          { Attribute::String.new(:name)                  }
+  let(:age)           { Attribute::Integer.new(:age, required: false) }
+  let(:header)        { [id, name, age]                               }
+  let(:body)          { [[1, 'Dan Kubb', 35]].each                    }
+  let(:base_relation) { Relation::Base.new('users', header, body)     }
+  let(:object)        { described_class.new                           }
 
   context 'when no object visited' do
     it_should_behave_like 'an idempotent method'

data/spec/unit/axiom/sql/generator/relation/binary/to_subquery_spec.rb

@@ -5,13 +5,13 @@ require 'spec_helper'
 describe SQL::Generator::Relation::Binary, '#to_subquery' do
   subject { object.to_subquery }
 
-  let(:id)            { Attribute::Integer.new(:id)                      }
-  let(:name)          { Attribute::String.new(:name)                     }
-  let(:age)           { Attribute::Integer.new(:age, :required => false) }
-  let(:header)        { [ id, name, age ]                                }
-  let(:body)          { [ [ 1, 'Dan Kubb', 35 ] ].each                   }
-  let(:base_relation) { Relation::Base.new('users', header, body)        }
-  let(:object)        { described_class.new                              }
+  let(:id)            { Attribute::Integer.new(:id)                   }
+  let(:name)          { Attribute::String.new(:name)                  }
+  let(:age)           { Attribute::Integer.new(:age, required: false) }
+  let(:header)        { [id, name, age]                               }
+  let(:body)          { [[1, 'Dan Kubb', 35]].each                    }
+  let(:base_relation) { Relation::Base.new('users', header, body)     }
+  let(:object)        { described_class.new                           }
 
   context 'when no object visited' do
     it_should_behave_like 'an idempotent method'

data/spec/unit/axiom/sql/generator/relation/binary/visit_axiom_algebra_join_spec.rb

@@ -5,18 +5,18 @@ require 'spec_helper'
 describe SQL::Generator::Relation::Binary, '#visit_axiom_algebra_join' do
   subject { object.visit_axiom_algebra_join(join) }
 
-  let(:relation_name)  { 'users'                                          }
-  let(:id)             { Attribute::Integer.new(:id)                      }
-  let(:name)           { Attribute::String.new(:name)                     }
-  let(:age)            { Attribute::Integer.new(:age, :required => false) }
-  let(:header)         { [ id, name, age ]                                }
-  let(:body)           { [ [ 1, 'Dan Kubb', 35 ] ].each                   }
-  let(:base_relation)  { Relation::Base.new(relation_name, header, body)  }
-  let(:other_relation) { Relation::Base.new('other', header, body)        }
-  let(:left)           { operand                                          }
-  let(:right)          { operand                                          }
-  let(:join)           { left.join(right)                                 }
-  let(:object)         { described_class.new                              }
+  let(:relation_name)  { 'users'                                         }
+  let(:id)             { Attribute::Integer.new(:id)                     }
+  let(:name)           { Attribute::String.new(:name)                    }
+  let(:age)            { Attribute::Integer.new(:age, required: false)   }
+  let(:header)         { [id, name, age]                                 }
+  let(:body)           { [[1, 'Dan Kubb', 35]].each                      }
+  let(:base_relation)  { Relation::Base.new(relation_name, header, body) }
+  let(:other_relation) { Relation::Base.new('other', header, body)       }
+  let(:left)           { operand                                         }
+  let(:right)          { operand                                         }
+  let(:join)           { left.join(right)                                }
+  let(:object)         { described_class.new                             }
 
   context 'when the operands are base relations' do
     let(:operand) { base_relation }
@@ -28,7 +28,7 @@ describe SQL::Generator::Relation::Binary, '#visit_axiom_algebra_join' do
   end
 
   context 'when the operands are projections' do
-    let(:operand) { base_relation.project([ :id, :name ]) }
+    let(:operand) { base_relation.project([:id, :name]) }
 
     it_should_behave_like 'a generated SQL SELECT query'
 
@@ -46,7 +46,7 @@ describe SQL::Generator::Relation::Binary, '#visit_axiom_algebra_join' do
   end
 
   context 'when the operands are rename' do
-    let(:operand) { base_relation.rename(:id => :user_id) }
+    let(:operand) { base_relation.rename(id: :user_id) }
 
     it_should_behave_like 'a generated SQL SELECT query'
 
@@ -85,7 +85,7 @@ describe SQL::Generator::Relation::Binary, '#visit_axiom_algebra_join' do
     end
 
     context 'summarize by a subset of the operand header' do
-      let(:operand) { base_relation.summarize([ :id, :name ]) { |r| r.add(:count, r.age.count) } }
+      let(:operand) { base_relation.summarize([:id, :name]) { |r| r.add(:count, r.age.count) } }
 
       it_should_behave_like 'a generated SQL SELECT query'
 
@@ -94,8 +94,8 @@ describe SQL::Generator::Relation::Binary, '#visit_axiom_algebra_join' do
     end
   end
 
-  context 'when the operands are ordered' do
-    let(:operand) { base_relation.sort_by { |r| [ r.id, r.name, r.age ] } }
+  context 'when the operands are sorted' do
+    let(:operand) { base_relation.sort_by { |r| [r.id, r.name, r.age] } }
 
     it_should_behave_like 'a generated SQL SELECT query'
 
@@ -104,7 +104,7 @@ describe SQL::Generator::Relation::Binary, '#visit_axiom_algebra_join' do
   end
 
   context 'when the operands are reversed' do
-    let(:operand) { base_relation.sort_by { |r| [ r.id, r.name, r.age ] }.reverse }
+    let(:operand) { base_relation.sort_by { |r| [r.id, r.name, r.age] }.reverse }
 
     it_should_behave_like 'a generated SQL SELECT query'
 
@@ -113,7 +113,7 @@ describe SQL::Generator::Relation::Binary, '#visit_axiom_algebra_join' do
   end
 
   context 'when the operands are limited' do
-    let(:operand) { base_relation.sort_by { |r| [ r.id, r.name, r.age ] }.take(1) }
+    let(:operand) { base_relation.sort_by { |r| [r.id, r.name, r.age] }.take(1) }
 
     it_should_behave_like 'a generated SQL SELECT query'
 
@@ -122,7 +122,7 @@ describe SQL::Generator::Relation::Binary, '#visit_axiom_algebra_join' do
   end
 
   context 'when the operands are offsets' do
-    let(:operand) { base_relation.sort_by { |r| [ r.id, r.name, r.age ] }.drop(1) }
+    let(:operand) { base_relation.sort_by { |r| [r.id, r.name, r.age] }.drop(1) }
 
     it_should_behave_like 'a generated SQL SELECT query'
 

data/spec/unit/axiom/sql/generator/relation/binary/visit_axiom_algebra_product_spec.rb

@@ -5,17 +5,17 @@ require 'spec_helper'
 describe SQL::Generator::Relation::Binary, '#visit_axiom_algebra_product' do
   subject { object.visit_axiom_algebra_product(product) }
 
-  let(:relation_name) { 'users_other'                                                              }
-  let(:id)            { Attribute::Integer.new(:id)                                                }
-  let(:name)          { Attribute::String.new(:name)                                               }
-  let(:age)           { Attribute::Integer.new(:age, :required => false)                           }
-  let(:header)        { [ id, name, age ]                                                          }
-  let(:other_header)  { [ id.rename(:other_id), name.rename(:other_name), age.rename(:other_age) ] }
-  let(:body)          { [ [ 1, 'Dan Kubb', 35 ] ].each                                             }
-  let(:users)         { Relation::Base.new('users', header, body)                                  }
-  let(:other)         { Relation::Base.new('other', other_header, body)                            }
-  let(:product)       { left.product(right)                                                        }
-  let(:object)        { described_class.new                                                        }
+  let(:relation_name) { 'users_other'                                                            }
+  let(:id)            { Attribute::Integer.new(:id)                                              }
+  let(:name)          { Attribute::String.new(:name)                                             }
+  let(:age)           { Attribute::Integer.new(:age, required: false)                            }
+  let(:header)        { [id, name, age]                                                          }
+  let(:other_header)  { [id.rename(:other_id), name.rename(:other_name), age.rename(:other_age)] }
+  let(:body)          { [[1, 'Dan Kubb', 35]].each                                               }
+  let(:users)         { Relation::Base.new('users', header, body)                                }
+  let(:other)         { Relation::Base.new('other', other_header, body)                          }
+  let(:product)       { left.product(right)                                                      }
+  let(:object)        { described_class.new                                                      }
 
   context 'when the operands are base relations' do
     let(:left)  { users }
@@ -28,8 +28,8 @@ describe SQL::Generator::Relation::Binary, '#visit_axiom_algebra_product' do
   end
 
   context 'when the operands are a projection' do
-    let(:left)  { users.project([ :id, :name ])             }
-    let(:right) { other.project([ :other_id, :other_name ]) }
+    let(:left)  { users.project([:id, :name])             }
+    let(:right) { other.project([:other_id, :other_name]) }
 
     it_should_behave_like 'a generated SQL SELECT query'
 
@@ -48,8 +48,8 @@ describe SQL::Generator::Relation::Binary, '#visit_axiom_algebra_product' do
   end
 
   context 'when the operand is a rename' do
-    let(:left)  { users.rename(:id => :user_id)             }
-    let(:right) { other.rename(:other_id => :other_user_id) }
+    let(:left)  { users.rename(id: :user_id)             }
+    let(:right) { other.rename(other_id: :other_user_id) }
 
     it_should_behave_like 'a generated SQL SELECT query'
 
@@ -91,8 +91,8 @@ describe SQL::Generator::Relation::Binary, '#visit_axiom_algebra_product' do
     end
 
     context 'summarize by a subset of the operand header' do
-      let(:left)  { users.summarize([ :id, :name ]) { |r| r.add(:count, r.age.count) }                         }
-      let(:right) { other.summarize([ :other_id, :other_name ]) { |r| r.add(:other_count, r.other_age.count) } }
+      let(:left)  { users.summarize([:id, :name]) { |r| r.add(:count, r.age.count) }                         }
+      let(:right) { other.summarize([:other_id, :other_name]) { |r| r.add(:other_count, r.other_age.count) } }
 
       it_should_behave_like 'a generated SQL SELECT query'
 
@@ -101,9 +101,9 @@ describe SQL::Generator::Relation::Binary, '#visit_axiom_algebra_product' do
     end
   end
 
-  context 'when the operand is ordered' do
-    let(:left)  { users.sort_by { |r| [ r.id, r.name, r.age ] }                   }
-    let(:right) { other.sort_by { |r| [ r.other_id, r.other_name, r.other_age ] } }
+  context 'when the operand is sorted' do
+    let(:left)  { users.sort_by { |r| [r.id, r.name, r.age] }                   }
+    let(:right) { other.sort_by { |r| [r.other_id, r.other_name, r.other_age] } }
 
     it_should_behave_like 'a generated SQL SELECT query'
 
@@ -112,8 +112,8 @@ describe SQL::Generator::Relation::Binary, '#visit_axiom_algebra_product' do
   end
 
   context 'when the operand is reversed' do
-    let(:left)  { users.sort_by { |r| [ r.id, r.name, r.age ] }.reverse                   }
-    let(:right) { other.sort_by { |r| [ r.other_id, r.other_name, r.other_age ] }.reverse }
+    let(:left)  { users.sort_by { |r| [r.id, r.name, r.age] }.reverse                   }
+    let(:right) { other.sort_by { |r| [r.other_id, r.other_name, r.other_age] }.reverse }
 
     it_should_behave_like 'a generated SQL SELECT query'
 
@@ -122,8 +122,8 @@ describe SQL::Generator::Relation::Binary, '#visit_axiom_algebra_product' do
   end
 
   context 'when the operand is limited' do
-    let(:left)  { users.sort_by { |r| [ r.id, r.name, r.age ] }.take(1)                   }
-    let(:right) { other.sort_by { |r| [ r.other_id, r.other_name, r.other_age ] }.take(1) }
+    let(:left)  { users.sort_by { |r| [r.id, r.name, r.age] }.take(1)                   }
+    let(:right) { other.sort_by { |r| [r.other_id, r.other_name, r.other_age] }.take(1) }
 
     it_should_behave_like 'a generated SQL SELECT query'
 
@@ -132,8 +132,8 @@ describe SQL::Generator::Relation::Binary, '#visit_axiom_algebra_product' do
   end
 
   context 'when the operand is an offset' do
-    let(:left)  { users.sort_by { |r| [ r.id, r.name, r.age ] }.drop(1)                   }
-    let(:right) { other.sort_by { |r| [ r.other_id, r.other_name, r.other_age ] }.drop(1) }
+    let(:left)  { users.sort_by { |r| [r.id, r.name, r.age] }.drop(1)                   }
+    let(:right) { other.sort_by { |r| [r.other_id, r.other_name, r.other_age] }.drop(1) }
 
     it_should_behave_like 'a generated SQL SELECT query'