Context Navigation

OWLQueryBuilderImpl.java @ 59

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

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

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

元の形式