दिलचस्प पोस्ट
एंड्रॉइड विकल्प मेनू आइकन प्रदर्शित नहीं होगा दिनांक को परिवर्तित करने के लिए जीएमटी 0 क्या Android पर एप्लिकेशन को स्वचालित रूप से अपडेट करने का कोई तरीका है? जब त्रुटि.नेटवर्क रिस्पॉन्सस रिक्त है तो एंड्रॉइड वॉली में एचटीपीपी स्थिति कोड व्यवहार ggplot2 एईएस () facet_grid () के साथ संयोजन में जब एईएस (डॉलर) के लिए डॉलर के संकेत चिह्न के साथ चर गुजर रहा है जावास्क्रिप्ट के साथ IE में टाइप करें <input> टाइपिंग std :: string :: c_str () और अस्थायी कैसे फाइल सिस्टम समवर्ती पढ़ा / लिखते हैं? अजगर में उपयोगी कब है? एक इनलाइन ब्लॉक तत्व में ऊपर और नीचे बड़े स्थान को निकालें एक्शन बार पर शीर्षक के पाठ का आकार कैसे बदल सकता है? 'पूंछ' कमांड के बराबर विंडोज जावास्क्रिप्ट के साथ दिनांक समय स्वरूपण कक्षाओं के बीच मैं एक जावा कॉलबैक कैसे करूं? निर्भरता इंजेक्शन (डीआई) को अंगार 2 में सही ढंग से कैसे उपयोग करें?

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

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

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

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

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

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

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

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

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

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

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

 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) 

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