veritas-sql-generator 0.0.3 → 0.0.4

data/spec/unit/veritas/sql/generator/function/numeric/visit_veritas_function_numeric_unary_minus_spec.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe SQL::Generator::Function::Numeric, '#visit_veritas_function_numeric_unary_minus' do
+  subject { object.visit_veritas_function_numeric_unary_minus(unary_minus) }
+
+  let(:described_class) { Class.new(SQL::Generator::Visitor) { include SQL::Generator::Function::Numeric } }
+  let(:unary_minus)     { Attribute::Integer.new(:number).unary_minus                                      }
+  let(:object)          { described_class.new                                                              }
+
+  it_should_behave_like 'a generated SQL expression'
+
+  its(:to_s) { should eql('- ("number")') }
+end

data/spec/unit/veritas/sql/generator/function/numeric/visit_veritas_function_numeric_unary_plus_spec.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe SQL::Generator::Function::Numeric, '#visit_veritas_function_numeric_unary_plus' do
+  subject { object.visit_veritas_function_numeric_unary_plus(unary_plus) }
+
+  let(:described_class) { Class.new(SQL::Generator::Visitor) { include SQL::Generator::Function::Numeric } }
+  let(:unary_plus)      { Attribute::Integer.new(:number).unary_plus                                       }
+  let(:object)          { described_class.new                                                              }
+
+  it_should_behave_like 'a generated SQL expression'
+
+  its(:to_s) { should eql('+ ("number")') }
+end

data/spec/unit/veritas/sql/generator/{logic/visit_veritas_logic_predicate_equality_spec.rb → function/predicate/visit_veritas_function_predicate_equality_spec.rb}

@@ -2,12 +2,12 @@
 
 require 'spec_helper'
 
-describe SQL::Generator::Logic, '#visit_veritas_logic_predicate_equality' do
-  subject { object.visit_veritas_logic_predicate_equality(equality) }
+describe SQL::Generator::Function::Predicate, '#visit_veritas_function_predicate_equality' do
+  subject { object.visit_veritas_function_predicate_equality(equality) }
 
-  let(:described_class) { Class.new(SQL::Generator::Visitor) { include SQL::Generator::Logic } }
-  let(:attribute)       { Attribute::Integer.new(:id)                                          }
-  let(:object)          { described_class.new                                                  }
+  let(:described_class) { Class.new(SQL::Generator::Visitor) { include SQL::Generator::Function::Predicate } }
+  let(:attribute)       { Attribute::Integer.new(:id)                                                        }
+  let(:object)          { described_class.new                                                                }
 
   context 'when the right operand is not nil' do
     let(:equality) { attribute.eq(1) }

data/spec/unit/veritas/sql/generator/{logic/visit_veritas_logic_predicate_exclusion_spec.rb → function/predicate/visit_veritas_function_predicate_exclusion_spec.rb}

@@ -2,12 +2,16 @@
 
 require 'spec_helper'
 
-describe SQL::Generator::Logic, '#visit_veritas_logic_predicate_exclusion' do
-  subject { object.visit_veritas_logic_predicate_exclusion(exclusion) }
+describe SQL::Generator::Function::Predicate, '#visit_veritas_function_predicate_exclusion' do
+  subject { object.visit_veritas_function_predicate_exclusion(exclusion) }
 
-  let(:described_class) { Class.new(SQL::Generator::Visitor) { include SQL::Generator::Logic } }
-  let(:attribute)       { Attribute::Integer.new(:id)                                          }
-  let(:object)          { described_class.new                                                  }
+  let(:described_class) { Class.new(SQL::Generator::Visitor) { include SQL::Generator::Function::Predicate } }
+  let(:attribute)       { Attribute::Integer.new(:id)                                                        }
+  let(:object)          { described_class.new                                                                }
+
+  before do
+    described_class.class_eval { include SQL::Generator::Function::Connective }
+  end
 
   context 'when right operand is an inclusive Range' do
     let(:exclusion) { attribute.exclude(1..10) }
@@ -38,6 +42,6 @@ describe SQL::Generator::Logic, '#visit_veritas_logic_predicate_exclusion' do
 
     it_should_behave_like 'a generated SQL expression'
 
-    its(:to_s) { should eql('1 = 1') }
+    its(:to_s) { should eql('TRUE') }
   end
 end

