@sap/cds-compiler 2.10.2 → 2.11.4

package/lib/transform/forHanaNew.js

@@ -3,7 +3,7 @@
 const { setProp, isBetaEnabled } = require('../base/model');
 const { getUtils, cloneCsn, forEachGeneric,
         forEachMember,
-        forEachMemberRecursively, forEachRef,
+        forEachMemberRecursively, forEachRef, getNamespace, getResultingName,
         forAllQueries, forAllElements, hasAnnotationValue, getArtifactDatabaseNameOf,
         getElementDatabaseNameOf, isBuiltinType, applyTransformations,
         isPersistedOnDatabase, getNormalizedQuery, isAspect, walkCsnPath,
@@ -15,11 +15,10 @@ const { csnRefs, pathId, implicitAs } = require('../model/csnRefs');
 const { checkCSNVersion } = require('../json/csnVersion');
 const validate = require('../checks/validator');
 const { addLocalizationViewsWithJoins, addLocalizationViews } = require('../transform/localized');
-const timetrace = require('../utils/timetrace');
+const { timetrace } = require('../utils/timetrace');
 const { createReferentialConstraints, assertConstraintIdentifierUniqueness } = require('./db/constraints');
 const { createDict } = require('../utils/objectUtils');
 const handleExists = require('./db/transformExists');
-const { usesMixinAssociation, getMixinAssocOfQueryIfPublished } = require('./db/helpers');
 const replaceAssociationsInGroupByOrderBy = require('./db/groupByOrderBy');
 const _forEachDefinition = require('../model/csnUtils').forEachDefinition;
 const flattening = require('./db/flattening');
@@ -27,6 +26,7 @@ const expansion = require('./db/expansion');
 const assertUnique = require('./db/assertUnique');
 const generateDrafts = require('./db/draft');
 const enrichUniversalCsn = require('./universalCsnEnricher');
+const { getViewTransformer } = require('./db/views');
 
 // By default: Do not process non-entities/views
 function forEachDefinition(csn, cb) {
@@ -100,7 +100,6 @@ function forEachDefinition(csn, cb) {
  * @param {string}      moduleName The calling compiler module name, e.g. `to.hdi` or `to.hdbcds`.
  */
 function transformForHanaWithCsn(inputModel, options, moduleName) {
-  const columnClearer = [];
   // copy the model as we don't want to change the input model
   timetrace.start('HANA transformation');
   /** @type {CSN.Model} */
@@ -115,7 +114,7 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
   let error, warning, info; // message functions
   /** @type {() => void} */
   let throwWithError;
-  let artifactRef, inspectRef, queryOrMain, effectiveType, // csnRefs
+  let artifactRef, inspectRef, effectiveType, // csnRefs
     addDefaultTypeFacets, expandStructsInExpression, toFinalBaseType, getFinalBaseType, // transformUtils
     get$combined; // csnUtils
 
@@ -138,6 +137,9 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
     error, warning, info, inspectRef, effectiveType, artifactRef, csnUtils: getUtils(csn), csn, options, getFinalBaseType, isAspect
   });
 
+  // Needs to happen before tuple expansion, so the newly generated WHERE-conditions have it applied
+  handleExists(csn, options, error);
+
   // Check if structured elements and managed associations are compared in an expression
   // and expand these structured elements. This tuple expansion allows all other
   // subsequent procession steps (especially a2j) to see plain paths in expressions.
@@ -150,7 +152,6 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
   // FIXME: This does something very similar to cloneWithTransformations -> refactor?
   const transformCsn = transformUtils.transformModel;
 
-  handleExists(csn, options, error);
 
   // (001) Add a temporal where condition to views where applicable before assoc2join
   //       assoc2join eventually rewrites the table aliases
@@ -212,10 +213,6 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
     }
   });
 
-  // Must happen after A2J, as A2J needs $self to correctly resolve stuff
-  if(doA2J)
-    flattening.removeLeadingSelf(csn);
-
   const {
     flattenStructuredElement,
     flattenStructStepsInRef, getForeignKeyArtifact,
@@ -231,6 +228,7 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
     isStructured,
     addStringAnnotationTo,
     cloneWithTransformations,
+    getContextOfArtifact,
   } = getUtils(csn);
 
   // (000) Rename primitive types, make UUID a String
