Context Navigation

OWLQueryBuilderImpl.java @ 60

リビジョン 60, 36.1 KB (コミッタ: wu, 11 年前)
language　パラメータ実装しました
属性 svn:mime-type の設定値 `text/plain`

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

Note: リポジトリブラウザについてのヘルプは TracBrowser を参照してください。

異なるフォーマットでダウンロード:

元の形式