@sap/cds-compiler 2.10.4 → 2.12.0

package/lib/transform/forHanaNew.js

@@ -1,25 +1,23 @@
 'use strict';
 
 const { setProp, isBetaEnabled } = require('../base/model');
-const { getUtils, cloneCsn, forEachGeneric,
-        forEachMember,
-        forEachMemberRecursively, forEachRef,
-        forAllQueries, forAllElements, hasAnnotationValue, getArtifactDatabaseNameOf,
-        getElementDatabaseNameOf, isBuiltinType, applyTransformations,
-        isPersistedOnDatabase, getNormalizedQuery, isAspect, walkCsnPath,
+const { getUtils, cloneCsn,
+        forEachMemberRecursively, forEachRef, forAllQueries,
+        getArtifactDatabaseNameOf, getElementDatabaseNameOf, isBuiltinType, applyTransformations,
+        isAspect, walkCsnPath,
       } = require('../model/csnUtils');
 const { makeMessageFunction } = require('../base/messages');
 const transformUtils = require('./transformUtilsNew');
 const { translateAssocsToJoinsCSN } = require('./translateAssocsToJoins');
-const { csnRefs, pathId, implicitAs } = require('../model/csnRefs');
+const { csnRefs, pathId } = require('../model/csnRefs');
 const { checkCSNVersion } = require('../json/csnVersion');
 const validate = require('../checks/validator');
+const { rejectManagedAssociationsAndStructuresForHdbcsNames } = require('../checks/selectItems');
 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 +25,10 @@ const expansion = require('./db/expansion');
 const assertUnique = require('./db/assertUnique');
 const generateDrafts = require('./db/draft');
 const enrichUniversalCsn = require('./universalCsnEnricher');
+const { getViewTransformer } = require('./db/views');
+const cdsPersistence = require('./db/cdsPersistence');
+const temporal = require('./db/temporal');
+const associations = require('./db/associations')
 
 // By default: Do not process non-entities/views
 function forEachDefinition(csn, cb) {
@@ -100,7 +102,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,16 +116,16 @@ 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
 
   bindCsnReference();
 
   throwWithError(); // reclassify and throw in case of non-configurable errors
-  
+
   if (options.csnFlavor === 'universal' && isBetaEnabled(options, 'enableUniversalCsn')) {
-    enrichUniversalCsn(csn, options); 
+    enrichUniversalCsn(csn, options);
     bindCsnReference();
   }
 
@@ -138,11 +139,16 @@ 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.
   // If errors are detected, throwWithError() will return from further processing
 
+  // If this function is ever undefined, we have a bug in our logic.
+  // @ts-ignore
   expandStructsInExpression(csn, { drillRef: true });
 
   throwWithError();
@@ -150,11 +156,10 @@ 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
-  forEachDefinition(csn, addTemporalWhereConditionToView);
+  forEachDefinition(csn, temporal.getViewDecorator(csn, {info}));
 
   // check unique constraints - further processing is done in rewriteUniqueConstraints
   assertUnique.prepare(csn, options, error, info);
@@ -212,23 +217,15 @@ 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,
+    flattenStructStepsInRef,
     isAssociationOperand, isDollarSelfOrProjectionOperand,
-    extractValidFromToKeyElement, checkAssignment, checkMultipleAssignments,
-    recurseElements
   } = transformUtils.getTransformers(csn, options, pathDelimiter);
 
   const {
     getCsnDef,
     isAssocOrComposition,
-    isManagedAssociationElement,
-    isStructured,
     addStringAnnotationTo,
     cloneWithTransformations,
   } = getUtils(csn);
@@ -273,28 +270,28 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
   // (040) Ignore entities and views that are abstract or implemented
   // or carry the annotation cds.persistence.skip/exists
   // These entities are not removed from the csn, but flagged as "to be ignored"
-  forEachDefinition(csn, handleCdsPersistence);
+  forEachDefinition(csn, cdsPersistence.getAnnoProcessor(csn, options, {warning}));
 
 
   // (050) Check @cds.valid.from/to only on entity
   //       Views are checked in (001), unbalanced valid.from/to's or mismatching origins
   //       Temporal only in beta-mode
-  forEachDefinition(csn, handleTemporalAnnotations);
+  forEachDefinition(csn, temporal.getAnnotationHandler(csn, options, pathDelimiter, {error}));
 
   handleManagedAssociationsAndCreateForeignKeys();
-  
+
   function handleManagedAssociationsAndCreateForeignKeys() {
-    forEachDefinition(csn, (art, artName) => handleManagedAssociationFKs(art, artName));
-    forEachDefinition(csn, (art, artName) => createForeignKeyElements(art, artName));
+    forEachDefinition(csn, associations.getForeignKeyFlattener(csn, options, pathDelimiter));
+    forEachDefinition(csn, associations.getForeignKeyElementCreator(csn, options, pathDelimiter, { error }));
   }
 
   forEachDefinition(csn, flattenIndexes);
   // Basic handling of associations in views and entities
-  forEachDefinition(csn, handleAssociations);
+  forEachDefinition(csn, associations.getManagedAssociationTransformer(csn, options, pathDelimiter));
 
   // (045) Strip all query-ish properties from views and projections annotated with '@cds.persistence.table',
   // and make them entities
-  forEachDefinition(csn, handleQueryish);
+  forEachDefinition(csn, cdsPersistence.getPersistenceTableProcessor(csn, options, {error}));
 
   // Allow using managed associations as steps in on-conditions to access their fks
   // To be done after handleAssociations, since then the foreign keys of the managed assocs
@@ -311,6 +308,14 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
   else
     addLocalizationViews(csn, options);
 
+  forEachDefinition(csn, (definition, artName, prop, path) => {
+    if (definition.query) {
+      // reject managed association and structure publishing for to-hdbcds.hdbcds
+      const that = { csnUtils: getUtils(csn), options, error };
+      rejectManagedAssociationsAndStructuresForHdbcsNames.call(that, definition, path)
+    }
+  });
+
   // For generating DB stuff:
   // - table-entity with parameters: not allowed
   // - view with parameters: ok on HANA, not allowed otherwise
@@ -331,7 +336,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,19 +348,20 @@ 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
   // See function comment for extensive information.
   assertUnique.rewrite(csn, options, pathDelimiter);
 
-  // Associations that point to thins marked with @cds.persistence.skip are removed
-  forEachDefinition(csn, ignoreAssociationToSkippedTarget);
+  // Associations that point to things marked with @cds.persistence.skip are removed
+  forEachDefinition(csn, cdsPersistence.getAssocToSkippedIgnorer(csn, options, {info}));
 
   // 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 +390,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 +398,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 +411,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,97 +422,35 @@ 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;
 
   /* ----------------------------------- Functions start here -----------------------------------------------*/
 
-  /**
-   * Create the foreign key elements for managed associations.
-   * Create them in-place, right after the corresponding association.
-   *
-   *
-   * @param {CSN.Artifact} art
-   * @param {string} artName
-   */
-  function createForeignKeyElements(art, artName) {
-    if ((art.kind === 'entity' || art.kind === 'view') && doA2J) {
-      forAllElements(art, artName, (parent, elements, pathToElements) => {
-        const elementsArray = [];
-        forEachGeneric(parent, 'elements', (element, elemName) => {
-          elementsArray.push([elemName, element]);
-          if (isManagedAssociationElement(element)) {
-            if (element.keys) {
-              for(let i = 0; i < element.keys.length; i++){
-                const foreignKey = element.keys[i];
-                const path =  [...pathToElements, elemName, 'keys', i];
-                foreignKey.ref = flattenStructStepsInRef(foreignKey.ref, path);
-                const [fkName, fkElem] = getForeignKeyArtifact(element, elemName, foreignKey, path);
-                if(parent.elements[fkName]) {
-                  error(null, [...pathToElements, elemName], { name: fkName, art: elemName },
-                       'Generated foreign key element $(NAME) for association $(ART) conflicts with existing element');
-                } else {
-                  elementsArray.push([fkName, fkElem]);
-                }
-                applyCachedAlias(foreignKey);
-                // join ref array as the struct / assoc steps are not necessary anymore
-                foreignKey.ref = [foreignKey.ref.join(pathDelimiter)]
-              }
-            }
-          }
-        });
-
-        // Don't fake consistency of the model by adding empty elements {}
-        if(elementsArray.length === 0)
-          return;
-
-        parent.elements = elementsArray.reduce((previous, [name, element]) => {
-          previous[name] = element;
-          return previous;
-        }, Object.create(null));
-
-      })
-    }
-
-    function applyCachedAlias(foreignKey) {
-      // If we have a $ref use that - it resolves aliased FKs correctly
-      if (foreignKey.$ref) {
-        foreignKey.ref = foreignKey.$ref;
-        delete foreignKey.$ref;
-      }
-    }
-  }
-
-
   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 +566,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
@@ -641,7 +574,8 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
   function transformSelfInBacklinks(artifact, artifactName, dummy, path) {
     // Fixme: For toHana mixins must be transformed, for toSql -d hana
     // mixin elements must be transformed, why can't toSql also use mixins?
-    doit(artifact.elements, path.concat([ 'elements' ]));
+    if(artifact.kind === 'entity' || artifact.query || (options.toHana && options.toHana.names === 'hdbcds' && artifact.kind == 'type'))
+      doit(artifact.elements, path.concat([ 'elements' ]));
     if (artifact.query && artifact.query.SELECT && artifact.query.SELECT.mixin)
       doit(artifact.query.SELECT.mixin, path.concat([ 'query', 'SELECT', 'mixin' ]));
 
@@ -699,60 +633,6 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
     }, [ 'definitions', artifactName ]);
   }
 