data/spec/unit/veritas/sql/generator/function/predicate/visit_veritas_function_predicate_greater_than_or_equal_to_spec.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe SQL::Generator::Function::Predicate, '#visit_veritas_function_predicate_greater_than_or_equal_to' do
+  subject { object.visit_veritas_function_predicate_greater_than_or_equal_to(greater_than_or_equal_to) }
+
+  let(:described_class)          { Class.new(SQL::Generator::Visitor) { include SQL::Generator::Function::Predicate } }
+  let(:greater_than_or_equal_to) { Attribute::Integer.new(:id).gte(1)                                                 }
+  let(:object)                   { described_class.new                                                                }
+
+  it_should_behave_like 'a generated SQL expression'
+
+  its(:to_s) { should eql('"id" >= 1') }
+end

data/spec/unit/veritas/sql/generator/{logic/visit_veritas_logic_predicate_greater_than_spec.rb → function/predicate/visit_veritas_function_predicate_greater_than_spec.rb}

@@ -2,12 +2,12 @@
 
 require 'spec_helper'
 
-describe SQL::Generator::Logic, '#visit_veritas_logic_predicate_greater_than' do
-  subject { object.visit_veritas_logic_predicate_greater_than(greater_than) }
+describe SQL::Generator::Function::Predicate, '#visit_veritas_function_predicate_greater_than' do
+  subject { object.visit_veritas_function_predicate_greater_than(greater_than) }
 
-  let(:described_class) { Class.new(SQL::Generator::Visitor) { include SQL::Generator::Logic } }
-  let(:greater_than)    { Attribute::Integer.new(:id).gt(1)                                    }
-  let(:object)          { described_class.new                                                  }
+  let(:described_class) { Class.new(SQL::Generator::Visitor) { include SQL::Generator::Function::Predicate } }
+  let(:greater_than)    { Attribute::Integer.new(:id).gt(1)                                                  }
+  let(:object)          { described_class.new                                                                }
 
   it_should_behave_like 'a generated SQL expression'
 

data/spec/unit/veritas/sql/generator/{logic/visit_veritas_logic_predicate_inclusion_spec.rb → function/predicate/visit_veritas_function_predicate_inclusion_spec.rb}

@@ -2,12 +2,16 @@
 
 require 'spec_helper'
 
-describe SQL::Generator::Logic, '#visit_veritas_logic_predicate_inclusion' do
-  subject { object.visit_veritas_logic_predicate_inclusion(inclusion) }
+describe SQL::Generator::Function::Predicate, '#visit_veritas_function_predicate_inclusion' do
+  subject { object.visit_veritas_function_predicate_inclusion(inclusion) }
 
-  let(:described_class) { Class.new(SQL::Generator::Visitor) { include SQL::Generator::Logic } }
-  let(:attribute)       { Attribute::Integer.new(:id)                                          }
-  let(:object)          { described_class.new                                                  }
+  let(:described_class) { Class.new(SQL::Generator::Visitor) { include SQL::Generator::Function::Predicate } }
+  let(:attribute)       { Attribute::Integer.new(:id)                                                        }
+  let(:object)          { described_class.new                                                                }
+
+  before do
+    described_class.class_eval { include SQL::Generator::Function::Connective }
+  end
 
   context 'when right operand is an inclusive Range' do
     let(:inclusion) { attribute.include(1..10) }
@@ -38,6 +42,6 @@ describe SQL::Generator::Logic, '#visit_veritas_logic_predicate_inclusion' do
 
     it_should_behave_like 'a generated SQL expression'
 
-    its(:to_s) { should eql('1 = 0') }
+    its(:to_s) { should eql('FALSE') }
   end
 end

data/spec/unit/veritas/sql/generator/{logic/visit_veritas_logic_predicate_inequality_spec.rb → function/predicate/visit_veritas_function_predicate_inequality_spec.rb}

@@ -2,11 +2,11 @@
 
 require 'spec_helper'
 
-describe SQL::Generator::Logic, '#visit_veritas_logic_predicate_inequality' do
-  subject { object.visit_veritas_logic_predicate_inequality(inequality) }
+describe SQL::Generator::Function::Predicate, '#visit_veritas_function_predicate_inequality' do
+  subject { object.visit_veritas_function_predicate_inequality(inequality) }
 
-  let(:described_class) { Class.new(SQL::Generator::Visitor) { include SQL::Generator::Logic } }
-  let(:object)          { described_class.new                                                  }
+  let(:described_class) { Class.new(SQL::Generator::Visitor) { include SQL::Generator::Function::Predicate } }
+  let(:object)          { described_class.new                                                                }
 
   context 'and the left attribute is optional' do
     let(:attribute)  { Attribute::Integer.new(:age, :required => false) }
@@ -18,8 +18,8 @@ describe SQL::Generator::Logic, '#visit_veritas_logic_predicate_inequality' do
   end
 
   context 'and the right attribute is optional' do
