@sap/cds-compiler 2.11.4 → 2.12.0

package/lib/transform/forHanaNew.js

@@ -1,19 +1,18 @@
 'use strict';
 
 const { setProp, isBetaEnabled } = require('../base/model');
-const { getUtils, cloneCsn, forEachGeneric,
-        forEachMember,
-        forEachMemberRecursively, forEachRef, getNamespace, getResultingName,
-        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 { createReferentialConstraints, assertConstraintIdentifierUniqueness } = require('./db/constraints');
@@ -27,6 +26,9 @@ 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) {
@@ -121,9 +123,9 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
   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();
   }
 
@@ -145,6 +147,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 +159,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);
@@ -215,20 +219,15 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
 
   const {
     flattenStructuredElement,
-    flattenStructStepsInRef, getForeignKeyArtifact,
+    flattenStructStepsInRef,
     isAssociationOperand, isDollarSelfOrProjectionOperand,
-    extractValidFromToKeyElement, checkAssignment, checkMultipleAssignments,
-    recurseElements
   } = transformUtils.getTransformers(csn, options, pathDelimiter);
 
   const {
     getCsnDef,
     isAssocOrComposition,
-    isManagedAssociationElement,
-    isStructured,
     addStringAnnotationTo,
     cloneWithTransformations,
-    getContextOfArtifact,
   } = getUtils(csn);
 
   // (000) Rename primitive types, make UUID a String
@@ -271,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
@@ -309,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
@@ -348,8 +355,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
@@ -434,63 +441,6 @@ 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));
@@ -624,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' ]));
 
@@ -682,61 +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') {
-      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
@@ -768,65 +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;
-
-      const namingMode = options.forHana && options.forHana.names;
-      // issue #3450 HANA CDS can not handle external artifacts which are part of a HANA CDS context
-      if (hasAnnotationValue(artifact, '@cds.persistence.exists') &&
-          options.transformation === 'hdbcds' &&
-          (namingMode === 'quoted' || namingMode === 'hdbcds')) {
-        let hanaCDSContextName;
-        if(namingMode === 'hdbcds') {
-          // for hdbcds names we only create a context if you defined a context/service in your cdl model
-          hanaCDSContextName = getContextOfArtifact(artifactName);
-        }
-        else {
-          // for quoted naming mode, we create a context if you either defined a context/service
-          // or a namespace in your cdl model
-          hanaCDSContextName = getContextOfArtifact(artifactName) || getNamespace(csn, artifactName);
-        }
-        if (hanaCDSContextName) {
-          warning('anno-unstable-hdbcds', [ 'definitions', artifactName ],
-            {
-              id: getResultingName(csn, options.forHana.names, artifactName),
-              name: getResultingName(csn, options.forHana.names, hanaCDSContextName),
-              anno: 'cds.persistence.exists',
-            },
-            'Do not use $(ANNO) on an entity named $(ID) in SAP HANA CDS when we also create a SAP HANA CDS context named $(NAME)'
-          );
-        }
-      }
-    }
-  }
-
   function handleAssocToJoins() {
     // With flattening errors, it makes little sense to continue.
     throwWithError();
@@ -848,216 +685,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.
@@ -1312,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>,
@@ -1455,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
    *
@@ -1729,81 +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
-   * @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); 
-  }
 }