wip: memory-issue-root-and-sub-children

Author: Yogu

spec/regression/traversal-performance/model/model.graphqls

@@ -12,7 +12,13 @@ type Root @rootEntity {
     children: [Child]
     grandchildren: [Grandchild] @collect(path: "children.children")
     extensionGrandchildren: [ExtensionGrandchild] @collect(path: "children.extension.children")
+
+    # 5 MB random string. Should not be queried because it's not stable
+    # it's just used to we see whether the reduce-extraction-to-projection optimization works
     payload: String
+
+    # 100 KB predictable string. Can be queried.
+    predictablePayload: String
 }
 
 type Child @childEntity {

spec/regression/traversal-performance/test-data.ts

@@ -0,0 +1,22 @@
+LET v_root1 = FIRST((
+  FOR v_root2
+  IN @@roots
+  FILTER (v_root2.`key` == @var1)
+  LIMIT @var2
+  RETURN v_root2
+))
+RETURN {
+  "Root": (IS_NULL(v_root1) ? null : {
+    "predictablePayload": v_root1.`predictablePayload`,
+    "children": v_root1.`children`[* RETURN {
+      "root": {
+        "key": v_root1.`key`
+      },
+      "children": CURRENT.`children`[* RETURN {
+        "key": CURRENT.`key`
+      }]
+    }]
+  })
+}
+
+// Peak memory usage: 10190848 bytes

spec/regression/traversal-performance/tests/root-and-sub-children/aql/fieldTraversal_andChildEntitiesWithArrayExpansion.aql

@@ -0,0 +1,31 @@
+LET v_root1 = FIRST((
+  FOR v_root2
+  IN @@roots
+  FILTER (v_root2.`key` == @var1)
+  LIMIT @var2
+  RETURN v_root2
+))
+RETURN {
+  "Root": (IS_NULL(v_root1) ? null : {
+    "predictablePayload": v_root1.`predictablePayload`,
+    "children": (
+      FOR v_item1
+      IN v_root1.`children`[*]
+      RETURN {
+        "root": {
+          "key": v_root1.`key`
+        },
+        "children": (
+          FOR v_item2
+          IN v_item1.`children`[*]
+          SORT (v_item2.`key`)
+          RETURN {
+            "key": v_item2.`key`
+          }
+        )
+      }
+    )
+  })
+}
+
+// Peak memory usage: 61243392 bytes

spec/regression/traversal-performance/tests/root-and-sub-children/aql/fieldTraversal_andChildEntitiesWithSubquery.aql

@@ -0,0 +1,5 @@
+{
+  "authRoles": ["user"],
+  // we request the payload here. Pay close attention to actual memory usage in the .aql files
+  "queryMemoryLimit": "100000000"
+}

spec/regression/traversal-performance/tests/root-and-sub-children/context.json

@@ -0,0 +1,50 @@
+query fieldTraversal_andChildEntitiesWithArrayExpansion {
+    Root(key: "root1") {
+        # this is a big field. query it so we're sure it is loaded from disk
+        predictablePayload
+
+        children {
+            # accessing root in a child entity subquery can lead to the root being copied into a
+            # register for each child. This happens if there is another subquery, that's why we're
+            # querying the children's children.
+            root {
+                key
+            }
+            children {
+                key
+            }
+        }
+    }
+}
+
+query fieldTraversal_andChildEntitiesWithSubquery {
+    Root(key: "root1") {
+        predictablePayload
+
+        children {
+            root {
+                key
+            }
+            # without order, the children can be fetched via an array expansion expression, which
+            # avoids the problem outlined above - but this no longer works if there is sorting
+            # because SORT is not supported in array expansion expressions
+            children(orderBy: key_ASC) {
+                key
+            }
+        }
+    }
+}
+
+query relationAndFieldTraversal_andChildEntitiesWithSubquery {
+    Super(key: "root1") {
+        rootChildren {
+            root {
+                predictablePayload
+            }
+
+            children(orderBy: key_ASC) {
+                key
+            }
+        }
+    }
+}

spec/regression/traversal-performance/tests/root-and-sub-children/result.json

@@ -138,8 +138,30 @@ export function createFieldNode(
             return createToNRelationNode(field, sourceNode);
         }
 
-        // there are no lists of references
+        // note: there are no lists of references
+
+        // TraversalQueryNode has support for filtering, sorting, paging etc. and those cases
+        // are optimized in the aql-generator
+        if (field.type.isChildEntityType) {
+            return new TraversalQueryNode({
+                sourceEntityNode: sourceNode,
+                fieldSegments: [
+                    {
+                        field,
+                        isListSegment: true,
+                        resultingType: field.type,
+                        isNullableSegment: false,
+                        resultIsList: true,
+                        kind: 'field',
+                        resultIsNullable: false,
+                        resultMayContainDuplicateEntities: false,
+                    },
+                ],
+                relationSegments: [],
+            });
+        }
 
+        // TODO aql-perf can we use TraversalQueryNode for other lists too?
         return createSafeListQueryNode(new FieldQueryNode(sourceNode, field));
     }