Ruby on Rails 5.2 - ActiveRecord::Associations::CollectionProxy

वर्ग ActiveRecord :: संघों :: CollectionProxy




ruby

वर्ग ActiveRecord :: संघों :: CollectionProxy

जनक:
रिश्ता

सक्रिय रिकॉर्ड में एसोसिएशन परदे के पीछे वस्तु के बीच बिचौलिये हैं, जो एसोसिएशन को @owner , @owner रूप में जाना जाता है, और वास्तविक संबंधित वस्तु, जिसे @target रूप में जाना जाता है। किसी भी प्रॉक्सी के बारे में जिस तरह की एसोसिएशन है, @reflection में उपलब्ध है। यह कक्षा ActiveRecord :: Reflection :: AssociationReflection का एक उदाहरण है।

उदाहरण के लिए, दिया गया

class Blog < ActiveRecord::Base
  has_many :posts
end

blog = Blog.first

blog.posts में एसोसिएशन प्रॉक्सी blog.posts रूप में blog में @owner , @owner रूप में अपने पदों का संग्रह है, और @reflection ऑब्जेक्ट a :has_many मैक्रो का प्रतिनिधित्व करता है।

यह वर्ग अज्ञात तरीकों को @target माध्यम से method_missing @target

@target ऑब्जेक्ट को तब तक लोड नहीं किया जाता है जब तक कि जरूरत न हो। उदाहरण के लिए,

blog.posts.count

एसक्यूएल के माध्यम से सीधे गणना की जाती है और वास्तविक पोस्ट रिकॉर्ड की तात्कालिकता से खुद को ट्रिगर नहीं करता है।

सार्वजनिक प्रवृत्ति के तरीके

<< (* रिकॉर्ड) स्रोत दिखाएँ
# File activerecord/lib/active_record/associations/collection_proxy.rb, line 1055
def <<(*records)
  proxy_association.concat(records) && self
end

एसोसिएशन की प्राथमिक कुंजी के लिए अपनी विदेशी कुंजी सेट करके संग्रह में एक या अधिक records जोड़ता है। self वापस लौटाता है, तो कई एपेंड एक साथ जंजीर हो सकते हैं।

class Person < ActiveRecord::Base
  has_many :pets
end

person.pets.size # => 0
person.pets << Pet.new(name: 'Fancy-Fancy')
person.pets << [Pet.new(name: 'Spook'), Pet.new(name: 'Choo-Choo')]
person.pets.size # => 3

person.id # => 1
person.pets
# => [
#      #<Pet id: 1, name: "Fancy-Fancy", person_id: 1>,
#      #<Pet id: 2, name: "Spook", person_id: 1>,
#      #<Pet id: 3, name: "Choo-Choo", person_id: 1>
#    ]
इसके अलावा उपनाम: push , append
# File activerecord/lib/active_record/associations/collection_proxy.rb, line 987
def ==(other)
  load_target == other
end

Array#== बराबर। यदि दो सरणियों में समान तत्वों की संख्या है और यदि प्रत्येक तत्व other सरणी में संबंधित तत्व के बराबर है, तो सही है, अन्यथा वापस लौटता false

class Person < ActiveRecord::Base
  has_many :pets
end

person.pets
# => [
#      #<Pet id: 1, name: "Fancy-Fancy", person_id: 1>,
#      #<Pet id: 2, name: "Spook", person_id: 1>
#    ]

other = person.pets.to_ary

person.pets == other
# => true

other = [Pet.new(id: 1), Pet.new(id: 2)]

person.pets == other
# => false
# File activerecord/lib/active_record/associations/collection_proxy.rb, line 899
      

अगर संग्रह खाली नहीं है, तो true है।

class Person < ActiveRecord::Base
  has_many :pets
end

person.pets.count # => 0
person.pets.any?  # => false

person.pets << Pet.new(name: 'Snoop')
person.pets.count # => 1
person.pets.any?  # => true

आप मानदंड को परिभाषित करने के लिए एक block भी पास कर सकते हैं। व्यवहार समान है, यह सही है अगर मापदंड के आधार पर संग्रह खाली नहीं है।

person.pets
# => [#<Pet name: "Snoop", group: "dogs">]

person.pets.any? do |pet|
  pet.group == 'cats'
end
# => false

person.pets.any? do |pet|
  pet.group == 'dogs'
end
# => true
परिशिष्ट (* रिकॉर्ड)
अन्य के लिए उपनाम: <<
निर्माण (विशेषताएँ = {}, और ब्लॉक) स्रोत दिखाएँ
# File activerecord/lib/active_record/associations/collection_proxy.rb, line 318
def build(attributes = {}, &block)
  @association.build(attributes, &block)
end

संग्रह प्रकार की एक नई वस्तु लौटाता है जिसे attributes साथ त्वरित किया गया है और इस ऑब्जेक्ट से जोड़ा गया है, लेकिन अभी तक सहेजा नहीं गया है। आप विशेषता हैश की एक सरणी पास कर सकते हैं, यह नई वस्तुओं के साथ एक सरणी लौटाएगा।

