arel 2.0.10 → 2.1.0

data/test/attributes/test_attribute.rb

@@ -326,7 +326,7 @@ module Arel
 
       describe '#eq' do
         it 'should return an equality node' do
-          attribute = Attribute.new nil, nil, nil
+          attribute = Attribute.new nil, nil
           equality = attribute.eq 1
           equality.left.must_equal attribute
           equality.right.must_equal 1
@@ -501,7 +501,7 @@ module Arel
         end
 
         it 'should return an in node' do
-          attribute = Attribute.new nil, nil, nil
+          attribute = Attribute.new nil, nil
           node = Nodes::In.new attribute, [1,2,3]
           node.left.must_equal attribute
           node.right.must_equal [1, 2, 3]
@@ -554,7 +554,7 @@ module Arel
         end
 
         it 'should return a NotIn node' do
-          attribute = Attribute.new nil, nil, nil
+          attribute = Attribute.new nil, nil
           node = Nodes::NotIn.new attribute, [1,2,3]
           node.left.must_equal attribute
           node.right.must_equal [1, 2, 3]

data/test/helper.rb

@@ -8,6 +8,6 @@ Arel::Table.engine = Arel::Sql::Engine.new(FakeRecord::Base.new)
 
 class Object
   def must_be_like other
-    self.gsub(/\s+/, ' ').strip.must_equal other.gsub(/\s+/, ' ').strip
+    gsub(/\s+/, ' ').strip.must_equal other.gsub(/\s+/, ' ').strip
   end
 end

data/test/nodes/test_as.rb

@@ -10,6 +10,12 @@ module Arel
           assert_equal attr, as.left
           assert_equal 'foo', as.right
         end
+
+        it 'converts right to SqlLiteral if a string' do
+          attr = Table.new(:users)[:id]
+          as = attr.as('foo')
+          assert_kind_of Arel::Nodes::SqlLiteral, as.right
+        end
       end
     end
   end

data/test/nodes/test_bin.rb

@@ -0,0 +1,23 @@
+require 'helper'
+
+module Arel
+  module Nodes
+    class TestBin < MiniTest::Unit::TestCase
+      def test_new
+        assert Arel::Nodes::Bin.new('zomg')
+      end
+
+      def test_default_to_sql
+        viz  = Arel::Visitors::ToSql.new Table.engine
+        node = Arel::Nodes::Bin.new(Arel.sql('zomg'))
+        assert_equal 'zomg', viz.accept(node)
+      end
+
+      def test_mysql_to_sql
+        viz  = Arel::Visitors::MySQL.new Table.engine
+        node = Arel::Nodes::Bin.new(Arel.sql('zomg'))
+        assert_equal 'BINARY zomg', viz.accept(node)
+      end
+    end
+  end
+end

data/test/nodes/test_named_function.rb

@@ -0,0 +1,30 @@
+require 'helper'
+
+module Arel
+  module Nodes
+    class TestNamedFunction < MiniTest::Unit::TestCase
+      def test_construct
+        function = NamedFunction.new 'omg', 'zomg'
+        assert_equal 'omg', function.name
+        assert_equal 'zomg', function.expressions
+      end
+
+      def test_function_alias
+        function = NamedFunction.new 'omg', 'zomg'
+        function = function.as('wth')
+        assert_equal 'omg', function.name
+        assert_equal 'zomg', function.expressions
+        assert_kind_of SqlLiteral, function.alias
+        assert_equal 'wth', function.alias
+      end
+
+      def test_construct_with_alias
+        function = NamedFunction.new 'omg', 'zomg', 'wth'
+        assert_equal 'omg', function.name
+        assert_equal 'zomg', function.expressions
+        assert_kind_of SqlLiteral, function.alias
+        assert_equal 'wth', function.alias
+      end
+    end
+  end
+end

data/test/nodes/test_node.rb

@@ -2,11 +2,16 @@ require 'helper'
 
 module Arel
   class TestNode < MiniTest::Unit::TestCase
