Inject the `PredicateBuilder` into the `Relation` instance

Construction of relations can be a hotspot, we don't want to create one
of these in the constructor. This also allows us to do more expensive
things in the predicate builder's constructor, since it's created once
per AR::Base subclass

3 files changed, 28 insertions, 27 deletions

diff --git a/activerecord/test/cases/relation/mutation_test.rb b/activerecord/test/cases/relation/mutation_test.rb
index 4c94c2fd0d..71abac35cc 100644
--- a/activerecord/test/cases/relation/mutation_test.rb
+++ b/activerecord/test/cases/relation/mutation_test.rb
@@ -25,7 +25,7 @@ module ActiveRecord
     end
 
     def relation
-      @relation ||= Relation.new FakeKlass.new('posts'), Post.arel_table
+      @relation ||= Relation.new FakeKlass.new('posts'), Post.arel_table, Post.predicate_builder
     end
 
     (Relation::MULTI_VALUE_METHODS - [:references, :extending, :order, :unscope, :select]).each do |method|
diff --git a/activerecord/test/cases/relation_test.rb b/activerecord/test/cases/relation_test.rb
index 3280945d09..c34516308e 100644
--- a/activerecord/test/cases/relation_test.rb
+++ b/activerecord/test/cases/relation_test.rb
@@ -23,19 +23,19 @@ module ActiveRecord
     end
 
     def test_construction
-      relation = Relation.new FakeKlass, :b
+      relation = Relation.new(FakeKlass, :b, nil)
       assert_equal FakeKlass, relation.klass
       assert_equal :b, relation.table
       assert !relation.loaded, 'relation is not loaded'
     end
 
     def test_responds_to_model_and_returns_klass
-      relation = Relation.new FakeKlass, :b
+      relation = Relation.new(FakeKlass, :b, nil)
       assert_equal FakeKlass, relation.model
     end
 
     def test_initialize_single_values
-      relation = Relation.new FakeKlass, :b
+      relation = Relation.new(FakeKlass, :b, nil)
       (Relation::SINGLE_VALUE_METHODS - [:create_with]).each do |method|
         assert_nil relation.send("#{method}_value"), method.to_s
       end
@@ -43,19 +43,19 @@ module ActiveRecord
     end
 
     def test_multi_value_initialize
-      relation = Relation.new FakeKlass, :b
+      relation = Relation.new(FakeKlass, :b, nil)
       Relation::MULTI_VALUE_METHODS.each do |method|
         assert_equal [], relation.send("#{method}_values"), method.to_s
       end
     end
 
     def test_extensions
-      relation = Relation.new FakeKlass, :b
+      relation = Relation.new(FakeKlass, :b, nil)
       assert_equal [], relation.extensions
     end
 
     def test_empty_where_values_hash
-      relation = Relation.new FakeKlass, :b
+      relation = Relation.new(FakeKlass, :b, nil)
       assert_equal({}, relation.where_values_hash)
 
       relation.where! :hello
@@ -63,19 +63,19 @@ module ActiveRecord
     end
 
     def test_has_values
-      relation = Relation.new Post, Post.arel_table
+      relation = Relation.new(Post, Post.arel_table, Post.predicate_builder)
       relation.where! relation.table[:id].eq(10)
       assert_equal({:id => 10}, relation.where_values_hash)
     end
 
     def test_values_wrong_table
-      relation = Relation.new Post, Post.arel_table
+      relation = Relation.new(Post, Post.arel_table, Post.predicate_builder)
       relation.where! Comment.arel_table[:id].eq(10)
       assert_equal({}, relation.where_values_hash)
     end
 
     def test_tree_is_not_traversed
-      relation = Relation.new Post, Post.arel_table
+      relation = Relation.new(Post, Post.arel_table, Post.predicate_builder)
       left     = relation.table[:id].eq(10)
       right    = relation.table[:id].eq(10)
       combine  = left.and right
@@ -84,24 +84,24 @@ module ActiveRecord
     end
 
     def test_table_name_delegates_to_klass
-      relation = Relation.new FakeKlass.new('posts'), :b
+      relation = Relation.new(FakeKlass.new('posts'), :b, Post.predicate_builder)
       assert_equal 'posts', relation.table_name
     end
 
     def test_scope_for_create
-      relation = Relation.new FakeKlass, :b
+      relation = Relation.new(FakeKlass, :b, nil)
       assert_equal({}, relation.scope_for_create)
     end
 
     def test_create_with_value
-      relation = Relation.new Post, Post.arel_table
+      relation = Relation.new(Post, Post.arel_table, Post.predicate_builder)
       hash = { :hello => 'world' }
       relation.create_with_value = hash
       assert_equal hash, relation.scope_for_create
     end
 
     def test_create_with_value_with_wheres
