veritas-sql-generator 0.0.3 → 0.0.4

data/spec/unit/veritas/sql/generator/relation/unary/visit_veritas_algebra_rename_spec.rb

@@ -11,7 +11,7 @@ describe SQL::Generator::Relation::Unary, '#visit_veritas_algebra_rename' 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(relation_name, header, body)    }
+  let(:base_relation) { Relation::Base.new(relation_name, header, body)  }
   let(:rename)        { operand.rename(:id => :user_id)                  }
   let(:object)        { described_class.new                              }
 
@@ -20,8 +20,8 @@ describe SQL::Generator::Relation::Unary, '#visit_veritas_algebra_rename' do
 
     it_should_behave_like 'a generated SQL SELECT query'
 
-    its(:to_s)        { should eql('SELECT "id" AS "user_id", "name", "age" FROM "users"') }
-    its(:to_subquery) { should eql('SELECT "id" AS "user_id", "name", "age" FROM "users"') }
+    its(:to_s)        { should eql('SELECT "id" AS "user_id", "name", "age" FROM "users"')   }
+    its(:to_subquery) { should eql('(SELECT "id" AS "user_id", "name", "age" FROM "users")') }
   end
 
   context 'when the operand is a projection' do
@@ -29,8 +29,17 @@ describe SQL::Generator::Relation::Unary, '#visit_veritas_algebra_rename' do
 
     it_should_behave_like 'a generated SQL SELECT query'
 
-    its(:to_s)        { should eql('SELECT DISTINCT "id" AS "user_id", "name" FROM "users"') }
-    its(:to_subquery) { should eql('SELECT DISTINCT "id" AS "user_id", "name" FROM "users"') }
+    its(:to_s)        { should eql('SELECT DISTINCT "id" AS "user_id", "name" FROM "users"')   }
+    its(:to_subquery) { should eql('(SELECT DISTINCT "id" AS "user_id", "name" FROM "users")') }
+  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)        { pending { should eql('SELECT "id" AS "user_id", "name", "age", 1 AS "one" FROM "users"') } }
+    its(:to_subquery) { pending { should eql('SELECT "id" AS "user_id", "name", "age", 1 AS "one" FROM "users"') } }
   end
 
   context 'when the operand is a rename' do
@@ -39,8 +48,8 @@ describe SQL::Generator::Relation::Unary, '#visit_veritas_algebra_rename' do
     context 'when the relation is not optimized' do
       it_should_behave_like 'a generated SQL SELECT query'
 
-      its(:to_s)        { should eql('SELECT "id" AS "user_id", "other_name", "age" FROM (SELECT "id", "name" AS "other_name", "age" FROM "users") AS "users"') }
-      its(:to_subquery) { should eql('SELECT "id" AS "user_id", "other_name", "age" FROM (SELECT "id", "name" AS "other_name", "age" FROM "users") AS "users"') }
+      its(:to_s)        { should eql('SELECT "id" AS "user_id", "other_name", "age" FROM (SELECT "id", "name" AS "other_name", "age" FROM "users") AS "users"')   }
+      its(:to_subquery) { should eql('(SELECT "id" AS "user_id", "other_name", "age" FROM (SELECT "id", "name" AS "other_name", "age" FROM "users") AS "users")') }
     end
 
     context 'when the operand is empty' do
@@ -48,8 +57,8 @@ describe SQL::Generator::Relation::Unary, '#visit_veritas_algebra_rename' do
 
       it_should_behave_like 'a generated SQL SELECT query'
 
-      its(:to_s)        { should eql('SELECT "id" AS "user_id", "name", "age" FROM (SELECT "id", "name", "age" FROM "users") AS "users"') }
-      its(:to_subquery) { should eql('SELECT "id" AS "user_id", "name", "age" FROM (SELECT "id", "name", "age" FROM "users") AS "users"') }
+      its(:to_s)        { should eql('SELECT "id" AS "user_id", "name", "age" FROM (SELECT "id", "name", "age" FROM "users") AS "users"')   }
+      its(:to_subquery) { should eql('(SELECT "id" AS "user_id", "name", "age" FROM (SELECT "id", "name", "age" FROM "users") AS "users")') }
     end
   end
 
@@ -58,8 +67,41 @@ describe SQL::Generator::Relation::Unary, '#visit_veritas_algebra_rename' do
 
     it_should_behave_like 'a generated SQL SELECT query'
 
-    its(:to_s)        { should eql('SELECT "id" AS "user_id", "name", "age" FROM "users" WHERE "id" = 1') }
-    its(:to_subquery) { should eql('SELECT "id" AS "user_id", "name", "age" FROM "users" WHERE "id" = 1') }
+    its(:to_s)        { should eql('SELECT "id" AS "user_id", "name", "age" FROM "users" WHERE "id" = 1')   }
+    its(:to_subquery) { should eql('(SELECT "id" AS "user_id", "name", "age" FROM "users" WHERE "id" = 1)') }
+  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) } }
+      let(:rename)        { operand.rename(:count => :other_count)                                     }
+
+      it_should_behave_like 'a generated SQL SELECT query'
+
+      its(:to_s)        { should eql('SELECT "count" AS "other_count" FROM (SELECT COUNT ("id") AS "count" FROM "users") AS "users"')   }
+      its(:to_subquery) { should eql('(SELECT "count" AS "other_count" FROM (SELECT COUNT ("id") AS "count" FROM "users") AS "users")') }
+    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) } }
+      let(:rename)        { operand.rename(:count => :other_count)                                     }
+
+      it_should_behave_like 'a generated SQL SELECT query'
+
+      its(:to_s)        { should eql('SELECT "count" AS "other_count" FROM (SELECT COUNT ("id") AS "count" FROM "users" HAVING FALSE) AS "users"')   }
+      its(:to_subquery) { should eql('(SELECT "count" AS "other_count" FROM (SELECT COUNT ("id") AS "count" FROM "users" HAVING FALSE) AS "users")') }
+    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)        { pending { should eql('SELECT "id" AS "user_id", "name", COUNT ("age") AS "count" FROM "users" GROUP BY "id", "name"') } }
+      its(:to_subquery) { pending { should eql('SELECT "id" AS "user_id", "name", COUNT ("age") AS "count" FROM "users" GROUP BY "id", "name"') } }
+    end
   end
 
   context 'when the operand is ordered' do
@@ -67,8 +109,8 @@ describe SQL::Generator::Relation::Unary, '#visit_veritas_algebra_rename' do
 
     it_should_behave_like 'a generated SQL SELECT query'
 
-    its(:to_s)        { should eql('SELECT "id" AS "user_id", "name", "age" FROM "users" ORDER BY "id", "name", "age"') }
-    its(:to_subquery) { should eql('SELECT "id" AS "user_id", "name", "age" FROM "users" ORDER BY "id", "name", "age"') }
+    its(:to_s)        { should eql('SELECT "id" AS "user_id", "name", "age" FROM "users" ORDER BY "id", "name", "age"')   }
+    its(:to_subquery) { should eql('(SELECT "id" AS "user_id", "name", "age" FROM "users" ORDER BY "id", "name", "age")') }
   end
 
   context 'when the operand is reversed' do
@@ -76,8 +118,8 @@ describe SQL::Generator::Relation::Unary, '#visit_veritas_algebra_rename' do
 
     it_should_behave_like 'a generated SQL SELECT query'
 
-    its(:to_s)        { should eql('SELECT "id" AS "user_id", "name", "age" FROM "users" ORDER BY "id" DESC, "name" DESC, "age" DESC') }
-    its(:to_subquery) { should eql('SELECT "id" AS "user_id", "name", "age" FROM "users" ORDER BY "id" DESC, "name" DESC, "age" DESC') }
+    its(:to_s)        { should eql('SELECT "id" AS "user_id", "name", "age" FROM "users" ORDER BY "id" DESC, "name" DESC, "age" DESC')   }
+    its(:to_subquery) { should eql('(SELECT "id" AS "user_id", "name", "age" FROM "users" ORDER BY "id" DESC, "name" DESC, "age" DESC)') }
   end
 
   context 'when the operand is limited' do
@@ -85,8 +127,8 @@ describe SQL::Generator::Relation::Unary, '#visit_veritas_algebra_rename' do
 
     it_should_behave_like 'a generated SQL SELECT query'
 
-    its(:to_s)        { should eql('SELECT "id" AS "user_id", "name", "age" FROM "users" ORDER BY "id", "name", "age" LIMIT 1') }
-    its(:to_subquery) { should eql('SELECT "id" AS "user_id", "name", "age" FROM "users" ORDER BY "id", "name", "age" LIMIT 1') }
+    its(:to_s)        { should eql('SELECT "id" AS "user_id", "name", "age" FROM "users" ORDER BY "id", "name", "age" LIMIT 1')   }
+    its(:to_subquery) { should eql('(SELECT "id" AS "user_id", "name", "age" FROM "users" ORDER BY "id", "name", "age" LIMIT 1)') }
   end
 
   context 'when the operand is an offset' do
