activerecord 5.1.5 → 5.2.8.1

data/lib/active_record/associations/has_many_through_association.rb

@@ -1,14 +1,14 @@
+# frozen_string_literal: true
+
 module ActiveRecord
-  # = Active Record Has Many Through Association
   module Associations
+    # = Active Record Has Many Through Association
     class HasManyThroughAssociation < HasManyAssociation #:nodoc:
       include ThroughAssociation
 
       def initialize(owner, reflection)
         super
-
-        @through_records     = {}
-        @through_association = nil
+        @through_records = {}
       end
 
       def concat(*records)
@@ -48,11 +48,6 @@ module ActiveRecord
       end
 
       private
-
-        def through_association
-          @through_association ||= owner.association(through_reflection.name)
-        end
-
         # The through record (built with build_record) is temporarily cached
         # so that it may be reused if insert_record is subsequently called.
         #
@@ -62,21 +57,14 @@ module ActiveRecord
           @through_records[record.object_id] ||= begin
             ensure_mutable
 
-            through_record = through_association.build(*options_for_through_record)
-            through_record.send("#{source_reflection.name}=", record)
-
-            if options[:source_type]
-              through_record.send("#{source_reflection.foreign_type}=", options[:source_type])
-            end
+            attributes = through_scope_attributes
+            attributes[source_reflection.name] = record
+            attributes[source_reflection.foreign_type] = options[:source_type] if options[:source_type]
 
-            through_record
+            through_association.build(attributes)
           end
         end
 
