@sap/cds-compiler 4.0.2 → 4.2.2

package/lib/transform/forRelationalDB.js

@@ -7,9 +7,9 @@ const { cloneCsnNonDict,
         isAspect, walkCsnPath, isPersistedOnDatabase,
       } = require('../model/csnUtils');
 const { makeMessageFunction } = require('../base/messages');
-const transformUtils = require('./transformUtilsNew');
+const transformUtils = require('./transformUtils');
 const { translateAssocsToJoinsCSN } = require('./translateAssocsToJoins');
-const { csnRefs, pathId, traverseQuery } = 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');
@@ -26,7 +26,7 @@ const expansion = require('./db/expansion');
 const assertUnique = require('./db/assertUnique');
 const generateDrafts = require('./draft/db');
 const enrichUniversalCsn = require('./universalCsn/universalCsnEnricher');
-const { getViewTransformer } = require('./db/views');
+const { getViewTransformer, ensureColumnNames } = require('./db/views');
 const cdsPersistence = require('./db/cdsPersistence');
 const temporal = require('./db/temporal');
 const associations = require('./db/associations')
@@ -98,17 +98,17 @@ function forEachDefinition(csn, cb) {
  * - (250) Remove name space definitions again (only in forRelationalDB). Maybe we can omit inserting namespace definitions
  *         completely (TODO)
  *
- * @param {CSN.Model}   inputModel
+ * @param {CSN.Model}   csn
  * @param {CSN.Options} options
  * @param {string}      moduleName The calling compiler module name, e.g. `to.hdi` or `to.hdbcds`.
  */
-function transformForRelationalDBWithCsn(inputModel, options, moduleName) {
+function transformForRelationalDBWithCsn(csn, options, moduleName) {
   // copy the model as we don't want to change the input model
   timetrace.start('HANA transformation');
 
   timetrace.start('Clone CSN');
   /** @type {CSN.Model} */
-  let csn = cloneCsnNonDict(inputModel, options);
+  csn = cloneCsnNonDict(csn, options);
   timetrace.stop('Clone CSN');
 
   checkCSNVersion(csn, options);
@@ -117,20 +117,13 @@ function transformForRelationalDBWithCsn(inputModel, options, moduleName) {
   // There is also an explicit default length via options.defaultStringLength
   const implicitDefaultLengths = getDefaultTypeLengths(options.sqlDialect);
 
+  /** @type {object} */
   let csnUtils;
+  /** @type {object} */
+  let messageFunctions;
   let message, error, warning, info; // message functions
   /** @type {() => void} */
   let throwWithAnyError;
-  // csnUtils
-  let artifactRef,
-    inspectRef,
-    effectiveType,
-    initDefinition,
-    dropDefinitionCache,
-    get$combined,
-    getCsnDef,
-    isAssocOrComposition,
-    addStringAnnotationTo;
   // transformUtils
   let addDefaultTypeFacets,
     expandStructsInExpression,
@@ -148,6 +141,8 @@ function transformForRelationalDBWithCsn(inputModel, options, moduleName) {
     bindCsnReference();
   }
 
+  ensureColumnNames(csn, options, csnUtils);
+
   const dialect = options.sqlDialect;
   const doA2J = !(options.transformation === 'hdbcds' && options.sqlMapping === 'hdbcds');
   if (!doA2J)
@@ -159,14 +154,16 @@ function transformForRelationalDBWithCsn(inputModel, options, moduleName) {
   timetrace.start('Validate');
   // Run validations on CSN - each validator function has access to the message functions and the inspect ref via this
   const cleanup = validate.forRelationalDB(csn, {
-    message, error, warning, info, inspectRef, effectiveType, artifactRef, csnUtils, csn, options, isAspect
+    ...messageFunctions, csnUtils, ...csnUtils, csn, options, isAspect
   });
   timetrace.stop('Validate');
 
-  rewriteCalculatedElementsInViews(csn, options, pathDelimiter, error);
+  rewriteCalculatedElementsInViews(csn, options, csnUtils, pathDelimiter, messageFunctions);
 
   // Needs to happen before tuple expansion, so the newly generated WHERE-conditions have it applied
-  handleExists(csn, options, error, inspectRef, initDefinition, dropDefinitionCache);
+  handleExists(csn, options, error, csnUtils.inspectRef, csnUtils.initDefinition, csnUtils.dropDefinitionCache);
+
+  doA2J && flattening.linkForeignKeyAnnotationExtensionsToAssociation(csn, options);
 
   // Check if structured elements and managed associations are compared in an expression
   // and expand these structured elements. This tuple expansion allows all other
@@ -179,19 +176,17 @@ function transformForRelationalDBWithCsn(inputModel, options, moduleName) {
 
   throwWithAnyError();
 
-  const transformCsn = transformUtils.transformModel;
-
   forEachDefinition(csn, [
     // (001) Add a temporal where condition to views where applicable before assoc2join
     //       assoc2join eventually rewrites the table aliases
-    temporal.getViewDecorator(csn, {info}, csnUtils),
+    temporal.getViewDecorator(csn, messageFunctions, csnUtils),
     // 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, throwWithAnyError}, csnUtils);
+    expansion.expandStructureReferences(csn, options, pathDelimiter, messageFunctions, csnUtils);
     bindCsnReference();
   }
 
@@ -217,7 +212,7 @@ function transformForRelationalDBWithCsn(inputModel, options, moduleName) {
     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);
+    flattening.resolveTypeReferences(csn, options, new WeakMap(), pathDelimiter);
   }
 
   // (010) If requested, translate associations to joins
@@ -227,7 +222,7 @@ function transformForRelationalDBWithCsn(inputModel, options, moduleName) {
   bindCsnReference();
 
   const redoProjections = [];
-  // Use the "raw" forEachDefinition here to ensure that the _ignore takes effect
+  // Use the "raw" forEachDefinition here to ensure that the $ignore takes effect
   _forEachDefinition(csn, (artifact) => {
     if(artifact.kind === 'entity' && artifact.projection) {
       artifact.query = { SELECT: artifact.projection };
@@ -242,8 +237,8 @@ function transformForRelationalDBWithCsn(inputModel, options, moduleName) {
         }
       })
     } 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;
+      // $ignore actions etc. - this loop seemed handy for this, as we can hook into an existing if
+      artifact.$ignore = true;
     }
   });
 
@@ -251,20 +246,30 @@ function transformForRelationalDBWithCsn(inputModel, options, moduleName) {
 
   timetrace.start('Transform CSN')
 
-  // (000) Rename primitive types, make UUID a String
-  transformCsn(csn, {
-    type: (val, node, key) => {
-      renamePrimitiveTypesAndUuid(val, node, key);
-      addDefaultTypeFacets(node, implicitDefaultLengths);
-    },
+  // 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.
+  {
+    const removeItems = new Set();
+    applyTransformations(csn, {
+      type: (node) => {
+        if (node.items || node.type && csnUtils.getFinalTypeInfo(node.type)?.items)
+          removeItems.add(node);
+        renamePrimitiveTypesAndUuid(node.type, node, 'type');
+        addDefaultTypeFacets(node, implicitDefaultLengths);
+      },
+      items: (node) => removeItems.add(node),
+    });
     // no support for array-of - turn into CLOB/Text
     // must be done after A2J or compiler checks could change
     // (e.g. annotation def checks for arrayed types)
-    items: (val, node) => {
+    for (const node of removeItems) {
       node.type = 'cds.LargeString';
       delete node.items;
-    },
-  }, true);
+    }
+    removeItems.clear();
+  }
 
   forEachDefinition(csn, [
     // (040) Ignore entities and views that are abstract or implemented
@@ -273,7 +278,7 @@ function transformForRelationalDBWithCsn(inputModel, options, moduleName) {
     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, {error})
+    temporal.getAnnotationHandler(csn, options, pathDelimiter, messageFunctions)
   ]);
 
   // eliminate the doA2J in the functions 'handleManagedAssociationFKs' and 'createForeignKeyElements'
@@ -285,7 +290,7 @@ function transformForRelationalDBWithCsn(inputModel, options, moduleName) {
 
   // (045) Strip all query-ish properties from views and projections annotated with '@cds.persistence.table',
   // and make them entities
-  forEachDefinition(csn, cdsPersistence.getPersistenceTableProcessor(csn, options, {error}));
+  forEachDefinition(csn, 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
@@ -341,19 +346,19 @@ function transformForRelationalDBWithCsn(inputModel, options, moduleName) {
     createReferentialConstraints(csn, options);
 
   // no constraints for drafts
-  generateDrafts(csn, options, pathDelimiter, { info, warning, error });
+  generateDrafts(csn, options, pathDelimiter, messageFunctions);
 
   // Set the final constraint paths and produce hana tc indexes if required
   // See function comment for extensive information.
   assertUnique.rewrite(csn, options, pathDelimiter);
 
   // Associations that point to things marked with @cds.persistence.skip are removed
-  forEachDefinition(csn, cdsPersistence.getAssocToSkippedIgnorer(csn, options, {info}, csnUtils));
+  forEachDefinition(csn, cdsPersistence.getAssocToSkippedIgnorer(csn, options, messageFunctions, csnUtils));
 
   // Apply view-specific transformations
   // (160) Projections now finally become views
   // Replace managed association in group/order by with foreign keys
-  const transformEntityOrViewPass2 = getViewTransformer(csn, options, {error, info}, transformCommon);
+  const transformEntityOrViewPass2 = getViewTransformer(csn, options, messageFunctions, transformCommon);
   forEachDefinition(csn, transformViews);
 
   // Recursively apply transformCommon and attach @cds.persistence.name
@@ -384,14 +389,14 @@ function transformForRelationalDBWithCsn(inputModel, options, moduleName) {
 
   const killers = {
     // Used to ignore actions etc from processing and remove associations/elements
-    '_ignore': function (parent, a, b, path){
+    '$ignore': function (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 {
-        delete parent._ignore;
+        delete parent.$ignore;
       }
     },
     // Still used in flattenStructuredElements - in db/flattening.js
@@ -441,7 +446,8 @@ function transformForRelationalDBWithCsn(inputModel, options, moduleName) {
   /* ----------------------------------- Functions start here -----------------------------------------------*/
 
   function bindCsnReference(){
-    ({ error, warning, info, message, throwWithAnyError } = makeMessageFunction(csn, options, moduleName));
+    messageFunctions = makeMessageFunction(csn, options, moduleName);
+    ({ error, warning, info, message, throwWithAnyError } = messageFunctions);
 
     ({ flattenStructuredElement,
       flattenStructStepsInRef,
@@ -451,94 +457,85 @@ function transformForRelationalDBWithCsn(inputModel, options, moduleName) {
       expandStructsInExpression,
       csnUtils
     } = transformUtils.getTransformers(csn, options, pathDelimiter));
-
-    ({ artifactRef,
-      inspectRef,
-      effectiveType,
-      initDefinition,
-      dropDefinitionCache,
-      get$combined,
-      getCsnDef,
-      isAssocOrComposition,
-      addStringAnnotationTo,
-    } = csnUtils);
   }
 
   function bindCsnReferenceOnly(){
     // invalidate caches for CSN ref API
-    ({ artifactRef, inspectRef, effectiveType, initDefinition, dropDefinitionCache } = csnRefs(csn));
+    const csnRefApi = csnRefs(csn);
+    Object.assign(csnUtils, csnRefApi);
   }
 
+  // For non-A2J only
   function handleMixinOnConditions(artifact, artifactName) {
-    if (!artifact.query)
+    if (!artifact.query) // projections can't have mixins
       return;
     forAllQueries(artifact.query, (query, path) => {
-      const { mixin } = query.SELECT  || {};
-      if(mixin) {
+      const { mixin } = query.SELECT || {};
+      if (mixin) {
         query.SELECT.columns
-        // filter for associations which are used in the SELECT
-        .filter((c) => {
-          return c.ref &&  c.ref.length > 1;
-        })
-        .forEach((usedAssoc) => {
-          const assocName = pathId(usedAssoc.ref[0]);
-          const mixinAssociation = mixin[assocName];
-          if(mixinAssociation){
-            mixinAssociation.on = getResolvedMixinOnCondition(csn, mixinAssociation, query, assocName, path.concat(['mixin', assocName]));
-          }
-        })
+          // filter for associations which are used in the SELECT
+          .filter((c) => {
+            return 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]));
+          })
       }
-    }, [ 'definitions', artifactName, 'query' ]);
-
-    function getResolvedMixinOnCondition(csn, mixinAssociation, query, assocName, path){
-      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){
-                  columnToReplace = onConditionPart.ref[links.length - 1];
-                }
-              }
-              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);
-                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)
-                    onConditionPart.ref[0] = element[0].parent;
-                });
-              }
+    }, ['definitions', artifactName, 'query']);
+  }
 
-              // No implicit CAST in on-condition
-              if(replaceWith && replaceWith.cast) {
-                const clone = cloneCsnNonDict(replaceWith, options);
-                delete clone.cast;
-                return clone;
-              }
-              return replaceWith || onConditionPart;
-            });
+  // For non-A2J only
+  function getResolvedMixinOnCondition(mixinAssociation, query, assocName, path) {
+    const referencedThroughStar = query.SELECT.columns.some((column) => column === '*');
+    return mixinAssociation.on.map(handeMixinOnConditionPart);
+
+    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) {
+          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
+        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)
+            onConditionPart.ref[0] = element[0].parent;
+        });
+        return onConditionPart;
+      }
+      else if (replaceWith) {
+        const clone = cloneCsnNonDict(replaceWith, options);
+        delete clone.cast;  // No implicit CAST in on-condition
+        delete clone.as;
+        return clone;
+      }
+      else {
+        return onConditionPart
+      }
     }
   }
 
