@sap/cds-compiler 2.10.4 → 2.12.0

package/lib/compiler/resolver.js

@@ -47,25 +47,30 @@ const {
 const { dictLocation } = require('../base/location');
 const { searchName, weakLocation } = require('../base/messages');
 const { combinedLocation } = require('../base/location');
-const { pushLink } = require('./utils');
+
+const { kindProperties } = require('./base');
 const {
-  getDefinerFunctions,
+  pushLink,
+  setLink,
+  annotationVal,
   augmentPath,
+  pathName,
   splitIntoPath,
-} = require('./definer');
+  linkToOrigin,
+  setMemberParent,
+  withAssociation,
+  storeExtension,
+  dependsOn,
+  dependsOnSilent,
+} = require('./utils');
 
 const detectCycles = require('./cycle-detector');
 const layers = require('./moduleLayers');
 
-const {
-  kindProperties, fns, setLink, linkToOrigin, setMemberParent, withAssociation, storeExtension,
-  dependsOn, dependsOnSilent,
-} = require('./shared');
-
 const annotationPriorities = {
   define: 1, extend: 2, annotate: 2, edmx: 3,
 };
-
+const $inferred = Symbol.for('cds.$inferred');
 
 // Export function of this file.  Resolve type references in augmented CSN
 // `model`.  If the model has a property argument `messages`, do not throw
