@sap/cds-compiler 2.4.4 → 2.10.2

package/lib/transform/forHanaNew.js

@@ -1,13 +1,12 @@
 'use strict';
 
-const { setProp, isBetaEnabled, isDeprecatedEnabled } = require('../base/model');
+const { setProp, isBetaEnabled } = require('../base/model');
 const { getUtils, cloneCsn, forEachGeneric,
         forEachMember,
         forEachMemberRecursively, forEachRef,
-        forAllQueries, forAllElements, hasBoolAnnotation, getArtifactDatabaseNameOf,
+        forAllQueries, forAllElements, hasAnnotationValue, getArtifactDatabaseNameOf,
         getElementDatabaseNameOf, isBuiltinType, applyTransformations,
-        isPersistedOnDatabase, getNormalizedQuery, isAspect, getResultingName,
-        getServiceNames
+        isPersistedOnDatabase, getNormalizedQuery, isAspect, walkCsnPath,
       } = require('../model/csnUtils');
 const { makeMessageFunction } = require('../base/messages');
 const transformUtils = require('./transformUtilsNew');
@@ -17,13 +16,17 @@ const { checkCSNVersion } = require('../json/csnVersion');
 const validate = require('../checks/validator');
 const { addLocalizationViewsWithJoins, addLocalizationViews } = require('../transform/localized');
 const timetrace = require('../utils/timetrace');
-const { createReferentialConstraints, assertConstraintIdentifierUniqueness } = require('./sql/constraints');
+const { createReferentialConstraints, assertConstraintIdentifierUniqueness } = require('./db/constraints');
 const { createDict } = require('../utils/objectUtils');
-const handleExists = require('./sql/transformExists');
-const { usesMixinAssociation, getMixinAssocOfQueryIfPublished } = require('./sql/helpers');
-const replaceAssociationsInGroupByOrderBy = require('./sql/groupByOrderBy');
+const handleExists = require('./db/transformExists');
+const { usesMixinAssociation, getMixinAssocOfQueryIfPublished } = require('./db/helpers');
+const replaceAssociationsInGroupByOrderBy = require('./db/groupByOrderBy');
 const _forEachDefinition = require('../model/csnUtils').forEachDefinition;
-const assertUnique = require('./sql/assertUnique');
+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
@@ -105,15 +100,13 @@ 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 draftSuffix = isDeprecatedEnabled(options, 'generatedEntityNameWithUnderscore') ? '_drafts' : '.drafts';
   const columnClearer = [];
   // copy the model as we don't want to change the input model
   timetrace.start('HANA transformation');
   /** @type {CSN.Model} */
   let csn = cloneCsn(inputModel, options);
 
-  // All services of the model - needed for drafts
-  const allServices = getServiceNames(inputModel);
+
 
   checkCSNVersion(csn, options);
 
@@ -123,14 +116,20 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
   /** @type {() => void} */
   let throwWithError;
   let artifactRef, inspectRef, queryOrMain, effectiveType, // csnRefs
-    addDefaultTypeFacets, expandStructsInOnConditions, 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);
 
@@ -139,34 +138,59 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
     error, warning, info, inspectRef, effectiveType, artifactRef, csnUtils: getUtils(csn), csn, options, getFinalBaseType, isAspect
   });
 
-  // Check if structured elements and managed associations are compared in an ON condition
+  // Check if structured elements and managed associations are compared in an expression
   // and expand these structured elements. This tuple expansion allows all other
-  // subsequent procession steps (especially a2j) to see plain paths in ON conditions.
+  // subsequent procession steps (especially a2j) to see plain paths in expressions.
   // If errors are detected, throwWithError() will return from further processing
 
-  forEachDefinition(csn, expandStructsInOnConditions);
+  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();
 
+  bindCsnReference();
+
   const redoProjections = [];
   // Use the "raw" forEachDefinition here to ensure that the _ignore takes effect
   _forEachDefinition(csn, (artifact) => {
@@ -188,12 +212,14 @@ 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, createForeignKeyElement, getForeignKeyArtifact,
+    flattenStructStepsInRef, getForeignKeyArtifact,
     isAssociationOperand, isDollarSelfOrProjectionOperand,
-    createAndAddDraftAdminDataProjection, createScalarElement, createAssociationElement,
-    addElement, copyAndAddElement, createAssociationPathComparison,
     extractValidFromToKeyElement, checkAssignment, checkMultipleAssignments,
     recurseElements
   } = transformUtils.getTransformers(csn, options, pathDelimiter);
@@ -201,7 +227,6 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
   const {
     getCsnDef,
     isAssocOrComposition,
-    isComposition,
     isManagedAssociationElement,
     isStructured,
     addStringAnnotationTo,
@@ -245,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"
@@ -263,56 +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
-    adaptQueryRefLater.forEach(fn => fn());
-  }else {
-    handleManagedAssociationsAndCreateForeignKeys();
-  }
-
+  handleManagedAssociationsAndCreateForeignKeys();
+  
   function handleManagedAssociationsAndCreateForeignKeys() {
     forEachDefinition(csn, (art, artName) => handleManagedAssociationFKs(art, artName));
     forEachDefinition(csn, (art, artName) => createForeignKeyElements(art, artName));
@@ -368,18 +338,13 @@ 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);
   }
 
