@sap/cds-compiler 4.0.2 → 4.1.2

package/lib/transform/db/assertUnique.js

@@ -1,8 +1,7 @@
 'use strict';
 
 const { forEachDefinition, hasAnnotationValue } = require('../../model/csnUtils');
-const { getTransformers } = require('../transformUtilsNew');
-const { setProp } = require('../../base/model');
+const { getTransformers } = require('../transformUtils');
 const { pathName } = require('../../compiler/utils');
 
 
@@ -97,7 +96,7 @@ function processAssertUnique( csn, options, error, info ) {
         }
         // 10) Store remaining paths (if any) in constraint dictionary
         if (flattenedPathObjects.length)
-          constraintDict[constraintName.join('.')] = flattenedPathObjects;
+          constraintDict[constraintName.join('.')] = { paths: flattenedPathObjects, parentTable: artifactName };
       }
     }
 
@@ -110,9 +109,9 @@ function processAssertUnique( csn, options, error, info ) {
     // preserve dictionary in '$tableConstraints' on the artifact for path rewriting and rendering
     if (Object.keys(constraintDict).length) {
       if (!('$tableConstraints' in artifact))
-        setProp(artifact, '$tableConstraints', Object.create(null));
+        artifact.$tableConstraints = Object.create(null);
 
-      setProp(artifact.$tableConstraints, 'unique', constraintDict);
+      artifact.$tableConstraints.unique = constraintDict;
     }
 
     /**
@@ -286,7 +285,7 @@ function rewriteUniqueConstraints( csn, options, pathDelimiter ) {
       }
       for (const uniqueConstraint in artifact.$tableConstraints.unique) {
         // iterate over each constraint
-        const c = uniqueConstraints[uniqueConstraint];
+        const c = uniqueConstraints[uniqueConstraint].paths;
         const rewrittenPaths = [];
         // and inspect each path of the constraint
         c.forEach((cpath) => {
@@ -319,7 +318,7 @@ function rewriteUniqueConstraints( csn, options, pathDelimiter ) {
           }
         });
         // preserve the rewritten and filtered paths for toSql
-        uniqueConstraints[uniqueConstraint] = rewrittenPaths;
+        uniqueConstraints[uniqueConstraint] = { paths: rewrittenPaths, parentTable: uniqueConstraints[uniqueConstraint].parentTable };
 
         // now add the index for HANA CDS
         if (options.transformation === 'hdbcds') {
@@ -335,7 +334,7 @@ function rewriteUniqueConstraints( csn, options, pathDelimiter ) {
           artifact.technicalConfig.hana.indexes[uniqueConstraint] = index;
         }
       }
-      setProp(artifact.$tableConstraints, 'unique', uniqueConstraints);
+      artifact.$tableConstraints.unique = uniqueConstraints;
     }
   }
 }

package/lib/transform/db/associations.js

@@ -48,8 +48,8 @@ function attachOnConditions( csn, csnUtils, pathDelimiter ) {
     // Assemble an ON-condition with the foreign keys created in earlier steps
     const onCondParts = [];
     let joinWithAnd = false;
-    if (elem.keys.length === 0) { // TODO: really kill instead of _ignore?
-      elem._ignore = true;
+    if (elem.keys.length === 0) { // TODO: really kill instead of $ignore?
+      elem.$ignore = true;
     }
     else {
       for (const foreignKey of elem.keys) {

package/lib/transform/db/cdsPersistence.js

@@ -3,13 +3,13 @@
 const {
   forEachGeneric, forEachMemberRecursively, hasAnnotationValue, isPersistedOnDatabase,
 } = require('../../model/csnUtils');
-const transformUtils = require('../transformUtilsNew');
+const transformUtils = require('../transformUtils');
 
 const exists = '@cds.persistence.exists';
 
 /**
  * Return a callback function for forEachDefinition that marks artifacts that are abstract or @cds.persistence.exists/skip
- * with _ignore.
+ * with $ignore.
  *
  * @returns {(artifact: CSN.Artifact, artifactName) => void} Callback function for forEachDefinition
  */
@@ -24,12 +24,12 @@ function getAnnoProcessor() {
                             hasAnnotationValue(artifact, '@cds.persistence.skip') ||
                             hasAnnotationValue(artifact, exists));
     if (ignoreArtifact)
-      artifact._ignore = true;
+      artifact.$ignore = true;
   }
 }
 
 /**
- * Return a callback function for forEachDefinition that marks associations with _ignore
+ * Return a callback function for forEachDefinition that marks associations with $ignore
  * if their target does not reach the database, i.e. marked with @cds.persistence.skip or is abstract
  *
  * @param {CSN.Model} csn
@@ -72,7 +72,7 @@ function getAssocToSkippedIgnorer( csn, options, messageFunctions, csnUtils ) {
   }
 
   /**
-   * Mark the given member with _ignore if it is an association/composition and it's target is unreachable.
+   * Mark the given member with $ignore if it is an association/composition and its target is unreachable.
    *
    * @param {CSN.Element} member
    * @param {string} memberName
@@ -81,13 +81,13 @@ function getAssocToSkippedIgnorer( csn, options, messageFunctions, csnUtils ) {
    */
   function ignore( member, memberName, prop, path ) {
     if (options.sqlDialect === 'hana' &&
-       !member._ignore && member.target &&
+       !member.$ignore && member.target &&
        isAssocOrComposition(member) &&
        !isPersistedOnDatabase(csn.definitions[member.target])) {
       info(null, path,
            { target: member.target, anno: '@cds.persistence.skip' },
            'Association has been removed as it\'s target $(TARGET) is annotated with $(ANNO)');
-      member._ignore = true;
+      member.$ignore = true;
     }
   }
 }
