@sap/cds-compiler 2.11.2 → 2.13.6

package/lib/transform/forHanaNew.js

@@ -1,19 +1,18 @@
 '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, forAllQueries, applyTransformationsOnNonDictionary,
+        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 { rejectManagedAssociationsAndStructuresForHdbcdsNames } = require('../checks/selectItems');
 const { addLocalizationViewsWithJoins, addLocalizationViews } = require('../transform/localized');
 const { timetrace } = require('../utils/timetrace');
 const { createReferentialConstraints, assertConstraintIdentifierUniqueness } = require('./db/constraints');
@@ -24,9 +23,13 @@ const _forEachDefinition = require('../model/csnUtils').forEachDefinition;
 const flattening = require('./db/flattening');
 const expansion = require('./db/expansion');
 const assertUnique = require('./db/assertUnique');
-const generateDrafts = require('./db/draft');
-const enrichUniversalCsn = require('./universalCsnEnricher');
+const generateDrafts = require('./draft/db');
+const enrichUniversalCsn = require('./universalCsn/universalCsnEnricher');
 const { getViewTransformer } = require('./db/views');
+const cdsPersistence = require('./db/cdsPersistence');
+const temporal = require('./db/temporal');
+const associations = require('./db/associations')
+const { ModelError } = require("../base/error");
 
 // By default: Do not process non-entities/views
 function forEachDefinition(csn, cb) {
@@ -111,19 +114,19 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
 
   const pathDelimiter = (options.forHana.names === 'hdbcds') ? '.' : '_';
 
-  let error, warning, info; // message functions
+  let message, error, warning, info; // message functions
   /** @type {() => void} */
   let throwWithError;
-  let artifactRef, inspectRef, effectiveType, // csnRefs
-    addDefaultTypeFacets, expandStructsInExpression, toFinalBaseType, getFinalBaseType, // transformUtils
-    get$combined; // csnUtils
+  let artifactRef, inspectRef, effectiveType, get$combined,
+    getFinalBaseType, // csnUtils (csnRefs)
+    addDefaultTypeFacets, expandStructsInExpression; // transformUtils
 
   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();
   }
 
