veritas-sql-generator 0.0.3

data/spec/unit/veritas/sql/generator/logic/visit_veritas_logic_predicate_less_than_or_equal_to_spec.rb

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

data/spec/unit/veritas/sql/generator/logic/visit_veritas_logic_predicate_less_than_spec.rb

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

data/spec/unit/veritas/sql/generator/logic/visit_veritas_logic_proposition_contradiction_spec.rb

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

data/spec/unit/veritas/sql/generator/logic/visit_veritas_logic_proposition_tautology_spec.rb

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

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

@@ -0,0 +1,35 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe SQL::Generator::Relation::Binary::Base, '#to_subquery' do
+  subject { object.to_subquery }
+
+  let(:id)            { Attribute::Integer.new(:id)                      }
+  let(:name)          { Attribute::String.new(:name)                     }
+  let(:age)           { Attribute::Integer.new(:age, :required => false) }
+  let(:header)        { [ id, name, age ]                                }
+  let(:body)          { [ [ 1, 'Dan Kubb', 35 ] ].each                   }
+  let(:base_relation) { 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 base relation is visited' do
+    before do
+      object.visit(base_relation)
+    end
+
+    it_should_behave_like 'a generated SQL expression'
+
+    its(:to_s) { should eql('"users"') }
+  end
+end

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

@@ -0,0 +1,22 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe SQL::Generator::Relation::Binary::Base, '#visit_veritas_base_relation' do
+  subject { object.visit_veritas_base_relation(base_relation) }
+
+  let(:relation_name) { 'users'                                          }
+  let(:id)            { Attribute::Integer.new(:id)                      }
+  let(:name)          { Attribute::String.new(:name)                     }
+  let(:age)           { Attribute::Integer.new(:age, :required => false) }
+  let(:header)        { [ id, name, age ]                                }
+  let(:body)          { [ [ 1, 'Dan Kubb', 35 ] ].each                   }
+  let(:base_relation) { BaseRelation.new(relation_name, header, body)    }
+  let(:object)        { described_class.new                              }
+
+  it_should_behave_like 'a generated SQL SELECT query'
+
+  its(:name) { should eql('users') }
+
+  its(:to_subquery) { should eql('"users"') }
+end

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

@@ -0,0 +1,42 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe SQL::Generator::Relation::Binary, '.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 base' do
+    let(:relation)  { base_relation                                              }
+    let(:generator) { SQL::Generator::Relation::Binary::Base.new.visit(relation) }
+
+    it_should_behave_like 'a generated SQL expression'
+
+    its(:to_s) { should == '"users"' }
+  end
+
+  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/binary/to_s_spec.rb

@@ -0,0 +1,35 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe SQL::Generator::Relation::Binary, '#to_s' do
+  subject { object.to_s }
+
+  let(:id)            { Attribute::Integer.new(:id)                      }
+  let(:name)          { Attribute::String.new(:name)                     }
+  let(:age)           { Attribute::Integer.new(:age, :required => false) }
+  let(:header)        { [ id, name, age ]                                }
+  let(:body)          { [ [ 1, 'Dan Kubb', 35 ] ].each                   }
+  let(:base_relation) { 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 join is visited' do
+    before do
+      object.visit(base_relation.join(base_relation))
+    end
+
+    it_should_behave_like 'a generated SQL expression'
+
+    its(:to_s) { should eql('SELECT "id", "name", "age" FROM "users" NATURAL JOIN "users"') }
+  end
+end

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

@@ -0,0 +1,35 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe SQL::Generator::Relation::Binary, '#to_subquery' do
+  subject { object.to_subquery }
+
+  let(:id)            { Attribute::Integer.new(:id)                      }
+  let(:name)          { Attribute::String.new(:name)                     }
+  let(:age)           { Attribute::Integer.new(:age, :required => false) }
+  let(:header)        { [ id, name, age ]                                }
+  let(:body)          { [ [ 1, 'Dan Kubb', 35 ] ].each                   }
+  let(:base_relation) { 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 join is visited' do
+    before do
+      object.visit(base_relation.join(base_relation))
+    end
+
+    it_should_behave_like 'a generated SQL expression'
+
+    its(:to_s) { should eql('SELECT * FROM "users" NATURAL JOIN "users"') }
+  end
+end

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

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

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

@@ -0,0 +1,139 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe SQL::Generator::Relation::Binary, '#visit_veritas_algebra_product' do
+  subject { object.visit_veritas_algebra_product(product) }
+
+  let(:relation_name) { 'users_other'                                                              }
+  let(:id)            { Attribute::Integer.new(:id)                                                }
+  let(:name)          { Attribute::String.new(:name)                                               }
+  let(:age)           { Attribute::Integer.new(:age, :required => false)                           }
+  let(:header)        { [ id, name, age ]                                                          }
+  let(:other_header)  { [ id.rename(:other_id), name.rename(:other_name), age.rename(:other_age) ] }
+  let(:body)          { [ [ 1, 'Dan Kubb', 35 ] ].each                                             }
+  let(:users)         { BaseRelation.new('users', header, body)                                    }
+  let(:other)         { BaseRelation.new('other', other_header, body)                              }
+  let(:product)       { left.product(right)                                                        }
+  let(:object)        { described_class.new                                                        }
+
+  context 'when the operands are base relations' do
+    let(:left)  { users }
+    let(:right) { other }
+
+    it_should_behave_like 'a generated SQL SELECT query'
+
+    its(:to_s)        { should eql('SELECT "id", "name", "age", "other_id", "other_name", "other_age" FROM "users" CROSS JOIN "other"') }
+    its(:to_subquery) { should eql('SELECT * FROM "users" CROSS JOIN "other"')                                                          }
+  end
+
+  context 'when the operands are a projection' do
+    let(:left)  { users.project([ :id, :name ])             }
+    let(:right) { other.project([ :other_id, :other_name ]) }
+
+    it_should_behave_like 'a generated SQL SELECT query'
+
+    its(:to_s)        { should eql('SELECT "id", "name", "other_id", "other_name" FROM (SELECT DISTINCT "id", "name" FROM "users") AS "left" CROSS JOIN (SELECT DISTINCT "other_id", "other_name" FROM "other") AS "right"') }
+    its(:to_subquery) { should eql('SELECT * FROM (SELECT DISTINCT "id", "name" FROM "users") AS "left" CROSS JOIN (SELECT DISTINCT "other_id", "other_name" FROM "other") AS "right"')                                      }
+  end
+
+  context 'when the operand is a rename' do
+    let(:left)  { users.rename(:id => :user_id)             }
+    let(:right) { other.rename(:other_id => :other_user_id) }
+
+    it_should_behave_like 'a generated SQL SELECT query'
+
+    its(:to_s)        { should eql('SELECT "user_id", "name", "age", "other_user_id", "other_name", "other_age" FROM (SELECT "id" AS "user_id", "name", "age" FROM "users") AS "left" CROSS JOIN (SELECT "other_id" AS "other_user_id", "other_name", "other_age" FROM "other") AS "right"') }
+    its(:to_subquery) { should eql('SELECT * FROM (SELECT "id" AS "user_id", "name", "age" FROM "users") AS "left" CROSS JOIN (SELECT "other_id" AS "other_user_id", "other_name", "other_age" FROM "other") AS "right"')                                                                    }
+  end
+
+  context 'when the operand is a restriction' do
+    let(:left)  { users.restrict { |r| r[:id].eq(1) }       }
+    let(:right) { other.restrict { |r| r[:other_id].eq(1) } }
+
+    it_should_behave_like 'a generated SQL SELECT query'
+
+    its(:to_s)        { should eql('SELECT "id", "name", "age", "other_id", "other_name", "other_age" FROM (SELECT * FROM "users" WHERE "id" = 1) AS "left" CROSS JOIN (SELECT * FROM "other" WHERE "other_id" = 1) AS "right"') }
+    its(:to_subquery) { should eql('SELECT * FROM (SELECT * FROM "users" WHERE "id" = 1) AS "left" CROSS JOIN (SELECT * FROM "other" WHERE "other_id" = 1) AS "right"')                                                          }
+  end
+
+  context 'when the operand is ordered' do
+    let(:left)  { users.order }
+    let(:right) { other.order }
+
+    it_should_behave_like 'a generated SQL SELECT query'
+
+    its(:to_s)        { should eql('SELECT "id", "name", "age", "other_id", "other_name", "other_age" FROM (SELECT * FROM "users" ORDER BY "id", "name", "age") AS "left" CROSS JOIN (SELECT * FROM "other" ORDER BY "other_id", "other_name", "other_age") AS "right"') }
+    its(:to_subquery) { should eql('SELECT * FROM (SELECT * FROM "users" ORDER BY "id", "name", "age") AS "left" CROSS JOIN (SELECT * FROM "other" ORDER BY "other_id", "other_name", "other_age") AS "right"')                                                          }
+  end
+
+  context 'when the operand is reversed' do
+    let(:left)  { users.order.reverse }
+    let(:right) { other.order.reverse }
+
+    it_should_behave_like 'a generated SQL SELECT query'
+
+    its(:to_s)        { should eql('SELECT "id", "name", "age", "other_id", "other_name", "other_age" FROM (SELECT * FROM "users" ORDER BY "id" DESC, "name" DESC, "age" DESC) AS "left" CROSS JOIN (SELECT * FROM "other" ORDER BY "other_id" DESC, "other_name" DESC, "other_age" DESC) AS "right"') }
+    its(:to_subquery) { should eql('SELECT * FROM (SELECT * FROM "users" ORDER BY "id" DESC, "name" DESC, "age" DESC) AS "left" CROSS JOIN (SELECT * FROM "other" ORDER BY "other_id" DESC, "other_name" DESC, "other_age" DESC) AS "right"')                                                          }
+  end
+
+  context 'when the operand is limited' do
+    let(:left)  { users.order.take(1) }
+    let(:right) { other.order.take(1) }
+
+    it_should_behave_like 'a generated SQL SELECT query'
+
+    its(:to_s)        { should eql('SELECT "id", "name", "age", "other_id", "other_name", "other_age" FROM (SELECT * FROM "users" ORDER BY "id", "name", "age" LIMIT 1) AS "left" CROSS JOIN (SELECT * FROM "other" ORDER BY "other_id", "other_name", "other_age" LIMIT 1) AS "right"') }
+    its(:to_subquery) { should eql('SELECT * FROM (SELECT * FROM "users" ORDER BY "id", "name", "age" LIMIT 1) AS "left" CROSS JOIN (SELECT * FROM "other" ORDER BY "other_id", "other_name", "other_age" LIMIT 1) AS "right"')                                                          }
+  end
+
+  context 'when the operand is an offset' do
+    let(:left)  { users.order.drop(1) }
+    let(:right) { other.order.drop(1) }
+
+    it_should_behave_like 'a generated SQL SELECT query'
+
+    its(:to_s)        { should eql('SELECT "id", "name", "age", "other_id", "other_name", "other_age" FROM (SELECT * FROM "users" ORDER BY "id", "name", "age" OFFSET 1) AS "left" CROSS JOIN (SELECT * FROM "other" ORDER BY "other_id", "other_name", "other_age" OFFSET 1) AS "right"') }
+    its(:to_subquery) { should eql('SELECT * FROM (SELECT * FROM "users" ORDER BY "id", "name", "age" OFFSET 1) AS "left" CROSS JOIN (SELECT * FROM "other" ORDER BY "other_id", "other_name", "other_age" OFFSET 1) AS "right"')                                                          }
+  end
+
+  context 'when the operand is a difference' do
+    let(:left)  { users.difference(users) }
+    let(:right) { other.difference(other) }
+
+    it_should_behave_like 'a generated SQL SELECT query'
+
+    its(:to_s)        { should eql('SELECT "id", "name", "age", "other_id", "other_name", "other_age" FROM ((SELECT * FROM "users") EXCEPT (SELECT * FROM "users")) AS "left" CROSS JOIN ((SELECT * FROM "other") EXCEPT (SELECT * FROM "other")) AS "right"') }
+    its(:to_subquery) { should eql('SELECT * FROM ((SELECT * FROM "users") EXCEPT (SELECT * FROM "users")) AS "left" CROSS JOIN ((SELECT * FROM "other") EXCEPT (SELECT * FROM "other")) AS "right"')                                                          }
+  end
+
+  context 'when the operand is a intersection' do
+    let(:left)  { users.intersect(users) }
+    let(:right) { other.intersect(other) }
+
+    it_should_behave_like 'a generated SQL SELECT query'
+
+    its(:to_s)        { should eql('SELECT "id", "name", "age", "other_id", "other_name", "other_age" FROM ((SELECT * FROM "users") INTERSECT (SELECT * FROM "users")) AS "left" CROSS JOIN ((SELECT * FROM "other") INTERSECT (SELECT * FROM "other")) AS "right"') }
+    its(:to_subquery) { should eql('SELECT * FROM ((SELECT * FROM "users") INTERSECT (SELECT * FROM "users")) AS "left" CROSS JOIN ((SELECT * FROM "other") INTERSECT (SELECT * FROM "other")) AS "right"')                                                          }
+  end
+
+  context 'when the operand is a union' do
+    let(:left)  { users.union(users) }
+    let(:right) { other.union(other) }
+
+    it_should_behave_like 'a generated SQL SELECT query'
+
+    its(:to_s)        { should eql('SELECT "id", "name", "age", "other_id", "other_name", "other_age" FROM ((SELECT * FROM "users") UNION (SELECT * FROM "users")) AS "left" CROSS JOIN ((SELECT * FROM "other") UNION (SELECT * FROM "other")) AS "right"') }
+    its(:to_subquery) { should eql('SELECT * FROM ((SELECT * FROM "users") UNION (SELECT * FROM "users")) AS "left" CROSS JOIN ((SELECT * FROM "other") UNION (SELECT * FROM "other")) AS "right"')                                                          }
+  end
+
+  context 'when the operand is a join' do
+    let(:left)  { users.join(users) }
+    let(:right) { other.join(other) }
+
+    it_should_behave_like 'a generated SQL SELECT query'
+
+    its(:to_s)        { should eql('SELECT "id", "name", "age", "other_id", "other_name", "other_age" FROM (SELECT * FROM "users" NATURAL JOIN "users") AS "left" CROSS JOIN (SELECT * FROM "other" NATURAL JOIN "other") AS "right"') }
+    its(:to_subquery) { should eql('SELECT * FROM (SELECT * FROM "users" NATURAL JOIN "users") AS "left" CROSS JOIN (SELECT * FROM "other" NATURAL JOIN "other") AS "right"')                                                          }
+  end
+end