class Person
  has_many :pets
end

person.pets.build
# => #<Pet id: nil, name: nil, person_id: 1>

person.pets.build(name: 'Fancy-Fancy')
# => #<Pet id: nil, name: "Fancy-Fancy", person_id: 1>

person.pets.build([{name: 'Spook'}, {name: 'Choo-Choo'}, {name: 'Brain'}])
# => [
#      #<Pet id: nil, name: "Spook", person_id: 1>,
#      #<Pet id: nil, name: "Choo-Choo", person_id: 1>,
#      #<Pet id: nil, name: "Brain", person_id: 1>
#    ]

person.pets.size  # => 5 # size of the collection
person.pets.count # => 0 # count from database
इसके अलावा उपनाम: new
गणना (संचालन, column_name) स्रोत दिखाएं
# File activerecord/lib/active_record/associations/collection_proxy.rb, line 752
def calculate(operation, column_name)
  null_scope? ? scope.calculate(operation, column_name) : super
end
सुपरक्लास विधि कहता है
# File activerecord/lib/active_record/associations/collection_proxy.rb, line 1071
def clear
  delete_all
  self
end

delete_all बराबर है। अंतर यह है कि हटाए गए ऑब्जेक्ट्स के साथ एक सरणी के बजाय, self लौटता है, इसलिए विधियों को जंजीर किया जा सकता है। अधिक जानकारी के लिए delete_all देखें। ध्यान दें कि क्योंकि delete_all सीधे डेटाबेस में SQL क्वेरी चलाकर रिकॉर्ड निकालता है, ऑब्जेक्ट का updated_at स्तंभ नहीं बदला गया है।

concat (* रिकॉर्ड्स) स्रोत दिखाएं
# File activerecord/lib/active_record/associations/collection_proxy.rb, line 393
def concat(*records)
  @association.concat(*records)
end

अपनी प्राथमिक कुंजी को एसोसिएशन की प्राथमिक कुंजी पर सेट करके संग्रह में एक या अधिक रिकॉर्ड जोड़ें। चूंकि << अपनी तर्क सूची को समतल करता है और प्रत्येक रिकॉर्ड को सम्मिलित करता है, push और concat व्यवहार करते हैं self वापस लौटाता है तो विधि कॉल जंजीर हो सकती है।

class Person < ActiveRecord::Base
  has_many :pets
end

person.pets.size # => 0
person.pets.concat(Pet.new(name: 'Fancy-Fancy'))
person.pets.concat(Pet.new(name: 'Spook'), Pet.new(name: 'Choo-Choo'))
person.pets.size # => 3

person.id # => 1
person.pets
# => [
#       #<Pet id: 1, name: "Fancy-Fancy", person_id: 1>,
#       #<Pet id: 2, name: "Spook", person_id: 1>,
#       #<Pet id: 3, name: "Choo-Choo", person_id: 1>
#    ]

person.pets.concat([Pet.new(name: 'Brain'), Pet.new(name: 'Benny')])
person.pets.size # => 5
गिनती (column_name = nil, & block) स्रोत दिखाएं
# File activerecord/lib/active_record/associations/collection_proxy.rb, line 786
      

सभी रिकॉर्ड गिनाए।

class Person < ActiveRecord::Base
  has_many :pets
end

# This will perform the count using SQL.
person.pets.count # => 3
person.pets
# => [
#       #<Pet id: 1, name: "Fancy-Fancy", person_id: 1>,
#       #<Pet id: 2, name: "Spook", person_id: 1>,
#       #<Pet id: 3, name: "Choo-Choo", person_id: 1>
#    ]

एक ब्लॉक पास करना SQL में किसी व्यक्ति के पालतू जानवरों का चयन करेगा और फिर रूबी का उपयोग करके गणना करेगा।

person.pets.count { |pet| pet.name.include?('-') } # => 2
बनाने (विशेषताएँ = {}, और ब्लॉक) स्रोत दिखाएँ
# File activerecord/lib/active_record/associations/collection_proxy.rb, line 349
def create(attributes = {}, &block)
  @association.create(attributes, &block)
end

संग्रह ऑब्जेक्ट का एक नया ऑब्जेक्ट लौटाता है जिसे विशेषताओं के साथ त्वरित किया गया है, इस ऑब्जेक्ट से जुड़ा हुआ है और जो पहले से ही सहेजा गया है (यदि यह सत्यापन पास करता है)।

class Person
  has_many :pets
end

person.pets.create(name: 'Fancy-Fancy')
# => #<Pet id: 1, name: "Fancy-Fancy", person_id: 1>

person.pets.create([{name: 'Spook'}, {name: 'Choo-Choo'}])
# => [
#      #<Pet id: 2, name: "Spook", person_id: 1>,
#      #<Pet id: 3, name: "Choo-Choo", person_id: 1>
#    ]

person.pets.size  # => 3
person.pets.count # => 3