-        def options_for_through_record
-          [through_scope_attributes]
-        end
-
         def through_scope_attributes
           scope.where_values_hash(through_association.reflection.name.to_s).
             except!(through_association.reflection.foreign_key,
@@ -95,7 +83,7 @@ module ActiveRecord
         def build_record(attributes)
           ensure_not_nested
 
-          record = super(attributes)
+          record = super
 
           inverse = source_reflection.inverse_of
           if inverse
@@ -138,21 +126,15 @@ module ActiveRecord
 
           scope = through_association.scope
           scope.where! construct_join_attributes(*records)
+          scope = scope.where(through_scope_attributes)
 
           case method
           when :destroy
             if scope.klass.primary_key
-              count = scope.destroy_all.length
+              count = scope.destroy_all.count(&:destroyed?)
             else
               scope.each(&:_run_destroy_callbacks)
-
-              arel = scope.arel
-
-              stmt = Arel::DeleteManager.new
-              stmt.from scope.klass.arel_table
-              stmt.wheres = arel.constraints
-
-              count = scope.klass.connection.delete(stmt, "SQL", scope.bound_attributes)
+              count = scope.delete_all
             end
           when :nullify
             count = scope.update_all(source_reflection.foreign_key => nil)
@@ -172,6 +154,30 @@ module ActiveRecord
           else
             update_counter(-count)
           end
+
+          count
+        end
+
+        def difference(a, b)
+          distribution = distribution(b)
+
+          a.reject { |record| mark_occurrence(distribution, record) }
+        end
+
+        def intersection(a, b)
+          distribution = distribution(b)
+
+          a.select { |record| mark_occurrence(distribution, record) }
+        end
+
+        def mark_occurrence(distribution, record)
+          distribution[record] > 0 && distribution[record] -= 1
+        end
+
+        def distribution(array)
+          array.each_with_object(Hash.new(0)) do |record, distribution|
+            distribution[record] += 1
+          end
         end
 
         def through_records_for(record)

data/lib/active_record/associations/has_one_association.rb

@@ -1,6 +1,8 @@
+# frozen_string_literal: true
+
 module ActiveRecord
-  # = Active Record Has One Association
   module Associations
+    # = Active Record Has One Association
     class HasOneAssociation < SingularAssociation #:nodoc:
       include ForeignAssociation
 
@@ -58,6 +60,7 @@ module ActiveRecord
           when :destroy
             target.destroyed_by_association = reflection
             target.destroy
+            throw(:abort) unless target.destroyed?
           when :nullify
             target.update_columns(reflection.foreign_key => nil) if target.persisted?
           end
@@ -104,6 +107,14 @@ module ActiveRecord
             yield
           end
         end
+
+        def _create_record(attributes, raise_error = false, &block)
+          unless owner.persisted?
+            raise ActiveRecord::RecordNotSaved, "You cannot call create unless the parent is saved"
+          end
+
+          super
+        end
     end
   end
 end

data/lib/active_record/associations/has_one_through_association.rb

@@ -1,20 +1,21 @@
+# frozen_string_literal: true
+
 module ActiveRecord
-  # = Active Record Has One Through Association
   module Associations
+    # = Active Record Has One Through Association
     class HasOneThroughAssociation < HasOneAssociation #:nodoc:
       include ThroughAssociation
 
-      def replace(record)
-        create_through_record(record)
+      def replace(record, save = true)
+        create_through_record(record, save)
         self.target = record
       end
 
       private
-
-        def create_through_record(record)
+        def create_through_record(record, save)
           ensure_not_nested
 
-          through_proxy  = owner.association(through_reflection.name)
+          through_proxy  = through_association
           through_record = through_proxy.load_target
 
           if through_record && !record
@@ -27,8 +28,12 @@ module ActiveRecord
             end
 
             if through_record
-              through_record.update(attributes)
-            elsif owner.new_record?
+              if through_record.new_record?
+                through_record.assign_attributes(attributes)
+              else
+                through_record.update(attributes)
+              end
+            elsif owner.new_record? || !save
               through_proxy.build(attributes)
             else
               through_proxy.create(attributes)

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

@@ -1,19 +1,19 @@
+# frozen_string_literal: true
+
 require "active_record/associations/join_dependency/join_part"
 
 module ActiveRecord
   module Associations
     class JoinDependency # :nodoc:
       class JoinAssociation < JoinPart # :nodoc:
-        # The reflection of the association represented
-        attr_reader :reflection
-
-        attr_accessor :tables
+        attr_reader :reflection, :tables
+        attr_accessor :table
 
         def initialize(reflection, children)
           super(reflection.klass, children)
 
-          @reflection      = reflection
-          @tables          = nil
+          @reflection = reflection
+          @tables     = nil
         end
 
         def match?(other)
@@ -21,84 +21,60 @@ module ActiveRecord
           super && reflection == other.reflection
         end
 
-        JoinInformation = Struct.new :joins, :binds
-
-        def join_constraints(foreign_table, foreign_klass, join_type, tables, chain)
-          joins         = []
-          binds         = []
-          tables        = tables.reverse
+        def join_constraints(foreign_table, foreign_klass, join_type, alias_tracker)
+          joins = []
 
           # The chain starts with the target table, but we want to end with it here (makes
           # more sense in this context), so we reverse
-          chain.reverse_each do |reflection|
-            table = tables.shift
+          reflection.chain.reverse_each.with_index(1) do |reflection, i|
+            table = tables[-i]
             klass = reflection.klass
 
-            join_keys   = reflection.join_keys
-            key         = join_keys.key
-            foreign_key = join_keys.foreign_key
-
-            constraint = build_constraint(klass, table, key, foreign_table, foreign_key)
+            join_scope = reflection.join_scope(table, foreign_table, foreign_klass)
 
-            rel = reflection.join_scope(table)
+            arel = join_scope.arel(alias_tracker.aliases)
+            nodes = arel.constraints.first
 
-            if rel && !rel.arel.constraints.empty?
-              binds += rel.bound_attributes
-              constraint = constraint.and rel.arel.constraints
+            others, children = nodes.children.partition do |node|
+              !fetch_arel_attribute(node) { |attr| attr.relation.name == table.name }
             end
+            nodes = table.create_and(children)
 
-            if reflection.type
-              value = foreign_klass.base_class.name
-              column = klass.columns_hash[reflection.type.to_s]
+            joins << table.create_join(table, table.create_on(nodes), join_type)
 
-              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)
+            unless others.empty?
+              joins.concat arel.join_sources
+              append_constraints(joins.last, others)
             end
 