@@ -331,7 +329,7 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
   // because otherwise we would produce wrong ON-conditions for the keys involved. Sigh ...
   forEachDefinition(csn, transformSelfInBacklinks);
 
-  if(isBetaEnabled(options, 'foreignKeyConstraints') && options.forHana){
+  if(options.forHana){
     /**
      * Referential Constraints are only supported for sql-dialect "hana" and "sqlite".
      * For to.hdbcds with naming mode "hdbcds", no foreign keys are calculated,
@@ -343,7 +341,7 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
     if(validOptionsForConstraint())
       createReferentialConstraints(csn, options);
   }
-
+  // no constraints for drafts
   generateDrafts(csn, options, pathDelimiter, { info, warning, error });
 
   // Set the final constraint paths and produce hana tc indexes if required
@@ -356,6 +354,7 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
   // Apply view-specific transformations
   // (160) Projections now finally become views
   // Replace managed association in group/order by with foreign keys
+  const transformEntityOrViewPass2 = getViewTransformer(csn, options, {error, info}, transformCommon);
   forEachDefinition(csn, transformViews);
 
   // Recursively apply transformCommon and attach @cds.persistence.name
@@ -384,8 +383,6 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
     checkConstraintIdentifiers,
     /* (250) Remove all namespaces from definitions */
     removeNamespaces,
-    /* (190 b) Replace enum types by their final base type */
-    replaceEnumsByBaseTypes,
     /* Check Type Parameters (precision, scale, length ...) */
     checkTypeParameters,
     /* Filter out aspects/types/abstract entities containing managed compositions of anonymous aspects */
@@ -394,6 +391,10 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
     removeKeyPropInType,
   ]);
 
+  // Remove leading $self to keep renderer-diffs smaller
+  if(doA2J)
+    flattening.removeLeadingSelf(csn);
+
   throwWithError();
 
   timetrace.stop();
@@ -403,6 +404,7 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
   }
 
   const killers = {
+    // Used to ignore actions etc from processing and remove associations/elements
     '_ignore': function (parent, a, b, path){
       if(path.length > 2) {
         const tail = path[path.length-1];
@@ -413,25 +415,20 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
         delete parent._ignore;
       }
     },
-    '_art': killProp,
-    '_effectiveType': killProp,
+    // Still used in flattenStructuredElements - in db/flattening.js
     '_flatElementNameWithDots': killProp,
-    '_sources': killProp,
+    // Set when setting default string/binary length - used in copyTypeProperties and fixBorkedElementsOfLocalized
+    // to not copy the .length property if it was only set via default
     '$default': killProp,
-    '$draftRoot': killProp,
-    '$env': killProp,
-    '$fksgenerated': killProp,
-    '$lateFlattening': killProp,
-    '$path': killProp,
+    // Set when we turn UUID into String, checked during generateDraftForHana
     '$renamed': killProp,
-    '$key': killProp,
-    '$generatedExists': killProp
+    // Set when we remove .key from temporal things, used in localized.js
+    '$key': killProp
   }
 
   applyTransformations(csn, killers, [], false);
 
   redoProjections.forEach(fn => fn());
-  columnClearer.forEach(fn => fn());
 
   return csn;
 
@@ -496,14 +493,14 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
 
   function bindCsnReference(){
     ({ error, warning, info, throwWithError } = makeMessageFunction(csn, options, moduleName));
-    ({ artifactRef, inspectRef, queryOrMain, effectiveType } = csnRefs(csn));
+    ({ artifactRef, inspectRef, effectiveType } = csnRefs(csn));
     ({ getFinalBaseType, get$combined } = getUtils(csn));
     ({ addDefaultTypeFacets, expandStructsInExpression, toFinalBaseType } = transformUtils.getTransformers(csn, options, pathDelimiter));
   }
 
   function bindCsnReferenceOnly(){
     // invalidate caches for CSN ref API
-    ({ artifactRef, inspectRef, queryOrMain, effectiveType } = csnRefs(csn));
+    ({ artifactRef, inspectRef, effectiveType } = csnRefs(csn));
   }
 
   function handleMixinOnConditions(artifact, artifactName) {
@@ -619,20 +616,6 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
     }
   }
 
