Revert "Extract `bind_param` and `bind_attribute` into `ActiveRecord::TestCase`"

This reverts commit b6ad4052d18e4b29b8a092526c2beef013e2bf4f.

This is not something that the majority of Active Record should be
testing or care about. We should look at having fewer places rely on
these details, not make it easier to rely on them.

13 files changed, 56 insertions, 46 deletions

diff --git a/activerecord/test/cases/adapter_test.rb b/activerecord/test/cases/adapter_test.rb
index 827bcba121..dd031e965c 100644
--- a/activerecord/test/cases/adapter_test.rb
+++ b/activerecord/test/cases/adapter_test.rb
@@ -242,7 +242,7 @@ module ActiveRecord
       def test_select_all_with_legacy_binds
         post = Post.create!(title: "foo", body: "bar")
         expected = @connection.select_all("SELECT * FROM posts WHERE id = #{post.id}")
-        result = @connection.select_all("SELECT * FROM posts WHERE id = #{bind_param.to_sql}", nil, [[nil, post.id]])
+        result = @connection.select_all("SELECT * FROM posts WHERE id = #{Arel::Nodes::BindParam.new.to_sql}", nil, [[nil, post.id]])
         assert_equal expected.to_hash, result.to_hash
       end
     end
diff --git a/activerecord/test/cases/adapters/postgresql/connection_test.rb b/activerecord/test/cases/adapters/postgresql/connection_test.rb
index 32afe331fa..ec90372545 100644
--- a/activerecord/test/cases/adapters/postgresql/connection_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/connection_test.rb
@@ -133,8 +133,8 @@ module ActiveRecord
 
     if ActiveRecord::Base.connection.prepared_statements
       def test_statement_key_is_logged
-        binds = [bind_attribute(nil, 1)]
-        @connection.exec_query("SELECT $1::integer", "SQL", binds, prepare: true)
+        bind = Relation::QueryAttribute.new(nil, 1, Type::Value.new)
+        @connection.exec_query("SELECT $1::integer", "SQL", [bind], prepare: true)
         name = @subscriber.payloads.last[:statement_name]
         assert name
         res = @connection.exec_query("EXPLAIN (FORMAT JSON) EXECUTE #{name}(1)")
diff --git a/activerecord/test/cases/adapters/postgresql/postgresql_adapter_test.rb b/activerecord/test/cases/adapters/postgresql/postgresql_adapter_test.rb
index 76e0ad60fe..5a3eafda6e 100644
--- a/activerecord/test/cases/adapters/postgresql/postgresql_adapter_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/postgresql_adapter_test.rb
@@ -202,8 +202,8 @@ module ActiveRecord
             string = @connection.quote("foo")
             @connection.exec_query("INSERT INTO ex (id, data) VALUES (1, #{string})")
 
-            binds = [bind_attribute("id", 1)]
-            result = @connection.exec_query("SELECT id, data FROM ex WHERE id = $1", nil, binds)
+            bind = Relation::QueryAttribute.new("id", 1, Type::Value.new)
+            result = @connection.exec_query("SELECT id, data FROM ex WHERE id = $1", nil, [bind])
 
             assert_equal 1, result.rows.length
             assert_equal 2, result.columns.length
@@ -217,8 +217,8 @@ module ActiveRecord
             string = @connection.quote("foo")
             @connection.exec_query("INSERT INTO ex (id, data) VALUES (1, #{string})")
 
-            binds = [bind_attribute("id", "1-fuu", Type::Integer.new)]
-            result = @connection.exec_query("SELECT id, data FROM ex WHERE id = $1", nil, binds)
+            bind = Relation::QueryAttribute.new("id", "1-fuu", Type::Integer.new)
+            result = @connection.exec_query("SELECT id, data FROM ex WHERE id = $1", nil, [bind])
 
             assert_equal 1, result.rows.length
             assert_equal 2, result.columns.length