-  /**
-   *
-   * Generate foreign keys for managed associations
-   * Forbid aliases for foreign keys
-   *
-   * @param {CSN.Artifact} artifact
-   * @param {string} artifactName
-   */
-  function handleAssociations(artifact, artifactName) {
-    // Do things specific for entities and views (pass 1)
-    if (artifact.kind === 'entity' || artifact.kind === 'view') {
-      forAllElements(artifact, artifactName, (parent, elements) => {
-        for (const elemName in elements) {
-          const elem = elements[elemName];
-          // (140) Generate foreign key elements and ON-condition for managed associations
-          // (unless explicitly asked to keep assocs unchanged)
-          if (doA2J) {
-            if (isManagedAssociationElement(elem))
-              transformManagedAssociation(parent, artifactName, elem, elemName);
-          }
-        }
-      })
-    }
-  }
-
-  function fixBorkedElementsOfLocalized(elements, pathToElements){
-    const pathToNonLocalized = ['definitions', pathToElements[1].replace('localized.',''), ...pathToElements.slice(2)];
-    const nonLocalizedElements = walkCsnPath(csn, pathToNonLocalized);
-
-
-    for(const elementName in elements){
-      const element = elements[elementName];
-      const reference = nonLocalizedElements[elementName];
-
-      // if the declared element is an enum, these values are with priority
-      if (!element.enum && reference.enum)
-        Object.assign(element, { enum: reference.enum });
-      if (!element.length && reference.length && !reference.$default)
-        Object.assign(element, { length: reference.length });
-      if (!element.precision && reference.precision)
-        Object.assign(element, { precision: reference.precision });
-      if (!element.scale && reference.scale)
-        Object.assign(element, { scale: reference.scale });
-      if (!element.srid && reference.srid)
-        Object.assign(element, { srid: reference.srid });
-      if (!element.keys && reference.keys)
-        Object.assign(element, { keys: cloneCsn(reference.keys, options)})
-      if (!element.type && reference.type)
-        Object.assign(element, { type: reference.type})
-      if (!element.on && reference.on && !reference.keys)
-        Object.assign(element, {on: cloneCsn(reference.on, options)})
-    }
-  }
-
   /**
    * @param {CSN.Artifact} artifact
    * @param {string} artifactName
@@ -784,48 +664,6 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
     }
   }
 
-   /**
-    * @param {CSN.Artifact} artifact
-    * @param {string} artifactName
-    */
-  function handleQueryish(artifact, artifactName) {
-    const stripQueryish = artifact.query && hasAnnotationValue(artifact, '@cds.persistence.table');
-
-    if (stripQueryish) {
-      artifact.kind = 'entity';
-      delete artifact.query;
-    }
-
-    recurseElements(artifact, [ 'definitions', artifactName ], (member, path) => {
-      // All elements must have a type for this to work
-      if (stripQueryish && !member._ignore && !member.kind && !member.type)
-        error(null, path, 'Expecting element to have a type if view is annotated with “@cds.persistence.table“');
-    });
-  }
-
-  /**
-   * @param {CSN.Artifact} artifact
-   * @param {string} artifactName
-   */
-  function handleCdsPersistence(artifact, artifactName) {
-    if (artifact.kind === 'entity' || artifact.kind === 'view') {
-      if (artifact.abstract
-        || hasAnnotationValue(artifact, '@cds.persistence.skip')
-        || hasAnnotationValue(artifact, '@cds.persistence.exists'))
-        artifact._ignore = true;
-
-      // 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 }"`);
-      }
-    }
-  }
-
   function handleAssocToJoins() {
     // With flattening errors, it makes little sense to continue.
     throwWithError();
@@ -843,242 +681,11 @@ 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;
   }
 