-  /**
-   * @param {CSN.Artifact} artifact
-   * @param {string} artifactName
-   */
-  function replaceEnumsByBaseTypes(artifact, artifactName) {
-    replaceEnumByBaseType(artifact);
-    forEachMemberRecursively(artifact, (member) => {
-      replaceEnumByBaseType(member);
-      if (options.forHana.alwaysResolveDerivedTypes || options.forHana.names === 'plain') {
-        toFinalBaseType(member);
-        addDefaultTypeFacets(member);
-      }
-    }, [ 'definitions', artifactName ]);
-  }
 
   /**
    * @param {CSN.Artifact} artifact
@@ -710,6 +693,7 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
   function handleAssociations(artifact, artifactName) {
     // Do things specific for entities and views (pass 1)
     if (artifact.kind === 'entity' || artifact.kind === 'view') {
+      const alreadyHandled = new WeakMap();
       forAllElements(artifact, artifactName, (parent, elements) => {
         for (const elemName in elements) {
           const elem = elements[elemName];
@@ -717,7 +701,7 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
           // (unless explicitly asked to keep assocs unchanged)
           if (doA2J) {
             if (isManagedAssociationElement(elem))
-              transformManagedAssociation(parent, artifactName, elem, elemName);
+              transformManagedAssociation(parent, artifactName, elem, elemName, alreadyHandled);
           }
         }
       })
@@ -814,14 +798,31 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
         || hasAnnotationValue(artifact, '@cds.persistence.exists'))
         artifact._ignore = true;
 
+      const namingMode = options.forHana && options.forHana.names;
       // issue #3450 HANA CDS can not handle external artifacts which are part of a HANA CDS context
-      if (options.forHana.names === 'quoted' &&
-          hasAnnotationValue(artifact, '@cds.persistence.exists')) {
-        const firstPath = artifactName.split('.')[0];
-        const topParent = csn.definitions[firstPath];
-        // namespaces, contexts and services become contexts in HANA CDS
-        if (topParent && [ 'namespace', 'context', 'service' ].includes(topParent.kind))
-          warning(null, [ 'definitions', artifactName ], `"${ artifactName }": external definition belongs to ${ topParent.kind } "${ firstPath }"`);
+      if (hasAnnotationValue(artifact, '@cds.persistence.exists') &&
+          options.transformation === 'hdbcds' &&
+          (namingMode === 'quoted' || namingMode === 'hdbcds')) {
+        let hanaCDSContextName;
+        if(namingMode === 'hdbcds') {
+          // for hdbcds names we only create a context if you defined a context/service in your cdl model
+          hanaCDSContextName = getContextOfArtifact(artifactName);
+        }
+        else {
+          // for quoted naming mode, we create a context if you either defined a context/service
+          // or a namespace in your cdl model
+          hanaCDSContextName = getContextOfArtifact(artifactName) || getNamespace(csn, artifactName);
+        }
+        if (hanaCDSContextName) {
+          warning('anno-unstable-hdbcds', [ 'definitions', artifactName ],
+            {
+              id: getResultingName(csn, options.forHana.names, artifactName),
+              name: getResultingName(csn, options.forHana.names, hanaCDSContextName),
+              anno: 'cds.persistence.exists',
+            },
+            'Do not use $(ANNO) on an entity named $(ID) in SAP HANA CDS when we also create a SAP HANA CDS context named $(NAME)'
+          );
+        }
       }
     }
   }
@@ -843,30 +844,6 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
       if (art.technicalConfig)
         newCsn.definitions[artName].technicalConfig = art.technicalConfig;
 
-      const newArt = newCsn.definitions[artName];
-
-      // No need to loop/check artifacts that won't reach the DB anyways
-      if (art.query && newArt && newArt.query && isPersistedOnDatabase(newArt)) {
-        // Loop through the newCSN and add possible new _ignore mixin to the kill list
-        forAllQueries(newArt.query, (q, p) => {
-          if (q.SELECT && q.SELECT.mixin) {
-            for(let mixinName of Object.keys(q.SELECT.mixin)) {
-              const mixinElement = q.SELECT.mixin[mixinName];
-              if (mixinElement._ignore && options.toSql) {
-                columnClearer.push(() => {
-                  const query = walkCsnPath(csn, p);
-                  for(let i = query.columns.length-1; i > -1; i--){
-                    const col = query.columns[i];
-                    if(col && col.ref && col.ref[0] === mixinName){
-                      query.columns.splice(i, 1);
-                    }
-                  }
-                });
-              }
-            }
-          }
-        }, ['definitions', artName, 'query']);
-      }
     });
     csn = newCsn;
   }
@@ -1052,10 +1029,12 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
     if (isPersistedOnDatabase(artifact)) {
       // TODO: structure in CSN is artifact.query.[SELECT/SET].mixin
       if (artifact.query) {
-        if (artifact.query.SELECT && artifact.query.SELECT.mixin)
+        // If we do A2J, we don't need to check the mixin. Either it is used -> a join
+        // or published -> handled via elements/members. Unused mixins are removed anyway. 
+        if (!doA2J && artifact.query.SELECT && artifact.query.SELECT.mixin)
           forEachGeneric(artifact.query.SELECT, 'mixin', ignore, path.concat([ 'query', 'SELECT' ]));
 
-        else if (artifact.query.SET && artifact.query.SET.mixin)
+        else if (!doA2J && artifact.query.SET && artifact.query.SET.mixin)
           forEachGeneric(artifact.query.SET, 'mixin', ignore, path.concat([ 'query', 'SET' ]));
       }
       forEachMemberRecursively(artifact, ignore, [ 'definitions', artifactName ]);
@@ -1096,6 +1075,9 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
 
     // (190 a) Replace enum symbols by their value (if found)
     replaceEnumSymbolsByValues(obj, path);
+
+    if (obj.enum)
+      delete obj.enum;
   }
 
   // Change the names of those builtin types that have different names in HANA.
@@ -1129,309 +1111,6 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
   //   }
   // }
 
-  /**
-  * Strip of leading $self of the ref
-  * @param {object} col A column
-  *
-  * @returns {object}
-  */
-  function stripLeadingSelf(col) {
-    if (col.ref && col.ref.length > 1 && col.ref[0] === '$self')
-      col.ref = col.ref.slice(1);
-
-
-    return col;
-  }
-
-  function isUnion(path){
-    const subquery = path[path.length-1];
-    const queryIndex = path[path.length-2]
-    const args = path[path.length-3];
-    const unionOperator = path[path.length-4];
-    return path.length > 3 && (subquery === 'SET' || subquery === 'SELECT') && typeof queryIndex === 'number' && queryIndex >= 0 && args === 'args' && unionOperator === 'SET';
-  }
-
-  function transformEntityOrViewPass2(query, artifact, artName, path) {
-    const { elements } = queryOrMain(query, artifact);
-    let hasNonAssocElements = false;
-    const isSelect = query && query.SELECT;
-    let isProjection = !!artifact.projection;
-    const columnMap = Object.create(null);
-    let isSelectStar = false;
-    if (isSelect) {
-      if (!query.SELECT.columns) {
-        isProjection = true;
-      }
-      else {
-        query.SELECT.columns.forEach((col) => {
-          if (col === '*') {
-            isSelectStar = true;
-          }
-          else if (col.as) {
-            if (!columnMap[col.as])
-              columnMap[col.as] = col;
-          }
-          else if (col.ref) {
-            if (!columnMap[col.ref[col.ref.length - 1]])
-              columnMap[col.ref[col.ref.length - 1]] = col;
-          }
-          else if (col.func) {
-            columnMap[col.func] = col;
-          }
-          else if (!columnMap[col]) {
-            columnMap[col] = col;
-          }
-        });
-      }
-    }
-    if (query && options.transformation === 'hdbcds') {
-      // check all queries/subqueries for mixin publishing inside of unions -> forbidden in hdbcds
-      if (query.SELECT && query.SELECT.mixin && path.indexOf('SET') !== -1) {
-        for (const elementName in elements) {
-          const element = elements[elementName];
-          if (element.target) {
-            let colLocation;
-            for (let i = 0; i < query.SELECT.columns.length; i++) {
-              const col = query.SELECT.columns[i];
-              if (col.ref && col.ref.length === 1) {
-                if (!colLocation && col.ref[0] === elementName)
-                  colLocation = i;
-
-
-                if (col.as === elementName)
-                  colLocation = i;
-              }
-            }
-            if (colLocation) {
-              const matchingCol = query.SELECT.columns[colLocation];
-              const possibleMixinName = matchingCol.ref[0];
-              const isMixin = query.SELECT.mixin[possibleMixinName] !== undefined;
-              if (element.target && isMixin)
-                error(null, path.concat([ 'columns', colLocation ]),
-                  `Element "${ elementName }" is a mixin association${ possibleMixinName !== elementName ? ` ("${ possibleMixinName }")` : '' } and can't be published in a UNION`);
-            }
-          }
-        }
-      }
-    }
-
-    // Second walk through the entity elements: Deal with associations (might also result in new elements)
-
-    // Will be initialized JIT inside the elements-loop
-    let $combined;
-
-    for (const elemName in elements) {
-      const elem = elements[elemName];
-      if (isSelect) {
-        if (!columnMap[elemName]) {
-          // Prepend an alias if present
-          let alias = (isProjection || isSelectStar) &&
-              (query.SELECT.from.as || (query.SELECT.from.ref && implicitAs(query.SELECT.from.ref)));
-          // In case of * and no explicit alias
-          // find the source of the col by looking at $combined and prepend it
-          if (isSelectStar && !alias && !isProjection) {
-            if (!$combined)
-              $combined = get$combined(query);
-
-
-            const matchingCombined = $combined[elemName];
-            // Internal errors - this should never happen!
-            if (matchingCombined.length > 1) { // should already be caught by compiler
-              throw new Error(`Ambiguous name - can't be resolved: ${ elemName }. Found in: ${ matchingCombined.map(o => o.parent) }`);
-            }
-            else if (matchingCombined.length === 0) { // no clue how this could happen? Invalid CSN?
-              throw new Error(`No matching entry found in UNION of all elements for: ${ elemName }`);
-            }
-            alias = matchingCombined[0].parent;
-          }
-          if (alias)
-            columnMap[elemName] = { ref: [ alias, elemName ] };
-          else
-            columnMap[elemName] = { ref: [ 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) {
-          const assoc_col = columnMap[elemName];
-          if (assoc_col && assoc_col.ref) {
-            elem.keys.forEach((key) => {
-              const ref = cloneCsn(assoc_col.ref, options);
-              ref[ref.length - 1] = [ ref[ref.length - 1] ].concat(key.as || key.ref).join(pathDelimiter);
-              const result = {
-                ref,
-              };
-              if (assoc_col.as)
-                result.as = key.$generatedFieldName;
-
-
-              if (assoc_col.key)
-                result.key = true;
-
-
-              const colName = result.as || ref[ref.length - 1];
-              columnMap[colName] = result;
-            });
-          }
-        }
-        // Add flattened structured things preserving aliases and refs with/without table alias
-        // If we add them when we get to them in "elements", we cannot know what table alias was used...
-        if (isStructured(elem) && doA2J) {
-          const col = columnMap[elemName];
-          const originalName = col.ref[col.ref.length - 1];
-          const flatElements = flattenStructuredElement(elem, originalName, [], path);
-          const aliasedFlatElements = originalName !== elemName ? Object.keys(flattenStructuredElement(elem, elemName, [], path)) : [];
-
-          Object.keys(flatElements).forEach((flatElemName, index ) => {
-            const clone = cloneCsn(col, options);
-            // For the ref, use the "original"
-            if (clone.ref)
-              clone.ref[clone.ref.length - 1] = flatElemName;
-
-            // If the column was aliased, use the alias-prefix for the flattened element
-            if (originalName !== elemName)
-              clone.as = aliasedFlatElements[index];
-
-            // Insert into map, giving precedence to the alias
-            columnMap[clone.as || flatElemName] = clone;
-          });
-        }
-      }
-      // Views must have at least one element that is not an unmanaged assoc
-      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)
-      // CDXCORE-585: Allow mixin associations to be used and published in parallel
-      if (query !== undefined && elem.target) {
-        if(isUnion(path) && options.transformation === 'hdbcds'){
-          if(isBetaEnabled(options, 'ignoreAssocPublishingInUnion') && doA2J){
-            if(elem.keys) {
-              info(null, path, `Managed association "${elemName}", published in a UNION, will be ignored`)
-            } else {
-              info(null, path, `Association "${elemName}", published in a UNION, will be ignored`)
-            }
-            elem._ignore = true;
-          }
-          else {
-            error(null, path, `Association "${elemName}" can't be published in a SAP HANA CDS UNION`)
-          }
-        } else if(path.length > 4 && options.transformation === 'hdbcds'){ // path.length > 4 -> is a subquery
-          error(null, path, { name: elemName },
-          'Association $(NAME) can\'t be published in a subquery')
-        } else {
-          /* Old implementation:
-        const isNotMixinByItself = !(elem.value && elem.value.path && elem.value.path.length == 1 && art.query && art.query.mixin && art.query.mixin[elem.value.path[0].id]);
-        */
-          const isNotMixinByItself = checkIsNotMixinByItself(query, columnMap, elem, elemName);
-          const {mixinElement, mixinName } = getMixinAssocOfQueryIfPublished(query, elem, elemName);
-          if (isNotMixinByItself || mixinElement !== undefined) {
-            // If the mixin is only published and not used, only display the __ clone. Ignore the "original".
-            if (mixinElement !== undefined && !usesMixinAssociation(query, elem, elemName)){
-              mixinElement._ignore = true;
-            }
-
-            delete elem._typeIsExplicit;
-            // Create an unused alias name for the MIXIN - use 3 _ to avoid collision with usings
-            let mixinElemName = `___${ mixinName || elemName }`;
-            while (elements[mixinElemName])
-              mixinElemName = `_${ mixinElemName }`;
-
-          // Copy the association element to the MIXIN clause under its alias name
-          // (shallow copy is sufficient, just fix name and value)
-            const mixinElem = Object.assign({}, elem);
-          // Perform common transformations on the newly generated MIXIN element (won't be reached otherwise)
-            transformCommon(mixinElem, mixinElemName);
-          // TODO: Can we rely on query.SELECT.mixin to check for mixins?
-          // Yes, we can - only SELECT can have mixin. But:
-          // - UNION
-          // - JOINS
-          // - Subqueries
-          // Are currently (and in the old transformer) not handled!
-            if (query.SELECT && !query.SELECT.mixin)
-              query.SELECT.mixin = Object.create(null);
-
-          // Let the original association element use the newly generated MIXIN name as value and alias
-            delete elem.viaAll;
-
-          // Clone 'on'-condition, pre-pending '$projection' to paths where appropriate,
-          // and fixing the association alias just created
-
-            if (mixinElem.on) {
-              mixinElem.on = cloneWithTransformations(mixinElem.on, {
-                ref: (ref) => {
-                // Clone the path, without any transformations
-                  const clonedPath = cloneWithTransformations(ref, {});
-                // Prepend '$projection' to the path, unless the first path step is the (mixin) element itself or starts with '$')
-                  if (clonedPath[0] == elemName) {
-                    clonedPath[0] = mixinElemName;
-                  }
-                  else if (!(clonedPath[0] && clonedPath[0].startsWith('$'))) {
-                    const projectionId = '$projection';
-                    clonedPath.unshift(projectionId);
-                  }
-                  return clonedPath;
-                },
-                func: (func) => {
-                // Unfortunately, function names are disguised as paths, so we would prepend a '$projection'
-                // above (no way to distinguish that in the callback for 'path' above). We can only pluck it
-                // off again here ... sigh
-                  if (func.ref && func.ref[0] && func.ref[0] === '$projection')
-                    func.ref = func.ref.slice(1);
-
-                  return func;
-                },
-              });
-            }
-
-            if (!mixinElem._ignore)
-              columnMap[elemName] = { ref: [ mixinElemName ], as: elemName };
-
-            if (query.SELECT) {
-              query.SELECT.mixin[mixinElemName] = mixinElem;
-            }
-          }
-        }
-      }
-    }
-
-    if (query && !hasNonAssocElements) {
-      // Complain if there are no elements other than unmanaged associations
-      // Allow with plain
-      error(null, [ 'definitions', artName ], { $reviewed: true } ,
-        'Expecting view or projection to have at least one element that is not an unmanaged association');
-    }
-
-    if (isSelect) {
-      // Workaround for bugzilla 176495 FIXME FIXME FIXME: is this really still needed?
-      // If a select item of a cdx view contains an expression, the result type cannot be computed
-      // but must be explicitly specified. This is important for the OData channel, which doesn't
-      // work if the type is missing (for HANA channel an explicit type is not required, as HANA CDS
-      // can compute the result type).
-      // Due to bug in HANA CDS, providing explicit type 'LargeString' or 'LargeBinary' causes a
-      // diserver crash. Until a fix in HANA CDS is available, we allow to suppress the explicit
-      // type in the HANA channel via an annotation.
-      Object.keys(columnMap).forEach((value) => {
-        const elem = elements[value];
-        if (elem && elem['@cds.workaround.noExplicitTypeForHANA'])
-          delete columnMap[value].cast;
-      });
-
-      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
-      for (let i = 0; i < query.SELECT.columns.length; i++) {
-        const col = query.SELECT.columns[i];
-        if (!col.as && col.ref && col.ref.length > 1) {
-          const { links } = inspectRef(path.concat([ 'columns', i ]));
-          if (links && links.slice(0, -1).some(({ art }) => isAssocOrComposition(art && art.type || '')))
-            col.as = col.ref[col.ref.length - 1];
-        }
-      }
-      delete query.SELECT.excluding;  // just to make the output of the new transformer the same as the old
-    }
-  }
-
 
   // If 'elem' has a default that is an enum constant, replace that by its value. Complain
   // if not found or not an enum type,
@@ -1448,7 +1127,7 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
         // Looks like it is always run?! But message says HANA CDS?!
         error(null, path, {
           $reviewed: true,
-          name: `#${elem.default['#']}`
+          name: `#${ elem.default['#'] }`
         },
         'Expecting enum literal $(NAME) to be used with an enum type');
       }
