root/BH13SPARQLBuilder/src/org/biohackathon/SPARQLBuilder/OWL/OWLQueryBuilderImpl.java @ 20

リビジョン 20, 21.8 KB (コミッタ: nori, 11 年 前)

getNextClassでcountLinksパラメータを追加した
  • 属性 svn:mime-type の設定値 text/plain
行番号 
1package org.biohackathon.SPARQLBuilder.OWL;
2
3import java.util.ArrayList;
4import java.util.Collection;
5import java.util.HashMap;
6import java.util.HashSet;
7import java.util.Set;
8
9
10import com.hp.hpl.jena.query.Query;
11import com.hp.hpl.jena.query.QueryExecution;
12import com.hp.hpl.jena.query.QueryExecutionFactory;
13import com.hp.hpl.jena.query.QueryFactory;
14import com.hp.hpl.jena.query.QuerySolution;
15import com.hp.hpl.jena.query.ResultSet;
16import com.hp.hpl.jena.rdf.model.Literal;
17import com.hp.hpl.jena.rdf.model.Resource;
18
19/**
20 * 繧ｯ繧ｨ繝ｪ繧堤函謌舌☆繧九◆繧√�讖溯�繧呈署萓帙☆繧区ｸ繧ｯ繝ｩ繧ｹ
21 * @author Norio KOBAYASHI
22 * @since 28.01.2014
23 * @version 29.01.2014
24 */
25public class OWLQueryBuilderImpl implements OWLQueryBuilder {
26
27        // private Model model = null;
28        private String endpointURI = null;
29
30       
31        /**
32         * 繧｢繧ｯ繧ｻ繧ｹ縺吶ｋSPARQL endpoint縺ｮURI繧呈欠螳壹☆繧区ｧ区�蟄�
33         *
34         * @param endpointURI縲€繧｢繧ｯ繧ｻ繧ｹ縺吶ｋSPARQL endpoint縺ｮURI
35         * @throws Exception
36         * @since 28.01.2014
37         */
38        public OWLQueryBuilderImpl(String endpointURI) {
39                this.endpointURI = endpointURI;
40        }
41
42        /**
43         * 繝�せ繝医↓菴ｿ逕ｨ縺吶ｋmain繝｡繧ｽ繝�ラ
44         * <p>
45         * 繧ｯ繧ｨ繝ｪ繝薙Ν繝€繝ｼ縺ｮ譛ｬ逡ｪ繝励Ο繧ｰ繝ｩ繝縺ｧ縺ｯ縺薙�繝｡繧ｽ繝�ラ縺ｯ菴ｿ逕ｨ縺励↑縺�
46         * </p>
47         * @param args 菴ｿ逕ｨ縺励↑縺�
48         * @throws Exception
49         * @since 28.01.2014
50         */
51        public static void main(String[] args) throws Exception {
52                String sparqlEndpoint = "http://dbpedia.org/sparql";
53                String keyword = "artiste";
54                String[] graphURIs = new String[0];
55
56                OWLQueryBuilder builder = new OWLQueryBuilderImpl(sparqlEndpoint);
57                SClass[] clz = builder.getOWLClasses(graphURIs, keyword);
58                for(SClass cls: clz){
59                        System.out.println(cls);
60                }
61
62                System.out.println("CLS");
63                ClassLink[] cls = builder.getNextClass(null, clz[0].getClassURI(), 0, false);
64                if( cls != null ){
65                        for( ClassLink cl: cls){
66                                System.out.println(cl.toString());
67                        }
68                }
69
70                System.out.println("CLS-INS");
71                cls = builder.getNextClassViaInstanceLink(null, clz[0].getClassURI(), 100);
72                if( cls != null ){
73                        for( ClassLink cl: cls){
74                                System.out.println(cl.toString());
75                        }
76                }
77
78                System.out.println("Instances");
79                Instance[] ins = builder.getInstances(null, "\"A.C. Reed\"@en");
80                if( ins != null ){
81                        for( Instance in: ins){
82                                System.out.println(in.toString());
83                        }
84                }
85
86               
87                System.out.println("INS-INS");
88                ins = builder.getInstances(null, "\"A.C. Reed\"@en");
89                InstanceLink[] iLinks = builder.getNextInstancesViaInstanceLink(null, ins[0].getInstanceURI(), 100);
90               
91
92               
93                if( iLinks != null ){
94                        for( InstanceLink in: iLinks){
95                                System.out.println(in.toString());
96                        }
97                }
98               
99               
100        }
101
102       
103        /**
104         * 譏守､ｺ逧�↓RDF縺ｧ譖ｸ縺九ｌ縺ｦ縺�ｋ繧ｯ繝ｩ繧ｹ繧貞叙蠕励☆繧�
105         * <p>
106         * 謖�ｮ壹＆繧後◆graphURIs縺ｮ荳ｭ縺九ｉ縲√く繝ｼ繝ｯ繝ｼ繝峨↓繝偵ャ繝医☆繧九Λ繝吶Ν繧呈戟縺､繧ｯ繝ｩ繧ｹ��dfs:Class�峨ｒ縺吶∋縺ｦ霑斐☆
107         * <br>
108         * </p>
109         *
110         * @param graphURIs縲€讀懃ｴ｢蟇ｾ雎｡縺ｮgraph縺ｮURI驟榊� (null繧�聞縺�縺ｮ驟榊�繧ょ庄)
111         * @param keyword ��ull繧�ｩｺ譁�ｭ励�荳榊庄��
112         * @return 繧ｯ繝ｩ繧ｹURI縺ｮ驟榊�
113         * @throws Exception
114         * @since 28.01.2014
115         */
116        public SClass[] getOWLClasses(String[] graphURIs, String keyword)
117                        throws Exception {
118                StringBuffer queryStr = new StringBuffer();
119                queryStr.append("PREFIX owl: <http://www.w3.org/2002/07/owl#>\n");
120                queryStr.append("PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>\n");
121                queryStr.append("PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>\n");
122                queryStr.append("SELECT DISTINCT ?c ?pLabel (COUNT(?i) AS ?numOfInstances)\n");
123                if (graphURIs != null) {
124                        for (String graphURI : graphURIs) {
125                                queryStr.append("FROM <");
126                                queryStr.append(graphURI);
127                                queryStr.append(">\n");
128                        }
129                }
130                queryStr.append("WHERE{\n");
131               
132                queryStr.append(" {?c rdf:type rdfs:Class} UNION {?c rdf:type owl:Class}\n");
133
134                queryStr.append("      ?c rdfs:label ?label.\n");
135                queryStr.append("      ?c rdfs:label ?pLabel.\n");
136                queryStr.append("      ?i rdf:type ?c.\n");
137
138//              queryStr.append("      ?c rdfs:label ");
139//              queryStr.append(keyword);
140//              queryStr.append(".");
141
142                queryStr.append("  FILTER (\n");
143                queryStr.append("    REGEX( ?label , \"");
144                queryStr.append(keyword);
145                queryStr.append("\" , \"i\" )\n");
146                queryStr.append("  )");
147                queryStr.append("\n}  GROUP BY ?c ?pLabel");
148
149// System.out.println(queryStr.toString());
150               
151                Query query = QueryFactory.create(queryStr.toString());
152                QueryExecution qexec = QueryExecutionFactory.sparqlService(endpointURI,
153                                query);
154
155                ResultSet results = qexec.execSelect();
156                HashMap<String,SClass> classMap = new HashMap<String,SClass>();
157                for (; results.hasNext();) {
158                        QuerySolution sol = results.next();
159                        Resource res = sol.getResource("c");
160                        String uri = res.getURI();
161                        int numOfInstances = sol.getLiteral("numOfInstances").getInt();
162//System.out.println(numOfInstances);
163                        Literal labelLiteral = sol.getLiteral("pLabel");
164                        SClass sClass = null;
165                        if( classMap.containsKey(uri)){
166                                sClass = classMap.get(uri);
167                        }
168                        else{
169                                        sClass = new SClass(uri, null, numOfInstances);
170                                        classMap.put(uri, sClass);
171                        }
172                                if( labelLiteral != null ){
173                                        String label = labelLiteral.getString();
174                                        String lang = labelLiteral.getLanguage();
175                                        sClass.addLabel(new Label(label, lang));
176                                }
177                }
178                qexec.close();
179                return classMap.values().toArray(new SClass[0]);
180        }
181
182
183        /**
184         *縲€繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ繧貞叙蠕励☆繧�
185         * <p>
186         * 謖�ｮ壹＆繧後◆graphURIs縺ｮ荳ｭ縺九ｉ縲√く繝ｼ繝ｯ繝ｼ繝峨↓繝偵ャ繝医☆繧九Λ繝吶Ν繧呈戟縺､繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ繧偵☆縺ｹ縺ｦ霑斐☆
187         * <br>
188         * 縺薙％縺ｧ繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ縺ｨ縺ｯ縲〉df:type縺ｮ荳ｻ隱槭→縺励※險倩ｿｰ縺輔ｌ縺ｦ縺�ｋ繧ゅ�繧偵＞縺�
189         * <br>
190         * </p>
191         *
192         * @param graphURIs縲€讀懃ｴ｢蟇ｾ雎｡縺ｮgraph縺ｮURI驟榊� (null繧�聞縺�縺ｮ驟榊�繧ょ庄)
193         * @param keyword ��ull繧�ｩｺ譁�ｭ励�荳榊庄��
194         * @return 繧ｯ繝ｩ繧ｹURI縺ｮ驟榊�
195         * @throws Exception
196         * @since 28.01.2014
197         */
198        public Instance[] getInstances(String[] graphURIs, String keyword)
199                        throws Exception {
200                StringBuffer queryStr = new StringBuffer();
201                queryStr.append("PREFIX owl: <http://www.w3.org/2002/07/owl#>\n");
202                queryStr.append("PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>\n");
203                queryStr.append("PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>\n");
204                queryStr.append("SELECT DISTINCT ?ins ?c \n");
205                if (graphURIs != null) {
206                        for (String graphURI : graphURIs) {
207                                queryStr.append("FROM <");
208                                queryStr.append(graphURI);
209                                queryStr.append(">\n");
210                        }
211                }
212                queryStr.append("WHERE{\n");
213//              queryStr.append(" {?c rdf:type rdfs:Class} UNION {?c rdf:type owl:Class}\n");
214
215               
216                queryStr.append("      ?ins rdf:type ?c.\n");
217                queryStr.append("      ?ins rdfs:label ");
218                queryStr.append(keyword);
219                queryStr.append(".\n");
220                queryStr.append(" FILTER (?c != rdf:Property)");
221                queryStr.append("}");
222                               
223// System.out.println(queryStr.toString());
224               
225                Query query = QueryFactory.create(queryStr.toString());
226                QueryExecution qexec = QueryExecutionFactory.sparqlService(endpointURI,
227                                query);
228
229                ResultSet results = qexec.execSelect();
230                HashMap<String, HashSet<String>> instanceMap = new HashMap<String, HashSet<String>>();
231                for (; results.hasNext();) {
232                        QuerySolution sol = results.next();
233                        Resource cls = sol.getResource("c");
234                        Resource ins = sol.getResource("ins");
235                        String clsURI = cls.getURI();
236                        String insURI = ins.getURI();
237                        if( instanceMap.containsKey(insURI)){
238                                HashSet<String> classes = instanceMap.get(insURI);
239                                classes.add(clsURI);
240                        }else{
241                                HashSet<String> classes = new HashSet<String>();
242                                instanceMap.put(insURI, classes);
243                                classes.add(clsURI);
244                        }
245                }
246                qexec.close();
247                Set<String> keySet = instanceMap.keySet();
248                ArrayList<Instance> instanceList = new ArrayList<Instance>();
249                for(String key: keySet){
250                        Instance ins = new Instance(key, instanceMap.get(key).toArray(new String[0]));
251                        instanceList.add(ins);
252                }
253                return instanceList.toArray(new Instance[0]);
254        }
255
256       
257        /**
258         *縲€謖�ｮ壹＆繧後◆繧ｯ繝ｩ繧ｹ繧定ｵｷ轤ｹ縺ｨ縺励€∵�遉ｺ逧�↓險倩ｿｰ縺輔ｌ縺ｦ縺�ｋOWL縺ｮproperty蛻ｶ邏�ｒ隱ｿ縺ｹ縲√◎縺ｮproperty蛻ｶ邏�〒
259         * 髢｢騾｣縺･縺代ｉ繧後※縺�ｋ繧ｯ繝ｩ繧ｹ繧堤ｶｲ鄒�噪縺ｫ蜿門ｾ励☆繧�
260         * <p>
261         * 蜃ｦ逅�ｯｾ雎｡繝��繧ｿ繧暖raphURIs縺ｧ謖�ｮ壹☆繧九％縺ｨ縺後〒縺阪ｋ
262         * <br>
263         * <br>
264         * </p>
265         *
266         * @param graphURIs縲€讀懃ｴ｢蟇ｾ雎｡縺ｮgraph縺ｮURI驟榊� 縲€(null繧�聞縺�縺ｮ驟榊�繧ょ庄)
267         * @param originClass 襍ｷ轤ｹ縺ｨ縺ｪ繧九け繝ｩ繧ｹ縺ｮURI縲€��ull荳榊庄��
268         * @param limit 隗｣縺ｨ縺励※霑斐＆繧後ｋClassLink驟榊�縺ｮ髟ｷ縺輔�荳企剞蛟､繧呈欠螳壹☆繧九€�荳企剞蛟､繧定ｨｭ螳壹＠縺ｪ縺�ｴ蜷医�0莉･荳九�蛟､繧呈欠螳壹☆繧�
269         * @return ClassLink縺ｮ驟榊�縲ゅ％縺薙↓縺ｯ縲∝叙蠕励＆繧後◆繧ｯ繝ｩ繧ｹ縺ｨ髢｢菫ゅ▼縺代ｉ繧後※縺�ｋ繝励Ο繝代ユ繧｣縲�未菫ゅ�蜷代″縺悟性縺ｾ繧後ｋ縲�
270         * @throws Exception
271         * @since 28.01.2014
272         */
273        public ClassLink[] getNextClass(String[] graphURIs, String originClass,
274                        int limit, boolean countLinks) throws Exception {
275                StringBuffer queryStr = new StringBuffer();
276                queryStr.append("PREFIX owl: <http://www.w3.org/2002/07/owl#>\n");
277                queryStr.append("PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>\n");
278                queryStr.append("PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>\n");
279
280                // SELECT
281                if( countLinks ){
282                                queryStr.append("SELECT DISTINCT ?p ?pDirection ?c (COUNT(?s) AS ?numOfLinks) \n");
283                }
284                else{
285                        queryStr.append("SELECT DISTINCT ?p ?pDirection ?c \n");
286                }
287               
288                if (graphURIs != null) {
289                        for (String graphURI : graphURIs) {
290                                queryStr.append("FROM <");
291                                queryStr.append(graphURI);
292                                queryStr.append(">\n");
293                        }
294                }
295                queryStr.append("WHERE{\n");
296                queryStr.append("  { ?c rdf:type rdfs:Class. }\n  UNION\n  { ?c rdf:type owl:Class. }\n");
297                queryStr.append("  { ?p rdfs:domain <");
298                queryStr.append(originClass);
299                queryStr.append(">.\n    ?p rdfs:range ?c.\n");
300
301                if( countLinks ){
302                                queryStr.append("    ?o ?p ?s.");
303                }
304               
305                queryStr.append("}\n  UNION\n");
306                queryStr.append("  { ?p rdfs:range <");
307                queryStr.append(originClass);
308                queryStr.append(">.\n");
309                queryStr.append("    ?p rdfs:domain ?c.\n");
310
311                if( countLinks ){
312                                queryStr.append("    ?s ?p ?o.");
313                }
314               
315                queryStr.append("}\n");
316
317                queryStr.append("    ?p ?pDirection ?c.\n");
318
319               
320                queryStr.append("  ?s rdf:type ?c.\n");
321
322                if( countLinks){
323                        queryStr.append("  ?o rdf:type <");
324                        queryStr.append(originClass);
325                        queryStr.append(">.\n");
326                        queryStr.append("}\nGROUP BY ?p ?pDirection ?c\n");
327                }
328                else{
329                        queryStr.append("}\n");
330                }
331                if (limit > 0) {
332                        queryStr.append("limit ");
333                        queryStr.append(limit);
334                        queryStr.append("\n");
335                }
336               
337                System.out.println(queryStr.toString());       
338       
339                Query query = QueryFactory.create(queryStr.toString());
340                QueryExecution qexec = QueryExecutionFactory.sparqlService(endpointURI,
341                                query);
342
343                ResultSet results = qexec.execSelect();
344                ArrayList<ClassLink> solCLs = new ArrayList<ClassLink>();
345                for (; results.hasNext();) {
346                        QuerySolution sol = results.next();
347                        Resource pro = sol.getResource("p");
348                        Resource cls = sol.getResource("c");
349                        Resource dir = sol.getResource("pDirection");
350                        String proURI = pro.getURI();
351                        String clsURI = cls.getURI();
352                        String dirURI = dir.getURI();
353
354//                      System.out.println(pro.getURI() + " " + cls.getURI() + " " + dir.getURI());
355                       
356                       
357                        Direction direction = null;
358                        if( dirURI.equals("http://www.w3.org/2000/01/rdf-schema#domain") || dirURI.equals("rdfs:domain")){
359                                direction = Direction.reverse;
360                        }
361                        if( dirURI.equals("http://www.w3.org/2000/01/rdf-schema#range") || dirURI.equals("rdfs:range")){
362                                if( direction != null ){
363                                        direction = Direction.both;
364                                }else{
365                                direction = Direction.forward;
366                                }
367                        }
368//                      System.out.println(direction);
369                        int numOfLinks = sol.getLiteral("numOfLinks").getInt();
370                        ClassLink cl = new ClassLink(proURI, clsURI, direction, numOfLinks);
371                        solCLs.add(cl);
372                }
373                qexec.close();
374                return solCLs.toArray(new ClassLink[0]);
375        }
376       
377       
378        /**
379         *縲€謖�ｮ壹＆繧後◆繧ｯ繝ｩ繧ｹ繧定ｵｷ轤ｹ縺ｨ縺励€√◎縺ｮ繧ｯ繝ｩ繧ｹ縺ｫ螻槭＠縺ｦ縺�ｋ繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ縺ｨ繝ｪ繝ｳ繧ｯ縺悟ｼｵ繧峨ｌ縺ｦ縺�ｋ繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ縺ｮ髮�粋繧貞叙蠕励＠縲∝叙蠕励＠縺溘う繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ縺ｮ繧ｯ繝ｩ繧ｹ繧堤ｶｲ鄒�噪縺ｫ蜿門ｾ励☆繧�
380         * <p>
381         * 縺薙％縺ｧ繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ縺ｨ縺ｯ縲〉df:type縺ｮ荳ｻ隱槭→縺励※險倩ｿｰ縺輔ｌ縺ｦ縺�ｋ繧ゅ�繧偵＞縺�
382         * <br>
383         * 蜃ｦ逅�ｯｾ雎｡繝��繧ｿ繧暖raphURIs縺ｧ謖�ｮ壹☆繧九％縺ｨ縺後〒縺阪ｋ
384         * <br>
385         * </p>
386         *
387         * @param graphURIs縲€讀懃ｴ｢蟇ｾ雎｡縺ｮgraph縺ｮURI驟榊� 縲€(null繧�聞縺�縺ｮ驟榊�繧ょ庄)
388         * @param originClass 襍ｷ轤ｹ縺ｨ縺ｪ繧九け繝ｩ繧ｹ縺ｮURI縲€��ull荳榊庄��
389         * @param limit 隗｣縺ｨ縺励※霑斐＆繧後ｋClassLink驟榊�縺ｮ髟ｷ縺輔�荳企剞蛟､繧呈欠螳壹☆繧九€�荳企剞蛟､繧定ｨｭ螳壹＠縺ｪ縺�ｴ蜷医�0莉･荳九�蛟､繧呈欠螳壹☆繧�
390         * @return ClassLink縺ｮ驟榊�縲ゅ％縺薙↓縺ｯ縲∝叙蠕励＆繧後◆繧ｯ繝ｩ繧ｹ縺ｨ髢｢菫ゅ▼縺代ｉ繧後※縺�ｋ繝励Ο繝代ユ繧｣縲�未菫ゅ�蜷代″縺悟性縺ｾ繧後ｋ縲�
391         * @throws Exception
392         * @since 28.01.2014
393         */
394        public ClassLink[] getNextClassViaInstanceLink(String[] graphURIs, String originClass,
395                        int limit) throws Exception {
396                StringBuffer queryStr = new StringBuffer();
397                queryStr.append("PREFIX owl: <http://www.w3.org/2002/07/owl#>\n");
398                queryStr.append("PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>\n");
399                queryStr.append("PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>\n");
400                queryStr.append("SELECT DISTINCT ?pf ?pr ?c \n");
401                if (graphURIs != null) {
402                        for (String graphURI : graphURIs) {
403                                queryStr.append("FROM <");
404                                queryStr.append(graphURI);
405                                queryStr.append(">\n");
406                        }
407                }
408                queryStr.append("WHERE{\n");
409                queryStr.append("  ?ins rdf:type ?c.\n");
410                queryStr.append("  ?insOrg rdf:type <");
411                queryStr.append(originClass);
412                queryStr.append(">.\n");
413                queryStr.append("  { ?ins ?pr ?insOrg. }\n  UNION { ?insOrg ?pf ?ins. }\n");
414                queryStr.append("}\n");
415                if (limit > 0) {
416                        queryStr.append("limit ");
417                        queryStr.append(limit);
418                        queryStr.append("\n");
419                }
420               
421//              System.out.println(queryStr.toString());       
422       
423                Query query = QueryFactory.create(queryStr.toString());
424                QueryExecution qexec = QueryExecutionFactory.sparqlService(endpointURI,
425                                query);
426
427                ResultSet results = qexec.execSelect();
428                ArrayList<ClassLink> solCLs = new ArrayList<ClassLink>();
429                for (; results.hasNext();) {
430                        QuerySolution sol = results.next();
431                        Resource proForward = sol.getResource("pf");
432                        Resource proReverse = sol.getResource("pr");
433                        Resource cls = sol.getResource("c");
434                        Direction direction = null;
435                        String propURI = null;
436                        if( proForward != null ){
437                                if( proReverse != null ){
438                                        direction = Direction.both;
439                                }else{
440                                        direction = Direction.forward;
441                                }
442                                propURI = proForward.getURI();
443                        }else{
444                                direction = Direction.reverse;
445                                propURI = proReverse.getURI();
446                        }
447                        String clsURI = cls.getURI();
448//                      System.out.println(propURI + " " + clsURI + " " + direction);
449                       
450                        ClassLink cl = new ClassLink(propURI, clsURI, direction, 0);
451                        solCLs.add(cl);
452                }
453                qexec.close();
454                return solCLs.toArray(new ClassLink[0]);
455        }
456
457       
458       
459        public Path[] getPaths(String startClass, String endClass) throws Exception {
460                OWLClassGraph graph = new OWLClassGraph(startClass, endClass);
461                return graph.getPaths(this, 0);
462        }
463
464        public String createSPARQL(Path path) throws Exception {
465                return null;
466        }
467
468
469       
470       
471/*
472        private String executeSelect(String sparqlQuery) throws Exception {
473                HttpClient client = HttpClientBuilder.create().build();
474                HttpPost httppost = new HttpPost(endpointURI);
475                httppost.setHeader("Content-Type", "application/x-www-form-urlencoded");
476                httppost.setHeader("Accept", "application/sparql-results+xml");
477                List<NameValuePair> nvpList = new ArrayList<NameValuePair>();
478                nvpList.add(new BasicNameValuePair("query", sparqlQuery));
479                // nvpList.add(new BasicNameValuePair("format",
480                // outputFormat.getMime()));
481                httppost.setEntity(new UrlEncodedFormEntity(nvpList, Charset
482                                .forName("UTF-8")));
483                HttpResponse response = client.execute(httppost);
484                // System.out.println("[StatusLine] " + response.getStatusLine());
485                HttpEntity entity = response.getEntity();
486                String entityString = EntityUtils.toString(entity, "UTF-8");
487                return entityString;
488        }
489*/
490       
491        /**
492         *縲€謖�ｮ壹＆繧後◆繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ繧定ｵｷ轤ｹ縺ｨ縺励€√◎縺ｮ繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ縺ｫ繝ｪ繝ｳ繧ｯ縺悟ｼｵ繧峨ｌ縺ｦ縺�ｋ繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ縺ｮ髮�粋繧貞叙蠕励☆繧九€�
493         *縲€蜿門ｾ励＆繧後◆蜷�う繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ縺ｮ繧ｯ繝ｩ繧ｹ繧らｶｲ鄒�噪縺ｫ蜿門ｾ励☆繧�
494         * <p>
495         * 縺薙％縺ｧ繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ縺ｨ縺ｯ縲〉df:type縺ｮ荳ｻ隱槭→縺励※險倩ｿｰ縺輔ｌ縺ｦ縺�ｋ繧ゅ�繧偵＞縺�
496         * <br>
497         * 蜃ｦ逅�ｯｾ雎｡繝��繧ｿ繧暖raphURIs縺ｧ謖�ｮ壹☆繧九％縺ｨ縺後〒縺阪ｋ
498         * <br>
499         * </p>
500         *
501         * @param graphURIs縲€讀懃ｴ｢蟇ｾ雎｡縺ｮgraph縺ｮURI驟榊� 縲€(null繧�聞縺�縺ｮ驟榊�繧ょ庄)
502         * @param originInstance 襍ｷ轤ｹ縺ｨ縺ｪ繧九う繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ縺ｮURI縲€��ull荳榊庄��
503         * @param limit 隗｣縺ｨ縺励※霑斐＆繧後ｋInstanceLink驟榊�縺ｮ髟ｷ縺輔�荳企剞蛟､繧呈欠螳壹☆繧九€�荳企剞蛟､繧定ｨｭ螳壹＠縺ｪ縺�ｴ蜷医�0莉･荳九�蛟､繧呈欠螳壹☆繧�
504         * @return InstanceLink縺ｮ驟榊�縲ゅ％縺薙↓縺ｯ縲∝叙蠕励＆繧後◆繧ｯ繝ｩ繧ｹ縺ｨ髢｢菫ゅ▼縺代ｉ繧後※縺�ｋ繝励Ο繝代ユ繧｣縲�未菫ゅ�蜷代″縺悟性縺ｾ繧後ｋ縲�
505         * @throws Exception
506         * @since 28.01.2014
507         */
508        public InstanceLink[] getNextInstancesViaInstanceLink(String[] graphURIs, String originInstance,
509                        int limit) throws Exception {
510                StringBuffer queryStr = new StringBuffer();
511                queryStr.append("PREFIX owl: <http://www.w3.org/2002/07/owl#>\n");
512                queryStr.append("PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>\n");
513                queryStr.append("PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>\n");
514                queryStr.append("SELECT DISTINCT ?pf ?pr ?ins ?c \n");
515                if (graphURIs != null) {
516                        for (String graphURI : graphURIs) {
517                                queryStr.append("FROM <");
518                                queryStr.append(graphURI);
519                                queryStr.append(">\n");
520                        }
521                }
522                queryStr.append("WHERE{\n");
523//              queryStr.append("  { ?c rdf:type rdfs:Class. }\n  UNION\n  { ?c rdf:type owl:Class. }\n");
524                queryStr.append("  ?ins rdf:type ?c.\n");
525                queryStr.append("  { ?ins ?pr <");
526                queryStr.append(originInstance);
527                queryStr.append(">. }\n  UNION { <");
528                queryStr.append(originInstance);
529                queryStr.append("> ?pf ?ins. }\n");
530
531                queryStr.append(" FILTER (?c != rdf:Property)");
532
533                queryStr.append("}\n");
534                if (limit > 0) {
535                        queryStr.append("limit ");
536                        queryStr.append(limit);
537                        queryStr.append("\n");
538                }
539               
540//              System.out.println(queryStr.toString());       
541       
542                Query query = QueryFactory.create(queryStr.toString());
543                QueryExecution qexec = QueryExecutionFactory.sparqlService(endpointURI,
544                                query);
545
546                ResultSet results = qexec.execSelect();
547                HashMap<String, InstanceLink> insLinkMap = new HashMap<String, InstanceLink>();
548                for (; results.hasNext();) {
549                        QuerySolution sol = results.next();
550                        Resource proForward = sol.getResource("pf");
551                        Resource proReverse = sol.getResource("pr");
552                        Resource ins = sol.getResource("ins");
553                        Resource cls = sol.getResource("c");
554                        Direction direction = null;
555                        String propURI = null;
556                        if( proForward != null ){
557                                if( proReverse != null ){
558                                        direction = Direction.both;
559                                }else{
560                                        direction = Direction.forward;
561                                }
562                                propURI = proForward.getURI();
563                        }else{
564                                direction = Direction.reverse;
565                                propURI = proReverse.getURI();
566                        }
567                        String clsURI = cls.getURI();
568                        String insURI = ins.getURI();
569                        String key = propURI + "\t" + insURI + "\t" + direction;
570                        if( insLinkMap.containsKey(key)){
571                                InstanceLink insLink = insLinkMap.get(key);
572                                insLink.addLinkedClassURI(clsURI);
573                        }else{
574                                InstanceLink insLink = new InstanceLink(propURI, insURI, new String[]{clsURI}, direction);
575                                insLinkMap.put(key, insLink);
576                        }
577                }
578                qexec.close();
579                Collection<InstanceLink> values = insLinkMap.values();
580                return values.toArray(new InstanceLink[0]);
581        }
582
583       
584        public LabelMap[] getLabels(String[] graphURIs, String[] resourceURIs, String language) throws Exception{
585                if( resourceURIs == null || resourceURIs.length == 0 ){
586                        return new LabelMap[0];
587                }
588                StringBuffer queryStr = new StringBuffer();
589                queryStr.append("PREFIX owl: <http://www.w3.org/2002/07/owl#>\n");
590                queryStr.append("PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>\n");
591                queryStr.append("PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>\n");
592                queryStr.append("SELECT DISTINCT ?res ?label \n");
593                if (graphURIs != null) {
594                        for (String graphURI : graphURIs) {
595                                queryStr.append("FROM <");
596                                queryStr.append(graphURI);
597                                queryStr.append(">\n");
598                        }
599                }
600                queryStr.append("WHERE{\n");
601                queryStr.append("  ?res rdfs:label ?label.\n");
602                queryStr.append("  FILTER(?res IN (");
603                boolean f = false;
604                for( String resourceURI: resourceURIs ){
605                        if(f){
606                                queryStr.append(", ");
607                        }
608                        f = true;
609                        queryStr.append("<");
610                        queryStr.append(resourceURI);
611                        queryStr.append(">");
612                }
613                queryStr.append("))\n");
614                queryStr.append("}");
615               
616                System.out.println(queryStr.toString());       
617       
618                Query query = QueryFactory.create(queryStr.toString());
619                QueryExecution qexec = QueryExecutionFactory.sparqlService(endpointURI,
620                                query);
621
622                ResultSet results = qexec.execSelect();
623                HashMap<String, LabelMap> lMap = new HashMap<String, LabelMap>();
624                for (; results.hasNext();) {
625                        QuerySolution sol = results.next();
626                        String uri = sol.getResource("res").getURI();
627                        Literal literal = sol.getLiteral("label");
628                        if( literal != null ){
629                                String label = literal.getString();
630                                String lang = literal.getLanguage();
631                                if( language != null && language.equals(lang)){
632                                        Label lbl = new Label(label, lang);
633                                        if( lMap.containsKey(uri)){
634                                                LabelMap lm = lMap.get(uri);
635                                                lm.addLabel(lbl);
636                                        }else{
637                                                LabelMap lm = new LabelMap(uri, new Label[]{lbl});
638                                                lMap.put(uri, lm);
639                                        }
640                                }
641                        }
642                }
643                return lMap.values().toArray(new LabelMap[0]);
644        }
645       
646}
Note: リポジトリブラウザについてのヘルプは TracBrowser を参照してください。