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

リビジョン 60, 36.1 KB (コミッタ: wu, 12 年 前)

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