@@ -1458,7 +1137,7 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
         if (!enumSymbol) {
           error(null, path, {
             $reviewed: true,
-            name: `#${elem.default['#']}`
+            name: `#${ elem.default['#'] }`
           }, 'Enum literal $(NAME) is undefined in enumeration type');
         }
         else if (enumSymbol.val !== undefined) { // `val` may be `null`
@@ -1475,30 +1154,6 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
     }
   }
 
-  // If 'node' has an enum type, change node's type to be the enum's base type
-  // and strip off the 'enum' property.
-  function replaceEnumByBaseType(node) {
-    if (node.items)
-      replaceEnumByBaseType(node.items);
-
-    // (190 b) Replace enum types by their final base type (must happen after 190 a)
-    /* Old implementation:
-    if (node && node._finalType && (node.enum || node._finalType.enum)) {
-      node.type = node._finalType.type
-      // node.type = node._finalType.type._artifact._finalType.type;
-      if (node._finalType.length) {
-        node.length = node._finalType.length;
-      }
-      setProp(node, '_finalType', node.type._artifact);
-      delete node.enum;
-    }
-    */
-    if (node && node.enum) {
-      // toFinalBaseType(node);
-      // addDefaultTypeFacets(node);
-      delete node.enum;
-    }
-  }
 
   // If the association element 'elem' of 'art' is a backlink association, massage its ON-condition
   // (in place) so that it
