नोड्स के बीच पथ की लंबाई की गणना करें?

Question

मैं दो नोड्स के बीच पथ की लंबाई कैसे प्राप्त कर सकता हूं? उदाहरण के लिए, एक संगठनात्मक पदानुक्रम दिया गया है, मैं कैसे निर्धारित कर सकता हूं कि माता-पिता और वंशवादी संगठन कितने दूर हैं? निम्न परिदृश्यों पर विचार करें:

1. OrgA -hasSubOrganization-> OrgB, OrgC

   यह बहुत साधारण मामले में जहां मैं एक इकाई के सभी तत्काल उप-संगठन प्राप्त करना चाहते है। इसलिए पथ लंबाई 1.

2. OrgA -> OrgB -> OrgC

   या सामान्य मामला है

   OrgA -> OrgB - - - - - - - - OrgZ 
   

मैं रिकर्सिवली ग्राफ नीचे पार और प्रत्येक संगठन hasSubOrganization के माध्यम से एक और संगठन से संबंधित लगाना चाहते हैं संपत्ति। सभी उप-संगठन पुनरावर्ती मैं property paths, उदाहरण के लिए, + ऑपरेटर का उपयोग कर सकते हैं पाने के लिए:

OrgA hasSubOrganization+ ?subOrg 

यह मैं सभी उप-संगठन सही पत्र-गांठ करने के लिए नीचे दे देंगे। लेकिन मेरा अंतिम लक्ष्य संगठन पदानुक्रम का निर्माण करना है, लेकिन "नोड्स/चरणों/स्तरों/हॉपों की संख्या उप-संगठनात्मकता" के बारे में जानकारी खो गई है। इसका मतलब है कि मैं एक विज़ुअलाइजेशन के लिए संगठन संरचना को फिर से नहीं बना सकता।

उपनगरीकरण के नाम के अलावा मैं "नोड्स दूर की संख्या" जानकारी कैप्चर कैसे कर सकता हूं?

Answer 1

यह एक RDF सूची SPARQL का उपयोग करने में एक तत्व है कि में वर्णित की स्थिति की गणना करने के लिए प्रयोग किया जाता उसी तकनीक पर आधारित है के लिए: Is it possible to get the position of an element in an RDF Collection in SPARQL?

आप इस तरह डेटा है, तो:

@prefix : <http://example.org> . 

:orgA :hasSuborganization :orgB, :orgC, :orgD. 
:orgB :hasSuborganization :orgE, :orgF. 
:orgE :hasSuborganization :orgG. 
:orgG :hasSuborganization :orgH. 

जो इस तरह एक पदानुक्रम में बताता है:

तो आप इस तरह एक प्रश्न का उपयोग कर सकते हैं:

prefix : <http://example.org> 

select ?super ?sub (count(?mid) as ?distance) { 
    ?super :hasSuborganization* ?mid . 
    ?mid :hasSuborganization+ ?sub . 
} 
group by ?super ?sub 
order by ?super ?sub 

इस तरह के परिणाम प्राप्त करने के:

$ sparql --query query.rq --data subs.n3 
---------------------------- 
| super | sub | distance | 
============================ 
| :orgA | :orgB | 1  | 
| :orgA | :orgC | 1  | 
| :orgA | :orgD | 1  | 
| :orgA | :orgE | 2  | 
| :orgA | :orgF | 2  | 
| :orgA | :orgG | 3  | 
| :orgA | :orgH | 4  | 
| :orgB | :orgE | 1  | 
| :orgB | :orgF | 1  | 
| :orgB | :orgG | 2  | 
| :orgB | :orgH | 3  | 
| :orgE | :orgG | 1  | 
| :orgE | :orgH | 2  | 
| :orgG | :orgH | 1  | 
---------------------------- 

चाल यहाँ पहचान करने के लिए कि X से Y तक किसी भी पथ एक के रूप में देखा जा सकता है (संभावित रूप से खाली) एक्स से कुछ इंटरमीडिएट नोड जेड (nonempty का मतलब है कि आप एक्स के रूप में एक्स चुन सकते हैं) जेड से वाई तक एक (खाली) पथ के साथ जोड़ा गया है। जेड लेने के संभावित तरीकों की संख्या पथ की लंबाई इंगित करती है।

Answer 2

आप प्रोपरी पथ का उपयोग करके ऐसा नहीं कर सकते हैं क्योंकि कार्यकारी समूह ने विशेष रूप से यह जानकारी उपलब्ध नहीं कराई है क्योंकि यह कार्यान्वयन को और अधिक जटिल बनाता है।

यदि आप पदानुक्रम उत्पन्न करना चाहते हैं तो यह शायद SPARQL क्वेरीज़ की पूरी श्रृंखला बनाने के लिए उतना ही कुशल होगा, जहां प्रत्येक क्वेरी पदानुक्रम के एक पत्ते को फैलाती है और यदि आपका लक्ष्य केवल कल्पना करने के लिए है तो संपत्ति पथ का उपयोग न करें पदानुक्रम

जेना Ontology API का उपयोग करके अन्य दृष्टिकोण हो सकते हैं - मैं उनकी मेलिंग सूची jena-users@incubator.apache पर पूछने की सलाह दूंगा।org अधिक विशेषज्ञ की सहायता