diff --git a/activerecord/test/cases/adapters/postgresql/schema_authorization_test.rb b/activerecord/test/cases/adapters/postgresql/schema_authorization_test.rb
index f86a76e08a..72639f2a3f 100644
--- a/activerecord/test/cases/adapters/postgresql/schema_authorization_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/schema_authorization_test.rb
@@ -68,7 +68,7 @@ class SchemaAuthorizationTest < ActiveRecord::PostgreSQLTestCase
         USERS.each do |u|
           @connection.clear_cache!
           set_session_auth u
-          assert_equal u, @connection.select_value("SELECT name FROM #{TABLE_NAME} WHERE id = $1", "SQL", [bind_attribute("id", 1)])
+          assert_equal u, @connection.select_value("SELECT name FROM #{TABLE_NAME} WHERE id = $1", "SQL", [bind_param(1)])
           set_session_auth
         end
       end
@@ -101,4 +101,8 @@ class SchemaAuthorizationTest < ActiveRecord::PostgreSQLTestCase
     def set_session_auth(auth = nil)
       @connection.session_auth = auth || "default"
     end
+
+    def bind_param(value)
+      ActiveRecord::Relation::QueryAttribute.new(nil, value, ActiveRecord::Type::Value.new)
+    end
 end
diff --git a/activerecord/test/cases/adapters/postgresql/schema_test.rb b/activerecord/test/cases/adapters/postgresql/schema_test.rb
index f6b957476b..75e30e4fe9 100644
--- a/activerecord/test/cases/adapters/postgresql/schema_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/schema_test.rb
@@ -169,17 +169,17 @@ class SchemaTest < ActiveRecord::PostgreSQLTestCase
 
   def test_raise_wrapped_exception_on_bad_prepare
     assert_raises(ActiveRecord::StatementInvalid) do
-      @connection.exec_query "select * from developers where id = ?", "sql", [bind_attribute("id", 1)]
+      @connection.exec_query "select * from developers where id = ?", "sql", [bind_param(1)]
     end
   end
 
   if ActiveRecord::Base.connection.prepared_statements
     def test_schema_change_with_prepared_stmt
       altered = false
-      @connection.exec_query "select * from developers where id = $1", "sql", [bind_attribute("id", 1)]
+      @connection.exec_query "select * from developers where id = $1", "sql", [bind_param(1)]
       @connection.exec_query "alter table developers add column zomg int", "sql", []
       altered = true
-      @connection.exec_query "select * from developers where id = $1", "sql", [bind_attribute("id", 1)]
+      @connection.exec_query "select * from developers where id = $1", "sql", [bind_param(1)]
     ensure
       # We are not using DROP COLUMN IF EXISTS because that syntax is only
       # supported by pg 9.X
@@ -467,6 +467,10 @@ class SchemaTest < ActiveRecord::PostgreSQLTestCase
       assert_equal this_index_column, this_index.columns[0]
       assert_equal this_index_name, this_index.name
     end
+
+    def bind_param(value)
+      ActiveRecord::Relation::QueryAttribute.new(nil, value, ActiveRecord::Type::Value.new)
+    end
 end
 
 class SchemaForeignKeyTest < ActiveRecord::PostgreSQLTestCase
diff --git a/activerecord/test/cases/adapters/sqlite3/sqlite3_adapter_test.rb b/activerecord/test/cases/adapters/sqlite3/sqlite3_adapter_test.rb
index cf0c37f70c..9160752b01 100644
--- a/activerecord/test/cases/adapters/sqlite3/sqlite3_adapter_test.rb
+++ b/activerecord/test/cases/adapters/sqlite3/sqlite3_adapter_test.rb
@@ -66,11 +66,11 @@ module ActiveRecord
 
       def test_exec_insert
         with_example_table do