-      relation = Relation.new Post, Post.arel_table
+      relation = Relation.new(Post, Post.arel_table, Post.predicate_builder)
       relation.where! relation.table[:id].eq(10)
       relation.create_with_value = {:hello => 'world'}
       assert_equal({:hello => 'world', :id => 10}, relation.scope_for_create)
@@ -109,7 +109,7 @@ module ActiveRecord
 
     # FIXME: is this really wanted or expected behavior?
     def test_scope_for_create_is_cached
-      relation = Relation.new Post, Post.arel_table
+      relation = Relation.new(Post, Post.arel_table, Post.predicate_builder)
       assert_equal({}, relation.scope_for_create)
 
       relation.where! relation.table[:id].eq(10)
@@ -126,31 +126,31 @@ module ActiveRecord
     end
 
     def test_empty_eager_loading?
-      relation = Relation.new FakeKlass, :b
+      relation = Relation.new(FakeKlass, :b, nil)
       assert !relation.eager_loading?
     end
 
     def test_eager_load_values
-      relation = Relation.new FakeKlass, :b
+      relation = Relation.new(FakeKlass, :b, nil)
       relation.eager_load! :b
       assert relation.eager_loading?
     end
 
     def test_references_values
-      relation = Relation.new FakeKlass, :b
+      relation = Relation.new(FakeKlass, :b, nil)
       assert_equal [], relation.references_values
       relation = relation.references(:foo).references(:omg, :lol)
       assert_equal ['foo', 'omg', 'lol'], relation.references_values
     end
 
     def test_references_values_dont_duplicate
-      relation = Relation.new FakeKlass, :b
+      relation = Relation.new(FakeKlass, :b, nil)
       relation = relation.references(:foo).references(:foo)
       assert_equal ['foo'], relation.references_values
     end
 
     test 'merging a hash into a relation' do
-      relation = Relation.new FakeKlass, :b
+      relation = Relation.new(FakeKlass, :b, nil)
       relation = relation.merge where: :lol, readonly: true
 
       assert_equal [:lol], relation.where_values
@@ -158,7 +158,7 @@ module ActiveRecord
     end
 
     test 'merging an empty hash into a relation' do
-      assert_equal [], Relation.new(FakeKlass, :b).merge({}).where_values
+      assert_equal [], Relation.new(FakeKlass, :b, nil).merge({}).where_values
     end
 
     test 'merging a hash with unknown keys raises' do
@@ -166,7 +166,7 @@ module ActiveRecord
     end
 
     test '#values returns a dup of the values' do
-      relation = Relation.new(FakeKlass, :b).where! :foo
+      relation = Relation.new(FakeKlass, :b, nil).where! :foo
       values   = relation.values
 
       values[:where] = nil
@@ -174,12 +174,12 @@ module ActiveRecord
     end
 
     test 'relations can be created with a values hash' do
-      relation = Relation.new(FakeKlass, :b, where: [:foo])
+      relation = Relation.new(FakeKlass, :b, nil, where: [:foo])
       assert_equal [:foo], relation.where_values
     end
 
     test 'merging a single where value' do
-      relation = Relation.new(FakeKlass, :b)
+      relation = Relation.new(FakeKlass, :b, nil)
       relation.merge!(where: :foo)
       assert_equal [:foo], relation.where_values
     end
@@ -192,13 +192,13 @@ module ActiveRecord
         end
       end
 
-      relation = Relation.new(klass, :b)
+      relation = Relation.new(klass, :b, nil)
       relation.merge!(where: ['foo = ?', 'bar'])
       assert_equal ['foo = bar'], relation.where_values
     end
 
     def test_merging_readonly_false
-      relation = Relation.new FakeKlass, :b
+      relation = Relation.new(FakeKlass, :b, nil)
       readonly_false_relation = relation.readonly(false)
       # test merging in both directions
       assert_equal false, relation.merge(readonly_false_relation).readonly_value
diff --git a/activerecord/test/cases/relations_test.rb b/activerecord/test/cases/relations_test.rb
index 3a0398d08d..408b0ff6ab 100644
--- a/activerecord/test/cases/relations_test.rb
+++ b/activerecord/test/cases/relations_test.rb
@@ -1663,7 +1663,8 @@ class RelationTest < ActiveRecord::TestCase
   test 'using a custom table affects the wheres' do
     table_alias = Post.arel_table.alias('omg_posts')
 
-    relation = ActiveRecord::Relation.new Post, table_alias
+    predicate_builder = ActiveRecord::PredicateBuilder.new(Post, table_alias)
+    relation = ActiveRecord::Relation.new(Post, table_alias, predicate_builder)
     relation.where!(:foo => "bar")
 
     node = relation.arel.constraints.first.grep(Arel::Attributes::Attribute).first