push static with comma-separated sources enabled

Author: emrekenar

src/main/antlr/While.g4

@@ -152,7 +152,7 @@ statement :   SKIP_S SEMI
 			| RETURN expression SEMI                                                                                                                    # return_statement
 			| fmu=expression DOT TICK OPARAN time=expression CPARAN SEMI                                                                                # tick_statement
 			| (declType = type)? target=expression ASS WINDOW OPARAN monitor=expression CPARAN SEMI                                                     # window_statement
-            | PUSH_STATIC SEMI                                                                                                                          # pushStatic_statement
+            | (declType = type)? target=expression ASS PUSH_STATIC OPARAN sources=expression CPARAN SEMI                                                # pushStatic_statement
 			| ((declType = type)? target=expression ASS)? expression DOT NAME OPARAN (expression (COMMA expression)*)? CPARAN SEMI                      # call_statement
         // TODO: allow new statements without assignment
 			| (declType = type)? target=expression ASS NEW newType = type OPARAN (expression (COMMA expression)*)? CPARAN (MODELS owldescription = expression)? SEMI                         # create_statement

src/main/kotlin/no/uio/microobject/ast/Translate.kt

@@ -434,7 +434,17 @@ class Translate : WhileBaseVisitor<ProgramElement>() {
     }
 
     override fun visitPushStatic_statement(ctx: PushStatic_statementContext?): ProgramElement {
-        return PushStaticStatement(ctx!!.start.line)
+        val target = visit(ctx!!.target) as Location
+        if(ctx.declType != null) {
+            val decl = getClassDecl(ctx)
+            val className = if(decl == null) ERRORTYPE.name else decl!!.className.text
+            val targetType = TypeChecker.translateType(ctx.declType, className, mutableMapOf())
+            target.setType(targetType)
+        }
+
+        val sources = visit(ctx!!.sources) as Expression
+
+        return PushStaticStmt(target, sources, ctx!!.start.line, target.getType())
     }
 
 

src/main/kotlin/no/uio/microobject/ast/stmt/PushStaticStmt.kt

@@ -8,36 +8,62 @@ import no.uio.microobject.ast.expr.TRUEEXPR
 import no.uio.microobject.runtime.*
 import no.uio.microobject.type.*
 import no.uio.microobject.data.TripleSettings
+import no.uio.microobject.main.ReasonerMode
 import org.apache.jena.datatypes.xsd.XSDDatatype
+import org.apache.jena.rdf.model.Model
 import java.io.File
 
 import eu.larkc.csparql.core.engine.CsparqlQueryResultProxy
 import eu.larkc.csparql.common.RDFTuple
 