-          binds = [bind_attribute("number", 10)]
-          @conn.exec_insert("insert into ex (number) VALUES (?)", "SQL", binds)
+          vals = [Relation::QueryAttribute.new("number", 10, Type::Value.new)]
+          @conn.exec_insert("insert into ex (number) VALUES (?)", "SQL", vals)
 
           result = @conn.exec_query(
-            "select number from ex where number = ?", "SQL", binds)
+            "select number from ex where number = ?", "SQL", vals)
 
           assert_equal 1, result.rows.length
           assert_equal 10, result.rows.first.first
@@ -134,7 +134,7 @@ module ActiveRecord
         with_example_table "id int, data string" do
           @conn.exec_query('INSERT INTO ex (id, data) VALUES (1, "foo")')
           result = @conn.exec_query(
-            "SELECT id, data FROM ex WHERE id = ?", nil, [bind_attribute("id", 1)])
+            "SELECT id, data FROM ex WHERE id = ?", nil, [Relation::QueryAttribute.new(nil, 1, Type::Value.new)])
 
           assert_equal 1, result.rows.length
           assert_equal 2, result.columns.length
@@ -148,7 +148,7 @@ module ActiveRecord
           @conn.exec_query('INSERT INTO ex (id, data) VALUES (1, "foo")')
 
           result = @conn.exec_query(
-            "SELECT id, data FROM ex WHERE id = ?", nil, [bind_attribute("id", "1-fuu", Type::Integer.new)])
+            "SELECT id, data FROM ex WHERE id = ?", nil, [Relation::QueryAttribute.new("id", "1-fuu", Type::Integer.new)])
 
           assert_equal 1, result.rows.length
           assert_equal 2, result.columns.length
diff --git a/activerecord/test/cases/bind_parameter_test.rb b/activerecord/test/cases/bind_parameter_test.rb
index 5af44c27eb..49fe219563 100644
--- a/activerecord/test/cases/bind_parameter_test.rb
+++ b/activerecord/test/cases/bind_parameter_test.rb
@@ -39,8 +39,9 @@ if ActiveRecord::Base.connection.prepared_statements
       end
 
       def test_binds_are_logged
-        binds = [bind_attribute("id", 1)]
-        sql   = "select * from topics where id = #{bind_param.to_sql}"
+        sub   = Arel::Nodes::BindParam.new
+        binds = [Relation::QueryAttribute.new("id", 1, Type::Value.new)]
+        sql   = "select * from topics where id = #{sub.to_sql}"
 
         @connection.exec_query(sql, "SQL", binds)
 
@@ -55,7 +56,7 @@ if ActiveRecord::Base.connection.prepared_statements
       end
 
       def test_logs_binds_after_type_cast
-        binds = [bind_attribute("id", "10", Type::Integer.new)]
+        binds = [Relation::QueryAttribute.new("id", "10", Type::Integer.new)]
         assert_logs_binds(binds)
       end
 
diff --git a/activerecord/test/cases/explain_test.rb b/activerecord/test/cases/explain_test.rb
index 4f6bd9327c..86fe90ae51 100644
--- a/activerecord/test/cases/explain_test.rb
+++ b/activerecord/test/cases/explain_test.rb
@@ -47,7 +47,7 @@ if ActiveRecord::Base.connection.supports_explain?
 
     def test_exec_explain_with_binds
       sqls    = %w(foo bar)
-      binds   = [[bind_attribute("wadus", 1)], [bind_attribute("chaflan", 2)]]
+      binds   = [[bind_param("wadus", 1)], [bind_param("chaflan", 2)]]
       queries = sqls.zip(binds)
 
       stub_explain_for_query_plans(["query plan foo\n", "query plan bar\n"]) do
@@ -79,5 +79,9 @@ if ActiveRecord::Base.connection.supports_explain?
           yield
         end
       end
+
+      def bind_param(name, value)
+        ActiveRecord::Relation::QueryAttribute.new(name, value, ActiveRecord::Type::Value.new)
+      end
   end
 end
