दिलचस्प पोस्ट
सी + + फ़ंक्शंस में डिफ़ॉल्ट पैरामीटर को पिछले क्यों जोड़ा जाना चाहिए? ElementName बाध्यकारी असफल है सरल VBA कोड मुझे समय त्रुटि चलाने के लिए देता है 91 वस्तु चर या ब्लॉक सेट के साथ नहीं KeyListener, कुंजी कुंजी बनाम कुंजी टाइप C ++ में वर्तमान CPU और RAM उपयोग कैसे प्राप्त करें? स्विफ्ट पर URL से छवि को लोड करना / डाउनलोड करना मैं स्विंगवॉर्कर के साथ एक बफर किए गए परिधीय उपकरण कैसे अनुकरण करता हूं? PHP में क्रेडिट कार्ड को मान्य करने का सबसे अच्छा तरीका क्या है? आरएसए सी # के साथ हस्ताक्षर हस्ताक्षर और सत्यापन सभी मौजूदा फ़ील्ड शामिल करें और दस्तावेज़ में नए फ़ील्ड जोड़ें इंटरनेट एक्सप्लोरर एक्सटेंशन के विकास के साथ कैसे आरंभ करें? डॉकर कन्टेनर की फ़ाइल सिस्टम तलाश रहा है क्या संकलक से यह प्रतिक्रिया मान्य है? जावा में HTML से बचने की अनुशंसित विधि सर्वर में एचटीएक्ससएएस में PHP संस्करण कैसे बदला जाए

संपत्ति पथ में सभी चरणों का पता लगाना

मैं SPARQL के लिए नया हूँ और मैं एक संपत्ति पथ क्वेरी बनाने की कोशिश कर रहा हूं जो मार्ग के साथ प्रत्येक मध्यवर्ती चरण को थूक देगा। अभी तक मेरे पास यह है:

select ?object where { <subjectURI> <isRelatedTo>+ ?object . } 

यह मुझे पथ के दौरान मेरे विषय यूआरआई के सभी संबंधों की एक सूची देता है, चाहे कितना दूर संबंध (मुझे सही करें यदि मैं अभी तक गलत हूं)।

लेकिन, मैं यह देखना चाहता हूं कि संबंधों का आयोजन कैसे किया जाता है। कुछ इस तरह:

 <subjectURI> <isRelatedTo> <object1> <object1> <isRelatedTo> <object2> <object2> <isRelatedTo> <object3> 

और इतने पर … क्या यह संभव है?

Solutions Collecting From Web of "संपत्ति पथ में सभी चरणों का पता लगाना"

नहीं, यह संपत्ति पथ के डिजाइन की एक सीमा है।

पथ या तो अधिक जटिल क्वेरी पैटर्न कॉम्पैक्ट करने के लिए उपयोग किया जा सकता है या उनका उपयोग आपके उदाहरण के अनुसार मनमानी लंबाई वाले पथ के लिए उपयोग करने के लिए किया जा सकता है।