-  // (015) Generate artificial draft shadow entities if requested
-  // Note that this needs to happen after implicit redirection has been performed, because it checks
-  // for all draft nodes (additional artifacts reachable via compositions) to be part of a service.
-  // This is typically achieved only by means of implicit redirection.
-  forEachDefinition(csn, generateDraft);
+  generateDrafts(csn, options, pathDelimiter, { info, warning, error });
 
   // Set the final constraint paths and produce hana tc indexes if required
   // See function comment for extensive information.
@@ -396,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);
   };
@@ -430,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();
@@ -445,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;
@@ -484,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) => {
@@ -535,8 +497,13 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
   function bindCsnReference(){
     ({ error, warning, info, throwWithError } = makeMessageFunction(csn, options, moduleName));
     ({ artifactRef, inspectRef, queryOrMain, effectiveType } = csnRefs(csn));
-    ({ getFinalBaseType } = getUtils(csn));
-    ({ addDefaultTypeFacets, expandStructsInOnConditions, toFinalBaseType } = transformUtils.getTransformers(csn, options, pathDelimiter));
+    ({ 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));
   }
 
   function handleMixinOnConditions(artifact, artifactName) {
@@ -561,25 +528,36 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
     }
     , [ 'definitions', artifactName, 'query' ]);
     function getResolvedMixinOnCondition(csn, mixinAssociation, query, assocName, path){
-      let { inspectRef } = csnRefs(csn);
+      const { inspectRef } = csnRefs(csn);
+      const referencedThroughStar = query.SELECT.columns.some((column) => column === '*');
       return mixinAssociation.on
             .map((onConditionPart, i) => {
               let columnToReplace;
               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];
                 }
               }
-              const replaceWith = query.SELECT ? query.SELECT.columns
-              .find((column) => column.as && column.as === columnToReplace || column.ref && column.ref[0] === columnToReplace ) :
-              null;
+              if (!columnToReplace)
+                return onConditionPart;
+
+              const replaceWith = query.SELECT.columns.find((column) =>
+                column.as && column.as === columnToReplace ||
+                column.ref && column.ref[0] === columnToReplace
+              );
+              if (!replaceWith && referencedThroughStar) {
+                // not explicitly in column list, check query sources
+                // get$combined also includes elements which are part of "excluding {}"
+                // this shouldn't be an issue here, as such references get rejected
+                const elementsOfQuerySources = get$combined(query);
+                Object.entries(elementsOfQuerySources).forEach(([id, element]) => {
+                  // if the ref points to an element which is not explicitly exposed in the column list,
+                  // but through the '*' operator -> replace the $projection / $self with the correct source entity
+                  if(id === columnToReplace)
+                    onConditionPart.ref[0] = element[0].parent;
+                });
+              }
 
               // No implicit CAST in on-condition
               if(replaceWith && replaceWith.cast) {
@@ -632,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 ]);
@@ -663,36 +634,6 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
     }, [ 'definitions', artifactName ]);
   }
 