-            joins << table.create_join(table, table.create_on(constraint), join_type)
-
             # The current table in this iteration becomes the foreign table in the next
             foreign_table, foreign_klass = table, klass
           end
 
-          JoinInformation.new joins, binds
+          joins
         end
 
-        #  Builds equality condition.
-        #
-        #  Example:
-        #
-        #  class Physician < ActiveRecord::Base
-        #    has_many :appointments
-        #  end
-        #
-        #  If I execute `Physician.joins(:appointments).to_a` then
-        #    klass         # => Physician
-        #    table         # => #<Arel::Table @name="appointments" ...>
-        #    key           # =>  physician_id
-        #    foreign_table # => #<Arel::Table @name="physicians" ...>
-        #    foreign_key   # => id
-        #
-        def build_constraint(klass, table, key, foreign_table, foreign_key)
-          constraint = table[key].eq(foreign_table[foreign_key])
-
-          if klass.finder_needs_type_condition?
-            constraint = table.create_and([
-              constraint,
-              klass.send(:type_condition, table)
-            ])
-          end
-
-          constraint
+        def tables=(tables)
+          @tables = tables
+          @table  = tables.first
         end
 
-        def table
-          tables.first
-        end
+        private
+          def fetch_arel_attribute(value)
+            case value
+            when Arel::Nodes::Between, Arel::Nodes::In, Arel::Nodes::NotIn, Arel::Nodes::Equality, Arel::Nodes::NotEqual, Arel::Nodes::LessThan, Arel::Nodes::LessThanOrEqual, Arel::Nodes::GreaterThan, Arel::Nodes::GreaterThanOrEqual
+              yield value.left.is_a?(Arel::Attributes::Attribute) ? value.left : value.right
+            end
+          end
 
-        def aliased_table_name
-          table.table_alias || table.name
-        end
+          def append_constraints(join, constraints)
+            if join.is_a?(Arel::Nodes::StringJoin)
+              join_string = table.create_and(constraints.unshift(join.left))
+              join.left = Arel.sql(base_klass.connection.visitor.compile(join_string))
+            else
+              join.right.expr.children.concat(constraints)
+            end
+          end
       end
     end
   end

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

@@ -1,20 +1,21 @@
+# frozen_string_literal: true
+
 require "active_record/associations/join_dependency/join_part"
 
 module ActiveRecord
   module Associations
     class JoinDependency # :nodoc:
       class JoinBase < JoinPart # :nodoc:
-        def match?(other)
-          return true if self == other
-          super && base_klass == other.base_klass
-        end
+        attr_reader :table
 
-        def table
-          base_klass.arel_table
+        def initialize(base_klass, table, children)
+          super(base_klass, children)
+          @table = table
         end
 
-        def aliased_table_name
-          base_klass.table_name
+        def match?(other)
+          return true if self == other
+          super && base_klass == other.base_klass
         end
       end
     end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module Associations
     class JoinDependency # :nodoc:
@@ -22,10 +24,6 @@ module ActiveRecord
           @children = children
         end
 
-        def name
-          reflection.name
-        end
-
         def match?(other)
           self.class == other.class
         end
@@ -35,13 +33,15 @@ module ActiveRecord
           children.each { |child| child.each(&block) }
         end
 
-        # An Arel::Table for the active_record
-        def table
-          raise NotImplementedError
+        def each_children(&block)
+          children.each do |child|
+            yield self, child
+            child.each_children(&block)
+          end
         end
 
-        # The alias for the active_record's table
-        def aliased_table_name
+        # An Arel::Table for the active_record
+        def table
           raise NotImplementedError
         end
 

data/lib/active_record/associations/join_dependency.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module Associations
     class JoinDependency # :nodoc:
