veritas-sql-generator 0.0.3

data/spec/unit/veritas/sql/generator/relation/class_methods/subquery_spec.rb

@@ -0,0 +1,33 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe SQL::Generator::Relation, '.subquery' do
+  subject { object.subquery(generator) }
+
+  let(:id)            { Attribute::Integer.new(:id)                      }
+  let(:name)          { Attribute::String.new(:name)                     }
+  let(:age)           { Attribute::Integer.new(:age, :required => false) }
+  let(:header)        { [ id, name, age ]                                }
+  let(:body)          { [ [ 1, 'Dan Kubb', 35 ] ].each                   }
+  let(:base_relation) { BaseRelation.new('users', header, body)          }
+  let(:object)        { described_class                                  }
+
+  context 'when generator is a unary' do
+    let(:relation)  { base_relation.project([ :id ])                      }
+    let(:generator) { SQL::Generator::Relation::Unary.new.visit(relation) }
+
+    it_should_behave_like 'a generated SQL expression'
+
+    its(:to_s) { should eql('(SELECT DISTINCT "id" FROM "users") AS "users"') }
+  end
+
+  context 'when generator is a binary' do
+    let(:relation)  { base_relation.join(base_relation)                    }
+    let(:generator) { SQL::Generator::Relation::Binary.new.visit(relation) }
+
+    it_should_behave_like 'a generated SQL expression'
+
+    its(:to_s) { should eql('(SELECT * FROM "users" NATURAL JOIN "users") AS "users"') }
+  end
+end

data/spec/unit/veritas/sql/generator/relation/class_methods/visit_spec.rb

@@ -0,0 +1,61 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe SQL::Generator::Relation, '.visit' do
+  subject { object.visit(relation) }
+
+  let(:id)            { Attribute::Integer.new(:id)                      }
+  let(:name)          { Attribute::String.new(:name)                     }
+  let(:age)           { Attribute::Integer.new(:age, :required => false) }
+  let(:header)        { [ id, name, age ]                                }
+  let(:body)          { [ [ 1, 'Dan Kubb', 35 ] ].each                   }
+  let(:base_relation) { BaseRelation.new('users', header, body)          }
+  let(:object)        { described_class                                  }
+
+  context 'when the relation is a set operation' do
+    let(:relation) { base_relation.union(base_relation) }
+
+    it { should be_kind_of(SQL::Generator::Relation::Set) }
+
+    its(:name) { should == 'users' }
+
+    it { should be_frozen }
+  end
+
+  context 'when the relation is a binary operation' do
+    let(:relation) { base_relation.join(base_relation.project([ :id ])) }
+
+    it { should be_kind_of(SQL::Generator::Relation::Binary) }
+
+    its(:name) { should == 'users' }
+
+    it { should be_frozen }
+  end
+
+  context 'when the relation is a unary operation' do
+    let(:relation) { base_relation.project([ :id ]) }
+
+    it { should be_kind_of(SQL::Generator::Relation::Unary) }
+
+    its(:name) { should == 'users' }
+
+    it { should be_frozen }
+  end
+
+  context 'when the relation is a base relation' do
+    let(:relation) { base_relation }
+
+    it { should be_kind_of(SQL::Generator::Relation::Base) }
+
+    its(:name) { should == 'users' }
+
+    it { should be_frozen }
+  end
+
+  context 'when the relation is invalid' do
+    let(:relation) { mock('Invalid Relation') }
+
+    specify { expect { subject }.to raise_error(SQL::Generator::InvalidRelationError, "#{relation.class} is not a visitable relation") }
+  end
+end

data/spec/unit/veritas/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/veritas/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) { BaseRelation.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/veritas/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) { BaseRelation.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 * FROM "users") EXCEPT (SELECT * 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 * FROM "users") INTERSECT (SELECT * 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 * FROM "users") UNION (SELECT * FROM "users")') }
+  end
+end