@@ -94,8 +136,8 @@ describe SQL::Generator::Relation::Unary, '#visit_veritas_algebra_rename' do
 
     it_should_behave_like 'a generated SQL SELECT query'
 
-    its(:to_s)        { should eql('SELECT "id" AS "user_id", "name", "age" FROM "users" ORDER BY "id", "name", "age" OFFSET 1') }
-    its(:to_subquery) { should eql('SELECT "id" AS "user_id", "name", "age" FROM "users" ORDER BY "id", "name", "age" OFFSET 1') }
+    its(:to_s)        { should eql('SELECT "id" AS "user_id", "name", "age" FROM "users" ORDER BY "id", "name", "age" OFFSET 1')   }
+    its(:to_subquery) { should eql('(SELECT "id" AS "user_id", "name", "age" FROM "users" ORDER BY "id", "name", "age" OFFSET 1)') }
   end
 
   context 'when the operand is a difference' do
@@ -103,8 +145,8 @@ describe SQL::Generator::Relation::Unary, '#visit_veritas_algebra_rename' do
 
     it_should_behave_like 'a generated SQL SELECT query'
 
-    its(:to_s)        { should eql('SELECT "id" AS "user_id", "name", "age" FROM ((SELECT * FROM "users") EXCEPT (SELECT * FROM "users")) AS "users"') }
-    its(:to_subquery) { should eql('SELECT "id" AS "user_id", "name", "age" FROM ((SELECT * FROM "users") EXCEPT (SELECT * FROM "users")) AS "users"') }
+    its(:to_s)        { should eql('SELECT "id" AS "user_id", "name", "age" FROM ((SELECT "id", "name", "age" FROM "users") EXCEPT (SELECT "id", "name", "age" FROM "users")) AS "users"')   }
+    its(:to_subquery) { should eql('(SELECT "id" AS "user_id", "name", "age" FROM ((SELECT "id", "name", "age" FROM "users") EXCEPT (SELECT "id", "name", "age" FROM "users")) AS "users")') }
   end
 
   context 'when the operand is an intersection' do
@@ -112,8 +154,8 @@ describe SQL::Generator::Relation::Unary, '#visit_veritas_algebra_rename' do
 
     it_should_behave_like 'a generated SQL SELECT query'
 
-    its(:to_s)        { should eql('SELECT "id" AS "user_id", "name", "age" FROM ((SELECT * FROM "users") INTERSECT (SELECT * FROM "users")) AS "users"') }
-    its(:to_subquery) { should eql('SELECT "id" AS "user_id", "name", "age" FROM ((SELECT * FROM "users") INTERSECT (SELECT * FROM "users")) AS "users"') }
+    its(:to_s)        { should eql('SELECT "id" AS "user_id", "name", "age" FROM ((SELECT "id", "name", "age" FROM "users") INTERSECT (SELECT "id", "name", "age" FROM "users")) AS "users"')   }
+    its(:to_subquery) { should eql('(SELECT "id" AS "user_id", "name", "age" FROM ((SELECT "id", "name", "age" FROM "users") INTERSECT (SELECT "id", "name", "age" FROM "users")) AS "users")') }
   end
 
   context 'when the operand is a union' do
@@ -121,8 +163,8 @@ describe SQL::Generator::Relation::Unary, '#visit_veritas_algebra_rename' do
 
     it_should_behave_like 'a generated SQL SELECT query'
 
-    its(:to_s)        { should eql('SELECT "id" AS "user_id", "name", "age" FROM ((SELECT * FROM "users") UNION (SELECT * FROM "users")) AS "users"') }
-    its(:to_subquery) { should eql('SELECT "id" AS "user_id", "name", "age" FROM ((SELECT * FROM "users") UNION (SELECT * FROM "users")) AS "users"') }
+    its(:to_s)        { should eql('SELECT "id" AS "user_id", "name", "age" FROM ((SELECT "id", "name", "age" FROM "users") UNION (SELECT "id", "name", "age" FROM "users")) AS "users"')   }
+    its(:to_subquery) { should eql('(SELECT "id" AS "user_id", "name", "age" FROM ((SELECT "id", "name", "age" FROM "users") UNION (SELECT "id", "name", "age" FROM "users")) AS "users")') }
   end
 
   context 'when the operand is a join' do
@@ -130,7 +172,7 @@ describe SQL::Generator::Relation::Unary, '#visit_veritas_algebra_rename' do
 
     it_should_behave_like 'a generated SQL SELECT query'
 
-    its(:to_s)        { should eql('SELECT "id" AS "user_id", "name", "age" FROM (SELECT * FROM "users" NATURAL JOIN "users") AS "users"') }
-    its(:to_subquery) { should eql('SELECT "id" AS "user_id", "name", "age" FROM (SELECT * FROM "users" NATURAL JOIN "users") AS "users"') }
+    its(:to_s)        { should eql('SELECT "id" AS "user_id", "name", "age" FROM (SELECT * FROM "users" AS "left" NATURAL JOIN "users" AS "right") AS "users"')   }
+    its(:to_subquery) { should eql('(SELECT "id" AS "user_id", "name", "age" FROM (SELECT * FROM "users" AS "left" NATURAL JOIN "users" AS "right") AS "users")') }
   end
 end

data/spec/unit/veritas/sql/generator/relation/unary/visit_veritas_algebra_restriction_spec.rb

@@ -11,7 +11,7 @@ describe SQL::Generator::Relation::Unary, '#visit_veritas_algebra_restriction' d
   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(:restriction)   { operand.restrict { |r| r[:id].eq(1) }            }
   let(:object)        { described_class.new                              }
 
@@ -21,7 +21,7 @@ describe SQL::Generator::Relation::Unary, '#visit_veritas_algebra_restriction' d
     it_should_behave_like 'a generated SQL SELECT query'
 
     its(:to_s)        { should eql('SELECT "id", "name", "age" FROM "users" WHERE "id" = 1') }
-    its(:to_subquery) { should eql('SELECT * FROM "users" WHERE "id" = 1')                   }
+    its(:to_subquery) { should eql('(SELECT * FROM "users" WHERE "id" = 1)')                 }
   end
 
   context 'when the operand is a projection' do
@@ -29,8 +29,17 @@ describe SQL::Generator::Relation::Unary, '#visit_veritas_algebra_restriction' d
 
     it_should_behave_like 'a generated SQL SELECT query'
 
-    its(:to_s)        { should eql('SELECT DISTINCT "id", "name" FROM "users" WHERE "id" = 1') }
-    its(:to_subquery) { should eql('SELECT DISTINCT "id", "name" FROM "users" WHERE "id" = 1') }
+    its(:to_s)        { should eql('SELECT DISTINCT "id", "name" FROM "users" WHERE "id" = 1')   }
+    its(:to_subquery) { should eql('(SELECT DISTINCT "id", "name" FROM "users" WHERE "id" = 1)') }
+  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 "users" WHERE "id" = 1') }
+    its(:to_subquery) { should eql('(SELECT * FROM (SELECT *, 1 AS "one" FROM "users") AS "users" WHERE "id" = 1)')                        }
   end
 
   context 'when the operand is a projection then a restriction' do
@@ -39,17 +48,17 @@ describe SQL::Generator::Relation::Unary, '#visit_veritas_algebra_restriction' d
     it_should_behave_like 'a generated SQL SELECT query'
 
     its(:to_s)        { should eql('SELECT "id", "name" FROM (SELECT DISTINCT "id", "name" FROM "users" WHERE "id" <> 2) AS "users" WHERE "id" = 1') }
-    its(:to_subquery) { should eql('SELECT * FROM (SELECT DISTINCT "id", "name" FROM "users" WHERE "id" <> 2) AS "users" WHERE "id" = 1')            }
+    its(:to_subquery) { should eql('(SELECT * FROM (SELECT DISTINCT "id", "name" FROM "users" WHERE "id" <> 2) AS "users" WHERE "id" = 1)')          }
   end
 
   context 'when the operand is a projection then a restriction, followed by another restriction' do
-    let(:tautology) { Logic::Proposition::Tautology.instance                                        }
-    let(:operand)   { base_relation.project([ :id, :name ]).restrict(tautology).restrict(tautology) }
+    let(:tautology) { Function::Proposition::Tautology.instance                                           }
+    let(:operand)   { base_relation.project([ :id, :name ]).restrict { tautology }.restrict { tautology } }
 
     it_should_behave_like 'a generated SQL SELECT query'
 
-    its(:to_s)        { should eql('SELECT "id", "name" FROM (SELECT * FROM (SELECT DISTINCT "id", "name" FROM "users" WHERE 1 = 1) AS "users" WHERE 1 = 1) AS "users" WHERE "id" = 1') }
-    its(:to_subquery) { should eql('SELECT * FROM (SELECT * FROM (SELECT DISTINCT "id", "name" FROM "users" WHERE 1 = 1) AS "users" WHERE 1 = 1) AS "users" WHERE "id" = 1')            }
+    its(:to_s)        { should eql('SELECT "id", "name" FROM (SELECT * FROM (SELECT DISTINCT "id", "name" FROM "users" WHERE TRUE) AS "users" WHERE TRUE) AS "users" WHERE "id" = 1') }
+    its(:to_subquery) { should eql('(SELECT * FROM (SELECT * FROM (SELECT DISTINCT "id", "name" FROM "users" WHERE TRUE) AS "users" WHERE TRUE) AS "users" WHERE "id" = 1)')          }
   end
 
   context 'when the operand is a rename' do
