General plan generator.

Author: LorenzBuehmann

sansa-inference-common/src/main/resources/schema.json

@@ -8,7 +8,7 @@
         {
           name: 'Triples',
           type: 'custom',
-          factory: 'org.sansa.inference.rules.plan.TriplesTableFactory'
+          factory: 'net.sansa_stack.inference.rules.plan.TriplesTableFactory'
         }
       ]
     }

sansa-inference-common/src/main/scala/net/sansa_stack/inference/rules/plan/PlanGenerator.scala

@@ -57,6 +57,7 @@ class PlanGenerator extends Logging{
   val clusters: Array[RelOptCluster] = Array(null)
   val relOptSchemas: Array[RelOptSchema] = Array(null)
   val rootSchemas: Array[SchemaPlus] = Array(null)
+
   Frameworks.withPlanner(new PlannerAction[Void] {
     override def apply(
                         cluster: RelOptCluster,

sansa-inference-common/src/main/scala/net/sansa_stack/inference/rules/plan/SQLGenerator.scala

@@ -0,0 +1,20 @@
+package net.sansa_stack.inference.rules.plan
+
+import org.apache.jena.reasoner.rulesys.Rule
+
+/**
+  * A SQL generator for rules.
+  *
+  * @author Lorenz Buehmann
+  */
+trait SQLGenerator {
+
+  /**
+    * Generates a SQL query for the given rule.
+    *
+    * @param rule the rule
+    * @return the SQL query
+    */
+  def generateSQLQuery(rule: Rule): String
+
+}

sansa-inference-common/src/main/scala/net/sansa_stack/inference/rules/plan/SimplePlanExecutor.scala

@@ -0,0 +1,28 @@
+package net.sansa_stack.inference.rules.plan
+
+import com.google.common.collect.ImmutableSet
+import org.apache.calcite.plan.{RelOptCluster, RelTraitSet}
+import org.apache.calcite.rel.RelNode
+import org.apache.calcite.rel.core.CorrelationId
+import org.apache.calcite.rel.logical.{LogicalFilter, LogicalJoin, LogicalProject}
+import org.apache.calcite.rex.RexNode
+
+/**
+  * @author Lorenz Buehmann
+  */
+class SimplePlanExecutor {
+
+  def execute(plan: RelNode): Unit = {
+//    plan match {
+//      case LogicalProject => plan.asInstanceOf[LogicalProject].
+//      case LogicalJoin =>
+//      case LogicalFilter(cluster,
+//      traitSet,
+//      child,
+//      condition,
+//      variablesSet) =>
+//    }
+  }
+
+
+}

sansa-inference-common/src/main/scala/net/sansa_stack/inference/rules/plan/SimplePlanGenerator.scala

@@ -0,0 +1,110 @@
+package net.sansa_stack.inference.rules.plan
+
+import java.io.PrintWriter
+
+import org.apache.calcite.config.Lex
+import org.apache.calcite.plan.{Contexts, ConventionTraitDef, RelTrait, RelTraitDef}
+import org.apache.calcite.rel.{RelCollationTraitDef, RelNode}
+import org.apache.calcite.schema.SchemaPlus
+import org.apache.calcite.sql.parser.SqlParser
+import org.apache.calcite.tools.{FrameworkConfig, Frameworks, Planner, RuleSets}
+import collection.JavaConverters._
+import scala.util.Try
+
+import org.apache.calcite.rel.`type`.RelDataTypeSystem
+import org.apache.calcite.rel.externalize.RelWriterImpl
+import org.apache.calcite.rel.rules.{FilterJoinRule, ProjectJoinTransposeRule}
+import org.apache.jena.reasoner.rulesys.Rule
+
+import net.sansa_stack.inference.utils.RuleUtils
+
+/**
+  * @author Lorenz Buehmann
+  */
+class SimplePlanGenerator(schema: SchemaPlus) {
+
+  val traitDefs: List[RelTraitDef[_ <: RelTrait]] = List(ConventionTraitDef.INSTANCE, RelCollationTraitDef.INSTANCE)
+
+  val optRuleSet = RuleSets.ofList(
+    FilterJoinRule.FILTER_ON_JOIN,// push a filter into a join
+    FilterJoinRule.JOIN,// push filter into the children of a join
+    ProjectJoinTransposeRule.INSTANCE// push a projection to the children of a join
+  )
+
+  val calciteFrameworkConfig: FrameworkConfig =
+    Frameworks.newConfigBuilder
+      .parserConfig(
+        SqlParser.configBuilder
+          // Lexical configuration defines how identifiers are quoted, whether they are converted to upper or lower
+          .setLex(Lex.MYSQL)
+          .build)
+      // Sets the schema to use by the planner
+      .defaultSchema(schema)
+      .traitDefs(traitDefs.asJava)
+      // Context provides a way to store data within the planner session that can be accessed in planner rules.
+      .context(Contexts.EMPTY_CONTEXT)
+      // Rule sets to use in transformation phases. Each transformation phase can use a different set of rules.
+      .ruleSets(optRuleSet)
+      // Custom cost factory to use during optimization
+      .costFactory(null)
+      .typeSystem(RelDataTypeSystem.DEFAULT)
+      .build()
+
+  lazy val planner: Planner = Frameworks.getPlanner(calciteFrameworkConfig)
+
+  val sqlGenerator = new SimpleSQLGenerator
+
+  /**
+    * Generates a logical plan for the rule.
+    *
+    * @param rule the rule
+    * @return the root node of the logical plan
+    */
+  def generateLogicalPlan(rule: Rule): RelNode = {
+    // generate SQL query
+    val sqlQuery = sqlGenerator.generateSQLQuery(rule)
+
+    // parse to SQL node
+    val sqlNode = Try(planner.parse(sqlQuery))
+
+    // validate the SQL node
+    val validatedSqlNode = planner.validate(sqlNode.get)
+
+    // return the root node
+    planner.rel(validatedSqlNode).project
+  }
+
+  /**
+    * Generates a logical plan for the rules.
+    *
+    * @param rules the rules
+    * @return the root node of the logical plan
+    */
+  def generateLogicalPlan(rules: Seq[Rule]): RelNode = {
+    // generate SQL query
+    val sqlQuery = rules.map(sqlGenerator.generateSQLQuery _).mkString(" UNION ")
+
+    // parse to SQL node
+    val sqlNode = Try(planner.parse(sqlQuery))
+
+    // validate the SQL node
+    val validatedSqlNode = planner.validate(sqlNode.get)
+
+    // return the root node
+    planner.rel(validatedSqlNode).project
+  }
+}
+
+object SimplePlanGenerator {
+
+  def main(args: Array[String]): Unit = {
+
+    val planGenerator = new SimplePlanGenerator(TriplesSchema.get())
+
+    val rules = RuleUtils.load("rules/rdfs-simple.rules")
+
+    val plan = planGenerator.generateLogicalPlan(Seq(rules(0), rules(1)))
+
+    plan.explain(new RelWriterImpl(new PrintWriter(System.out)))
+  }
+}

sansa-inference-common/src/main/scala/net/sansa_stack/inference/rules/plan/SimpleSQLGenerator.scala

@@ -0,0 +1,49 @@
+package net.sansa_stack.inference.rules.plan
+
+import scala.collection.mutable
+
+import org.apache.jena.graph.Node
+import org.apache.jena.reasoner.rulesys.Rule
+
+import net.sansa_stack.inference.utils.RuleUtils.RuleExtension
+import net.sansa_stack.inference.utils.TripleUtils._
+import net.sansa_stack.inference.utils.{Logging, RuleUtils}
+
+/**
+  * @author Lorenz Buehmann
+  */
+class SimpleSQLGenerator extends SQLGenerator with Logging {
+
+  def generateSQLQuery(rule: Rule): String = {
+    info(s"Rule:\n$rule")
+
+    val body = rule.bodyTriplePatterns().map(tp => tp.toTriple).toSet
+
+    val visited = mutable.Set[org.apache.jena.graph.Triple]()
+
+    //    process(body.head, body, visited)
+
+    // group triple patterns by var
+    val map = new mutable.HashMap[Node, collection.mutable.Set[org.apache.jena.graph.Triple]]() with mutable.MultiMap[Node, org.apache.jena.graph.Triple]
+    body.foreach { tp =>
+      val vars = RuleUtils.varsOf(tp)
+      vars.foreach { v =>
+        map.addBinding(v, tp)
+      }
+    }
+
+    val joins = new mutable.HashSet[Join]
+
+    map.foreach{e =>
+      val v = e._1
+      val tps = e._2.toList.sortBy(_.toString).combinations(2).foreach(c =>
+        joins.add(new Join(c(0), c(1), v))
+      )
+    }
+
+    val sqlQuery = new Plan(body, rule.headTriplePatterns().toList.head.asTriple(), joins).toSQL
+    info(s"SQL Query:\n$sqlQuery")
+
+    sqlQuery
+  }
+}

sansa-inference-common/src/main/scala/net/sansa_stack/inference/utils/NodeTableBuilder.scala

@@ -0,0 +1,36 @@
+package net.sansa_stack.inference.utils
+
+import org.apache.jena.graph.NodeFactory
+import org.apache.jena.tdb.base.file.Location
+import org.apache.jena.tdb.setup.DatasetBuilderStd
+import org.apache.jena.tdb.store.DatasetGraphTDB
+import tdb.bulkloader2.CmdNodeTableBuilder
+import tdb.cmdline.CmdTDB
+
+/**
+  * @author Lorenz Buehmann
+  */
+object NodeTableBuilder {
+
+  def main(args: Array[String]): Unit = {
+    CmdTDB.init()
+    DatasetBuilderStd.setOptimizerWarningFlag(false)
+    new CmdNodeTableBuilder(args: _*).mainRun()
+
+    val location = Location.create("/tmp/node_table")
+
+    // This formats the location correctly.
+    // But we're not really interested in it all.
+    val dsg = DatasetBuilderStd.create(location)
+
+    // so close indexes and the prefix table.
+    val nodeTable = dsg.getTripleTable.getNodeTupleTable.getNodeTable
+    val id = nodeTable.getNodeIdForNode(NodeFactory.createURI("http://www.Department0.University6.edu/FullProfessor0"))
+    println(id)
+
+    val node = nodeTable.getNodeForNodeId(id)
+
+    println(node)
+  }
+
+}

sansa-inference-common/src/main/scala/net/sansa_stack/inference/utils/RuleUtils.scala

@@ -8,9 +8,11 @@ import scalax.collection.mutable.Graph
 import org.apache.jena.graph.Node
 import org.apache.jena.reasoner.TriplePattern
 import org.apache.jena.reasoner.rulesys.Rule
+import org.jgrapht.alg.cycle.TarjanSimpleCycles
 
 import net.sansa_stack.inference.rules.RuleEntailmentType
 import net.sansa_stack.inference.rules.RuleEntailmentType._
+import net.sansa_stack.inference.utils.graph.LabeledEdge
 
 /**
   * Utility class for rules.
@@ -318,6 +320,18 @@ object RuleUtils {
         bodyPredicates.intersect(headPredicates).nonEmpty
 
     }
+
+    val g = GraphUtils.asJGraphtRuleGraph(asGraph(rule))
+
+    // get cycles of length > 2
+    val cycleDetector = new TarjanSimpleCycles[Node, LabeledEdge[Node, String]](g)
+    val cycles = cycleDetector.findSimpleCycles().asScala.filter(c => c.size() == 2)
+
+    cycles.foreach(c => {
+      println(c)
+    })
+
+    true
   }
 
   /**

sansa-inference-common/src/test/scala/net/sansa_stack/inference/common/DependencyGraphTest.scala

@@ -1,6 +1,7 @@
 package net.sansa_stack.inference.common
 
 import net.sansa_stack.inference.rules._
+import net.sansa_stack.inference.rules.minimizer.DefaultRuleDependencyGraphMinimizer
 import net.sansa_stack.inference.utils.GraphUtils._
 import net.sansa_stack.inference.utils.RuleUtils
 
@@ -18,19 +19,21 @@ object DependencyGraphTest {
 //    val names = Seq("rdfs5", "rdfs7", "rdfp3", "rdfp4") // property TC rule + some instance rules
 
     // define the rules
-    val rules = RuleSets.OWL_HORST.filter(r => names.contains(r.getName))
+    val rules = RuleSets.OWL_HORST//.filter(r => names.contains(r.getName))
     val profile = ReasoningProfile.OWL_HORST
 //    val rules = RuleSets.RDFS_SIMPLE
 //    val profile = ReasoningProfile.RDFS_SIMPLE
 
+    val minimizer = new DefaultRuleDependencyGraphMinimizer()
+
     // export graphs
     rules.foreach(rule => RuleUtils.asGraph(rule).export(s"${path}/rule-${rule.getName}.graphml"))
 
     // generate the rule dependency graph
     var dependencyGraph = RuleDependencyGraphGenerator.generate(rules)
     dependencyGraph.export(s"${path}/rdg-${profile}.graphml")
 
-    dependencyGraph = RuleDependencyGraphGenerator.generate(rules, pruned = true)
+    dependencyGraph = minimizer.execute(dependencyGraph) // RuleDependencyGraphGenerator.generate(rules, pruned = true)
     dependencyGraph.export(s"${path}/rdg-${profile}-pruned.graphml")
 //    dependencyGraph.exportAsPDF(s"${path}/rdg-${profile}-pruned.pdf")
 
@@ -51,6 +54,8 @@ object DependencyGraphTest {
 
     layer._2.foreach{rdg =>
       println("Processing dependency graph " + rdg.printNodes())
+      println(rdg.isCyclic)
+      rdg.nodes.foreach(n => println(n findSuccessor (_.outDegree >= 1)))
     }
   }
 }