@sap/cds-compiler 2.13.8 → 2.15.2

package/lib/render/toHdbcds.js

@@ -7,8 +7,8 @@ const {
 } = require('../model/csnUtils');
 const keywords = require('../base/keywords');
 const {
-  renderFunc, beautifyExprArray, getRealName, addContextMarkers, addIntermediateContexts, cdsToSqlTypes,
-  hasHanaComment, getHanaComment, findElement, funcWithoutParen, getSqlSnippets,
+  renderFunc, getExpressionRenderer, getRealName, addContextMarkers, addIntermediateContexts, cdsToSqlTypes,
+  hasHanaComment, getHanaComment, funcWithoutParen, getSqlSnippets,
 } = require('./utils/common');
 const {
   renderReferentialConstraint,
@@ -26,13 +26,13 @@ const $PROJECTION = '$projection';
 const $SELF = '$self';
 
 /**
- * Get the comment and in addition escape \n so HANA CDS can handle it.
+ * Get the comment and in addition escape \n and `'` so SAP HANA CDS can handle it.
  *
  * @param {CSN.Artifact} obj
  * @returns {string}
  */
 function getEscapedHanaComment(obj) {
-  return getHanaComment(obj).replace(/\n/g, '\\n');
+  return getHanaComment(obj).replace(/\n/g, '\\n').replace(/'/g, "''");
 }
 
 /**
@@ -56,9 +56,40 @@ function toHdbcdsSource(csn, options) {
   const hdbcdsNames = options.sqlMapping === 'hdbcds';
 
   const {
-    info, warning, error, throwWithError,
+    info, warning, error, throwWithAnyError,
   } = makeMessageFunction(csn, options, 'to.hdbcds');
 
+  const renderExpr = getExpressionRenderer({
+    finalize: x => x,
+    explicitTypeCast(x, env) {
+      let typeRef = renderTypeReference(x.cast, env);
+
+      // inside a cast expression, the cds and hana cds types need to be mapped to hana sql types
+      const hanaSqlType = cdsToSqlTypes.hana[x.cast.type] || cdsToSqlTypes.standard[x.cast.type];
+      if (hanaSqlType) {
+        const typeRefWithoutParams = typeRef.substring(0, typeRef.indexOf('(')) || typeRef;
+        typeRef = typeRef.replace(typeRefWithoutParams, hanaSqlType);
+      }
+      return `CAST(${renderExpr(x, env)} AS ${typeRef})`;
+    },
+    val: renderExpressionLiteral,
+    enum: x => `#${x['#']}`,
+    ref: renderExpressionRef,
+    aliasOnly(x, _env) {
+      return x.as;
+    },
+    windowFunction: renderExpressionFunc,
+    func: renderExpressionFunc,
+    xpr(x, env) {
+      if (this.nestedExpr && !x.cast)
+        return `(${renderExpr(x.xpr, env, this.inline, true)})`;
+
+      return renderExpr(x.xpr, env, this.inline, true);
+    },
+    SELECT: (x, env) => `(${renderQuery(x, false, increaseIndent(env))})`,
+    SET: (x, env) => `${renderQuery(x, false, increaseIndent(env))}`,
+  });
+
   checkCSNVersion(csn, options);
 
   const hdbcdsResult = Object.create(null);
@@ -117,7 +148,7 @@ function toHdbcdsSource(csn, options) {
 
   killList.forEach(fn => fn());
 
-  throwWithError();
+  throwWithAnyError();
   timetrace.stop();
   return options.testMode ? sort(hdbcdsResult) : hdbcdsResult;
 
@@ -217,7 +248,7 @@ function toHdbcdsSource(csn, options) {
    *
    * @param {string} containee Name of the contained artifact
    * @param {string} contextName Name of the (grand?)parent context
-   * @returns {boolean} True if there is another context inbetween
+   * @returns {boolean} True if there is another context in between
    */
   function isContainedInOtherContext(containee, contextName) {
     const parts = containee.split('.');
@@ -280,7 +311,7 @@ function toHdbcdsSource(csn, options) {
    * Render a context or service. Return the resulting source string.
    *
    * If the context is shadowed by another entity, the context itself is not rendered,
-   * but any contained (and transitively contained) entites and views are.
+   * but any contained (and transitively contained) entities and views are.
    *
    * @param {string} artifactName Name of the context/service
    * @param {CSN.Artifact} art Content of the context/service
@@ -687,18 +718,19 @@ function toHdbcdsSource(csn, options) {
    * Return the resulting source string (no trailing LF).
    *
    * @param {object} col Column to render
+   * @param {CSN.Elements} elements where column exists
    * @param {CdlRenderEnvironment} env Environment
-   * @param {CSN.Element} [element] Element (non-enum from subquery possibly) corresponding to the column ref
    * @returns {string} Rendered column
    */
-  function renderViewColumn(col, env, element) {
+  function renderViewColumn(col, elements, env ) {
     // Annotations and column
     let result = '';
 
-    const leaf = col.as || col.ref && col.ref[col.ref.length - 1];
-    // Render 'null as <alias>' only for database and if element is virtual
+    const leaf = col.as || col.ref && col.ref[col.ref.length - 1] || col.func;
+    const element = elements[leaf];
 
-    if (element && element.virtual || env._artifact.elements[leaf] && env._artifact.elements[leaf].virtual) {
+    // Render 'null as <alias>' only for database and if element is virtual
+    if (element && element.virtual) {
       if (isDeprecatedEnabled(options, 'renderVirtualElements'))
         return `${result}${env.indent}null as ${formatIdentifier(leaf)}`;
     }
@@ -803,12 +835,12 @@ function toHdbcdsSource(csn, options) {
     // Set operator, like UNION, INTERSECT, ...
     if (query.SET) {
       // First arg may be leading query
-      result += `(${renderQuery(query.SET.args[0], isLeadingQuery, env, path.concat([ 'SET', 'args', 0 ]), elements)}`;
+      result += `(${renderQuery(query.SET.args[0], isLeadingQuery, env, path.concat([ 'SET', 'args', 0 ]), elements || query.SET.elements)}`;
       // FIXME: Clarify if set operators can be n-ary (assuming binary here)
       if (query.SET.op) {
         // Loop over all other arguments, i.e. for A UNION B UNION C UNION D ...
         for (let i = 1; i < query.SET.args.length; i++)
-          result += `\n${env.indent}${query.SET.op}${query.SET.all ? ' all' : ''} ${renderQuery(query.SET.args[i], false, env, path.concat([ 'SET', 'args', i ]))}`;
+          result += `\n${env.indent}${query.SET.op}${query.SET.all ? ' all' : ''} ${renderQuery(query.SET.args[i], false, env, path.concat([ 'SET', 'args', i ]), elements || query.SET.elements)}`;
       }
       result += ')';
       // Set operation may also have an ORDER BY and LIMIT/OFFSET (in contrast to the ones belonging to
@@ -843,7 +875,7 @@ function toHdbcdsSource(csn, options) {
     result += select.distinct ? ' distinct' : '';
     if (select.columns) {
       result += ' {\n';
-      result += `${select.columns.map(col => renderViewColumn(col, childEnv, findElement(elements, col)))
+      result += `${select.columns.map(col => renderViewColumn(col, elements || select.elements, childEnv))
         .filter(s => s !== '')
         .join(',\n')}\n`;
       result += `${env.indent}}`;
@@ -1109,239 +1141,154 @@ function toHdbcdsSource(csn, options) {
   }
 
   /**
-   * Render an expression (including paths and values) or condition 'x'.
-   * (no trailing LF, don't indent if inline)
+   * Render a single path step 's' at path position 'idx', which can have filters or parameters or be a function
    *
-   * @param {any} expr Expression to render
-   * @param {CdlRenderEnvironment} env Environment
-   * @param {boolean} [inline=true] Whether to render inline
-   * @param {boolean} [inExpr=false] Whether the expression is already inside another expression
-   * @param {boolean} [alwaysRenderCast=false] Whether to _always_ render SQL-style casts, even if `nestedExpr === false`.
-   *                                           Note: This is a hack for casts() inside groupBy.
-   * @returns {string} Rendered expression
+   * @param {string|object} s Path step
+   * @param {number} idx Path position
+   * @returns {string} Rendered path step
    */
-  function renderExpr(expr, env, inline = true, inExpr = false, alwaysRenderCast = false) {
-    // Compound expression
-    if (Array.isArray(expr))
-      return beautifyExprArray(expr.map(item => renderExpr(item, env, inline, inExpr)));
-
-    if (typeof expr === 'object' && expr !== null) {
-      if ((inExpr || alwaysRenderCast) && expr.cast && expr.cast.type)
-        return renderExplicitTypeCast(renderExprObject(expr));
-      return renderExprObject(expr);
-    }
+  function renderPathStep(s, idx, ref, env, inline) {
+    // Simple id or absolute name
+    if (typeof s === 'string') {
+      // HANA-specific extra magic (should actually be in forHana)
+      // In HANA, we replace leading $self by the absolute name of the current artifact
+      // (see FIXME at renderArtifact)
+      if (idx === 0 && s === $SELF) {
+        // do not produce USING for $projection
+        if (env.currentArtifactName === $PROJECTION)
+          return env.currentArtifactName;
+
+        return plainNames ? renderAbsoluteNamePlain(env.currentArtifactName, env)
+          : renderAbsoluteNameWithQuotes(env.currentArtifactName, env);
+      }
+      // HANA-specific translation of '$now' and '$user'
+      if (s === '$now' && ref.length === 1)
+        return 'CURRENT_TIMESTAMP';
 
-    // Not a literal value but part of an operator, function etc - just leave as it is
-    return expr;
+      // In first path position, do not quote $projection and magic $-variables like CURRENT_DATE, $now etc.
+      // FIXME: We should rather explicitly recognize quoting somehow
 
+      // TODO: quote $parameters if it doesn't reference a parameter, this requires knowledge about the kind
+      // Example: both views are correct in HANA CDS
+      // entity E { key id: Integer; }
+      // view EV with parameters P1: Integer as select from E { id, $parameters.P1 };
+      // view EVp as select from E as "$parameters" { "$parameters".id };
 
-    /**
-     * Various special cases represented as objects
-     *
-     * @param {object} x Expression
-     * @returns {string} Rendered expression object
-     */
-    function renderExprObject(x) {
-      if (x.list) {
-        // set "inExpr" to false: treat list elements as new expressions
-        return `(${x.list.map(item => renderExpr(item, env, inline, false)).join(', ')})`;
-      }
-      else if (x.val !== undefined) {
-        return renderExpressionLiteral(x);
-      }
-      // Enum symbol
-      else if (x['#']) {
-        return `#${x['#']}`;
-      }
-      // Reference: Array of path steps, possibly preceded by ':'
-      else if (x.ref) {
-        return renderExpressionRef(x);
-      }
-      // Function call, possibly with args (use '=>' for named args)
-      else if (x.func) {
-        // test for non-regular HANA identifier that needs to be quoted
-        // identifier                  {letter}({letter_or_digit}|[#$])*
-        // letter                      [A-Za-z_]
-        // letter_or_digit             [A-Za-z_0-9]
-
-        const regex = RegExp(/^[a-zA-Z][\w#$]*$/, 'g');
-        const funcName = regex.test(x.func) ? x.func : quoteId(x.func);
-        // we can't quote functions with parens, issue warning if it is a reserved keyword
-        if (!funcWithoutParen(x, 'hana') && keywords.hdbcds.includes(uppercaseAndUnderscore(funcName)))
-          warning(null, x.$location, `The identifier “${uppercaseAndUnderscore(funcName)}“ is a SAP HANA keyword`);
-        return renderFunc(funcName, x, 'hana', a => renderArgs(a, '=>', env));
-      }
-      // Nested expression
-      else if (x.xpr) {
-        if (inExpr && !x.cast)
-          return `(${renderExpr(x.xpr, env, inline, true)})`;
-
-        return renderExpr(x.xpr, env, inline, true);
-      }
-      // Sub-select
-      else if (x.SELECT) {
-        // renderQuery for SELECT does not bring its own parentheses (because it is also used in renderView)
-        return `(${renderQuery(x, false, increaseIndent(env))})`;
-      }
-      else if (x.SET) {
-        // renderQuery for SET always brings its own parentheses (because it is also used in renderViewSource)
-        return `${renderQuery(x, false, increaseIndent(env))}`;
-      }
+      if (idx === 0 &&
+            [ $SELF, $PROJECTION, '$session' ].includes(s))
+        return s;
 
-      throw new ModelError(`Unknown expression: ${JSON.stringify(x)}`);
+      return formatIdentifier(s);
     }
-    /**
-     * @param {object} x Expression with a val and/or literal property
-     * @returns {string} Rendered expression
-     */
-    function renderExpressionLiteral(x) {
-      // Literal value, possibly with explicit 'literal' property
-      switch (x.literal || typeof x.val) {
-        case 'number':
-        case 'boolean':
-        case 'null':
-          return x.val;
-        case 'x':
-        case 'date':
-        case 'time':
-        case 'timestamp':
-          return `${x.literal}'${x.val}'`;
-        case 'string':
-          return `'${x.val.replace(/'/g, '\'\'')}'`;
-        case 'object':
-          if (x.val === null)
-            return 'null';
-
-        // otherwise fall through to
-        default:
-          throw new ModelError(`Unknown literal or type: ${JSON.stringify(x)}`);
+    // ID with filters or parameters
+    else if (typeof s === 'object') {
+      // Sanity check
+      if (!s.func && !s.id)
+        throw new ModelError(`Unknown path step object: ${JSON.stringify(s)}`);
+
+      // Not really a path step but an object-like function call
+      if (s.func)
+        return `${s.func}(${renderArgs(s, '=>', env)})`;
+
+      // Path step, possibly with view parameters and/or filters
+      let result = `${formatIdentifier(s.id)}`;
+      if (s.args) {
+        // View parameters
+        result += `(${renderArgs(s, ':', env)})`;
       }
-    }
-
-    /**
-     * @param {object} x Expression with a ref property
-     * @returns {string} Rendered expression
-     * @todo no extra magic with x.param or x.global
-     */
-    function renderExpressionRef(x) {
-      if (!x.param && !x.global) {
-        const magicReplacement = getVariableReplacement(x.ref, options);
-        if (x.ref[0] === '$user') {
-          if (magicReplacement !== null)
-            return `'${magicReplacement}'`;
-
-          // Keep old way of solving this to remain backwards compatible
-          // FIXME: this is all not enough: we might need an explicit select item alias
-          if (x.ref[1] === 'id') {
-            if (options.magicVars && options.magicVars.user && (typeof options.magicVars.user === 'string' || options.magicVars.user instanceof String))
-              return `'${options.magicVars.user}'`;
-
-            else if ((options.magicVars && options.magicVars.user && options.magicVars.user.id) && (typeof options.magicVars.user.id === 'string' || options.magicVars.user.id instanceof String))
-              return `'${options.magicVars.user.id}'`;
-
-            return 'SESSION_CONTEXT(\'APPLICATIONUSER\')';
-          }
-          else if (x.ref[1] === 'locale') {
-            return 'SESSION_CONTEXT(\'LOCALE\')';
-          }
-        }
-        else if (x.ref[0] === '$at') {
-          if (x.ref[1] === 'from')
-            return 'TO_TIMESTAMP(SESSION_CONTEXT(\'VALID-FROM\'))';
-
-          else if (x.ref[1] === 'to')
-            return 'TO_TIMESTAMP(SESSION_CONTEXT(\'VALID-TO\'))';
-        }
-        else if (x.ref[0] === '$session' && magicReplacement !== null) {
-          return `'${magicReplacement}'`;
-        }
+      if (s.where) {
+        // Filter, possibly with cardinality
+        result += `[${s.cardinality ? (`${s.cardinality.max}: `) : ''}${renderExpr(s.where, env, inline, true)}]`;
       }
-      return `${(x.param || x.global) ? ':' : ''}${x.ref.map((step, index) => renderPathStep(step, index, x.ref)).join('.')}`;
+      return result;
     }
 
-    /**
-     * Renders an explicit `cast()` inside an 'xpr'.
-     *
-     * @param {string} value Value to cast
-     * @returns {string} Rendered cast()
-     */
-    function renderExplicitTypeCast(value) {
-      let typeRef = renderTypeReference(expr.cast, env);
+    throw new ModelError(`Unknown path step: ${JSON.stringify(s)}`);
+  }
 
-      // inside a cast expression, the cds and hana cds types need to be mapped to hana sql types
-      const hanaSqlType = cdsToSqlTypes.hana[expr.cast.type] || cdsToSqlTypes.standard[expr.cast.type];
-      if (hanaSqlType) {
-        const typeRefWithoutParams = typeRef.substring(0, typeRef.indexOf('(')) || typeRef;
-        typeRef = typeRef.replace(typeRefWithoutParams, hanaSqlType);
-      }
-      return `CAST(${value} AS ${typeRef})`;
+  /**
+   * @param {object} x Expression with a val and/or literal property
+   * @returns {string} Rendered expression
+   */
+  function renderExpressionLiteral(x) {
+    // Literal value, possibly with explicit 'literal' property
+    switch (x.literal || typeof x.val) {
+      case 'number':
+      case 'boolean':
+      case 'null':
+        return x.val;
+      case 'x':
+      case 'date':
+      case 'time':
+      case 'timestamp':
+        return `${x.literal}'${x.val}'`;
+      case 'string':
+        return `'${x.val.replace(/'/g, '\'\'')}'`;
+      case 'object':
+        if (x.val === null)
+          return 'null';
+
+        // otherwise fall through to
+      default:
+        throw new ModelError(`Unknown literal or type: ${JSON.stringify(x)}`);
     }
+  }
 
-    /**
-     * Render a single path step 's' at path position 'idx', which can have filters or parameters or be a function
-     *
-     * @param {string|object} s Path step
-     * @param {number} idx Path position
-     * @returns {string} Rendered path step
-     */
-    function renderPathStep(s, idx, ref) {
-      // Simple id or absolute name
-      if (typeof s === 'string') {
-        // HANA-specific extra magic (should actually be in forHana)
-        // In HANA, we replace leading $self by the absolute name of the current artifact
-        // (see FIXME at renderArtifact)
-        if (idx === 0 && s === $SELF) {
-          // do not produce USING for $projection
-          if (env.currentArtifactName === $PROJECTION)
-            return env.currentArtifactName;
-
-          return plainNames ? renderAbsoluteNamePlain(env.currentArtifactName, env)
-            : renderAbsoluteNameWithQuotes(env.currentArtifactName, env);
-        }
-        // HANA-specific translation of '$now' and '$user'
-        if (s === '$now' && ref.length === 1)
-          return 'CURRENT_TIMESTAMP';
+  /**
+   * Render the given expression x - which has a .func property
+   *
+   * @param {object} x
+   * @param {CdlRenderEnvironment} env
+   * @returns {string}
+   */
+  function renderExpressionFunc(x, env) {
+    const regex = RegExp(/^[a-zA-Z][\w#$]*$/, 'g');
+    const funcName = regex.test(x.func) ? x.func : quoteId(x.func);
+    // we can't quote functions with parens, issue warning if it is a reserved keyword
+    if (!funcWithoutParen(x, 'hana') && keywords.hdbcds.includes(uppercaseAndUnderscore(funcName)))
+      warning(null, x.$location, `The identifier “${uppercaseAndUnderscore(funcName)}“ is a SAP HANA keyword`);
+    return renderFunc(funcName, x, 'hana', a => renderArgs(a, '=>', env));
+  }
 
-        // In first path position, do not quote $projection and magic $-variables like CURRENT_DATE, $now etc.
-        // FIXME: We should rather explicitly recognize quoting somehow
+  /**
+   * @param {object} x Expression with a ref property
+   * @returns {string} Rendered expression
+   * @todo no extra magic with x.param or x.global
+   */
+  function renderExpressionRef(x, env) {
+    if (!x.param && !x.global) {
+      const magicReplacement = getVariableReplacement(x.ref, options);
+      if (x.ref[0] === '$user') {
+        if (magicReplacement !== null)
+          return `'${magicReplacement}'`;
 
-        // TODO: quote $parameters if it doesn't reference a parameter, this requires knowledge about the kind
-        // Example: both views are correct in HANA CDS
-        // entity E { key id: Integer; }
-        // view EV with parameters P1: Integer as select from E { id, $parameters.P1 };
-        // view EVp as select from E as "$parameters" { "$parameters".id };
+        // Keep old way of solving this to remain backwards compatible
+        // FIXME: this is all not enough: we might need an explicit select item alias
+        if (x.ref[1] === 'id') {
+          if (options.magicVars && options.magicVars.user && (typeof options.magicVars.user === 'string' || options.magicVars.user instanceof String))
+            return `'${options.magicVars.user}'`;
 
-        if (idx === 0 &&
-          [ $SELF, $PROJECTION, '$session' ].includes(s))
-          return s;
+          else if ((options.magicVars && options.magicVars.user && options.magicVars.user.id) && (typeof options.magicVars.user.id === 'string' || options.magicVars.user.id instanceof String))
+            return `'${options.magicVars.user.id}'`;
 
-        return formatIdentifier(s);
-      }
-      // ID with filters or parameters
-      else if (typeof s === 'object') {
-        // Sanity check
-        if (!s.func && !s.id)
-          throw new ModelError(`Unknown path step object: ${JSON.stringify(s)}`);
-
-        // Not really a path step but an object-like function call
-        if (s.func)
-          return `${s.func}(${renderArgs(s, '=>', env)})`;
-
-        // Path step, possibly with view parameters and/or filters
-        let result = `${formatIdentifier(s.id)}`;
-        if (s.args) {
-          // View parameters
-          result += `(${renderArgs(s, ':', env)})`;
+          return 'SESSION_CONTEXT(\'APPLICATIONUSER\')';
         }
-        if (s.where) {
-          // Filter, possibly with cardinality
-          result += `[${s.cardinality ? (`${s.cardinality.max}: `) : ''}${renderExpr(s.where, env, inline, true)}]`;
+        else if (x.ref[1] === 'locale') {
+          return 'SESSION_CONTEXT(\'LOCALE\')';
         }
-        return result;
       }
+      else if (x.ref[0] === '$at') {
+        if (x.ref[1] === 'from')
+          return 'TO_TIMESTAMP(SESSION_CONTEXT(\'VALID-FROM\'))';
 
-      throw new ModelError(`Unknown path step: ${JSON.stringify(s)}`);
+        else if (x.ref[1] === 'to')
+          return 'TO_TIMESTAMP(SESSION_CONTEXT(\'VALID-TO\'))';
+      }
+      else if (x.ref[0] === '$session' && magicReplacement !== null) {
+        return `'${magicReplacement}'`;
+      }
     }
+    return `${(x.param || x.global) ? ':' : ''}${x.ref.map((step, index) => renderPathStep(step, index, x.ref, env, this.inline)).join('.')}`;
   }
 
   /**
@@ -1349,7 +1296,7 @@ function toHdbcdsSource(csn, options) {
    * using 'sep' as separator for positional parameters
    *
    * @param {object} node with `args` to render
-   * @param {string} sep Seperator between arguments
+   * @param {string} sep Separator between arguments
    * @param {CdlRenderEnvironment} env Environment
    * @returns {string} Rendered arguments
    */
@@ -1692,7 +1639,7 @@ function toHdbcdsSource(csn, options) {
   }
 
   /**
-   * Returns a copy of 'env' with increased indentation (and resetted name prefix)
+   * Returns a copy of 'env' with increased indentation - also resets the name prefix
    *
    * @param {CdlRenderEnvironment} env Current environment
    * @returns {CdlRenderEnvironment} New environment with increased indent
@@ -1713,15 +1660,15 @@ function toHdbcdsSource(csn, options) {
   }
 
   /**
-   * Return an absolute path 'abspath', with '::' inserted if required by naming strategy 'hdbcds',
+   * Return an absolute path 'absPath', with '::' inserted if required by naming strategy 'hdbcds',
    * with appropriate "-quotes
    *
-   * @param {string} abspath Absolute path to quote
+   * @param {string} absPath Absolute path to quote
    * @returns {string} Quoted path
    */
-  function quoteAbsolutePathString(abspath) {
-    const namespace = getNamespace(csn, abspath);
-    const resultingName = getResultingName(csn, options.sqlMapping, abspath);
+  function quoteAbsolutePathString(absPath) {
+    const namespace = getNamespace(csn, absPath);
+    const resultingName = getResultingName(csn, options.sqlMapping, absPath);
 
     if (hdbcdsNames && namespace)
       return `${quotePathString(namespace)}::${quotePathString(resultingName.slice(namespace.length + 2))}`;
@@ -1738,14 +1685,13 @@ function toHdbcdsSource(csn, options) {
   function quoteId(id) {
     // Should only ever be called for real IDs (i.e. no dots inside)
     if (id.indexOf('.') !== -1)
-      throw new ModelError(id);
+      throw new ModelError(`HDBCDS: Tried to quote id with dot: ${id}`);
 
 
-    switch (options.forHana.names) {
+    switch (options.sqlMapping) {
       case 'plain':
         return smartId(id, 'hdbcds');
       case 'quoted':
-        return delimitedId(id, 'hdbcds');
       case 'hdbcds':
         return delimitedId(id, 'hdbcds');
       default:
@@ -1754,17 +1700,17 @@ function toHdbcdsSource(csn, options) {
   }
 
   /*
-   * Return an absolute name 'absname', with '::' inserted if required by naming strategy 'hdbcds', quoted
+   * Return an absolute name 'absName', with '::' inserted if required by naming strategy 'hdbcds', quoted
    * as if it was a single identifier (required only for native USINGs)
    *
-   * @param {string} absname Absolute name
-   * @returns {string} Correctly quoted absname
+   * @param {string} absName Absolute name
+   * @returns {string} Correctly quoted absName
    */
-  function quoteAbsoluteNameAsId(absname) {
-    const resultingName = getResultingName(csn, options.sqlMapping, absname);
+  function quoteAbsoluteNameAsId(absName) {
+    const resultingName = getResultingName(csn, options.sqlMapping, absName);
 
     if (hdbcdsNames) {
-      const namespace = getNamespace(csn, absname);
+      const namespace = getNamespace(csn, absName);
       if (namespace)
         return `"${(`${namespace}::${resultingName.substring(namespace.length + 2)}`).replace(/"/g, '""')}"`;
     }
@@ -1778,7 +1724,7 @@ function toHdbcdsSource(csn, options) {
    * @returns {string} Quoted/uppercased id
    */
   function formatIdentifier(id) {
-    id = options.forHana.names === 'plain' ? id.toUpperCase() : id;
+    id = plainNames ? id.toUpperCase() : id;
     return quoteId(id);
   }