axiom-sql-generator 0.1.0

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

@@ -0,0 +1,15 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe SQL::Generator::Relation::Insertion, '#to_subquery' do
+  subject { object.to_subquery }
+
+  let(:object) { described_class.new }
+
+  it 'delegates to #to_s' do
+    sql = stub('sql')
+    object.should_receive(:to_s).with(no_args).and_return(sql)
+    should equal(sql)
+  end
+end

data/spec/unit/axiom/sql/generator/relation/insertion/visit_axiom_relation_operation_insertion_spec.rb

@@ -0,0 +1,187 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe SQL::Generator::Relation::Insertion, '#visit_axiom_relation_operation_insertion' do
+  subject { object.visit_axiom_relation_operation_insertion(insertion) }
+
+  let(:object)        { described_class.new                              }
+  let(:insertion)     { operand.insert(other)                            }
+  let(:operand)       { Relation::Base.new(relation_name, header, body)  }
+  let(:relation_name) { 'users'                                          }
+  let(:header)        { [ id, name, age ]                                }
+  let(:body)          { [].each                                          }
+  let(:id)            { Attribute::Integer.new(:id)                      }
+  let(:name)          { Attribute::String.new(:name)                     }
+  let(:age)           { Attribute::Integer.new(:age, :required => false) }
+
+  context 'inserting a non-empty materialized relation' do
+    let(:other) { operand.materialize            }
+    let(:body)  { [ [ 1, 'Dan Kubb', 36 ] ].each }
+
+    it_should_behave_like 'a generated SQL expression'
+
+    its(:to_s)        { should eql('INSERT INTO users ("id", "name", "age") VALUES (1, \'Dan Kubb\', 36)') }
+    its(:to_subquery) { should eql('INSERT INTO users ("id", "name", "age") VALUES (1, \'Dan Kubb\', 36)') }
+  end
+
+  context 'inserting an empty materialized relation' do
+    let(:other) { operand.materialize }
+
+    it_should_behave_like 'a generated SQL expression'
+
+    its(:to_s)        { should eql('INSERT INTO users ("id", "name", "age") SELECT 0 LIMIT 0') }
+    its(:to_subquery) { should eql('INSERT INTO users ("id", "name", "age") SELECT 0 LIMIT 0') }
+  end
+
+  context 'inserting a base relation' do
+    let(:other) { operand }
+
+    it_should_behave_like 'a generated SQL expression'
+
+    its(:to_s)        { should eql('INSERT INTO users ("id", "name", "age") SELECT "id", "name", "age" FROM "users"') }
+    its(:to_subquery) { should eql('INSERT INTO users ("id", "name", "age") SELECT "id", "name", "age" FROM "users"') }
+  end
+
+  context 'inserting a projection' do
+    let(:header) { [ id, name ]                    }
+    let(:other)  { operand.project([ :id, :name ]) }
+
+    it_should_behave_like 'a generated SQL SELECT query'
+
+    its(:to_s)        { should eql('INSERT INTO users ("id", "name") SELECT DISTINCT "id", "name" FROM "users"') }
+    its(:to_subquery) { should eql('INSERT INTO users ("id", "name") SELECT DISTINCT "id", "name" FROM "users"') }
+  end
+
+  context 'inserting an extension' do
+    let(:other) { Relation::Base.new('other', [ id, name ], body).extend { |r| r.add(age, 1) } }
+
+    it_should_behave_like 'a generated SQL SELECT query'
+
+    its(:to_s)        { should eql('INSERT INTO users ("id", "name", "age") SELECT "id", "name", 1 AS "age" FROM "other"') }
+    its(:to_subquery) { should eql('INSERT INTO users ("id", "name", "age") SELECT "id", "name", 1 AS "age" FROM "other"') }
+  end
+
+  context 'inserting a rename' do
+    let(:other) { Relation::Base.new('other', [ [ :other_id, Integer ], name, age ], body).rename(:other_id => :id) }
+
+    it_should_behave_like 'a generated SQL SELECT query'
+
+    its(:to_s)        { should eql('INSERT INTO users ("id", "name", "age") SELECT "other_id" AS "id", "name", "age" FROM "other"') }
+    its(:to_subquery) { should eql('INSERT INTO users ("id", "name", "age") SELECT "other_id" AS "id", "name", "age" FROM "other"') }
+  end
+
+  context 'inserting a restriction' do
+    let(:other) { operand.restrict { |r| r.id.eq(1) } }
+
+    it_should_behave_like 'a generated SQL SELECT query'
+
+    its(:to_s)        { should eql('INSERT INTO users ("id", "name", "age") SELECT "id", "name", "age" FROM "users" WHERE "id" = 1') }
+    its(:to_subquery) { should eql('INSERT INTO users ("id", "name", "age") SELECT "id", "name", "age" FROM "users" WHERE "id" = 1') }
+  end
+
+  context 'inserting a summarization' do
+    context 'summarize per table dee' do
+      let(:summarize_per) { TABLE_DEE                                                      }
+      let(:operand)       { Relation::Base.new(relation_name, [ id ], body)                }
+      let(:other)         { operand.summarize(summarize_per) { |r| r.add(id, r.id.count) } }
+
+      it_should_behave_like 'a generated SQL SELECT query'
+
+      its(:to_s)        { should eql('INSERT INTO users ("id") SELECT COUNT ("id") AS "id" FROM "users"') }
+      its(:to_subquery) { should eql('INSERT INTO users ("id") SELECT COUNT ("id") AS "id" FROM "users"') }
+    end
+
+    context 'summarize per table dum' do
+      let(:summarize_per) { TABLE_DUM                                                      }
+      let(:operand)       { Relation::Base.new(relation_name, [ id ], body)                }
+      let(:other)         { operand.summarize(summarize_per) { |r| r.add(id, r.id.count) } }
+
+      it_should_behave_like 'a generated SQL SELECT query'
+
+      its(:to_s)        { should eql('INSERT INTO users ("id") SELECT COUNT ("id") AS "id" FROM "users" HAVING FALSE') }
+      its(:to_subquery) { should eql('INSERT INTO users ("id") SELECT COUNT ("id") AS "id" FROM "users" HAVING FALSE') }
+    end
+
+    context 'summarize by a subset of the operand header' do
+      let(:other) { operand.summarize([ :id, :name ]) { |r| r.add(age, r.age.count) } }
+
+      it_should_behave_like 'a generated SQL SELECT query'
+
+      its(:to_s)        { should eql('INSERT INTO users ("id", "name", "age") SELECT "id", "name", COUNT ("age") AS "age" FROM "users" GROUP BY "id", "name" HAVING COUNT (*) > 0') }
+      its(:to_subquery) { should eql('INSERT INTO users ("id", "name", "age") SELECT "id", "name", COUNT ("age") AS "age" FROM "users" GROUP BY "id", "name" HAVING COUNT (*) > 0') }
+    end
+  end
+
+  context 'inserting an order' do
+    let(:other) { operand.sort_by { |r| [ r.id, r.name, r.age ] } }
+
+    it_should_behave_like 'a generated SQL SELECT query'
+
+    its(:to_s)        { should eql('INSERT INTO users ("id", "name", "age") SELECT "id", "name", "age" FROM "users" ORDER BY "id", "name", "age"') }
+    its(:to_subquery) { should eql('INSERT INTO users ("id", "name", "age") SELECT "id", "name", "age" FROM "users" ORDER BY "id", "name", "age"') }
+  end
+
+  context 'inserting a reverse' do
+    let(:other) { operand.sort_by { |r| [ r.id, r.name, r.age ] }.reverse }
+
+    it_should_behave_like 'a generated SQL SELECT query'
+
+    its(:to_s)        { should eql('INSERT INTO users ("id", "name", "age") SELECT "id", "name", "age" FROM "users" ORDER BY "id" DESC, "name" DESC, "age" DESC') }
+    its(:to_subquery) { should eql('INSERT INTO users ("id", "name", "age") SELECT "id", "name", "age" FROM "users" ORDER BY "id" DESC, "name" DESC, "age" DESC') }
+  end
+
+  context 'inserting a limit' do
+    let(:other) { operand.sort_by { |r| [ r.id, r.name, r.age ] }.take(1) }
+
+    it_should_behave_like 'a generated SQL SELECT query'
+
+    its(:to_s)        { should eql('INSERT INTO users ("id", "name", "age") SELECT "id", "name", "age" FROM "users" ORDER BY "id", "name", "age" LIMIT 1') }
+    its(:to_subquery) { should eql('INSERT INTO users ("id", "name", "age") SELECT "id", "name", "age" FROM "users" ORDER BY "id", "name", "age" LIMIT 1') }
+  end
+
+  context 'inserting an offset' do
+    let(:other) { operand.sort_by { |r| [ r.id, r.name, r.age ] }.drop(1) }
+
+    it_should_behave_like 'a generated SQL SELECT query'
+
+    its(:to_s)        { should eql('INSERT INTO users ("id", "name", "age") SELECT "id", "name", "age" FROM "users" ORDER BY "id", "name", "age" OFFSET 1') }
+    its(:to_subquery) { should eql('INSERT INTO users ("id", "name", "age") SELECT "id", "name", "age" FROM "users" ORDER BY "id", "name", "age" OFFSET 1') }
+  end
+
+  context 'inserting a difference' do
+    let(:other) { operand.difference(operand) }
+
+    it_should_behave_like 'a generated SQL SELECT query'
+
+    its(:to_s)        { should eql('INSERT INTO users ("id", "name", "age") (SELECT "id", "name", "age" FROM "users") EXCEPT (SELECT "id", "name", "age" FROM "users")') }
+    its(:to_subquery) { should eql('INSERT INTO users ("id", "name", "age") (SELECT "id", "name", "age" FROM "users") EXCEPT (SELECT "id", "name", "age" FROM "users")') }
+  end
+
+  context 'inserting a intersection' do
+    let(:other) { operand.intersect(operand) }
+
+    it_should_behave_like 'a generated SQL SELECT query'
+
+    its(:to_s)        { should eql('INSERT INTO users ("id", "name", "age") (SELECT "id", "name", "age" FROM "users") INTERSECT (SELECT "id", "name", "age" FROM "users")') }
+    its(:to_subquery) { should eql('INSERT INTO users ("id", "name", "age") (SELECT "id", "name", "age" FROM "users") INTERSECT (SELECT "id", "name", "age" FROM "users")') }
+  end
+
+  context 'inserting a union' do
+    let(:other) { operand.union(operand) }
+
+    it_should_behave_like 'a generated SQL SELECT query'
+
+    its(:to_s)        { should eql('INSERT INTO users ("id", "name", "age") (SELECT "id", "name", "age" FROM "users") UNION (SELECT "id", "name", "age" FROM "users")') }
+    its(:to_subquery) { should eql('INSERT INTO users ("id", "name", "age") (SELECT "id", "name", "age" FROM "users") UNION (SELECT "id", "name", "age" FROM "users")') }
+  end
+
+  context 'inserting a join' do
+    let(:other) { operand.join(operand) }
+
+    it_should_behave_like 'a generated SQL SELECT query'
+
+    its(:to_s)        { should eql('INSERT INTO users ("id", "name", "age") SELECT "id", "name", "age" FROM "users" AS "left" NATURAL JOIN "users" AS "right"') }
+    its(:to_subquery) { should eql('INSERT INTO users ("id", "name", "age") SELECT "id", "name", "age" FROM "users" AS "left" NATURAL JOIN "users" AS "right"') }
+  end
+end