@@ -80,7 +89,40 @@ describe SQL::Generator::Relation::Unary, '#visit_veritas_algebra_restriction' d
     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 "users" WHERE "id" = 1') }
-    its(:to_subquery) { should eql('SELECT * FROM (SELECT * FROM "users" WHERE "id" = 1) AS "users" WHERE "id" = 1')                   }
+    its(:to_subquery) { should eql('(SELECT * FROM (SELECT * FROM "users" WHERE "id" = 1) AS "users" WHERE "id" = 1)')                 }
+  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) } }
+      let(:restriction)   { operand.restrict { |r| r[:count].eq(1) }                                   }
+
+      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 "users" WHERE "count" = 1') }
+      its(:to_subquery) { should eql('(SELECT * FROM (SELECT COUNT ("id") AS "count" FROM "users") AS "users" WHERE "count" = 1)')     }
+    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) } }
+      let(:restriction)   { operand.restrict { |r| r[:count].eq(1) }                                   }
+
+      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 "users" WHERE "count" = 1') }
+      its(:to_subquery) { should eql('(SELECT * FROM (SELECT COUNT ("id") AS "count" FROM "users" HAVING FALSE) AS "users" WHERE "count" = 1)')     }
+    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 "users" WHERE "id" = 1') }
+      its(:to_subquery) { should eql('(SELECT * FROM (SELECT "id", "name", COUNT ("age") AS "count" FROM "users" GROUP BY "id", "name" HAVING COUNT (*) > 0) AS "users" WHERE "id" = 1)')                   }
+    end
   end
 
   context 'when the operand is ordered' do
@@ -89,7 +131,7 @@ describe SQL::Generator::Relation::Unary, '#visit_veritas_algebra_restriction' d
     it_should_behave_like 'a generated SQL SELECT query'
 
     its(:to_s)        { should eql('SELECT "id", "name", "age" FROM "users" WHERE "id" = 1 ORDER BY "id", "name", "age"') }
-    its(:to_subquery) { should eql('SELECT * FROM "users" WHERE "id" = 1 ORDER BY "id", "name", "age"')                   }
+    its(:to_subquery) { should eql('(SELECT * FROM "users" WHERE "id" = 1 ORDER BY "id", "name", "age")')                 }
   end
 
   context 'when the operand is reversed' do
@@ -98,7 +140,7 @@ describe SQL::Generator::Relation::Unary, '#visit_veritas_algebra_restriction' d
     it_should_behave_like 'a generated SQL SELECT query'
 
     its(:to_s)        { should eql('SELECT "id", "name", "age" FROM "users" WHERE "id" = 1 ORDER BY "id" DESC, "name" DESC, "age" DESC') }
-    its(:to_subquery) { should eql('SELECT * FROM "users" WHERE "id" = 1 ORDER BY "id" DESC, "name" DESC, "age" DESC')                   }
+    its(:to_subquery) { should eql('(SELECT * FROM "users" WHERE "id" = 1 ORDER BY "id" DESC, "name" DESC, "age" DESC)')                 }
   end
 
   context 'when the operand is limited' do
@@ -107,7 +149,7 @@ describe SQL::Generator::Relation::Unary, '#visit_veritas_algebra_restriction' d
     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 "users" WHERE "id" = 1') }
-    its(:to_subquery) { should eql('SELECT * FROM (SELECT * FROM "users" ORDER BY "id", "name", "age" LIMIT 1) AS "users" WHERE "id" = 1')                   }
+    its(:to_subquery) { should eql('(SELECT * FROM (SELECT * FROM "users" ORDER BY "id", "name", "age" LIMIT 1) AS "users" WHERE "id" = 1)')                 }
   end
 
   context 'when the operand is an offset' do
@@ -116,7 +158,7 @@ describe SQL::Generator::Relation::Unary, '#visit_veritas_algebra_restriction' d
     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 "users" WHERE "id" = 1') }
-    its(:to_subquery) { should eql('SELECT * FROM (SELECT * FROM "users" ORDER BY "id", "name", "age" OFFSET 1) AS "users" WHERE "id" = 1')                   }
+    its(:to_subquery) { should eql('(SELECT * FROM (SELECT * FROM "users" ORDER BY "id", "name", "age" OFFSET 1) AS "users" WHERE "id" = 1)')                 }
   end
 
   context 'when the operand is a difference' do
@@ -124,8 +166,8 @@ describe SQL::Generator::Relation::Unary, '#visit_veritas_algebra_restriction' d
 
     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 "users" WHERE "id" = 1') }
-    its(:to_subquery) { should eql('SELECT * FROM ((SELECT * FROM "users") EXCEPT (SELECT * FROM "users")) AS "users" WHERE "id" = 1')                   }
+    its(:to_s)        { should eql('SELECT "id", "name", "age" FROM ((SELECT "id", "name", "age" FROM "users") EXCEPT (SELECT "id", "name", "age" FROM "users")) AS "users" WHERE "id" = 1') }
+    its(:to_subquery) { should eql('(SELECT * FROM ((SELECT "id", "name", "age" FROM "users") EXCEPT (SELECT "id", "name", "age" FROM "users")) AS "users" WHERE "id" = 1)')                 }
   end
 
   context 'when the operand is an intersection' do
@@ -133,8 +175,8 @@ describe SQL::Generator::Relation::Unary, '#visit_veritas_algebra_restriction' d
 
     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 "users" WHERE "id" = 1') }
-    its(:to_subquery) { should eql('SELECT * FROM ((SELECT * FROM "users") INTERSECT (SELECT * FROM "users")) AS "users" WHERE "id" = 1')                   }
+    its(:to_s)        { should eql('SELECT "id", "name", "age" FROM ((SELECT "id", "name", "age" FROM "users") INTERSECT (SELECT "id", "name", "age" FROM "users")) AS "users" WHERE "id" = 1') }
+    its(:to_subquery) { should eql('(SELECT * FROM ((SELECT "id", "name", "age" FROM "users") INTERSECT (SELECT "id", "name", "age" FROM "users")) AS "users" WHERE "id" = 1)')                 }
   end
 
   context 'when the operand is a union' do
@@ -142,8 +184,8 @@ describe SQL::Generator::Relation::Unary, '#visit_veritas_algebra_restriction' d
 
     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 "users" WHERE "id" = 1') }
-    its(:to_subquery) { should eql('SELECT * FROM ((SELECT * FROM "users") UNION (SELECT * FROM "users")) AS "users" WHERE "id" = 1')                   }
+    its(:to_s)        { should eql('SELECT "id", "name", "age" FROM ((SELECT "id", "name", "age" FROM "users") UNION (SELECT "id", "name", "age" FROM "users")) AS "users" WHERE "id" = 1') }
+    its(:to_subquery) { should eql('(SELECT * FROM ((SELECT "id", "name", "age" FROM "users") UNION (SELECT "id", "name", "age" FROM "users")) AS "users" WHERE "id" = 1)')                 }
   end
 
   context 'when the operand is a join' do
@@ -151,7 +193,7 @@ describe SQL::Generator::Relation::Unary, '#visit_veritas_algebra_restriction' d
 
     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 "users" WHERE "id" = 1') }
-    its(:to_subquery) { should eql('SELECT * FROM (SELECT * FROM "users" NATURAL JOIN "users") AS "users" WHERE "id" = 1')                   }
+    its(:to_s)        { should eql('SELECT "id", "name", "age" FROM (SELECT * FROM "users" AS "left" NATURAL JOIN "users" AS "right") AS "users" WHERE "id" = 1') }
+    its(:to_subquery) { should eql('(SELECT * FROM (SELECT * FROM "users" AS "left" NATURAL JOIN "users" AS "right") AS "users" WHERE "id" = 1)')                 }
   end
 end

data/spec/unit/veritas/sql/generator/relation/unary/visit_veritas_algebra_summarization_spec.rb

