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

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

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