+    def test_includes_factory_methods
+      assert Node.new.respond_to?(:create_join)
+    end
+
     def test_all_nodes_are_nodes
       Nodes.constants.map { |k|
         Nodes.const_get(k)
       }.grep(Class).each do |klass|
         next if Nodes::SqlLiteral == klass
+        next if klass.name =~ /^Arel::Nodes::Test/
         assert klass.ancestors.include?(Nodes::Node), klass.name
       end
     end
@@ -24,5 +29,10 @@ module Arel
       node.each.each { |n| list << n }
       assert_equal [node], list
     end
+
+    def test_enumerable
+      node = Nodes::Node.new
+      assert_kind_of Enumerable, node
+    end
   end
 end

data/test/nodes/test_not.rb

@@ -6,13 +6,10 @@ module Arel
       describe '#not' do
         it 'makes a NOT node' do
           attr = Table.new(:users)[:id]
-          left  = attr.eq(10)
-          right = attr.eq(11)
-          node  = left.or right
-          node.expr.left.must_equal left
-          node.expr.right.must_equal right
-
-          node.or(right).not
+          expr  = attr.eq(10)
+          node  = expr.not
+          node.must_be_kind_of Not
+          node.expr.must_equal expr
         end
       end
     end

data/test/nodes/test_select_core.rb

@@ -1,22 +1,31 @@
 require 'helper'
 
-describe Arel::Nodes::SelectCore do
-  describe "#clone" do
-    it "clones froms, projections and wheres" do
-      core = Arel::Nodes::SelectCore.new
-      core.froms       = %w[a b c]
-      core.projections = %w[d e f]
-      core.wheres      = %w[g h i]
+module Arel
+  module Nodes
+    class TestSelectCore < MiniTest::Unit::TestCase
+      def test_clone
+        core = Arel::Nodes::SelectCore.new
+        core.froms       = %w[a b c]
+        core.projections = %w[d e f]
+        core.wheres      = %w[g h i]
 
-      dolly = core.clone
+        dolly = core.clone
 
-      dolly.froms.must_equal core.froms
-      dolly.projections.must_equal core.projections
-      dolly.wheres.must_equal core.wheres
+        dolly.froms.must_equal core.froms
+        dolly.projections.must_equal core.projections
+        dolly.wheres.must_equal core.wheres
 
-      dolly.froms.wont_be_same_as core.froms
-      dolly.projections.wont_be_same_as core.projections
-      dolly.wheres.wont_be_same_as core.wheres
+        dolly.froms.wont_be_same_as core.froms
+        dolly.projections.wont_be_same_as core.projections
+        dolly.wheres.wont_be_same_as core.wheres
+      end
+
+      def test_set_quantifier
+        core = Arel::Nodes::SelectCore.new
+        core.set_quantifier = Arel::Nodes::Distinct.new
+        viz = Arel::Visitors::ToSql.new Table.engine
+        assert_match 'DISTINCT', viz.accept(core)
+      end
     end
   end
 end

data/test/support/fake_record.rb

@@ -3,20 +3,29 @@ module FakeRecord
   end
 
   class Connection
-    attr_reader :tables
+    attr_reader :tables, :columns_hash
 
     def initialize
-      @tables = %w{ users photos developers }
+      @tables = %w{ users photos developers products}
       @columns = {
         'users' => [
           Column.new('id', :integer),
           Column.new('name', :string),
           Column.new('bool', :boolean),
-          Column.new('created_at', :date),
+          Column.new('created_at', :date)
+        ],
+        'products' => [
+          Column.new('id', :integer),
+          Column.new('price', :decimal)
         ]
       }
+      @columns_hash = {
+        'users' => Hash[@columns['users'].map { |x| [x.name, x] }],
+        'products' => Hash[@columns['products'].map { |x| [x.name, x] }]
+      }
       @primary_keys = {
-        'users' => 'id'
+        'users' => 'id',
+        'products' => 'id'
       }
     end
 
@@ -75,6 +84,14 @@ module FakeRecord
     def with_connection
       yield connection
     end
+
+    def table_exists? name
+      connection.tables.include? name.to_s
+    end
+
+    def columns_hash
+      connection.columns_hash
+    end
   end
 
   class Base