diff --git a/activerecord/test/cases/inheritance_test.rb b/activerecord/test/cases/inheritance_test.rb
index a54480fdb4..b57a778f6d 100644
--- a/activerecord/test/cases/inheritance_test.rb
+++ b/activerecord/test/cases/inheritance_test.rb
@@ -418,6 +418,7 @@ class InheritanceTest < ActiveRecord::TestCase
 
   def test_eager_load_belongs_to_primary_key_quoting
     con = Account.connection
+    bind_param = Arel::Nodes::BindParam.new
     assert_sql(/#{con.quote_table_name('companies')}\.#{con.quote_column_name('id')} = (?:#{Regexp.quote(bind_param.to_sql)}|1)/) do
       Account.all.merge!(includes: :firm).find(1)
     end
diff --git a/activerecord/test/cases/relation/where_chain_test.rb b/activerecord/test/cases/relation/where_chain_test.rb
index 86e150ed79..a96d1ae5b5 100644
--- a/activerecord/test/cases/relation/where_chain_test.rb
+++ b/activerecord/test/cases/relation/where_chain_test.rb
@@ -25,7 +25,7 @@ module ActiveRecord
     end
 
     def test_association_not_eq
-      expected = Arel::Nodes::Grouping.new(Comment.arel_table[@name].not_eq(bind_param))
+      expected = Arel::Nodes::Grouping.new(Comment.arel_table[@name].not_eq(Arel::Nodes::BindParam.new))
       relation = Post.joins(:comments).where.not(comments: { title: "hello" })
       assert_equal(expected.to_sql, relation.where_clause.ast.to_sql)
     end
diff --git a/activerecord/test/cases/relation/where_clause_test.rb b/activerecord/test/cases/relation/where_clause_test.rb
index 57d7b315b0..9da87d8df5 100644
--- a/activerecord/test/cases/relation/where_clause_test.rb
+++ b/activerecord/test/cases/relation/where_clause_test.rb
@@ -47,15 +47,15 @@ class ActiveRecord::Relation
     test "merge removes bind parameters matching overlapping equality clauses" do
       a = WhereClause.new(
         [table["id"].eq(bind_param), table["name"].eq(bind_param)],
-        [bind_attribute("id", 1), bind_attribute("name", "Sean")],
+        [attribute("id", 1), attribute("name", "Sean")],
       )
       b = WhereClause.new(
         [table["name"].eq(bind_param)],
-        [bind_attribute("name", "Jim")]
+        [attribute("name", "Jim")]
       )
       expected = WhereClause.new(
         [table["id"].eq(bind_param), table["name"].eq(bind_param)],
-        [bind_attribute("id", 1), bind_attribute("name", "Jim")],
+        [attribute("id", 1), attribute("name", "Jim")],
       )
 
       assert_equal expected, a.merge(b)
@@ -103,17 +103,17 @@ class ActiveRecord::Relation
         table["name"].eq(bind_param),
         table["age"].gteq(bind_param),
       ], [
-        bind_attribute("name", "Sean"),
-        bind_attribute("age", 30),
+        attribute("name", "Sean"),
+        attribute("age", 30),
       ])
-      expected = WhereClause.new([table["age"].gteq(bind_param)], [bind_attribute("age", 30)])
+      expected = WhereClause.new([table["age"].gteq(bind_param)], [attribute("age", 30)])
 
       assert_equal expected, where_clause.except("id", "name")
     end
 
     test "except jumps over unhandled binds (like with OR) correctly" do
       wcs = (0..9).map do |i|
-        WhereClause.new([table["id#{i}"].eq(bind_param)], [bind_attribute("id#{i}", i)])
+        WhereClause.new([table["id#{i}"].eq(bind_param)], [attribute("id#{i}", i)])
       end
 
       wc = wcs[0] + wcs[1] + wcs[2].or(wcs[3]) + wcs[4] + wcs[5] + wcs[6].or(wcs[7]) + wcs[8] + wcs[9]
