Context Navigation

OWLQueryBuilderImpl.java @ 58

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

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

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

元の形式