data/test/test_attributes.rb

@@ -2,6 +2,14 @@ require 'helper'
 
 module Arel
   describe 'Attributes' do
+    it 'responds to lower' do
+      relation  = Table.new(:users)
+      attribute = relation[:foo]
+      node      = attribute.lower
+      assert_equal 'LOWER', node.name
+      assert_equal [attribute], node.expressions
+    end
+
     describe 'for' do
       it 'deals with unknown column types' do
         column = Struct.new(:type).new :crazy

data/test/test_crud.rb

@@ -35,10 +35,8 @@ module Arel
         table = Table.new :users
         fc = FakeCrudder.new
         fc.from table
-        fc.insert [[table[:id], 'foo']]
-        fc.engine.calls.find { |method, _|
-          method == :insert
-        }.wont_be_nil
+        im = fc.compile_insert [[table[:id], 'foo']]
+        assert_instance_of Arel::InsertManager, im
       end
     end
 
@@ -47,10 +45,8 @@ module Arel
         table = Table.new :users
         fc = FakeCrudder.new
         fc.from table
-        fc.update [[table[:id], 'foo']]
-        fc.engine.calls.find { |method, _|
-          method == :update
-        }.wont_be_nil
+        stmt = fc.compile_update [[table[:id], 'foo']]
+        assert_instance_of Arel::UpdateManager, stmt
       end
     end
 
@@ -59,10 +55,8 @@ module Arel
         table = Table.new :users
         fc = FakeCrudder.new
         fc.from table
-        fc.delete
-        fc.engine.calls.find { |method, _|
-          method == :delete
-        }.wont_be_nil
+        stmt = fc.compile_delete
+        assert_instance_of Arel::DeleteManager, stmt
       end
     end
   end

data/test/test_factory_methods.rb

@@ -0,0 +1,34 @@
+require 'helper'
+
+module Arel
+  module FactoryMethods
+    class TestFactoryMethods < MiniTest::Unit::TestCase
+      class Factory
+        include Arel::FactoryMethods
+      end
+
+      def setup
+        @factory = Factory.new
+      end
+
+      def test_create_join
+        join = @factory.create_join :one, :two
+        assert_kind_of Nodes::Join, join
+        assert_equal :two, join.right
+      end
+
+      def test_create_on
+        on = @factory.create_on :one
+        assert_instance_of Nodes::On, on
+        assert_equal :one, on.expr
+      end
+
+      def test_lower
+        lower = @factory.lower :one
+        assert_instance_of Nodes::NamedFunction, lower
+        assert_equal 'LOWER', lower.name
+        assert_equal [:one], lower.expressions
+      end
+    end
+  end
+end

data/test/test_insert_manager.rb

@@ -9,6 +9,25 @@ module Arel
     end
 
     describe 'insert' do
+      it 'can create a Values node' do
+        table   = Table.new(:users)
+        manager = Arel::InsertManager.new Table.engine
+        values  = manager.create_values %w{ a b }, %w{ c d }
+
+        assert_kind_of Arel::Nodes::Values, values
+        assert_equal %w{ a b }, values.left
+        assert_equal %w{ c d }, values.right
+      end
+
+      it 'allows sql literals' do
+        table          = Table.new(:users)
+        manager        = Arel::InsertManager.new Table.engine
+        manager.values = manager.create_values [Arel.sql('*')], %w{ a }
+        manager.to_sql.must_be_like %{
+          INSERT INTO NULL VALUES (*)
+        }
+      end
+
       it "inserts false" do
         table = Table.new(:users)
         manager = Arel::InsertManager.new Table.engine

data/test/test_select_manager.rb

@@ -26,6 +26,21 @@ module Arel
     def quote_table_name thing; @engine.connection.quote_table_name thing end
     def quote_column_name thing; @engine.connection.quote_column_name thing end
     def quote thing, column; @engine.connection.quote thing, column end
