Class: ActiveRecord::Associations::Association

Inherits:
Object
  • Object
show all
Defined in:
activerecord/lib/active_record/associations/association.rb

Overview

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 owner, and the associated result set, known as the target. Association metadata is available in reflection, which is an instance of ActiveRecord::Reflection::AssociationReflection.

For example, given

class Blog < ActiveRecord::Base
  has_many :posts
end

blog = Blog.first

The association of blog.posts has the object blog as its owner, the collection of its posts as target, and the reflection object represents a :has_many macro.

Direct Known Subclasses

CollectionAssociation, SingularAssociation

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(owner, reflection) ⇒ Association


40
41
42
43
44
45
46
47
48
# File 'activerecord/lib/active_record/associations/association.rb', line 40

def initialize(owner, reflection)
  reflection.check_validity!

  @owner, @reflection = owner, reflection
  @_scope = nil

  reset
  reset_scope
end

Instance Attribute Details

#ownerObject (readonly)

Returns the value of attribute owner


36
37
38
# File 'activerecord/lib/active_record/associations/association.rb', line 36

def owner
  @owner
end

#reflectionObject (readonly)

Returns the value of attribute reflection


36
37
38
# File 'activerecord/lib/active_record/associations/association.rb', line 36

def reflection
  @reflection
end

#targetObject

Returns the value of attribute target


36
37
38
# File 'activerecord/lib/active_record/associations/association.rb', line 36

def target
  @target
end

Instance Method Details

#create(attributes = nil, &block) ⇒ Object


193
194
195
# File 'activerecord/lib/active_record/associations/association.rb', line 193

def create(attributes = nil, &block)
  _create_record(attributes, &block)
end

#create!(attributes = nil, &block) ⇒ Object


197
198
199
# File 'activerecord/lib/active_record/associations/association.rb', line 197

def create!(attributes = nil, &block)
  _create_record(attributes, true, &block)
end

#extensionsObject


142
143
144
145
146
147
148
149
150
# File 'activerecord/lib/active_record/associations/association.rb', line 142

def extensions
  extensions = klass.default_extensions | reflection.extensions

  if reflection.scope
    extensions |= reflection.scope_for(klass.unscoped, owner).extensions
  end

  extensions
end

#initialize_attributes(record, except_from_scope_attributes = nil) ⇒ Object

:nodoc:


183
184
185
186
187
188
189
190
191
# File 'activerecord/lib/active_record/associations/association.rb', line 183

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

#inversed_from(record) ⇒ Object Also known as: inversed_from_queries


130
131
132
133
# File 'activerecord/lib/active_record/associations/association.rb', line 130

def inversed_from(record)
  self.target = record
  @inversed = !!record
end

#klassObject

Returns the class of the target. belongs_to polymorphic overrides this to look at the polymorphic_type field on the owner.


138
139
140
# File 'activerecord/lib/active_record/associations/association.rb', line 138

def klass
  reflection.klass
end

#load_targetObject

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.


162
163
164
165
166
167
168
169
# File 'activerecord/lib/active_record/associations/association.rb', line 162

def load_target
  @target = find_target if (@stale_state && stale_target?) || find_target?

  loaded! unless loaded?
  target
rescue ActiveRecord::RecordNotFound
  reset
end

#loaded!Object

Asserts the target has been loaded setting the loaded flag to true.


78
79
80
81
82
# File 'activerecord/lib/active_record/associations/association.rb', line 78

def loaded!
  @loaded = true
  @stale_state = stale_state
  @inversed = false
end

#loaded?Boolean

Has the target been already loaded?


73
74
75
# File 'activerecord/lib/active_record/associations/association.rb', line 73

def loaded?
  @loaded
end

#marshal_dumpObject

We can't dump @reflection and @through_reflection since it contains the scope proc


172
173
174
175
# File 'activerecord/lib/active_record/associations/association.rb', line 172

def marshal_dump
  ivars = (instance_variables - [:@reflection, :@through_reflection]).map { |name| [name, instance_variable_get(name)] }
  [@reflection.name, ivars]
end

#marshal_load(data) ⇒ Object


177
178
179
180
181
# File 'activerecord/lib/active_record/associations/association.rb', line 177

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

#reload(force = false) ⇒ Object

Reloads the target and returns self on success. The QueryCache is cleared if force is true.


64
65
66
67
68
69
70
# File 'activerecord/lib/active_record/associations/association.rb', line 64

def reload(force = false)
  klass.connection.clear_query_cache if force && klass
  reset
  reset_scope
  load_target
  self unless target.nil?
end

#remove_inverse_instance(record) ⇒ Object

Remove the inverse association, if possible


124
125
126
127
128
# File 'activerecord/lib/active_record/associations/association.rb', line 124

def remove_inverse_instance(record)
  if inverse = inverse_association_for(record)
    inverse.inversed_from(nil)
  end
end

#resetObject

Resets the loaded flag to false and sets the target to nil.


51
52
53
54
55
56
# File 'activerecord/lib/active_record/associations/association.rb', line 51

def reset
  @loaded = false
  @target = nil
  @stale_state = nil
  @inversed = false
end

#reset_negative_cacheObject

:nodoc:


58
59
60
# File 'activerecord/lib/active_record/associations/association.rb', line 58

def reset_negative_cache # :nodoc:
  reset if loaded? && target.nil?
end

#reset_scopeObject


104
105
106
# File 'activerecord/lib/active_record/associations/association.rb', line 104

def reset_scope
  @association_scope = nil
end

#scopeObject


100
101
102
# File 'activerecord/lib/active_record/associations/association.rb', line 100

def scope
  @_scope&.spawn || target_scope.merge!(association_scope)
end

#scoping(relation, &block) ⇒ Object


201
202
203
204
205
206
# File 'activerecord/lib/active_record/associations/association.rb', line 201

def scoping(relation, &block)
  @_scope = relation
  relation.scoping(&block)
ensure
  @_scope = nil
end

#set_inverse_instance(record) ⇒ Object

Set the inverse association, if possible


109
110
111
112
113
114
# File 'activerecord/lib/active_record/associations/association.rb', line 109

def set_inverse_instance(record)
  if inverse = inverse_association_for(record)
    inverse.inversed_from(owner)
  end
  record
end

#set_inverse_instance_from_queries(record) ⇒ Object


116
117
118
119
120
121
# File 'activerecord/lib/active_record/associations/association.rb', line 116

def set_inverse_instance_from_queries(record)
  if inverse = inverse_association_for(record)
    inverse.inversed_from_queries(owner)
  end
  record
end

#stale_target?Boolean

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.


90
91
92
# File 'activerecord/lib/active_record/associations/association.rb', line 90

def stale_target?
  !@inversed && loaded? && @stale_state != stale_state
end