person.pets.find(1, 2, 3)
# => [
#       #<Pet id: 1, name: "Fancy-Fancy", person_id: 1>,
#       #<Pet id: 2, name: "Spook", person_id: 1>,
#       #<Pet id: 3, name: "Choo-Choo", person_id: 1>
#    ]
सर्जन करना! (विशेषताएँ = {}, और ब्लॉक) स्रोत दिखाएं
# File activerecord/lib/active_record/associations/collection_proxy.rb, line 365
def create!(attributes = {}, &block)
  @association.create!(attributes, &block)
end

जैसे create , सिवाय इसके कि यदि रिकॉर्ड अमान्य है, तो अपवाद को उठाता है।

class Person
  has_many :pets
end

class Pet
  validates :name, presence: true
end

person.pets.create!(name: nil)
# => ActiveRecord::RecordInvalid: Validation failed: Name can't be blank
हटाना (* रिकॉर्ड) स्रोत दिखाएँ
# File activerecord/lib/active_record/associations/collection_proxy.rb, line 648
def delete(*records)
  @association.delete(*records)
end

:dependent विकल्प द्वारा निर्दिष्ट रणनीति के अनुसार संग्रह से आपूर्ति records गए records हटाता है। यदि कोई :dependent विकल्प नहीं दिया गया है, तो यह डिफ़ॉल्ट रणनीति का पालन करेगा। हटाए गए रिकॉर्ड के साथ एक सरणी देता है।

:delete_all लिए :delete_all संघों के has_many :through से, डिफ़ॉल्ट विलोपन रणनीति है :delete_all

has_many संघों के लिए, डिफ़ॉल्ट विलोपन रणनीति है :nullify । यह विदेशी कुंजियों को NULL को सेट करता NULL

class Person < ActiveRecord::Base
  has_many :pets # dependent: :nullify option by default
end

person.pets.size # => 3
person.pets
# => [
#       #<Pet id: 1, name: "Fancy-Fancy", person_id: 1>,
#       #<Pet id: 2, name: "Spook", person_id: 1>,
#       #<Pet id: 3, name: "Choo-Choo", person_id: 1>
#    ]

person.pets.delete(Pet.find(1))
# => [#<Pet id: 1, name: "Fancy-Fancy", person_id: 1>]

person.pets.size # => 2
person.pets
# => [
#       #<Pet id: 2, name: "Spook", person_id: 1>,
#       #<Pet id: 3, name: "Choo-Choo", person_id: 1>
#    ]

Pet.find(1)
# => #<Pet id: 1, name: "Fancy-Fancy", person_id: nil>

यदि यह सेट किया गया है :destroy सभी records को destroy विधि destroy करके हटा दिया जाता है। अधिक जानकारी के लिए destroy देखें।

class Person < ActiveRecord::Base
  has_many :pets, dependent: :destroy
end

person.pets.size # => 3
person.pets
# => [
#       #<Pet id: 1, name: "Fancy-Fancy", person_id: 1>,
#       #<Pet id: 2, name: "Spook", person_id: 1>,
#       #<Pet id: 3, name: "Choo-Choo", person_id: 1>
#    ]

person.pets.delete(Pet.find(1), Pet.find(3))
# => [
#       #<Pet id: 1, name: "Fancy-Fancy", person_id: 1>,
#       #<Pet id: 3, name: "Choo-Choo", person_id: 1>
#    ]

person.pets.size # => 1
person.pets
# => [#<Pet id: 2, name: "Spook", person_id: 1>]

Pet.find(1, 3)
# => ActiveRecord::RecordNotFound: Couldn't find all Pets with 'id': (1, 3)

यदि इसे :delete_all सेट किया :delete_all , तो उनकी destroy विधि को कॉल किए बिना सभी records हटा records जाते हैं।

class Person < ActiveRecord::Base
  has_many :pets, dependent: :delete_all
end

person.pets.size # => 3
person.pets
# => [
#       #<Pet id: 1, name: "Fancy-Fancy", person_id: 1>,
#       #<Pet id: 2, name: "Spook", person_id: 1>,
#       #<Pet id: 3, name: "Choo-Choo", person_id: 1>
#    ]

person.pets.delete(Pet.find(1))
# => [#<Pet id: 1, name: "Fancy-Fancy", person_id: 1>]

person.pets.size # => 2
person.pets
# => [
#       #<Pet id: 2, name: "Spook", person_id: 1>,
#       #<Pet id: 3, name: "Choo-Choo", person_id: 1>
#    ]

Pet.find(1)
# => ActiveRecord::RecordNotFound: Couldn't find Pet with 'id'=1

आप Integer या String मानों को पारित कर सकते हैं, यह id को जवाब देने वाले रिकॉर्ड ढूंढता है और उन पर डिलीट निष्पादित करता है।

class Person < ActiveRecord::Base
  has_many :pets
end

person.pets.size # => 3
person.pets
# => [
#       #<Pet id: 1, name: "Fancy-Fancy", person_id: 1>,
#       #<Pet id: 2, name: "Spook", person_id: 1>,
#       #<Pet id: 3, name: "Choo-Choo", person_id: 1>
#    ]

person.pets.delete("1")
# => [#<Pet id: 1, name: "Fancy-Fancy", person_id: 1>]

