Refactor Active Record to let Arel manage bind params

A common source of bugs and code bloat within Active Record has been the
need for us to maintain the list of bind values separately from the AST
they're associated with. This makes any sort of AST manipulation
incredibly difficult, as any time we want to potentially insert or
remove an AST node, we need to traverse the entire tree to find where
the associated bind parameters are.

With this change, the bind parameters now live on the AST directly.
Active Record does not need to know or care about them until the final
AST traversal for SQL construction. Rather than returning just the SQL,
the Arel collector will now return both the SQL and the bind parameters.
At this point the connection adapter will have all the values that it
had before.

A bit of this code is janky and something I'd like to refactor later. In
particular, I don't like how we're handling associations in the
predicate builder, the special casing of `StatementCache::Substitute` in
`QueryAttribute`, or generally how we're handling bind value replacement
in the statement cache when prepared statements are disabled.

This also mostly reverts #26378, as it moved all the code into a
location that I wanted to delete.

/cc @metaskills @yahonda, this change will affect the adapters

Fixes #29766.
Fixes #29804.
Fixes #26541.
Close #28539.
Close #24769.
Close #26468.
Close #26202.

There are probably other issues/PRs that can be closed because of this
commit, but that's all I could find on the first few pages.

1 files changed, 13 insertions, 71 deletions

diff --git a/activerecord/lib/active_record/relation/predicate_builder.rb b/activerecord/lib/active_record/relation/predicate_builder.rb
index 3b8f8da634..ee7fef4711 100644
--- a/activerecord/lib/active_record/relation/predicate_builder.rb
+++ b/activerecord/lib/active_record/relation/predicate_builder.rb
@@ -8,10 +8,9 @@ module ActiveRecord
       @table = table
       @handlers = []
 
-      register_handler(BasicObject, BasicObjectHandler.new)
+      register_handler(BasicObject, BasicObjectHandler.new(self))
       register_handler(Base, BaseHandler.new(self))
-      register_handler(Range, RangeHandler.new)
-      register_handler(RangeHandler::RangeWithBinds, RangeHandler.new)
+      register_handler(Range, RangeHandler.new(self))
       register_handler(Relation, RelationHandler.new)
       register_handler(Array, ArrayHandler.new(self))
     end
@@ -21,11 +20,6 @@ module ActiveRecord
       expand_from_hash(attributes)
     end
 
-    def create_binds(attributes)
-      attributes = convert_dot_notation_to_hash(attributes)
-      create_binds_for_hash(attributes)
-    end
-
     def self.references(attributes)
       attributes.map do |key, value|
         if value.is_a?(Hash)
@@ -56,8 +50,11 @@ module ActiveRecord
       handler_for(value).call(attribute, value)
     end
 
-    # TODO Change this to private once we've dropped Ruby 2.2 support.
-    # Workaround for Ruby 2.2 "private attribute?" warning.
+    def build_bind_attribute(column_name, value)
+      attr = Relation::QueryAttribute.new(column_name.to_s, value, table.type(column_name))
+      Arel::Nodes::BindParam.new(attr)
+    end
+
     protected
 
       attr_reader :table
@@ -68,29 +65,13 @@ module ActiveRecord
         attributes.flat_map do |key, value|
           if value.is_a?(Hash) && !table.has_column?(key)
             associated_predicate_builder(key).expand_from_hash(value)
-          else
-            build(table.arel_attribute(key), value)
-          end
-        end
-      end
-
-      def create_binds_for_hash(attributes)
-        result = attributes.dup
-        binds = []
-
-        attributes.each do |column_name, value|
-          case
-          when value.is_a?(Hash) && !table.has_column?(column_name)
-            attrs, bvs = associated_predicate_builder(column_name).create_binds_for_hash(value)
-            result[column_name] = attrs
-            binds += bvs
-          when table.associated_with?(column_name)
+          elsif table.associated_with?(key)
             # Find the foreign key when using queries such as:
             # Post.where(author: author)
             #
             # For polymorphic relationships, find the foreign key and type:
             # PriceEstimate.where(estimate_of: treasure)
-            associated_table = table.associated_table(column_name)
+            associated_table = table.associated_table(key)
             if associated_table.polymorphic_association?
               case value.is_a?(Array) ? value.first : value
               when Base, Relation
@@ -100,40 +81,14 @@ module ActiveRecord
             end
 
             klass ||= AssociationQueryValue
-            result[column_name] = klass.new(associated_table, value).queries.map do |query|
-              attrs, bvs = create_binds_for_hash(query)
-              binds.concat(bvs)
-              attrs
-            end
-          when value.is_a?(Range) && !table.type(column_name).respond_to?(:subtype)
-            first = value.begin
-            last = value.end
-            unless first.respond_to?(:infinite?) && first.infinite?
-              binds << build_bind_attribute(column_name, first)
-              first = Arel::Nodes::BindParam.new
+            queries = klass.new(associated_table, value).queries.map do |query|
+              expand_from_hash(query).reduce(&:and)
             end
-            unless last.respond_to?(:infinite?) && last.infinite?
-              binds << build_bind_attribute(column_name, last)
-              last = Arel::Nodes::BindParam.new
-            end
-
-            result[column_name] = RangeHandler::RangeWithBinds.new(first, last, value.exclude_end?)
-          when value.is_a?(Relation)
-            binds.concat(value.bound_attributes)
+            queries.reduce(&:or)
           else
-            if can_be_bound?(column_name, value)
-              bind_attribute = build_bind_attribute(column_name, value)
-              if value.is_a?(StatementCache::Substitute) || !bind_attribute.value_for_database.nil?
-                result[column_name] = Arel::Nodes::BindParam.new
-                binds << bind_attribute
-              else
-                result[column_name] = nil
-              end
-            end
+            build(table.arel_attribute(key), value)
           end
         end
-
-        [result, binds]
       end
 
     private
@@ -161,19 +116,6 @@ module ActiveRecord
       def handler_for(object)
         @handlers.detect { |klass, _| klass === object }.last
       end
-
-      def can_be_bound?(column_name, value)
-        case value
-        when Array, Range
-          table.type(column_name).respond_to?(:subtype)
-        else
-          !value.nil? && handler_for(value).is_a?(BasicObjectHandler)
-        end
-      end
-
-      def build_bind_attribute(column_name, value)
-        Relation::QueryAttribute.new(column_name.to_s, value, table.type(column_name))
-      end
   end
 end