activerecord 4.2.6 → 5.0.0

data/lib/active_record/associations/has_many_through_association.rb

@@ -1,5 +1,3 @@
-require 'active_support/core_ext/string/filters'
-
 module ActiveRecord
   # = Active Record Has Many Through Association
   module Associations
@@ -13,21 +11,6 @@ module ActiveRecord
         @through_association = nil
       end
 
-      # Returns the size of the collection by executing a SELECT COUNT(*) query
-      # if the collection hasn't been loaded, and by calling collection.size if
-      # it has. If the collection will likely have a size greater than zero,
-      # and if fetching the collection will be needed afterwards, one less
-      # SELECT query will be generated by using #length instead.
-      def size
-        if has_cached_counter?
-          owner._read_attribute cached_counter_attribute_name(reflection)
-        elsif loaded?
-          target.size
-        else
-          super
-        end
-      end
-
       def concat(*records)
         unless owner.new_record?
           records.flatten.each do |record|
@@ -55,25 +38,14 @@ module ActiveRecord
       def insert_record(record, validate = true, raise = false)
         ensure_not_nested
 
-        if record.new_record?
-          if raise
-            record.save!(:validate => validate)
-          else
-            return unless record.save(:validate => validate)
-          end
+        if raise
+          record.save!(:validate => validate)
+        else
+          return unless record.save(:validate => validate)
         end
 
         save_through_record(record)
-        if has_cached_counter? && !through_reflection_updates_counter_cache?
-          ActiveSupport::Deprecation.warn(<<-MSG.squish)
-            Automatic updating of counter caches on through associations has been
-            deprecated, and will be removed in Rails 5. Instead, please set the
-            appropriate `counter_cache` options on the `has_many` and `belongs_to`
-            for your associations to #{through_reflection.name}.
-          MSG
 
-          update_counter_in_database(1)
-        end
         record
       end
 
@@ -143,7 +115,7 @@ module ActiveRecord
         def update_through_counter?(method)
           case method
           when :destroy
-            !inverse_updates_counter_cache?(through_reflection)
+            !through_reflection.inverse_updates_counter_cache?
           when :nullify
             false
           else
@@ -166,17 +138,15 @@ module ActiveRecord
             if scope.klass.primary_key
               count = scope.destroy_all.length
             else
-              scope.each do |record|
-                record._run_destroy_callbacks
-              end
+              scope.each(&:_run_destroy_callbacks)
 
               arel = scope.arel
 
-              stmt = Arel::DeleteManager.new arel.engine
+              stmt = Arel::DeleteManager.new
               stmt.from scope.klass.arel_table
               stmt.wheres = arel.constraints
 
-              count = scope.klass.connection.delete(stmt, 'SQL', scope.bind_values)
+              count = scope.klass.connection.delete(stmt, 'SQL', scope.bound_attributes)
             end
           when :nullify
             count = scope.update_all(source_reflection.foreign_key => nil)
@@ -233,15 +203,6 @@ module ActiveRecord
         def invertible_for?(record)
           false
         end
-
-        def has_cached_counter?(reflection = reflection())
-          owner.attribute_present?(cached_counter_attribute_name(reflection))
-        end
-
-        def through_reflection_updates_counter_cache?
-          counter_name = cached_counter_attribute_name
-          inverse_updates_counter_named?(counter_name, through_reflection)
-        end
     end
   end
 end

data/lib/active_record/associations/has_one_association.rb

@@ -1,5 +1,5 @@
 module ActiveRecord
-  # = Active Record Belongs To Has One Association
+  # = Active Record Has One Association
   module Associations
     class HasOneAssociation < SingularAssociation #:nodoc:
       include ForeignAssociation
@@ -11,9 +11,16 @@ module ActiveRecord
 
         when :restrict_with_error
           if load_target
-            record = klass.human_attribute_name(reflection.name).downcase
-            owner.errors.add(:base, :"restrict_dependent_destroy.one", record: record)
-            false
+            record = owner.class.human_attribute_name(reflection.name).downcase
+            message = owner.errors.generate_message(:base, :'restrict_dependent_destroy.one', record: record, raise: true) rescue nil
+            if message
+              ActiveSupport::Deprecation.warn(<<-MESSAGE.squish)
+                The error key `:'restrict_dependent_destroy.one'` has been deprecated and will be removed in Rails 5.1.
+                Please use `:'restrict_dependent_destroy.has_one'` instead.
+              MESSAGE
+            end
+            owner.errors.add(:base, message || :'restrict_dependent_destroy.has_one', record: record)
+            throw(:abort)
           end
 
         else