person.pets.delete(2, 3)
# => [
#       #<Pet id: 2, name: "Spook", person_id: 1>,
#       #<Pet id: 3, name: "Choo-Choo", person_id: 1>
#    ]
delete_all (निर्भर = शून्य) स्रोत दिखाएं
# File activerecord/lib/active_record/associations/collection_proxy.rb, line 502
def delete_all(dependent = nil)
  @association.delete_all(dependent)
end

:dependent विकल्प द्वारा निर्दिष्ट रणनीति के अनुसार संग्रह से सभी रिकॉर्ड हटाता है। यदि कोई :dependent विकल्प नहीं दिया गया है, तो यह डिफ़ॉल्ट रणनीति का पालन करेगा।

:delete_all लिए :delete_all संघों के has_many :through से, डिफ़ॉल्ट विलोपन रणनीति है :delete_all

has_many संघों के लिए, डिफ़ॉल्ट विलोपन रणनीति है :nullify । यह विदेशी कुंजियों को NULL को सेट करता NULL

class Person < ActiveRecord::Base
  has_many :pets # dependent: :nullify option by default
end

person.pets.size # => 3
person.pets
# => [
#       #<Pet id: 1, name: "Fancy-Fancy", person_id: 1>,
#       #<Pet id: 2, name: "Spook", person_id: 1>,
#       #<Pet id: 3, name: "Choo-Choo", person_id: 1>
#    ]

person.pets.delete_all
# => [
#       #<Pet id: 1, name: "Fancy-Fancy", person_id: 1>,
#       #<Pet id: 2, name: "Spook", person_id: 1>,
#       #<Pet id: 3, name: "Choo-Choo", person_id: 1>
#    ]

person.pets.size # => 0
person.pets      # => []

Pet.find(1, 2, 3)
# => [
#       #<Pet id: 1, name: "Fancy-Fancy", person_id: nil>,
#       #<Pet id: 2, name: "Spook", person_id: nil>,
#       #<Pet id: 3, name: "Choo-Choo", person_id: nil>
#    ]

यदि :dependent विकल्प :destroy करने के लिए सेट किया गया है :destroy तो दोनों has_many और has_many :through निर्भरता डिफ़ॉल्ट के has_many :through से :delete_all रणनीति के :destroy । रिकॉर्ड त्वरित नहीं हैं और कॉलबैक को निकाल नहीं दिया जाएगा।

class Person < ActiveRecord::Base
  has_many :pets, dependent: :destroy
end

person.pets.size # => 3
person.pets
# => [
#       #<Pet id: 1, name: "Fancy-Fancy", person_id: 1>,
#       #<Pet id: 2, name: "Spook", person_id: 1>,
#       #<Pet id: 3, name: "Choo-Choo", person_id: 1>
#    ]

person.pets.delete_all

Pet.find(1, 2, 3)
# => ActiveRecord::RecordNotFound: Couldn't find all Pets with 'id': (1, 2, 3)

यदि यह इसके लिए सेट है :delete_all , सभी ऑब्जेक्ट्स को उनके destroy विधि को कॉल किए बिना हटा दिया जाता है

class Person < ActiveRecord::Base
  has_many :pets, dependent: :delete_all
end

person.pets.size # => 3
person.pets
# => [
#       #<Pet id: 1, name: "Fancy-Fancy", person_id: 1>,
#       #<Pet id: 2, name: "Spook", person_id: 1>,
#       #<Pet id: 3, name: "Choo-Choo", person_id: 1>
#    ]

person.pets.delete_all

Pet.find(1, 2, 3)
# => ActiveRecord::RecordNotFound: Couldn't find all Pets with 'id': (1, 2, 3)
नष्ट (* रिकॉर्ड) स्रोत दिखाएँ
# File activerecord/lib/active_record/associations/collection_proxy.rb, line 720
def destroy(*records)
  @association.destroy(*records)
end

आपूर्ति records गए records नष्ट कर देता है और उन्हें संग्रह से निकाल देता है। यह विधि हमेशा डेटाबेस से रिकॉर्ड को हटा देगी :dependent विकल्प। हटाए गए रिकॉर्ड के साथ एक सरणी देता है।

class Person < ActiveRecord::Base
  has_many :pets
end

person.pets.size # => 3
person.pets
# => [
#       #<Pet id: 1, name: "Fancy-Fancy", person_id: 1>,
#       #<Pet id: 2, name: "Spook", person_id: 1>,
#       #<Pet id: 3, name: "Choo-Choo", person_id: 1>
#    ]

person.pets.destroy(Pet.find(1))
# => [#<Pet id: 1, name: "Fancy-Fancy", person_id: 1>]

person.pets.size # => 2
person.pets
# => [
#       #<Pet id: 2, name: "Spook", person_id: 1>,
#       #<Pet id: 3, name: "Choo-Choo", person_id: 1>
#    ]

person.pets.destroy(Pet.find(2), Pet.find(3))
# => [
#       #<Pet id: 2, name: "Spook", person_id: 1>,
#       #<Pet id: 3, name: "Choo-Choo", person_id: 1>
#    ]

