aboutsummaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/main/scala/rsacomb/FilteringProgram.scala45
-rw-r--r--src/main/scala/rsacomb/Main.scala3
-rw-r--r--src/test/scala/rsacomb/CanonicalModelSpec.scala3
-rw-r--r--src/test/scala/rsacomb/FilteringProgramSpecs.scala447
-rw-r--r--src/test/scala/rsacomb/OWLAxiomSpec.scala58
-rw-r--r--src/test/scala/rsacomb/OWLClassSpec.scala63
6 files changed, 313 insertions, 306 deletions
diff --git a/src/main/scala/rsacomb/FilteringProgram.scala b/src/main/scala/rsacomb/FilteringProgram.scala
index dc5e95e..b0d4aab 100644
--- a/src/main/scala/rsacomb/FilteringProgram.scala
+++ b/src/main/scala/rsacomb/FilteringProgram.scala
@@ -32,8 +32,29 @@ class FilteringProgram(query: SelectQuery, constants: List[Term])
32 /* Makes mplicit conversion OWLAPI IRI <-> RDFox IRI available */ 32 /* Makes mplicit conversion OWLAPI IRI <-> RDFox IRI available */
33 import RDFoxUtil._ 33 import RDFoxUtil._
34 34
35 val answer: List[Term] = query.getSelection.asScala.map(_.getVariable).toList 35 lazy val variables = {
36 val bounded: List[Term] = this.getBoundedVariables 36 query.getQueryBody.getWherePattern match {
37 case b: ConjunctionPattern => {
38 b.getConjuncts.asScala.toSet.flatMap { conj: QueryPattern =>
39 conj match {
40 case c: TriplePattern =>
41 Set(c.getSubject, c.getPredicate, c.getObject)
42 .filter(_.isInstanceOf[Variable])
43 case _ => Set()
44 }
45 }
46 }
47 case _ => Set()
48 }
49 }.toList
50
51 val answer: List[Term] =
52 if (query.getAllPossibleVariables) {
53 variables
54 } else {
55 query.getSelection.asScala.map(_.getVariable).toList
56 }
57 val bounded: List[Term] = this.variables.filterNot(answer.contains(_))
37 58
38 val facts: List[TupleTableAtom] = constants.map(named) 59 val facts: List[TupleTableAtom] = constants.map(named)
39 val rules: List[Rule] = this.generateFilteringProgram().map(reifyRule) 60 val rules: List[Rule] = this.generateFilteringProgram().map(reifyRule)
@@ -45,26 +66,6 @@ class FilteringProgram(query: SelectQuery, constants: List[Term])
45 RSA.internal("NAMED") 66 RSA.internal("NAMED")
46 ) 67 )
47 68
48 private def getBoundedVariables: List[Term] = {
49 def extract(body: GroupGraphPattern): Set[Term] = {
50 body match {
51 case b: ConjunctionPattern => {
52 b.getConjuncts.asScala.toSet.flatMap { conj: QueryPattern =>
53 conj match {
54 case c: TriplePattern =>
55 Set(c.getSubject, c.getPredicate, c.getObject).filter(
56 _.isInstanceOf[Variable]
57 )
58 case _ => Set()
59 }
60 }
61 }
62 case _ => Set()
63 }
64 }
65 extract(query.getQueryBody.getWherePattern).toList
66 }
67
68 /* NOTE: we are restricting to queries that contain conjunctions of 69 /* NOTE: we are restricting to queries that contain conjunctions of
69 * atoms for the time being. This might need to be reviewed in the 70 * atoms for the time being. This might need to be reviewed in the
70 * future. 71 * future.
diff --git a/src/main/scala/rsacomb/Main.scala b/src/main/scala/rsacomb/Main.scala
index 5d92061..830f1e0 100644
--- a/src/main/scala/rsacomb/Main.scala
+++ b/src/main/scala/rsacomb/Main.scala
@@ -62,8 +62,7 @@ object RSAComb extends App {
62 "SELECT ?X WHERE {?X ?Y ?Z}" 62 "SELECT ?X WHERE {?X ?Y ?Z}"
63 ) 63 )
64 64
65 /* Compute the filtering program from the given query */ 65 val filter = query map { q => ontology.filteringProgram(q) }
66 val filter = ontology.filteringProgram(query)
67 66
68 /* ... */ 67 /* ... */
69 } 68 }
diff --git a/src/test/scala/rsacomb/CanonicalModelSpec.scala b/src/test/scala/rsacomb/CanonicalModelSpec.scala
index e8db89d..88a0d29 100644
--- a/src/test/scala/rsacomb/CanonicalModelSpec.scala
+++ b/src/test/scala/rsacomb/CanonicalModelSpec.scala
@@ -9,7 +9,8 @@ import org.semanticweb.owlapi.model._
9import uk.ac.manchester.cs.owl.owlapi._ 9import uk.ac.manchester.cs.owl.owlapi._
10import org.semanticweb.owlapi.dlsyntax.renderer.DLSyntaxObjectRenderer 10import org.semanticweb.owlapi.dlsyntax.renderer.DLSyntaxObjectRenderer
11 11
12import tech.oxfordsemantic.jrdfox.logic.{Rule, Variable} 12import tech.oxfordsemantic.jrdfox.logic.datalog.Rule
13import tech.oxfordsemantic.jrdfox.logic.expression.Variable
13 14
14import scala.collection.JavaConverters._ 15import scala.collection.JavaConverters._
15 16
diff --git a/src/test/scala/rsacomb/FilteringProgramSpecs.scala b/src/test/scala/rsacomb/FilteringProgramSpecs.scala
index 2dcf682..26b0857 100644
--- a/src/test/scala/rsacomb/FilteringProgramSpecs.scala
+++ b/src/test/scala/rsacomb/FilteringProgramSpecs.scala
@@ -7,15 +7,14 @@ import org.scalatest.Inspectors
7import org.scalatest.flatspec.AnyFlatSpec 7import org.scalatest.flatspec.AnyFlatSpec
8import org.scalatest.matchers.should.Matchers 8import org.scalatest.matchers.should.Matchers
9 9
10import tech.oxfordsemantic.jrdfox.logic.{Variable, Atom, IRI} 10import tech.oxfordsemantic.jrdfox.logic.datalog.TupleTableAtom
11import tech.oxfordsemantic.jrdfox.logic.{Query, QueryType} 11import tech.oxfordsemantic.jrdfox.logic.expression.{Variable, IRI}
12import tech.oxfordsemantic.jrdfox.logic.LogicFormat 12import tech.oxfordsemantic.jrdfox.logic.sparql.statement.{Query, SelectQuery}
13import tech.oxfordsemantic.jrdfox.Prefixes 13import tech.oxfordsemantic.jrdfox.Prefixes
14 14
15import scala.collection.JavaConverters._ 15import scala.collection.JavaConverters._
16 16
17import rsacomb.RDFoxUtil._ 17import rsacomb.RDFoxUtil._
18import tech.oxfordsemantic.jrdfox.logic.Conjunction
19 18
20object FilteringProgramSpec { 19object FilteringProgramSpec {
21 20
@@ -34,254 +33,254 @@ object FilteringProgramSpec {
34 33
35 // QUERY 0 34 // QUERY 0
36 35
37 // val query0 = parseQuery(""" 36 val query0 = parseQuery("""
38 // SELECT ?subj 37 SELECT ?subj
39 // WHERE { 38 WHERE {
40 // ?subj ?pred ?obj 39 ?subj ?pred ?obj
41 // } 40 }
42 // """, prefixes) 41 """, prefixes).get
43 42
44 val query0 = Query.create( 43 // val query0 = Query.create(
45 QueryType.SELECT, 44 // QueryType.SELECT,
46 false, 45 // false,
47 List(v("subj")).asJava, 46 // List(v("subj")).asJava,
48 Atom.rdf(v("subj"), v("pred"), v("obj")) 47 // Atom.rdf(v("subj"), v("pred"), v("obj"))
49 ) 48 // )
50 49
51 // QUERY 1 50 // QUERY 1
52 51
53 // val query1 = parseQuery(""" 52 val query1 = parseQuery("""
54 // SELECT * 53 SELECT *
55 // WHERE { 54 WHERE {
56 // ?w a :Wellbore 55 ?w a :Wellbore
57 // } 56 }
58 // """, prefixes) 57 """, prefixes).get
59 58
60 val query1 = Query.create( 59 // val query1 = Query.create(
61 QueryType.SELECT, 60 // QueryType.SELECT,
62 false, 61 // false,
63 List(v("w")).asJava, 62 // List(v("w")).asJava,
64 Atom.rdf(v("w"), IRI.RDF_TYPE, c("Wellbore")) 63 // Atom.rdf(v("w"), IRI.RDF_TYPE, c("Wellbore"))
65 ) 64 // )
66 65
67 // QUERY 2 66 // QUERY 2
68 67
69 // val query2 = parseQuery( 68 val query2 = parseQuery(
70 // """ 69 """
71 // SELECT * 70 SELECT *
72 // WHERE { 71 WHERE {
73 // ?w a :Wellbore ; 72 ?w a :Wellbore ;
74 // :wellboreDocument ?doc . 73 :wellboreDocument ?doc .
75 // ?doc :hasURL ?document_hyperlink 74 ?doc :hasURL ?document_hyperlink
76 // } 75 }
77 // """, 76 """,
78 // prefixes 77 prefixes
78 ).get
79
80 // val query2 = Query.create(
81 // QueryType.SELECT,
82 // false,
83 // List(v("w"), v("doc"), v("document_hyperlink")).asJava,
84 // Conjunction.create(
85 // Atom.rdf(v("w"), IRI.RDF_TYPE, c("Wellbore")),
86 // Atom.rdf(v("w"), c("wellboreDocument"), v("doc")),
87 // Atom.rdf(v("doc"), c("hasURL"), v("document_hyperlink"))
88 // )
79 // ) 89 // )
80 90
81 val query2 = Query.create(
82 QueryType.SELECT,
83 false,
84 List(v("w"), v("doc"), v("document_hyperlink")).asJava,
85 Conjunction.create(
86 Atom.rdf(v("w"), IRI.RDF_TYPE, c("Wellbore")),
87 Atom.rdf(v("w"), c("wellboreDocument"), v("doc")),
88 Atom.rdf(v("doc"), c("hasURL"), v("document_hyperlink"))
89 )
90 )
91
92 // QUERY 3 91 // QUERY 3
93 92
94 // val query3 = parseQuery( 93 val query3 = parseQuery(
95 // """ 94 """
96 // SELECT ?wellbore ?formation_pressure 95 SELECT ?wellbore ?formation_pressure
97 // WHERE { 96 WHERE {
98 // ?w a :Wellbore ; 97 ?w a :Wellbore ;
99 // :name ?wellbore ; 98 :name ?wellbore ;
100 // :hasFormationPressure ?fp . 99 :hasFormationPressure ?fp .
101 // ?fp :valueInStandardUnit ?formation_pressure 100 ?fp :valueInStandardUnit ?formation_pressure
102 // } 101 }
103 // """, 102 """,
104 // prefixes 103 prefixes
104 ).get
105
106 // val query3 = Query.create(
107 // QueryType.SELECT,
108 // false,
109 // List(v("wellbore"), v("formation_pressure")).asJava,
110 // Conjunction.create(
111 // Atom.rdf(v("w"), IRI.RDF_TYPE, c("Wellbore")),
112 // Atom.rdf(v("w"), c("name"), v("wellbore")),
113 // Atom.rdf(v("w"), c("hasFormationPressure"), v("fp")),
114 // Atom.rdf(v("fp"), c("valueInStandardUnit"), v("formation_pressure"))
115 // )
105 // ) 116 // )
106 117
107 val query3 = Query.create(
108 QueryType.SELECT,
109 false,
110 List(v("wellbore"), v("formation_pressure")).asJava,
111 Conjunction.create(
112 Atom.rdf(v("w"), IRI.RDF_TYPE, c("Wellbore")),
113 Atom.rdf(v("w"), c("name"), v("wellbore")),
114 Atom.rdf(v("w"), c("hasFormationPressure"), v("fp")),
115 Atom.rdf(v("fp"), c("valueInStandardUnit"), v("formation_pressure"))
116 )
117 )
118
119 // QUERY 4 118 // QUERY 4
120 119
121 // val query4 = parseQuery( 120 val query4 = parseQuery(
122 // """ 121 """
123 // SELECT * 122 SELECT *
124 // WHERE { 123 WHERE {
125 // ?w a :Wellbore ; 124 ?w a :Wellbore ;
126 // :hasGeochemicalMeasurement ?measurement . 125 :hasGeochemicalMeasurement ?measurement .
127 // ?measurement :cgType ?cgtype ; 126 ?measurement :cgType ?cgtype ;
128 // :peakName ?peakType ; 127 :peakName ?peakType ;
129 // :peakHeight ?peak_height ; 128 :peakHeight ?peak_height ;
130 // :peakAmount ?peak_amount 129 :peakAmount ?peak_amount
131 // } 130 }
132 // """, 131 """,
133 // prefixes 132 prefixes
133 ).get
134
135 // val query4 = Query.create(
136 // QueryType.SELECT,
137 // false,
138 // List(
139 // v("w"),
140 // v("measurement"),
141 // v("cgtype"),
142 // v("peakType"),
143 // v("peak_height"),
144 // v("peak_amount")
145 // ).asJava,
146 // Conjunction.create(
147 // Atom.rdf(v("w"), IRI.RDF_TYPE, c("Wellbore")),
148 // Atom.rdf(v("w"), c("hasGeochemicalMeasurement"), v("measurement")),
149 // Atom.rdf(v("measurement"), c("cgType"), v("cgtype")),
150 // Atom.rdf(v("measurement"), c("peakName"), v("peakType")),
151 // Atom.rdf(v("measurement"), c("peakHeight"), v("peak_height")),
152 // Atom.rdf(v("measurement"), c("peakAmount"), v("peak_amount"))
153 // )
134 // ) 154 // )
135 155
136 val query4 = Query.create(
137 QueryType.SELECT,
138 false,
139 List(
140 v("w"),
141 v("measurement"),
142 v("cgtype"),
143 v("peakType"),
144 v("peak_height"),
145 v("peak_amount")
146 ).asJava,
147 Conjunction.create(
148 Atom.rdf(v("w"), IRI.RDF_TYPE, c("Wellbore")),
149 Atom.rdf(v("w"), c("hasGeochemicalMeasurement"), v("measurement")),
150 Atom.rdf(v("measurement"), c("cgType"), v("cgtype")),
151 Atom.rdf(v("measurement"), c("peakName"), v("peakType")),
152 Atom.rdf(v("measurement"), c("peakHeight"), v("peak_height")),
153 Atom.rdf(v("measurement"), c("peakAmount"), v("peak_amount"))
154 )
155 )
156
157 // QUERY 5 156 // QUERY 5
158 157
159 // val query5 = parseQuery( 158 val query5 = parseQuery(
160 // """ 159 """
161 // SELECT ?wellbore ?unit_name ?discovery 160 SELECT ?wellbore ?unit_name ?discovery
162 // WHERE { 161 WHERE {
163 // ?w a :Wellbore ; 162 ?w a :Wellbore ;
164 // :name ?wellbore ; 163 :name ?wellbore ;
165 // :hasWellboreInterval ?c_int ; 164 :hasWellboreInterval ?c_int ;
166 // :hasWellboreInterval ?f_int . 165 :hasWellboreInterval ?f_int .
167 // ?c_int :hasUnit ?c_unit . 166 ?c_int :hasUnit ?c_unit .
168 // ?c_unit :name ?unit_name . 167 ?c_unit :name ?unit_name .
169 // ?f_int a :FluidZone ; 168 ?f_int a :FluidZone ;
170 // :name ?discovery ; 169 :name ?discovery ;
171 // :overlapsWellboreInterval ?c_int 170 :overlapsWellboreInterval ?c_int
172 // } 171 }
173 // """, 172 """,
174 // prefixes 173 prefixes
174 ).get
175
176 // val query5 = Query.create(
177 // QueryType.SELECT,
178 // false,
179 // List(v("wellbore"), v("unit_name"), v("discovery")).asJava,
180 // Conjunction.create(
181 // Atom.rdf(v("w"), IRI.RDF_TYPE, c("Wellbore")),
182 // Atom.rdf(v("w"), c("name"), v("wellbore")),
183 // Atom.rdf(v("w"), c("hasWellboreInterval"), v("c_int")),
184 // Atom.rdf(v("w"), c("hasWellboreInterval"), v("f_int")),
185 // Atom.rdf(v("c_int"), c("hasUnit"), v("c_unit")),
186 // Atom.rdf(v("c_unit"), c("name"), v("unit_name")),
187 // Atom.rdf(v("f_int"), IRI.RDF_TYPE, c("FluidZone")),
188 // Atom.rdf(v("f_int"), c("name"), v("discovery")),
189 // Atom.rdf(v("f_int"), c("overlapsWellboreInterval"), v("c_int"))
190 // )
175 // ) 191 // )
176 192
177 val query5 = Query.create(
178 QueryType.SELECT,
179 false,
180 List(v("wellbore"), v("unit_name"), v("discovery")).asJava,
181 Conjunction.create(
182 Atom.rdf(v("w"), IRI.RDF_TYPE, c("Wellbore")),
183 Atom.rdf(v("w"), c("name"), v("wellbore")),
184 Atom.rdf(v("w"), c("hasWellboreInterval"), v("c_int")),
185 Atom.rdf(v("w"), c("hasWellboreInterval"), v("f_int")),
186 Atom.rdf(v("c_int"), c("hasUnit"), v("c_unit")),
187 Atom.rdf(v("c_unit"), c("name"), v("unit_name")),
188 Atom.rdf(v("f_int"), IRI.RDF_TYPE, c("FluidZone")),
189 Atom.rdf(v("f_int"), c("name"), v("discovery")),
190 Atom.rdf(v("f_int"), c("overlapsWellboreInterval"), v("c_int"))
191 )
192 )
193
194 // QUERY 6 193 // QUERY 6
195 194
196 // val query6 = parseQuery( 195 val query6 = parseQuery(
197 // """ 196 """
198 // SELECT DISTINCT ?wellbore ?content 197 SELECT DISTINCT ?wellbore ?content
199 // WHERE { 198 WHERE {
200 // ?w a :Wellbore ; 199 ?w a :Wellbore ;
201 // :name ?wellbore ; 200 :name ?wellbore ;
202 // :hasWellboreInterval ?int . 201 :hasWellboreInterval ?int .
203 // ?int a :FluidZone ; 202 ?int a :FluidZone ;
204 // :fluidZoneContent ?content 203 :fluidZoneContent ?content
205 // } 204 }
206 // """, 205 """,
207 // prefixes 206 prefixes
207 ).get
208
209 // val query6 = Query.create(
210 // QueryType.SELECT,
211 // true,
212 // List(v("wellbore"), v("content")).asJava,
213 // Conjunction.create(
214 // Atom.rdf(v("w"), IRI.RDF_TYPE, c("Wellbore")),
215 // Atom.rdf(v("w"), c("name"), v("wellbore")),
216 // Atom.rdf(v("w"), c("hasWellboreInterval"), v("int")),
217 // Atom.rdf(v("int"), IRI.RDF_TYPE, c("FluidZone")),
218 // Atom.rdf(v("int"), c("fluidZoneContent"), v("content"))
219 // )
208 // ) 220 // )
209 221
210 val query6 = Query.create(
211 QueryType.SELECT,
212 true,
213 List(v("wellbore"), v("content")).asJava,
214 Conjunction.create(
215 Atom.rdf(v("w"), IRI.RDF_TYPE, c("Wellbore")),
216 Atom.rdf(v("w"), c("name"), v("wellbore")),
217 Atom.rdf(v("w"), c("hasWellboreInterval"), v("int")),
218 Atom.rdf(v("int"), IRI.RDF_TYPE, c("FluidZone")),
219 Atom.rdf(v("int"), c("fluidZoneContent"), v("content"))
220 )
221 )
222
223 // QUERY 7 222 // QUERY 7
224 223
225 // val query7 = parseQuery( 224 val query7 = parseQuery(
226 // """ 225 """
227 // SELECT ?wName ?sample ?porosity ?top_depth_md ?bot_depth_md 226 SELECT ?wName ?sample ?porosity ?top_depth_md ?bot_depth_md
228 // WHERE { 227 WHERE {
229 // ?w a :Wellbore ; 228 ?w a :Wellbore ;
230 // :name ?wName ; 229 :name ?wName ;
231 // :hasWellboreInterval ?z . 230 :hasWellboreInterval ?z .
232 // ?z :hasUnit ?u . 231 ?z :hasUnit ?u .
233 // ?u :name ?strat_unit_name . 232 ?u :name ?strat_unit_name .
234 // ?wellbore :hasWellboreInterval ?cored_int . 233 ?wellbore :hasWellboreInterval ?cored_int .
235 // ?c :extractedFrom ?cored_int ; 234 ?c :extractedFrom ?cored_int ;
236 // :hasCoreSample ?sample . 235 :hasCoreSample ?sample .
237 // ?sample :hasDepth ?sample_depth . 236 ?sample :hasDepth ?sample_depth .
238 // ?sample_depth 237 ?sample_depth
239 // :inWellboreInterval ?z . 238 :inWellboreInterval ?z .
240 // ?sample :hasPorosity ?p . 239 ?sample :hasPorosity ?p .
241 // ?p :valueInStandardUnit ?porosity . 240 ?p :valueInStandardUnit ?porosity .
242 // ?z :hasTopDepth ?top . 241 ?z :hasTopDepth ?top .
243 // ?top a :MeasuredDepth ; 242 ?top a :MeasuredDepth ;
244 // :valueInStandardUnit ?top_depth_md . 243 :valueInStandardUnit ?top_depth_md .
245 // ?z :hasBottomDepth ?bot . 244 ?z :hasBottomDepth ?bot .
246 // ?bot a :MeasuredDepth ; 245 ?bot a :MeasuredDepth ;
247 // :valueInStandardUnit ?bot_depth_md 246 :valueInStandardUnit ?bot_depth_md
248 // } 247 }
249 // """, 248 """,
250 // prefixes 249 prefixes
250 ).get
251
252 // val query7 = Query.create(
253 // QueryType.SELECT,
254 // false,
255 // List(
256 // v("wName"),
257 // v("sample"),
258 // v("porosity"),
259 // v("top_depth_md"),
260 // v("bot_depth_md")
261 // ).asJava,
262 // Conjunction.create(
263 // Atom.rdf(v("w"), IRI.RDF_TYPE, c("Wellbore")),
264 // Atom.rdf(v("w"), c("name"), v("wName")),
265 // Atom.rdf(v("w"), c("hasWellboreInterval"), v("z")),
266 // Atom.rdf(v("z"), c("hasUnit"), v("u")),
267 // Atom.rdf(v("u"), c("name"), v("strat_unit_name")),
268 // Atom.rdf(v("wellbore"), c("hasWellboreInterval"), v("cored_int")),
269 // Atom.rdf(v("c"), c("extractedFrom"), v("cored_int")),
270 // Atom.rdf(v("c"), c("hasCoreSample"), v("sample")),
271 // Atom.rdf(v("sample"), c("hasDepth"), v("sample_depth")),
272 // Atom.rdf(v("sample_depth"), c("inWellboreInterval"), v("z")),
273 // Atom.rdf(v("sample"), c("hasPorosity"), v("p")),
274 // Atom.rdf(v("p"), c("valueInStandardUnit"), v("porosity")),
275 // Atom.rdf(v("z"), c("hasTopDepth"), v("top")),
276 // Atom.rdf(v("top"), IRI.RDF_TYPE, c("MeasuredDepth")),
277 // Atom.rdf(v("top"), c("valueInStandardUnit"), v("top_depth_md")),
278 // Atom.rdf(v("z"), c("hasBottomDepth"), v("bot")),
279 // Atom.rdf(v("bot"), IRI.RDF_TYPE, c("MeasuredDepth")),
280 // Atom.rdf(v("bot"), c("valueInStandardUnit"), v("bot_depth_md"))
281 // )
251 // ) 282 // )
252 283
253 val query7 = Query.create(
254 QueryType.SELECT,
255 false,
256 List(
257 v("wName"),
258 v("sample"),
259 v("porosity"),
260 v("top_depth_md"),
261 v("bot_depth_md")
262 ).asJava,
263 Conjunction.create(
264 Atom.rdf(v("w"), IRI.RDF_TYPE, c("Wellbore")),
265 Atom.rdf(v("w"), c("name"), v("wName")),
266 Atom.rdf(v("w"), c("hasWellboreInterval"), v("z")),
267 Atom.rdf(v("z"), c("hasUnit"), v("u")),
268 Atom.rdf(v("u"), c("name"), v("strat_unit_name")),
269 Atom.rdf(v("wellbore"), c("hasWellboreInterval"), v("cored_int")),
270 Atom.rdf(v("c"), c("extractedFrom"), v("cored_int")),
271 Atom.rdf(v("c"), c("hasCoreSample"), v("sample")),
272 Atom.rdf(v("sample"), c("hasDepth"), v("sample_depth")),
273 Atom.rdf(v("sample_depth"), c("inWellboreInterval"), v("z")),
274 Atom.rdf(v("sample"), c("hasPorosity"), v("p")),
275 Atom.rdf(v("p"), c("valueInStandardUnit"), v("porosity")),
276 Atom.rdf(v("z"), c("hasTopDepth"), v("top")),
277 Atom.rdf(v("top"), IRI.RDF_TYPE, c("MeasuredDepth")),
278 Atom.rdf(v("top"), c("valueInStandardUnit"), v("top_depth_md")),
279 Atom.rdf(v("z"), c("hasBottomDepth"), v("bot")),
280 Atom.rdf(v("bot"), IRI.RDF_TYPE, c("MeasuredDepth")),
281 Atom.rdf(v("bot"), c("valueInStandardUnit"), v("bot_depth_md"))
282 )
283 )
284
285 val queries = 284 val queries =
286 List(query0, query1, query2, query3, query4, query5, query6, query7) 285 List(query0, query1, query2, query3, query4, query5, query6, query7)
287 286
diff --git a/src/test/scala/rsacomb/OWLAxiomSpec.scala b/src/test/scala/rsacomb/OWLAxiomSpec.scala
index c685987..75803d8 100644
--- a/src/test/scala/rsacomb/OWLAxiomSpec.scala
+++ b/src/test/scala/rsacomb/OWLAxiomSpec.scala
@@ -19,18 +19,22 @@ import uk.ac.manchester.cs.owl.owlapi.{
19import uk.ac.manchester.cs.owl.owlapi.{OWLObjectPropertyImpl} 19import uk.ac.manchester.cs.owl.owlapi.{OWLObjectPropertyImpl}
20import org.semanticweb.owlapi.model.{OWLAxiom} 20import org.semanticweb.owlapi.model.{OWLAxiom}
21 21
22import tech.oxfordsemantic.jrdfox.logic.{Rule, BindAtom, BuiltinFunctionCall} 22import tech.oxfordsemantic.jrdfox.logic.Datatype
23import tech.oxfordsemantic.jrdfox.logic.{ 23import tech.oxfordsemantic.jrdfox.logic.datalog.{
24 Atom, 24 Rule,
25 TupleTableName, 25 BindAtom,
26 TupleTableAtom,
27 TupleTableName
28}
29import tech.oxfordsemantic.jrdfox.logic.expression.{
30 FunctionCall,
26 Term, 31 Term,
27 Variable, 32 Variable,
28 Literal, 33 Literal
29 Datatype
30} 34}
31 35
32import org.semanticweb.owlapi.model.{IRI => OWLIRI} 36import org.semanticweb.owlapi.model.{IRI => OWLIRI}
33import tech.oxfordsemantic.jrdfox.logic.{IRI => RDFIRI} 37import tech.oxfordsemantic.jrdfox.logic.expression.{IRI => RDFIRI}
34 38
35object OWLAxiomSpec { 39object OWLAxiomSpec {
36 40
@@ -188,15 +192,15 @@ class OWLAxiomSpec extends AnyFlatSpec with Matchers with LoneElement {
188 it should "contain a conjuction of atoms (Student[?x],Worker[?x]) in the body of the rule" in { 192 it should "contain a conjuction of atoms (Student[?x],Worker[?x]) in the body of the rule" in {
189 val result = convertAxiom(axiom_OWLSubClassOf1, term_x) 193 val result = convertAxiom(axiom_OWLSubClassOf1, term_x)
190 val body = List( 194 val body = List(
191 Atom.rdf(term_x, RDFIRI.RDF_TYPE, iri_Student), 195 TupleTableAtom.rdf(term_x, RDFIRI.RDF_TYPE, iri_Student),
192 Atom.rdf(term_x, RDFIRI.RDF_TYPE, iri_Worker) 196 TupleTableAtom.rdf(term_x, RDFIRI.RDF_TYPE, iri_Worker)
193 ) 197 )
194 result.loneElement.getBody should contain theSameElementsAs body 198 result.loneElement.getBody should contain theSameElementsAs body
195 } 199 }
196 200
197 it should "contain a single atom (PartTimeStudent[?x]) in the head of the rule" in { 201 it should "contain a single atom (PartTimeStudent[?x]) in the head of the rule" in {
198 val result = convertAxiom(axiom_OWLSubClassOf1, term_x) 202 val result = convertAxiom(axiom_OWLSubClassOf1, term_x)
199 val head = Atom.rdf(term_x, RDFIRI.RDF_TYPE, iri_PartTimeStudent) 203 val head = TupleTableAtom.rdf(term_x, RDFIRI.RDF_TYPE, iri_PartTimeStudent)
200 result.loneElement.getHead.loneElement should be(head) 204 result.loneElement.getHead.loneElement should be(head)
201 } 205 }
202 206
@@ -212,7 +216,7 @@ class OWLAxiomSpec extends AnyFlatSpec with Matchers with LoneElement {
212 val skolem = SkolemStrategy.Constant(axiom_OWLSubClassOf2.toString) 216 val skolem = SkolemStrategy.Constant(axiom_OWLSubClassOf2.toString)
213 val result = convertAxiom(axiom_OWLSubClassOf2, term_x, skolem) 217 val result = convertAxiom(axiom_OWLSubClassOf2, term_x, skolem)
214 val body = 218 val body =
215 Atom.rdf(term_x, RDFIRI.RDF_TYPE, iri_Student.getIRIString) 219 TupleTableAtom.rdf(term_x, RDFIRI.RDF_TYPE, iri_Student.getIRIString)
216 result.loneElement.getBody.loneElement should equal(body) 220 result.loneElement.getBody.loneElement should equal(body)
217 } 221 }
218 222
@@ -221,8 +225,8 @@ class OWLAxiomSpec extends AnyFlatSpec with Matchers with LoneElement {
221 // val result = convertAxiom(axiom_OWLSubClassOf2, term_x, skolem) 225 // val result = convertAxiom(axiom_OWLSubClassOf2, term_x, skolem)
222 // val term_c = RSA.internal(skolem.const.getIRI) 226 // val term_c = RSA.internal(skolem.const.getIRI)
223 // val head = List( 227 // val head = List(
224 // Atom.rdf(term_x, iri_hasSupervisor, term_c), 228 // TupleTableAtom.rdf(term_x, iri_hasSupervisor, term_c),
225 // Atom.rdf(term_c, RDFIRI.RDF_TYPE, iri_Professor) 229 // TupleTableAtom.rdf(term_c, RDFIRI.RDF_TYPE, iri_Professor)
226 // ) 230 // )
227 // result.loneElement.getHead should contain theSameElementsAs (head) 231 // result.loneElement.getHead should contain theSameElementsAs (head)
228 // } 232 // }
@@ -239,7 +243,7 @@ class OWLAxiomSpec extends AnyFlatSpec with Matchers with LoneElement {
239 val skolem = SkolemStrategy.Standard(axiom_OWLSubClassOf2.toString) 243 val skolem = SkolemStrategy.Standard(axiom_OWLSubClassOf2.toString)
240 val result = convertAxiom(axiom_OWLSubClassOf2, term_x, skolem) 244 val result = convertAxiom(axiom_OWLSubClassOf2, term_x, skolem)
241 val body = 245 val body =
242 Atom.rdf(term_x, RDFIRI.RDF_TYPE, iri_Student) 246 TupleTableAtom.rdf(term_x, RDFIRI.RDF_TYPE, iri_Student)
243 result.loneElement.getBody should contain(body) 247 result.loneElement.getBody should contain(body)
244 } 248 }
245 249
@@ -255,8 +259,8 @@ class OWLAxiomSpec extends AnyFlatSpec with Matchers with LoneElement {
255 // val skolem = SkolemStrategy.Standard(axiom_OWLSubClassOf2.toString) 259 // val skolem = SkolemStrategy.Standard(axiom_OWLSubClassOf2.toString)
256 // val result = convertAxiom(axiom_OWLSubClassOf2, term_x, skolem) 260 // val result = convertAxiom(axiom_OWLSubClassOf2, term_x, skolem)
257 // val head = List( 261 // val head = List(
258 // Atom.rdf(term_x, iri_hasSupervisor, term_y), 262 // TupleTableAtom.rdf(term_x, iri_hasSupervisor, term_y),
259 // Atom.rdf(term_y, RDFIRI.RDF_TYPE, iri_Professor) 263 // TupleTableAtom.rdf(term_y, RDFIRI.RDF_TYPE, iri_Professor)
260 // ) 264 // )
261 // result.loneElement.getHead should contain theSameElementsAs head 265 // result.loneElement.getHead should contain theSameElementsAs head
262 // } 266 // }
@@ -270,8 +274,8 @@ class OWLAxiomSpec extends AnyFlatSpec with Matchers with LoneElement {
270 // it should "contain a conjunction of atoms (hasSupervisor[?x,?y],Professor[?y]) in the body of the rule" in { 274 // it should "contain a conjunction of atoms (hasSupervisor[?x,?y],Professor[?y]) in the body of the rule" in {
271 // val result = convertAxiom(axiom_OWLSubClassOf3, term_x) 275 // val result = convertAxiom(axiom_OWLSubClassOf3, term_x)
272 // val body = List( 276 // val body = List(
273 // Atom.rdf(term_x, iri_hasSupervisor, term_y), 277 // TupleTableAtom.rdf(term_x, iri_hasSupervisor, term_y),
274 // Atom.rdf(term_y, RDFIRI.RDF_TYPE, iri_Professor) 278 // TupleTableAtom.rdf(term_y, RDFIRI.RDF_TYPE, iri_Professor)
275 // ) 279 // )
276 // result.loneElement.getBody should contain theSameElementsAs body 280 // result.loneElement.getBody should contain theSameElementsAs body
277 // } 281 // }
@@ -279,7 +283,7 @@ class OWLAxiomSpec extends AnyFlatSpec with Matchers with LoneElement {
279 it should "contain a single atom (Student[?x]) in the head of the rule" in { 283 it should "contain a single atom (Student[?x]) in the head of the rule" in {
280 val result = convertAxiom(axiom_OWLSubClassOf3, term_x) 284 val result = convertAxiom(axiom_OWLSubClassOf3, term_x)
281 val head = 285 val head =
282 Atom.rdf(term_x, RDFIRI.RDF_TYPE, iri_Student) 286 TupleTableAtom.rdf(term_x, RDFIRI.RDF_TYPE, iri_Student)
283 result.loneElement.getHead.loneElement should be(head) 287 result.loneElement.getHead.loneElement should be(head)
284 } 288 }
285 289
@@ -292,13 +296,13 @@ class OWLAxiomSpec extends AnyFlatSpec with Matchers with LoneElement {
292 it should "contain a single atoms (Student[?x]) in the body of the rule" in { 296 it should "contain a single atoms (Student[?x]) in the body of the rule" in {
293 val result = convertAxiom(axiom_OWLSubClassOf4, term_x) 297 val result = convertAxiom(axiom_OWLSubClassOf4, term_x)
294 val body = 298 val body =
295 Atom.rdf(term_x, RDFIRI.RDF_TYPE, iri_Student) 299 TupleTableAtom.rdf(term_x, RDFIRI.RDF_TYPE, iri_Student)
296 result.loneElement.getBody.loneElement should be(body) 300 result.loneElement.getBody.loneElement should be(body)
297 } 301 }
298 302
299 it should "contain a single atom (sameAs[?x,alice])) in the head of the rule" in { 303 it should "contain a single atom (sameAs[?x,alice])) in the head of the rule" in {
300 val result = convertAxiom(axiom_OWLSubClassOf4, term_x) 304 val result = convertAxiom(axiom_OWLSubClassOf4, term_x)
301 val head = Atom.rdf(term_x, RDFIRI.SAME_AS, term_alice) 305 val head = TupleTableAtom.rdf(term_x, RDFIRI.SAME_AS, term_alice)
302 result.loneElement.getHead.loneElement should be(head) 306 result.loneElement.getHead.loneElement should be(head)
303 } 307 }
304 308
@@ -311,18 +315,18 @@ class OWLAxiomSpec extends AnyFlatSpec with Matchers with LoneElement {
311 // it should "contain a conjunction of atoms (...) in the body of the rule" in { 315 // it should "contain a conjunction of atoms (...) in the body of the rule" in {
312 // val result = convertAxiom(axiom_OWLSubClassOf5, term_x) 316 // val result = convertAxiom(axiom_OWLSubClassOf5, term_x)
313 // val body = List( 317 // val body = List(
314 // Atom.rdf(term_x, RDFIRI.RDF_TYPE, iri_Student), 318 // TupleTableAtom.rdf(term_x, RDFIRI.RDF_TYPE, iri_Student),
315 // Atom.rdf(term_x, iri_hasSupervisor, term_y), 319 // TupleTableAtom.rdf(term_x, iri_hasSupervisor, term_y),
316 // Atom.rdf(term_y, RDFIRI.RDF_TYPE, iri_Professor), 320 // TupleTableAtom.rdf(term_y, RDFIRI.RDF_TYPE, iri_Professor),
317 // Atom.rdf(term_x, iri_hasSupervisor, term_z), 321 // TupleTableAtom.rdf(term_x, iri_hasSupervisor, term_z),
318 // Atom.rdf(term_z, RDFIRI.RDF_TYPE, iri_Professor) 322 // TupleTableAtom.rdf(term_z, RDFIRI.RDF_TYPE, iri_Professor)
319 // ) 323 // )
320 // result.loneElement.getBody should contain theSameElementsAs body 324 // result.loneElement.getBody should contain theSameElementsAs body
321 // } 325 // }
322 326
323 // it should "contain a single atom (sameAs[?x,?z])) in the head of the rule" in { 327 // it should "contain a single atom (sameAs[?x,?z])) in the head of the rule" in {
324 // val result = convertAxiom(axiom_OWLSubClassOf5, term_x) 328 // val result = convertAxiom(axiom_OWLSubClassOf5, term_x)
325 // val head = Atom.rdf(term_y, RDFIRI.SAME_AS, term_z) 329 // val head = TupleTableAtom.rdf(term_y, RDFIRI.SAME_AS, term_z)
326 // result.loneElement.getHead.loneElement should be(head) 330 // result.loneElement.getHead.loneElement should be(head)
327 // } 331 // }
328 332
diff --git a/src/test/scala/rsacomb/OWLClassSpec.scala b/src/test/scala/rsacomb/OWLClassSpec.scala
index ed91ba7..a8ac14e 100644
--- a/src/test/scala/rsacomb/OWLClassSpec.scala
+++ b/src/test/scala/rsacomb/OWLClassSpec.scala
@@ -18,16 +18,19 @@ import uk.ac.manchester.cs.owl.owlapi.{
18} 18}
19import uk.ac.manchester.cs.owl.owlapi.{OWLObjectPropertyImpl} 19import uk.ac.manchester.cs.owl.owlapi.{OWLObjectPropertyImpl}
20import org.semanticweb.owlapi.model.IRI 20import org.semanticweb.owlapi.model.IRI
21import tech.oxfordsemantic.jrdfox.logic.{IRI => RDFIRI} 21import tech.oxfordsemantic.jrdfox.logic.expression.{IRI => RDFIRI}
22 22
23import tech.oxfordsemantic.jrdfox.logic.{BindAtom, BuiltinFunctionCall} 23import tech.oxfordsemantic.jrdfox.logic.Datatype
24import tech.oxfordsemantic.jrdfox.logic.{ 24import tech.oxfordsemantic.jrdfox.logic.datalog.{
25 Atom, 25 TupleTableAtom,
26 TupleTableName, 26 TupleTableName,
27 BindAtom
28}
29import tech.oxfordsemantic.jrdfox.logic.expression.{
30 FunctionCall,
27 Term, 31 Term,
28 Variable, 32 Variable,
29 Literal, 33 Literal
30 Datatype
31} 34}
32 35
33import rsacomb.RDFoxRuleShards 36import rsacomb.RDFoxRuleShards
@@ -116,10 +119,10 @@ class OWLClassSpec extends AnyFlatSpec with Matchers with LoneElement {
116 result shouldBe a[RDFoxRuleShards] 119 result shouldBe a[RDFoxRuleShards]
117 } 120 }
118 121
119 it should "have a single Atom in its result list" in { 122 it should "have a single TupleTableAtom in its result list" in {
120 val visitor = RDFoxClassExprConverter(term_x) 123 val visitor = RDFoxClassExprConverter(term_x)
121 val result = class_OWLClass.accept(visitor) 124 val result = class_OWLClass.accept(visitor)
122 result.res.loneElement shouldBe an[Atom] 125 result.res.loneElement shouldBe an[TupleTableAtom]
123 } 126 }
124 127
125 it should "have an empty extension list" in { 128 it should "have an empty extension list" in {
@@ -156,10 +159,10 @@ class OWLClassSpec extends AnyFlatSpec with Matchers with LoneElement {
156 result shouldBe a[RDFoxRuleShards] 159 result shouldBe a[RDFoxRuleShards]
157 } 160 }
158 161
159 // it should "be converted into a single <owl:sameAs> Atom" in { 162 // it should "be converted into a single <owl:sameAs> TupleTableAtom" in {
160 // val visitor = RDFoxClassExprConverter(term_x) 163 // val visitor = RDFoxClassExprConverter(term_x)
161 // val result = class_OWLObjectOneOf.accept(visitor) 164 // val result = class_OWLObjectOneOf.accept(visitor)
162 // result.res.loneElement should (be (a [Atom]) and have ('tupleTableName (pred_sameAs))) 165 // result.res.loneElement should (be (a [TupleTableAtom]) and have ('tupleTableName (pred_sameAs)))
163 // } 166 // }
164 167
165 it should "have an empty extension list" in { 168 it should "have an empty extension list" in {
@@ -176,12 +179,12 @@ class OWLClassSpec extends AnyFlatSpec with Matchers with LoneElement {
176 result shouldBe a[RDFoxRuleShards] 179 result shouldBe a[RDFoxRuleShards]
177 } 180 }
178 181
179 it should "have two Atoms in its result list" in { 182 it should "have two TupleTableAtoms in its result list" in {
180 val visitor = RDFoxClassExprConverter(term_x) 183 val visitor = RDFoxClassExprConverter(term_x)
181 val result = class_OWLObjectSomeValuesFrom.accept(visitor) 184 val result = class_OWLObjectSomeValuesFrom.accept(visitor)
182 exactly(2, result.res) should (be(an[Atom]) and have( 185 exactly(2, result.res) should (be(an[TupleTableAtom])
183 'numberOfArguments (3) 186 //and have('numberOfArguments (3))
184 )) 187 )
185 } 188 }
186 189
187 it should "have an empty extension list" in { 190 it should "have an empty extension list" in {
@@ -198,13 +201,13 @@ class OWLClassSpec extends AnyFlatSpec with Matchers with LoneElement {
198 result shouldBe a[RDFoxRuleShards] 201 result shouldBe a[RDFoxRuleShards]
199 } 202 }
200 203
201 it should "have exactly two Atoms in its result list" in { 204 it should "have exactly two TupleTableAtoms in its result list" in {
202 val skolem = SkolemStrategy.Standard(class_OWLObjectSomeValuesFrom.toString) 205 val skolem = SkolemStrategy.Standard(class_OWLObjectSomeValuesFrom.toString)
203 val visitor = RDFoxClassExprConverter(term_x, List(), skolem) 206 val visitor = RDFoxClassExprConverter(term_x, List(), skolem)
204 val result = class_OWLObjectSomeValuesFrom.accept(visitor) 207 val result = class_OWLObjectSomeValuesFrom.accept(visitor)
205 exactly(2, result.res) should (be(an[Atom]) and have( 208 exactly(2, result.res) should (be(an[TupleTableAtom])
206 'numberOfArguments (3) 209 //and have('numberOfArguments (3))
207 )) 210 )
208 } 211 }
209 212
210 it should "should have a single SKOLEM call in the extension list" in { 213 it should "should have a single SKOLEM call in the extension list" in {
@@ -212,8 +215,8 @@ class OWLClassSpec extends AnyFlatSpec with Matchers with LoneElement {
212 val visitor = RDFoxClassExprConverter(term_x, List(), skolem) 215 val visitor = RDFoxClassExprConverter(term_x, List(), skolem)
213 val result = class_OWLObjectSomeValuesFrom.accept(visitor) 216 val result = class_OWLObjectSomeValuesFrom.accept(visitor)
214 result.ext.loneElement shouldBe a[BindAtom] 217 result.ext.loneElement shouldBe a[BindAtom]
215 val builtin = result.ext.head.asInstanceOf[BindAtom].getBuiltinExpression 218 val builtin = result.ext.head.asInstanceOf[BindAtom].getExpression
216 builtin should (be(a[BuiltinFunctionCall]) and have( 219 builtin should (be(a[FunctionCall]) and have(
217 'functionName ("SKOLEM") 220 'functionName ("SKOLEM")
218 )) 221 ))
219 } 222 }
@@ -226,13 +229,13 @@ class OWLClassSpec extends AnyFlatSpec with Matchers with LoneElement {
226 result shouldBe a[RDFoxRuleShards] 229 result shouldBe a[RDFoxRuleShards]
227 } 230 }
228 231
229 it should "have exactly two Atoms in its result list" in { 232 it should "have exactly two TupleTableAtoms in its result list" in {
230 val skolem = SkolemStrategy.Constant(class_OWLObjectSomeValuesFrom.toString) 233 val skolem = SkolemStrategy.Constant(class_OWLObjectSomeValuesFrom.toString)
231 val visitor = RDFoxClassExprConverter(term_x, List(), skolem) 234 val visitor = RDFoxClassExprConverter(term_x, List(), skolem)
232 val result = class_OWLObjectSomeValuesFrom.accept(visitor) 235 val result = class_OWLObjectSomeValuesFrom.accept(visitor)
233 exactly(2, result.res) should (be(an[Atom]) and have( 236 exactly(2, result.res) should (be(an[TupleTableAtom])
234 'numberOfArguments (3) 237 //and have('numberOfArguments (3))
235 )) 238 )
236 } 239 }
237 240
238 it should "have an empty extension list" in { 241 it should "have an empty extension list" in {
@@ -250,20 +253,20 @@ class OWLClassSpec extends AnyFlatSpec with Matchers with LoneElement {
250 result shouldBe a[RDFoxRuleShards] 253 result shouldBe a[RDFoxRuleShards]
251 } 254 }
252 255
253 // it should "have a single <owl:sameAs> Atom in the result list" in { 256 // it should "have a single <owl:sameAs> TupleTableAtom in the result list" in {
254 // val visitor = RDFoxClassExprConverter(term_x) 257 // val visitor = RDFoxClassExprConverter(term_x)
255 // val result = class_OWLObjectMaxCardinality.accept(visitor) 258 // val result = class_OWLObjectMaxCardinality.accept(visitor)
256 // result.res.loneElement should (be(an[Atom]) and have( 259 // result.res.loneElement should (be(an[TupleTableAtom]) and have(
257 // 'tupleTableName (pred_sameAs) 260 // 'tupleTableName (pred_sameAs)
258 // )) 261 // ))
259 // } 262 // }
260 263
261 it should "have 4 Atoms in its extension list" in { 264 it should "have 4 TupleTableAtoms in its extension list" in {
262 val visitor = RDFoxClassExprConverter(term_x) 265 val visitor = RDFoxClassExprConverter(term_x)
263 val result = class_OWLObjectMaxCardinality.accept(visitor) 266 val result = class_OWLObjectMaxCardinality.accept(visitor)
264 exactly(4, result.ext) should (be(an[Atom]) and have( 267 exactly(4, result.ext) should (be(an[TupleTableAtom])
265 'numberOfArguments (3) 268 //and have('numberOfArguments (3))
266 )) 269 )
267 } 270 }
268 271
269} // class OWLClassSpec 272} // class OWLClassSpec
generated by cgit v1.2.3 (git 2.25.1) at 2025-07-04 03:15:32 +0000