data/spec/unit/axiom/sql/generator/relation/materialized/visit_axiom_relation_materialized_spec.rb

@@ -0,0 +1,28 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe SQL::Generator::Relation::Materialized, '#visit_axiom_relation_materialized' do
+  subject { object.visit_axiom_relation_materialized(relation) }
+
+  let(:object) { described_class.new  }
+  let(:header) { [ [ :id, Integer ], [ :name, String ] ] }
+
+  context 'with an non-empty relation' do
+    let(:relation) { Relation.new(header, [ [ 1, 'John Doe' ], [ 2, 'Jane Doe' ] ]) }
+
+    it_should_behave_like 'a generated SQL expression'
+
+    its(:to_s)        { should eql('VALUES (1, \'John Doe\'), (2, \'Jane Doe\')')   }
+    its(:to_subquery) { should eql('(VALUES (1, \'John Doe\'), (2, \'Jane Doe\'))') }
+  end
+
+  context 'with an empty relation' do
+    let(:relation) { Relation.new(header, []) }
+
+    it_should_behave_like 'a generated SQL expression'
+
+    its(:to_s)        { should eql('SELECT 0 LIMIT 0')   }
+    its(:to_subquery) { should eql('(SELECT 0 LIMIT 0)') }
+  end
+end

data/spec/unit/axiom/sql/generator/relation/materialized/visited_spec.rb