person.pets.size  # => 0
person.pets       # => []

Pet.find(1, 2, 3) # => ActiveRecord::RecordNotFound: Couldn't find all Pets with 'id': (1, 2, 3)

आप Integer या String मानों को पारित कर सकते हैं, यह id जवाबों को रिकॉर्ड करता है और फिर उन्हें डेटाबेस से हटा देता है।

person.pets.size # => 3
person.pets
# => [
#       #<Pet id: 4, name: "Benny", person_id: 1>,
#       #<Pet id: 5, name: "Brain", person_id: 1>,
#       #<Pet id: 6, name: "Boss",  person_id: 1>
#    ]

person.pets.destroy("4")
# => #<Pet id: 4, name: "Benny", person_id: 1>

person.pets.size # => 2
person.pets
# => [
#       #<Pet id: 5, name: "Brain", person_id: 1>,
#       #<Pet id: 6, name: "Boss",  person_id: 1>
#    ]

person.pets.destroy(5, 6)
# => [
#       #<Pet id: 5, name: "Brain", person_id: 1>,
#       #<Pet id: 6, name: "Boss",  person_id: 1>
#    ]

person.pets.size  # => 0
person.pets       # => []

Pet.find(4, 5, 6) # => ActiveRecord::RecordNotFound: Couldn't find all Pets with 'id': (4, 5, 6)
# File activerecord/lib/active_record/associations/collection_proxy.rb, line 529
def destroy_all
  @association.destroy_all
end

:dependent विकल्प को अनदेखा करते हुए डेटाबेस से सीधे संग्रह के रिकॉर्ड को हटाता है। रिकॉर्ड्स को before_remove किया जाता है और यह before_remove , after_remove , before_destroy और after_destroy

class Person < ActiveRecord::Base
  has_many :pets
end

person.pets.size # => 3
person.pets
# => [
#       #<Pet id: 1, name: "Fancy-Fancy", person_id: 1>,
#       #<Pet id: 2, name: "Spook", person_id: 1>,
#       #<Pet id: 3, name: "Choo-Choo", person_id: 1>
#    ]

person.pets.destroy_all

person.pets.size # => 0
person.pets      # => []

Pet.find(1) # => Couldn't find Pet with id=1
अलग (मान = सत्य) स्रोत दिखाएँ
# File activerecord/lib/active_record/associations/collection_proxy.rb, line 751
      

निर्दिष्ट करता है कि रिकॉर्ड अद्वितीय होना चाहिए या नहीं।

class Person < ActiveRecord::Base
  has_many :pets
end

person.pets.select(:name)
# => [
#      #<Pet name: "Fancy-Fancy">,
#      #<Pet name: "Fancy-Fancy">
#    ]

person.pets.select(:name).distinct
# => [#<Pet name: "Fancy-Fancy">]

person.pets.select(:name).distinct.distinct(false)
# => [
#      #<Pet name: "Fancy-Fancy">,
#      #<Pet name: "Fancy-Fancy">
#    ]
# File activerecord/lib/active_record/associations/collection_proxy.rb, line 859
def empty?
  @association.empty?
end

अगर संग्रह खाली true तो true है। यदि संग्रह लोड किया गया है तो यह collection.size.zero? बराबर है collection.size.zero? । यदि संग्रह लोड नहीं किया गया है, तो यह !collection.exists? बराबर है !collection.exists? । यदि संग्रह पहले से लोड नहीं किया गया है और आप वैसे भी रिकॉर्ड प्राप्त करने जा रहे हैं तो collection.length.zero? जाँच करना बेहतर है collection.length.zero?

class Person < ActiveRecord::Base
  has_many :pets
end

person.pets.count  # => 1
person.pets.empty? # => false

person.pets.delete_all

person.pets.count  # => 0
person.pets.empty? # => true
पाँचवाँ () स्रोत दिखाएँ
# File activerecord/lib/active_record/associations/collection_proxy.rb, line 208
      

केवल पाँचवें रिकॉर्ड को छोड़कर first समान।

ढूँढें (* args) स्रोत दिखाएँ
# File activerecord/lib/active_record/associations/collection_proxy.rb, line 138
def find(*args)
  return super if block_given?
  @association.find(*args)
end

id जवाब में संग्रह में एक वस्तु ढूँढता है। ActiveRecord :: Base.find के समान नियमों का उपयोग करता है। ActiveRecord::RecordNotFound ऑब्जेक्ट नहीं मिल सकता है तो ActiveRecord::RecordNotFound त्रुटि देता है।

class Person < ActiveRecord::Base
  has_many :pets
end

person.pets
# => [
#       #<Pet id: 1, name: "Fancy-Fancy", person_id: 1>,
#       #<Pet id: 2, name: "Spook", person_id: 1>,
#       #<Pet id: 3, name: "Choo-Choo", person_id: 1>
#    ]

person.pets.find(1) # => #<Pet id: 1, name: "Fancy-Fancy", person_id: 1>
person.pets.find(4) # => ActiveRecord::RecordNotFound: Couldn't find Pet with 'id'=4

