@sap/cds-compiler 2.12.0 → 2.13.6

package/lib/transform/db/associations.js

@@ -1,333 +1,55 @@
 'use strict';
 
 const {
-  cloneCsn, forEachGeneric,
-  forAllElements,
+  applyTransformationsOnNonDictionary,
+  applyTransformations,
   getUtils,
 } = require('../../model/csnUtils');
 
-const transformUtils = require('../transformUtilsNew');
-const { setProp } = require('../../base/model');
-
-
-/**
- * Return a callback function for forEachDefinition that flattens the foreign keys of managed associations.
- * Foreign keys that are managed associations are replaced by their respective foreign keys.
- *
- * @param {CSN.Model} csn
- * @param {CSN.Options} options
- * @param {string} pathDelimiter
- * @returns {(artifact: CSN.Artifact, artifactName: string) => void} Callback for forEachDefinition
- */
-function getForeignKeyFlattener(csn, options, pathDelimiter) {
-  const doA2J = !(options.transformation === 'hdbcds' && options.sqlMapping === 'hdbcds');
-  const {
-    isManagedAssociationElement,
-    isStructured,
-    inspectRef,
-  } = getUtils(csn);
-
-  const {
-    flattenStructuredElement,
-    flattenStructStepsInRef,
-  } = transformUtils.getTransformers(csn, options, pathDelimiter);
-
-  return handleManagedAssociationFKs;
-
-  /**
-   * Flatten and create the foreign key elements of managed associaitons
-   *
-   * @param {CSN.Artifact} art
-   * @param {string} artName
-   */
-  function handleManagedAssociationFKs(art, artName) {
-    if ((art.kind === 'entity' || art.kind === 'view') && doA2J) {
-      forAllElements(art, artName, (parent, elements, pathToElements) => {
-        forEachGeneric(parent, 'elements', (element, elemName) => {
-          if (element.keys && isManagedAssociationElement(element)) {
-            // replace foreign keys that are managed associations by their respective foreign keys
-            flattenFKs(element, elemName, [ ...pathToElements, elemName ]);
-          }
-        });
-      });
-    }
-  }
-
-  /**
-   * Flattens all foreign keys
-   *
-   * Structures will be resolved to individual elements with scalar types
-   *
-   * Associations will be replaced by their respective foreign keys
-   *
-   * If a structure contains an assoc, this will also be resolved and vice versa
-   *
-   * @param {CSN.Element} assoc
-   * @param {string} assocName
-   * @param {CSN.Path} path
-   */
-  function flattenFKs(assoc, assocName, path) {
-    let finished = false;
-    while (!finished) {
-      const newKeys = [];
-      finished = processKeys(assoc, assocName, path, newKeys);
-      assoc.keys = newKeys;
-    }
-    assoc.keys = assoc.keys.filter(o => !o.$toDelete);
-  }
-
-  /**
-   * Walk over the keys and replace structures by their leafs, managed associations by their foreign keys and keep scalar values as-is.
-   *
-   * @param {CSN.Element} assoc
-   * @param {string} assocName
-   * @param {CSN.Path} path
-   * @param {object[]} collector New keys array to collect the flattened stuff in
-   * @returns {boolean} True if all keys are scalar - false if there are things that still need to be processed.
-   */
-  function processKeys(assoc, assocName, path, collector) {
-    let finished = true;
-    for (let i = 0; i < assoc.keys.length; i++) {
-      const pathToKey = path.concat([ 'keys', i ]);
-      const { art } = inspectRef(pathToKey);
-      const { ref } = assoc.keys[i];
-      if (isStructured(art)) {
-        finished = false;
-        // Mark this element to filter it later - not needed after expansion
-        setProp(assoc.keys[i], '$toDelete', true);
-        const flat = flattenStructuredElement(art, ref[ref.length - 1], [], pathToKey);
-        Object.keys(flat).forEach((flatElemName) => {
-          const key = assoc.keys[i];
-          const clone = cloneCsn(assoc.keys[i], options);
-          if (clone.as) {
-            const lastRef = clone.ref[clone.ref.length - 1];
-            // Cut off the last ref part from the beginning of the flat name
-            const flatBaseName = flatElemName.slice(lastRef.length);
-            // Join it to the existing table alias
-            clone.as += flatBaseName;
-            // do not loose the $ref for nested keys
-            if (key.$ref) {
-              let aliasedLeaf = key.$ref[key.$ref.length - 1];
-              aliasedLeaf += flatBaseName;
-              setProp(clone, '$ref', key.$ref.slice(0, key.$ref.length - 1).concat(aliasedLeaf));
-            }
-          }
-          if (clone.ref) {
-            clone.ref[clone.ref.length - 1] = flatElemName;
-            // Now we need to properly flatten the whole ref
-            clone.ref = flattenStructStepsInRef(clone.ref, pathToKey);
-          }
-          if (!clone.as)
-            clone.as = flatElemName;
-          // Directly work on csn.definitions - this way the changes take effect in csnRefs/inspectRef immediately
-          // Add the newly generated foreign keys to the end - they will be picked up later on
-          // Recursive solutions run into call stack issues
-          collector.push(clone);
-        });
-      }
-      else if (art.target) {
-        finished = false;
-        // Mark this element to filter it later - not needed after expansion
-        setProp(assoc.keys[i], '$toDelete', true);
-        // Directly work on csn.definitions - this way the changes take effect in csnRefs/inspectRef immediately
-        // Add the newly generated foreign keys to the end - they will be picked up later on
-        // Recursive solutions run into call stack issues
-        art.keys.forEach(key => collector.push(cloneAndExtendRef(key, assoc.keys[i])));
-      }
-      else if (assoc.keys[i].ref && !assoc.keys[i].as) {
-        assoc.keys[i].as = assoc.keys[i].ref[assoc.keys[i].ref.length - 1];
-        collector.push(assoc.keys[i]);
-      }
-      else {
-        collector.push(assoc.keys[i]);
-      }
-    }
-    return finished;
-  }
-
-  /**
-   * Clone base and extend the .ref and .as of the clone with the .ref and .as of ref.
-   *
-   * @param {object} key A foreign key entry (of a managed assoc as a fk of another assoc)
-   * @param {object} base The fk-ref that has key as a fk
-   * @returns {object} The clone of base
-   */
-  function cloneAndExtendRef(key, base) {
-    const { ref } = base;
-    const clone = cloneCsn(base, options);
-    if (key.ref) {
-      // We build a ref that contains the aliased fk - that element will be created later on, so this ref is not resolvable yet
-      // Therefore we keep it as $ref - ref is the non-aliased, resolvable "clone"
-      // Later on, after we know that these foreign key elements are created, we replace ref with this $ref
-      let $ref;
-      if (base.$ref) {
-        // if a base $ref is provided, use it to correctly resolve association chains
-        const refChain = [ base.$ref[base.$ref.length - 1] ].concat(key.as || key.ref);
-        $ref = base.$ref.slice(0, base.$ref.length - 1).concat(refChain);
-      }
-      else {
-        $ref = base.ref.concat( key.as || key.ref); // Keep along the aliases
-      }
-      setProp(clone, '$ref', $ref);
-      clone.ref = clone.ref.concat(key.ref);
-    }
-
-    if (!clone.as && clone.ref && clone.ref.length > 0)
-      clone.as = ref[ref.length - 1] + pathDelimiter + (key.as || key.ref.join(pathDelimiter));
-    else
-      clone.as += pathDelimiter + (key.as || key.ref.join(pathDelimiter));
-
-    return clone;
-  }
-}
-
 
 /**
- * Return a callback function for forEachDefinition that
+ * In all .elements of entities and views (and their bound actions/functions), create the on-condition for
+ * a managed associations. This needs to happen after the .keys are expanded and the corresponding elements are created.
  *
  * @param {CSN.Model} csn
- * @param {CSN.Options} options
  * @param {string} pathDelimiter
- * @param {object} messageFunctions
- * @param {Function} messageFunctions.error
- * @returns {(artifact: CSN.Artifact, artifactName: string) => void} Callback for forEachDefinition
+ * @returns {CSN.Model} Return the input csn, with the transformations applied
  */