@@ -58,7 +65,7 @@ module ActiveRecord
             when :destroy
               target.destroy
             when :nullify
-              target.update_columns(reflection.foreign_key => nil)
+              target.update_columns(reflection.foreign_key => nil) if target.persisted?
           end
         end
       end

data/lib/active_record/associations/join_dependency/join_association.rb

@@ -25,7 +25,7 @@ module ActiveRecord
 
         def join_constraints(foreign_table, foreign_klass, node, join_type, tables, scope_chain, chain)
           joins         = []
-          bind_values   = []
+          binds         = []
           tables        = tables.reverse
 
           scope_chain_index = 0
@@ -43,23 +43,36 @@ module ActiveRecord
 
             constraint = build_constraint(klass, table, key, foreign_table, foreign_key)
 
+            predicate_builder = PredicateBuilder.new(TableMetadata.new(klass, table))
             scope_chain_items = scope_chain[scope_chain_index].map do |item|
               if item.is_a?(Relation)
                 item
               else
-                ActiveRecord::Relation.create(klass, table).instance_exec(node, &item)
+                ActiveRecord::Relation.create(klass, table, predicate_builder)
+                  .instance_exec(node, &item)
               end
             end
             scope_chain_index += 1
 
-            scope_chain_items.concat [klass.send(:build_default_scope, ActiveRecord::Relation.create(klass, table))].compact
+            klass_scope =
+              if klass.current_scope
+                klass.current_scope.clone
+              else
+                relation = ActiveRecord::Relation.create(
+                  klass,
+                  table,
+                  predicate_builder,
+                )
+                klass.send(:build_default_scope, relation)
+              end
+            scope_chain_items.concat [klass_scope].compact
 
             rel = scope_chain_items.inject(scope_chain_items.shift) do |left, right|
               left.merge right
             end
 
             if rel && !rel.arel.constraints.empty?
-              bind_values.concat rel.bind_values
+              binds += rel.bound_attributes
               constraint = constraint.and rel.arel.constraints
             end
 
@@ -67,9 +80,8 @@ module ActiveRecord
               value = foreign_klass.base_class.name
               column = klass.columns_hash[reflection.type.to_s]
 
-              substitute = klass.connection.substitute_at(column)
-              bind_values.push [column, value]
-              constraint = constraint.and table[reflection.type].eq substitute
+              binds << Relation::QueryAttribute.new(column.name, value, klass.type_for_attribute(column.name))
+              constraint = constraint.and klass.arel_attribute(reflection.type, table).eq(Arel::Nodes::BindParam.new)
             end
 
             joins << table.create_join(table, table.create_on(constraint), join_type)
@@ -78,7 +90,7 @@ module ActiveRecord
             foreign_table, foreign_klass = table, klass
           end
 
-          JoinInformation.new joins, bind_values
+          JoinInformation.new joins, binds
         end
 
         #  Builds equality condition.

data/lib/active_record/associations/join_dependency.rb

@@ -20,7 +20,7 @@ module ActiveRecord
         end
 
         def columns
-          @tables.flat_map { |t| t.column_aliases }
+          @tables.flat_map(&:column_aliases)
         end
 
         # An array of [column_name, alias] pairs for the table
@@ -32,7 +32,7 @@ module ActiveRecord
           @alias_cache[node][column]
         end
 
-        class Table < Struct.new(:node, :columns)
+        class Table < Struct.new(:node, :columns) # :nodoc:
           def table
             Arel::Nodes::TableAlias.new node.table, node.aliased_table_name
           end
@@ -93,8 +93,7 @@ module ActiveRecord
       #    joins # =>  []
       #
       def initialize(base, associations, joins)
-        @alias_tracker = AliasTracker.create(base.connection, joins)
-        @alias_tracker.aliased_table_for(base.table_name, base.table_name) # Updates the count for base.table_name to 1
+        @alias_tracker = AliasTracker.create_with_joins(base.connection, base.table_name, joins, base.type_caster)
         tree = self.class.make_tree associations
         @join_root = JoinBase.new base, build(tree, base)
         @join_root.children.each { |child| construct_tables! @join_root, child }
