cruddl 4.2.3 → 5.0.0-0.deploytest.0

package/dist/src/database/arangodb/aql-generator.js

@@ -15,6 +15,7 @@ const aql_1 = require("./aql");
 const arango_basics_1 = require("./arango-basics");
 const arango_search_helpers_1 = require("./schema-migration/arango-search-helpers");
 const execution_options_1 = require("../../execution/execution-options");
+const traversal_helpers_1 = require("./traversal-helpers");
 var AccessType;
 (function (AccessType) {
     /**
@@ -67,7 +68,7 @@ class QueryContext {
      * @param variableNode the variable token as it is referenced in the query tree
      * @param aqlVariable the variable token as it will be available within the AQL fragment
      */
-    newNestedContextWithVariableMapping(variableNode, aqlVariable) {
+    newNestedContextWithVariableBinding(variableNode, aqlVariable) {
         const newContext = new QueryContext(this.options);
         newContext.variableMap = new Map(this.variableMap);
         newContext.variableMap.set(variableNode, aqlVariable);
@@ -80,27 +81,21 @@ class QueryContext {
     /**
      * Creates a new QueryContext that is identical to this one but has one additional variable binding
      *
-     * The AQLFragment for the variable will be available via getVariable().
+     * If aqlFrag is omitted, a new AQLVariable will be created using the name of the variableNode.
      *
-     * @param {VariableQueryNode} variableNode the variable as referenced in the query tree
-     * @returns {QueryContext} the nested context
+     * For aqlFrag, you can specify an AQLVariable or a different AQLFragment (e.g. a field access).
+     * Do not specify complex AQL expressions because they would be repeated for every use of the
+     * variable.
+     *
+     * @param variableNode the variable as referenced in the query tree
+     * @param aqlFrag the fragment representing the variable in AQL
+     * @returns the new context
      */
-    introduceVariable(variableNode) {
+    bindVariable(variableNode, aqlFrag = new aql_1.AQLVariable(variableNode.label)) {
         if (this.variableMap.has(variableNode)) {
             throw new Error(`Variable ${variableNode} is introduced twice`);
         }
-        const variable = new aql_1.AQLVariable(variableNode.label);
-        return this.newNestedContextWithVariableMapping(variableNode, variable);
-    }
-    /**
-     * Creates a new QueryContext that is identical to this one but has one additional variable binding
-     *
-     * @param variableNode the variable as referenced in the query tree
-     * @param existingVariable a variable that has been previously introduced with introduceVariable() and fetched by getVariable
-     * @returns {QueryContext} the nested context
-     */
-    introduceVariableAlias(variableNode, existingVariable) {
-        return this.newNestedContextWithVariableMapping(variableNode, existingVariable);
+        return this.newNestedContextWithVariableBinding(variableNode, aqlFrag);
     }
     /**
      * Creates a new QueryContext that includes an additional transaction step and adds resultVariable to the scope
@@ -118,7 +113,7 @@ class QueryContext {
         let newContext;
         if (resultVariable) {
             resultVar = new aql_1.AQLQueryResultVariable(resultVariable.label);
-            newContext = this.newNestedContextWithVariableMapping(resultVariable, resultVar);
+            newContext = this.newNestedContextWithVariableBinding(resultVariable, resultVar);
         }
         else {
             resultVar = undefined;
@@ -170,6 +165,10 @@ class QueryContext {
         if (!variable) {
             throw new Error(`Variable ${variableNode.toString()} is used but not introduced`);
         }
+        // we're returning an AQLFragment as AQLVariable
+        // it can be a non-variable fragment (e.g. a simple field access) if we used bindVariable
+        // typescript only allows it because there are no private fields in AQLVariable
+        // TODO introduce a better way to introduce a VariableQueryNode as AQLVariable, then make this here return AQLFragment
         return variable;
     }
     getPreExecuteQueries() {
@@ -207,7 +206,7 @@ function createAQLCompoundQuery(node, resultVariable, resultValidator, context)
     const variableAssignmentNodes = [];
     node = (0, utils_1.extractVariableAssignments)(node, variableAssignmentNodes);
     for (const assignmentNode of variableAssignmentNodes) {
-        context = context.introduceVariable(assignmentNode.variableNode);
+        context = context.bindVariable(assignmentNode.variableNode);
         const tmpVar = context.getVariable(assignmentNode.variableNode);
         variableAssignments.push((0, aql_1.aql) `LET ${tmpVar} = ${processNode(assignmentNode.variableValueNode, context)}`);
     }
@@ -233,6 +232,9 @@ var aqlExt;
 (function (aqlExt) {
     function safeJSONKey(key) {
         if (aql_1.aql.isSafeIdentifier(key)) {
+            // TODO meta fields are currently not considered safe because of the leading underscore
+            // think about if we should generally allow leading underscores in isSafeIdentifier
+            // or just allow them here (here it would definitely be safe)
             // we could always collide with a (future) keyword, so use "name" syntax instead of identifier
             // ("" looks more natural than `` in json keys)
             return (0, aql_1.aql) `${aql_1.aql.string(key)}`;
@@ -242,14 +244,14 @@ var aqlExt;
         }
     }
     aqlExt.safeJSONKey = safeJSONKey;
-    function parenthesizeList(...content) {
+    function subquery(...content) {
         return aql_1.aql.lines((0, aql_1.aql) `(`, aql_1.aql.indent(aql_1.aql.lines(...content)), (0, aql_1.aql) `)`);
     }
-    aqlExt.parenthesizeList = parenthesizeList;
-    function parenthesizeObject(...content) {
-        return (0, aql_1.aql) `FIRST${parenthesizeList(...content)}`;
+    aqlExt.subquery = subquery;
+    function firstOfSubquery(...content) {
+        return (0, aql_1.aql) `FIRST${subquery(...content)}`;
     }
-    aqlExt.parenthesizeObject = parenthesizeObject;
+    aqlExt.firstOfSubquery = firstOfSubquery;
 })(aqlExt || (aqlExt = {}));
 const processors = new Map();
 function register(type, processor) {
@@ -298,11 +300,11 @@ register(query_tree_1.VariableQueryNode, (node, context) => {
     return context.getVariable(node);
 });
 register(query_tree_1.VariableAssignmentQueryNode, (node, context) => {
-    const newContext = context.introduceVariable(node.variableNode);
+    const newContext = context.bindVariable(node.variableNode);
     const tmpVar = newContext.getVariable(node.variableNode);
     // note that we have to know statically if the context var is a list or an object
     // assuming object here because lists are not needed currently
-    return aqlExt.parenthesizeObject((0, aql_1.aql) `LET ${tmpVar} = ${processNode(node.variableValueNode, newContext)}`, (0, aql_1.aql) `RETURN ${processNode(node.resultNode, newContext)}`);
+    return aqlExt.firstOfSubquery((0, aql_1.aql) `LET ${tmpVar} = ${processNode(node.variableValueNode, newContext)}`, (0, aql_1.aql) `RETURN ${processNode(node.resultNode, newContext)}`);
 });
 register(query_tree_1.WithPreExecutionQueryNode, (node, context) => {
     let currentContext = context;
@@ -358,14 +360,14 @@ register(query_tree_1.RevisionQueryNode, (node, context) => {
 });
 register(flex_search_2.FlexSearchQueryNode, (node, context) => {
     let itemContext = context
-        .introduceVariable(node.itemVariable)
+        .bindVariable(node.itemVariable)
         .withExtension(inFlexSearchFilterSymbol, true);
     const viewName = (0, arango_search_helpers_1.getFlexSearchViewNameForRootEntity)(node.rootEntityType);
     context.addCollectionAccess(viewName, AccessType.EXPLICIT_READ);
-    return aqlExt.parenthesizeList((0, aql_1.aql) `FOR ${itemContext.getVariable(node.itemVariable)}`, (0, aql_1.aql) `IN ${aql_1.aql.collection(viewName)}`, (0, aql_1.aql) `SEARCH ${processNode(node.flexFilterNode, itemContext)}`, node.isOptimisationsDisabled ? (0, aql_1.aql) `OPTIONS { conditionOptimization: 'none' }` : (0, aql_1.aql) ``, (0, aql_1.aql) `RETURN ${itemContext.getVariable(node.itemVariable)}`);
+    return aqlExt.subquery((0, aql_1.aql) `FOR ${itemContext.getVariable(node.itemVariable)}`, (0, aql_1.aql) `IN ${aql_1.aql.collection(viewName)}`, (0, aql_1.aql) `SEARCH ${processNode(node.flexFilterNode, itemContext)}`, node.isOptimisationsDisabled ? (0, aql_1.aql) `OPTIONS { conditionOptimization: 'none' }` : (0, aql_1.aql) ``, (0, aql_1.aql) `RETURN ${itemContext.getVariable(node.itemVariable)}`);
 });
 register(query_tree_1.TransformListQueryNode, (node, context) => {
-    let itemContext = context.introduceVariable(node.itemVariable);
+    let itemContext = context.bindVariable(node.itemVariable);
     const itemVar = itemContext.getVariable(node.itemVariable);
     let itemProjectionContext = itemContext;
     // move LET statements up
@@ -376,11 +378,16 @@ register(query_tree_1.TransformListQueryNode, (node, context) => {
     const variableAssignmentNodes = [];
     innerNode = (0, utils_1.extractVariableAssignments)(innerNode, variableAssignmentNodes);
     for (const assignmentNode of variableAssignmentNodes) {
-        itemProjectionContext = itemProjectionContext.introduceVariable(assignmentNode.variableNode);
+        itemProjectionContext = itemProjectionContext.bindVariable(assignmentNode.variableNode);
         const tmpVar = itemProjectionContext.getVariable(assignmentNode.variableNode);
         variableAssignments.push((0, aql_1.aql) `LET ${tmpVar} = ${processNode(assignmentNode.variableValueNode, itemProjectionContext)}`);
     }
-    return aqlExt.parenthesizeList((0, aql_1.aql) `FOR ${itemVar}`, generateInClauseWithFilterAndOrderAndLimit({ node, context, itemContext, itemVar }), ...variableAssignments, (0, aql_1.aql) `RETURN ${processNode(innerNode, itemProjectionContext)}`);
+    // TODO aql-perf: set maxProjects to a value > 5?
+    // The reduce-extraction-to-projection optimization is crucial to reduce memory usage of queries
+    // over large root entities if only some of the fields are queried. The default is to only apply
+    // it if 5 or less fields are selected. We probably want to increase this limit
+    // (also applies to FollowEdgeQueryNode and TraversalQueryNode)
+    return aqlExt.subquery((0, aql_1.aql) `FOR ${itemVar}`, generateInClauseWithFilterAndOrderAndLimit({ node, context, itemContext, itemVar }), ...variableAssignments, (0, aql_1.aql) `RETURN ${processNode(innerNode, itemProjectionContext)}`);
 });
 /**
  * Generates an IN... clause for a TransformListQueryNode to be used within a query / subquery (FOR ... IN ...)
@@ -390,37 +397,42 @@ function generateInClauseWithFilterAndOrderAndLimit({ node, context, itemVar, it
     let filterDanglingEdges = (0, aql_1.aql) ``;
     if (node.listNode instanceof query_tree_1.FollowEdgeQueryNode) {
         list = getSimpleFollowEdgeFragment(node.listNode, context);
-        filterDanglingEdges = (0, aql_1.aql) `FILTER ${itemVar} != null`;
+        // using $var._key != null instead of $var != null because the latter prevents ArangoDB
+        // from applying the reduce-extraction-to-projection optimization
+        filterDanglingEdges = (0, aql_1.aql) `FILTER ${itemVar}._key != null`;
     }
     else {
         list = processNode(node.listNode, context);
     }
     let filter = (0, utils_1.simplifyBooleans)(node.filterNode);
-    let limitClause;
-    if (node.maxCount != undefined) {
-        if (node.skip === 0) {
-            limitClause = (0, aql_1.aql) `LIMIT ${node.maxCount}`;
+    return aql_1.aql.lines((0, aql_1.aql) `IN ${list}`, filter instanceof query_tree_1.ConstBoolQueryNode && filter.value
+        ? (0, aql_1.aql) ``
+        : (0, aql_1.aql) `FILTER ${processNode(filter, itemContext)}`, filterDanglingEdges, generateSortAQL(node.orderBy, itemContext), generateLimitClause(node) ?? (0, aql_1.aql) ``);
+}
+function generateLimitClause({ skip = 0, maxCount }) {
+    // Todo use something like aql.integer() which validates the number is an integer and within range
+    // (that way, we don't have so many bound parameters)
+    if (maxCount != undefined) {
+        if (skip === 0) {
+            return (0, aql_1.aql) `LIMIT ${maxCount}`;
         }
         else {
-            limitClause = (0, aql_1.aql) `LIMIT ${node.skip}, ${node.maxCount}`;
+            return (0, aql_1.aql) `LIMIT ${skip}, ${maxCount}`;
         }
     }
-    else if (node.skip > 0) {
-        limitClause = (0, aql_1.aql) `LIMIT ${node.skip}, ${Number.MAX_SAFE_INTEGER}`;
+    else if (skip > 0) {
+        return (0, aql_1.aql) `LIMIT ${skip}, ${Number.MAX_SAFE_INTEGER}`;
     }
     else {
-        limitClause = (0, aql_1.aql) ``;
+        return undefined;
     }
-    return aql_1.aql.lines((0, aql_1.aql) `IN ${list}`, filter instanceof query_tree_1.ConstBoolQueryNode && filter.value
-        ? (0, aql_1.aql) ``
-        : (0, aql_1.aql) `FILTER ${processNode(filter, itemContext)}`, filterDanglingEdges, generateSortAQL(node.orderBy, itemContext), limitClause);
 }
 /**
  * Generates an IN... clause for a list to be used within a query / subquery (FOR ... IN ...)
  */
 function generateInClause(node, context, entityVar) {
     if (node instanceof query_tree_1.TransformListQueryNode && node.innerNode === node.itemVariable) {
-        const itemContext = context.introduceVariableAlias(node.itemVariable, entityVar);
+        const itemContext = context.bindVariable(node.itemVariable, entityVar);
         return generateInClauseWithFilterAndOrderAndLimit({
             node,
             itemContext,
@@ -444,7 +456,7 @@ register(query_tree_1.CountQueryNode, (node, context) => {
     // note that ArangoDB's inline-subqueries rule optimizes for the case where listNode is a TransformList again.
     const itemVar = aql_1.aql.variable('item');
     const countVar = aql_1.aql.variable('count');
-    return aqlExt.parenthesizeObject((0, aql_1.aql) `FOR ${itemVar}`, (0, aql_1.aql) `IN ${processNode(node.listNode, context)}`, (0, aql_1.aql) `COLLECT WITH COUNT INTO ${countVar}`, (0, aql_1.aql) `RETURN ${countVar}`);
+    return aqlExt.firstOfSubquery((0, aql_1.aql) `FOR ${itemVar}`, (0, aql_1.aql) `IN ${processNode(node.listNode, context)}`, (0, aql_1.aql) `COLLECT WITH COUNT INTO ${countVar}`, (0, aql_1.aql) `RETURN ${countVar}`);
 });
 register(query_tree_1.AggregationQueryNode, (node, context) => {
     const itemVar = aql_1.aql.variable('item');
@@ -550,7 +562,6 @@ register(query_tree_1.AggregationQueryNode, (node, context) => {
             break;
         // these should also remove NULL values by definition
         case model_1.AggregationOperator.DISTINCT:
-            // use COLLECT a = a instead of RETURN DISTINCT to be able to sort
             distinct = true;
             filterFrag = (0, aql_1.aql) `${itemVar} != null`;
             isList = true;
@@ -563,27 +574,34 @@ register(query_tree_1.AggregationQueryNode, (node, context) => {
         default:
             throw new Error(`Unsupported aggregator: ${node.aggregationOperator}`);
     }
-    return aqlExt[isList ? 'parenthesizeList' : 'parenthesizeObject']((0, aql_1.aql) `FOR ${itemVar}`, (0, aql_1.aql) `IN ${processNode(node.listNode, context)}`, filterFrag ? (0, aql_1.aql) `FILTER ${filterFrag}` : (0, aql_1.aql) ``, sort ? (0, aql_1.aql) `SORT ${itemVar}` : (0, aql_1.aql) ``, aggregationFunction
+    const subqueryFrag = aqlExt.subquery((0, aql_1.aql) `FOR ${itemVar}`, (0, aql_1.aql) `IN ${processNode(node.listNode, context)}`, filterFrag ? (0, aql_1.aql) `FILTER ${filterFrag}` : (0, aql_1.aql) ``, sort ? (0, aql_1.aql) `SORT ${itemVar}` : (0, aql_1.aql) ``, aggregationFunction
         ? (0, aql_1.aql) `COLLECT AGGREGATE ${aggregationVar} = ${aggregationFunction}(${itemFrag})`
         : distinct
             ? (0, aql_1.aql) `COLLECT ${aggregationVar} = ${itemFrag}`
             : (0, aql_1.aql) ``, (0, aql_1.aql) `RETURN ${resultFragment}`);
+    if (isList) {
+        return subqueryFrag;
+    }
+    else {
+        // generates FIRST(...) because subqueryFrag has parentheses
+        return (0, aql_1.aql) `FIRST${subqueryFrag}`;
+    }
 });
 register(query_tree_1.UpdateChildEntitiesQueryNode, (node, context) => {
     const itemsVar = aql_1.aql.variable('items');
     const itemsWithIndexVar = aql_1.aql.variable('itemsWithIndex');
-    const childContext = context.introduceVariable(node.dictionaryVar);
+    const childContext = context.bindVariable(node.dictionaryVar);
     const dictVar = childContext.getVariable(node.dictionaryVar);
     const updatedDictVar = aql_1.aql.variable('updatedDict');
     const itemVar = aql_1.aql.variable('item');
     const indexVar = aql_1.aql.variable('indexVar');
-    return aqlExt.parenthesizeList(
+    return aqlExt.subquery(
     // could be a complex expression, and we're using it multiple times -> store in a variable
     (0, aql_1.aql) `LET ${itemsVar} = ${processNode(node.originalList, context)}`, 
     // add a __index property to each item so we can sort by this later
     // regular field names cannot start with an underscore, so we're safe to use __index as a
     // temporary property to store the index of the child entity in the list
-    (0, aql_1.aql) `LET ${itemsWithIndexVar} = ${aqlExt.parenthesizeList((0, aql_1.aql) `FOR ${indexVar}`, 
+    (0, aql_1.aql) `LET ${itemsWithIndexVar} = ${aqlExt.subquery((0, aql_1.aql) `FOR ${indexVar}`, 
     // 0..-1 would evaluate to [0, -1], so the ZIP would complain because the right side
     // has more entries (2) than the left (0). RANGE() behaves the same
     (0, aql_1.aql) `IN LENGTH(${itemsVar}) > 0 ? 0..(LENGTH(${itemsVar}) - 1) : []`, (0, aql_1.aql) `RETURN MERGE(NTH(${itemsVar}, ${indexVar}), { __index: ${indexVar} })`)}`, 
@@ -610,9 +628,10 @@ register(query_tree_1.MergeObjectsQueryNode, (node, context) => {
     return (0, aql_1.aql) `MERGE(${objectsFragment})`;
 });
 register(query_tree_1.ObjectEntriesQueryNode, (node, context) => {
+    // TODO aql-perf: use array inline expression
     const objectVar = aql_1.aql.variable('object');
     const keyVar = aql_1.aql.variable('key');
-    return aqlExt.parenthesizeList((0, aql_1.aql) `LET ${objectVar} = ${processNode(node.objectNode, context)}`, (0, aql_1.aql) `FOR ${keyVar} IN IS_DOCUMENT(${objectVar}) ? ATTRIBUTES(${objectVar}) : []`, (0, aql_1.aql) `RETURN [ ${keyVar}, ${objectVar}[${keyVar}] ]`);
+    return aqlExt.subquery((0, aql_1.aql) `LET ${objectVar} = ${processNode(node.objectNode, context)}`, (0, aql_1.aql) `FOR ${keyVar} IN IS_DOCUMENT(${objectVar}) ? ATTRIBUTES(${objectVar}) : []`, (0, aql_1.aql) `RETURN [ ${keyVar}, ${objectVar}[${keyVar}] ]`);
 });
 register(query_tree_1.FirstOfListQueryNode, (node, context) => {
     return (0, aql_1.aql) `FIRST(${processNode(node.listNode, context)})`;
@@ -759,7 +778,7 @@ function getBillingInput(node, key, context, currentTimestamp) {
 }
 register(query_tree_1.CreateBillingEntityQueryNode, (node, context) => {
     const currentTimestamp = context.options.clock.getCurrentTimestamp();
-    return aqlExt.parenthesizeList((0, aql_1.aql) `UPSERT {
+    return aqlExt.subquery((0, aql_1.aql) `UPSERT {
             key: ${node.key},
             type: ${node.rootEntityTypeName}
         }`, (0, aql_1.aql) `INSERT {
@@ -774,7 +793,7 @@ register(query_tree_1.CreateBillingEntityQueryNode, (node, context) => {
 register(query_tree_1.ConfirmForBillingQueryNode, (node, context) => {
     const key = processNode(node.keyNode, context);
     const currentTimestamp = context.options.clock.getCurrentTimestamp();
-    return aqlExt.parenthesizeList((0, aql_1.aql) `UPSERT {
+    return aqlExt.subquery((0, aql_1.aql) `UPSERT {
             key: ${key},
             type: ${node.rootEntityTypeName}
         }`, (0, aql_1.aql) `INSERT {
@@ -1017,109 +1036,683 @@ register(query_tree_1.EntitiesQueryNode, (node, context) => {
 });
 register(query_tree_1.FollowEdgeQueryNode, (node, context) => {
     const tmpVar = aql_1.aql.variable('node');
-    // need to wrap this in a subquery because ANY is not possible as first token of an expression node in AQL
-    return aqlExt.parenthesizeList((0, aql_1.aql) `FOR ${tmpVar}`, (0, aql_1.aql) `IN ${getSimpleFollowEdgeFragment(node, context)}`, (0, aql_1.aql) `FILTER ${tmpVar} != null`, (0, aql_1.aql) `RETURN ${tmpVar}`);
+    return aqlExt.subquery((0, aql_1.aql) `FOR ${tmpVar}`, (0, aql_1.aql) `IN ${getSimpleFollowEdgeFragment(node, context)}`, 
+    // filter out dangling edges (edges that point to non-existing entities)
+    // using $var._key != null instead of $var != null because the latter prevents ArangodB
+    // from applying the reduce-extraction-to-projection optimization
+    (0, aql_1.aql) `FILTER ${tmpVar}._key != null`, (0, aql_1.aql) `RETURN ${tmpVar}`);
 });
 register(query_tree_1.TraversalQueryNode, (node, context) => {
-    const sourceFrag = processNode(node.sourceEntityNode, context);
-    const fieldDepth = node.fieldSegments.filter((s) => s.isListSegment).length;
-    if (node.relationSegments.length) {
-        let mapFrag;
-        let remainingDepth = fieldDepth;
-        if (node.fieldSegments.length) {
-            // if we have both, it might be beneficial to do the field traversal within the mapping node
-            // because it may allow ArangoDB to figure out that only one particular field is of interest, and e.g.
-            // discard the root entities earlier
-            if (node.captureRootEntity) {
-                if (fieldDepth === 0) {
-                    // fieldSegments.length && fieldDepth === 0 means we only traverse through entity extensions
-                    // actually, shouldn't really occur because a collect path can't end with an entity extension and
-                    // value objects don't capture root entities
-                    // however, we can easily implement this so let's do it
-                    mapFrag = (nodeFrag) => (0, aql_1.aql) `{ obj: ${getFieldTraversalFragmentWithoutFlattening(node.fieldSegments, nodeFrag)}, root: ${nodeFrag}) }`;
-                }
-                else {
-                    // the result of getFieldTraversalFragmentWithoutFlattening() now is a list, so we need to iterate
-                    // over it. if the depth is > 1, we need to flatten the deeper ones so we can do one FOR loop over them
-                    // we still return a list, so we just reduce the depth to 1 and not to 0
-                    const entityVar = aql_1.aql.variable('entity');
-                    mapFrag = (rootEntityFrag) => aqlExt.parenthesizeList((0, aql_1.aql) `FOR ${entityVar} IN ${getFlattenFrag(getFieldTraversalFragmentWithoutFlattening(node.fieldSegments, rootEntityFrag), fieldDepth - 1)}`, (0, aql_1.aql) `RETURN { obj: ${entityVar}, root: ${rootEntityFrag} }`);
-                    remainingDepth = 1;
-                }
+    // We have a lot of different methods here for different cases
+    // The AQL looks very different depending on the case, and separate methods are easiser to
+    // understand than lots of conditionals in one big method
+    if (node.relationSegments.length && node.fieldSegments.length) {
+        if (!node.fieldSegments.some((f) => f.isListSegment)) {
+            // non-list field segments are similar to no field segments at all because we just
+            // append a simple field path to the root variable
+            if (node.resultIsList) {
+                return processTraversalWithListRelationSegmentsAndNonListFieldSegments(node, context);
             }
             else {
-                mapFrag = (nodeFrag) => getFieldTraversalFragmentWithoutFlattening(node.fieldSegments, nodeFrag);
+                // We currently don't allow non-list @collect paths, so this is never executed
+                // Keep it for nonetheless because we might allow it in the future or use
+                // TraversalQueryNode for other purposes
+                return processTraversalWithNonListRelationSegmentsAndNonListFieldSegments(node, context);
             }
         }
+        if (node.innerNode && (0, traversal_helpers_1.mightGenerateSubquery)(node.innerNode)) {
+            // cannot have subqueries within array expansions, so we need to use a subquery here
+            return processTraversalWithRelationAndListFieldSegmentsUsingSubquery(node, context);
+        }
+        // these both use array expansion expressions
+        if (node.orderBy.isUnordered()) {
+            return processTraversalWithRelationAndListFieldSegmentsUsingArrayExpansionWithoutSort(node, context);
+        }
         else {
-            if (node.captureRootEntity) {
-                // doesn't make sense to capture the root entity if we're returning the root entities
-                throw new Error(`captureRootEntity without fieldSegments detected`);
-            }
+            return processTraversalWithRelationAndListFieldSegmentsUsingArrayExpansionWithSort(node, context);
         }
-        // traversal requires real ids
-        let fixedSourceFrag = sourceFrag;
-        if (node.entitiesIdentifierKind === query_tree_1.EntitiesIdentifierKind.ID) {
-            if (node.sourceIsList) {
-                fixedSourceFrag = getFullIDFromKeysFragment(sourceFrag, node.relationSegments[0].relationSide.sourceType);
-            }
-            else {
-                fixedSourceFrag = getFullIDFromKeyFragment(sourceFrag, node.relationSegments[0].relationSide.sourceType);
-            }
+    }
+    else if (node.relationSegments.length) {
+        if (node.resultIsList) {
+            return processTraversalWithOnlyRelationSegmentsAsList(node, context);
         }
-        const frag = getRelationTraversalFragment({
-            segments: node.relationSegments,
-            sourceFrag: fixedSourceFrag,
-            sourceIsList: node.sourceIsList,
-            alwaysProduceList: node.alwaysProduceList,
-            mapFrag,
-            context,
-        });
-        if (node.relationSegments.some((s) => s.isListSegment) || node.sourceIsList) {
-            // if the relation contains a list segment, getRelationTraversalFragment will return a list
-            // if we already returned lists within the mapFrag (-> current value of remainingDepth), we need to add that
-            remainingDepth++;
+        else {
+            // We currently don't allow non-list @collect paths, so this is never executed
+            // Keep it for nonetheless because we might allow it in the future or use
+            // TraversalQueryNode for other purposes
+            return processTraversalWithOnlyRelationSegmentsNoList(node, context);
         }
-        // flatten 1 less than the depth, see below
-        return getFlattenFrag(frag, remainingDepth - 1);
     }
-    if (node.captureRootEntity) {
-        // doesn't make sense (and isn't possible) to capture the root entity if we're not even crossing root entities
-        throw new Error(`captureRootEntity without relationSegments detected`);
+    else if (node.fieldSegments.length) {
+        // In the simple case, we can use an array expansion expression instead of a subquery
+        // - SORT is not supported by array expressions (documented)
+        // - subqueries in array expressions currently cause an internal error in arangodb (3.12.6)
+        if (node.orderBy.isUnordered() &&
+            (!node.innerNode || !(0, traversal_helpers_1.mightGenerateSubquery)(node.innerNode))) {
+            return processTraversalWithOnlyFieldSegmentsUsingArrayExpansion(node, context);
+        }
+        else {
+            return processTraversalWithOnlyFieldSegmentsUsingSubquery(node, context);
+        }
     }
-    if (node.sourceIsList) {
-        // don't need, don't bother
-        throw new Error(`sourceIsList without relationSegments detected`);
+    else {
+        // don't need this case, so better guard against it
+        throw new Error(`TraversalQueryNode must have at least one segment`);
     }
-    if (node.alwaysProduceList) {
-        // don't need, don't bother
-        throw new Error(`alwaysProduceList without relationSegments detected`);
+});
+/**
+ * Produces:
+ *
+ *     FIRST(
+ *         FOR node1 IN OUTBOUND source_hop1
+ *         FOR node2 in OUTBOUND hop1_hop2
+ *         FOR result IN OUTBOUND hop2_target
+ *         RETURN innerNode(result)
+ *     )
+ *
+ * or, if preserveNullValues is true and hop2_target is a to-1 relation:
+ *
+ *     FIRST(
+ *         FOR node1 IN OUTBOUND source_hop1
+ *         FOR node2 in OUTBOUND hop1_hop2
+ *         LET result = FIRST(FOR node3 IN OUTBOUND hop2_target RETURNN node3)
+ *         RETURN innerNode(result)
+ *     )
+ */
+function processTraversalWithOnlyRelationSegmentsNoList(node, context) {
+    if (node.fieldSegments.length > 0) {
+        throw new Error(`Did not expect any field segments`);
+    }
+    if (node.filterNode ||
+        !node.orderBy.isUnordered() ||
+        node.skip !== undefined ||
+        node.maxCount !== undefined) {
+        throw new Error(`Cannot have filter, orderBy, skip or maxCount on non-list relation traversal`);
+    }
+    const innerContext = context.bindVariable(node.itemVariable);
+    const itemVar = innerContext.getVariable(node.itemVariable);
+    const forStatementsFrag = getRelationTraversalForStatements({
+        node,
+        innermostItemVar: itemVar,
+        preserveNullValues: node.preserveNullValues,
+        context,
+    });
+    return aqlExt.firstOfSubquery(forStatementsFrag, (0, aql_1.aql) `RETURN ${node.innerNode ? processNode(node.innerNode, innerContext) : itemVar}`);
+}
+/**
+ * Produces:
+ *
+ *     FOR node1 IN OUTBOUND source_hop1
+ *     FOR node2 in OUTBOUND hop1_hop2
+ *     FOR item IN OUTBOUND hop2_target
+ *     FILTER filterExpr(item)
+ *     SORT item.field1 ASC
+ *     LIMIT skip, maxCount
+ *     RETURN innerNode(item)
+ *
+ * or, if preserveNullValues is true and hop2_target is a to-1 relation:
+ *
+ *     FOR node1 IN OUTBOUND source_hop1
+ *     FOR node2 in OUTBOUND hop1_hop2
+ *     LET item = FIRST(FOR node3 IN OUTBOUND hop2_target RETURN node3)
+ *     FILTER filterExpr(item)
+ *     SORT item.field1 ASC
+ *     LIMIT skip, maxCount
+ *     RETURN innerNode(item)
+ */
+function processTraversalWithOnlyRelationSegmentsAsList(node, context) {
+    if (node.fieldSegments.length > 0) {
+        throw new Error(`Did not expect any field segments`);
+    }
+    // note: this is the only variant where sourceIsList and alwaysProduceList is supported
+    // (used in getPreEntityRemovalStatementsForRelationSide())
+    // - sourceIsList is handled in getRelationTraversalForStatements()
+    // - alwaysProduceList is automatically handled because we always RETURN a list here
+    // we could refactor the single usage so it does not use a TraversalQueryNode in the first place
+    const itemVar = aql_1.aql.variable(`node`);
+    const innerContext = context.bindVariable(node.itemVariable, itemVar);
+    const forStatementsFrag = getRelationTraversalForStatements({
+        node,
+        innermostItemVar: itemVar,
+        context,
+        preserveNullValues: node.preserveNullValues,
+    });
+    return aqlExt.subquery(forStatementsFrag, node.filterNode ? (0, aql_1.aql) `FILTER ${processNode(node.filterNode, context)}` : (0, aql_1.aql) ``, 
+    // yes, we can SORT and LIMIT like this even if there are multiple FOR statements
+    // because there is one result set for the cross product of all FOR statements
+    // see https://docs.arangodb.com/3.12/aql/high-level-operations/for/#usage
+    generateSortAQL(node.orderBy, innerContext), generateLimitClause(node) ?? (0, aql_1.aql) ``, (0, aql_1.aql) `RETURN ${node.innerNode ? processNode(node.innerNode, innerContext) : itemVar}`);
+}
+/**
+ * Produces:
+ *
+ *     FOR node1 IN OUTBOUND source_hop1
+ *     FOR node2 in OUTBOUND hop1_hop2
+ *     FOR item IN OUTBOUND hop2_target
+ *     FILTER filterExpr(item.fieldSegment1.fieldSegment2)
+ *     SORT item.fieldSegment1.fieldSegment2.sortField ASC
+ *     LIMIT skip, maxCount
+ *     RETURN innerNode(item.fieldSegment1.fieldSegment2, { root: node2 })
+ *
+ * or, if preserveNullValues is true and hop2_target is a to-1 relation:
+ *
+ *     FOR node1 IN OUTBOUND source_hop1
+ *     FOR node2 in OUTBOUND hop1_hop2
+ *     LET item = FIRST(FOR node3 IN OUTBOUND hop2_target RETURN node3)
+ *     FILTER filterExpr(item.fieldSegment1.fieldSegment2)
+ *     SORT item.fieldSegment1.fieldSegment2.sortField ASC
+ *     LIMIT skip, maxCount
+ *     RETURN innerNode(item.fieldSegment1.fieldSegment2, { root: node2 })
+ */
+function processTraversalWithListRelationSegmentsAndNonListFieldSegments(node, context) {
+    if (!node.relationSegments.some((f) => f.isListSegment)) {
+        throw new Error(`Expected at least one relation list segment`);
+    }
+    if (node.fieldSegments.some((f) => f.isListSegment)) {
+        throw new Error(`Did not expect any field list segments`);
+    }
+    // this is very similar to processTraversalWithOnlyRelationSegmentsAsList(),
+    // but instead of using the rootVar in filter, sort and mapping, we use the field traversal result
+    const rootVar = aql_1.aql.variable(`root`);
+    const forStatementsFrag = getRelationTraversalForStatements({
+        node,
+        innermostItemVar: rootVar,
+        context,
+        preserveNullValues: node.preserveNullValues,
+    });
+    const fieldTraversalFrag = getFieldTraversalFragment({
+        segments: node.fieldSegments,
+        sourceFrag: rootVar,
+    });
+    const innerContext = context.bindVariable(node.itemVariable, fieldTraversalFrag);
+    // note: we don't filter out NULL values even if preserveNullValues is false because that's currently
+    // only a flag for performance - actually filtering out NULLs is done by a surrounding AggregationQueryNode
+    // TODO aql-perf remove this note once the NULL filtering / preserving has moved out of AggregationQueryNode
+    return aqlExt.subquery(forStatementsFrag, node.filterNode ? (0, aql_1.aql) `FILTER ${processNode(node.filterNode, innerContext)}` : (0, aql_1.aql) ``, generateSortAQL(node.orderBy, innerContext), generateLimitClause(node) ?? (0, aql_1.aql) ``, (0, aql_1.aql) `RETURN ${node.innerNode ? processNode(node.innerNode, innerContext) : fieldTraversalFrag}`);
+}
+/**
+ * Produces:
+ *
+ *     FIRST(
+ *         FOR node1 IN OUTBOUND source_hop1
+ *         FOR node2 in OUTBOUND hop1_hop2
+ *         FOR item IN OUTBOUND hop2_target
+ *         RETURN innerNode(item.fieldSegment1.fieldSegment2, { root: node2 })
+ *     )
+ *
+ * or, if preserveNullValues is true and hop2_target is a to-1 relation:
+ *
+ *     FIRST(
+ *         FOR node1 IN OUTBOUND source_hop1
+ *         FOR node2 in OUTBOUND hop1_hop2
+ *         LET item = FIRST(FOR node3 IN OUTBOUND hop2_target RETURN node3)
+ *         RETURN innerNode(item.fieldSegment1.fieldSegment2, { root: node2 })
+ *     )
+ */
+function processTraversalWithNonListRelationSegmentsAndNonListFieldSegments(node, context) {
+    if (node.fieldSegments.some((f) => f.isListSegment)) {
+        throw new Error(`Did not expect any field list segments`);
+    }
+    if (node.relationSegments.some((f) => f.isListSegment)) {
+        throw new Error(`Did not expect any relation list segments`);
+    }
+    if (node.filterNode ||
+        !node.orderBy.isUnordered() ||
+        node.skip !== undefined ||
+        node.maxCount !== undefined) {
+        throw new Error(`Cannot have filter, orderBy, skip or maxCount on non-list traversal`);
+    }
+    // this is very similar to processTraversalWithOnlyRelationSegmentsNoList(),
+    // but instead of using the rootVar in mapping, we use the field traversal result
+    const rootVar = aql_1.aql.variable(`root`);
+    const forStatementsFrag = getRelationTraversalForStatements({
+        node,
+        innermostItemVar: rootVar,
+        preserveNullValues: node.preserveNullValues,
+        context,
+    });
+    const fieldTraversalFrag = getFieldTraversalFragment({
+        segments: node.fieldSegments,
+        sourceFrag: rootVar,
+    });
+    const innerContext = context.bindVariable(node.itemVariable, fieldTraversalFrag);
+    return aqlExt.firstOfSubquery(forStatementsFrag, (0, aql_1.aql) `RETURN ${node.innerNode ? processNode(node.innerNode, innerContext) : fieldTraversalFrag}`);
+}
+/**
+ * Produces:
+ *
+ *     FOR node1 IN OUTBOUND source_hop1
+ *     FOR node2 in OUTBOUND hop1_hop2
+ *     FOR root IN OUTBOUND hop2_target
+ *     FOR item IN root.fieldSegment1[*].fieldSegment2[** FILTER filterExpr(CURRENT)][*]
+ *     SORT item.sortValues[0]
+ *     LIMIT skip, maxCount
+ *     RETURN innerNode(item, { root })
+ *
+ * or, if preserveNullValues is true and hop2_target is a to-1 relation:
+ *
+ *     FOR node1 IN OUTBOUND source_hop1
+ *     FOR node2 in OUTBOUND hop1_hop2
+ *     LET root = FIRST(FOR node3 IN OUTBOUND hop2_target RETURN node3)
+ *     FOR item IN root.fieldSegment1[*].fieldSegment2[** FILTER filterExpr(CURRENT)][*]
+ *     SORT item.sortValues[0]
+ *     LIMIT skip, maxCount
+ *     RETURN innerNode(item, { root })
+ */
+function processTraversalWithRelationAndListFieldSegmentsUsingSubquery(node, context) {
+    if (!node.relationSegments.length || !node.fieldSegments) {
+        throw new Error(`Expected both relation and field segments`);
+    }
+    if (!node.fieldSegments.some((s) => s.isListSegment)) {
+        throw new Error(`Expected at least one list field segment`);
+    }
+    if (!node.resultIsList) {
+        throw new Error(`Cannot have sort on non-list traversal`);
+    }
+    // this will hold the node of the innermost relation traversal
+    const rootVar = aql_1.aql.variable('root');
+    const forStatementsFrag = getRelationTraversalForStatements({
+        node,
+        innermostItemVar: rootVar,
+        preserveNullValues: node.preserveNullValues,
+        context,
+    });
+    const filterNode = node.filterNode;
+    const innerFilterFrag = filterNode
+        ? (itemFrag) => {
+            // don't provide rootEntityVariable
+            // (if we want to filter on root, it should happen outside already)
+            const innerContext = context.bindVariable(node.itemVariable, itemFrag);
+            return processNode(filterNode, innerContext);
+        }
+        : undefined;
+    const fieldTraversalFrag = getFieldTraversalFragment({
+        segments: node.fieldSegments,
+        sourceFrag: rootVar,
+        filterFrag: innerFilterFrag,
+    });
+    const itemVar = aql_1.aql.variable(`item`);
+    const innerContext = context
+        .bindVariable(node.itemVariable, itemVar)
+        .bindVariable(node.rootEntityVariable, rootVar);
+    // The fieldTraversalFrag will produce a list, so a simple RETURN mapFrag would result in nested lists
+    // -> we iterate over the items again to flatten the lists (the FOR ${itemVar} ...)
+    return aqlExt.subquery((0, aql_1.aql) `${forStatementsFrag}`, (0, aql_1.aql) `FOR ${itemVar} IN ${fieldTraversalFrag}`, generateSortAQL(node.orderBy, innerContext), generateLimitClause(node) ?? (0, aql_1.aql) ``, (0, aql_1.aql) `RETURN ${node.innerNode ? processNode(node.innerNode, innerContext) : itemVar}`);
+}
+/**
+ * Produces this if the result of the relation traversal is a single item:
+ *
+ *     FOR node1 IN OUTBOUND source_hop1
+ *     FOR node2 in OUTBOUND hop1_hop2
+ *     FOR root IN OUTBOUND hop2_target
+ *     FOR item IN root.fieldSegment1[*].fieldSegment2[**][*
+ *         FILTER filterExpr(CURRENT)
+ *         LIMIT skip, maxCount
+ *         RETURN innerNode(CURRENT, { root })
+ *     ]
+ *     RETURN item
+ *
+ * or, if the result of the relation traversal is a list:
+ *
+ *     FOR node1 IN OUTBOUND source_hop1
+ *     FOR node2 in OUTBOUND hop1_hop2
+ *     FOR root IN OUTBOUND hop2_target
+ *     FOR item IN root.fieldSegment1[*].fieldSegment2[**][*
+ *         FILTER filterExpr(CURRENT)
+ *         RETURN innerNode(CURRENT, { root })
+ *     ]
+ *     LIMIT skip, maxCount
+ *     RETURN item
+ *
+ * ---
+ *
+ * or, if preserveNullValues is true and hop2_target is a to-1 relation:
+ *
+ *     FOR node1 IN OUTBOUND source_hop1
+ *     FOR node2 in OUTBOUND hop1_hop2
+ *     LET root = FIRST(FOR node3 IN OUTBOUND hop2_target RETURN node3)
+ *     FOR item IN root.fieldSegment1[*].fieldSegment2[**][*
+ *         FILTER filterExpr(CURRENT)
+ *         LIMIT skip, maxCount
+ *         RETURN innerNode(CURRENT, { root })
+ *     ]
+ *     RETURN item
+ *
+ * or, if the result of the relation traversal is a list:
+ *
+ *     FOR node1 IN OUTBOUND source_hop1
+ *     FOR node2 in OUTBOUND hop1_hop2
+ *     LET root = FIRST(FOR node3 IN OUTBOUND hop2_target RETURN node3)
+ *     FOR item IN root.fieldSegment1[*].fieldSegment2[**][*
+ *         FILTER filterExpr(CURRENT)
+ *         RETURN innerNode(CURRENT, { root })
+ *     ]
+ *     LIMIT skip, maxCount
+ *     RETURN item
+ */
+function processTraversalWithRelationAndListFieldSegmentsUsingArrayExpansionWithoutSort(node, context) {
+    if (!node.relationSegments.length || !node.fieldSegments) {
+        throw new Error(`Expected both relation and field segments`);
+    }
+    if (!node.fieldSegments.some((s) => s.isListSegment)) {
+        throw new Error(`Expected at least one list field segment`);
+    }
+    if (!node.orderBy.isUnordered()) {
+        throw new Error(`Did not expect orderBy clauses`);
+    }
+    // this will hold the node of the innermost relation traversal
+    const rootVar = aql_1.aql.variable('root');
+    const forStatementsFrag = getRelationTraversalForStatements({
+        node,
+        innermostItemVar: rootVar,
+        preserveNullValues: node.preserveNullValues,
+        context,
+    });
+    const innerNode = node.innerNode;
+    const innerMapFrag = innerNode
+        ? (itemFrag) => {
+            const innerContext = context
+                .bindVariable(node.itemVariable, itemFrag)
+                .bindVariable(node.rootEntityVariable, rootVar);
+            return processNode(innerNode, innerContext);
+        }
+        : undefined;
+    // We can do the LIMIT within the field traversal's mapping function using an array expansion,
+    // but only if the relation traversal yields at most one result (i.e. if it only follows 1:1 relations)
+    const lastRelationSegment = node.relationSegments[node.relationSegments.length - 1];
+    let limitArgs;
+    let innerLimitArgs;
+    if (lastRelationSegment.resultIsList) {
+        limitArgs = {
+            skip: node.skip,
+            maxCount: node.maxCount,
+        };
+        innerLimitArgs = {};
+    }
+    else {
+        limitArgs = {};
+        innerLimitArgs = {
+            skip: node.skip,
+            maxCount: node.maxCount,
+        };
+    }
+    let innerFilterFrag;
+    const filterNode = node.filterNode;
+    if (filterNode) {
+        innerFilterFrag = (itemFrag) => {
+            // don't map rootEntityVariable
+            // (if we want to filter on root, it should happen outside already)
+            const innerContext = context.bindVariable(node.itemVariable, itemFrag);
+            return processNode(filterNode, innerContext);
+        };
+    }
+    const fieldTraversalFrag = getFieldTraversalFragment({
+        segments: node.fieldSegments,
+        sourceFrag: rootVar,
+        mapFrag: innerMapFrag,
+        filterFrag: innerFilterFrag,
+        ...innerLimitArgs,
+    });
+    // the fieldTraversalFrag will produce a list, so a simple RETURN mapFrag would result in nested lists
+    // -> we iterate over the items again to flatten the lists
+    // Note: If the relation traversal only consists of 1:1, we could theoretically use something like this:
+    //     LET root = FIRST(FOR obj IN OUTBOUND source edge_collection RETURN obj)
+    //     RETURN root.children
+    // however, that would prevent the reduce-extraction-to-projection optimization
+    // (because we would access the whole root object)
+    // -> it's better to produce the same structure as we do for 1:n relation traversals:
+    //     FOR root IN OUTBOUND source edge_collection
+    //     FOR item IN root.children
+    //     RETURN item
+    // (could also use FLATTEN(), but since we're already using nested FORs, this is probably cleaner)
+    const itemVar = aql_1.aql.variable(`item`);
+    return aqlExt.subquery((0, aql_1.aql) `${forStatementsFrag}`, (0, aql_1.aql) `FOR ${itemVar} IN ${fieldTraversalFrag}`, generateLimitClause(limitArgs) ?? (0, aql_1.aql) ``, (0, aql_1.aql) `RETURN ${itemVar}`);
+}
+/**
+ * Produces:
+ *
+ *     FOR node1 IN OUTBOUND source_hop1
+ *     FOR node2 in OUTBOUND hop1_hop2
+ *     FOR root IN OUTBOUND hop2_target
+ *     FOR item IN root.fieldSegment1[*].fieldSegment2[**][*
+ *         FILTER filterExpr(CURRENT)
+ *         RETURN {
+ *             value: innerNode(CURRENT, { root }),
+ *             sortValues: [
+ *                 CURRENT.sortField1,
+ *                 CURRENT.sortField2
+ *             ]
+ *         }
+ *     ]
+ *     SORT item.sortValues[0] ASC, item.sortValues[1] DESC
+ *     LIMIT skip, maxCount
+ *     RETURN item.value
+ *
+ * or, if preserveNullValues is true and hop2_target is a to-1 relation:
+ *
+ *     FOR node1 IN OUTBOUND source_hop1
+ *     FOR node2 in OUTBOUND hop1_hop2
+ *     LET root = FIRST(FOR node3 IN OUTBOUND hop2_target RETURN node3)
+ *     FOR item IN root.fieldSegment1[*].fieldSegment2[**][*
+ *         FILTER filterExpr(CURRENT)
+ *         RETURN {
+ *             value: innerNode(CURRENT, { root }),
+ *             sortValues: [
+ *                 CURRENT.sortField1,
+ *                 CURRENT.sortField2
+ *             ]
+ *         }
+ *     ]
+ *     SORT item.sortValues[0] ASC, item.sortValues[1] DESC
+ *     LIMIT skip, maxCount
+ *     RETURN item.value
+ */
+function processTraversalWithRelationAndListFieldSegmentsUsingArrayExpansionWithSort(node, context) {
+    if (!node.relationSegments.length || !node.fieldSegments) {
+        throw new Error(`Expected both relation and field segments`);
+    }
+    if (!node.fieldSegments.some((s) => s.isListSegment)) {
+        throw new Error(`Expected at least one list field segment`);
+    }
+    if (!node.resultIsList) {
+        throw new Error(`Cannot have sort on non-list traversal`);
+    }
+    if (node.orderBy.isUnordered()) {
+        throw new Error(`Expected orderBy clauses`);
+    }
+    // this will hold the node of the innermost relation traversal
+    const rootVar = aql_1.aql.variable('root');
+    const forStatementsFrag = getRelationTraversalForStatements({
+        node,
+        innermostItemVar: rootVar,
+        preserveNullValues: node.preserveNullValues,
+        context,
+    });
+    /*
+      A simple way to implement this would be to first SORT, and then map:
+
+          FOR v_root1 IN 1..1 INBOUND v_order1 @@deliveries_order
+          FOR v_item1 IN v_root1.`deliveryContents`[*].`items`[**]
+          SORT v_item1.`itemNumber`
+          RETURN {
+            "itemNumber": v_item1.`itemNumber`
+          }
+
+      (this is done by processTraversalWithRelationAndListFieldSegmentsUsingSubquery())
+
+      Instead, we map first, then SORT:
+
+          FOR v_root1 IN 1..1 INBOUND v_order1 @@deliveries_order
+          FOR v_item1 IN v_root1.`deliveryContents`[*].`items`[** RETURN {
+            value: {
+              "itemNumber": CURRENT.`itemNumber`
+            },
+            sortValues: [
+              CURRENT.`itemNumber`
+            ]
+          }]
+          SORT v_item1.sortValues[0]
+          RETURN v_item1.value
+
+      This seems to reduce the memory consumption by up to factor 2
+      if there are many / large fields in the items that are not needed at all
+      (because sorting probably copies the whole item into some temporary structure)
+     */
+    // we sort after mapping roots to items, so we need to preserve the sort values that are based on the item
+    // -> we produce items like this: { value: ..., sortValues: [...] }
+    const innerMapFrag = (itemFrag) => {
+        const innerContext = context
+            .bindVariable(node.itemVariable, itemFrag)
+            .bindVariable(node.rootEntityVariable, rootVar);
+        const valueFrag = node.innerNode ? processNode(node.innerNode, innerContext) : itemFrag;
+        return aql_1.aql.lines((0, aql_1.aql) `{`, aql_1.aql.indent(aql_1.aql.lines((0, aql_1.aql) `value: ${valueFrag},`, (0, aql_1.aql) `sortValues: [`, aql_1.aql.indent(aql_1.aql.join(node.orderBy.clauses.map((c) => processNode(c.valueNode, innerContext)), (0, aql_1.aql) `,\n`)), (0, aql_1.aql) `]`)), (0, aql_1.aql) `}`);
+    };
+    const filterNode = node.filterNode;
+    const innerFilterFrag = filterNode
+        ? (itemFrag) => {
+            // don't provide rootEntityVariable
+            // (if we want to filter on root, it should happen outside already)
+            const innerContext = context.bindVariable(node.itemVariable, itemFrag);
+            return processNode(filterNode, innerContext);
+        }
+        : undefined;
+    const fieldTraversalFrag = getFieldTraversalFragment({
+        segments: node.fieldSegments,
+        sourceFrag: rootVar,
+        mapFrag: innerMapFrag,
+        filterFrag: innerFilterFrag,
+    });
+    // holds the { value, sortValues }
+    const itemVar = aql_1.aql.variable(`item`);
+    const clauseFrags = node.orderBy.clauses.map((clause, index) => (0, aql_1.aql) `${itemVar}.sortValues[${aql_1.aql.integer(index)}]${dirAQL(clause.direction)}`);
+    // The fieldTraversalFrag will produce a list, so a simple RETURN mapFrag would result in nested lists
+    // -> we iterate over the items again to flatten the lists (the FOR ${itemVar} ...)
+    return aqlExt.subquery((0, aql_1.aql) `${forStatementsFrag}`, (0, aql_1.aql) `FOR ${itemVar} IN ${fieldTraversalFrag}`, (0, aql_1.aql) `SORT ${aql_1.aql.join(clauseFrags, (0, aql_1.aql) `, `)}`, generateLimitClause(node) ?? (0, aql_1.aql) ``, (0, aql_1.aql) `RETURN ${itemVar}.value`);
+}
+/**
+ * Produces:
+ *
+ *     source.listFieldSegment1[*].listFieldSegment2[**][*
+ *         FILTER filterExpr(CURRENT.nonListFieldSegment)
+ *         LIMIT skip, maxCount
+ *         RETURN innerNode(CURRENT.nonListFieldSegment)
+ *     ]
+ */
+function processTraversalWithOnlyFieldSegmentsUsingArrayExpansion(node, context) {
+    if (node.relationSegments.length) {
+        throw new Error(`Expected no relation segments`);
     }
     if (node.entitiesIdentifierKind !== query_tree_1.EntitiesIdentifierKind.ENTITY) {
         throw new Error(`Only ENTITY identifiers supported without relationSegments`);
     }
+    if (!node.orderBy.isUnordered()) {
+        throw new Error(`Did not expect orderBy clauses`);
+    }
     if (!node.fieldSegments.length) {
-        // should normally not occur
-        return sourceFrag;
+        throw new Error(`Expected at least one field segment`);
     }
-    // flatten 1 less than the fieldDepth:
-    // - no list segments -> evaluate to the object
-    // - one list segment -> evaluate to the list, so no flattening
-    // - two list segments -> needs flattening once to get one list
-    return getFlattenFrag(getFieldTraversalFragmentWithoutFlattening(node.fieldSegments, sourceFrag), fieldDepth - 1);
-});
-function getRelationTraversalFragment({ segments, sourceFrag, sourceIsList, alwaysProduceList, mapFrag, context, }) {
-    if (!segments.length) {
-        return sourceFrag;
+    const sourceFrag = processNode(node.sourceEntityNode, context);
+    // no SORT clause, so we can put everything into array expansions
+    // This is more efficient than using subqueries.
+    const innerNode = node.innerNode;
+    const mapFrag = innerNode
+        ? (itemFrag) => processNode(innerNode, context.bindVariable(node.itemVariable, itemFrag))
+        : undefined;
+    const filterNode = node.filterNode;
+    const filterFrag = filterNode
+        ? (itemFrag) => processNode(filterNode, context.bindVariable(node.itemVariable, itemFrag))
+        : undefined;
+    // if there are no list segments, this will just be a simple path access
+    // -> will naturally be either a list or not, depending on what's needed
+    return getFieldTraversalFragment({
+        segments: node.fieldSegments,
+        sourceFrag,
+        mapFrag,
+        filterFrag,
+        skip: node.skip,
+        maxCount: node.maxCount,
+    });
+}
+/**
+ * Produces:
+ *
+ *     FOR item IN source.listFieldSegment1[*].listFieldSegment2[**].nonListFieldSegment
+ *     FILTER filterExpr(item)
+ *     SORT item.sortField1 ASC, item.sortField1 DESC
+ *     LIMIT skip, maxCount
+ *     RETURN innerNode(item)
+ */
+function processTraversalWithOnlyFieldSegmentsUsingSubquery(node, context) {
+    if (node.relationSegments.length) {
+        throw new Error(`Expected no relation segments`);
+    }
+    if (node.entitiesIdentifierKind !== query_tree_1.EntitiesIdentifierKind.ENTITY) {
+        throw new Error(`Only ENTITY identifiers supported without relationSegments`);
+    }
+    if (!node.fieldSegments.length) {
+        throw new Error(`Expected at least one field segment`);
+    }
+    if (!node.resultIsList) {
+        // this branch would always create a list due to the subquery
+        throw new Error(`Cannot have orderBy on non-list field traversal`);
+    }
+    const sourceFrag = processNode(node.sourceEntityNode, context);
+    // need to use a subquery because array inline expressions don't support SORT
+    // this also means we can't do the innerNode mapping in inline expressions using [* RETURN ...]
+    // because otherwise we could not access the sort fields outside
+    // theoretically we could map the sort fields like we do in the relation + field traversal case,
+    // but we wouldn't gain anything from this here
+    // -> a simple subquery
+    // TODO aql-perf: we could use the { value, sortValues } approach here as well to reduce memory consumption
+    const fieldTraversalFrag = getFieldTraversalFragment({
+        segments: node.fieldSegments,
+        sourceFrag,
+    });
+    const itemVar = aql_1.aql.variable('item');
+    const innerContext = context.bindVariable(node.itemVariable, itemVar);
+    const returnValueFrag = node.innerNode ? processNode(node.innerNode, innerContext) : itemVar;
+    // filter in the subquery instead of in getFieldTraversalFragment() because the filter
+    // expression might use subqueries
+    const filterFrag = node.filterNode
+        ? (0, aql_1.aql) `FILTER ${processNode(node.filterNode, innerContext)}`
+        : (0, aql_1.aql) ``;
+    return aqlExt.subquery((0, aql_1.aql) `FOR ${itemVar}`, (0, aql_1.aql) `IN ${fieldTraversalFrag}`, filterFrag, generateSortAQL(node.orderBy, innerContext), generateLimitClause(node) ?? (0, aql_1.aql) ``, (0, aql_1.aql) `RETURN ${returnValueFrag}`);
+}
+function getRelationTraversalForStatements({ node, innermostItemVar, context, preserveNullValues = false, }) {
+    if (!node.relationSegments.length) {
+        throw new Error(`Expected at least one relation segment`);
+    }
+    const segments = node.relationSegments;
+    const sourceIsList = node.sourceIsList;
+    const plainSourceFrag = processNode(node.sourceEntityNode, context);
+    // traversal requires real ids
+    let sourceFrag;
+    if (node.entitiesIdentifierKind === query_tree_1.EntitiesIdentifierKind.ID) {
+        if (node.sourceIsList) {
+            sourceFrag = getFullIDFromKeysFragment(plainSourceFrag, node.relationSegments[0].relationSide.sourceType);
+        }
+        else {
+            sourceFrag = getFullIDFromKeyFragment(plainSourceFrag, node.relationSegments[0].relationSide.sourceType);
+        }
+    }
+    else {
+        sourceFrag = plainSourceFrag;
     }
-    // ArangoDB 3.4.5 introduced PRUNE which also supports IS_SAME_COLLECTION so we may be able to use just one
-    // traversal which lists all affected edge collections and prunes on the path in the future.
-    const forFragments = [];
     const sourceEntityVar = aql_1.aql.variable(`sourceEntity`);
     let currentObjectFrag = sourceIsList ? sourceEntityVar : sourceFrag;
+    const forFragments = sourceIsList
+        ? [(0, aql_1.aql) `FOR ${sourceEntityVar} IN ${sourceFrag}`]
+        : [];
+    // ArangoDB 3.4.5 introduced PRUNE which also supports IS_SAME_COLLECTION so we may be able to use just one
+    // traversal which lists all affected edge collections and prunes on the path in the future.
     let segmentIndex = 0;
+    const lastListSegmentIndex = segments.findLastIndex((s) => s.isListSegment);
     for (const segment of segments) {
-        const nodeVar = aql_1.aql.variable(`node`);
+        const isLastSegment = segmentIndex === segments.length - 1;
+        // if there is no list segment, lastListSegmentIndex is -1, so needsNullableVar is true for all segments
+        const needsNullableVar = preserveNullValues && segmentIndex > lastListSegmentIndex; // see below
+        // the caller can specify the result var because they will need it to work with it
+        const nodeVar = isLastSegment && !needsNullableVar ? innermostItemVar : aql_1.aql.variable(`node`);
         const edgeVar = aql_1.aql.variable(`edge`);
         const pathVar = aql_1.aql.variable(`path`);
         const dir = segment.relationSide.isFromSide ? (0, aql_1.aql) `OUTBOUND` : (0, aql_1.aql) `INBOUND`;
@@ -1129,7 +1722,7 @@ function getRelationTraversalFragment({ segments, sourceFrag, sourceIsList, alwa
             if (!segment.vertexFilterVariable) {
                 throw new Error(`vertexFilter is set, but vertexFilterVariable is not`);
             }
-            const filterContext = context.introduceVariableAlias(segment.vertexFilterVariable, nodeVar);
+            const filterContext = context.bindVariable(segment.vertexFilterVariable, nodeVar);
             // PRUNE to stop on a node that has to be filtered out (only necessary for traversals > 1 path length)
             // however, PRUNE only seems to be a performance feature and is not reliably evaluated
             // (e.g. it's not when using COLLECT with distinct for some reason), so we need to add a path filter
@@ -1142,7 +1735,7 @@ function getRelationTraversalFragment({ segments, sourceFrag, sourceIsList, alwa
                     throw new Error(`Unsupported filter pattern for graph traversal`);
                 }
                 const vertexInPathFrag = (0, aql_1.aql) `${pathVar}.vertices[*]`;
-                const pathFilterContext = context.introduceVariableAlias(segment.vertexFilterVariable, vertexInPathFrag);
+                const pathFilterContext = context.bindVariable(segment.vertexFilterVariable, vertexInPathFrag);
                 const lhsFrag = processNode(segment.vertexFilter.lhs, pathFilterContext);
                 const opFrag = getAQLOperator(segment.vertexFilter.operator);
                 if (!opFrag) {
@@ -1158,68 +1751,138 @@ function getRelationTraversalFragment({ segments, sourceFrag, sourceIsList, alwa
             }
         }
         const traversalFrag = (0, aql_1.aql) `FOR ${nodeVar}, ${edgeVar}, ${pathVar} IN ${segment.minDepth}..${segment.maxDepth} ${dir} ${currentObjectFrag} ${getCollectionForRelation(segment.relationSide.relation, AccessType.EXPLICIT_READ, context)}${pruneFrag}${filterFrag}`;
-        if (segment.isListSegment || (alwaysProduceList && segmentIndex === segments.length - 1)) {
+        // if we just put one FOR after the other, we never get NULL values:
+        // consider Consignment has-many Delivery has-one Order
+        //   LET consignment = ...
+        //   FOR delivery IN OUTBOUND consignment consignment_deliveries
+        //   FOR order IN OUTBOUND delivery delivery_order
+        //   RETURN order
+        // The second FOR would simply not find any orders, so the whole subquery would be [].
+        // This is ok most of the time because regular lists in cruddl never have NULL values
+        // but for some aggregations, we need to count NULL values (-> preserveNullValues is true)
+        // to not break these cases, we use a LET statement. This is inefficient though as it
+        // retrieves the whole document and prevents reduce-extraction-to-projection optimizations
+        // TODO aql-perf we should refactor those cases to embed the aggregation in the traversal
+        if (needsNullableVar) {
+            // to ignore dangling edges, add a FILTER though
+            // (if there was one dangling edge and one real edge collected, we should use the real one)
+            // using $var._key != null instead of $var != null because the latter prevents ArangoDB
+            // from applying the reduce-extraction-to-projection optimization
+            const nullableVar = isLastSegment ? innermostItemVar : aql_1.aql.variable(`nullableNode`);
+            forFragments.push((0, aql_1.aql) `LET ${nullableVar} = FIRST(${traversalFrag} FILTER ${nodeVar}._key != NULL RETURN ${nodeVar})`);
+            currentObjectFrag = nullableVar;
+        }
+        else {
             // this is simple - we can just push one FOR statement after the other
             forFragments.push(traversalFrag);
             currentObjectFrag = nodeVar;
         }
-        else {
-            // if this is not a list, we need to preserve NULL values
-            // (actually, we don't in some cases, but we need to figure out when)
-            // to preserve null values, we need to use FIRST
-            // to ignore dangling edges, add a FILTER though (if there was one dangling edge and one real edge collected, we should use the real one)
-            const nullableVar = aql_1.aql.variable(`nullableNode`);
-            forFragments.push((0, aql_1.aql) `LET ${nullableVar} = FIRST(${traversalFrag} FILTER ${nodeVar} != null RETURN ${nodeVar})`);
-            currentObjectFrag = nullableVar;
-        }
         context.addCollectionAccess((0, arango_basics_1.getCollectionNameForRootEntity)(segment.relationSide.targetType), AccessType.IMPLICIT_READ);
         segmentIndex++;
     }
-    const lastSegment = segments[segments.length - 1];
-    // remove dangling edges, unless we already did because the last segment wasn't a list segment (see above, we add the FILTER there)
-    if (lastSegment.isListSegment) {
-        forFragments.push((0, aql_1.aql) `FILTER ${currentObjectFrag} != null`);
+    // each FOR automatically removes NULLs of the previous step (just how FOR works)
+    // This does not apply to the last FOR though
+    // - if it's not a list, this is correct: we would want the NULL values there
+    //   (e.g. deliveries.order should have as many NULLs as there are deliveries without an order)
+    //   dangling edges are already filtered out above in the LET (needsNullableVar)
+    // - if it's a list, we shouldn't have any NULLs because we don't have "relation to NULL"s
+    //   in case of dangling edges however (i.e. edge without corresponding document)
+    //   we could generate NULLS. We generally ignore those in cruddl. -> filter them out
+    //   preserveNullValues is handled above (the dangling edge filter is in the LET there)
+    if (segments[segments.length - 1].isListSegment) {
+        // using $var._key != null instead of $var != null because the latter prevents ArangoDB
+        // from applying the reduce-extraction-to-projection optimization
+        forFragments.push((0, aql_1.aql) `FILTER ${currentObjectFrag}._key != null`);
     }
-    const returnFrag = mapFrag ? mapFrag(currentObjectFrag) : currentObjectFrag;
-    const returnList = lastSegment.resultIsList || sourceIsList || alwaysProduceList;
     // make sure we don't return a list with one element
-    return aqlExt[returnList ? 'parenthesizeList' : 'parenthesizeObject'](sourceIsList ? (0, aql_1.aql) `FOR ${sourceEntityVar} IN ${sourceFrag}` : (0, aql_1.aql) ``, ...forFragments, (0, aql_1.aql) `RETURN ${returnFrag}`);
-}
-function getFlattenFrag(listFrag, depth) {
-    if (depth <= 0) {
-        return listFrag;
-    }
-    if (depth === 1) {
-        return (0, aql_1.aql) `${listFrag}[**]`;
-    }
-    return (0, aql_1.aql) `FLATTEN(${listFrag}, ${aql_1.aql.integer(depth)})`;
+    return aql_1.aql.lines(...forFragments);
 }
-function getFieldTraversalFragmentWithoutFlattening(segments, sourceFrag) {
+function getFieldTraversalFragment({ segments, sourceFrag, mapFrag, filterFrag, skip = 0, maxCount, }) {
     if (!segments.length) {
         return sourceFrag;
     }
+    if ((mapFrag || filterFrag || maxCount !== undefined || skip > 0) &&
+        !segments.some((s) => s.isListSegment)) {
+        throw new Error(`Cannot have map, filter or limit on field traversal without list segments`);
+    }
+    const limitFrag = generateLimitClause({ skip, maxCount });
+    // We use array inline expressions instead of FOR ... IN ... RETURN ... because this reduces the number of
+    // execution nodes which would need to pass the data between them. Inline expressions are more efficient.
+    //
+    // We flatten on the go
+    //  -> source[*].field1[**].field2[**]
+    // (instead of (source[*].field1[*].field2[*])[***})
+    // because this allows us to put a LIMIT on the last item and have it apply to the list as a whole.
+    // Every access "into" an array requires a [*] or [**] operator because otherwise you would just get NULL
+    //
+    // The first array access uses [*], further ones use [**] because using [*] again would result in nested arrays.
+    // source[*].prop is equivalent to source.map(o => o.prop)
+    // source[**] is equivalent to source.flat()
+    // source[**].prop is equivalent to source.flat().map(o => o.prop)
+    // (there is no direct equivalent of flatMap())
+    //
+    // If there are non-list segments in the middle, those can just be put without an operator:
+    // source.items[*].extension.children[**].extension.children[**]
+    // (equivalent to source.items.map(o => o.extension.children).flatMap(o => o.extension.children))
+    //
+    // [*] treats NULL as an empty list, even though this is undocumented:
+    // https://docs.arangodb.com/stable/aql/operators/#array-expansion
+    // > It is required that the expanded variable is an array.
+    // however, the code that handles it looks very intentional (if not array, return empty array)
+    // https://github.com/arangodb/arangodb/blob/b1f655a12d80b6f44d3384919cb707019bd00c3a/arangod/Aql/Expression.cpp#L1685
+    // -> it is unlikely to be changed.
+    //
+    // The same does not apply to flattening however: while (NULL)[**] == [] just as (NULL)[*] == [],
+    // ([NULL])[**] == [ NULL ] (so it just does not flatten, but keep the null)
+    // we need to treat the NULL item as an empty list (e.g. an uninitialized child entity field)
+    // -> we need to use [*][**] instead of just [**]
+    //
+    // We also append [**] at the end if there were two list segments because we still need to flatten then
+    // If there was only one list segment, we append [*] at the end because it converts NULL to an empty list
     let frag = sourceFrag;
+    let index = 0;
+    let hasSeenListSegment = false;
+    const lastListSegmentIndex = segments.findLastIndex((s) => s.isListSegment);
     for (const segment of segments) {
         frag = (0, aql_1.aql) `${frag}${getPropertyAccessFragment(segment.field.name)}`;
         if (segment.isListSegment) {
-            // the array expansion operator [*] does two useful things:
-            // - it performs the next field access basically as .map(o => o.fieldName).
-            // - it converts non-lists to lists (important so that if we flatten afterwards, we don't include NULL lists
-            // the latter is why we also add the [*] at the end of the expression, which might look strange in the AQL.
-            frag = (0, aql_1.aql) `${frag}[*]`;
+            // use ** to flatten / flatMap if this is a nested list
+            // always use * after to convert NULLs to empty lists
+            const operatorPrefixFrag = hasSeenListSegment ? (0, aql_1.aql) `[*][**` : (0, aql_1.aql) `[*`;
+            const operatorSuffixFrag = (0, aql_1.aql) `]`;
+            if (index === lastListSegmentIndex) {
+                // If there is a non-list segment at the end, we stop the regular expression at the last list segment
+                // and instead put the non-list segments into the RETURN / FILTER
+                // (e.g. source.items[*].children[** FILTER CURRENT.extension.field > 0 RETURN CURRENT.extension)
+                const remainingSegments = segments.slice(index + 1);
+                const itemAccessFrag = remainingSegments.reduce((currentFrag, seg) => (0, aql_1.aql) `${currentFrag ?? (0, aql_1.aql) ``}${getPropertyAccessFragment(seg.field.name)}`, undefined);
+                const itemFrag = (0, aql_1.aql) `CURRENT${itemAccessFrag ?? (0, aql_1.aql) ``}`;
+                // if there are remaining segments to access, and we don't have a map, just append the item
+                // access at the end: source.items[*].field
+                const suffixFrag = itemAccessFrag && !mapFrag ? itemAccessFrag : (0, aql_1.aql) ``;
+                const returnExprFrag = mapFrag ? (0, aql_1.aql) ` RETURN ${mapFrag(itemFrag)}` : (0, aql_1.aql) ``;
+                const filterExprFrag = filterFrag ? (0, aql_1.aql) ` FILTER ${filterFrag(itemFrag)}` : (0, aql_1.aql) ``;
+                const limitExprFrag = limitFrag ? (0, aql_1.aql) ` ${limitFrag}` : (0, aql_1.aql) ``;
+                return (0, aql_1.aql) `${frag}${operatorPrefixFrag}${filterExprFrag}${limitExprFrag}${returnExprFrag}${operatorSuffixFrag}${suffixFrag}`;
+            }
+            else {
+                frag = (0, aql_1.aql) `${frag}${operatorPrefixFrag}${operatorSuffixFrag}`;
+            }
+            hasSeenListSegment = true;
         }
+        index++;
     }
     return frag;
 }
 register(query_tree_1.CreateEntityQueryNode, (node, context) => {
-    return aqlExt.parenthesizeObject((0, aql_1.aql) `INSERT ${processNode(node.objectNode, context)} IN ${getCollectionForType(node.rootEntityType, AccessType.WRITE, context)}`, (0, aql_1.aql) `RETURN NEW._key`);
+    return aqlExt.firstOfSubquery((0, aql_1.aql) `INSERT ${processNode(node.objectNode, context)} IN ${getCollectionForType(node.rootEntityType, AccessType.WRITE, context)}`, (0, aql_1.aql) `RETURN NEW._key`);
 });
 register(query_tree_1.CreateEntitiesQueryNode, (node, context) => {
     const entityVar = aql_1.aql.variable('entity');
-    return aqlExt.parenthesizeList((0, aql_1.aql) `FOR ${entityVar} IN ${processNode(node.objectsNode, context)}`, (0, aql_1.aql) `INSERT ${entityVar} IN ${getCollectionForType(node.rootEntityType, AccessType.WRITE, context)}`, (0, aql_1.aql) `RETURN NEW._key`);
+    return aqlExt.subquery((0, aql_1.aql) `FOR ${entityVar} IN ${processNode(node.objectsNode, context)}`, (0, aql_1.aql) `INSERT ${entityVar} IN ${getCollectionForType(node.rootEntityType, AccessType.WRITE, context)}`, (0, aql_1.aql) `RETURN NEW._key`);
 });
 register(query_tree_1.UpdateEntitiesQueryNode, (node, context) => {
-    const newContext = context.introduceVariable(node.currentEntityVariable);
+    const newContext = context.bindVariable(node.currentEntityVariable);
     const entityVar = newContext.getVariable(node.currentEntityVariable);
     let entityFrag;
     let options;
@@ -1235,7 +1898,7 @@ register(query_tree_1.UpdateEntitiesQueryNode, (node, context) => {
         entityFrag = entityVar;
         options = (0, aql_1.aql) `{ mergeObjects: false }`;
     }
-    return aqlExt.parenthesizeList((0, aql_1.aql) `FOR ${entityVar}`, (0, aql_1.aql) `IN ${processNode(node.listNode, context)}`, (0, aql_1.aql) `UPDATE ${entityFrag}`, (0, aql_1.aql) `WITH ${updateFrag}`, (0, aql_1.aql) `IN ${getCollectionForType(node.rootEntityType, AccessType.WRITE, context)}`, (0, aql_1.aql) `OPTIONS ${options}`, (0, aql_1.aql) `RETURN NEW._key`);
+    return aqlExt.subquery((0, aql_1.aql) `FOR ${entityVar}`, (0, aql_1.aql) `IN ${processNode(node.listNode, context)}`, (0, aql_1.aql) `UPDATE ${entityFrag}`, (0, aql_1.aql) `WITH ${updateFrag}`, (0, aql_1.aql) `IN ${getCollectionForType(node.rootEntityType, AccessType.WRITE, context)}`, (0, aql_1.aql) `OPTIONS ${options}`, (0, aql_1.aql) `RETURN NEW._key`);
 });
 register(query_tree_1.DeleteEntitiesQueryNode, (node, context) => {
     const entityVar = aql_1.aql.variable((0, utils_2.decapitalize)(node.rootEntityType.name));
@@ -1254,16 +1917,24 @@ register(query_tree_1.DeleteEntitiesQueryNode, (node, context) => {
         entityFrag = entityVar;
         optionsFrag = (0, aql_1.aql) ``;
     }
-    const countVar = aql_1.aql.variable(`count`);
-    return aqlExt[node.resultValue === query_tree_1.DeleteEntitiesResultValue.OLD_ENTITIES
-        ? 'parenthesizeList'
-        : 'parenthesizeObject']((0, aql_1.aql) `FOR ${entityVar}`, (0, aql_1.aql) `${generateInClause(node.listNode, context, entityVar)}`, (0, aql_1.aql) `REMOVE ${entityFrag}`, (0, aql_1.aql) `IN ${getCollectionForType(node.rootEntityType, AccessType.WRITE, context)}`, optionsFrag, node.resultValue === query_tree_1.DeleteEntitiesResultValue.OLD_ENTITIES
-        ? (0, aql_1.aql) `RETURN OLD`
-        : aql_1.aql.lines((0, aql_1.aql) `COLLECT WITH COUNT INTO ${countVar}`, (0, aql_1.aql) `RETURN ${countVar}`));
+    const commonFrags = [
+        (0, aql_1.aql) `FOR ${entityVar}`,
+        (0, aql_1.aql) `${generateInClause(node.listNode, context, entityVar)}`,
+        (0, aql_1.aql) `REMOVE ${entityFrag}`,
+        (0, aql_1.aql) `IN ${getCollectionForType(node.rootEntityType, AccessType.WRITE, context)}`,
+        optionsFrag,
+    ];
+    if (node.resultValue === query_tree_1.DeleteEntitiesResultValue.OLD_ENTITIES) {
+        return aqlExt.subquery(...commonFrags, (0, aql_1.aql) `RETURN OLD`);
+    }
+    else {
+        const countVar = aql_1.aql.variable(`count`);
+        return aqlExt.firstOfSubquery(...commonFrags, (0, aql_1.aql) `COLLECT WITH COUNT INTO ${countVar}`, (0, aql_1.aql) `RETURN ${countVar}`);
+    }
 });
 register(query_tree_1.AddEdgesQueryNode, (node, context) => {
     const edgeVar = aql_1.aql.variable('edge');
-    return aqlExt.parenthesizeList((0, aql_1.aql) `FOR ${edgeVar}`, (0, aql_1.aql) `IN [ ${aql_1.aql.join(node.edges.map((edge) => formatEdge(node.relation, edge, context)), (0, aql_1.aql) `, `)} ]`, (0, aql_1.aql) `UPSERT { _from: ${edgeVar}._from, _to: ${edgeVar}._to }`, // need to unpack avoid dynamic property names in UPSERT example filter
+    return aqlExt.subquery((0, aql_1.aql) `FOR ${edgeVar}`, (0, aql_1.aql) `IN [ ${aql_1.aql.join(node.edges.map((edge) => formatEdge(node.relation, edge, context)), (0, aql_1.aql) `, `)} ]`, (0, aql_1.aql) `UPSERT { _from: ${edgeVar}._from, _to: ${edgeVar}._to }`, // need to unpack avoid dynamic property names in UPSERT example filter
     (0, aql_1.aql) `INSERT ${edgeVar}`, (0, aql_1.aql) `UPDATE {}`, (0, aql_1.aql) `IN ${getCollectionForRelation(node.relation, AccessType.WRITE, context)}`);
 });
 register(query_tree_1.RemoveEdgesQueryNode, (node, context) => {
@@ -1283,7 +1954,7 @@ register(query_tree_1.RemoveEdgesQueryNode, (node, context) => {
     else {
         edgeFilter = (0, aql_1.aql) ``;
     }
-    return aqlExt.parenthesizeList(node.edgeFilter.fromIDsNode
+    return aqlExt.subquery(node.edgeFilter.fromIDsNode
         ? (0, aql_1.aql) `FOR ${fromVar} IN ${getFullIDsFromKeysNode(node.edgeFilter.fromIDsNode, node.relation.fromType, context)}`
         : (0, aql_1.aql) ``, node.edgeFilter.toIDsNode
         ? (0, aql_1.aql) `FOR ${toVar} IN ${getFullIDsFromKeysNode(node.edgeFilter.toIDsNode, node.relation.toType, context)}`
@@ -1291,7 +1962,7 @@ register(query_tree_1.RemoveEdgesQueryNode, (node, context) => {
 });
 register(query_tree_1.SetEdgeQueryNode, (node, context) => {
     const edgeVar = aql_1.aql.variable('edge');
-    return aqlExt.parenthesizeList((0, aql_1.aql) `UPSERT ${formatEdge(node.relation, node.existingEdge, context)}`, (0, aql_1.aql) `INSERT ${formatEdge(node.relation, node.newEdge, context)}`, (0, aql_1.aql) `UPDATE ${formatEdge(node.relation, node.newEdge, context)}`, (0, aql_1.aql) `IN ${getCollectionForRelation(node.relation, AccessType.WRITE, context)}`);
+    return aqlExt.subquery((0, aql_1.aql) `UPSERT ${formatEdge(node.relation, node.existingEdge, context)}`, (0, aql_1.aql) `INSERT ${formatEdge(node.relation, node.newEdge, context)}`, (0, aql_1.aql) `UPDATE ${formatEdge(node.relation, node.newEdge, context)}`, (0, aql_1.aql) `IN ${getCollectionForRelation(node.relation, AccessType.WRITE, context)}`);
 });
 /**
  * Gets an aql fragment that evaluates to a string of the format "collectionName/objectKey", given a query node that
@@ -1376,16 +2047,16 @@ function getAQLOperator(op) {
             return undefined;
     }
 }
+function dirAQL(dir) {
+    if (dir == query_tree_1.OrderDirection.DESCENDING) {
+        return (0, aql_1.aql) ` DESC`;
+    }
+    return (0, aql_1.aql) ``;
+}
 function generateSortAQL(orderBy, context) {
     if (orderBy.isUnordered()) {
         return (0, aql_1.aql) ``;
     }
-    function dirAQL(dir) {
-        if (dir == query_tree_1.OrderDirection.DESCENDING) {
-            return (0, aql_1.aql) ` DESC`;
-        }
-        return (0, aql_1.aql) ``;
-    }
     const clauses = orderBy.clauses.map((cl) => (0, aql_1.aql) `(${processNode(cl.valueNode, context)}) ${dirAQL(cl.direction)}`);
     return (0, aql_1.aql) `SORT ${aql_1.aql.join(clauses, (0, aql_1.aql) `, `)}`;
 }