-    let(:attribute)  { Attribute::Integer.new(:age, :required => false) }
-    let(:inequality) { Logic::Predicate::Inequality.new(1, attribute)   }
+    let(:attribute)  { Attribute::Integer.new(:age, :required => false)  }
+    let(:inequality) { Function::Predicate::Inequality.new(1, attribute) }
 
     it_should_behave_like 'a generated SQL expression'
 
@@ -27,8 +27,8 @@ describe SQL::Generator::Logic, '#visit_veritas_logic_predicate_inequality' do
   end
 
   context 'and the left is a value' do
-    let(:attribute)  { Attribute::Integer.new(:id)                    }
-    let(:inequality) { Logic::Predicate::Inequality.new(1, attribute) }
+    let(:attribute)  { Attribute::Integer.new(:id)                       }
+    let(:inequality) { Function::Predicate::Inequality.new(1, attribute) }
 
     it_should_behave_like 'a generated SQL expression'
 

data/spec/unit/veritas/sql/generator/function/predicate/visit_veritas_function_predicate_less_than_or_equal_to_spec.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe SQL::Generator::Function::Predicate, '#visit_veritas_function_predicate_less_than_or_equal_to' do
+  subject { object.visit_veritas_function_predicate_less_than_or_equal_to(less_than_or_equal_to) }
+
+  let(:described_class)       { Class.new(SQL::Generator::Visitor) { include SQL::Generator::Function::Predicate } }
+  let(:less_than_or_equal_to) { Attribute::Integer.new(:id).lte(1)                                                 }
+  let(:object)                { described_class.new                                                                }
+
+  it_should_behave_like 'a generated SQL expression'
+
+  its(:to_s) { should eql('"id" <= 1') }
+end

data/spec/unit/veritas/sql/generator/{logic/visit_veritas_logic_predicate_less_than_spec.rb → function/predicate/visit_veritas_function_predicate_less_than_spec.rb}

@@ -2,12 +2,12 @@
 
 require 'spec_helper'
 
-describe SQL::Generator::Logic, '#visit_veritas_logic_predicate_less_than' do
-  subject { object.visit_veritas_logic_predicate_less_than(less_than) }
+describe SQL::Generator::Function::Predicate, '#visit_veritas_function_predicate_less_than' do
+  subject { object.visit_veritas_function_predicate_less_than(less_than) }
 
-  let(:described_class) { Class.new(SQL::Generator::Visitor) { include SQL::Generator::Logic } }
-  let(:less_than)       { Attribute::Integer.new(:id).lt(1)                                    }
-  let(:object)          { described_class.new                                                  }
+  let(:described_class) { Class.new(SQL::Generator::Visitor) { include SQL::Generator::Function::Predicate } }
+  let(:less_than)       { Attribute::Integer.new(:id).lt(1)                                                  }
+  let(:object)          { described_class.new                                                                }
 
   it_should_behave_like 'a generated SQL expression'
 

data/spec/unit/veritas/sql/generator/function/proposition/visit_veritas_function_proposition_contradiction_spec.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe SQL::Generator::Function::Proposition, '#visit_veritas_function_proposition_contradiction' do
+  subject { object.visit_veritas_function_proposition_contradiction(contradiction) }
+
+  let(:described_class) { Class.new(SQL::Generator::Visitor) { include SQL::Generator::Function::Proposition } }
+  let(:contradiction)   { Function::Proposition::Contradiction.instance                                        }
+  let(:object)          { described_class.new                                                                  }
+
+  it_should_behave_like 'a generated SQL expression'
+
+  its(:to_s) { should eql('FALSE') }
+end

data/spec/unit/veritas/sql/generator/function/proposition/visit_veritas_function_proposition_tautology_spec.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe SQL::Generator::Function::Proposition, '#visit_veritas_function_proposition_tautology' do
+  subject { object.visit_veritas_function_proposition_tautology(tautology) }
+
+  let(:described_class) { Class.new(SQL::Generator::Visitor) { include SQL::Generator::Function::Proposition } }
+  let(:tautology)       { Function::Proposition::Tautology.instance                                            }
+  let(:object)          { described_class.new                                                                  }
+
+  it_should_behave_like 'a generated SQL expression'
+
+  its(:to_s) { should eql('TRUE') }
+end

data/spec/unit/veritas/sql/generator/function/string/visit_veritas_function_string_length_spec.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe SQL::Generator::Function::String, '#visit_veritas_function_string_length' do
+  subject { object.visit_veritas_function_string_length(length) }
+
+  let(:described_class) { Class.new(SQL::Generator::Visitor) { include SQL::Generator::Function::String } }
+  let(:length)          { Attribute::String.new(:name).length                                             }
+  let(:object)          { described_class.new                                                             }
+
+  it_should_behave_like 'a generated SQL expression'
+
+  its(:to_s) { should eql('LENGTH ("name")') }
+end