+    def columns table, message = nil
+      @engine.connection.columns table, message
+    end
+
+    def columns_hash
+      @engine.connection.columns_hash
+    end
+
+    def table_exists? name
+      @engine.connection.table_exists? name
+    end
+
+    def tables
+      @engine.connection.tables
+    end
 
     def execute sql, name = nil, *args
       @executed << sql
@@ -36,6 +51,12 @@ module Arel
   end
 
   describe 'select manager' do
+    def test_join_sources
+      manager = Arel::SelectManager.new Table.engine
+      manager.join_sources << Arel::Nodes::StringJoin.new('foo')
+      assert_equal "SELECT FROM 'foo'", manager.to_sql
+    end
+
     describe 'backwards compatibility' do
       describe 'project' do
         it 'accepts symbols as sql literals' do
@@ -70,6 +91,34 @@ module Arel
         end
       end
 
+      describe 'as' do
+        it 'makes an AS node by grouping the AST' do
+          manager = Arel::SelectManager.new Table.engine
+          as = manager.as(Arel.sql('foo'))
+          assert_kind_of Arel::Nodes::Grouping, as.left
+          assert_equal manager.ast, as.left.expr
+          assert_equal 'foo', as.right
+        end
+
+        it 'converts right to SqlLiteral if a string' do
+          manager = Arel::SelectManager.new Table.engine
+          as = manager.as('foo')
+          assert_kind_of Arel::Nodes::SqlLiteral, as.right
+        end
+
+        it 'can make a subselect' do
+          manager = Arel::SelectManager.new Table.engine
+          manager.project Arel.star
+          manager.from Arel.sql('zomg')
+          as = manager.as(Arel.sql('foo'))
+
+          manager = Arel::SelectManager.new Table.engine
+          manager.project Arel.sql('name')
+          manager.from as
+          manager.to_sql.must_be_like "SELECT name FROM (SELECT * FROM zomg ) foo"
+        end
+      end
+
       describe 'from' do
         it 'ignores strings when table of same name exists' do
           table   = Table.new :users
@@ -80,15 +129,47 @@ module Arel
           manager.project table['id']
           manager.to_sql.must_be_like 'SELECT "users"."id" FROM users'
         end
+
+        it 'should support any ast' do
+          table   = Table.new :users
+          manager1 = Arel::SelectManager.new Table.engine
+
+          manager2 = Arel::SelectManager.new Table.engine
+          manager2.project(Arel.sql('*'))
+          manager2.from table
+
+          manager1.project Arel.sql('lol')
+          as = manager2.as Arel.sql('omg')
+          manager1.from(as)
+
+          manager1.to_sql.must_be_like %{
+            SELECT lol FROM (SELECT * FROM "users" ) omg
+          }
+        end
       end
 
-      describe '#having' do
+      describe 'having' do
         it 'converts strings to SQLLiterals' do
           table   = Table.new :users
           mgr = table.from table
           mgr.having 'foo'
           mgr.to_sql.must_be_like %{ SELECT FROM "users" HAVING foo }
         end
+
+        it 'can have multiple items specified separately' do
+          table = Table.new :users
+          mgr = table.from table
+          mgr.having 'foo'
+          mgr.having 'bar'
+          mgr.to_sql.must_be_like %{ SELECT FROM "users" HAVING foo AND bar }
+        end
+
+        it 'can have multiple items specified together' do
+          table = Table.new :users
+          mgr = table.from table
+          mgr.having 'foo', 'bar'
+          mgr.to_sql.must_be_like %{ SELECT FROM "users" HAVING foo AND bar }
+        end
       end
 
       describe 'on' do
@@ -118,6 +199,16 @@ module Arel
         m2.project "foo"
         mgr.to_sql.wont_equal m2.to_sql
       end
+
+      it 'makes updates to the correct copy' do
+        table   = Table.new :users, :engine => Table.engine, :as => 'foo'
+        mgr = table.from table
+        m2 = mgr.clone
+        m3 = m2.clone
+        m2.project "foo"
+        mgr.to_sql.wont_equal m2.to_sql
+        m3.to_sql.must_equal mgr.to_sql
+      end
     end
 
     describe 'initialize' do
