@sap/cds-compiler 6.5.0 → 6.6.0

package/lib/compiler/shared.js

@@ -846,6 +846,8 @@ function fns( model ) {
 
     if (!semantics.dollar) {
       valid.push( dynamicDict );
+      if (isMainRef)            // eslint-disable-next-line no-return-assign
+        valid.forEach( ( d, idx ) => (valid[idx] = removeGapArtifact( d )) );
     }
     else {
       const filterFn = semantics.variableFilter || removeRestrictedVariables;
@@ -908,14 +910,22 @@ function fns( model ) {
       }
       // need to do that here, because we also need to disallow Service.AutoExposed:elem
       // TODO: but Service.AutoExposed.NotAuto should be fine
-      if (isMainRef !== 'all' && artItemsCount === 0 &&
-          art.$inferred === 'autoexposed' && !user.$inferred) {
-        // Depending on the processing sequence, the following could be a
-        // simple 'ref-undefined-art'/'ref-undefined-def' - TODO: which we
-        // could "change" to this message at the end of compile():
-        error( 'ref-unexpected-autoexposed', [ item.location, user ], { art },
-               'An auto-exposed entity can\'t be referred to - expose entity $(ART) explicitly' );
-        return null;            // continuation semantics: like “not found”
+      if (isMainRef && isMainRef !== 'all' && artItemsCount === 0) {
+        if (art.kind === 'namespace') {
+          if (env !== false) {
+            semantics.notFound( user, item, [ removeGapArtifact( env ) ],
+                                null, prev, path, semantics );
+          }
+          return null;
+        }
+        else if (art.$inferred === 'autoexposed' && !user.$inferred) {
+          // Depending on the processing sequence, the following could be a
+          // simple 'ref-undefined-art'/'ref-undefined-def' - TODO: which we
+          // could "change" to this message at the end of compile():
+          error( 'ref-unexpected-autoexposed', [ item.location, user ], { art },
+                 'An auto-exposed entity can\'t be referred to - expose entity $(ART) explicitly' );
+          return null;            // continuation semantics: like “not found”
+        }
       }
     }
     return art;
@@ -978,7 +988,25 @@ function fns( model ) {
           return def;
         if (def.$duplicates)
           return false;
-        return setArtifactLink( head, def ); // we do not want to see the using
+        art = setArtifactLink( head, def ); // we do not want to see the using
+        if (art.kind !== 'namespace')
+          return art;
+      }
+      /* FALLTHROUGH */
+      case 'namespace': {
+        if (semantics.isMainRef === 'all' || path.length !== 1 && ref.scope !== 1)
+          return art;
+        const valid = [];
+        const lexical = userBlock( user );
+        if (lexical) {
+          for (let env = lexical; env; env = env._block)
+            valid.push( removeGapArtifact( env.artifacts || Object.create( null ) ) );
+        }
+        valid.push( removeGapArtifact( model.definitions ) );
+        semantics.notFound?.( user._user || user, head, valid, model.definitions,
+                              null, path, semantics );
+
+        return null;
       }
       case 'mixin': {
         // use a source element having that name if in `extend … with columns`:
@@ -2153,6 +2181,18 @@ function removeDollarNames( dict ) {
   return r;
 }
 
+function removeGapArtifact( dict ) {
+  const r = Object.create( null );
+  for (const name in dict) {
+    const art = dict[name];
+    // TODO: for gaps with sub artifacts, we use use `${name}.` as name
+    // TODO: clarify with LSP
+    if (art.kind !== 'namespace' || art._subArtifacts)
+      r[name] = dict[name];
+  }
+  return r;
+}
+
 module.exports = {
   fns,
 };

package/lib/compiler/utils.js

@@ -206,6 +206,7 @@ function initExprAnnoBlock( art, block ) {
 
 function initDollarSelf( art ) {
   // TODO: use setMemberParent() ?
+  // TODO: also on 'namespace's?  (test with annotation with checked ref on them)
   const self = {
     name: { id: '$self', location: art.location },
     kind: '$self',
@@ -285,10 +286,9 @@ function dependsOnSilent( user, art ) {
   user._deps.push( { art } );
 }
 
-function storeExtension( elem, name, prop, parent, block ) {
+function storeExtension( elem, name, prop, parent ) {
   if (prop === 'enum')
     prop = 'elements';
-  setLink( elem, '_block', block );
   const kind = `_${ elem.kind }`; // _extend or _annotate
   if (!parent[kind])
     setLink( parent, kind, {} );

package/lib/edm/annotations/edmJson.js

@@ -21,7 +21,7 @@ const { conditionAsTree, expressionAsTree } = require('../../model/xprAsTree');
  * @returns {object}
  */
 
-function xpr2edmJson( carrier, anno, location, options, messageFunctions ) {
+function xpr2edmJson( carrier, anno, location, options, messageFunctions, genericTranslationHelpers ) {
   const { message, error } = messageFunctions;
 
   const annoVal = carrier[anno];
@@ -77,9 +77,9 @@ function xpr2edmJson( carrier, anno, location, options, messageFunctions ) {
   };
   //----------------------------------
   // Error transformer
-  const notADynExpr = (parent, op, xpr, csnPath, parentParent, parentProp, txt) => {
+  const notADynExpr = (parent, op, xpr, csnPath, parentParent, parentProp, ctx) => {
     error('odata-anno-xpr', location, {
-      anno, op: txt ?? op, '#': 'notadynexpr',
+      anno, op: ctx.txt ?? op, '#': 'notadynexpr',
     });
     delete parent[op];
   };
@@ -95,26 +95,26 @@ function xpr2edmJson( carrier, anno, location, options, messageFunctions ) {
     '.': notADynExpr,
     exists: notADynExpr,
     SELECT: notADynExpr,
-    SET: (p, o) => notADynExpr(p, o, null, null, null, null, 'UNION'),
+    SET: (p, o, xpr, csnPath, parentParent, parentProp, ctx) => notADynExpr(p, o, null, null, null, null, Object.assign(ctx, { txt: 'UNION' })),
     like: notADynExpr,
     new: notADynExpr,
   };
 
   //----------------------------------
   // list is a $Collection => []
-  transform.list = (parent, prop, xpr, csnPath, parentParent, parentProp) => {
+  transform.list = (parent, prop, xpr, csnPath, parentParent, parentProp, ctx) => {
     parentParent[parentProp] = xpr.filter(a => a);
-    transformExpression(parentParent, parentProp, transform);
+    transformExpression(parentParent, parentProp, transform, csnPath, ctx);
   };
   // XPR
-  transform.xpr = (parent, prop, xpr, csnPath, parentParent, parentProp) => {
+  transform.xpr = (parent, prop, xpr, csnPath, parentParent, parentProp, ctx) => {
     // eliminate 'xpr' node by pulling up xpr node to its parent
     parentParent[parentProp] = xpr;
-    transformExpression(parentParent, parentProp, transform);
+    transformExpression(parentParent, parentProp, transform, csnPath, ctx);
   };
   //----------------------------------
   // CASE
-  transform.case = (parent, prop, caseExpr) => {
+  transform.case = (parent, prop, caseExpr, csnPath, parentParent, parentProp, ctx) => {
     // transform simple case expression into search case expression
     // case <expr1> when <expr2> ... ===> case when <expr1> = <expr2> ...
     let i = 0;
@@ -141,14 +141,14 @@ function xpr2edmJson( carrier, anno, location, options, messageFunctions ) {
       curIf.$If.push(caseExpr[i]);
     parent.$If = edmIf.$If;
     delete parent.case;
-    transformExpression(parent, undefined, transform);
+    transformExpression(parent, undefined, transform, csnPath, ctx);
   };
-  transform.$If = (_parent, _prop, expr) => {
-    transformExpression(expr, undefined, transform);
+  transform.$If = (_parent, _prop, expr, csnPath, parentParent, parentProp, ctx) => {
+    transformExpression(expr, undefined, transform, csnPath, ctx);
   };
   //----------------------------------
   // Cast => $Cast
-  transform.cast = (parent, prop, castExpr, csnPath, parentParent, parentProp) => {
+  transform.cast = (parent, prop, castExpr, csnPath, parentParent, parentProp, ctx) => {
     const csnType = castExpr[0];
     // try to resolve to final scalar base type and use that instead of derived type
     if (!isBuiltinType(csnType.type)) {
@@ -183,7 +183,7 @@ function xpr2edmJson( carrier, anno, location, options, messageFunctions ) {
 
 
     parentParent[parentProp] = castFunc;
-    transformExpression(parentParent, parentProp, transform);
+    transformExpression(parentParent, parentProp, transform, csnPath, ctx);
   };
   //----------------------------------
   const evalArgs = (argDef, args, propName) => {
@@ -215,11 +215,11 @@ function xpr2edmJson( carrier, anno, location, options, messageFunctions ) {
   };
 
   // Binary Operator Macro
-  const op = (opStr, exact = 2) => (parent, prop, xpr) => {
+  const op = (opStr, exact = 2) => (parent, prop, xpr, csnPath, parentParent, parentProp, ctx) => {
     evalArgs({ exact }, xpr, prop);
     parent[opStr] = xpr;
     delete parent[prop];
-    transformExpression(parent, undefined, transform);
+    transformExpression(parent, undefined, transform, csnPath, ctx);
   };
   //----------------------------------
   // LOGICAL
@@ -245,7 +245,7 @@ function xpr2edmJson( carrier, anno, location, options, messageFunctions ) {
   transform.$Lt = noOp;
   transform['<='] = op('$Le');
   transform.$Le = noOp;
-  transform.in = (parent, prop, xpr) => {
+  transform.in = (parent, prop, xpr, csnPath, parentParent, parentProp, ctx) => {
     let args = xpr[1].list;
     if (!args) {
       if (Array.isArray(xpr[1].xpr))
@@ -256,12 +256,12 @@ function xpr2edmJson( carrier, anno, location, options, messageFunctions ) {
     evalArgs({ min: 1 }, args, prop);
     parent.$In = [ xpr[0], args ];
     delete parent[prop];
-    transformExpression(parent, undefined, transform);
+    transformExpression(parent, undefined, transform, csnPath, ctx);
   };
   transform.$In = noOp;
-  transform.between = (parent, prop, xpr, csnPath, parentParent, parentProp) => {
+  transform.between = (parent, prop, xpr, csnPath, parentParent, parentProp, ctx) => {
     evalArgs({ exact: 2 }, xpr.slice(1), prop);
-    transformExpression(xpr, undefined, transform);
+    transformExpression(xpr, undefined, transform, csnPath, ctx);
     delete parent[prop];
     parentParent[parentProp]
       = {
@@ -271,28 +271,28 @@ function xpr2edmJson( carrier, anno, location, options, messageFunctions ) {
         ],
       };
   };
-  transform['||'] = (parent, prop, xpr, csnPath, parentParent, parentProp) => {
+  transform['||'] = (parent, prop, xpr, csnPath, parentParent, parentProp, ctx) => {
     evalArgs({ exact: 2 }, xpr, prop);
-    transformExpression(xpr, undefined, transform);
+    transformExpression(xpr, undefined, transform, csnPath, ctx);
     delete parent[prop];
     parentParent[parentProp].$Apply = xpr;
     parentParent[parentProp].$Function = 'odata.concat';
   };
   //----------------------------------
   // ARITHMETICAL AND UNARY
-  transform['+'] = (parent, prop, xpr, csnPath, parentParent, parentProp) => {
+  transform['+'] = (parent, prop, xpr, csnPath, parentParent, parentProp, ctx) => {
     if (Array.isArray(xpr)) {
       op('$Add')(parent, prop, xpr);
     }
     else {
       delete parent[prop];
       parentParent[parentProp] = xpr;
-      transformExpression(parentParent, parentProp, transform);
+      transformExpression(parentParent, parentProp, transform, csnPath, ctx);
     }
   };
   transform.$Add = noOp;
-  transform['-'] = (parent, prop, xpr) => {
-    op(Array.isArray(xpr) ? '$Sub' : '$Neg')(parent, prop, xpr);
+  transform['-'] = (parent, prop, xpr, csnPath, parentParent, parentProp, ctx) => {
+    op(Array.isArray(xpr) ? '$Sub' : '$Neg')(parent, prop, xpr, csnPath, parentParent, parentProp, ctx);
   };
   transform.$Sub = noOp;
   transform.$Neg = noOp;
@@ -311,12 +311,84 @@ function xpr2edmJson( carrier, anno, location, options, messageFunctions ) {
     else
       parentParent[parentProp] = xpr;
   };
-  transform['#'] = (parent, prop, xpr, csnPath, parentParent, parentProp, txt) => {
-    if (parent['#'] && parent.val) // enum reference that was resolved by the compiler
-      delete parent['#'];
-    else
-      notADynExpr(parent, prop, xpr, csnPath, parentParent, parentProp, txt);
+  transform['#'] = (parent, prop, xpr, csnPath, parentParent, parentParentName, ctx) => {
+    // enum reference that was resolved by the compiler
+    if (!(parent['#'] && parent.val))
+      parent.EnumMember = getEnumMemberValue(xpr, ctx);
+    delete parent['#'];
   };
+  //----------------------------------
+  // Enum type resolving helper functions
+  function getEnumMemberValue( enumMember, ctx ) {
+    // inner annotations play a role here?
+
+    const annoNameParts = anno.slice(1).split('.');
+    // The term of an annotation is the part between the first '@' and the second '.'
+    const termName = `${ annoNameParts[0] }.${ annoNameParts[1] }`;
+    const term = genericTranslationHelpers.getDictTerm(termName, options);
+    // get term's type
+    let typeName = term?.Type;
+    let type = genericTranslationHelpers.getDictType(typeName);
+
+    ({ type, typeName } = resolveNestedTypePath(annoNameParts.slice(2), typeName, type));
+
+    if (type?.$kind === 'EnumType')
+      return valiteAndGetFullEnumMemberNameFromEnumType(enumMember, type, typeName);
+    if (type?.$kind === 'ComplexType') {
+      // If we end up with a ComplexType here, the enum member is defined in a property of the complex type, which is
+      // a collection. Only in that case the flattening of annotation stops in the core compiler.
+      // Here we need to continue resolving the substructure inside a collection item.
+      const indexOfAnnoInCsnPath = ctx.xprCsnPath.indexOf(anno);
+      // we take the part of the csnPath after the annotation and remove the numeric values, as these are the array indexes
+      const subStructAnnoNames = ctx.xprCsnPath.slice(indexOfAnnoInCsnPath + 1).filter(e => typeof e === 'string');
+      ({ type, typeName } = resolveNestedTypePath(subStructAnnoNames, typeName, type));
+      if (type?.$kind === 'EnumType')
+        return valiteAndGetFullEnumMemberNameFromEnumType(enumMember, type, typeName);
+    }
+
+    if (type && type.$kind !== 'EnumType') {
+      // resolved to not an EnumType -> warn about it and return what the input value
+      message('odata-anno-value', location, {
+        anno, value: `"#${ enumMember }"`, type: typeName, '#': 'std',
+      });
+    }
+    return enumMember;
+  }
+
+  function resolveNestedTypePath( annoNameParts, typeName, type ) {
+    for (let i = 0; i < annoNameParts.length; i++) {
+      if (type?.$kind === 'ComplexType') {
+        const properties = type.Properties;
+        const propName = Object.keys(properties).find(p => p === annoNameParts[i]);
+        if (propName) {
+          if (properties[propName].startsWith('Collection(')) {
+            // strip the 'Collection(...)' wrapper
+            typeName = properties[propName].slice(11, -1);
+            type = genericTranslationHelpers.getDictType(typeName);
+          }
+          else {
+            type = genericTranslationHelpers.getDictType(properties[propName]);
+            typeName = properties[propName];
+          }
+        }
+      }
+    }
+    return { type, typeName };
+  }
+
+  function valiteAndGetFullEnumMemberNameFromEnumType( member, enumType, typeName ) {
+    const members = enumType?.Members;
+    if (members && !members.includes(member)) {
+      message('odata-anno-value', location, {
+        anno, type: typeName, value: `"#${ member }"`, rawvalues: members.map(m => `#${ m }`), '#': 'enum',
+      });
+      return member;
+    }
+    return `${ typeName }/${ member }`;
+  }
+  //----------------------------------
+
+
   transform.ref = (parent, prop, xpr, csnPath, parentParent, parentProp) => {
     // until empty filter syntax is introduced for the annotation expressions,
     // we ignore the filters in order to generate EDMX
@@ -332,7 +404,7 @@ function xpr2edmJson( carrier, anno, location, options, messageFunctions ) {
   };
   //----------------------------------
   // Functions
-  transform.func = (parent, prop, xpr, csnPath, parentParent, parentProp) => {
+  transform.func = (parent, prop, xpr, csnPath, parentParent, parentProp, ctx) => {
     const rewriteArgs = (argDefs, evalVal = true) => {
       Object.entries(argDefs).forEach(([ argName, argDef ]) => {
         const [ foundProps, newArgs ]
@@ -723,7 +795,7 @@ function xpr2edmJson( carrier, anno, location, options, messageFunctions ) {
       // $Record ???
       $Collection: () => {
         standard(parentParent, parentProp);
-        transformExpression(parentParent, parentProp, transform);
+        transformExpression(parentParent, parentProp, transform, csnPath, ctx);
       },
       $Path: () => {
         oneArg(parent, xpr);
@@ -733,7 +805,7 @@ function xpr2edmJson( carrier, anno, location, options, messageFunctions ) {
             anno, op: `${ xpr }(…)`, meta: 'string', '#': 'wrongval_meta',
           });
         }
-        transformExpression(parentParent, parentProp, transform);
+        transformExpression(parentParent, parentProp, transform, csnPath, ctx);
       },
       $Null: () => {
         parent[xpr] = true;
@@ -753,7 +825,7 @@ function xpr2edmJson( carrier, anno, location, options, messageFunctions ) {
         funcDef.forEach(f => f());
       else
         funcDef();
-      transformExpression(parent, undefined, transform);
+      transformExpression(parent, undefined, transform, csnPath, ctx);
     }
     else {
       const funcName = xpr.startsWith('odata.') ? xpr : `odata.${ xpr }`;
@@ -770,7 +842,7 @@ function xpr2edmJson( carrier, anno, location, options, messageFunctions ) {
           parentParent[parentProp].$Function = funcName;
           delete parentParent[parentProp].func;
           delete parentParent[parentProp].args;
-          transformExpression(parentParent, parentProp, transform);
+          transformExpression(parentParent, parentProp, transform, csnPath, ctx);
         }
       }
       else {
@@ -787,7 +859,9 @@ function xpr2edmJson( carrier, anno, location, options, messageFunctions ) {
       if (isAnnotationExpression(parent)) {
         delete parent['='];
         const edmJson = preTransformXpr(parent);
-        parentParent[parentProp] = transformExpression({ $edmJson: edmJson }, undefined, transform);
+        // csnPath to this certain expression is passed inside of the 'ctx' variable, in case it is needed for resolving types from the
+        // dictionary, for instance in enum symbols resolving, see transform['#']
+        parentParent[parentProp] = transformExpression({ $edmJson: edmJson }, undefined, transform, csnPath, { xprCsnPath: csnPath });
       }
     },
   }, location);

package/lib/edm/annotations/genericTranslation.js

@@ -468,7 +468,9 @@ function csn2annotationEdm( reqDefs, reqDefsUtils, csnVocabularies, serviceName,
             }
           },
         }, ctx.csnPath || ctx.location);
-        xpr2edmJson(carrier, knownAnno, ctx.location, options, messageFunctions);
+        xpr2edmJson(carrier, knownAnno, ctx.location, options, messageFunctions, {
+          oDataDictionary, getDictTerm, getDictType,
+        });
       }
     });
 

package/lib/main.d.ts

@@ -1023,9 +1023,6 @@ declare namespace compiler {
      *  - elements are flattened
      *  - …
      *
-     * THIS IS HIGHLY EXPERIMENTAL
-     *
-     * Beta flag `effectiveCsn` is required.
      *
      * @internal
      */

package/lib/main.js

@@ -188,9 +188,11 @@ module.exports = {
   $lsp: {
     parse: (...args) => compiler.parseX(...args),
     compile: (...args) => compiler.compileX(...args),
+    compileSync: (...args) => compiler.compileSyncX(...args),
     getArtifactName: art => base.getArtifactName(art),
     traverseSemanticTokens: (xsn, options) => lsp.traverseSemanticTokens(xsn, options),
     getSemanticTokenOrigin: obj => lsp.getSemanticTokenOrigin(obj),
+    xsnToCsn: ( xsn, options ) => toCsn.compactModel( xsn, options ),
   },
 
   // CSN Model related functionality

package/lib/model/csnRefs.js

@@ -245,9 +245,10 @@ const referenceSemantics = {
   inline: { lexical: justDollar, dynamic: 'inline' },   // ...using baseEnv
   ref_where: { lexical: justDollar, dynamic: 'ref-target' }, // ...using baseEnv
   on: { lexical: justDollar, dynamic: 'query' }, // assoc defs, redirected to
+  // there are also 'on_join' and 'on_mixin' with default semantics
+  $calc: { lexical: justDollar, dynamic: 'query' }, // calculation for draft
   annotation: { lexical: justDollar, dynamic: 'query' }, // anno top-level `ref`
   annotationExpr: { lexical: justDollar, dynamic: 'query' }, // annotation assignment
-  // there are also 'on_join' and 'on_mixin' with default semantics
   orderBy_ref: { lexical: query => query, dynamic: 'query' },
   orderBy_expr: { lexical: query => query, dynamic: 'source' }, // ref in ORDER BY expression
   orderBy_set_ref: { lexical: query => query.$next, dynamic: 'query' }, // to outer SELECT (from UNION)
@@ -1075,6 +1076,7 @@ function analyseCsnPath( csnPath, csn, resolve ) {
     if (refCtx === 'annotation' && typeof obj === 'object') {
       // we do not know yet whether the annotation value is an expression or not →
       // loop over outer array and records (structure values):
+      // TODO: add test → `@(A: [{target: ($user)}])` on query column
       if (Array.isArray( obj ) || !isAnnotationExpression( obj )) {
         obj = obj[prop];
         continue;
@@ -1164,6 +1166,9 @@ function analyseCsnPath( csnPath, csn, resolve ) {
     else if (prop[0] === '@') {
       refCtx = 'annotation';
     }
+    else if (prop === '$calc') {
+      refCtx = '$calc';
+    }
     else if (prop !== 'xpr' && prop !== 'list') {
       // 'xpr' and 'list' do not change the ref context, all other props do:
       refCtx = prop;

package/lib/render/toSql.js

@@ -1294,11 +1294,7 @@ function toSqlDdl( csn, options, messageFunctions ) {
 
       // Set operation may also have an ORDER BY and LIMIT/OFFSET (in contrast to the ones belonging to
       // each SELECT)
-      // If the whole SET has an ORDER BY/LIMIT, wrap the part before that in parentheses
-      // (otherwise some SQL implementations (e.g. sqlite) would interpret the ORDER BY/LIMIT as belonging
-      // to the last SET argument, not to the whole SET)
       if (query.SET.orderBy || query.SET.limit) {
-        result = `(${ result })`;
         if (query.SET.orderBy) {
           const orderBy = query.SET.orderBy.map(entry => renderOrderByEntry(entry, env.withSubPath([ 'orderBy' ]))).join(', ');
           result += `\n${ env.indent }ORDER BY ${ orderBy }`;

package/lib/transform/db/applyTransformations.js

@@ -270,7 +270,7 @@ function applyTransformations( csn, customTransformers = {}, artifactTransformer
  * - the path to the property
  *
  * @param {object} parent The "parent" of which we transform a property of
- * @param {string} prop The property of parent to start at
+ * @param {string|number} prop The property of parent to start at
  * @param {object} customTransformers Map of prop to transform and function to apply
  * @param {applyTransformationsOptions} [options={}]
  * @param {CSN.Path} path Path pointing to parent

package/lib/transform/db/associations.js

@@ -155,7 +155,6 @@ function getFKAccessFinalizer( csn, options, csnUtils, pathDelimiter, processOnI
    */
   function handleManagedAssocSteps( artifact, artifactName ) {
     const transformer = getTransformer();
-    const inColumnsTransformer = getTransformer(true);
 
     if (options.transformation === 'effective')
       processRefsInAnnotations(artifact, transformer, [ 'definitions', artifactName ]);
@@ -185,14 +184,13 @@ function getFKAccessFinalizer( csn, options, csnUtils, pathDelimiter, processOnI
       if (processOnInQueries) {
         queryTransformers.columns = (parent, prop, columns, path) => {
           for (let i = 0; i < columns.length; i++) {
-            const column = columns[i];
-            if (column.ref) {
-              inColumnsTransformer.ref(column, 'ref', column.ref, path.concat([ 'columns', i ]));
-              column.ref.forEach((step, index) => {
-                if (step.where)
-                  transform(step, 'where', step.where, path.concat([ 'columns', i, 'ref', index ]));
-              });
-            }
+            applyTransformationsOnNonDictionary(
+              columns,
+              i,
+              transformer,
+              { drillRef: true, skipStandard: { on: true } },
+              path.concat( [ 'columns' ] )
+            );
           }
         };
         queryTransformers.on = transform;
@@ -201,17 +199,27 @@ function getFKAccessFinalizer( csn, options, csnUtils, pathDelimiter, processOnI
       if (options.transformation === 'effective' || options.transformation === 'odata')
         queryTransformers.xpr = transform;
 
-      applyTransformationsOnNonDictionary(artifact, artifact.query ? 'query' : 'projection', queryTransformers, { drillRef: true }, [ 'definitions', artifactName ]);
+      applyTransformationsOnNonDictionary(
+        artifact,
+        artifact.query ? 'query' : 'projection',
+        queryTransformers,
+        {
+          drillRef: true,
+          skipDict: {
+            mixin: !(options.transformation in { odata: 1, effective: 1 }),
+          },
+        },
+        [ 'definitions', artifactName ]
+      );
     }
 
     /**
      *
-     * @param {boolean} isColumns Whether the transformation is taking place on a column
      * @returns {object}
      */
-    function getTransformer( isColumns = false ) {
+    function getTransformer() {
       return {
-        ref: (refOwner, prop, ref, path) => {
+        ref: (refOwner, prop, ref, path, grandParent) => {
           // [<assoc base>.]<managed assoc>.<field>
           if (ref.length > 1) {
             const { links } = inspectRef(path);
@@ -232,10 +240,11 @@ function getFKAccessFinalizer( csn, options, csnUtils, pathDelimiter, processOnI
                     fkAlias = fks[0].as || fks[0].ref[fks[0].ref.length - 1];
                     const managedAssocStepName = ref[i];
                     const newFkName = `${ managedAssocStepName }${ pathDelimiter }${ fkAlias }`;
-                    if (isColumns) {
+                    // only set alias for top level column refs
+                    if (Array.isArray(grandParent) && path.at(-2) === 'columns') {
                       refOwner.ref = [ ...ref.slice(0, i), newFkName ];
                       if (!refOwner.as)
-                        refOwner.as = implicitAs(ref);
+                        refOwner.as = ref.at(-1).id || ref.at(-1);
                     }
                     else {
                       refOwner.ref = [ ...ref.slice(0, i), newFkName ];

package/lib/transform/db/flattening.js

@@ -226,7 +226,7 @@ function getStructStepsFlattener( csn, options, messageFunctions, resolved, path
           // Explicitly set implicit alias for things that are now flattened - but only in columns
           // TODO: Can this be done elegantly during expand phase already?
           if (parent.$implicitAlias) { // an expanded s -> s.a is marked with this - do not add implicit alias "a" there, we want s_a
-            if (parent.ref.at(-1) === parent.as) // for a simple s that was expanded - for s.substructure this would not apply
+            if (parent.ref.at(-1) === parent.as && !parent.ref.at(-1).includes('.') ) // for a simple s that was expanded - for s.substructure this would not apply
               delete parent.as;
             delete parent.$implicitAlias;
           }

package/lib/transform/db/views.js

@@ -70,7 +70,6 @@ function getViewTransformer( csn, options, messageFunctions ) {
     get$combined, isAssocOrComposition,
     inspectRef, queryOrMain, // csnRefs
   } = csnUtils;
-  const pathDelimiter = options.forHana && (options.sqlMapping === 'hdbcds') ? '.' : '_';
   const { error, info } = messageFunctions;
   const doA2J = !(options.transformation === 'hdbcds' && options.sqlMapping === 'hdbcds');
 
@@ -158,39 +157,6 @@ function getViewTransformer( csn, options, messageFunctions ) {
       columnMap[elemName] = { ref: [ elemName ] };
   }
 
-  /**
-   * So far, we only added foreign keys to elements - we also need to create corresponding columns
-   * and respect aliasing etc.
-   *
-   * @todo Maybe this can be done earlier, during flattening/expansion already?
-   * @param {object} columnMap
-   * @param {CSN.Element} elem
-   * @param {string} elemName
-   */
-  function addForeignKeysToColumns( columnMap, elem, elemName ) {
-    const assocCol = columnMap[elemName];
-    if (assocCol && assocCol.ref) {
-      elem.keys.forEach((foreignKey) => {
-        const ref = cloneCsnNonDict(assocCol.ref, options);
-        ref[ref.length - 1] = [ getLastRefStepString(ref) ].concat(foreignKey.as).join(pathDelimiter);
-        const result = {
-          ref,
-        };
-        if (assocCol.as) {
-          const columnName = `${ assocCol.as }${ pathDelimiter }${ foreignKey.as }`;
-          result.as = columnName;
-        }
-
-        if (assocCol.key)
-          result.key = true;
-
-        const colName = result.as || getLastRefStepString(ref);
-        columnMap[colName] = result;
-      });
-    }
-  }
-
-
   /**
    * Check for invalid association publishing (in Union or in Subquery) (for hdbcds) and
    * create the __clone for publishing stuff.
@@ -354,11 +320,6 @@ function getViewTransformer( csn, options, messageFunctions ) {
       if (isSelect) {
         if (!columnMap[elemName])
           addProjectionOrStarElement(query, isProjection, isSelectStar, $combined, columnMap, elemName);
-
-        // For associations - make sure that the foreign keys have the same "style"
-        // If A.assoc => A.assoc_id, else if assoc => assoc_id or assoc as Assoc => Assoc_id
-        if (elem.keys && doA2J)
-          addForeignKeysToColumns(columnMap, elem, elemName);
       }
       // Views must have at least one element that is not an unmanaged assoc
       if (!elem.on && !elem.$ignore)