data/spec/unit/veritas/sql/generator/literal/class_methods/dup_frozen_spec.rb

@@ -8,7 +8,7 @@ describe SQL::Generator::Literal, '.dup_frozen' do
   let(:object) { SQL::Generator::Literal }
 
   context 'with a frozen object' do
-    let(:object_arg) { Date.today.freeze }
+    let(:object_arg) { Time.now.freeze }
 
     it { should_not equal(object_arg) }
 
@@ -16,7 +16,7 @@ describe SQL::Generator::Literal, '.dup_frozen' do
   end
 
   context 'with a non-frozen object' do
-    let(:object_arg) { Date.today }
+    let(:object_arg) { Time.now }
 
     it { should equal(object_arg) }
   end

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

@@ -10,7 +10,7 @@ describe SQL::Generator::Relation::Binary::Base, '#to_subquery' do
   let(:age)           { Attribute::Integer.new(:age, :required => false) }
   let(:header)        { [ id, name, age ]                                }
   let(:body)          { [ [ 1, 'Dan Kubb', 35 ] ].each                   }
-  let(:base_relation) { BaseRelation.new('users', header, body)          }
+  let(:base_relation) { Relation::Base.new('users', header, body)        }
   let(:object)        { described_class.new                              }
 
   context 'when no object visited' do

data/spec/unit/veritas/sql/generator/relation/binary/base/{visit_veritas_base_relation_spec.rb → visit_veritas_relation_base_spec.rb}

@@ -2,8 +2,8 @@
 
 require 'spec_helper'
 
-describe SQL::Generator::Relation::Binary::Base, '#visit_veritas_base_relation' do
-  subject { object.visit_veritas_base_relation(base_relation) }
+describe SQL::Generator::Relation::Binary::Base, '#visit_veritas_relation_base' do
+  subject { object.visit_veritas_relation_base(base_relation) }
 
   let(:relation_name) { 'users'                                          }
   let(:id)            { Attribute::Integer.new(:id)                      }
@@ -11,7 +11,7 @@ describe SQL::Generator::Relation::Binary::Base, '#visit_veritas_base_relation'
   let(:age)           { Attribute::Integer.new(:age, :required => false) }
   let(:header)        { [ id, name, age ]                                }
   let(:body)          { [ [ 1, 'Dan Kubb', 35 ] ].each                   }
-  let(:base_relation) { BaseRelation.new(relation_name, header, body)    }
+  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/veritas/sql/generator/relation/binary/to_s_spec.rb

@@ -10,7 +10,7 @@ describe SQL::Generator::Relation::Binary, '#to_s' do
   let(:age)           { Attribute::Integer.new(:age, :required => false) }
   let(:header)        { [ id, name, age ]                                }
   let(:body)          { [ [ 1, 'Dan Kubb', 35 ] ].each                   }
-  let(:base_relation) { BaseRelation.new('users', header, body)          }
+  let(:base_relation) { Relation::Base.new('users', header, body)        }
   let(:object)        { described_class.new                              }
 
   context 'when no object visited' do
@@ -30,6 +30,6 @@ describe SQL::Generator::Relation::Binary, '#to_s' do
 
     it_should_behave_like 'a generated SQL expression'
 
-    its(:to_s) { should eql('SELECT "id", "name", "age" FROM "users" NATURAL JOIN "users"') }
+    its(:to_s) { should eql('SELECT "id", "name", "age" FROM "users" AS "left" NATURAL JOIN "users" AS "right"') }
   end
 end

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

@@ -10,7 +10,7 @@ describe SQL::Generator::Relation::Binary, '#to_subquery' do
   let(:age)           { Attribute::Integer.new(:age, :required => false) }
   let(:header)        { [ id, name, age ]                                }
   let(:body)          { [ [ 1, 'Dan Kubb', 35 ] ].each                   }
-  let(:base_relation) { BaseRelation.new('users', header, body)          }
+  let(:base_relation) { Relation::Base.new('users', header, body)        }
   let(:object)        { described_class.new                              }
 
   context 'when no object visited' do
@@ -30,6 +30,6 @@ describe SQL::Generator::Relation::Binary, '#to_subquery' do
 
     it_should_behave_like 'a generated SQL expression'
 
-    its(:to_s) { should eql('SELECT * FROM "users" NATURAL JOIN "users"') }
+    its(:to_s) { should eql('(SELECT * FROM "users" AS "left" NATURAL JOIN "users" AS "right")') }
   end
 end

data/spec/unit/veritas/sql/generator/relation/binary/visit_veritas_algebra_join_spec.rb

