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

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

wrap: getNextClass and 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
9import com.hp.hpl.jena.query.Query;
10import com.hp.hpl.jena.query.QueryExecution;
11import com.hp.hpl.jena.query.QueryExecutionFactory;
12import com.hp.hpl.jena.query.QueryFactory;
13import com.hp.hpl.jena.query.QuerySolution;
14import com.hp.hpl.jena.query.ResultSet;
15import com.hp.hpl.jena.rdf.model.Literal;
16import com.hp.hpl.jena.rdf.model.Resource;
17
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         * 繧｢繧ｯ繧ｻ繧ｹ縺吶ｋSPARQL endpoint縺ｮURI繧呈欠螳壹☆繧区ｧ区�蟄�
32         *
33         * @param endpointURI
34         *            縲€繧｢繧ｯ繧ｻ繧ｹ縺吶ｋ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         *
48         * @param args
49         *            菴ｿ逕ｨ縺励↑縺�
50         * @throws Exception
51         * @since 28.01.2014
52         */
53        public static void main(String[] args) throws Exception {
54                // String sparqlEndpoint = "http://dbpedia.org/sparql";
55                String sparqlEndpoint = "http://lsd.dbcls.jp/sparql";
56                // String keyword = "artiste";
57                String keyword = "EnglishCode";
58                String[] graphURIs = new String[0];
59
60                keyword = null;
61
62                OWLQueryBuilder builder = new OWLQueryBuilderImpl(sparqlEndpoint);
63
64/*
65                SClass[] clz = builder.getOWLClasses(graphURIs, keyword, false);
66                for (SClass cls : clz) {
67                        System.out.println(cls);
68                }
69                clz = builder.countInstances(null, clz);
70                for (SClass cls : clz) {
71                        System.out.println(cls);
72                }
73*/
74                System.out.println("CLS");
75
76                String uri = "http://purl.jp/bio/10/lsd/ontology/201209#EnglishEntry";
77               
78                ClassLink[] cls = builder.getNextClass(null, uri, 100, false);
79
80                if (cls != null) {
81                        for (ClassLink cl : cls) {
82                                System.out.println(cl.toString());
83                        }
84                        cls = builder.countLinks(null, uri, cls);
85                        for (ClassLink cl : cls) {
86                                System.out.println(cl.toString());
87                        }
88                }
89/*
90                System.out.println("CLS-INS");
91                cls = builder.getNextClassViaInstanceLink(null, clz[0].getClassURI(),
92                                100);
93                if (cls != null) {
94                        for (ClassLink cl : cls) {
95                                System.out.println(cl.toString());
96                        }
97                }
98
99                System.out.println("Instances");
100                Instance[] ins = builder.getInstances(null, "\"A.C. Reed\"@en");
101                if (ins != null) {
102                        for (Instance in : ins) {
103                                System.out.println(in.toString());
104                        }
105                }
106*/
107                /*
108                 * System.out.println("INS-INS"); ins = builder.getInstances(null,
109                 * "\"A.C. Reed\"@en"); InstanceLink[] iLinks =
110                 * builder.getNextInstancesViaInstanceLink(null,
111                 * ins[0].getInstanceURI(), 100);
112                 *
113                 * if (iLinks != null) { for (InstanceLink in : iLinks) {
114                 * System.out.println(in.toString()); } }
115                 */
116        }
117
118       
119       
120       
121        /**
122         * 譏守､ｺ逧�↓RDF縺ｧ譖ｸ縺九ｌ縺ｦ縺�ｋ繧ｯ繝ｩ繧ｹ繧貞叙蠕励☆繧�
123         * <p>
124         * 謖�ｮ壹＆繧後◆graphURIs縺ｮ荳ｭ縺九ｉ縲√く繝ｼ繝ｯ繝ｼ繝峨↓繝偵ャ繝医☆繧九Λ繝吶Ν繧呈戟縺､繧ｯ繝ｩ繧ｹ��dfs:Class�峨ｒ縺吶∋縺ｦ霑斐☆ <br>
125         * </p>
126         *
127         * @param graphURIs
128         *            縲€讀懃ｴ｢蟇ｾ雎｡縺ｮgraph縺ｮURI驟榊� (null繧�聞縺�縺ｮ驟榊�繧ょ庄)
129         * @param keyword
130         *            ��ull繧�ｩｺ譁�ｭ励�荳榊庄��
131         * @return 繧ｯ繝ｩ繧ｹURI縺ｮ驟榊�
132         * @throws Exception
133         * @since 28.01.2014
134         */
135        public SClass[] getOWLClasses(String[] graphURIs, String keyword,
136                        boolean countInstances) throws Exception {
137                StringBuffer queryStr = new StringBuffer();
138                queryStr.append("PREFIX owl: <http://www.w3.org/2002/07/owl#>\n");
139                queryStr.append("PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>\n");
140                queryStr.append("PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>\n");
141                if (countInstances) {
142                        queryStr.append("SELECT DISTINCT ?c ?pLabel (COUNT(?i) AS ?numOfInstances)\n");
143                } else {
144                        queryStr.append("SELECT DISTINCT ?c ?pLabel \n");
145                }
146                if (graphURIs != null) {
147                        for (String graphURI : graphURIs) {
148                                queryStr.append("FROM <");
149                                queryStr.append(graphURI);
150                                queryStr.append(">\n");
151                        }
152                }
153                queryStr.append("WHERE{\n");
154
155                //
156                queryStr.append(" {?c rdf:type rdfs:Class} UNION {?c rdf:type owl:Class}\n");
157//              queryStr.append("  ?i rdf:type ?c.\n");
158
159
160               
161                if (countInstances) {
162                        queryStr.append("  ?c rdfs:label ?label.\n");
163                }
164                queryStr.append("  ?c rdfs:label ?pLabel.\n");
165                if (countInstances) {
166                        queryStr.append("      ?i rdf:type ?c.\n");
167                }
168                // queryStr.append("      ?c rdfs:label ");
169                // queryStr.append(keyword);
170                // queryStr.append(".");
171                if (keyword != null && keyword.length() != 0) {
172                        queryStr.append("  FILTER (\n");
173                        queryStr.append("    REGEX( ?label , \"");
174                        queryStr.append(keyword);
175                        queryStr.append("\" , \"i\" )\n");
176                        queryStr.append("  )\n");
177                }
178                if (countInstances) {
179                        queryStr.append("}  GROUP BY ?c ?pLabel");
180                } else {
181                        queryStr.append("}");
182                }
183                System.out.println(queryStr.toString());
184
185                Query query = QueryFactory.create(queryStr.toString());
186                QueryExecution qexec = QueryExecutionFactory.sparqlService(endpointURI,
187                                query);
188
189                ResultSet results = qexec.execSelect();
190                HashMap<String, SClass> classMap = new HashMap<String, SClass>();
191                for (; results.hasNext();) {
192                        QuerySolution sol = results.next();
193                        Resource res = sol.getResource("c");
194                        if (res != null) {
195                                String uri = res.getURI();
196                                int numOfInstances = 0;
197                                if (countInstances) {
198                                        numOfInstances = sol.getLiteral("numOfInstances").getInt();
199                                }
200                                // System.out.println(numOfInstances);
201                                Literal labelLiteral = sol.getLiteral("pLabel");
202                                SClass sClass = null;
203                                if (classMap.containsKey(uri)) {
204                                        sClass = classMap.get(uri);
205                                } else {
206                                        sClass = new SClass(uri, null, numOfInstances);
207                                        classMap.put(uri, sClass);
208                                }
209                                if (labelLiteral != null) {
210                                        String label = labelLiteral.getString();
211                                        String lang = labelLiteral.getLanguage();
212                                        sClass.addLabel(new Label(label, lang));
213                                }
214                        }
215                }
216                qexec.close();
217                return classMap.values().toArray(new SClass[0]);
218        }
219
220        /**
221         * 縲€繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ繧貞叙蠕励☆繧�
222         * <p>
223         * 謖�ｮ壹＆繧後◆graphURIs縺ｮ荳ｭ縺九ｉ縲√く繝ｼ繝ｯ繝ｼ繝峨↓繝偵ャ繝医☆繧九Λ繝吶Ν繧呈戟縺､繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ繧偵☆縺ｹ縺ｦ霑斐☆ <br>
224         * 縺薙％縺ｧ繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ縺ｨ縺ｯ縲〉df:type縺ｮ荳ｻ隱槭→縺励※險倩ｿｰ縺輔ｌ縺ｦ縺�ｋ繧ゅ�繧偵＞縺�<br>
225         * </p>
226         *
227         * @param graphURIs
228         *            縲€讀懃ｴ｢蟇ｾ雎｡縺ｮgraph縺ｮURI驟榊� (null繧�聞縺�縺ｮ驟榊�繧ょ庄)
229         * @param keyword
230         *            ��ull繧�ｩｺ譁�ｭ励�荳榊庄��
231         * @return 繧ｯ繝ｩ繧ｹURI縺ｮ驟榊�
232         * @throws Exception
233         * @since 28.01.2014
234         */
235        public Instance[] getInstances(String[] graphURIs, String keyword)
236                        throws Exception {
237                StringBuffer queryStr = new StringBuffer();
238                queryStr.append("PREFIX owl: <http://www.w3.org/2002/07/owl#>\n");
239                queryStr.append("PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>\n");
240                queryStr.append("PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>\n");
241                queryStr.append("SELECT DISTINCT ?ins ?c \n");
242                if (graphURIs != null) {
243                        for (String graphURI : graphURIs) {
244                                queryStr.append("FROM <");
245                                queryStr.append(graphURI);
246                                queryStr.append(">\n");
247                        }
248                }
249                queryStr.append("WHERE{\n");
250                // queryStr.append(" {?c rdf:type rdfs:Class} UNION {?c rdf:type owl:Class}\n");
251
252                queryStr.append("      ?ins rdf:type ?c.\n");
253                queryStr.append("      ?ins rdfs:label ");
254                queryStr.append(keyword);
255                queryStr.append(".\n");
256                queryStr.append(" FILTER (?c != rdf:Property)");
257                queryStr.append("}");
258
259                // System.out.println(queryStr.toString());
260
261                Query query = QueryFactory.create(queryStr.toString());
262                QueryExecution qexec = QueryExecutionFactory.sparqlService(endpointURI,
263                                query);
264
265                ResultSet results = qexec.execSelect();
266                HashMap<String, HashSet<String>> instanceMap = new HashMap<String, HashSet<String>>();
267                for (; results.hasNext();) {
268                        QuerySolution sol = results.next();
269                        Resource cls = sol.getResource("c");
270                        Resource ins = sol.getResource("ins");
271                        String clsURI = cls.getURI();
272                        String insURI = ins.getURI();
273                        if (instanceMap.containsKey(insURI)) {
274                                HashSet<String> classes = instanceMap.get(insURI);
275                                classes.add(clsURI);
276                        } else {
277                                HashSet<String> classes = new HashSet<String>();
278                                instanceMap.put(insURI, classes);
279                                classes.add(clsURI);
280                        }
281                }
282                qexec.close();
283                Set<String> keySet = instanceMap.keySet();
284                ArrayList<Instance> instanceList = new ArrayList<Instance>();
285                for (String key : keySet) {
286                        Instance ins = new Instance(key, instanceMap.get(key).toArray(
287                                        new String[0]));
288                        instanceList.add(ins);
289                }
290                return instanceList.toArray(new Instance[0]);
291        }
292
293        /**
294         * 縲€謖�ｮ壹＆繧後◆繧ｯ繝ｩ繧ｹ繧定ｵｷ轤ｹ縺ｨ縺励€∵�遉ｺ逧�↓險倩ｿｰ縺輔ｌ縺ｦ縺�ｋOWL縺ｮproperty蛻ｶ邏�ｒ隱ｿ縺ｹ縲√◎縺ｮproperty蛻ｶ邏�〒
295         * 髢｢騾｣縺･縺代ｉ繧後※縺�ｋ繧ｯ繝ｩ繧ｹ繧堤ｶｲ鄒�噪縺ｫ蜿門ｾ励☆繧�
296         * <p>
297         * 蜃ｦ逅�ｯｾ雎｡繝��繧ｿ繧暖raphURIs縺ｧ謖�ｮ壹☆繧九％縺ｨ縺後〒縺阪ｋ <br>
298         * <br>
299         * </p>
300         *
301         * @param graphURIs
302         *            縲€讀懃ｴ｢蟇ｾ雎｡縺ｮgraph縺ｮURI驟榊� 縲€(null繧�聞縺�縺ｮ驟榊�繧ょ庄)
303         * @param originClass
304         *            襍ｷ轤ｹ縺ｨ縺ｪ繧九け繝ｩ繧ｹ縺ｮURI縲€��ull荳榊庄��
305         * @param limit
306         *            隗｣縺ｨ縺励※霑斐＆繧後ｋClassLink驟榊�縺ｮ髟ｷ縺輔�荳企剞蛟､繧呈欠螳壹☆繧九€�荳企剞蛟､繧定ｨｭ螳壹＠縺ｪ縺�ｴ蜷医�0莉･荳九�蛟､繧呈欠螳壹☆繧�
307         * @return ClassLink縺ｮ驟榊�縲ゅ％縺薙↓縺ｯ縲∝叙蠕励＆繧後◆繧ｯ繝ｩ繧ｹ縺ｨ髢｢菫ゅ▼縺代ｉ繧後※縺�ｋ繝励Ο繝代ユ繧｣縲�未菫ゅ�蜷代″縺悟性縺ｾ繧後ｋ縲�
308         * @throws Exception
309         * @since 28.01.2014
310         */
311        public ClassLink[] getNextClass(String[] graphURIs, String originClass,
312                        int limit, boolean countLinks) throws Exception {
313                ClassLink[] cLinks = getNextClassSub(graphURIs, originClass, limit, false);
314                if( countLinks ){
315                        cLinks = countLinks(graphURIs, originClass, cLinks);
316                }
317                return cLinks;
318        }
319
320        private ClassLink[] getNextClassSub(String[] graphURIs, String originClass,
321                        int limit, boolean countLinks) throws Exception {
322                                StringBuffer queryStr = new StringBuffer();
323                queryStr.append("PREFIX owl: <http://www.w3.org/2002/07/owl#>\n");
324                queryStr.append("PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>\n");
325                queryStr.append("PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>\n");
326
327                // SELECT
328                if (countLinks) {
329                        queryStr.append("SELECT DISTINCT ?p ?pDirection ?c (COUNT(?s) AS ?numOfLinks) \n");
330                } else {
331                        queryStr.append("SELECT DISTINCT ?p ?pDirection ?c \n");
332                }
333
334                if (graphURIs != null) {
335                        for (String graphURI : graphURIs) {
336                                queryStr.append("FROM <");
337                                queryStr.append(graphURI);
338                                queryStr.append(">\n");
339                        }
340                }
341                queryStr.append("WHERE{\n");
342                // queryStr.append("  { ?c rdf:type rdfs:Class. }\n  UNION\n  { ?c rdf:type owl:Class. }\n");
343                queryStr.append("  { ?p rdfs:domain <");
344                queryStr.append(originClass);
345                queryStr.append(">.\n    ?p rdfs:range ?c.\n");
346
347                if (countLinks) {
348                        queryStr.append("    ?o ?p ?s.");
349                } else {
350                        queryStr.append("filter(exists{\n");
351                        queryStr.append("  ?o rdf:type ?c.\n");
352                        queryStr.append(" ?s rdf:type <");
353                        queryStr.append(originClass);
354                        queryStr.append(">.\n");
355                        queryStr.append("       ?s ?p ?o.})\n");
356                }
357
358                queryStr.append("}\n  UNION\n");
359                queryStr.append("  { ?p rdfs:range <");
360                queryStr.append(originClass);
361                queryStr.append(">.\n");
362                queryStr.append("    ?p rdfs:domain ?c.\n");
363
364                if (countLinks) {
365                        queryStr.append("    ?s ?p ?o.");
366                } else {
367                        queryStr.append("filter(exists{\n");
368                        queryStr.append("  ?s rdf:type ?c.\n");
369                        queryStr.append(" ?o rdf:type <");
370                        queryStr.append(originClass);
371                        queryStr.append(">.\n");
372                        queryStr.append("       ?s ?p ?o.})\n");
373                }
374
375                queryStr.append("}\n");
376
377                queryStr.append("    ?p ?pDirection ?c.\n");
378
379                queryStr.append("  ?s rdf:type ?c.\n");
380
381                if (countLinks) {
382                        queryStr.append("}\nGROUP BY ?p ?pDirection ?c\n");
383                } else {
384                        queryStr.append("}\n");
385                }
386                if (limit > 0) {
387                        queryStr.append("limit ");
388                        queryStr.append(limit);
389                        queryStr.append("\n");
390                }
391
392                System.out.println(queryStr.toString());
393
394                Query query = QueryFactory.create(queryStr.toString());
395                QueryExecution qexec = QueryExecutionFactory.sparqlService(endpointURI,
396                                query);
397
398                ResultSet results = qexec.execSelect();
399                ArrayList<ClassLink> solCLs = new ArrayList<ClassLink>();
400                for (; results.hasNext();) {
401                        QuerySolution sol = results.next();
402                        Resource pro = sol.getResource("p");
403                        if (pro != null) {
404                                Resource cls = sol.getResource("c");
405                                Resource dir = sol.getResource("pDirection");
406                                String proURI = pro.getURI();
407                                String clsURI = cls.getURI();
408                                String dirURI = dir.getURI();
409
410                                // System.out.println(pro.getURI() + " " + cls.getURI() + " " +
411                                // dir.getURI());
412
413                                Direction direction = null;
414                                if (dirURI
415                                                .equals("http://www.w3.org/2000/01/rdf-schema#domain")
416                                                || dirURI.equals("rdfs:domain")) {
417                                        direction = Direction.reverse;
418                                }
419                                if (dirURI.equals("http://www.w3.org/2000/01/rdf-schema#range")
420                                                || dirURI.equals("rdfs:range")) {
421                                        if (direction != null) {
422                                                direction = Direction.both;
423                                        } else {
424                                                direction = Direction.forward;
425                                        }
426                                }
427                                // System.out.println(direction);
428                                int numOfLinks = 0;
429                                if (countLinks) {
430                                        numOfLinks = sol.getLiteral("numOfLinks").getInt();
431                                }
432                                ClassLink cl = new ClassLink(proURI, clsURI, direction,
433                                                numOfLinks);
434                                solCLs.add(cl);
435                        }
436                }
437                qexec.close();
438                return solCLs.toArray(new ClassLink[0]);
439        }
440
441        /**
442         * 縲€謖�ｮ壹＆繧後◆繧ｯ繝ｩ繧ｹ繧定ｵｷ轤ｹ縺ｨ縺励€√◎縺ｮ繧ｯ繝ｩ繧ｹ縺ｫ螻槭＠縺ｦ縺�ｋ繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ縺ｨ繝ｪ繝ｳ繧ｯ縺悟ｼｵ繧峨ｌ縺ｦ縺�ｋ繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ縺ｮ髮�粋繧貞叙蠕励＠縲�
443         * 蜿門ｾ励＠縺溘う繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ縺ｮ繧ｯ繝ｩ繧ｹ繧堤ｶｲ鄒�噪縺ｫ蜿門ｾ励☆繧�
444         * <p>
445         * 縺薙％縺ｧ繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ縺ｨ縺ｯ縲〉df:type縺ｮ荳ｻ隱槭→縺励※險倩ｿｰ縺輔ｌ縺ｦ縺�ｋ繧ゅ�繧偵＞縺�<br>
446         * 蜃ｦ逅�ｯｾ雎｡繝��繧ｿ繧暖raphURIs縺ｧ謖�ｮ壹☆繧九％縺ｨ縺後〒縺阪ｋ <br>
447         * </p>
448         *
449         * @param graphURIs
450         *            縲€讀懃ｴ｢蟇ｾ雎｡縺ｮgraph縺ｮURI驟榊� 縲€(null繧�聞縺�縺ｮ驟榊�繧ょ庄)
451         * @param originClass
452         *            襍ｷ轤ｹ縺ｨ縺ｪ繧九け繝ｩ繧ｹ縺ｮURI縲€��ull荳榊庄��
453         * @param limit
454         *            隗｣縺ｨ縺励※霑斐＆繧後ｋClassLink驟榊�縺ｮ髟ｷ縺輔�荳企剞蛟､繧呈欠螳壹☆繧九€�荳企剞蛟､繧定ｨｭ螳壹＠縺ｪ縺�ｴ蜷医�0莉･荳九�蛟､繧呈欠螳壹☆繧�
455         * @return ClassLink縺ｮ驟榊�縲ゅ％縺薙↓縺ｯ縲∝叙蠕励＆繧後◆繧ｯ繝ｩ繧ｹ縺ｨ髢｢菫ゅ▼縺代ｉ繧後※縺�ｋ繝励Ο繝代ユ繧｣縲�未菫ゅ�蜷代″縺悟性縺ｾ繧後ｋ縲�
456         * @throws Exception
457         * @since 28.01.2014
458         */
459        public ClassLink[] getNextClassViaInstanceLink(String[] graphURIs,
460                        String originClass, int limit) throws Exception {
461                StringBuffer queryStr = new StringBuffer();
462                queryStr.append("PREFIX owl: <http://www.w3.org/2002/07/owl#>\n");
463                queryStr.append("PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>\n");
464                queryStr.append("PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>\n");
465                queryStr.append("SELECT DISTINCT ?pf ?pr ?c \n");
466                if (graphURIs != null) {
467                        for (String graphURI : graphURIs) {
468                                queryStr.append("FROM <");
469                                queryStr.append(graphURI);
470                                queryStr.append(">\n");
471                        }
472                }
473                queryStr.append("WHERE{\n");
474                queryStr.append("  ?ins rdf:type ?c.\n");
475                queryStr.append("  ?insOrg rdf:type <");
476                queryStr.append(originClass);
477                queryStr.append(">.\n");
478                queryStr.append("  { ?ins ?pr ?insOrg. }\n  UNION { ?insOrg ?pf ?ins. }\n");
479                queryStr.append("}\n");
480                if (limit > 0) {
481                        queryStr.append("limit ");
482                        queryStr.append(limit);
483                        queryStr.append("\n");
484                }
485
486                // System.out.println(queryStr.toString());
487
488                Query query = QueryFactory.create(queryStr.toString());
489                QueryExecution qexec = QueryExecutionFactory.sparqlService(endpointURI,
490                                query);
491
492                ResultSet results = qexec.execSelect();
493                ArrayList<ClassLink> solCLs = new ArrayList<ClassLink>();
494                for (; results.hasNext();) {
495                        QuerySolution sol = results.next();
496                        Resource proForward = sol.getResource("pf");
497                        Resource proReverse = sol.getResource("pr");
498                        Resource cls = sol.getResource("c");
499                        Direction direction = null;
500                        String propURI = null;
501                        if (proForward != null) {
502                                if (proReverse != null) {
503                                        direction = Direction.both;
504                                } else {
505                                        direction = Direction.forward;
506                                }
507                                propURI = proForward.getURI();
508                        } else {
509                                direction = Direction.reverse;
510                                propURI = proReverse.getURI();
511                        }
512                        String clsURI = cls.getURI();
513                        // System.out.println(propURI + " " + clsURI + " " + direction);
514
515                        ClassLink cl = new ClassLink(propURI, clsURI, direction, 0);
516                        solCLs.add(cl);
517                }
518                qexec.close();
519                return solCLs.toArray(new ClassLink[0]);
520        }
521
522        public Path[] getPaths(String startClass, String endClass, int mode,
523                        boolean countLinks) throws Exception {
524                OWLClassGraph graph = new OWLClassGraph(startClass, endClass);
525                return graph.getPaths(this, mode, countLinks);
526        }
527
528        public String createSPARQL(Path path) throws Exception {
529                return null;
530        }
531
532        /*
533         * private String executeSelect(String sparqlQuery) throws Exception {
534         * HttpClient client = HttpClientBuilder.create().build(); HttpPost httppost
535         * = new HttpPost(endpointURI); httppost.setHeader("Content-Type",
536         * "application/x-www-form-urlencoded"); httppost.setHeader("Accept",
537         * "application/sparql-results+xml"); List<NameValuePair> nvpList = new
538         * ArrayList<NameValuePair>(); nvpList.add(new BasicNameValuePair("query",
539         * sparqlQuery)); // nvpList.add(new BasicNameValuePair("format", //
540         * outputFormat.getMime())); httppost.setEntity(new
541         * UrlEncodedFormEntity(nvpList, Charset .forName("UTF-8"))); HttpResponse
542         * response = client.execute(httppost); //
543         * System.out.println("[StatusLine] " + response.getStatusLine());
544         * HttpEntity entity = response.getEntity(); String entityString =
545         * EntityUtils.toString(entity, "UTF-8"); return entityString; }
546         */
547
548        /**
549         * 縲€謖�ｮ壹＆繧後◆繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ繧定ｵｷ轤ｹ縺ｨ縺励€√◎縺ｮ繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ縺ｫ繝ｪ繝ｳ繧ｯ縺悟ｼｵ繧峨ｌ縺ｦ縺�ｋ繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ縺ｮ髮�粋繧貞叙蠕励☆繧九€�
550         * 縲€蜿門ｾ励＆繧後◆蜷�う繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ縺ｮ繧ｯ繝ｩ繧ｹ繧らｶｲ鄒�噪縺ｫ蜿門ｾ励☆繧�
551         * <p>
552         * 縺薙％縺ｧ繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ縺ｨ縺ｯ縲〉df:type縺ｮ荳ｻ隱槭→縺励※險倩ｿｰ縺輔ｌ縺ｦ縺�ｋ繧ゅ�繧偵＞縺�<br>
553         * 蜃ｦ逅�ｯｾ雎｡繝��繧ｿ繧暖raphURIs縺ｧ謖�ｮ壹☆繧九％縺ｨ縺後〒縺阪ｋ <br>
554         * </p>
555         *
556         * @param graphURIs
557         *            縲€讀懃ｴ｢蟇ｾ雎｡縺ｮgraph縺ｮURI驟榊� 縲€(null繧�聞縺�縺ｮ驟榊�繧ょ庄)
558         * @param originInstance
559         *            襍ｷ轤ｹ縺ｨ縺ｪ繧九う繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ縺ｮURI縲€��ull荳榊庄��
560         * @param limit
561         *            隗｣縺ｨ縺励※霑斐＆繧後ｋInstanceLink驟榊�縺ｮ髟ｷ縺輔�荳企剞蛟､繧呈欠螳壹☆繧九€�荳企剞蛟､繧定ｨｭ螳壹＠縺ｪ縺�ｴ蜷医�0莉･荳九�蛟､繧呈欠螳壹☆繧�
562         * @return InstanceLink縺ｮ驟榊�縲ゅ％縺薙↓縺ｯ縲∝叙蠕励＆繧後◆繧ｯ繝ｩ繧ｹ縺ｨ髢｢菫ゅ▼縺代ｉ繧後※縺�ｋ繝励Ο繝代ユ繧｣縲�未菫ゅ�蜷代″縺悟性縺ｾ繧後ｋ縲�
563         * @throws Exception
564         * @since 28.01.2014
565         */
566        public InstanceLink[] getNextInstancesViaInstanceLink(String[] graphURIs,
567                        String originInstance, int limit) throws Exception {
568                StringBuffer queryStr = new StringBuffer();
569                queryStr.append("PREFIX owl: <http://www.w3.org/2002/07/owl#>\n");
570                queryStr.append("PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>\n");
571                queryStr.append("PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>\n");
572                queryStr.append("SELECT DISTINCT ?pf ?pr ?ins ?c \n");
573                if (graphURIs != null) {
574                        for (String graphURI : graphURIs) {
575                                queryStr.append("FROM <");
576                                queryStr.append(graphURI);
577                                queryStr.append(">\n");
578                        }
579                }
580                queryStr.append("WHERE{\n");
581                // queryStr.append("  { ?c rdf:type rdfs:Class. }\n  UNION\n  { ?c rdf:type owl:Class. }\n");
582                queryStr.append("  ?ins rdf:type ?c.\n");
583                queryStr.append("  { ?ins ?pr <");
584                queryStr.append(originInstance);
585                queryStr.append(">. }\n  UNION { <");
586                queryStr.append(originInstance);
587                queryStr.append("> ?pf ?ins. }\n");
588
589                queryStr.append(" FILTER (?c != rdf:Property)");
590
591                queryStr.append("}\n");
592                if (limit > 0) {
593                        queryStr.append("limit ");
594                        queryStr.append(limit);
595                        queryStr.append("\n");
596                }
597
598                // System.out.println(queryStr.toString());
599
600                Query query = QueryFactory.create(queryStr.toString());
601                QueryExecution qexec = QueryExecutionFactory.sparqlService(endpointURI,
602                                query);
603
604                ResultSet results = qexec.execSelect();
605                HashMap<String, InstanceLink> insLinkMap = new HashMap<String, InstanceLink>();
606                for (; results.hasNext();) {
607                        QuerySolution sol = results.next();
608                        Resource proForward = sol.getResource("pf");
609                        Resource proReverse = sol.getResource("pr");
610                        Resource ins = sol.getResource("ins");
611                        Resource cls = sol.getResource("c");
612                        Direction direction = null;
613                        String propURI = null;
614                        if (proForward != null) {
615                                if (proReverse != null) {
616                                        direction = Direction.both;
617                                } else {
618                                        direction = Direction.forward;
619                                }
620                                propURI = proForward.getURI();
621                        } else {
622                                direction = Direction.reverse;
623                                propURI = proReverse.getURI();
624                        }
625                        String clsURI = cls.getURI();
626                        String insURI = ins.getURI();
627                        String key = propURI + "\t" + insURI + "\t" + direction;
628                        if (insLinkMap.containsKey(key)) {
629                                InstanceLink insLink = insLinkMap.get(key);
630                                insLink.addLinkedClassURI(clsURI);
631                        } else {
632                                InstanceLink insLink = new InstanceLink(propURI, insURI,
633                                                new String[] { clsURI }, direction);
634                                insLinkMap.put(key, insLink);
635                        }
636                }
637                qexec.close();
638                Collection<InstanceLink> values = insLinkMap.values();
639                return values.toArray(new InstanceLink[0]);
640        }
641
642        public LabelMap[] getLabels(String[] graphURIs, String[] resourceURIs,
643                        String language) throws Exception {
644                if (resourceURIs == null || resourceURIs.length == 0) {
645                        return new LabelMap[0];
646                }
647                StringBuffer queryStr = new StringBuffer();
648                queryStr.append("PREFIX owl: <http://www.w3.org/2002/07/owl#>\n");
649                queryStr.append("PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>\n");
650                queryStr.append("PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>\n");
651                queryStr.append("SELECT DISTINCT ?res ?label \n");
652                if (graphURIs != null) {
653                        for (String graphURI : graphURIs) {
654                                queryStr.append("FROM <");
655                                queryStr.append(graphURI);
656                                queryStr.append(">\n");
657                        }
658                }
659                queryStr.append("WHERE{\n");
660                queryStr.append("  ?res rdfs:label ?label.\n");
661                queryStr.append("  FILTER(?res IN (");
662                boolean f = false;
663                for (String resourceURI : resourceURIs) {
664                        if (f) {
665                                queryStr.append(", ");
666                        }
667                        f = true;
668                        queryStr.append("<");
669                        queryStr.append(resourceURI);
670                        queryStr.append(">");
671                }
672                queryStr.append("))\n");
673                queryStr.append("}");
674
675                System.out.println(queryStr.toString());
676
677                Query query = QueryFactory.create(queryStr.toString());
678                QueryExecution qexec = QueryExecutionFactory.sparqlService(endpointURI,
679                                query);
680
681                ResultSet results = qexec.execSelect();
682                HashMap<String, LabelMap> lMap = new HashMap<String, LabelMap>();
683                for (; results.hasNext();) {
684                        QuerySolution sol = results.next();
685                        String uri = sol.getResource("res").getURI();
686                        Literal literal = sol.getLiteral("label");
687                        if (literal != null) {
688                                String label = literal.getString();
689                                String lang = literal.getLanguage();
690                                if (language != null && language.equals(lang)) {
691                                        Label lbl = new Label(label, lang);
692                                        if (lMap.containsKey(uri)) {
693                                                LabelMap lm = lMap.get(uri);
694                                                lm.addLabel(lbl);
695                                        } else {
696                                                LabelMap lm = new LabelMap(uri, new Label[] { lbl });
697                                                lMap.put(uri, lm);
698                                        }
699                                }
700                        }
701                }
702                return lMap.values().toArray(new LabelMap[0]);
703        }
704
705        public ClassLink[] countLinks(String[] graphURIs, String startClassURI,
706                        ClassLink[] classLinks) throws Exception {
707                if (classLinks == null || classLinks.length == 0) {
708                        return new ClassLink[0];
709                }
710                for (ClassLink classLink : classLinks) {
711                        StringBuffer queryStr = new StringBuffer();
712                        queryStr.append("PREFIX owl: <http://www.w3.org/2002/07/owl#>\n");
713                        queryStr.append("PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>\n");
714                        queryStr.append("PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>\n");
715
716                        queryStr.append("SELECT (COUNT(?os) AS ?numOfLinks) \n");
717                        if (graphURIs != null) {
718                                for (String graphURI : graphURIs) {
719                                        queryStr.append("FROM <");
720                                        queryStr.append(graphURI);
721                                        queryStr.append(">\n");
722                                }
723                        }
724
725                        queryStr.append("WHERE{\n");
726                        if (classLink.getDirection() == Direction.forward) {
727                                queryStr.append("?is rdf:type  <");
728                                queryStr.append(startClassURI);
729                                queryStr.append(">.\n");
730                                queryStr.append("?os rdf:type  <");
731                                queryStr.append(classLink.getLinkedClassURI());
732                                queryStr.append(">.\n");
733                                queryStr.append("?is <");
734                                queryStr.append(classLink.getPropertyURI());
735                                queryStr.append("> ?os.\n");
736                                queryStr.append("}");
737                        } else {
738                                if (classLink.getDirection() == Direction.forward) {
739                                        queryStr.append("?os rdf:type  <");
740                                        queryStr.append(startClassURI);
741                                        queryStr.append(">.\n");
742                                        queryStr.append("?is rdf:type  <");
743                                        queryStr.append(classLink.getLinkedClassURI());
744                                        queryStr.append(">.\n");
745                                        queryStr.append("?is <");
746                                        queryStr.append(classLink.getPropertyURI());
747                                        queryStr.append("> ?os.\n");
748                                        queryStr.append("}");
749                                } else {
750                                        queryStr.append("?os rdf:type  <");
751                                        queryStr.append(startClassURI);
752                                        queryStr.append(">.\n");
753                                        queryStr.append("?is rdf:type  <");
754                                        queryStr.append(classLink.getLinkedClassURI());
755                                        queryStr.append(">.\n");
756                                        queryStr.append("{?is <");
757                                        queryStr.append(classLink.getPropertyURI());
758                                        queryStr.append("> ?os.}\n");
759                                        queryStr.append("UNION\n");
760                                        queryStr.append("{?os <");
761                                        queryStr.append(classLink.getPropertyURI());
762                                        queryStr.append("> ?is.}\n");
763                                        queryStr.append("}");
764                                }
765                        }
766                        System.out.println(queryStr.toString());
767
768                        Query query = QueryFactory.create(queryStr.toString());
769                        QueryExecution qexec = QueryExecutionFactory.sparqlService(
770                                        endpointURI, query);
771
772                        ResultSet results = qexec.execSelect();
773                        if (results.hasNext()) {
774                                QuerySolution sol = results.next();
775                                Literal lit = sol.getLiteral("numOfLinks");
776                                if (lit != null) {
777                                        int numOfLinks = lit.getInt();
778                                        classLink.setNumOfLinks(numOfLinks);
779                                }
780                        }
781                        qexec.close();
782                }
783                return classLinks;
784        }
785
786        public SClass[] countInstances(String[] graphURIs, SClass[] classes)
787                        throws Exception {
788                if (classes == null || classes.length == 0) {
789                        return new SClass[0];
790                }
791                HashMap<String, SClass> classMap = new HashMap<String, SClass>();
792                for (SClass sc : classes) {
793                        classMap.put(sc.getClassURI(), sc);
794                }
795                StringBuffer queryStr = new StringBuffer();
796                queryStr.append("PREFIX owl: <http://www.w3.org/2002/07/owl#>\n");
797                queryStr.append("PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>\n");
798                queryStr.append("PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>\n");
799                queryStr.append("SELECT DISTINCT ?cls  (COUNT(?is) AS ?numOfInstances)\n");
800                if (graphURIs != null) {
801                        for (String graphURI : graphURIs) {
802                                queryStr.append("FROM <");
803                                queryStr.append(graphURI);
804                                queryStr.append(">\n");
805                        }
806                }
807                queryStr.append("WHERE{\n");
808                queryStr.append("  ?is rdf:type ?cls.\n");
809                queryStr.append("  FILTER(?cls IN (");
810                boolean f = false;
811                Set<String> clsSet = classMap.keySet();
812                for (String clsURI : clsSet) {
813                        if (f) {
814                                queryStr.append(", ");
815                        }
816                        f = true;
817                        queryStr.append("<");
818                        queryStr.append(clsURI);
819                        queryStr.append(">");
820                }
821                queryStr.append("))\n");
822                queryStr.append("} GROUP BY ?cls");
823
824                System.out.println(queryStr.toString());
825
826                Query query = QueryFactory.create(queryStr.toString());
827                QueryExecution qexec = QueryExecutionFactory.sparqlService(endpointURI,
828                                query);
829
830                ResultSet results = qexec.execSelect();
831                for (; results.hasNext();) {
832                        QuerySolution sol = results.next();
833                        String uri = sol.getResource("cls").getURI();
834                        SClass sc = classMap.get(uri);
835                        Literal lit = sol.getLiteral("numOfInstances");
836                        if (lit != null) {
837                                int numOfInstances = lit.getInt();
838                                sc.setNumOfInstances(numOfInstances);
839                        }
840                }
841                qexec.close();
842
843                return classes;
844        }
845
846}
Note: リポジトリブラウザについてのヘルプは TracBrowser を参照してください。