@@ -124,7 +124,7 @@ function getPersistenceTableProcessor( csn, options, messageFunctions ) {
 
       recurseElements(artifact, [ 'definitions', artifactName ], (member, path) => {
         // All elements must have a type for this to work
-        if (!member._ignore && !member.kind && !member.type) {
+        if (!member.$ignore && !member.kind && !member.type) {
           error(null, path, { anno: '@cds.persistence.table' },
                 'Expecting element to have a type if view is annotated with $(ANNO)');
         }

package/lib/transform/db/expansion.js

@@ -274,15 +274,8 @@ function expandStructureReferences( csn, options, pathDelimiter, { error, info,
         return { columns, toMany: [] };
 
       for (const col of columns) {
-        if (col.expand) {
-          // TODO: Can col.ref be empty without an as? Assumption is it cannot - if it has, it's an error, we throw, compiler checks.
-          const { expanded, toManys } = expandInline(root, col, col.ref || [], [ dbName(col) ]);
-
-          allToMany.push(...toManys);
-          newThing.push(...expanded);
-        }
-        else if (col.inline) {
-          const { expanded, toManys } = expandInline(root, col, col.ref || [], []);
+        if (col.expand || col.inline) {
+          const { expanded, toManys } = expandInline(root, col, col.ref || [], col.expand ? [ dbName(col) ] : []);
 
           allToMany.push(...toManys);
           newThing.push(...expanded);
@@ -335,18 +328,21 @@ function expandStructureReferences( csn, options, pathDelimiter, { error, info,
           });
           toManys.push({ art: current, ref: currentRef, as: currentAlias.join(pathDelimiter) });
         }
-        else if (current.expand) {
-          current.expand = replaceStar(nextBase(current, base), current.expand, current.excluding);
-          for (let i = current.expand.length - 1; i >= 0; i--) {
-            const sub = current.expand[i];
-            stack.push([ nextBase(current, base), sub, sub.ref ? currentRef.concat(sub.ref) : currentRef, !sub.inline ? currentAlias.concat(dbName(sub)) : currentAlias ]);
-          }
-        }
-        else if (current.inline) {
-          current.inline = replaceStar(nextBase(current, base), current.inline, current.excluding);
-          for (let i = current.inline.length - 1; i >= 0; i--) {
-            const sub = current.inline[i];
-            stack.push([ nextBase(current, base), sub, sub.ref ? currentRef.concat(sub.ref) : currentRef, !sub.inline ? currentAlias.concat(dbName(sub)) : currentAlias ]);
+        else if (current.expand || current.inline) {
+          const withoutStar = replaceStar(nextBase(current, base), current.expand || current.inline, current.excluding);
+          current[current.expand ? 'expand' : 'inline'] = withoutStar;
+          for (let i = withoutStar.length - 1; i >= 0; i--) {
+            const sub = withoutStar[i];
+            let subRef;
+            if (sub.ref) {
+              // Each expand/inline can introduce another layer of $self/$projection.  Since $self is
+              // a path-breakout, we can simply use the ref without outer expand/inline-references.
+              subRef = (sub.$scope === '$self') ? sub.ref : currentRef.concat(sub.ref);
+            }
+            else {
+              subRef = currentRef;
+            }
+            stack.push([ nextBase(current, base), sub, subRef, !sub.inline ? currentAlias.concat(dbName(sub)) : currentAlias ]);
           }
         }
         else if (current.xpr || current.args) {

package/lib/transform/db/flattening.js

@@ -5,7 +5,7 @@ const {
   isBuiltinType, cloneCsnNonDict,
   copyAnnotations, implicitAs, isDeepEqual,
 } = require('../../model/csnUtils');
-const transformUtils = require('../transformUtilsNew');
+const transformUtils = require('../transformUtils');
 const { csnRefs } = require('../../model/csnRefs');
 const { setProp } = require('../../base/model');
 const { forEach } = require('../../utils/objectUtils');
@@ -79,24 +79,23 @@ function resolveTypeReferences( csn, options, resolved, pathDelimiter, iterateOp
   const ignoreOdataKinds = { aspect: 1, event: 1, type: 1 };
   const replaceWithDummyKinds = { action: 1, function: 1, event: 1 };
   applyTransformations(csn, {
-    cast: (parent, prop, cast, path) => {
-      // Resolve cast already - we otherwise lose .localized
-      if (cast.type && !isBuiltinType(cast.type) && (!options.toOdata || options.toOdata && !isODataV4BuiltinFromService(cast.type, path) && !isODataItems(cast.type)))
-        toFinalBaseType(parent.cast, resolved, true);
-    },
-    // @ts-ignore
-    type: (parent, prop, type, path) => {
-      if (options.toOdata && parent.kind && parent.kind in ignoreOdataKinds)
+    type: (node, prop, type, path, parent, parentProp) => {
+      if (options.toOdata && node.kind && node.kind in ignoreOdataKinds)
         return;
+      if (parentProp === 'cast') {
+        const e = csnUtils.getFinalTypeInfo(type, t => resolved.get(t)?.art || csnUtils.artifactRef(t));
+        if (!e || e.items || e.elements)
+          return;
+      }
       if (!isBuiltinType(type) && (!options.toOdata || options.toOdata && !isODataV4BuiltinFromService(type, path) && !isODataItems(type))) {
-        toFinalBaseType(parent, resolved, true);
+        toFinalBaseType(node, resolved, true);
 
-        if (parent.items) // items could have unresolved types
-          toFinalBaseType(parent.items, resolved, true);
+        if (node.items) // items could have unresolved types
+          toFinalBaseType(node.items, resolved, true);
 
         // structured types might not have the child-types replaced.
         // Drill down to ensure this.
-        let nextElements = parent.elements || parent.items?.elements;
+        let nextElements = node.elements || node.items?.elements;
         if (nextElements) {
           const stack = [ nextElements ];
           while (stack.length > 0) {
@@ -111,9 +110,9 @@ function resolveTypeReferences( csn, options, resolved, pathDelimiter, iterateOp
           }
         }
 
-        const directLocalized = parent.localized || false;
+        const directLocalized = node.localized || false;
         if (!directLocalized && !options.toOdata)
-          removeLocalized(parent);
+          removeLocalized(node);
       }
     },
   }, [ (definitions, artifactName, artifact) => {
@@ -284,8 +283,7 @@ function flattenElements( csn, options, pathDelimiter, error, iterateOptions = {
     forEach(dict, (elementName, element) => {
       if (element.elements) {
         // Ignore the structured element, replace it by its flattened form
-        // TODO: use $ignore - _ is for links
-        element._ignore = true;
+        element.$ignore = true;
 
         const branches = getBranches(element, elementName, effectiveType, pathDelimiter);
         const flatElems = flattenStructuredElement(element, elementName, [], path.concat([ 'elements', elementName ]));
@@ -308,6 +306,8 @@ function flattenElements( csn, options, pathDelimiter, error, iterateOptions = {
 
 
           if (flatElement.type && isAssocOrComposition(flatElement) && flatElement.on) {
+            // unmanaged relations can't be primary key
+            delete flatElement.key;
             // Make refs resolvable by fixing the first ref step
             for (const onPart of flatElement.on) {
               if (onPart.ref) {
@@ -441,6 +441,7 @@ function handleManagedAssociationsAndCreateForeignKeys( csn, options, error, war
    * @param {*} path
    */
   function flattenFKs( assoc, assocName, path ) {
+    // TODO Depth first search and not iterate mark and sweep approach
     let finished = false;
     while (!finished) {
       const newKeys = [];
@@ -465,8 +466,6 @@ function handleManagedAssociationsAndCreateForeignKeys( csn, options, error, war
         const { ref } = assoc.keys[i];
         if (isStructured(art)) {
           done = false;
-          // Mark this element to filter it later - not needed after expansion
-          setProp(assoc.keys[i], '$toDelete', true);
           const flat = flattenStructuredElement(art, ref[ref.length - 1], [], pathToKey);
           Object.keys(flat).forEach((flatElemName) => {
             const key = assoc.keys[i];
@@ -502,12 +501,10 @@ function handleManagedAssociationsAndCreateForeignKeys( csn, options, error, war
         }
         else if (art.target) {
           done = false;
-          // Mark this element to filter it later - not needed after expansion
-          setProp(assoc.keys[i], '$toDelete', true);
           // Directly work on csn.definitions - this way the changes take effect in csnRefs/inspectRef immediately
           // Add the newly generated foreign keys to the end - they will be picked up later on
           // Recursive solutions run into call stack issues
-          art.keys.forEach(key => collector.push(cloneAndExtendRef(key, assoc.keys[i], ref)));
+          art.keys?.forEach(key => collector.push(cloneAndExtendRef(key, assoc.keys[i], ref)));
         }
         else if (assoc.keys[i].ref && !assoc.keys[i].as) {
           setProp(assoc.keys[i], inferredAlias, true);
@@ -523,7 +520,6 @@ function handleManagedAssociationsAndCreateForeignKeys( csn, options, error, war
       }
       return done;
     }
-    assoc.keys = assoc.keys.filter(o => !o.$toDelete);
 
     /**
      * Clone base and extend the .ref and .as of the clone with the .ref and .as of ref.
@@ -612,6 +608,10 @@ function handleManagedAssociationsAndCreateForeignKeys( csn, options, error, war
           return acc;
         }, Object.create(null));
 
+        // set default for single foreign key from association (if available)
+        if (element.default?.val !== undefined && fks.length === 1)
+          fks[0][1].default = element.default;
+
         // check for duplicate foreign keys
         Object.entries(refCount).forEach(([ name, occ ]) => {
           if (occ > 1)

package/lib/transform/db/rewriteCalculatedElements.js

@@ -3,12 +3,16 @@
 const { setProp } = require('../../base/model');
 const { CompilerAssertion } = require('../../base/error');
 const {
-  forEachDefinition, applyTransformationsOnNonDictionary, applyTransformationsOnDictionary, implicitAs, cloneCsnNonDict, getUtils,
+  forEachDefinition,
+  applyTransformationsOnNonDictionary,
+  applyTransformationsOnDictionary,
+  implicitAs,
+  cloneCsnNonDict,
   forEachMemberRecursively,
 } = require('../../model/csnUtils');
 const { getBranches } = require('./flattening');
 const { getColumnMap } = require('./views');
-const { checkForeignKeyAccess } = require('../../checks/onConditions');
+const { requireForeignKeyAccess } = require('../../checks/onConditions');
 
 const cloneCsnOptions = { hiddenPropertiesToClone: [ '_art', '_links', '$env', '$scope' ] };
 
@@ -19,11 +23,13 @@ const cloneCsnOptions = { hiddenPropertiesToClone: [ '_art', '_links', '$env', '
  *
  * @param {CSN.Model} csn
  * @param {CSN.Options} options
+ * @param {object} csnUtils
  * @param {string} pathDelimiter
- * @param {Function} error
+ * @param {object} messageFunctions
  */
-function rewriteCalculatedElementsInViews( csn, options, pathDelimiter, error ) {
-  const { inspectRef, effectiveType } = getUtils(csn, 'init-all');
+function rewriteCalculatedElementsInViews( csn, options, csnUtils, pathDelimiter, messageFunctions ) {
+  const { inspectRef, effectiveType } = csnUtils;
+  const { error } = messageFunctions;
 
   const views = [];
   const entities = [];
@@ -121,7 +127,7 @@ function rewriteCalculatedElementsInViews( csn, options, pathDelimiter, error )
         }
         else {
           // It's a managed association - access of the foreign keys is allowed
-          checkForeignKeyAccess(parent, i, csnPath, (errorIndex) => {
+          requireForeignKeyAccess(parent, i, (errorIndex) => {
             error('ref-unexpected-navigation', csnPath, {
               '#': 'calc-non-fk', id, elemref: parent, name: value[errorIndex].id || value[errorIndex],
             });
@@ -412,7 +418,7 @@ function rewriteCalculatedElementsInViews( csn, options, pathDelimiter, error )
    * @param {CSN.QuerySelect} SELECT
    * @returns {object}
    */
-  function getDirectlyAdressableElements( SELECT ) {
+  function getDirectlyAddressableElements( SELECT ) {
     const { from } = SELECT;
     if (from.ref) {
       return from._art.elements;
@@ -422,7 +428,7 @@ function rewriteCalculatedElementsInViews( csn, options, pathDelimiter, error )
     }
     else if (from.SET) {
       // args[0] could be SELECT or UNION
-      return getDirectlyAdressableElements({ from: from.SET.args[0] });
+      return getDirectlyAddressableElements({ from: from.SET.args[0] });
     }
     else if (from.args) {
       const mergedElements = Object.create(null);
@@ -432,7 +438,7 @@ function rewriteCalculatedElementsInViews( csn, options, pathDelimiter, error )
             mergedElements[elementName] = arg._art.elements[elementName];
         }
         else if (arg.SET) {
-          return getDirectlyAdressableElements({ from: arg.SET.args[0] });
+          return getDirectlyAddressableElements({ from: arg.SET.args[0] });
         }
         else if (arg.SELECT) { // TODO: UNION
           for (const elementName in arg.SELECT.elements)
@@ -440,7 +446,7 @@ function rewriteCalculatedElementsInViews( csn, options, pathDelimiter, error )
         }
         else if (arg.args) { // TODO: Is it safe to do recursion here?
           for (const subarg of arg.args) {
-            const elements = getDirectlyAdressableElements({ from: subarg });
+            const elements = getDirectlyAddressableElements({ from: subarg });
             for (const elementName in elements)
               mergedElements[elementName] = elements[elementName];
           }
@@ -465,8 +471,8 @@ function rewriteCalculatedElementsInViews( csn, options, pathDelimiter, error )
    */
   function makeAllCalculatedElementsExplicitColumns( elements, SELECT, containsExpandInline ) {
     const cleanupCallbacks = [];
-    const root = getDirectlyAdressableElements(SELECT);
-    const columnMap = getColumnMap( { SELECT });
+    const root = getDirectlyAddressableElements(SELECT);
+    const columnMap = getColumnMap( { SELECT }, csnUtils );
     const hasStar = SELECT.columns.includes('*');
     const unfoldingMap = {};
     let starContainsCalculated = false;
@@ -699,9 +705,9 @@ function processCalculatedElementsInEntities( csn ) {
  */
 function removeDummyValueInEntity( artifact, path ) {
   applyTransformationsOnDictionary(artifact.elements, {
-    value: (parent, prop, value, p, root) => {
+    value: (parent, prop, value, p, elements) => {
       if (!value.stored)
-        delete root[p[p.length - 1]];
+        delete elements[p[p.length - 1]];
     },
   }, {}, path.concat( 'elements' ));
 }

package/lib/transform/db/temporal.js

@@ -5,7 +5,7 @@ const {
 } = require('../../model/csnUtils');
 const { implicitAs } = require('../../model/csnRefs');
 const { setProp } = require('../../base/model');
-const { getTransformers } = require('../transformUtilsNew');
+const { getTransformers } = require('../transformUtils');
 
 const validToString = '@cds.valid.to';
 const validFromString = '@cds.valid.from';

package/lib/transform/db/transformExists.js

@@ -53,22 +53,23 @@ const { ModelError } = require('../../base/error');
 function handleExists( csn, options, error, inspectRef, initDefinition, dropDefinitionCache ) {
   const generatedExists = new WeakMap();
   forEachDefinition(csn, (artifact, artifactName) => {
+    // drop cache: Otherwise, the projection/query hack below won't work, because csnRefs
+    // thinks that the artifact was already initialized (including all queries).
+    dropDefinitionCache(artifact);
     if (artifact.projection) // do the same hack we do for the other stuff...
       artifact.query = { SELECT: artifact.projection };
 
     if (artifact.query) {
-      forAllQueries(artifact.query, (query, path) => {
+      forAllQueries(artifact.query, function handleExistsQuery(query, path) {
         if (!generatedExists.has(query)) {
           const toProcess = []; // Collect all expressions we need to process here
-          if (query.SELECT && query.SELECT.where && query.SELECT.where.length > 1)
+          if (query.SELECT?.where?.length > 1)
             toProcess.push([ path.slice(0, -1), path.concat('where') ]);
 
-
-          if (query.SELECT && query.SELECT.columns)
+          if (query.SELECT?.columns)
             toProcess.push([ path.slice(0, -1), path.concat('columns') ]);
 
-
-          if (query.SELECT && query.SELECT.from.on )
+          if (query.SELECT?.from.on)
             toProcess.push([ path.slice(0, -1), path.concat([ 'from', 'on' ]) ]);
 
           for (const [ , exprPath ] of toProcess) {
@@ -268,7 +269,7 @@ function handleExists( csn, options, error, inspectRef, initDefinition, dropDefi
 
         const { links } = inspectRef(exprPath.concat(i));
 
-        const assocs = links.filter(link => link.art && link.art.target).map(link => current.ref[link.idx]);
+        const assocs = links.filter(link => link.art?.target).map(link => current.ref[link.idx]);
 
         checkForInvalidAssoc(assocs);
       }

package/lib/transform/db/views.js

@@ -1,10 +1,11 @@
 'use strict';
 
 const {
-  getUtils, cloneCsnNonDict, applyTransformationsOnNonDictionary,
+  getUtils, cloneCsnNonDict, applyTransformationsOnNonDictionary, forEachDefinition,
 } = require('../../model/csnUtils');
-const { implicitAs } = require('../../model/csnRefs');
+const { implicitAs, columnAlias } = require('../../model/csnRefs');
 const { ModelError } = require('../../base/error');
+const { setProp } = require('../../base/model');
 
 /**
  * If a mixin association is published, return the mixin association.
@@ -66,10 +67,11 @@ function usesMixinAssociation( query, association, associationName ) {
  * @returns {(query: CSN.Query, artifact: CSN.Artifact, artName: string, path: CSN.Path) => void} Transformer function for views
  */
 function getViewTransformer( csn, options, messageFunctions, transformCommon ) {
+  const csnUtils = getUtils(csn);
   const {
     get$combined, isAssocOrComposition,
     inspectRef, queryOrMain, // csnRefs
-  } = getUtils(csn);
+  } = csnUtils;
   const pathDelimiter = options.forHana && (options.sqlMapping === 'hdbcds') ? '.' : '_';
   const { error, info } = messageFunctions;
   const doA2J = !(options.transformation === 'hdbcds' && options.sqlMapping === 'hdbcds');
@@ -213,7 +215,7 @@ function getViewTransformer( csn, options, messageFunctions, transformCommon ) {
         else
           info('query-ignoring-assoc-in-union', queryPath, { name: elemName, '#': 'std' });
 
-        elem._ignore = true;
+        elem.$ignore = true;
       }
       else {
         error(null, queryPath, { name: elemName }, 'Association $(NAME) can\'t be published in a SAP HANA CDS UNION');
@@ -270,7 +272,7 @@ function getViewTransformer( csn, options, messageFunctions, transformCommon ) {
           }, {}, elementsPath.concat(elemName));
         }
 
-        if (!mixinElem._ignore)
+        if (!mixinElem.$ignore)
           columnMap[elemName] = { ref: [ mixinElemName ], as: elemName };
 
         if (query.SELECT) {
@@ -311,7 +313,7 @@ function getViewTransformer( csn, options, messageFunctions, transformCommon ) {
 
 
   /**
-   * Loop over the columns and call all of the given functions with the column and the path
+   * Loop over the columns and call all the given functions with the column and the path
    *
    * @param {Function[]} functions
    * @param {CSN.Column[]} columns
@@ -332,6 +334,7 @@ function getViewTransformer( csn, options, messageFunctions, transformCommon ) {
    */
   // eslint-disable-next-line complexity
   function transformViewOrEntity( query, artifact, artName, path ) {
+    csnUtils.initDefinition(artifact);
     const { elements } = queryOrMain(query, artifact);
     // We use the elements from the leading query/main artifact - adapt the path
     const elementsPath = elements === artifact.elements ? path.slice(0, 2).concat('elements') : path.concat('elements');
@@ -340,7 +343,7 @@ function getViewTransformer( csn, options, messageFunctions, transformCommon ) {
     let hasNonAssocElements = false;
     const isSelect = query && query.SELECT;
     const isProjection = !!artifact.projection || query && query.SELECT && !query.SELECT.columns;
-    const columnMap = getColumnMap(query);
+    const columnMap = getColumnMap(query, csnUtils);
     const isSelectStar = query && query.SELECT && query.SELECT.columns && query.SELECT.columns.indexOf('*') !== -1;
 
     // check all queries/subqueries for mixin publishing inside of unions -> forbidden in hdbcds
@@ -365,7 +368,7 @@ function getViewTransformer( csn, options, messageFunctions, transformCommon ) {
           addForeignKeysToColumns(columnMap, elem, elemName);
       }
       // Views must have at least one element that is not an unmanaged assoc
-      if (!elem.on && !elem._ignore)
+      if (!elem.on && !elem.$ignore)
         hasNonAssocElements = true;
 
       // (180 b) Create MIXINs for association elements in projections or views (those that are not mixins by themselves)
@@ -383,7 +386,7 @@ function getViewTransformer( csn, options, messageFunctions, transformCommon ) {
 
     if (isSelect) {
       // Build new columns from the column map - bring elements and columns back in sync basically
-      query.SELECT.columns = Object.keys(elements).filter(elem => !elements[elem]._ignore).map(key => stripLeadingSelf(columnMap[key]));
+      query.SELECT.columns = Object.keys(elements).filter(elem => !elements[elem].$ignore).map(key => stripLeadingSelf(columnMap[key]));
       // If following an association, explicitly set the implicit alias
       // due to an issue with HANA - this seems to only have an effect on ref files with hdbcds-hdbcds, so only run then
       const columnProcessors = [];
@@ -476,45 +479,82 @@ function getLastRefStepString( ref ) {
 }
 
 /**
- * Build a map of the resulting names (i.e. the element name of the column) and references to the respective columns
+ * This function is similar to csnRefs()' `columnName()`, but does not split the
+ * last `col.ref` segment on `.`.
  *
+ * TODO: The HDBCDS backend relies on this. Also the HDI backend relies
+ *       on this for virtual elements somehow.  That can probably be fixed
+ *       by using csnRefs()'s `getElement()`.
+ * TODO: Remove this function; update HDBCDS/HDI
+ *
+ * @param {CSN.Column} col
+ * @returns {string}
+ */
+function columnNameForMap( col ) {
+  return col.as || (!col.args && col.func) || (col.ref && getLastRefStepString( col.ref ));
+}
+
+/**
+ * Build a map of the resulting names (i.e. the element name of the column) and references
+ * to the respective columns.
  * This can later be used to match from elements to columns.
  *
  * @param {CSN.Query} query
+ * @param {object} csnUtils
  * @returns {object}
  */
-function getColumnMap( query ) {
+function getColumnMap( query, csnUtils ) {
   const map = Object.create(null);
-  if (query && query.SELECT && query.SELECT.columns) {
+  if (query?.SELECT?.columns) {
     query.SELECT.columns.forEach((col) => {
-      if (col === '*') {
-        // do nothing
-      }
-      else if (col.as) {
-        if (!map[col.as])
-          map[col.as] = col;
-      }
-      else if (col.ref) {
-        // .id on last path step can happen with hdbcds.hdbcds and malicious CSN input - maybe also with params?
-        // We made things right in the end with the second add of missing stuff, but why not do it
-        // right from the getgo
-        const last = getLastRefStepString(col.ref);
-        if (!map[last])
-          map[last] = col;
-      }
-      else if (col.func) {
-        map[col.func] = col;
-      }
-      else if (!map[col]) {
-        map[col] = col;
+      if (col !== '*') {
+        // Fallback to csnUtils for columns without any alias (internal one is created)
+        const as = columnNameForMap(col) || csnUtils.getColumnName( col );
+        if (as && !map[as])
+          map[as] = col;
       }
     });
   }
-
   return map;
 }
 
+
+/**
+ * Ensure that each column in the CSN has a name.  A column does not have
+ * a name if the column is an expression and there is no explicit alias.
+ * In that case an internal alias (from csnRefs()) is used and made explicit
+ * via non-enumerable `as`.
+ *
+ * For HDBCDS, the alias is made explicit as an enumerable property, because
+ * HDBCDS does not support expressions as columns without aliases.
+ *
+ * Notes:
+ *  - The alias is removed after A2J: we rely on the compiler ignoring non-enumerable CSN properties.
+ *  - We can't use e.g. `$as`, as csnRefs() does not use that property, and it must not
+ *    invent another name for the column (could happen after flattening).
+ *
+ * @param {CSN.Model} csn
+ * @param {CSN.Options} options
+ * @param {object} csnUtils
+ */
+function ensureColumnNames( csn, options, csnUtils ) {
+  forEachDefinition(csn, (def) => {
+    csnUtils.initDefinition(def);
+    for (const query of csnUtils.$getQueries(def) || []) {
+      for (const col of query._select.columns || []) {
+        if (col !== '*' && !columnAlias(col)) {
+          if (options.transformation === 'hdbcds')
+            col.as = csnUtils.getColumnName(col);
+          else
+            setProp(col, 'as', csnUtils.getColumnName(col));
+        }
+      }
+    }
+  });
+}
+
 module.exports = {
   getViewTransformer,
   getColumnMap,
+  ensureColumnNames,
 };