@sap/cds-compiler 2.5.2 → 2.11.0

package/lib/transform/forHanaNew.js

@@ -6,7 +6,7 @@ const { getUtils, cloneCsn, forEachGeneric,
         forEachMemberRecursively, forEachRef,
         forAllQueries, forAllElements, hasAnnotationValue, getArtifactDatabaseNameOf,
         getElementDatabaseNameOf, isBuiltinType, applyTransformations,
-        isPersistedOnDatabase, getNormalizedQuery, isAspect,
+        isPersistedOnDatabase, getNormalizedQuery, isAspect, walkCsnPath,
       } = require('../model/csnUtils');
 const { makeMessageFunction } = require('../base/messages');
 const transformUtils = require('./transformUtilsNew');
@@ -15,15 +15,18 @@ const { csnRefs, pathId, implicitAs } = require('../model/csnRefs');
 const { checkCSNVersion } = require('../json/csnVersion');
 const validate = require('../checks/validator');
 const { addLocalizationViewsWithJoins, addLocalizationViews } = require('../transform/localized');
-const timetrace = require('../utils/timetrace');
+const { timetrace } = require('../utils/timetrace');
 const { createReferentialConstraints, assertConstraintIdentifierUniqueness } = require('./db/constraints');
 const { createDict } = require('../utils/objectUtils');
 const handleExists = require('./db/transformExists');
-const { usesMixinAssociation, getMixinAssocOfQueryIfPublished } = require('./db/helpers');
 const replaceAssociationsInGroupByOrderBy = require('./db/groupByOrderBy');
 const _forEachDefinition = require('../model/csnUtils').forEachDefinition;
+const flattening = require('./db/flattening');
+const expansion = require('./db/expansion');
 const assertUnique = require('./db/assertUnique');
 const generateDrafts = require('./db/draft');
