initial workings on inversion.

astral/catalyst/impl/src/com/astraldb/catalyst/Tester.scala

@@ -46,6 +46,7 @@ object Tester
     val bdd: Result,
     val lesserSpark: Result,
     val spark: Result,
+    val invertedastral: Result,
   )
   {
  
@@ -54,6 +55,7 @@ object Tester
       "Astral-BDD" -> bdd,
       "Spark-Fair" -> lesserSpark,
       "Spark-Full" -> spark,
+      "Inverted-Astral" -> invertedastral,
     )
  
     def validate(completenessCheck: Boolean = false): Unit =
@@ -188,6 +190,9 @@ object Tester
       lesserSpark = Result.time {
         LesserSparkOptimizer.rewrite(analyzed)
       },
+      invertedastral = Result.time {
+        InvertedOptimizer.rewrite(analyzed)
+      },
       spark = Result.time {
         optimizer.execute(analyzed) -> 0
       }
@@ -278,4 +283,4 @@ object Tester
     println(test(df))
 
   }
-}
+}

astral/compiler/src/com/astraldb/codegen/InvertedOptimizer.scala

@@ -0,0 +1,11 @@
+package com.astraldb.codegen
+
+import com.astraldb.spec.Definition
+
+object InvertedOptimizer
+{
+  def apply(definition: Definition): String =
+  {
+    scala.InvertedOptimizer(definition.rules.map { "Inverted" +  _.safeLabel }).toString
+  }
+}

astral/compiler/src/com/astraldb/codegen/InvertedRule.scala

@@ -0,0 +1,14 @@
+package com.astraldb.codegen
+
+import com.astraldb.spec
+import com.astraldb.bdd
+import com.astraldb.codegen
+
+object InvertedRule
+{
+  def apply(schema: spec.Definition, rule: spec.Rule, benchmark: Boolean = false): String =
+  {
+    scala.InvertedRule(schema, rule).toString
+  }
+
+}

astral/compiler/src/com/astraldb/codegen/Render.scala

@@ -32,7 +32,12 @@ object Render
 
       Map(
         "Optimizer.scala" -> Optimizer(schema),
-      ) ++ (bddRule.flatMap { case (family, bdd) => Seq(
+      ) ++ Map(
+        "InvertedOptimizer.scala" -> InvertedOptimizer(schema),
+      ) ++ schema.rules.map { rule =>
+        s"Inverted${rule.safeLabel}.scala" -> InvertedRule(schema, rule)
+      }.toMap
+      ++ (bddRule.flatMap { case (family, bdd) => Seq(
         s"${family.scalaType}BDD.scala" -> Rule(schema, bdd, family, false),
         s"${family.scalaType}BDDOptimizer.scala" -> Optimizer.bdd(family)
       )}.toMap) ++ schema.rules.map { rule =>
@@ -51,4 +56,4 @@ object Render
       println(content)
     }
   }
-}
+}

astral/compiler/views/com/astraldb/codegen/InvertedOptimizer.scala.scala

@@ -0,0 +1,37 @@
+@import com.astraldb.spec.Definition
+
+@(rules: Seq[String], clazz: String = "InvertedOptimizer")
+
+object @clazz
+{
+  val rules = Seq[Rule[LogicalPlan]](
+    @for(rule <- rules){ @rule , 
+    }
+  )
+
+  def MAX_ITERATIONS = 100
+
+  def rewrite(plan: LogicalPlan): (LogicalPlan, Int) =
+  {
+    var current = plan
+    var last = plan
+
+    for(i <- 0 until MAX_ITERATIONS)
+    {
+      current = current.transform{ case theplan =>
+        var newPlan = theplan
+        for(rule <- rules)
+        {
+          newPlan = rule(newPlan)
+        }
+        newPlan
+      }
+      if(last.fastEquals(current))
+      {
+        return (current, i+1)
+      }
+      last = current
+    }
+    return (current, MAX_ITERATIONS)
+  }
+}

astral/compiler/views/com/astraldb/codegen/InvertedRule.scala.scala

@@ -0,0 +1,37 @@
+@import com.astraldb.spec.Rule
+@import com.astraldb.spec.Type
+@import com.astraldb.spec.Definition
+@import com.astraldb.codegen.Match
+@import com.astraldb.codegen.Expression
+@import com.astraldb.codegen.Code
+@import com.astraldb.codegen.CodeScope
+@import com.astraldb.typecheck.TypecheckMatch
+
+@(schema: Definition, rule: Rule, clazz: String = "Inverted")
+
+@{
+  val matchSchema = TypecheckMatch(
+      rule.pattern, 
+      rule.family, 
+      schema, 
+      schema.globals
+    )
+}
+
+object @{clazz}@{rule.safeLabel} extends Rule[@{rule.family.scalaType}]
+{
+  def apply(plan: @{rule.family.scalaType}): @{rule.family.scalaType} =
+    plan match { case plan =>
+      @Match(
+        schema = schema,
+        pattern = rule.pattern,
+        target = Code.Literal("plan"),
+        targetPath = Seq.empty,
+        targetType = rule.family,
+        onSuccess = Expression(schema, rule.rewrite, _),
+        onFail = { _ => Code.Literal("plan") },
+        name = Some("plan"),
+        scope = CodeScope(schema.globals)
+      ).toString(6).stripPrefix("      ")
+    }
+}