@sap/cds-compiler 6.3.6 → 6.4.6

package/lib/model/csnRefs.js

@@ -170,26 +170,46 @@
 //   any reference in the entity is inspected: with data for the query
 //   hierarchy, query number, table aliases and links from a column to its
 //   respective inferred element.
-// - TODO: some `name` property would also be useful (set with `initDefinition`)
 
-// Properties in cache:
+// Property name convention in cache:
 //
-// - _effectiveType on def/member/items: cached result of effectiveType()
-// - _origin on def/member/items: the "prototype"
-// - $origin on def/member/items: whether implicit _origin refs have been set for direct members
-// - _parent: currently just use to allow ref to `up_` in anonymous aspect
-//   for managed compositions;
-//   in queries always the main artifact (see `$next` for name resolution)
-// - _env on non-string path item: environment provided by the ref so far,
-//    next path item is element in it
-// - _ref on non-string `type` or `from` ref, or on alias: the referred def/elem
+// - $PropName: to other cache object (with proto), dictionary (w/o proto), or scalar
+// - _PropName, PropName: to CSN object value or dictionary of CSN node (_PropName),
+//    or CSN dictionary (PropName)
+
+// Property `_parent` in cache set with initDefinition() is set for members:
 //
-// - $queries on def: array of all queries of an entity
+// - for an action, param or element: the node containing the dictionary of …,
+//   → elements of the leading/other query have main/query as _parent
+// - for a `returns`/`items` or anonymous `target`/`targetAspect`: the node containing
+//   the object (remark: in XSN, the _parent link of elements/items in items differs)
+// - for any query: use main as _parent
+// - for a mixin or table alias: use query select as _parent
+// - for a column: TODO
+
+// Additional properties in cache set with initDefinition():
+//
+// - $name: name for a main artifact (in `definitions`) or a column
+// - _keys: the foreign keys as dictionary
+// - $origin$step: for Univeral CSN (TODO: describe further)
+// - $queries on def: array of caches for all queryies, null in anonymous aspects
 // - $queryNumber: the index position +1 of a query inside the $queries array
-// - $aliases on query: dictionary of alias names to cache with _ref/_select and elements
-// - _select: value of the `SELECT` property of a query (or value of `projection`)
+// - _select: value of the `SELECT` or `projection` property of a query
 // - elements: the elements of the query (original CSN elements from query or main)
+// - $next: the “upper” query cache, used when searching for a table alias
+// - $aliases: dictionary of caches for table aliases
+//   (currently not stored as cache of table alias, has _ref/_select and elements)
 // - _element on query column: the corresponding element
+// - _column on element of a query entity: the column “creating” it
+
+// Other properties set on-demand:
+//
+// - _ref on object with a `ref` property: cached return value of artifactRef{,.from}
+// - _env on non-string path item: environment provided by the ref so far,
+//    next path item is element in it
+// - _effectiveType on def/member/items: cached result of effectiveType()
+// - _origin on def/member/items: the "prototype" (via type or relevant ref)
+
 
 'use strict';
 
@@ -250,7 +270,7 @@ function csnRefs( csn, universalReady ) {
   // const { definitions } = csn;
   const cache = new WeakMap();
   setCache( BUILTIN_TYPE, '_origin', null );
-  if (universalReady === 'init-all')
+  if (universalReady === 'init-all') // TODO: remove
     initAllDefinitions();
 
   // Functions which set the new `baseEnv`:
@@ -263,79 +283,241 @@ function csnRefs( csn, universalReady ) {
       return getCache( pathItem, '_env' );
     } );
   };
-  artifactRef.from = fromArtifactRef;
+  artifactRef.from = artifactRefFrom;
   return {
+    // init and drop caches: ----------------------------------------------------
+    initAllDefinitions,         // TODO: delete
+    initDefinition,
+    dropDefinitionCache,
+    // artifact references, effective type, and origin: -------------------------
+    artifactRef,                // with prop `from`, see above
     effectiveType,
-    artifactRef,
-    getOrigin,
-    queryForElements,
+    getOrigin: art => cached( art, '_origin', getOriginRaw ),
+    // the main API function: ---------------------------------------------------
     inspectRef,
-    queryOrMain,
+    // file and semantic location for CSN path: ---------------------------------
+    msgLocations,
+    // small cache functions ----------------------------------------------------
     getColumn: elem => getCache( elem, '_column' ),
     getElement: col => getCache( col, '_element' ),
     /** Returns the column's name; either explicit, implicit or internal one. */
-    getColumnName: col => getCache( col, '$as' ),
+    getColumnName: col => getCache( col, '$name' ),
+    /** Return the query cache (with `elements`) for the query. */
+    queryForElements: query => query && cache.get( query.projection || query ),
     $getQueries: def => getCache( def, '$queries' ), // unstable API
-    initDefinition,
-    initAllDefinitions,
-    dropDefinitionCache,
-    targetAspect,
-    msgLocations,
     __getCache_forEnrichCsnDebugging: obj => cache.get( obj ),
+    // functions which we could return top-level: -------------------------------
+    targetAspect,
+    queryOrMain,
   };
 
+  // Init and drop caches: ------------------------------------------------------
+
+  function initAllDefinitions() { // TODO: delete
+    for (const name of Object.keys( csn.definitions || {}))
+      initDefinition( name );
+  }
+
   /**
-   * Return the type relevant for name resolution, i.e. the object which has a
-   * `target`, `elements`, `enum` property, or no `type` property.
-   * (This function could be simplified if we would use JS prototypes for type refs.)
+   * Initialize the cache for the definition named `main` and all its members,
+   * including queries and embedded anonymous aspects.
    *
-   * @param {CSN.ArtifactWithRefs} art
+   * Return the initialized artifact.
    */