person.pets.find(2) { |pet| pet.name.downcase! }
# => #<Pet id: 2, name: "fancy-fancy", person_id: 1>

person.pets.find(2, 3)
# => [
#       #<Pet id: 2, name: "Spook", person_id: 1>,
#       #<Pet id: 3, name: "Choo-Choo", person_id: 1>
#    ]
सुपरक्लास विधि कहता है
पहला (सीमा = शून्य) स्रोत दिखाएं
# File activerecord/lib/active_record/associations/collection_proxy.rb, line 176
      

संग्रह से पहला रिकॉर्ड, या पहला n रिकॉर्ड लौटाता है। यदि संग्रह खाली है, तो पहला फ़ॉर्म nil , और दूसरा फ़ॉर्म खाली सरणी देता है।

class Person < ActiveRecord::Base
  has_many :pets
end

person.pets
# => [
#       #<Pet id: 1, name: "Fancy-Fancy", person_id: 1>,
#       #<Pet id: 2, name: "Spook", person_id: 1>,
#       #<Pet id: 3, name: "Choo-Choo", person_id: 1>
#    ]

person.pets.first # => #<Pet id: 1, name: "Fancy-Fancy", person_id: 1>

person.pets.first(2)
# => [
#      #<Pet id: 1, name: "Fancy-Fancy", person_id: 1>,
#      #<Pet id: 2, name: "Spook", person_id: 1>
#    ]

another_person_without.pets          # => []
another_person_without.pets.first    # => nil
another_person_without.pets.first(3) # => []
चालीस_ट्वो () स्रोत दिखाएं
# File activerecord/lib/active_record/associations/collection_proxy.rb, line 217
      

केवल first चालीस सेकंड रिकॉर्ड रिटर्न के अलावा के रूप में ही। इसे "रेडिट" एक्सेस करने के रूप में भी जाना जाता है।

# File activerecord/lib/active_record/associations/collection_proxy.rb, line 200
      

केवल चौथे रिकॉर्ड को छोड़कर first समान।

शामिल? (रिकॉर्ड) दिखाएँ स्रोत
# File activerecord/lib/active_record/associations/collection_proxy.rb, line 950
def include?(record)
  [email protected]?(record)
end

अगर संग्रह में दिए गए record मौजूद हैं, तो true है।

class Person < ActiveRecord::Base
  has_many :pets
end

person.pets # => [#<Pet id: 20, name: "Snoop">]

person.pets.include?(Pet.find(20)) # => true
person.pets.include?(Pet.find(21)) # => false
अंतिम (सीमा = शून्य) स्रोत दिखाएं
# File activerecord/lib/active_record/associations/collection_proxy.rb, line 259
def last(limit = nil)
  load_target if find_from_target?
  super
end

संग्रह से अंतिम रिकॉर्ड, या अंतिम n रिकॉर्ड लौटाता है। यदि संग्रह खाली है, तो पहला फ़ॉर्म nil , और दूसरा फ़ॉर्म खाली सरणी देता है।

class Person < ActiveRecord::Base
  has_many :pets
end

person.pets
# => [
#       #<Pet id: 1, name: "Fancy-Fancy", person_id: 1>,
#       #<Pet id: 2, name: "Spook", person_id: 1>,
#       #<Pet id: 3, name: "Choo-Choo", person_id: 1>
#    ]

person.pets.last # => #<Pet id: 3, name: "Choo-Choo", person_id: 1>

person.pets.last(2)
# => [
#      #<Pet id: 2, name: "Spook", person_id: 1>,
#      #<Pet id: 3, name: "Choo-Choo", person_id: 1>
#    ]

another_person_without.pets         # => []
another_person_without.pets.last    # => nil
another_person_without.pets.last(3) # => []
सुपरक्लास विधि कहता है
# File activerecord/lib/active_record/associations/collection_proxy.rb, line 841
      

लक्ष्य पर संग्रह कॉलिंग का size लौटाता है। यदि संग्रह पहले ही लोड हो चुका है, तो length और size बराबर हैं। यदि नहीं और आपको किसी भी तरह से रिकॉर्ड की आवश्यकता होगी, तो यह विधि एक कम क्वेरी लेगी। अन्यथा size अधिक कुशल है।

class Person < ActiveRecord::Base
  has_many :pets
end

person.pets.length # => 3
# executes something like SELECT "pets".* FROM "pets" WHERE "pets"."person_id" = 1

# Because the collection is loaded, you can
# call the collection with no additional queries:
person.pets
# => [
#       #<Pet id: 1, name: "Fancy-Fancy", person_id: 1>,
#       #<Pet id: 2, name: "Spook", person_id: 1>,
#       #<Pet id: 3, name: "Choo-Choo", person_id: 1>
#    ]
# File activerecord/lib/active_record/associations/collection_proxy.rb, line 45
def load_target
  @association.load_target
end
लदा हुआ? () स्रोत दिखाएं
# File activerecord/lib/active_record/associations/collection_proxy.rb, line 54
def loaded?
  @association.loaded?
end

यदि एसोसिएशन लोड किया गया है, तो true , अन्यथा false