@@ -125,7 +216,7 @@ module Arel
         table   = Table.new :users, :engine => Table.engine, :as => 'foo'
         mgr = table.from table
         mgr.skip 10
-        mgr.to_sql.must_be_like %{ SELECT FROM "users" "foo" OFFSET 10 }
+        mgr.to_sql.must_be_like %{ SELECT FROM "users" foo OFFSET 10 }
       end
     end
 
@@ -144,6 +235,32 @@ module Arel
       end
     end
 
+    describe 'offset' do
+      it 'should add an offset' do
+        table   = Table.new :users
+        mgr = table.from table
+        mgr.offset = 10
+        mgr.to_sql.must_be_like %{ SELECT FROM "users" OFFSET 10 }
+      end
+
+      it 'should remove an offset' do
+        table   = Table.new :users
+        mgr = table.from table
+        mgr.offset = 10
+        mgr.to_sql.must_be_like %{ SELECT FROM "users" OFFSET 10 }
+
+        mgr.offset = nil
+        mgr.to_sql.must_be_like %{ SELECT FROM "users" }
+      end
+
+      it 'should return the offset' do
+        table   = Table.new :users
+        mgr = table.from table
+        mgr.offset = 10
+        assert_equal 10, mgr.offset
+      end
+    end
+
     describe 'exists' do
       it 'should create an exists clause' do
         table = Table.new(:users)
@@ -164,6 +281,130 @@ module Arel
       end
     end
 
+    describe 'union' do
+      before do
+        table = Table.new :users
+        @m1 = Arel::SelectManager.new Table.engine, table
+        @m1.project Arel.star
+        @m1.where(table[:age].lt(18))
+
+        @m2 = Arel::SelectManager.new Table.engine, table
+        @m2.project Arel.star
+        @m2.where(table[:age].gt(99))
+
+
+      end
+
+      it 'should union two managers' do
+        # FIXME should this union "managers" or "statements" ?
+        # FIXME this probably shouldn't return a node
+        node = @m1.union @m2
+
+        # maybe FIXME: decide when wrapper parens are needed
+        node.to_sql.must_be_like %{
+          ( SELECT * FROM "users"  WHERE "users"."age" < 18 UNION SELECT * FROM "users"  WHERE "users"."age" > 99 )
+        }
+      end
+
+      it 'should union all' do
+        node = @m1.union :all, @m2
+
+        node.to_sql.must_be_like %{
+          ( SELECT * FROM "users"  WHERE "users"."age" < 18 UNION ALL SELECT * FROM "users"  WHERE "users"."age" > 99 )
+        }
+      end
+
+    end
+
+    describe 'intersect' do
+      before do
+        table = Table.new :users
+        @m1 = Arel::SelectManager.new Table.engine, table
+        @m1.project Arel.star
+        @m1.where(table[:age].gt(18))
+
+        @m2 = Arel::SelectManager.new Table.engine, table
+        @m2.project Arel.star
+        @m2.where(table[:age].lt(99))
+
+
+      end
+
+      it 'should interect two managers' do
+        # FIXME should this intersect "managers" or "statements" ?
+        # FIXME this probably shouldn't return a node
+        node = @m1.intersect @m2
+
+        # maybe FIXME: decide when wrapper parens are needed
+        node.to_sql.must_be_like %{
+          ( SELECT * FROM "users"  WHERE "users"."age" > 18 INTERSECT SELECT * FROM "users"  WHERE "users"."age" < 99 )
+        }
+      end
+
+    end
+
+    describe 'except' do
+      before do
+        table = Table.new :users
+        @m1 = Arel::SelectManager.new Table.engine, table
+        @m1.project Arel.star
+        @m1.where(table[:age].in(18..60))
+
+        @m2 = Arel::SelectManager.new Table.engine, table
+        @m2.project Arel.star
+        @m2.where(table[:age].in(40..99))
+
+
+      end
+
+      it 'should except two managers' do
+        # FIXME should this except "managers" or "statements" ?
+        # FIXME this probably shouldn't return a node
+        node = @m1.except @m2
+
+        # maybe FIXME: decide when wrapper parens are needed
+        node.to_sql.must_be_like %{
+          ( SELECT * FROM "users"  WHERE "users"."age" BETWEEN 18 AND 60 EXCEPT SELECT * FROM "users"  WHERE "users"."age" BETWEEN 40 AND 99 )
+        }
+      end
+
+    end
+
+    describe 'with' do
+
+      it "should support WITH RECURSIVE" do
+        comments           = Table.new(:comments)
+        comments_id        = comments[:id]
+        comments_parent_id = comments[:parent_id]
+
+        replies            = Table.new(:replies)
+        replies_id         = replies[:id]
+
+        recursive_term = Arel::SelectManager.new Table.engine
+        recursive_term.from(comments).project(comments_id, comments_parent_id).where(comments_id.eq 42)
+
+        non_recursive_term = Arel::SelectManager.new Table.engine
+        non_recursive_term.from(comments).project(comments_id, comments_parent_id).join(replies).on(comments_parent_id.eq replies_id)
+
+        union = recursive_term.union(non_recursive_term)
+
+        as_statement = Arel::Nodes::As.new replies, union
+
+        manager = Arel::SelectManager.new Table.engine
+        manager.with(:recursive, as_statement).from(replies).project(Arel.star)
+
+        sql = manager.to_sql
+        sql.must_be_like %{
+          WITH RECURSIVE "replies" AS (
+              SELECT "comments"."id", "comments"."parent_id" FROM "comments" WHERE "comments"."id" = 42
+            UNION
+              SELECT "comments"."id", "comments"."parent_id" FROM "comments" INNER JOIN "replies" ON "comments"."parent_id" = "replies"."id"
+          )
+          SELECT * FROM "replies"
+        }
+      end
+    end
+
     describe 'ast' do
       it 'should return the ast' do
         table   = Table.new :users
