private static void appendNamespace(StringBuilder builder, Namespace namespace) {
// PREFIX pref: <pref_name>
builder
.append(" PREFIX ")
.append(namespace.getPrefix())
.append(": <")
.append(namespace.getName())
.append("> ");
}
@Override
public Map<String, String> getNsPrefixMap() {
Map<String, String> map = new HashMap<String, String>();
try {
RepositoryResult<Namespace> result = getGraph().getConnection().getNamespaces();
while (result.hasNext()) {
Namespace ns = result.next();
map.put(ns.getPrefix(), ns.getName());
}
} catch (RepositoryException e) {
throw new RuntimeException(e);
}
return map;
}
public Map<String, String> getNamespaces() {
Map<String, String> map = new HashMap<String, String>();
try {
RepositoryResult<Namespace> spaces = con.getNamespaces();
try {
while (spaces.hasNext()) {
Namespace ns = spaces.next();
map.put(ns.getPrefix(), ns.getName());
}
} finally {
spaces.close();
}
return map;
} catch (RepositoryException e) {
throw new ModelException(e);
}
}
@Override
public String getNsURIPrefix(String uri) {
// TODO speed this up!
String prefix = null;
try {
RepositoryResult<Namespace> result = getGraph().getConnection().getNamespaces();
while (prefix == null && result.hasNext()) {
Namespace ns = result.next();
if (uri.equalsIgnoreCase(ns.getName())) {
prefix = ns.getPrefix();
}
}
} catch (RepositoryException e) {
throw new RuntimeException(e);
}
return prefix;
}
@Test
public void testGetNamespaces() throws Exception {
con.begin();
con.setNamespace("rdf", RDF.NAMESPACE);
con.commit();
CloseableIteration<? extends Namespace, SailException> namespaces = con.getNamespaces();
try {
assertTrue(namespaces.hasNext());
Namespace rdf = namespaces.next();
assertEquals("rdf", rdf.getPrefix());
assertEquals(RDF.NAMESPACE, rdf.getName());
assertTrue(!namespaces.hasNext());
} finally {
namespaces.close();
}
}
/**
* Returns a string containing prefixes defined in the given repository. The returned string is in
* format that can be used for a SPARQL query.
*
* @param repository
* @return string containing prefixes defined in the given repository for a usage in SPARQL query
*/
public static String getSparqlQueryPrefixesHumanReadable(Repository repository) {
StringBuilder query = new StringBuilder();
RepositoryResult<Namespace> namespaces;
RepositoryConnection con = null;
try {
con = repository.getConnection();
namespaces = con.getNamespaces();
while (namespaces.hasNext()) {
Namespace space = namespaces.next();
appendHumanReadableNamespace(query, space);
}
// add well known rdf and rdfs prefixes if they are missing
// they are used by basic queries (these might be issued on empty
// repositories and the missing prefixes are causing troubles)
if (query.indexOf(RDF_NAMESPACE.getName()) == -1) {
appendNamespace(query, RDF_NAMESPACE);
}
if (query.indexOf(RDFS_NAMESPACE.getName()) == -1) {
appendNamespace(query, RDFS_NAMESPACE);
}
} catch (RepositoryException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} finally {
try {
if (con != null) {
con.close();
}
} catch (RepositoryException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
return query.toString();
}
/**
* Returns format of given uri that can be used in a SPARQL query. If the uri is prefixed with a
* prefix which is known in the given repo than the return value of this function is the given
* uri. <br>
* If the uri is not prefixed with a known prefix it is assumed that it has no prefix and the
* value returned by this function is <uri>
*
* @param uri
* @param repo
* @return given uri if it has prefix known by repo <br>
* <uri> otherwise
*/
public static String getUriForSparqlQuery(String uri, Repository repo) {
// check if the instanceUri starts with one of known prefixes
RepositoryConnection con = null;
try {
con = repo.getConnection();
RepositoryResult<Namespace> namespaces = con.getNamespaces();
while (namespaces.hasNext()) {
Namespace space = namespaces.next();
if (uri.startsWith(space.getPrefix())) {
return uri;
}
}
} catch (RepositoryException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} finally {
try {
if (con != null) {
con.close();
}
} catch (RepositoryException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
// instanceUri is not prefixed => it has to be put into <> symbols for
// SPARQL query
if (!uri.startsWith("<")) {
uri = "<" + uri;
}
if (!uri.endsWith(">")) {
uri += ">";
}
return uri;
}
private static void addPrefixes(Map<String, Object> ctx, Set<Namespace> namespaces) {
for (final Namespace ns : namespaces) {
ctx.put(ns.getPrefix(), ns.getName());
}
}
@Override
protected String getNamespaceInternal(String prefix) throws SailException {
Namespace ns = namespaces.findByPrefix(prefix);
if (ns == null) return null;
return ns.getName();
}