activerecord 6.0.0

data/lib/active_record/associations/alias_tracker.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/string/conversions"
+
+module ActiveRecord
+  module Associations
+    # Keeps track of table aliases for ActiveRecord::Associations::JoinDependency
+    class AliasTracker # :nodoc:
+      def self.create(connection, initial_table, joins)
+        if joins.empty?
+          aliases = Hash.new(0)
+        else
+          aliases = Hash.new { |h, k|
+            h[k] = initial_count_for(connection, k, joins)
+          }
+        end
+        aliases[initial_table] = 1
+        new(connection, aliases)
+      end
+
+      def self.initial_count_for(connection, name, table_joins)
+        quoted_name = nil
+
+        counts = table_joins.map do |join|
+          if join.is_a?(Arel::Nodes::StringJoin)
+            # quoted_name should be case ignored as some database adapters (Oracle) return quoted name in uppercase
+            quoted_name ||= connection.quote_table_name(name)
+
+            # Table names + table aliases
+            join.left.scan(
+              /JOIN(?:\s+\w+)?\s+(?:\S+\s+)?(?:#{quoted_name}|#{name})\sON/i
+            ).size
+          elsif join.is_a?(Arel::Nodes::Join)
+            join.left.name == name ? 1 : 0
+          elsif join.is_a?(Hash)
+            join[name]
+          else
+            raise ArgumentError, "joins list should be initialized by list of Arel::Nodes::Join"
+          end
+        end
+
+        counts.sum
+      end
+
+      # table_joins is an array of arel joins which might conflict with the aliases we assign here
+      def initialize(connection, aliases)
+        @aliases    = aliases
+        @connection = connection
+      end
+
+      def aliased_table_for(table_name, aliased_name, type_caster)
+        if aliases[table_name].zero?
+          # If it's zero, we can have our table_name
+          aliases[table_name] = 1
+          Arel::Table.new(table_name, type_caster: type_caster)
+        else
+          # Otherwise, we need to use an alias
+          aliased_name = @connection.table_alias_for(aliased_name)
+
+          # Update the count
+          aliases[aliased_name] += 1
+
+          table_alias = if aliases[aliased_name] > 1
+            "#{truncate(aliased_name)}_#{aliases[aliased_name]}"
+          else
+            aliased_name
+          end
+          Arel::Table.new(table_name, type_caster: type_caster).alias(table_alias)
+        end
+      end
+
+      attr_reader :aliases
+
+      private
+
+        def truncate(name)
+          name.slice(0, @connection.table_alias_length - 2)
+        end
+    end
+  end
+end

data/lib/active_record/associations/association.rb

@@ -0,0 +1,332 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/array/wrap"
+
+module ActiveRecord
+  module Associations
+    # = Active Record Associations
+    #
+    # This is the root class of all associations ('+ Foo' signifies an included module Foo):
+    #
+    #   Association
+    #     SingularAssociation
+    #       HasOneAssociation + ForeignAssociation
+    #         HasOneThroughAssociation + ThroughAssociation
+    #       BelongsToAssociation
+    #         BelongsToPolymorphicAssociation
+    #     CollectionAssociation
+    #       HasManyAssociation + ForeignAssociation
+    #         HasManyThroughAssociation + ThroughAssociation
+    #
+    # Associations in Active Record are middlemen between the object that
+    # holds the association, known as the <tt>owner</tt>, and the associated
+    # result set, known as the <tt>target</tt>. Association metadata is available in
+    # <tt>reflection</tt>, which is an instance of <tt>ActiveRecord::Reflection::AssociationReflection</tt>.
+    #
+    # For example, given
+    #
+    #   class Blog < ActiveRecord::Base
+    #     has_many :posts
+    #   end
+    #
+    #   blog = Blog.first
+    #
+    # The association of <tt>blog.posts</tt> has the object +blog+ as its
+    # <tt>owner</tt>, the collection of its posts as <tt>target</tt>, and
+    # the <tt>reflection</tt> object represents a <tt>:has_many</tt> macro.
+    class Association #:nodoc:
+      attr_reader :owner, :target, :reflection
+
+      delegate :options, to: :reflection
+
+      def initialize(owner, reflection)
+        reflection.check_validity!
+
+        @owner, @reflection = owner, reflection
+
+        reset
+        reset_scope
+      end
+
+      # Resets the \loaded flag to +false+ and sets the \target to +nil+.
+      def reset
+        @loaded = false
+        @target = nil
+        @stale_state = nil
+        @inversed = false
+      end
+
+      # Reloads the \target and returns +self+ on success.
+      # The QueryCache is cleared if +force+ is true.
+      def reload(force = false)
+        klass.connection.clear_query_cache if force && klass
+        reset
+        reset_scope
+        load_target
+        self unless target.nil?
+      end
+
+      # Has the \target been already \loaded?
+      def loaded?
+        @loaded
+      end
+
+      # Asserts the \target has been loaded setting the \loaded flag to +true+.
+      def loaded!
+        @loaded = true
+        @stale_state = stale_state
+        @inversed = false
+      end
+
+      # The target is stale if the target no longer points to the record(s) that the
+      # relevant foreign_key(s) refers to. If stale, the association accessor method
+      # on the owner will reload the target. It's up to subclasses to implement the
+      # stale_state method if relevant.
+      #
+      # Note that if the target has not been loaded, it is not considered stale.
+      def stale_target?
+        !@inversed && loaded? && @stale_state != stale_state
+      end
+
+      # Sets the target of this association to <tt>\target</tt>, and the \loaded flag to +true+.
+      def target=(target)
+        @target = target
+        loaded!
+      end
+
+      def scope
+        target_scope.merge!(association_scope)
+      end
+
+      def reset_scope
+        @association_scope = nil
+      end
+
+      # Set the inverse association, if possible
+      def set_inverse_instance(record)
+        if inverse = inverse_association_for(record)
+          inverse.inversed_from(owner)
+        end
+        record
+      end
+
+      def set_inverse_instance_from_queries(record)
+        if inverse = inverse_association_for(record)
+          inverse.inversed_from_queries(owner)
+        end
+        record
+      end
+
+      # Remove the inverse association, if possible
+      def remove_inverse_instance(record)
+        if inverse = inverse_association_for(record)
+          inverse.inversed_from(nil)
+        end
+      end
+
+      def inversed_from(record)
+        self.target = record
+        @inversed = !!record
+      end
+      alias :inversed_from_queries :inversed_from
+
+      # Returns the class of the target. belongs_to polymorphic overrides this to look at the
+      # polymorphic_type field on the owner.
+      def klass
+        reflection.klass
+      end
+
+      def extensions
+        extensions = klass.default_extensions | reflection.extensions
+
+        if reflection.scope
+          extensions |= reflection.scope_for(klass.unscoped, owner).extensions
+        end
+
+        extensions
+      end
+
+      # Loads the \target if needed and returns it.
+      #
+      # This method is abstract in the sense that it relies on +find_target+,
+      # which is expected to be provided by descendants.
+      #
+      # If the \target is already \loaded it is just returned. Thus, you can call
+      # +load_target+ unconditionally to get the \target.
+      #
+      # ActiveRecord::RecordNotFound is rescued within the method, and it is
+      # not reraised. The proxy is \reset and +nil+ is the return value.
+      def load_target
+        @target = find_target if (@stale_state && stale_target?) || find_target?
+
+        loaded! unless loaded?
+        target
+      rescue ActiveRecord::RecordNotFound
+        reset
+      end
+
+      # We can't dump @reflection and @through_reflection since it contains the scope proc
+      def marshal_dump
+        ivars = (instance_variables - [:@reflection, :@through_reflection]).map { |name| [name, instance_variable_get(name)] }
+        [@reflection.name, ivars]
+      end
+
+      def marshal_load(data)
+        reflection_name, ivars = data
+        ivars.each { |name, val| instance_variable_set(name, val) }
+        @reflection = @owner.class._reflect_on_association(reflection_name)
+      end
+
+      def initialize_attributes(record, except_from_scope_attributes = nil) #:nodoc:
+        except_from_scope_attributes ||= {}
+        skip_assign = [reflection.foreign_key, reflection.type].compact
+        assigned_keys = record.changed_attribute_names_to_save
+        assigned_keys += except_from_scope_attributes.keys.map(&:to_s)
+        attributes = scope_for_create.except!(*(assigned_keys - skip_assign))
+        record.send(:_assign_attributes, attributes) if attributes.any?
+        set_inverse_instance(record)
+      end
+
+      def create(attributes = {}, &block)
+        _create_record(attributes, &block)
+      end
+
+      def create!(attributes = {}, &block)
+        _create_record(attributes, true, &block)
+      end
+
+      private
+        def find_target
+          scope = self.scope
+          return scope.to_a if skip_statement_cache?(scope)
+
+          conn = klass.connection
+          sc = reflection.association_scope_cache(conn, owner) do |params|
+            as = AssociationScope.create { params.bind }
+            target_scope.merge!(as.scope(self))
+          end
+
+          binds = AssociationScope.get_bind_values(owner, reflection.chain)
+          sc.execute(binds, conn) { |record| set_inverse_instance(record) } || []
+        end
+
+        # The scope for this association.
+        #
+        # Note that the association_scope is merged into the target_scope only when the
+        # scope method is called. This is because at that point the call may be surrounded
+        # by scope.scoping { ... } or unscoped { ... } etc, which affects the scope which
+        # actually gets built.
+        def association_scope
+          if klass
+            @association_scope ||= AssociationScope.scope(self)
+          end
+        end
+
+        # Can be overridden (i.e. in ThroughAssociation) to merge in other scopes (i.e. the
+        # through association's scope)
+        def target_scope
+          AssociationRelation.create(klass, self).merge!(klass.scope_for_association)
+        end
+
+        def scope_for_create
+          scope.scope_for_create
+        end
+
+        def find_target?
+          !loaded? && (!owner.new_record? || foreign_key_present?) && klass
+        end
+
+        def creation_attributes
+          attributes = {}
+
+          if (reflection.has_one? || reflection.collection?) && !options[:through]
+            attributes[reflection.foreign_key] = owner[reflection.active_record_primary_key]
+
+            if reflection.type
+              attributes[reflection.type] = owner.class.polymorphic_name
+            end
+          end
+
+          attributes
+        end
+
+        # Sets the owner attributes on the given record
+        def set_owner_attributes(record)
+          creation_attributes.each { |key, value| record[key] = value }
+        end
+
+        # Returns true if there is a foreign key present on the owner which
+        # references the target. This is used to determine whether we can load
+        # the target if the owner is currently a new record (and therefore
+        # without a key). If the owner is a new record then foreign_key must
+        # be present in order to load target.
+        #
+        # Currently implemented by belongs_to (vanilla and polymorphic) and
+        # has_one/has_many :through associations which go through a belongs_to.
+        def foreign_key_present?
+          false
+        end
+
+        # Raises ActiveRecord::AssociationTypeMismatch unless +record+ is of
+        # the kind of the class of the associated objects. Meant to be used as
+        # a sanity check when you are about to assign an associated record.
+        def raise_on_type_mismatch!(record)
+          unless record.is_a?(reflection.klass)
+            fresh_class = reflection.class_name.safe_constantize
+            unless fresh_class && record.is_a?(fresh_class)
+              message = "#{reflection.class_name}(##{reflection.klass.object_id}) expected, "\
+                "got #{record.inspect} which is an instance of #{record.class}(##{record.class.object_id})"
+              raise ActiveRecord::AssociationTypeMismatch, message
+            end
+          end
+        end
+
+        def inverse_association_for(record)
+          if invertible_for?(record)
+            record.association(inverse_reflection_for(record).name)
+          end
+        end
+
+        # Can be redefined by subclasses, notably polymorphic belongs_to
+        # The record parameter is necessary to support polymorphic inverses as we must check for
+        # the association in the specific class of the record.
+        def inverse_reflection_for(record)
+          reflection.inverse_of
+        end
+
+        # Returns true if inverse association on the given record needs to be set.
+        # This method is redefined by subclasses.
+        def invertible_for?(record)
+          foreign_key_for?(record) && inverse_reflection_for(record)
+        end
+
+        # Returns true if record contains the foreign_key
+        def foreign_key_for?(record)
+          record.has_attribute?(reflection.foreign_key)
+        end
+
+        # This should be implemented to return the values of the relevant key(s) on the owner,
+        # so that when stale_state is different from the value stored on the last find_target,
+        # the target is stale.
+        #
+        # This is only relevant to certain associations, which is why it returns +nil+ by default.
+        def stale_state
+        end
+
+        def build_record(attributes)
+          reflection.build_association(attributes) do |record|
+            initialize_attributes(record, attributes)
+            yield(record) if block_given?
+          end
+        end
+
+        # Returns true if statement cache should be skipped on the association reader.
+        def skip_statement_cache?(scope)
+          reflection.has_scope? ||
+            scope.eager_loading? ||
+            klass.scope_attributes? ||
+            reflection.source_reflection.active_record.default_scopes.any?
+        end
+    end
+  end
+end

data/lib/active_record/associations/association_scope.rb

@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Associations
+    class AssociationScope #:nodoc:
+      def self.scope(association)
+        INSTANCE.scope(association)
+      end
+
+      def self.create(&block)
+        block ||= lambda { |val| val }
+        new(block)
+      end
+
+      def initialize(value_transformation)
+        @value_transformation = value_transformation
+      end
+
+      INSTANCE = create
+
+      def scope(association)
+        klass = association.klass
+        reflection = association.reflection
+        scope = klass.unscoped
+        owner = association.owner
+        chain = get_chain(reflection, association, scope.alias_tracker)
+
+        scope.extending! reflection.extensions
+        scope = add_constraints(scope, owner, chain)
+        scope.limit!(1) unless reflection.collection?
+        scope
+      end
+
+      def self.get_bind_values(owner, chain)
+        binds = []
+        last_reflection = chain.last
+
+        binds << last_reflection.join_id_for(owner)
+        if last_reflection.type
+          binds << owner.class.polymorphic_name
+        end
+
+        chain.each_cons(2).each do |reflection, next_reflection|
+          if reflection.type
+            binds << next_reflection.klass.polymorphic_name
+          end
+        end
+        binds
+      end
+
+      private
+        attr_reader :value_transformation
+
+        def join(table, constraint)
+          table.create_join(table, table.create_on(constraint))
+        end
+
+        def last_chain_scope(scope, reflection, owner)
+          join_keys = reflection.join_keys
+          key = join_keys.key
+          foreign_key = join_keys.foreign_key
+
+          table = reflection.aliased_table
+          value = transform_value(owner[foreign_key])
+          scope = apply_scope(scope, table, key, value)
+
+          if reflection.type
+            polymorphic_type = transform_value(owner.class.polymorphic_name)
+            scope = apply_scope(scope, table, reflection.type, polymorphic_type)
+          end
+
+          scope
+        end
+
+        def transform_value(value)
+          value_transformation.call(value)
+        end
+
+        def next_chain_scope(scope, reflection, next_reflection)
+          join_keys = reflection.join_keys
+          key = join_keys.key
+          foreign_key = join_keys.foreign_key
+
+          table = reflection.aliased_table
+          foreign_table = next_reflection.aliased_table
+          constraint = table[key].eq(foreign_table[foreign_key])
+
+          if reflection.type
+            value = transform_value(next_reflection.klass.polymorphic_name)
+            scope = apply_scope(scope, table, reflection.type, value)
+          end
+
+          scope.joins!(join(foreign_table, constraint))
+        end
+
+        class ReflectionProxy < SimpleDelegator # :nodoc:
+          attr_reader :aliased_table
+
+          def initialize(reflection, aliased_table)
+            super(reflection)
+            @aliased_table = aliased_table
+          end
+
+          def all_includes; nil; end
+        end
+
+        def get_chain(reflection, association, tracker)
+          name = reflection.name
+          chain = [Reflection::RuntimeReflection.new(reflection, association)]
+          reflection.chain.drop(1).each do |refl|
+            aliased_table = tracker.aliased_table_for(
+              refl.table_name,
+              refl.alias_candidate(name),
+              refl.klass.type_caster
+            )
+            chain << ReflectionProxy.new(refl, aliased_table)
+          end
+          chain
+        end
+
+        def add_constraints(scope, owner, chain)
+          scope = last_chain_scope(scope, chain.last, owner)
+
+          chain.each_cons(2) do |reflection, next_reflection|
+            scope = next_chain_scope(scope, reflection, next_reflection)
+          end
+
+          chain_head = chain.first
+          chain.reverse_each do |reflection|
+            # Exclude the scope of the association itself, because that
+            # was already merged in the #scope method.
+            reflection.constraints.each do |scope_chain_item|
+              item = eval_scope(reflection, scope_chain_item, owner)
+
+              if scope_chain_item == chain_head.scope
+                scope.merge! item.except(:where, :includes, :unscope, :order)
+              end
+
+              reflection.all_includes do
+                scope.includes! item.includes_values
+              end
+
+              scope.unscope!(*item.unscope_values)
+              scope.where_clause += item.where_clause
+              scope.order_values = item.order_values | scope.order_values
+            end
+          end
+
+          scope
+        end
+
+        def apply_scope(scope, table, key, value)
+          if scope.table == table
+            scope.where!(key => value)
+          else
+            scope.where!(table.name => { key => value })
+          end
+        end
+
+        def eval_scope(reflection, scope, owner)
+          relation = reflection.build_scope(reflection.aliased_table)
+          relation.instance_exec(owner, &scope) || relation
+        end
+    end
+  end
+end