@@ -5,25 +5,26 @@ require 'spec_helper'
 describe SQL::Generator::Relation::Binary, '#visit_veritas_algebra_join' do
   subject { object.visit_veritas_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) { BaseRelation.new(relation_name, 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 }
 
     it_should_behave_like 'a generated SQL SELECT query'
 
-    its(:to_s)        { should eql('SELECT "id", "name", "age" FROM "users" NATURAL JOIN "users"') }
-    its(:to_subquery) { should eql('SELECT * FROM "users" NATURAL JOIN "users"')                   }
+    its(:to_s)        { should eql('SELECT "id", "name", "age" FROM "users" AS "left" NATURAL JOIN "users" AS "right"') }
+    its(:to_subquery) { should eql('(SELECT * FROM "users" AS "left" NATURAL JOIN "users" AS "right")')                 }
   end
 
   context 'when the operands are projections' do
@@ -32,7 +33,16 @@ describe SQL::Generator::Relation::Binary, '#visit_veritas_algebra_join' do
     it_should_behave_like 'a generated SQL SELECT query'
 
     its(:to_s)        { should eql('SELECT "id", "name" FROM (SELECT DISTINCT "id", "name" FROM "users") AS "left" NATURAL JOIN (SELECT DISTINCT "id", "name" FROM "users") AS "right"') }
-    its(:to_subquery) { should eql('SELECT * FROM (SELECT DISTINCT "id", "name" FROM "users") AS "left" NATURAL JOIN (SELECT DISTINCT "id", "name" FROM "users") AS "right"')            }
+    its(:to_subquery) { should eql('(SELECT * FROM (SELECT DISTINCT "id", "name" FROM "users") AS "left" NATURAL JOIN (SELECT DISTINCT "id", "name" FROM "users") AS "right")')          }
+  end
+
+  context 'when the operand is an extension' do
+    let(:operand) { base_relation.extend { |r| r.add(:one, 1) } }
+
+    it_should_behave_like 'a generated SQL SELECT query'
+
+    its(:to_s)        { should eql('SELECT "id", "name", "age", "one" FROM (SELECT *, 1 AS "one" FROM "users") AS "left" NATURAL JOIN (SELECT *, 1 AS "one" FROM "users") AS "right"') }
+    its(:to_subquery) { should eql('(SELECT * FROM (SELECT *, 1 AS "one" FROM "users") AS "left" NATURAL JOIN (SELECT *, 1 AS "one" FROM "users") AS "right")')                        }
   end
 
   context 'when the operands are rename' do
@@ -41,7 +51,7 @@ describe SQL::Generator::Relation::Binary, '#visit_veritas_algebra_join' do
     it_should_behave_like 'a generated SQL SELECT query'
 
     its(:to_s)        { should eql('SELECT "user_id", "name", "age" FROM (SELECT "id" AS "user_id", "name", "age" FROM "users") AS "left" NATURAL JOIN (SELECT "id" AS "user_id", "name", "age" FROM "users") AS "right"') }
-    its(:to_subquery) { should eql('SELECT * FROM (SELECT "id" AS "user_id", "name", "age" FROM "users") AS "left" NATURAL JOIN (SELECT "id" AS "user_id", "name", "age" FROM "users") AS "right"')                        }
+    its(:to_subquery) { should eql('(SELECT * FROM (SELECT "id" AS "user_id", "name", "age" FROM "users") AS "left" NATURAL JOIN (SELECT "id" AS "user_id", "name", "age" FROM "users") AS "right")')                      }
   end
 
   context 'when the operands are restrictions' do
@@ -50,7 +60,38 @@ describe SQL::Generator::Relation::Binary, '#visit_veritas_algebra_join' do
     it_should_behave_like 'a generated SQL SELECT query'
 
     its(:to_s)        { should eql('SELECT "id", "name", "age" FROM (SELECT * FROM "users" WHERE "id" = 1) AS "left" NATURAL JOIN (SELECT * FROM "users" WHERE "id" = 1) AS "right"') }
-    its(:to_subquery) { should eql('SELECT * FROM (SELECT * FROM "users" WHERE "id" = 1) AS "left" NATURAL JOIN (SELECT * FROM "users" WHERE "id" = 1) AS "right"')                   }
+    its(:to_subquery) { should eql('(SELECT * FROM (SELECT * FROM "users" WHERE "id" = 1) AS "left" NATURAL JOIN (SELECT * FROM "users" WHERE "id" = 1) AS "right")')                 }
+  end
+
+  context 'when the operand is a summarization' do
+    context 'summarize per table dee' do
+      let(:summarize_per) { TABLE_DEE                                                                  }
+      let(:operand)       { base_relation.summarize(summarize_per) { |r| r.add(:count, r[:id].count) } }
+
+      it_should_behave_like 'a generated SQL SELECT query'
+
+      its(:to_s)        { should eql('SELECT "count" FROM (SELECT COUNT ("id") AS "count" FROM "users") AS "left" NATURAL JOIN (SELECT COUNT ("id") AS "count" FROM "users") AS "right"') }
+      its(:to_subquery) { should eql('(SELECT * FROM (SELECT COUNT ("id") AS "count" FROM "users") AS "left" NATURAL JOIN (SELECT COUNT ("id") AS "count" FROM "users") AS "right")')     }
+    end
+
+    context 'summarize per table dum' do
+      let(:summarize_per) { TABLE_DUM                                                                  }
+      let(:operand)       { base_relation.summarize(summarize_per) { |r| r.add(:count, r[:id].count) } }
+
+      it_should_behave_like 'a generated SQL SELECT query'
+
+      its(:to_s)        { should eql('SELECT "count" FROM (SELECT COUNT ("id") AS "count" FROM "users" HAVING FALSE) AS "left" NATURAL JOIN (SELECT COUNT ("id") AS "count" FROM "users" HAVING FALSE) AS "right"') }
+      its(:to_subquery) { should eql('(SELECT * FROM (SELECT COUNT ("id") AS "count" FROM "users" HAVING FALSE) AS "left" NATURAL JOIN (SELECT COUNT ("id") AS "count" FROM "users" HAVING FALSE) AS "right")')     }
+    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) } }
+
+      it_should_behave_like 'a generated SQL SELECT query'
+
+      its(:to_s)        { should eql('SELECT "id", "name", "count" FROM (SELECT "id", "name", COUNT ("age") AS "count" FROM "users" GROUP BY "id", "name" HAVING COUNT (*) > 0) AS "left" NATURAL JOIN (SELECT "id", "name", COUNT ("age") AS "count" FROM "users" GROUP BY "id", "name" HAVING COUNT (*) > 0) AS "right"') }
+      its(:to_subquery) { should eql('(SELECT * FROM (SELECT "id", "name", COUNT ("age") AS "count" FROM "users" GROUP BY "id", "name" HAVING COUNT (*) > 0) AS "left" NATURAL JOIN (SELECT "id", "name", COUNT ("age") AS "count" FROM "users" GROUP BY "id", "name" HAVING COUNT (*) > 0) AS "right")')                   }
+    end
   end
 
   context 'when the operands are ordered' do