@@ -243,6 +484,29 @@ module Arel
         manager = Arel::SelectManager.new Table.engine
         manager.order(table[:id]).must_equal manager
       end
+
+      it 'has order attributes' do
+        table   = Table.new :users
+        manager = Arel::SelectManager.new Table.engine
+        manager.project SqlLiteral.new '*'
+        manager.from table
+        manager.order table[:id].desc
+        manager.to_sql.must_be_like %{
+          SELECT * FROM "users" ORDER BY "users"."id" DESC
+        }
+      end
+
+      it 'has order attributes for expressions' do
+        table   = Table.new :users
+        manager = Arel::SelectManager.new Table.engine
+        manager.project SqlLiteral.new '*'
+        manager.from table
+        manager.order table[:id].count.desc
+        manager.to_sql.must_be_like %{
+          SELECT * FROM "users" ORDER BY COUNT("users"."id") DESC
+        }
+      end
+
     end
 
     describe 'on' do
@@ -284,6 +548,41 @@ module Arel
       end
     end
 
+    it 'should hand back froms' do
+      relation = Arel::SelectManager.new Table.engine
+      assert_equal [], relation.froms
+    end
+
+    it 'should create and nodes' do
+      relation = Arel::SelectManager.new Table.engine
+      children = ['foo', 'bar', 'baz']
+      clause = relation.create_and children
+      assert_kind_of Arel::Nodes::And, clause
+      assert_equal children, clause.children
+    end
+
+    it 'should create insert managers' do
+      relation = Arel::SelectManager.new Table.engine
+      insert = relation.create_insert
+      assert_kind_of Arel::InsertManager, insert
+    end
+
+    it 'should create join nodes' do
+      relation = Arel::SelectManager.new Table.engine
+      join = relation.create_join 'foo', 'bar'
+      assert_kind_of Arel::Nodes::InnerJoin, join
+      assert_equal 'foo', join.left
+      assert_equal 'bar', join.right
+    end
+
+    it 'should create join nodes with a klass' do
+      relation = Arel::SelectManager.new Table.engine
+      join = relation.create_join 'foo', 'bar', Arel::Nodes::OuterJoin
+      assert_kind_of Arel::Nodes::OuterJoin, join
+      assert_equal 'foo', join.left
+      assert_equal 'bar', join.right
+    end
+
     describe 'join' do
       it 'responds to join' do
         left      = Table.new :users
