रेल पॉलीमोर्फिक है_मनी

Question

रेल पर रूबी का उपयोग करके, मैं एक पॉलिमॉर्फिक has_many रिश्ते को कैसे प्राप्त कर सकता हूं जहां मालिक हमेशा ज्ञात होता है लेकिन एसोसिएशन में आइटम कुछ पॉलिमॉर्फिक (लेकिन समरूप) प्रकार का होता है, जो कि एक कॉलम द्वारा निर्दिष्ट होता है मालिक? उदाहरण के लिए, Producer कक्षा has_many उत्पादों का मानना ​​है लेकिन निर्माता उदाहरणों में वास्तव में कई साइकिलें, या पोप्सिकल्स या शॉलेस हो सकती हैं। मैं आसानी से प्रत्येक उत्पाद वर्ग (साइकिल, पोप्सिकल, आदि) के पास belongs_to निर्माता के साथ संबंध रख सकता हूं लेकिन एक निर्माता उदाहरण दिया गया है कि यदि वे अलग-अलग प्रकार के होते हैं (प्रति उत्पादक उदाहरण) तो मैं उत्पादों का संग्रह कैसे प्राप्त कर सकता हूं?

रेल पॉलिमॉर्फिक संघों उत्पादकों को कई उत्पादों से संबंधित होने की अनुमति देता है, लेकिन मुझे रिश्ते को अन्य तरीकों से होने की आवश्यकता है।

class Bicycle < ActiveRecord::Base 
    belongs_to :producer 
end 

class Popsicle < ActiveRecord::Base 
    belongs_to :producer 
end 

class Producer < ActiveRecord::Base 
    has_many :products, :polymorphic_column => :type # last part is made-up... 
end 

तो मेरी निर्माता तालिका पहले से ही एक "प्रकार" कॉलम जो मेरे जैसे कुछ करने जाने के लिए कुछ उत्पाद वर्ग से मेल खाती है (उदाहरण के लिए साइकिल, Popsicle, आदि), लेकिन मैं रेल कैसे प्राप्त कर सकते हैं:

उदाहरण के लिए

>> bike_producer.products 
#=> [Bicycle@123, Bicycle@456, ...] 
>> popsicle_producer.products 
#=> [Popsicle@321, Popsicle@654, ...] 

क्षमा करें अगर यह स्पष्ट है या एक सामान्य दोहराव है; मुझे आसानी से इसे प्राप्त करने में आश्चर्यजनक कठिनाई हो रही है।

Answer 1

यहां वर्तमान में उपयोग की जाने वाली वर्कअराउंड है। यह सुविधा विधियों (संग्रह परिचालन) कि आप वास्तविक ActiveRecord :: संघों से प्राप्त कर के किसी भी प्रदान नहीं करता है, लेकिन यह एक दिया निर्माता के लिए उत्पादों की सूची प्राप्त करने का तरीका प्रदान करता है:

class Bicycle < ActiveRecord::Base 
    belongs_to :producer 
end 

class Popsicle < ActiveRecord::Base 
    belongs_to :producer 
end 

class Producer < ActiveRecord::Base 
    PRODUCT_TYPE_MAPPING = { 
    'bicycle' => Bicycle, 
    'popsicle' => Popsicle 
    }.freeze 
    def products 
    klass = PRODUCT_TYPE_MAPPING[self.type] 
    klass ? klass.find_all_by_producer_id(self.id) : [] 
    end 
end 

एक और नकारात्मक पक्ष यह है कि मुझे वर्गों को टाइप करने के लिए प्रकार स्ट्रिंग्स के मैपिंग को बनाए रखना चाहिए, लेकिन यह स्वचालित हो सकता है। हालांकि, यह समाधान मेरे उद्देश्यों के लिए पर्याप्त होगा।

Answer 2

class Note < ActiveRecord::Base 

belongs_to :note_obj, :polymorphic => true 
belongs_to :user 


end 


class Contact < ActiveRecord::Base 

belongs_to :contact_obj, :polymorphic => true 
belongs_to :phone_type 

end 



class CarrierHq < ActiveRecord::Base 


has_many :contacts, :as => :contact_obj 
has_many :notes, :as => :note_obj 


end 

Answer 3

कृपया यह प्रारूप पर

class Bicycle < ActiveRecord::Base 
    belongs_to :bicycle_obj,:polymorphic => true 
end 

class Popsicle < ActiveRecord::Base 
    belongs_to :popsicle_obj , :polymorphic => true 
end 

class Producer < ActiveRecord::Base 
    has_many :bicycles , :as=>:bicycle_obj 
    has_many :popsicle , :as=>:popsicle_obj 
end 

उपयोग इस कोड को ले लो। यदि आपको इसके साथ कोई समस्या है, तो कृपया एक टिप्पणी छोड़ दें।

Answer 4

मुझे लगता है कि पॉलिमॉर्फिक संघों को रेल में दस्तावेज किया गया है। एक एकल टेबल विरासत स्कीमा है, जो सबसे अधिक प्रलेखन प्राप्त करता है, लेकिन यदि आप एकल तालिका विरासत का उपयोग नहीं कर रहे हैं, तो कुछ गायब जानकारी है।

संबंधित_to एसोसिएशन को polymorphic => true विकल्प का उपयोग करके सक्षम किया जा सकता है। हालांकि, जब तक कि आप एकल तालिका विरासत का उपयोग नहीं कर रहे हैं, has_many एसोसिएशन काम नहीं करता है, क्योंकि इसे उन टेबलों के सेट को जानने की आवश्यकता होगी जिनके पास विदेशी कुंजी हो सकती है।

(जो मुझे मिला उससे), मुझे लगता है कि स्वच्छ समाधान बेस क्लास के लिए टेबल और मॉडल रखना है, और बेस टेबल में विदेशी कुंजी है।

create_table "products", :force => true do |table| 
    table.integer "derived_product_id" 
    table.string "derived_product_type" 
    table.integer "producer_id" 
    end 

    class Product < ActiveRecord::Base 
    belongs_to :producer 
    end 

    class Producer < ActiveRecord::Base 
    has_many :products 
    end 

फिर, एक उत्पादन वस्तु, निर्माता के लिए, आप producer.products.derived_products के साथ उत्पादों मिलना चाहिए।

मैंने अभी तक निर्माता_डरिव_प्रॉडक्ट्स के साथ सहयोग करने के लिए has_many के साथ खेला नहीं है, इसलिए मैं इसे काम करने पर टिप्पणी नहीं कर सकता।

Answer 5

आपको उत्पादकों पर नहीं, उत्पादकों पर एसटीआई का उपयोग करना होगा। इस तरह आपके पास प्रत्येक प्रकार के निर्माता के लिए अलग-अलग व्यवहार होते हैं, लेकिन एक producers तालिका में।

(लगभग) कोई बहुलकता बिल्कुल नहीं!

class Product < ActiveRecord::Base 
    # does not have a 'type' column, so there is no STI here, 
    # it is like an abstract superclass. 
    belongs_to :producer 
end 

class Bicycle < Product 
end 

class Popsicle < Product 
end 

class Producer < ActiveRecord::Base 
    # it has a 'type' column so we have STI here!! 
end 

class BicycleProducer < Producer 
    has_many :products, :class_name => "Bicycle", :inverse_of => :producer 
end 

class PopsicleProducer < Producer 
    has_many :products, :class_name => "Popsicle", :inverse_of => :producer 
end