+const enrichUniversalCsn = require('./universalCsnEnricher');
+const { getViewTransformer } = require('./db/views');
 
 // By default: Do not process non-entities/views
 function forEachDefinition(csn, cb) {
@@ -36,12 +39,6 @@ function forEachDefinition(csn, cb) {
  * The behavior is controlled by the following options:
  * options = {
  *    forHana.names                               // See the behavior of 'names' in toHana, toSql and toRename
- *    forHana.keepNamespaces                      // Do not transform namespaces to contexts (to be used for
- *                                                // producing HANA-CDS compatible names with 'toHana', 'toSql' ...)
- *    forHana.keepStructsAssocs                   // Do not flatten structs, do not convert managed assocs to
- *                                                // unmanaged ones, do not convert assocs to joins (to be used
- *                                                // for rendering strictly HANA-CDS compatible CDS source with
- *                                                // 'toHana')
  *    forHana.alwaysResolveDerivedTypes           // Always resolve derived type chains (by default, this is only
  *                                                // done for 'quoted' names). FIXME: Should always be done in general.
  * }
@@ -50,12 +47,11 @@ function forEachDefinition(csn, cb) {
  * - (000) Some primitive type names are mapped to HANA type names (e.g. DateTime => UTCDateTime,
  *         Date => LocalDate, ...).The primitive type 'UUID' is renamed to 'String' (see also 060 below).
  * - (001) Add a temporal where condition to views where applicable before assoc2join
- * - (010) (not for 'keepStructsAssocs'): Transform associations to joins
+ * - (010) (not for to.hdbcds with hdbcds names): Transform associations to joins
  * - (015) Draft shadow entities are generated for entities/views annotated with '@odata.draft.enabled'.
  * - (020) Check: in "plain" mode, quoted ids are not allowed.
  *         (a) check in namespace declarations
  *         (b) check in artifact/element definitions.
- * - (030) For all elements, derived types are replaced by their final base type.
  * - (040) Abstract entities and entities 'implemented in' something are ignored, as well
  *         as entities annotated with '@cds.persistence.skip' or '@cds.persistence.exists'.
  * - (050) Checks on the hierarchical model (pre-flattening)
@@ -69,10 +65,9 @@ function forEachDefinition(csn, cb) {
  * - (100) 'masked' is ignored (a), and attribute 'localized' is removed (b)
  * - (110) Actions and functions (bound or unbound) are ignored.
  * - (120) (a) Services become contexts.
- *         (b) (not for 'keepNamespaces'): Namespaces become contexts.
- * - (130) (not for 'keepStructsAssocs'): Elements having structured types are flattened into
+ * - (130) (not for to.hdbcds with hdbcds names): Elements having structured types are flattened into
  *         multiple elements (using '_' or '.' as name separator, depending on 'forHana.names').
- * - (140) (not for 'keepStructsAssocs'): Managed associations get explicit ON-conditions, with
+ * - (140) (not for to.hdbcds with hdbcds names): Managed associations get explicit ON-conditions, with
  *         generated foreign key elements (also using '_' or '.' as name separator, depending on 'forHana.names').
  * - (150) (a) Elements from inherited (included) entities are copied into the receiving entity
  *         (b) The 'include' property is removed from entities.
@@ -86,10 +81,10 @@ function forEachDefinition(csn, cb) {
  *         (a) enum constants in defaults are replaced by their values (assuming a matching enum as element type)
  *         (b) the enum-ness is stripped off (i.e. the enum type is replaced by its final base type).
  * - (200) The 'key' property is removed from all elements of types.
- * - (210) (not for 'keepStructsAssocs'): Managed associations in GROUP BY and ORDER BY are
+ * - (210) (not for to.hdbcds with hdbcds names): Managed associations in GROUP BY and ORDER BY are
  *         replaced by by their foreign key fields.
  * - (220) Contexts that contain no artifacts or only ignored artifacts are ignored.
- * - (230) (only for 'keepStructsAssocs'): The following are rejected in views
+ * - (230) (only for to.hdbcds with hdbcds names): The following are rejected in views
  *         (a) Structured elements
  *         (b) Managed association elements
  *         (c) Managed association entries in GROUP BY
@@ -105,7 +100,6 @@ function forEachDefinition(csn, cb) {
  * @param {string}      moduleName The calling compiler module name, e.g. `to.hdi` or `to.hdbcds`.
  */
 function transformForHanaWithCsn(inputModel, options, moduleName) {
-  const columnClearer = [];
   // copy the model as we don't want to change the input model
   timetrace.start('HANA transformation');
   /** @type {CSN.Model} */
@@ -120,15 +114,21 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
   let error, warning, info; // message functions
   /** @type {() => void} */
   let throwWithError;
-  let artifactRef, inspectRef, queryOrMain, effectiveType, // csnRefs
-    addDefaultTypeFacets, expandStructsInExpression, toFinalBaseType, getFinalBaseType; // transformUtils
+  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); 
+    bindCsnReference();
+  }
 
   const dialect = options.forHana && options.forHana.dialect || options.toSql && options.toSql.dialect;
-  const doA2J = !options.forHana.keepStructsAssocs;
+  const doA2J = !(options.transformation === 'hdbcds' && options.sqlMapping === 'hdbcds');
   if (!doA2J)
     forEachDefinition(csn, handleMixinOnConditions);
 
@@ -142,25 +142,48 @@ 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
 
-  forEachDefinition(csn, expandStructsInExpression);
+  expandStructsInExpression(csn, { drillRef: true });
 
   throwWithError();
 
   // FIXME: This does something very similar to cloneWithTransformations -> refactor?
   const transformCsn = transformUtils.transformModel;
 
-  handleExists(csn, error);
+  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);
 
- // check unique constraints - further processing is done in rewriteUniqueConstraints`
+  // check unique constraints - further processing is done in rewriteUniqueConstraints
   assertUnique.prepare(csn, options, error, info);
 
+  if(doA2J) {
+    // Expand a structured thing in: keys, columns, order by, group by
+    expansion.expandStructureReferences(csn, options, pathDelimiter, {error, info, throwWithError});
+    bindCsnReference();
+  }
+
   // Remove properties attached by validator - they do not "grow" as the model grows.
   cleanup();
 
+  bindCsnReferenceOnly();
+
+
+  if(doA2J) {
+    const resolved = new WeakMap();
+    // No refs with struct-steps exist anymore
+    flattening.flattenAllStructStepsInRefs(csn, options, resolved, pathDelimiter);
+    // No type references exist anymore
+    // Needs to happen exactly between flattenAllStructStepsInRefs and flattenElements to keep model resolvable.
+    flattening.resolveTypeReferences(csn, options, resolved, pathDelimiter);
+    // No structured elements exists anymore
+    flattening.flattenElements(csn, options, pathDelimiter, error);
+  } else {
+    // For to.hdbcds with naming mode hdbcds we also need to resolve the types
+    flattening.resolveTypeReferences(csn, options, undefined, pathDelimiter);
+  }
+
   // (010) If requested, translate associations to joins
   if (doA2J)
     handleAssocToJoins();
@@ -188,6 +211,10 @@ 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,
@@ -242,13 +269,6 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
     },
   }, true);
 
-  // (030) - For all elements, replace derived types by final base type
-  forEachDefinition(csn, (artifact) => {
-    forEachMemberRecursively(artifact, (member) => {
-      toFinalBaseType(member);
-    });
-  });
-
   // (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"
@@ -260,57 +280,8 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
   //       Temporal only in beta-mode
   forEachDefinition(csn, handleTemporalAnnotations);
 
-  // Basic flattening of views and entities
-  // These steps need happen in isolation so that
-  // the following step can rely on the rest of the model having
-  // a certain structure, i.e. structs unfolded
-  if(!options.forHana.keepStructsAssocs) {
-    const flatteningOfStructured = [];
-    const adaptRefs = [];
-    // A2J resolves paths in queries to their flattened version,
-    // that is the foreign key of a managed assoc that will be generated in a later step
-    // we need to adapt the refs after the foreign keys are generated
-    const adaptQueryRefLater = [];
-
-    const fkRefs = new WeakMap();
-
-    applyTransformations(csn, {
-      keys: (parent, prop, keys) => {
-        keys.forEach(key => fkRefs.set(key.ref, true));
-      },
-      ref: (parent, prop, ref, path) => {
-        // Do not process fk refs - no need to adapt
-        if(fkRefs.has(ref))
-          return;
-
-        setProp(parent, '$path', [...path]);
-        const lastRef = ref[ref.length-1];
-        const fn = () => {
-          const scopedPath = [...parent.$path];
-          parent.ref = flattenStructStepsInRef(ref, scopedPath);
-          // Explicitly set implicit alias for things that are now flattened - but only in columns
-          if (parent.ref[ref.length - 1] != lastRef && insideColumns(scopedPath) && !parent.as)
-            parent.as = lastRef;
-        };
-        // adapt queries later
-        const enclosingArtifact = csn.definitions[path[1]];
-        if(enclosingArtifact.query)
-          adaptQueryRefLater.push(fn);
-        else
-          adaptRefs.push(fn);
-      }
-    }, [(definitions, artifactName, artifact) => flatteningOfStructured.push(() => flattenStructuredElements(artifact, artifactName))]);
-
-    adaptRefs.forEach(fn => fn());
-    flatteningOfStructured.forEach(fn => fn());
-    handleManagedAssociationsAndCreateForeignKeys();
-    // now the foreign key references in queries are resolvable
-    bindCsnReferenceOnly();
-    adaptQueryRefLater.forEach(fn => fn());
-  }else {
-    handleManagedAssociationsAndCreateForeignKeys();
-  }
-
+  handleManagedAssociationsAndCreateForeignKeys();
+  
   function handleManagedAssociationsAndCreateForeignKeys() {
     forEachDefinition(csn, (art, artName) => handleManagedAssociationFKs(art, artName));
     forEachDefinition(csn, (art, artName) => createForeignKeyElements(art, artName));
@@ -359,20 +330,19 @@ 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,
      * hence we do not generate the referential constraints for them.
      */
     const validOptionsForConstraint = () => {
-      return (options.forHana.dialect === 'sqlite' || options.forHana.dialect === 'hana') &&
-            !(options.toHana && options.toHana.names === 'hdbcds')
+      return (options.forHana.dialect === 'sqlite' || options.forHana.dialect === 'hana') && doA2J;
     }
     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
@@ -385,17 +355,12 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
   // Apply view-specific transformations
   // (160) Projections now finally become views
   // Replace managed association in group/order by with foreign keys
+  const transformEntityOrViewPass2 = getViewTransformer(csn, options, {error, info}, transformCommon);
   forEachDefinition(csn, transformViews);
 
   // Recursively apply transformCommon and attach @cds.persistence.name
   forEachDefinition(csn, recursivelyApplyCommon);
 
-  // (20 a) If we keep associations as they are (hdbcds naming convention), we cannot have structured
-  // view elements (we could enumerate the elements but we can't give them the names one would expect)
-  // Check foreign keys of redirected associations
-  // (200) Strip 'key' property from type elements
-  forEachDefinition(csn, recursiveChecks);
-
   const checkConstraintIdentifiers = (artifact, artifactName, prop, path) => {
     assertConstraintIdentifierUniqueness(artifact, artifactName, path, error);
   };
@@ -419,12 +384,12 @@ 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 */
-    ignoreNonPersistedArtifactsWithAnonymousAspectComposition
+    ignoreNonPersistedArtifactsWithAnonymousAspectComposition,
+    // (200) Strip 'key' property from type elements
+    removeKeyPropInType,
   ]);
 
   throwWithError();