-  /**
-   * @param {CSN.Artifact} artifact
-   * @param {string} artifactName
-   */
-  function generateDraft(artifact, artifactName) {
-    if ((artifact.kind === 'entity' || artifact.kind === 'view') && hasBoolAnnotation(artifact, '@odata.draft.enabled')) {
-      // Ignore if not part of a service
-      if (!isPartOfService(artifactName)) {
-        warning(null, [ 'definitions', artifactName ], 'Ignoring annotation “@odata.draft.enabled” as the artifact is not part of a service');
-        return;
-      }
-
-      // Determine the set of target draft nodes belonging to this draft root (the draft root
-      // itself plus all its transitively composition-reachable targets)
-      const draftNodes = Object.create(null);
-      collectDraftNodesInto(artifact, artifactName, artifact, draftNodes);
-      // Draft-enable all of them
-      for (const name in draftNodes)
-        generateDraftForHana(draftNodes[name], name, artifactName);
-
-      // Redirect associations/compositions between draft shadow nodes
-      for (const name in draftNodes) {
-        const shadowNode = csn.definitions[`${ name }${draftSuffix}`];
-        // Might not exist because of previous errors
-        if (shadowNode)
-          redirectDraftTargets(csn.definitions[`${ name }${draftSuffix}`], draftNodes);
-      }
-    }
-  }
-
   /**
    * @param {CSN.Artifact} artifact
    * @param {string} artifactName
@@ -734,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'
@@ -743,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:
@@ -774,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);
           }
@@ -785,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){
@@ -832,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 },
@@ -848,7 +789,7 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
     * @param {string} artifactName
     */
   function handleQueryish(artifact, artifactName) {
-    const stripQueryish = artifact.query && hasBoolAnnotation(artifact, '@cds.persistence.table');
+    const stripQueryish = artifact.query && hasAnnotationValue(artifact, '@cds.persistence.table');
 
     if (stripQueryish) {
       artifact.kind = 'entity';
@@ -869,13 +810,13 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
   function handleCdsPersistence(artifact, artifactName) {
     if (artifact.kind === 'entity' || artifact.kind === 'view') {
       if (artifact.abstract
-        || hasBoolAnnotation(artifact, '@cds.persistence.skip')
-        || hasBoolAnnotation(artifact, '@cds.persistence.exists'))
+        || hasAnnotationValue(artifact, '@cds.persistence.skip')
+        || hasAnnotationValue(artifact, '@cds.persistence.exists'))
         artifact._ignore = true;
 
       // issue #3450 HANA CDS can not handle external artifacts which are part of a HANA CDS context
       if (options.forHana.names === 'quoted' &&
-          hasBoolAnnotation(artifact, '@cds.persistence.exists')) {
+          hasAnnotationValue(artifact, '@cds.persistence.exists')) {
         const firstPath = artifactName.split('.')[0];
         const topParent = csn.definitions[firstPath];
         // namespaces, contexts and services become contexts in HANA CDS
@@ -886,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
@@ -910,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){
@@ -925,7 +869,6 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
       }
     });
     csn = newCsn;
-    bindCsnReference();
   }
 
   /**
@@ -984,6 +927,25 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
     }
   }
 
+  function hasFalsyTemporalAnnotations(SELECT, elements, from, to) {
+    let fromElement = elements[from.name];
+    let toElement = elements[to.name];
+
+    if(SELECT.columns) {
+      for(const col of SELECT.columns) {
+        if(col.ref) {
+          const implicitAlias = implicitAs(col.ref);
+          if(implicitAlias === from.name)
+            fromElement = elements[col.as || implicitAlias];
+          else if(implicitAlias === to.name)
+            toElement = elements[col.as || implicitAlias];
+        }
+      }
+    }
+    const val = fromElement && toElement && hasAnnotationValue(fromElement, '@cds.valid.from', false) && hasAnnotationValue(toElement, '@cds.valid.to', false);
+    return val;
+  }
+
   /**
    * Add a where condition to views that
    * - are annotated with @cds.valid.from and @cds.valid.to,
@@ -1009,31 +971,33 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
       if (from.length === 1 && to.length === 1) {
         // and both are from the same origin
         if (from[0].source === to[0].source && from[0].parent === to[0].parent) {
-          const fromPath = {
-            ref: [
-              from[0].parent,
-              from[0].name,
-            ],
-          };
+          if(!hasFalsyTemporalAnnotations(normalizedQuery.query.SELECT, artifact.elements, from[0], to[0])) {
+            const fromPath = {
+              ref: [
+                from[0].parent,
+                from[0].name,
+              ],
+            };
 
-          const toPath = {
-            ref: [
-              to[0].parent,
-              to[0].name,
-            ],
-          };
+            const toPath = {
+              ref: [
+                to[0].parent,
+                to[0].name,
+              ],
+            };
 
 
-          const atFrom = { ref: [ '$at', 'from' ] };
-          const atTo = { ref: [ '$at', 'to' ] };
+            const atFrom = { ref: [ '$at', 'from' ] };
+            const atTo = { ref: [ '$at', 'to' ] };
 
-          const cond = [ '(', fromPath, '<', atTo, 'and', toPath, '>', atFrom, ')' ];
+            const cond = [ '(', fromPath, '<', atTo, 'and', toPath, '>', atFrom, ')' ];
 
-          if (normalizedQuery.query.SELECT.where) { // if there is an existing where-clause, extend it by adding 'and (temporal clause)'
-            normalizedQuery.query.SELECT.where = [ '(', ...normalizedQuery.query.SELECT.where, ')', 'and', ...cond ];
-          }
-          else {
-            normalizedQuery.query.SELECT.where = cond;
+            if (normalizedQuery.query.SELECT.where) { // if there is an existing where-clause, extend it by adding 'and (temporal clause)'
+              normalizedQuery.query.SELECT.where = [ '(', ...normalizedQuery.query.SELECT.where, ')', 'and', ...cond ];
+            }
+            else {
+              normalizedQuery.query.SELECT.where = cond;
+            }
           }
         }
         else {
@@ -1050,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.
    *
@@ -1185,10 +1028,10 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
       if (!Array.isArray(elt))
         elt = [ elt ];
       elt.forEach((e) => {
-        if (hasBoolAnnotation(e.element, '@cds.valid.from'))
+        if (hasAnnotationValue(e.element, '@cds.valid.from'))
           from.push(e);
 
-        if (hasBoolAnnotation(e.element, '@cds.valid.to'))
+        if (hasAnnotationValue(e.element, '@cds.valid.to'))
           to.push(e);
       });
     }
@@ -1219,7 +1062,7 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
     }
     function ignore(member, memberName, prop, path) {
       if (dialect === 'hana' && !member._ignore && member.target && isAssocOrComposition(member.type) && isUnreachableAssociationTarget(csn.definitions[member.target])) {
-        const targetAnnotation = hasBoolAnnotation(csn.definitions[member.target], '@cds.persistence.exists') ? '@cds.persistence.exists' : '@cds.persistence.skip';
+        const targetAnnotation = hasAnnotationValue(csn.definitions[member.target], '@cds.persistence.exists') ? '@cds.persistence.exists' : '@cds.persistence.skip';
         info(null, path,
           { target: member.target, anno: targetAnnotation },
           'Association has been removed as it\'s target $(TARGET) is annotated with $(ANNO)'
@@ -1234,7 +1077,7 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
    * @returns {boolean}
    */
   function isUnreachableAssociationTarget(art) {
-    return !isPersistedOnDatabase(art) || hasBoolAnnotation(art, '@cds.persistence.exists');
+    return !isPersistedOnDatabase(art) || hasAnnotationValue(art, '@cds.persistence.exists');
   }
 
   /**
@@ -1255,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'
@@ -1351,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) {
@@ -1419,17 +1252,14 @@ 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) => {
               const ref = cloneCsn(assoc_col.ref, options);
               ref[ref.length - 1] = [ ref[ref.length - 1] ].concat(key.as || key.ref).join(pathDelimiter);
-              // Keep the $env of the parent column
-              // so that we can still resolve the ref later on
               const result = {
                 ref,
-                $env: assoc_col.$env,
               };
               if (assoc_col.as)
                 result.as = key.$generatedFieldName;
@@ -1446,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);
@@ -1471,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`)
@@ -1497,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 {
@@ -1579,8 +1398,8 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
     if (query && !hasNonAssocElements) {
       // Complain if there are no elements other than unmanaged associations
       // Allow with plain
-      error(null, [ 'definitions', artName ],
-        'For SAP HANA CDS or SQL, a view or projection must have at least one element that is not an unmanaged association');
+      error(null, [ 'definitions', artName ], { $reviewed: true } ,
+        'Expecting view or projection to have at least one element that is not an unmanaged association');
     }
 
     if (isSelect) {
@@ -1627,13 +1446,20 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
       if (!Enum) {
         // Not an enum at all
         // Looks like it is always run?! But message says HANA CDS?!
-        error(null, path, `Enum literal "#${ elem.default['#'] }" can only be used with an enum type in SAP HANA CDS`);
+        error(null, path, {
+          $reviewed: true,
+          name: `#${elem.default['#']}`
+        },
+        'Expecting enum literal $(NAME) to be used with an enum type');
       }
       else {
         // Try to get the corresponding enum symbol from the element's type
         const enumSymbol = Enum[elem.default['#']];
         if (!enumSymbol) {
-          error(null, path, `Enum literal "#${ elem.default['#'] }" not found in enumeration type`);
+          error(null, path, {
+            $reviewed: true,
+            name: `#${elem.default['#']}`
+          }, 'Enum literal $(NAME) is undefined in enumeration type');
         }
         else if (enumSymbol.val !== undefined) { // `val` may be `null`
           // Replace default with enum value
@@ -1703,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 {
@@ -1796,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 = [
           {
@@ -1852,243 +1696,6 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
     }
   }
 
-  // Collect all artifacts that are transitively reachable via compositions from 'artifact' into 'draftNodes'.
-  // 'rootArtifact' is the root artifact where composition traversal started.
-  // Check that no artifact other than the root node has '@odata.draft.enabled'
-  function collectDraftNodesInto(artifact, artifactName, rootArtifact, draftNodes) {
-    // Collect the artifact itself
-    draftNodes[artifactName] = artifact;
-    // Follow all composition targets in elements of 'artifact'
-    for (const elemName in artifact.elements) {
-      const elem = artifact.elements[elemName];
-      if (elem.target && isComposition(elem.type)) {
-        const draftNode = getCsnDef(elem.target);
-        const draftNodeName = elem.target;
-        // Sanity check
-        if (!draftNode)
-          throw new Error(`Expecting target to be resolved: ${ JSON.stringify(elem, null, 2) }`);
-
-        // Ignore composition if not part of a service
-        if (!isPartOfService(draftNodeName)) {
-
-          warning(null, [ 'definitions', artifactName, 'elements', elemName ], { target: draftNodeName },
-            'Ignoring draft node for composition target $(TARGET) because it is not part of a service');
-          continue;
-        }
-        // Barf if a draft node other than the root has @odata.draft.enabled itself
-        if (draftNode != rootArtifact && hasBoolAnnotation(draftNode, '@odata.draft.enabled')) {
-          error(null, [ 'definitions', artifactName, 'elements', elemName ], `Composition in draft-enabled entity can't lead to another entity with “@odata.draft.enabled”`);
-          delete draftNodes[draftNodeName];
-          continue;
-        }
-        // Recurse unless already known
-        if (!hasBoolAnnotation(draftNode, '@odata.draft.enabled', false) && !draftNodes[draftNodeName])
-          collectDraftNodesInto(draftNode, draftNodeName, rootArtifact, draftNodes);
-      }
-    }
-  }
-
-  /**
-   * Generate all that is required in HANA CDS for draft enablement of 'artifact'.
-   *
-   * @param {CSN.Artifact} artifact
-   * @param {string} artifactName
-   * @param {string} draftRootName
-   */
-  function generateDraftForHana(artifact, artifactName, draftRootName) {
-    // Sanity check
-    if (!isPartOfService(artifactName))
-      throw new Error(`Expecting artifact to be part of a service: ${ JSON.stringify(artifact) }`);
-
-
-    // The name of the draft shadow entity we should generate
-    const draftsArtifactName = `${ artifactName }${draftSuffix}`;
-
-    // extract keys for UUID inspection
-    const keys = [];
-    forEachGeneric( artifact, 'elements', (elt) => {
-      if (elt.key && elt.key === true && !elt.virtual)
-        keys.push(elt);
-    });
-
-    // In contrast to EDM, the DB entity may have more than one technical keys but should have idealy exactly one key of type cds.UUID
-    if (keys.length !== 1)
-      warning(null, [ 'definitions', artifactName ], 'Entity annotated with “@odata.draft.enabled” should have exactly one key element');
-
-    const uuidCount = keys.reduce((uuidCount, k) => ((k.type === 'cds.String' && k.$renamed === 'cds.UUID' && k.length === 36) ? uuidCount+1 : uuidCount), 0);
-    if (uuidCount === 0)
-      warning(null, [ 'definitions', artifactName ], 'Entity annotated with “@odata.draft.enabled” should have one key element of type “cds.UUID”');
-
-
-    const matchingService = getMatchingService(artifactName);
-    // Generate the DraftAdministrativeData projection into the service, unless there is already one
-    const draftAdminDataProjectionName = `${ matchingService }.` + 'DraftAdministrativeData';
-    let draftAdminDataProjection = csn.definitions[draftAdminDataProjectionName];
-    if (!draftAdminDataProjection) {
-      draftAdminDataProjection = createAndAddDraftAdminDataProjection(matchingService, true);
-
-      if (!draftAdminDataProjection.projection.columns && draftAdminDataProjection.elements.DraftUUID) {
-        draftAdminDataProjection.projection.columns = Object.keys(draftAdminDataProjection.elements).map(e => e === 'DraftUUID' ? { key: true, ref: ['DraftAdministrativeData', e]} : {ref: ['DraftAdministrativeData', e]});
-      }
-    }
-
-    // Barf if it is not an entity or not what we expect
-    if (draftAdminDataProjection.kind !== 'entity' || !draftAdminDataProjection.elements['DraftUUID']) {
-      // See draftAdminDataProjection which is defined in `csn.definitions`.
-      const path = [ 'definitions', draftAdminDataProjectionName ];
-      error(null, path, { name: draftAdminDataProjectionName },
-        'Generated entity $(NAME) conflicts with existing artifact');
-    }
-
-    const persistenceName = getResultingName(csn, options.forHana.names, draftsArtifactName);
-    // Duplicate the artifact as a draft shadow entity
-    if (csn.definitions[persistenceName]) {
-      const definingDraftRoot = csn.definitions[persistenceName].$draftRoot;
-      if (!definingDraftRoot)
-        error(null, [ 'definitions', artifactName ], { name: persistenceName },
-          'Generated entity name $(NAME) conflicts with existing entity');
-
-      else
-        error(null, [ 'definitions', draftRootName ], { name: persistenceName },
-          `Entity $(NAME) already generated by draft root "${ definingDraftRoot }"`);
-
-      return;
-    }
-    const draftsArtifact = {
-      kind: 'entity',
-      elements: Object.create(null),
-    };
-
-    // Add draft shadow entity to the csn
-    csn.definitions[draftsArtifactName] = draftsArtifact;
-
-    setProp(draftsArtifact, '$draftRoot', draftRootName);
-    if(artifact.$location)
-      setProp(draftsArtifact, '$location', artifact.$location);
-
-    // Copy all elements
-    for (const elemName in artifact.elements) {
-      const origElem = artifact.elements[elemName];
-      let elem = undefined;
-      if(isDeprecatedEnabled(options, 'renderVirtualElements') && origElem.virtual)
-        elem = copyAndAddElement(origElem, draftsArtifact, draftsArtifactName, elemName)[elemName];
-      else if(!origElem.virtual)
-        elem = copyAndAddElement(origElem, draftsArtifact, draftsArtifactName, elemName)[elemName];
-      if(elem) {
-        // Remove "virtual" - cap/issues 4956
-        if(elem.virtual) {
-          delete elem.virtual;
-        }
-        // explicitly set nullable if not key and not unmanaged association
-        if (!elem.key && !elem.on)
-          elem.notNull = false;
-      }
-    }
-
-    // Generate the additional elements into the draft-enabled artifact
-
-    // key IsActiveEntity : Boolean default true
-    const isActiveEntity = createScalarElement('IsActiveEntity', 'cds.Boolean', false);
-    // Use artifactName and not draftsArtifactName because otherwise we may point to the generated
-    // entity in CSN and won't get a proper location (draftsArtifact has inherited all
-    // elements from the original artifact).
-    addElement(isActiveEntity, draftsArtifact, artifactName);
-
-    // HasActiveEntity : Boolean default false
-    const hasActiveEntity = createScalarElement('HasActiveEntity', 'cds.Boolean', false);
-    addElement(hasActiveEntity, draftsArtifact, artifactName);
-
-    // HasDraftEntity : Boolean default false;
-    const hasDraftEntity = createScalarElement('HasDraftEntity', 'cds.Boolean', false);
-    addElement(hasDraftEntity, draftsArtifact, artifactName);
-
-    // DraftAdministrativeData : Association to one DraftAdministrativeData not null;
-    const draftAdministrativeData = createAssociationElement('DraftAdministrativeData', draftAdminDataProjectionName, true);
-    draftAdministrativeData.DraftAdministrativeData.cardinality = {
-      max: 1,
-    };
-    draftAdministrativeData.DraftAdministrativeData.notNull = true;
-    addElement(draftAdministrativeData, draftsArtifact, artifactName);
-    // Note that we may need to do the HANA transformation steps for managed associations
-    // (foreign key field generation, generatedFieldName, creating ON-condition) by hand,
-    // because the corresponding transformation steps have already been done on all artifacts
-    // when we come here). Only for 'keepStructsAssocs' this is not required.
-    /**
-     * The given association has a key named DraftUUID
-     *
-     * @param {CSN.Association} association Assoc to check
-     * @returns {object}
-     */
-    function getDraftUUIDKey(association) {
-      if (association.keys) {
-        const filtered = association.keys.filter(o => (o.ref && !o.as && o.ref.length === 1 && o.ref[0] === 'DraftUUID') || (o.as && o.as === 'DraftUUID'));
-        if (filtered.length === 1)
-          return filtered[0];
-
-        else if (filtered.length > 1)
-          return filtered.filter(o => o.as && o.as === 'DraftUUID');
-      }
-
-      return undefined;
-    }
-
-    function getNameForRef(obj) {
-      if (obj.as)
-        return obj.as;
-
-      return obj.ref[obj.ref.length - 1];
-    }
-
-    const draftUUIDKey = getDraftUUIDKey(draftAdministrativeData.DraftAdministrativeData);
-    if (!options.forHana.keepStructsAssocs && draftUUIDKey) {
-      const path = [ 'definitions', draftsArtifactName, 'elements', 'DraftAdministrativeData', 'keys', 0 ];
-      createForeignKeyElement(draftAdministrativeData.DraftAdministrativeData, 'DraftAdministrativeData', draftUUIDKey, draftsArtifact, draftsArtifactName, path);
-      draftAdministrativeData.DraftAdministrativeData.on = createAssociationPathComparison('DraftAdministrativeData',
-                                                                                           getNameForRef(draftUUIDKey),
-                                                                                           '=',
-                                                                                           `DraftAdministrativeData${ pathDelimiter }DraftUUID`);
-      // The notNull has been transferred to the foreign key field and must be removed on the association
-      delete draftAdministrativeData.DraftAdministrativeData.notNull;
-
-      // The association is now unmanaged, i.e. actually it should no longer have foreign keys
-      // at all. But the processing of backlink associations below expects to have them, so
-      // we don't delete them (but mark them as implicit so that toCdl does not render them)
-      // draftAdministrativeData.DraftAdministrativeData.implicitForeignKeys = true;
-    }
-  }
-
-  // Redirect all association/composition targets in 'artifact' that point to targets in
-  // the dictionary 'draftNodes' to their corresponding draft shadow artifacts.
-  function redirectDraftTargets(artifact, draftNodes) {
-    for (const elemName in artifact.elements) {
-      const elem = artifact.elements[elemName];
-      if (elem.target) {
-        const targetArt = getCsnDef(elem.target);
-        // Nothing to do if target is not a draft node
-        if (!draftNodes[elem.target])
-          continue;
-
-        // Redirect the composition/association in this draft shadow entity to the target draft shadow entity
-        // console.error(`Redirecting target of ${elemName} in ${artifact.name.absolute} to ${target.name.absolute + '_drafts'}`);
-        const { shadowTarget, shadowTargetName } = getDraftShadowEntityFor(targetArt, elem.target);
-        // Might not exist because of previous errors
-        if (shadowTarget)
-          elem.target = shadowTargetName;
-          // FIXME: Strictly speaking, we would also need to replace the foreign keys' _artifact links,
-          // but since their content is identical anyway, we simply omit that for now.
-      }
-    }
-
-    // Returns the corresponding draft shadow artifact for draft node 'draftNode'.
-    function getDraftShadowEntityFor(draftNode, draftNodeName) {
-      // Sanity check
-      if (!draftNodes[draftNodeName])
-        throw new Error(`Not a draft node: ${ draftNodeName }`);
-
-      return { shadowTarget: csn.definitions[`${ draftNodeName }${draftSuffix}`], shadowTargetName: `${ draftNodeName }${draftSuffix}` };
-    }
-  }
-
   /**
    * @todo: XSN - Implementation most likely too naive, can we rely on query.SELECT.mixin?
    *
@@ -2109,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
@@ -2137,20 +1740,20 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
         for (const name in parameters) {
           const param = parameters[name];
           if (!node[param] && absolute !== 'cds.hana.ST_POINT' && absolute !== 'cds.hana.ST_GEOMETRY')
-            error(null, path, `Actual value for type parameter '${ param }' missing in reference to type '${ absolute }'`);
+            error('missing-type-parameter', path, { name: param, id: absolute, $reviewed: false });
         }
         switch (absolute) {
           case 'cds.String':
           case 'cds.Binary':
           case 'cds.hana.VARCHAR': {
-            checkTypeParamValue(node, 'length', 'positiveInteger', { min: 1, max: 5000 }, path);
+            checkTypeParamValue(node, 'length', { min: 1, max: 5000 }, path);
             break;
           }
           case 'cds.Decimal': {
             // Don't check with "plain"?
             if (node.precision || node.scale) {
-              checkTypeParamValue(node, 'precision', 'positiveInteger', { max: 38 }, path);
-              checkTypeParamValue(node, 'scale', 'positiveInteger', { max: node.precision }, path);
+              checkTypeParamValue(node, 'precision', { max: 38 }, path);
+              checkTypeParamValue(node, 'scale', { max: node.precision }, path);
             }
             break;
           }
@@ -2158,12 +1761,12 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
           case 'cds.hana.BINARY':
           case 'cds.hana.NCHAR':
           case 'cds.hana.CHAR': {
-            checkTypeParamValue(node, 'length', 'positiveInteger', { min: 1, max: 2000 }, path);
+            checkTypeParamValue(node, 'length', { min: 1, max: 2000 }, path);
             break;
           }
           case 'cds.hana.ST_POINT':
           case 'cds.hana.ST_GEOMETRY': {
-            checkTypeParamValue(node, 'srid', 'positiveInteger', { max: Number.MAX_SAFE_INTEGER }, path);
+            checkTypeParamValue(node, 'srid', { max: Number.MAX_SAFE_INTEGER }, path);
             break;
           }
         }
@@ -2171,32 +1774,26 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
 
       // Check that the value of the type property `paramName` (e.g. length, precision, scale ...) is of `expectedType`
       // (which can currently only be 'positiveInteger') and (optional) the value is in a given range
-      function checkTypeParamValue(node, paramName, expectedType, range = null, path = null) {
+      function checkTypeParamValue(node, paramName, range = null, path = null) {
         const paramValue = node[paramName];
         if (paramValue == undefined) {
-          if(options.toSql || artifact.query || !["cds.Binary","cds.hana.BINARY", 'cds.hana.NCHAR','cds.hana.CHAR'].includes(node.type)) {
+          if(options.toSql || artifact.query || !['cds.Binary','cds.hana.BINARY', 'cds.hana.NCHAR','cds.hana.CHAR'].includes(node.type)) {
             return true;
           } else {
-            return error(null, path, `Actual value for type parameter '${ paramName }' missing in reference to type '${ node.type }'`);
+            return error('missing-type-parameter', path, { name: paramName, id: node.type, $reviewed: false });
           }
         }
-        switch (expectedType) {
-          case 'positiveInteger':
-            if (!(Number.isInteger(paramValue) && paramValue >= 0)) {
-              error(null, path, `Actual parameter '${ paramName }' for '${ node.type }' must be positive integer`);
-              return false;
-            }
-            break;
-          default:
-            throw 'Unknown "expectedType"';
-        }
         if (range) {
           if (isMaxParameterLengthRestricted(node.type) && range.max && paramValue > range.max) {
-            error(null, path, `Actual parameter '${ paramName }' for '${ node.type }' is larger than allowed (max: ${ range.max })`);
+            error(null, path,
+              { prop: paramName, type: node.type, number: range.max, $reviewed: false },
+              'Expecting parameter $(PROP) for type $(TYPE) to not exceed $(NUMBER)');
             return false;
           }
           if (range.min && paramValue < range.min) {
-            error(null, path, `Actual parameter '${ paramName }' for '${ node.type }' is smaller than allowed (min: ${ range.min })`);
+            error(null, path,
+              { prop: paramName, type: node.type, number: range.min, $reviewed: false },
+              'Expecting parameter $(PROP) for type $(TYPE) to be greater than or equal to $(NUMBER)');
             return false;
           }
         }
@@ -2215,152 +1812,6 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
     return !(options.toSql && type === 'cds.String' && (options.toSql.dialect === 'sqlite' || options.toSql.dialect === 'plain'));
   }
 
-  /**
-   * Check if the given artifact is part of a service.
-   *
-   * @param {string} artifactName Absolute name of the artifact
-   * @returns {boolean}
-   */
-  function isPartOfService(artifactName) {
-    for (const serviceName of allServices) {
-      if (artifactName.startsWith(`${ serviceName }.`))
-        return true;
-    }
-
-    return false;
-  }
-
-  /**
-   * Get the service name containing the artifact.
-   *
-   * @param {string} artifactName Absolute name of the artifact
-   * @returns {boolean|string} Name of the service or false if no match is found.
-   */
-  function getMatchingService(artifactName) {
-    const matches = [];
-    for (const serviceName of allServices) {
-      if (artifactName.startsWith(`${ serviceName }.`))
-        matches.push(serviceName);
-    }
-    if (matches.length === 0)
-      return false;
-    else
-      return matches.sort((a, b) => a.length - b.length)[0];
-  }
-
-  /**
-   * 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
    *
@@ -2368,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...
@@ -2512,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) {
@@ -2579,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) => {
@@ -2592,7 +2043,7 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
                   const link = links[i];
                   // We found the latest managed assoc path step
                   if (link.art && link.art.target && link.art.keys) {
-                    // Doesn't work when ref-where or similar is used
+                    // Doesn't work when ref-target (filter condition) or similar is used
                     if (!ref.slice(i).some(refElement => typeof refElement !== 'string')) {
                       // We join the managed assoc with everything following it
                       const sourceElementName = ref.slice(i).join(pathDelimiter);