-data class PushStaticStmt(val pos : Int = -1) : Statement {
-    override fun toString(): String = "pushStatic()"
+data class PushStaticStmt(val target : Location, val sources: Expression, val pos : Int = -1, val declares: Type?) : Statement {
+    override fun toString(): String = "$target:=pushStatic(sources=$sources)"
     override fun getRDF(): String {
         var s = "prog:stmt${this.hashCode()} rdf:type smol:PushStaticStmt.".trimIndent()
         return s
     }
 
 
     override fun eval(heapObj: Memory, stackFrame: StackEntry, interpreter: Interpreter): EvalResult {
-        // fixed iri: prog:staticTable
-        val namedIri = "${interpreter.settings.progPrefix}staticTable"
+        val namedIri = interpreter.streamManager.getStaticNamedIri()
+
+        // parse sources from comma-separated string sources
+        val sourcesLit = interpreter.eval(sources, stackFrame)
+        if (sourcesLit.tag != STRINGTYPE) {
+            throw Exception("The sources parameter in pushStatic statement must be a string literal")
+        }
+        val sourcesStr = sourcesLit.literal.removeSurrounding("\"")
+        val sourcesList = sourcesStr.split(",")
+        val sourcesMap = hashMapOf(
+            "heap"             to false,
+            "staticTable"      to false,
+            "vocabularyFile"   to false,
+            "externalOntology" to false,
+            "urlOntology"      to false,
+            "fmos"             to false
+        )
+        for (s in sourcesList) {
+            val trimmed = s.trim()
+            if (sourcesMap.containsKey(trimmed)) {
+                sourcesMap[trimmed] = true
+            } else {
+                throw Exception("Unknown source '$trimmed' in pushStatic statement, only comma-separated [heap, staticTable, vocabularyFile, externalOntology, urlOntology, fmos] are allowed")
+            }
+        }
 
-        // add only staticTable
         val ts = TripleSettings(
-            sources = hashMapOf("heap" to false, "staticTable" to true, "vocabularyFile" to false, "fmos" to false, "externalOntology" to false, "urlOntology" to false),
+            sources = sourcesMap,
             guards = hashMapOf("heap" to true, "staticTable" to true),
             virtualization = hashMapOf("heap" to true, "staticTable" to true, "fmos" to true),
             jenaReasoner = interpreter.settings.reasoner,
             cachedModel = null
         )
-        val sTableModel = interpreter.tripleManager.getModel(ts)
-        interpreter.streamManager.putStaticNamedGraph(namedIri, sTableModel)
 
-        return EvalResult(null, emptyList())
+        val model = interpreter.tripleManager.getModel(ts)
+
+        interpreter.streamManager.putStaticNamedGraph(namedIri, model)
+        val resultLit = LiteralExpr(namedIri, STRINGTYPE)
+        return replaceStmt(AssignStmt(target, resultLit, declares = declares), stackFrame)
     }
 
 }

src/main/kotlin/no/uio/microobject/data/StreamManager.kt

@@ -47,6 +47,10 @@ class StreamManager(private val settings: Settings, val staticTable: StaticTable
 
     var clockVar : String? = null
     var clockTimestampSec : String? = null
+    var lastTimestamp: Long = 0
+    var firstTsPassed: Boolean = false
+
+    var nStaticGraphsPushed = 0
 
     init {
 
@@ -82,8 +86,18 @@ class StreamManager(private val settings: Settings, val staticTable: StaticTable
     }
 
     private fun getTimestamp(): Long {
-        if (clockTimestampSec != null) return secToMs(clockTimestampSec!!.toLong())
-        return System.currentTimeMillis()
+        var ms: Long
+        if (clockTimestampSec != null) {
+            ms = secToMs(clockTimestampSec!!.toLong())
+            if (!firstTsPassed) ms -= 1  // workaround: first timestamp is decreased by 1 ms
+        } else {
+            ms = System.currentTimeMillis()
+        }
+
+        if (ms > lastTimestamp && !firstTsPassed) firstTsPassed = true
+
+        lastTimestamp = ms
+        return ms
     }
 
     private fun secToMs(s: Long): Long {
@@ -128,13 +142,14 @@ class StreamManager(private val settings: Settings, val staticTable: StaticTable
     public fun registerQuery(name: LiteralExpr, queryExpr : Expression, params: List<Expression>, stackMemory: Memory, heap: GlobalMemory, obj: LiteralExpr, SPARQL : Boolean = true): CsparqlQueryResultProxy {
         if (!engineInitialized) initEngine()
         val queryStr = prepareQuery(name, queryExpr, params, stackMemory, heap, obj, SPARQL)
-        var resultProxy = engine.registerQuery(queryStr, true) // reasoning enabled
+        if (settings.verbose) println("Registering query:\n$queryStr")
+        var resultProxy = engine.registerQuery(queryStr, false) // reasoning disabled
         resultProxy.addObserver(ResultPusher(name, queryResults)) // each key is only used by one observer
         return resultProxy
     }
 
     private fun prepareQuery(name: LiteralExpr, queryExpr : Expression, params : List<Expression>, stackMemory: Memory, heap: GlobalMemory, obj: LiteralExpr, SPARQL : Boolean = true) : String{
-        val queryHeader = "REGISTER QUERY ${name.literal} AS "
+        val queryHeader = "REGISTER QUERY Query${name.literal} AS "
 
         val queryBody = interpreter!!.prepareQuery(queryExpr, params, stackMemory, heap, obj, SPARQL)
             .removePrefix("\"").removeSuffix("\"")
@@ -167,5 +182,11 @@ class StreamManager(private val settings: Settings, val staticTable: StaticTable
         engine.putStaticNamedModel(iri, sw.toString())
     }
 
+    public fun getStaticNamedIri(): String {
+        val s = "${settings.runPrefix}loadStatic${nStaticGraphsPushed}"
+        nStaticGraphsPushed += 1
+        return s
+    }
+
 }