पूर्व को एक ऐसे रूप में परिवर्तित किया जा सकता है जो आपको मध्यवर्ती चरणों जैसे उदाहरण देता है

 SELECT * WHERE { ?s <http://predicate>/<http://predicate> ?o } 

निम्न में परिवर्तित किया जा सकता है:

 SELECT * WHERE { ?s <http://predicate> ?intermediate . ?intermediate <http://predicate> ?o . } 

दुर्भाग्य से, मनमानी लंबाई के रास्ते के लिए भी ऐसा नहीं किया जा सकता। हालांकि यदि आपको पता है कि पथ पर ऊपरी बाध्य क्या है तो आप अपनी क्वेरी को इस तरह से लिख सकते हैं:

 SELECT * WHERE { { ?s <http://predicate> ?step1 . ?step1 <http://predicate> ?o . } UNION { ?s <http://predicate> ?step1 . ?step1 <http://predicate> ?step2 . ?step2 <http://predicate> ?o . } # Add additional UNION for each length of path you want up to your upper bound } 

यद्यपि आप तुरंत देख सकते हैं कि यह चीज़ों को बहुत ही क्रियाशील बनाता है

आपकी सटीक आवश्यकताओं के आधार पर, संपत्ति के रास्ते क्या कर सकते हैं, इसकी कुछ सीमाएँ हैं, लेकिन आप यहां की जरूरतों को प्राप्त करने में सक्षम हो सकते हैं। इस डेटा पर विचार करें:

 @prefix : <urn:ex:>. :a :relatedTo :b . :b :relatedTo :c . :c :relatedTo :d . :a :relatedTo :e . :e :relatedTo :f . :f :relatedTo :g . :h :relatedTo :i . :i :relatedTo :j . :j :relatedTo :k . :k :relatedTo :l . 

जिसमें तीन हैं :relatedTo पथ के लिए:

 a --> b --> c --> d a --> e --> f --> g h --> i --> j --> k --> l 

मुझे पता है कि आपके मामले में, आपके पास एक विशिष्ट विषय था, लेकिन हम थोड़ा सा सामान्यीकरण कर सकते हैं, और इनमें से प्रत्येक रास्ते में प्रत्येक किनारे के लिए पूछें, जैसे कि एक प्रश्न के साथ:

 prefix : <urn:ex:> select * where { # start a path ?begin :relatedTo* ?midI . FILTER NOT EXISTS { [] :relatedTo ?begin } # grab next edge ?midI :relatedTo ?midJ . # get to the end of the path. ?midJ :relatedTo* ?end . FILTER NOT EXISTS { ?end :relatedTo [] } } order by ?start ?end 

 $ arq --data data.n3 --query query.sparql ----------------------------- | begin | midI | midJ | end | ============================= | :a | :a | :b | :d | | :a | :b | :c | :d | | :a | :c | :d | :d | | :a | :a | :e | :g | | :a | :e | :f | :g | | :a | :f | :g | :g | | :h | :h | :i | :l | | :h | :i | :j | :l | | :h | :j | :k | :l | | :h | :k | :l | :l | ----------------------------- 

जो प्रत्येक के प्रत्येक किनारे को दर्शाता है :relatedTo पथ आप आउटपुट को थोड़ा सा सुंदर बना सकते हैं:

 prefix : <urn:ex:> select (concat(str(?begin),"--",str(?end)) as ?path) ?midI ?midJ where { # start a path ?begin :relatedTo* ?midI . FILTER NOT EXISTS { [] :relatedTo ?begin } # grab next edge ?midI :relatedTo ?midJ . # get to the end of the path. ?midJ :relatedTo* ?end . FILTER NOT EXISTS { ?end :relatedTo [] } } order by ?path 

 $ arq --data data.n3 --query query.sparql -------------------------------------- | path | midI | midJ | ====================================== | "urn:ex:a--urn:ex:d" | :a | :b | | "urn:ex:a--urn:ex:d" | :b | :c | | "urn:ex:a--urn:ex:d" | :c | :d | | "urn:ex:a--urn:ex:g" | :a | :e | | "urn:ex:a--urn:ex:g" | :e | :f | | "urn:ex:a--urn:ex:g" | :f | :g | | "urn:ex:h--urn:ex:l" | :h | :i | | "urn:ex:h--urn:ex:l" | :i | :j | | "urn:ex:h--urn:ex:l" | :j | :k | | "urn:ex:h--urn:ex:l" | :k | :l | -------------------------------------- 

यह वही दृष्टिकोण आपको कुछ दिलचस्प चीजों को जानने देगा जैसे कुछ नोड्स कितने अलग हैं:

 prefix : <urn:ex:> select ?begin ?end (count(*) as ?length) where { # start a path ?begin :relatedTo* ?midI . FILTER NOT EXISTS { [] :relatedTo ?begin } # grab next edge ?midI :relatedTo ?midJ . # get to the end of the path. ?midJ :relatedTo* ?end . FILTER NOT EXISTS { ?end :relatedTo [] } } group by ?begin ?end 

 ------------------------ | begin | end | length | ======================== | :a | :g | 3 | | :a | :d | 3 | | :h | :l | 4 | ------------------------ 

ऊपर दिए गए डेटा में, पथ वर्णमाला क्रम में होंगे और इसलिए छँटाई सही क्रम में किनारों का उत्पादन करती है। हालांकि, यहां तक ​​कि किनारे के नोड्स वर्णमाला में नहीं हैं, फिर भी हम सूची में उनकी स्थिति की गणना करके उन्हें मुद्रित कर सकते हैं। यह क्वेरी:

 prefix : <urn:ex:> select ?begin ?midI ?midJ (count(?counter) as ?position) ?end where { ?begin :relatedTo* ?counter . ?counter :relatedTo* ?midI . FILTER NOT EXISTS { [] :relatedTo ?begin } ?midI :relatedTo ?midJ . ?midJ :relatedTo* ?end . FILTER NOT EXISTS { ?end :relatedTo [] } } group by ?begin ?end ?midI ?midJ 

 ---------------------------------- | begin | midI | midJ | .1 | end | ================================== | :a | :a | :b | 1 | :d | | :a | :b | :c | 2 | :d | | :a | :c | :d | 3 | :d | | :a | :a | :e | 1 | :g | | :a | :e | :f | 2 | :g | | :a | :f | :g | 3 | :g | | :h | :h | :i | 1 | :l | | :h | :i | :j | 2 | :l | | :h | :j | :k | 3 | :l | | :h | :k | :l | 4 | :l | ---------------------------------- 

हमें उस गिनती को देखने की जरूरी आवश्यकता नहीं है, लेकिन आप स्थिति को चुनने के बजाय, आप इसे एक सॉर्टिंग हालत के रूप में इस्तेमाल कर सकते हैं:

 prefix : <urn:ex:> select ?begin ?midI ?midJ ?end where { ?begin :relatedTo* ?counter . ?counter :relatedTo* ?midI . FILTER NOT EXISTS { [] :relatedTo ?begin } ?midI :relatedTo ?midJ . ?midJ :relatedTo* ?end . FILTER NOT EXISTS { ?end :relatedTo [] } } group by ?begin ?end ?midI ?midJ order by ?begin ?end count(?counter) 

और अनुक्रम में अपने किनारों को प्राप्त करने की गारंटी दी जाएगी