@@ -104,9 +103,14 @@ module ActiveRecord
         join_root.drop(1).map!(&:reflection)
       end
 
-      def join_constraints(outer_joins)
+      def join_constraints(outer_joins, join_type)
         joins = join_root.children.flat_map { |child|
-          make_inner_joins join_root, child
+
+          if join_type == Arel::Nodes::OuterJoin
+            make_left_outer_joins join_root, child
+          else
+            make_inner_joins join_root, child
+          end
         }
 
         joins.concat outer_joins.flat_map { |oj|
@@ -132,9 +136,9 @@ module ActiveRecord
       def instantiate(result_set, aliases)
         primary_key = aliases.column_alias(join_root, join_root.primary_key)
 
-        seen = Hash.new { |h,parent_klass|
-          h[parent_klass] = Hash.new { |i,parent_id|
-            i[parent_id] = Hash.new { |j,child_klass| j[child_klass] = {} }
+        seen = Hash.new { |i, object_id|
+          i[object_id] = Hash.new { |j, child_class|
+            j[child_class] = {}
           }
         }
 
@@ -177,6 +181,14 @@ module ActiveRecord
         [info] + child.children.flat_map { |c| make_outer_joins(child, c) }
       end
 
+      def make_left_outer_joins(parent, child)
+        tables    = child.tables
+        join_type = Arel::Nodes::OuterJoin
+        info      = make_constraints parent, child, tables, join_type
+
+        [info] + child.children.flat_map { |c| make_left_outer_joins(child, c) }
+      end
+
       def make_inner_joins(parent, child)
         tables    = child.tables
         join_type = Arel::Nodes::InnerJoin
@@ -216,7 +228,7 @@ module ActiveRecord
 
       def find_reflection(klass, name)
         klass._reflect_on_association(name) or
-          raise ConfigurationError, "Association named '#{ name }' was not found on #{ klass.name }; perhaps you misspelled it?"
+          raise ConfigurationError, "Can't join '#{ klass.name }' to association named '#{ name }'; perhaps you misspelled it?"
       end
 
       def build(associations, base_klass)
@@ -235,18 +247,15 @@ module ActiveRecord
 
       def construct(ar_parent, parent, row, rs, seen, model_cache, aliases)
         return if ar_parent.nil?
-        primary_id  = ar_parent.id
 
         parent.children.each do |node|
           if node.reflection.collection?
             other = ar_parent.association(node.reflection.name)
             other.loaded!
-          else
-            if ar_parent.association_cache.key?(node.reflection.name)
-              model = ar_parent.association(node.reflection.name).target
-              construct(model, node, row, rs, seen, model_cache, aliases)
-              next
-            end
+          elsif ar_parent.association_cached?(node.reflection.name)
+            model = ar_parent.association(node.reflection.name).target
+            construct(model, node, row, rs, seen, model_cache, aliases)
+            next
           end
 
           key = aliases.column_alias(node, node.primary_key)
@@ -257,13 +266,14 @@ module ActiveRecord
             next
           end
 
-          model = seen[parent.base_klass][primary_id][node.base_klass][id]
+          model = seen[ar_parent.object_id][node.base_klass][id]
 
           if model
             construct(model, node, row, rs, seen, model_cache, aliases)
           else
             model = construct_model(ar_parent, node, row, model_cache, id, aliases)
-            seen[parent.base_klass][primary_id][node.base_klass][id] = model
+            model.readonly!
+            seen[ar_parent.object_id][node.base_klass][id] = model
             construct(model, node, row, rs, seen, model_cache, aliases)
           end
         end

data/lib/active_record/associations/preloader/association.rb

@@ -12,7 +12,6 @@ module ActiveRecord
           @preload_scope = preload_scope
           @model         = owners.first && owners.first.class
           @scope         = nil
-          @owners_by_key = nil
           @preloaded_records = []
         end
 
@@ -33,7 +32,7 @@ module ActiveRecord
         end
 
         def query_scope(ids)
-          scope.where(association_key.in(ids))
+          scope.where(association_key_name => ids)
         end
 
         def table
@@ -48,7 +47,7 @@ module ActiveRecord
         # This is overridden by HABTM as the condition should be on the foreign_key column in
         # the join table
         def association_key
-          table[association_key_name]
+          klass.arel_attribute(association_key_name, table)
         end
 
         # The name of the key on the model which declares the association
@@ -56,18 +55,6 @@ module ActiveRecord
           raise NotImplementedError
         end
 
-        def owners_by_key
-          @owners_by_key ||= if key_conversion_required?
-                               owners.group_by do |owner|
-                                 owner[owner_key_name].to_s
-                               end
-                             else
-                               owners.group_by do |owner|
-                                 owner[owner_key_name]
-                               end
-                             end
-        end
-
         def options
           reflection.options
         end
@@ -75,32 +62,33 @@ module ActiveRecord
         private
 
         def associated_records_by_owner(preloader)
-          owners_map = owners_by_key
-          owner_keys = owners_map.keys.compact
-
-          # Each record may have multiple owners, and vice-versa
-          records_by_owner = owners.each_with_object({}) do |owner,h|
-            h[owner] = []
+          records = load_records
+          owners.each_with_object({}) do |owner, result|
+            result[owner] = records[convert_key(owner[owner_key_name])] || []
           end
+        end
 
-          if owner_keys.any?
-            # Some databases impose a limit on the number of ids in a list (in Oracle it's 1000)
-            # Make several smaller queries if necessary or make one query if the adapter supports it
-            sliced  = owner_keys.each_slice(klass.connection.in_clause_length || owner_keys.size)
-
-            records = load_slices sliced
-            records.each do |record, owner_key|
-              owners_map[owner_key].each do |owner|
-                records_by_owner[owner] << record
-              end
+        def owner_keys
+          unless defined?(@owner_keys)
+            @owner_keys = owners.map do |owner|
+              owner[owner_key_name]
             end
+            @owner_keys.uniq!
+            @owner_keys.compact!
           end
-
-          records_by_owner
+          @owner_keys
         end
 
         def key_conversion_required?
-          association_key_type != owner_key_type
+          @key_conversion_required ||= association_key_type != owner_key_type
+        end
+
+        def convert_key(key)
+          if key_conversion_required?
+            key.to_s
+          else
+            key
+          end
         end
 
         def association_key_type
@@ -111,17 +99,17 @@ module ActiveRecord
           @model.type_for_attribute(owner_key_name.to_s).type
         end
 
-        def load_slices(slices)
-          @preloaded_records = slices.flat_map { |slice|
+        def load_records
+          return {} if owner_keys.empty?
+          # Some databases impose a limit on the number of ids in a list (in Oracle it's 1000)
+          # Make several smaller queries if necessary or make one query if the adapter supports it
+          slices  = owner_keys.each_slice(klass.connection.in_clause_length || owner_keys.size)
+          @preloaded_records = slices.flat_map do |slice|
             records_for(slice)
-          }
-
-          @preloaded_records.map { |record|
-            key = record[association_key_name]
-            key = key.to_s if key_conversion_required?
-
-            [record, key]
-          }
+          end
+          @preloaded_records.group_by do |record| 
+            convert_key(record[association_key_name])
+          end
         end
 
         def reflection_scope
@@ -131,19 +119,25 @@ module ActiveRecord
         def build_scope
           scope = klass.unscoped
 
-          values         = reflection_scope.values
-          reflection_binds = reflection_scope.bind_values
+          values = reflection_scope.values
           preload_values = preload_scope.values
-          preload_binds  = preload_scope.bind_values
 
-          scope.where_values      = Array(values[:where])      + Array(preload_values[:where])
+          scope.where_clause = reflection_scope.where_clause + preload_scope.where_clause
           scope.references_values = Array(values[:references]) + Array(preload_values[:references])
-          scope.bind_values       = (reflection_binds + preload_binds)
 
-          scope._select!   preload_values[:select] || values[:select] || table[Arel.star]
+          if preload_values[:select] || values[:select]
+            scope._select!(preload_values[:select] || values[:select])
+          end
           scope.includes! preload_values[:includes] || values[:includes]
-          scope.joins! preload_values[:joins] || values[:joins]
-          scope.order! preload_values[:order] || values[:order]
+          if preload_scope.joins_values.any?
+            scope.joins!(preload_scope.joins_values)
+          else
+            scope.joins!(reflection_scope.joins_values)
+          end
+
+          if order_values = preload_values[:order] || values[:order]
+            scope.order!(order_values)
+          end
 
           if preload_values[:reordering] || values[:reordering]
             scope.reordering_value = true

data/lib/active_record/associations/preloader/collection_association.rb

@@ -2,13 +2,8 @@ module ActiveRecord
   module Associations
     class Preloader
       class CollectionAssociation < Association #:nodoc:
-
         private
 
-        def build_scope
-          super.order(preload_scope.values[:order] || reflection_scope.values[:order])
-        end
-
         def preload(preloader)
           associated_records_by_owner(preloader).each do |owner, records|
             association = owner.association(reflection.name)
@@ -17,7 +12,6 @@ module ActiveRecord
             records.each { |record| association.set_inverse_instance(record) }
           end
         end
-
       end
     end
   end

data/lib/active_record/associations/preloader/has_many_through.rb

@@ -8,7 +8,7 @@ module ActiveRecord
           records_by_owner = super
 
           if reflection_scope.distinct_value
-            records_by_owner.each_value { |records| records.uniq! }
+            records_by_owner.each_value(&:uniq!)
           end
 
           records_by_owner

data/lib/active_record/associations/preloader/has_one.rb

@@ -2,7 +2,6 @@ module ActiveRecord
   module Associations
     class Preloader
       class HasOne < SingularAssociation #:nodoc:
-
         def association_key_name
           reflection.foreign_key
         end
@@ -10,13 +9,6 @@ module ActiveRecord
         def owner_key_name
           reflection.active_record_primary_key
         end
-
-        private
-
-        def build_scope
-          super.order(preload_scope.values[:order] || reflection_scope.values[:order])
-        end
-
       end
     end
   end

data/lib/active_record/associations/preloader/through_association.rb

@@ -18,7 +18,8 @@ module ActiveRecord
           through_records = owners.map do |owner|
             association = owner.association through_reflection.name
 
-            [owner, Array(association.reader)]
+            center = target_records_from_association(association)
+            [owner, Array(center)]
           end
 
           reset_association owners, through_reflection.name
@@ -37,28 +38,35 @@ module ActiveRecord
             }
           end
 
-          record_offset = {}
-          @preloaded_records.each_with_index do |record,i|
-            record_offset[record] = i
-          end
-
-          through_records.each_with_object({}) { |(lhs,center),records_by_owner|
+          through_records.each_with_object({}) do |(lhs,center), records_by_owner|
             pl_to_middle = center.group_by { |record| middle_to_pl[record] }
 
             records_by_owner[lhs] = pl_to_middle.flat_map do |pl, middles|
               rhs_records = middles.flat_map { |r|
                 association = r.association source_reflection.name
 
-                association.reader
+                target_records_from_association(association)
               }.compact
 
-              rhs_records.sort_by { |rhs| record_offset[rhs] }
+              # Respect the order on `reflection_scope` if it exists, else use the natural order.
+              if reflection_scope.values[:order].present?
+                @id_map ||= id_to_index_map @preloaded_records
+                rhs_records.sort_by { |rhs| @id_map[rhs] }
+              else
+                rhs_records
+              end
             end
-          }
+          end
         end
 
         private
 
+        def id_to_index_map(ids)
+          id_map = {}
+          ids.each_with_index { |id, index| id_map[id] = index }
+          id_map
+        end
+
         def reset_association(owners, association_name)
           should_reset = (through_scope != through_reflection.klass.unscoped) ||
              (reflection.options[:source_type] && through_reflection.collection?)
@@ -78,18 +86,23 @@ module ActiveRecord
           if options[:source_type]
             scope.where! reflection.foreign_type => options[:source_type]
           else
-            unless reflection_scope.where_values.empty?
+            unless reflection_scope.where_clause.empty?
               scope.includes_values = Array(reflection_scope.values[:includes] || options[:source])
-              scope.where_values    = reflection_scope.values[:where]
-              scope.bind_values     = reflection_scope.bind_values
+              scope.where_clause = reflection_scope.where_clause
             end
 
             scope.references! reflection_scope.values[:references]
-            scope = scope.order reflection_scope.values[:order] if scope.eager_loading?
+            if scope.eager_loading? && order_values = reflection_scope.values[:order]
+              scope = scope.order(order_values)
+            end
           end
 
           scope
         end
+
+        def target_records_from_association(association)
+          association.loaded? ? association.target : association.reader
+        end
       end
     end
   end