data/spec/unit/veritas/sql/generator/relation/set/visit_veritas_algebra_difference_spec.rb

@@ -0,0 +1,138 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe SQL::Generator::Relation::Set, '#visit_veritas_algebra_difference' do
+  subject { object.visit_veritas_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) { BaseRelation.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 * FROM "users") EXCEPT (SELECT * 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 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 * FROM "users" WHERE "id" = 1) EXCEPT (SELECT * FROM "users" WHERE "id" = 1)')                                     }
+  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", "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 * FROM "users" ORDER BY "id", "name", "age") EXCEPT (SELECT * FROM "users" ORDER BY "id", "name", "age")')                                     }
+  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", "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 * FROM "users" ORDER BY "id" DESC, "name" DESC, "age" DESC) EXCEPT (SELECT * FROM "users" ORDER BY "id" DESC, "name" DESC, "age" DESC)')                                     }
+  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", "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 * FROM "users" ORDER BY "id", "name", "age" LIMIT 1) EXCEPT (SELECT * FROM "users" ORDER BY "id", "name", "age" LIMIT 1)')                                     }
+  end
+
+  context 'when the operands are offsets' do
+    let(:operand) { base_relation.order.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 * FROM "users" ORDER BY "id", "name", "age" OFFSET 1) EXCEPT (SELECT * 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 * FROM "users") EXCEPT (SELECT * FROM "users")) EXCEPT ((SELECT * FROM "users") EXCEPT (SELECT * 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 * FROM "users") INTERSECT (SELECT * FROM "users")) EXCEPT ((SELECT * FROM "users") INTERSECT (SELECT * 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 * FROM "users") UNION (SELECT * FROM "users")) EXCEPT ((SELECT * FROM "users") UNION (SELECT * 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" NATURAL JOIN "users") EXCEPT (SELECT "id", "name", "age" FROM "users" NATURAL JOIN "users")') }
+    its(:to_subquery) { should eql('(SELECT * FROM "users" NATURAL JOIN "users") EXCEPT (SELECT * FROM "users" NATURAL JOIN "users")')                                     }
+  end
+
+  context 'when the operands have different base relations' do
+    let(:relation_name) { 'users_others'                           }
+    let(:left)          { BaseRelation.new('users',  header, body) }
+    let(:right)         { BaseRelation.new('others', header, body) }
+
+    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 * FROM "users") EXCEPT (SELECT * FROM "others")')                                     }
+  end
+end

data/spec/unit/veritas/sql/generator/relation/set/visit_veritas_algebra_intersection_spec.rb

@@ -0,0 +1,138 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe SQL::Generator::Relation::Set, '#visit_veritas_algebra_intersection' do
+  subject { object.visit_veritas_algebra_intersection(intersection) }
+
+  let(:relation_name) { 'users'                                          }
+  let(:id)            { Attribute::Integer.new(:id)                      }
+  let(:name)          { Attribute::String.new(:name)                     }
+  let(:age)           { Attribute::Integer.new(:age, :required => false) }
+  let(:header)        { [ id, name, age ]                                }
+  let(:body)          { [ [ 1, 'Dan Kubb', 35 ] ].each                   }
+  let(:base_relation) { BaseRelation.new(relation_name, header, body)    }
+  let(:left)          { operand                                          }
+  let(:right)         { operand                                          }
+  let(:intersection)  { left.intersect(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") INTERSECT (SELECT "id", "name", "age" FROM "users")') }
+    its(:to_subquery) { should eql('(SELECT * FROM "users") INTERSECT (SELECT * 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") INTERSECT (SELECT DISTINCT "id", "name" FROM "users")') }
+    its(:to_subquery) { should eql('(SELECT DISTINCT "id", "name" FROM "users") INTERSECT (SELECT DISTINCT "id", "name" 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") INTERSECT (SELECT "id" AS "user_id", "name", "age" FROM "users")') }
+    its(:to_subquery) { should eql('(SELECT "id" AS "user_id", "name", "age" FROM "users") INTERSECT (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) INTERSECT (SELECT "id", "name", "age" FROM "users" WHERE "id" = 1)') }
+    its(:to_subquery) { should eql('(SELECT * FROM "users" WHERE "id" = 1) INTERSECT (SELECT * FROM "users" WHERE "id" = 1)')                                     }
+  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", "name", "age" FROM "users" ORDER BY "id", "name", "age") INTERSECT (SELECT "id", "name", "age" FROM "users" ORDER BY "id", "name", "age")') }
+    its(:to_subquery) { should eql('(SELECT * FROM "users" ORDER BY "id", "name", "age") INTERSECT (SELECT * FROM "users" ORDER BY "id", "name", "age")')                                     }
+  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", "name", "age" FROM "users" ORDER BY "id" DESC, "name" DESC, "age" DESC) INTERSECT (SELECT "id", "name", "age" FROM "users" ORDER BY "id" DESC, "name" DESC, "age" DESC)') }
+    its(:to_subquery) { should eql('(SELECT * FROM "users" ORDER BY "id" DESC, "name" DESC, "age" DESC) INTERSECT (SELECT * FROM "users" ORDER BY "id" DESC, "name" DESC, "age" DESC)')                                     }
+  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", "name", "age" FROM "users" ORDER BY "id", "name", "age" LIMIT 1) INTERSECT (SELECT "id", "name", "age" FROM "users" ORDER BY "id", "name", "age" LIMIT 1)') }
+    its(:to_subquery) { should eql('(SELECT * FROM "users" ORDER BY "id", "name", "age" LIMIT 1) INTERSECT (SELECT * FROM "users" ORDER BY "id", "name", "age" LIMIT 1)')                                     }
+  end
+
+  context 'when the operands are offsets' do
+    let(:operand) { base_relation.order.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) INTERSECT (SELECT "id", "name", "age" FROM "users" ORDER BY "id", "name", "age" OFFSET 1)') }
+    its(:to_subquery) { should eql('(SELECT * FROM "users" ORDER BY "id", "name", "age" OFFSET 1) INTERSECT (SELECT * 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")) INTERSECT ((SELECT "id", "name", "age" FROM "users") EXCEPT (SELECT "id", "name", "age" FROM "users"))') }
+    its(:to_subquery) { should eql('((SELECT * FROM "users") EXCEPT (SELECT * FROM "users")) INTERSECT ((SELECT * FROM "users") EXCEPT (SELECT * 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")) INTERSECT ((SELECT "id", "name", "age" FROM "users") INTERSECT (SELECT "id", "name", "age" FROM "users"))') }
+    its(:to_subquery) { should eql('((SELECT * FROM "users") INTERSECT (SELECT * FROM "users")) INTERSECT ((SELECT * FROM "users") INTERSECT (SELECT * 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")) INTERSECT ((SELECT "id", "name", "age" FROM "users") UNION (SELECT "id", "name", "age" FROM "users"))') }
+    its(:to_subquery) { should eql('((SELECT * FROM "users") UNION (SELECT * FROM "users")) INTERSECT ((SELECT * FROM "users") UNION (SELECT * 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" NATURAL JOIN "users") INTERSECT (SELECT "id", "name", "age" FROM "users" NATURAL JOIN "users")') }
+    its(:to_subquery) { should eql('(SELECT * FROM "users" NATURAL JOIN "users") INTERSECT (SELECT * FROM "users" NATURAL JOIN "users")')                                     }
+  end
+
+  context 'when the operands have different base relations' do
+    let(:relation_name) { 'users_others'                           }
+    let(:left)          { BaseRelation.new('users',  header, body) }
+    let(:right)         { BaseRelation.new('others', header, body) }
+
+    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 "others")') }
+    its(:to_subquery) { should eql('(SELECT * FROM "users") INTERSECT (SELECT * FROM "others")')                                     }
+  end
+end