@sap/cds-compiler 2.5.0 → 2.10.4

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');
@@ -22,8 +22,11 @@ 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');
 
 // 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
@@ -121,14 +116,20 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
   /** @type {() => void} */
   let throwWithError;
   let artifactRef, inspectRef, queryOrMain, effectiveType, // csnRefs
-    addDefaultTypeFacets, expandStructsInExpression, toFinalBaseType, getFinalBaseType; // transformUtils
+    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 +143,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 +212,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 +270,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 +281,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));
@@ -366,8 +338,7 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
      * 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);
@@ -390,12 +361,6 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
   // 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);
   };
@@ -424,7 +389,9 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
     /* 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();
@@ -439,7 +406,8 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
     '_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;
@@ -478,7 +446,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) => {
@@ -529,7 +497,7 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
   function bindCsnReference(){
     ({ error, warning, info, throwWithError } = makeMessageFunction(csn, options, moduleName));
     ({ artifactRef, inspectRef, queryOrMain, effectiveType } = csnRefs(csn));
-    ({ getFinalBaseType } = getUtils(csn));
+    ({ getFinalBaseType, get$combined } = getUtils(csn));
     ({ addDefaultTypeFacets, expandStructsInExpression, toFinalBaseType } = transformUtils.getTransformers(csn, options, pathDelimiter));
   }
 
@@ -568,12 +536,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,16 +610,9 @@ 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 ]);
@@ -720,7 +675,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 +684,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:
@@ -760,7 +715,7 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
           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);
           }
@@ -771,7 +726,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 +773,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 +827,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
@@ -896,7 +854,7 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
               const mixinElement = q.SELECT.mixin[mixinName];
               if (mixinElement._ignore && options.toSql) {
                 columnClearer.push(() => {
-                  const query = walkCsnPath(p);
+                  const query = walkCsnPath(csn, p);
                   for(let i = query.columns.length-1; i > -1; i--){
                     const col = query.columns[i];
                     if(col && col.ref && col.ref[0] === mixinName){
@@ -1056,127 +1014,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.
    *
@@ -1261,16 +1098,6 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
     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;
-  }
-
   // Change the names of those builtin types that have different names in HANA.
   // (do that directly in the csn where the builtin types are defined, so that
   // all users of the types benefit from it). Also add the type parameter 'length'
@@ -1357,7 +1184,7 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
         });
       }
     }
-    if (query && options.toHana) {
+    if (query && options.transformation === 'hdbcds') {
       // check all queries/subqueries for mixin publishing inside of unions -> forbidden in hdbcds
       if (query.SELECT && query.SELECT.mixin && path.indexOf('SET') !== -1) {
         for (const elementName in elements) {
@@ -1425,7 +1252,7 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
 
         // 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) {
+        if (elem.keys && doA2J) {
           const assoc_col = columnMap[elemName];
           if (assoc_col && assoc_col.ref) {
             elem.keys.forEach((key) => {
@@ -1449,7 +1276,7 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
         }
         // 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) {
+        if (isStructured(elem) && doA2J) {
           const col = columnMap[elemName];
           const originalName = col.ref[col.ref.length - 1];
           const flatElements = flattenStructuredElement(elem, originalName, [], path);
@@ -1474,21 +1301,10 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
       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(isUnion(path) && options.transformation === 'hdbcds'){
           if(isBetaEnabled(options, 'ignoreAssocPublishingInUnion') && doA2J){
             if(elem.keys) {
               info(null, path, `Managed association "${elemName}", published in a UNION, will be ignored`)
@@ -1500,7 +1316,7 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
           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
+        } else if(path.length > 4 && options.transformation === 'hdbcds'){ // path.length > 4 -> is a subquery
           error(null, path, { name: elemName },
           'Association $(NAME) can\'t be published in a subquery')
         } else {
@@ -1713,23 +1529,41 @@ 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;
+             // remember name of backlink, important for foreign key constraints
+            if(elem.$selfOnCondition)
+              elem.$selfOnCondition.backlinkName += `_${ backlinkName }`;
+            else {
+              setProp(elem, '$selfOnCondition', {
+                backlinkName
+              }) // important for the foreign key constraints
+            }
           }
           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;
+            // remember name of backlink, important for foreign key constraints
+            if(elem.$selfOnCondition)
+              elem.$selfOnCondition.backlinkName += `_${ backlinkName }`;
+            else {
+              setProp(elem, '$selfOnCondition', {
+                backlinkName
+              }) // important for the foreign key constraints
+            }
           }
           // Otherwise take one (!) token unchanged
           else {
@@ -1806,8 +1640,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 = [
           {
@@ -1882,10 +1716,6 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
     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 +1812,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 +1819,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 +1963,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 +2030,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) => {