Merge Arel into Active Record

60 files changed, 6722 insertions, 0 deletions

diff --git a/activerecord/test/cases/arel/attributes/attribute_test.rb b/activerecord/test/cases/arel/attributes/attribute_test.rb
new file mode 100644
index 0000000000..802d6e743f
--- /dev/null
+++ b/activerecord/test/cases/arel/attributes/attribute_test.rb
@@ -0,0 +1,1014 @@
+# frozen_string_literal: true
+require_relative '../helper'
+require 'ostruct'
+
+module Arel
+  module Attributes
+    class AttributeTest < Arel::Spec
+      describe '#not_eq' do
+        it 'should create a NotEqual node' do
+          relation = Table.new(:users)
+          relation[:id].not_eq(10).must_be_kind_of Nodes::NotEqual
+        end
+
+        it 'should generate != in sql' do
+          relation = Table.new(:users)
+          mgr = relation.project relation[:id]
+          mgr.where relation[:id].not_eq(10)
+          mgr.to_sql.must_be_like %{
+            SELECT "users"."id" FROM "users" WHERE "users"."id" != 10
+          }
+        end
+
+        it 'should handle nil' do
+          relation = Table.new(:users)
+          mgr = relation.project relation[:id]
+          mgr.where relation[:id].not_eq(nil)
+          mgr.to_sql.must_be_like %{
+            SELECT "users"."id" FROM "users" WHERE "users"."id" IS NOT NULL
+          }
+        end
+      end
+
+      describe '#not_eq_any' do
+        it 'should create a Grouping node' do
+          relation = Table.new(:users)
+          relation[:id].not_eq_any([1,2]).must_be_kind_of Nodes::Grouping
+        end
+
+        it 'should generate ORs in sql' do
+          relation = Table.new(:users)
+          mgr = relation.project relation[:id]
+          mgr.where relation[:id].not_eq_any([1,2])
+          mgr.to_sql.must_be_like %{
+            SELECT "users"."id" FROM "users" WHERE ("users"."id" != 1 OR "users"."id" != 2)
+          }
+        end
+      end
+
+      describe '#not_eq_all' do
+        it 'should create a Grouping node' do
+          relation = Table.new(:users)
+          relation[:id].not_eq_all([1,2]).must_be_kind_of Nodes::Grouping
+        end
+
+        it 'should generate ANDs in sql' do
+          relation = Table.new(:users)
+          mgr = relation.project relation[:id]
+          mgr.where relation[:id].not_eq_all([1,2])
+          mgr.to_sql.must_be_like %{
+            SELECT "users"."id" FROM "users" WHERE ("users"."id" != 1 AND "users"."id" != 2)
+          }
+        end
+      end
+
+      describe '#gt' do
+        it 'should create a GreaterThan node' do
+          relation = Table.new(:users)
+          relation[:id].gt(10).must_be_kind_of Nodes::GreaterThan
+        end
+
+        it 'should generate > in sql' do
+          relation = Table.new(:users)
+          mgr = relation.project relation[:id]
+          mgr.where relation[:id].gt(10)
+          mgr.to_sql.must_be_like %{
+            SELECT "users"."id" FROM "users" WHERE "users"."id" > 10
+          }
+        end
+
+        it 'should handle comparing with a subquery' do
+          users = Table.new(:users)
+
+          avg = users.project(users[:karma].average)
+          mgr = users.project(Arel.star).where(users[:karma].gt(avg))
+
+          mgr.to_sql.must_be_like %{
+            SELECT * FROM "users" WHERE "users"."karma" > (SELECT AVG("users"."karma") FROM "users")
+          }
+        end
+
+        it 'should accept various data types.' do
+          relation = Table.new(:users)
+          mgr = relation.project relation[:id]
+          mgr.where relation[:name].gt('fake_name')
+          mgr.to_sql.must_match %{"users"."name" > 'fake_name'}
+
+          current_time = ::Time.now
+          mgr.where relation[:created_at].gt(current_time)
+          mgr.to_sql.must_match %{"users"."created_at" > '#{current_time}'}
+        end
+      end
+
+      describe '#gt_any' do
+        it 'should create a Grouping node' do
+          relation = Table.new(:users)
+          relation[:id].gt_any([1,2]).must_be_kind_of Nodes::Grouping
+        end
+
+        it 'should generate ORs in sql' do
+          relation = Table.new(:users)
+          mgr = relation.project relation[:id]
+          mgr.where relation[:id].gt_any([1,2])
+          mgr.to_sql.must_be_like %{
+            SELECT "users"."id" FROM "users" WHERE ("users"."id" > 1 OR "users"."id" > 2)
+          }
+        end
+      end
+
+      describe '#gt_all' do
+        it 'should create a Grouping node' do
+          relation = Table.new(:users)
+          relation[:id].gt_all([1,2]).must_be_kind_of Nodes::Grouping
+        end
+
+        it 'should generate ANDs in sql' do
+          relation = Table.new(:users)
+          mgr = relation.project relation[:id]
+          mgr.where relation[:id].gt_all([1,2])
+          mgr.to_sql.must_be_like %{
+            SELECT "users"."id" FROM "users" WHERE ("users"."id" > 1 AND "users"."id" > 2)
+          }
+        end
+      end
+
+      describe '#gteq' do
+        it 'should create a GreaterThanOrEqual node' do
+          relation = Table.new(:users)
+          relation[:id].gteq(10).must_be_kind_of Nodes::GreaterThanOrEqual
+        end
+
+        it 'should generate >= in sql' do
+          relation = Table.new(:users)
+          mgr = relation.project relation[:id]
+          mgr.where relation[:id].gteq(10)
+          mgr.to_sql.must_be_like %{
+            SELECT "users"."id" FROM "users" WHERE "users"."id" >= 10
+          }
+        end
+
+        it 'should accept various data types.' do
+          relation = Table.new(:users)
+          mgr = relation.project relation[:id]
+          mgr.where relation[:name].gteq('fake_name')
+          mgr.to_sql.must_match %{"users"."name" >= 'fake_name'}
+
+          current_time = ::Time.now
+          mgr.where relation[:created_at].gteq(current_time)
+          mgr.to_sql.must_match %{"users"."created_at" >= '#{current_time}'}
+        end
+      end
+
+      describe '#gteq_any' do
+        it 'should create a Grouping node' do
+          relation = Table.new(:users)
+          relation[:id].gteq_any([1,2]).must_be_kind_of Nodes::Grouping
+        end
+
+        it 'should generate ORs in sql' do
+          relation = Table.new(:users)
+          mgr = relation.project relation[:id]
+          mgr.where relation[:id].gteq_any([1,2])
+          mgr.to_sql.must_be_like %{
+            SELECT "users"."id" FROM "users" WHERE ("users"."id" >= 1 OR "users"."id" >= 2)
+          }
+        end
+      end
+
+      describe '#gteq_all' do
+        it 'should create a Grouping node' do
+          relation = Table.new(:users)
+          relation[:id].gteq_all([1,2]).must_be_kind_of Nodes::Grouping
+        end
+
+        it 'should generate ANDs in sql' do
+          relation = Table.new(:users)
+          mgr = relation.project relation[:id]
+          mgr.where relation[:id].gteq_all([1,2])
+          mgr.to_sql.must_be_like %{
+            SELECT "users"."id" FROM "users" WHERE ("users"."id" >= 1 AND "users"."id" >= 2)
+          }
+        end
+      end
+
+      describe '#lt' do
+        it 'should create a LessThan node' do
+          relation = Table.new(:users)
+          relation[:id].lt(10).must_be_kind_of Nodes::LessThan
+        end
+
+        it 'should generate < in sql' do
+          relation = Table.new(:users)
+          mgr = relation.project relation[:id]
+          mgr.where relation[:id].lt(10)
+          mgr.to_sql.must_be_like %{
+            SELECT "users"."id" FROM "users" WHERE "users"."id" < 10
+          }
+        end
+
+        it 'should accept various data types.' do
+          relation = Table.new(:users)
+          mgr = relation.project relation[:id]
+          mgr.where relation[:name].lt('fake_name')
+          mgr.to_sql.must_match %{"users"."name" < 'fake_name'}
+
+          current_time = ::Time.now
+          mgr.where relation[:created_at].lt(current_time)
+          mgr.to_sql.must_match %{"users"."created_at" < '#{current_time}'}
+        end
+      end
+
+      describe '#lt_any' do
+        it 'should create a Grouping node' do
+          relation = Table.new(:users)
+          relation[:id].lt_any([1,2]).must_be_kind_of Nodes::Grouping
+        end
+
+        it 'should generate ORs in sql' do
+          relation = Table.new(:users)
+          mgr = relation.project relation[:id]
+          mgr.where relation[:id].lt_any([1,2])
+          mgr.to_sql.must_be_like %{
+            SELECT "users"."id" FROM "users" WHERE ("users"."id" < 1 OR "users"."id" < 2)
+          }
+        end
+      end
+
+      describe '#lt_all' do
+        it 'should create a Grouping node' do
+          relation = Table.new(:users)
+          relation[:id].lt_all([1,2]).must_be_kind_of Nodes::Grouping
+        end
+
+        it 'should generate ANDs in sql' do
+          relation = Table.new(:users)
+          mgr = relation.project relation[:id]
+          mgr.where relation[:id].lt_all([1,2])
+          mgr.to_sql.must_be_like %{
+            SELECT "users"."id" FROM "users" WHERE ("users"."id" < 1 AND "users"."id" < 2)
+          }
+        end
+      end
+
+      describe '#lteq' do
+        it 'should create a LessThanOrEqual node' do
+          relation = Table.new(:users)
+          relation[:id].lteq(10).must_be_kind_of Nodes::LessThanOrEqual
+        end
+
+        it 'should generate <= in sql' do
+          relation = Table.new(:users)
+          mgr = relation.project relation[:id]
+          mgr.where relation[:id].lteq(10)
+          mgr.to_sql.must_be_like %{
+            SELECT "users"."id" FROM "users" WHERE "users"."id" <= 10
+          }
+        end
+
+        it 'should accept various data types.' do
+          relation = Table.new(:users)
+          mgr = relation.project relation[:id]
+          mgr.where relation[:name].lteq('fake_name')
+          mgr.to_sql.must_match %{"users"."name" <= 'fake_name'}
+
+          current_time = ::Time.now
+          mgr.where relation[:created_at].lteq(current_time)
+          mgr.to_sql.must_match %{"users"."created_at" <= '#{current_time}'}
+        end
+      end
+
+      describe '#lteq_any' do
+        it 'should create a Grouping node' do
+          relation = Table.new(:users)
+          relation[:id].lteq_any([1,2]).must_be_kind_of Nodes::Grouping
+        end
+
+        it 'should generate ORs in sql' do
+          relation = Table.new(:users)
+          mgr = relation.project relation[:id]
+          mgr.where relation[:id].lteq_any([1,2])
+          mgr.to_sql.must_be_like %{
+            SELECT "users"."id" FROM "users" WHERE ("users"."id" <= 1 OR "users"."id" <= 2)
+          }
+        end
+      end
+
+      describe '#lteq_all' do
+        it 'should create a Grouping node' do
+          relation = Table.new(:users)
+          relation[:id].lteq_all([1,2]).must_be_kind_of Nodes::Grouping
+        end
+
+        it 'should generate ANDs in sql' do
+          relation = Table.new(:users)
+          mgr = relation.project relation[:id]
+          mgr.where relation[:id].lteq_all([1,2])
+          mgr.to_sql.must_be_like %{
+            SELECT "users"."id" FROM "users" WHERE ("users"."id" <= 1 AND "users"."id" <= 2)
+          }
+        end
+      end
+
+      describe '#average' do
+        it 'should create a AVG node' do
+          relation = Table.new(:users)
+          relation[:id].average.must_be_kind_of Nodes::Avg
+        end
+
+        it 'should generate the proper SQL' do
+          relation = Table.new(:users)
+          mgr = relation.project relation[:id].average
+          mgr.to_sql.must_be_like %{
+            SELECT AVG("users"."id")
+            FROM "users"
+          }
+        end
+      end
+
+      describe '#maximum' do
+        it 'should create a MAX node' do
+          relation = Table.new(:users)
+          relation[:id].maximum.must_be_kind_of Nodes::Max
+        end
+
+        it 'should generate proper SQL' do
+          relation = Table.new(:users)
+          mgr = relation.project relation[:id].maximum
+          mgr.to_sql.must_be_like %{
+            SELECT MAX("users"."id")
+            FROM "users"
+          }
+        end
+      end
+
+      describe '#minimum' do
+        it 'should create a Min node' do
+          relation = Table.new(:users)
+          relation[:id].minimum.must_be_kind_of Nodes::Min
+        end
+
+        it 'should generate proper SQL' do
+          relation = Table.new(:users)
+          mgr = relation.project relation[:id].minimum
+          mgr.to_sql.must_be_like %{
+            SELECT MIN("users"."id")
+            FROM "users"
+          }
+        end
+      end
+
+      describe '#sum' do
+        it 'should create a SUM node' do
+          relation = Table.new(:users)
+          relation[:id].sum.must_be_kind_of Nodes::Sum
+        end
+
+        it 'should generate the proper SQL' do
+          relation = Table.new(:users)
+          mgr = relation.project relation[:id].sum
+          mgr.to_sql.must_be_like %{
+            SELECT SUM("users"."id")
+            FROM "users"
+          }
+        end
+      end
+
+      describe '#count' do
+        it 'should return a count node' do
+          relation = Table.new(:users)
+          relation[:id].count.must_be_kind_of Nodes::Count
+        end
+
+        it 'should take a distinct param' do
+          relation = Table.new(:users)
+          count = relation[:id].count(nil)
+          count.must_be_kind_of Nodes::Count
+          count.distinct.must_be_nil
+        end
+      end
+
+      describe '#eq' do
+        it 'should return an equality node' do
+          attribute = Attribute.new nil, nil
+          equality = attribute.eq 1
+          equality.left.must_equal attribute
+          equality.right.val.must_equal 1
+          equality.must_be_kind_of Nodes::Equality
+        end
+
+        it 'should generate = in sql' do
+          relation = Table.new(:users)
+          mgr = relation.project relation[:id]
+          mgr.where relation[:id].eq(10)
+          mgr.to_sql.must_be_like %{
+            SELECT "users"."id" FROM "users" WHERE "users"."id" = 10
+          }
+        end
+
+        it 'should handle nil' do
+          relation = Table.new(:users)
+          mgr = relation.project relation[:id]
+          mgr.where relation[:id].eq(nil)
+          mgr.to_sql.must_be_like %{
+            SELECT "users"."id" FROM "users" WHERE "users"."id" IS NULL
+          }
+        end
+      end
+
+      describe '#eq_any' do
+        it 'should create a Grouping node' do
+          relation = Table.new(:users)
+          relation[:id].eq_any([1,2]).must_be_kind_of Nodes::Grouping
+        end
+
+        it 'should generate ORs in sql' do
+          relation = Table.new(:users)
+          mgr = relation.project relation[:id]
+          mgr.where relation[:id].eq_any([1,2])
+          mgr.to_sql.must_be_like %{
+            SELECT "users"."id" FROM "users" WHERE ("users"."id" = 1 OR "users"."id" = 2)
+          }
+        end
+
+        it 'should not eat input' do
+          relation = Table.new(:users)
+          mgr = relation.project relation[:id]
+          values = [1,2]
+          mgr.where relation[:id].eq_any(values)
+          values.must_equal [1,2]
+        end
+      end
+
+      describe '#eq_all' do
+        it 'should create a Grouping node' do
+          relation = Table.new(:users)
+          relation[:id].eq_all([1,2]).must_be_kind_of Nodes::Grouping
+        end
+
+        it 'should generate ANDs in sql' do
+          relation = Table.new(:users)
+          mgr = relation.project relation[:id]
+          mgr.where relation[:id].eq_all([1,2])
+          mgr.to_sql.must_be_like %{
+            SELECT "users"."id" FROM "users" WHERE ("users"."id" = 1 AND "users"."id" = 2)
+          }
+        end
+
+        it 'should not eat input' do
+          relation = Table.new(:users)
+          mgr = relation.project relation[:id]
+          values = [1,2]
+          mgr.where relation[:id].eq_all(values)
+          values.must_equal [1,2]
+        end
+      end
+
+      describe '#matches' do
+        it 'should create a Matches node' do
+          relation = Table.new(:users)
+          relation[:name].matches('%bacon%').must_be_kind_of Nodes::Matches
+        end
+
+        it 'should generate LIKE in sql' do
+          relation = Table.new(:users)
+          mgr = relation.project relation[:id]
+          mgr.where relation[:name].matches('%bacon%')
+          mgr.to_sql.must_be_like %{
+            SELECT "users"."id" FROM "users" WHERE "users"."name" LIKE '%bacon%'
+          }
+        end
+      end
+
+      describe '#matches_any' do
+        it 'should create a Grouping node' do
+          relation = Table.new(:users)
+          relation[:name].matches_any(['%chunky%','%bacon%']).must_be_kind_of Nodes::Grouping
+        end
+
+        it 'should generate ORs in sql' do
+          relation = Table.new(:users)
+          mgr = relation.project relation[:id]
+          mgr.where relation[:name].matches_any(['%chunky%','%bacon%'])
+          mgr.to_sql.must_be_like %{
+            SELECT "users"."id" FROM "users" WHERE ("users"."name" LIKE '%chunky%' OR "users"."name" LIKE '%bacon%')
+          }
+        end
+      end
+
+      describe '#matches_all' do
+        it 'should create a Grouping node' do
+          relation = Table.new(:users)
+          relation[:name].matches_all(['%chunky%','%bacon%']).must_be_kind_of Nodes::Grouping
+        end
+
+        it 'should generate ANDs in sql' do
+          relation = Table.new(:users)
+          mgr = relation.project relation[:id]
+          mgr.where relation[:name].matches_all(['%chunky%','%bacon%'])
+          mgr.to_sql.must_be_like %{
+            SELECT "users"."id" FROM "users" WHERE ("users"."name" LIKE '%chunky%' AND "users"."name" LIKE '%bacon%')
+          }
+        end
+      end
+
+      describe '#does_not_match' do
+        it 'should create a DoesNotMatch node' do
+          relation = Table.new(:users)
+          relation[:name].does_not_match('%bacon%').must_be_kind_of Nodes::DoesNotMatch
+        end
+
+        it 'should generate NOT LIKE in sql' do
+          relation = Table.new(:users)
+          mgr = relation.project relation[:id]
+          mgr.where relation[:name].does_not_match('%bacon%')
+          mgr.to_sql.must_be_like %{
+            SELECT "users"."id" FROM "users" WHERE "users"."name" NOT LIKE '%bacon%'
+          }
+        end
+      end
+
+      describe '#does_not_match_any' do
+        it 'should create a Grouping node' do
+          relation = Table.new(:users)
+          relation[:name].does_not_match_any(['%chunky%','%bacon%']).must_be_kind_of Nodes::Grouping
+        end
+
+        it 'should generate ORs in sql' do
+          relation = Table.new(:users)
+          mgr = relation.project relation[:id]
+          mgr.where relation[:name].does_not_match_any(['%chunky%','%bacon%'])
+          mgr.to_sql.must_be_like %{
+            SELECT "users"."id" FROM "users" WHERE ("users"."name" NOT LIKE '%chunky%' OR "users"."name" NOT LIKE '%bacon%')
+          }
+        end
+      end
+
+      describe '#does_not_match_all' do
+        it 'should create a Grouping node' do
+          relation = Table.new(:users)
+          relation[:name].does_not_match_all(['%chunky%','%bacon%']).must_be_kind_of Nodes::Grouping
+        end
+
+        it 'should generate ANDs in sql' do
+          relation = Table.new(:users)
+          mgr = relation.project relation[:id]
+          mgr.where relation[:name].does_not_match_all(['%chunky%','%bacon%'])
+          mgr.to_sql.must_be_like %{
+            SELECT "users"."id" FROM "users" WHERE ("users"."name" NOT LIKE '%chunky%' AND "users"."name" NOT LIKE '%bacon%')
+          }
+        end
+      end
+
+      describe 'with a range' do
+        it 'can be constructed with a standard range' do
+          attribute = Attribute.new nil, nil
+          node = attribute.between(1..3)
+
+          node.must_equal Nodes::Between.new(
+            attribute,
+            Nodes::And.new([
+              Nodes::Casted.new(1, attribute),
+              Nodes::Casted.new(3, attribute)
+            ])
+          )
+        end
+
+        it 'can be constructed with a range starting from -Infinity' do
+          attribute = Attribute.new nil, nil
+          node = attribute.between(-::Float::INFINITY..3)
+
+          node.must_equal Nodes::LessThanOrEqual.new(
+            attribute,
+            Nodes::Casted.new(3, attribute)
+          )
+        end
+
+        it 'can be constructed with a quoted range starting from -Infinity' do
+          attribute = Attribute.new nil, nil
+          node = attribute.between(quoted_range(-::Float::INFINITY, 3, false))
+
+          node.must_equal Nodes::LessThanOrEqual.new(
+            attribute,
+            Nodes::Quoted.new(3)
+          )
+        end
+
+        it 'can be constructed with an exclusive range starting from -Infinity' do
+          attribute = Attribute.new nil, nil
+          node = attribute.between(-::Float::INFINITY...3)
+
+          node.must_equal Nodes::LessThan.new(
+            attribute,
+            Nodes::Casted.new(3, attribute)
+          )
+        end
+
+        it 'can be constructed with a quoted exclusive range starting from -Infinity' do
+          attribute = Attribute.new nil, nil
+          node = attribute.between(quoted_range(-::Float::INFINITY, 3, true))
+
+          node.must_equal Nodes::LessThan.new(
+            attribute,
+            Nodes::Quoted.new(3)
+          )
+        end
+
+        it 'can be constructed with an infinite range' do
+          attribute = Attribute.new nil, nil
+          node = attribute.between(-::Float::INFINITY..::Float::INFINITY)
+
+          node.must_equal Nodes::NotIn.new(attribute, [])
+        end
+
+        it 'can be constructed with a quoted infinite range' do
+          attribute = Attribute.new nil, nil
+          node = attribute.between(quoted_range(-::Float::INFINITY, ::Float::INFINITY, false))
+
+          node.must_equal Nodes::NotIn.new(attribute, [])
+        end
+
+
+        it 'can be constructed with a range ending at Infinity' do
+          attribute = Attribute.new nil, nil
+          node = attribute.between(0..::Float::INFINITY)
+
+          node.must_equal Nodes::GreaterThanOrEqual.new(
+            attribute,
+            Nodes::Casted.new(0, attribute)
+          )
+        end
+
+        it 'can be constructed with a quoted range ending at Infinity' do
+          attribute = Attribute.new nil, nil
+          node = attribute.between(quoted_range(0, ::Float::INFINITY, false))
+
+          node.must_equal Nodes::GreaterThanOrEqual.new(
+            attribute,
+            Nodes::Quoted.new(0)
+          )
+        end
+
+        it 'can be constructed with an exclusive range' do
+          attribute = Attribute.new nil, nil
+          node = attribute.between(0...3)
+
+          node.must_equal Nodes::And.new([
+            Nodes::GreaterThanOrEqual.new(
+              attribute,
+              Nodes::Casted.new(0, attribute)
+            ),
+            Nodes::LessThan.new(
+              attribute,
+              Nodes::Casted.new(3, attribute)
+            )
+          ])
+        end
+
+        def quoted_range(begin_val, end_val, exclude)
+          OpenStruct.new(
+            begin: Nodes::Quoted.new(begin_val),
+            end: Nodes::Quoted.new(end_val),
+            exclude_end?: exclude,
+          )
+        end
+      end
+
+      describe '#in' do
+        it 'can be constructed with a subquery' do
+          relation = Table.new(:users)
+          mgr = relation.project relation[:id]
+          mgr.where relation[:name].does_not_match_all(['%chunky%','%bacon%'])
+          attribute = Attribute.new nil, nil
+
+          node = attribute.in(mgr)
+
+          node.must_equal Nodes::In.new(attribute, mgr.ast)
+        end
+
+        it 'can be constructed with a list' do
+          attribute = Attribute.new nil, nil
+          node = attribute.in([1, 2, 3])
+
+          node.must_equal Nodes::In.new(
+            attribute,
+            [
+              Nodes::Casted.new(1, attribute),
+              Nodes::Casted.new(2, attribute),
+              Nodes::Casted.new(3, attribute),
+            ]
+          )
+        end
+
+        it 'can be constructed with a random object' do
+          attribute = Attribute.new nil, nil
+          random_object = Object.new
+          node = attribute.in(random_object)
+
+          node.must_equal Nodes::In.new(
+            attribute,
+            Nodes::Casted.new(random_object, attribute)
+          )
+        end
+
+        it 'should generate IN in sql' do
+          relation = Table.new(:users)
+          mgr = relation.project relation[:id]
+          mgr.where relation[:id].in([1,2,3])
+          mgr.to_sql.must_be_like %{
+            SELECT "users"."id" FROM "users" WHERE "users"."id" IN (1, 2, 3)
+          }
+        end
+      end
+
+      describe '#in_any' do
+        it 'should create a Grouping node' do
+          relation = Table.new(:users)
+          relation[:id].in_any([1,2]).must_be_kind_of Nodes::Grouping
+        end
+
+        it 'should generate ORs in sql' do
+          relation = Table.new(:users)
+          mgr = relation.project relation[:id]
+          mgr.where relation[:id].in_any([[1,2], [3,4]])
+          mgr.to_sql.must_be_like %{
+            SELECT "users"."id" FROM "users" WHERE ("users"."id" IN (1, 2) OR "users"."id" IN (3, 4))
+          }
+        end
+      end
+
+      describe '#in_all' do
+        it 'should create a Grouping node' do
+          relation = Table.new(:users)
+          relation[:id].in_all([1,2]).must_be_kind_of Nodes::Grouping
+        end
+
+        it 'should generate ANDs in sql' do
+          relation = Table.new(:users)
+          mgr = relation.project relation[:id]
+          mgr.where relation[:id].in_all([[1,2], [3,4]])
+          mgr.to_sql.must_be_like %{
+            SELECT "users"."id" FROM "users" WHERE ("users"."id" IN (1, 2) AND "users"."id" IN (3, 4))
+          }
+        end
+      end
+
+      describe 'with a range' do
+        it 'can be constructed with a standard range' do
+          attribute = Attribute.new nil, nil
+          node = attribute.not_between(1..3)
+
+          node.must_equal Nodes::Grouping.new(Nodes::Or.new(
+            Nodes::LessThan.new(
+              attribute,
+              Nodes::Casted.new(1, attribute)
+            ),
+            Nodes::GreaterThan.new(
+              attribute,
+              Nodes::Casted.new(3, attribute)
+            )
+          ))
+        end
+
+        it 'can be constructed with a range starting from -Infinity' do
+          attribute = Attribute.new nil, nil
+          node = attribute.not_between(-::Float::INFINITY..3)
+
+          node.must_equal Nodes::GreaterThan.new(
+            attribute,
+            Nodes::Casted.new(3, attribute)
+          )
+        end
+
+        it 'can be constructed with an exclusive range starting from -Infinity' do
+          attribute = Attribute.new nil, nil
+          node = attribute.not_between(-::Float::INFINITY...3)
+
+          node.must_equal Nodes::GreaterThanOrEqual.new(
+            attribute,
+            Nodes::Casted.new(3, attribute)
+          )
+        end
+
+        it 'can be constructed with an infinite range' do
+          attribute = Attribute.new nil, nil
+          node = attribute.not_between(-::Float::INFINITY..::Float::INFINITY)
+
+          node.must_equal Nodes::In.new(attribute, [])
+        end
+
+        it 'can be constructed with a range ending at Infinity' do
+          attribute = Attribute.new nil, nil
+          node = attribute.not_between(0..::Float::INFINITY)
+
+          node.must_equal Nodes::LessThan.new(
+            attribute,
+            Nodes::Casted.new(0, attribute)
+          )
+        end
+
+        it 'can be constructed with an exclusive range' do
+          attribute = Attribute.new nil, nil
+          node = attribute.not_between(0...3)
+
+          node.must_equal Nodes::Grouping.new(Nodes::Or.new(
+            Nodes::LessThan.new(
+              attribute,
+              Nodes::Casted.new(0, attribute)
+            ),
+            Nodes::GreaterThanOrEqual.new(
+              attribute,
+              Nodes::Casted.new(3, attribute)
+            )
+          ))
+        end
+      end
+
+      describe '#not_in' do
+        it 'can be constructed with a subquery' do
+          relation = Table.new(:users)
+          mgr = relation.project relation[:id]
+          mgr.where relation[:name].does_not_match_all(['%chunky%','%bacon%'])
+          attribute = Attribute.new nil, nil
+
+          node = attribute.not_in(mgr)
+
+          node.must_equal Nodes::NotIn.new(attribute, mgr.ast)
+        end
+
+        it 'can be constructed with a Union' do
+          relation = Table.new(:users)
+          mgr1 = relation.project(relation[:id])
+          mgr2 = relation.project(relation[:id])
+
+          union = mgr1.union(mgr2)
+          node = relation[:id].in(union)
+          node.to_sql.must_be_like %{
+            "users"."id" IN (( SELECT "users"."id" FROM "users" UNION SELECT "users"."id" FROM "users" ))
+          }
+        end
+
+        it 'can be constructed with a list' do
+          attribute = Attribute.new nil, nil
+          node = attribute.not_in([1, 2, 3])
+
+          node.must_equal Nodes::NotIn.new(
+            attribute,
+            [
+              Nodes::Casted.new(1, attribute),
+              Nodes::Casted.new(2, attribute),
+              Nodes::Casted.new(3, attribute),
+            ]
+          )
+        end
+
+        it 'can be constructed with a random object' do
+          attribute = Attribute.new nil, nil
+          random_object = Object.new
+          node = attribute.not_in(random_object)
+
+          node.must_equal Nodes::NotIn.new(
+            attribute,
+            Nodes::Casted.new(random_object, attribute)
+          )
+        end
+
+        it 'should generate NOT IN in sql' do
+          relation = Table.new(:users)
+          mgr = relation.project relation[:id]
+          mgr.where relation[:id].not_in([1,2,3])
+          mgr.to_sql.must_be_like %{
+            SELECT "users"."id" FROM "users" WHERE "users"."id" NOT IN (1, 2, 3)
+          }
+        end
+      end
+
+      describe '#not_in_any' do
+        it 'should create a Grouping node' do
+          relation = Table.new(:users)
+          relation[:id].not_in_any([1,2]).must_be_kind_of Nodes::Grouping
+        end
+
+        it 'should generate ORs in sql' do
+          relation = Table.new(:users)
+          mgr = relation.project relation[:id]
+          mgr.where relation[:id].not_in_any([[1,2], [3,4]])
+          mgr.to_sql.must_be_like %{
+            SELECT "users"."id" FROM "users" WHERE ("users"."id" NOT IN (1, 2) OR "users"."id" NOT IN (3, 4))
+          }
+        end
+      end
+
+      describe '#not_in_all' do
+        it 'should create a Grouping node' do
+          relation = Table.new(:users)
+          relation[:id].not_in_all([1,2]).must_be_kind_of Nodes::Grouping
+        end
+
+        it 'should generate ANDs in sql' do
+          relation = Table.new(:users)
+          mgr = relation.project relation[:id]
+          mgr.where relation[:id].not_in_all([[1,2], [3,4]])
+          mgr.to_sql.must_be_like %{
+            SELECT "users"."id" FROM "users" WHERE ("users"."id" NOT IN (1, 2) AND "users"."id" NOT IN (3, 4))
+          }
+        end
+      end
+
+      describe '#eq_all' do
+        it 'should create a Grouping node' do
+          relation = Table.new(:users)
+          relation[:id].eq_all([1,2]).must_be_kind_of Nodes::Grouping
+        end
+
+        it 'should generate ANDs in sql' do
+          relation = Table.new(:users)
+          mgr = relation.project relation[:id]
+          mgr.where relation[:id].eq_all([1,2])
+          mgr.to_sql.must_be_like %{
+            SELECT "users"."id" FROM "users" WHERE ("users"."id" = 1 AND "users"."id" = 2)
+          }
+        end
+      end
+
+      describe '#asc' do
+        it 'should create an Ascending node' do
+          relation = Table.new(:users)
+          relation[:id].asc.must_be_kind_of Nodes::Ascending
+        end
+
+        it 'should generate ASC in sql' do
+          relation = Table.new(:users)
+          mgr = relation.project relation[:id]
+          mgr.order relation[:id].asc
+          mgr.to_sql.must_be_like %{
+            SELECT "users"."id" FROM "users" ORDER BY "users"."id" ASC
+          }
+        end
+      end
+
+      describe '#desc' do
+        it 'should create a Descending node' do
+          relation = Table.new(:users)
+          relation[:id].desc.must_be_kind_of Nodes::Descending
+        end
+
+        it 'should generate DESC in sql' do
+          relation = Table.new(:users)
+          mgr = relation.project relation[:id]
+          mgr.order relation[:id].desc
+          mgr.to_sql.must_be_like %{
+            SELECT "users"."id" FROM "users" ORDER BY "users"."id" DESC
+          }
+        end
+      end
+
+      describe 'equality' do
+        describe '#to_sql' do
+          it 'should produce sql' do
+            table = Table.new :users
+            condition = table['id'].eq 1
+            condition.to_sql.must_equal '"users"."id" = 1'
+          end
+        end
+      end
+
+      describe 'type casting' do
+        it 'does not type cast by default' do
+          table = Table.new(:foo)
+          condition = table["id"].eq("1")
+
+          refute table.able_to_type_cast?
+          condition.to_sql.must_equal %("foo"."id" = '1')
+        end
+
+        it 'type casts when given an explicit caster' do
+          fake_caster = Object.new
+          def fake_caster.type_cast_for_database(attr_name, value)
+            if attr_name == "id"
+              value.to_i
+            else
+              value
+            end
+          end
+          table = Table.new(:foo, type_caster: fake_caster)
+          condition = table["id"].eq("1").and(table["other_id"].eq("2"))
+
+          assert table.able_to_type_cast?
+          condition.to_sql.must_equal %("foo"."id" = 1 AND "foo"."other_id" = '2')
+        end
+
+        it 'does not type cast SqlLiteral nodes' do
+          fake_caster = Object.new
+          def fake_caster.type_cast_for_database(attr_name, value)
+            value.to_i
+          end
+          table = Table.new(:foo, type_caster: fake_caster)
+          condition = table["id"].eq(Arel.sql("(select 1)"))
+
+          assert table.able_to_type_cast?
+          condition.to_sql.must_equal %("foo"."id" = (select 1))
+        end
+      end
+    end
+  end
+end
diff --git a/activerecord/test/cases/arel/attributes_test.rb b/activerecord/test/cases/arel/attributes_test.rb
new file mode 100644
index 0000000000..e17a6f5fd2
--- /dev/null
+++ b/activerecord/test/cases/arel/attributes_test.rb
@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+require_relative '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 'equality' do
+      it 'is equal with equal ivars' do
+        array = [Attribute.new('foo', 'bar'), Attribute.new('foo', 'bar')]
+        assert_equal 1, array.uniq.size
+      end
+
+      it 'is not equal with different ivars' do
+        array = [Attribute.new('foo', 'bar'), Attribute.new('foo', 'baz')]
+        assert_equal 2, array.uniq.size
+      end
+    end
+
+    describe 'for' do
+      it 'deals with unknown column types' do
+        column = Struct.new(:type).new :crazy
+        Attributes.for(column).must_equal Attributes::Undefined
+      end
+
+      it 'returns the correct constant for strings' do
+        [:string, :text, :binary].each do |type|
+          column = Struct.new(:type).new type
+          Attributes.for(column).must_equal Attributes::String
+        end
+      end
+
+      it 'returns the correct constant for ints' do
+        column = Struct.new(:type).new :integer
+        Attributes.for(column).must_equal Attributes::Integer
+      end
+
+      it 'returns the correct constant for floats' do
+        column = Struct.new(:type).new :float
+        Attributes.for(column).must_equal Attributes::Float
+      end
+
+      it 'returns the correct constant for decimals' do
+        column = Struct.new(:type).new :decimal
+        Attributes.for(column).must_equal Attributes::Decimal
+      end
+
+      it 'returns the correct constant for boolean' do
+        column = Struct.new(:type).new :boolean
+        Attributes.for(column).must_equal Attributes::Boolean
+      end
+
+      it 'returns the correct constant for time' do
+        [:date, :datetime, :timestamp, :time].each do |type|
+          column = Struct.new(:type).new type
+          Attributes.for(column).must_equal Attributes::Time
+        end
+      end
+    end
+  end
+end
diff --git a/activerecord/test/cases/arel/collectors/bind_test.rb b/activerecord/test/cases/arel/collectors/bind_test.rb
new file mode 100644
index 0000000000..febc7290a7
--- /dev/null
+++ b/activerecord/test/cases/arel/collectors/bind_test.rb
@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+require_relative '../helper'
+
+module Arel
+  module Collectors
+    class TestBind < Arel::Test
+      def setup
+        @conn = FakeRecord::Base.new
+        @visitor = Visitors::ToSql.new @conn.connection
+        super
+      end
+
+      def collect node
+        @visitor.accept(node, Collectors::Bind.new)
+      end
+
+      def compile node
+        collect(node).value
+      end
+
+      def ast_with_binds bvs
+        table = Table.new(:users)
+        manager = Arel::SelectManager.new table
+        manager.where(table[:age].eq(Nodes::BindParam.new(bvs.shift)))
+        manager.where(table[:name].eq(Nodes::BindParam.new(bvs.shift)))
+        manager.ast
+      end
+
+      def test_compile_gathers_all_bind_params
+        binds = compile(ast_with_binds(["hello", "world"]))
+        assert_equal ["hello", "world"], binds
+
+        binds = compile(ast_with_binds(["hello2", "world3"]))
+        assert_equal ["hello2", "world3"], binds
+      end
+    end
+  end
+end
diff --git a/activerecord/test/cases/arel/collectors/composite_test.rb b/activerecord/test/cases/arel/collectors/composite_test.rb
new file mode 100644
index 0000000000..e330cae7a6
--- /dev/null
+++ b/activerecord/test/cases/arel/collectors/composite_test.rb
@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+require_relative '../helper'
+
+require 'arel/collectors/bind'
+require 'arel/collectors/composite'
+
+module Arel
+  module Collectors
+    class TestComposite < Arel::Test
+      def setup
+        @conn = FakeRecord::Base.new
+        @visitor = Visitors::ToSql.new @conn.connection
+        super
+      end
+
+      def collect node
+        sql_collector = Collectors::SQLString.new
+        bind_collector = Collectors::Bind.new
+        collector = Collectors::Composite.new(sql_collector, bind_collector)
+        @visitor.accept(node, collector)
+      end
+
+      def compile node
+        collect(node).value
+      end
+
+      def ast_with_binds bvs
+        table = Table.new(:users)
+        manager = Arel::SelectManager.new table
+        manager.where(table[:age].eq(Nodes::BindParam.new(bvs.shift)))
+        manager.where(table[:name].eq(Nodes::BindParam.new(bvs.shift)))
+        manager.ast
+      end
+
+      def test_composite_collector_performs_multiple_collections_at_once
+        sql, binds = compile(ast_with_binds(["hello", "world"]))
+        assert_equal 'SELECT FROM "users" WHERE "users"."age" = ? AND "users"."name" = ?', sql
+        assert_equal ["hello", "world"], binds
+
+        sql, binds = compile(ast_with_binds(["hello2", "world3"]))
+        assert_equal 'SELECT FROM "users" WHERE "users"."age" = ? AND "users"."name" = ?', sql
+        assert_equal ["hello2", "world3"], binds
+      end
+    end
+  end
+end
diff --git a/activerecord/test/cases/arel/collectors/sql_string_test.rb b/activerecord/test/cases/arel/collectors/sql_string_test.rb
new file mode 100644
index 0000000000..a8ed3eb625
--- /dev/null
+++ b/activerecord/test/cases/arel/collectors/sql_string_test.rb
@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+require_relative '../helper'
+
+module Arel
+  module Collectors
+    class TestSqlString < Arel::Test
+      def setup
+        @conn = FakeRecord::Base.new
+        @visitor = Visitors::ToSql.new @conn.connection
+        super
+      end
+
+      def collect node
+        @visitor.accept(node, Collectors::SQLString.new)
+      end
+
+      def compile node
+        collect(node).value
+      end
+
+      def ast_with_binds bv
+        table = Table.new(:users)
+        manager = Arel::SelectManager.new table
+        manager.where(table[:age].eq(bv))
+        manager.where(table[:name].eq(bv))
+        manager.ast
+      end
+
+      def test_compile
+        bv = Nodes::BindParam.new(1)
+        collector = collect ast_with_binds bv
+
+        sql = collector.compile ["hello", "world"]
+        assert_equal 'SELECT FROM "users" WHERE "users"."age" = ? AND "users"."name" = ?', sql
+      end
+
+      def test_returned_sql_uses_utf8_encoding
+        bv = Nodes::BindParam.new(1)
+        collector = collect ast_with_binds bv
+
+        sql = collector.compile ["hello", "world"]
+        assert_equal sql.encoding, Encoding::UTF_8
+      end
+    end
+  end
+end
diff --git a/activerecord/test/cases/arel/collectors/substitute_bind_collector_test.rb b/activerecord/test/cases/arel/collectors/substitute_bind_collector_test.rb
new file mode 100644
index 0000000000..18f0ac14de
--- /dev/null
+++ b/activerecord/test/cases/arel/collectors/substitute_bind_collector_test.rb
@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+require_relative '../helper'
+require 'arel/collectors/substitute_binds'
+require 'arel/collectors/sql_string'
+
+module Arel
+  module Collectors
+    class TestSubstituteBindCollector < Arel::Test
+      def setup
+        @conn = FakeRecord::Base.new
+        @visitor = Visitors::ToSql.new @conn.connection
+        super
+      end
+
+      def ast_with_binds
+        table = Table.new(:users)
+        manager = Arel::SelectManager.new table
+        manager.where(table[:age].eq(Nodes::BindParam.new("hello")))
+        manager.where(table[:name].eq(Nodes::BindParam.new("world")))
+        manager.ast
+      end
+
+      def compile(node, quoter)
+        collector = Collectors::SubstituteBinds.new(quoter, Collectors::SQLString.new)
+        @visitor.accept(node, collector).value
+      end
+
+      def test_compile
+        quoter = Object.new
+        def quoter.quote(val)
+          val.to_s
+        end
+        sql = compile(ast_with_binds, quoter)
+        assert_equal 'SELECT FROM "users" WHERE "users"."age" = hello AND "users"."name" = world', sql
+      end
+
+      def test_quoting_is_delegated_to_quoter
+        quoter = Object.new
+        def quoter.quote(val)
+          val.inspect
+        end
+        sql = compile(ast_with_binds, quoter)
+        assert_equal 'SELECT FROM "users" WHERE "users"."age" = "hello" AND "users"."name" = "world"', sql
+      end
+    end
+  end
+end
diff --git a/activerecord/test/cases/arel/crud_test.rb b/activerecord/test/cases/arel/crud_test.rb
new file mode 100644
index 0000000000..38a956b9dd
--- /dev/null
+++ b/activerecord/test/cases/arel/crud_test.rb
@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+require_relative 'helper'
+
+module Arel
+  class FakeCrudder < SelectManager
+    class FakeEngine
+      attr_reader :calls, :connection_pool, :spec, :config
+
+      def initialize
+        @calls = []
+        @connection_pool = self
+        @spec = self
+        @config =  { :adapter => 'sqlite3' }
+      end
+
+      def connection; self end
+
+      def method_missing name, *args
+        @calls << [name, args]
+      end
+    end
+
+    include Crud
+
+    attr_reader :engine
+    attr_accessor :ctx
+
+    def initialize engine = FakeEngine.new
+      super
+    end
+  end
+
+  describe 'crud' do
+    describe 'insert' do
+      it 'should call insert on the connection' do
+        table = Table.new :users
+        fc = FakeCrudder.new
+        fc.from table
+        im = fc.compile_insert [[table[:id], 'foo']]
+        assert_instance_of Arel::InsertManager, im
+      end
+    end
+
+    describe 'update' do
+      it 'should call update on the connection' do
+        table = Table.new :users
+        fc = FakeCrudder.new
+        fc.from table
+        stmt = fc.compile_update [[table[:id], 'foo']], Arel::Attributes::Attribute.new(table, 'id')
+        assert_instance_of Arel::UpdateManager, stmt
+      end
+    end
+
+    describe 'delete' do
+      it 'should call delete on the connection' do
+        table = Table.new :users
+        fc = FakeCrudder.new
+        fc.from table
+        stmt = fc.compile_delete
+        assert_instance_of Arel::DeleteManager, stmt
+      end
+    end
+  end
+end
diff --git a/activerecord/test/cases/arel/delete_manager_test.rb b/activerecord/test/cases/arel/delete_manager_test.rb
new file mode 100644
index 0000000000..36d482f10b
--- /dev/null
+++ b/activerecord/test/cases/arel/delete_manager_test.rb
@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+require_relative 'helper'
+
+module Arel
+  class DeleteManagerTest < Arel::Spec
+    describe 'new' do
+      it 'takes an engine' do
+        Arel::DeleteManager.new
+      end
+    end
+
+    it 'handles limit properly' do
+      table = Table.new(:users)
+      dm = Arel::DeleteManager.new
+      dm.take 10
+      dm.from table
+      assert_match(/LIMIT 10/, dm.to_sql)
+    end
+
+    describe 'from' do
+      it 'uses from' do
+        table = Table.new(:users)
+        dm = Arel::DeleteManager.new
+        dm.from table
+        dm.to_sql.must_be_like %{ DELETE FROM "users" }
+      end
+
+      it 'chains' do
+        table = Table.new(:users)
+        dm = Arel::DeleteManager.new
+        dm.from(table).must_equal dm
+      end
+    end
+
+    describe 'where' do
+      it 'uses where values' do
+        table = Table.new(:users)
+        dm = Arel::DeleteManager.new
+        dm.from table
+        dm.where table[:id].eq(10)
+        dm.to_sql.must_be_like %{ DELETE FROM "users" WHERE "users"."id" = 10}
+      end
+
+      it 'chains' do
+        table = Table.new(:users)
+        dm = Arel::DeleteManager.new
+        dm.where(table[:id].eq(10)).must_equal dm
+      end
+    end
+  end
+end
diff --git a/activerecord/test/cases/arel/factory_methods_test.rb b/activerecord/test/cases/arel/factory_methods_test.rb
new file mode 100644
index 0000000000..2600b81e31
--- /dev/null
+++ b/activerecord/test/cases/arel/factory_methods_test.rb
@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+require_relative 'helper'
+
+module Arel
+  module FactoryMethods
+    class TestFactoryMethods < Arel::Test
+      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_create_true
+        true_node = @factory.create_true
+        assert_instance_of Nodes::True, true_node
+      end
+
+      def test_create_false
+        false_node = @factory.create_false
+        assert_instance_of Nodes::False, false_node
+      end
+
+      def test_lower
+        lower = @factory.lower :one
+        assert_instance_of Nodes::NamedFunction, lower
+        assert_equal 'LOWER', lower.name
+        assert_equal [:one], lower.expressions.map(&:expr)
+      end
+    end
+  end
+end
diff --git a/activerecord/test/cases/arel/helper.rb b/activerecord/test/cases/arel/helper.rb
new file mode 100644
index 0000000000..b716ee833f
--- /dev/null
+++ b/activerecord/test/cases/arel/helper.rb
@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+require 'rubygems'
+require 'minitest/autorun'
+require 'arel'
+
+require_relative 'support/fake_record'
+
+class Object
+  def must_be_like other
+    gsub(/\s+/, ' ').strip.must_equal other.gsub(/\s+/, ' ').strip
+  end
+end
+
+module Arel
+  class Test < Minitest::Test
+    def setup
+      super
+      @arel_engine = Arel::Table.engine
+      Arel::Table.engine = FakeRecord::Base.new
+    end
+
+    def teardown
+      Arel::Table.engine = @arel_engine if defined? @arel_engine
+      super
+    end
+
+    def assert_like expected, actual
+      assert_equal expected.gsub(/\s+/, ' ').strip,
+                   actual.gsub(/\s+/, ' ').strip
+    end
+  end
+
+  class Spec < Minitest::Spec
+    before do
+      @arel_engine = Arel::Table.engine
+      Arel::Table.engine = FakeRecord::Base.new
+    end
+
+    after do
+      Arel::Table.engine = @arel_engine if defined? @arel_engine
+    end
+  end
+end
diff --git a/activerecord/test/cases/arel/insert_manager_test.rb b/activerecord/test/cases/arel/insert_manager_test.rb
new file mode 100644
index 0000000000..33fab63fbc
--- /dev/null
+++ b/activerecord/test/cases/arel/insert_manager_test.rb
@@ -0,0 +1,244 @@
+# frozen_string_literal: true
+require_relative 'helper'
+
+module Arel
+  class InsertManagerTest < Arel::Spec
+    describe 'new' do
+      it 'takes an engine' do
+        Arel::InsertManager.new
+      end
+    end
+
+    describe 'insert' do
+      it 'can create a Values node' do
+        manager = Arel::InsertManager.new
+        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
+        manager        = Arel::InsertManager.new
+        manager.into Table.new(:users)
+        manager.values = manager.create_values [Arel.sql('*')], %w{ a }
+        manager.to_sql.must_be_like %{
+          INSERT INTO \"users\" VALUES (*)
+        }
+      end
+
+      it 'works with multiple values' do
+        table = Table.new(:users)
+        manager = Arel::InsertManager.new
+        manager.into table
+
+        manager.columns << table[:id]
+        manager.columns << table[:name]
+
+        manager.values = manager.create_values_list([
+          %w{1 david},
+          %w{2 kir},
+          ["3", Arel.sql('DEFAULT')],
+        ])
+
+        manager.to_sql.must_be_like %{
+          INSERT INTO \"users\" (\"id\", \"name\") VALUES ('1', 'david'), ('2', 'kir'), ('3', DEFAULT)
+        }
+      end
+
+      it 'literals in multiple values are not escaped' do
+        table = Table.new(:users)
+        manager = Arel::InsertManager.new
+        manager.into table
+
+        manager.columns << table[:name]
+
+        manager.values = manager.create_values_list([
+          [Arel.sql('*')],
+          [Arel.sql('DEFAULT')],
+        ])
+
+        manager.to_sql.must_be_like %{
+          INSERT INTO \"users\" (\"name\") VALUES (*), (DEFAULT)
+        }
+      end
+
+      it 'works with multiple single values' do
+        table = Table.new(:users)
+        manager = Arel::InsertManager.new
+        manager.into table
+
+        manager.columns << table[:name]
+
+        manager.values = manager.create_values_list([
+          %w{david},
+          %w{kir},
+          [Arel.sql('DEFAULT')],
+        ])
+
+        manager.to_sql.must_be_like %{
+          INSERT INTO \"users\" (\"name\") VALUES ('david'), ('kir'), (DEFAULT)
+        }
+      end
+
+      it "inserts false" do
+        table = Table.new(:users)
+        manager = Arel::InsertManager.new
+
+        manager.insert [[table[:bool], false]]
+        manager.to_sql.must_be_like %{
+          INSERT INTO "users" ("bool") VALUES ('f')
+        }
+      end
+
+      it "inserts null" do
+        table = Table.new(:users)
+        manager = Arel::InsertManager.new
+        manager.insert [[table[:id], nil]]
+        manager.to_sql.must_be_like %{
+          INSERT INTO "users" ("id") VALUES (NULL)
+        }
+      end
+
+      it "inserts time" do
+        table = Table.new(:users)
+        manager = Arel::InsertManager.new
+
+        time = Time.now
+        attribute = table[:created_at]
+
+        manager.insert [[attribute, time]]
+        manager.to_sql.must_be_like %{
+          INSERT INTO "users" ("created_at") VALUES (#{Table.engine.connection.quote time})
+        }
+      end
+
+      it 'takes a list of lists' do
+        table = Table.new(:users)
+        manager = Arel::InsertManager.new
+        manager.into table
+        manager.insert [[table[:id], 1], [table[:name], 'aaron']]
+        manager.to_sql.must_be_like %{
+          INSERT INTO "users" ("id", "name") VALUES (1, 'aaron')
+        }
+      end
+
+      it 'defaults the table' do
+        table = Table.new(:users)
+        manager = Arel::InsertManager.new
+        manager.insert [[table[:id], 1], [table[:name], 'aaron']]
+        manager.to_sql.must_be_like %{
+          INSERT INTO "users" ("id", "name") VALUES (1, 'aaron')
+        }
+      end
+
+      it 'noop for empty list' do
+        table = Table.new(:users)
+        manager = Arel::InsertManager.new
+        manager.insert [[table[:id], 1]]
+        manager.insert []
+        manager.to_sql.must_be_like %{
+          INSERT INTO "users" ("id") VALUES (1)
+        }
+      end
+
+      it 'is chainable' do
+        table = Table.new(:users)
+        manager = Arel::InsertManager.new
+        insert_result = manager.insert [[table[:id],1]]
+        assert_equal manager, insert_result
+      end
+    end
+
+    describe 'into' do
+      it 'takes a Table and chains' do
+        manager = Arel::InsertManager.new
+        manager.into(Table.new(:users)).must_equal manager
+      end
+
+      it 'converts to sql' do
+        table   = Table.new :users
+        manager = Arel::InsertManager.new
+        manager.into table
+        manager.to_sql.must_be_like %{
+          INSERT INTO "users"
+        }
+      end
+    end
+
+    describe 'columns' do
+      it "converts to sql" do
+        table   = Table.new :users
+        manager = Arel::InsertManager.new
+        manager.into table
+        manager.columns << table[:id]
+        manager.to_sql.must_be_like %{
+          INSERT INTO "users" ("id")
+        }
+      end
+    end
+
+    describe "values" do
+      it "converts to sql" do
+        table   = Table.new :users
+        manager = Arel::InsertManager.new
+        manager.into table
+
+        manager.values = Nodes::Values.new [1]
+        manager.to_sql.must_be_like %{
+          INSERT INTO "users" VALUES (1)
+        }
+      end
+
+      it "accepts sql literals" do
+        table   = Table.new :users
+        manager = Arel::InsertManager.new
+        manager.into table
+
+        manager.values = Arel.sql("DEFAULT VALUES")
+        manager.to_sql.must_be_like %{
+          INSERT INTO "users" DEFAULT VALUES
+        }
+      end
+    end
+
+    describe "combo" do
+      it "combines columns and values list in order" do
+        table   = Table.new :users
+        manager = Arel::InsertManager.new
+        manager.into table
+
+        manager.values = Nodes::Values.new [1, 'aaron']
+        manager.columns << table[:id]
+        manager.columns << table[:name]
+        manager.to_sql.must_be_like %{
+          INSERT INTO "users" ("id", "name") VALUES (1, 'aaron')
+        }
+      end
+    end
+
+    describe "select" do
+
+      it "accepts a select query in place of a VALUES clause" do
+        table   = Table.new :users
+
+        manager = Arel::InsertManager.new
+        manager.into table
+
+        select = Arel::SelectManager.new
+        select.project Arel.sql('1')
+        select.project Arel.sql('"aaron"')
+
+        manager.select select
+        manager.columns << table[:id]
+        manager.columns << table[:name]
+        manager.to_sql.must_be_like %{
+          INSERT INTO "users" ("id", "name") (SELECT 1, "aaron")
+        }
+      end
+
+    end
+
+  end
+end
diff --git a/activerecord/test/cases/arel/nodes/and_test.rb b/activerecord/test/cases/arel/nodes/and_test.rb
new file mode 100644
index 0000000000..de63e0bb31
--- /dev/null
+++ b/activerecord/test/cases/arel/nodes/and_test.rb
@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+require_relative '../helper'
+
+module Arel
+  module Nodes
+    describe 'And' do
+      describe 'equality' do
+        it 'is equal with equal ivars' do
+          array = [And.new(['foo', 'bar']), And.new(['foo', 'bar'])]
+          assert_equal 1, array.uniq.size
+        end
+
+        it 'is not equal with different ivars' do
+          array = [And.new(['foo', 'bar']), And.new(['foo', 'baz'])]
+          assert_equal 2, array.uniq.size
+        end
+      end
+    end
+  end
+end
+
diff --git a/activerecord/test/cases/arel/nodes/as_test.rb b/activerecord/test/cases/arel/nodes/as_test.rb
new file mode 100644
index 0000000000..09c8aa8d62
--- /dev/null
+++ b/activerecord/test/cases/arel/nodes/as_test.rb
@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+require_relative '../helper'
+
+module Arel
+  module Nodes
+    describe 'As' do
+      describe '#as' do
+        it 'makes an AS node' do
+          attr = Table.new(:users)[:id]
+          as = attr.as(Arel.sql('foo'))
+          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
+
+      describe 'equality' do
+        it 'is equal with equal ivars' do
+          array = [As.new('foo', 'bar'), As.new('foo', 'bar')]
+          assert_equal 1, array.uniq.size
+        end
+
+        it 'is not equal with different ivars' do
+          array = [As.new('foo', 'bar'), As.new('foo', 'baz')]
+          assert_equal 2, array.uniq.size
+        end
+      end
+    end
+  end
+end
diff --git a/activerecord/test/cases/arel/nodes/ascending_test.rb b/activerecord/test/cases/arel/nodes/ascending_test.rb
new file mode 100644
index 0000000000..5c73e69fa5
--- /dev/null
+++ b/activerecord/test/cases/arel/nodes/ascending_test.rb
@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+require_relative '../helper'
+
+module Arel
+  module Nodes
+    class TestAscending < Arel::Test
+      def test_construct
+        ascending = Ascending.new 'zomg'
+        assert_equal 'zomg', ascending.expr
+      end
+
+      def test_reverse
+        ascending = Ascending.new 'zomg'
+        descending = ascending.reverse
+        assert_kind_of Descending, descending
+        assert_equal ascending.expr, descending.expr
+      end
+
+      def test_direction
+        ascending = Ascending.new 'zomg'
+        assert_equal :asc, ascending.direction
+      end
+
+      def test_ascending?
+        ascending = Ascending.new 'zomg'
+        assert ascending.ascending?
+      end
+
+      def test_descending?
+        ascending = Ascending.new 'zomg'
+        assert !ascending.descending?
+      end
+
+      def test_equality_with_same_ivars
+        array = [Ascending.new('zomg'), Ascending.new('zomg')]
+        assert_equal 1, array.uniq.size
+      end
+
+      def test_inequality_with_different_ivars
+        array = [Ascending.new('zomg'), Ascending.new('zomg!')]
+        assert_equal 2, array.uniq.size
+      end
+    end
+  end
+end
diff --git a/activerecord/test/cases/arel/nodes/bin_test.rb b/activerecord/test/cases/arel/nodes/bin_test.rb
new file mode 100644
index 0000000000..923a296adf
--- /dev/null
+++ b/activerecord/test/cases/arel/nodes/bin_test.rb
@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+require_relative '../helper'
+
+module Arel
+  module Nodes
+    class TestBin < Arel::Test
+      def test_new
+        assert Arel::Nodes::Bin.new('zomg')
+      end
+
+      def test_default_to_sql
+        viz  = Arel::Visitors::ToSql.new Table.engine.connection_pool
+        node = Arel::Nodes::Bin.new(Arel.sql('zomg'))
+        assert_equal 'zomg', viz.accept(node, Collectors::SQLString.new).value
+      end
+
+      def test_mysql_to_sql
+        viz  = Arel::Visitors::MySQL.new Table.engine.connection_pool
+        node = Arel::Nodes::Bin.new(Arel.sql('zomg'))
+        assert_equal 'BINARY zomg', viz.accept(node, Collectors::SQLString.new).value
+      end
+
+      def test_equality_with_same_ivars
+        array = [Bin.new('zomg'), Bin.new('zomg')]
+        assert_equal 1, array.uniq.size
+      end
+
+      def test_inequality_with_different_ivars
+        array = [Bin.new('zomg'), Bin.new('zomg!')]
+        assert_equal 2, array.uniq.size
+      end
+    end
+  end
+end
diff --git a/activerecord/test/cases/arel/nodes/binary_test.rb b/activerecord/test/cases/arel/nodes/binary_test.rb
new file mode 100644
index 0000000000..0bea35f7dd
--- /dev/null
+++ b/activerecord/test/cases/arel/nodes/binary_test.rb
@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+require_relative '../helper'
+
+module Arel
+  module Nodes
+    describe 'Binary' do
+      describe '#hash' do
+        it 'generates a hash based on its value' do
+          eq = Equality.new('foo', 'bar')
+          eq2 = Equality.new('foo', 'bar')
+          eq3 = Equality.new('bar', 'baz')
+
+          assert_equal eq.hash, eq2.hash
+          refute_equal eq.hash, eq3.hash
+        end
+
+        it 'generates a hash specific to its class' do
+          eq = Equality.new('foo', 'bar')
+          neq = NotEqual.new('foo', 'bar')
+
+          refute_equal eq.hash, neq.hash
+        end
+      end
+    end
+  end
+end
diff --git a/activerecord/test/cases/arel/nodes/bind_param_test.rb b/activerecord/test/cases/arel/nodes/bind_param_test.rb
new file mode 100644
index 0000000000..665581edce
--- /dev/null
+++ b/activerecord/test/cases/arel/nodes/bind_param_test.rb
@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+require_relative '../helper'
+
+module Arel
+  module Nodes
+    describe 'BindParam' do
+      it 'is equal to other bind params with the same value' do
+        BindParam.new(1).must_equal(BindParam.new(1))
+        BindParam.new("foo").must_equal(BindParam.new("foo"))
+      end
+
+      it 'is not equal to other nodes' do
+        BindParam.new(nil).wont_equal(Node.new)
+      end
+
+      it 'is not equal to bind params with different values' do
+        BindParam.new(1).wont_equal(BindParam.new(2))
+      end
+    end
+  end
+end
diff --git a/activerecord/test/cases/arel/nodes/case_test.rb b/activerecord/test/cases/arel/nodes/case_test.rb
new file mode 100644
index 0000000000..70364fe6ab
--- /dev/null
+++ b/activerecord/test/cases/arel/nodes/case_test.rb
@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+require_relative '../helper'
+
+module Arel
+  module Nodes
+    describe 'Case' do
+      describe '#initialize' do
+        it 'sets case expression from first argument' do
+          node = Case.new 'foo'
+
+          assert_equal 'foo', node.case
+        end
+
+        it 'sets default case from second argument' do
+          node = Case.new nil, 'bar'
+
+          assert_equal 'bar', node.default
+        end
+      end
+
+      describe '#clone' do
+        it 'clones case, conditions and default' do
+          foo = Nodes.build_quoted 'foo'
+
+          node = Case.new
+          node.case = foo
+          node.conditions = [When.new(foo, foo)]
+          node.default = foo
+
+          dolly = node.clone
+
+          assert_equal dolly.case, node.case
+          refute_same  dolly.case, node.case
+
+          assert_equal dolly.conditions, node.conditions
+          refute_same  dolly.conditions, node.conditions
+
+          assert_equal dolly.default, node.default
+          refute_same  dolly.default, node.default
+        end
+      end
+
+      describe 'equality' do
+        it 'is equal with equal ivars' do
+          foo = Nodes.build_quoted 'foo'
+          one = Nodes.build_quoted 1
+          zero = Nodes.build_quoted 0
+
+          case1 = Case.new foo
+          case1.conditions = [When.new(foo, one)]
+          case1.default = Else.new zero
+
+          case2 = Case.new foo
+          case2.conditions = [When.new(foo, one)]
+          case2.default = Else.new zero
+
+          array = [case1, case2]
+
+          assert_equal 1, array.uniq.size
+        end
+
+        it 'is not equal with different ivars' do
+          foo = Nodes.build_quoted 'foo'
+          bar = Nodes.build_quoted 'bar'
+          one = Nodes.build_quoted 1
+          zero = Nodes.build_quoted 0
+
+          case1 = Case.new foo
+          case1.conditions = [When.new(foo, one)]
+          case1.default = Else.new zero
+
+          case2 = Case.new foo
+          case2.conditions = [When.new(bar, one)]
+          case2.default = Else.new zero
+
+          array = [case1, case2]
+
+          assert_equal 2, array.uniq.size
+        end
+      end
+    end
+  end
+end
diff --git a/activerecord/test/cases/arel/nodes/casted_test.rb b/activerecord/test/cases/arel/nodes/casted_test.rb
new file mode 100644
index 0000000000..a6e2dd2294
--- /dev/null
+++ b/activerecord/test/cases/arel/nodes/casted_test.rb
@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+require_relative '../helper'
+
+module Arel
+  module Nodes
+    describe Casted do
+      describe '#hash' do
+        it 'is equal when eql? returns true' do
+          one = Casted.new 1, 2
+          also_one = Casted.new 1, 2
+
+          assert_equal one.hash, also_one.hash
+        end
+      end
+    end
+  end
+end
diff --git a/activerecord/test/cases/arel/nodes/count_test.rb b/activerecord/test/cases/arel/nodes/count_test.rb
new file mode 100644
index 0000000000..28d8481993
--- /dev/null
+++ b/activerecord/test/cases/arel/nodes/count_test.rb
@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+require_relative '../helper'
+
+class Arel::Nodes::CountTest < Arel::Spec
+  describe "as" do
+    it 'should alias the count' do
+      table = Arel::Table.new :users
+      table[:id].count.as('foo').to_sql.must_be_like %{
+        COUNT("users"."id") AS foo
+      }
+    end
+  end
+
+  describe "eq" do
+    it "should compare the count" do
+      table = Arel::Table.new :users
+      table[:id].count.eq(2).to_sql.must_be_like %{
+        COUNT("users"."id") = 2
+      }
+    end
+  end
+
+  describe 'equality' do
+    it 'is equal with equal ivars' do
+      array = [Arel::Nodes::Count.new('foo'), Arel::Nodes::Count.new('foo')]
+      assert_equal 1, array.uniq.size
+    end
+
+    it 'is not equal with different ivars' do
+      array = [Arel::Nodes::Count.new('foo'), Arel::Nodes::Count.new('foo!')]
+      assert_equal 2, array.uniq.size
+    end
+  end
+
+  describe 'math' do
+    it 'allows mathematical functions' do
+      table = Arel::Table.new :users
+      (table[:id].count + 1).to_sql.must_be_like %{
+        (COUNT("users"."id") + 1)
+      }
+    end
+  end
+end
diff --git a/activerecord/test/cases/arel/nodes/delete_statement_test.rb b/activerecord/test/cases/arel/nodes/delete_statement_test.rb
new file mode 100644
index 0000000000..ada8964646
--- /dev/null
+++ b/activerecord/test/cases/arel/nodes/delete_statement_test.rb
@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+require_relative '../helper'
+
+describe Arel::Nodes::DeleteStatement do
+  describe "#clone" do
+    it "clones wheres" do
+      statement = Arel::Nodes::DeleteStatement.new
+      statement.wheres = %w[a b c]
+
+      dolly = statement.clone
+      dolly.wheres.must_equal statement.wheres
+      dolly.wheres.wont_be_same_as statement.wheres
+    end
+  end
+
+  describe 'equality' do
+    it 'is equal with equal ivars' do
+      statement1 = Arel::Nodes::DeleteStatement.new
+      statement1.wheres = %w[a b c]
+      statement2 = Arel::Nodes::DeleteStatement.new
+      statement2.wheres = %w[a b c]
+      array = [statement1, statement2]
+      assert_equal 1, array.uniq.size
+    end
+
+    it 'is not equal with different ivars' do
+      statement1 = Arel::Nodes::DeleteStatement.new
+      statement1.wheres = %w[a b c]
+      statement2 = Arel::Nodes::DeleteStatement.new
+      statement2.wheres = %w[1 2 3]
+      array = [statement1, statement2]
+      assert_equal 2, array.uniq.size
+    end
+  end
+end
diff --git a/activerecord/test/cases/arel/nodes/descending_test.rb b/activerecord/test/cases/arel/nodes/descending_test.rb
new file mode 100644
index 0000000000..5fe0ba62b0
--- /dev/null
+++ b/activerecord/test/cases/arel/nodes/descending_test.rb
@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+require_relative '../helper'
+
+module Arel
+  module Nodes
+    class TestDescending < Arel::Test
+      def test_construct
+        descending = Descending.new 'zomg'
+        assert_equal 'zomg', descending.expr
+      end
+
+      def test_reverse
+        descending = Descending.new 'zomg'
+        ascending = descending.reverse
+        assert_kind_of Ascending, ascending
+        assert_equal descending.expr, ascending.expr
+      end
+
+      def test_direction
+        descending = Descending.new 'zomg'
+        assert_equal :desc, descending.direction
+      end
+
+      def test_ascending?
+        descending = Descending.new 'zomg'
+        assert !descending.ascending?
+      end
+
+      def test_descending?
+        descending = Descending.new 'zomg'
+        assert descending.descending?
+      end
+
+      def test_equality_with_same_ivars
+        array = [Descending.new('zomg'), Descending.new('zomg')]
+        assert_equal 1, array.uniq.size
+      end
+
+      def test_inequality_with_different_ivars
+        array = [Descending.new('zomg'), Descending.new('zomg!')]
+        assert_equal 2, array.uniq.size
+      end
+    end
+  end
+end
diff --git a/activerecord/test/cases/arel/nodes/distinct_test.rb b/activerecord/test/cases/arel/nodes/distinct_test.rb
new file mode 100644
index 0000000000..465700118e
--- /dev/null
+++ b/activerecord/test/cases/arel/nodes/distinct_test.rb
@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+require_relative '../helper'
+
+module Arel
+  module Nodes
+    describe 'Distinct' do
+      describe 'equality' do
+        it 'is equal to other distinct nodes' do
+          array = [Distinct.new, Distinct.new]
+          assert_equal 1, array.uniq.size
+        end
+
+        it 'is not equal with other nodes' do
+          array = [Distinct.new, Node.new]
+          assert_equal 2, array.uniq.size
+        end
+      end
+    end
+  end
+end
+
diff --git a/activerecord/test/cases/arel/nodes/equality_test.rb b/activerecord/test/cases/arel/nodes/equality_test.rb
new file mode 100644
index 0000000000..28a74de321
--- /dev/null
+++ b/activerecord/test/cases/arel/nodes/equality_test.rb
@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+require_relative '../helper'
+
+module Arel
+  module Nodes
+    describe 'equality' do
+      # FIXME: backwards compat
+      describe 'backwards compat' do
+        describe 'operator' do
+          it 'returns :==' do
+            attr = Table.new(:users)[:id]
+            left  = attr.eq(10)
+            left.operator.must_equal :==
+          end
+        end
+
+        describe 'operand1' do
+          it "should equal left" do
+            attr = Table.new(:users)[:id]
+            left  = attr.eq(10)
+            left.left.must_equal left.operand1
+          end
+        end
+
+        describe 'operand2' do
+          it "should equal right" do
+            attr = Table.new(:users)[:id]
+            left  = attr.eq(10)
+            left.right.must_equal left.operand2
+          end
+        end
+
+        describe 'to_sql' do
+          it 'takes an engine' do
+            engine = FakeRecord::Base.new
+            engine.connection.extend Module.new {
+              attr_accessor :quote_count
+              def quote(*args) @quote_count += 1; super; end
+              def quote_column_name(*args) @quote_count += 1; super; end
+              def quote_table_name(*args) @quote_count += 1; super; end
+            }
+            engine.connection.quote_count = 0
+
+            attr = Table.new(:users)[:id]
+            test = attr.eq(10)
+            test.to_sql engine
+            engine.connection.quote_count.must_equal 3
+          end
+        end
+      end
+
+      describe 'or' do
+        it 'makes an OR 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
+        end
+      end
+
+      describe 'and' do
+        it 'makes and AND node' do
+          attr = Table.new(:users)[:id]
+          left  = attr.eq(10)
+          right = attr.eq(11)
+          node  = left.and right
+          node.left.must_equal left
+          node.right.must_equal right
+        end
+      end
+
+      it 'is equal with equal ivars' do
+        array = [Equality.new('foo', 'bar'), Equality.new('foo', 'bar')]
+        assert_equal 1, array.uniq.size
+      end
+
+      it 'is not equal with different ivars' do
+        array = [Equality.new('foo', 'bar'), Equality.new('foo', 'baz')]
+        assert_equal 2, array.uniq.size
+      end
+    end
+  end
+end
diff --git a/activerecord/test/cases/arel/nodes/extract_test.rb b/activerecord/test/cases/arel/nodes/extract_test.rb
new file mode 100644
index 0000000000..f6dc1626a4
--- /dev/null
+++ b/activerecord/test/cases/arel/nodes/extract_test.rb
@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+require_relative '../helper'
+
+class Arel::Nodes::ExtractTest < Arel::Spec
+  it "should extract field" do
+    table = Arel::Table.new :users
+    table[:timestamp].extract('date').to_sql.must_be_like %{
+      EXTRACT(DATE FROM "users"."timestamp")
+    }
+  end
+
+  describe "as" do
+    it 'should alias the extract' do
+      table = Arel::Table.new :users
+      table[:timestamp].extract('date').as('foo').to_sql.must_be_like %{
+        EXTRACT(DATE FROM "users"."timestamp") AS foo
+      }
+    end
+
+    it 'should not mutate the extract' do
+      table = Arel::Table.new :users
+      extract = table[:timestamp].extract('date')
+      before = extract.dup
+      extract.as('foo')
+      assert_equal extract, before
+    end
+  end
+
+  describe 'equality' do
+    it 'is equal with equal ivars' do
+      table = Arel::Table.new :users
+      array = [table[:attr].extract('foo'), table[:attr].extract('foo')]
+      assert_equal 1, array.uniq.size
+    end
+
+    it 'is not equal with different ivars' do
+      table = Arel::Table.new :users
+      array = [table[:attr].extract('foo'), table[:attr].extract('bar')]
+      assert_equal 2, array.uniq.size
+    end
+  end
+end
diff --git a/activerecord/test/cases/arel/nodes/false_test.rb b/activerecord/test/cases/arel/nodes/false_test.rb
new file mode 100644
index 0000000000..8b91dc227c
--- /dev/null
+++ b/activerecord/test/cases/arel/nodes/false_test.rb
@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+require_relative '../helper'
+
+module Arel
+  module Nodes
+    describe 'False' do
+      describe 'equality' do
+        it 'is equal to other false nodes' do
+          array = [False.new, False.new]
+          assert_equal 1, array.uniq.size
+        end
+
+        it 'is not equal with other nodes' do
+          array = [False.new, Node.new]
+          assert_equal 2, array.uniq.size
+        end
+      end
+    end
+  end
+end
+
diff --git a/activerecord/test/cases/arel/nodes/grouping_test.rb b/activerecord/test/cases/arel/nodes/grouping_test.rb
new file mode 100644
index 0000000000..7ad1584f0f
--- /dev/null
+++ b/activerecord/test/cases/arel/nodes/grouping_test.rb
@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+require_relative '../helper'
+
+module Arel
+  module Nodes
+    class GroupingTest < Arel::Spec
+      it 'should create Equality nodes' do
+        grouping = Grouping.new(Nodes.build_quoted('foo'))
+        grouping.eq('foo').to_sql.must_be_like %q{('foo') = 'foo'}
+      end
+
+      describe 'equality' do
+        it 'is equal with equal ivars' do
+          array = [Grouping.new('foo'), Grouping.new('foo')]
+          assert_equal 1, array.uniq.size
+        end
+
+        it 'is not equal with different ivars' do
+          array = [Grouping.new('foo'), Grouping.new('bar')]
+          assert_equal 2, array.uniq.size
+        end
+      end
+    end
+  end
+end
+
diff --git a/activerecord/test/cases/arel/nodes/infix_operation_test.rb b/activerecord/test/cases/arel/nodes/infix_operation_test.rb
new file mode 100644
index 0000000000..28a4710dc0
--- /dev/null
+++ b/activerecord/test/cases/arel/nodes/infix_operation_test.rb
@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+require_relative '../helper'
+
+module Arel
+  module Nodes
+    class TestInfixOperation < Arel::Test
+      def test_construct
+        operation = InfixOperation.new :+, 1, 2
+        assert_equal :+, operation.operator
+        assert_equal 1, operation.left
+        assert_equal 2, operation.right
+      end
+
+      def test_operation_alias
+        operation = InfixOperation.new :+, 1, 2
+        aliaz = operation.as('zomg')
+        assert_kind_of As, aliaz
+        assert_equal operation, aliaz.left
+        assert_equal 'zomg', aliaz.right
+      end
+
+      def test_operation_ordering
+        operation = InfixOperation.new :+, 1, 2
+        ordering = operation.desc
+        assert_kind_of Descending, ordering
+        assert_equal operation, ordering.expr
+        assert ordering.descending?
+      end
+
+      def test_equality_with_same_ivars
+        array = [InfixOperation.new(:+, 1, 2), InfixOperation.new(:+, 1, 2)]
+        assert_equal 1, array.uniq.size
+      end
+
+      def test_inequality_with_different_ivars
+        array = [InfixOperation.new(:+, 1, 2), InfixOperation.new(:+, 1, 3)]
+        assert_equal 2, array.uniq.size
+      end
+    end
+  end
+end
diff --git a/activerecord/test/cases/arel/nodes/insert_statement_test.rb b/activerecord/test/cases/arel/nodes/insert_statement_test.rb
new file mode 100644
index 0000000000..87f9d83a32
--- /dev/null
+++ b/activerecord/test/cases/arel/nodes/insert_statement_test.rb
@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+require_relative '../helper'
+
+describe Arel::Nodes::InsertStatement do
+  describe "#clone" do
+    it "clones columns and values" do
+      statement = Arel::Nodes::InsertStatement.new
+      statement.columns = %w[a b c]
+      statement.values  = %w[x y z]
+
+      dolly = statement.clone
+      dolly.columns.must_equal statement.columns
+      dolly.values.must_equal statement.values
+
+      dolly.columns.wont_be_same_as statement.columns
+      dolly.values.wont_be_same_as statement.values
+    end
+  end
+
+  describe 'equality' do
+    it 'is equal with equal ivars' do
+      statement1 = Arel::Nodes::InsertStatement.new
+      statement1.columns = %w[a b c]
+      statement1.values  = %w[x y z]
+      statement2 = Arel::Nodes::InsertStatement.new
+      statement2.columns = %w[a b c]
+      statement2.values  = %w[x y z]
+      array = [statement1, statement2]
+      assert_equal 1, array.uniq.size
+    end
+
+    it 'is not equal with different ivars' do
+      statement1 = Arel::Nodes::InsertStatement.new
+      statement1.columns = %w[a b c]
+      statement1.values  = %w[x y z]
+      statement2 = Arel::Nodes::InsertStatement.new
+      statement2.columns = %w[a b c]
+      statement2.values  = %w[1 2 3]
+      array = [statement1, statement2]
+      assert_equal 2, array.uniq.size
+    end
+  end
+end
diff --git a/activerecord/test/cases/arel/nodes/named_function_test.rb b/activerecord/test/cases/arel/nodes/named_function_test.rb
new file mode 100644
index 0000000000..30f6dac595
--- /dev/null
+++ b/activerecord/test/cases/arel/nodes/named_function_test.rb
@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+require_relative '../helper'
+
+module Arel
+  module Nodes
+    class TestNamedFunction < Arel::Test
+      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
+
+      def test_equality_with_same_ivars
+        array = [
+          NamedFunction.new('omg', 'zomg', 'wth'),
+          NamedFunction.new('omg', 'zomg', 'wth')
+        ]
+        assert_equal 1, array.uniq.size
+      end
+
+      def test_inequality_with_different_ivars
+        array = [
+          NamedFunction.new('omg', 'zomg', 'wth'),
+          NamedFunction.new('zomg', 'zomg', 'wth')
+        ]
+        assert_equal 2, array.uniq.size
+      end
+    end
+  end
+end
diff --git a/activerecord/test/cases/arel/nodes/node_test.rb b/activerecord/test/cases/arel/nodes/node_test.rb
new file mode 100644
index 0000000000..c1d3a01d1c
--- /dev/null
+++ b/activerecord/test/cases/arel/nodes/node_test.rb
@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+require_relative '../helper'
+
+module Arel
+  class TestNode < Arel::Test
+    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 Nodes::BindParam == klass
+        next if klass.name =~ /^Arel::Nodes::(?:Test|.*Test$)/
+        assert klass.ancestors.include?(Nodes::Node), klass.name
+      end
+    end
+
+    def test_each
+      list = []
+      node = Nodes::Node.new
+      node.each { |n| list << n }
+      assert_equal [node], list
+    end
+
+    def test_generator
+      list = []
+      node = Nodes::Node.new
+      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
diff --git a/activerecord/test/cases/arel/nodes/not_test.rb b/activerecord/test/cases/arel/nodes/not_test.rb
new file mode 100644
index 0000000000..15f94a6f10
--- /dev/null
+++ b/activerecord/test/cases/arel/nodes/not_test.rb
@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+require_relative '../helper'
+
+module Arel
+  module Nodes
+    describe 'not' do
+      describe '#not' do
+        it 'makes a NOT node' do
+          attr = Table.new(:users)[:id]
+          expr  = attr.eq(10)
+          node  = expr.not
+          node.must_be_kind_of Not
+          node.expr.must_equal expr
+        end
+      end
+
+      describe 'equality' do
+        it 'is equal with equal ivars' do
+          array = [Not.new('foo'), Not.new('foo')]
+          assert_equal 1, array.uniq.size
+        end
+
+        it 'is not equal with different ivars' do
+          array = [Not.new('foo'), Not.new('baz')]
+          assert_equal 2, array.uniq.size
+        end
+      end
+    end
+  end
+end
diff --git a/activerecord/test/cases/arel/nodes/or_test.rb b/activerecord/test/cases/arel/nodes/or_test.rb
new file mode 100644
index 0000000000..4f8d56d165
--- /dev/null
+++ b/activerecord/test/cases/arel/nodes/or_test.rb
@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+require_relative '../helper'
+
+module Arel
+  module Nodes
+    describe 'or' do
+      describe '#or' do
+        it 'makes an OR 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
+
+          oror = node.or(right)
+          oror.expr.left.must_equal node
+          oror.expr.right.must_equal right
+        end
+      end
+
+      describe 'equality' do
+        it 'is equal with equal ivars' do
+          array = [Or.new('foo', 'bar'), Or.new('foo', 'bar')]
+          assert_equal 1, array.uniq.size
+        end
+
+        it 'is not equal with different ivars' do
+          array = [Or.new('foo', 'bar'), Or.new('foo', 'baz')]
+          assert_equal 2, array.uniq.size
+        end
+      end
+    end
+  end
+end
diff --git a/activerecord/test/cases/arel/nodes/over_test.rb b/activerecord/test/cases/arel/nodes/over_test.rb
new file mode 100644
index 0000000000..c9804c395f
--- /dev/null
+++ b/activerecord/test/cases/arel/nodes/over_test.rb
@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+require_relative '../helper'
+
+class Arel::Nodes::OverTest < Arel::Spec
+  describe 'as' do
+    it 'should alias the expression' do
+      table = Arel::Table.new :users
+      table[:id].count.over.as('foo').to_sql.must_be_like %{
+        COUNT("users"."id") OVER () AS foo
+      }
+    end
+  end
+
+  describe 'with literal' do
+    it 'should reference the window definition by name' do
+      table = Arel::Table.new :users
+      table[:id].count.over('foo').to_sql.must_be_like %{
+        COUNT("users"."id") OVER "foo"
+      }
+    end
+  end
+
+  describe 'with SQL literal' do
+    it 'should reference the window definition by name' do
+      table = Arel::Table.new :users
+      table[:id].count.over(Arel.sql('foo')).to_sql.must_be_like %{
+        COUNT("users"."id") OVER foo
+      }
+    end
+  end
+
+  describe 'with no expression' do
+    it 'should use empty definition' do
+      table = Arel::Table.new :users
+      table[:id].count.over.to_sql.must_be_like %{
+        COUNT("users"."id") OVER ()
+      }
+    end
+  end
+
+  describe 'with expression' do
+    it 'should use definition in sub-expression' do
+      table = Arel::Table.new :users
+      window = Arel::Nodes::Window.new.order(table['foo'])
+      table[:id].count.over(window).to_sql.must_be_like %{
+        COUNT("users"."id") OVER (ORDER BY \"users\".\"foo\")
+      }
+    end
+  end
+
+  describe 'equality' do
+    it 'is equal with equal ivars' do
+      array = [
+        Arel::Nodes::Over.new('foo', 'bar'),
+        Arel::Nodes::Over.new('foo', 'bar')
+      ]
+      assert_equal 1, array.uniq.size
+    end
+
+    it 'is not equal with different ivars' do
+      array = [
+        Arel::Nodes::Over.new('foo', 'bar'),
+        Arel::Nodes::Over.new('foo', 'baz')
+      ]
+      assert_equal 2, array.uniq.size
+    end
+  end
+end
diff --git a/activerecord/test/cases/arel/nodes/select_core_test.rb b/activerecord/test/cases/arel/nodes/select_core_test.rb
new file mode 100644
index 0000000000..bbb06666b6
--- /dev/null
+++ b/activerecord/test/cases/arel/nodes/select_core_test.rb
@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+require_relative '../helper'
+
+module Arel
+  module Nodes
+    class TestSelectCore < Arel::Test
+      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
+
+        assert_equal core.froms, dolly.froms
+        assert_equal core.projections, dolly.projections
+        assert_equal core.wheres, dolly.wheres
+
+        refute_same core.froms, dolly.froms
+        refute_same core.projections, dolly.projections
+        refute_same core.wheres, dolly.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.connection_pool
+        assert_match 'DISTINCT', viz.accept(core, Collectors::SQLString.new).value
+      end
+
+      def test_equality_with_same_ivars
+        core1 = SelectCore.new
+        core1.froms       = %w[a b c]
+        core1.projections = %w[d e f]
+        core1.wheres      = %w[g h i]
+        core1.groups      = %w[j k l]
+        core1.windows     = %w[m n o]
+        core1.havings     = %w[p q r]
+        core2 = SelectCore.new
+        core2.froms       = %w[a b c]
+        core2.projections = %w[d e f]
+        core2.wheres      = %w[g h i]
+        core2.groups      = %w[j k l]
+        core2.windows     = %w[m n o]
+        core2.havings     = %w[p q r]
+        array = [core1, core2]
+        assert_equal 1, array.uniq.size
+      end
+
+      def test_inequality_with_different_ivars
+        core1 = SelectCore.new
+        core1.froms       = %w[a b c]
+        core1.projections = %w[d e f]
+        core1.wheres      = %w[g h i]
+        core1.groups      = %w[j k l]
+        core1.windows     = %w[m n o]
+        core1.havings     = %w[p q r]
+        core2 = SelectCore.new
+        core2.froms       = %w[a b c]
+        core2.projections = %w[d e f]
+        core2.wheres      = %w[g h i]
+        core2.groups      = %w[j k l]
+        core2.windows     = %w[m n o]
+        core2.havings     = %w[l o l]
+        array = [core1, core2]
+        assert_equal 2, array.uniq.size
+      end
+    end
+  end
+end
diff --git a/activerecord/test/cases/arel/nodes/select_statement_test.rb b/activerecord/test/cases/arel/nodes/select_statement_test.rb
new file mode 100644
index 0000000000..5e313e03fa
--- /dev/null
+++ b/activerecord/test/cases/arel/nodes/select_statement_test.rb
@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+require_relative '../helper'
+
+describe Arel::Nodes::SelectStatement do
+  describe "#clone" do
+    it "clones cores" do
+      statement = Arel::Nodes::SelectStatement.new %w[a b c]
+
+      dolly = statement.clone
+      dolly.cores.must_equal      statement.cores
+      dolly.cores.wont_be_same_as statement.cores
+    end
+  end
+
+  describe 'equality' do
+    it 'is equal with equal ivars' do
+      statement1 = Arel::Nodes::SelectStatement.new %w[a b c]
+      statement1.offset = 1
+      statement1.limit  = 2
+      statement1.lock   = false
+      statement1.orders = %w[x y z]
+      statement1.with   = 'zomg'
+      statement2 = Arel::Nodes::SelectStatement.new %w[a b c]
+      statement2.offset = 1
+      statement2.limit  = 2
+      statement2.lock   = false
+      statement2.orders = %w[x y z]
+      statement2.with   = 'zomg'
+      array = [statement1, statement2]
+      assert_equal 1, array.uniq.size
+    end
+
+    it 'is not equal with different ivars' do
+      statement1 = Arel::Nodes::SelectStatement.new %w[a b c]
+      statement1.offset = 1
+      statement1.limit  = 2
+      statement1.lock   = false
+      statement1.orders = %w[x y z]
+      statement1.with   = 'zomg'
+      statement2 = Arel::Nodes::SelectStatement.new %w[a b c]
+      statement2.offset = 1
+      statement2.limit  = 2
+      statement2.lock   = false
+      statement2.orders = %w[x y z]
+      statement2.with   = 'wth'
+      array = [statement1, statement2]
+      assert_equal 2, array.uniq.size
+    end
+  end
+end
diff --git a/activerecord/test/cases/arel/nodes/sql_literal_test.rb b/activerecord/test/cases/arel/nodes/sql_literal_test.rb
new file mode 100644
index 0000000000..0c4f23be78
--- /dev/null
+++ b/activerecord/test/cases/arel/nodes/sql_literal_test.rb
@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+require_relative '../helper'
+require 'yaml'
+
+module Arel
+  module Nodes
+    class SqlLiteralTest < Arel::Spec
+      before do
+        @visitor = Visitors::ToSql.new Table.engine.connection
+      end
+
+      def compile node
+        @visitor.accept(node, Collectors::SQLString.new).value
+      end
+
+      describe 'sql' do
+        it 'makes a sql literal node' do
+          sql = Arel.sql 'foo'
+          sql.must_be_kind_of Arel::Nodes::SqlLiteral
+        end
+      end
+
+      describe 'count' do
+        it 'makes a count node' do
+          node = SqlLiteral.new('*').count
+          compile(node).must_be_like %{ COUNT(*) }
+        end
+
+        it 'makes a distinct node' do
+          node = SqlLiteral.new('*').count true
+          compile(node).must_be_like %{ COUNT(DISTINCT *) }
+        end
+      end
+
+      describe 'equality' do
+        it 'makes an equality node' do
+          node = SqlLiteral.new('foo').eq(1)
+          compile(node).must_be_like %{ foo = 1 }
+        end
+
+        it 'is equal with equal contents' do
+          array = [SqlLiteral.new('foo'), SqlLiteral.new('foo')]
+          assert_equal 1, array.uniq.size
+        end
+
+        it 'is not equal with different contents' do
+          array = [SqlLiteral.new('foo'), SqlLiteral.new('bar')]
+          assert_equal 2, array.uniq.size
+        end
+      end
+
+      describe 'grouped "or" equality' do
+        it 'makes a grouping node with an or node' do
+          node = SqlLiteral.new('foo').eq_any([1,2])
+          compile(node).must_be_like %{ (foo = 1 OR foo = 2) }
+        end
+      end
+
+      describe 'grouped "and" equality' do
+        it 'makes a grouping node with an and node' do
+          node = SqlLiteral.new('foo').eq_all([1,2])
+          compile(node).must_be_like %{ (foo = 1 AND foo = 2) }
+        end
+      end
+
+      describe 'serialization' do
+        it 'serializes into YAML' do
+          yaml_literal = SqlLiteral.new('foo').to_yaml
+          assert_equal('foo', YAML.load(yaml_literal))
+        end
+      end
+    end
+  end
+end
diff --git a/activerecord/test/cases/arel/nodes/sum_test.rb b/activerecord/test/cases/arel/nodes/sum_test.rb
new file mode 100644
index 0000000000..46c908d872
--- /dev/null
+++ b/activerecord/test/cases/arel/nodes/sum_test.rb
@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+require_relative '../helper'
+
+class Arel::Nodes::SumTest < Arel::Spec
+  describe "as" do
+    it 'should alias the sum' do
+      table = Arel::Table.new :users
+      table[:id].sum.as('foo').to_sql.must_be_like %{
+        SUM("users"."id") AS foo
+      }
+    end
+  end
+
+  describe 'equality' do
+    it 'is equal with equal ivars' do
+      array = [Arel::Nodes::Sum.new('foo'), Arel::Nodes::Sum.new('foo')]
+      assert_equal 1, array.uniq.size
+    end
+
+    it 'is not equal with different ivars' do
+      array = [Arel::Nodes::Sum.new('foo'), Arel::Nodes::Sum.new('foo!')]
+      assert_equal 2, array.uniq.size
+    end
+  end
+  
+  describe 'order' do
+    it 'should order the sum' do
+      table = Arel::Table.new :users
+      table[:id].sum.desc.to_sql.must_be_like %{
+        SUM("users"."id") DESC
+      }
+    end
+  end
+end
diff --git a/activerecord/test/cases/arel/nodes/table_alias_test.rb b/activerecord/test/cases/arel/nodes/table_alias_test.rb
new file mode 100644
index 0000000000..b1b49919d5
--- /dev/null
+++ b/activerecord/test/cases/arel/nodes/table_alias_test.rb
@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+require_relative '../helper'
+
+module Arel
+  module Nodes
+    describe 'table alias' do
+      describe 'equality' do
+        it 'is equal with equal ivars' do
+          relation1 = Table.new(:users)
+          node1     = TableAlias.new relation1, :foo
+          relation2 = Table.new(:users)
+          node2     = TableAlias.new relation2, :foo
+          array = [node1, node2]
+          assert_equal 1, array.uniq.size
+        end
+
+        it 'is not equal with different ivars' do
+          relation1 = Table.new(:users)
+          node1     = TableAlias.new relation1, :foo
+          relation2 = Table.new(:users)
+          node2     = TableAlias.new relation2, :bar
+          array = [node1, node2]
+          assert_equal 2, array.uniq.size
+        end
+      end
+    end
+  end
+end
diff --git a/activerecord/test/cases/arel/nodes/true_test.rb b/activerecord/test/cases/arel/nodes/true_test.rb
new file mode 100644
index 0000000000..198e7b1aa4
--- /dev/null
+++ b/activerecord/test/cases/arel/nodes/true_test.rb
@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+require_relative '../helper'
+
+module Arel
+  module Nodes
+    describe 'True' do
+      describe 'equality' do
+        it 'is equal to other true nodes' do
+          array = [True.new, True.new]
+          assert_equal 1, array.uniq.size
+        end
+
+        it 'is not equal with other nodes' do
+          array = [True.new, Node.new]
+          assert_equal 2, array.uniq.size
+        end
+      end
+    end
+  end
+end
+
+
diff --git a/activerecord/test/cases/arel/nodes/unary_operation_test.rb b/activerecord/test/cases/arel/nodes/unary_operation_test.rb
new file mode 100644
index 0000000000..e76b59c8e1
--- /dev/null
+++ b/activerecord/test/cases/arel/nodes/unary_operation_test.rb
@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+require_relative '../helper'
+
+module Arel
+  module Nodes
+    class TestUnaryOperation < Arel::Test
+      def test_construct
+        operation = UnaryOperation.new :-, 1
+        assert_equal :-, operation.operator
+        assert_equal 1, operation.expr
+      end
+
+      def test_operation_alias
+        operation = UnaryOperation.new :-, 1
+        aliaz = operation.as('zomg')
+        assert_kind_of As, aliaz
+        assert_equal operation, aliaz.left
+        assert_equal 'zomg', aliaz.right
+      end
+
+      def test_operation_ordering
+        operation = UnaryOperation.new :-, 1
+        ordering = operation.desc
+        assert_kind_of Descending, ordering
+        assert_equal operation, ordering.expr
+        assert ordering.descending?
+      end
+
+      def test_equality_with_same_ivars
+        array = [UnaryOperation.new(:-, 1), UnaryOperation.new(:-, 1)]
+        assert_equal 1, array.uniq.size
+      end
+
+      def test_inequality_with_different_ivars
+        array = [UnaryOperation.new(:-, 1), UnaryOperation.new(:-, 2)]
+        assert_equal 2, array.uniq.size
+      end
+    end
+  end
+end
diff --git a/activerecord/test/cases/arel/nodes/update_statement_test.rb b/activerecord/test/cases/arel/nodes/update_statement_test.rb
new file mode 100644
index 0000000000..3a635f75d6
--- /dev/null
+++ b/activerecord/test/cases/arel/nodes/update_statement_test.rb
@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+require_relative '../helper'
+
+describe Arel::Nodes::UpdateStatement do
+  describe "#clone" do
+    it "clones wheres and values" do
+      statement = Arel::Nodes::UpdateStatement.new
+      statement.wheres = %w[a b c]
+      statement.values = %w[x y z]
+
+      dolly = statement.clone
+      dolly.wheres.must_equal statement.wheres
+      dolly.wheres.wont_be_same_as statement.wheres
+
+      dolly.values.must_equal statement.values
+      dolly.values.wont_be_same_as statement.values
+    end
+  end
+
+  describe 'equality' do
+    it 'is equal with equal ivars' do
+      statement1 = Arel::Nodes::UpdateStatement.new
+      statement1.relation = 'zomg'
+      statement1.wheres   = 2
+      statement1.values   = false
+      statement1.orders   = %w[x y z]
+      statement1.limit    = 42
+      statement1.key      = 'zomg'
+      statement2 = Arel::Nodes::UpdateStatement.new
+      statement2.relation = 'zomg'
+      statement2.wheres   = 2
+      statement2.values   = false
+      statement2.orders   = %w[x y z]
+      statement2.limit    = 42
+      statement2.key      = 'zomg'
+      array = [statement1, statement2]
+      assert_equal 1, array.uniq.size
+    end
+
+    it 'is not equal with different ivars' do
+      statement1 = Arel::Nodes::UpdateStatement.new
+      statement1.relation = 'zomg'
+      statement1.wheres   = 2
+      statement1.values   = false
+      statement1.orders   = %w[x y z]
+      statement1.limit    = 42
+      statement1.key      = 'zomg'
+      statement2 = Arel::Nodes::UpdateStatement.new
+      statement2.relation = 'zomg'
+      statement2.wheres   = 2
+      statement2.values   = false
+      statement2.orders   = %w[x y z]
+      statement2.limit    = 42
+      statement2.key      = 'wth'
+      array = [statement1, statement2]
+      assert_equal 2, array.uniq.size
+    end
+  end
+end
diff --git a/activerecord/test/cases/arel/nodes/window_test.rb b/activerecord/test/cases/arel/nodes/window_test.rb
new file mode 100644
index 0000000000..81ecd5ced8
--- /dev/null
+++ b/activerecord/test/cases/arel/nodes/window_test.rb
@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+require_relative '../helper'
+
+module Arel
+  module Nodes
+    describe 'Window' do
+      describe 'equality' do
+        it 'is equal with equal ivars' do
+          window1 = Window.new
+          window1.orders = [1, 2]
+          window1.partitions = [1]
+          window1.frame 3
+          window2 = Window.new
+          window2.orders = [1, 2]
+          window2.partitions = [1]
+          window2.frame 3
+          array = [window1, window2]
+          assert_equal 1, array.uniq.size
+        end
+
+        it 'is not equal with different ivars' do
+          window1 = Window.new
+          window1.orders = [1, 2]
+          window1.partitions = [1]
+          window1.frame 3
+          window2 = Window.new
+          window2.orders = [1, 2]
+          window1.partitions = [1]
+          window2.frame 4
+          array = [window1, window2]
+          assert_equal 2, array.uniq.size
+        end
+      end
+    end
+
+    describe 'NamedWindow' do
+      describe 'equality' do
+        it 'is equal with equal ivars' do
+          window1 = NamedWindow.new 'foo'
+          window1.orders = [1, 2]
+          window1.partitions = [1]
+          window1.frame 3
+          window2 = NamedWindow.new 'foo'
+          window2.orders = [1, 2]
+          window2.partitions = [1]
+          window2.frame 3
+          array = [window1, window2]
+          assert_equal 1, array.uniq.size
+        end
+
+        it 'is not equal with different ivars' do
+          window1 = NamedWindow.new 'foo'
+          window1.orders = [1, 2]
+          window1.partitions = [1]
+          window1.frame 3
+          window2 = NamedWindow.new 'bar'
+          window2.orders = [1, 2]
+          window2.partitions = [1]
+          window2.frame 3
+          array = [window1, window2]
+          assert_equal 2, array.uniq.size
+        end
+      end
+    end
+
+    describe 'CurrentRow' do
+      describe 'equality' do
+        it 'is equal to other current row nodes' do
+          array = [CurrentRow.new, CurrentRow.new]
+          assert_equal 1, array.uniq.size
+        end
+
+        it 'is not equal with other nodes' do
+          array = [CurrentRow.new, Node.new]
+          assert_equal 2, array.uniq.size
+        end
+      end
+    end
+  end
+end
diff --git a/activerecord/test/cases/arel/nodes_test.rb b/activerecord/test/cases/arel/nodes_test.rb
new file mode 100644
index 0000000000..1934ef4c3b
--- /dev/null
+++ b/activerecord/test/cases/arel/nodes_test.rb
@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+require_relative 'helper'
+
+module Arel
+  module Nodes
+    class TestNodes < Arel::Test
+      def test_every_arel_nodes_have_hash_eql_eqeq_from_same_class
+        # #descendants code from activesupport
+        node_descendants = []
+        ObjectSpace.each_object(Arel::Nodes::Node.singleton_class) do |k|
+          next if k.respond_to?(:singleton_class?) && k.singleton_class?
+          node_descendants.unshift k unless k == self
+        end
+        node_descendants.delete(Arel::Nodes::Node)
+        node_descendants.delete(Arel::Nodes::NodeExpression)
+
+        bad_node_descendants = node_descendants.reject do |subnode|
+          eqeq_owner = subnode.instance_method(:==).owner
+          eql_owner = subnode.instance_method(:eql?).owner
+          hash_owner = subnode.instance_method(:hash).owner
+
+          eqeq_owner < Arel::Nodes::Node &&
+              eqeq_owner == eql_owner &&
+              eqeq_owner == hash_owner
+        end
+
+        problem_msg = 'Some subclasses of Arel::Nodes::Node do not have a' \
+            ' #== or #eql? or #hash defined from the same class as the others'
+        assert_empty bad_node_descendants, problem_msg
+      end
+
+
+    end
+  end
+end
diff --git a/activerecord/test/cases/arel/select_manager_test.rb b/activerecord/test/cases/arel/select_manager_test.rb
new file mode 100644
index 0000000000..e9056953d8
--- /dev/null
+++ b/activerecord/test/cases/arel/select_manager_test.rb
@@ -0,0 +1,1236 @@
+# frozen_string_literal: true
+require_relative 'helper'
+
+module Arel
+
+  class SelectManagerTest < Arel::Spec
+    def test_join_sources
+      manager = Arel::SelectManager.new
+      manager.join_sources << Arel::Nodes::StringJoin.new(Nodes.build_quoted('foo'))
+      assert_equal "SELECT FROM 'foo'", manager.to_sql
+    end
+
+    describe 'backwards compatibility' do
+      describe 'project' do
+        it 'accepts symbols as sql literals' do
+          table   = Table.new :users
+          manager = Arel::SelectManager.new
+          manager.project :id
+          manager.from table
+          manager.to_sql.must_be_like %{
+            SELECT id FROM "users"
+          }
+        end
+      end
+
+      describe 'order' do
+        it 'accepts symbols' do
+          table   = Table.new :users
+          manager = Arel::SelectManager.new
+          manager.project Nodes::SqlLiteral.new '*'
+          manager.from table
+          manager.order :foo
+          manager.to_sql.must_be_like %{ SELECT * FROM "users" ORDER BY foo }
+        end
+      end
+
+      describe 'group' do
+        it 'takes a symbol' do
+          table   = Table.new :users
+          manager = Arel::SelectManager.new
+          manager.from table
+          manager.group :foo
+          manager.to_sql.must_be_like %{ SELECT FROM "users" GROUP BY foo }
+        end
+      end
+
+      describe 'as' do
+        it 'makes an AS node by grouping the AST' do
+          manager = Arel::SelectManager.new
+          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
+          as = manager.as('foo')
+          assert_kind_of Arel::Nodes::SqlLiteral, as.right
+        end
+
+        it 'can make a subselect' do
+          manager = Arel::SelectManager.new
+          manager.project Arel.star
+          manager.from Arel.sql('zomg')
+          as = manager.as(Arel.sql('foo'))
+
+          manager = Arel::SelectManager.new
+          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
+          manager = Arel::SelectManager.new
+
+          manager.from table
+          manager.from 'users'
+          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
+
+          manager2 = Arel::SelectManager.new
+          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
+        it 'converts strings to SQLLiterals' do
+          table   = Table.new :users
+          mgr = table.from
+          mgr.having Arel.sql('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
+          mgr.having Arel.sql('foo')
+          mgr.having Arel.sql('bar')
+          mgr.to_sql.must_be_like %{ SELECT FROM "users" HAVING foo AND bar }
+        end
+
+        it 'can receive any node' do
+          table = Table.new :users
+          mgr = table.from
+          mgr.having Arel::Nodes::And.new([Arel.sql('foo'), Arel.sql('bar')])
+          mgr.to_sql.must_be_like %{ SELECT FROM "users" HAVING foo AND bar }
+        end
+      end
+
+      describe 'on' do
+        it 'converts to sqlliterals' do
+          table = Table.new :users
+          right = table.alias
+          mgr   = table.from
+          mgr.join(right).on("omg")
+          mgr.to_sql.must_be_like %{ SELECT  FROM "users" INNER JOIN "users" "users_2" ON omg }
+        end
+
+        it 'converts to sqlliterals with multiple items' do
+          table = Table.new :users
+          right = table.alias
+          mgr   = table.from
+          mgr.join(right).on("omg", "123")
+          mgr.to_sql.must_be_like %{ SELECT  FROM "users" INNER JOIN "users" "users_2" ON omg AND 123 }
+        end
+      end
+    end
+
+    describe 'clone' do
+      it 'creates new cores' do
+        table   = Table.new :users, :as => 'foo'
+        mgr = table.from
+        m2 = mgr.clone
+        m2.project "foo"
+        mgr.to_sql.wont_equal m2.to_sql
+      end
+
+      it 'makes updates to the correct copy' do
+        table   = Table.new :users, :as => 'foo'
+        mgr = table.from
+        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
+      it 'uses alias in sql' do
+        table   = Table.new :users, :as => 'foo'
+        mgr = table.from
+        mgr.skip 10
+        mgr.to_sql.must_be_like %{ SELECT FROM "users" "foo" OFFSET 10 }
+      end
+    end
+
+    describe 'skip' do
+      it 'should add an offset' do
+        table   = Table.new :users
+        mgr = table.from
+        mgr.skip 10
+        mgr.to_sql.must_be_like %{ SELECT FROM "users" OFFSET 10 }
+      end
+
+      it 'should chain' do
+        table   = Table.new :users
+        mgr = table.from
+        mgr.skip(10).to_sql.must_be_like %{ SELECT FROM "users" OFFSET 10 }
+      end
+    end
+
+    describe 'offset' do
+      it 'should add an offset' do
+        table   = Table.new :users
+        mgr = table.from
+        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
+        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
+        mgr.offset = 10
+        assert_equal 10, mgr.offset
+      end
+    end
+
+    describe 'exists' do
+      it 'should create an exists clause' do
+        table = Table.new(:users)
+        manager = Arel::SelectManager.new table
+        manager.project Nodes::SqlLiteral.new '*'
+        m2 = Arel::SelectManager.new
+        m2.project manager.exists
+        m2.to_sql.must_be_like %{ SELECT EXISTS (#{manager.to_sql}) }
+      end
+
+      it 'can be aliased' do
+        table = Table.new(:users)
+        manager = Arel::SelectManager.new table
+        manager.project Nodes::SqlLiteral.new '*'
+        m2 = Arel::SelectManager.new
+        m2.project manager.exists.as('foo')
+        m2.to_sql.must_be_like %{ SELECT EXISTS (#{manager.to_sql}) AS foo }
+      end
+    end
+
+    describe 'union' do
+      before do
+        table = Table.new :users
+        @m1 = Arel::SelectManager.new table
+        @m1.project Arel.star
+        @m1.where(table[:age].lt(18))
+
+        @m2 = Arel::SelectManager.new 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
+        @m1.project Arel.star
+        @m1.where(table[:age].gt(18))
+
+        @m2 = Arel::SelectManager.new 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
+        @m1.project Arel.star
+        @m1.where(table[:age].between(18..60))
+
+        @m2 = Arel::SelectManager.new table
+        @m2.project Arel.star
+        @m2.where(table[:age].between(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 basic WITH' do
+        users          = Table.new(:users)
+        users_top      = Table.new(:users_top)
+        comments       = Table.new(:comments)
+
+        top            = users.project(users[:id]).where(users[:karma].gt(100))
+        users_as       = Arel::Nodes::As.new(users_top, top)
+        select_manager = comments.project(Arel.star).with(users_as)
+                          .where(comments[:author_id].in(users_top.project(users_top[:id])))
+
+        select_manager.to_sql.must_be_like %{
+          WITH "users_top" AS (SELECT "users"."id" FROM "users" WHERE "users"."karma" > 100) SELECT * FROM "comments" WHERE "comments"."author_id" IN (SELECT "users_top"."id" FROM "users_top")
+        }
+      end
+
+      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
+        recursive_term.from(comments).project(comments_id, comments_parent_id).where(comments_id.eq 42)
+
+        non_recursive_term = Arel::SelectManager.new
+        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
+        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
+        mgr = table.from
+        assert mgr.ast
+      end
+
+      it 'should allow orders to work when the ast is grepped' do
+        table   = Table.new :users
+        mgr = table.from
+        mgr.project Arel.sql '*'
+        mgr.from table
+        mgr.orders << Arel::Nodes::Ascending.new(Arel.sql('foo'))
+        mgr.ast.grep(Arel::Nodes::OuterJoin)
+        mgr.to_sql.must_be_like %{ SELECT * FROM "users" ORDER BY foo ASC }
+      end
+    end
+
+    describe 'taken' do
+      it 'should return limit' do
+        manager = Arel::SelectManager.new
+        manager.take 10
+        manager.taken.must_equal 10
+      end
+    end
+
+    describe 'lock' do
+      # This should fail on other databases
+      it 'adds a lock node' do
+        table   = Table.new :users
+        mgr = table.from
+        mgr.lock.to_sql.must_be_like %{ SELECT FROM "users" FOR UPDATE }
+      end
+    end
+
+    describe 'orders' do
+      it 'returns order clauses' do
+        table   = Table.new :users
+        manager = Arel::SelectManager.new
+        order = table[:id]
+        manager.order table[:id]
+        manager.orders.must_equal [order]
+      end
+    end
+
+    describe 'order' do
+      it 'generates order clauses' do
+        table   = Table.new :users
+        manager = Arel::SelectManager.new
+        manager.project Nodes::SqlLiteral.new '*'
+        manager.from table
+        manager.order table[:id]
+        manager.to_sql.must_be_like %{
+          SELECT * FROM "users" ORDER BY "users"."id"
+        }
+      end
+
+      # FIXME: I would like to deprecate this
+      it 'takes *args' do
+        table   = Table.new :users
+        manager = Arel::SelectManager.new
+        manager.project Nodes::SqlLiteral.new '*'
+        manager.from table
+        manager.order table[:id], table[:name]
+        manager.to_sql.must_be_like %{
+          SELECT * FROM "users" ORDER BY "users"."id", "users"."name"
+        }
+      end
+
+      it 'chains' do
+        table   = Table.new :users
+        manager = Arel::SelectManager.new
+        manager.order(table[:id]).must_equal manager
+      end
+
+      it 'has order attributes' do
+        table   = Table.new :users
+        manager = Arel::SelectManager.new
+        manager.project Nodes::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
+    end
+
+    describe 'on' do
+      it 'takes two params' do
+        left      = Table.new :users
+        right     = left.alias
+        predicate = left[:id].eq(right[:id])
+        manager   = Arel::SelectManager.new
+
+        manager.from left
+        manager.join(right).on(predicate, predicate)
+        manager.to_sql.must_be_like %{
+           SELECT FROM "users"
+             INNER JOIN "users" "users_2"
+               ON "users"."id" = "users_2"."id" AND
+               "users"."id" = "users_2"."id"
+        }
+      end
+
+      it 'takes three params' do
+        left      = Table.new :users
+        right     = left.alias
+        predicate = left[:id].eq(right[:id])
+        manager   = Arel::SelectManager.new
+
+        manager.from left
+        manager.join(right).on(
+          predicate,
+          predicate,
+          left[:name].eq(right[:name])
+        )
+        manager.to_sql.must_be_like %{
+           SELECT FROM "users"
+             INNER JOIN "users" "users_2"
+               ON "users"."id" = "users_2"."id" AND
+               "users"."id" = "users_2"."id" AND
+               "users"."name" = "users_2"."name"
+        }
+      end
+    end
+
+    it 'should hand back froms' do
+      relation = Arel::SelectManager.new
+      assert_equal [], relation.froms
+    end
+
+    it 'should create and nodes' do
+      relation = Arel::SelectManager.new
+      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
+      insert = relation.create_insert
+      assert_kind_of Arel::InsertManager, insert
+    end
+
+    it 'should create join nodes' do
+      relation = Arel::SelectManager.new
+      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 full outer join klass' do
+      relation = Arel::SelectManager.new
+      join = relation.create_join 'foo', 'bar', Arel::Nodes::FullOuterJoin
+      assert_kind_of Arel::Nodes::FullOuterJoin, join
+      assert_equal 'foo', join.left
+      assert_equal 'bar', join.right
+    end
+
+    it 'should create join nodes with a outer join klass' do
+      relation = Arel::SelectManager.new
+      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
+
+    it 'should create join nodes with a right outer join klass' do
+      relation = Arel::SelectManager.new
+      join = relation.create_join 'foo', 'bar', Arel::Nodes::RightOuterJoin
+      assert_kind_of Arel::Nodes::RightOuterJoin, join
+      assert_equal 'foo', join.left
+      assert_equal 'bar', join.right
+    end
+
+    describe 'join' do
+      it 'responds to join' do
+        left      = Table.new :users
+        right     = left.alias
+        predicate = left[:id].eq(right[:id])
+        manager   = Arel::SelectManager.new
+
+        manager.from left
+        manager.join(right).on(predicate)
+        manager.to_sql.must_be_like %{
+           SELECT FROM "users"
+             INNER JOIN "users" "users_2"
+               ON "users"."id" = "users_2"."id"
+        }
+      end
+
+      it 'takes a class' do
+        left      = Table.new :users
+        right     = left.alias
+        predicate = left[:id].eq(right[:id])
+        manager   = Arel::SelectManager.new
+
+        manager.from left
+        manager.join(right, Nodes::OuterJoin).on(predicate)
+        manager.to_sql.must_be_like %{
+           SELECT FROM "users"
+             LEFT OUTER JOIN "users" "users_2"
+               ON "users"."id" = "users_2"."id"
+        }
+      end
+
+      it 'takes the full outer join class' do
+        left      = Table.new :users
+        right     = left.alias
+        predicate = left[:id].eq(right[:id])
+        manager   = Arel::SelectManager.new
+
+        manager.from left
+        manager.join(right, Nodes::FullOuterJoin).on(predicate)
+        manager.to_sql.must_be_like %{
+           SELECT FROM "users"
+             FULL OUTER JOIN "users" "users_2"
+               ON "users"."id" = "users_2"."id"
+        }
+      end
+
+      it 'takes the right outer join class' do
+        left      = Table.new :users
+        right     = left.alias
+        predicate = left[:id].eq(right[:id])
+        manager   = Arel::SelectManager.new
+
+        manager.from left
+        manager.join(right, Nodes::RightOuterJoin).on(predicate)
+        manager.to_sql.must_be_like %{
+           SELECT FROM "users"
+             RIGHT OUTER JOIN "users" "users_2"
+               ON "users"."id" = "users_2"."id"
+        }
+      end
+
+      it 'noops on nil' do
+        manager   = Arel::SelectManager.new
+        manager.join(nil).must_equal manager
+      end
+
+      it 'raises EmptyJoinError on empty' do
+        left      = Table.new :users
+        manager   = Arel::SelectManager.new
+
+        manager.from left
+        assert_raises(EmptyJoinError) do
+          manager.join("")
+        end
+      end
+    end
+
+    describe 'outer join' do
+      it 'responds to join' do
+        left      = Table.new :users
+        right     = left.alias
+        predicate = left[:id].eq(right[:id])
+        manager   = Arel::SelectManager.new
+
+        manager.from left
+        manager.outer_join(right).on(predicate)
+        manager.to_sql.must_be_like %{
+           SELECT FROM "users"
+             LEFT OUTER JOIN "users" "users_2"
+               ON "users"."id" = "users_2"."id"
+        }
+      end
+
+      it 'noops on nil' do
+        manager   = Arel::SelectManager.new
+        manager.outer_join(nil).must_equal manager
+      end
+    end
+
+    describe 'joins' do
+
+      it 'returns inner join sql' do
+        table   = Table.new :users
+        aliaz   = table.alias
+        manager = Arel::SelectManager.new
+        manager.from Nodes::InnerJoin.new(aliaz, table[:id].eq(aliaz[:id]))
+        assert_match 'INNER JOIN "users" "users_2" "users"."id" = "users_2"."id"',
+                     manager.to_sql
+      end
+
+      it 'returns outer join sql' do
+        table   = Table.new :users
+        aliaz   = table.alias
+        manager = Arel::SelectManager.new
+        manager.from Nodes::OuterJoin.new(aliaz, table[:id].eq(aliaz[:id]))
+        assert_match 'LEFT OUTER JOIN "users" "users_2" "users"."id" = "users_2"."id"',
+                     manager.to_sql
+      end
+
+      it 'can have a non-table alias as relation name' do
+        users    = Table.new :users
+        comments = Table.new :comments
+
+        counts = comments.from.
+          group(comments[:user_id]).
+          project(
+            comments[:user_id].as("user_id"),
+            comments[:user_id].count.as("count")
+          ).as("counts")
+
+        joins = users.join(counts).on(counts[:user_id].eq(10))
+        joins.to_sql.must_be_like  %{
+          SELECT FROM "users" INNER JOIN (SELECT "comments"."user_id" AS user_id, COUNT("comments"."user_id") AS count FROM "comments" GROUP BY "comments"."user_id") counts ON counts."user_id" = 10
+        }
+      end
+
+      it "joins itself" do
+        left      = Table.new :users
+        right     = left.alias
+        predicate = left[:id].eq(right[:id])
+
+        mgr = left.join(right)
+        mgr.project Nodes::SqlLiteral.new('*')
+        mgr.on(predicate).must_equal mgr
+
+        mgr.to_sql.must_be_like %{
+           SELECT * FROM "users"
+             INNER JOIN "users" "users_2"
+               ON "users"."id" = "users_2"."id"
+        }
+      end
+
+      it 'returns string join sql' do
+        manager = Arel::SelectManager.new
+        manager.from Nodes::StringJoin.new(Nodes.build_quoted('hello'))
+        assert_match "'hello'", manager.to_sql
+      end
+    end
+
+    describe 'group' do
+      it 'takes an attribute' do
+        table   = Table.new :users
+        manager = Arel::SelectManager.new
+        manager.from table
+        manager.group table[:id]
+        manager.to_sql.must_be_like %{
+          SELECT FROM "users" GROUP BY "users"."id"
+        }
+      end
+
+      it 'chains' do
+        table   = Table.new :users
+        manager = Arel::SelectManager.new
+        manager.group(table[:id]).must_equal manager
+      end
+
+      it 'takes multiple args' do
+        table   = Table.new :users
+        manager = Arel::SelectManager.new
+        manager.from table
+        manager.group table[:id], table[:name]
+        manager.to_sql.must_be_like %{
+          SELECT FROM "users" GROUP BY "users"."id", "users"."name"
+        }
+      end
+
+      # FIXME: backwards compat
+      it 'makes strings literals' do
+        table   = Table.new :users
+        manager = Arel::SelectManager.new
+        manager.from table
+        manager.group 'foo'
+        manager.to_sql.must_be_like %{ SELECT FROM "users" GROUP BY foo }
+      end
+    end
+
+    describe 'window definition' do
+      it 'can be empty' do
+        table   = Table.new :users
+        manager = Arel::SelectManager.new
+        manager.from table
+        manager.window('a_window')
+        manager.to_sql.must_be_like %{
+          SELECT FROM "users" WINDOW "a_window" AS ()
+        }
+      end
+
+      it 'takes an order' do
+        table   = Table.new :users
+        manager = Arel::SelectManager.new
+        manager.from table
+        manager.window('a_window').order(table['foo'].asc)
+        manager.to_sql.must_be_like %{
+          SELECT FROM "users" WINDOW "a_window" AS (ORDER BY "users"."foo" ASC)
+        }
+      end
+
+      it 'takes an order with multiple columns' do
+        table   = Table.new :users
+        manager = Arel::SelectManager.new
+        manager.from table
+        manager.window('a_window').order(table['foo'].asc, table['bar'].desc)
+        manager.to_sql.must_be_like %{
+          SELECT FROM "users" WINDOW "a_window" AS (ORDER BY "users"."foo" ASC, "users"."bar" DESC)
+        }
+      end
+
+      it 'takes a partition' do
+        table   = Table.new :users
+        manager = Arel::SelectManager.new
+        manager.from table
+        manager.window('a_window').partition(table['bar'])
+        manager.to_sql.must_be_like %{
+          SELECT FROM "users" WINDOW "a_window" AS (PARTITION BY "users"."bar")
+        }
+      end
+
+      it 'takes a partition and an order' do
+        table   = Table.new :users
+        manager = Arel::SelectManager.new
+        manager.from table
+        manager.window('a_window').partition(table['foo']).order(table['foo'].asc)
+        manager.to_sql.must_be_like %{
+          SELECT FROM "users" WINDOW "a_window" AS (PARTITION BY "users"."foo"
+            ORDER BY "users"."foo" ASC)
+        }
+      end
+
+      it 'takes a partition with multiple columns' do
+        table   = Table.new :users
+        manager = Arel::SelectManager.new
+        manager.from table
+        manager.window('a_window').partition(table['bar'], table['baz'])
+        manager.to_sql.must_be_like %{
+          SELECT FROM "users" WINDOW "a_window" AS (PARTITION BY "users"."bar", "users"."baz")
+        }
+      end
+
+      it 'takes a rows frame, unbounded preceding' do
+        table   = Table.new :users
+        manager = Arel::SelectManager.new
+        manager.from table
+        manager.window('a_window').rows(Arel::Nodes::Preceding.new)
+        manager.to_sql.must_be_like %{
+          SELECT FROM "users" WINDOW "a_window" AS (ROWS UNBOUNDED PRECEDING)
+        }
+      end
+
+      it 'takes a rows frame, bounded preceding' do
+        table   = Table.new :users
+        manager = Arel::SelectManager.new
+        manager.from table
+        manager.window('a_window').rows(Arel::Nodes::Preceding.new(5))
+        manager.to_sql.must_be_like %{
+          SELECT FROM "users" WINDOW "a_window" AS (ROWS 5 PRECEDING)
+        }
+      end
+
+      it 'takes a rows frame, unbounded following' do
+        table   = Table.new :users
+        manager = Arel::SelectManager.new
+        manager.from table
+        manager.window('a_window').rows(Arel::Nodes::Following.new)
+        manager.to_sql.must_be_like %{
+          SELECT FROM "users" WINDOW "a_window" AS (ROWS UNBOUNDED FOLLOWING)
+        }
+      end
+
+      it 'takes a rows frame, bounded following' do
+        table   = Table.new :users
+        manager = Arel::SelectManager.new
+        manager.from table
+        manager.window('a_window').rows(Arel::Nodes::Following.new(5))
+        manager.to_sql.must_be_like %{
+          SELECT FROM "users" WINDOW "a_window" AS (ROWS 5 FOLLOWING)
+        }
+      end
+
+      it 'takes a rows frame, current row' do
+        table   = Table.new :users
+        manager = Arel::SelectManager.new
+        manager.from table
+        manager.window('a_window').rows(Arel::Nodes::CurrentRow.new)
+        manager.to_sql.must_be_like %{
+          SELECT FROM "users" WINDOW "a_window" AS (ROWS CURRENT ROW)
+        }
+      end
+
+      it 'takes a rows frame, between two delimiters' do
+        table   = Table.new :users
+        manager = Arel::SelectManager.new
+        manager.from table
+        window = manager.window('a_window')
+        window.frame(
+          Arel::Nodes::Between.new(
+            window.rows,
+            Nodes::And.new([
+              Arel::Nodes::Preceding.new,
+              Arel::Nodes::CurrentRow.new
+            ])))
+        manager.to_sql.must_be_like %{
+          SELECT FROM "users" WINDOW "a_window" AS (ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)
+        }
+      end
+
+      it 'takes a range frame, unbounded preceding' do
+        table   = Table.new :users
+        manager = Arel::SelectManager.new
+        manager.from table
+        manager.window('a_window').range(Arel::Nodes::Preceding.new)
+        manager.to_sql.must_be_like %{
+          SELECT FROM "users" WINDOW "a_window" AS (RANGE UNBOUNDED PRECEDING)
+        }
+      end
+
+      it 'takes a range frame, bounded preceding' do
+        table   = Table.new :users
+        manager = Arel::SelectManager.new
+        manager.from table
+        manager.window('a_window').range(Arel::Nodes::Preceding.new(5))
+        manager.to_sql.must_be_like %{
+          SELECT FROM "users" WINDOW "a_window" AS (RANGE 5 PRECEDING)
+        }
+      end
+
+      it 'takes a range frame, unbounded following' do
+        table   = Table.new :users
+        manager = Arel::SelectManager.new
+        manager.from table
+        manager.window('a_window').range(Arel::Nodes::Following.new)
+        manager.to_sql.must_be_like %{
+          SELECT FROM "users" WINDOW "a_window" AS (RANGE UNBOUNDED FOLLOWING)
+        }
+      end
+
+      it 'takes a range frame, bounded following' do
+        table   = Table.new :users
+        manager = Arel::SelectManager.new
+        manager.from table
+        manager.window('a_window').range(Arel::Nodes::Following.new(5))
+        manager.to_sql.must_be_like %{
+          SELECT FROM "users" WINDOW "a_window" AS (RANGE 5 FOLLOWING)
+        }
+      end
+
+      it 'takes a range frame, current row' do
+        table   = Table.new :users
+        manager = Arel::SelectManager.new
+        manager.from table
+        manager.window('a_window').range(Arel::Nodes::CurrentRow.new)
+        manager.to_sql.must_be_like %{
+          SELECT FROM "users" WINDOW "a_window" AS (RANGE CURRENT ROW)
+        }
+      end
+
+      it 'takes a range frame, between two delimiters' do
+        table   = Table.new :users
+        manager = Arel::SelectManager.new
+        manager.from table
+        window = manager.window('a_window')
+        window.frame(
+          Arel::Nodes::Between.new(
+            window.range,
+            Nodes::And.new([
+              Arel::Nodes::Preceding.new,
+              Arel::Nodes::CurrentRow.new
+            ])))
+        manager.to_sql.must_be_like %{
+          SELECT FROM "users" WINDOW "a_window" AS (RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)
+        }
+      end
+    end
+
+    describe 'delete' do
+      it "copies from" do
+        table   = Table.new :users
+        manager = Arel::SelectManager.new
+        manager.from table
+        stmt = manager.compile_delete
+
+        stmt.to_sql.must_be_like %{ DELETE FROM "users" }
+      end
+
+      it "copies where" do
+        table   = Table.new :users
+        manager = Arel::SelectManager.new
+        manager.from table
+        manager.where table[:id].eq 10
+        stmt = manager.compile_delete
+
+        stmt.to_sql.must_be_like %{
+          DELETE FROM "users" WHERE "users"."id" = 10
+        }
+      end
+    end
+
+    describe 'where_sql' do
+      it 'gives me back the where sql' do
+        table   = Table.new :users
+        manager = Arel::SelectManager.new
+        manager.from table
+        manager.where table[:id].eq 10
+        manager.where_sql.must_be_like %{ WHERE "users"."id" = 10 }
+      end
+
+      it 'joins wheres with AND' do
+        table   = Table.new :users
+        manager = Arel::SelectManager.new
+        manager.from table
+        manager.where table[:id].eq 10
+        manager.where table[:id].eq 11
+        manager.where_sql.must_be_like %{ WHERE "users"."id" = 10 AND "users"."id" = 11}
+      end
+
+      it 'handles database specific statements' do
+        old_visitor = Table.engine.connection.visitor
+        Table.engine.connection.visitor = Visitors::PostgreSQL.new Table.engine.connection
+        table   = Table.new :users
+        manager = Arel::SelectManager.new
+        manager.from table
+        manager.where table[:id].eq 10
+        manager.where table[:name].matches 'foo%'
+        manager.where_sql.must_be_like %{ WHERE "users"."id" = 10 AND "users"."name" ILIKE 'foo%' }
+        Table.engine.connection.visitor = old_visitor
+      end
+
+      it 'returns nil when there are no wheres' do
+        table   = Table.new :users
+        manager = Arel::SelectManager.new
+        manager.from table
+        manager.where_sql.must_be_nil
+      end
+    end
+
+    describe 'update' do
+
+      it 'creates an update statement' do
+        table   = Table.new :users
+        manager = Arel::SelectManager.new
+        manager.from table
+        stmt = manager.compile_update({table[:id] => 1}, Arel::Attributes::Attribute.new(table, 'id'))
+
+        stmt.to_sql.must_be_like %{
+          UPDATE "users" SET "id" = 1
+        }
+      end
+
+      it 'takes a string' do
+        table   = Table.new :users
+        manager = Arel::SelectManager.new
+        manager.from table
+        stmt = manager.compile_update(Nodes::SqlLiteral.new('foo = bar'), Arel::Attributes::Attribute.new(table, 'id'))
+
+        stmt.to_sql.must_be_like %{ UPDATE "users" SET foo = bar }
+      end
+
+      it 'copies limits' do
+        table   = Table.new :users
+        manager = Arel::SelectManager.new
+        manager.from table
+        manager.take 1
+        stmt = manager.compile_update(Nodes::SqlLiteral.new('foo = bar'), Arel::Attributes::Attribute.new(table, 'id'))
+        stmt.key = table['id']
+
+        stmt.to_sql.must_be_like %{
+          UPDATE "users" SET foo = bar
+          WHERE "users"."id" IN (SELECT "users"."id" FROM "users" LIMIT 1)
+        }
+      end
+
+      it 'copies order' do
+        table   = Table.new :users
+        manager = Arel::SelectManager.new
+        manager.from table
+        manager.order :foo
+        stmt = manager.compile_update(Nodes::SqlLiteral.new('foo = bar'), Arel::Attributes::Attribute.new(table, 'id'))
+        stmt.key = table['id']
+
+        stmt.to_sql.must_be_like %{
+          UPDATE "users" SET foo = bar
+          WHERE "users"."id" IN (SELECT "users"."id" FROM "users" ORDER BY foo)
+        }
+      end
+
+      it 'copies where clauses' do
+        table   = Table.new :users
+        manager = Arel::SelectManager.new
+        manager.where table[:id].eq 10
+        manager.from table
+        stmt = manager.compile_update({table[:id] => 1}, Arel::Attributes::Attribute.new(table, 'id'))
+
+        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
+        table   = Table.new :users
+        manager = Arel::SelectManager.new
+        manager.where table[:foo].eq 10
+        manager.take 42
+        manager.from table
+        stmt = manager.compile_update({table[:id] => 1}, Arel::Attributes::Attribute.new(table, 'id'))
+
+        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
+
+    end
+
+    describe 'project' do
+      it "takes sql literals" do
+        manager = Arel::SelectManager.new
+        manager.project Nodes::SqlLiteral.new '*'
+        manager.to_sql.must_be_like %{ SELECT * }
+      end
+
+      it 'takes multiple args' do
+        manager = Arel::SelectManager.new
+        manager.project Nodes::SqlLiteral.new('foo'),
+          Nodes::SqlLiteral.new('bar')
+        manager.to_sql.must_be_like %{ SELECT foo, bar }
+      end
+
+      it 'takes strings' do
+        manager = Arel::SelectManager.new
+        manager.project '*'
+        manager.to_sql.must_be_like %{ SELECT * }
+      end
+
+    end
+
+    describe 'projections' do
+      it 'reads projections' do
+        manager = Arel::SelectManager.new
+        manager.project Arel.sql('foo'), Arel.sql('bar')
+        manager.projections.must_equal [Arel.sql('foo'), Arel.sql('bar')]
+      end
+    end
+
+    describe 'projections=' do
+      it 'overwrites projections' do
+        manager = Arel::SelectManager.new
+        manager.project Arel.sql('foo')
+        manager.projections = [Arel.sql('bar')]
+        manager.to_sql.must_be_like %{ SELECT bar }
+      end
+    end
+
+    describe 'take' do
+      it "knows take" do
+        table   = Table.new :users
+        manager = Arel::SelectManager.new
+        manager.from(table).project(table['id'])
+        manager.where(table['id'].eq(1))
+        manager.take 1
+
+        manager.to_sql.must_be_like %{
+          SELECT "users"."id"
+          FROM "users"
+          WHERE "users"."id" = 1
+          LIMIT 1
+        }
+      end
+
+      it "chains" do
+        manager = Arel::SelectManager.new
+        manager.take(1).must_equal manager
+      end
+
+      it 'removes LIMIT when nil is passed' do
+        manager = Arel::SelectManager.new
+        manager.limit = 10
+        assert_match('LIMIT', manager.to_sql)
+
+        manager.limit = nil
+        refute_match('LIMIT', manager.to_sql)
+      end
+    end
+
+    describe 'where' do
+      it "knows where" do
+        table   = Table.new :users
+        manager = Arel::SelectManager.new
+        manager.from(table).project(table['id'])
+        manager.where(table['id'].eq(1))
+        manager.to_sql.must_be_like %{
+          SELECT "users"."id"
+          FROM "users"
+          WHERE "users"."id" = 1
+        }
+      end
+
+      it "chains" do
+        table   = Table.new :users
+        manager = Arel::SelectManager.new
+        manager.from(table)
+        manager.project(table['id']).where(table['id'].eq 1).must_equal manager
+      end
+    end
+
+    describe 'from' do
+      it "makes sql" do
+        table   = Table.new :users
+        manager = Arel::SelectManager.new
+
+        manager.from table
+        manager.project table['id']
+        manager.to_sql.must_be_like 'SELECT "users"."id" FROM "users"'
+      end
+
+      it "chains" do
+        table   = Table.new :users
+        manager = Arel::SelectManager.new
+        manager.from(table).project(table['id']).must_equal manager
+        manager.to_sql.must_be_like 'SELECT "users"."id" FROM "users"'
+      end
+    end
+
+    describe 'source' do
+      it 'returns the join source of the select core' do
+        manager = Arel::SelectManager.new
+        manager.source.must_equal manager.ast.cores.last.source
+      end
+    end
+
+    describe 'distinct' do
+      it 'sets the quantifier' do
+        manager = Arel::SelectManager.new
+
+        manager.distinct
+        manager.ast.cores.last.set_quantifier.class.must_equal Arel::Nodes::Distinct
+
+        manager.distinct(false)
+        manager.ast.cores.last.set_quantifier.must_be_nil
+      end
+
+      it "chains" do
+        manager = Arel::SelectManager.new
+        manager.distinct.must_equal manager
+        manager.distinct(false).must_equal manager
+      end
+    end
+
+    describe 'distinct_on' do
+      it 'sets the quantifier' do
+        manager = Arel::SelectManager.new
+        table = Table.new :users
+
+        manager.distinct_on(table['id'])
+        manager.ast.cores.last.set_quantifier.must_equal Arel::Nodes::DistinctOn.new(table['id'])
+
+        manager.distinct_on(false)
+        manager.ast.cores.last.set_quantifier.must_be_nil
+      end
+
+      it "chains" do
+        manager = Arel::SelectManager.new
+        table = Table.new :users
+
+        manager.distinct_on(table['id']).must_equal manager
+        manager.distinct_on(false).must_equal manager
+      end
+    end
+  end
+end
diff --git a/activerecord/test/cases/arel/support/fake_record.rb b/activerecord/test/cases/arel/support/fake_record.rb
new file mode 100644
index 0000000000..75ac1e072f
--- /dev/null
+++ b/activerecord/test/cases/arel/support/fake_record.rb
@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+require 'date'
+module FakeRecord
+  class Column < Struct.new(:name, :type)
+  end
+
+  class Connection
+    attr_reader :tables
+    attr_accessor :visitor
+
+    def initialize(visitor = nil)
+      @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)
+        ],
+        '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',
+        'products' => 'id'
+      }
+      @visitor = visitor
+    end
+
+    def columns_hash table_name
+      @columns_hash[table_name]
+    end
+
+    def primary_key name
+      @primary_keys[name.to_s]
+    end
+
+    def data_source_exists? name
+      @tables.include? name.to_s
+    end
+
+    def columns name, message = nil
+      @columns[name.to_s]
+    end
+
+    def quote_table_name name
+      "\"#{name.to_s}\""
+    end
+
+    def quote_column_name name
+      "\"#{name.to_s}\""
+    end
+
+    def schema_cache
+      self
+    end
+
+    def quote thing
+      case thing
+      when DateTime
+        "'#{thing.strftime("%Y-%m-%d %H:%M:%S")}'"
+      when Date
+        "'#{thing.strftime("%Y-%m-%d")}'"
+      when true
+        "'t'"
+      when false
+        "'f'"
+      when nil
+        'NULL'
+      when Numeric
+        thing
+      else
+        "'#{thing.to_s.gsub("'", "\\\\'")}'"
+      end
+    end
+  end
+
+  class ConnectionPool
+    class Spec < Struct.new(:config)
+    end
+
+    attr_reader :spec, :connection
+
+    def initialize
+      @spec = Spec.new(:adapter => 'america')
+      @connection = Connection.new
+      @connection.visitor = Arel::Visitors::ToSql.new(connection)
+    end
+
+    def with_connection
+      yield connection
+    end
+
+    def table_exists? name
+      connection.tables.include? name.to_s
+    end
+
+    def columns_hash
+      connection.columns_hash
+    end
+
+    def schema_cache
+      connection
+    end
+
+    def quote thing
+      connection.quote thing
+    end
+  end
+
+  class Base
+    attr_accessor :connection_pool
+
+    def initialize
+      @connection_pool = ConnectionPool.new
+    end
+
+    def connection
+      connection_pool.connection
+    end
+  end
+end
diff --git a/activerecord/test/cases/arel/table_test.rb b/activerecord/test/cases/arel/table_test.rb
new file mode 100644
index 0000000000..ccb3ab302f
--- /dev/null
+++ b/activerecord/test/cases/arel/table_test.rb
@@ -0,0 +1,215 @@
+# frozen_string_literal: true
+require_relative 'helper'
+
+module Arel
+  class TableTest < Arel::Spec
+    before do
+      @relation = Table.new(:users)
+    end
+
+    it 'should create join nodes' do
+      join = @relation.create_string_join 'foo'
+      assert_kind_of Arel::Nodes::StringJoin, join
+      assert_equal 'foo', join.left
+    end
+
+    it 'should create join nodes' do
+      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
+      join = @relation.create_join 'foo', 'bar', Arel::Nodes::FullOuterJoin
+      assert_kind_of Arel::Nodes::FullOuterJoin, join
+      assert_equal 'foo', join.left
+      assert_equal 'bar', join.right
+    end
+
+    it 'should create join nodes with a klass' do
+      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
+
+    it 'should create join nodes with a klass' do
+      join = @relation.create_join 'foo', 'bar', Arel::Nodes::RightOuterJoin
+      assert_kind_of Arel::Nodes::RightOuterJoin, join
+      assert_equal 'foo', join.left
+      assert_equal 'bar', join.right
+    end
+
+    it 'should return an insert manager' do
+      im = @relation.compile_insert 'VALUES(NULL)'
+      assert_kind_of Arel::InsertManager, im
+      im.into Table.new(:users)
+      assert_equal "INSERT INTO \"users\" VALUES(NULL)", im.to_sql
+    end
+
+    describe 'skip' do
+      it 'should add an offset' do
+        sm = @relation.skip 2
+        sm.to_sql.must_be_like "SELECT FROM \"users\" OFFSET 2"
+      end
+    end
+
+    describe 'having' do
+      it 'adds a having clause' do
+        mgr = @relation.having @relation[:id].eq(10)
+        mgr.to_sql.must_be_like %{
+         SELECT FROM "users" HAVING "users"."id" = 10
+        }
+      end
+    end
+
+    describe 'backwards compat' do
+      describe 'join' do
+        it 'noops on nil' do
+          mgr = @relation.join nil
+
+          mgr.to_sql.must_be_like %{ SELECT FROM "users" }
+        end
+
+        it 'raises EmptyJoinError on empty' do
+          assert_raises(EmptyJoinError) do
+            @relation.join ""
+          end
+        end
+
+        it 'takes a second argument for join type' do
+          right     = @relation.alias
+          predicate = @relation[:id].eq(right[:id])
+          mgr = @relation.join(right, Nodes::OuterJoin).on(predicate)
+
+          mgr.to_sql.must_be_like %{
+           SELECT FROM "users"
+             LEFT OUTER JOIN "users" "users_2"
+               ON "users"."id" = "users_2"."id"
+          }
+        end
+      end
+
+      describe 'join' do
+        it 'creates an outer join' do
+          right     = @relation.alias
+          predicate = @relation[:id].eq(right[:id])
+          mgr = @relation.outer_join(right).on(predicate)
+
+          mgr.to_sql.must_be_like %{
+            SELECT FROM "users"
+              LEFT OUTER JOIN "users" "users_2"
+                ON "users"."id" = "users_2"."id"
+          }
+        end
+      end
+    end
+
+    describe 'group' do
+      it 'should create a group' do
+        manager = @relation.group @relation[:id]
+        manager.to_sql.must_be_like %{
+          SELECT FROM "users" GROUP BY "users"."id"
+        }
+      end
+    end
+
+    describe 'alias' do
+      it 'should create a node that proxies to a table' do
+        node = @relation.alias
+        node.name.must_equal 'users_2'
+        node[:id].relation.must_equal node
+      end
+    end
+
+    describe 'new' do
+      it 'should accept a hash' do
+        rel = Table.new :users, :as => 'foo'
+        rel.table_alias.must_equal 'foo'
+      end
+
+      it 'ignores as if it equals name' do
+        rel = Table.new :users, :as => 'users'
+        rel.table_alias.must_be_nil
+      end
+    end
+
+    describe 'order' do
+      it "should take an order" do
+        manager = @relation.order "foo"
+        manager.to_sql.must_be_like %{ SELECT FROM "users" ORDER BY foo }
+      end
+    end
+
+    describe 'take' do
+      it "should add a limit" do
+        manager = @relation.take 1
+        manager.project Nodes::SqlLiteral.new '*'
+        manager.to_sql.must_be_like %{ SELECT * FROM "users" LIMIT 1 }
+      end
+    end
+
+    describe 'project' do
+      it 'can project' do
+        manager = @relation.project Nodes::SqlLiteral.new '*'
+        manager.to_sql.must_be_like %{ SELECT * FROM "users" }
+      end
+
+      it 'takes multiple parameters' do
+        manager = @relation.project Nodes::SqlLiteral.new('*'), Nodes::SqlLiteral.new('*')
+        manager.to_sql.must_be_like %{ SELECT *, * FROM "users" }
+      end
+    end
+
+    describe 'where' do
+      it "returns a tree manager" do
+        manager = @relation.where @relation[:id].eq 1
+        manager.project @relation[:id]
+        manager.must_be_kind_of TreeManager
+        manager.to_sql.must_be_like %{
+          SELECT "users"."id"
+          FROM "users"
+          WHERE "users"."id" = 1
+        }
+      end
+    end
+
+    it "should have a name" do
+      @relation.name.must_equal 'users'
+    end
+
+    it "should have a table name" do
+      @relation.table_name.must_equal 'users'
+    end
+
+    describe '[]' do
+      describe 'when given a Symbol' do
+        it "manufactures an attribute if the symbol names an attribute within the relation" do
+          column = @relation[:id]
+          column.name.must_equal :id
+        end
+      end
+    end
+
+    describe 'equality' do
+      it 'is equal with equal ivars' do
+        relation1 = Table.new(:users)
+        relation1.table_alias = 'zomg'
+        relation2 = Table.new(:users)
+        relation2.table_alias = 'zomg'
+        array = [relation1, relation2]
+        assert_equal 1, array.uniq.size
+      end
+
+      it 'is not equal with different ivars' do
+        relation1 = Table.new(:users)
+        relation1.table_alias = 'zomg'
+        relation2 = Table.new(:users)
+        relation2.table_alias = 'zomg2'
+        array = [relation1, relation2]
+        assert_equal 2, array.uniq.size
+      end
+    end
+  end
+end
diff --git a/activerecord/test/cases/arel/update_manager_test.rb b/activerecord/test/cases/arel/update_manager_test.rb
new file mode 100644
index 0000000000..91118c5e9f
--- /dev/null
+++ b/activerecord/test/cases/arel/update_manager_test.rb
@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+require_relative 'helper'
+
+module Arel
+  class UpdateManagerTest < Arel::Spec
+    describe 'new' do
+      it 'takes an engine' do
+        Arel::UpdateManager.new
+      end
+    end
+
+    it "should not quote sql literals" do
+      table = Table.new(:users)
+      um = Arel::UpdateManager.new
+      um.table table
+      um.set [[table[:name], Arel::Nodes::BindParam.new(1)]]
+      um.to_sql.must_be_like %{ UPDATE "users" SET "name" =  ? }
+    end
+
+    it 'handles limit properly' do
+      table = Table.new(:users)
+      um = Arel::UpdateManager.new
+      um.key = 'id'
+      um.take 10
+      um.table table
+      um.set [[table[:name], nil]]
+      assert_match(/LIMIT 10/, um.to_sql)
+    end
+
+    describe 'set' do
+      it "updates with null" do
+        table = Table.new(:users)
+        um = Arel::UpdateManager.new
+        um.table table
+        um.set [[table[:name], nil]]
+        um.to_sql.must_be_like %{ UPDATE "users" SET "name" =  NULL }
+      end
+
+      it 'takes a string' do
+        table = Table.new(:users)
+        um = Arel::UpdateManager.new
+        um.table table
+        um.set Nodes::SqlLiteral.new "foo = bar"
+        um.to_sql.must_be_like %{ UPDATE "users" SET foo = bar }
+      end
+
+      it 'takes a list of lists' do
+        table = Table.new(:users)
+        um = Arel::UpdateManager.new
+        um.table table
+        um.set [[table[:id], 1], [table[:name], 'hello']]
+        um.to_sql.must_be_like %{
+          UPDATE "users" SET "id" = 1, "name" =  'hello'
+        }
+      end
+
+      it 'chains' do
+        table = Table.new(:users)
+        um = Arel::UpdateManager.new
+        um.set([[table[:id], 1], [table[:name], 'hello']]).must_equal um
+      end
+    end
+
+    describe 'table' do
+      it 'generates an update statement' do
+        um = Arel::UpdateManager.new
+        um.table Table.new(:users)
+        um.to_sql.must_be_like %{ UPDATE "users" }
+      end
+
+      it 'chains' do
+        um = Arel::UpdateManager.new
+        um.table(Table.new(:users)).must_equal um
+      end
+
+      it 'generates an update statement with joins' do
+        um = Arel::UpdateManager.new
+
+        table = Table.new(:users)
+        join_source = Arel::Nodes::JoinSource.new(
+          table,
+          [table.create_join(Table.new(:posts))]
+        )
+
+        um.table join_source
+        um.to_sql.must_be_like %{ UPDATE "users" INNER JOIN "posts" }
+      end
+    end
+
+    describe 'where' do
+      it 'generates a where clause' do
+        table = Table.new :users
+        um = Arel::UpdateManager.new
+        um.table table
+        um.where table[:id].eq(1)
+        um.to_sql.must_be_like %{
+          UPDATE "users" WHERE "users"."id" = 1
+        }
+      end
+
+      it 'chains' do
+        table = Table.new :users
+        um = Arel::UpdateManager.new
+        um.table table
+        um.where(table[:id].eq(1)).must_equal um
+      end
+    end
+
+    describe 'key' do
+      before do
+        @table = Table.new :users
+        @um = Arel::UpdateManager.new
+        @um.key = @table[:foo]
+      end
+
+      it 'can be set' do
+        @um.ast.key.must_equal @table[:foo]
+      end
+
+      it 'can be accessed' do
+        @um.key.must_equal @table[:foo]
+      end
+    end
+  end
+end
diff --git a/activerecord/test/cases/arel/visitors/depth_first_test.rb b/activerecord/test/cases/arel/visitors/depth_first_test.rb
new file mode 100644
index 0000000000..b841d119d2
--- /dev/null
+++ b/activerecord/test/cases/arel/visitors/depth_first_test.rb
@@ -0,0 +1,270 @@
+# frozen_string_literal: true
+require_relative '../helper'
+
+module Arel
+  module Visitors
+    class TestDepthFirst < Arel::Test
+      Collector = Struct.new(:calls) do
+        def call object
+          calls << object
+        end
+      end
+
+      def setup
+        @collector = Collector.new []
+        @visitor = Visitors::DepthFirst.new @collector
+      end
+
+      def test_raises_with_object
+        assert_raises(TypeError) do
+          @visitor.accept(Object.new)
+        end
+      end
+
+
+      # unary ops
+      [
+        Arel::Nodes::Not,
+        Arel::Nodes::Group,
+        Arel::Nodes::On,
+        Arel::Nodes::Grouping,
+        Arel::Nodes::Offset,
+        Arel::Nodes::Ordering,
+        Arel::Nodes::StringJoin,
+        Arel::Nodes::UnqualifiedColumn,
+        Arel::Nodes::Top,
+        Arel::Nodes::Limit,
+        Arel::Nodes::Else,
+      ].each do |klass|
+        define_method("test_#{klass.name.gsub('::', '_')}") do
+          op = klass.new(:a)
+          @visitor.accept op
+          assert_equal [:a, op], @collector.calls
+        end
+      end
+
+      # functions
+      [
+        Arel::Nodes::Exists,
+        Arel::Nodes::Avg,
+        Arel::Nodes::Min,
+        Arel::Nodes::Max,
+        Arel::Nodes::Sum,
+      ].each do |klass|
+        define_method("test_#{klass.name.gsub('::', '_')}") do
+          func = klass.new(:a, "b")
+          @visitor.accept func
+          assert_equal [:a, "b", false, func], @collector.calls
+        end
+      end
+
+      def test_named_function
+        func = Arel::Nodes::NamedFunction.new(:a, :b, "c")
+        @visitor.accept func
+        assert_equal [:a, :b, false, "c", func], @collector.calls
+      end
+
+      def test_lock
+        lock = Nodes::Lock.new true
+        @visitor.accept lock
+        assert_equal [lock], @collector.calls
+      end
+
+      def test_count
+        count = Nodes::Count.new :a, :b, "c"
+        @visitor.accept count
+        assert_equal [:a, "c", :b, count], @collector.calls
+      end
+
+      def test_inner_join
+        join = Nodes::InnerJoin.new :a, :b
+        @visitor.accept join
+        assert_equal [:a, :b, join], @collector.calls
+      end
+
+      def test_full_outer_join
+        join = Nodes::FullOuterJoin.new :a, :b
+        @visitor.accept join
+        assert_equal [:a, :b, join], @collector.calls
+      end
+
+      def test_outer_join
+        join = Nodes::OuterJoin.new :a, :b
+        @visitor.accept join
+        assert_equal [:a, :b, join], @collector.calls
+      end
+
+      def test_right_outer_join
+        join = Nodes::RightOuterJoin.new :a, :b
+        @visitor.accept join
+        assert_equal [:a, :b, join], @collector.calls
+      end
+
+      [
+        Arel::Nodes::Assignment,
+        Arel::Nodes::Between,
+        Arel::Nodes::Concat,
+        Arel::Nodes::DoesNotMatch,
+        Arel::Nodes::Equality,
+        Arel::Nodes::GreaterThan,
+        Arel::Nodes::GreaterThanOrEqual,
+        Arel::Nodes::In,
+        Arel::Nodes::LessThan,
+        Arel::Nodes::LessThanOrEqual,
+        Arel::Nodes::Matches,
+        Arel::Nodes::NotEqual,
+        Arel::Nodes::NotIn,
+        Arel::Nodes::Or,
+        Arel::Nodes::TableAlias,
+        Arel::Nodes::Values,
+        Arel::Nodes::As,
+        Arel::Nodes::DeleteStatement,
+        Arel::Nodes::JoinSource,
+        Arel::Nodes::When,
+      ].each do |klass|
+        define_method("test_#{klass.name.gsub('::', '_')}") do
+          binary = klass.new(:a, :b)
+          @visitor.accept binary
+          assert_equal [:a, :b, binary], @collector.calls
+        end
+      end
+
+      def test_Arel_Nodes_InfixOperation
+        binary = Arel::Nodes::InfixOperation.new(:o, :a, :b)
+        @visitor.accept binary
+        assert_equal [:a, :b, binary], @collector.calls
+      end
+
+      # N-ary
+      [
+        Arel::Nodes::And,
+      ].each do |klass|
+        define_method("test_#{klass.name.gsub('::', '_')}") do
+          binary = klass.new([:a, :b, :c])
+          @visitor.accept binary
+          assert_equal [:a, :b, :c, binary], @collector.calls
+        end
+      end
+
+      [
+        Arel::Attributes::Integer,
+        Arel::Attributes::Float,
+        Arel::Attributes::String,
+        Arel::Attributes::Time,
+        Arel::Attributes::Boolean,
+        Arel::Attributes::Attribute
+      ].each do |klass|
+        define_method("test_#{klass.name.gsub('::', '_')}") do
+          binary = klass.new(:a, :b)
+          @visitor.accept binary
+          assert_equal [:a, :b, binary], @collector.calls
+        end
+      end
+
+      def test_table
+        relation = Arel::Table.new(:users)
+        @visitor.accept relation
+        assert_equal ['users', relation], @collector.calls
+      end
+
+      def test_array
+        node = Nodes::Or.new(:a, :b)
+        list = [node]
+        @visitor.accept list
+        assert_equal [:a, :b, node, list], @collector.calls
+      end
+
+      def test_set
+        node = Nodes::Or.new(:a, :b)
+        set  = Set.new([node])
+        @visitor.accept set
+        assert_equal [:a, :b, node, set], @collector.calls
+      end
+
+      def test_hash
+        node = Nodes::Or.new(:a, :b)
+        hash = { node => node }
+        @visitor.accept hash
+        assert_equal [:a, :b, node, :a, :b, node, hash], @collector.calls
+      end
+
+      def test_update_statement
+        stmt = Nodes::UpdateStatement.new
+        stmt.relation = :a
+        stmt.values << :b
+        stmt.wheres << :c
+        stmt.orders << :d
+        stmt.limit = :e
+
+        @visitor.accept stmt
+        assert_equal [:a, :b, stmt.values, :c, stmt.wheres, :d, stmt.orders,
+          :e, stmt], @collector.calls
+      end
+
+      def test_select_core
+        core = Nodes::SelectCore.new
+        core.projections << :a
+        core.froms = :b
+        core.wheres << :c
+        core.groups << :d
+        core.windows << :e
+        core.havings << :f
+
+        @visitor.accept core
+        assert_equal [
+          :a, core.projections,
+          :b, [],
+          core.source,
+          :c, core.wheres,
+          :d, core.groups,
+          :e, core.windows,
+          :f, core.havings,
+          core], @collector.calls
+      end
+
+      def test_select_statement
+        ss = Nodes::SelectStatement.new
+        ss.cores.replace [:a]
+        ss.orders << :b
+        ss.limit = :c
+        ss.lock = :d
+        ss.offset = :e
+
+        @visitor.accept ss
+        assert_equal [
+          :a, ss.cores,
+          :b, ss.orders,
+          :c,
+          :d,
+          :e,
+          ss], @collector.calls
+      end
+
+      def test_insert_statement
+        stmt = Nodes::InsertStatement.new
+        stmt.relation = :a
+        stmt.columns << :b
+        stmt.values = :c
+
+        @visitor.accept stmt
+        assert_equal [:a, :b, stmt.columns, :c, stmt], @collector.calls
+      end
+
+      def test_case
+        node = Arel::Nodes::Case.new
+        node.case = :a
+        node.conditions << :b
+        node.default = :c
+
+        @visitor.accept node
+        assert_equal [:a, :b, node.conditions, :c, node], @collector.calls
+      end
+
+      def test_node
+        node = Nodes::Node.new
+        @visitor.accept node
+        assert_equal [node], @collector.calls
+      end
+    end
+  end
+end
diff --git a/activerecord/test/cases/arel/visitors/dispatch_contamination_test.rb b/activerecord/test/cases/arel/visitors/dispatch_contamination_test.rb
new file mode 100644
index 0000000000..eb278cde4c
--- /dev/null
+++ b/activerecord/test/cases/arel/visitors/dispatch_contamination_test.rb
@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+require_relative '../helper'
+require 'concurrent'
+
+module Arel
+  module Visitors
+    class DummyVisitor < Visitor
+      def initialize
+        super
+        @barrier = Concurrent::CyclicBarrier.new(2)
+      end
+
+      def visit_Arel_Visitors_DummySuperNode node
+        42
+      end
+
+      # This is terrible, but it's the only way to reliably reproduce
+      # the possible race where two threads attempt to correct the
+      # dispatch hash at the same time.
+      def send *args
+        super
+      rescue
+        # Both threads try (and fail) to dispatch to the subclass's name
+        @barrier.wait
+        raise
+      ensure
+        # Then one thread successfully completes (updating the dispatch
+        # table in the process) before the other finishes raising its
+        # exception.
+        Thread.current[:delay].wait if Thread.current[:delay]
+      end
+    end
+
+    class DummySuperNode
+    end
+
+    class DummySubNode < DummySuperNode
+    end
+
+    class DispatchContaminationTest < Arel::Spec
+      before do
+        @connection = Table.engine.connection
+        @table = Table.new(:users)
+      end
+
+      it 'dispatches properly after failing upwards' do
+        node = Nodes::Union.new(Nodes::True.new, Nodes::False.new)
+        assert_equal "( TRUE UNION FALSE )", node.to_sql
+
+        node.first # from Nodes::Node's Enumerable mixin
+
+        assert_equal "( TRUE UNION FALSE )", node.to_sql
+      end
+
+      it 'is threadsafe when implementing superclass fallback' do
+        visitor = DummyVisitor.new
+        main_thread_finished = Concurrent::Event.new
+
+        racing_thread = Thread.new do
+          Thread.current[:delay] = main_thread_finished
+          visitor.accept DummySubNode.new
+        end
+
+        assert_equal 42, visitor.accept(DummySubNode.new)
+        main_thread_finished.set
+
+        assert_equal 42, racing_thread.value
+      end
+    end
+  end
+end
+
diff --git a/activerecord/test/cases/arel/visitors/dot_test.rb b/activerecord/test/cases/arel/visitors/dot_test.rb
new file mode 100644
index 0000000000..048482c3ca
--- /dev/null
+++ b/activerecord/test/cases/arel/visitors/dot_test.rb
@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+require_relative '../helper'
+
+module Arel
+  module Visitors
+    class TestDot < Arel::Test
+      def setup
+        @visitor = Visitors::Dot.new
+      end
+
+      # functions
+      [
+        Nodes::Sum,
+        Nodes::Exists,
+        Nodes::Max,
+        Nodes::Min,
+        Nodes::Avg,
+      ].each do |klass|
+        define_method("test_#{klass.name.gsub('::', '_')}") do
+          op = klass.new(:a, "z")
+          @visitor.accept op, Collectors::PlainString.new
+        end
+      end
+
+      def test_named_function
+        func = Nodes::NamedFunction.new 'omg', 'omg'
+        @visitor.accept func, Collectors::PlainString.new
+      end
+
+      # unary ops
+      [
+        Arel::Nodes::Not,
+        Arel::Nodes::Group,
+        Arel::Nodes::On,
+        Arel::Nodes::Grouping,
+        Arel::Nodes::Offset,
+        Arel::Nodes::Ordering,
+        Arel::Nodes::UnqualifiedColumn,
+        Arel::Nodes::Top,
+        Arel::Nodes::Limit,
+      ].each do |klass|
+        define_method("test_#{klass.name.gsub('::', '_')}") do
+          op = klass.new(:a)
+          @visitor.accept op, Collectors::PlainString.new
+        end
+      end
+
+      # binary ops
+      [
+        Arel::Nodes::Assignment,
+        Arel::Nodes::Between,
+        Arel::Nodes::DoesNotMatch,
+        Arel::Nodes::Equality,
+        Arel::Nodes::GreaterThan,
+        Arel::Nodes::GreaterThanOrEqual,
+        Arel::Nodes::In,
+        Arel::Nodes::LessThan,
+        Arel::Nodes::LessThanOrEqual,
+        Arel::Nodes::Matches,
+        Arel::Nodes::NotEqual,
+        Arel::Nodes::NotIn,
+        Arel::Nodes::Or,
+        Arel::Nodes::TableAlias,
+        Arel::Nodes::Values,
+        Arel::Nodes::As,
+        Arel::Nodes::DeleteStatement,
+        Arel::Nodes::JoinSource,
+        Arel::Nodes::Casted,
+      ].each do |klass|
+        define_method("test_#{klass.name.gsub('::', '_')}") do
+          binary = klass.new(:a, :b)
+          @visitor.accept binary, Collectors::PlainString.new
+        end
+      end
+
+      def test_Arel_Nodes_BindParam
+        node = Arel::Nodes::BindParam.new(1)
+        collector = Collectors::PlainString.new
+        assert_match '[label="<f0>Arel::Nodes::BindParam"]', @visitor.accept(node, collector).value
+      end
+    end
+  end
+end
diff --git a/activerecord/test/cases/arel/visitors/ibm_db_test.rb b/activerecord/test/cases/arel/visitors/ibm_db_test.rb
new file mode 100644
index 0000000000..d7569eedc3
--- /dev/null
+++ b/activerecord/test/cases/arel/visitors/ibm_db_test.rb
@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+require_relative '../helper'
+
+module Arel
+  module Visitors
+    class IbmDbTest < Arel::Spec
+      before do
+        @visitor = IBM_DB.new Table.engine.connection
+      end
+
+      def compile node
+        @visitor.accept(node, Collectors::SQLString.new).value
+      end
+
+      it 'uses FETCH FIRST n ROWS to limit results' do
+        stmt = Nodes::SelectStatement.new
+        stmt.limit = Nodes::Limit.new(1)
+        sql = compile(stmt)
+        sql.must_be_like "SELECT FETCH FIRST 1 ROWS ONLY"
+      end
+
+      it 'uses FETCH FIRST n ROWS in updates with a limit' do
+        table = Table.new(:users)
+        stmt = Nodes::UpdateStatement.new
+        stmt.relation = table
+        stmt.limit = Nodes::Limit.new(Nodes.build_quoted(1))
+        stmt.key = table[:id]
+        sql = compile(stmt)
+        sql.must_be_like "UPDATE \"users\" WHERE \"users\".\"id\" IN (SELECT \"users\".\"id\" FROM \"users\" FETCH FIRST 1 ROWS ONLY)"
+      end
+
+    end
+  end
+end
diff --git a/activerecord/test/cases/arel/visitors/informix_test.rb b/activerecord/test/cases/arel/visitors/informix_test.rb
new file mode 100644
index 0000000000..bb6ff42f05
--- /dev/null
+++ b/activerecord/test/cases/arel/visitors/informix_test.rb
@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+require_relative '../helper'
+
+module Arel
+  module Visitors
+    class InformixTest < Arel::Spec
+      before do
+        @visitor = Informix.new Table.engine.connection
+      end
+
+      def compile node
+        @visitor.accept(node, Collectors::SQLString.new).value
+      end
+
+      it 'uses FIRST n to limit results' do
+        stmt = Nodes::SelectStatement.new
+        stmt.limit = Nodes::Limit.new(1)
+        sql = compile(stmt)
+        sql.must_be_like "SELECT FIRST 1"
+      end
+
+      it 'uses FIRST n in updates with a limit' do
+        table = Table.new(:users)
+        stmt = Nodes::UpdateStatement.new
+        stmt.relation = table
+        stmt.limit = Nodes::Limit.new(Nodes.build_quoted(1))
+        stmt.key = table[:id]
+        sql = compile(stmt)
+        sql.must_be_like "UPDATE \"users\" WHERE \"users\".\"id\" IN (SELECT FIRST 1 \"users\".\"id\" FROM \"users\")"
+      end
+
+      it 'uses SKIP n to jump results' do
+        stmt = Nodes::SelectStatement.new
+        stmt.offset = Nodes::Offset.new(10)
+        sql = compile(stmt)
+        sql.must_be_like "SELECT SKIP 10"
+      end
+
+      it 'uses SKIP before FIRST' do
+        stmt = Nodes::SelectStatement.new
+        stmt.limit = Nodes::Limit.new(1)
+        stmt.offset = Nodes::Offset.new(1)
+        sql = compile(stmt)
+        sql.must_be_like "SELECT SKIP 1 FIRST 1"
+      end
+
+      it 'uses INNER JOIN to perform joins' do
+        core = Nodes::SelectCore.new
+        table = Table.new(:posts)
+        core.source = Nodes::JoinSource.new(table, [table.create_join(Table.new(:comments))])
+
+        stmt = Nodes::SelectStatement.new([core])
+        sql = compile(stmt)
+        sql.must_be_like 'SELECT FROM "posts" INNER JOIN "comments"'
+      end
+
+    end
+  end
+end
diff --git a/activerecord/test/cases/arel/visitors/mssql_test.rb b/activerecord/test/cases/arel/visitors/mssql_test.rb
new file mode 100644
index 0000000000..4e81678813
--- /dev/null
+++ b/activerecord/test/cases/arel/visitors/mssql_test.rb
@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+require_relative '../helper'
+
+module Arel
+  module Visitors
+    class MssqlTest < Arel::Spec
+      before do
+        @visitor = MSSQL.new Table.engine.connection
+        @table = Arel::Table.new "users"
+      end
+
+      def compile node
+        @visitor.accept(node, Collectors::SQLString.new).value
+      end
+
+      it 'should not modify query if no offset or limit' do
+        stmt = Nodes::SelectStatement.new
+        sql = compile(stmt)
+        sql.must_be_like "SELECT"
+      end
+
+      it 'should go over table PK if no .order() or .group()' do
+        stmt = Nodes::SelectStatement.new
+        stmt.cores.first.from = @table
+        stmt.limit = Nodes::Limit.new(10)
+        sql = compile(stmt)
+        sql.must_be_like "SELECT _t.* FROM (SELECT ROW_NUMBER() OVER (ORDER BY \"users\".\"id\") as _row_num FROM \"users\") as _t WHERE _row_num BETWEEN 1 AND 10"
+      end
+
+      it 'caches the PK lookup for order' do
+        connection = Minitest::Mock.new
+        connection.expect(:primary_key, ["id"], ["users"])
+
+        # We don't care how many times these methods are called
+        def connection.quote_table_name(*); ""; end
+        def connection.quote_column_name(*); ""; end
+
+        @visitor = MSSQL.new(connection)
+        stmt = Nodes::SelectStatement.new
+        stmt.cores.first.from = @table
+        stmt.limit = Nodes::Limit.new(10)
+
+        compile(stmt)
+        compile(stmt)
+
+        connection.verify
+      end
+
+      it 'should use TOP for limited deletes' do
+        stmt = Nodes::DeleteStatement.new
+        stmt.relation = @table
+        stmt.limit = Nodes::Limit.new(10)
+        sql = compile(stmt)
+
+        sql.must_be_like "DELETE TOP (10) FROM \"users\""
+      end
+
+      it 'should go over query ORDER BY if .order()' do
+        stmt = Nodes::SelectStatement.new
+        stmt.limit = Nodes::Limit.new(10)
+        stmt.orders << Nodes::SqlLiteral.new('order_by')
+        sql = compile(stmt)
+        sql.must_be_like "SELECT _t.* FROM (SELECT ROW_NUMBER() OVER (ORDER BY order_by) as _row_num) as _t WHERE _row_num BETWEEN 1 AND 10"
+      end
+
+      it 'should go over query GROUP BY if no .order() and there is .group()' do
+        stmt = Nodes::SelectStatement.new
+        stmt.cores.first.groups << Nodes::SqlLiteral.new('group_by')
+        stmt.limit = Nodes::Limit.new(10)
+        sql = compile(stmt)
+        sql.must_be_like "SELECT _t.* FROM (SELECT ROW_NUMBER() OVER (ORDER BY group_by) as _row_num GROUP BY group_by) as _t WHERE _row_num BETWEEN 1 AND 10"
+      end
+
+      it 'should use BETWEEN if both .limit() and .offset' do
+        stmt = Nodes::SelectStatement.new
+        stmt.limit = Nodes::Limit.new(10)
+        stmt.offset = Nodes::Offset.new(20)
+        sql = compile(stmt)
+        sql.must_be_like "SELECT _t.* FROM (SELECT ROW_NUMBER() OVER (ORDER BY ) as _row_num) as _t WHERE _row_num BETWEEN 21 AND 30"
+      end
+
+      it 'should use >= if only .offset' do
+        stmt = Nodes::SelectStatement.new
+        stmt.offset = Nodes::Offset.new(20)
+        sql = compile(stmt)
+        sql.must_be_like "SELECT _t.* FROM (SELECT ROW_NUMBER() OVER (ORDER BY ) as _row_num) as _t WHERE _row_num >= 21"
+      end
+
+      it 'should generate subquery for .count' do
+        stmt = Nodes::SelectStatement.new
+        stmt.limit = Nodes::Limit.new(10)
+        stmt.cores.first.projections << Nodes::Count.new('*')
+        sql = compile(stmt)
+        sql.must_be_like "SELECT COUNT(1) as count_id FROM (SELECT _t.* FROM (SELECT ROW_NUMBER() OVER (ORDER BY ) as _row_num) as _t WHERE _row_num BETWEEN 1 AND 10) AS subquery"
+      end
+
+    end
+  end
+end
diff --git a/activerecord/test/cases/arel/visitors/mysql_test.rb b/activerecord/test/cases/arel/visitors/mysql_test.rb
new file mode 100644
index 0000000000..f9b468b1d2
--- /dev/null
+++ b/activerecord/test/cases/arel/visitors/mysql_test.rb
@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+require_relative '../helper'
+
+module Arel
+  module Visitors
+    class MysqlTest < Arel::Spec
+      before do
+        @visitor = MySQL.new Table.engine.connection
+      end
+
+      def compile node
+        @visitor.accept(node, Collectors::SQLString.new).value
+      end
+
+      it 'squashes parenthesis on multiple unions' do
+        subnode = Nodes::Union.new Arel.sql('left'), Arel.sql('right')
+        node    = Nodes::Union.new subnode, Arel.sql('topright')
+        assert_equal 1, compile(node).scan('(').length
+
+        subnode = Nodes::Union.new Arel.sql('left'), Arel.sql('right')
+        node    = Nodes::Union.new Arel.sql('topleft'), subnode
+        assert_equal 1, compile(node).scan('(').length
+      end
+
+      ###
+      # :'(
+      # http://dev.mysql.com/doc/refman/5.0/en/select.html#id3482214
+      it 'defaults limit to 18446744073709551615' do
+        stmt = Nodes::SelectStatement.new
+        stmt.offset = Nodes::Offset.new(1)
+        sql = compile(stmt)
+        sql.must_be_like "SELECT FROM DUAL LIMIT 18446744073709551615 OFFSET 1"
+      end
+
+      it "should escape LIMIT" do
+        sc = Arel::Nodes::UpdateStatement.new
+        sc.relation = Table.new(:users)
+        sc.limit = Nodes::Limit.new(Nodes.build_quoted("omg"))
+        assert_equal("UPDATE \"users\" LIMIT 'omg'", compile(sc))
+      end
+
+      it 'uses DUAL for empty from' do
+        stmt = Nodes::SelectStatement.new
+        sql = compile(stmt)
+        sql.must_be_like "SELECT FROM DUAL"
+      end
+
+      describe 'locking' do
+        it 'defaults to FOR UPDATE when locking' do
+          node = Nodes::Lock.new(Arel.sql('FOR UPDATE'))
+          compile(node).must_be_like "FOR UPDATE"
+        end
+
+        it 'allows a custom string to be used as a lock' do
+          node = Nodes::Lock.new(Arel.sql('LOCK IN SHARE MODE'))
+          compile(node).must_be_like "LOCK IN SHARE MODE"
+        end
+      end
+
+      describe "concat" do
+        it "concats columns" do
+          @table = Table.new(:users)
+          query = @table[:name].concat(@table[:name])
+          compile(query).must_be_like %{
+            CONCAT("users"."name", "users"."name")
+          }
+        end
+
+        it "concats a string" do
+          @table = Table.new(:users)
+          query = @table[:name].concat(Nodes.build_quoted('abc'))
+          compile(query).must_be_like %{
+            CONCAT("users"."name", 'abc')
+          }
+        end
+      end
+    end
+  end
+end
diff --git a/activerecord/test/cases/arel/visitors/oracle12_test.rb b/activerecord/test/cases/arel/visitors/oracle12_test.rb
new file mode 100644
index 0000000000..ef2050b7c9
--- /dev/null
+++ b/activerecord/test/cases/arel/visitors/oracle12_test.rb
@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+require_relative '../helper'
+
+module Arel
+  module Visitors
+    class Oracle12Test < Arel::Spec
+      before do
+        @visitor = Oracle12.new Table.engine.connection
+        @table = Table.new(:users)
+      end
+
+      def compile node
+        @visitor.accept(node, Collectors::SQLString.new).value
+      end
+
+      it 'modified except to be minus' do
+        left = Nodes::SqlLiteral.new("SELECT * FROM users WHERE age > 10")
+        right = Nodes::SqlLiteral.new("SELECT * FROM users WHERE age > 20")
+        sql = compile Nodes::Except.new(left, right)
+        sql.must_be_like %{
+          ( SELECT * FROM users WHERE age > 10 MINUS SELECT * FROM users WHERE age > 20 )
+        }
+      end
+
+      it 'generates select options offset then limit' do
+        stmt = Nodes::SelectStatement.new
+        stmt.offset = Nodes::Offset.new(1)
+        stmt.limit = Nodes::Limit.new(10)
+        sql = compile(stmt)
+        sql.must_be_like "SELECT OFFSET 1 ROWS FETCH FIRST 10 ROWS ONLY"
+      end
+
+      describe 'locking' do
+        it 'generates ArgumentError if limit and lock are used' do
+          stmt = Nodes::SelectStatement.new
+          stmt.limit = Nodes::Limit.new(10)
+          stmt.lock = Nodes::Lock.new(Arel.sql('FOR UPDATE'))
+          assert_raises ArgumentError do
+            compile(stmt)
+          end
+        end
+
+        it 'defaults to FOR UPDATE when locking' do
+          node = Nodes::Lock.new(Arel.sql('FOR UPDATE'))
+          compile(node).must_be_like "FOR UPDATE"
+        end
+      end
+
+      describe "Nodes::BindParam" do
+        it "increments each bind param" do
+          query = @table[:name].eq(Arel::Nodes::BindParam.new(1))
+            .and(@table[:id].eq(Arel::Nodes::BindParam.new(1)))
+          compile(query).must_be_like %{
+            "users"."name" = :a1 AND "users"."id" = :a2
+          }
+        end
+      end
+    end
+  end
+end
diff --git a/activerecord/test/cases/arel/visitors/oracle_test.rb b/activerecord/test/cases/arel/visitors/oracle_test.rb
new file mode 100644
index 0000000000..0737774fbf
--- /dev/null
+++ b/activerecord/test/cases/arel/visitors/oracle_test.rb
@@ -0,0 +1,196 @@
+# frozen_string_literal: true
+require_relative '../helper'
+
+module Arel
+  module Visitors
+    class OracleTest < Arel::Spec
+      before do
+        @visitor = Oracle.new Table.engine.connection
+        @table = Table.new(:users)
+      end
+
+      def compile node
+        @visitor.accept(node, Collectors::SQLString.new).value
+      end
+
+      it 'modifies order when there is distinct and first value' do
+        # *sigh*
+        select = "DISTINCT foo.id, FIRST_VALUE(projects.name) OVER (foo) AS alias_0__"
+        stmt = Nodes::SelectStatement.new
+        stmt.cores.first.projections << Nodes::SqlLiteral.new(select)
+        stmt.orders << Nodes::SqlLiteral.new('foo')
+        sql = compile(stmt)
+        sql.must_be_like %{
+          SELECT #{select} ORDER BY alias_0__
+        }
+      end
+
+      it 'is idempotent with crazy query' do
+        # *sigh*
+        select = "DISTINCT foo.id, FIRST_VALUE(projects.name) OVER (foo) AS alias_0__"
+        stmt = Nodes::SelectStatement.new
+        stmt.cores.first.projections << Nodes::SqlLiteral.new(select)
+        stmt.orders << Nodes::SqlLiteral.new('foo')
+
+        sql = compile(stmt)
+        sql2 = compile(stmt)
+        sql.must_equal sql2
+      end
+
+      it 'splits orders with commas' do
+        # *sigh*
+        select = "DISTINCT foo.id, FIRST_VALUE(projects.name) OVER (foo) AS alias_0__"
+        stmt = Nodes::SelectStatement.new
+        stmt.cores.first.projections << Nodes::SqlLiteral.new(select)
+        stmt.orders << Nodes::SqlLiteral.new('foo, bar')
+        sql = compile(stmt)
+        sql.must_be_like %{
+          SELECT #{select} ORDER BY alias_0__, alias_1__
+        }
+      end
+
+      it 'splits orders with commas and function calls' do
+        # *sigh*
+        select = "DISTINCT foo.id, FIRST_VALUE(projects.name) OVER (foo) AS alias_0__"
+        stmt = Nodes::SelectStatement.new
+        stmt.cores.first.projections << Nodes::SqlLiteral.new(select)
+        stmt.orders << Nodes::SqlLiteral.new('NVL(LOWER(bar, foo), foo) DESC, UPPER(baz)')
+        sql = compile(stmt)
+        sql.must_be_like %{
+          SELECT #{select} ORDER BY alias_0__ DESC, alias_1__
+        }
+      end
+
+      describe 'Nodes::SelectStatement' do
+        describe 'limit' do
+          it 'adds a rownum clause' do
+            stmt = Nodes::SelectStatement.new
+            stmt.limit = Nodes::Limit.new(10)
+            sql = compile stmt
+            sql.must_be_like %{ SELECT WHERE ROWNUM <= 10 }
+          end
+
+          it 'is idempotent' do
+            stmt = Nodes::SelectStatement.new
+            stmt.orders << Nodes::SqlLiteral.new('foo')
+            stmt.limit = Nodes::Limit.new(10)
+            sql = compile stmt
+            sql2 = compile stmt
+            sql.must_equal sql2
+          end
+
+          it 'creates a subquery when there is order_by' do
+            stmt = Nodes::SelectStatement.new
+            stmt.orders << Nodes::SqlLiteral.new('foo')
+            stmt.limit = Nodes::Limit.new(10)
+            sql = compile stmt
+            sql.must_be_like %{
+              SELECT * FROM (SELECT ORDER BY foo ) WHERE ROWNUM <= 10
+            }
+          end
+
+          it 'creates a subquery when there is group by' do
+            stmt = Nodes::SelectStatement.new
+            stmt.cores.first.groups << Nodes::SqlLiteral.new('foo')
+            stmt.limit = Nodes::Limit.new(10)
+            sql = compile stmt
+            sql.must_be_like %{
+              SELECT * FROM (SELECT GROUP BY foo ) WHERE ROWNUM <= 10
+            }
+          end
+
+          it 'creates a subquery when there is DISTINCT' do
+            stmt = Nodes::SelectStatement.new
+            stmt.cores.first.set_quantifier = Arel::Nodes::Distinct.new
+            stmt.cores.first.projections << Nodes::SqlLiteral.new('id')
+            stmt.limit = Arel::Nodes::Limit.new(10)
+            sql = compile stmt
+            sql.must_be_like %{
+              SELECT * FROM (SELECT DISTINCT id ) WHERE ROWNUM <= 10
+            }
+          end
+
+          it 'creates a different subquery when there is an offset' do
+            stmt = Nodes::SelectStatement.new
+            stmt.limit = Nodes::Limit.new(10)
+            stmt.offset = Nodes::Offset.new(10)
+            sql = compile stmt
+            sql.must_be_like %{
+              SELECT * FROM (
+                SELECT raw_sql_.*, rownum raw_rnum_
+                FROM (SELECT ) raw_sql_
+                 WHERE rownum <= 20
+              )
+              WHERE raw_rnum_ > 10
+            }
+          end
+
+          it 'creates a subquery when there is limit and offset with BindParams' do
+            stmt = Nodes::SelectStatement.new
+            stmt.limit = Nodes::Limit.new(Nodes::BindParam.new(1))
+            stmt.offset = Nodes::Offset.new(Nodes::BindParam.new(1))
+            sql = compile stmt
+            sql.must_be_like %{
+              SELECT * FROM (
+                SELECT raw_sql_.*, rownum raw_rnum_
+                FROM (SELECT ) raw_sql_
+                 WHERE rownum <= (:a1 + :a2)
+              )
+              WHERE raw_rnum_ > :a3
+            }
+          end
+
+          it 'is idempotent with different subquery' do
+            stmt = Nodes::SelectStatement.new
+            stmt.limit = Nodes::Limit.new(10)
+            stmt.offset = Nodes::Offset.new(10)
+            sql = compile stmt
+            sql2 = compile stmt
+            sql.must_equal sql2
+          end
+        end
+
+        describe 'only offset' do
+          it 'creates a select from subquery with rownum condition' do
+            stmt = Nodes::SelectStatement.new
+            stmt.offset = Nodes::Offset.new(10)
+            sql = compile stmt
+            sql.must_be_like %{
+              SELECT * FROM (
+                SELECT raw_sql_.*, rownum raw_rnum_
+                FROM (SELECT) raw_sql_
+              )
+              WHERE raw_rnum_ > 10
+            }
+          end
+        end
+      end
+
+      it 'modified except to be minus' do
+        left = Nodes::SqlLiteral.new("SELECT * FROM users WHERE age > 10")
+        right = Nodes::SqlLiteral.new("SELECT * FROM users WHERE age > 20")
+        sql = compile Nodes::Except.new(left, right)
+        sql.must_be_like %{
+          ( SELECT * FROM users WHERE age > 10 MINUS SELECT * FROM users WHERE age > 20 )
+        }
+      end
+
+      describe 'locking' do
+        it 'defaults to FOR UPDATE when locking' do
+          node = Nodes::Lock.new(Arel.sql('FOR UPDATE'))
+          compile(node).must_be_like "FOR UPDATE"
+        end
+      end
+
+      describe "Nodes::BindParam" do
+        it "increments each bind param" do
+          query = @table[:name].eq(Arel::Nodes::BindParam.new(1))
+            .and(@table[:id].eq(Arel::Nodes::BindParam.new(1)))
+          compile(query).must_be_like %{
+            "users"."name" = :a1 AND "users"."id" = :a2
+          }
+        end
+      end
+    end
+  end
+end
diff --git a/activerecord/test/cases/arel/visitors/postgres_test.rb b/activerecord/test/cases/arel/visitors/postgres_test.rb
new file mode 100644
index 0000000000..6aa786b14f
--- /dev/null
+++ b/activerecord/test/cases/arel/visitors/postgres_test.rb
@@ -0,0 +1,280 @@
+# frozen_string_literal: true
+require_relative '../helper'
+
+module Arel
+  module Visitors
+    class PostgresTest < Arel::Spec
+      before do
+        @visitor = PostgreSQL.new Table.engine.connection
+        @table = Table.new(:users)
+        @attr = @table[:id]
+      end
+
+      def compile node
+        @visitor.accept(node, Collectors::SQLString.new).value
+      end
+
+      describe 'locking' do
+        it 'defaults to FOR UPDATE' do
+          compile(Nodes::Lock.new(Arel.sql('FOR UPDATE'))).must_be_like %{
+            FOR UPDATE
+          }
+        end
+
+        it 'allows a custom string to be used as a lock' do
+          node = Nodes::Lock.new(Arel.sql('FOR SHARE'))
+          compile(node).must_be_like %{
+            FOR SHARE
+          }
+        end
+      end
+
+      it "should escape LIMIT" do
+        sc = Arel::Nodes::SelectStatement.new
+        sc.limit = Nodes::Limit.new(Nodes.build_quoted("omg"))
+        sc.cores.first.projections << Arel.sql('DISTINCT ON')
+        sc.orders << Arel.sql("xyz")
+        sql =  compile(sc)
+        assert_match(/LIMIT 'omg'/, sql)
+        assert_equal 1, sql.scan(/LIMIT/).length, 'should have one limit'
+      end
+
+      it 'should support DISTINCT ON' do
+        core = Arel::Nodes::SelectCore.new
+        core.set_quantifier = Arel::Nodes::DistinctOn.new(Arel.sql('aaron'))
+        assert_match 'DISTINCT ON ( aaron )', compile(core)
+      end
+
+      it 'should support DISTINCT' do
+        core = Arel::Nodes::SelectCore.new
+        core.set_quantifier = Arel::Nodes::Distinct.new
+        assert_equal 'SELECT DISTINCT', compile(core)
+      end
+
+      it 'encloses LATERAL queries in parens' do
+        subquery = @table.project(:id).where(@table[:name].matches('foo%'))
+        compile(subquery.lateral).must_be_like %{
+          LATERAL (SELECT id FROM "users" WHERE "users"."name" ILIKE 'foo%')
+        }
+      end
+
+      it 'produces LATERAL queries with alias' do
+        subquery = @table.project(:id).where(@table[:name].matches('foo%'))
+        compile(subquery.lateral('bar')).must_be_like %{
+          LATERAL (SELECT id FROM "users" WHERE "users"."name" ILIKE 'foo%') bar
+        }
+      end
+
+      describe "Nodes::Matches" do
+        it "should know how to visit" do
+          node = @table[:name].matches('foo%')
+          node.must_be_kind_of Nodes::Matches
+          node.case_sensitive.must_equal(false)
+          compile(node).must_be_like %{
+            "users"."name" ILIKE 'foo%'
+          }
+        end
+
+        it "should know how to visit case sensitive" do
+          node = @table[:name].matches('foo%', nil, true)
+          node.case_sensitive.must_equal(true)
+          compile(node).must_be_like %{
+            "users"."name" LIKE 'foo%'
+          }
+        end
+
+        it "can handle ESCAPE" do
+          node = @table[:name].matches('foo!%', '!')
+          compile(node).must_be_like %{
+            "users"."name" ILIKE 'foo!%' ESCAPE '!'
+          }
+        end
+
+        it 'can handle subqueries' do
+          subquery = @table.project(:id).where(@table[:name].matches('foo%'))
+          node = @attr.in subquery
+          compile(node).must_be_like %{
+            "users"."id" IN (SELECT id FROM "users" WHERE "users"."name" ILIKE 'foo%')
+          }
+        end
+      end
+
+      describe "Nodes::DoesNotMatch" do
+        it "should know how to visit" do
+          node = @table[:name].does_not_match('foo%')
+          node.must_be_kind_of Nodes::DoesNotMatch
+          node.case_sensitive.must_equal(false)
+          compile(node).must_be_like %{
+            "users"."name" NOT ILIKE 'foo%'
+          }
+        end
+
+        it "should know how to visit case sensitive" do
+          node = @table[:name].does_not_match('foo%', nil, true)
+          node.case_sensitive.must_equal(true)
+          compile(node).must_be_like %{
+            "users"."name" NOT LIKE 'foo%'
+          }
+        end
+
+        it "can handle ESCAPE" do
+          node = @table[:name].does_not_match('foo!%', '!')
+          compile(node).must_be_like %{
+            "users"."name" NOT ILIKE 'foo!%' ESCAPE '!'
+          }
+        end
+
+        it 'can handle subqueries' do
+          subquery = @table.project(:id).where(@table[:name].does_not_match('foo%'))
+          node = @attr.in subquery
+          compile(node).must_be_like %{
+            "users"."id" IN (SELECT id FROM "users" WHERE "users"."name" NOT ILIKE 'foo%')
+          }
+        end
+      end
+
+      describe "Nodes::Regexp" do
+        it "should know how to visit" do
+          node = @table[:name].matches_regexp('foo.*')
+          node.must_be_kind_of Nodes::Regexp
+          node.case_sensitive.must_equal(true)
+          compile(node).must_be_like %{
+            "users"."name" ~ 'foo.*'
+          }
+        end
+
+        it "can handle case insensitive" do
+          node = @table[:name].matches_regexp('foo.*', false)
+          node.must_be_kind_of Nodes::Regexp
+          node.case_sensitive.must_equal(false)
+          compile(node).must_be_like %{
+            "users"."name" ~* 'foo.*'
+          }
+        end
+
+        it 'can handle subqueries' do
+          subquery = @table.project(:id).where(@table[:name].matches_regexp('foo.*'))
+          node = @attr.in subquery
+          compile(node).must_be_like %{
+            "users"."id" IN (SELECT id FROM "users" WHERE "users"."name" ~ 'foo.*')
+          }
+        end
+      end
+
+      describe "Nodes::NotRegexp" do
+        it "should know how to visit" do
+          node = @table[:name].does_not_match_regexp('foo.*')
+          node.must_be_kind_of Nodes::NotRegexp
+          node.case_sensitive.must_equal(true)
+          compile(node).must_be_like %{
+            "users"."name" !~ 'foo.*'
+          }
+        end
+
+        it "can handle case insensitive" do
+          node = @table[:name].does_not_match_regexp('foo.*', false)
+          node.case_sensitive.must_equal(false)
+          compile(node).must_be_like %{
+            "users"."name" !~* 'foo.*'
+          }
+        end
+
+        it 'can handle subqueries' do
+          subquery = @table.project(:id).where(@table[:name].does_not_match_regexp('foo.*'))
+          node = @attr.in subquery
+          compile(node).must_be_like %{
+            "users"."id" IN (SELECT id FROM "users" WHERE "users"."name" !~ 'foo.*')
+          }
+        end
+      end
+
+      describe "Nodes::BindParam" do
+        it "increments each bind param" do
+          query = @table[:name].eq(Arel::Nodes::BindParam.new(1))
+            .and(@table[:id].eq(Arel::Nodes::BindParam.new(1)))
+          compile(query).must_be_like %{
+            "users"."name" = $1 AND "users"."id" = $2
+          }
+        end
+      end
+
+      describe "Nodes::Cube" do
+        it "should know how to visit with array arguments" do
+          node = Arel::Nodes::Cube.new([@table[:name], @table[:bool]])
+          compile(node).must_be_like %{
+            CUBE( "users"."name", "users"."bool" )
+          }
+        end
+
+        it "should know how to visit with CubeDimension Argument" do
+          dimensions = Arel::Nodes::GroupingElement.new([@table[:name], @table[:bool]])
+          node = Arel::Nodes::Cube.new(dimensions)
+          compile(node).must_be_like %{
+            CUBE( "users"."name", "users"."bool" )
+          }
+        end
+
+        it "should know how to generate paranthesis when supplied with many Dimensions" do
+          dim1 = Arel::Nodes::GroupingElement.new(@table[:name])
+          dim2 = Arel::Nodes::GroupingElement.new([@table[:bool], @table[:created_at]])
+          node = Arel::Nodes::Cube.new([dim1, dim2])
+          compile(node).must_be_like %{
+            CUBE( ( "users"."name" ), ( "users"."bool", "users"."created_at" ) )
+          }
+        end
+      end
+
+      describe "Nodes::GroupingSet" do
+        it "should know how to visit with array arguments" do
+          node = Arel::Nodes::GroupingSet.new([@table[:name], @table[:bool]])
+          compile(node).must_be_like %{
+            GROUPING SET( "users"."name", "users"."bool" )
+          }
+        end
+
+        it "should know how to visit with CubeDimension Argument" do
+          group = Arel::Nodes::GroupingElement.new([@table[:name], @table[:bool]])
+          node = Arel::Nodes::GroupingSet.new(group)
+          compile(node).must_be_like %{
+            GROUPING SET( "users"."name", "users"."bool" )
+          }
+        end
+
+        it "should know how to generate paranthesis when supplied with many Dimensions" do
+          group1 = Arel::Nodes::GroupingElement.new(@table[:name])
+          group2 = Arel::Nodes::GroupingElement.new([@table[:bool], @table[:created_at]])
+          node = Arel::Nodes::GroupingSet.new([group1, group2])
+          compile(node).must_be_like %{
+            GROUPING SET( ( "users"."name" ), ( "users"."bool", "users"."created_at" ) )
+          }
+        end
+      end
+
+      describe "Nodes::RollUp" do
+        it "should know how to visit with array arguments" do
+          node = Arel::Nodes::RollUp.new([@table[:name], @table[:bool]])
+          compile(node).must_be_like %{
+            ROLLUP( "users"."name", "users"."bool" )
+          }
+        end
+
+        it "should know how to visit with CubeDimension Argument" do
+          group = Arel::Nodes::GroupingElement.new([@table[:name], @table[:bool]])
+          node = Arel::Nodes::RollUp.new(group)
+          compile(node).must_be_like %{
+            ROLLUP( "users"."name", "users"."bool" )
+          }
+        end
+
+        it "should know how to generate paranthesis when supplied with many Dimensions" do
+          group1 = Arel::Nodes::GroupingElement.new(@table[:name])
+          group2 = Arel::Nodes::GroupingElement.new([@table[:bool], @table[:created_at]])
+          node = Arel::Nodes::RollUp.new([group1, group2])
+          compile(node).must_be_like %{
+            ROLLUP( ( "users"."name" ), ( "users"."bool", "users"."created_at" ) )
+          }
+        end
+      end
+    end
+  end
+end
diff --git a/activerecord/test/cases/arel/visitors/sqlite_test.rb b/activerecord/test/cases/arel/visitors/sqlite_test.rb
new file mode 100644
index 0000000000..23f66ee096
--- /dev/null
+++ b/activerecord/test/cases/arel/visitors/sqlite_test.rb
@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+require_relative '../helper'
+
+module Arel
+  module Visitors
+    class SqliteTest < Arel::Spec
+      before do
+        @visitor = SQLite.new Table.engine.connection_pool
+      end
+
+      it 'defaults limit to -1' do
+        stmt = Nodes::SelectStatement.new
+        stmt.offset = Nodes::Offset.new(1)
+        sql = @visitor.accept(stmt, Collectors::SQLString.new).value
+        sql.must_be_like "SELECT LIMIT -1 OFFSET 1"
+      end
+
+      it 'does not support locking' do
+        node = Nodes::Lock.new(Arel.sql('FOR UPDATE'))
+        assert_equal '', @visitor.accept(node, Collectors::SQLString.new).value
+      end
+
+      it 'does not support boolean' do
+        node = Nodes::True.new()
+        assert_equal '1', @visitor.accept(node, Collectors::SQLString.new).value
+        node = Nodes::False.new()
+        assert_equal '0', @visitor.accept(node, Collectors::SQLString.new).value
+      end
+    end
+  end
+end
diff --git a/activerecord/test/cases/arel/visitors/to_sql_test.rb b/activerecord/test/cases/arel/visitors/to_sql_test.rb
new file mode 100644
index 0000000000..1503bcd578
--- /dev/null
+++ b/activerecord/test/cases/arel/visitors/to_sql_test.rb
@@ -0,0 +1,653 @@
+# frozen_string_literal: true
+require_relative '../helper'
+require 'bigdecimal'
+
+module Arel
+  module Visitors
+    describe 'the to_sql visitor' do
+      before do
+        @conn = FakeRecord::Base.new
+        @visitor = ToSql.new @conn.connection
+        @table = Table.new(:users)
+        @attr = @table[:id]
+      end
+
+      def compile node
+        @visitor.accept(node, Collectors::SQLString.new).value
+      end
+
+      it 'works with BindParams' do
+        node = Nodes::BindParam.new(1)
+        sql = compile node
+        sql.must_be_like '?'
+      end
+
+      it 'does not quote BindParams used as part of a Values' do
+        bp = Nodes::BindParam.new(1)
+        values = Nodes::Values.new([bp])
+        sql = compile values
+        sql.must_be_like 'VALUES (?)'
+      end
+
+      it 'can define a dispatch method' do
+        visited = false
+        viz = Class.new(Arel::Visitors::Visitor) {
+          define_method(:hello) do |node, c|
+            visited = true
+          end
+
+          def dispatch
+            { Arel::Table => 'hello' }
+          end
+        }.new
+
+        viz.accept(@table, Collectors::SQLString.new)
+        assert visited, 'hello method was called'
+      end
+
+      it 'should not quote sql literals' do
+        node = @table[Arel.star]
+        sql = compile node
+        sql.must_be_like '"users".*'
+      end
+
+      it 'should visit named functions' do
+        function = Nodes::NamedFunction.new('omg', [Arel.star])
+        assert_equal 'omg(*)', compile(function)
+      end
+
+      it 'should chain predications on named functions' do
+        function = Nodes::NamedFunction.new('omg', [Arel.star])
+        sql = compile(function.eq(2))
+        sql.must_be_like %{ omg(*) = 2 }
+      end
+
+      it 'should handle nil with named functions' do
+        function = Nodes::NamedFunction.new('omg', [Arel.star])
+        sql = compile(function.eq(nil))
+        sql.must_be_like %{ omg(*) IS NULL }
+      end
+
+      it 'should visit built-in functions' do
+        function = Nodes::Count.new([Arel.star])
+        assert_equal 'COUNT(*)', compile(function)
+
+        function = Nodes::Sum.new([Arel.star])
+        assert_equal 'SUM(*)', compile(function)
+
+        function = Nodes::Max.new([Arel.star])
+        assert_equal 'MAX(*)', compile(function)
+
+        function = Nodes::Min.new([Arel.star])
+        assert_equal 'MIN(*)', compile(function)
+
+        function = Nodes::Avg.new([Arel.star])
+        assert_equal 'AVG(*)', compile(function)
+      end
+
+      it 'should visit built-in functions operating on distinct values' do
+        function = Nodes::Count.new([Arel.star])
+        function.distinct = true
+        assert_equal 'COUNT(DISTINCT *)', compile(function)
+
+        function = Nodes::Sum.new([Arel.star])
+        function.distinct = true
+        assert_equal 'SUM(DISTINCT *)', compile(function)
+
+        function = Nodes::Max.new([Arel.star])
+        function.distinct = true
+        assert_equal 'MAX(DISTINCT *)', compile(function)
+
+        function = Nodes::Min.new([Arel.star])
+        function.distinct = true
+        assert_equal 'MIN(DISTINCT *)', compile(function)
+
+        function = Nodes::Avg.new([Arel.star])
+        function.distinct = true
+        assert_equal 'AVG(DISTINCT *)', compile(function)
+      end
+
+      it 'works with lists' do
+        function = Nodes::NamedFunction.new('omg', [Arel.star, Arel.star])
+        assert_equal 'omg(*, *)', compile(function)
+      end
+
+      describe 'Nodes::Equality' do
+        it "should escape strings" do
+          test = Table.new(:users)[:name].eq 'Aaron Patterson'
+          compile(test).must_be_like %{
+            "users"."name" = 'Aaron Patterson'
+          }
+        end
+
+        it 'should handle false' do
+          table = Table.new(:users)
+          val = Nodes.build_quoted(false, table[:active])
+          sql = compile Nodes::Equality.new(val, val)
+          sql.must_be_like %{ 'f' = 'f' }
+        end
+
+        it 'should handle nil' do
+          sql = compile Nodes::Equality.new(@table[:name], nil)
+          sql.must_be_like %{ "users"."name" IS NULL }
+        end
+      end
+
+      describe 'Nodes::Grouping' do
+        it 'wraps nested groupings in brackets only once' do
+          sql = compile Nodes::Grouping.new(Nodes::Grouping.new(Nodes.build_quoted('foo')))
+          sql.must_equal "('foo')"
+        end
+      end
+
+      describe 'Nodes::NotEqual' do
+        it 'should handle false' do
+          val = Nodes.build_quoted(false, @table[:active])
+          sql = compile Nodes::NotEqual.new(@table[:active], val)
+          sql.must_be_like %{ "users"."active" != 'f' }
+        end
+
+        it 'should handle nil' do
+          val = Nodes.build_quoted(nil, @table[:active])
+          sql = compile Nodes::NotEqual.new(@table[:name], val)
+          sql.must_be_like %{ "users"."name" IS NOT NULL }
+        end
+      end
+
+      it "should visit string subclass" do
+        [
+          Class.new(String).new(":'("),
+          Class.new(Class.new(String)).new(":'("),
+        ].each do |obj|
+          val = Nodes.build_quoted(obj, @table[:active])
+          sql = compile Nodes::NotEqual.new(@table[:name], val)
+          sql.must_be_like %{ "users"."name" != ':\\'(' }
+        end
+      end
+
+      it "should visit_Class" do
+        compile(Nodes.build_quoted(DateTime)).must_equal "'DateTime'"
+      end
+
+      it "should escape LIMIT" do
+        sc = Arel::Nodes::SelectStatement.new
+        sc.limit = Arel::Nodes::Limit.new(Nodes.build_quoted("omg"))
+        assert_match(/LIMIT 'omg'/, compile(sc))
+      end
+
+      it "should contain a single space before ORDER BY" do
+        table = Table.new(:users)
+        test = table.order(table[:name])
+        sql = compile test
+        assert_match(/"users" ORDER BY/, sql)
+      end
+
+      it "should quote LIMIT without column type coercion" do
+        table = Table.new(:users)
+        sc = table.where(table[:name].eq(0)).take(1).ast
+        assert_match(/WHERE "users"."name" = 0 LIMIT 1/, compile(sc))
+      end
+
+      it "should visit_DateTime" do
+        dt = DateTime.now
+        table = Table.new(:users)
+        test = table[:created_at].eq dt
+        sql = compile test
+
+        sql.must_be_like %{"users"."created_at" = '#{dt.strftime("%Y-%m-%d %H:%M:%S")}'}
+      end
+
+      it "should visit_Float" do
+        test = Table.new(:products)[:price].eq 2.14
+        sql = compile test
+        sql.must_be_like %{"products"."price" = 2.14}
+      end
+
+      it "should visit_Not" do
+        sql = compile Nodes::Not.new(Arel.sql("foo"))
+        sql.must_be_like "NOT (foo)"
+      end
+
+      it "should apply Not to the whole expression" do
+        node = Nodes::And.new [@attr.eq(10), @attr.eq(11)]
+        sql = compile Nodes::Not.new(node)
+        sql.must_be_like %{NOT ("users"."id" = 10 AND "users"."id" = 11)}
+      end
+
+      it "should visit_As" do
+        as = Nodes::As.new(Arel.sql("foo"), Arel.sql("bar"))
+        sql = compile as
+        sql.must_be_like "foo AS bar"
+      end
+
+      it "should visit_Bignum" do
+        compile 8787878092
+      end
+
+      it "should visit_Hash" do
+        compile(Nodes.build_quoted({:a => 1}))
+      end
+
+      it "should visit_Set" do
+        compile Nodes.build_quoted(Set.new([1, 2]))
+      end
+
+      it "should visit_BigDecimal" do
+        compile Nodes.build_quoted(BigDecimal('2.14'))
+      end
+
+      it "should visit_Date" do
+        dt = Date.today
+        table = Table.new(:users)
+        test = table[:created_at].eq dt
+        sql = compile test
+
+        sql.must_be_like %{"users"."created_at" = '#{dt.strftime("%Y-%m-%d")}'}
+      end
+
+      it "should visit_NilClass" do
+        compile(Nodes.build_quoted(nil)).must_be_like "NULL"
+      end
+
+      it "unsupported input should raise UnsupportedVisitError" do
+        error = assert_raises(UnsupportedVisitError) { compile(nil) }
+        assert_match(/\AUnsupported/, error.message)
+      end
+
+      it "should visit_Arel_SelectManager, which is a subquery" do
+        mgr = Table.new(:foo).project(:bar)
+        compile(mgr).must_be_like '(SELECT bar FROM "foo")'
+      end
+
+      it "should visit_Arel_Nodes_And" do
+        node = Nodes::And.new [@attr.eq(10), @attr.eq(11)]
+        compile(node).must_be_like %{
+          "users"."id" = 10 AND "users"."id" = 11
+        }
+      end
+
+      it "should visit_Arel_Nodes_Or" do
+        node = Nodes::Or.new @attr.eq(10), @attr.eq(11)
+        compile(node).must_be_like %{
+          "users"."id" = 10 OR "users"."id" = 11
+        }
+      end
+
+      it "should visit_Arel_Nodes_Assignment" do
+        column = @table["id"]
+        node = Nodes::Assignment.new(
+          Nodes::UnqualifiedColumn.new(column),
+          Nodes::UnqualifiedColumn.new(column)
+        )
+        compile(node).must_be_like %{
+          "id" = "id"
+        }
+      end
+
+      it "should visit visit_Arel_Attributes_Time" do
+        attr = Attributes::Time.new(@attr.relation, @attr.name)
+        compile attr
+      end
+
+      it "should visit_TrueClass" do
+        test = Table.new(:users)[:bool].eq(true)
+        compile(test).must_be_like %{ "users"."bool" = 't' }
+      end
+
+      describe "Nodes::Matches" do
+        it "should know how to visit" do
+          node = @table[:name].matches('foo%')
+          compile(node).must_be_like %{
+            "users"."name" LIKE 'foo%'
+          }
+        end
+
+        it "can handle ESCAPE" do
+          node = @table[:name].matches('foo!%', '!')
+          compile(node).must_be_like %{
+            "users"."name" LIKE 'foo!%' ESCAPE '!'
+          }
+        end
+
+        it 'can handle subqueries' do
+          subquery = @table.project(:id).where(@table[:name].matches('foo%'))
+          node = @attr.in subquery
+          compile(node).must_be_like %{
+            "users"."id" IN (SELECT id FROM "users" WHERE "users"."name" LIKE 'foo%')
+          }
+        end
+      end
+
+      describe "Nodes::DoesNotMatch" do
+        it "should know how to visit" do
+          node = @table[:name].does_not_match('foo%')
+          compile(node).must_be_like %{
+            "users"."name" NOT LIKE 'foo%'
+          }
+        end
+
+        it "can handle ESCAPE" do
+          node = @table[:name].does_not_match('foo!%', '!')
+          compile(node).must_be_like %{
+            "users"."name" NOT LIKE 'foo!%' ESCAPE '!'
+          }
+        end
+
+        it 'can handle subqueries' do
+          subquery = @table.project(:id).where(@table[:name].does_not_match('foo%'))
+          node = @attr.in subquery
+          compile(node).must_be_like %{
+            "users"."id" IN (SELECT id FROM "users" WHERE "users"."name" NOT LIKE 'foo%')
+          }
+        end
+      end
+
+      describe "Nodes::Ordering" do
+        it "should know how to visit" do
+          node = @attr.desc
+          compile(node).must_be_like %{
+            "users"."id" DESC
+          }
+        end
+      end
+
+      describe "Nodes::In" do
+        it "should know how to visit" do
+          node = @attr.in [1, 2, 3]
+          compile(node).must_be_like %{
+            "users"."id" IN (1, 2, 3)
+          }
+        end
+
+        it "should return 1=0 when empty right which is always false" do
+          node = @attr.in []
+          compile(node).must_equal '1=0'
+        end
+
+        it 'can handle two dot ranges' do
+          node = @attr.between 1..3
+          compile(node).must_be_like %{
+            "users"."id" BETWEEN 1 AND 3
+          }
+        end
+
+        it 'can handle three dot ranges' do
+          node = @attr.between 1...3
+          compile(node).must_be_like %{
+            "users"."id" >= 1 AND "users"."id" < 3
+          }
+        end
+
+        it 'can handle ranges bounded by infinity' do
+          node = @attr.between 1..Float::INFINITY
+          compile(node).must_be_like %{
+            "users"."id" >= 1
+          }
+          node = @attr.between(-Float::INFINITY..3)
+          compile(node).must_be_like %{
+            "users"."id" <= 3
+          }
+          node = @attr.between(-Float::INFINITY...3)
+          compile(node).must_be_like %{
+            "users"."id" < 3
+          }
+          node = @attr.between(-Float::INFINITY..Float::INFINITY)
+          compile(node).must_be_like %{1=1}
+        end
+
+        it 'can handle subqueries' do
+          table = Table.new(:users)
+          subquery = table.project(:id).where(table[:name].eq('Aaron'))
+          node = @attr.in subquery
+          compile(node).must_be_like %{
+            "users"."id" IN (SELECT id FROM "users" WHERE "users"."name" = 'Aaron')
+          }
+        end
+      end
+
+      describe "Nodes::InfixOperation" do
+        it "should handle Multiplication" do
+          node = Arel::Attributes::Decimal.new(Table.new(:products), :price) * Arel::Attributes::Decimal.new(Table.new(:currency_rates), :rate)
+          compile(node).must_equal %("products"."price" * "currency_rates"."rate")
+        end
+
+        it "should handle Division" do
+          node = Arel::Attributes::Decimal.new(Table.new(:products), :price) / 5
+          compile(node).must_equal %("products"."price" / 5)
+        end
+
+        it "should handle Addition" do
+          node = Arel::Attributes::Decimal.new(Table.new(:products), :price) + 6
+          compile(node).must_equal %(("products"."price" + 6))
+        end
+
+        it "should handle Subtraction" do
+          node = Arel::Attributes::Decimal.new(Table.new(:products), :price) - 7
+          compile(node).must_equal %(("products"."price" - 7))
+        end
+
+        it "should handle Concatination" do
+          table = Table.new(:users)
+          node = table[:name].concat(table[:name])
+          compile(node).must_equal %("users"."name" || "users"."name")
+        end
+
+        it "should handle BitwiseAnd" do
+          node = Arel::Attributes::Integer.new(Table.new(:products), :bitmap) & 16
+          compile(node).must_equal %(("products"."bitmap" & 16))
+        end
+
+        it "should handle BitwiseOr" do
+          node = Arel::Attributes::Integer.new(Table.new(:products), :bitmap) | 16
+          compile(node).must_equal %(("products"."bitmap" | 16))
+        end
+
+        it "should handle BitwiseXor" do
+          node = Arel::Attributes::Integer.new(Table.new(:products), :bitmap) ^ 16
+          compile(node).must_equal %(("products"."bitmap" ^ 16))
+        end
+
+        it "should handle BitwiseShiftLeft" do
+          node = Arel::Attributes::Integer.new(Table.new(:products), :bitmap) << 4
+          compile(node).must_equal %(("products"."bitmap" << 4))
+        end
+
+        it "should handle BitwiseShiftRight" do
+          node = Arel::Attributes::Integer.new(Table.new(:products), :bitmap) >> 4
+          compile(node).must_equal %(("products"."bitmap" >> 4))
+        end
+
+        it "should handle arbitrary operators" do
+          node = Arel::Nodes::InfixOperation.new(
+            '&&',
+            Arel::Attributes::String.new(Table.new(:products), :name),
+            Arel::Attributes::String.new(Table.new(:products), :name)
+          )
+          compile(node).must_equal %("products"."name" && "products"."name")
+        end
+      end
+
+      describe "Nodes::UnaryOperation" do
+        it "should handle BitwiseNot" do
+          node = ~ Arel::Attributes::Integer.new(Table.new(:products), :bitmap)
+          compile(node).must_equal %( ~ "products"."bitmap")
+        end
+
+        it "should handle arbitrary operators" do
+          node = Arel::Nodes::UnaryOperation.new('!', Arel::Attributes::String.new(Table.new(:products), :active))
+          compile(node).must_equal %( ! "products"."active")
+        end
+      end
+
+      describe "Nodes::NotIn" do
+        it "should know how to visit" do
+          node = @attr.not_in [1, 2, 3]
+          compile(node).must_be_like %{
+            "users"."id" NOT IN (1, 2, 3)
+          }
+        end
+
+        it "should return 1=1 when empty right which is always true" do
+          node = @attr.not_in []
+          compile(node).must_equal '1=1'
+        end
+
+        it 'can handle two dot ranges' do
+          node = @attr.not_between 1..3
+          compile(node).must_equal(
+            %{("users"."id" < 1 OR "users"."id" > 3)}
+          )
+        end
+
+        it 'can handle three dot ranges' do
+          node = @attr.not_between 1...3
+          compile(node).must_equal(
+            %{("users"."id" < 1 OR "users"."id" >= 3)}
+          )
+        end
+
+        it 'can handle ranges bounded by infinity' do
+          node = @attr.not_between 1..Float::INFINITY
+          compile(node).must_be_like %{
+            "users"."id" < 1
+          }
+          node = @attr.not_between(-Float::INFINITY..3)
+          compile(node).must_be_like %{
+            "users"."id" > 3
+          }
+          node = @attr.not_between(-Float::INFINITY...3)
+          compile(node).must_be_like %{
+            "users"."id" >= 3
+          }
+          node = @attr.not_between(-Float::INFINITY..Float::INFINITY)
+          compile(node).must_be_like %{1=0}
+        end
+
+        it 'can handle subqueries' do
+          table = Table.new(:users)
+          subquery = table.project(:id).where(table[:name].eq('Aaron'))
+          node = @attr.not_in subquery
+          compile(node).must_be_like %{
+            "users"."id" NOT IN (SELECT id FROM "users" WHERE "users"."name" = 'Aaron')
+          }
+        end
+      end
+
+      describe 'Constants' do
+        it "should handle true" do
+          test = Table.new(:users).create_true
+          compile(test).must_be_like %{
+            TRUE
+          }
+        end
+
+        it "should handle false" do
+          test = Table.new(:users).create_false
+          compile(test).must_be_like %{
+            FALSE
+          }
+        end
+      end
+
+      describe 'TableAlias' do
+        it "should use the underlying table for checking columns" do
+          test = Table.new(:users).alias('zomgusers')[:id].eq '3'
+          compile(test).must_be_like %{
+            "zomgusers"."id" = '3'
+          }
+        end
+      end
+
+      describe 'distinct on' do
+        it 'raises not implemented error' do
+          core = Arel::Nodes::SelectCore.new
+          core.set_quantifier = Arel::Nodes::DistinctOn.new(Arel.sql('aaron'))
+
+          assert_raises(NotImplementedError) do
+            compile(core)
+          end
+        end
+      end
+
+      describe 'Nodes::Regexp' do
+        it 'raises not implemented error' do
+          node = Arel::Nodes::Regexp.new(@table[:name], Nodes.build_quoted('foo%'))
+
+          assert_raises(NotImplementedError) do
+            compile(node)
+          end
+        end
+      end
+
+      describe 'Nodes::NotRegexp' do
+        it 'raises not implemented error' do
+          node = Arel::Nodes::NotRegexp.new(@table[:name], Nodes.build_quoted('foo%'))
+
+          assert_raises(NotImplementedError) do
+            compile(node)
+          end
+        end
+      end
+
+      describe 'Nodes::Case' do
+        it 'supports simple case expressions' do
+          node = Arel::Nodes::Case.new(@table[:name])
+            .when('foo').then(1)
+            .else(0)
+
+          compile(node).must_be_like %{
+            CASE "users"."name" WHEN 'foo' THEN 1 ELSE 0 END
+          }
+        end
+
+        it 'supports extended case expressions' do
+          node = Arel::Nodes::Case.new
+            .when(@table[:name].in(%w(foo bar))).then(1)
+            .else(0)
+
+          compile(node).must_be_like %{
+            CASE WHEN "users"."name" IN ('foo', 'bar') THEN 1 ELSE 0 END
+          }
+        end
+
+        it 'works without default branch' do
+          node = Arel::Nodes::Case.new(@table[:name])
+            .when('foo').then(1)
+
+          compile(node).must_be_like %{
+            CASE "users"."name" WHEN 'foo' THEN 1 END
+          }
+        end
+
+        it 'allows chaining multiple conditions' do
+          node = Arel::Nodes::Case.new(@table[:name])
+            .when('foo').then(1)
+            .when('bar').then(2)
+            .else(0)
+
+          compile(node).must_be_like %{
+            CASE "users"."name" WHEN 'foo' THEN 1 WHEN 'bar' THEN 2 ELSE 0 END
+          }
+        end
+
+        it 'supports #when with two arguments and no #then' do
+          node = Arel::Nodes::Case.new @table[:name]
+
+          { foo: 1, bar: 0 }.reduce(node) { |_node, pair| _node.when(*pair) }
+
+          compile(node).must_be_like %{
+            CASE "users"."name" WHEN 'foo' THEN 1 WHEN 'bar' THEN 0 END
+          }
+        end
+
+        it 'can be chained as a predicate' do
+          node = @table[:name].when('foo').then('bar').else('baz')
+
+          compile(node).must_be_like %{
+            CASE "users"."name" WHEN 'foo' THEN 'bar' ELSE 'baz' END
+          }
+        end
+      end
+    end
+  end
+end