@@ -326,30 +625,27 @@ module Arel
         table   = Table.new :users
         aliaz   = table.alias
         manager = Arel::SelectManager.new Table.engine
-        manager.from Nodes::InnerJoin.new(table, aliaz, table[:id].eq(aliaz[:id]))
+        manager.from Nodes::InnerJoin.new(aliaz, table[:id].eq(aliaz[:id]))
         manager.join_sql.must_be_like %{
           INNER JOIN "users" "users_2" "users"."id" = "users_2"."id"
         }
-        manager.joins(manager).must_equal manager.join_sql
       end
 
       it 'returns outer join sql' do
         table   = Table.new :users
         aliaz   = table.alias
         manager = Arel::SelectManager.new Table.engine
-        manager.from Nodes::OuterJoin.new(table, aliaz, table[:id].eq(aliaz[:id]))
+        manager.from Nodes::OuterJoin.new(aliaz, table[:id].eq(aliaz[:id]))
         manager.join_sql.must_be_like %{
           LEFT OUTER JOIN "users" "users_2" "users"."id" = "users_2"."id"
         }
-        manager.joins(manager).must_equal manager.join_sql
       end
 
       it 'returns string join sql' do
         table   = Table.new :users
         manager = Arel::SelectManager.new Table.engine
-        manager.from Nodes::StringJoin.new(table, 'hello')
+        manager.from Nodes::StringJoin.new('hello')
         manager.join_sql.must_be_like %{ 'hello' }
-        manager.joins(manager).must_equal manager.join_sql
       end
 
       it 'returns nil join sql' do
@@ -411,9 +707,9 @@ module Arel
         table   = Table.new :users
         manager = Arel::SelectManager.new engine
         manager.from table
-        manager.delete
+        stmt = manager.compile_delete
 
-        engine.executed.last.must_be_like %{ DELETE FROM "users" }
+        stmt.to_sql.must_be_like %{ DELETE FROM "users" }
       end
 
       it "copies where" do
@@ -422,9 +718,9 @@ module Arel
         manager = Arel::SelectManager.new engine
         manager.from table
         manager.where table[:id].eq 10
-        manager.delete
+        stmt = manager.compile_delete
 