@@ -0,0 +1,26 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe SQL::Generator::Relation::Materialized, '#visited?' do
+  subject { object.visited? }
+
+  let(:object)   { described_class.new                        }
+  let(:relation) { Relation.new([ [ :id, Integer ] ], [ [] ]) }
+
+  context 'when the relation is visited' do
+    before do
+      object.visit_axiom_relation_materialized(relation)
+    end
+
+    it_should_behave_like 'an idempotent method'
+
+    it { should be(true) }
+  end
+
+  context 'when the relation is not visited' do
+    it_should_behave_like 'an idempotent method'
+
+    it { should be(false) }
+  end
+end

data/spec/unit/axiom/sql/generator/relation/name_spec.rb

@@ -0,0 +1,30 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe SQL::Generator::Relation, '#name' do
+  subject { object.name }
+
+  let(:described_class) { Class.new(SQL::Generator::Relation) }
+  let(:object)          { described_class.new                 }
+
+  context 'when name is nil' do
+    it_should_behave_like 'an idempotent method'
+
+    it { should be_nil }
+  end
+
+  context 'when name is set' do
+    let(:name) { 'test' }
+
+    before do
+      # subclasses set @name, but nothing in this class
+      # does does so simulate it being set
+      object.instance_variable_set(:@name, name)
+    end
+
+    it_should_behave_like 'an idempotent method'
+
+    it { should equal(name) }
+  end
+end

