Class: ActiveRecord::Associations::AssociationCollection
- Inherits:
-
AssociationProxy
- Object
- AssociationProxy
- ActiveRecord::Associations::AssociationCollection
- Defined in:
- lib/active_record/associations/association_collection.rb
Overview
AssociationCollection is an abstract class that provides common stuff to ease the implementation of association proxies that represent collections. See the class hierarchy in AssociationProxy.
You need to be careful with assumptions regarding the target: The proxy does not fetch records from the database until it needs them, but new ones created with build
are added to the target. So, the target may be non-empty and still lack children waiting to be read from the database. If you look directly to the database you cannot assume that’s the entire collection because new records may have beed added to the target, etc.
If you need to work on all current children, new and existing records, load_target
and the loaded
flag are your friends.
Direct Known Subclasses
Instance Method Summary collapse
-
#<<(*records) ⇒ Object
(also: #push, #concat)
Add
records
to this association. - #any? ⇒ Boolean
- #build(attributes = {}, &block) ⇒ Object
-
#clear ⇒ Object
Removes all records from this association.
-
#count(*args) ⇒ Object
Count all records using SQL.
- #create(attrs = {}) ⇒ Object
- #create!(attrs = {}) ⇒ Object
-
#delete(*records) ⇒ Object
Removes
records
from this association callingbefore_remove
andafter_remove
callbacks. -
#delete_all ⇒ Object
Remove all records from this association.
-
#destroy(*records) ⇒ Object
Destroy
records
and remove them from this association callingbefore_remove
andafter_remove
callbacks. -
#destroy_all ⇒ Object
Destory all the records from this association.
-
#empty? ⇒ Boolean
Equivalent to
collection.size.zero?
. - #find(*args) ⇒ Object
-
#first(*args) ⇒ Object
Fetches the first one using SQL if possible.
- #include?(record) ⇒ Boolean
-
#initialize(owner, reflection) ⇒ AssociationCollection
constructor
:nodoc:.
-
#last(*args) ⇒ Object
Fetches the last one using SQL if possible.
-
#length ⇒ Object
Returns the size of the collection calling
size
on the target. - #proxy_respond_to?(method, include_private = false) ⇒ Boolean
-
#replace(other_array) ⇒ Object
Replace this collection with
other_array
This will perform a diff and delete/add only records that have changed. - #reset ⇒ Object
-
#size ⇒ Object
Returns the size of the collection by executing a SELECT COUNT(*) query if the collection hasn’t been loaded, and calling
collection.size
if it has. -
#sum(*args) ⇒ Object
Calculate sum using SQL, not Enumerable.
- #to_ary ⇒ Object
-
#transaction(*args) ⇒ Object
Starts a transaction in the association class’s database connection.
- #uniq(collection = self) ⇒ Object
Methods inherited from AssociationProxy
#===, #aliased_table_name, #conditions, #inspect, #loaded, #loaded?, #proxy_owner, #proxy_reflection, #proxy_target, #reload, #respond_to?, #send, #target, #target=
Constructor Details
#initialize(owner, reflection) ⇒ AssociationCollection
:nodoc:
19 20 21 22 |
# File 'lib/active_record/associations/association_collection.rb', line 19 def initialize(owner, reflection) super construct_sql end |
Dynamic Method Handling
This class handles dynamic methods through the method_missing method
#method_missing(method, *args) ⇒ Object (protected)
366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 |
# File 'lib/active_record/associations/association_collection.rb', line 366 def method_missing(method, *args) if @target.respond_to?(method) || (!@reflection.klass.respond_to?(method) && Class.respond_to?(method)) if block_given? super { |*block_args| yield(*block_args) } else super end elsif @reflection.klass.scopes.include?(method) @reflection.klass.scopes[method].call(self, *args) else with_scope(construct_scope) do if block_given? @reflection.klass.send(method, *args) { |*block_args| yield(*block_args) } else @reflection.klass.send(method, *args) end end end end |
Instance Method Details
#<<(*records) ⇒ Object Also known as: push, concat
Add records
to this association. Returns self
so method calls may be chained.
Since << flattens its argument list and inserts each record, push
and concat
behave identically.
111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 |
# File 'lib/active_record/associations/association_collection.rb', line 111 def <<(*records) result = true load_target if @owner.new_record? transaction do flatten_deeper(records).each do |record| raise_on_type_mismatch(record) add_record_to_target_with_callbacks(record) do |r| result &&= insert_record(record) unless @owner.new_record? end end end result && self end |
#any? ⇒ Boolean
298 299 300 301 302 303 304 |
# File 'lib/active_record/associations/association_collection.rb', line 298 def any? if block_given? method_missing(:any?) { |*block_args| yield(*block_args) } else !empty? end end |
#build(attributes = {}, &block) ⇒ Object
98 99 100 101 102 103 104 105 106 107 |
# File 'lib/active_record/associations/association_collection.rb', line 98 def build(attributes = {}, &block) if attributes.is_a?(Array) attributes.collect { |attr| build(attr, &block) } else build_record(attributes) do |record| block.call(record) if block_given? set_belongs_to_association_for(record) end end end |
#clear ⇒ Object
Removes all records from this association. Returns self
so method calls may be chained.
220 221 222 223 224 225 226 227 228 229 230 |
# File 'lib/active_record/associations/association_collection.rb', line 220 def clear return self if length.zero? # forces load_target if it hasn't happened already if @reflection.[:dependent] && @reflection.[:dependent] == :destroy destroy_all else delete_all end self end |
#count(*args) ⇒ Object
Count all records using SQL. If the :counter_sql
option is set for the association, it will be used for the query. If no :counter_sql
was supplied, but :finder_sql
was set, the descendant’s construct_sql
method will have set :counter_sql automatically. Otherwise, construct options and pass them with scope to the target class’s count
.
167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 |
# File 'lib/active_record/associations/association_collection.rb', line 167 def count(*args) if @reflection.[:counter_sql] @reflection.klass.count_by_sql(@counter_sql) else column_name, = @reflection.klass.send(:construct_count_options_from_args, *args) if @reflection.[:uniq] # This is needed because 'SELECT count(DISTINCT *)..' is not valid SQL. column_name = "#{@reflection.quoted_table_name}.#{@reflection.klass.primary_key}" if column_name == :all .merge!(:distinct => true) end value = @reflection.klass.send(:with_scope, construct_scope) { @reflection.klass.count(column_name, ) } limit = @reflection.[:limit] offset = @reflection.[:offset] if limit || offset [ [value - offset.to_i, 0].max, limit.to_i ].min else value end end end |
#create(attrs = {}) ⇒ Object
241 242 243 244 245 246 247 248 249 250 |
# File 'lib/active_record/associations/association_collection.rb', line 241 def create(attrs = {}) if attrs.is_a?(Array) attrs.collect { |attr| create(attr) } else create_record(attrs) do |record| yield(record) if block_given? record.save end end end |
#create!(attrs = {}) ⇒ Object
252 253 254 255 256 257 |
# File 'lib/active_record/associations/association_collection.rb', line 252 def create!(attrs = {}) create_record(attrs) do |record| yield(record) if block_given? record.save! end end |
#delete(*records) ⇒ Object
Removes records
from this association calling before_remove
and after_remove
callbacks.
This method is abstract in the sense that delete_records
has to be provided by descendants. Note this method does not imply the records are actually removed from the database, that depends precisely on delete_records
. They are in any case removed from the collection.
198 199 200 201 202 203 |
# File 'lib/active_record/associations/association_collection.rb', line 198 def delete(*records) remove_records(records) do |records, old_records| delete_records(old_records) if old_records.any? records.each { |record| @target.delete(record) } end end |
#delete_all ⇒ Object
Remove all records from this association
See delete for more info.
148 149 150 151 152 |
# File 'lib/active_record/associations/association_collection.rb', line 148 def delete_all load_target delete(@target) reset_target! end |
#destroy(*records) ⇒ Object
Destroy records
and remove them from this association calling before_remove
and after_remove
callbacks.
Note that this method will always remove records from the database ignoring the :dependent
option.
210 211 212 213 214 215 216 217 |
# File 'lib/active_record/associations/association_collection.rb', line 210 def destroy(*records) records = find(records) if records.any? {|record| record.kind_of?(Fixnum) || record.kind_of?(String)} remove_records(records) do |records, old_records| old_records.each { |record| record.destroy } end load_target end |
#destroy_all ⇒ Object
Destory all the records from this association.
See destroy for more info.
235 236 237 238 239 |
# File 'lib/active_record/associations/association_collection.rb', line 235 def destroy_all load_target destroy(@target) reset_target! end |
#empty? ⇒ Boolean
Equivalent to collection.size.zero?
. If the collection has not been already loaded and you are going to fetch the records anyway it is better to check collection.length.zero?
.
294 295 296 |
# File 'lib/active_record/associations/association_collection.rb', line 294 def empty? size.zero? end |
#find(*args) ⇒ Object
24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 |
# File 'lib/active_record/associations/association_collection.rb', line 24 def find(*args) = args. # If using a custom finder_sql, scan the entire collection. if @reflection.[:finder_sql] expects_array = args.first.kind_of?(Array) ids = args.flatten.compact.uniq.map { |arg| arg.to_i } if ids.size == 1 id = ids.first record = load_target.detect { |r| id == r.id } expects_array ? [ record ] : record else load_target.select { |r| ids.include?(r.id) } end else conditions = "#{@finder_sql}" if sanitized_conditions = sanitize_sql([:conditions]) conditions << " AND (#{sanitized_conditions})" end [:conditions] = conditions if [:order] && @reflection.[:order] [:order] = "#{[:order]}, #{@reflection.[:order]}" elsif @reflection.[:order] [:order] = @reflection.[:order] end # Build options specific to association () () # Pass through args exactly as we received them. args << @reflection.klass.find(*args) end end |
#first(*args) ⇒ Object
Fetches the first one using SQL if possible.
65 66 67 68 69 70 71 72 |
# File 'lib/active_record/associations/association_collection.rb', line 65 def first(*args) if fetch_first_or_last_using_find?(args) find(:first, *args) else load_target unless loaded? @target.first(*args) end end |
#include?(record) ⇒ Boolean
332 333 334 335 336 337 |
# File 'lib/active_record/associations/association_collection.rb', line 332 def include?(record) return false unless record.is_a?(@reflection.klass) load_target if @reflection.[:finder_sql] && !loaded? return @target.include?(record) if loaded? exists?(record) end |
#last(*args) ⇒ Object
Fetches the last one using SQL if possible.
75 76 77 78 79 80 81 82 |
# File 'lib/active_record/associations/association_collection.rb', line 75 def last(*args) if fetch_first_or_last_using_find?(args) find(:last, *args) else load_target unless loaded? @target.last(*args) end end |
#length ⇒ Object
Returns the size of the collection calling size
on the target.
If the collection has been already loaded length
and size
are equivalent. If not and you are going to need the records anyway this method will take one less query. Otherwise size
is more efficient.
287 288 289 |
# File 'lib/active_record/associations/association_collection.rb', line 287 def length load_target.size end |
#proxy_respond_to?(method, include_private = false) ⇒ Boolean
339 340 341 |
# File 'lib/active_record/associations/association_collection.rb', line 339 def proxy_respond_to?(method, include_private = false) super || @reflection.klass.respond_to?(method, include_private) end |
#replace(other_array) ⇒ Object
Replace this collection with other_array
This will perform a diff and delete/add only records that have changed.
319 320 321 322 323 324 325 326 327 328 329 330 |
# File 'lib/active_record/associations/association_collection.rb', line 319 def replace(other_array) other_array.each { |val| raise_on_type_mismatch(val) } load_target other = other_array.size < 100 ? other_array : other_array.to_set current = @target.size < 100 ? @target : @target.to_set transaction do delete(@target.select { |v| !other.include?(v) }) concat(other_array.select { |v| !current.include?(v) }) end end |
#reset ⇒ Object
93 94 95 96 |
# File 'lib/active_record/associations/association_collection.rb', line 93 def reset reset_target! @loaded = false end |
#size ⇒ Object
Returns the size of the collection by executing a SELECT COUNT(*) query if the collection hasn’t been loaded, and calling collection.size
if it has.
If the collection has been already loaded size
and length
are equivalent. If not and you are going to need the records anyway length
will take one less query. Otherwise size
is more efficient.
This method is abstract in the sense that it relies on count_records
, which is a method descendants have to provide.
269 270 271 272 273 274 275 276 277 278 279 280 |
# File 'lib/active_record/associations/association_collection.rb', line 269 def size if @owner.new_record? || (loaded? && !@reflection.[:uniq]) @target.size elsif !loaded? && @reflection.[:group] load_target.size elsif !loaded? && !@reflection.[:uniq] && @target.is_a?(Array) unsaved_records = @target.select { |r| r.new_record? } unsaved_records.size + count_records else count_records end end |
#sum(*args) ⇒ Object
Calculate sum using SQL, not Enumerable
155 156 157 158 159 160 161 |
# File 'lib/active_record/associations/association_collection.rb', line 155 def sum(*args) if block_given? calculate(:sum, *args) { |*block_args| yield(*block_args) } else calculate(:sum, *args) end end |
#to_ary ⇒ Object
84 85 86 87 88 89 90 91 |
# File 'lib/active_record/associations/association_collection.rb', line 84 def to_ary load_target if @target.is_a?(Array) @target.to_ary else Array(@target) end end |
#transaction(*args) ⇒ Object
Starts a transaction in the association class’s database connection.
class Author < ActiveRecord::Base
has_many :books
end
Author.find(:first).books.transaction do
# same effect as calling Book.transaction
end
139 140 141 142 143 |
# File 'lib/active_record/associations/association_collection.rb', line 139 def transaction(*args) @reflection.klass.transaction(*args) do yield end end |
#uniq(collection = self) ⇒ Object
306 307 308 309 310 311 312 313 314 315 |
# File 'lib/active_record/associations/association_collection.rb', line 306 def uniq(collection = self) seen = Set.new collection.inject([]) do |kept, record| unless seen.include?(record.id) kept << record seen << record.id end kept end end |