@@ -134,7 +137,7 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
 
   // Run validations on CSN - each validator function has access to the message functions and the inspect ref via this
   const cleanup = validate.forHana(csn, {
-    error, warning, info, inspectRef, effectiveType, artifactRef, csnUtils: getUtils(csn), csn, options, getFinalBaseType, isAspect
+    message, 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
@@ -145,6 +148,8 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
   // 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();
@@ -155,7 +160,7 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
 
   // (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);
@@ -213,57 +218,25 @@ 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);
 
   // (000) Rename primitive types, make UUID a String
   transformCsn(csn, {
-    type: (val, node, key, path) => {
-      // Resolve type-of chains
-      function fn() {
-        // val can be undefined: books as myBooks : redirected to Model.MyBooks
-        if (val && val.ref) {
-          const { art } = inspectRef(path);
-          if (art && art.type) {
-            val = art.type;
-            // This is somehow needed to update the ref so that inspectRef sees it
-            node[key] = val;
-            if (val.ref)
-              fn();
-          }
-          else {
-            // Doesn't seem to ever ocurr
-          }
-        }
-      }
-      fn();
+    type: (val, node, key) => {
       renamePrimitiveTypesAndUuid(val, node, key);
       addDefaultTypeFacets(node);
     },
-    cast: (val) => {
-      if (options.forHana.names === 'plain' || options.toSql )
-        toFinalBaseType(val);
-      renamePrimitiveTypesAndUuid(val.type, val, 'type');
-      addDefaultTypeFacets(val);
-    },
     // HANA/SQLite do not support array-of - turn into CLOB/Text
     items: (val, node) => {
       node.type = 'cds.LargeString';
@@ -274,36 +247,32 @@ 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());
 
 
   // (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);
-
-  handleManagedAssociationsAndCreateForeignKeys();
-  
-  function handleManagedAssociationsAndCreateForeignKeys() {
-    forEachDefinition(csn, (art, artName) => handleManagedAssociationFKs(art, artName));
-    forEachDefinition(csn, (art, artName) => createForeignKeyElements(art, artName));
-  }
+  forEachDefinition(csn, temporal.getAnnotationHandler(csn, options, pathDelimiter, {error}));
+
+  // eliminate the doA2J in the functions 'handleManagedAssociationFKs' and 'createForeignKeyElements'
+  doA2J && flattening.handleManagedAssociationsAndCreateForeignKeys(csn, options, error, pathDelimiter, true, { allowArtifact: artifact => (artifact.kind === 'entity') });
 
-  forEachDefinition(csn, flattenIndexes);
-  // Basic handling of associations in views and entities
-  forEachDefinition(csn, handleAssociations);
+  doA2J && forEachDefinition(csn, flattenIndexes);
+  // Managed associations get an on-condition - in views and entities
+  doA2J && associations.attachOnConditions(csn, 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
   // are part of the elements
-  forEachDefinition(csn, handleManagedAssocStepsInOnCondition);
+  if (doA2J)
+    forEachDefinition(csn, associations.getManagedAssocStepsInOnConditionFinalizer(csn, pathDelimiter));
 
   // Create convenience views for localized entities/views.
-  // To be done after handleManagedAssocStepsInOnCondition because associations are
+  // To be done after getManagedAssocStepsInOnConditionFinalizer because associations are
   // handled and before handleDBChecks which removes the localized attribute.
   // Association elements of localized convenience views do not have hidden properties
   // like $managed set, so we cannot do this earlier on.
@@ -312,6 +281,14 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
   else
     addLocalizationViews(csn, options);
 
+  !doA2J && 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 };
+      rejectManagedAssociationsAndStructuresForHdbcdsNames.call(that, definition, path)
+    }
+  });
+
   // For generating DB stuff:
   // - table-entity with parameters: not allowed
   // - view with parameters: ok on HANA, not allowed otherwise
@@ -332,18 +309,14 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
   // because otherwise we would produce wrong ON-conditions for the keys involved. Sigh ...
   forEachDefinition(csn, transformSelfInBacklinks);
 
-  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,
-     * hence we do not generate the referential constraints for them.
-     */
-    const validOptionsForConstraint = () => {
-      return (options.forHana.dialect === 'sqlite' || options.forHana.dialect === 'hana') && doA2J;
-    }
-    if(validOptionsForConstraint())
-      createReferentialConstraints(csn, options);
-  }
+  /**
+   * Referential Constraints are only supported for sql-dialect "hana" and "sqlite".
+   * For to.hdbcds with naming mode "hdbcds", no foreign keys are calculated,
+   * hence we do not generate the referential constraints for them.
+   */
+  if((options.sqlDialect === 'hana' || options.sqlDialect === 'sqlite') && doA2J)
+    createReferentialConstraints(csn, options);
+
   // no constraints for drafts
   generateDrafts(csn, options, pathDelimiter, { info, warning, error });
 
@@ -351,8 +324,8 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
   // 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
@@ -366,34 +339,20 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
   const checkConstraintIdentifiers = (artifact, artifactName, prop, path) => {
     assertConstraintIdentifierUniqueness(artifact, artifactName, path, error);
   };
-  const removeNamespaces = (artifact, artifactName) => {
-    if (artifact.kind === 'namespace')
-      delete csn.definitions[artifactName];
-  };
-  const ignoreNonPersistedArtifactsWithAnonymousAspectComposition = (artifact) => {
-    if(artifact.kind === 'type' || artifact.kind === 'aspect' || artifact.kind === 'entity' && artifact.abstract){
-      if(artifact.elements && Object.keys(artifact.elements).some((elementName) => {
-        const element = artifact.elements[elementName];
-        return !element.target && element.targetAspect && typeof element.targetAspect !== 'string';
-      })) {
-        artifact._ignore = true;
-      }
-    }
-  };
 
   forEachDefinition(csn, [
     /* assert that there will be no conflicting unique- and foreign key constraint identifiers */
     checkConstraintIdentifiers,
-    /* (250) Remove all namespaces from definitions */
-    removeNamespaces,
     /* Check Type Parameters (precision, scale, length ...) */
     checkTypeParameters,
-    /* Filter out aspects/types/abstract entities containing managed compositions of anonymous aspects */
-    ignoreNonPersistedArtifactsWithAnonymousAspectComposition,
     // (200) Strip 'key' property from type elements
     removeKeyPropInType,
   ]);
 
