@sap/cds-compiler 2.15.2 → 3.0.2

package/lib/render/utils/sql.js

@@ -40,18 +40,18 @@ function renderReferentialConstraint(constraint, indent, toUpperCase, csn, optio
   }
 
   const renderAsHdbconstraint = options.transformation === 'hdbcds' ||
-                                (options.toSql && options.toSql.src === 'hdi') ||
+                                options.src === 'hdi' ||
                                 (options.manageConstraints && options.manageConstraints.src === 'hdi');
 
-  const { names } = options.forHana;
-  const forSqlite = options.toSql && options.toSql.dialect === 'sqlite';
+  const { sqlMapping } = options;
+  const forSqlite = options.sqlDialect === 'sqlite';
   let result = '';
   result += `${indent}CONSTRAINT ${quoteId(constraint.identifier)}\n`;
   if (renderAsHdbconstraint)
-    result += `${indent}ON ${quoteId(getResultingName(csn, names, constraint.dependentTable))}\n`;
+    result += `${indent}ON ${quoteId(getResultingName(csn, sqlMapping, constraint.dependentTable))}\n`;
   if (!alterConstraint) {
     result += `${indent}FOREIGN KEY(${constraint.foreignKey.map(quoteId).join(', ')})\n`;
-    result += `${indent}REFERENCES ${quoteId(getResultingName(csn, names, constraint.parentTable))}(${constraint.parentKey.map(quoteId).join(', ')})\n`;
+    result += `${indent}REFERENCES ${quoteId(getResultingName(csn, sqlMapping, constraint.parentTable))}(${constraint.parentKey.map(quoteId).join(', ')})\n`;
     const onDeleteRemark = constraint.onDeleteRemark ? ` -- ${constraint.onDeleteRemark}` : '';
 
     // omit 'RESTRICT' action for ON UPDATE / ON DELETE, because it interferes with deferred constraint check
@@ -65,12 +65,13 @@ function renderReferentialConstraint(constraint, indent, toUpperCase, csn, optio
     }
   }
   // constraint enforcement / validation must be switched off using sqlite pragma statement
-  if (options.toSql && options.toSql.dialect !== 'sqlite') {
+  // Does not include HDBCDS.
+  if (options.toSql && !forSqlite) {
     result += `${indent}${!constraint.validated ? 'NOT ' : ''}VALIDATED\n`;
     result += `${indent}${!constraint.enforced ? 'NOT ' : ''}ENFORCED\n`;
   }
   // for sqlite, the DEFERRABLE keyword is required
-  result += `${indent}${options.toSql && options.toSql.dialect === 'sqlite' ? 'DEFERRABLE ' : ''}INITIALLY DEFERRED`;
+  result += `${indent}${forSqlite ? 'DEFERRABLE ' : ''}INITIALLY DEFERRED`;
   return result;
 }
 
