root/SPARQLBuilderWWW2016/src/java/org/biohackathon/SPARQLBuilder/OWL/EndpointAnalyzer.java @ 268

リビジョン 268, 39.4 KB (コミッタ: atsuko, 9 年 前)

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