@@ -73,21 +78,21 @@ const annotationPriorities = {
 // that property (should be a vector).
 function resolve( model ) {
   const { options } = model;
-  // Get shared "resolve" functionality and the message function:
+  // Get shared functionality and the message function:
+  const {
+    info, warning, error, message,
+  } = model.$messageFunctions;
   const {
     resolvePath,
     resolveTypeArguments,
     defineAnnotations,
     attachAndEmitValidNames,
-  } = fns( model, environment );
-  const {
-    info, warning, error, message,
-  } = model.$messageFunctions;
-  const {
     initArtifact,
     lateExtensions,
     projectionAncestor,
-  } = getDefinerFunctions(model);
+  } = model.$functions;
+  model.$volatileFunctions.environment = environment;
+
   /** @type {any} may also be a boolean */
   let newAutoExposed = [];
 
@@ -242,6 +247,7 @@ function resolve( model ) {
     const chain = [];
     while (art && !('_effectiveType' in art) &&
            (art.type || art._origin || art.value && art.value.path) &&
+           // TODO: really stop at art.enum?
            !art.target && !art.enum && !art.elements && !art.items) {
       chain.push( art );
       setProp( art, '_effectiveType', 0 ); // initial setting in case of cycles
@@ -273,13 +279,17 @@ function resolve( model ) {
       // collect the "latest" cardinality (calculate lazyly if necessary)
       let cardinality = art.cardinality ||
           art._effectiveType && (() => getCardinality( art._effectiveType ));
+      let prev = art;
       for (const a of chain) {
         if (a.cardinality)
           cardinality = a.cardinality;
         if (a.expand && expandFromColumns( a, art, cardinality ) ||
             art.target && redirectImplicitly( a, art ) ||
-            art.elements && expandElements( a, art, eType ))
+            art.elements && expandElements( a, art, eType ) ||
+            art.items && expandItems( a, art, eType ))
           art = a;
+        else if (art.enum && expandEnum( a, prev ))
+          prev = a;             // do not set art - effective type is base
         setProp( a, '_effectiveType', art );
       }
     }
@@ -351,13 +361,13 @@ function resolve( model ) {
       while (struct.kind === 'element')
         struct = struct._parent;
       if (struct.kind === 'select') {
-        message( 'ref-invalid-typeof', [ ref.location, user ],
+        message( 'type-unexpected-typeof', [ ref.location, user ],
                  { keyword: 'type of', '#': struct.kind } );
         // we actually refer to an element in _combined; TODO: return null if
         // not configurable; would produce illegal CSN with sub queries in FROM
       }
       else if (struct !== user._main) {
-        message( 'ref-invalid-typeof', [ ref.location, user ],
+        message( 'type-unexpected-typeof', [ ref.location, user ],
                  { keyword: 'type of', '#': struct.kind } );
         return setProp( ref, '_artifact', null );
       }
@@ -405,7 +415,8 @@ function resolve( model ) {
     for (const view of resolveChain.reverse()) {
       if (view._status !== '_query' ) { // not already resolved
         setProp( view, '_status', '_query' );
-        traverseQueryPost( view.query, false, populateQuery );
+        // must be run in order “sub query in FROM first”:
+        traverseQueryPost( view.query, null, populateQuery );
         if (view.elements$)     // specified elements
           mergeSpecifiedElements( view );
         if (!view.$entity) {
@@ -494,7 +505,8 @@ function resolve( model ) {
         });
       }
       forEachGeneric( { elements: alias.elements }, 'elements', ( elem, name ) => {
-        dictAddArray( query._combined, name, elem, null ); // not dictAdd()
+        if (elem.$duplicates !== true)
+          dictAddArray( query._combined, name, elem, null ); // not dictAdd()
       });
     }
   }
@@ -535,6 +547,23 @@ function resolve( model ) {
     setMemberParent( key, name, elem ); // TODO: set _block here if not present?
   }
 
+  function expandItems( art, origin, eType ) {
+    if (!enableExpandElements || art.items)
+      return false;
+    if (isInParents( art, eType )) {
+      art.items = 0;            // circular
+      return true;
+    }
+    const ref = art.type || art.value || art.name;
+    const location = ref && ref.location || art.location;
+    art.items = { $inferred: 'expand-element', location };
+    setProp( art.items, '_outer', art );
+    setProp( art.items, '_origin', origin.items );
+    if (!art.$expand)
+      art.$expand = 'origin';   // if value stays, elements won't appear in CSN
+    return true;
+  }
+
   function expandElements( art, struct, eType ) {
     if (!enableExpandElements)
       return false;
@@ -566,7 +595,28 @@ function resolve( model ) {
     // member property):
     if (!art.$expand)
       art.$expand = 'origin';   // if value stays, elements won't appear in CSN
-    // TODO: have some art.elements[SYM.$inferred] = 'expand-elements';
+    // TODO: have some art.elements[SYM.$inferred] = 'expand-element';
+    return true;
+  }
+
+  function expandEnum( art, origin ) {
+    if (!enableExpandElements || art.enum)
+      return false;
+    const ref = art.type || art.value || art.name;
+    const location = weakLocation( ref && ref.location || art.location );
+    art.enum = Object.create(null);
+    for (const name in origin.enum) {
+      const orig = origin.enum[name];
+      linkToOrigin( orig, name, art, 'enum', location, true )
+        // or should we use orig.location? - TODO: try to find test to see message
+        .$inferred = 'expand-element';
+    }
+    // Set elements expansion status (the if condition is always true, as no
+    // elements expansion will take place on artifact with existing other
+    // member property):
+    if (!art.$expand)
+      art.$expand = 'origin';   // if value stays, elements won't appear in CSN
+    art.enum[$inferred] = 'expand-element';
     return true;
   }
 
@@ -604,7 +654,7 @@ function resolve( model ) {
   //               not counting propagated ones; set up to the definition (main artifact)
   //               (only set with anno on $inferred elem)
   // Usage according to CSN flavor:
-  // - gensrc: do not render enferred elements (including expanded elements),
+  // - gensrc: do not render inferred elements (including expanded elements),
   //           collect annotate statements with value 'annotate'
   // - client: do not render expanded sub elements if artifact/member is no type, has a type,
   //           has $expand = 'origin', and all its _origin also have $expand = 'origin'
@@ -672,35 +722,69 @@ function resolve( model ) {
       else if (exposed.length === 1) {
         target = exposed[0];
       }
-      else {
-        message( (elem !== assoc ? 'redirected-implicitly-ambiguous' : 'type-ambiguous-target'),
-                 [ (elem.value || elem.name).location, elem ],
+      else if (elem === assoc) {
+        // `assoc: Association to ModelEntity`: user-provided target is to be auto-redirected
+        warning( 'type-ambiguous-target',
+                 [ elem.target.location, elem ],
                  {
                    target,
-                   service,
-                   art: definitionScope( target ),
+                   // art: definitionScope( target ), - TODO extra debug info in message
                    sorted_arts: exposed,
-                   '#': ( elemScope !== true ? 'std' : 'scoped' ),
                  }, {
                    // eslint-disable-next-line max-len
-                   std: 'Target $(TARGET) is exposed in service $(SERVICE) by multiple projections $(SORTED_ARTS) - no implicit redirection',
+                   std: 'Replace target $(TARGET) by one of $(SORTED_ARTS); can\'t auto-redirect this association if multiple projections exist in this service',
                    // eslint-disable-next-line max-len
-                   scoped: 'Target $(TARGET) is defined in scope $(ART) which exposed in service $(SERVICE) by multiple projections - no implicit redirection',
+                   two: 'Replace target $(TARGET) by $(SORTED_ARTS) or $(SECOND); can\'t auto-redirect this association if multiple projections exist in this service',
                  });
+        // continuation semantics: no auto-redirection
+      }
+      else {
+        // referred (and probably inferred) assoc (without a user-provided target at that place)
+        // HINT: consider bin/cdsv2m.js when changing the following message text
+        // No grouped and sub messages yet (TODO v3): mention at all target places with all assocs
+        const withAnno = annotationVal( exposed[0]['@cds.redirection.target'] );
+        for (const proj of exposed) {
+          // TODO: def-ambiguous-target (just v3, as the current is infamous and used in options),
+          message( 'redirected-implicitly-ambiguous',
+                   [ weakLocation( proj.location ), proj ],
+                   {
+                     '#': withAnno && 'justOne',
+                     target,
+                     art: elem,
+                     // art: definitionScope( target ), - TODO extra debug info in message
+                     anno: 'cds.redirection.target',
+                     sorted_arts: exposed,
+                   }, {
+                     // eslint-disable-next-line max-len
+                     std: 'Add $(ANNO) to one of $(SORTED_ARTS) to select the entity as redirection target for $(TARGET) in this service; can\'t auto-redirect $(ART) otherwise',
+                     // eslint-disable-next-line max-len
+                     two: 'Add $(ANNO) to either $(SORTED_ARTS) or $(SECOND) to select the entity as redirection target for $(TARGET) in this service; can\'t auto-redirect $(ART) otherwise',
+                     // eslint-disable-next-line max-len
+                     justOne: 'Remove $(ANNO) from all but one of $(SORTED_ARTS) to have a unique redirection target for $(TARGET) in this service; can\'t auto-redirect $(ART) otherwise',
+                   } );
+        }
         // continuation semantics: no implicit redirections
       }
     }
     if (elem.target) {          // redirection for Association to / Composition of
       if (elem.target._artifact === target) // no change (due to no implicit redirection)
         return true;
+      const type = resolvePath( elem.type, 'type', elem ); // cds.Association or cds.Composition
       const origin = {
-        kind: elem.kind,
+        kind: elem.kind, // necessary for rewrite, '$user-provided' would be best
         name: elem.name,
+        type: {
+          path: [ { id: type.name.absolute, location: elem.type.location } ],
+          scope: 'global',
+          location: elem.type.location,
+        },
         target: elem.target,
         $inferred: 'REDIRECTED',
         location: elem.target.location,
       };
       setLink( elem, origin, '_origin' );
+      setLink( elem.type, type, '_artifact' );
+      setLink( origin, elem, '_outer' );
       setLink( origin, elem._parent, '_parent' );
       if (elem._main)           // remark: the param `elem` can also be a type
         setLink( origin, elem._main, '_main' );
@@ -708,11 +792,11 @@ function resolve( model ) {
       setLink( origin, elem._block, '_block' );
       if (elem.foreignKeys) {
         origin.foreignKeys = elem.foreignKeys;
-        delete elem.foreignKeys;
+        delete elem.foreignKeys; // will be rewritten
       }
       if (elem.on) {
         origin.on = elem.on;
-        delete elem.on;
+        delete elem.on;         // will be rewritten
       }
     }
     elem.target = {
@@ -771,10 +855,7 @@ function resolve( model ) {
                                         target._descendants[service.name.absolute] ||
                                         [],
                                         elemScope, target );
-    const preferred = descendants.filter( ( d ) => {
-      const anno = d['@cds.redirection.target'];
-      return anno && (anno.val === undefined || anno.val );
-    } );
+    const preferred = descendants.filter( d => annotationVal( d['@cds.redirection.target'] ) );
     const exposed = preferred.length ? preferred : descendants;
     if (exposed.length < 2)
       return exposed || [];
@@ -813,7 +894,7 @@ function resolve( model ) {
       // Need to filter out auto-exposed, otherwise the behavior is
       // processing-order dependent (not storing the autoexposed in
       // _descendents would only be an alternative w/o recompilation)
-      return descendants.filter( d => !d['@cds.autoexposed'] );
+      return descendants.filter( d => !annotationVal( d['@cds.autoexposed'] ) );
     }
     // try scope as target first, even if it has @cds.redirection.target: false
     if (isDirectProjection( elemScope, target ))
@@ -944,6 +1025,7 @@ function resolve( model ) {
       $inferred: 'autoexposed',
       '@cds.autoexposed': {
         name: { path: [ { id: 'cds.autoexposed', location } ], location },
+        $inferred: 'autoexposed',
       },
     };
     // TODO: do we need to tag the generated entity with elemScope = 'auto'?
@@ -1027,7 +1109,6 @@ function resolve( model ) {
         // or use userQuery( query ) in the following, too?
         setMemberParent( col, `.${ q.$inlines.length }`, query );
         initFromColumns( query, col.inline, col );
-        continue;
       }
       else if (!col.$replacement) {
         const id = ensureColumnName( col, query );
@@ -1441,8 +1522,9 @@ function resolve( model ) {
     }
     // Resolve projections/views
     // if (art.query)console.log( info( null, [art.query.location,art.query], 'VQ:' ).toString() );
-    // TODO: here, any order should be ok, i.e. just loop over $queries
-    traverseQueryPost( art.query, false, resolveQuery );
+
+    if (art.$queries)
+      art.$queries.forEach( resolveQuery );
 
     if (obj.type || obj._origin || obj.value && obj.value.path || obj.elements) // typed artifacts
       effectiveType(obj);  // set _effectiveType if appropriate, (future?): copy elems if extended
@@ -1520,9 +1602,17 @@ function resolve( model ) {
     }
   }
 
-  function annotateMembers( art, extensions = [], prop, name, parent, kind ) {
+  /**
+   * @param {XSN.Artifact} art
+   * @param {XSN.Extension[]} [extensions]
+   * @param {string} [prop]
+   * @param {string} [name]
+   * @param {object} [parent]
+   * @param {string} [kind]
+   */
+  function annotateMembers( art, extensions, prop, name, parent, kind ) {
     const showMsg = !art && parent && parent.kind !== 'annotate';
-    if (!art && extensions.length) {
+    if (!art && extensions && extensions.length) {
       if (Array.isArray( parent ))
         return;
       const parentExt = extensionFor(parent);
@@ -1538,7 +1628,7 @@ function resolve( model ) {
       }
     }
 
-    for (const ext of extensions) {
+    for (const ext of extensions || []) {
       if ('_artifact' in ext.name) // already applied
         continue;
       setProp( ext.name, '_artifact', art );
@@ -1658,6 +1748,8 @@ function resolve( model ) {
           location,
           $inferred: 'expand-param',
         };
+        setProp( art.returns, '_parent', art );
+        setProp( art.returns, '_main', art._main || art );
         setProp( art.returns, '_origin', origin.returns );
       }
     }
@@ -1765,7 +1857,7 @@ function resolve( model ) {
                          [ mergeSource.name.location, art ], { code: '...' } );
                   return;
                 }
-                mergeTarget.val.splice(pos, 1, ...mergeSource.val);
+                mergeTarget.val = mergeArrayValues( mergeSource.val, mergeTarget.val );
               }
             }
           });
@@ -1785,7 +1877,7 @@ function resolve( model ) {
                    [ mergeSource.name.location, art ], { code: '...' } );
             return mergeTarget;
           }
-          mergeTarget.val.splice(pos, 1, ...mergeSource.val);
+          mergeTarget.val = mergeArrayValues( mergeSource.val, mergeTarget.val );
           layer = layers.layer( mergeSource._block );
           delete layerAnnos[(layer) ? layer.realname : ''];
           pos = findEllipsis( mergeTarget );
@@ -1796,6 +1888,89 @@ function resolve( model ) {
       return mergeTarget;
     }
 
+    function mergeArrayValues( previousValue, arraySpec ) {
+      let prevPos = 0;
+      const result = [];
+      for (const item of arraySpec) {
+        const ell = item && item.literal === 'token' && item.val === '...';
+        if (!ell) {
+          result.push( item );
+        }
+        else {
+          let upToSpec = item.upTo && checkUpToSpec( item.upTo, true );
+          while (prevPos < previousValue.length) {
+            const prevItem = previousValue[prevPos++];
+            result.push( prevItem );
+            if (upToSpec && prevItem && equalUpTo( prevItem, item.upTo)) {
+              upToSpec = false;
+              break;
+            }
+          }
+          if (upToSpec) {       // non-matched UP TO
+            warning( null, [ item.upTo.location, art ], { anno: annoName, code: '... up to' },
+                     'The $(CODE) value does not match any item in the base annotation $(ANNO)' );
+          }
+        }
+      }
+      return result;
+    }
+
+    function checkUpToSpec( upToSpec, trueIfFullUpTo ) {
+      const { literal } = upToSpec;
+      if (trueIfFullUpTo !== true) { // inside struct of UP TO
+        if (![ 'struct', 'array' ].includes( literal ))
+          return true;
+      }
+      else if (literal === 'struct') {
+        return Object.values( upToSpec.struct ).every( checkUpToSpec );
+      }
+      else if (![ 'array', 'boolean', 'null' ].includes( literal )) {
+        return true;
+      }
+      error( null, [ upToSpec.location, art ],
+             { anno: annoName, code: '... up to', '#': literal },
+             {
+               std: 'Unexpected $(CODE) value type in the assignment of $(ANNO)',
+               array: 'Unexpected array as $(CODE) value in the assignment of $(ANNO)',
+               // eslint-disable-next-line max-len
+               struct: 'Unexpected structure as $(CODE) structure property value in the assignment of $(ANNO)',
+               boolean: 'Unexpected boolean as $(CODE) value in the assignment of $(ANNO)',
+               null: 'Unexpected null as $(CODE) value in the assignment of $(ANNO)',
+             } );
+      return false;
+    }
+
+    function equalUpTo( previousItem, upToSpec ) {
+      if (!previousItem)
+        return false;
+      if ('val' in upToSpec) {
+        if (previousItem.val === upToSpec.val) // enum, struct and ref have no val
+          return true;
+        const typeUpTo = typeof upToSpec.val;
+        const typePrev = typeof previousItem.val;
+        if (typeUpTo === 'number')
+          return typePrev === 'string' && previousItem.val === upToSpec.val.toString();
+        if (typePrev === 'number')
+          return typeUpTo === 'string' && upToSpec.val === previousItem.val.toString();
+      }
+      else if (upToSpec.path) {
+        return previousItem.path && normalizeRef( previousItem ) === normalizeRef( upToSpec );
+      }
+      else if (upToSpec.sym) {
+        return previousItem.sym && previousItem.sym.id === upToSpec.sym.id;
+      }
+      else if (upToSpec.struct && previousItem.struct) {
+        return Object.entries( upToSpec.struct )
+          .every( ([ n, v ]) => equalUpTo( previousItem.struct[n], v ) );
+      }
+      return false;
+    }
+
+    function normalizeRef( node ) { // see to-csn.js
+      const ref = pathName( node.path );
+      return node.variant ? `${ ref }#${ node.variant.id }` : ref;
+    }
+
     function removeEllipsis(a, pos = findEllipsis( a )) {
       let count = 0;
       while (a.literal === 'array' && pos > -1) {
@@ -1868,7 +2043,7 @@ function resolve( model ) {
   function resolveQuery( query ) {
     if (!query._main)           // parse error
       return;
-    populateQuery( query );
+    traverseQueryPost( query, null, populateQuery );
     forEachGeneric( query, '$tableAliases', ( alias ) => {
       // console.log( info( null, [alias.location,alias], 'SQA:' ).toString() );
       if (alias.kind === 'mixin')
@@ -2009,6 +2184,7 @@ function resolve( model ) {
         dependsOnSilent(art, key);
       }
     });
+    obj.foreignKeys[$inferred] = 'keys';
   }
 
   function addForeignKeyNavigations( art ) {
@@ -2177,8 +2353,6 @@ function resolve( model ) {
   // Only top-level queries and sub queries in FROM
 
   function rewriteSimple( art ) {
-    // If we have a proper seperation of view elements and elements of the
-    // primary query, we can delete this function.
     // return;
     if (!art.includes && !art.query) {
       // console.log(message( null, art.location, art, {target:art._target},
@@ -2191,7 +2365,7 @@ function resolve( model ) {
   }
 
   function rewriteView( view ) {
-    traverseQueryPost( view.query, false, ( query ) => {
+    traverseQueryExtra( view, ( query ) => {
       forEachGeneric( query, 'elements', rewriteAssociation );
     } );
     if (view.includes)          // entities with structure includes:
@@ -2199,6 +2373,7 @@ function resolve( model ) {
   }
 
   // Check explicit ON / keys with REDIRECTED TO
+  // TODO: run on all queries, but this is potentially incompatible
   function rewriteViewCheck( view ) {
     traverseQueryPost( view.query, false, ( query ) => {
       forEachGeneric( query, 'elements', rewriteAssociationCheck );
@@ -2424,7 +2599,7 @@ function resolve( model ) {
       resolveExpr( cond, rewriteExpr, elem, nav.tableAlias );
     }
     else {
-      // TODO: support that
+      // TODO: support that, now that the ON condition is rewritten in the right order
       error( null, [ elem.value.location, elem ],
              'Selecting unmanaged associations from a sub query is not supported' );
     }
@@ -2593,6 +2768,8 @@ function resolve( model ) {
   }
 
   function resolveExpr( expr, expected, user, extDict, expandOrInline) {
+    // TODO: when we have rewritten the resolvePath functions,
+    // define a traverseExpr() in ./utils.js
     // TODO: extra "expected" 'expand'/'inline' instead o param `expandOrInline`
     if (!expr || typeof expr === 'string') // parse error or keywords in {xpr:...}
       return;
@@ -2629,7 +2806,7 @@ function resolve( model ) {
     else if (expr.query) {
       const { query } = expr;
       if (query.kind || query._leadingQuery) { // UNION has _leadingQuery
-        traverseQueryPost( query, false, resolveQuery );
+        // traverseQueryPost( query, false, resolveQuery );
       }
       else {
         error( 'expr-no-subquery', [ expr.location, user ], {},
@@ -2640,9 +2817,10 @@ function resolve( model ) {
       const args = Array.isArray(expr.args) ? expr.args : Object.values( expr.args );
       args.forEach( e => e && resolveExpr( e, e.$expected || expected, user, extDict ) );
     }
-    if (expr.suffix && !isBetaEnabled( options, 'windowFunctions' )) {
+    if (expr.suffix && isDeprecatedEnabled( options )) {
       const { location } = expr.suffix[0] || expr;
-      error( null, [ location, user ], 'Window functions are not supported' );
+      error( null, [ location, user ], { prop: 'deprecated' },
+             'Window functions are not supported if $(PROP) options are set' );
     }
     if (expr.suffix)
       expr.suffix.forEach( s => s && resolveExpr( s, expected, user, extDict ) );
@@ -2827,11 +3005,11 @@ function navProjection( navigation, preferred ) {
     : navigation._projections[0] || null;
 }
 
-// Query tree post-order traversal - called for everything which makes a query
+// Query tree post-order traversal - called for everything which contributes to the query
+// i.e. is necessary to calculate the elements of the query
 // except "real ones": operands of UNION etc, JOIN with ON, and sub queries in FROM
+// NOTE: does not run on non-referred sub queries!  Consider using ‹main›.$queries instead!
 function traverseQueryPost( query, simpleOnly, callback ) {
-  while (Array.isArray(query)) // query in parentheses, TODO: remove
-    query = query[0];
   if (!query)                   // parser error
     return;
   if (!query.op) {              // in FROM (not JOIN)
@@ -2851,13 +3029,51 @@ function traverseQueryPost( query, simpleOnly, callback ) {
     // console.log('FE:')
   }
   else if (query.args) {             // JOIN, UNION, INTERSECT
-    for (const q of query.args)
-      traverseQueryPost( q, simpleOnly, callback );
-    // The ON condition has to be traversed extra, because it must be evaluated
-    // after the complete FROM has been traversed.  It is also not necessary to
-    // evaluate it in populateQuery().
+    if (!query.join && simpleOnly == null) {
+      // enough for elements: traverse only first args for UNION/INTERSECT
+      // TODO: we might use this also when we do not rewrite associations
+      // in non-referred sub queries
+      traverseQueryPost( query.args[0], simpleOnly, callback );
+    }
+    else {
+      for (const q of query.args)
+        traverseQueryPost( q, simpleOnly, callback );
+      // The ON condition has to be traversed extra, because it must be evaluated
+      // after the complete FROM has been traversed.  It is also not necessary to
+      // evaluate it in populateQuery().
+    }
   }
   // else: with parse error (`select from <EOF>`, `select distinct from;`)
 }
 
+// Call callback on all queries in dependency order, i.e. starting with query Q
+// 1. sub queries in FROM sources of Q
+// 2. Q itself, except if non-referred query, but with right UNION parts
+// 3. sub queries in ON in FROM of Q
+// 4. sub queries in columns, WHERE, HAVING
+function traverseQueryExtra( main, callback ) {
+  if (!main.$queries)
+    return;
+  // with a top-level UNION, $queries[0] is just the left
+  traverseQueryPost( main.query, false, (q) => { // also with right of UNION (to be compatible)
+    setProp( q, '_status', 'extra' );
+    callback( q );
+  } );
+  for (const query of main.$queries.slice(1)) {
+    if (query._status === 'extra' || query._parent.kind === '$tableAlias')
+      continue; // if parent is alias, query is FROM source -> run by traverseQueryPost
+    // we are now in the top-level (parent is entity) or a non-referred query (parent is query)
+    setProp( query, '_status', 'extra' ); // do not call callback() in non-referred query
+    // console.log( 'A:', query.name,query._status)
+    traverseQueryPost( query, null, (q) => {
+      if (q._status !== 'extra') {
+        // console.log( 'T:', q.name)
+        setProp( q, '_status', 'extra' );
+        callback( q );
+      }
+      // else console.log( 'E:', q.name)
+    } );
+  }
+}
+
 module.exports = resolve;