data/spec/unit/axiom/sql/generator/relation/set/class_methods/normalize_operand_headers_spec.rb

@@ -0,0 +1,35 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe SQL::Generator::Relation::Set, '.normalize_operand_headers' do
+  subject { object.normalize_operand_headers(relation) }
+
+  let(:object)        { described_class                          }
+  let(:relation)      { left.union(right)                        }
+  let(:relation_name) { 'test'                                   }
+  let(:header)        { [ [ :id, Integer, ], [ :name, String ] ] }
+  let(:body)          { [].each                                  }
+
+  context 'when the left and right headers are sorted in the same order' do
+    let(:left)  { Relation::Base.new(relation_name, header, body) }
+    let(:right) { Relation::Base.new(relation_name, header, body) }
+
+    it { should equal(relation) }
+  end
+
+  context 'when the left and right headers are sorted in different order' do
+    let(:left)  { Relation::Base.new(relation_name, header,         body) }
+    let(:right) { Relation::Base.new(relation_name, header.reverse, body) }
+
+    it { should_not equal(relation) }
+
+    its(:right) { should_not equal(right) }
+
+    it { should be_kind_of(relation.class) }
+
+    its(:left) { should equal(left) }
+
+    its(:right) { should eql(right.project(header)) }
+  end
+end

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