@@ -1538,14 +1193,7 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
             if (multipleExprs)
               result.push(')');
             i += 3;
-             // remember name of backlink, important for foreign key constraints
-            if(elem.$selfOnCondition)
-              elem.$selfOnCondition.backlinkName += `_${ backlinkName }`;
-            else {
-              setProp(elem, '$selfOnCondition', {
-                backlinkName
-              }) // important for the foreign key constraints
-            }
+            attachBacklinkInformation(backlinkName);
           }
           else if (isDollarSelfOrProjectionOperand(xprArgs[i + 2]) && isAssociationOperand(xprArgs[i], path.concat([ i ]))) {
             const assoc = inspectRef(path.concat([ i ])).art;
@@ -1556,14 +1204,7 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
             if (multipleExprs)
               result.push(')');
             i += 3;
-            // remember name of backlink, important for foreign key constraints
-            if(elem.$selfOnCondition)
-              elem.$selfOnCondition.backlinkName += `_${ backlinkName }`;
-            else {
-              setProp(elem, '$selfOnCondition', {
-                backlinkName
-              }) // important for the foreign key constraints
-            }
+            attachBacklinkInformation(backlinkName);
           }
           // Otherwise take one (!) token unchanged
           else {
@@ -1583,6 +1224,24 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
         }
       }
       return result;
