रेल में एक अप्रत्यक्ष ग्राफ मॉडल?

Question

graph databases की भाषा आयात,

1. नोड्स को समझने (हलकों द्वारा प्रतिनिधित्व),
2. किनारों (तीर द्वारा प्रतिनिधित्व), और
3. गुण (मेटाडाटा नोड्स/किनारों के)

ग्राफिक (विकिपीडिया के सौजन्य से) एक directed graph वर्णन करता है।

रेल में undirected graph मॉडल करने का सबसे अच्छा तरीका क्या है?

कहना है कि, एक ग्राफ जहां सभी किनारों पारस्परिक (ऊपर ग्राफिक के रूप में) हैं, और जहां प्रत्येक बढ़त के गुणों दिशा की परवाह किए बिना ही कर रहे हैं (विपरीत ऊपर ग्राफिक के लिए)।

आइए ActiveRecord के माध्यम से एक एसक्यूएल स्टोर का उपयोग कर एक डिफ़ॉल्ट रेल 3 सेटअप मान लें।

एक डबल polymorphic association उपरोक्त छवि द्वारा वर्णित डेटा को मॉडल करने में सक्षम एक निर्देशित ग्राफ तैयार करेगा।

def Edge < ActiveRecord::Base 
    belongs_to :head, polymorphic: true 
    belongs_to :tail, polymorphic: true 
end 

class Node < ActiveRecord::Base 
    has_many :from, as: :head 
    has_many :to, as: :tail 
end 

class Group < ActiveRecord::Base 
    # a Node of Type: Group 
    has_many :from, as: :head 
    has_many :to, as: :tail 
end 

क्या कोई इस मॉडल को व्यस्त रिश्तों को प्रबंधित करने के लिए बढ़ा सकता है, या एक बेहतर मॉडल उपलब्ध है? एक एप्लिकेशन के

---

एक तत्व एक ग्राफ समस्या हो सकती है, लेकिन इसका मतलब यह नहीं एप्लिकेशन समस्या के आसपास केंद्रित है, कि ग्राफ transversals डेटा पर किया जाना चाहिए, और न ही डाटासेट उपलब्ध स्मृति से बड़ा है कि । आप स्टोर कर सकते हैं बढ़त के गुणों सदस्यता मॉडल int के माध्यम से

class Group < ActiveRecord::Base 
    has_many :memberships 
    has_many :persons, :through => :memberships 
end 

class Membership < ActiveRecord::Base 
    belongs_to :group 
    belongs_to :person 
end 

class Person < ActiveRecord::Base 
    has_many :memberships 
    has_many :groups, :through => :memberships 
end 

:

Answer 1

एक अनिर्दिष्ट ग्राफ में, केवल एक चीज आप को पता है की जरूरत है, एक नोड एक और नोड से जुड़ा है या नहीं। और एक दिशा के रूप में ऐसी कोई बात नहीं है।

सरल दृष्टिकोण:

class Node 
    has_many :connected_nodes 
    has_many :nodes, :through => :connected_nodes 
end 

class ConnectedNode 
    belongs_to :node 
    belongs_to :connected_node, :class_name => 'Node' 
end 

यह भी एक निकटता सूची कहा जाता है: प्रत्येक नोड के लिए हम आसानी से सटे (जुड़े) नोड्स की सूची प्राप्त कर सकते हैं।

इस दृष्टिकोण के साथ एक संभावित समस्या: हम कनेक्शन को दो बार स्टोर करते हैं। ए बी से जुड़ा हुआ है और बी

से जुड़ा हुआ है, इसलिए यह केवल एक बार प्रत्येक कनेक्शन को स्टोर करने के लिए बेहतर सामान्य लगता है, और फिर हम वास्तव में आपके मूल प्रस्ताव के करीब आते हैं।

class Connection 
    belongs_to :node1, :class_name => 'Node' 
    belongs_to :node2, :clasS_name => 'Node' 
end 

केवल हम नामकरण के माध्यम से किसी ऑर्डर या दिशा को लागू नहीं करने के लिए अपना सर्वश्रेष्ठ प्रयास करते हैं।

कनेक्टेड नोड्स को पुनर्प्राप्त करना सभी नोड्स node1 या node2 के रूप में जुड़े हुए हैं, इसलिए प्रभावी रूप से किसी भी संभावित दिशा को अनदेखा कर रहे हैं।

इस मामले में आपको एक सत्यापन व्यक्त करने की भी आवश्यकता है कि (नोड 1, नोड 2) के साथ कनेक्शन अद्वितीय है, लेकिन वह (नोड 2, नोड 1) वास्तव में वही है और इसे दो बार सम्मिलित नहीं किया जा सकता है।

मेरी व्यक्तिगत पसंद दूसरी स्कीमा का उपयोग करना होगा, हालांकि पहला समाधान बनाए रखना तेज हो सकता है (यह भी देखें question)।

मुझे भी एक बहुत ही रोचक article मिला जहां लेखक बताते हैं कि डेटाबेस में ग्राफ कैसे संग्रहीत किए जा सकते हैं। बहुत गहरा, लेकिन अधिक डेटाबेस केंद्रित।

उम्मीद है कि इससे मदद मिलती है।

Answer 2

इसके बजाय बहुरूपी संघों का उपयोग करने का,, has_many उपयोग करके देखें।

Answer 3

नियो 4 जे का उपयोग क्यों नहीं करें?

http://wiki.neo4j.org/content/Ruby

https://github.com/andreasronge/neo4j-rails-example

https://github.com/andreasronge/neo4j