@@ -0,0 +1,55 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe SQL::Generator::Relation::Set, '#to_s' do
+  subject { object.to_s }
+
+  let(:id)            { Attribute::Integer.new(:id)                      }
+  let(:name)          { Attribute::String.new(:name)                     }
+  let(:age)           { Attribute::Integer.new(:age, :required => false) }
+  let(:header)        { [ id, name, age ]                                }
+  let(:body)          { [ [ 1, 'Dan Kubb', 35 ] ].each                   }
+  let(:base_relation) { Relation::Base.new('users', header, body)        }
+  let(:object)        { described_class.new                              }
+
+  context 'when no object visited' do
+    it_should_behave_like 'an idempotent method'
+
+    it { should respond_to(:to_s) }
+
+    it { should be_frozen }
+
+    its(:to_s) { should == '' }
+  end
+
+  context 'when a difference is visited' do
+    before do
+      object.visit(base_relation.difference(base_relation))
+    end
+
+    it_should_behave_like 'a generated SQL expression'
+
+    its(:to_s) { should eql('(SELECT "id", "name", "age" FROM "users") EXCEPT (SELECT "id", "name", "age" FROM "users")') }
+  end
+
+  context 'when an intersection is visited' do
+    before do
+      object.visit(base_relation.intersect(base_relation))
+    end
+
+    it_should_behave_like 'a generated SQL expression'
+
+    its(:to_s) { should eql('(SELECT "id", "name", "age" FROM "users") INTERSECT (SELECT "id", "name", "age" FROM "users")') }
+  end
+
+  context 'when a union is visited' do
+    before do
+      object.visit(base_relation.union(base_relation))
+    end
+
+    it_should_behave_like 'a generated SQL expression'
+
+    its(:to_s) { should eql('(SELECT "id", "name", "age" FROM "users") UNION (SELECT "id", "name", "age" FROM "users")') }
+  end
+end

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

@@ -0,0 +1,55 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe SQL::Generator::Relation::Set, '#to_subquery' do
+  subject { object.to_subquery }
+
+  let(:id)            { Attribute::Integer.new(:id)                      }
+  let(:name)          { Attribute::String.new(:name)                     }
+  let(:age)           { Attribute::Integer.new(:age, :required => false) }
+  let(:header)        { [ id, name, age ]                                }
+  let(:body)          { [ [ 1, 'Dan Kubb', 35 ] ].each                   }
+  let(:base_relation) { Relation::Base.new('users', header, body)        }
+  let(:object)        { described_class.new                              }
+
+  context 'when no object visited' do
+    it_should_behave_like 'an idempotent method'
+
+    it { should respond_to(:to_s) }
+
+    it { should be_frozen }
+
+    its(:to_s) { should == '' }
+  end
+
+  context 'when a difference is visited' do
+    before do
+      object.visit(base_relation.difference(base_relation))
+    end
+
+    it_should_behave_like 'a generated SQL expression'
+
+    its(:to_s) { should eql('((SELECT "id", "name", "age" FROM "users") EXCEPT (SELECT "id", "name", "age" FROM "users"))') }
+  end
+
+  context 'when an intersection is visited' do
+    before do
+      object.visit(base_relation.intersect(base_relation))
+    end
+
+    it_should_behave_like 'a generated SQL expression'
+
+    its(:to_s) { should eql('((SELECT "id", "name", "age" FROM "users") INTERSECT (SELECT "id", "name", "age" FROM "users"))') }
+  end
+
+  context 'when a union is visited' do
+    before do
+      object.visit(base_relation.union(base_relation))
+    end
+
+    it_should_behave_like 'a generated SQL expression'
+
+    its(:to_s) { should eql('((SELECT "id", "name", "age" FROM "users") UNION (SELECT "id", "name", "age" FROM "users"))') }
+  end
+end