person.pets.loaded? # => false
person.pets
person.pets.loaded? # => true
# File activerecord/lib/active_record/associations/collection_proxy.rb, line 940
      

यदि संग्रह में एक से अधिक रिकॉर्ड हैं, तो यह सही है। collection.size > 1 बराबर। आकार collection.size > 1

class Person < ActiveRecord::Base
  has_many :pets
end

person.pets.count # => 1
person.pets.many? # => false

person.pets << Pet.new(name: 'Snoopy')
person.pets.count # => 2
person.pets.many? # => true

आप मानदंड को परिभाषित करने के लिए एक block भी पास कर सकते हैं। व्यवहार समान है, यह सही है अगर मापदंड के आधार पर संग्रह एक से अधिक रिकॉर्ड है।

person.pets
# => [
#      #<Pet name: "Gorby", group: "cats">,
#      #<Pet name: "Puff", group: "cats">,
#      #<Pet name: "Snoop", group: "dogs">
#    ]

person.pets.many? do |pet|
  pet.group == 'dogs'
end
# => false

person.pets.many? do |pet|
  pet.group == 'cats'
end
# => true
नया (विशेषताएँ = {}, और ब्लॉक)
के लिए उपनाम: build
# File activerecord/lib/active_record/associations/collection_proxy.rb, line 756
def pluck(*column_names)
  null_scope? ? scope.pluck(*column_names) : super
end
सुपरक्लास विधि कहता है
# File activerecord/lib/active_record/associations/collection_proxy.rb, line 1061
def prepend(*args)
  raise NoMethodError, "prepend on association is not defined. Please use <<, push or append"
end
प्रॉक्सी_बेसिटी () स्रोत दिखाएं
# File activerecord/lib/active_record/associations/collection_proxy.rb, line 954
def proxy_association
  @association
end
धक्का (* रिकॉर्ड)
अन्य के लिए उपनाम: <<
पुनः लोड () दिखाएँ स्रोत
# File activerecord/lib/active_record/associations/collection_proxy.rb, line 1090
def reload
  proxy_association.reload
  reset_scope
end

डेटाबेस से संग्रह पुनः लोड करें। self लौटाता है।

class Person < ActiveRecord::Base
  has_many :pets
end

person.pets # fetches pets from the database
# => [#<Pet id: 1, name: "Snoop", group: "dogs", person_id: 1>]

person.pets # uses the pets cache
# => [#<Pet id: 1, name: "Snoop", group: "dogs", person_id: 1>]

person.pets.reload # fetches pets from the database
# => [#<Pet id: 1, name: "Snoop", group: "dogs", person_id: 1>]
बदलें (other_array) स्रोत दिखाएं
# File activerecord/lib/active_record/associations/collection_proxy.rb, line 419
def replace(other_array)
  @association.replace(other_array)
end

इस संग्रह को other_array साथ other_array । यह एक बदलाव करेगा और केवल रिकॉर्ड को हटा / जोड़ देगा।

class Person < ActiveRecord::Base
  has_many :pets
end

person.pets
# => [#<Pet id: 1, name: "Gorby", group: "cats", person_id: 1>]