+
+      /**
+       * The knowledge whether an association was an `<up_>` association in a
+       * `$self = <comp>.<up_>` comparison, is important for the foreign key constraints.
+       * By the time we generate them, such on-conditions are already transformed
+       * --> no more `$self` in the on-conditions, that is why we need to remember it here.
+       *
+       * @param {string} backlinkName name of `<up_>` in a `$self = <comp>.<up_>` comparison
+       */
+      function attachBacklinkInformation(backlinkName) {
+        if (elem.$selfOnCondition)
+          elem.$selfOnCondition.up_.push(backlinkName);
+        else {
+          setProp(elem, '$selfOnCondition', {
+            up_: [backlinkName]
+          });
+        }
+      }
     }
 
     elem.on = processExpressionArgs(elem.on, pathToOn);
@@ -1683,6 +1342,10 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
         if (ref[0] === assocName) // we are in the "path" from the forwarding assoc => need to remove the first part of the path
         {
           ref.shift();
+        } else if(ref && ref.length > 1 && ref[0] === '$self' && ref[1] === assocName) {
+          // We could also have a $self infront of the assoc name - so we would need to shift twice
+          ref.shift();
+          ref.shift();
         }
         else { // we are in the backlink assoc "path" => need to push at the beginning the association's id
           ref.unshift(elemName);
@@ -1696,26 +1359,6 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
     }
   }
 