data/spec/unit/axiom/sql/generator/relation/set/visit_axiom_algebra_difference_spec.rb

@@ -0,0 +1,191 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe SQL::Generator::Relation::Set, '#visit_axiom_algebra_difference' do
+  subject { object.visit_axiom_algebra_difference(difference) }
+
+  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(:left)          { operand                                          }
+  let(:right)         { operand                                          }
+  let(:difference)    { left.difference(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") EXCEPT (SELECT "id", "name", "age" FROM "users")')   }
+    its(:to_subquery) { should eql('((SELECT "id", "name", "age" FROM "users") EXCEPT (SELECT "id", "name", "age" FROM "users"))') }
+  end
+
+  context 'when the operands are projections' do
+    let(:operand) { base_relation.project([ :id, :name ]) }
+
+    it_should_behave_like 'a generated SQL SELECT query'
+
+    its(:to_s)        { should eql('(SELECT DISTINCT "id", "name" FROM "users") EXCEPT (SELECT DISTINCT "id", "name" FROM "users")')   }
+    its(:to_subquery) { should eql('((SELECT DISTINCT "id", "name" FROM "users") EXCEPT (SELECT DISTINCT "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)        { should eql('(SELECT "id", "name", "age", 1 AS "one" FROM "users") EXCEPT (SELECT "id", "name", "age", 1 AS "one" FROM "users")')   }
+    its(:to_subquery) { should eql('((SELECT "id", "name", "age", 1 AS "one" FROM "users") EXCEPT (SELECT "id", "name", "age", 1 AS "one" FROM "users"))') }
+  end
+
+  context 'when the operands are renames' do
+    let(:operand) { base_relation.rename(:id => :user_id) }
+
+    it_should_behave_like 'a generated SQL SELECT query'
+
+    its(:to_s)        { should eql('(SELECT "id" AS "user_id", "name", "age" FROM "users") EXCEPT (SELECT "id" AS "user_id", "name", "age" FROM "users")')   }
+    its(:to_subquery) { should eql('((SELECT "id" AS "user_id", "name", "age" FROM "users") EXCEPT (SELECT "id" AS "user_id", "name", "age" FROM "users"))') }
+  end
+
+  context 'when the operands are restrictions' 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", "name", "age" FROM "users" WHERE "id" = 1) EXCEPT (SELECT "id", "name", "age" FROM "users" WHERE "id" = 1)')   }
+    its(:to_subquery) { should eql('((SELECT "id", "name", "age" FROM "users" WHERE "id" = 1) EXCEPT (SELECT "id", "name", "age" FROM "users" WHERE "id" = 1))') }
+  end
+
+  context 'when the operand is a summarization' do
+  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 ("id") AS "count" FROM "users") EXCEPT (SELECT COUNT ("id") AS "count" FROM "users")')   }
+      its(:to_subquery) { should eql('((SELECT COUNT ("id") AS "count" FROM "users") EXCEPT (SELECT COUNT ("id") AS "count" FROM "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) } }
+
+      it_should_behave_like 'a generated SQL SELECT query'
+
+      its(:to_s)        { should eql('(SELECT COUNT ("id") AS "count" FROM "users" HAVING FALSE) EXCEPT (SELECT COUNT ("id") AS "count" FROM "users" HAVING FALSE)')   }
+      its(:to_subquery) { should eql('((SELECT COUNT ("id") AS "count" FROM "users" HAVING FALSE) EXCEPT (SELECT COUNT ("id") AS "count" FROM "users" HAVING FALSE))') }
+    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 ("age") AS "count" FROM "users" GROUP BY "id", "name" HAVING COUNT (*) > 0) EXCEPT (SELECT "id", "name", COUNT ("age") AS "count" FROM "users" GROUP BY "id", "name" HAVING COUNT (*) > 0)')   }
+      its(:to_subquery) { should eql('((SELECT "id", "name", COUNT ("age") AS "count" FROM "users" GROUP BY "id", "name" HAVING COUNT (*) > 0) EXCEPT (SELECT "id", "name", COUNT ("age") AS "count" FROM "users" GROUP BY "id", "name" HAVING COUNT (*) > 0))') }
+    end
+  end
+
+  context 'when the operand is ordered' do
+    let(:operand) { base_relation.sort_by { |r| [ r.id, r.name, r.age ] } }
+
+    it_should_behave_like 'a generated SQL SELECT query'
+
+    its(:to_s)        { should eql('(SELECT "id", "name", "age" FROM "users" ORDER BY "id", "name", "age") EXCEPT (SELECT "id", "name", "age" FROM "users" ORDER BY "id", "name", "age")')   }
+    its(:to_subquery) { should eql('((SELECT "id", "name", "age" FROM "users" ORDER BY "id", "name", "age") EXCEPT (SELECT "id", "name", "age" FROM "users" ORDER BY "id", "name", "age"))') }
+  end
+
+  context 'when the operand is reversed' do
+    let(:operand) { base_relation.sort_by { |r| [ r.id, r.name, r.age ] }.reverse }
+
+    it_should_behave_like 'a generated SQL SELECT query'
+
+    its(:to_s)        { should eql('(SELECT "id", "name", "age" FROM "users" ORDER BY "id" DESC, "name" DESC, "age" DESC) EXCEPT (SELECT "id", "name", "age" FROM "users" ORDER BY "id" DESC, "name" DESC, "age" DESC)')   }
+    its(:to_subquery) { should eql('((SELECT "id", "name", "age" FROM "users" ORDER BY "id" DESC, "name" DESC, "age" DESC) EXCEPT (SELECT "id", "name", "age" FROM "users" ORDER BY "id" DESC, "name" DESC, "age" DESC))') }
+  end
+
+  context 'when the operand is limited' do
+    let(:operand) { base_relation.sort_by { |r| [ r.id, r.name, r.age ] }.take(1) }
+
+    it_should_behave_like 'a generated SQL SELECT query'
+
+    its(:to_s)        { should eql('(SELECT "id", "name", "age" FROM "users" ORDER BY "id", "name", "age" LIMIT 1) EXCEPT (SELECT "id", "name", "age" FROM "users" ORDER BY "id", "name", "age" LIMIT 1)')   }
+    its(:to_subquery) { should eql('((SELECT "id", "name", "age" FROM "users" ORDER BY "id", "name", "age" LIMIT 1) EXCEPT (SELECT "id", "name", "age" FROM "users" ORDER BY "id", "name", "age" LIMIT 1))') }
+  end
+
+  context 'when the operands are offsets' do
+    let(:operand) { base_relation.sort_by { |r| [ r.id, r.name, r.age ] }.drop(1) }
+
+    it_should_behave_like 'a generated SQL SELECT query'
+
+    its(:to_s)        { should eql('(SELECT "id", "name", "age" FROM "users" ORDER BY "id", "name", "age" OFFSET 1) EXCEPT (SELECT "id", "name", "age" FROM "users" ORDER BY "id", "name", "age" OFFSET 1)')   }
+    its(:to_subquery) { should eql('((SELECT "id", "name", "age" FROM "users" ORDER BY "id", "name", "age" OFFSET 1) EXCEPT (SELECT "id", "name", "age" FROM "users" ORDER BY "id", "name", "age" OFFSET 1))') }
+  end
+
+  context 'when the operands are differences' do
+    let(:operand) { base_relation.difference(base_relation) }
+
+    it_should_behave_like 'a generated SQL SELECT query'
+
+    its(:to_s)        { should eql('((SELECT "id", "name", "age" FROM "users") EXCEPT (SELECT "id", "name", "age" FROM "users")) EXCEPT ((SELECT "id", "name", "age" FROM "users") EXCEPT (SELECT "id", "name", "age" FROM "users"))')   }
+    its(:to_subquery) { should eql('(((SELECT "id", "name", "age" FROM "users") EXCEPT (SELECT "id", "name", "age" FROM "users")) EXCEPT ((SELECT "id", "name", "age" FROM "users") EXCEPT (SELECT "id", "name", "age" FROM "users")))') }
+  end
+
+  context 'when the operands are intersections' do
+    let(:operand) { base_relation.intersect(base_relation) }
+
+    it_should_behave_like 'a generated SQL SELECT query'
+
+    its(:to_s)        { should eql('((SELECT "id", "name", "age" FROM "users") INTERSECT (SELECT "id", "name", "age" FROM "users")) EXCEPT ((SELECT "id", "name", "age" FROM "users") INTERSECT (SELECT "id", "name", "age" FROM "users"))')   }
+    its(:to_subquery) { should eql('(((SELECT "id", "name", "age" FROM "users") INTERSECT (SELECT "id", "name", "age" FROM "users")) EXCEPT ((SELECT "id", "name", "age" FROM "users") INTERSECT (SELECT "id", "name", "age" FROM "users")))') }
+  end
+
+  context 'when the operands are unions' do
+    let(:operand) { base_relation.union(base_relation) }
+
+    it_should_behave_like 'a generated SQL SELECT query'
+
+    its(:to_s)        { should eql('((SELECT "id", "name", "age" FROM "users") UNION (SELECT "id", "name", "age" FROM "users")) EXCEPT ((SELECT "id", "name", "age" FROM "users") UNION (SELECT "id", "name", "age" FROM "users"))')   }
+    its(:to_subquery) { should eql('(((SELECT "id", "name", "age" FROM "users") UNION (SELECT "id", "name", "age" FROM "users")) EXCEPT ((SELECT "id", "name", "age" FROM "users") UNION (SELECT "id", "name", "age" FROM "users")))') }
+  end
+
+  context 'when the operands are joins' do
+    let(:operand) { base_relation.join(base_relation) }
+
+    it_should_behave_like 'a generated SQL SELECT query'
+
+    its(:to_s)        { should eql('(SELECT "id", "name", "age" FROM "users" AS "left" NATURAL JOIN "users" AS "right") EXCEPT (SELECT "id", "name", "age" FROM "users" AS "left" NATURAL JOIN "users" AS "right")')   }
+    its(:to_subquery) { should eql('((SELECT "id", "name", "age" FROM "users" AS "left" NATURAL JOIN "users" AS "right") EXCEPT (SELECT "id", "name", "age" FROM "users" AS "left" NATURAL JOIN "users" AS "right"))') }
+  end
+
+  context 'when the operands have different base relations' do
+    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") EXCEPT (SELECT "id", "name", "age" FROM "others")')   }
+    its(:to_subquery) { should eql('((SELECT "id", "name", "age" FROM "users") EXCEPT (SELECT "id", "name", "age" FROM "others"))') }
+  end
+
+  context 'when the operands have headers sorted in different orders' do
+    let(:left)  { Relation::Base.new(relation_name, header,         body) }
+    let(:right) { Relation::Base.new(relation_name, header.reverse, body) }
+
+    it_should_behave_like 'a generated SQL SELECT query'
+
+    its(:to_s)        { should eql('(SELECT "id", "name", "age" FROM "users") EXCEPT (SELECT DISTINCT "id", "name", "age" FROM "users")')   }
+    its(:to_subquery) { should eql('((SELECT "id", "name", "age" FROM "users") EXCEPT (SELECT DISTINCT "id", "name", "age" FROM "users"))') }
+  end
+end