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
|
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)
// 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")
* )
* ```
*/
|