-  /**
-   * @todo: XSN - Implementation most likely too naive, can we rely on query.SELECT.mixin?
-   *
-   * @param {CSN.Query} query
-   * @param {object} columnMap
-   * @param {CSN.Artifact} columnMap
-   * @param {string} elementName
-   */
-  function checkIsNotMixinByItself(query, columnMap, element, elementName) {
-    if (query && query.SELECT && query.SELECT.mixin) {
-      const col = columnMap[elementName];
-
-      const realName = col.ref[col.ref.length - 1];
-      // If the element is not part of the mixin => True
-      return query.SELECT.mixin[realName] == undefined;
-    }
-    // the artifact does not define any mixins, the element cannot be a mixin
-    return true;
-  }
-
   /**
    * @param {CSN.Artifact} artifact
    * @param {string} artifactName
@@ -2050,11 +1693,12 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
                       const source = findSource(links, i - 1) || artifact;
                       // allow specifying managed assoc on the source side
                       const fks = link.art.keys.filter(fk => ref[i] + pathDelimiter + fk.ref[0] ===  sourceElementName);
-
                       if(fks && fks.length >= 1){
                         const fk = fks[0];
-                        if(source && source.elements[fk.$generatedFieldName])
-                          refOwner.ref = [ ...ref.slice(0, i), fk.$generatedFieldName ];
+                        const managedAssocStepName = refOwner.ref[i];
+                        const fkName = `${ managedAssocStepName }${ pathDelimiter }${ fk.as }`;
+                        if(source && source.elements[fkName])
+                          refOwner.ref = [ ...ref.slice(0, i), fkName ];
                       }
                     }
                   }
@@ -2093,12 +1737,13 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
    * @param {string} artifactName
    * @param {Object} elem The association to process
    * @param {string} elemName
+   * @param {WeakMap} alreadyHandled To cache which elements were already processed
    * @returns {void}
    */
-  function transformManagedAssociation(artifact, artifactName, elem, elemName) {
+  function transformManagedAssociation(artifact, artifactName, elem, elemName, alreadyHandled) {
     // No need to run over this - we already did, possibly because it was referenced in the ON-Condition
     // of another association - see a few lines lower
-    if (elem.$fksgenerated)
+    if (alreadyHandled.has(elem))
       return;
     // Generate foreign key elements for managed associations, and assemble an ON-condition with them
     const onCondParts = [];
@@ -2115,10 +1760,10 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
             elemName,
           ].concat(foreignKey.ref),
         };
-
+        const fkName =  `${ elemName }${ pathDelimiter }${ foreignKey.as }`;
         const fKeyArg = {
           ref: [
-            foreignKey.$generatedFieldName,
+            fkName,
           ],
         };
 
@@ -2157,7 +1802,7 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
         elem.implicitForeignKeys = true;
     */
     // Remember that we already processed this
-    setProp(elem, '$fksgenerated', true);
+    alreadyHandled.set(elem, true); 
   }
 }