-  /**
-   * @param {CSN.Artifact} artifact
-   * @param {string} artifactName
-   */
-  function handleTemporalAnnotations(artifact, artifactName) {
-    const validFrom = [];
-    const validTo = [];
-    const validKey = [];
-
-    recurseElements(artifact, [ 'definitions', artifactName ], (member, path) => {
-      const [ f, t, k ] = extractValidFromToKeyElement(member, path);
-      validFrom.push(...f);
-      validTo.push(...t);
-      validKey.push(...k);
-    });
-
-    if (artifact.kind === 'entity' && !artifact.query) {
-      validFrom.forEach(obj => checkAssignment('@cds.valid.from', obj.element, obj.path, artifact));
-      validTo.forEach(obj => checkAssignment('@cds.valid.to', obj.element, obj.path, artifact));
-      validKey.forEach(obj => checkAssignment('@cds.valid.key', obj.element, obj.path, artifact));
-      checkMultipleAssignments(validFrom, '@cds.valid.from', artifact, artifactName);
-      checkMultipleAssignments(validTo, '@cds.valid.to', artifact, artifactName, true);
-      checkMultipleAssignments(validKey, '@cds.valid.key', artifact, artifactName);
-    }
-
-    // if there is an cds.valid.key, make this the only primary key
-    // otherwise add all cds.valid.from to primary key tuple
-    if (validKey.length) {
-      if (!validFrom.length || !validTo.length)
-        error(null, [ 'definitions', artifactName ],
-        'Expecting “@cds.valid.from” and “@cds.valid.to” if “@cds.valid.key” is used');
-
-      forEachMember(artifact, (member) => {
-        if (member.key) {
-          member.unique = true;
-          delete member.key;
-          // Remember that this element was a key in the original artifact.
-          // This is needed for localized convenience view generation.
-          setProp(member, '$key', true);
-        }
-      });
-      validKey.forEach((member) => {
-        member.element.key = true;
-      });
-
-      validFrom.forEach((member) => {
-        member.element.unique = true;
-      });
-    }
-    else {
-      validFrom.forEach((member) => {
-        member.element.key = true;
-      });
-    }
-  }
 