@@ -162,8 +162,8 @@ class ActiveRecord::Relation
     end
 
     test "or joins the two clauses using OR" do
-      where_clause = WhereClause.new([table["id"].eq(bind_param)], [bind_attribute("id", 1)])
-      other_clause = WhereClause.new([table["name"].eq(bind_param)], [bind_attribute("name", "Sean")])
+      where_clause = WhereClause.new([table["id"].eq(bind_param)], [attribute("id", 1)])
+      other_clause = WhereClause.new([table["name"].eq(bind_param)], [attribute("name", "Sean")])
       expected_ast =
         Arel::Nodes::Grouping.new(
           Arel::Nodes::Or.new(table["id"].eq(bind_param), table["name"].eq(bind_param))
@@ -175,7 +175,7 @@ class ActiveRecord::Relation
     end
 
     test "or returns an empty where clause when either side is empty" do
-      where_clause = WhereClause.new([table["id"].eq(bind_param)], [bind_attribute("id", 1)])
+      where_clause = WhereClause.new([table["id"].eq(bind_param)], [attribute("id", 1)])
 
       assert_equal WhereClause.empty, where_clause.or(WhereClause.empty)
       assert_equal WhereClause.empty, WhereClause.empty.or(where_clause)
@@ -186,5 +186,13 @@ class ActiveRecord::Relation
       def table
         Arel::Table.new("table")
       end
+
+      def bind_param
+        Arel::Nodes::BindParam.new
+      end
+
+      def attribute(name, value)
+        ActiveRecord::Attribute.with_cast_value(name, value, ActiveRecord::Type::Value.new)
+      end
   end
 end
diff --git a/activerecord/test/cases/relations_test.rb b/activerecord/test/cases/relations_test.rb
index 316ea75e36..d294f8f628 100644
--- a/activerecord/test/cases/relations_test.rb
+++ b/activerecord/test/cases/relations_test.rb
@@ -1853,8 +1853,7 @@ class RelationTest < ActiveRecord::TestCase
   def test_unscope_removes_binds
     left = Post.where(id: 20)
 
-    binds = [bind_attribute("id", 20, Post.type_for_attribute("id"))]
-    assert_equal binds, left.bound_attributes
+    assert_equal 1, left.bound_attributes.length
 
     relation = left.unscope(where: :id)
     assert_equal [], relation.bound_attributes
@@ -1864,21 +1863,18 @@ class RelationTest < ActiveRecord::TestCase
     left = Post.where(id: 20)
     right = Post.where(id: [1, 2, 3, 4])
 
-    binds = [bind_attribute("id", 20, Post.type_for_attribute("id"))]
-    assert_equal binds, left.bound_attributes
+    assert_equal 1, left.bound_attributes.length
 
     merged = left.merge(right)
     assert_equal [], merged.bound_attributes
   end
 
   def test_merging_keeps_lhs_binds
-    binds = [bind_attribute("id", 20, Post.type_for_attribute("id"))]
-
     right  = Post.where(id: 20)
     left   = Post.where(id: 10)
 
     merged = left.merge(right)
-    assert_equal binds, merged.bound_attributes
+    assert_equal [20], merged.bound_attributes.map(&:value)
   end
 
   def test_locked_should_not_build_arel
diff --git a/activerecord/test/cases/test_case.rb b/activerecord/test/cases/test_case.rb
index 9f594fef85..31b11c19f7 100644
--- a/activerecord/test/cases/test_case.rb
+++ b/activerecord/test/cases/test_case.rb
@@ -75,14 +75,6 @@ module ActiveRecord
       model.reset_column_information
       model.column_names.include?(column_name.to_s)
     end
-
-    def bind_param
-      Arel::Nodes::BindParam.new
-    end
-
-    def bind_attribute(name, value, type = ActiveRecord::Type.default_value)
-      ActiveRecord::Relation::QueryAttribute.new(name, value, type)
-    end
   end
 
   class PostgreSQLTestCase < TestCase