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

リビジョン 65, 39.2 KB (コミッタ: atsuko, 10 年 前)

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