+  // Remove leading $self to keep renderer-diffs smaller
+  if(doA2J)
+    flattening.removeLeadingSelf(csn);
+
   throwWithError();
 
   timetrace.stop();
@@ -425,7 +384,7 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
     '$key': killProp
   }
 
-  applyTransformations(csn, killers, [], false);
+  applyTransformations(csn, killers, [], { skipIgnore: false});
 
   redoProjections.forEach(fn => fn());
 
@@ -433,68 +392,10 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
 
   /* ----------------------------------- 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, effectiveType } = csnRefs(csn));
-    ({ getFinalBaseType, get$combined } = getUtils(csn));
-    ({ addDefaultTypeFacets, expandStructsInExpression, toFinalBaseType } = transformUtils.getTransformers(csn, options, pathDelimiter));
+    ({ error, warning, info, message, throwWithError } = makeMessageFunction(csn, options, moduleName));
+    ({ artifactRef, inspectRef, effectiveType, getFinalBaseType, get$combined } = getUtils(csn));
+    ({ addDefaultTypeFacets, expandStructsInExpression } = transformUtils.getTransformers(csn, options, pathDelimiter));
   }
 
   function bindCsnReferenceOnly(){
@@ -521,8 +422,8 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
           }
         })
       }
-    }
-    , [ 'definitions', artifactName, 'query' ]);
+    }, [ 'definitions', artifactName, 'query' ]);
+
     function getResolvedMixinOnCondition(csn, mixinAssociation, query, assocName, path){
       const { inspectRef } = csnRefs(csn);
       const referencedThroughStar = query.SELECT.columns.some((column) => column === '*');
@@ -573,7 +474,7 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
   function transformViews(artifact, artifactName) {
     if (!artifact._ignore) {
       // Do things specific for entities and views (pass 2)
-      if ((artifact.kind === 'entity' || artifact.kind === 'view') && artifact.query) {
+      if ((artifact.kind === 'entity') && artifact.query) {
         forAllQueries(artifact.query, (q, p) => {
           transformEntityOrViewPass2(q, artifact, artifactName, p)
           replaceAssociationsInGroupByOrderBy(q, options, inspectRef, error, p);
@@ -588,7 +489,7 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
    */
   function recursivelyApplyCommon(artifact, artifactName) {
     if (!artifact._ignore) {
-      if (![ 'service', 'context', 'namespace', 'annotation', 'action', 'function' ].includes(artifact.kind))
+      if (artifact.kind !== 'service' && artifact.kind !== 'context')
         addStringAnnotationTo('@cds.persistence.name', getArtifactDatabaseNameOf(artifactName, options.forHana.names, csn), artifact);
 
       forEachMemberRecursively(artifact, (member, memberName, property, path) => {
@@ -607,9 +508,9 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
    * @param {string} artifactName
    */
   function removeKeyPropInType(artifact, artifactName) {
-    if (!artifact._ignore) {
+    if (!artifact._ignore && artifact.kind === 'type') {
       forEachMemberRecursively(artifact, (member) => {
-        if (artifact.kind === 'type' && member.key)
+        if (member.key)
           delete member.key;
       }, [ 'definitions', artifactName ]);
     }
@@ -623,7 +524,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' ]));
 
@@ -657,91 +559,38 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
         if (artifact.params) {
           // HANA does not allow 'WITH ASSOCIATIONS' on something with parameters:
           // SAP DBTech JDBC: [7]: feature not supported: parameterized sql view cannot support association: line 1 col 1 (at pos 0)
-          error(null, path, 'Unexpected association in parameterized view');
+          message('def-unexpected-paramview-assoc', path, { '#': 'view' });
         }
         else if(artifact['@cds.persistence.udf'] || artifact['@cds.persistence.calcview']) {
           // UDF/CVs w/o params don't support 'WITH ASSOCIATIONS'
-          error(null, path, `Associations are not allowed in entities annotated with @cds.persistence { udf, calcview }`);
+          const anno = artifact['@cds.persistence.udf'] ? '@cds.persistence.udf' : '@cds.persistence.calcview';
+          message('def-unexpected-calcview-assoc', path, { '#': 'entity-persistence', anno });
         }
         if (csn.definitions[member.target].params) {
           // HANA does not allow association targets with parameters or to UDFs/CVs w/o parameters:
           // SAP DBTech JDBC: [7]: feature not supported: cannot support create association to a parameterized view
-          error(null, path, 'Unexpected parameterized association target');
+          message('def-unexpected-paramview-assoc', path, { '#': 'target' });
         }
-        else if(csn.definitions[member.target]['@cds.persistence.udf'] || artifact['@cds.persistence.calcview']) {
+        else if(csn.definitions[member.target]['@cds.persistence.udf'] || csn.definitions[member.target]['@cds.persistence.calcview']) {
           // HANA won't check the assoc target but when querying an association with target UDF, this is the error:
           // SAP DBTech JDBC: [259]: invalid table name: target object SYSTEM.UDF does not exist: line 3 col 6 (at pos 43)
           // CREATE TABLE F (id INTEGER NOT NULL);
           // CREATE FUNCTION UDF RETURNS TABLE (ID INTEGER) LANGUAGE SQLSCRIPT SQL SECURITY DEFINER AS BEGIN RETURN SELECT ID FROM F; END;
           // CREATE TABLE Y (  id INTEGER NOT NULL,  toUDF_id INTEGER) WITH ASSOCIATIONS (MANY TO ONE JOIN UDF AS toUDF ON (toUDF.id = toUDF_id));
           // CREATE VIEW U AS SELECT  id, toUDF.a FROM Y;
-          error(null, path, `Associations can't point to entities annotated with @cds.persistence { udf, calcview }`);
+          const anno = csn.definitions[member.target]['@cds.persistence.udf'] ? '@cds.persistence.udf' : '@cds.persistence.calcview';
+          message('def-unexpected-calcview-assoc', path, { '#': 'target-persistence', anno });
         }
       }
     }, [ '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') {
-      const alreadyHandled = new WeakMap();
-      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, alreadyHandled);
-          }
-        }
-      })
-    }
-  }
-
-  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
    */
   function handleChecksForWithParameters(artifact, artifactName) {
-    if (!artifact._ignore && artifact.params && (artifact.kind === 'entity' || artifact.kind === 'view')) {
+    if (!artifact._ignore && artifact.params && (artifact.kind === 'entity')) {
       if (!artifact.query) { // table entity with params
         // Allow with plain
         error(null, [ 'definitions', artifactName ], { '#': options.toSql ? 'sql' : 'std' }, {
@@ -767,48 +616,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();
@@ -830,216 +637,7 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
     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 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 (!doA2J && 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.
@@ -1262,7 +860,7 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
       else if (assoc.on)
         return transformDollarSelfComparisonWithUnmanagedAssoc(assocOp, assoc, assocName, elemName);
 
-      throw new Error(`Expected either managed or unmanaged association in $self-comparison: ${ JSON.stringify(elem.on) }`);
+      throw new ModelError(`Expected either managed or unmanaged association in $self-comparison: ${ JSON.stringify(elem.on) }`);
     }
 
     // For a condition `<elemName>.<assoc> = $self` in the ON-condition of element <elemName>,
@@ -1294,14 +892,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>,
@@ -1319,18 +915,23 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
       const newOnCond = cloneWithTransformations(assoc.on, {
         ref: (value) => cloneWithTransformations(value, {}),
       });
-      // goes through the the newOnCond and transform all the 'path' elements
-      forEachRef(newOnCond, (ref) => {
-        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 { // we are in the backlink assoc "path" => need to push at the beginning the association's id
-          ref.unshift(elemName);
-          // if there was a $self identifier in the forwarding association onCond
-          // we do not need it any more, as we prepended in the previous step the back association's id
-          if (ref[1] === '$self')
-            ref.splice(1, 1);
+      applyTransformationsOnNonDictionary({on: newOnCond}, 'on', {
+        ref: (parent, prop, ref) => {
+          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);
+            // if there was a $self identifier in the forwarding association onCond
+            // we do not need it any more, as we prepended in the previous step the back association's id
+            if (ref[1] === '$self')
+              ref.splice(1, 1);
+          }
         }
       });
       return newOnCond;
@@ -1433,148 +1034,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
    *
@@ -1584,7 +1043,7 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
   function flattenIndexes(art, artName) {
     // Flatten structs in indexes (unless explicitly asked to keep structs)
     const tc = art.technicalConfig;
-    if ((art.kind === 'entity' || art.kind === 'view') && doA2J) {
+    if (art.kind === 'entity') {
       if (tc && tc[dialect]) {
         // Secondary and fulltext indexes
         for (const name in tc[dialect].indexes) {
@@ -1638,150 +1097,6 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
       }
     }
   }
-
-  /**
-   * Loop over all elements and for all unmanaged associations translate
-   * <assoc base>.<managed assoc>.<fk> to <assoc base>.<managed assoc>_<fk>
-   *
-   * Or in other words: Allow using the foreign keys of managed associations in on-conditions
-   *
-   * @param {CSN.Artifact} artifact Artifact to check
-   * @param {string} artifactName Name of the artifact
-   */
-  function handleManagedAssocStepsInOnCondition(artifact, artifactName) {
-    for (const elemName in artifact.elements) {
-      const elem = artifact.elements[elemName];
-      if (doA2J) {
-        // The association is an unmanaged on
-        if (!elem.keys && elem.target && elem.on) {
-          forEachRef(elem.on, (ref, refOwner, path) => {
-            // [<assoc base>.]<managed assoc>.<field>
-            if (ref.length > 1) {
-              const { links } = inspectRef(path);
-              if (links) {
-                // eslint-disable-next-line for-direction
-                for (let i = links.length - 1; i >= 0; i--) {
-                  const link = links[i];
-                  // We found the latest managed assoc path step
-                  if (link.art && link.art.target && link.art.keys) {
-                    // Doesn't work when ref-target (filter condition) or similar is used
-                    if (!ref.slice(i).some(refElement => typeof refElement !== 'string')) {
-                      // We join the managed assoc with everything following it
-                      const sourceElementName = ref.slice(i).join(pathDelimiter);
-                      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];
-                        const managedAssocStepName = refOwner.ref[i];
-                        const fkName = `${ managedAssocStepName }${ pathDelimiter }${ fk.as }`;
-                        if(source && source.elements[fkName])
-                          refOwner.ref = [ ...ref.slice(0, i), fkName ];
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }, [ 'definitions', artifactName, 'elements', elemName, 'on' ]);
-        }
-      }
-    }
-
-    /**
-     * Find out where the managed association is
-     *
-     * @param {Array} links
-     * @param {Number} startIndex
-     * @returns {Object| undefined} CSN definition of the source of the managed association
-     *
-     */
-    function findSource(links, startIndex) {
-      for (let i = startIndex; i >= 0; i--) {
-        const link = links[i];
-        // We found the latest assoc step - now check where that points to
-        if (link.art && link.art.target)
-          return csn.definitions[link.art.target];
-      }
-
-      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
-   * @param {WeakMap} alreadyHandled To cache which elements were already processed
-   * @returns {void}
-   */
-  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 (alreadyHandled.has(elem))
-      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 fkName =  `${ elemName }${ pathDelimiter }${ foreignKey.as }`;
-        const fKeyArg = {
-          ref: [
-            fkName,
-          ],
-        };
-
-        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
-    alreadyHandled.set(elem, true); 
-  }
 }