@sap/cds-compiler 6.1.0 → 6.3.0

package/lib/transform/forRelationalDB.js

@@ -1,13 +1,16 @@
 'use strict';
 
 const { setProp, isBetaEnabled } = require('../base/model');
-const { forEachMemberRecursively, forAllQueries, applyTransformationsOnNonDictionary,
-        getArtifactDatabaseNameOf, getElementDatabaseNameOf, applyTransformations,
-        walkCsnPath, isPersistedOnDatabase
-      } = require('../model/csnUtils');
+const {
+  forEachMemberRecursively, forAllQueries, applyTransformationsOnNonDictionary,
+  getArtifactDatabaseNameOf, getElementDatabaseNameOf, applyTransformations,
+  walkCsnPath, isPersistedOnDatabase,
+} = require('../model/csnUtils');
 const transformUtils = require('./transformUtils');
 const { translateAssocsToJoinsCSN } = require('./translateAssocsToJoins');
-const { csnRefs, pathId, traverseQuery, columnAlias} = require('../model/csnRefs');
+const {
+  csnRefs, pathId, traverseQuery, columnAlias,
+} = require('../model/csnRefs');
 const { checkCSNVersion } = require('../json/csnVersion');
 const validate = require('../checks/validator');
 const { rejectManagedAssociationsAndStructuresForHdbcdsNames } = require('../checks/selectItems');
@@ -33,11 +36,11 @@ const backlinks = require('./db/backlinks');
 const { getDefaultTypeLengths } = require('../render/utils/common');
 const { featureFlags } = require('./featureFlags');
 const { cloneCsnNonDict, cloneFullCsn } = require('../model/cloneCsn');
-const { processSqlServices, createServiceDummy  } = require('./db/processSqlServices');
+const { processSqlServices, createServiceDummy } = require('./db/processSqlServices');
 
 // By default: Do not process non-entities/views
 function forEachDefinition(csn, cb) {
-  _forEachDefinition(csn, cb, {skip: ['annotation', 'action', 'function','event']})
+  _forEachDefinition(csn, cb, { skip: [ 'annotation', 'action', 'function', 'event' ] });
 }
 
 /**
@@ -129,10 +132,10 @@ function transformForRelationalDBWithCsn(csn, options, messageFunctions) {
   /** @type {() => void} */
   let throwWithAnyError;
   // transformUtils
-  let addDefaultTypeFacets,
-    expandStructsInExpression,
-    flattenStructuredElement,
-    flattenStructStepsInRef;
+  let addDefaultTypeFacets;
+  let expandStructsInExpression;
+  let flattenStructuredElement;
+  let flattenStructStepsInRef;
 
   bindCsnReference();
 
