मनमानी गुणों के साथ SPARQL संपत्ति पथ प्रश्न

Question

SPARQL property path मनमानी लंबाई के प्रश्नों को विशिष्ट गुणों का उपयोग करने की आवश्यकता होती है। मैं संसाधन से शुरू होने और किसी अन्य संसाधन में समाप्त होने वाले किसी भी पथ से पूछताछ करना चाहता हूं। उदाहरण के लिए:

SELECT ?p 
WHERE { :startNode ?p* :endNode } 

जहां ?p* एक पथ निर्दिष्ट करता है। क्या इसे करने का कोई तरीका है?

Answer 1

आप सही हैं कि आप संपत्ति पथ अभिव्यक्तियों में चर का उपयोग नहीं कर सकते हैं। ऐसी कुछ चीजें हैं जिन्हें आप कर सकते हैं, हालांकि, यह आपकी मदद कर सकता है।

कि क्या एक रास्ता मौजूद है

आप इसे और उसका निषेध के अलगाव लेने के द्वारा किसी वाइल्डकार्ड का उपयोग कर सकते हैं, तो आप एक सरल प्रश्न है कि जाँच करता है वहाँ एक रास्ता जोड़ने है कि क्या कर सकते हैं जाँच करने के लिए एक वाइल्डकार्ड दो संसाधनों:

<source> (<>|!<>)* <target> 

आप एक : उपसर्ग परिभाषित किया है, कि, भी कम हो सकता है क्योंकि : एक वैध IRI है:

<source> (:|!:)* <target> 

अगर वहाँ दो नोड्स के बीच एक पथ (या एकाधिक पथ) है, तो आप इसे ?p से जुड़े हुए वाइल्डकार्ड रास्तों का उपयोग कर अलग हो सकता है, और इसलिए सभी ?p रों उस रास्ते पर कर रहे हैं:

<source> (:|!:)* ?x . 
?x ?p ?y . 
?y (:|!:)* <target> . 

आप, मुझे लगता है, कि भी कम कर सकते हैं खाली बजाय नोड्स ?x और ?y का उपयोग करके:

<source> (:|!:)* [ ?p [ (:|!:)* <target> ] ] 

(यही कारण है कि काम नहीं कर सकते, तू gh। मुझे याद है कि व्याकरण वास्तव में रिक्त नोड्स के भीतर कुछ स्थानों में संपत्ति पथों को अस्वीकार करता है। मुझे यकीन है कि नहीं कर रहा हूँ।)

एक एकल पथ के लिए, इस मामले में, गुण और पदों मिलता तो group_concat

अब, वहाँ दो संसाधनों के बीच सिर्फ एक रास्ता है, आप भी है कि साथ गुण प्राप्त कर सकते हैं पथ, उनके पदों के साथ। आप उन पदों के अनुसार आदेश दे सकते हैं, और उसके बाद गुणों को एक स्ट्रिंग में क्रमबद्ध करने के लिए समूह का उपयोग कर सकते हैं। उदाहरण के साथ देखना शायद सबसे आसान है। मान लीजिए आप निम्न डेटा जो :a:d करने से एक भी मार्ग है मिल गया है:

@prefix : <urn:ex:> . 

:a :p1 :b . 
:b :p2 :c . 
:c :p3 :d . 

तो फिर तुम पथ और अपनी स्थिति की प्रत्येक प्रॉपर्टी प्राप्त करने के लिए इस तरह की एक क्वेरी का उपयोग कर सकते हैं। (यह केवल वहाँ एक भी मार्ग है, हालांकि अगर काम करता है। यह कैसे काम करता के बारे में अधिक एक बिट के लिए Is it possible to get the position of an element in an RDF Collection in SPARQL? को मेरा उत्तर देखें।)

prefix : <urn:ex:> 

select ?p (count(?mid) as ?pos) where { 
    :a (:|!:)* ?mid . 
    ?mid (:|!:)* ?x . 
    ?x ?p ?y. 
    ?y (:|!:)* :d 
} 
group by ?x ?p ?y 

------------- 
| p | pos | 
============= 
| :p2 | 2 | 
| :p1 | 1 | 
| :p3 | 3 | 
------------- 

अब, अगर आप ?pos द्वारा उन परिणामों के आदेश और रैप कि किसी अन्य प्रश्न में, तो आप गुणों की एक स्ट्रिंग प्राप्त करने के लिए पर group_concat का उपयोग कर सकते हैं। (संरक्षित आदेश की गारंटी नहीं है, लेकिन यह बहुत आम व्यवहार है।और कैसे इस तकनीक काम करता है का एक और उदाहरण के लिए obtain the matrix in protege को मेरा उत्तर देखें, क्यों यह गारंटी नहीं है के बारे में चर्चा के लिए my answer to Ordering in GROUP_CONCAT in SPARQL 1.1।)

prefix : <urn:ex:> 

select (group_concat(concat('<',str(?p),'>');separator=' ') as ?path) { 
    select ?p (count(?mid) as ?pos) where { 
    :a (:|!:)* ?mid . 
    ?mid (:|!:)* ?x . 
    ?x ?p ?y. 
    ?y (:|!:)* :d 
    } 
    group by ?x ?p ?y 
    order by ?pos 
} 

----------------------------------------- 
| path         | 
========================================= 
| "<urn:ex:p1> <urn:ex:p2> <urn:ex:p3>" | 
-----------------------------------------