@@ -85,9 +86,9 @@ function getIdentifierUtils(options) {
   /**
    * Return 'name' with appropriate "-quotes.
    * Additionally perform the following conversions on 'name'
-   * If 'options.toSql.names' is 'plain'
+   * If 'options.sqlMapping' is 'plain'
    *   - replace '.' or '::' by '_'
-   * else if 'options.toSql.names' is 'quoted'
+   * else if 'options.sqlMapping' is 'quoted'
    *   - replace '::' by '.'
    * Complain about names that collide with known SQL keywords or functions
    *
@@ -97,13 +98,13 @@ function getIdentifierUtils(options) {
   function quoteSqlId(name) {
     name = prepareIdentifier(name);
 
-    switch (options.toSql.names) {
+    switch (options.sqlMapping) {
       case 'plain':
-        return smartId(name, options.toSql.dialect);
+        return smartId(name, options.sqlDialect);
       case 'quoted':
-        return delimitedId(name, options.toSql.dialect);
+        return delimitedId(name, options.sqlDialect);
       case 'hdbcds':
-        return delimitedId(name, options.toSql.dialect);
+        return delimitedId(name, options.sqlDialect);
       default:
         return undefined;
     }
@@ -111,9 +112,9 @@ function getIdentifierUtils(options) {
 
   /**
      * Prepare an identifier:
-     * If 'options.toSql.names' is 'plain'
+     * If 'options.sqlMapping' is 'plain'
      *   - replace '.' or '::' by '_'
-     * else if 'options.toSql.names' is 'quoted'
+     * else if 'options.sqlMapping' is 'quoted'
      *  - replace '::' by '.'
      *
      * @param {string} name Identifier to prepare
@@ -121,11 +122,11 @@ function getIdentifierUtils(options) {
      */
   function prepareIdentifier(name) {
     // Sanity check
-    if (options.toSql.dialect === 'sqlite' && options.toSql.names !== 'plain')
-      throw new ModelError(`Not expecting ${options.toSql.names} names for 'sqlite' dialect`);
+    if (options.sqlDialect === 'sqlite' && options.sqlMapping !== 'plain')
+      throw new ModelError(`Not expecting ${options.sqlMapping} names for 'sqlite' dialect`);
 
 
-    switch (options.toSql.names) {
+    switch (options.sqlMapping) {
       case 'plain':
         return name.replace(/(\.|::)/g, '_');
       case 'quoted':
@@ -133,7 +134,7 @@ function getIdentifierUtils(options) {
       case 'hdbcds':
         return name;
       default:
-        throw new ModelError(`No matching rendering found for naming mode ${options.toSql.names}`);
+        throw new ModelError(`No matching rendering found for naming mode ${options.sqlMapping}`);
     }
   }
 }

package/lib/sql-identifier.js

@@ -45,6 +45,12 @@ const sqlDialects = {
     effectiveName: name => name,
     asDelimitedId: name => `"${ name.replace(/"/g, '""')}"`,
   },
+  postgres: {
+    regularRegex: /^[A-Za-z_][A-Za-z_$0-9]*$/,
+    reservedWords: keywords.postgres,
+    effectiveName: name => name.toLowerCase(),
+    asDelimitedId: name => `"${ name.replace(/"/g, '""')}"`,
+  },
   hana: {
     regularRegex: /^[A-Za-z_][A-Za-z_$#0-9]*$/,
     reservedWords: keywords.hana,

package/lib/transform/db/.eslintrc.json

@@ -17,15 +17,16 @@
     "sonarjs/prefer-single-boolean-return": "off",
     // Very whiny and nitpicky
     "sonarjs/cognitive-complexity": "off",
+    "sonarjs/no-duplicate-string": "off",
     // Does not recognize TS types
     "jsdoc/no-undefined-types": "off"
   },
   "parserOptions": {
-    "ecmaVersion": 2018,
+    "ecmaVersion": 2020,
     "sourceType": "script"
   },
   "env": {
-    "es6": true,
+    "es2020": true,
     "node": true
   },
   "settings": {

package/lib/transform/db/cdsPersistence.js

@@ -81,26 +81,16 @@ function getAssocToSkippedIgnorer(csn, options, messageFunctions) {
    * @todo Why do we check for @cds.persistence.exists here if the parent-function only calls this for skip/abstract?
    */
   function ignore(member, memberName, prop, path) {
-    if (options.sqlDialect === 'hana' && !member._ignore && member.target && isAssocOrComposition(member.type) && isUnreachableAssociationTarget(csn.definitions[member.target])) {
-      const targetAnnotation = hasAnnotationValue(csn.definitions[member.target], exists) ? exists : '@cds.persistence.skip';
+    if (options.sqlDialect === 'hana' &&
+       !member._ignore && member.target &&
+       isAssocOrComposition(member.type) &&
+       !isPersistedOnDatabase(csn.definitions[member.target])) {
       info(null, path,
-           { target: member.target, anno: targetAnnotation },
+           { target: member.target, anno: '@cds.persistence.skip' },
            'Association has been removed as it\'s target $(TARGET) is annotated with $(ANNO)');
       member._ignore = true;
     }
   }
-
-  /**
-   * Check whether the given artifact is an unreachable association target because it will not "realy" hit the database:
-   * - @cds.persistence.skip/exists
-   * - abstract
-   *
-   * @param {CSN.Artifact} art
-   * @returns {boolean}
-   */
-  function isUnreachableAssociationTarget(art) {
-    return !isPersistedOnDatabase(art) || hasAnnotationValue(art, exists);
-  }
 }
 
 /**

package/lib/transform/db/constraints.js

@@ -517,7 +517,7 @@ function createReferentialConstraints(csn, options) {
         onDeleteRemark = `Up_ link for Composition "${$foreignKeyConstraint.upLinkFor}" implies existential dependency`;
       referentialConstraints[`${getResultingName(csn, 'quoted', artifactName)}_${$foreignKeyConstraint.sourceAssociation}`] = {
         // constraint identifier start with `c__` to avoid name clashes
-        identifier: `c__${getResultingName(csn, options.forHana.names, artifactName)}_${$foreignKeyConstraint.sourceAssociation}`,
+        identifier: `c__${getResultingName(csn, options.sqlMapping, artifactName)}_${$foreignKeyConstraint.sourceAssociation}`,
         foreignKey: dependentKey,
         parentKey,
         dependentTable: artifactName,

package/lib/transform/db/expansion.js

@@ -24,10 +24,11 @@ const { forEach } = require('../../utils/objectUtils');
  * @param {object} iterateOptions
  */
 function expandStructureReferences(csn, options, pathDelimiter, { error, info, throwWithAnyError }, iterateOptions = {}) {
+  const csnUtils = getUtils(csn);
   const {
-    isStructured, get$combined, getFinalBaseType, getServiceName,
-  } = getUtils(csn);
-  let { effectiveType, inspectRef } = csnRefs(csn);
+    isStructured, get$combined, getFinalBaseTypeWithProps, getServiceName,
+  } = csnUtils;
+  let { effectiveType, inspectRef } = csnUtils;
 
   if (isBetaEnabled(options, 'nestedProjections'))
     rewriteExpandInline();
@@ -239,13 +240,13 @@ function expandStructureReferences(csn, options, pathDelimiter, { error, info, t
      */
     function nextBase(parent, base) {
       if (parent.ref) {
-        const finalBaseType = getFinalBaseType(parent._art.type);
+        const finalBaseType = getFinalBaseTypeWithProps(parent._art.type);
         const art = parent._art;
 
-        if (finalBaseType === 'cds.Association' || finalBaseType === 'cds.Composition')
+        if (finalBaseType && (finalBaseType.type === 'cds.Association' || finalBaseType.type === 'cds.Composition'))
           return csn.definitions[art.target].elements;
 
-        return art.elements || finalBaseType.elements;
+        return art.elements || finalBaseType?.elements;
       }
 
       return base;

package/lib/transform/db/flattening.js

@@ -47,6 +47,7 @@ function removeLeadingSelf(csn) {
  * @param {object} iterateOptions
  */
 function resolveTypeReferences(csn, options, resolved, pathDelimiter, iterateOptions = {}) {
+  const typeCache = Object.create(null); // TODO: Argument as well?
   /**
    * Remove .localized from the element and any sub-elements
    *
@@ -67,8 +68,8 @@ function resolveTypeReferences(csn, options, resolved, pathDelimiter, iterateOpt
         stack.push(...Object.values(current.elements));
     }
   }
-  const { toFinalBaseType } = transformUtils.getTransformers(csn, options, pathDelimiter);
-  const { getServiceName, getFinalBaseType } = getUtils(csn);
+  const { toFinalBaseType, csnUtils } = transformUtils.getTransformers(csn, options, pathDelimiter);
+  const { getServiceName, getFinalBaseTypeWithProps } = csnUtils;
 
   // We don't want to iterate over actions
   if (iterateOptions.skipDict && !iterateOptions.skipDict.actions)
@@ -82,14 +83,14 @@ function resolveTypeReferences(csn, options, resolved, pathDelimiter, iterateOpt
     cast: (parent, prop, cast, path) => {
       // Resolve cast already - we otherwise lose .localized
       if (cast.type && !isBuiltinType(cast.type) && (!options.toOdata || options.toOdata && !isODataV4BuiltinFromService(cast.type, path) && !isODataItems(cast.type)))
-        toFinalBaseType(parent.cast, resolved, true);
+        toFinalBaseType(parent.cast, resolved, true, typeCache);
     },
     // @ts-ignore
     type: (parent, prop, type, path) => {
       if (options.toOdata && parent.kind && parent.kind in ignoreOdataKinds)
         return;
       if (!isBuiltinType(type) && (!options.toOdata || options.toOdata && !isODataV4BuiltinFromService(type, path) && !isODataItems(type))) {
-        toFinalBaseType(parent, resolved);
+        toFinalBaseType(parent, resolved, true, typeCache);
         // structured types might not have the child-types replaced.
         // Drill down to ensure this.
         if (parent.elements) {
@@ -98,7 +99,7 @@ function resolveTypeReferences(csn, options, resolved, pathDelimiter, iterateOpt
             const elements = stack.pop();
             for (const e of Object.values(elements)) {
               if (e.type && !isBuiltinType(e.type))
-                toFinalBaseType(e, resolved);
+                toFinalBaseType(e, resolved, true, typeCache);
 
               if (e.elements)
                 stack.push(e.elements);
@@ -152,11 +153,11 @@ function resolveTypeReferences(csn, options, resolved, pathDelimiter, iterateOpt
    * @returns {boolean}
    */
   function isODataV4BuiltinFromService(typeName, path) {
-    if (!options.toOdata || (options.toOdata && options.toOdata.version === 'v2') || typeof typeName !== 'string')
+    if (!options.toOdata || (options.odataVersion === 'v2') || typeof typeName !== 'string')
       return false;
 
     const typeServiceName = getServiceName(typeName);
-    const finalBaseType = getFinalBaseType(typeName);
+    const finalBaseType = getFinalBaseTypeWithProps(typeName)?.type;
     // we need the service of the current definition
     const currDefServiceName = getServiceName(path[1]);
 
@@ -266,9 +267,8 @@ function flattenAllStructStepsInRefs(csn, options, resolved, pathDelimiter, iter
  * @param {object} iterateOptions
  */
 function flattenElements(csn, options, pathDelimiter, error, iterateOptions = {}) {
-  const { isAssocOrComposition } = getUtils(csn);
-  const { flattenStructuredElement } = transformUtils.getTransformers(csn, options, pathDelimiter);
-  const { effectiveType } = csnRefs(csn);
+  const { flattenStructuredElement, csnUtils } = transformUtils.getTransformers(csn, options, pathDelimiter);
+  const { isAssocOrComposition, effectiveType } = csnUtils;
   const transformers = {
     elements: flatten,
   };
@@ -299,11 +299,13 @@ function flattenElements(csn, options, pathDelimiter, error, iterateOptions = {}
         const flatElems = flattenStructuredElement(element, elementName, [], path.concat([ 'elements', elementName ]));
 
         for (const flatElemName in flatElems) {
-          if (parent[prop][flatElemName])
+          if (parent[prop][flatElemName]) {
             // TODO: combine message ID with generated FK duplicate
-            // do the duplicate check in the consruct callback, requires to mark generated flat elements,
+            // do the duplicate check in the construct callback, requires to mark generated flat elements,
             // check: Error location should be the existing element like @odata.foreignKey4
-            error(null, path.concat([ 'elements', elementName ]), `"${path[1]}.${elementName}": Flattened struct element name conflicts with existing element: "${flatElemName}"`);
+            error('name-duplicate-element', path.concat([ 'elements', elementName ]),
+                  { '#': 'flatten-element-exist', name: flatElemName });
+          }
 
           const flatElement = flatElems[flatElemName];
 
@@ -609,8 +611,7 @@ function handleManagedAssociationsAndCreateForeignKeys(csn, options, error, path
           ((options.toOdata && isDeepEqual(element, parent[prop][fk[0]], true)) ||
             !options.toOdata)) {
             // error location is the colliding element
-            error(null, eltPath, { name: fk[0], art: elementName },
-                  'Generated foreign key element $(NAME) for association $(ART) conflicts with existing element');
+            error('name-duplicate-element', eltPath, { '#': 'flatten-fkey-exists', name: fk[0], art: elementName });
           }
           // attach a proper $path
           setProp(element, '$path', eltPath);
@@ -619,10 +620,8 @@ function handleManagedAssociationsAndCreateForeignKeys(csn, options, error, path
 
         // check for duplicate foreign keys
         Object.entries(refCount).forEach(([ name, occ ]) => {
-          if (occ > 1) {
-            error(null, eltPath, { name },
-                  'Duplicate definition of foreign key element $(NAME)');
-          }
+          if (occ > 1)
+            error('name-duplicate-element', eltPath, { '#': 'flatten-fkey-gen', name, art: elementName });
         });
         if (element.keys) {
           element.keys.forEach((key, i) => {

package/lib/transform/db/views.js

@@ -3,7 +3,7 @@
 const {
   getUtils, cloneCsnNonDict, applyTransformationsOnNonDictionary,
 } = require('../../model/csnUtils');
-const { implicitAs, csnRefs } = require('../../model/csnRefs');
+const { implicitAs } = require('../../model/csnRefs');
 const { isBetaEnabled } = require('../../base/model');
 const { ModelError } = require('../../base/error');
 
@@ -69,9 +69,9 @@ function usesMixinAssociation(query, association, associationName) {
 function getViewTransformer(csn, options, messageFunctions, transformCommon) {
   const {
     get$combined, isAssocOrComposition,
+    inspectRef, queryOrMain, // csnRefs
   } = getUtils(csn);
-  const { inspectRef, queryOrMain } = csnRefs(csn);
-  const pathDelimiter = (options.forHana.names === 'hdbcds') ? '.' : '_';
+  const pathDelimiter = options.forHana && (options.sqlMapping === 'hdbcds') ? '.' : '_';
   const { error, info } = messageFunctions;
   const doA2J = !(options.transformation === 'hdbcds' && options.sqlMapping === 'hdbcds');
 

package/lib/transform/draft/.eslintrc.json

@@ -23,11 +23,11 @@
     "sonarjs/no-duplicate-string": "off"
   },
   "parserOptions": {
-    "ecmaVersion": 2018,
+    "ecmaVersion": 2020,
     "sourceType": "script"
   },
   "env": {
-    "es6": true,
+    "es2020": true,
     "node": true
   },
   "settings": {

package/lib/transform/draft/db.js

@@ -1,7 +1,7 @@
 'use strict';
 
 const {
-  hasAnnotationValue, getUtils, getServiceNames, forEachDefinition,
+  hasAnnotationValue, getServiceNames, forEachDefinition,
   getResultingName, forEachMemberRecursively,
 } = require('../../model/csnUtils');
 const { setProp, isDeprecatedEnabled } = require('../../base/model');
@@ -19,15 +19,15 @@ const booleanBuiltin = 'cds.Boolean';
  * @param {object} messageFunctions
  */
 function generateDrafts(csn, options, pathDelimiter, messageFunctions) {
-  const draftSuffix = isDeprecatedEnabled(options, 'generatedEntityNameWithUnderscore') ? '_drafts' : '.drafts';
+  const draftSuffix = isDeprecatedEnabled(options, '_generatedEntityNameWithUnderscore') ? '_drafts' : '.drafts';
   // All services of the model - needed for drafts
   const allServices = getServiceNames(csn);
   const draftRoots = new WeakMap();
   const {
     createForeignKeyElement, createAndAddDraftAdminDataProjection, createScalarElement, createAssociationElement,
-    addElement, copyAndAddElement, createAssociationPathComparison,
+    addElement, copyAndAddElement, createAssociationPathComparison, csnUtils,
   } = getTransformers(csn, options, pathDelimiter);
-  const { getCsnDef, isComposition } = getUtils(csn);
+  const { getCsnDef, isComposition } = csnUtils;
   const { error, warning } = messageFunctions;
 
   forEachDefinition(csn, generateDraft);
@@ -155,7 +155,7 @@ function generateDrafts(csn, options, pathDelimiter, messageFunctions) {
             'Generated entity $(NAME) conflicts with existing artifact');
     }
 
-    const persistenceName = getResultingName(csn, options.forHana.names, draftsArtifactName);
+    const persistenceName = getResultingName(csn, options.sqlMapping, draftsArtifactName);
     // Duplicate the artifact as a draft shadow entity
     if (csn.definitions[persistenceName]) {
       const definingDraftRoot = draftRoots.get(csn.definitions[persistenceName]);
@@ -187,7 +187,7 @@ function generateDrafts(csn, options, pathDelimiter, messageFunctions) {
     for (const elemName in artifact.elements) {
       const origElem = artifact.elements[elemName];
       let elem;
-      if ((isDeprecatedEnabled(options, 'renderVirtualElements') && origElem.virtual) || !origElem.virtual)
+      if ((isDeprecatedEnabled(options, '_renderVirtualElements') && origElem.virtual) || !origElem.virtual)
         elem = copyAndAddElement(origElem, draftsArtifact, draftsArtifactName, elemName)[elemName];
       if (elem) {
         // Remove "virtual" - cap/issues 4956

package/lib/transform/draft/odata.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const { forEachDefinition, getUtils, getServiceNames } = require('../../model/csnUtils');
+const { forEachDefinition, getServiceNames } = require('../../model/csnUtils');
 const { forEach } = require('../../utils/objectUtils');
 const { isArtifactInSomeService, getServiceOfArtifact } = require('../odata/utils');
 const { getTransformers } = require('../transformUtilsNew');
@@ -30,15 +30,14 @@ function generateDrafts(csn, options, services) {
     createAssociationElement, createAssociationPathComparison,
     addElement, createAction, assignAction,
     resetAnnotation,
+    csnUtils,
   } = getTransformers(csn, options);
-
   const {
     getFinalType,
     getServiceName,
     hasAnnotationValue,
-    getFinalBaseType,
-    getFinalTypeDef,
-  } = getUtils(csn);
+    getFinalBaseTypeWithProps,
+  } = csnUtils;
 
   const { error, info } = makeMessageFunction(csn, options, 'for.odata');
 
@@ -197,8 +196,8 @@ function generateDrafts(csn, options, services) {
             stack.push(elem);
           }
           else if (elem.type) { // types - possibly structured
-            const typeDef = elem.type.ref ? getFinalBaseType(elem.type) : getFinalTypeDef(elem.type);
-            if (typeDef.elements)
+            const typeDef = getFinalBaseTypeWithProps(elem.type);
+            if (typeDef?.elements)
               stack.push(typeDef);
           }
         });

package/lib/transform/forHanaNew.js

@@ -41,9 +41,7 @@ function forEachDefinition(csn, cb) {
  * in HANA CDS style, used by 'toHana', toSql' and 'toRename'.
  * The behavior is controlled by the following options:
  * options = {
- *    forHana.names                               // See the behavior of 'names' in toHana, toSql and toRename
- *    forHana.alwaysResolveDerivedTypes           // Always resolve derived type chains (by default, this is only
- *                                                // done for 'quoted' names). FIXME: Should always be done in general.
+ *    sqlMapping // See the behavior of 'sqlMapping' in toHana, toSql and toRename
  * }
  * The result model will always have 'options.forHana' set, to indicate that these transformations have happened.
  * The following transformations are made:
@@ -69,9 +67,9 @@ function forEachDefinition(csn, cb) {
  * - (110) Actions and functions (bound or unbound) are ignored.
  * - (120) (a) Services become contexts.
  * - (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').
+ *         multiple elements (using '_' or '.' as name separator, depending on 'sqlMapping').
  * - (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').
+ *         generated foreign key elements (also using '_' or '.' as name separator, depending on 'sqlMapping').
  * - (150) (a) Elements from inherited (included) entities are copied into the receiving entity
  *         (b) The 'include' property is removed from entities.
  * - (160) Projections become views, with MIXINs for association elements (adding $projection where
@@ -94,7 +92,7 @@ function forEachDefinition(csn, cb) {
  *         (d) Managed association entries in ORDER BY
  * - (240) All artifacts (a), elements, foreign keys, parameters (b) that have a DB representation are annotated
  *         with their database name (as '@cds.persistence.name') according to the naming convention chosen
- *         in 'options.forHana.names'.
+ *         in 'options.sqlMapping'.
  * - (250) Remove name space definitions again (only in forHanaNew). Maybe we can omit inserting namespace definitions
  *         completely (TODO)
  *
@@ -108,17 +106,14 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
   /** @type {CSN.Model} */
   let csn = cloneCsnNonDict(inputModel, options);
 
-
-
   checkCSNVersion(csn, options);
 
-  const pathDelimiter = (options.forHana.names === 'hdbcds') ? '.' : '_';
+  const pathDelimiter = (options.sqlMapping === 'hdbcds') ? '.' : '_';
 
   let message, error, warning, info; // message functions
   /** @type {() => void} */
   let throwWithAnyError;
   let artifactRef, inspectRef, effectiveType, get$combined,
-    getFinalBaseType, // csnUtils (csnRefs)
     addDefaultTypeFacets, expandStructsInExpression; // transformUtils
 
   bindCsnReference();
@@ -130,14 +125,14 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
     bindCsnReference();
   }
 
-  const dialect = options.forHana && options.forHana.dialect || options.toSql && options.toSql.dialect;
+  const dialect = options.sqlDialect;
   const doA2J = !(options.transformation === 'hdbcds' && options.sqlMapping === 'hdbcds');
   if (!doA2J)
     forEachDefinition(csn, handleMixinOnConditions);
 
   // Run validations on CSN - each validator function has access to the message functions and the inspect ref via this
   const cleanup = validate.forHana(csn, {
-    message, error, warning, info, inspectRef, effectiveType, artifactRef, csnUtils: getUtils(csn), csn, options, getFinalBaseType, isAspect
+    message, error, warning, info, inspectRef, effectiveType, artifactRef, csnUtils: getUtils(csn), csn, options, isAspect
   });
 
   // Needs to happen before tuple expansion, so the newly generated WHERE-conditions have it applied
@@ -222,6 +217,7 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
     flattenStructuredElement,
     flattenStructStepsInRef,
     isAssociationOperand, isDollarSelfOrProjectionOperand,
+    csnUtils,
   } = transformUtils.getTransformers(csn, options, pathDelimiter);
 
   const {
@@ -229,7 +225,7 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
     isAssocOrComposition,
     addStringAnnotationTo,
     cloneWithTransformations,
-  } = getUtils(csn);
+  } = csnUtils;
 
   // (000) Rename primitive types, make UUID a String
   transformCsn(csn, {
@@ -409,8 +405,9 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
 
   function bindCsnReference(){
     ({ error, warning, info, message, throwWithAnyError } = makeMessageFunction(csn, options, moduleName));
-    ({ artifactRef, inspectRef, effectiveType, getFinalBaseType, get$combined } = getUtils(csn));
     ({ addDefaultTypeFacets, expandStructsInExpression } = transformUtils.getTransformers(csn, options, pathDelimiter));
+    // TODO: Can we use csnUtils of the call above (transformUtils.getTransformers)?
+    ({ artifactRef, inspectRef, effectiveType, get$combined } = getUtils(csn));
   }
 
   function bindCsnReferenceOnly(){
@@ -509,7 +506,7 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
   function recursivelyApplyCommon(artifact, artifactName) {
     if (!artifact._ignore) {
       if (artifact.kind !== 'service' && artifact.kind !== 'context')
-        addStringAnnotationTo('@cds.persistence.name', getArtifactDatabaseNameOf(artifactName, options.forHana.names, csn), artifact);
+        addStringAnnotationTo('@cds.persistence.name', getArtifactDatabaseNameOf(artifactName, options.sqlMapping, csn, options.sqlDialect), artifact);
 
       forEachMemberRecursively(artifact, (member, memberName, property, path) => {
         transformCommon(member, memberName, path);
@@ -517,7 +514,7 @@ function transformForHanaWithCsn(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.forHana.names), member);
+          addStringAnnotationTo('@cds.persistence.name', getElementDatabaseNameOf(memberName, options.sqlMapping, options.sqlDialect), member);
       }, [ 'definitions', artifactName ]);
     }
   }
@@ -543,7 +540,7 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
   function transformSelfInBacklinks(artifact, artifactName, dummy, path) {
     // Fixme: For toHana mixins must be transformed, for toSql -d hana
     // mixin elements must be transformed, why can't toSql also use mixins?
-    if(artifact.kind === 'entity' || artifact.query || (options.toHana && options.toHana.names === 'hdbcds' && artifact.kind == 'type'))
+    if(artifact.kind === 'entity' || artifact.query || (options.forHana && options.sqlMapping === 'hdbcds' && artifact.kind === 'type'))
       doit(artifact.elements, path.concat([ 'elements' ]));
     if (artifact.query && artifact.query.SELECT && artifact.query.SELECT.mixin)
       doit(artifact.query.SELECT.mixin, path.concat([ 'query', 'SELECT', 'mixin' ]));
@@ -574,7 +571,7 @@ function transformForHanaWithCsn(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.forHana.dialect === 'hana' && member.target && isAssocOrComposition(member.type) && !isBetaEnabled(options, 'assocsWithParams')) {
+      if (options.sqlDialect === 'hana' && member.target && isAssocOrComposition(member.type) && !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)
@@ -617,7 +614,7 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
           sql: 'Table-like entities with parameters are not supported for conversion to SQL',
         });
       }
-      else if (options.forHana.dialect === 'sqlite') { // view with params
+      else if (options.sqlDialect === 'sqlite') { // view with params
         // Allow with plain
         error(null, [ 'definitions', artifactName ], `SQLite does not support entities with parameters`);
       }
@@ -626,8 +623,8 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
           if (pname.match(/\W/g) || pname.match(/^\d/) || pname.match(/^_/)) { // parameter name must be 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 },
+          else if (options.sqlMapping !== 'plain' && pname.toUpperCase() !== pname) { // not plain mode: param name must be all upper
+            warning(null, [ 'definitions', artifactName, 'params', pname ], { name: options.sqlMapping },
                    'Expecting parameter to be uppercase in naming mode $(NAME)');
           }
         }
@@ -1048,7 +1045,7 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
   * @returns {boolean}
   */
   function isMaxParameterLengthRestricted(type) {
-    return !(options.toSql && type === 'cds.String' && (options.toSql.dialect === 'sqlite' || options.toSql.dialect === 'plain'));
+    return !(options.toSql && type === 'cds.String' && (options.sqlDialect === 'sqlite' || options.sqlDialect === 'plain'));
   }
 
   /**