other_pets = [Pet.new(name: 'Puff', group: 'celebrities']

person.pets.replace(other_pets)

person.pets
# => [#<Pet id: 2, name: "Puff", group: "celebrities", person_id: 1>]

यदि आपूर्ति की गई सरणी में गलत एसोसिएशन प्रकार है, तो यह ActiveRecord::AssociationTypeMismatch त्रुटि उठाता है:

person.pets.replace(["doo", "ggie", "gaga"])
# => ActiveRecord::AssociationTypeMismatch: Pet expected, got String
# File activerecord/lib/active_record/associations/collection_proxy.rb, line 1111
def reset
  proxy_association.reset
  proxy_association.reset_scope
  reset_scope
end

एसोसिएशन को उतारता है। self लौटाता है।

class Person < ActiveRecord::Base
  has_many :pets
end

person.pets # fetches pets from the database
# => [#<Pet id: 1, name: "Snoop", group: "dogs", person_id: 1>]

person.pets # uses the pets cache
# => [#<Pet id: 1, name: "Snoop", group: "dogs", person_id: 1>]

person.pets.reset # clears the pets cache

person.pets  # fetches pets from the database
# => [#<Pet id: 1, name: "Snoop", group: "dogs", person_id: 1>]
गुंजाइश () स्रोत दिखाएँ
# File activerecord/lib/active_record/associations/collection_proxy.rb, line 959
def scope
  @scope ||= @association.scope
end

इस एसोसिएशन में रिकॉर्ड्स के लिए एक Relation ऑब्जेक्ट लौटाता है

# File activerecord/lib/active_record/associations/collection_proxy.rb, line 184
      

केवल दूसरे रिकॉर्ड को छोड़कर first समान।

# File activerecord/lib/active_record/associations/collection_proxy.rb, line 233
      

केवल first -से-अंतिम रिकॉर्ड को छोड़कर first समान।

स्रोत का चयन करें (* फ़ील्ड, और ब्लॉक)
# File activerecord/lib/active_record/associations/collection_proxy.rb, line 112
      

दो तरह से काम करता है।

पहला: परिणाम सेट से चयनित होने के लिए फ़ील्ड का एक सबसेट निर्दिष्ट करें।

class Person < ActiveRecord::Base
  has_many :pets
end

person.pets
# => [
#       #<Pet id: 1, name: "Fancy-Fancy", person_id: 1>,
#       #<Pet id: 2, name: "Spook", person_id: 1>,
#       #<Pet id: 3, name: "Choo-Choo", person_id: 1>
#    ]

person.pets.select(:name)
# => [
#      #<Pet id: nil, name: "Fancy-Fancy">,
#      #<Pet id: nil, name: "Spook">,
#      #<Pet id: nil, name: "Choo-Choo">
#    ]

person.pets.select(:id, :name)
# => [
#      #<Pet id: 1, name: "Fancy-Fancy">,
#      #<Pet id: 2, name: "Spook">,
#      #<Pet id: 3, name: "Choo-Choo">
#    ]

सावधान रहें क्योंकि इसका मतलब यह भी है कि आप किसी मॉडल ऑब्जेक्ट को केवल उन फ़ील्ड्स से आरंभ कर रहे हैं जिन्हें आपने चुना है। यदि आप id को छोड़कर किसी ऐसे क्षेत्र तक पहुँचने का प्रयास करते हैं जो आपके द्वारा प्राप्त प्रारंभिक रिकॉर्ड में नहीं है:

person.pets.select(:name).first.person_id
# => ActiveModel::MissingAttributeError: missing attribute: person_id

दूसरा: आप किसी ब्लॉक को पास कर सकते हैं, इसलिए इसे Array # select की तरह ही इस्तेमाल किया जा सकता है। यह कार्यक्षेत्र के लिए डेटाबेस से ऑब्जेक्ट्स की एक सरणी बनाता है, उन्हें एक एरे में परिवर्तित करता है और एरे # चयन का उपयोग करके उनके माध्यम से पुनरावृति करता है।

person.pets.select { |pet| pet.name =~ /oo/ }
# => [
#      #<Pet id: 2, name: "Spook", person_id: 1>,
#      #<Pet id: 3, name: "Choo-Choo", person_id: 1>
#    ]
# File activerecord/lib/active_record/associations/collection_proxy.rb, line 810
def size
  @association.size
end

संग्रह का आकार लौटाता है। यदि संग्रह लोड नहीं किया गया है, तो यह SELECT COUNT(*) क्वेरी निष्पादित करता है। इसके अलावा यह collection.size कहता है। आकार।

यदि संग्रह पहले से लोड किया गया है तो size और length बराबर है। यदि नहीं और आप को रिकॉर्ड की जरूरत है तो वैसे भी length कम होगी। अन्यथा size अधिक कुशल है।

class Person < ActiveRecord::Base
  has_many :pets
end

person.pets.size # => 3
# executes something like SELECT COUNT(*) FROM "pets" WHERE "pets"."person_id" = 1

person.pets # This will execute a SELECT * FROM query
# => [
#       #<Pet id: 1, name: "Fancy-Fancy", person_id: 1>,
#       #<Pet id: 2, name: "Spook", person_id: 1>,
#       #<Pet id: 3, name: "Choo-Choo", person_id: 1>
#    ]

person.pets.size # => 3
# Because the collection is already loaded, this will behave like
# collection.size and no SQL count query is executed.
# File activerecord/lib/active_record/associations/collection_proxy.rb, line 289
def take(limit = nil)
  load_target if find_from_target?
  super
end

ActiveRecord::Base.take के समान नियमों का उपयोग करके संग्रह से एक रिकॉर्ड (या एन रिकॉर्ड किया जाता है यदि एक पैरामीटर की आपूर्ति की जाती है)।

class Person < ActiveRecord::Base
  has_many :pets
end

person.pets
# => [
#       #<Pet id: 1, name: "Fancy-Fancy", person_id: 1>,
#       #<Pet id: 2, name: "Spook", person_id: 1>,
#       #<Pet id: 3, name: "Choo-Choo", person_id: 1>
#    ]

person.pets.take # => #<Pet id: 1, name: "Fancy-Fancy", person_id: 1>

person.pets.take(2)
# => [
#      #<Pet id: 1, name: "Fancy-Fancy", person_id: 1>,
#      #<Pet id: 2, name: "Spook", person_id: 1>
#    ]

another_person_without.pets         # => []
another_person_without.pets.take    # => nil
another_person_without.pets.take(2) # => []
सुपरक्लास विधि कहता है
# File activerecord/lib/active_record/associations/collection_proxy.rb, line 41
def target
  @association.target
end
# File activerecord/lib/active_record/associations/collection_proxy.rb, line 192
      

केवल तीसरे रिकॉर्ड को छोड़कर first समान।

# File activerecord/lib/active_record/associations/collection_proxy.rb, line 225
      

केवल तीसरे-से-अंतिम रिकॉर्ड को छोड़कर first समान।