@@ -59,7 +100,7 @@ describe SQL::Generator::Relation::Binary, '#visit_veritas_algebra_join' do
     it_should_behave_like 'a generated SQL SELECT query'
 
     its(:to_s)        { should eql('SELECT "id", "name", "age" FROM (SELECT * FROM "users" ORDER BY "id", "name", "age") AS "left" NATURAL JOIN (SELECT * FROM "users" ORDER BY "id", "name", "age") AS "right"') }
-    its(:to_subquery) { should eql('SELECT * FROM (SELECT * FROM "users" ORDER BY "id", "name", "age") AS "left" NATURAL JOIN (SELECT * FROM "users" ORDER BY "id", "name", "age") AS "right"')                   }
+    its(:to_subquery) { should eql('(SELECT * FROM (SELECT * FROM "users" ORDER BY "id", "name", "age") AS "left" NATURAL JOIN (SELECT * FROM "users" ORDER BY "id", "name", "age") AS "right")')                 }
   end
 
   context 'when the operands are reversed' do
@@ -68,7 +109,7 @@ describe SQL::Generator::Relation::Binary, '#visit_veritas_algebra_join' do
     it_should_behave_like 'a generated SQL SELECT query'
 
     its(:to_s)        { should eql('SELECT "id", "name", "age" FROM (SELECT * FROM "users" ORDER BY "id" DESC, "name" DESC, "age" DESC) AS "left" NATURAL JOIN (SELECT * FROM "users" ORDER BY "id" DESC, "name" DESC, "age" DESC) AS "right"') }
-    its(:to_subquery) { should eql('SELECT * FROM (SELECT * FROM "users" ORDER BY "id" DESC, "name" DESC, "age" DESC) AS "left" NATURAL JOIN (SELECT * FROM "users" ORDER BY "id" DESC, "name" DESC, "age" DESC) AS "right"')                   }
+    its(:to_subquery) { should eql('(SELECT * FROM (SELECT * FROM "users" ORDER BY "id" DESC, "name" DESC, "age" DESC) AS "left" NATURAL JOIN (SELECT * FROM "users" ORDER BY "id" DESC, "name" DESC, "age" DESC) AS "right")')                 }
   end
 
   context 'when the operands are limited' do
