4 files changed, 171 insertions, 126 deletions

diff --git a/src/main/scala/uk/ac/ox/cs/rsacomb/util/DataFactory.scala b/src/main/scala/uk/ac/ox/cs/rsacomb/util/DataFactory.scala
new file mode 100644
index 0000000..848c6b5
--- /dev/null
+++ b/src/main/scala/uk/ac/ox/cs/rsacomb/util/DataFactory.scala
@@ -0,0 +1,29 @@
+package uk.ac.ox.cs.rsacomb.util
+
+import org.semanticweb.owlapi.apibinding.OWLManager
+import org.semanticweb.owlapi.model.OWLClass
+import tech.oxfordsemantic.jrdfox.logic.expression.Variable
+
+/** Simple fresh variable/class generator */
+object DataFactory {
+
+  /** Manager instance to interface with OWLAPI */
+  private val manager = OWLManager.createOWLOntologyManager()
+  private val factory = manager.getOWLDataFactory()
+
+  def apply(counter: Integer = -1): DataFactory = new DataFactory(counter)
+}
+
+class DataFactory(private var counter: Integer) {
+
+  private def getNext(): Integer = {
+    counter += 1
+    counter
+  }
+
+  def getVariable(): Variable =
+    Variable.create(f"I${this.getNext()}%05d")
+
+  def getOWLClass(): OWLClass =
+    DataFactory.factory.getOWLClass(s"X${this.getNext()}")
+}
diff --git a/src/main/scala/uk/ac/ox/cs/rsacomb/util/Logger.scala b/src/main/scala/uk/ac/ox/cs/rsacomb/util/Logger.scala
index bcb1445..a55b5a0 100644
--- a/src/main/scala/uk/ac/ox/cs/rsacomb/util/Logger.scala
+++ b/src/main/scala/uk/ac/ox/cs/rsacomb/util/Logger.scala
@@ -25,6 +25,10 @@ import java.io.PrintStream
   */
 object Logger {
 
+  private val time = Calendar.getInstance()
+
+  private lazy val dir = os.temp.dir(os.pwd, "rsacomb-", false)
+
   /** Output stream for the logger. */
   var output: PrintStream = System.out
 
@@ -34,7 +38,7 @@ object Logger {
     def compare(that: Level) = this.level - that.level
     override def toString = name
   }
-  case object QUIET extends Level(0, "normal")
+  case object QUIET extends Level(0, "quiet")
   case object NORMAL extends Level(1, "normal")
   case object DEBUG extends Level(2, "debug")
   case object VERBOSE extends Level(3, "verbose")
@@ -42,12 +46,13 @@ object Logger {
   /** Currend logger level */
   var level: Level = DEBUG
 
-  def print(str: Any, lvl: Level = NORMAL): Unit = {
-    if (lvl <= level) {
-      val time = Calendar.getInstance.getTime
-      output println s"[$lvl][$time] $str"
-    }
-  }
+  def print(str: Any, lvl: Level = NORMAL): Unit =
+    if (lvl <= level)
+      output println s"[$lvl][${time.getTime}] $str"
+
+  def write(content: => os.Source, file: String, lvl: Level = VERBOSE): Unit =
+    if (lvl <= level)
+      os.write.append(dir / file, content)
 
   def timed[A](expr: => A, desc: String = "", lvl: Level = NORMAL): A = {
     val t0 = System.currentTimeMillis()
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 a9027cf..e3e7dd4 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,9 +39,11 @@ 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
 import uk.ac.ox.cs.rsacomb.suffix.Nth
 import uk.ac.ox.cs.rsacomb.util.Logger
 
@@ -84,12 +87,29 @@ object RDFoxUtil {
     val password = ""
     val server =
       ConnectionFactory.newServerConnection(serverUrl, role, password)
+    opts.put("type", "par-complex-nn")
     if (!server.containsDataStore(datastore))
-      server.createDataStore(datastore, "par-complex-nn", opts)
+      server.createDataStore(datastore, opts)
     val data = server.newDataStoreConnection(datastore)
     (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(
@@ -122,13 +142,14 @@ object RDFoxUtil {
   def addRules(data: DataStoreConnection, rules: Seq[Rule]): Unit =
     Logger.timed(
       if (rules.length > 0) {
-        data.importData(
-          UpdateType.ADDITION,
-          RSA.Prefixes,
-          rules
-            .map(_.toString(Prefixes.s_emptyPrefixes))
-            .mkString("\n")
-        )
+        data addRules rules
+        // data.importData(
+        //   UpdateType.ADDITION,
+        //   RSA.Prefixes,
+        //   rules
+        //     .map(_.toString(Prefixes.s_emptyPrefixes))
+        //     .mkString("\n")
+        // )
       },
       s"Loading ${rules.length} rules",
       Logger.DEBUG
@@ -139,10 +160,15 @@ object RDFoxUtil {
     * @param data datastore connection
     * @param facts collection of facts to be added to the data store
     */
-  def addFacts(data: DataStoreConnection, facts: Seq[TupleTableAtom]): Unit =
+  def addFacts(
+      data: DataStoreConnection,
+      graph: IRI,
+      facts: Seq[TupleTableAtom]
+  ): Unit =
     Logger.timed(
       if (facts.length > 0) {
         data.importData(
+          graph.getIRI,
           UpdateType.ADDITION,
           RSA.Prefixes,
           facts
@@ -157,15 +183,17 @@ 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(data: DataStoreConnection, files: File*): Unit =
+  def addData(data: DataStoreConnection, graph: IRI, files: os.Path*): Unit =
     Logger.timed(
-      files.foreach {
+      files.foreach { path =>
         data.importData(
+          graph.getIRI,
           UpdateType.ADDITION,
           RSA.Prefixes,
-          _
+          path.toIO
         )
       },
       "Loading data files",
@@ -176,15 +204,6 @@ object RDFoxUtil {
   def materialize(data: DataStoreConnection): Unit =
     Logger.timed(data.updateMaterialization(), "Materialization", Logger.DEBUG)
 
-  /** Load SPARQL query from file. */
-  def loadQueryFromFile(file: File): String = {
-    val source = io.Source.fromFile(file)
-    val query = source.getLines mkString "\n"
-    Logger print s"Loaded query:\n$query"
-    source.close()
-    query
-  }
-
   /** Export data in `text/turtle`.
     *
     * @param data datastore connection from which to export data.
@@ -205,6 +224,50 @@ object RDFoxUtil {
     )
   }
 
+  /** Load SPARQL queries from file.
+    *
+    * The file can list multiple queries, each preceeded with a
+    * single line containing "#^[Query<id>]" where "<id>" is a number.
+    * Empty lines are ignored.
+    *
+    * @note if a query is not recognized as a [[SelectQuery]] by RDFox
+    * it is discarded.
+    *
+    * @param file file containing a list of conjunctive queries.
+    * @param prefixes additional prefixes for the query. It defaults to
+    * an empty set.
+    *
+    * @return a list of [[tech.oxfordsemantic.jrdfox.logic.sparql.statement.SelectQuery SelectQuery]] queries.
+    */
+  def loadQueriesFromFile(
+      path: os.Path,
+      prefixes: Prefixes = new Prefixes()
+  ): List[ConjunctiveQuery] = {
+    val header = raw"\^\[[Qq]uery(\d+)\]".r
+    val comment = "^#.*".r
+    val queries = os.read
+      .lines(path)
+      .map(_.trim.filter(_ >= ' '))
+      .filterNot(_ == "")
+      .foldRight((List.empty[Option[ConjunctiveQuery]], List.empty[String])) {
+        case (line, (acc, query)) => {
+          line match {
+            case header(id) => {
+              val cq =
+                ConjunctiveQuery.parse(id.toInt, query.mkString(" "), prefixes)
+              (cq :: acc, List.empty)
+            }
+            case comment() => (acc, query)
+            case _         => (acc, line :: query)
+          }
+        }
+      }
+      ._1
+      .collect { case Some(q) => q }
+    Logger print s"Loaded ${queries.length} queries from $path"
+    queries
+  }
+
   /** Parse a SELECT query from a string in SPARQL format.
     *
     * @param query the string containing the SPARQL query
@@ -282,12 +345,14 @@ object RDFoxUtil {
     * compatible with RDFox engine. This helper allows to build a query
     * to gather all instances of an internal predicate
     *
+    * @param graph named graph to query for the provided predicate
     * @param pred name of the predicate to describe.
     * @param arity arity of the predicate.
     * @return a string containing a SPARQL query.
     */
   def buildDescriptionQuery(
-      pred: String,
+      graph: IRI,
+      pred: IRI,
       arity: Int
   ): String = {
     if (arity > 0) {
@@ -295,55 +360,12 @@ object RDFoxUtil {
       s"""
       SELECT $variables
       WHERE {
-          ?K a rsa:$pred.
-          TT <http://oxfordsemantic.tech/RDFox#SKOLEM> { $variables ?K } .
+        GRAPH $graph { ?K a $pred }.
+        TT ${TupleTableName.SKOLEM} { $variables ?K } .
       }
       """
     } else {
-      "ASK { ?X a rsa:Ans }"
-    }
-  }
-
-  /** Reify a [[tech.oxfordsemantic.jrdfox.logic.datalog.Rule Rule]].
-    *
-    * This is needed because RDFox supports only predicates of arity 1
-    * or 2, but the filtering program uses predicates with higher arity.
-    *
-    * @note we can perform a reification of the atoms thanks to the
-    * built-in `SKOLEM` funtion of RDFox.
-    */
-  def reify(rule: Rule): Rule = {
-    val (sk, as) = rule.getHead.map(_.reified).unzip
-    val head: List[TupleTableAtom] = as.flatten
-    val skolem: List[BodyFormula] = sk.flatten
-    val body: List[BodyFormula] = rule.getBody.map(reify).flatten
-    Rule.create(head, skolem ::: body)
-  }
-
-  /** Reify a [[tech.oxfordsemantic.jrdfox.logic.datalog.BodyFormula BodyFormula]].
-    *
-    * This is needed because RDFox supports only predicates of arity 1
-    * or 2, but the filtering program uses predicates with higher arity.
-    *
-    * @note we can perform a reification of the atoms thanks to the
-    * built-in `SKOLEM` funtion of RDFox.
-    */
-  private def reify(formula: BodyFormula): List[BodyFormula] = {
-    formula match {
-      case atom: TupleTableAtom => atom.reified._2
-      case neg: Negation => {
-        val (sk, as) = neg.getNegatedAtoms
-          .map({
-            case a: TupleTableAtom => a.reified
-            case a                 => (None, List(a))
-          })
-          .unzip
-        val skolem =
-          sk.flatten.map(_.getArguments.last).collect { case v: Variable => v }
-        val atoms = as.flatten
-        List(Negation.create(skolem, atoms))
-      }
-      case other => List(other)
+      s"ASK { GRAPH $graph { ?X a $pred } }"
     }
   }
 
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..5abb83c 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,15 +42,51 @@ import scala.collection.JavaConverters._
 
 object RSA {
 
+  /** Simplify conversion between Java and Scala `List`s */
+  import uk.ac.ox.cs.rsacomb.implicits.JavaCollections._
+
+  /** 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#")
 
+  /** Creates a `rsacomb:<name>` IRI */
+  def apply(name: Any): IRI =
+    IRI.create(
+      //Prefixes.decodeIRI("rsacomb:") + name.toString
+      Prefixes.getPrefixIRIsByPrefixName.get("rsacomb:").getIRI + name.toString
+    )
+
+  /** Helper IRIs */
+  val ANS = RSA("Ans")
+  val AQ = RSA("AQ")
   val CONGRUENT = RSA("congruent")
+  val FK = RSA("FK")
+  val ID = RSA("ID")
+  val IN = RSA("In")
   val NAMED = RSA("Named")
+  val NI = RSA("NI")
+  val QM = RSA("QM")
+  val SP = RSA("SP")
+  val TQ = RSA("TQ")
+
+  def Named(tt: TupleTableName)(x: Term): TupleTableAtom =
+    TupleTableAtom.create(tt, x, IRI.RDF_TYPE, RSA.NAMED)
+  def Congruent(tt: TupleTableName)(x: Term, y: Term): TupleTableAtom =
+    TupleTableAtom.create(tt, x, RSA.CONGRUENT, y)
+  def Skolem(skolem: Term, terms: List[Term]): TupleTableAtom =
+    TupleTableAtom.create(TupleTableName.SKOLEM, terms :+ skolem)
+
+  // def In(t: Term)(implicit set: Term) =
+  //   TupleTableAtom.rdf(t, RSA("In"), set)
 
-  private def atom(name: IRI, vars: List[Term]): TupleTableAtom =
-    TupleTableAtom.create(TupleTableName.create(name.getIRI), vars: _*)
+  // def NotIn(t: Term)(implicit set: Term) = Negation.create(In(t)(set))
+
+  /* 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)
@@ -61,51 +97,4 @@ object RSA {
   def U(t: Term) =
     TupleTableAtom.rdf(t, IRI.RDF_TYPE, RSA("U"))
 
-  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 Congruent(t1: Term, t2: Term) =
-    TupleTableAtom.rdf(t1, RSA("congruent"), t2)
-
-  def QM(implicit q: ConjunctiveQuery) =
-    atom(RSA("QM"), q.answer ::: q.bounded)
-
-  def ID(t1: Term, t2: Term)(implicit q: ConjunctiveQuery) = {
-    atom(RSA("ID"), (q.answer ::: q.bounded) :+ t1 :+ t2)
-  }
-
-  def Named(t: Term) =
-    TupleTableAtom.rdf(t, IRI.RDF_TYPE, RSA("Named"))
-
-  def Thing(t: Term) =
-    TupleTableAtom.rdf(t, IRI.RDF_TYPE, IRI.THING)
-
-  def NI(t: Term) =
-    TupleTableAtom.rdf(t, IRI.RDF_TYPE, RSA("NI"))
-
-  def TQ(t1: Term, t2: Term, sx: RSASuffix)(implicit q: ConjunctiveQuery) =
-    atom(RSA("TQ" :: sx), (q.answer ::: q.bounded) :+ t1 :+ t2)
-
-  def AQ(t1: Term, t2: Term, sx: RSASuffix)(implicit q: ConjunctiveQuery) =
-    atom(RSA("AQ" :: sx), (q.answer ::: q.bounded) :+ t1 :+ t2)
-
-  def FK(implicit q: ConjunctiveQuery) =
-    atom(RSA("FK"), q.answer ::: q.bounded)
-
-  def SP(implicit q: ConjunctiveQuery) =
-    atom(RSA("SP"), q.answer ::: q.bounded)
-
-  def Ans(implicit q: ConjunctiveQuery) = {
-    if (q.bcq)
-      TupleTableAtom.rdf(RSA("blank"), IRI.RDF_TYPE, RSA("Ans"))
-    else
-      atom(RSA("Ans"), q.answer)
-  }
-
-  def apply(name: Any): IRI =
-    IRI.create(
-      Prefixes.getPrefixIRIsByPrefixName.get("rsa:").getIRI + name.toString
-    )
 }