-function getForeignKeyElementCreator(csn, options, pathDelimiter, messageFunctions) {
-  const { error } = messageFunctions;
-  const doA2J = !(options.transformation === 'hdbcds' && options.sqlMapping === 'hdbcds');
+function attachOnConditions(csn, pathDelimiter) {
   const {
-    isManagedAssociationElement,
+    isManagedAssociation,
   } = getUtils(csn);
 
-  const {
-    flattenStructStepsInRef, getForeignKeyArtifact,
-  } = transformUtils.getTransformers(csn, options, pathDelimiter);
-
-
-  return createForeignKeyElements;
-
-  /**
-   * Create the foreign key elements for managed associations.
-   * Create them in-place, right after the corresponding association.
-   *
-   *
-   * @param {CSN.Artifact} art
-   * @param {string} artName
-   */
-  function createForeignKeyElements(art, artName) {
-    if ((art.kind === 'entity' || art.kind === 'view') && doA2J) {
-      forAllElements(art, artName, (parent, elements, pathToElements) => {
-        const elementsArray = [];
-        forEachGeneric(parent, 'elements', (element, elemName) => {
-          elementsArray.push([ elemName, element ]);
-          if (element.keys && isManagedAssociationElement(element)) {
-            for (let i = 0; i < element.keys.length; i++) {
-              const foreignKey = element.keys[i];
-              const path = [ ...pathToElements, elemName, 'keys', i ];
-              foreignKey.ref = flattenStructStepsInRef(foreignKey.ref, path);
-              const [ fkName, fkElem ] = getForeignKeyArtifact(element, elemName, foreignKey, path);
-              if (parent.elements[fkName]) {
-                error(null, [ ...pathToElements, elemName ], { name: fkName, art: elemName },
-                      'Generated foreign key element $(NAME) for association $(ART) conflicts with existing element');
-              }
-              else {
-                elementsArray.push([ fkName, fkElem ]);
-              }
-              applyCachedAlias(foreignKey);
-              // join ref array as the struct / assoc steps are not necessary anymore
-              foreignKey.ref = [ foreignKey.ref.join(pathDelimiter) ];
-            }
-          }
-        });
-
-        // Don't fake consistency of the model by adding empty elements {}
-        if (elementsArray.length === 0)
-          return;
-
-        parent.elements = elementsArray.reduce((previous, [ name, element ]) => {
-          previous[name] = element;
-          return previous;
-        }, Object.create(null));
-      });
-    }
-
-    /**
-     * We save the aliased representation of the fk in $ref - I suppose to stay resolvable?
-     *
-     * We now use this $ref for ref and delete it.
-     *
-     * @param {object} foreignKey
-     * @todo With nested projections, we solve similar problems, maybe adapt?
-     */
-    function applyCachedAlias(foreignKey) {
-      // If we have a $ref use that - it resolves aliased FKs correctly
-      if (foreignKey.$ref) {
-        foreignKey.ref = foreignKey.$ref;
-        delete foreignKey.$ref;
+  const alreadyHandled = new WeakMap();
+  applyTransformations(csn, {
+    elements: (parent, prop, elements) => {
+      for (const elemName in elements) {
+        const elem = elements[elemName];
+        // (140) Generate the ON-condition for managed associations
+        if (isManagedAssociation(elem))
+          transformManagedAssociation(elem, elemName);
       }
-    }
-  }
-}
+    },     /* only for views and entities */
+  }, [], { skipIgnore: false, allowArtifact: artifact => (artifact.kind === 'entity') });
 
-/**
- * Return a callback function for forEachDefinition that
- *
- * @param {CSN.Model} csn
- * @param {CSN.Options} options
- * @param {string} pathDelimiter
- * @returns {(artifact: CSN.Artifact, artifactName: string) => void} Callback for forEachDefinition
- */
-function getManagedAssociationTransformer(csn, options, pathDelimiter) {
-  const doA2J = !(options.transformation === 'hdbcds' && options.sqlMapping === 'hdbcds');
-  const {
-    isManagedAssociationElement,
-  } = getUtils(csn);
-
-  return handleAssociations;
-
-  /**
-   *
-   * Generate foreign keys for managed associations
-   * Forbid aliases for foreign keys
-   *
-   * @param {CSN.Artifact} artifact
-   * @param {string} artifactName
-   */
-  function handleAssociations(artifact, artifactName) {
-    // Do things specific for entities and views (pass 1)
-    if (artifact.kind === 'entity' || artifact.kind === 'view') {
-      const alreadyHandled = new WeakMap();
-      forAllElements(artifact, artifactName, (parent, elements) => {
-        for (const elemName in elements) {
-          const elem = elements[elemName];
-          // (140) Generate foreign key elements and ON-condition for managed associations
-          // (unless explicitly asked to keep assocs unchanged)
-          if (doA2J && isManagedAssociationElement(elem))
-            transformManagedAssociation(parent, artifactName, elem, elemName, alreadyHandled);
-        }
-      });
-    }
-  }
+  return csn;
 
   /**
    * Create the foreign key elements for a managed association and build the on-condition
    *
-   * @param {CSN.Artifact} artifact
-   * @param {string} artifactName
    * @param {Object} elem The association to process
    * @param {string} elemName
-   * @param {WeakMap} alreadyHandled To cache which elements were already processed
    * @returns {void}
    */
-  function transformManagedAssociation(artifact, artifactName, elem, elemName, alreadyHandled) {
+  function transformManagedAssociation(elem, elemName) {
     // No need to run over this - we already did, possibly because it was referenced in the ON-Condition
     // of another association - see a few lines lower
     if (alreadyHandled.has(elem))
       return;
-    // Generate foreign key elements for managed associations, and assemble an ON-condition with them
+    // Assemble an ON-condition with the foreign keys created in earlier steps
     const onCondParts = [];
     let joinWithAnd = false;
-    if (elem.keys.length === 0) {
+    if (elem.keys.length === 0) { // TODO: really kill instead of _ignore?
       elem._ignore = true;
     }
     else {
@@ -366,24 +88,100 @@ function getManagedAssociationTransformer(csn, options, pathDelimiter) {
     if (elem.key)
       delete elem.key;
 
-
     // If the managed association has a 'not null' property => remove it
     if (elem.notNull)
       delete elem.notNull;
 
-
     // The association is now unmanaged, i.e. actually it should no longer have foreign keys
     // at all. But the processing of backlink associations below expects to have them, so
-    // we don't delete them (but mark them as implicit so that toCdl does not render them)
+    // we don't delete them
+    // TODO: maybe make non-enumerable, so we become recompilable in the future?
 
     // Remember that we already processed this
     alreadyHandled.set(elem, true);
   }
 }
 
+/**
+ * @param {CSN.Model} csn
+ * @param {string} pathDelimiter
+ * @returns {(artifact: CSN.Artifact, artifactName: string) => void} Callback for forEachDefinition
+ */
+function getManagedAssocStepsInOnConditionFinalizer(csn, pathDelimiter) {
+  const {
+    inspectRef,
+  } = getUtils(csn);
+
+  return handleManagedAssocStepsInOnCondition;
+
+  /**
+   * Loop over all elements and for all unmanaged associations translate
+   * <assoc base>.<managed assoc>.<fk> to <assoc base>.<managed assoc>_<fk>
+   *
+   * Or in other words: Allow using the foreign keys of managed associations in on-conditions
+   *
+   * @param {CSN.Artifact} artifact Artifact to check
+   * @param {string} artifactName Name of the artifact
+   */
+  function handleManagedAssocStepsInOnCondition(artifact, artifactName) {
+    for (const elemName in artifact.elements) {
+      const elem = artifact.elements[elemName];
+      // The association is an unmanaged on
+      if (!elem.keys && elem.target && elem.on) {
+        applyTransformationsOnNonDictionary(elem, 'on', {
+          ref: (refOwner, prop, ref, path) => {
+            // [<assoc base>.]<managed assoc>.<field>
+            if (ref.length > 1) {
+              const { links } = inspectRef(path);
+              if (links) {
+                // eslint-disable-next-line for-direction
+                for (let i = links.length - 1; i >= 0; i--) {
+                  const link = links[i];
+                  // We found the latest managed assoc path step
+                  if (link.art && link.art.target && link.art.keys &&
+                    // Doesn't work when ref-target (filter condition) or similar is used
+                    !ref.slice(i).some(refElement => typeof refElement !== 'string')) {
+                    // We join the managed assoc with everything following it
+                    const sourceElementName = ref.slice(i).join(pathDelimiter);
+                    const source = findSource(links, i - 1) || artifact;
+                    // allow specifying managed assoc on the source side
+                    const fks = link.art.keys.filter(fk => ref[i] + pathDelimiter + fk.ref[0] === sourceElementName);
+                    if (fks && fks.length >= 1) {
+                      const fk = fks[0];
+                      const managedAssocStepName = refOwner.ref[i];
+                      const fkName = `${managedAssocStepName}${pathDelimiter}${fk.as}`;
+                      if (source && source.elements[fkName])
+                        refOwner.ref = [ ...ref.slice(0, i), fkName ];
+                    }
+                  }
+                }
+              }
+            }
+          },
+        }, {}, [ 'definitions', artifactName, 'elements', elemName ]);
+      }
+    }
+
+    /**
+     * Find out where the managed association is
+     *
+     * @param {Array} links
+     * @param {number} startIndex
+     * @returns {Object| undefined} CSN definition of the source of the managed association
+     */
+    function findSource(links, startIndex) {
+      for (let i = startIndex; i >= 0; i--) {
+        const link = links[i];
+        // We found the latest assoc step - now check where that points to
+        if (link.art && link.art.target)
+          return csn.definitions[link.art.target];
+      }
 
+      return undefined;
+    }
+  }
+}
 module.exports = {
-  getForeignKeyFlattener,
-  getForeignKeyElementCreator,
-  getManagedAssociationTransformer,
+  attachOnConditions,
+  getManagedAssocStepsInOnConditionFinalizer,
 };

package/lib/transform/db/cdsPersistence.js

@@ -20,7 +20,7 @@ function getAnnoProcessor() {
    * @param {CSN.Artifact} artifact
    */
   function handleCdsPersistence(artifact) {
-    const ignoreArtifact = (artifact.kind === 'entity' || artifact.kind === 'view') &&
+    const ignoreArtifact = (artifact.kind === 'entity') &&
                            (artifact.abstract ||
                             hasAnnotationValue(artifact, '@cds.persistence.skip') ||
                             hasAnnotationValue(artifact, exists));
@@ -91,7 +91,7 @@ function getAssocToSkippedIgnorer(csn, options, messageFunctions) {
   }
 
   /**
-   * Check wether the given artifact is an unreachable association target because it will not "realy" hit the database:
+   * Check whether the given artifact is an unreachable association target because it will not "realy" hit the database:
    * - @cds.persistence.skip/exists
    * - abstract
    *

package/lib/transform/db/constraints.js

@@ -1,8 +1,9 @@
 'use strict';
 
 const { forEachDefinition } = require('../../base/model');
-const { forAllElements, hasAnnotationValue, getResultingName } = require('../../model/csnUtils');
+const { applyTransformations, hasAnnotationValue, getResultingName } = require('../../model/csnUtils');
 const { csnRefs } = require('../../model/csnRefs');
+const { forEach, forEachKey } = require('../../utils/objectUtils');
 
 const COMPOSITION = 'cds.Composition';
 const ASSOCIATION = 'cds.Association';
@@ -28,34 +29,36 @@ function createReferentialConstraints(csn, options) {
   // compositions must be processed first, as the <up_> links for them must result in `ON DELETE CASCADE`
   const compositions = [];
   const associations = [];
-  forEachDefinition(csn, (artifact, artifactName) => {
-    if (!artifact.query && artifact.kind === 'entity') {
-      forAllElements(artifact, artifactName, (parent, elements, path) => {
-        // Step I: iterate compositions, enrich dependent keys for <up_> association in target entity of composition
-        for (const elementName in elements) {
-          const element = elements[elementName];
-          if (element.type === COMPOSITION && element.$selfOnCondition) {
-            compositions.push({
-              fn: () => {
-                foreignKeyConstraintForUpLinkOfComposition(element, parent, path.concat([ elementName ]));
-              },
-            });
-          }
+  applyTransformations(csn, {
+    elements: (parent, prop, elements, path) => {
+      // Step I: iterate compositions, enrich dependent keys for <up_> association in target entity of composition
+      for (const elementName in elements) {
+        const element = elements[elementName];
+        const ePath = path.concat([ 'elements', elementName ]); // Save a copy in this scope for the late callback
+        if (element.type === COMPOSITION && element.$selfOnCondition) {
+          compositions.push({
+            fn: () => {
+              foreignKeyConstraintForUpLinkOfComposition(element, parent, ePath);
+            },
+          });
         }
-        // Step II: iterate associations, enrich dependent keys (in entity containing the association)
-        for (const elementName in elements) {
-          const element = elements[elementName];
-          if (element.keys && isToOne(element) && element.type === ASSOCIATION || element.type === COMPOSITION && treatCompositionLikeAssociation(element)) {
-            associations.push({
-              fn: () => {
-                foreignKeyConstraintForAssociation(element, path.concat([ elementName ]));
-              },
-            });
-          }
+      }
+
+      // Step II: iterate associations, enrich dependent keys (in entity containing the association)
+      for (const elementName in elements) {
+        const element = elements[elementName];
+        const ePath = path.concat([ 'elements', elementName ]); // Save a copy in this scope for the late callback
+        if (element.keys && isToOne(element) && element.type === ASSOCIATION || element.type === COMPOSITION && treatCompositionLikeAssociation(element)) {
+          associations.push({
+            fn: () => {
+              foreignKeyConstraintForAssociation(element, ePath );
+            },
+          });
         }
-      });
-    }
-  });
+      }
+    },
+  }, [], { skipIgnore: false, skipArtifact: a => a.query || a.kind !== 'entity' });
+
   // create constraints on foreign keys
   // always process unmanaged first, up_ links must be flagged
   // before they are processed
@@ -215,8 +218,7 @@ function createReferentialConstraints(csn, options) {
    *  Skip referential constraint if the parent table (association target, or artifact where composition is defined)
    *  of the relation is:
    *    - a query
-   *    - TODO: Revisit -- annotated with '@cds.persistence.skip:true'
-   *    - TODO: Revisit -- annotated with '@cds.persistence.exists:true'
+   *    - annotated with '@cds.persistence.skip:true'
    *
    *  The following decision table reflects the current implementation:
    *
@@ -491,18 +493,20 @@ function createReferentialConstraints(csn, options) {
       const dependentKey = [ elementName ];
       const onDeleteRules = new Set();
       onDeleteRules.add($foreignKeyConstraint.onDelete);
-      // find all other $foreignKeyConstraint with same $sourceAssociation and same parentTable
-      Object.entries(artifact.elements)
-        .filter(([ , e ]) => e.$foreignKeyConstraint &&
-          e.$foreignKeyConstraint.sourceAssociation === $foreignKeyConstraint.sourceAssociation &&
-          e.$foreignKeyConstraint.parentTable === $foreignKeyConstraint.parentTable)
-        .forEach(([ foreignKeyName, foreignKey ]) => {
-          const $foreignKeyConstraintCopy = Object.assign({}, foreignKey.$foreignKeyConstraint);
-          delete foreignKey.$foreignKeyConstraint;
-          parentKey.push($foreignKeyConstraintCopy.parentKey);
-          dependentKey.push(foreignKeyName);
-          onDeleteRules.add($foreignKeyConstraintCopy.onDelete);
-        });
+      forEach(artifact.elements, (foreignKeyName, foreignKey) => {
+        // find all other `$foreignKeyConstraint`s with same `$sourceAssociation` and same `parentTable`
+        const matchingForeignKeyFound = foreignKey.$foreignKeyConstraint &&
+        foreignKey.$foreignKeyConstraint.sourceAssociation === $foreignKeyConstraint.sourceAssociation &&
+        foreignKey.$foreignKeyConstraint.parentTable === $foreignKeyConstraint.parentTable;
+        if (!matchingForeignKeyFound)
+          return;
+
+        const $foreignKeyConstraintCopy = Object.assign({}, foreignKey.$foreignKeyConstraint);
+        delete foreignKey.$foreignKeyConstraint;
+        parentKey.push($foreignKeyConstraintCopy.parentKey);
+        dependentKey.push(foreignKeyName);
+        onDeleteRules.add($foreignKeyConstraintCopy.onDelete);
+      });
       // onDelete Rule is the "weakest" rule applicable. Precedence: RESTRICT > SET NULL > CASCADE
       const onDelete = onDeleteRules.has('RESTRICT') ? 'RESTRICT' : 'CASCADE';
       let onDeleteRemark = null;
@@ -510,14 +514,14 @@ function createReferentialConstraints(csn, options) {
       if (options.testMode && onDelete === 'CASCADE')
         onDeleteRemark = `Up_ link for Composition "${$foreignKeyConstraint.upLinkFor}" implies existential dependency`;
       referentialConstraints[`${getResultingName(csn, 'quoted', artifactName)}_${$foreignKeyConstraint.sourceAssociation}`] = {
-        identifier: `${getResultingName(csn, options.forHana.names, artifactName)}_${$foreignKeyConstraint.sourceAssociation}`,
+        // constraint identifier start with `c__` to avoid name clashes
+        identifier: `c__${getResultingName(csn, options.forHana.names, artifactName)}_${$foreignKeyConstraint.sourceAssociation}`,
         foreignKey: dependentKey,
         parentKey,
         dependentTable: artifactName,
         parentTable,
         onDelete,
         onDeleteRemark, // explain why this particular rule is chosen
-        // TODO: do we want to switch off validation / enforcement via annotation on association?
         validated: $foreignKeyConstraint.validated,
         enforced: $foreignKeyConstraint.enforced,
       };
@@ -545,15 +549,14 @@ function assertConstraintIdentifierUniqueness(artifact, artifactName, path, erro
   if (!(artifact.$tableConstraints && artifact.$tableConstraints.referential && artifact.$tableConstraints.unique))
     return;
 
-  Object.keys(artifact.$tableConstraints.unique)
-    .map(id => `${artifactName}_${id}`) // final unique constraint identifier will be generated in renderer likewise
-    .forEach((uniqueConstraintIdentifier) => {
-      if (artifact.$tableConstraints.referential[uniqueConstraintIdentifier]) {
-        error(null, path,
-              { name: uniqueConstraintIdentifier, art: artifactName },
-              'Duplicate constraint name $(NAME) in artifact $(ART)');
-      }
-    });
+  forEachKey(artifact.$tableConstraints.unique, (uniqueConstraintKey) => {
+    const uniqueConstraintIdentifier = `${artifactName}_${uniqueConstraintKey}`; // final unique constraint identifier will be generated in renderer likewise
+    if (artifact.$tableConstraints.referential[uniqueConstraintIdentifier]) {
+      error(null, path,
+            { name: uniqueConstraintIdentifier, art: artifactName },
+            'Duplicate constraint name $(NAME) in artifact $(ART)');
+    }
+  });
 }
 
 module.exports = { createReferentialConstraints, assertConstraintIdentifierUniqueness };