1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
|
package rsacomb
/* Java imports */
import java.io.File
import java.util.HashMap
import scala.collection.JavaConverters._
import tech.oxfordsemantic.jrdfox.client.UpdateType
/* Local imports */
import rsacomb.RSA._
object RSAComb extends App {
val help: String = """
rsacomb - combined approach for CQ answering for RSA ontologies.
USAGE
rsacomb <path/to/ontology.owl> <path/to/query.sparql>
where
the ontology is expected to be an OWL file and the (single)
query a SPARQL query file.
"""
/* Simple arguments handling
*
* TODO: use something better later on
*/
if (args.length < 2) {
println(help)
sys.exit;
}
val ontoPath = new File(args(0))
val queryPath = new File(args(1))
if (!ontoPath.isFile || !queryPath.isFile) {
println("The provided arguments are not regular files.\n\n")
println(help)
sys.exit;
}
/* Create RSA object from generic OWLOntology
*
* TODO: It might be required to check if the ontology in input is
* Horn-ALCHOIQ. At the moment we are assuming this is always the
* case.
*/
val ontology: RSAOntology = RSA.loadOntology(ontoPath)
if (ontology.isRSA) {
/* Load query */
val query = RDFoxUtil.parseQuery(
"""
SELECT ?uno
WHERE {
?uno a :D ;
:R ?due .
?due :S ?tre .
?tre a :D .
}
"""
)
/* Compute answers to query */
query match {
case Some(query) => {
// Open connection to RDFox
val (server, data) = RDFoxUtil.openConnection("AnswerComputation")
// Gather canonical model and filtering rules
val canon = ontology.canonicalModel
val filter = ontology.filteringProgram(query)
{
filter.rules.foreach(println)
}
// Import relevant data
data.importData(UpdateType.ADDITION, RSA.Prefixes, ":a a :A .")
data.addRules(canon.rules.asJava)
data.addRules(filter.rules.asJava)
// Collect answers to query
for ((v, i) <- filter.variables.view.zipWithIndex) {
println(s"Variable $i:")
val query = s"SELECT ?X ?Y WHERE { ?X internal:Ans_$i ?Y }"
val cursor =
data.createCursor(
RSA.Prefixes,
query,
new HashMap[String, String]()
);
var mul = cursor.open()
while (mul > 0) {
printf(
"Ans_%d(%s,%s)",
i,
cursor.getResource(0),
cursor.getResource(1)
)
mul = cursor.advance()
}
}
// Close connection to RDFox
RDFoxUtil.closeConnection(server, data)
}
case None => {}
}
}
}
/* Notes:
*
* To establish a connection with a local RDFox instance, do the
* following:
*
* ```
* val serverConnection : ServerConnection = ConnectionFactory.newServerConnection("rdfox:local", "", "")
* serverConnection.createDataStore("test","seq",new HashMap())
* val dataStoreConnection : DataStoreConnection = serverConnection.newDataStoreConnection("test")
* dataStoreConnection.importData(
* UpdateType.ADDITION,
* Prefixes.s_emptyPrefixes,
* new File("./path/to/file")
* )
* ```
*/
|
