Merge pull request github#12304 from MathiasVP/more-fixes-to-large-join-order-query

QL: More fixes to the join-order query

Author: MathiasVP

ql/ql/src/queries/performance/LargeJoinOrder.ql

@@ -30,16 +30,16 @@ predicate hasTupleCount(
   float tupleCount
 ) {
   inLayer = firstPredicate(recursive) and
-  exists(PipeLineRun run | run = inLayer.getPipelineRuns().getRun(iteration) |
-    ordering = run.getRAReference() and
+  exists(PipeLineRun run |
+    run = inLayer.getPipelineRuns().getRun(iteration) and ordering = run.getRAReference()
+  |
     tupleCount = run.getCount(i)
-  )
-  or
-  exists(SummaryEvent inLayer0, float tupleCount0, PipeLineRun run |
-    run = inLayer.getPipelineRuns().getRun(pragma[only_bind_into](iteration)) and
-    successor(recursive, inLayer0, inLayer) and
-    hasTupleCount(recursive, ordering, inLayer0, pragma[only_bind_into](iteration), i, tupleCount0) and
-    tupleCount = run.getCount(i) + tupleCount0
+    or
+    exists(SummaryEvent inLayer0, float tupleCount0 |
+      successor(recursive, inLayer0, inLayer) and
+      hasTupleCount(recursive, ordering, inLayer0, pragma[only_bind_into](iteration), i, tupleCount0) and
+      tupleCount = run.getCount(i) + tupleCount0
+    )
   )
 }
 
@@ -58,57 +58,51 @@ predicate hasDuplication(
   ComputeRecursive recursive, string ordering, SummaryEvent inLayer, int iteration, int i,
   float duplication
 ) {
-  inLayer = firstPredicate(recursive) and
-  exists(PipeLineRun run | run = inLayer.getPipelineRuns().getRun(iteration) |
-    ordering = run.getRAReference() and
+  exists(PipeLineRun run |
+    run = inLayer.getPipelineRuns().getRun(iteration) and
+    ordering = run.getRAReference()
+  |
+    inLayer = firstPredicate(recursive) and
     duplication = run.getDuplicationPercentage(i)
-  )
-  or
-  exists(SummaryEvent inLayer0, float duplication0, PipeLineRun run |
-    run = inLayer.getPipelineRuns().getRun(pragma[only_bind_into](iteration)) and
-    successor(recursive, inLayer0, inLayer) and
-    hasDuplication(recursive, ordering, inLayer0, pragma[only_bind_into](iteration), i, duplication0) and
-    duplication = run.getDuplicationPercentage(i).maximum(duplication0)
+    or
+    exists(SummaryEvent inLayer0, float duplication0 |
+      successor(recursive, inLayer0, inLayer) and
+      hasDuplication(recursive, ordering, inLayer0, pragma[only_bind_into](iteration), i,
+        duplication0) and
+      duplication = run.getDuplicationPercentage(i).maximum(duplication0)
+    )
   )
 }
 
 predicate hasDuplication(ComputeRecursive recursive, string ordering, int i, float duplication) {
   duplication =
-    max(SummaryEvent inLayer, int iteration, int dup |
-      inLayer = getInLayerOrRecursive(recursive) and
-      hasDuplication(recursive, ordering, inLayer, iteration, i, dup)
-    |
-      dup
-    )
+    max(int iteration, int dup | hasDuplication(recursive, ordering, _, iteration, i, dup) | dup)
 }
 
 /**
  * Holds if the ordering `ordering` has `resultSize` resultSize in the `iteration`'th iteration.
- *
- * For example, the "base" ordering in iteration 0 has size 42.
  */
 private predicate hasResultSize(
   ComputeRecursive recursive, string ordering, SummaryEvent inLayer, int iteration, float resultSize
 ) {
-  inLayer = firstPredicate(recursive) and
-  ordering = inLayer.getPipelineRuns().getRun(iteration).getRAReference() and
-  resultSize = inLayer.getDeltaSize(iteration)
-  or
-  exists(SummaryEvent inLayer0, int resultSize0 |
-    successor(recursive, inLayer0, inLayer) and
-    hasResultSize(recursive, ordering, inLayer0, iteration, resultSize0) and
-    resultSize = inLayer.getDeltaSize(iteration) + resultSize0
+  exists(PipeLineRun run |
+    run = inLayer.getPipelineRuns().getRun(iteration) and
+    ordering = run.getRAReference()
+  |
+    inLayer = firstPredicate(recursive) and
+    resultSize = inLayer.getDeltaSize(iteration)
+    or
+    exists(SummaryEvent inLayer0, int resultSize0 |
+      successor(recursive, inLayer0, inLayer) and
+      hasResultSize(recursive, ordering, inLayer0, iteration, resultSize0) and
+      resultSize = inLayer.getDeltaSize(iteration) + resultSize0
+    )
   )
 }
 
 predicate hasResultSize(ComputeRecursive recursive, string ordering, float resultSize) {
   resultSize =
-    strictsum(InLayer inLayer, int iteration, float r |
-      inLayer.getComputeRecursiveEvent() = recursive and
-      hasResultSize(recursive, ordering, inLayer, iteration, r)
-    |
-      r
-    )
+    strictsum(int iteration, float r | hasResultSize(recursive, ordering, _, iteration, r) | r)
 }
 
 RAParser<PipeLine>::RAExpr getAnRaOperation(SummaryEvent inLayer, string ordering) {
@@ -122,17 +116,20 @@ SummaryEvent getInLayerEventWithName(ComputeRecursive recursive, string predicat
 
 bindingset[predicateName, iteration]
 int getSize(ComputeRecursive recursive, string predicateName, int iteration, TDeltaKind kind) {
-  exists(int i |
+  exists(int i, SummaryEvent event |
     kind = TPrevious() and
     i = iteration - 1
     or
     kind = TCurrent() and
     i = iteration
   |
-    result = getInLayerEventWithName(recursive, predicateName).getDeltaSize(i)
-    or
-    not exists(getInLayerEventWithName(recursive, predicateName).getDeltaSize(i)) and
-    result = 0
+    event = getInLayerEventWithName(recursive, predicateName) and
+    (
+      result = event.getDeltaSize(i)
+      or
+      not exists(event.getDeltaSize(i)) and
+      result = 0
+    )
   )
 }
 
@@ -154,36 +151,53 @@ private predicate isDelta(string predicateName, TDeltaKind kind, string withoutS
   withoutSuffix = predicateName.regexpCapture("(.+)#cur_delta", 1)
 }
 
+bindingset[iteration]
+float getRecursiveDependencySize(
+  ComputeRecursive recursive, string predicateName, int iteration, SummaryEvent inLayer,
+  string ordering, TDeltaKind kind
+) {
+  result = getSize(recursive, predicateName, iteration, kind) and
+  isDelta(getAnRaOperation(inLayer, ordering).getARhsPredicate(), kind, predicateName)
+}
+
+bindingset[ordering, iteration]
+predicate hasDependentPredicateSizeImpl(
+  ComputeRecursive recursive, string ordering, float size, string predicateName, int iteration,
+  SummaryEvent inLayer
+) {
+  // We treat the base case as a non-recursive case
+  if ordering = "base"
+  then
+    size =
+      [
+        getDependencyWithName(recursive.getDependencies(), predicateName).getResultSize(),
+        getRecursiveDependencySize(recursive, predicateName, iteration, inLayer, ordering,
+          TCurrent())
+      ]
+  else
+    size =
+      getRecursiveDependencySize(recursive, predicateName, iteration, inLayer, ordering, TPrevious())
+}
+
+pragma[nomagic]
 predicate hasDependentPredicateSize(
   ComputeRecursive recursive, string ordering, SummaryEvent inLayer, int iteration,
   string predicateName, float size
 ) {
-  exists( |
-    inLayer = firstPredicate(recursive) and
-    ordering = inLayer.getPipelineRuns().getRun(iteration).getRAReference()
-  |
-    // We treat iteration 0 as a non-recursive case
-    if ordering = "base"
-    then size = getDependencyWithName(recursive.getDependencies(), predicateName).getResultSize()
-    else
-      exists(TDeltaKind kind |
-        size = getSize(recursive, predicateName, iteration, kind) and
-        isDelta(getAnRaOperation(inLayer, ordering).getARhsPredicate(), kind, predicateName)
-      )
-  )
-  or
-  exists(SummaryEvent inLayer0, float size0 |
-    successor(recursive, inLayer0, inLayer) and
-    hasDependentPredicateSize(recursive, ordering, inLayer0, iteration, predicateName, size0)
+  exists(PipeLineRun run |
+    run = inLayer.getPipelineRuns().getRun(pragma[only_bind_into](iteration)) and
+    ordering = run.getRAReference()
   |
-    // We treat iteration 0 as a non-recursive case
-    if ordering = "base"
-    then size = getDependencyWithName(recursive.getDependencies(), predicateName).getResultSize()
-    else
-      exists(TDeltaKind kind |
-        size = getSize(recursive, predicateName, iteration, kind) + size0 and
-        isDelta(getAnRaOperation(inLayer, ordering).getARhsPredicate(), kind, predicateName)
-      )
+    inLayer = firstPredicate(recursive) and
+    hasDependentPredicateSizeImpl(recursive, ordering, size, predicateName, iteration, inLayer)
+    or
+    exists(SummaryEvent inLayer0, float size0, float size1 |
+      successor(recursive, inLayer0, inLayer) and
+      hasDependentPredicateSize(recursive, ordering, inLayer0, pragma[only_bind_into](iteration),
+        predicateName, size0) and
+      hasDependentPredicateSizeImpl(recursive, ordering, size1, predicateName, iteration, inLayer) and
+      size = size0 + size1
+    )
   )
 }
 
@@ -195,9 +209,8 @@ predicate hasDependentPredicateSize(
   ComputeRecursive recursive, string ordering, string predicateName, float size
 ) {
   size =
-    strictsum(SummaryEvent inLayer, int iteration, int s |
-      inLayer = getInLayerOrRecursive(recursive) and
-      hasDependentPredicateSize(recursive, ordering, inLayer, iteration, predicateName, s)
+    strictsum(int iteration, float s |
+      hasDependentPredicateSize(recursive, ordering, _, iteration, predicateName, s)
     |
       s
     )