@@ -33,20 +35,14 @@ module ActiveRecord
         end
 
         Table = Struct.new(:node, :columns) do # :nodoc:
-          def table
-            Arel::Nodes::TableAlias.new node.table, node.aliased_table_name
-          end
-
           def column_aliases
-            t = table
+            t = node.table
             columns.map { |column| t[column.name].as Arel.sql column.alias }
           end
         end
         Column = Struct.new(:name, :alias)
       end
 
-      attr_reader :alias_tracker, :base_klass, :join_root
-
       def self.make_tree(associations)
         hash = {}
         walk_tree associations, hash
@@ -71,69 +67,31 @@ module ActiveRecord
         end
       end
 
-      # base is the base class on which operation is taking place.
-      # associations is the list of associations which are joined using hash, symbol or array.
-      # joins is the list of all string join commands and arel nodes.
-      #
-      #  Example :
-      #
-      #  class Physician < ActiveRecord::Base
-      #    has_many :appointments
-      #    has_many :patients, through: :appointments
-      #  end
-      #
-      #  If I execute `@physician.patients.to_a` then
-      #    base # => Physician
-      #    associations # => []
-      #    joins # =>  [#<Arel::Nodes::InnerJoin: ...]
-      #
-      #  However if I execute `Physician.joins(:appointments).to_a` then
-      #    base # => Physician
-      #    associations # => [:appointments]
-      #    joins # =>  []
-      #
-      def initialize(base, associations, joins, eager_loading: true)
-        @alias_tracker = AliasTracker.create_with_joins(base.connection, base.table_name, joins)
-        @eager_loading = eager_loading
+      def initialize(base, table, associations)
         tree = self.class.make_tree associations
-        @join_root = JoinBase.new base, build(tree, base)
-        @join_root.children.each { |child| construct_tables! @join_root, child }
+        @join_root = JoinBase.new(base, table, build(tree, base))
       end
 
       def reflections
         join_root.drop(1).map!(&:reflection)
       end
 
-      def join_constraints(outer_joins, join_type)
-        joins = join_root.children.flat_map { |child|
+      def join_constraints(joins_to_add, join_type, alias_tracker)
+        @alias_tracker = alias_tracker
 
-          if join_type == Arel::Nodes::OuterJoin
-            make_left_outer_joins join_root, child
-          else
-            make_inner_joins join_root, child
-          end
-        }
+        construct_tables!(join_root)
+        joins = make_join_constraints(join_root, join_type)
 
-        joins.concat outer_joins.flat_map { |oj|
+        joins.concat joins_to_add.flat_map { |oj|
+          construct_tables!(oj.join_root)
           if join_root.match? oj.join_root
             walk join_root, oj.join_root
           else
-            oj.join_root.children.flat_map { |child|
-              make_outer_joins oj.join_root, child
-            }
+            make_join_constraints(oj.join_root, join_type)
           end
         }
       end
 
-      def aliases
-        @aliases ||= Aliases.new join_root.each_with_index.map { |join_part, i|
-          columns = join_part.column_names.each_with_index.map { |column_name, j|
-            Aliases::Column.new column_name, "t#{i}_r#{j}"
-          }
-          Aliases::Table.new(join_part, columns)
-        }
-      end
-
       def instantiate(result_set, &block)
         primary_key = aliases.column_alias(join_root, join_root.primary_key)
 
@@ -165,37 +123,40 @@ module ActiveRecord
         parents.values
       end
 
-      private
-
-        def make_constraints(parent, child, tables, join_type)
-          chain         = child.reflection.chain
-          foreign_table = parent.table
-          foreign_klass = parent.base_klass
-          child.join_constraints(foreign_table, foreign_klass, join_type, tables, chain)
-        end
+      def apply_column_aliases(relation)
+        relation._select!(-> { aliases.columns })
+      end
 
-        def make_outer_joins(parent, child)
-          tables    = table_aliases_for(parent, child)
-          join_type = Arel::Nodes::OuterJoin
-          info      = make_constraints parent, child, tables, join_type
+      protected
+        attr_reader :alias_tracker, :join_root
 
-          [info] + child.children.flat_map { |c| make_outer_joins(child, c) }
+      private
+        def aliases
+          @aliases ||= Aliases.new join_root.each_with_index.map { |join_part, i|
+            columns = join_part.column_names.each_with_index.map { |column_name, j|
+              Aliases::Column.new column_name, "t#{i}_r#{j}"
+            }
+            Aliases::Table.new(join_part, columns)
+          }
         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) }