-  function effectiveType( art ) {
-    const cachedType = getCache( art, '_effectiveType' );
-    if (cachedType !== undefined)
-      return cachedType;
+  function initDefinition( main ) {
+    const name = typeof main === 'string' && main;
+    if (name) {
+      main = csn.definitions[name];
+      setCache( main, '$name', name );
+    }
+    // TODO: some --test-mode check that the argument is in ‹csn›.definitions ?
+    if (!main || getCache( main, '$queries' ) !== undefined) // already computed
+      return main;
 
-    const chain = [];
-    let origin;
-    while (getCache( art, '_effectiveType' ) === undefined &&
-           (origin = cached( art, '_origin', getOriginRaw )) &&
-           !art.elements && !art.target && !art.targetAspect && !art.enum && !art.items) {
-      chain.push( art );
-      setCache( art, '_effectiveType', 0 ); // initial setting in case of cycles
-      art = origin;
+    traverseDef( main, null, null, null, initNode );
+    const queries = cached( main, '$queries', allQueries );
+    for (const qcache of queries || []) {
+      const { _select } = qcache;
+      const { elements } = _select;
+      if (elements) {
+        for (const n of Object.keys( elements ))
+          traverseDef( elements[n], _select, n, 'element', initNode );
+      }
+      if (_select.mixin) {
+        for (const n of Object.keys( _select.mixin ))
+          setCache( _select.mixin[n], '_parent', _select ); // relevant initNode() part
+      }
     }
-    if (!chain.length)
-      return setCache( art, '_effectiveType', art );
+    return main;
+  }
 
-    if (getCache( art, '_effectiveType' ) === 0)
-      throw new ModelError( 'Circular type reference');
-    const type = getCache( art, '_effectiveType' ) || art;
-    chain.forEach( a => setCache( a, '_effectiveType', type ) );
-    return type;
+  function initNode( art, parent, name, kind ) {
+    setCache( art, '_parent', parent );
+    if (art.keys)            // TODO: what about managed w/o keys in Univeral CSN?
+      setCache( art, '_keys', getKeysDict( art ) );
+    if (kind === 'target') {
+      // Prevent re-initialization of anonymous aspect with initDefinition():
+      // (that would be with parent: null which would be wrong)
+      setCache( art, '$queries', null );
+      return;
+    }
+    if (art.type || !kind)      // with type, top-level, query or mixin
+      return;
+    const { $origin } = art;
+    if (typeof $origin === 'object') // null, […], {…}
+      return;
+    const step = $origin || name;
+    if (parent.$origin ||
+        parent.type && kind !== 'enum' && parent.$origin !== null ||
+        getCache( parent, '$origin$step' ))
+      setCache( art, '$origin$step', (kind === 'element' ? step : { [kind]: step }) );
   }
 
   /**
-   * @param {CSN.Artifact} art
+   * Get the array of all (sub-)queries (value of the `SELECT`/`projection`
+   * property) inside the given `main` artifact (of `main.query`).
+   *
+   * @param {CSN.Definition} main
+   * @returns {CSN.Query[]}
    */
-  function navigationEnv( art, staticAssoc ) {
-    let env = effectiveType( art );
-    // here, we do not care whether it is semantically ok to navigate into sub
-    // elements of array items (that is the task of the core compiler /
-    // semantic check)
-    while (env.items)
-      env = effectiveType( env.items );
-    if (env.elements)           // shortcut
-      return env;
-    const target = (staticAssoc ? targetAspect( env ) : env.target || env.targetAspect);
-    if (typeof target !== 'string')
-      return target || env;
-    return initDefinition( target );
+  function allQueries( main ) {
+    const all = [];
+    const projection = main.query || main.projection && main;
+    if (!projection)
+      return null;
+    traverseQuery( projection, null, null, function memorize( query, fromSelect, parentQuery ) {
+      if (query.ref) {          // ref in from
+        // console.log('SQ:',query,cache.get(query))
+        const as = query.as || implicitAs( query.ref );
+        const _ref = artifactRefFrom( query );
+        // TODO: really eval from refs here and not on-demand?
+        // if not, just have this (w/o elements) as cache elem on the CSN node
+        getCache( fromSelect, '$aliases' )[as] = { _ref, elements: _ref.elements, _parent: query };
+      }
+      else {
+        const qcache = getQueryCache( parentQuery );
+        if (query !== main)
+          cache.set( query, qcache );
+
+        if (fromSelect) {
+          const $queryNumber = all.length + 1;
+          const alias = query.as || `$_select_${ $queryNumber }__`;
+          getCache( fromSelect, '$aliases' )[alias] = qcache;
+        }
+
+        const select = query.SELECT || query.projection;
+        if (select) {
+          cache.set( select, qcache ); // query and query.SELECT have the same cache qcache
+          qcache._select = select;
+          qcache._parent = main;
+          all.push( qcache );
+        }
+      }
+    } );
+    all.forEach( function initElements( qcache, index ) {
+      qcache._parent = main;
+      qcache.$queryNumber = index + 1;
+      const { elements } = (index ? qcache._select : main);
+      qcache.elements = elements;
+      const { columns } = qcache._select;
+      if (elements && columns)
+        columns.map( (col, colIndex) => initColumnElement( col, colIndex, qcache ) );
+      else if (columns && !elements)
+        throw new ModelError( `Query elements not available: ${ Object.keys( (index ? qcache._select : main) ).join('+') }`);
+    } );
+    return all;
+  }
+
+  /**
+   * Return the cache object for a new query.
+   * Might re-use cache object with the `parentQuery`, or use `parentQuery`
+   * for link to next lexical environment.
+   */
+
+  function getQueryCache( parentQuery ) {
+    if (!parentQuery)
+      return { $aliases: Object.create(null) };
+    const pcache = cache.get( parentQuery.projection || parentQuery );
+    if (!parentQuery.SET)       // SELECT / projection: real sub query
+      return { $aliases: Object.create(null), $next: pcache };
+    // the parent query is a SET: that is not a sub query
+    // (works, as no sub queries are allowed in ORDER BY)
+    return (!pcache._select)    // no leading query yet
+      ? pcache                  // share cache with parent query
+      : { $aliases: Object.create(null), $next: pcache.$next };
+  }
+
+  /**
+   * TODO: comment
+   *
+   * In the OData backend, the sub elements from a column with expand might
+   * have been “externalized” into a named type. No backward `_column` link
+   * from the (now the type) element is possible this way, of course...
+   */
+  function initColumnElement( col, colIndex, parentElementOrQueryCache, externalElements ) {
+    if (col === '*')
+      return;
+    if (col.inline) {
+      col.inline.map( c => initColumnElement( c, null, parentElementOrQueryCache, externalElements ) );
+      return;
+    }
+    setCache( col, '_parent',   // not set for query (has property _select)
+              !parentElementOrQueryCache._select && parentElementOrQueryCache );
+    // TODO: why set _parent suddently to a cache and not the SELECT?
+    let as = columnAlias( col );
+    if (!as && colIndex !== null)
+      as = `$_column_${ colIndex + 1 }`;
+    setCache( col, '$name', as );
+    let type = parentElementOrQueryCache;
+    if (col.cast)
+      traverseType( col.cast, col, colIndex, 'column', initNode );
+
+    while (type.items)
+      type = type.items;
+    if (!type.elements) {
+      // in OData backend, the sub elements from a column with expand might have
+      // been “externalized” into a named type.  No backward _column link is
+      // possible this way, of course...
+      type = artifactRef( type.type );
+      externalElements = true;
+    }
+    const elem = setCache( col, '_element', type.elements[as] );
+    if (elem && !externalElements) // TODO to.sql: something is strange if `elem` is not set
+      setCache( elem, '_column', col );
+    if (col.expand)
+      col.expand.map( c => initColumnElement( c, null, elem, externalElements ) );
+  }
+
+  function dropDefinitionCache( main ) {
+    const queries = getCache( main, '$queries' );
+    if (!queries)               // not yet initialized
+      return;
+    if (!cache.delete( main ))  // not yet initialized
+      return;
+    for (const qcache of queries || []) {
+      const { _select } = qcache;
+      for (const n of Object.keys( _select.mixin || {} ))
+        cache.delete( _select.mixin[n] );
+      dropColumnsCache( _select.columns );
+      traverseDef( _select, null, null, null, a => cache.delete( a ) ); // elements
+    }
+    traverseDef( main, null, null, null, a => cache.delete( a ) );
+  }
+
+  function dropColumnsCache( select ) {
+    if (!select)
+      return;
+    for (const col of select.columns || select.expand || select.inline || []) {
+      dropColumnsCache( col );
+      cache.delete( select );
+    }
   }
 
+  // Artifact references, effective type, and origin: ---------------------------
+
   /**
    * Return the object pointing to by the artifact reference (in 'type',
-   * 'includes', 'target', raw 'from').
+   * 'includes', 'target').  For `from`, use artifactRefFrom()!
    *
    * @param {CSN.ArtifactReferencePath|string} ref
    * @param {any} [notFound] Value that is returned in case the artifact reference
@@ -362,12 +544,11 @@ function csnRefs( csn, universalReady ) {
     throw new ModelError( `Unknown artifact reference: ${ typeof ref !== 'string' ? JSON.stringify(ref.ref) : ref }` );
   }
 
-  function fromArtifactRef( ref ) {
-    // do not cache while there is second param
-    const art = artifactFromRef( ref );
+  function artifactRefFrom( ref ) {
+    const art = cached( ref, '_ref', r => navigationEnv( artifactPathRef( r ) ) );
     if (art)
       return art;
-    throw new ModelError( `Unknown artifact reference: ${ typeof ref !== 'string' ? JSON.stringify(ref.ref) : ref }` );
+    throw new ModelError( `Unknown artifact reference: ${ JSON.stringify(ref.ref) }` );
   }
 
   function artifactPathRef( ref ) {
@@ -380,35 +561,53 @@ function csnRefs( csn, universalReady ) {
     return art;
   }
 
-  function artifactFromRef( ref, noLast ) {
-    const [ head, ...tail ] = ref.ref;
-    let art = initDefinition( pathId( head ) );
-    for (const elem of tail) {
-      const env = navigationEnv( art );
-      art = env.elements[pathId( elem )];
-    }
-    if (noLast)                 // TODO: delete that param
-      return art;
-    return navigationEnv( art );
+  /**
+   * @param {CSN.Artifact} art
+   */
+  function navigationEnv( art, staticAssoc ) {
+    let env = effectiveType( art );
+    // here, we do not care whether it is semantically ok to navigate into sub
+    // elements of array items (that is the task of the core compiler /
+    // semantic check)
+    while (env.items)
+      env = effectiveType( env.items );
+    if (env.elements)           // shortcut
+      return env;
+    const target = (staticAssoc ? targetAspect( env ) : env.target || env.targetAspect);
+    if (typeof target !== 'string')
+      return target || env;
+    return initDefinition( target );
   }
 
-  // Return target when resolving references in 'keys'
-  function assocTarget( art, refCtx ) {
-    // Call contexts:
-    // 1. normal definition of association with explicit foreign keys
-    // 2. auto-redirected association with renaming of foreign keys
-    //    (currently: `keys` always available on inherited associations)
-    // 3. user-induced redirection (in 'cast') with explicit foreign keys
-    // 4. original provided association def inside $origin with explicit foreign keys
-    //    (outside $origin like 2)
-    const targetName = refCtx !== 'keys_origin' && art.target ||
-                    art.$origin && art.$origin.target ||
-                    art.cast.target;
-    return initDefinition( targetName );
-  }
+  /**
+   * Return the type relevant for name resolution, i.e. the object which has a
+   * `target`, `elements`, `enum` property, or no `type` property.
+   * (This function could be simplified if we would use JS prototypes for type refs.)
+   *
+   * @param {CSN.ArtifactWithRefs} art
+   */
+  function effectiveType( art ) {
+    const cachedType = getCache( art, '_effectiveType' );
+    if (cachedType !== undefined)
+      return cachedType;
+
+    const chain = [];
+    let origin;
+    while (getCache( art, '_effectiveType' ) === undefined &&
+           (origin = cached( art, '_origin', getOriginRaw )) &&
+           !art.elements && !art.target && !art.targetAspect && !art.enum && !art.items) {
+      chain.push( art );
+      setCache( art, '_effectiveType', 0 ); // initial setting in case of cycles
+      art = origin;
+    }
+    if (!chain.length)
+      return setCache( art, '_effectiveType', art );
 
-  function getOrigin( art ) {
-    return cached( art, '_origin', getOriginRaw );
+    if (getCache( art, '_effectiveType' ) === 0)
+      throw new ModelError( 'Circular type reference');
+    const type = getCache( art, '_effectiveType' ) || art;
+    chain.forEach( a => setCache( a, '_effectiveType', type ) );
+    return type;
   }
 
   function getOriginRaw( art ) {
@@ -435,6 +634,16 @@ function csnRefs( csn, universalReady ) {
     return originNavigation( origin, step );
   }
 
+  function boundActionOrMain( art ) {
+    while (art.kind !== 'action' && art.kind !== 'function') {
+      const p = getCache( art, '_parent' );
+      if (!p)
+        return art;
+      art = p;
+    }
+    return art;
+  }
+
   function getOriginExplicit( $origin ) { // null, […], {…}
     if (!$origin)
       return null;
@@ -455,117 +664,28 @@ function csnRefs( csn, universalReady ) {
       return navigationEnv( art, true ).elements[step];
 
     if (step.action)
-      return effectiveArtFor( art, 'actions' )[step.action];
+      return effectiveArtifactFor( art, 'actions' )[step.action];
     if (step.param)
-      return effectiveArtFor( art, 'params' )[step.param];
+      return effectiveArtifactFor( art, 'params' )[step.param];
     if (step.returns)
-      return effectiveArtFor( art, 'returns' );
+      return effectiveArtifactFor( art, 'returns' );
     if (step.enum)
       return navigationEnv( art, true ).enum[step.enum];
     if (step.items)
       return effectiveType( art ).items;
     if (step.target)
       return targetAspect( effectiveType( art ) );
-    throw new CompilerAssertion( `Illegal navigation step ${ Object.keys(step)[0] }` );
+    const [ prop, val ] = Object.entries( step )[0];
+    throw new CompilerAssertion( `Illegal navigation step {${ prop }: "${ val }"}` );
   }
 
-  function effectiveArtFor( art, property ) {
+  function effectiveArtifactFor( art, property ) {
     while (!art[property])
-      art = getOrigin( art );
+      art = cached( art, '_origin', getOriginRaw );
     return art[property];
   }
 
-  function boundActionOrMain( art ) {
-    while (art.kind !== 'action' && art.kind !== 'function') {
-      const p = getCache( art, '_parent' );
-      if (!p)
-        return art;
-      art = p;
-    }
-    return art;
-  }
-
-  function queryForElements( query ) {
-    return query && cache.get( query.projection || query );
-  }
-
-  function initAllDefinitions() {
-    for (const name of Object.keys( csn.definitions || {}))
-      initDefinition( name );
-  }
-
-  function initDefinition( main ) {
-    const name = typeof main === 'string' && main;
-    if (name) {
-      main = csn.definitions[name];
-      setCache( main, '$name', name );
-    }
-    // TODO: some --test-mode check that the argument is in ‹csn›.definitions ?
-    if (!main || getCache( main, '$queries' ) !== undefined) // already computed
-      return main;
-    traverseDef( main, null, null, null, initNode );
-    const queries = cached( main, '$queries', allQueries );
-    for (const qcache of queries || []) {
-      const { _select } = qcache;
-      const { elements } = _select;
-      if (elements) {
-        for (const n of Object.keys( elements ))
-          traverseDef( elements[n], _select, 'element', n, initNode );
-      }
-      if (_select.mixin) {
-        for (const n of Object.keys( _select.mixin ))
-          setCache( _select.mixin[n], '_parent', _select ); // relevant initNode() part
-      }
-    }
-    return main;
-  }
-
-  function initNode( art, parent, kind, name ) {
-    setCache( art, '_parent', parent );
-    if (art.keys)
-      setCache(art, '_keys', getKeysDict( art ));
-    if (kind === 'target') {
-      // Prevent re-initialization of anonymous aspect with initDefinition():
-      // (that would be with parent: null which would be wrong)
-      setCache( art, '$queries', null );
-      return;
-    }
-    if (art.type || !kind)      // with type, top-level, query or mixin
-      return;
-    const { $origin } = art;
-    if (typeof $origin === 'object') // null, […], {…}
-      return;
-    const step = $origin || name;
-    if (parent.$origin ||
-        parent.type && kind !== 'enum' && parent.$origin !== null ||
-        getCache( parent, '$origin$step' ))
-      setCache( art, '$origin$step', (kind === 'element' ? step : { [kind]: step }) );
-  }
-
-  function dropDefinitionCache( main ) {
-    const queries = getCache( main, '$queries' );
-    if (!queries)               // not yet initialized
-      return;
-    if (!cache.delete( main ))  // not yet initialized
-      return;
-    for (const qcache of queries || []) {
-      const { _select } = qcache;
-      for (const n of Object.keys( _select.mixin || {} ))
-        cache.delete( _select.mixin[n] );
-      dropColumnsCache( _select.columns );
-      traverseDef( _select, null, null, null, a => cache.delete( a ) ); // elements
-    }
-    traverseDef( main, null, null, null, a => cache.delete( a ) );
-  }
-
-  function dropColumnsCache( select ) {
-    if (!select)
-      return;
-    for (const col of select.columns || select.expand || select.inline || []) {
-      dropColumnsCache( col );
-      cache.delete( select );
-    }
-  }
+  // ----------------------------------------------------------------------------
 
   /**
    * @param {CSN.Path} csnPath
@@ -663,12 +783,10 @@ function csnRefs( csn, universalReady ) {
           return resolvePath( path, elemParent.elements[head], null, 'query' );
       }
       if (!query) {                // outside queries - TODO: items?
-        let art = parent.elements?.[head];
-        if (parent.keys) {
-          const keysDict = getCache( parent, '_keys' );
-          art = keysDict[head];
-        } // Ref to up_ in anonymous aspect
-        else if (!art && head === 'up_') {
+        // refs in annos on foreign keys use fk name, not fk ref name:
+        const dict = parent.elements ?? getCache( parent, '_keys' );
+        let art = dict?.[head];
+        if (!art && head === 'up_') { // ref to up_ in anonymous aspect
           const up = getCache( parent, '_parent' );
           const target = up && typeof up.target === 'string' && csn.definitions[up.target];
           if (target && target.elements) {
@@ -757,6 +875,23 @@ function csnRefs( csn, universalReady ) {
       };
   }
 
+  // Return target when resolving references in 'keys'
+  function assocTarget( art, refCtx ) {
+    // Call contexts:
+    // 1. normal definition of association with explicit foreign keys
+    // 2. auto-redirected association with renaming of foreign keys
+    //    (currently: `keys` always available on inherited associations)
+    // 3. user-induced redirection (in 'cast') with explicit foreign keys
+    // 4. original provided association def inside $origin with explicit foreign keys
+    //    (outside $origin like 2)
+    const targetName = refCtx !== 'keys_origin' && art.target ||
+                    art.$origin && art.$origin.target ||
+                    art.cast.target;
+    return initDefinition( targetName );
+  }
+
+  // File and semantic location for CSN path: -----------------------------------
+
   /**
    * Return [ Location, SemanticLocation ] from `csnPath`.
    */
@@ -855,336 +990,56 @@ function csnRefs( csn, universalReady ) {
       }
       artifact.element.push( elem || name + 1);
       artifact.innerKind = kind || undefined;
-      ++index;
-    }
-    function suffix( prop ) {
-      artifact.suffix = prop;
-      obj = null;               // stop
-    }
-  }
-  /**
-   * Get the array of all (sub-)queries (value of the `SELECT`/`projection`
-   * property) inside the given `main` artifact (of `main.query`).
-   *
-   * @param {CSN.Definition} main
-   * @returns {CSN.Query[]}
-   */
-  function allQueries( main ) {
-    const all = [];
-    const projection = main.query || main.projection && main;
-    if (!projection)
-      return null;
-    traverseQuery( projection, null, null, function memorize( query, fromSelect, parentQuery ) {
-      if (query.ref) {          // ref in from
-        // console.log('SQ:',query,cache.get(query))
-        const as = query.as || implicitAs( query.ref );
-        const _ref = cached( query, '_from', artifactFromRef );
-        getCache( fromSelect, '$aliases' )[as] = { _ref, elements: _ref.elements, _parent: query };
-      }
-      else {
-        const qcache = getQueryCache( parentQuery );
-        if (query !== main)
-          cache.set( query, qcache );
-
-        if (fromSelect) {
-          const $queryNumber = all.length + 1;
-          const alias = query.as || `$_select_${ $queryNumber }__`;
-          getCache(fromSelect, '$aliases')[alias] = qcache;
-        }
-
-        const select = query.SELECT || query.projection;
-        if (select) {
-          cache.set( select, qcache ); // query and query.SELECT have the same cache qcache
-          qcache._select = select;
-          qcache._parent = main;
-          all.push( qcache );
-        }
-      }
-    } );
-    all.forEach( function initElements( qcache, index ) {
-      qcache._parent = main;
-      qcache.$queryNumber = index + 1;
-      const { elements } = (index ? qcache._select : main);
-      qcache.elements = elements;
-      const { columns } = qcache._select;
-      if (elements && columns)
-        columns.map( (col, colIndex) => initColumnElement( col, colIndex, qcache ) );
-      else if (columns && !elements)
-        throw new ModelError( `Query elements not available: ${ Object.keys( (index ? qcache._select : main) ).join('+') }`);
-    } );
-    return all;
-  }
-
-  /**
-   * Return the cache object for a new query.
-   * Might re-use cache object with the `parentQuery`, or use `parentQuery`
-   * for link to next lexical environment.
-   */
-
-  function getQueryCache( parentQuery ) {
-    if (!parentQuery)
-      return { $aliases: Object.create(null) };
-    const pcache = cache.get( parentQuery.projection || parentQuery );
-    if (!parentQuery.SET)       // SELECT / projection: real sub query
-      return { $aliases: Object.create(null), $next: pcache };
-    // the parent query is a SET: that is not a sub query
-    // (works, as no sub queries are allowed in ORDER BY)
-    return (!pcache._select)    // no leading query yet
-      ? pcache                  // share cache with parent query
-      : { $aliases: Object.create(null), $next: pcache.$next };
-  }
-
-  function initColumnElement( col, colIndex, parentElementOrQueryCache, externalElements ) {
-    if (col === '*')
-      return;
-    if (col.inline) {
-      col.inline.map( c => initColumnElement( c, null, parentElementOrQueryCache, externalElements ) );
-      return;
-    }
-    setCache( col, '_parent',   // not set for query (has property _select)
-              !parentElementOrQueryCache._select && parentElementOrQueryCache );
-    let as = columnAlias( col );
-    if (!as && colIndex !== null)
-      as = `$_column_${ colIndex + 1 }`;
-    setCache( col, '$as', as );
-    let type = parentElementOrQueryCache;
-    if (col.cast)
-      traverseType( col.cast, col, 'column', colIndex, initNode );
-
-    while (type.items)
-      type = type.items;
-    if (!type.elements) {
-      // in OData backend, the sub elements from a column with expand might have
-      // been “externalized” into a named type.  No backward _column link is
-      // possible this way, of course...
-      type = artifactRef( type.type );
-      externalElements = true;
-    }
-    const elem = setCache( col, '_element', type.elements[as] );
-    if (elem && !externalElements) // TODO to.sql: something is strange if `elem` is not set
-      setCache( elem, '_column', col );
-    if (col.expand)
-      col.expand.map( c => initColumnElement( c, null, elem, externalElements ) );
-  }
-
-  // property name convention in cache:
-  // - $name: to other cache object (with proto), dictionary (w/o proto), or scalar
-  // - _name, name: to CSN object value (_name) or dictionary (name)
-
-  function setCache( obj, prop, val ) {
-    let hidden = cache.get( obj );
-    if (!hidden) {
-      hidden = {};
-      cache.set( obj, hidden );
-    }
-    // TODO: we might keep the following with --test-mode
-    // if (hidden[prop] !== undefined) {
-    //   console.log('RS:',prop,hidden[prop],val,obj)
-    //   throw Error('RESET')
-    // }
-    hidden[prop] = val;
-    return val;
-  }
-
-  function getCache( obj, prop ) {
-    const hidden = cache.get( obj );
-    return hidden && hidden[prop];
-  }
-
-  function cached( obj, prop, calc ) {
-    let hidden = cache.get( obj );
-    if (!hidden) {
-      hidden = {};
-      cache.set( obj, hidden );
-    }
-    else if (hidden[prop] !== undefined) {
-      return hidden[prop];
-    }
-    const val = calc( obj );
-    hidden[prop] = val;
-    return val;
-  }
-}
-
-/**
- * Foreign keys are stored in an array; for easier name resolution, create
- * a dictionary of them.
- */
-function getKeysDict( art ) {
-  const dict = Object.create(null);
-  for (const key of art.keys)
-    dict[key.as || implicitAs( key.ref )] = key;
-  return dict;
-}
-
-/**
- * Return value of a query SELECT for the query node, or the main artifact,
- * i.e. a value with an `elements` property.
- * TODO: only used in forRelationalDB - move somewhere else
- *
- * @param {object} query node (object with SET or SELECT property)
- * @param {object} main definition
- */
-function queryOrMain( query, main ) {
-  while (query.SET)
-    query = query.SET.args[0];
-  if (query.SELECT && query.SELECT.elements)
-    return query.SELECT;
-  let leading = main.query || main;
-  while (leading.SET)
-    leading = leading.SET.args[0];
-  // If an entity has both a projection and query property, the param `query`
-  // can be the entity itself (when inspect is called with a csnPath containing
-  // 'projection'), but `leading` can be its `query` property:
-  if ((leading === query || leading === query.query) && main.elements)
-    return main;
-  throw new ModelError( `Query elements not available: ${ Object.keys( query ).join('+') }`);
-}
-
-/**
- * Traverse query in pre-order
- *
- * The callback is called on the following XSN nodes inside the query `query`:
- * - a query node, which has property `SET` or `SELECT` (or `projection`),
- * - a query source node inside `from` if it has property `ref`,
- * - NOT on a `join` node inside `from`.
- *
- * @param {CSN.Query} query
- * @param {CSN.QuerySelect} fromSelect for query in `from`
- * @param {CSN.Query} parentQuery for a sub query (ex those in `from`)
- * @param {(query: CSN.Query&CSN.QueryFrom, select: CSN.QuerySelectEnriched, parentQuery: CSN.Query) => void} callback
- */
-function traverseQuery( query, fromSelect, parentQuery, callback ) {
-  const select = query.SELECT || query.projection;
-  if (select) {
-    callback( query, fromSelect, parentQuery );
-    traverseFrom( select.from, select, parentQuery, callback );
-    for (const prop of [ 'columns', 'where', 'having' ]) {
-      // all properties which can have sub queries (`join-on` also can)
-      const expr = select[prop];
-      if (expr)
-        expr.forEach( q => traverseExpr( q, query, callback ) );
-    }
-  }
-  else if (query.SET) {
-    callback( query, fromSelect, parentQuery );
-    const { args } = query.SET;
-    for (const q of args || [])
-      traverseQuery( q, null, query, callback );
-  }
-}
-
-/**
- * @param {CSN.QueryFrom} from
- * @param {CSN.QuerySelect} fromSelect
- * @param {CSN.Query} parentQuery
- * @param {(from: CSN.QueryFrom, select: CSN.QuerySelect, parentQuery: CSN.Query) => void} callback
- */
-function traverseFrom( from, fromSelect, parentQuery, callback ) {
-  if (from.ref) {
-    callback( from, fromSelect, parentQuery );
-  }
-  else if (from.args) {         // join
-    from.args.forEach( arg => traverseFrom( arg, fromSelect, parentQuery, callback ) );
-    if (from.on)                // join-on, potentially having a sub query (in xpr)
-      from.on.forEach(arg => traverseExpr( arg, fromSelect, callback ));
-  }
-  else {                        // sub query in FROM
-    traverseQuery( from, fromSelect, parentQuery, callback );
-  }
-}
-
-function traverseExpr( expr, parentQuery, callback ) {
-  if (expr.SELECT || expr.SET)
-    traverseQuery( expr, null, parentQuery, callback );
-  for (const prop of [ 'args', 'xpr' ]) {
-    // all properties which could have sub queries (directly or indirectly),
-    const val = expr[prop];
-    if (val && typeof val === 'object') {
-      const args = Array.isArray( val ) ? val : Object.values( val );
-      args.forEach( e => traverseExpr( e, parentQuery, callback ) );
-    }
-  }
-}
-
-function traverseDef( node, parent, kind, name, callback ) {
-  callback( node, parent, kind, name );
-  if (node.params) {
-    for (const n of Object.keys( node.params ))
-      traverseType( node.params[n], node, 'param', n, callback );
-  }
-  if (node.returns)
-    traverseType( node.returns, node, 'returns', true, callback );
-  traverseType( node, true, kind, name, callback );
-  if (node.actions) {
-    for (const n of Object.keys( node.actions ))
-      traverseDef( node.actions[n], node, 'action', n, callback );
-  }
-}
-
-function traverseType( node, parent, kind, name, callback ) {
-  if (parent !== true)
-    callback( node, parent, kind, name );
-  const target = targetAspect( node );
-  if (target && typeof target === 'object' && target.elements) {
-    callback( target, node, 'target', true );
-    node = target;
-  }
-  else if (node.items) {
-    let items = 0;
-    while (node.items) {
-      callback( node.items, node, 'items', ++items );
-      node = node.items;
+      ++index;
+    }
+    function suffix( prop ) {
+      artifact.suffix = prop;
+      obj = null;               // stop
     }
   }
-  if (node.elements) {
-    for (const n of Object.keys( node.elements ))
-      traverseDef( node.elements[n], node, 'element', n, callback );
-  }
-  if (node.enum) {
-    for (const n of Object.keys( node.enum ))
-      traverseDef( node.enum[n], node, 'enum', n, callback );
-  }
-}
 
-function targetAspect( art ) {
-  const { $origin } = art;
-  return art.targetAspect ||
-    $origin && typeof $origin === 'object' && !Array.isArray( $origin ) && $origin.target ||
-    art.target;
-}
+  // Low-level cache functions: -------------------------------------------------
 
-function pathId( item ) {
-  return (typeof item === 'string') ? item : item.id;
-}
+  function setCache( obj, prop, val ) {
+    let hidden = cache.get( obj );
+    if (!hidden) {
+      hidden = {};
+      cache.set( obj, hidden );
+    }
+    // TODO: we might keep the following with --test-mode
+    // if (hidden[prop] !== undefined) {
+    //   console.log('RS:',prop,hidden[prop],val,obj)
+    //   throw Error('RESET')
+    // }
+    hidden[prop] = val;
+    return val;
+  }
 
-function implicitAs( ref ) {
-  if (typeof ref !== 'string')
-    ref = ref[ref.length - 1];
-  const id = (typeof ref === 'string') ? ref : ref.id; // inlined `pathId`
-  return id.substring( id.lastIndexOf('.') + 1 );
-}
+  function getCache( obj, prop ) {
+    const hidden = cache.get( obj );
+    return hidden && hidden[prop];
+  }
 
-function startCsnPath( csnPath, csn ) {
-  const head = csnPath[0];
-  if (typeof head !== 'string') {
-    const {
-      main, parent, art, query,
-    } = head;
-    return {
-      index: 1, main, parent, art, query,
-    };
+  function cached( obj, prop, calc ) {
+    let hidden = cache.get( obj );
+    if (!hidden) {
+      hidden = {};
+      cache.set( obj, hidden );
+    }
+    else if (hidden[prop] !== undefined) {
+      return hidden[prop];
+    }
+    const val = calc( obj );
+    hidden[prop] = val;
+    return val;
   }
-  if (csnPath.length < 2 || head !== 'definitions' && head !== 'vocabularies')
-    throw new CompilerAssertion( 'References outside definitions and vocabularies not supported yet' );
-  const art = csn[head][csnPath[1]];
-  return {
-    index: 2, main: art, parent: art, art, query: null,
-  };
 }
 
+// CSN path analysing: ----------------------------------------------------------
 
 /**
+ * Analyse path `csnPath` in the CSN `csn` and call `resolve`.
+ *
  * @param {CSN.Path} csnPath
  * @param {CSN.Model} csn
  * @param {any} resolve
@@ -1255,6 +1110,8 @@ function analyseCsnPath( csnPath, csn, resolve ) {
     }
     else if (prop === 'items' || prop === 'returns') {
       art = obj[prop];
+      // TODO: what about parent here?, see cache property _parent
+      // BTW, still necessary to calculate parent here if we have _parent?
     }
     else if (prop === 'args') {
       isName = true;            // for named arguments
@@ -1276,6 +1133,7 @@ function analyseCsnPath( csnPath, csn, resolve ) {
           baseEnv = resolve.expandInline( obj, baseCtx, main, query, parent, baseEnv );
         refCtx = prop;
       }
+      // TODO: for on condition in expand, also set an environment
       isName = prop;
     }
     else if (prop === 'on') {
@@ -1309,8 +1167,160 @@ function analyseCsnPath( csnPath, csn, resolve ) {
   return resolve( obj, refCtx, main, query, parent, baseEnv );
 }
 
+function startCsnPath( csnPath, csn ) {
+  const head = csnPath[0];
+  if (typeof head !== 'string') {
+    const {
+      main, parent, art, query,
+    } = head;
+    return {
+      index: 1, main, parent, art, query,
+    };
+  }
+  if (csnPath.length < 2 || head !== 'definitions' && head !== 'vocabularies')
+    throw new CompilerAssertion( 'References outside definitions and vocabularies not supported yet' );
+  const art = csn[head][csnPath[1]];
+  return {
+    index: 2, main: art, parent: art, art, query: null,
+  };
+}
+
+// CSN traversal functions: -----------------------------------------------------
+
+/**
+ * Traverse an artifact `node` and its members, but without queries, in pre-order.
+ *
+ * Call `callback` on all nodes with the following arguments:
+ *
+ * - `node`: the current node
+ * - `parent`: the parent node (containing the dictionary),
+ *   see the initial file comment for cache property _parent for details
+ * - `name`: the name of the current node in the parent dictionary, or
+ *   true for `returns` parameter, and increasing number for `items` object
+ * - `kind`
+ *
+ *
+ * The callback is called on the following CSN nodes inside the query `query`:
+ * - a query node, which has property `SET` or `SELECT` (or `projection`),
+ * - a query source node inside `from` if it has property `ref`,
+ * - NOT on a `join` node inside `from`.
+ *
+ * @param {CSN.Query} query
+ * @param {CSN.QuerySelect} fromSelect for query in `from`
+ * @param {CSN.Query} parentQuery for a sub query (ex those in `from`)
+ * @param {(query: CSN.Query&CSN.QueryFrom, select: CSN.QuerySelectEnriched, parentQuery: CSN.Query) => void} callback
+ */
+
+function traverseDef( node, parent, name, kind, callback ) {
+  callback( node, parent, name, kind );
+  if (node.params) {
+    for (const n of Object.keys( node.params ))
+      traverseType( node.params[n], node, n, 'param', callback );
+  }
+  if (node.returns)
+    traverseType( node.returns, node, true, 'returns', callback );
+  traverseType( node, true, name, kind, callback );
+  if (node.actions) {
+    for (const n of Object.keys( node.actions ))
+      traverseDef( node.actions[n], node, n, 'action', callback );
+  }
+}
+
+function traverseType( node, parent, name, kind, callback ) {
+  if (parent !== true)
+    callback( node, parent, name, kind );
+  const target = targetAspect( node );
+  if (target && typeof target === 'object' && target.elements) {
+    callback( target, node, true, 'target' );
+    node = target;
+  }
+  else if (node.items) {
+    let items = 0;
+    while (node.items) {
+      callback( node.items, node, ++items, 'items' );
+      node = node.items;
+    }
+  }
+  if (node.elements) {
+    for (const n of Object.keys( node.elements ))
+      traverseDef( node.elements[n], node, n, 'element', callback );
+  }
+  if (node.enum) {
+    for (const n of Object.keys( node.enum ))
+      traverseDef( node.enum[n], node, n, 'enum', callback );
+  }
+}
+
+/**
+ * Traverse query in pre-order
+ *
+ * The callback is called on the following CSN nodes inside the query `query`:
+ * - a query node, which has property `SET` or `SELECT` (or `projection`),
+ * - a query source node inside `from` if it has property `ref`,
+ * - NOT on a `join` node inside `from`.
+ *
+ * @param {CSN.Query} query
+ * @param {CSN.QuerySelect} fromSelect for query in `from`
+ * @param {CSN.Query} parentQuery for a sub query (ex those in `from`)
+ * @param {(query: CSN.Query&CSN.QueryFrom, select: CSN.QuerySelectEnriched, parentQuery: CSN.Query) => void} callback
+ */
+function traverseQuery( query, fromSelect, parentQuery, callback ) {
+  const select = query.SELECT || query.projection;
+  if (select) {
+    callback( query, fromSelect, parentQuery );
+    traverseFrom( select.from, select, parentQuery, callback );
+    for (const prop of [ 'columns', 'where', 'having' ]) {
+      // all properties which can have sub queries (`join-on` also can)
+      const expr = select[prop];
+      if (expr)
+        expr.forEach( q => traverseExpr( q, query, callback ) );
+    }
+  }
+  else if (query.SET) {
+    callback( query, fromSelect, parentQuery );
+    const { args } = query.SET;
+    for (const q of args || [])
+      traverseQuery( q, null, query, callback );
+  }
+}
+
+/**
+ * @param {CSN.QueryFrom} from
+ * @param {CSN.QuerySelect} fromSelect
+ * @param {CSN.Query} parentQuery
+ * @param {(from: CSN.QueryFrom, select: CSN.QuerySelect, parentQuery: CSN.Query) => void} callback
+ */
+function traverseFrom( from, fromSelect, parentQuery, callback ) {
+  if (from.ref) {
+    callback( from, fromSelect, parentQuery );
+  }
+  else if (from.args) {         // join
+    from.args.forEach( arg => traverseFrom( arg, fromSelect, parentQuery, callback ) );
+    if (from.on)                // join-on, potentially having a sub query (in xpr)
+      from.on.forEach(arg => traverseExpr( arg, fromSelect, callback ));
+  }
+  else {                        // sub query in FROM
+    traverseQuery( from, fromSelect, parentQuery, callback );
+  }
+}
+
+function traverseExpr( expr, parentQuery, callback ) {
+  if (expr.SELECT || expr.SET)
+    traverseQuery( expr, null, parentQuery, callback );
+  for (const prop of [ 'args', 'xpr' ]) {
+    // all properties which could have sub queries (directly or indirectly),
+    const val = expr[prop];
+    if (val && typeof val === 'object') {
+      const args = Array.isArray( val ) ? val : Object.values( val );
+      args.forEach( e => traverseExpr( e, parentQuery, callback ) );
+    }
+  }
+}
+
+// Small CSN utility functions: -------------------------------------------------
+
 // A SELECT which is (unnecessarily) put into parentheses, the CSN
-// representation uses SET without `op` and args of length 1:
+// representation uses SET without `op` and args of length 1 in compiler <v6:
 function isSelectQuery( query ) {
   while (query.SET) {
     const { args } = query.SET;
@@ -1332,13 +1342,71 @@ function columnAlias( col ) {
   return col.as || (!col.args && col.func) || (col.ref && implicitAs( col.ref ));
 }
 
+function implicitAs( ref ) {
+  if (typeof ref !== 'string')
+    ref = ref[ref.length - 1];
+  const id = (typeof ref === 'string') ? ref : ref.id; // inlined `pathId`
+  return id.substring( id.lastIndexOf('.') + 1 );
+}
+
+function pathId( item ) {
+  return (typeof item === 'string') ? item : item.id;
+}
+
+/**
+ * Foreign keys are stored in an array; for easier name resolution, create
+ * a dictionary of them.
+ */
+function getKeysDict( art ) {
+  const dict = Object.create(null);
+  for (const key of art.keys)
+    dict[key.as || implicitAs( key.ref )] = key;
+  return dict;
+}
+
+/**
+ * Return the target aspect (or target entity if that does not exist) of `art`.
+ * Works with both CSN flavors `client` and `universal`.
+ */
+function targetAspect( art ) {
+  const { $origin } = art;
+  return ($origin
+    ? typeof $origin === 'object' && !Array.isArray( $origin ) && $origin.target
+    : art.targetAspect
+  ) || art.target;
+}
+
+/**
+ * Return value of a query SELECT for the query node, or the main artifact,
+ * i.e. a value with an `elements` property.
+ * TODO: only used in transformViewOrEntity() - make it use queryForElements()
+ *
+ * @param {object} query node (object with SET or SELECT property)
+ * @param {object} main definition
+ */
+function queryOrMain( query, main ) {
+  while (query.SET)
+    query = query.SET.args[0];
+  if (query.SELECT?.elements)
+    return query.SELECT;
+  let leading = main.query || main;
+  while (leading.SET)
+    leading = leading.SET.args[0];
+  // If an entity has both a projection and query property, the param `query`
+  // can be the entity itself (when inspect is called with a csnPath containing
+  // 'projection'), but `leading` can be its `query` property:
+  if ((leading === query || leading === query.query) && main.elements)
+    return main;
+  throw new ModelError( `Query elements not available: ${ Object.keys( query ).join('+') }`);
+}
+
 module.exports = {
+  artifactProperties,
   csnRefs,
+  analyseCsnPath,
   traverseQuery,
-  artifactProperties,
+  columnAlias,
   implicitAs,
-  getKeysDict,
-  analyseCsnPath,
   pathId,
-  columnAlias,
+  getKeysDict,
 };