blob: bf96a3167345a05ae0d5cf6a53de2774380e3f7e (
plain) (
blame)
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
|
package uk.ac.ox.cs.rsacomb
import java.io.File
import java.util.HashMap
import scala.collection.JavaConverters._
import tech.oxfordsemantic.jrdfox.client.UpdateType
import tech.oxfordsemantic.jrdfox.logic.expression.{IRI, Term}
import tech.oxfordsemantic.jrdfox.logic.sparql.statement.SelectQuery
import util.{Logger, RDFoxUtil, RSA}
import sparql.ConjunctiveQuery
/** Entry point of the program.
*
* The executable expects a SPARQL query and a non-empty sequence of
* ontology files as arguments. The query file is expected to contain
* exactly one query, while the ontology files will be programmatically
* merged in a single ontology.
*
* @todo better arguments handling is needed. Look into some library
* for this.
* @todo at the moment the input ontology is assumed to be Horn-ALCHOIQ.
* This might not be the case.
*/
object RSAComb extends App {
val help: String = """
rsacomb - combined approach for CQ answering for RSA ontologies.
USAGE
rsacomb <query> <ontology> [...]
where
- query: path to a file containing a single SPARQL query
- ontology: one or more ontology files
"""
if (args.length < 2) {
println(help)
sys.exit;
}
val queryPath = new File(args(0))
val ontoPaths = args.drop(1).map(new File(_))
if (!queryPath.isFile || !ontoPaths.forall(_.isFile)) {
println("The provided arguments are not regular files.\n\n")
println(help)
sys.exit;
}
val ontology = RSAOntology(ontoPaths: _*)
if (ontology.isRSA) {
Logger print "Ontology is RSA!"
val query = RDFoxUtil.loadQueryFromFile(queryPath.getAbsoluteFile)
ConjunctiveQuery.parse(query) match {
case Some(query) => {
val answers = ontology ask query
Logger.print(s"$answers", Logger.QUIET)
Logger print s"Number of answers: ${answers.length} (${answers.lengthWithMultiplicity})"
/* Additional DEBUG information */
if (Logger.level >= Logger.DEBUG) {
/* Unfiltered rules */
val unfiltered = ontology askUnfiltered query
unfiltered map { u =>
Logger print s"Number of unfiltered answers: ${u.length} (${u.map(_._1).sum})."
/* Spurious answers */
val spurious = {
val variables = query.variables.length
val sp = RDFoxUtil.buildDescriptionQuery("SP", variables)
ontology.queryDataStore(query, sp, RSA.Prefixes)
}
spurious map { s =>
Logger print s"Number of spurious answers: ${s.length} (${s.map(_._1).sum})"
/* Spurious/unfiltered percentage */
val perc =
if (u.length > 0) (s.length / u.length.toFloat) * 100 else 0
Logger print s"Percentage of spurious answers: $perc%"
}
}
}
}
case None =>
throw new RuntimeException("Submitted query is not conjunctive")
}
}
}
|