-        engine.executed.last.must_be_like %{
+        stmt.to_sql.must_be_like %{
           DELETE FROM "users" WHERE "users"."id" = 10
         }
       end
@@ -454,9 +750,10 @@ module Arel
         manager = Arel::SelectManager.new engine
         manager.from table
         manager.take 1
-        manager.update(SqlLiteral.new('foo = bar'))
+        stmt = manager.compile_update(SqlLiteral.new('foo = bar'))
+        stmt.key = table['id']
 
-        engine.executed.last.must_be_like %{
+        stmt.to_sql.must_be_like %{
           UPDATE "users" SET foo = bar
           WHERE "users"."id" IN (SELECT "users"."id" FROM "users" LIMIT 1)
         }
@@ -468,9 +765,10 @@ module Arel
         manager = Arel::SelectManager.new engine
         manager.from table
         manager.order :foo
-        manager.update(SqlLiteral.new('foo = bar'))
+        stmt = manager.compile_update(SqlLiteral.new('foo = bar'))
+        stmt.key = table['id']
 
-        engine.executed.last.must_be_like %{
+        stmt.to_sql.must_be_like %{
           UPDATE "users" SET foo = bar
           WHERE "users"."id" IN (SELECT "users"."id" FROM "users" ORDER BY foo)
         }
@@ -481,9 +779,9 @@ module Arel
         table   = Table.new :users
         manager = Arel::SelectManager.new engine
         manager.from table
-        manager.update(SqlLiteral.new('foo = bar'))
+        stmt = manager.compile_update(SqlLiteral.new('foo = bar'))
 
-        engine.executed.last.must_be_like %{ UPDATE "users" SET foo = bar }
+        stmt.to_sql.must_be_like %{ UPDATE "users" SET foo = bar }
       end
 
       it 'copies where clauses' do
@@ -492,21 +790,35 @@ module Arel
         manager = Arel::SelectManager.new engine
         manager.where table[:id].eq 10
         manager.from table
-        manager.update(table[:id] => 1)
+        stmt = manager.compile_update(table[:id] => 1)
 
-        engine.executed.last.must_be_like %{
+        stmt.to_sql.must_be_like %{
           UPDATE "users" SET "id" = 1 WHERE "users"."id" = 10
         }
       end
 
+      it 'copies where clauses when nesting is triggered' do
+        engine  = EngineProxy.new Table.engine
+        table   = Table.new :users
+        manager = Arel::SelectManager.new engine
+        manager.where table[:foo].eq 10
+        manager.take 42
+        manager.from table
+        stmt = manager.compile_update(table[:id] => 1)
+
+        stmt.to_sql.must_be_like %{
+          UPDATE "users" SET "id" = 1 WHERE "users"."id" IN (SELECT "users"."id" FROM "users" WHERE "users"."foo" = 10 LIMIT 42)
+        }
+      end
+
       it 'executes an update statement' do
         engine  = EngineProxy.new Table.engine
         table   = Table.new :users
         manager = Arel::SelectManager.new engine
         manager.from table
-        manager.update(table[:id] => 1)
+        stmt = manager.compile_update(table[:id] => 1)
 
-        engine.executed.last.must_be_like %{
+        stmt.to_sql.must_be_like %{
           UPDATE "users" SET "id" = 1
         }
       end
@@ -555,6 +867,15 @@ module Arel
         manager = Arel::SelectManager.new Table.engine
         manager.take(1).must_equal manager
       end
+
+      it 'removes LIMIT when nil is passed' do
+        manager = Arel::SelectManager.new Table.engine
+        manager.limit = 10
+        assert_match('LIMIT', manager.to_sql)
+
+        manager.limit = nil
+        refute_match('LIMIT', manager.to_sql)
+      end
     end
 
     describe 'where' do
@@ -614,46 +935,4 @@ module Arel
       end
     end
   end
-
-  describe 'set operations' do
-    before do
-      @table = Table.new :users
-      @m1 = Arel::SelectManager.new Table.engine, @table
-      @m1.project Arel.sql('*')
-      @m2 = Arel::SelectManager.new Table.engine, @table
-      @m2.project Arel.sql('*')
-    end
-
-    it 'supports union' do
-      @m1.where(@table[:id].lt(18))
-      @m2.where(@table[:id].gt(99))
-      (@m1.union @m2).to_sql.must_be_like %{
-        ( SELECT * FROM "users"  WHERE "users"."id" < 18 UNION SELECT * FROM "users"  WHERE "users"."id" > 99 )
-      }
-    end
-
-    it 'supports union all' do
-      @m1.where(@table[:id].lt(18))
-      @m2.where(@table[:id].gt(99))
-      (@m1.union :all, @m2).to_sql.must_be_like %{
-        ( SELECT * FROM "users"  WHERE "users"."id" < 18 UNION ALL SELECT * FROM "users"  WHERE "users"."id" > 99 )
-      }
-    end
-
-    it 'supports intersect' do
-      @m1.where(@table[:id].gt(18))
-      @m2.where(@table[:id].lt(99))
-      (@m1.intersect @m2).to_sql.must_be_like %{
-        ( SELECT * FROM "users"  WHERE "users"."id" > 18 INTERSECT SELECT * FROM "users"  WHERE "users"."id" < 99 )
-      }
-    end
-
-    it 'supports except' do
-      @m1.where(@table[:id].in(18..60))
-      @m2.where(@table[:id].in(40..99))
-      (@m1.except @m2).to_sql.must_be_like %{
-        ( SELECT * FROM "users"  WHERE "users"."id" BETWEEN 18 AND 60 EXCEPT SELECT * FROM "users"  WHERE "users"."id" BETWEEN 40 AND 99 )
-      }
-    end
-  end
 end