@@ -77,7 +118,7 @@ describe SQL::Generator::Relation::Binary, '#visit_veritas_algebra_join' do
     it_should_behave_like 'a generated SQL SELECT query'
 
     its(:to_s)        { should eql('SELECT "id", "name", "age" FROM (SELECT * FROM "users" ORDER BY "id", "name", "age" LIMIT 1) AS "left" NATURAL JOIN (SELECT * FROM "users" ORDER BY "id", "name", "age" LIMIT 1) AS "right"') }
-    its(:to_subquery) { should eql('SELECT * FROM (SELECT * FROM "users" ORDER BY "id", "name", "age" LIMIT 1) AS "left" NATURAL JOIN (SELECT * FROM "users" ORDER BY "id", "name", "age" LIMIT 1) AS "right"')                   }
+    its(:to_subquery) { should eql('(SELECT * FROM (SELECT * FROM "users" ORDER BY "id", "name", "age" LIMIT 1) AS "left" NATURAL JOIN (SELECT * FROM "users" ORDER BY "id", "name", "age" LIMIT 1) AS "right")')                 }
   end
 
   context 'when the operands are offsets' do
@@ -86,7 +127,7 @@ describe SQL::Generator::Relation::Binary, '#visit_veritas_algebra_join' do
     it_should_behave_like 'a generated SQL SELECT query'
 
     its(:to_s)        { should eql('SELECT "id", "name", "age" FROM (SELECT * FROM "users" ORDER BY "id", "name", "age" OFFSET 1) AS "left" NATURAL JOIN (SELECT * FROM "users" ORDER BY "id", "name", "age" OFFSET 1) AS "right"') }
-    its(:to_subquery) { should eql('SELECT * FROM (SELECT * FROM "users" ORDER BY "id", "name", "age" OFFSET 1) AS "left" NATURAL JOIN (SELECT * FROM "users" ORDER BY "id", "name", "age" OFFSET 1) AS "right"')                   }
+    its(:to_subquery) { should eql('(SELECT * FROM (SELECT * FROM "users" ORDER BY "id", "name", "age" OFFSET 1) AS "left" NATURAL JOIN (SELECT * FROM "users" ORDER BY "id", "name", "age" OFFSET 1) AS "right")')                 }
   end
 
   context 'when the operands are differences' do
@@ -94,8 +135,8 @@ describe SQL::Generator::Relation::Binary, '#visit_veritas_algebra_join' do
 
     it_should_behave_like 'a generated SQL SELECT query'
 
-    its(:to_s)        { should eql('SELECT "id", "name", "age" FROM ((SELECT * FROM "users") EXCEPT (SELECT * FROM "users")) AS "left" NATURAL JOIN ((SELECT * FROM "users") EXCEPT (SELECT * FROM "users")) AS "right"') }
-    its(:to_subquery) { should eql('SELECT * FROM ((SELECT * FROM "users") EXCEPT (SELECT * FROM "users")) AS "left" NATURAL JOIN ((SELECT * FROM "users") EXCEPT (SELECT * FROM "users")) AS "right"')                   }
+    its(:to_s)        { should eql('SELECT "id", "name", "age" FROM ((SELECT "id", "name", "age" FROM "users") EXCEPT (SELECT "id", "name", "age" FROM "users")) AS "left" NATURAL JOIN ((SELECT "id", "name", "age" FROM "users") EXCEPT (SELECT "id", "name", "age" FROM "users")) AS "right"') }
+    its(:to_subquery) { should eql('(SELECT * FROM ((SELECT "id", "name", "age" FROM "users") EXCEPT (SELECT "id", "name", "age" FROM "users")) AS "left" NATURAL JOIN ((SELECT "id", "name", "age" FROM "users") EXCEPT (SELECT "id", "name", "age" FROM "users")) AS "right")')                 }
   end
 
   context 'when the operands are intersections' do
@@ -103,8 +144,8 @@ describe SQL::Generator::Relation::Binary, '#visit_veritas_algebra_join' do
 
     it_should_behave_like 'a generated SQL SELECT query'
 
