Make canonical model generation parametric over named graph

2 files changed, 54 insertions, 28 deletions

diff --git a/src/main/scala/uk/ac/ox/cs/rsacomb/util/RDFoxUtil.scala b/src/main/scala/uk/ac/ox/cs/rsacomb/util/RDFoxUtil.scala
index 6f5ff31..568858c 100644
--- a/src/main/scala/uk/ac/ox/cs/rsacomb/util/RDFoxUtil.scala
+++ b/src/main/scala/uk/ac/ox/cs/rsacomb/util/RDFoxUtil.scala
@@ -17,6 +17,7 @@
 package uk.ac.ox.cs.rsacomb.util
 
 import java.io.{OutputStream, File, StringReader}
+import scala.collection.JavaConverters._
 import tech.oxfordsemantic.jrdfox.Prefixes
 import tech.oxfordsemantic.jrdfox.client.{
   ComponentInfo,
@@ -38,7 +39,8 @@ import tech.oxfordsemantic.jrdfox.logic.expression.{
   Literal,
   Resource,
   Variable,
-  Term
+  Term,
+  IRI
 }
 import tech.oxfordsemantic.jrdfox.logic.sparql.statement.SelectQuery
 import uk.ac.ox.cs.rsacomb.sparql.ConjunctiveQuery
@@ -92,6 +94,22 @@ object RDFoxUtil {
     (server, data)
   }
 
+  /** Get the IRI of a named graph (creating it if necessary)
+    *
+    * @param datastore name of the datastore to perform the action in.
+    * @param name name of the named graph.
+    *
+    * @return the full IRI for the (new) named graph.
+    */
+  def getNamedGraph(datastore: String, name: String): IRI = {
+    val graph = RSA(name)
+    val (server, data) = openConnection(datastore)
+    if (!data.containsTupleTable(graph.getIRI))
+      data.createTupleTable(graph.getIRI, Map("type" -> "named-graph").asJava)
+    RDFoxUtil.closeConnection(server, data)
+    return graph
+  }
+
   /** Create a built-in `rdfox:SKOLEM` TupleTableAtom. */
   def skolem(name: String, terms: Term*): TupleTableAtom =
     TupleTableAtom.create(
@@ -143,14 +161,14 @@ object RDFoxUtil {
     * @param facts collection of facts to be added to the data store
     */
   def addFacts(
-      graph: String,
       data: DataStoreConnection,
+      graph: IRI,
       facts: Seq[TupleTableAtom]
   ): Unit =
     Logger.timed(
       if (facts.length > 0) {
         data.importData(
-          graph,
+          graph.getIRI,
           UpdateType.ADDITION,
           RSA.Prefixes,
           facts
@@ -165,12 +183,13 @@ object RDFoxUtil {
   /** Imports a sequence of files directly into a datastore.
     *
     * @param data datastore connection.
+    * @param graph named graph where the data should be uploaded
     * @param files sequence of files to upload.
     */
-  def addData(graph: String, data: DataStoreConnection, files: File*): Unit =
+  def addData(data: DataStoreConnection, graph: IRI, files: File*): Unit =
     Logger.timed(
       files.foreach {
-        data.importData(graph, UpdateType.ADDITION, RSA.Prefixes, _)
+        data.importData(graph.getIRI, UpdateType.ADDITION, RSA.Prefixes, _)
       },
       "Loading data files",
       Logger.DEBUG
diff --git a/src/main/scala/uk/ac/ox/cs/rsacomb/util/RSA.scala b/src/main/scala/uk/ac/ox/cs/rsacomb/util/RSA.scala
index 8b341ba..96d3aa8 100644
--- a/src/main/scala/uk/ac/ox/cs/rsacomb/util/RSA.scala
+++ b/src/main/scala/uk/ac/ox/cs/rsacomb/util/RSA.scala
@@ -42,32 +42,29 @@ import scala.collection.JavaConverters._
 
 object RSA {
 
+  /** Set of default prefixes to be included in all datastore operations */
   val Prefixes: Prefixes = new Prefixes()
-  Prefixes.declarePrefix("rsa:", "http://www.cs.ox.ac.uk/isg/rsa/")
+  Prefixes.declarePrefix("rsacomb:", "http://www.cs.ox.ac.uk/isg/RSAComb#")
+  Prefixes.declarePrefix("rdfox:", "http://oxfordsemantic.tech/RDFox#")
   Prefixes.declarePrefix("owl:", "http://www.w3.org/2002/07/owl#")
 
-  val CONGRUENT = RSA("congruent")
-  val NAMED = RSA("Named")
-
-  private def atom(name: IRI, vars: List[Term]): TupleTableAtom =
-    TupleTableAtom.create(TupleTableName.create(name.getIRI), vars: _*)
-
-  def E(t1: Term, t2: Term) =
-    TupleTableAtom.rdf(t1, RSA("E"), t2)
-
-  def PE(t1: Term, t2: Term) =
-    TupleTableAtom.rdf(t1, RSA("PE"), t2)
+  /** Creates a `rsacomb:<name>` IRI */
+  def apply(name: Any): IRI =
+    IRI.create(
+      Prefixes.getPrefixIRIsByPrefixName.get("rsacomb:").getIRI + name.toString
+    )
 
-  def U(t: Term) =
-    TupleTableAtom.rdf(t, IRI.RDF_TYPE, RSA("U"))
+  val NAMED = RSA("Named")
+  val CONGRUENT = RSA("congruent")
+  val IN = RSA("In")
 
-  def In(t: Term)(implicit set: Term) =
-    TupleTableAtom.rdf(t, RSA("In"), set)
+  // def In(t: Term)(implicit set: Term) =
+  //   TupleTableAtom.rdf(t, RSA("In"), set)
 
-  def NotIn(t: Term)(implicit set: Term) = Negation.create(In(t)(set))
+  // def NotIn(t: Term)(implicit set: Term) = Negation.create(In(t)(set))
 
-  def Congruent(t1: Term, t2: Term) =
-    TupleTableAtom.rdf(t1, RSA("congruent"), t2)
+  // def Congruent(t1: Term, t2: Term) =
+  //   TupleTableAtom.rdf(t1, RSA("congruent"), t2)
 
   def QM(implicit q: ConjunctiveQuery) =
     atom(RSA("QM"), q.answer ::: q.bounded)
@@ -104,8 +101,18 @@ object RSA {
       atom(RSA("Ans"), q.answer)
   }
 
-  def apply(name: Any): IRI =
-    IRI.create(
-      Prefixes.getPrefixIRIsByPrefixName.get("rsa:").getIRI + name.toString
-    )
+  /* TODO: review after reworking the dependency graph construction */
+
+  // private def atom(name: IRI, vars: List[Term]): TupleTableAtom =
+  //   TupleTableAtom.create(TupleTableName.create(name.getIRI), vars: _*)
+
+  def E(t1: Term, t2: Term) =
+    TupleTableAtom.rdf(t1, RSA("E"), t2)
+
+  def PE(t1: Term, t2: Term) =
+    TupleTableAtom.rdf(t1, RSA("PE"), t2)
+
+  def U(t: Term) =
+    TupleTableAtom.rdf(t, IRI.RDF_TYPE, RSA("U"))
+
 }