+        def construct_tables!(join_root)
+          join_root.each_children do |parent, child|
+            child.tables = table_aliases_for(parent, child)
+          end
         end
 
-        def make_inner_joins(parent, child)
-          tables    = child.tables
-          join_type = Arel::Nodes::InnerJoin
-          info      = make_constraints parent, child, tables, join_type
+        def make_join_constraints(join_root, join_type)
+          join_root.children.flat_map do |child|
+            make_constraints(join_root, child, join_type)
+          end
+        end
 
-          [info] + child.children.flat_map { |c| make_inner_joins(child, c) }
+        def make_constraints(parent, child, join_type = Arel::Nodes::OuterJoin)
+          foreign_table = parent.table
+          foreign_klass = parent.base_klass
+          joins = child.join_constraints(foreign_table, foreign_klass, join_type, alias_tracker)
+          joins.concat child.children.flat_map { |c| make_constraints(child, c, join_type) }
         end
 
         def table_aliases_for(parent, node)
@@ -208,15 +169,9 @@ module ActiveRecord
           }
         end
 
-        def construct_tables!(parent, node)
-          node.tables = table_aliases_for(parent, node)
-          node.children.each { |child| construct_tables! node, child }
-        end
-
         def table_alias_for(reflection, parent, join)
           name = "#{reflection.plural_name}_#{parent.table_name}"
-          name << "_join" if join
-          name
+          join ? "#{name}_join" : name
         end
 
         def walk(left, right)
@@ -224,8 +179,8 @@ module ActiveRecord
             [left.children.find { |node2| node1.match? node2 }, node1]
           }.partition(&:first)
 
-          ojs = missing.flat_map { |_, n| make_outer_joins left, n }
-          intersection.flat_map { |l, r| walk l, r }.concat ojs
+          joins = intersection.flat_map { |l, r| r.table = l.table; walk(l, r) }
+          joins.concat missing.flat_map { |_, n| make_constraints(left, n) }
         end
 
         def find_reflection(klass, name)
@@ -240,12 +195,11 @@ module ActiveRecord
             reflection.check_eager_loadable!
 
             if reflection.polymorphic?
-              next unless @eager_loading
               raise EagerLoadPolymorphicError.new(reflection)
             end
 
-            JoinAssociation.new reflection, build(right, reflection.klass)
-          end.compact
+            JoinAssociation.new(reflection, build(right, reflection.klass))
+          end
         end
 
         def construct(ar_parent, parent, row, rs, seen, model_cache, aliases)
@@ -269,18 +223,19 @@ module ActiveRecord
               next
             end
 
-            model = seen[ar_parent.object_id][node.base_klass][id]
+            model = seen[ar_parent.object_id][node][id]
 
             if model
               construct(model, node, row, rs, seen, model_cache, aliases)
             else
               model = construct_model(ar_parent, node, row, model_cache, id, aliases)
 
-              if node.reflection.scope_for(node.base_klass).readonly_value
+              if node.reflection.scope &&
+                  node.reflection.scope_for(node.base_klass.unscoped).readonly_value
                 model.readonly!
               end
 
-              seen[ar_parent.object_id][node.base_klass][id] = model
+              seen[ar_parent.object_id][node][id] = model
               construct(model, node, row, rs, seen, model_cache, aliases)
             end
           end