@@ -0,0 +1,652 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe SQL::Generator::Relation::Unary, '#visit_veritas_algebra_summarization' do
+  subject { object.visit_veritas_algebra_summarization(summarization) }
+
+  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', [ id ], [ [ 1 ] ])   }
+  let(:object)         { described_class.new                              }
+
+  context 'summarize per table dee' do
+    let(:summarize_per) { TABLE_DEE                                                             }
+    let(:summarization) { operand.summarize(summarize_per) { |r| r.add(:count, r[:age].count) } }
+
+    context 'when the operand is a base relation' do
+      let(:operand) { base_relation }
+
+      it_should_behave_like 'a generated SQL SELECT query'
+
+      its(:to_s)        { should eql('SELECT COUNT ("age") AS "count" FROM "users"')   }
+      its(:to_subquery) { should eql('(SELECT COUNT ("age") AS "count" FROM "users")') }
+    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 COUNT ("age") AS "count" FROM (SELECT *, 1 AS "one" FROM "users") AS "users"')   }
+      its(:to_subquery) { should eql('(SELECT COUNT ("age") AS "count" FROM (SELECT *, 1 AS "one" FROM "users") AS "users")') }
+    end
+
+    context 'when the operand is a projection' do
+      let(:operand)       { base_relation.project([ :id, :name ])                                }
+      let(:summarization) { operand.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 ("id") AS "count" FROM (SELECT DISTINCT "id", "name" FROM "users") AS "users"')   }
+      its(:to_subquery) { should eql('(SELECT COUNT ("id") AS "count" FROM (SELECT DISTINCT "id", "name" FROM "users") AS "users")') }
+    end
+
+    context 'when the operand is a rename' do
+      let(:operand) { base_relation.rename(:name => :other_name) }
+
+      it_should_behave_like 'a generated SQL SELECT query'
+
+      its(:to_s)        { should eql('SELECT COUNT ("age") AS "count" FROM (SELECT "id", "name" AS "other_name", "age" FROM "users") AS "users"')   }
+      its(:to_subquery) { should eql('(SELECT COUNT ("age") AS "count" FROM (SELECT "id", "name" AS "other_name", "age" FROM "users") AS "users")') }
+    end
+
+    context 'when the operand is a restriction' do
+      let(:operand) { base_relation.restrict { |r| r[:id].eq(1) } }
+
+      it_should_behave_like 'a generated SQL SELECT query'
+
+      its(:to_s)        { should eql('SELECT COUNT ("age") AS "count" FROM (SELECT * FROM "users" WHERE "id" = 1) AS "users"')   }
+      its(:to_subquery) { should eql('(SELECT COUNT ("age") AS "count" FROM (SELECT * FROM "users" WHERE "id" = 1) AS "users")') }
+    end
+
+    context 'when the operand is a summarization' do
+      let(:operand)       { base_relation.summarize([ :id ]) { |r| r.add(:count, r[:age].count) }   }
+      let(:summarization) { operand.summarize(summarize_per) { |r| r.add(:count, r[:count].count) } }
+
+      it_should_behave_like 'a generated SQL SELECT query'
+
+      its(:to_s)        { should eql('SELECT COUNT ("count") AS "count" FROM (SELECT "id", COUNT ("age") AS "count" FROM "users" GROUP BY "id" HAVING COUNT (*) > 0) AS "users"')   }
+      its(:to_subquery) { should eql('(SELECT COUNT ("count") AS "count" FROM (SELECT "id", COUNT ("age") AS "count" FROM "users" GROUP BY "id" HAVING COUNT (*) > 0) AS "users")') }
+    end
+
+    context 'when the operand is ordered' do
+      let(:operand) { base_relation.order }
+
+      it_should_behave_like 'a generated SQL SELECT query'
+
+      its(:to_s)        { should eql('SELECT COUNT ("age") AS "count" FROM (SELECT * FROM "users" ORDER BY "id", "name", "age") AS "users"')   }
+      its(:to_subquery) { should eql('(SELECT COUNT ("age") AS "count" FROM (SELECT * FROM "users" ORDER BY "id", "name", "age") AS "users")') }
+    end
+
+    context 'when the operand is reversed' do
+      let(:operand) { base_relation.order.reverse }
+
+      it_should_behave_like 'a generated SQL SELECT query'
+
+      its(:to_s)        { should eql('SELECT COUNT ("age") AS "count" FROM (SELECT * FROM "users" ORDER BY "id" DESC, "name" DESC, "age" DESC) AS "users"')   }
+      its(:to_subquery) { should eql('(SELECT COUNT ("age") AS "count" FROM (SELECT * FROM "users" ORDER BY "id" DESC, "name" DESC, "age" DESC) AS "users")') }
+    end
+
+    context 'when the operand is limited' do
+      let(:operand) { base_relation.order.take(1) }
+
+      it_should_behave_like 'a generated SQL SELECT query'
+
+      its(:to_s)        { should eql('SELECT COUNT ("age") AS "count" FROM (SELECT * FROM "users" ORDER BY "id", "name", "age" LIMIT 1) AS "users"')   }
+      its(:to_subquery) { should eql('(SELECT COUNT ("age") AS "count" FROM (SELECT * FROM "users" ORDER BY "id", "name", "age" LIMIT 1) AS "users")') }
+    end
+
+    context 'when the operand is an offset' do
+      let(:operand) { base_relation.order.drop(1) }
+
+      it_should_behave_like 'a generated SQL SELECT query'
+
+      its(:to_s)        { should eql('SELECT COUNT ("age") AS "count" FROM (SELECT * FROM "users" ORDER BY "id", "name", "age" OFFSET 1) AS "users"')   }
+      its(:to_subquery) { should eql('(SELECT COUNT ("age") AS "count" FROM (SELECT * FROM "users" ORDER BY "id", "name", "age" OFFSET 1) AS "users")') }
+    end
+
+    context 'when the operand is a difference' do
+      let(:operand) { base_relation.difference(base_relation) }
+
+      it_should_behave_like 'a generated SQL SELECT query'
+
+      its(:to_s)        { should eql('SELECT COUNT ("age") AS "count" FROM ((SELECT "id", "name", "age" FROM "users") EXCEPT (SELECT "id", "name", "age" FROM "users")) AS "users"')   }
+      its(:to_subquery) { should eql('(SELECT COUNT ("age") AS "count" FROM ((SELECT "id", "name", "age" FROM "users") EXCEPT (SELECT "id", "name", "age" FROM "users")) AS "users")') }
+    end
+
+    context 'when the operand is an intersection' do
+      let(:operand) { base_relation.intersect(base_relation) }
+
+      it_should_behave_like 'a generated SQL SELECT query'
+
+      its(:to_s)        { should eql('SELECT COUNT ("age") AS "count" FROM ((SELECT "id", "name", "age" FROM "users") INTERSECT (SELECT "id", "name", "age" FROM "users")) AS "users"')   }
+      its(:to_subquery) { should eql('(SELECT COUNT ("age") AS "count" FROM ((SELECT "id", "name", "age" FROM "users") INTERSECT (SELECT "id", "name", "age" FROM "users")) AS "users")') }
+    end
+
+    context 'when the operand is a union' do
+      let(:operand) { base_relation.union(base_relation) }
+
+      it_should_behave_like 'a generated SQL SELECT query'
+
+      its(:to_s)        { should eql('SELECT COUNT ("age") AS "count" FROM ((SELECT "id", "name", "age" FROM "users") UNION (SELECT "id", "name", "age" FROM "users")) AS "users"')   }
+      its(:to_subquery) { should eql('(SELECT COUNT ("age") AS "count" FROM ((SELECT "id", "name", "age" FROM "users") UNION (SELECT "id", "name", "age" FROM "users")) AS "users")') }
+    end
+
+    context 'when the operand is a join' do
+      let(:operand) { base_relation.join(base_relation) }
+
+      it_should_behave_like 'a generated SQL SELECT query'
+
+      its(:to_s)        { should eql('SELECT COUNT ("age") AS "count" FROM (SELECT * FROM "users" AS "left" NATURAL JOIN "users" AS "right") AS "users"')   }
+      its(:to_subquery) { should eql('(SELECT COUNT ("age") AS "count" FROM (SELECT * FROM "users" AS "left" NATURAL JOIN "users" AS "right") AS "users")') }
+    end
+  end
+
+  context 'summarize per table dum' do
+    let(:summarize_per) { TABLE_DUM                                                             }
+    let(:summarization) { operand.summarize(summarize_per) { |r| r.add(:count, r[:age].count) } }
+
+    context 'when the operand is a base relation' do
+      let(:operand) { base_relation }
+
+      it_should_behave_like 'a generated SQL SELECT query'
+
+      its(:to_s)        { should eql('SELECT COUNT ("age") AS "count" FROM "users" HAVING FALSE')   }
+      its(:to_subquery) { should eql('(SELECT COUNT ("age") AS "count" FROM "users" HAVING FALSE)') }
+    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 COUNT ("age") AS "count" FROM (SELECT *, 1 AS "one" FROM "users") AS "users" HAVING FALSE')   }
+      its(:to_subquery) { should eql('(SELECT COUNT ("age") AS "count" FROM (SELECT *, 1 AS "one" FROM "users") AS "users" HAVING FALSE)') }
+    end
+
+    context 'when the operand is a projection' do
+      let(:operand)       { base_relation.project([ :id, :name ])                                }
+      let(:summarization) { operand.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 ("id") AS "count" FROM (SELECT DISTINCT "id", "name" FROM "users") AS "users" HAVING FALSE')   }
+      its(:to_subquery) { should eql('(SELECT COUNT ("id") AS "count" FROM (SELECT DISTINCT "id", "name" FROM "users") AS "users" HAVING FALSE)') }
+    end
+
+    context 'when the operand is a rename' do
+      let(:operand) { base_relation.rename(:name => :other_name) }
+
+      it_should_behave_like 'a generated SQL SELECT query'
+
+      its(:to_s)        { should eql('SELECT COUNT ("age") AS "count" FROM (SELECT "id", "name" AS "other_name", "age" FROM "users") AS "users" HAVING FALSE')   }
+      its(:to_subquery) { should eql('(SELECT COUNT ("age") AS "count" FROM (SELECT "id", "name" AS "other_name", "age" FROM "users") AS "users" HAVING FALSE)') }
+    end
+
+    context 'when the operand is a restriction' do
+      let(:operand) { base_relation.restrict { |r| r[:id].eq(1) } }
+
+      it_should_behave_like 'a generated SQL SELECT query'
+
+      its(:to_s)        { should eql('SELECT COUNT ("age") AS "count" FROM (SELECT * FROM "users" WHERE "id" = 1) AS "users" HAVING FALSE')   }
+      its(:to_subquery) { should eql('(SELECT COUNT ("age") AS "count" FROM (SELECT * FROM "users" WHERE "id" = 1) AS "users" HAVING FALSE)') }
+    end
+
+    context 'when the operand is a summarization' do
+      let(:operand)       { base_relation.summarize([ :id ]) { |r| r.add(:count, r[:age].count) }   }
+      let(:summarization) { operand.summarize(summarize_per) { |r| r.add(:count, r[:count].count) } }
+
+      it_should_behave_like 'a generated SQL SELECT query'
+
+      its(:to_s)        { should eql('SELECT COUNT ("count") AS "count" FROM (SELECT "id", COUNT ("age") AS "count" FROM "users" GROUP BY "id" HAVING COUNT (*) > 0) AS "users" HAVING FALSE')   }
+      its(:to_subquery) { should eql('(SELECT COUNT ("count") AS "count" FROM (SELECT "id", COUNT ("age") AS "count" FROM "users" GROUP BY "id" HAVING COUNT (*) > 0) AS "users" HAVING FALSE)') }
+    end
+
+    context 'when the operand is ordered' do
+      let(:operand) { base_relation.order }
+
+      it_should_behave_like 'a generated SQL SELECT query'
+
+      its(:to_s)        { should eql('SELECT COUNT ("age") AS "count" FROM (SELECT * FROM "users" ORDER BY "id", "name", "age") AS "users" HAVING FALSE')   }
+      its(:to_subquery) { should eql('(SELECT COUNT ("age") AS "count" FROM (SELECT * FROM "users" ORDER BY "id", "name", "age") AS "users" HAVING FALSE)') }
+    end
+
+    context 'when the operand is reversed' do
+      let(:operand) { base_relation.order.reverse }
+
+      it_should_behave_like 'a generated SQL SELECT query'
+
+      its(:to_s)        { should eql('SELECT COUNT ("age") AS "count" FROM (SELECT * FROM "users" ORDER BY "id" DESC, "name" DESC, "age" DESC) AS "users" HAVING FALSE')   }
+      its(:to_subquery) { should eql('(SELECT COUNT ("age") AS "count" FROM (SELECT * FROM "users" ORDER BY "id" DESC, "name" DESC, "age" DESC) AS "users" HAVING FALSE)') }
+    end
+
+    context 'when the operand is limited' do
+      let(:operand) { base_relation.order.take(1) }
+
+      it_should_behave_like 'a generated SQL SELECT query'
+
+      its(:to_s)        { should eql('SELECT COUNT ("age") AS "count" FROM (SELECT * FROM "users" ORDER BY "id", "name", "age" LIMIT 1) AS "users" HAVING FALSE')   }
+      its(:to_subquery) { should eql('(SELECT COUNT ("age") AS "count" FROM (SELECT * FROM "users" ORDER BY "id", "name", "age" LIMIT 1) AS "users" HAVING FALSE)') }
+    end
+
+    context 'when the operand is an offset' do
+      let(:operand) { base_relation.order.drop(1) }
+
+      it_should_behave_like 'a generated SQL SELECT query'
+
+      its(:to_s)        { should eql('SELECT COUNT ("age") AS "count" FROM (SELECT * FROM "users" ORDER BY "id", "name", "age" OFFSET 1) AS "users" HAVING FALSE')   }
+      its(:to_subquery) { should eql('(SELECT COUNT ("age") AS "count" FROM (SELECT * FROM "users" ORDER BY "id", "name", "age" OFFSET 1) AS "users" HAVING FALSE)') }
+    end
+
+    context 'when the operand is a difference' do
+      let(:operand) { base_relation.difference(base_relation) }
+
+      it_should_behave_like 'a generated SQL SELECT query'
+
+      its(:to_s)        { should eql('SELECT COUNT ("age") AS "count" FROM ((SELECT "id", "name", "age" FROM "users") EXCEPT (SELECT "id", "name", "age" FROM "users")) AS "users" HAVING FALSE')   }
+      its(:to_subquery) { should eql('(SELECT COUNT ("age") AS "count" FROM ((SELECT "id", "name", "age" FROM "users") EXCEPT (SELECT "id", "name", "age" FROM "users")) AS "users" HAVING FALSE)') }
+    end
+
+    context 'when the operand is an intersection' do
+      let(:operand) { base_relation.intersect(base_relation) }
+
+      it_should_behave_like 'a generated SQL SELECT query'
+
+      its(:to_s)        { should eql('SELECT COUNT ("age") AS "count" FROM ((SELECT "id", "name", "age" FROM "users") INTERSECT (SELECT "id", "name", "age" FROM "users")) AS "users" HAVING FALSE')   }
+      its(:to_subquery) { should eql('(SELECT COUNT ("age") AS "count" FROM ((SELECT "id", "name", "age" FROM "users") INTERSECT (SELECT "id", "name", "age" FROM "users")) AS "users" HAVING FALSE)') }
+    end
+
+    context 'when the operand is a union' do
+      let(:operand) { base_relation.union(base_relation) }
+
+      it_should_behave_like 'a generated SQL SELECT query'
+
+      its(:to_s)        { should eql('SELECT COUNT ("age") AS "count" FROM ((SELECT "id", "name", "age" FROM "users") UNION (SELECT "id", "name", "age" FROM "users")) AS "users" HAVING FALSE')   }
+      its(:to_subquery) { should eql('(SELECT COUNT ("age") AS "count" FROM ((SELECT "id", "name", "age" FROM "users") UNION (SELECT "id", "name", "age" FROM "users")) AS "users" HAVING FALSE)') }
+    end
+
+    context 'when the operand is a join' do
+      let(:operand) { base_relation.join(base_relation) }
+
+      it_should_behave_like 'a generated SQL SELECT query'
+
+      its(:to_s)        { should eql('SELECT COUNT ("age") AS "count" FROM (SELECT * FROM "users" AS "left" NATURAL JOIN "users" AS "right") AS "users" HAVING FALSE')   }
+      its(:to_subquery) { should eql('(SELECT COUNT ("age") AS "count" FROM (SELECT * FROM "users" AS "left" NATURAL JOIN "users" AS "right") AS "users" HAVING FALSE)') }
+    end
+  end
+
+  context 'summarize by a subset of the operand header' do
+    let(:summarize_by)  { [ :id ]                                                              }
+    let(:summarization) { operand.summarize(summarize_by) { |r| r.add(:count, r[:age].count) } }
+
+    context 'when the operand is a base relation' do
+      let(:operand) { base_relation }
+
+      it_should_behave_like 'a generated SQL SELECT query'
+
+      its(:to_s)        { should eql('SELECT "id", COUNT ("age") AS "count" FROM "users" GROUP BY "id" HAVING COUNT (*) > 0')   }
+      its(:to_subquery) { should eql('(SELECT "id", COUNT ("age") AS "count" FROM "users" GROUP BY "id" HAVING COUNT (*) > 0)') }
+    end
+
+    context 'when the operand is a projection' do
+      let(:operand)       { base_relation.project([ :id, :name ])                                 }
+      let(:summarization) { operand.summarize(summarize_by) { |r| r.add(:count, r[:name].count) } }
+
+      it_should_behave_like 'a generated SQL SELECT query'
+
+      its(:to_s)        { should eql('SELECT "id", COUNT ("name") AS "count" FROM (SELECT DISTINCT "id", "name" FROM "users") AS "users" GROUP BY "id" HAVING COUNT (*) > 0')   }
+      its(:to_subquery) { should eql('(SELECT "id", COUNT ("name") AS "count" FROM (SELECT DISTINCT "id", "name" FROM "users") AS "users" GROUP BY "id" HAVING COUNT (*) > 0)') }
+    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", COUNT ("age") AS "count" FROM (SELECT *, 1 AS "one" FROM "users") AS "users" GROUP BY "id" HAVING COUNT (*) > 0')   }
+      its(:to_subquery) { should eql('(SELECT "id", COUNT ("age") AS "count" FROM (SELECT *, 1 AS "one" FROM "users") AS "users" GROUP BY "id" HAVING COUNT (*) > 0)') }
+    end
+
+    context 'when the operand is a rename' do
+      let(:operand) { base_relation.rename(:name => :other_name) }
+
+      it_should_behave_like 'a generated SQL SELECT query'
+
+      its(:to_s)        { should eql('SELECT "id", COUNT ("age") AS "count" FROM (SELECT "id", "name" AS "other_name", "age" FROM "users") AS "users" GROUP BY "id" HAVING COUNT (*) > 0')   }
+      its(:to_subquery) { should eql('(SELECT "id", COUNT ("age") AS "count" FROM (SELECT "id", "name" AS "other_name", "age" FROM "users") AS "users" GROUP BY "id" HAVING COUNT (*) > 0)') }
+    end
+
+    context 'when the operand is a restriction' do
+      let(:operand) { base_relation.restrict { |r| r[:id].eq(1) } }
+
+      it_should_behave_like 'a generated SQL SELECT query'
+
+      its(:to_s)        { should eql('SELECT "id", COUNT ("age") AS "count" FROM (SELECT * FROM "users" WHERE "id" = 1) AS "users" GROUP BY "id" HAVING COUNT (*) > 0')   }
+      its(:to_subquery) { should eql('(SELECT "id", COUNT ("age") AS "count" FROM (SELECT * FROM "users" WHERE "id" = 1) AS "users" GROUP BY "id" HAVING COUNT (*) > 0)') }
+    end
+
+    context 'when the operand is ordered' do
+      let(:operand) { base_relation.order }
+
+      it_should_behave_like 'a generated SQL SELECT query'
+
+      its(:to_s)        { should eql('SELECT "id", COUNT ("age") AS "count" FROM (SELECT * FROM "users" ORDER BY "id", "name", "age") AS "users" GROUP BY "id" HAVING COUNT (*) > 0')   }
+      its(:to_subquery) { should eql('(SELECT "id", COUNT ("age") AS "count" FROM (SELECT * FROM "users" ORDER BY "id", "name", "age") AS "users" GROUP BY "id" HAVING COUNT (*) > 0)') }
+    end
+
+    context 'when the operand is reversed' do
+      let(:operand) { base_relation.order.reverse }
+
+      it_should_behave_like 'a generated SQL SELECT query'
+
+      its(:to_s)        { should eql('SELECT "id", COUNT ("age") AS "count" FROM (SELECT * FROM "users" ORDER BY "id" DESC, "name" DESC, "age" DESC) AS "users" GROUP BY "id" HAVING COUNT (*) > 0')   }
+      its(:to_subquery) { should eql('(SELECT "id", COUNT ("age") AS "count" FROM (SELECT * FROM "users" ORDER BY "id" DESC, "name" DESC, "age" DESC) AS "users" GROUP BY "id" HAVING COUNT (*) > 0)') }
+    end
+
+    context 'when the operand is limited' do
+      let(:operand) { base_relation.order.take(1) }
+
+      it_should_behave_like 'a generated SQL SELECT query'
+
+      its(:to_s)        { should eql('SELECT "id", COUNT ("age") AS "count" FROM (SELECT * FROM "users" ORDER BY "id", "name", "age" LIMIT 1) AS "users" GROUP BY "id" HAVING COUNT (*) > 0')   }
+      its(:to_subquery) { should eql('(SELECT "id", COUNT ("age") AS "count" FROM (SELECT * FROM "users" ORDER BY "id", "name", "age" LIMIT 1) AS "users" GROUP BY "id" HAVING COUNT (*) > 0)') }
+    end
+
+    context 'when the operand is an offset' do
+      let(:operand) { base_relation.order.drop(1) }
+
+      it_should_behave_like 'a generated SQL SELECT query'
+
+      its(:to_s)        { should eql('SELECT "id", COUNT ("age") AS "count" FROM (SELECT * FROM "users" ORDER BY "id", "name", "age" OFFSET 1) AS "users" GROUP BY "id" HAVING COUNT (*) > 0')   }
+      its(:to_subquery) { should eql('(SELECT "id", COUNT ("age") AS "count" FROM (SELECT * FROM "users" ORDER BY "id", "name", "age" OFFSET 1) AS "users" GROUP BY "id" HAVING COUNT (*) > 0)') }
+    end
+
+    context 'when the operand is a difference' do
+      let(:operand) { base_relation.difference(base_relation) }
+
+      it_should_behave_like 'a generated SQL SELECT query'
+
+      its(:to_s)        { should eql('SELECT "id", COUNT ("age") AS "count" FROM ((SELECT "id", "name", "age" FROM "users") EXCEPT (SELECT "id", "name", "age" FROM "users")) AS "users" GROUP BY "id" HAVING COUNT (*) > 0')   }
+      its(:to_subquery) { should eql('(SELECT "id", COUNT ("age") AS "count" FROM ((SELECT "id", "name", "age" FROM "users") EXCEPT (SELECT "id", "name", "age" FROM "users")) AS "users" GROUP BY "id" HAVING COUNT (*) > 0)') }
+    end
+
+    context 'when the operand is an intersection' do
+      let(:operand) { base_relation.intersect(base_relation) }
+
+      it_should_behave_like 'a generated SQL SELECT query'
+
+      its(:to_s)        { should eql('SELECT "id", COUNT ("age") AS "count" FROM ((SELECT "id", "name", "age" FROM "users") INTERSECT (SELECT "id", "name", "age" FROM "users")) AS "users" GROUP BY "id" HAVING COUNT (*) > 0')   }
+      its(:to_subquery) { should eql('(SELECT "id", COUNT ("age") AS "count" FROM ((SELECT "id", "name", "age" FROM "users") INTERSECT (SELECT "id", "name", "age" FROM "users")) AS "users" GROUP BY "id" HAVING COUNT (*) > 0)') }
+    end
+
+    context 'when the operand is a union' do
+      let(:operand) { base_relation.union(base_relation) }
+
+      it_should_behave_like 'a generated SQL SELECT query'
+
+      its(:to_s)        { should eql('SELECT "id", COUNT ("age") AS "count" FROM ((SELECT "id", "name", "age" FROM "users") UNION (SELECT "id", "name", "age" FROM "users")) AS "users" GROUP BY "id" HAVING COUNT (*) > 0')   }
+      its(:to_subquery) { should eql('(SELECT "id", COUNT ("age") AS "count" FROM ((SELECT "id", "name", "age" FROM "users") UNION (SELECT "id", "name", "age" FROM "users")) AS "users" GROUP BY "id" HAVING COUNT (*) > 0)') }
+    end
+
+    context 'when the operand is a join' do
+      let(:operand) { base_relation.join(base_relation) }
+
+      it_should_behave_like 'a generated SQL SELECT query'
+
+      its(:to_s)        { should eql('SELECT "id", COUNT ("age") AS "count" FROM (SELECT * FROM "users" AS "left" NATURAL JOIN "users" AS "right") AS "users" GROUP BY "id" HAVING COUNT (*) > 0')   }
+      its(:to_subquery) { should eql('(SELECT "id", COUNT ("age") AS "count" FROM (SELECT * FROM "users" AS "left" NATURAL JOIN "users" AS "right") AS "users" GROUP BY "id" HAVING COUNT (*) > 0)') }
+    end
+  end
+
+  context 'summarize per another base relation' do
+    let(:summarize_per) { other_relation                                                        }
+    let(:summarization) { operand.summarize(summarize_per) { |r| r.add(:count, r[:age].count) } }
+
+    context 'when the operand is a base relation' do
+      let(:operand) { base_relation }
+
+      it_should_behave_like 'a generated SQL SELECT query'
+
+      its(:to_s)        { should eql('SELECT "id", COUNT ("age") AS "count" FROM "other" AS "other" NATURAL LEFT JOIN "users" GROUP BY "id"')   }
+      its(:to_subquery) { should eql('(SELECT "id", COUNT ("age") AS "count" FROM "other" AS "other" NATURAL LEFT JOIN "users" GROUP BY "id")') }
+    end
+
+    context 'when the operand is a projection' do
+      let(:operand)       { base_relation.project([ :id, :name ])                                  }
+      let(:summarization) { operand.summarize(summarize_per) { |r| r.add(:count, r[:name].count) } }
+
+      it_should_behave_like 'a generated SQL SELECT query'
+
+      its(:to_s)        { should eql('SELECT "id", COUNT ("name") AS "count" FROM "other" AS "other" NATURAL LEFT JOIN (SELECT DISTINCT "id", "name" FROM "users") AS "users" GROUP BY "id"')   }
+      its(:to_subquery) { should eql('(SELECT "id", COUNT ("name") AS "count" FROM "other" AS "other" NATURAL LEFT JOIN (SELECT DISTINCT "id", "name" FROM "users") AS "users" GROUP BY "id")') }
+    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", COUNT ("age") AS "count" FROM "other" AS "other" NATURAL LEFT JOIN (SELECT *, 1 AS "one" FROM "users") AS "users" GROUP BY "id"')   }
+      its(:to_subquery) { should eql('(SELECT "id", COUNT ("age") AS "count" FROM "other" AS "other" NATURAL LEFT JOIN (SELECT *, 1 AS "one" FROM "users") AS "users" GROUP BY "id")') }
+    end
+
+    context 'when the operand is a rename' do
+      let(:operand) { base_relation.rename(:name => :other_name) }
+
+      it_should_behave_like 'a generated SQL SELECT query'
+
+      its(:to_s)        { should eql('SELECT "id", COUNT ("age") AS "count" FROM "other" AS "other" NATURAL LEFT JOIN (SELECT "id", "name" AS "other_name", "age" FROM "users") AS "users" GROUP BY "id"')   }
+      its(:to_subquery) { should eql('(SELECT "id", COUNT ("age") AS "count" FROM "other" AS "other" NATURAL LEFT JOIN (SELECT "id", "name" AS "other_name", "age" FROM "users") AS "users" GROUP BY "id")') }
+    end
+
+    context 'when the operand is a restriction' do
+      let(:operand) { base_relation.restrict { |r| r[:id].eq(1) } }
+
+      it_should_behave_like 'a generated SQL SELECT query'
+
+      its(:to_s)        { should eql('SELECT "id", COUNT ("age") AS "count" FROM "other" AS "other" NATURAL LEFT JOIN (SELECT * FROM "users" WHERE "id" = 1) AS "users" GROUP BY "id"')   }
+      its(:to_subquery) { should eql('(SELECT "id", COUNT ("age") AS "count" FROM "other" AS "other" NATURAL LEFT JOIN (SELECT * FROM "users" WHERE "id" = 1) AS "users" GROUP BY "id")') }
+    end
+
+    context 'when the operand is ordered' do
+      let(:operand) { base_relation.order }
+
+      it_should_behave_like 'a generated SQL SELECT query'
+
+      its(:to_s)        { should eql('SELECT "id", COUNT ("age") AS "count" FROM "other" AS "other" NATURAL LEFT JOIN (SELECT * FROM "users" ORDER BY "id", "name", "age") AS "users" GROUP BY "id"')   }
+      its(:to_subquery) { should eql('(SELECT "id", COUNT ("age") AS "count" FROM "other" AS "other" NATURAL LEFT JOIN (SELECT * FROM "users" ORDER BY "id", "name", "age") AS "users" GROUP BY "id")') }
+    end
+
+    context 'when the operand is reversed' do
+      let(:operand) { base_relation.order.reverse }
+
+      it_should_behave_like 'a generated SQL SELECT query'
+
+      its(:to_s)        { should eql('SELECT "id", COUNT ("age") AS "count" FROM "other" AS "other" NATURAL LEFT JOIN (SELECT * FROM "users" ORDER BY "id" DESC, "name" DESC, "age" DESC) AS "users" GROUP BY "id"')   }
+      its(:to_subquery) { should eql('(SELECT "id", COUNT ("age") AS "count" FROM "other" AS "other" NATURAL LEFT JOIN (SELECT * FROM "users" ORDER BY "id" DESC, "name" DESC, "age" DESC) AS "users" GROUP BY "id")') }
+    end
+
+    context 'when the operand is limited' do
+      let(:operand) { base_relation.order.take(1) }
+
+      it_should_behave_like 'a generated SQL SELECT query'
+
+      its(:to_s)        { should eql('SELECT "id", COUNT ("age") AS "count" FROM "other" AS "other" NATURAL LEFT JOIN (SELECT * FROM "users" ORDER BY "id", "name", "age" LIMIT 1) AS "users" GROUP BY "id"')   }
+      its(:to_subquery) { should eql('(SELECT "id", COUNT ("age") AS "count" FROM "other" AS "other" NATURAL LEFT JOIN (SELECT * FROM "users" ORDER BY "id", "name", "age" LIMIT 1) AS "users" GROUP BY "id")') }
+    end
+
+    context 'when the operand is an offset' do
+      let(:operand) { base_relation.order.drop(1) }
+
+      it_should_behave_like 'a generated SQL SELECT query'
+
+      its(:to_s)        { should eql('SELECT "id", COUNT ("age") AS "count" FROM "other" AS "other" NATURAL LEFT JOIN (SELECT * FROM "users" ORDER BY "id", "name", "age" OFFSET 1) AS "users" GROUP BY "id"')   }
+      its(:to_subquery) { should eql('(SELECT "id", COUNT ("age") AS "count" FROM "other" AS "other" NATURAL LEFT JOIN (SELECT * FROM "users" ORDER BY "id", "name", "age" OFFSET 1) AS "users" GROUP BY "id")') }
+    end
+
+    context 'when the operand is a difference' do
+      let(:operand) { base_relation.difference(base_relation) }
+
+      it_should_behave_like 'a generated SQL SELECT query'
+
+      its(:to_s)        { should eql('SELECT "id", COUNT ("age") AS "count" FROM "other" AS "other" NATURAL LEFT JOIN ((SELECT "id", "name", "age" FROM "users") EXCEPT (SELECT "id", "name", "age" FROM "users")) AS "users" GROUP BY "id"')   }
+      its(:to_subquery) { should eql('(SELECT "id", COUNT ("age") AS "count" FROM "other" AS "other" NATURAL LEFT JOIN ((SELECT "id", "name", "age" FROM "users") EXCEPT (SELECT "id", "name", "age" FROM "users")) AS "users" GROUP BY "id")') }
+    end
+
+    context 'when the operand is an intersection' do
+      let(:operand) { base_relation.intersect(base_relation) }
+
+      it_should_behave_like 'a generated SQL SELECT query'
+
+      its(:to_s)        { should eql('SELECT "id", COUNT ("age") AS "count" FROM "other" AS "other" NATURAL LEFT JOIN ((SELECT "id", "name", "age" FROM "users") INTERSECT (SELECT "id", "name", "age" FROM "users")) AS "users" GROUP BY "id"')   }
+      its(:to_subquery) { should eql('(SELECT "id", COUNT ("age") AS "count" FROM "other" AS "other" NATURAL LEFT JOIN ((SELECT "id", "name", "age" FROM "users") INTERSECT (SELECT "id", "name", "age" FROM "users")) AS "users" GROUP BY "id")') }
+    end
+
+    context 'when the operand is a union' do
+      let(:operand) { base_relation.union(base_relation) }
+
+      it_should_behave_like 'a generated SQL SELECT query'
+
+      its(:to_s)        { should eql('SELECT "id", COUNT ("age") AS "count" FROM "other" AS "other" NATURAL LEFT JOIN ((SELECT "id", "name", "age" FROM "users") UNION (SELECT "id", "name", "age" FROM "users")) AS "users" GROUP BY "id"')   }
+      its(:to_subquery) { should eql('(SELECT "id", COUNT ("age") AS "count" FROM "other" AS "other" NATURAL LEFT JOIN ((SELECT "id", "name", "age" FROM "users") UNION (SELECT "id", "name", "age" FROM "users")) AS "users" GROUP BY "id")') }
+    end
+
+    context 'when the operand is a join' do
+      let(:operand) { base_relation.join(base_relation) }
+
+      it_should_behave_like 'a generated SQL SELECT query'
+
+      its(:to_s)        { should eql('SELECT "id", COUNT ("age") AS "count" FROM "other" AS "other" NATURAL LEFT JOIN (SELECT * FROM "users" AS "left" NATURAL JOIN "users" AS "right") AS "users" GROUP BY "id"')   }
+      its(:to_subquery) { should eql('(SELECT "id", COUNT ("age") AS "count" FROM "other" AS "other" NATURAL LEFT JOIN (SELECT * FROM "users" AS "left" NATURAL JOIN "users" AS "right") AS "users" GROUP BY "id")') }
+    end
+  end
+
+  context 'summarize per another projected relation' do
+    let(:summarize_per) { other_relation.project([ :id ])                                       }
+    let(:summarization) { operand.summarize(summarize_per) { |r| r.add(:count, r[:age].count) } }
+
+    context 'when the operand is a base relation' do
+      let(:operand) { base_relation }
+
+      it_should_behave_like 'a generated SQL SELECT query'
+
+      its(:to_s)        { should eql('SELECT "id", COUNT ("age") AS "count" FROM (SELECT DISTINCT "id" FROM "other") AS "other" NATURAL LEFT JOIN "users" GROUP BY "id"')   }
+      its(:to_subquery) { should eql('(SELECT "id", COUNT ("age") AS "count" FROM (SELECT DISTINCT "id" FROM "other") AS "other" NATURAL LEFT JOIN "users" GROUP BY "id")') }
+    end
+
+    context 'when the operand is a projection' do
+      let(:operand)       { base_relation.project([ :id, :name ])                                  }
+      let(:summarization) { operand.summarize(summarize_per) { |r| r.add(:count, r[:name].count) } }
+
+      it_should_behave_like 'a generated SQL SELECT query'
+
+      its(:to_s)        { should eql('SELECT "id", COUNT ("name") AS "count" FROM (SELECT DISTINCT "id" FROM "other") AS "other" NATURAL LEFT JOIN (SELECT DISTINCT "id", "name" FROM "users") AS "users" GROUP BY "id"')   }
+      its(:to_subquery) { should eql('(SELECT "id", COUNT ("name") AS "count" FROM (SELECT DISTINCT "id" FROM "other") AS "other" NATURAL LEFT JOIN (SELECT DISTINCT "id", "name" FROM "users") AS "users" GROUP BY "id")') }
+    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", COUNT ("age") AS "count" FROM (SELECT DISTINCT "id" FROM "other") AS "other" NATURAL LEFT JOIN (SELECT *, 1 AS "one" FROM "users") AS "users" GROUP BY "id"')   }
+      its(:to_subquery) { should eql('(SELECT "id", COUNT ("age") AS "count" FROM (SELECT DISTINCT "id" FROM "other") AS "other" NATURAL LEFT JOIN (SELECT *, 1 AS "one" FROM "users") AS "users" GROUP BY "id")') }
+    end
+
+    context 'when the operand is a rename' do
+      let(:operand) { base_relation.rename(:name => :other_name) }
+
+      it_should_behave_like 'a generated SQL SELECT query'
+
+      its(:to_s)        { should eql('SELECT "id", COUNT ("age") AS "count" FROM (SELECT DISTINCT "id" FROM "other") AS "other" NATURAL LEFT JOIN (SELECT "id", "name" AS "other_name", "age" FROM "users") AS "users" GROUP BY "id"')   }
+      its(:to_subquery) { should eql('(SELECT "id", COUNT ("age") AS "count" FROM (SELECT DISTINCT "id" FROM "other") AS "other" NATURAL LEFT JOIN (SELECT "id", "name" AS "other_name", "age" FROM "users") AS "users" GROUP BY "id")') }
+    end
+
+    context 'when the operand is a restriction' do
+      let(:operand) { base_relation.restrict { |r| r[:id].eq(1) } }
+
+      it_should_behave_like 'a generated SQL SELECT query'
+
+      its(:to_s)        { should eql('SELECT "id", COUNT ("age") AS "count" FROM (SELECT DISTINCT "id" FROM "other") AS "other" NATURAL LEFT JOIN (SELECT * FROM "users" WHERE "id" = 1) AS "users" GROUP BY "id"')   }
+      its(:to_subquery) { should eql('(SELECT "id", COUNT ("age") AS "count" FROM (SELECT DISTINCT "id" FROM "other") AS "other" NATURAL LEFT JOIN (SELECT * FROM "users" WHERE "id" = 1) AS "users" GROUP BY "id")') }
+    end
+
+    context 'when the operand is ordered' do
+      let(:operand) { base_relation.order }
+
+      it_should_behave_like 'a generated SQL SELECT query'
+
+      its(:to_s)        { should eql('SELECT "id", COUNT ("age") AS "count" FROM (SELECT DISTINCT "id" FROM "other") AS "other" NATURAL LEFT JOIN (SELECT * FROM "users" ORDER BY "id", "name", "age") AS "users" GROUP BY "id"')   }
+      its(:to_subquery) { should eql('(SELECT "id", COUNT ("age") AS "count" FROM (SELECT DISTINCT "id" FROM "other") AS "other" NATURAL LEFT JOIN (SELECT * FROM "users" ORDER BY "id", "name", "age") AS "users" GROUP BY "id")') }
+    end
+
+    context 'when the operand is reversed' do
+      let(:operand) { base_relation.order.reverse }
+
+      it_should_behave_like 'a generated SQL SELECT query'
+
+      its(:to_s)        { should eql('SELECT "id", COUNT ("age") AS "count" FROM (SELECT DISTINCT "id" FROM "other") AS "other" NATURAL LEFT JOIN (SELECT * FROM "users" ORDER BY "id" DESC, "name" DESC, "age" DESC) AS "users" GROUP BY "id"')   }
+      its(:to_subquery) { should eql('(SELECT "id", COUNT ("age") AS "count" FROM (SELECT DISTINCT "id" FROM "other") AS "other" NATURAL LEFT JOIN (SELECT * FROM "users" ORDER BY "id" DESC, "name" DESC, "age" DESC) AS "users" GROUP BY "id")') }
+    end
+
+    context 'when the operand is limited' do
+      let(:operand) { base_relation.order.take(1) }
+
+      it_should_behave_like 'a generated SQL SELECT query'
+
+      its(:to_s)        { should eql('SELECT "id", COUNT ("age") AS "count" FROM (SELECT DISTINCT "id" FROM "other") AS "other" NATURAL LEFT JOIN (SELECT * FROM "users" ORDER BY "id", "name", "age" LIMIT 1) AS "users" GROUP BY "id"')   }
+      its(:to_subquery) { should eql('(SELECT "id", COUNT ("age") AS "count" FROM (SELECT DISTINCT "id" FROM "other") AS "other" NATURAL LEFT JOIN (SELECT * FROM "users" ORDER BY "id", "name", "age" LIMIT 1) AS "users" GROUP BY "id")') }
+    end
+
+    context 'when the operand is an offset' do
+      let(:operand) { base_relation.order.drop(1) }
+
+      it_should_behave_like 'a generated SQL SELECT query'
+
+      its(:to_s)        { should eql('SELECT "id", COUNT ("age") AS "count" FROM (SELECT DISTINCT "id" FROM "other") AS "other" NATURAL LEFT JOIN (SELECT * FROM "users" ORDER BY "id", "name", "age" OFFSET 1) AS "users" GROUP BY "id"')   }
+      its(:to_subquery) { should eql('(SELECT "id", COUNT ("age") AS "count" FROM (SELECT DISTINCT "id" FROM "other") AS "other" NATURAL LEFT JOIN (SELECT * FROM "users" ORDER BY "id", "name", "age" OFFSET 1) AS "users" GROUP BY "id")') }
+    end
+
+    context 'when the operand is a difference' do
+      let(:operand) { base_relation.difference(base_relation) }
+
+      it_should_behave_like 'a generated SQL SELECT query'
+
+      its(:to_s)        { should eql('SELECT "id", COUNT ("age") AS "count" FROM (SELECT DISTINCT "id" FROM "other") AS "other" NATURAL LEFT JOIN ((SELECT "id", "name", "age" FROM "users") EXCEPT (SELECT "id", "name", "age" FROM "users")) AS "users" GROUP BY "id"')   }
+      its(:to_subquery) { should eql('(SELECT "id", COUNT ("age") AS "count" FROM (SELECT DISTINCT "id" FROM "other") AS "other" NATURAL LEFT JOIN ((SELECT "id", "name", "age" FROM "users") EXCEPT (SELECT "id", "name", "age" FROM "users")) AS "users" GROUP BY "id")') }
+    end
+
+    context 'when the operand is an intersection' do
+      let(:operand) { base_relation.intersect(base_relation) }
+
+      it_should_behave_like 'a generated SQL SELECT query'
+
+      its(:to_s)        { should eql('SELECT "id", COUNT ("age") AS "count" FROM (SELECT DISTINCT "id" FROM "other") AS "other" NATURAL LEFT JOIN ((SELECT "id", "name", "age" FROM "users") INTERSECT (SELECT "id", "name", "age" FROM "users")) AS "users" GROUP BY "id"')   }
+      its(:to_subquery) { should eql('(SELECT "id", COUNT ("age") AS "count" FROM (SELECT DISTINCT "id" FROM "other") AS "other" NATURAL LEFT JOIN ((SELECT "id", "name", "age" FROM "users") INTERSECT (SELECT "id", "name", "age" FROM "users")) AS "users" GROUP BY "id")') }
+    end
+
+    context 'when the operand is a union' do
+      let(:operand) { base_relation.union(base_relation) }
+
+      it_should_behave_like 'a generated SQL SELECT query'
+
+      its(:to_s)        { should eql('SELECT "id", COUNT ("age") AS "count" FROM (SELECT DISTINCT "id" FROM "other") AS "other" NATURAL LEFT JOIN ((SELECT "id", "name", "age" FROM "users") UNION (SELECT "id", "name", "age" FROM "users")) AS "users" GROUP BY "id"')   }
+      its(:to_subquery) { should eql('(SELECT "id", COUNT ("age") AS "count" FROM (SELECT DISTINCT "id" FROM "other") AS "other" NATURAL LEFT JOIN ((SELECT "id", "name", "age" FROM "users") UNION (SELECT "id", "name", "age" FROM "users")) AS "users" GROUP BY "id")') }
+    end
+
+    context 'when the operand is a join' do
+      let(:operand) { base_relation.join(base_relation) }
+
+      it_should_behave_like 'a generated SQL SELECT query'
+
+      its(:to_s)        { should eql('SELECT "id", COUNT ("age") AS "count" FROM (SELECT DISTINCT "id" FROM "other") AS "other" NATURAL LEFT JOIN (SELECT * FROM "users" AS "left" NATURAL JOIN "users" AS "right") AS "users" GROUP BY "id"')   }
+      its(:to_subquery) { should eql('(SELECT "id", COUNT ("age") AS "count" FROM (SELECT DISTINCT "id" FROM "other") AS "other" NATURAL LEFT JOIN (SELECT * FROM "users" AS "left" NATURAL JOIN "users" AS "right") AS "users" GROUP BY "id")') }
+    end
+  end
+end