-  function hasFalsyTemporalAnnotations(SELECT, elements, from, to) {
-    let fromElement = elements[from.name];
-    let toElement = elements[to.name];
-
-    if(SELECT.columns) {
-      for(const col of SELECT.columns) {
-        if(col.ref) {
-          const implicitAlias = implicitAs(col.ref);
-          if(implicitAlias === from.name)
-            fromElement = elements[col.as || implicitAlias];
-          else if(implicitAlias === to.name)
-            toElement = elements[col.as || implicitAlias];
-        }
-      }
-    }
-    const val = fromElement && toElement && hasAnnotationValue(fromElement, '@cds.valid.from', false) && hasAnnotationValue(toElement, '@cds.valid.to', false);
-    return val;
-  }
-
-  /**
-   * Add a where condition to views that
-   * - are annotated with @cds.valid.from and @cds.valid.to,
-   * - have only one @cds.valid.from and @cds.valid.to,
-   * - and both annotations come from the same entity
-   *
-   * If the view has one of the annotations but the other conditions are not met, an error will be raised.
-   *
-   * @param {CSN.Artifact} artifact
-   * @param {string} artifactName
-   */
-  function addTemporalWhereConditionToView(artifact, artifactName) {
-    const normalizedQuery = getNormalizedQuery(artifact);
-    if (normalizedQuery && normalizedQuery.query && normalizedQuery.query.SELECT) {
-      // BLOCKER: We need information to handle $combined
-      // What we are trying to achieve by this:
-      // Forbid joining/selecting from two or more temporal entities
-      // Idea: Follow the query-tree and check each from
-      // Collect all source-entities and compute our own $combined
-      const $combined = get$combined(normalizedQuery.query);
-      const [ from, to ] = getFromToElements($combined);
-      // exactly one validFrom & validTo
-      if (from.length === 1 && to.length === 1) {
-        // and both are from the same origin
-        if (from[0].source === to[0].source && from[0].parent === to[0].parent) {
-          if(!hasFalsyTemporalAnnotations(normalizedQuery.query.SELECT, artifact.elements, from[0], to[0])) {
-            const fromPath = {
-              ref: [
-                from[0].parent,
-                from[0].name,
-              ],
-            };
-
-            const toPath = {
-              ref: [
-                to[0].parent,
-                to[0].name,
-              ],
-            };
-
-
-            const atFrom = { ref: [ '$at', 'from' ] };
-            const atTo = { ref: [ '$at', 'to' ] };
-
-            const cond = [ '(', fromPath, '<', atTo, 'and', toPath, '>', atFrom, ')' ];
-
-            if (normalizedQuery.query.SELECT.where) { // if there is an existing where-clause, extend it by adding 'and (temporal clause)'
-              normalizedQuery.query.SELECT.where = [ '(', ...normalizedQuery.query.SELECT.where, ')', 'and', ...cond ];
-            }
-            else {
-              normalizedQuery.query.SELECT.where = cond;
-            }
-          }
-        }
-        else {
-          info(null, [ 'definitions', artifactName ], `No temporal WHERE clause added as "${ from[0].error_parent }"."${ from[0].name }" and "${ to[0].error_parent }"."${ to[0].name }" are not of same origin`);
-        }
-      }
-      else if (from.length > 0 || to.length > 0) {
-        const missingAnnotation = from.length > to.length ? '@cds.valid.to' : '@cds.valid.from';
-        info(null, [ 'definitions', artifactName ],
-          { anno: missingAnnotation },
-          'No temporal WHERE clause added because $(ANNO) is missing'
-        )
-      }
-    }
-  }
-
-  /**
-   * Get all elements tagged with @cds.valid.from/to from the union of all entities of the from-clause.
-   *
-   * @param {any} combined union of all entities of the from-clause
-   * @returns {Array[]} Array where first field is array of elements with @cds.valid.from, second field is array of elements with @cds.valid.to.
-   */
-  function getFromToElements(combined) {
-    const from = [];
-    const to = [];
-    for (const name in combined) {
-      let elt = combined[name];
-      if (!Array.isArray(elt))
-        elt = [ elt ];
-      elt.forEach((e) => {
-        if (hasAnnotationValue(e.element, '@cds.valid.from'))
-          from.push(e);
-
-        if (hasAnnotationValue(e.element, '@cds.valid.to'))
-          to.push(e);
-      });
-    }
-
-    return [ from, to ];
-  }
-
-  /**
-   * Associations that target a @cds.persistence.skip artifact must be removed
-   * from the persistence model
-   *
-   * @param {CSN.Artifact} artifact
-   * @param {string} artifactName
-   * @param {string} prop
-   * @param {CSN.Path} path
-   */
-  function ignoreAssociationToSkippedTarget(artifact, artifactName, prop, path) {
-    if (isPersistedOnDatabase(artifact)) {
-      // TODO: structure in CSN is artifact.query.[SELECT/SET].mixin
-      if (artifact.query) {
-        if (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)
-          forEachGeneric(artifact.query.SET, 'mixin', ignore, path.concat([ 'query', 'SET' ]));
-      }
-      forEachMemberRecursively(artifact, ignore, [ 'definitions', artifactName ]);
-    }
-    function ignore(member, memberName, prop, path) {
-      if (dialect === 'hana' && !member._ignore && member.target && isAssocOrComposition(member.type) && isUnreachableAssociationTarget(csn.definitions[member.target])) {
-        const targetAnnotation = hasAnnotationValue(csn.definitions[member.target], '@cds.persistence.exists') ? '@cds.persistence.exists' : '@cds.persistence.skip';
-        info(null, path,
-          { target: member.target, anno: targetAnnotation },
-          'Association has been removed as it\'s target $(TARGET) is annotated with $(ANNO)'
-        );
-        member._ignore = true;
-      }
-    }
-  }
-
-  /**
-   * @param {CSN.Artifact} art
-   * @returns {boolean}
-   */
-  function isUnreachableAssociationTarget(art) {
-    return !isPersistedOnDatabase(art) || hasAnnotationValue(art, '@cds.persistence.exists');
-  }
 
   /**
    * Remove `localized` from elements and replace Enum symbols by their values.
@@ -1096,6 +703,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 +739,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 +755,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 +765,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 +782,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 +821,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 +832,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 +852,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);
@@ -1653,14 +940,12 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
         conditions.push([ a[0], '=', a[1] ]);
       });
 
-      const result = conditions.reduce((prev, current) => {
+      return conditions.reduce((prev, current) => {
         if (prev.length === 0)
           return [ ...current ];
 
         return [ ...prev, 'and', ...current ];
       }, []);
-
-      return result;
     }
 
     // For a condition `<elemName>.<assoc> = $self` in the ON-condition of element <elemName>,
@@ -1683,6 +968,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 +985,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
@@ -1812,148 +1081,6 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
     return !(options.toSql && type === 'cds.String' && (options.toSql.dialect === 'sqlite' || options.toSql.dialect === 'plain'));
   }
 
-  /**
-   * Flatten and create the foreign key elements of managed associaitons
-   *
-   * @param {CSN.Artifact} art
-   * @param {string} artName
-   */
-  function handleManagedAssociationFKs(art, artName) {
-    if ((art.kind === 'entity' || art.kind === 'view') && doA2J) {
-      forAllElements(art, artName, (parent, elements, pathToElements) => {
-        if(artName.startsWith('localized.') && pathToElements.length > 3) {
-          // In subqueries, the elements of localized views are missing all the important bits and pieces...
-          fixBorkedElementsOfLocalized(elements, pathToElements);
-        }
-        forEachGeneric(parent, 'elements', (element, elemName) => {
-          if (isManagedAssociationElement(element)) {
-            if (element.keys) {
-              // replace foreign keys that are managed associations by their respective foreign keys
-              flattenFKs(element, elemName, [ ...pathToElements, elemName ]);
-            }
-          }
-        });
-      })
-    }
-  }
-
-
-  /**
-   * Flattens all foreign keys
-   *
-   * Structures will be resolved to individual elements with scalar types
-   *
-   * Associations will be replaced by their respective foreign keys
-   *
-   * If a structure contains an assoc, this will also be resolved and vice versa
-   *
-   * @param {*} assoc
-   * @param {*} assocName
-   * @param {*} path
-   */
-  function flattenFKs(assoc, assocName, path) {
-    let finished = false;
-    while(!finished) {
-      const newKeys = [];
-      finished = processKeys(assoc, assocName, path, newKeys);
-      assoc.keys = newKeys;
-    }
-
-    function processKeys(assoc, assocName, path, collector) {
-      let finished = true;
-      for (let i = 0; i < assoc.keys.length; i++) {
-        const pathToKey = path.concat([ 'keys', i ]);
-        const { art } = inspectRef(pathToKey);
-        const { ref } = assoc.keys[i];
-        if (isStructured(art)) {
-          finished = 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];
-            const clone = cloneCsn(assoc.keys[i], options);
-            if (clone.as) {
-              const lastRef = clone.ref[clone.ref.length - 1];
-              // Cut off the last ref part from the beginning of the flat name
-              const flatBaseName = flatElemName.slice(lastRef.length);
-              // Join it to the existing table alias
-              clone.as += flatBaseName;
-              // do not loose the $ref for nested keys
-              if(key.$ref){
-                let aliasedLeaf = key.$ref[key.$ref.length - 1 ];
-                aliasedLeaf += flatBaseName;
-                setProp(clone, '$ref', key.$ref.slice(0, key.$ref.length - 1).concat(aliasedLeaf));
-              }
-            }
-            if (clone.ref) {
-              clone.ref[clone.ref.length - 1] = flatElemName;
-              // Now we need to properly flatten the whole ref
-              clone.ref = flattenStructStepsInRef(clone.ref, pathToKey);
-            }
-            if (!clone.as) {
-              clone.as = flatElemName;
-              // TODO: can we use $inferred? Does it have other weird side-effects?
-              setProp(clone, '$inferredAlias', 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
-            collector.push(clone);
-          });
-        }
-        else if (art.target) {
-          finished = 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)));
-        }
-        else if (assoc.keys[i].ref && !assoc.keys[i].as) {
-          setProp(assoc.keys[i], '$inferredAlias', true);
-          assoc.keys[i].as = assoc.keys[i].ref[assoc.keys[i].ref.length - 1];
-          collector.push(assoc.keys[i]);
-        } else {
-          collector.push(assoc.keys[i]);
-        }
-      }
-      return finished;
-    }
-    assoc.keys = assoc.keys.filter(o => !o.$toDelete);
-  }
-
-  function cloneAndExtendRef(key, base, ref) {
-    const clone = cloneCsn(base, options);
-    if (key.ref) {
-      // We build a ref that contains the aliased fk - that element will be created later on, so this ref is not resolvable yet
-      // Therefore we keep it as $ref - ref is the non-aliased, resolvable "clone"
-      // Later on, after we know that these foreign key elements are created, we replace ref with this $ref
-      let $ref;
-      if(base.$ref){
-        // if a base $ref is provided, use it to correctly resolve association chains
-        const refChain =  [base.$ref[base.$ref.length - 1]].concat(key.as || key.ref);
-        $ref = base.$ref.slice(0, base.$ref.length - 1).concat(refChain)
-      } else {
-        $ref = base.ref.concat( key.as || key.ref); // Keep along the aliases
-      }
-      setProp(clone, '$ref', $ref);
-      clone.ref = clone.ref.concat(key.ref);
-    }
-
-    if (!clone.as && clone.ref && clone.ref.length > 0) {
-      clone.as = ref[ref.length - 1] + pathDelimiter + (key.as || key.ref.join(pathDelimiter));
-      // TODO: can we use $inferred? Does it have other weird side-effects?
-      setProp(clone, '$inferredAlias', true);
-    }
-    else {
-      clone.as += pathDelimiter + (key.as || key.ref.join(pathDelimiter));
-    }
-
-    return clone;
-  }
-
   /**
    * Flatten technical configuration stuff
    *
@@ -2050,11 +1177,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 ];
                       }
                     }
                   }
@@ -2085,80 +1213,6 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
       return undefined;
     }
   }
-
-  /**
-   * Create the foreign key elements for a managed association and build the on-condition
-   *
-   * @param {CSN.Artifact} artifact
-   * @param {string} artifactName
-   * @param {Object} elem The association to process
-   * @param {string} elemName
-   * @returns {void}
-   */
-  function transformManagedAssociation(artifact, artifactName, elem, elemName) {
-    // 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)
-      return;
-    // Generate foreign key elements for managed associations, and assemble an ON-condition with them
-    const onCondParts = [];
-    let join_with_and = false;
-    if(elem.keys.length === 0)
-      elem._ignore = true;
-    else {
-      for (let i = 0; i < elem.keys.length; i++) {
-        const foreignKey = elem.keys[i];
-
-      // Assemble left hand side of 'assoc.key = fkey'
-        const assocKeyArg = {
-          ref: [
-            elemName,
-          ].concat(foreignKey.ref),
-        };
-
-        const fKeyArg = {
-          ref: [
-            foreignKey.$generatedFieldName,
-          ],
-        };
-
-        if (join_with_and) { // more than one FK
-          onCondParts.push('and');
-        }
-
-        onCondParts.push(
-        assocKeyArg
-      );
-        onCondParts.push('=');
-        onCondParts.push(fKeyArg);
-
-        if (!join_with_and)
-          join_with_and = true;
-      }
-      elem.on = onCondParts;
-    }
-
-    // If the managed association has a 'key' property => remove it as unmanaged assocs cannot be keys
-    // TODO: Are there other modifiers (like 'key') that are valid for managed, but not valid for unmanaged assocs?
-    if (elem.key)
-      delete elem.key;
-
-
-    // If the managed association has a 'not null' property => remove it
-    if (elem.notNull)
-      delete elem.notNull;
-
-
-    // The association is now unmanaged, i.e. actually it should no longer have foreign keys
-    // at all. But the processing of backlink associations below expects to have them, so
-    // we don't delete them (but mark them as implicit so that toCdl does not render them)
-    /* Skip for now - forHana adds this to elements, but it is not part of the resulting CSN
-        forHanaNew -> Somehow ends up in the CSN?!
-        elem.implicitForeignKeys = true;
-    */
-    // Remember that we already processed this
-    setProp(elem, '$fksgenerated', true);
-  }
 }