टिंकरपॉप में दो नोड्स के बीच सबसे छोटा रास्ता खोजने का सबसे अच्छा तरीका 3.1

Question

मुझे पता है कि यह कई बार पूछा गया था लेकिन मुझे टिंकरपॉप (3.1) के अंतिम संस्करण के बारे में कोई संदर्भ नहीं मिला है, जिसमें कई नए उपयोगी फ़ंक्शंस शामिल हैं जिनका हम उपयोग कर सकते हैं हमारे ट्रैवर्सल

मान लें कि मुझे नोड्स 3 और 4 के बीच सबसे छोटा रास्ता मिलना है। क्या यह ट्रैवर्सल ध्वनि है?

g.V(3).repeat(out()).until(id().is(4).and().simplePath()).path().limit(1) 

यहाँ मैं यह सोचते हैं रहा है कि जब मैं एक BFS खोज पाशन कर रहा हूँ निष्पादित किया जाता है it seems that this was the case with the loop() function के रूप में (इस प्रकार, पहला परिणाम कम से कम पथ है)।

इसके अतिरिक्त, until चरण में पहले बाध्य चर (as चरण का उपयोग करके) शामिल करने का कोई तरीका है? दरअसल, मैं ट्रेवर्सल दौरान दो नोड्स का चयन करने के, कोशिश कर रहा हूँ, और फिर उन्हें बीच कम से कम पथ की खोज, उदाहरण के लिए

g.V().match(
__as('e0').out('Feedbacks').as('e1'), 
__as('e0').repeat(out('Meets')).until(<I reach e1>).path().<get_length>.as('len') 
).select('e0', 'e1', 'len') 

अंत के रूप में पिछले ट्रेवर्सल से देखा जा सकता है, यह करने के लिए स्पष्ट नहीं है मैं कैसे सबसे छोटा रास्ता की लंबाई प्राप्त कर सकते हैं। जबकि

g.V(3).repeat(out()).until(id().is(4).and().simplePath()).path().by(__size()) 

एक त्रुटि देता है तरह

g.V(3).repeat(out()).until(id().is(4).and().simplePath()).path().size() 

कुछ का उपयोग करते हुए परिणाम (पंक्तियों की संख्या लौटे) के आकार देता है,।

यहां ग्राफ है जिसके साथ मैं प्रयोग कर रहा हूं, क्या कोई भी थोड़ा खेलना चाहता है। उस दिन पहली पथ हमेशा कम से कम पथ है,

g.V(3).repeat(out().simplePath()).until(hasId(4)).path().limit(1) 

आपका धारणा सही है:

graph = TinkerGraph.open() 
e0 = graph.addVertex(T.id, 0, label, "User", "name", "e0") 
e1 = graph.addVertex(T.id, 1, label, "User", "name", "e1") 
e2 = graph.addVertex(T.id, 2, label, "User", "name", "e2") 
e3 = graph.addVertex(T.id, 3, label, "User", "name", "e3") 
e4 = graph.addVertex(T.id, 4, label, "User", "name", "e4") 
e0.addEdge("Feedbacks", e2) 
e0.addEdge("Meets", e1) 
e2.addEdge("Feedbacks", e4) 
e2.addEdge("Meets", e4) 
e3.addEdge("Feedbacks", e0) 
e3.addEdge("Meets", e2) 
e4.addEdge("Feedbacks", e0) 
g = graph.traversal() 

Answer 1

आपके कम से कम पथ क्वेरी के लिए एक से थोड़ा कम संस्करण है। संख्यात्मक विश्लेषण पाने के लिए आपको count(local) उपयोग कर सकते हैं:

g.V().as("e0").out("Feedbacks").as("e1").select("e0"). 
     repeat(out("Meets")).until(where(eq("e1"))).path(). 
     map(union(count(local), constant(-2)).sum()).as("len"). 
     select("e0","e1","len") 

मैं से 2 घटाना:

g.V(3).repeat(out().simplePath()).until(hasId(4)).path().count(local) 

अद्यतन

अपने अद्यतन क्वेरी के बारे में, यह एक समस्या का समाधान करना चाहिए कुल पथ की लंबाई, क्योंकि मुझे लगता है कि आप केवल repeat() ब्लॉक से गुजरने वाले पथ की लंबाई में रुचि रखते हैं और शुरुआत में out().select() नहीं होना चाहिए शामिल थे। यदि ऐसा नहीं है, तो आप केवल count(local).as("len"). के साथ तीसरी पंक्ति को प्रतिस्थापित कर सकते हैं।