@@ -436,34 +401,31 @@ 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];
-        const parentParent = walkCsnPath(path.slice(0, -1));
+        const parentPath = path.slice(0, -1)
+        const parentParent = walkCsnPath(csn, parentPath);
         delete parentParent[tail];
       } else {
         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;
 
@@ -478,7 +440,7 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
    * @param {string} artName
    */
   function createForeignKeyElements(art, artName) {
-    if ((art.kind === 'entity' || art.kind === 'view') && !options.forHana.keepStructsAssocs) {
+    if ((art.kind === 'entity' || art.kind === 'view') && doA2J) {
       forAllElements(art, artName, (parent, elements, pathToElements) => {
         const elementsArray = [];
         forEachGeneric(parent, 'elements', (element, elemName) => {
@@ -528,14 +490,14 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
 
   function bindCsnReference(){
     ({ error, warning, info, throwWithError } = makeMessageFunction(csn, options, moduleName));
-    ({ artifactRef, inspectRef, queryOrMain, effectiveType } = csnRefs(csn));
-    ({ getFinalBaseType } = getUtils(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) {
@@ -568,12 +530,6 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
               if(onConditionPart.ref && (onConditionPart.ref[0] === '$projection' || onConditionPart.ref[0] === '$self')){
                 const { links } = inspectRef(path.concat(['on', i]));
                 if(links){
-                  // no assocs in $projection / $self paths #5050
-                  links.forEach((element, j) => {
-                    const { art } = links[j];
-                    if(art && art.target) // Fine for plain
-                      error(null, path.concat(['on', j]), `Step "${onConditionPart.ref[j]}" in path "${onConditionPart.ref.join('.')}" must not be an association`);
-                  });
                   columnToReplace = onConditionPart.ref[links.length - 1];
                 }
               }
@@ -648,36 +604,15 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
    * @param {CSN.Artifact} artifact
    * @param {string} artifactName
    */
-  function recursiveChecks(artifact, artifactName) {
+  function removeKeyPropInType(artifact, artifactName) {
     if (!artifact._ignore) {
-      forEachMemberRecursively(artifact, (member, memberName, property, path) => {
-        if (options.forHana.keepStructsAssocs &&
-          artifact.query &&
-          isStructured(member)) {
-          error(null, path, `With "hdbcds" naming, structured elements can't be used in a view`);
-          return;
-        }
-
+      forEachMemberRecursively(artifact, (member) => {
         if (artifact.kind === 'type' && member.key)
           delete member.key;
       }, [ 'definitions', artifactName ]);
     }
   }
 
-  /**
-   * @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
@@ -720,7 +655,7 @@ 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, `Associations are not allowed in entities with parameters`);
+          error(null, path, 'Unexpected association in parameterized view');
         }
         else if(artifact['@cds.persistence.udf'] || artifact['@cds.persistence.calcview']) {
           // UDF/CVs w/o params don't support 'WITH ASSOCIATIONS'
@@ -729,7 +664,7 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
         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, `Associations can't point to entities with parameters`);
+          error(null, path, 'Unexpected parameterized association target');
         }
         else if(csn.definitions[member.target]['@cds.persistence.udf'] || artifact['@cds.persistence.calcview']) {
           // HANA won't check the assoc target but when querying an association with target UDF, this is the error:
@@ -755,14 +690,15 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
   function handleAssociations(artifact, artifactName) {
     // Do things specific for entities and views (pass 1)
     if (artifact.kind === 'entity' || artifact.kind === 'view') {
+      const alreadyHandled = new WeakMap();
       forAllElements(artifact, artifactName, (parent, elements) => {
         for (const elemName in elements) {
           const elem = elements[elemName];
           // (140) Generate foreign key elements and ON-condition for managed associations
           // (unless explicitly asked to keep assocs unchanged)
-          if (!options.forHana.keepStructsAssocs) {
+          if (doA2J) {
             if (isManagedAssociationElement(elem))
-              transformManagedAssociation(parent, artifactName, elem, elemName);
+              transformManagedAssociation(parent, artifactName, elem, elemName, alreadyHandled);
           }
         }
       })
@@ -771,7 +707,7 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
 
   function fixBorkedElementsOfLocalized(elements, pathToElements){
     const pathToNonLocalized = ['definitions', pathToElements[1].replace('localized.',''), ...pathToElements.slice(2)];
-    const nonLocalizedElements = walkCsnPath(pathToNonLocalized);
+    const nonLocalizedElements = walkCsnPath(csn, pathToNonLocalized);
 
 
     for(const elementName in elements){
@@ -818,7 +754,7 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
       else {
         for (const pname in artifact.params) {
           if (pname.match(/\W/g) || pname.match(/^\d/) || pname.match(/^_/)) { // parameter name must be regular SQL identifier
-            warning(null, [ 'definitions', artifactName, 'params', pname ], `"${ artifactName }", parameter "${ pname }": is not a regular SQL identifier`);
+            warning(null, [ 'definitions', artifactName, 'params', pname ], `Expecting regular SQL-Identifier`);
           }
           else if (options.forHana.names !== 'plain' && pname.toUpperCase() !== pname) { // not plain mode: param name must be all upper
             warning(null, [ 'definitions', artifactName, 'params', pname ], { name: options.forHana.names },
@@ -872,9 +808,12 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
   }
 
   function handleAssocToJoins() {
+    // With flattening errors, it makes little sense to continue.
+    throwWithError();
     // the augmentor isn't able to deal with technical configurations and since assoc2join can ignore it we
     // simply make it invisible and copy it over to the result csn
     forEachDefinition(csn, art => art.technicalConfig && setProp(art, 'technicalConfig', art.technicalConfig));
+
     const newCsn = translateAssocsToJoinsCSN(csn, options);
 
     // restore all (non-enumerable) properties that wouldn't survive reaugmentation/compactification into the new compact model
@@ -885,30 +824,6 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
       if (art.technicalConfig)
         newCsn.definitions[artName].technicalConfig = art.technicalConfig;
 
-      const newArt = newCsn.definitions[artName];
-
-      // No need to loop/check artifacts that won't reach the DB anyways
-      if (art.query && newArt && newArt.query && isPersistedOnDatabase(newArt)) {
-        // Loop through the newCSN and add possible new _ignore mixin to the kill list
-        forAllQueries(newArt.query, (q, p) => {
-          if (q.SELECT && q.SELECT.mixin) {
-            for(let mixinName of Object.keys(q.SELECT.mixin)) {
-              const mixinElement = q.SELECT.mixin[mixinName];
-              if (mixinElement._ignore && options.toSql) {
-                columnClearer.push(() => {
-                  const query = walkCsnPath(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;
   }
@@ -1056,127 +971,6 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
     }
   }
 
-
-  /**
-   * Compute and return $combined for the given query.
-   *
-   * @param {CSN.Query} query
-   * @returns {object}
-   */
-  function get$combined(query) {
-    const sources = getSources(query);
-    return sources;
-
-    /**
-     * Get the union of all elements from the from clause
-     * - descend into unions, following the lead query
-     * - merge all queries in case of joins
-     * - follow subqueries
-     *
-     * @param {CSN.Query} query Query to check
-     * @returns {object} Map of sources
-     */
-    function getSources(query) {
-      // Remark CW: better just a while along query.SET.args[0]
-      if (query.SET) {
-        if (query.SET.args[0].SELECT && query.SET.args[0].SELECT.elements)
-          return mergeElementsIntoMap(Object.create(null), query.SET.args[0].SELECT.elements, query.SET.args[0].$location);
-
-        return getSources(query.SET.args[0]);
-      }
-      else if (query.SELECT) {
-        if (query.SELECT.from.args) {
-          return walkArgs(query.SELECT.from.args);
-        }
-        else if (query.SELECT.from.ref) {
-          const art = artifactRef(query.SELECT.from);
-          return mergeElementsIntoMap(Object.create(null), art.elements, art.$location,
-            query.SELECT.from.as || query.SELECT.from.ref[query.SELECT.from.ref.length - 1],
-            query.SELECT.from.ref[query.SELECT.from.ref.length - 1] || query.SELECT.from.as );
-        }
-        else if (query.SELECT.from.SET || query.SELECT.from.SELECT) {
-          return getSources(query.SELECT.from);
-        }
-      }
-
-      function walkArgs(args) {
-        let elements = Object.create(null);
-        for (const arg of args) {
-          if (arg.args) {
-            elements = mergeElementMaps(elements, walkArgs(arg.args));
-          }
-          else if (arg.ref) {
-            const art = artifactRef(arg);
-            elements = mergeElementsIntoMap(elements, art.elements, art.$location, arg.as || arg.ref[arg.ref.length - 1], arg.ref[arg.ref.length - 1] || arg.as);
-          }
-          else if (arg.SELECT || arg.SET) {
-            elements = mergeElementMaps(elements, getSources(arg));
-          }
-        }
-
-        return elements;
-      }
-
-      return {};
-
-      /**
-       * Merge two maps of elements together
-       *
-       * @param {object} mapA Map a - will be returned
-       * @param {object} mapB Map b - will not be returned
-       * @returns {object} mapA
-       */
-      function mergeElementMaps(mapA, mapB) {
-        for (const elementName in mapB) {
-          if (!mapA[elementName])
-            mapA[elementName] = [];
-
-          mapB[elementName].forEach(e => mapA[elementName].push(e));
-        }
-
-        return mapA;
-      }
-
-      /**
-       * Merge elements into an existing map
-       *
-       * @param {any} existingMap map to merge into - will be returned
-       * @param {object} elements elements to merge into the map
-       * @param {CSN.Location} $location $location of the elements - where they come from
-       * @param {any} [parent] Name of the parent of the elements, alias before ref
-       * @param {any} [error_parent] Parent name to use for error messages, ref before alias
-       * @returns {object} existingMap
-       */
-      function mergeElementsIntoMap(existingMap, elements, $location, parent, error_parent) {
-        for (const elementName in elements) {
-          const element = elements[elementName];
-          if (!existingMap[elementName])
-            existingMap[elementName] = [];
-
-
-          existingMap[elementName].push({
-            element, name: elementName, source: $location, parent: getBaseName(parent), error_parent,
-          });
-        }
-
-        return existingMap;
-      }
-    }
-  }
-  /**
-   * Return the name part of the artifact name - no namespace etc.
-   * @param {string|object} name Absolute name of the artifact
-   */
-  function getBaseName(name) {
-    if (!name)
-      return name;
-
-    if (name.id)
-      return name.id.substring( name.id.lastIndexOf('.')+1 );
-
-    return name.substring( name.lastIndexOf('.')+1 )
-  }
-
   /**
    * Get all elements tagged with @cds.valid.from/to from the union of all entities of the from-clause.
    *
@@ -1215,10 +1009,12 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
     if (isPersistedOnDatabase(artifact)) {
       // TODO: structure in CSN is artifact.query.[SELECT/SET].mixin
       if (artifact.query) {
-        if (artifact.query.SELECT && artifact.query.SELECT.mixin)
+        // If we do A2J, we don't need to check the mixin. Either it is used -> a join
+        // or published -> handled via elements/members. Unused mixins are removed anyway. 
+        if (!doA2J && artifact.query.SELECT && artifact.query.SELECT.mixin)
           forEachGeneric(artifact.query.SELECT, 'mixin', ignore, path.concat([ 'query', 'SELECT' ]));
 
-        else if (artifact.query.SET && artifact.query.SET.mixin)
+        else if (!doA2J && artifact.query.SET && artifact.query.SET.mixin)
           forEachGeneric(artifact.query.SET, 'mixin', ignore, path.concat([ 'query', 'SET' ]));
       }
       forEachMemberRecursively(artifact, ignore, [ 'definitions', artifactName ]);
@@ -1259,16 +1055,9 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
 
     // (190 a) Replace enum symbols by their value (if found)
     replaceEnumSymbolsByValues(obj, path);
-  }
-
-  function walkCsnPath(path) {
-    /** @type {object} */
-    let obj = csn;
-    for(let i = 0; i < path.length; i++){
-      obj = obj[path[i]];
-    }
 
-    return obj;
+    if (obj.enum)
+      delete obj.enum;
   }
 
   // Change the names of those builtin types that have different names in HANA.
@@ -1302,320 +1091,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.toHana) {
-      // 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 && !options.forHana.keepStructsAssocs) {
-          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) && !options.forHana.keepStructsAssocs) {
-          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;
-
-
-      // (230 b) If we keep associations as they are (hdbcds naming convention), we cannot have managed associations
-      // as view elements (their foreign keys cannot be addressed in the view)
-      if (options.forHana.keepStructsAssocs &&
-        query &&
-        isAssocOrComposition(elem.type) &&
-        !elem.on) {
-        error(null, [ 'definitions', artName, 'elements', elemName ], `With "hdbcds" naming, managed association elements can't be used in a view`);
-        continue;
-      }
-
-      // (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.toHana){
-          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.toHana){ // 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,
@@ -1632,7 +1107,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');
       }
@@ -1642,7 +1117,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`
@@ -1659,30 +1134,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
@@ -1713,23 +1164,27 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
             const assoc = inspectRef(path.concat([ i + 2 ])).art;
             if (multipleExprs)
               result.push('(');
+            const backlinkName = xprArgs[i + 2].ref[xprArgs[i + 2].ref.length - 1];
             result.push(...transformDollarSelfComparison(xprArgs[i + 2],
               assoc,
-              xprArgs[i + 2].ref[xprArgs[i + 2].ref.length - 1],
+              backlinkName,
               elem, elemName, art, artName, path.concat([ i ])
             ));
             if (multipleExprs)
               result.push(')');
             i += 3;
+            attachBacklinkInformation(backlinkName);
           }
           else if (isDollarSelfOrProjectionOperand(xprArgs[i + 2]) && isAssociationOperand(xprArgs[i], path.concat([ i ]))) {
             const assoc = inspectRef(path.concat([ i ])).art;
             if (multipleExprs)
               result.push('(');
-            result.push(...transformDollarSelfComparison(xprArgs[i], assoc, xprArgs[i].ref[xprArgs[i].ref.length - 1], elem, elemName, art, artName, path.concat([ i + 2 ])));
+            const backlinkName = xprArgs[i].ref[xprArgs[i].ref.length - 1];
+            result.push(...transformDollarSelfComparison(xprArgs[i], assoc, backlinkName, elem, elemName, art, artName, path.concat([ i + 2 ])));
             if (multipleExprs)
               result.push(')');
             i += 3;
+            attachBacklinkInformation(backlinkName);
           }
           // Otherwise take one (!) token unchanged
           else {
@@ -1749,6 +1204,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);
@@ -1806,8 +1279,8 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
       assoc.keys.forEach((k) => {
         // Depending on naming conventions, the foreign key may two path steps (hdbcds) or be a single path step with a flattened name (plain, quoted)
         // With to.hdbcds in conjunction with hdbcds naming, we need to NOT use the alias - else we get deployment errors
-        const keyName = k.as && !(options.toHana && options.toHana.names === 'hdbcds') ? [k.as] : k.ref;
-        const fKeyPath = options.forHana.keepStructsAssocs ? [ assocName, ...keyName ] : [ `${ assocName }${ pathDelimiter }${ keyName[0] }` ];
+        const keyName = k.as && doA2J ? [k.as] : k.ref;
+        const fKeyPath = !doA2J ? [ assocName, ...keyName ] : [ `${ assocName }${ pathDelimiter }${ keyName[0] }` ];
         // FIXME: _artifact to the args ???
         const a = [
           {
@@ -1862,30 +1335,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;
-  }
-
-  function insideColumns(path) {
-    return path.length >= 3 && path[path.length - 3] === 'SELECT' && path[path.length - 2] === 'columns';
-  }
-
   /**
    * @param {CSN.Artifact} artifact
    * @param {string} artifactName
@@ -1982,119 +1431,6 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
     return !(options.toSql && type === 'cds.String' && (options.toSql.dialect === 'sqlite' || options.toSql.dialect === 'plain'));
   }
 
-  /**
-   * Get not just the leafs, but all the branches of a structured element
-   *
-   * @param {object} element Structured element
-   * @param {string} elementName Name of the structured element
-   * @returns {object} Returns a dictionary, where the key is the flat name of the branch and the value is an array of element-steps.
-   */
-  function getBranches(element, elementName){
-    const branches = {};
-    const subbranchNames = [];
-    const subbranchElements = [];
-    walkElements(element, elementName);
-    function walkElements(e, name){
-      if(isBuiltinType(e)){
-        branches[subbranchNames.concat(name).join(pathDelimiter)] = subbranchElements.concat(e);
-      } else {
-        const eType = effectiveType(e)
-        const subelements = e.elements || eType.elements;
-        if(subelements){
-          subbranchElements.push(e);
-          subbranchNames.push(name);
-          for(let [subelementName, subelement] of Object.entries(subelements)){
-            walkElements(subelement, subelementName);
-          }
-          subbranchNames.pop();
-          subbranchElements.pop();
-        } else {
-          branches[subbranchNames.concat(name).join(pathDelimiter)] = subbranchElements.concat(e);
-        }
-
-      }
-    }
-    return branches;
-  }
-
-  /**
-   * Flatten structures
-   *
-   * @param {CSN.Artifact} art Artifact
-   * @param {string} artName Artifact Name
-   */
-  function flattenStructuredElements(art, artName) {
-    if ((art.kind === 'entity' || art.kind === 'view') && !options.forHana.keepStructsAssocs) {
-      forAllElements(art, artName, (parent, elements, pathToElements) => {
-        const elementsArray = [];
-        for (const elemName in elements) {
-          const pathToElement = pathToElements.concat([elemName])
-          const elem = parent.elements[elemName];
-          elementsArray.push([elemName, elem]);
-          if (isStructured(elem)) {
-            // Ignore the structured element, replace it by its flattened form
-            // TODO: use $ignore - _ is for links
-            elem._ignore = true;
-
-            const branches = getBranches(elem, elemName);
-            const flatElems = flattenStructuredElement(elem, elemName, [], pathToElement);
-
-            for (const flatElemName in flatElems) {
-              if (parent.elements[flatElemName])
-                error(null, pathToElement, `"${ artName }.${ elemName }": Flattened struct element name conflicts with existing element: "${ flatElemName }"`);
-
-              const flatElement = flatElems[flatElemName];
-
-              // Check if we have a valid notNull chain
-              const branch = branches[flatElemName];
-              if(flatElement.notNull !== false && !branch.some(s => !s.notNull)){
-                flatElement.notNull = true;
-              }
-
-              if(flatElement.type && isAssocOrComposition(flatElement.type) && flatElement.on){
-                // Make refs resolvable by fixing the first ref step
-                for (let i = 0; i < flatElement.on.length; i++) {
-                  const onPart = flatElement.on[i];
-                  if (onPart.ref) {
-                    const firstRef = flatElement.on[i].ref[0];
-
-                  /*
-                    when element is defined in the current name resolution scope, like
-                      entity E {
-                        key x: Integer;
-                            s : {
-                            y : Integer;
-                            a3 : association to E on a3.x = y;
-                            }
-                      }
-                      We need to replace y with s_y and a3 with s_a3 - we must take care to not escape our local scope
-                  */
-                    const prefix = flatElement._flatElementNameWithDots.split('.').slice(0,-1).join(pathDelimiter);
-                    const possibleFlatName = prefix + pathDelimiter + firstRef;
-
-                    if (flatElems[possibleFlatName])
-                      flatElement.on[i].ref[0] = possibleFlatName;
-                  }
-                }
-              }
-              elementsArray.push([flatElemName, flatElement]);
-              // Still add them - otherwise we might not detect collisions between generated elements.
-              parent.elements[flatElemName] = flatElement;
-            }
-          }
-        }
-          //  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));
-      });
-    }
-  }
-
   /**
    * Flatten and create the foreign key elements of managed associaitons
    *
@@ -2102,7 +1438,7 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
    * @param {string} artName
    */
   function handleManagedAssociationFKs(art, artName) {
-    if ((art.kind === 'entity' || art.kind === 'view') && !options.forHana.keepStructsAssocs) {
+    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...
@@ -2246,7 +1582,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') && !options.forHana.keepStructsAssocs) {
+    if ((art.kind === 'entity' || art.kind === 'view') && doA2J) {
       if (tc && tc[dialect]) {
         // Secondary and fulltext indexes
         for (const name in tc[dialect].indexes) {
@@ -2313,7 +1649,7 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
   function handleManagedAssocStepsInOnCondition(artifact, artifactName) {
     for (const elemName in artifact.elements) {
       const elem = artifact.elements[elemName];
-      if (!options.forHana.keepStructsAssocs) {
+      if (doA2J) {
         // The association is an unmanaged on
         if (!elem.keys && elem.target && elem.on) {
           forEachRef(elem.on, (ref, refOwner, path) => {
@@ -2333,11 +1669,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 ];
                       }
                     }
                   }
@@ -2376,12 +1713,13 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
    * @param {string} artifactName
    * @param {Object} elem The association to process
    * @param {string} elemName
+   * @param {WeakMap} alreadyHandled To cache which elements were already processed
    * @returns {void}
    */
-  function transformManagedAssociation(artifact, artifactName, elem, elemName) {
+  function transformManagedAssociation(artifact, artifactName, elem, elemName, alreadyHandled) {
     // No need to run over this - we already did, possibly because it was referenced in the ON-Condition
     // of another association - see a few lines lower
-    if (elem.$fksgenerated)
+    if (alreadyHandled.has(elem))
       return;
     // Generate foreign key elements for managed associations, and assemble an ON-condition with them
     const onCondParts = [];
@@ -2398,10 +1736,10 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
             elemName,
           ].concat(foreignKey.ref),
         };
-
+        const fkName =  `${ elemName }${ pathDelimiter }${ foreignKey.as }`;
         const fKeyArg = {
           ref: [
-            foreignKey.$generatedFieldName,
+            fkName,
           ],
         };
 
@@ -2440,7 +1778,7 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
         elem.implicitForeignKeys = true;
     */
     // Remember that we already processed this
-    setProp(elem, '$fksgenerated', true);
+    alreadyHandled.set(elem, true); 
   }
 }