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

リビジョン 269, 39.0 KB (コミッタ: nori, 10 年 前)

クローラー結果としてCrawledDataset が扱えるようにの暫定版
行番号 
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 graphURI, 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 graphURI, 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 (graphURI != 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 graphURI, 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 (graphURI != 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 graphURI, 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 (graphURI != null) {
384                                queryStr.append("FROM <");
385                                queryStr.append(graphURI);
386                                queryStr.append(">\n");
387                }
388                queryStr.append("WHERE{\n");
389                // queryStr.append(" {?c rdf:type rdfs:Class} UNION {?c rdf:type owl:Class}\n");
390
391                queryStr.append("      ?ins rdf:type ?c.\n");
392                queryStr.append("      ?ins rdfs:label ");
393                queryStr.append(keyword);
394                queryStr.append(".\n");
395                queryStr.append(" FILTER (?c != rdf:Property)");
396                queryStr.append("}");
397
398                // System.out.println(queryStr.toString());
399
400                Query query = QueryFactory.create(queryStr.toString());
401                QueryExecution qexec = QueryExecutionFactory.sparqlService(endpointURI,
402                                query);
403
404                ResultSet results = qexec.execSelect();
405                HashMap<String, HashSet<String>> instanceMap = new HashMap<String, HashSet<String>>();
406                for (; results.hasNext();) {
407                        QuerySolution sol = results.next();
408                        Resource cls = sol.getResource("c");
409                        Resource ins = sol.getResource("ins");
410                        String clsURI = cls.getURI();
411                        String insURI = ins.getURI();
412                        if (instanceMap.containsKey(insURI)) {
413                                HashSet<String> classes = instanceMap.get(insURI);
414                                classes.add(clsURI);
415                        } else {
416                                HashSet<String> classes = new HashSet<String>();
417                                instanceMap.put(insURI, classes);
418                                classes.add(clsURI);
419                        }
420                }
421                qexec.close();
422                Set<String> keySet = instanceMap.keySet();
423                ArrayList<Instance> instanceList = new ArrayList<Instance>();
424                for (String key : keySet) {
425                        Instance ins = new Instance(key, instanceMap.get(key).toArray(
426                                        new String[0]));
427                        instanceList.add(ins);
428                }
429                return instanceList.toArray(new Instance[0]);
430        }
431
432        /**
433         * 縲€謖�ｮ壹＆繧後◆繧ｯ繝ｩ繧ｹ繧定ｵｷ轤ｹ縺ｨ縺励€∵�遉ｺ逧�↓險倩ｿｰ縺輔ｌ縺ｦ縺�ｋOWL縺ｮproperty蛻ｶ邏�ｒ隱ｿ縺ｹ縲√◎縺ｮproperty蛻ｶ邏�〒
434         * 髢｢騾｣縺･縺代ｉ繧後※縺�ｋ繧ｯ繝ｩ繧ｹ繧堤ｶｲ鄒�噪縺ｫ蜿門ｾ励☆繧�
435         * <p>
436         * 蜃ｦ逅�ｯｾ雎｡繝��繧ｿ繧暖raphURIs縺ｧ謖�ｮ壹☆繧九％縺ｨ縺後〒縺阪ｋ <br>
437         * <br>
438         * </p>
439         *
440         * @param graphURIs
441         *            縲€讀懃ｴ｢蟇ｾ雎｡縺ｮgraph縺ｮURI驟榊� 縲€(null繧�聞縺�縺ｮ驟榊�繧ょ庄)
442         * @param originClass
443         *            襍ｷ轤ｹ縺ｨ縺ｪ繧九け繝ｩ繧ｹ縺ｮURI縲€��ull荳榊庄��
444         * @param limit
445         *            隗｣縺ｨ縺励※霑斐＆繧後ｋClassLink驟榊�縺ｮ髟ｷ縺輔�荳企剞蛟､繧呈欠螳壹☆繧九€�荳企剞蛟､繧定ｨｭ螳壹＠縺ｪ縺�ｴ蜷医�0莉･荳九�蛟､繧呈欠螳壹☆繧�
446         * @return ClassLink縺ｮ驟榊�縲ゅ％縺薙↓縺ｯ縲∝叙蠕励＆繧後◆繧ｯ繝ｩ繧ｹ縺ｨ髢｢菫ゅ▼縺代ｉ繧後※縺�ｋ繝励Ο繝代ユ繧｣縲�未菫ゅ�蜷代″縺悟性縺ｾ繧後ｋ縲�
447         * @throws Exception
448         * @since 28.01.2014
449         */
450        public ClassLink[] getNextClass(String graphURI, String originClass,
451                        int limit, boolean countLinks) throws Exception {
452                ClassLink[] cLinks = getNextClassSub(graphURI, originClass, limit,
453                                false);
454                if (countLinks) {
455                        cLinks = countLinks(graphURI, originClass, cLinks);
456                }
457                return cLinks;
458        }
459
460        private ClassLink[] getNextClassSub(String graphURI, String originClass,
461                        int limit, boolean countLinks) throws Exception {
462                StringBuffer queryStr = new StringBuffer();
463                queryStr.append("PREFIX owl: <http://www.w3.org/2002/07/owl#>\n");
464                queryStr.append("PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>\n");
465                queryStr.append("PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>\n");
466
467                // SELECT
468                if (countLinks) {
469                        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");
470                } else {
471                        queryStr.append("SELECT DISTINCT ?p ?pDirection ?c \n");
472                }
473
474                if (graphURI != null) {
475                                queryStr.append("FROM <");
476                                queryStr.append(graphURI);
477                                queryStr.append(">\n");
478                }
479                queryStr.append("WHERE{\n");
480                // queryStr.append("  { ?c rdf:type rdfs:Class. }\n  UNION\n  { ?c rdf:type owl:Class. }\n");
481                queryStr.append("  { ?p rdfs:domain <");
482                queryStr.append(originClass);
483                queryStr.append(">.\n    ?p rdfs:range ?c.\n");
484
485                if (countLinks) {
486                        queryStr.append("    ?o ?p ?s.");
487                } else {
488                        queryStr.append("filter(exists{\n");
489                        queryStr.append("  ?o rdf:type ?c.\n");
490                        queryStr.append(" ?s rdf:type <");
491                        queryStr.append(originClass);
492                        queryStr.append(">.\n");
493                        queryStr.append("       ?s ?p ?o.})\n");
494                }
495
496                queryStr.append("}\n  UNION\n");
497                queryStr.append("  { ?p rdfs:range <");
498                queryStr.append(originClass);
499                queryStr.append(">.\n");
500                queryStr.append("    ?p rdfs:domain ?c.\n");
501
502                if (countLinks) {
503                        queryStr.append("    ?s ?p ?o.");
504                } else {
505                        queryStr.append("filter(exists{\n");
506                        queryStr.append("  ?s rdf:type ?c.\n");
507                        queryStr.append(" ?o rdf:type <");
508                        queryStr.append(originClass);
509                        queryStr.append(">.\n");
510                        queryStr.append("       ?s ?p ?o.})\n");
511                }
512
513                queryStr.append("}\n");
514
515                queryStr.append("    ?p ?pDirection ?c.\n");
516
517                // queryStr.append("  ?s rdf:type ?c.\n");
518
519                if (countLinks) {
520                        queryStr.append("}\nGROUP BY ?p ?pDirection ?c\n");
521                } else {
522                        queryStr.append("}\n");
523                }
524                if (limit > 0) {
525                        queryStr.append("limit ");
526                        queryStr.append(limit);
527                        queryStr.append("\n");
528                }
529
530                System.out.println("getNextClasses SPARQL Query: ");
531                System.out.println(queryStr.toString());
532
533                Query query = QueryFactory.create(queryStr.toString());
534                QueryExecution qexec = null;
535                try {
536                        qexec = QueryExecutionFactory.sparqlService(endpointURI, query);
537                } catch (Exception ex) {
538                        ex.printStackTrace();
539                        throw ex;
540                }
541
542                ResultSet results = null;
543                try {
544                        long start = System.currentTimeMillis();
545                        results = qexec.execSelect();
546                        long end = System.currentTimeMillis();
547                        System.out.println("EXEC TIME: " + (end - start));
548                } catch (Exception ex) {
549                        ex.printStackTrace();
550                        throw ex;
551                }
552
553                ArrayList<ClassLink> solCLs = new ArrayList<ClassLink>();
554                for (; results.hasNext();) {
555                        QuerySolution sol = results.next();
556                        Resource pro = sol.getResource("p");
557                        if (pro != null) {
558                                Resource cls = sol.getResource("c");
559                                Resource dir = sol.getResource("pDirection");
560                                String proURI = pro.getURI();
561                                String clsURI = cls.getURI();
562                                String dirURI = dir.getURI();
563
564                                // System.out.println(pro.getURI() + " " + cls.getURI() + " " +
565                                // dir.getURI());
566
567                                Direction direction = null;
568                                if (dirURI
569                                                .equals("http://www.w3.org/2000/01/rdf-schema#domain")
570                                                || dirURI.equals("rdfs:domain")) {
571                                        direction = Direction.reverse;
572                                }
573                                if (dirURI.equals("http://www.w3.org/2000/01/rdf-schema#range")
574                                                || dirURI.equals("rdfs:range")) {
575                                        if (direction != null) {
576                                                direction = Direction.both;
577                                        } else {
578                                                direction = Direction.forward;
579                                        }
580                                }
581                                // System.out.println(direction);
582                                int numOfLinks = 0;
583                                if (countLinks) {
584                                        numOfLinks = sol.getLiteral("numOfLinks").getInt();
585                                }
586                                ClassLink cl = new ClassLink(proURI, clsURI, null,direction,
587                                                numOfLinks, 0, 0, 0, 0, true, true);
588                                solCLs.add(cl);
589                        }
590                }
591                qexec.close();
592                return solCLs.toArray(new ClassLink[0]);
593        }
594
595        /**
596         * 縲€謖�ｮ壹＆繧後◆繧ｯ繝ｩ繧ｹ繧定ｵｷ轤ｹ縺ｨ縺励€√◎縺ｮ繧ｯ繝ｩ繧ｹ縺ｫ螻槭＠縺ｦ縺�ｋ繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ縺ｨ繝ｪ繝ｳ繧ｯ縺悟ｼｵ繧峨ｌ縺ｦ縺�ｋ繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ縺ｮ髮�粋繧貞叙蠕励＠縲�
597         * 蜿門ｾ励＠縺溘う繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ縺ｮ繧ｯ繝ｩ繧ｹ繧堤ｶｲ鄒�噪縺ｫ蜿門ｾ励☆繧�
598         * <p>
599         * 縺薙％縺ｧ繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ縺ｨ縺ｯ縲〉df:type縺ｮ荳ｻ隱槭→縺励※險倩ｿｰ縺輔ｌ縺ｦ縺�ｋ繧ゅ�繧偵＞縺�<br>
600         * 蜃ｦ逅�ｯｾ雎｡繝��繧ｿ繧暖raphURIs縺ｧ謖�ｮ壹☆繧九％縺ｨ縺後〒縺阪ｋ <br>
601         * </p>
602         *
603         * @param graphURIs
604         *            縲€讀懃ｴ｢蟇ｾ雎｡縺ｮgraph縺ｮURI驟榊� 縲€(null繧�聞縺�縺ｮ驟榊�繧ょ庄)
605         * @param originClass
606         *            襍ｷ轤ｹ縺ｨ縺ｪ繧九け繝ｩ繧ｹ縺ｮURI縲€��ull荳榊庄��
607         * @param limit
608         *            隗｣縺ｨ縺励※霑斐＆繧後ｋClassLink驟榊�縺ｮ髟ｷ縺輔�荳企剞蛟､繧呈欠螳壹☆繧九€�荳企剞蛟､繧定ｨｭ螳壹＠縺ｪ縺�ｴ蜷医�0莉･荳九�蛟､繧呈欠螳壹☆繧�
609         * @return ClassLink縺ｮ驟榊�縲ゅ％縺薙↓縺ｯ縲∝叙蠕励＆繧後◆繧ｯ繝ｩ繧ｹ縺ｨ髢｢菫ゅ▼縺代ｉ繧後※縺�ｋ繝励Ο繝代ユ繧｣縲�未菫ゅ�蜷代″縺悟性縺ｾ繧後ｋ縲�
610         * @throws Exception
611         * @since 28.01.2014
612         */
613        public ClassLink[] getNextClassViaInstanceLink(String graphURI,
614                        String originClass, int limit) throws Exception {
615                StringBuffer queryStr = new StringBuffer();
616                queryStr.append("PREFIX owl: <http://www.w3.org/2002/07/owl#>\n");
617                queryStr.append("PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>\n");
618                queryStr.append("PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>\n");
619                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");
620                if (graphURI != null) {
621//                      for (String graphURI : graphURIs) {
622                                queryStr.append("FROM <");
623                                queryStr.append(graphURI);
624                                queryStr.append(">\n");
625//                      }
626                }
627                queryStr.append("WHERE{\n");
628                queryStr.append("  ?ins rdf:type ?c.\n");
629                queryStr.append("  ?insOrg rdf:type <");
630                queryStr.append(originClass);
631                queryStr.append(">.\n");
632                queryStr.append("  { ?ins ?pr ?insOrg. }\n  UNION { ?insOrg ?pf ?ins. }\n");
633                queryStr.append("}\n");
634                queryStr.append("GROUP BY ?pf ?pr ?c\n");
635                if (limit > 0) {
636                        queryStr.append("limit ");
637                        queryStr.append(limit);
638                        queryStr.append("\n");
639                }
640
641                System.out.println(queryStr.toString());
642
643                Query query = QueryFactory.create(queryStr.toString());
644                QueryExecution qexec = QueryExecutionFactory.sparqlService(endpointURI,
645                                query);
646
647                ResultSet results = null;
648                try {
649                        long start = System.currentTimeMillis();
650                        results = qexec.execSelect();
651                        long end = System.currentTimeMillis();
652                        System.out.println("EXEC TIME: " + (end - start));
653                } catch (Exception ex) {
654                        ex.printStackTrace();
655                        throw ex;
656                }
657
658                ArrayList<ClassLink> solCLs = new ArrayList<ClassLink>();
659                for (; results.hasNext();) {
660                        QuerySolution sol = results.next();
661                        Resource proForward = sol.getResource("pf");
662                        Resource proReverse = sol.getResource("pr");
663                        Resource cls = sol.getResource("c");
664                        Direction direction = null;
665                        String propURI = null;
666                        int numOfLinks = 0;
667                        int numOfLinkedInstances = 0;
668                        int numOfOriginInstances = 0;
669                        if (proForward != null) {
670                                if (proReverse != null) {
671                                        numOfLinks = sol.getLiteral("numOfForwardLinks").getInt();
672                                        numOfLinks += sol.getLiteral("numOfReverseLinks").getInt();
673                                        numOfLinkedInstances = sol.getLiteral(
674                                                        "numOfLinkedInstances").getInt();
675                                        numOfOriginInstances = sol.getLiteral(
676                                                        "numOfOriginInstances").getInt();
677                                        direction = Direction.both;
678                                } else {
679                                        numOfLinkedInstances = sol.getLiteral(
680                                                        "numOfLinkedInstances").getInt();
681                                        numOfOriginInstances = sol.getLiteral(
682                                                        "numOfOriginInstances").getInt();
683                                        numOfLinks = sol.getLiteral("numOfForwardLinks").getInt();
684                                        direction = Direction.forward;
685                                }
686                                propURI = proForward.getURI();
687                        } else {
688                                direction = Direction.reverse;
689                                propURI = proReverse.getURI();
690                                numOfLinkedInstances = sol.getLiteral("numOfOriginInstances")
691                                                .getInt();
692                                numOfOriginInstances = sol.getLiteral("numOfLinkedInstances")
693                                                .getInt();
694                                numOfLinks = sol.getLiteral("numOfReverseLinks").getInt();
695                        }
696                        String clsURI = cls.getURI();
697                        // System.out.println(propURI + " " + clsURI + " " + direction);
698
699                        ClassLink cl = new ClassLink(propURI, clsURI, null, direction,
700                                        numOfLinks, numOfOriginInstances, numOfLinkedInstances, 0,
701                                        0, true, true);
702                        solCLs.add(cl);
703                }
704                qexec.close();
705                return solCLs.toArray(new ClassLink[0]);
706        }
707
708/*
709        public Path[] getPaths(String startClass, String endClass, int mode,
710                        boolean countLinks) throws Exception {
711                OWLClassGraph graph = new OWLClassGraph(startClass, endClass);
712                // mode = 2 & countLinks = true are recommended
713                return graph.getPaths(this, mode, countLinks);
714        }
715
716        public String createSPARQL(Path path) throws Exception {
717                return null;
718        }
719*/
720
721        /*
722         * private String executeSelect(String sparqlQuery) throws Exception {
723         * HttpClient client = HttpClientBuilder.create().build(); HttpPost httppost
724         * = new HttpPost(endpointURI); httppost.setHeader("Content-Type",
725         * "application/x-www-form-urlencoded"); httppost.setHeader("Accept",
726         * "application/sparql-results+xml"); List<NameValuePair> nvpList = new
727         * ArrayList<NameValuePair>(); nvpList.add(new BasicNameValuePair("query",
728         * sparqlQuery)); // nvpList.add(new BasicNameValuePair("format", //
729         * outputFormat.getMime())); httppost.setEntity(new
730         * UrlEncodedFormEntity(nvpList, Charset .forName("UTF-8"))); HttpResponse
731         * response = client.execute(httppost); //
732         * System.out.println("[StatusLine] " + response.getStatusLine());
733         * HttpEntity entity = response.getEntity(); String entityString =
734         * EntityUtils.toString(entity, "UTF-8"); return entityString; }
735         */
736
737        /**
738         * 縲€謖�ｮ壹＆繧後◆繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ繧定ｵｷ轤ｹ縺ｨ縺励€√◎縺ｮ繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ縺ｫ繝ｪ繝ｳ繧ｯ縺悟ｼｵ繧峨ｌ縺ｦ縺�ｋ繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ縺ｮ髮�粋繧貞叙蠕励☆繧九€�
739         * 縲€蜿門ｾ励＆繧後◆蜷�う繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ縺ｮ繧ｯ繝ｩ繧ｹ繧らｶｲ鄒�噪縺ｫ蜿門ｾ励☆繧�
740         * <p>
741         * 縺薙％縺ｧ繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ縺ｨ縺ｯ縲〉df:type縺ｮ荳ｻ隱槭→縺励※險倩ｿｰ縺輔ｌ縺ｦ縺�ｋ繧ゅ�繧偵＞縺�<br>
742         * 蜃ｦ逅�ｯｾ雎｡繝��繧ｿ繧暖raphURIs縺ｧ謖�ｮ壹☆繧九％縺ｨ縺後〒縺阪ｋ <br>
743         * </p>
744         *
745         * @param graphURIs
746         *            縲€讀懃ｴ｢蟇ｾ雎｡縺ｮgraph縺ｮURI驟榊� 縲€(null繧�聞縺�縺ｮ驟榊�繧ょ庄)
747         * @param originInstance
748         *            襍ｷ轤ｹ縺ｨ縺ｪ繧九う繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ縺ｮURI縲€��ull荳榊庄��
749         * @param limit
750         *            隗｣縺ｨ縺励※霑斐＆繧後ｋInstanceLink驟榊�縺ｮ髟ｷ縺輔�荳企剞蛟､繧呈欠螳壹☆繧九€�荳企剞蛟､繧定ｨｭ螳壹＠縺ｪ縺�ｴ蜷医�0莉･荳九�蛟､繧呈欠螳壹☆繧�
751         * @return InstanceLink縺ｮ驟榊�縲ゅ％縺薙↓縺ｯ縲∝叙蠕励＆繧後◆繧ｯ繝ｩ繧ｹ縺ｨ髢｢菫ゅ▼縺代ｉ繧後※縺�ｋ繝励Ο繝代ユ繧｣縲�未菫ゅ�蜷代″縺悟性縺ｾ繧後ｋ縲�
752         * @throws Exception
753         * @since 28.01.2014
754         */
755        public InstanceLink[] getNextInstancesViaInstanceLink(String graphURI,
756                        String originInstance, int limit) throws Exception {
757                StringBuffer queryStr = new StringBuffer();
758                queryStr.append("PREFIX owl: <http://www.w3.org/2002/07/owl#>\n");
759                queryStr.append("PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>\n");
760                queryStr.append("PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>\n");
761                queryStr.append("SELECT DISTINCT ?pf ?pr ?ins ?c \n");
762                if (graphURI != null) {
763                                queryStr.append("FROM <");
764                                queryStr.append(graphURI);
765                                queryStr.append(">\n");
766                }
767                queryStr.append("WHERE{\n");
768                // queryStr.append("  { ?c rdf:type rdfs:Class. }\n  UNION\n  { ?c rdf:type owl:Class. }\n");
769                queryStr.append("  ?ins rdf:type ?c.\n");
770                queryStr.append("  { ?ins ?pr <");
771                queryStr.append(originInstance);
772                queryStr.append(">. }\n  UNION { <");
773                queryStr.append(originInstance);
774                queryStr.append("> ?pf ?ins. }\n");
775
776                queryStr.append(" FILTER (?c != rdf:Property)");
777
778                queryStr.append("}\n");
779                if (limit > 0) {
780                        queryStr.append("limit ");
781                        queryStr.append(limit);
782                        queryStr.append("\n");
783                }
784
785                // System.out.println(queryStr.toString());
786
787                Query query = QueryFactory.create(queryStr.toString());
788                QueryExecution qexec = QueryExecutionFactory.sparqlService(endpointURI,
789                                query);
790
791                ResultSet results = qexec.execSelect();
792                HashMap<String, InstanceLink> insLinkMap = new HashMap<String, InstanceLink>();
793                for (; results.hasNext();) {
794                        QuerySolution sol = results.next();
795                        Resource proForward = sol.getResource("pf");
796                        Resource proReverse = sol.getResource("pr");
797                        Resource ins = sol.getResource("ins");
798                        Resource cls = sol.getResource("c");
799                        Direction direction = null;
800                        String propURI = null;
801                        if (proForward != null) {
802                                if (proReverse != null) {
803                                        direction = Direction.both;
804                                } else {
805                                        direction = Direction.forward;
806                                }
807                                propURI = proForward.getURI();
808                        } else {
809                                direction = Direction.reverse;
810                                propURI = proReverse.getURI();
811                        }
812                        String clsURI = cls.getURI();
813                        String insURI = ins.getURI();
814                        String key = propURI + "\t" + insURI + "\t" + direction;
815                        if (insLinkMap.containsKey(key)) {
816                                InstanceLink insLink = insLinkMap.get(key);
817                                insLink.addLinkedClassURI(clsURI);
818                        } else {
819                                InstanceLink insLink = new InstanceLink(propURI, insURI,
820                                                new String[] { clsURI }, direction);
821                                insLinkMap.put(key, insLink);
822                        }
823                }
824                qexec.close();
825                Collection<InstanceLink> values = insLinkMap.values();
826                return values.toArray(new InstanceLink[0]);
827        }
828
829        public LabelMap[] getLabels(String graphURI, String[] resourceURIs,
830                        String language) throws Exception {
831//              if (resourceURIs == null || resourceURIs.length == 0) {
832//                      return new LabelMap[0];
833//              }
834                StringBuffer queryStr = new StringBuffer();
835                queryStr.append("PREFIX owl: <http://www.w3.org/2002/07/owl#>\n");
836                queryStr.append("PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>\n");
837                queryStr.append("PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>\n");
838                queryStr.append("SELECT DISTINCT ?res ?label \n");
839                if (graphURI != null) {
840                                queryStr.append("FROM <");
841                                queryStr.append(graphURI);
842                                queryStr.append(">\n");
843                }
844                queryStr.append("WHERE{\n");
845                queryStr.append("  ?res rdfs:label ?label.\n");
846                queryStr.append("  FILTER(?res IN (");
847                boolean f = false;
848                for (String resourceURI : resourceURIs) {
849                        if (f) {
850                                queryStr.append(", ");
851                        }
852                        f = true;
853                        queryStr.append("<");
854                        queryStr.append(resourceURI);
855                        queryStr.append(">");
856                }
857                queryStr.append("))\n");
858                queryStr.append("}");
859
860                System.out.println(queryStr.toString());
861
862                Query query = QueryFactory.create(queryStr.toString());
863                QueryExecution qexec = QueryExecutionFactory.sparqlService(endpointURI,
864                                query);
865
866                ResultSet results = qexec.execSelect();
867                HashMap<String, LabelMap> lMap = new HashMap<String, LabelMap>();
868                for (; results.hasNext();) {
869                        QuerySolution sol = results.next();
870                        String uri = sol.getResource("res").getURI();
871                        Literal literal = sol.getLiteral("label");
872                        if (literal != null) {
873                                String label = literal.getString();
874                                String lang = literal.getLanguage();
875                                if (language != null && language.equals(lang)) {
876                                        Label lbl = new Label(label, lang);
877                                        if (lMap.containsKey(uri)) {
878                                                LabelMap lm = lMap.get(uri);
879                                                lm.addLabel(lbl);
880                                        } else {
881                                                LabelMap lm = new LabelMap(uri, new Label[] { lbl });
882                                                lMap.put(uri, lm);
883                                        }
884                                }
885                        }
886                }
887                return lMap.values().toArray(new LabelMap[0]);
888        }
889
890        public ClassLink[] countLinks(String graphURI, String startClassURI,
891                        ClassLink[] classLinks) throws Exception {
892                if (classLinks == null || classLinks.length == 0) {
893                        return new ClassLink[0];
894                }
895                for (ClassLink classLink : classLinks) {
896                        StringBuffer queryStr = new StringBuffer();
897                        queryStr.append("PREFIX owl: <http://www.w3.org/2002/07/owl#>\n");
898                        queryStr.append("PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>\n");
899                        queryStr.append("PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>\n");
900
901                        queryStr.append("SELECT (COUNT(?os) AS ?numOfLinks) (COUNT(DISTINCT(?is)) AS ?numOfOriginInstances) (COUNT(DISTINCT(?os)) AS ?numOfLinkedInstances) \n");
902                        if (graphURI != null) {
903                                        queryStr.append("FROM <");
904                                        queryStr.append(graphURI);
905                                        queryStr.append(">\n");
906                        }
907
908                        queryStr.append("WHERE{\n");
909                        if (classLink.getDirection() == Direction.forward) {
910                                queryStr.append("?is rdf:type  <");
911                                queryStr.append(startClassURI);
912                                queryStr.append(">.\n");
913                                queryStr.append("?os rdf:type  <");
914                                queryStr.append(classLink.getLinkedClassURI());
915                                queryStr.append(">.\n");
916                                queryStr.append("?is <");
917                                queryStr.append(classLink.getPropertyURI());
918                                queryStr.append("> ?os.\n");
919                                queryStr.append("}");
920                        } else {
921                                if (classLink.getDirection() == Direction.forward) {
922                                        queryStr.append("?os rdf:type  <");
923                                        queryStr.append(startClassURI);
924                                        queryStr.append(">.\n");
925                                        queryStr.append("?is rdf:type  <");
926                                        queryStr.append(classLink.getLinkedClassURI());
927                                        queryStr.append(">.\n");
928                                        queryStr.append("?is <");
929                                        queryStr.append(classLink.getPropertyURI());
930                                        queryStr.append("> ?os.\n");
931                                        queryStr.append("}");
932                                } else {
933                                        queryStr.append("?os rdf:type  <");
934                                        queryStr.append(startClassURI);
935                                        queryStr.append(">.\n");
936                                        queryStr.append("?is rdf:type  <");
937                                        queryStr.append(classLink.getLinkedClassURI());
938                                        queryStr.append(">.\n");
939                                        queryStr.append("{?is <");
940                                        queryStr.append(classLink.getPropertyURI());
941                                        queryStr.append("> ?os.}\n");
942                                        queryStr.append("UNION\n");
943                                        queryStr.append("{?os <");
944                                        queryStr.append(classLink.getPropertyURI());
945                                        queryStr.append("> ?is.}\n");
946                                        queryStr.append("}");
947                                }
948                        }
949                        System.out.println(queryStr.toString());
950
951                        Query query = QueryFactory.create(queryStr.toString());
952                        QueryExecution qexec = QueryExecutionFactory.sparqlService(
953                                        endpointURI, query);
954
955                        ResultSet results = qexec.execSelect();
956                        if (results.hasNext()) {
957                                QuerySolution sol = results.next();
958                                Literal lit = sol.getLiteral("numOfLinks");
959                                if (lit != null) {
960                                        int numOfLinks = lit.getInt();
961                                        classLink.setNumOfLinks(numOfLinks);
962                                }
963                                lit = sol.getLiteral("numOfLinkedInstances");
964                                if (lit != null) {
965                                        int numOfLinkedInstances = lit.getInt();
966                                        classLink.setNumOfLinkedInstances(numOfLinkedInstances);
967                                }
968                                lit = sol.getLiteral("numOfOriginInstances");
969                                if (lit != null) {
970                                        int numOfOriginInstances = lit.getInt();
971                                        classLink.setNumOfOriginInstances(numOfOriginInstances);
972                                }
973                                lit = sol.getLiteral("numOfOriginClassInstances");
974                                if (lit != null) {
975                                        int numOfOriginClassInstances = lit.getInt();
976                                        classLink
977                                                        .setNumOfOriginClassInstances(numOfOriginClassInstances);
978                                }
979                                lit = sol.getLiteral("numOfLinkedClassInstances");
980                                if (lit != null) {
981                                        int numOfLinkedClassInstances = lit.getInt();
982                                        classLink
983                                                        .setNumOfLinkedClassInstances(numOfLinkedClassInstances);
984                                }
985                        }
986                        qexec.close();
987
988                        // count instances
989                        queryStr = new StringBuffer();
990                        queryStr.append("PREFIX owl: <http://www.w3.org/2002/07/owl#>\n");
991                        queryStr.append("PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>\n");
992                        queryStr.append("PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>\n");
993
994                        queryStr.append("SELECT (COUNT(?ics) AS ?numOfOriginClassInstances) \n");
995                        if (graphURI != null) {
996                                        queryStr.append("FROM <");
997                                        queryStr.append(graphURI);
998                                        queryStr.append(">\n");
999                        }
1000
1001                        queryStr.append("WHERE{\n");
1002                        if (classLink.getDirection() == Direction.forward) {
1003                                queryStr.append("?ics rdf:type  <");
1004                                queryStr.append(startClassURI);
1005                                queryStr.append(">.\n");
1006                                queryStr.append("}");
1007                        } else {
1008                                if (classLink.getDirection() == Direction.forward) {
1009                                        queryStr.append("?ics rdf:type  <");
1010                                        queryStr.append(classLink.getLinkedClassURI());
1011                                        queryStr.append(">.\n");
1012                                        queryStr.append("}");
1013                                } else {
1014                                        queryStr.append("?ics rdf:type  <");
1015                                        queryStr.append(classLink.getLinkedClassURI());
1016                                        queryStr.append(">.\n");
1017                                        queryStr.append("}");
1018                                }
1019                        }
1020
1021                        System.out.println(queryStr.toString());
1022
1023                        query = QueryFactory.create(queryStr.toString());
1024                        qexec = QueryExecutionFactory.sparqlService(endpointURI, query);
1025
1026                        results = qexec.execSelect();
1027                        if (results.hasNext()) {
1028                                QuerySolution sol = results.next();
1029                                Literal lit = null;
1030                                lit = sol.getLiteral("numOfOriginClassInstances");
1031                                if (lit != null) {
1032                                        int numOfOriginClassInstances = lit.getInt();
1033                                        classLink
1034                                                        .setNumOfOriginClassInstances(numOfOriginClassInstances);
1035                                }
1036                        }
1037                        qexec.close();
1038
1039                        // count instances
1040                        queryStr = new StringBuffer();
1041                        queryStr.append("PREFIX owl: <http://www.w3.org/2002/07/owl#>\n");
1042                        queryStr.append("PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>\n");
1043                        queryStr.append("PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>\n");
1044
1045                        queryStr.append("SELECT (COUNT(?ocs) AS ?numOfLinkedClassInstances) \n");
1046                        if (graphURI != null) {
1047                                        queryStr.append("FROM <");
1048                                        queryStr.append(graphURI);
1049                                        queryStr.append(">\n");
1050                        }
1051
1052                        queryStr.append("WHERE{\n");
1053                        if (classLink.getDirection() == Direction.forward) {
1054                                queryStr.append("?ocs rdf:type  <");
1055                                queryStr.append(classLink.getLinkedClassURI());
1056                                queryStr.append(">.\n");
1057                                queryStr.append("}");
1058                        } else {
1059                                if (classLink.getDirection() == Direction.forward) {
1060                                        queryStr.append("?ocs rdf:type  <");
1061                                        queryStr.append(startClassURI);
1062                                        queryStr.append(">.\n");
1063                                        queryStr.append("}");
1064                                } else {
1065                                        queryStr.append("?ocs rdf:type  <");
1066                                        queryStr.append(startClassURI);
1067                                        queryStr.append(">.\n");
1068                                        queryStr.append("}");
1069                                }
1070                        }
1071
1072                        System.out.println(queryStr.toString());
1073
1074                        query = QueryFactory.create(queryStr.toString());
1075                        qexec = QueryExecutionFactory.sparqlService(endpointURI, query);
1076
1077                        results = qexec.execSelect();
1078                        if (results.hasNext()) {
1079                                QuerySolution sol = results.next();
1080                                Literal lit = null;
1081                                lit = sol.getLiteral("numOfLinkedClassInstances");
1082                                if (lit != null) {
1083                                        int numOfLinkedClassInstances = lit.getInt();
1084                                        classLink
1085                                                        .setNumOfLinkedClassInstances(numOfLinkedClassInstances);
1086                                }
1087                        }
1088                        qexec.close();
1089
1090                }
1091                return classLinks;
1092        }
1093
1094        public SClass[] countInstances(String[] graphURIs, SClass[] classes)
1095                        throws Exception {
1096                if (classes == null || classes.length == 0) {
1097                        return new SClass[0];
1098                }
1099                HashMap<String, SClass> classMap = new HashMap<String, SClass>();
1100                for (SClass sc : classes) {
1101                        classMap.put(sc.getClassURI(), sc);
1102                }
1103                StringBuffer queryStr = new StringBuffer();
1104                queryStr.append("PREFIX owl: <http://www.w3.org/2002/07/owl#>\n");
1105                queryStr.append("PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>\n");
1106                queryStr.append("PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>\n");
1107                queryStr.append("SELECT DISTINCT ?cls  (COUNT(?is) AS ?numOfInstances)\n");
1108                if (graphURIs != null) {
1109                        for (String graphURI : graphURIs) {
1110                                queryStr.append("FROM <");
1111                                queryStr.append(graphURI);
1112                                queryStr.append(">\n");
1113                        }
1114                }
1115                queryStr.append("WHERE{\n");
1116                queryStr.append("  ?is rdf:type ?cls.\n");
1117                queryStr.append("  FILTER(?cls IN (");
1118                boolean f = false;
1119                Set<String> clsSet = classMap.keySet();
1120                for (String clsURI : clsSet) {
1121                        if (f) {
1122                                queryStr.append(", ");
1123                        }
1124                        f = true;
1125                        queryStr.append("<");
1126                        queryStr.append(clsURI);
1127                        queryStr.append(">");
1128                }
1129                queryStr.append("))\n");
1130                queryStr.append("} GROUP BY ?cls");
1131
1132                System.out.println(queryStr.toString());
1133
1134                Query query = QueryFactory.create(queryStr.toString());
1135                QueryExecution qexec = QueryExecutionFactory.sparqlService(endpointURI,
1136                                query);
1137
1138                ResultSet results = qexec.execSelect();
1139                for (; results.hasNext();) {
1140                        QuerySolution sol = results.next();
1141                        String uri = sol.getResource("cls").getURI();
1142                        SClass sc = classMap.get(uri);
1143                        Literal lit = sol.getLiteral("numOfInstances");
1144                        if (lit != null) {
1145                                int numOfInstances = lit.getInt();
1146                                sc.setNumOfInstances(numOfInstances);
1147                        }
1148                }
1149                qexec.close();
1150
1151                return classes;
1152        }
1153
1154}
Note: リポジトリブラウザについてのヘルプは TracBrowser を参照してください。