+
   /**
    * @param {CSN.Artifact} artifact
    * @param {string} artifactName
    */
   function transformViews(artifact, artifactName) {
-    if (!artifact._ignore) {
+    if (!artifact.$ignore) {
       // Do things specific for entities and views (pass 2)
       if ((artifact.kind === 'entity') && artifact.query) {
 
@@ -557,7 +554,7 @@ function transformForRelationalDBWithCsn(inputModel, options, moduleName) {
 
         const process = (parent, prop, query, path) => {
           transformEntityOrViewPass2(parent, artifact, artifactName, path.concat(prop))
-          replaceAssociationsInGroupByOrderBy(parent, options, inspectRef, error, path.concat(prop));
+          replaceAssociationsInGroupByOrderBy(parent, options, csnUtils.inspectRef, error, path.concat(prop));
           return query;
         }
         applyTransformationsOnNonDictionary(csn.definitions, artifactName, {
@@ -572,9 +569,9 @@ function transformForRelationalDBWithCsn(inputModel, options, moduleName) {
    * @param {string} artifactName
    */
   function recursivelyApplyCommon(artifact, artifactName) {
-    if (!artifact._ignore) {
+    if (!artifact.$ignore) {
       if (artifact.kind !== 'service' && artifact.kind !== 'context')
-        addStringAnnotationTo('@cds.persistence.name', getArtifactDatabaseNameOf(artifactName, options.sqlMapping, csn, options.sqlDialect), artifact);
+        csnUtils.addStringAnnotationTo('@cds.persistence.name', getArtifactDatabaseNameOf(artifactName, options.sqlMapping, csn, options.sqlDialect), artifact);
 
       forEachMemberRecursively(artifact, (member, memberName, property, path) => {
         if (property === 'returns')
@@ -584,7 +581,7 @@ function transformForRelationalDBWithCsn(inputModel, options, moduleName) {
         // Virtual elements in entities and types are not annotated, as they have no DB representation.
         // In views they are, as we generate a null expression for them (null as <colname>)
         if ((!member.virtual || artifact.query))
-          addStringAnnotationTo('@cds.persistence.name', getElementDatabaseNameOf(memberName, options.sqlMapping, options.sqlDialect), member);
+          csnUtils.addStringAnnotationTo('@cds.persistence.name', getElementDatabaseNameOf(memberName, options.sqlMapping, options.sqlDialect), member);
       }, [ 'definitions', artifactName ]);
     }
   }
@@ -594,7 +591,7 @@ function transformForRelationalDBWithCsn(inputModel, options, moduleName) {
    * @param {string} artifactName
    */
   function removeKeyPropInType(artifact, artifactName) {
-    if (!artifact._ignore && artifact.kind === 'type') {
+    if (!artifact.$ignore && artifact.kind === 'type') {
       forEachMemberRecursively(artifact, (member) => {
         if (member.key)
           delete member.key;
@@ -618,7 +615,7 @@ function transformForRelationalDBWithCsn(inputModel, options, moduleName) {
     function doit(dict, subPath) {
       for (const elemName in dict) {
         const elem = dict[elemName];
-        if (elem.on && isAssocOrComposition(elem))
+        if (elem.on && csnUtils.isAssocOrComposition(elem))
           processBacklinkAssoc(elem, elemName, artifact, artifactName, subPath.concat([ elemName, 'on' ]));
       }
     }
@@ -641,7 +638,7 @@ function transformForRelationalDBWithCsn(inputModel, options, moduleName) {
       // For HANA: Report an error on
       // - view with parameters that has an element of type association/composition
       // - association that points to entity with parameters
-      if (options.sqlDialect === 'hana' && member.target && isAssocOrComposition(member) && !isBetaEnabled(options, 'assocsWithParams')) {
+      if (options.sqlDialect === 'hana' && member.target && csnUtils.isAssocOrComposition(member) && !isBetaEnabled(options, 'assocsWithParams')) {
         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)
@@ -676,7 +673,7 @@ function transformForRelationalDBWithCsn(inputModel, options, moduleName) {
    * @param {string} artifactName
    */
   function handleChecksForWithParameters(artifact, artifactName) {
-    if (!artifact._ignore && artifact.params && (artifact.kind === 'entity')) {
+    if (!artifact.$ignore && artifact.params && (artifact.kind === 'entity')) {
       if (!artifact.query) { // table entity with params
         // Allow with plain
         error(null, [ 'definitions', artifactName ], { '#': options.toSql ? 'sql' : 'std' }, {
@@ -707,19 +704,38 @@ function transformForRelationalDBWithCsn(inputModel, options, moduleName) {
     throwWithAnyError();
     // 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));
+    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
     forEachDefinition(csn, (art, artName) => {
       if(art['$tableConstraints']) {
-        setProp(newCsn.definitions[artName], '$tableConstraints', art['$tableConstraints']);
+        newCsn.definitions[artName].$tableConstraints = art['$tableConstraints'];
       }
       if (art.technicalConfig)
         newCsn.definitions[artName].technicalConfig = art.technicalConfig;
 
     });
+    // restore $fkExtensions and $structRef for foreign key annotations
+    if (isBetaEnabled(options, 'annotateForeignKeys')) {
+      forEachDefinition(csn, (oldDef, artName) => {
+        const newDef = newCsn.definitions[artName];
+        if(oldDef?.elements) {
+          Object.entries(oldDef.elements).forEach(([eltName, oldElt]) => {
+            const newElt = newDef.elements[eltName];
+            if(oldElt.$fkExtensions)
+              setProp(newElt, '$fkExtensions', oldElt.$fkExtensions);
+            oldElt.keys?.forEach((fk, i) => {
+              if(fk.$structRef && newElt.keys?.[i])
+                setProp(newElt.keys[i], '$structRef', fk.$structRef);
+            })
+          })
+        }
+      });
+    }
     csn = newCsn;
   }
 
@@ -754,11 +770,7 @@ function transformForRelationalDBWithCsn(inputModel, options, moduleName) {
   function renamePrimitiveTypesAndUuid(val, node, key) {
     // assert key === 'type'
     const hanaNamesMap = createDict({
-      'cds.DateTime': 'cds.UTCDateTime',
-      'cds.Timestamp': 'cds.UTCTimestamp',
-      'cds.Date': 'cds.LocalDate',
-      'cds.Time': 'cds.LocalTime',
-      'cds.UUID': 'cds.String',
+      'cds.UUID': 'cds.String'
     });
     node[key] = hanaNamesMap[val] || val;
     if (val === 'cds.UUID' && !node.length) {
@@ -790,7 +802,7 @@ function transformForRelationalDBWithCsn(inputModel, options, moduleName) {
     if (elem.default && elem.default['#']) {
       let Enum = elem.enum;
       if (!Enum && !isBuiltinType(elem.type)) {
-        const typeDef = getCsnDef(elem.type);
+        const typeDef = csnUtils.getCsnDef(elem.type);
         Enum = typeDef && typeDef.enum;
       }
       if (!Enum) {
@@ -852,7 +864,7 @@ function transformForRelationalDBWithCsn(inputModel, options, moduleName) {
           // Check if one side is $self and the other an association
           // (if so, replace all three tokens with the condition generated from the other side, in parentheses)
           if (isDollarSelfOrProjectionOperand(xprArgs[i]) && isAssociationOperand(xprArgs[i + 2], path.concat([ i + 2 ]))) {
-            const assoc = inspectRef(path.concat([ i + 2 ])).art;
+            const assoc = csnUtils.inspectRef(path.concat([ i + 2 ])).art;
             if (multipleExprs)
               result.push('(');
             const backlinkName = xprArgs[i + 2].ref[xprArgs[i + 2].ref.length - 1];
@@ -867,7 +879,7 @@ function transformForRelationalDBWithCsn(inputModel, options, moduleName) {
             attachBacklinkInformation(backlinkName);
           }
           else if (isDollarSelfOrProjectionOperand(xprArgs[i + 2]) && isAssociationOperand(xprArgs[i], path.concat([ i ]))) {
-            const assoc = inspectRef(path.concat([ i ])).art;
+            const assoc = csnUtils.inspectRef(path.concat([ i ])).art;
             if (multipleExprs)
               result.push('(');
             const backlinkName = xprArgs[i].ref[xprArgs[i].ref.length - 1];
@@ -943,7 +955,7 @@ function transformForRelationalDBWithCsn(inputModel, options, moduleName) {
         if(assoc.keys.length)
           return transformDollarSelfComparisonWithManagedAssoc(assocOp, assoc, assocName, elemName);
         else {
-          elem._ignore = true;
+          elem.$ignore = true;
           return [];
         }
       }
@@ -1034,10 +1046,10 @@ function transformForRelationalDBWithCsn(inputModel, options, moduleName) {
   function checkTypeParameters(artifact, artifactName) {
     forEachMemberRecursively(artifact, (member, memberName, prop, path) => {
       // Check type parameters (length, precision, scale ...)
-      if (!member._ignore && member.type)
+      if (!member.$ignore && member.type)
         _check(member, memberName, csn, path);
 
-      if (!member._ignore && member.items && member.items.type)
+      if (!member.$ignore && member.items && member.items.type)
         _check(member.items, memberName, csn, path.concat([ 'items' ]));
     }, [ 'definitions', artifactName ]);
 
@@ -1079,7 +1091,7 @@ function transformForRelationalDBWithCsn(inputModel, options, moduleName) {
       // (which can currently only be 'positiveInteger') and (optional) the value is in a given range
       function checkTypeParamValue(node, paramName, range = null, path = null) {
         const paramValue = node[paramName];
-        if (paramValue === undefined || paramValue === null) {
+        if (paramValue == null) {
           if(options.toSql || artifact.query || !['cds.Binary','cds.hana.BINARY', 'cds.hana.NCHAR','cds.hana.CHAR'].includes(node.type)) {
             return true;
           } else {
@@ -1134,7 +1146,7 @@ function transformForRelationalDBWithCsn(inputModel, options, moduleName) {
               if (typeof val === 'object' && val.ref) {
                 // Replace a reference by references to it's elements, if it is structured
                 const path = [ 'definitions', artName, 'technicalConfig', dialect, 'indexes', name, idx ];
-                const { art } = inspectRef(path);
+                const { art } = csnUtils.inspectRef(path);
                 if (!art) {
                   // A reference that has no artifact (e.g. the reference to the index name itself). Just copy it over
                   flattenedIndex.push(val);
@@ -1176,8 +1188,8 @@ function transformForRelationalDBWithCsn(inputModel, options, moduleName) {
       }
     }
   }
-}
 
+}
 
 module.exports = {
   transformForRelationalDBWithCsn,