@@ -163,12 +166,12 @@ function transformForRelationalDBWithCsn(csn, options, messageFunctions) {
   // exit if validators found errors
   throwWithAnyError();
 
-  if(csn.meta?.[featureFlags]?.$calculatedElements)
+  if (csn.meta?.[featureFlags]?.$calculatedElements)
     rewriteCalculatedElementsInViews(csn, options, csnUtils, pathDelimiter, messageFunctions);
 
   timetrace.start('Where-Exists handling');
   // Needs to happen before tuple expansion, so the newly generated WHERE-conditions have it applied
-  handleExists(csn, options, error, csnUtils.inspectRef, csnUtils.initDefinition, csnUtils.dropDefinitionCache);
+  handleExists(csn, options, messageFunctions, csnUtils);
   timetrace.stop('Where-Exists handling');
 
   // Check if structured elements and managed associations are compared in an expression
@@ -179,17 +182,17 @@ function transformForRelationalDBWithCsn(csn, options, messageFunctions) {
   timetrace.start('Expand Structures (expressions + refs)');
   // If this function is ever undefined, we have a bug in our logic.
   // @ts-ignore
-  expandStructsInExpression(csn, { drillRef: true });
+  expandStructsInExpression({ drillRef: true });
 
   forEachDefinition(csn, [
     // (001) Add a temporal where condition to views where applicable before assoc2join
     //       assoc2join eventually rewrites the table aliases
     temporal.getViewDecorator(csn, messageFunctions, csnUtils, options),
     // check unique constraints - further processing is done in rewriteUniqueConstraints
-    assertUnique.prepare(csn, options, messageFunctions)
+    assertUnique.prepare(csn, options, messageFunctions),
   ]);
 
-  if(doA2J) {
+  if (doA2J) {
     // Expand a structured thing in: keys, columns, order by, group by
     // In addition, kill all non-sql-backend relevant annotations
     expansion.expandStructureReferences(csn, options, pathDelimiter, messageFunctions, csnUtils, { processAnnotations: true });
@@ -220,7 +223,7 @@ function transformForRelationalDBWithCsn(csn, options, messageFunctions) {
   // With that, we could still ensure the processing order (assuming we don't run into problems with scoping).
   // To analyze: Increased memory vs. saved cycles
   // Looked at it with AFC: This is only a small part of the overall processing time, enrich step of validator is just as expensive
-  if(doA2J) {
+  if (doA2J) {
     const resolved = new WeakMap();
     // No refs with struct-steps exist anymore
     flattening.flattenAllStructStepsInRefs(csn, options, messageFunctions, resolved, pathDelimiter);
@@ -229,7 +232,8 @@ function transformForRelationalDBWithCsn(csn, options, messageFunctions) {
     flattening.resolveTypeReferences(csn, options, messageFunctions, resolved, pathDelimiter);
     // No structured elements exists anymore
     flattening.flattenElements(csn, options, messageFunctions, pathDelimiter);
-  } else {
+  }
+  else {
     // For to.hdbcds with naming mode hdbcds we also need to resolve the types
     flattening.resolveTypeReferences(csn, options, messageFunctions, new WeakMap(), pathDelimiter);
   }
@@ -247,19 +251,19 @@ function transformForRelationalDBWithCsn(csn, options, messageFunctions) {
   const redoProjections = [];
   // Use the "raw" forEachDefinition here to ensure that the $ignore takes effect
   _forEachDefinition(csn, (artifact) => {
-    if(artifact.kind === 'entity' && artifact.projection) {
+    if (artifact.kind === 'entity' && artifact.projection) {
       artifact.query = { SELECT: artifact.projection };
       delete artifact.projection;
       redoProjections.push(() => {
-        if(artifact.query) {
+        if (artifact.query) {
           artifact.projection = artifact.query.SELECT;
           delete artifact.query;
-          if(artifact.$syntax === 'projection') {
+          if (artifact.$syntax === 'projection')
             delete artifact.$syntax;
-          }
         }
-      })
-    } else if(artifact.kind === 'annotation' || artifact.kind === 'action' || artifact.kind === 'function' || artifact.kind === 'event'){
+      });
+    }
+    else if (artifact.kind === 'annotation' || artifact.kind === 'action' || artifact.kind === 'function' || artifact.kind === 'event') {
       // $ignore actions etc. - this loop seemed handy for this, as we can hook into an existing if
       artifact.$ignore = true;
     }
@@ -267,21 +271,20 @@ function transformForRelationalDBWithCsn(csn, options, messageFunctions) {
 
   processCalculatedElementsInEntities(csn, options);
 
-  timetrace.start('Transform CSN')
+  timetrace.start('Transform CSN');
 
   // Rename primitive types, make UUID a String; replace `items` by cds.LargeString
   //
   // First, gather all nodes that are arrayed: Don't replace inline, or getFinalTypeInfo()
   // may not return `.items` for types that were already processed.
   // TODO: Do this in resolveTypeReferences?
-  {
-    applyTransformations(csn, {
-      type: (node) => {
-        renamePrimitiveTypesAndUuid(node.type, node, 'type');
-        addDefaultTypeFacets(node, implicitDefaultLengths);
-      },
-    });
-  }
+  applyTransformations(csn, {
+    type: (node) => {
+      renamePrimitiveTypesAndUuid(node.type, node, 'type');
+      addDefaultTypeFacets(node, implicitDefaultLengths);
+    },
+  });
+
 
   forEachDefinition(csn, [
     // (040) Ignore entities and views that are abstract or implemented
@@ -290,24 +293,29 @@ function transformForRelationalDBWithCsn(csn, options, messageFunctions) {
     cdsPersistence.getAnnoProcessor(),
     // (050) Check @cds.valid.from/to only on entity
     //       Views are checked in (001), unbalanced valid.from/to's or mismatching origins
-    temporal.getAnnotationHandler(csn, options, pathDelimiter, messageFunctions)
+    temporal.getAnnotationHandler(csn, options, pathDelimiter, messageFunctions),
   ]);
 
-  // eliminate the doA2J in the functions 'handleManagedAssociationFKs' and 'createForeignKeyElements'
-  doA2J && flattening.handleManagedAssociationsAndCreateForeignKeys(csn, options, messageFunctions, pathDelimiter, true, csnUtils, { skipDict: { actions: true }, allowArtifact: artifact => (artifact.kind === 'entity') });
-
-  doA2J && forEachDefinition(csn, flattenIndexes);
-  // Managed associations get an on-condition - in views and entities
-  doA2J && associations.attachOnConditions(csn, csnUtils, pathDelimiter);
+  if (doA2J) {
+    // eliminate the doA2J in the functions 'handleManagedAssociationFKs' and 'createForeignKeyElements'
+    flattening.handleManagedAssociationsAndCreateForeignKeys(
+      csn, options, messageFunctions, pathDelimiter, true, csnUtils,
+      { skipDict: { actions: true }, allowArtifact: artifact => (artifact.kind === 'entity') }
+    );
+    forEachDefinition(csn, flattenIndexes);
+    // Managed associations get an on-condition - in views and entities
+    associations.attachOnConditions(csn, csnUtils, pathDelimiter);
+  }
 
   {
     // (045) Strip all query-ish properties from views and projections annotated with '@cds.persistence.table',
     // and make them entities
-    const fns = [cdsPersistence.getPersistenceTableProcessor(csn, options, messageFunctions)];
+    const fns = [ cdsPersistence.getPersistenceTableProcessor(csn, options, messageFunctions) ];
     // Allow using managed associations as steps in on-conditions to access their fks
     // To be done after handleAssociations, since then the foreign keys of the managed assocs
     // are part of the elements
-    if(doA2J) fns.push(associations.getFKAccessFinalizer(csn, csnUtils, pathDelimiter));
+    if (doA2J)
+      fns.push(associations.getFKAccessFinalizer(csn, options, csnUtils, pathDelimiter));
 
     forEachDefinition(csn, fns);
   }
@@ -327,7 +335,7 @@ function transformForRelationalDBWithCsn(csn, options, messageFunctions) {
       if (!doA2J && definition.query && isPersistedOnDatabase(definition)) {
         // reject managed association and structure publishing for to-hdbcds.hdbcds
         const that = { csnUtils, options, error };
-        rejectManagedAssociationsAndStructuresForHdbcdsNames.call(that, definition, path)
+        rejectManagedAssociationsAndStructuresForHdbcdsNames.call(that, definition, path);
       }
     },
     // (170) Transform '$self' in backlink associations to appropriate key comparisons
@@ -335,7 +343,7 @@ function transformForRelationalDBWithCsn(csn, options, messageFunctions) {
     // draft shadow entities have crooked '_artifact' links, confusing the backlink processing.
     // But it must also happen after flattenForeignKeys has been called for all artifacts,
     // because otherwise we would produce wrong ON-conditions for the keys involved. Sigh ...
-    backlinks.getBacklinkTransformer(csnUtils, messageFunctions, options, pathDelimiter, doA2J)
+    backlinks.getBacklinkTransformer(csnUtils, messageFunctions, options, pathDelimiter, doA2J),
   ]);
 
   /**
@@ -343,7 +351,7 @@ function transformForRelationalDBWithCsn(csn, options, messageFunctions) {
    * For to.hdbcds with naming mode "hdbcds", no foreign keys are calculated,
    * hence we do not generate the referential constraints for them.
    */
-  if(options.sqlDialect !== 'plain' && options.sqlDialect !== 'h2' && doA2J)
+  if (options.sqlDialect !== 'plain' && options.sqlDialect !== 'h2' && doA2J)
     createReferentialConstraints(csn, options);
 
   // no constraints for drafts
@@ -360,24 +368,24 @@ function transformForRelationalDBWithCsn(csn, options, messageFunctions) {
   messageFunctions.throwWithError();
 
   // TODO: Might have to do this earlier if we want special rendering for projections?
-  const findAndMarkSqlServiceArtifacts = options.sqlDialect === 'hana' && options.src === 'hdi' && (csn.meta?.[featureFlags]?.$sqlService || csn.meta?.[featureFlags]?.$dummyService) ? processSqlServices(csn, options): () => {}
+  const findAndMarkSqlServiceArtifacts = options.sqlDialect === 'hana' && options.src === 'hdi' && (csn.meta?.[featureFlags]?.$sqlService || csn.meta?.[featureFlags]?.$dummyService || csn.meta?.[featureFlags]?.$dataProductService) ? processSqlServices(csn, options) : () => {};
 
   // Apply view-specific transformations
   // (160) Projections now finally become views
   // Replace managed association in group/order by with foreign keys
   const transformEntityOrViewPass2 = getViewTransformer(csn, options, messageFunctions);
-  forEachDefinition(csn, [(artifact, artifactName) => {
+  forEachDefinition(csn, [ (artifact, artifactName) => {
     findAndMarkSqlServiceArtifacts(artifact, artifactName);
-    if(artifact.$dummyService)
+    if (artifact.$dummyService)
       createServiceDummy(artifact, artifactName, csn, messageFunctions);
-  },  transformViews]);
+  }, transformViews ]);
 
-  if(!doA2J) {
+  if (!doA2J) {
     forEachDefinition(csn, [
       // (200) Strip 'key' property from type elements
       removeKeyPropInType,
       (artifact, artifactName) => {
-        if(artifact.kind === 'type') {
+        if (artifact.kind === 'type') {
           forEachMemberRecursively(artifact, (member, memberName, prop, path) => {
             // Check type parameters (length, precision, scale ...)
             if (!member.$ignore) {
@@ -388,7 +396,7 @@ function transformForRelationalDBWithCsn(csn, options, messageFunctions) {
             }
           }, [ 'definitions', artifactName ]);
         }
-      }
+      },
     ]);
   }
 
@@ -409,55 +417,56 @@ function transformForRelationalDBWithCsn(csn, options, messageFunctions) {
           csnUtils.addStringAnnotationTo('@cds.persistence.name', getElementDatabaseNameOf(name, options.sqlMapping, options.sqlDialect), element);
       });
       // Remove leading $self to keep renderer-diffs smaller
-      if(doA2J && options.transformation === 'hdbcds')
+      if (doA2J && options.transformation === 'hdbcds')
         flattening.removeLeadingSelf(parent, prop, elements);
-    }
-  }, [(definitions, artifactName, artifact) => {
+    },
+  }, [ (definitions, artifactName, artifact) => {
     // Attach @cds.persistence.name to artifacts
     if (!artifact.$ignore && artifact.kind !== 'service' && artifact.kind !== 'context')
       csnUtils.addStringAnnotationTo('@cds.persistence.name', getArtifactDatabaseNameOf(artifactName, options.sqlMapping, csn, options.sqlDialect), artifact);
-  }], { allowArtifact: artifact => artifact.kind === 'entity'});
+  } ], { allowArtifact: artifact => artifact.kind === 'entity' });
 
   throwWithAnyError();
 
-  function killProp(parent, prop){
+  function killProp(parent, prop) {
     delete parent[prop];
   }
 
-  function killParent(parent, a, b, path){
-    if(path.length > 2) {
-      const tail = path[path.length-1];
-      const parentPath = path.slice(0, -1)
+  function killParent(parent, a, b, path) {
+    if (path.length > 2) {
+      const tail = path[path.length - 1];
+      const parentPath = path.slice(0, -1);
       const parentParent = walkCsnPath(csn, parentPath);
       delete parentParent[tail];
-    } else {
+    }
+    else {
       delete parent.$ignore;
     }
   }
 
   const killers = {
     // Used to ignore actions etc from processing and remove associations/elements
-    '$ignore': killParent,
+    $ignore: killParent,
     // Still used in flattenStructuredElements - in db/flattening.js
-    '_flatElementNameWithDots': killProp,
+    _flatElementNameWithDots: killProp,
     // Set when setting default string/binary length - used in copyTypeProperties and fixBorkedElementsOfLocalized
     // to not copy the .length property if it was only set via default
-    '$default': killProp,
+    $default: killProp,
     // Set when we turn UUID into String, checked during generateDraftForHana
-    '$renamed': killProp,
+    $renamed: killProp,
     // Set when we remove .key from temporal things, used in localized.js
-    '$key': killProp,
+    $key: killProp,
     // We need .elements easily for rendering - otherwise we have to compute it then
     // Does not fit in the "killers" theme - TODO: Find a better place
     SET: (parent, prop, SET) => {
-      if(!SET.elements) {
-        const stack = [parent];
-        while(stack.length > 0) {
+      if (!SET.elements) {
+        const stack = [ parent ];
+        while (stack.length > 0) {
           const query = stack.pop();
 
-          if(query.SET)
+          if (query.SET)
             stack.push(query.SET.args[0]);
-          else if(query.SELECT)
+          else if (query.SELECT)
             setProp(SET, 'elements', query.SELECT.elements);
         }
       }
@@ -465,34 +474,33 @@ function transformForRelationalDBWithCsn(csn, options, messageFunctions) {
     includes: killProp,
     masked: killProp,
     localized: killProp,
-  }
+  };
 
-  if(options.sqlDialect === 'postgres') {
+  if (options.sqlDialect === 'postgres') {
     killers.length = (parent) => {
-      if (parent.type === 'cds.Binary') {
+      if (parent.type === 'cds.Binary')
         delete parent.length;
-      }
-    }
+    };
   }
 
-  if(options.sqlDialect === 'hana' && options.withHanaAssociations === false && doA2J) {
+  if (options.sqlDialect === 'hana' && options.withHanaAssociations === false && doA2J)
     killers.target = killParent;
-  }
+
 
   const killTypes = [];
 
-  if(doA2J) { // replace types and aspects with dummies to shrink overall CSN size
+  if (doA2J) { // replace types and aspects with dummies to shrink overall CSN size
     killers.kind = (parent, prop, kind, path) => {
-      if(kind === 'type' || kind === 'aspect') {
+      if (kind === 'type' || kind === 'aspect') {
         const artifactName = path[1];
         killTypes.push(() => {
           csn.definitions[artifactName] = {
             kind,
-            type: 'cds.Integer'
+            type: 'cds.Integer',
           };
-        })
+        });
       }
-    }
+    };
   }
 
   applyTransformations(csn, killers, [], { skipIgnore: false });
@@ -506,19 +514,20 @@ function transformForRelationalDBWithCsn(csn, options, messageFunctions) {
 
   /* ----------------------------------- Functions start here -----------------------------------------------*/
 
-  function bindCsnReference(){
+  function bindCsnReference() {
     messageFunctions.setModel(csn);
     ({ error, throwWithAnyError } = messageFunctions);
 
-    ({ flattenStructuredElement,
+    ({
+      flattenStructuredElement,
       flattenStructStepsInRef,
       addDefaultTypeFacets,
       expandStructsInExpression,
-      csnUtils
+      csnUtils,
     } = transformUtils.getTransformers(csn, options, messageFunctions, pathDelimiter));
   }
 
-  function bindCsnReferenceOnly(){
+  function bindCsnReferenceOnly() {
     // invalidate caches for CSN ref API
     const csnRefApi = csnRefs(csn);
     Object.assign(csnUtils, csnRefApi);
@@ -533,45 +542,42 @@ function transformForRelationalDBWithCsn(csn, options, messageFunctions) {
       if (mixin) {
         query.SELECT.columns
           // filter for associations which are used in the SELECT
-          .filter((c) => {
-            return c.ref && c.ref.length > 1;
-          })
+          .filter(c => c.ref && c.ref.length > 1)
           .forEach((usedAssoc) => {
             const assocName = pathId(usedAssoc.ref[0]);
             const mixinAssociation = mixin[assocName];
             if (mixinAssociation)
-              mixinAssociation.on = getResolvedMixinOnCondition(mixinAssociation, query, assocName, path.concat(['mixin', assocName]));
-          })
+              mixinAssociation.on = getResolvedMixinOnCondition(mixinAssociation, query, assocName, path.concat([ 'mixin', assocName ]));
+          });
       }
-    }, ['definitions', artifactName, 'query']);
+    }, [ 'definitions', artifactName, 'query' ]);
   }
 
   // For non-A2J only
   function getResolvedMixinOnCondition(mixinAssociation, query, assocName, path) {
-    const referencedThroughStar = query.SELECT.columns.some((column) => column === '*');
+    const referencedThroughStar = query.SELECT.columns.some(column => column === '*');
     return mixinAssociation.on.map(handeMixinOnConditionPart);
 
-    function handeMixinOnConditionPart(onConditionPart, i)  {
+    function handeMixinOnConditionPart(onConditionPart, i) {
       let columnToReplace;
-      if (onConditionPart.ref && (onConditionPart.ref[0] === '$projection' || onConditionPart.ref[0] === '$self')){
-        const { links } = csnUtils.inspectRef(path.concat(['on', i]));
-        if (links) {
+      if (onConditionPart.ref && (onConditionPart.ref[0] === '$projection' || onConditionPart.ref[0] === '$self')) {
+        const { links } = csnUtils.inspectRef(path.concat([ 'on', i ]));
+        if (links)
           columnToReplace = onConditionPart.ref[links.length - 1];
-        }
       }
       if (!columnToReplace)
         return onConditionPart;
 
       const replaceWith = query.SELECT.columns.find(col => columnAlias(col) === 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
+        // 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 = csnUtils.get$combined(query);
         forEach(elementsOfQuerySources, (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)
+          // 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;
         });
         return onConditionPart;
@@ -582,9 +588,8 @@ function transformForRelationalDBWithCsn(csn, options, messageFunctions) {
         delete clone.as;
         return clone;
       }
-      else {
-        return onConditionPart
-      }
+
+      return onConditionPart;
     }
   }
 
@@ -597,29 +602,29 @@ function transformForRelationalDBWithCsn(csn, options, messageFunctions) {
     if (!artifact.$ignore) {
       // Do things specific for entities and views (pass 2)
       if ((artifact.kind === 'entity') && artifact.query) {
-
         // First pass: Set alias name for SELECTs without table alias. Required for setting proper table aliases
         // for HDBCDS in naming mode HDBCDS.  We use the same schema as the core-compiler, so duplicates should
         // have already been reported.
-        if(options.transformation === 'hdbcds' && options.sqlMapping === 'hdbcds') {
+        if (options.transformation === 'hdbcds' && options.sqlMapping === 'hdbcds') {
           let selectDepth = 0;
           traverseQuery(artifact.query, null, null, (query, fromSelect) => {
             if (!query.ref && !query.as && fromSelect) {
               // Use +1; for UNION, it's the next select, for SELECT, it's increased later.
-              query.as = `$_select_${selectDepth + 1}__`;
+              query.as = `$_select_${ selectDepth + 1 }__`;
             }
-            if (query.SELECT) ++selectDepth;
+            if (query.SELECT)
+              ++selectDepth;
           });
         }
 
         const process = (parent, prop, query, path) => {
-          transformEntityOrViewPass2(parent, artifact, artifactName, path.concat(prop))
+          transformEntityOrViewPass2(parent, artifact, artifactName, path.concat(prop));
           replaceAssociationsInGroupByOrderBy(parent, options, csnUtils.inspectRef, error, path.concat(prop));
           return query;
-        }
+        };
         applyTransformationsOnNonDictionary(csn.definitions, artifactName, {
-          SELECT: process
-        }, {}, [ 'definitions']);
+          SELECT: process,
+        }, {}, [ 'definitions' ]);
       }
     }
   }
@@ -654,9 +659,9 @@ function transformForRelationalDBWithCsn(csn, options, messageFunctions) {
 
     // restore all (non-enumerable) properties that wouldn't survive reaugmentation/compactification into the new compact model
     forEachDefinition(csn, (art, artName) => {
-      if (art['$tableConstraints']) {
-        newCsn.definitions[artName].$tableConstraints = art['$tableConstraints'];
-      }
+      if (art.$tableConstraints)
+        newCsn.definitions[artName].$tableConstraints = art.$tableConstraints;
+
       if (art.technicalConfig)
         newCsn.definitions[artName].technicalConfig = art.technicalConfig;
     });
@@ -677,7 +682,7 @@ function transformForRelationalDBWithCsn(csn, options, messageFunctions) {
     // assert key === 'type'
     const hanaNamesMap = {
       __proto__: null,
-      'cds.UUID': 'cds.String'
+      'cds.UUID': 'cds.String',
     };
     node[key] = hanaNamesMap[val] || val;
     if (val === 'cds.UUID' && !node.length) {
@@ -685,9 +690,9 @@ function transformForRelationalDBWithCsn(csn, options, messageFunctions) {
       setProp(node, '$renamed', 'cds.UUID');
     }
 
-    if(options.sqlDialect === 'h2' && val === 'cds.Decimal' && node.scale === undefined) {
+    if (options.sqlDialect === 'h2' && val === 'cds.Decimal' && node.scale === undefined)
       node[key] = 'cds.DecimalFloat'; // cds.Decimal and cds.Decimal(p) should map do DECFLOAT for h2
-    }
+
 
     // Length/Precision/Scale is done in addDefaultTypeFacets
   }
@@ -742,23 +747,27 @@ function transformForRelationalDBWithCsn(csn, options, messageFunctions) {
           if (options.sqlDialect === 'plain')
             error('ref-unsupported-type', path, { '#': 'dialect', type: node.type, value: 'plain' });
           else if (options.transformation === 'hdbcds')
-            error('ref-unsupported-type', path, {'#': 'hdbcds', type: node.type, value: options.sqlDialect });
+            error('ref-unsupported-type', path, { '#': 'hdbcds', type: node.type, value: options.sqlDialect });
           break;
         }
         case 'cds.Vector': {
           if (options.sqlDialect !== 'hana') {
             error('ref-unsupported-type', path, {
-              '#': 'hana', type: node.type, value: 'hana',
-              othervalue: options.sqlDialect
+              '#': 'hana',
+              type: node.type,
+              value: 'hana',
+              othervalue: options.sqlDialect,
             });
           }
           else if (options.transformation === 'hdbcds') {
             error('ref-unsupported-type', path, {
-              '#': 'hdbcds', type: node.type, value: options.sqlDialect
+              '#': 'hdbcds', type: node.type, value: options.sqlDialect,
             });
           }
           break;
         }
+        default:
+          break; // nothing to check for unknown types
       }
     }
 
@@ -767,21 +776,22 @@ function transformForRelationalDBWithCsn(csn, options, messageFunctions) {
     function checkTypeParamValue(node, paramName, range = null, path = null) {
       const paramValue = node[paramName];
       if (paramValue == null) {
-        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('type-missing-argument', path, { name: paramName, id: node.type, $reviewed: false });
-        }
+
+        return error('type-missing-argument', path, { name: paramName, id: node.type, $reviewed: false });
       }
       if (range) {
         if (isMaxParameterLengthRestricted(node.type) && range.max && paramValue > range.max) {
-          error('type-unexpected-argument', path,
-            { '#': 'max', prop: paramName, type: node.type, number: range.max, $reviewed: false });
+          error('type-unexpected-argument', path, {
+            '#': 'max', prop: paramName, type: node.type, number: range.max, $reviewed: false,
+          });
           return false;
         }
         if (range.min && paramValue < range.min) {
-          error('type-unexpected-argument', path,
-            { '#': 'min', prop: paramName, type: node.type, number: range.min, $reviewed: false });
+          error('type-unexpected-argument', path, {
+            '#': 'min', prop: paramName, type: node.type, number: range.min, $reviewed: false,
+          });
           return false;
         }
       }
@@ -816,9 +826,10 @@ function transformForRelationalDBWithCsn(csn, options, messageFunctions) {
           if (Array.isArray(index)) {
             const flattenedIndex = [];
             const isFulltextIndex = (index[0] === 'fulltext');
-            index.forEach((val, idx) => {
+            for (let idx = 0; idx < index.length; idx++) {
+              const val = index[idx];
               if (typeof val === 'object' && val.ref) {
-                // Replace a reference by references to it's elements, if it is structured
+                // Replace a reference by references to its elements, if it is structured
                 const path = [ 'definitions', artName, 'technicalConfig', dialect, 'indexes', name, idx ];
                 const { art } = csnUtils.inspectRef(path);
                 if (!art) {
@@ -832,7 +843,7 @@ function transformForRelationalDBWithCsn(csn, options, messageFunctions) {
                   // First, compute the name from the path, e.g ['s', 's1', 's2' ] will result in 'S_s1_s2' ...
                   const [ refPath ] = flattenStructStepsInRef(val.ref, path);
                   // ... and take this as the prefix for all elements
-                  const flattenedElems = flattenStructuredElement(art, refPath, [], ['definitions', artName, 'elements']);
+                  const flattenedElems = flattenStructuredElement(art, refPath, [], [ 'definitions', artName, 'elements' ]);
                   Object.keys(flattenedElems).forEach((elem, i, elems) => {
                     // if it's not the first entry, add a ',' ...
                     if (i)
@@ -850,11 +861,10 @@ function transformForRelationalDBWithCsn(csn, options, messageFunctions) {
                   flattenedIndex.push({ ref: refPath });
                 }
               }
-              else // it's just some token like 'index', '(' etc. so we copy it over
-              {
+              else { // it's just some token like 'index', '(' etc. so we copy it over
                 flattenedIndex.push(val);
               }
-            });
+            }
             // Replace index by the flattened one
             tc[dialect].indexes[name] = flattenedIndex;
           }
@@ -862,7 +872,6 @@ function transformForRelationalDBWithCsn(csn, options, messageFunctions) {
       }
     }
   }
-
 }
 
 module.exports = {