-    its(:to_s)        { should eql('SELECT "id", "name", "age" FROM ((SELECT * FROM "users") INTERSECT (SELECT * FROM "users")) AS "left" NATURAL JOIN ((SELECT * FROM "users") INTERSECT (SELECT * FROM "users")) AS "right"') }
-    its(:to_subquery) { should eql('SELECT * FROM ((SELECT * FROM "users") INTERSECT (SELECT * FROM "users")) AS "left" NATURAL JOIN ((SELECT * FROM "users") INTERSECT (SELECT * FROM "users")) AS "right"')                   }
+    its(:to_s)        { should eql('SELECT "id", "name", "age" FROM ((SELECT "id", "name", "age" FROM "users") INTERSECT (SELECT "id", "name", "age" FROM "users")) AS "left" NATURAL JOIN ((SELECT "id", "name", "age" FROM "users") INTERSECT (SELECT "id", "name", "age" FROM "users")) AS "right"') }
+    its(:to_subquery) { should eql('(SELECT * FROM ((SELECT "id", "name", "age" FROM "users") INTERSECT (SELECT "id", "name", "age" FROM "users")) AS "left" NATURAL JOIN ((SELECT "id", "name", "age" FROM "users") INTERSECT (SELECT "id", "name", "age" FROM "users")) AS "right")')                 }
   end
 
   context 'when the operands are unions' do
@@ -112,8 +153,8 @@ describe SQL::Generator::Relation::Binary, '#visit_veritas_algebra_join' do
 
     it_should_behave_like 'a generated SQL SELECT query'
 
-    its(:to_s)        { should eql('SELECT "id", "name", "age" FROM ((SELECT * FROM "users") UNION (SELECT * FROM "users")) AS "left" NATURAL JOIN ((SELECT * FROM "users") UNION (SELECT * FROM "users")) AS "right"') }
-    its(:to_subquery) { should eql('SELECT * FROM ((SELECT * FROM "users") UNION (SELECT * FROM "users")) AS "left" NATURAL JOIN ((SELECT * FROM "users") UNION (SELECT * FROM "users")) AS "right"')                   }
+    its(:to_s)        { should eql('SELECT "id", "name", "age" FROM ((SELECT "id", "name", "age" FROM "users") UNION (SELECT "id", "name", "age" FROM "users")) AS "left" NATURAL JOIN ((SELECT "id", "name", "age" FROM "users") UNION (SELECT "id", "name", "age" FROM "users")) AS "right"') }
+    its(:to_subquery) { should eql('(SELECT * FROM ((SELECT "id", "name", "age" FROM "users") UNION (SELECT "id", "name", "age" FROM "users")) AS "left" NATURAL JOIN ((SELECT "id", "name", "age" FROM "users") UNION (SELECT "id", "name", "age" FROM "users")) AS "right")')                 }
   end
 
   context 'when the operands are joins' do
@@ -121,18 +162,18 @@ describe SQL::Generator::Relation::Binary, '#visit_veritas_algebra_join' do
 
     it_should_behave_like 'a generated SQL SELECT query'
 
-    its(:to_s)        { should eql('SELECT "id", "name", "age" FROM (SELECT * FROM "users" NATURAL JOIN "users") AS "left" NATURAL JOIN (SELECT * FROM "users" NATURAL JOIN "users") AS "right"') }
-    its(:to_subquery) { should eql('SELECT * FROM (SELECT * FROM "users" NATURAL JOIN "users") AS "left" NATURAL JOIN (SELECT * FROM "users" NATURAL JOIN "users") AS "right"')                   }
+    its(:to_s)        { should eql('SELECT "id", "name", "age" FROM (SELECT * FROM "users" AS "left" NATURAL JOIN "users" AS "right") AS "left" NATURAL JOIN (SELECT * FROM "users" AS "left" NATURAL JOIN "users" AS "right") AS "right"') }
+    its(:to_subquery) { should eql('(SELECT * FROM (SELECT * FROM "users" AS "left" NATURAL JOIN "users" AS "right") AS "left" NATURAL JOIN (SELECT * FROM "users" AS "left" NATURAL JOIN "users" AS "right") AS "right")')                 }
   end
 
   context 'when the operands have different base relations' do
-    let(:relation_name) { 'users_others'                           }
-    let(:left)          { BaseRelation.new('users',  header, body) }
-    let(:right)         { BaseRelation.new('others', header, body) }
+    let(:relation_name) { 'users_others'                             }
+    let(:left)          { Relation::Base.new('users',  header, body) }
+    let(:right)         { Relation::Base.new('others', header, body) }
 
     it_should_behave_like 'a generated SQL SELECT query'
 
-    its(:to_s)        { should eql('SELECT "id", "name", "age" FROM "users" NATURAL JOIN "others"') }
-    its(:to_subquery) { should eql('SELECT * FROM "users" NATURAL JOIN "others"')                   }
+    its(:to_s)        { should eql('SELECT "id", "name", "age" FROM "users" AS "left" NATURAL JOIN "others" AS "right"') }
+    its(:to_subquery) { should eql('(SELECT * FROM "users" AS "left" NATURAL JOIN "others" AS "right")')                 }
   end
 end