我不想在本体之间实现基于规则的映射，以便完成数据迁移的常见任务。
为了实现这一点，我开发了一个抽象数据结构，它能够存储由任何数据类型的xml表示提供的所有信息。然后我写了一个解析器，它构建了一个基于目标文档类型定义的本体。现在当我读取数据时，它首先与 abstractDatatype 命名空间相关联，我们称之为 aS 。 目标数据结构位于命名空间 tS 中。
如果我尝试通过类似的规则在两个具有相同名称但名称空间不同的资源之间表达类型公平：
[mappingRule1: (aS:?a rdf:type aS:?b) (tS:?c rdf:type tS:?b) -> (aS:?a rdf:type tS:?b)]
推理者没有得到它。也许规则中存在错误，应该解释为：如果在aS中存在与不同命名空间tS相同的类型名称，那么 aS 的所有个体也会得到 tS 中的相同类型 另一个问题是，如果没有类型的个人，这种规则可能不起作用，并且我被告知表达它可能是不够的。几乎可以我也可以创建SubClassOf规则，它们在所有组合之间进行映射，但这会在模型中产生大量的 dirt ，我希望能够添加更多的过滤条件而不是制作更一般。
但是，如果有人对基于规则的本体映射有一些经验，我会很高兴得到一些见解。
这是一个java单元测试，演示无法正常工作映射问题：
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import java.io.BufferedOutputStream;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.logging.Level;
import java.util.logging.Logger;
import org.junit.Before;
import org.junit.Test;
import com.hp.hpl.jena.rdf.model.InfModel;
import com.hp.hpl.jena.rdf.model.Model;
import com.hp.hpl.jena.rdf.model.ModelFactory;
import com.hp.hpl.jena.rdf.model.Property;
import com.hp.hpl.jena.rdf.model.RDFNode;
import com.hp.hpl.jena.rdf.model.Resource;
import com.hp.hpl.jena.rdf.model.Statement;
import com.hp.hpl.jena.rdf.model.StmtIterator;
import com.hp.hpl.jena.reasoner.Derivation;
import com.hp.hpl.jena.reasoner.Reasoner;
import com.hp.hpl.jena.reasoner.ReasonerRegistry;
import com.hp.hpl.jena.reasoner.rulesys.GenericRuleReasoner;
import com.hp.hpl.jena.reasoner.rulesys.Rule;
import com.hp.hpl.jena.util.PrintUtil;
import com.hp.hpl.jena.vocabulary.RDF;
import com.hp.hpl.jena.vocabulary.RDFS;
public class ReasonerTest {
String aS = "http://www.custom.eu/abstractDatascheme#";
String tS = "http://www.custom.eu/targetDatascheme#";
Model model = ModelFactory.createDefaultModel();
InfModel inf;
Resource AA = model.createResource(aS + "A");
Resource AB = model.createResource(aS + "B");
Resource AC = model.createResource(aS + "C");
Resource AD = model.createResource(aS + "D");
Resource TA = model.createResource(tS + "A");
Resource TB = model.createResource(tS + "B");
Property p = model.createProperty(aS, "p");
Property q = model.createProperty(aS, "q");
@Before
public void init() {
PrintUtil.registerPrefix("aS", aS);
PrintUtil.registerPrefix("tS", tS);
AA.addProperty(p, "foo");
// Get an RDFS reasoner
GenericRuleReasoner rdfsReasoner = (GenericRuleReasoner) ReasonerRegistry.getRDFSReasoner();
// Steal its rules, and add one of our own, and create a reasoner with these rules
List<Rule> rdfRules = new ArrayList<>( rdfsReasoner.getRules() );
List<Rule> rules = new ArrayList<>();
String customRules = "[transitiveRule: (?a aS:p ?b) (?b aS:p ?c) -> (?a aS:p ?c)] \n" +
"[mappingRule1: (aS:?a rdf:type aS:?b) (tS:?c rdf:type tS:?b) -> (aS:?a rdf:type tS:?b)] \n" +
"[mappingRule2a: -> (aS:?a rdfs:subClassOf tS:?a)] \n" +
"[mappingRule2b: -> (tS:?a rdfs:subClassOf aS:?a)]";
rules.addAll(rdfRules);
rules.add(Rule.parseRule(customRules));
Reasoner reasoner = new GenericRuleReasoner(rules);
reasoner.setDerivationLogging(true);
inf = ModelFactory.createInfModel(reasoner, model);
}
@Test
public void mapping() {
AA.addProperty(RDF.type, model.createResource(aS + "CommonType"));
TA.addProperty(RDF.type, model.createResource(tS + "CommonType"));
String trace = null;
trace = getDerivations(trace, AA, RDF.type, TA);
assertNotNull(trace);
}
private String getDerivations(String trace, Resource subject, Property predicate, Resource object) {
PrintWriter out = new PrintWriter(System.out);
for (StmtIterator i = inf.listStatements(subject, predicate, object); i.hasNext(); ) {
Statement s = i.nextStatement();
System.out.println("Statement is " + s);
for (Iterator<Derivation> id = inf.getDerivation(s); id.hasNext(); ) {
Derivation deriv = (Derivation) id.next();
deriv.printTrace(out, true);
trace += deriv.toString();
}
}
out.flush();
return trace;
}
@Test
public void subProperty() {
// Hierarchy
model.add(p, RDFS.subPropertyOf, q);
StmtIterator stmts = inf.listStatements(AA, q, (RDFNode) null);
assertTrue(stmts.hasNext());
while (stmts.hasNext()) {
System.out.println("Statement: " + stmts.next());
}
}
@Test
public void derivation() {
// Derivations
AA.addProperty(p, AB);
AB.addProperty(p, AC);
AC.addProperty(p, AD);
String trace = null;
trace = getDerivations(trace, AA, p, AD);
assertNotNull(trace);
}
@Test
public void derivations() {
String trace = null;
PrintWriter out = new PrintWriter(System.out);
for (StmtIterator i = inf.listStatements(); i.hasNext(); ) {
Statement s = i.nextStatement();
System.out.println("Statement is " + s);
for (Iterator<Derivation> id = inf.getDerivation(s); id.hasNext(); ) {
Derivation deriv = (Derivation) id.next();
deriv.printTrace(out, true);
trace += deriv.toString();
}
}
out.flush();
assertNotNull(trace);
}
@Test
public void listStatements() {
StmtIterator stmtIterator = inf.listStatements();
while (stmtIterator.hasNext()) {
System.out.println(stmtIterator.nextStatement());
}
}
@Test
public void listRules() {
List<Rule> rules = ((GenericRuleReasoner) inf.getReasoner()).getRules();
for (Rule rule : rules) {
System.out.println(rule.toString());
}
}
@Test
public void saveDerivation() {
DataOutputStream out1;
try {
out1 = new DataOutputStream(new BufferedOutputStream(new FileOutputStream("target/test-output/testOnto.owl")));
inf.write(out1);
}
catch (IOException ex) {
Logger.getLogger(ReasonerTest.class.getName()).log(Level.SEVERE, null, ex);
}
}
@Test
public void printRdfRules() {
GenericRuleReasoner rdfsReasoner = (GenericRuleReasoner) ReasonerRegistry.getRDFSReasoner();
List<Rule> customRules = new ArrayList<>(rdfsReasoner.getRules());
PrintWriter writer = null;
try {
File directory = new File("target/test-output/");
if (!directory.exists()) {
directory.mkdir();
}
writer = new PrintWriter("target/test-output/rfd.rules", "UTF-8");
}
catch (IOException ex) {
Logger.getLogger(ReasonerTest.class.getName()).log(Level.SEVERE, null, ex);
}
for (Rule customRule : customRules) {
writer.println(customRule.toString());
}
writer.close();
}
}
答案 0 :(得分：1)
您不能只执行ns:?x并期望它匹配其字符串形式以ns:所代表的开头的URI资源，并将?x绑定到其余部分（或整个事情）。如果要使用查看URI字符串形式的规则，则必须使用strConcat获取其字符串形式，并使用regex进行一些匹配和提取。这是一个示例，其中m:Person用作类型，x:a a n:Person位于数据中，m:Person和n:Person具有相同的后缀前缀n:和m:，并推断出x:a a m:Person。
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import com.hp.hpl.jena.rdf.model.InfModel;
import com.hp.hpl.jena.rdf.model.Model;
import com.hp.hpl.jena.rdf.model.ModelFactory;
import com.hp.hpl.jena.reasoner.Reasoner;
import com.hp.hpl.jena.reasoner.rulesys.GenericRuleReasoner;
import com.hp.hpl.jena.reasoner.rulesys.Rule;
import com.hp.hpl.jena.util.PrintUtil;
public class TypeMappingExample {
public static void main(String[] args) throws IOException {
PrintUtil.registerPrefix( "n", "urn:ex:n/" );
PrintUtil.registerPrefix( "m", "urn:ex:m/" );
String content = "\n" +
"@prefix n: <urn:ex:n/>.\n" +
"@prefix m: <urn:ex:m/>.\n" +
"@prefix x: <urn:ex:x/>" +
"\n" +
"x:a a n:Person.\n" +
"x:b a m:Person.\n" +
"";
Model model = ModelFactory.createDefaultModel();
try ( InputStream in = new ByteArrayInputStream( content.getBytes() )) {
model.read( in, null, "TTL" );
}
String rule = "\n" +
"[strConcat(n:,'(.*)',?nprefix),\n" +
" strConcat(m:,'(.*)',?mprefix),\n" +
" (?x rdf:type ?ntype), strConcat(?ntype,?ntypestr),\n" +
" (?y rdf:type ?mtype), strConcat(?mtype,?mtypestr)," +
" regex(?ntypestr,?nprefix,?nsuffix),\n" +
" regex(?mtypestr,?mprefix,?msuffix),\n" +
" equal(?nsuffix,?msuffix)\n" +
" -> \n" +
"(?x rdf:type ?mtype)]";
Reasoner reasoner = new GenericRuleReasoner( Rule.parseRules( rule ));
InfModel imodel = ModelFactory.createInfModel( reasoner, model );
imodel.write( System.out, "TTL" );
}
}
@prefix n: <urn:ex:n/> .
@prefix m: <urn:ex:m/> .
@prefix x: <urn:ex:x/> .
x:a a m:Person , n:Person .
x:b a m:Person .
正如您所看到的，字符串处理相当粗糙; Jena的内置版本设计用于从URI等获取字符串。一些SPARQL函数会使这更容易，但它仍然有点不优雅，因为IRI实际上应该是 opaque 标识符。
更容易的解决方案是确保所有类都有标签，并说两个类具有相同的标签，然后一个的实例是另一个的实例。如果你已经很好地利用了rdfs：isDefinedBy，你可以使用以下内容：＃/ p>
[(?c1 a rdfs:Class) (?c1 rdfs:isDefinedBy ?ont1) (?c1 rdfs:label ?name)
(?c2 a rdfs:Class) (?c2 rdfs:isDefinedBy ?ont2) (?c2 rdfs:label ?name)
->
[(?x rdf:type ?c1) -> (?x rdf:type ?c2)]]