@sap/cds-compiler 2.5.2 → 2.11.0

package/lib/render/toHdbcds.js

@@ -3,12 +3,12 @@
 const {
   getParentNameOf, getLastPartOf, getLastPartOfRef,
   hasValidSkipOrExists, isBuiltinType, generatedByCompilerVersion, getNormalizedQuery,
-  getRootArtifactName, getResultingName, getNamespace,
+  getRootArtifactName, getResultingName, getNamespace, forEachMember, getVariableReplacement,
 } = require('../model/csnUtils');
 const keywords = require('../base/keywords');
 const {
-  renderFunc, processExprArray, getRealName, addContextMarkers, addIntermediateContexts, cdsToSqlTypes,
-  hasHanaComment, getHanaComment, findElement,
+  renderFunc, beautifyExprArray, getRealName, addContextMarkers, addIntermediateContexts, cdsToSqlTypes,
+  hasHanaComment, getHanaComment, findElement, funcWithoutParen,
 } = require('./utils/common');
 const {
   renderReferentialConstraint,
@@ -17,7 +17,9 @@ const DuplicateChecker = require('./DuplicateChecker');
 const { isDeprecatedEnabled, forEachDefinition } = require('../base/model');
 const { checkCSNVersion } = require('../json/csnVersion');
 const { makeMessageFunction } = require('../base/messages');
-const timetrace = require('../utils/timetrace');
+const { timetrace } = require('../utils/timetrace');
+
+const { smartId, delimitedId } = require('../sql-identifier');
 
 const $PROJECTION = '$projection';
 const $SELF = '$self';
@@ -39,8 +41,7 @@ function getEscapedHanaComment(obj) {
  * { "foo" : "using XY; context foo {...};",
  *   "bar::wiz" : "namespace bar::; entity wiz {...};"
  * }
- * If 'options.toHana' is set, render HANA-ish source dialect (currently
- * only affects translation of '$self.foo' in paths and ::-ish namespace declarations)
+ *
  * FIXME: This comment no longer tells the whole truth
  *
  * @param {CSN.Model} csn HANA transformed CSN
@@ -49,9 +50,9 @@ function getEscapedHanaComment(obj) {
  */
 function toHdbcdsSource(csn, options) {
   timetrace.start('HDBCDS rendering');
-  const plainNames = options.toHana && options.toHana.names === 'plain';
-  const quotedNames = options.toHana && options.toHana.names === 'quoted';
-  const hdbcdsNames = options.toHana && options.toHana.names === 'hdbcds';
+  const plainNames = options.sqlMapping === 'plain';
+  const quotedNames = options.sqlMapping === 'quoted';
+  const hdbcdsNames = options.sqlMapping === 'hdbcds';
 
   const {
     info, warning, error, throwWithError,
@@ -62,7 +63,7 @@ function toHdbcdsSource(csn, options) {
   const result = Object.create(null);
 
 
-  const globalDuplicateChecker = new DuplicateChecker(options.toHana.names); // registry for all artifact names and element names
+  const globalDuplicateChecker = new DuplicateChecker(options.sqlMapping); // registry for all artifact names and element names
 
   const killList = [];
   if (quotedNames)
@@ -389,7 +390,7 @@ function toHdbcdsSource(csn, options) {
     const childEnv = increaseIndent(env);
     const normalizedArtifactName = renderArtifactName(artifactName, env);
 
-    globalDuplicateChecker.addArtifact(art['@cds.persistence.name'], art && art.$location, artifactName);
+    globalDuplicateChecker.addArtifact(art['@cds.persistence.name'], env.path, artifactName);
 
     if (hasHanaComment(art, options))
       result += `${env.indent}@Comment: '${getEscapedHanaComment(art)}'\n`;
@@ -401,7 +402,11 @@ function toHdbcdsSource(csn, options) {
     }
     result += ' {\n';
     const duplicateChecker = new DuplicateChecker(); // registry for all artifact names and element names
-    duplicateChecker.addArtifact(artifactName, art && art.$location, artifactName);
+    duplicateChecker.addArtifact(artifactName, env.path, artifactName);
+    childEnv.path = env.path.concat('elements');
+    // calculate __aliases which must be used in case an association
+    // has the same identifier as it's target
+    createTopLevelAliasesForArtifact(artifactName, art, env);
     for (const name in art.elements)
       result += renderElement(name, art.elements[name], childEnv, duplicateChecker);
 
@@ -411,6 +416,33 @@ function toHdbcdsSource(csn, options) {
     return result;
   }
 
+  /**
+   * If an association/composition has the same identifier as it's target
+   * we must render an "using target as __target" and use the alias to refer to the target
+   *
+   * @param {string} artName
+   * @param {CSN.Artifact} art
+   * @param {CdlRenderEnvironment} env
+   */
+  function createTopLevelAliasesForArtifact(artName, art, env) {
+    forEachMember(art, (element) => {
+      if (!element.target)
+        return;
+
+      let alias = element['@cds.persistence.name'];
+      if (uppercaseAndUnderscore(element.target) === element['@cds.persistence.name']) {
+        alias = createTopLevelAliasName(element['@cds.persistence.name']);
+        // calculate new alias if it would conflict with other csn.Artifact
+        while (csn.definitions[alias])
+          alias = createTopLevelAliasName(alias);
+        env.topLevelAliases[element['@cds.persistence.name']] = {
+          quotedName: formatIdentifier(element['@cds.persistence.name']),
+          quotedAlias: formatIdentifier(alias),
+        };
+      }
+    });
+  }
+
   /**
    * Render the 'technical configuration { ... }' section 'tc' of an entity.
    *
@@ -516,9 +548,9 @@ function toHdbcdsSource(csn, options) {
     // Special handling for HANA CDS: Must omit the ':' before anonymous structured types (for historical reasons)
     const omitColon = (!elm.type && elm.elements);
     let result = '';
-    const quotedElementName = quoteOrUppercaseId(elementName, elm.$location);
+    const quotedElementName = formatIdentifier(elementName);
     if (duplicateChecker)
-      duplicateChecker.addElement(quotedElementName, elm && elm.$location, elementName);
+      duplicateChecker.addElement(quotedElementName, env.path, elementName);
 
     if (hasHanaComment(elm, options))
       result += `${env.indent}@Comment: '${getEscapedHanaComment(elm)}'\n`;
@@ -526,7 +558,7 @@ function toHdbcdsSource(csn, options) {
     result += env.indent + (elm.key && !isSubElement ? 'key ' : '') +
                          (elm.masked ? 'masked ' : '') +
                          quotedElementName + (omitColon ? ' ' : ' : ') +
-                         renderTypeReference(elm, env, undefined) +
+                         renderTypeReference(elm, env) +
                          renderNullability(elm);
     if (elm.default)
       result += ` default ${renderExpr(elm.default, env)}`;
@@ -548,7 +580,7 @@ function toHdbcdsSource(csn, options) {
     if (source.SELECT || source.SET) {
       let result = `(${renderQuery(source, false, increaseIndent(env))})`;
       if (source.as)
-        result += ` as ${quoteOrUppercaseId(source.as)}`;
+        result += ` as ${formatIdentifier(source.as)}`;
 
       return result;
     }
@@ -598,7 +630,7 @@ function toHdbcdsSource(csn, options) {
 
     // Even the first step might have parameters and/or a filter
     if (path.ref[0].args)
-      result += `(${renderArgs(path.ref[0].args, ':', env)})`;
+      result += `(${renderArgs(path.ref[0], ':', env)})`;
 
     if (path.ref[0].where)
       result += `[${path.ref[0].cardinality ? (`${path.ref[0].cardinality.max}: `) : ''}${renderExpr(path.ref[0].where, env, true, true)}]`;
@@ -624,14 +656,14 @@ function toHdbcdsSource(csn, options) {
   function renderAbsolutePathWithAlias(path, env) {
     let result = renderAbsolutePath(path, env);
     // Take care of aliases - for artifact references, use the resulting name (multi-dot joined with _)
-    const implicitAlias = path.ref.length === 0 ? getLastPartOf(getResultingName(csn, options.toHana.names, path.ref[0])) : getLastPartOfRef(path.ref);
+    const implicitAlias = path.ref.length === 0 ? getLastPartOf(getResultingName(csn, options.sqlMapping, path.ref[0])) : getLastPartOfRef(path.ref);
     if (path.as) {
       // Source had an alias - render it
-      result += ` as ${quoteOrUppercaseId(path.as)}`;
+      result += ` as ${formatIdentifier(path.as)}`;
     }
-    else if (getLastPartOf(result) !== quoteOrUppercaseId(implicitAlias)) {
+    else if (getLastPartOf(result) !== formatIdentifier(implicitAlias)) {
       // Render an artificial alias if the result would produce a different one
-      result += ` as ${quoteOrUppercaseId(implicitAlias)}`;
+      result += ` as ${formatIdentifier(implicitAlias)}`;
     }
     return result;
   }
@@ -648,14 +680,14 @@ function toHdbcdsSource(csn, options) {
    */
   function renderViewColumn(col, env, element) {
     // Annotations and column
-    let result = element && hasHanaComment(element, options) ? `${env.indent}@Comment: '${getEscapedHanaComment(element)}'\n` : '';
+    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
 
     if (element && element.virtual || env._artifact.elements[leaf] && env._artifact.elements[leaf].virtual) {
       if (isDeprecatedEnabled(options, 'renderVirtualElements'))
-        return `${result}${env.indent}null as ${quoteOrUppercaseId(leaf)}`;
+        return `${result}${env.indent}null as ${formatIdentifier(leaf)}`;
     }
     else {
       return renderNonVirtualColumn();
@@ -683,7 +715,7 @@ function toHdbcdsSource(csn, options) {
         alias = leaf;
 
       if (alias)
-        result += ` as ${quoteOrUppercaseId(alias)}`;
+        result += ` as ${formatIdentifier(alias)}`;
 
       // Explicit type provided for the view element?
       if (col.cast && col.cast.target) {
@@ -710,7 +742,8 @@ function toHdbcdsSource(csn, options) {
    */
   function renderView(artifactName, art, env) {
     let result = '';
-    globalDuplicateChecker.addArtifact(art['@cds.persistence.name'], art.$location, artifactName);
+    const artifactPath = [ 'definitions', artifactName ];
+    globalDuplicateChecker.addArtifact(art['@cds.persistence.name'], artifactPath, artifactName);
 
     if (hasHanaComment(art, options))
       result += `${env.indent}@Comment: '${getEscapedHanaComment(art)}'\n`;
@@ -726,7 +759,7 @@ function toHdbcdsSource(csn, options) {
       result += ' as ';
     }
     env._artifact = art;
-    result += renderQuery(getNormalizedQuery(art).query, true, env, [ 'definitions', artifactName, 'query' ], art.elements);
+    result += renderQuery(getNormalizedQuery(art).query, true, env, artifactPath.concat(art.projection ? 'projection' : 'query'), art.elements);
     result += ';\n';
     return result;
   }
@@ -776,7 +809,6 @@ function toHdbcdsSource(csn, options) {
     const childEnv = increaseIndent(env);
     childEnv.currentArtifactName = $PROJECTION; // $self to be replaced by $projection
     result += `select from ${renderViewSource(select.from, env)}`;
-
     if (select.mixin) {
       let elems = '';
       for (const name in select.mixin)
@@ -797,7 +829,7 @@ function toHdbcdsSource(csn, options) {
       result += `${env.indent}}`;
     }
     if (select.excluding) {
-      result += ` excluding {\n${select.excluding.map(id => `${childEnv.indent}${quoteOrUppercaseId(id)}`).join(',\n')}\n`;
+      result += ` excluding {\n${select.excluding.map(id => `${childEnv.indent}${formatIdentifier(id)}`).join(',\n')}\n`;
       result += `${env.indent}}`;
     }
 
@@ -895,7 +927,7 @@ function toHdbcdsSource(csn, options) {
   function renderParameter(parName, par, env) {
     if (par.notNull === true || par.notNull === false)
       info(null, env.path.concat([ 'params', parName ]), 'Not Null constraints on HDBCDS view parameters are not allowed and are ignored');
-    return `${env.indent + quoteOrUppercaseId(parName)} : ${renderTypeReference(par, env)}`;
+    return `${env.indent + formatParamIdentifier(parName, env.path.concat([ 'params', parName ]))} : ${renderTypeReference(par, env)}`;
   }
 
   /**
@@ -927,7 +959,7 @@ function toHdbcdsSource(csn, options) {
     }
     else {
       // Derived type or annotation with non-anonymous type
-      result += ` : ${renderTypeReference(art, env, false)};\n`;
+      result += ` : ${renderTypeReference(art, env)};\n`;
     }
     return result;
   }
@@ -938,10 +970,9 @@ function toHdbcdsSource(csn, options) {
    *
    * @param {CSN.Element} elm Element using the type reference
    * @param {CdlRenderEnvironment} env Environment
-   * @param {boolean} [noEnum=false] If true, do not render enums
    * @returns {string} Rendered type reference
    */
-  function renderTypeReference(elm, env, noEnum = false) {
+  function renderTypeReference(elm, env) {
     let result = '';
 
     // Array type: Render items instead
@@ -979,11 +1010,7 @@ function toHdbcdsSource(csn, options) {
     // Reference to another element
     if (elm.type.ref) {
       // For HANA CDS, we need a 'type of'
-      let result = `type of ${renderAbsolutePath(elm.type, env)}`;
-      if (elm.enum)
-        result += renderEnum(elm.enum, env);
-
-      return result;
+      return `type of ${renderAbsolutePath(elm.type, env)}`;
     }
 
     // If we get here, it must be a named type
@@ -995,8 +1022,6 @@ function toHdbcdsSource(csn, options) {
       // Type names are never flattened (derived types are unraveled in HANA)
       result += renderAbsoluteNameWithQuotes(elm.type, env);
     }
-    if (elm.enum && !noEnum)
-      result += renderEnum(elm.enum, env);
 
     return result;
   }
@@ -1012,10 +1037,24 @@ function toHdbcdsSource(csn, options) {
 
     result += `${renderCardinality(elm.cardinality)} to `;
 
+
     // normal target or named aspect
     if (elm.target || elm.targetAspect && typeof elm.targetAspect === 'string') {
-      result += plainNames ? renderAbsoluteNamePlain(elm.target || elm.targetAspect, env)
-        : renderAbsoluteNameWithQuotes(elm.target || elm.targetAspect, env);
+      // we might have a "using target as __target"
+      const targetArtifact = csn.definitions[elm.target];
+      const targetAlias = env.topLevelAliases[targetArtifact['@cds.persistence.name']];
+      if (targetAlias) {
+        result += targetAlias.quotedAlias;
+      }
+      else {
+        result += plainNames ? renderAbsoluteNamePlain(elm.target || elm.targetAspect, env)
+          : renderAbsoluteNameWithQuotes(elm.target || elm.targetAspect, env);
+      }
+    }
+
+    // ON-condition (if any)
+    if (elm.on) {
+      result += ` on ${renderExpr(elm.on, env, true, true)}`;
     }
     else if (elm.targetAspect && elm.targetAspect.elements) { // anonymous aspect
       const childEnv = increaseIndent(env);
@@ -1027,11 +1066,6 @@ function toHdbcdsSource(csn, options) {
     }
 
 
-    // ON-condition (if any)
-    if (elm.on)
-      result += ` on ${renderExpr(elm.on, env, true, true)}`;
-
-
     // Foreign keys (if any, unless we also have an ON_condition (which means we have been transformed from managed to unmanaged)
     if (elm.keys && !elm.on)
       result += ` { ${Object.keys(elm.keys).map(name => renderForeignKey(elm.keys[name], env)).join(', ')} }`;
@@ -1053,27 +1087,6 @@ function toHdbcdsSource(csn, options) {
     return elm.type.replace(/^cds\./, '') + renderTypeParameters(elm);
   }
 
-  /**
-   * Render the 'enum { ... } part of a type declaration
-   *
-   * @param {CSN.EnumElements} enumPart Enum part of a type declaration
-   * @param {CdlRenderEnvironment} env Environment
-   * @returns {string} Rendered enum
-   */
-  function renderEnum(enumPart, env) {
-    let result = ' enum {\n';
-    const childEnv = increaseIndent(env);
-    for (const name in enumPart) {
-      const enumConst = enumPart[name];
-      result += childEnv.indent + quoteId(name);
-      if (enumConst.val !== undefined)
-        result += ` = ${renderExpr(enumConst, childEnv)}`;
-      result += ';\n';
-    }
-    result += `${env.indent}}`;
-    return result;
-  }
-
   /**
    * Render an expression (including paths and values) or condition 'x'.
    * (no trailing LF, don't indent if inline)
@@ -1087,7 +1100,7 @@ function toHdbcdsSource(csn, options) {
   function renderExpr(x, env, inline = true, inExpr = false) {
     // Compound expression
     if (Array.isArray(x))
-      return processExprArray(x, renderExpr, env, inline, inExpr);
+      return beautifyExprArray(x.map(item => renderExpr(item, env, inline, inExpr)));
 
     if (typeof x === 'object' && x !== null) {
       if (inExpr && x.cast && x.cast.type)
@@ -1129,6 +1142,9 @@ function toHdbcdsSource(csn, options) {
 
         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
@@ -1185,14 +1201,19 @@ function toHdbcdsSource(csn, options) {
      */
     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.toHana.user && typeof options.toHana.user === 'string' || options.toHana.user instanceof String)
-              return `'${options.toHana.user}'`;
+            if (options.magicVars && options.magicVars.user && (typeof options.magicVars.user === 'string' || options.magicVars.user instanceof String))
+              return `'${options.magicVars.user}'`;
 
-            else if ((options.toHana.user && options.toHana.user.id) && (typeof options.toHana.user.id === 'string' || options.toHana.user.id instanceof String))
-              return `'${options.toHana.user.id}'`;
+            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\')';
           }
@@ -1207,6 +1228,9 @@ function toHdbcdsSource(csn, options) {
           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)).join('.')}`;
     }
@@ -1218,7 +1242,7 @@ function toHdbcdsSource(csn, options) {
      * @returns {string} Rendered cast()
      */
     function renderExplicitTypeCast(value) {
-      let typeRef = renderTypeReference(x.cast, env, true);
+      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];
@@ -1267,7 +1291,7 @@ function toHdbcdsSource(csn, options) {
           [ $SELF, $PROJECTION, '$session' ].includes(s))
           return s;
 
-        return quoteOrUppercaseId(s);
+        return formatIdentifier(s);
       }
       // ID with filters or parameters
       else if (typeof s === 'object') {
@@ -1277,13 +1301,13 @@ function toHdbcdsSource(csn, options) {
 
         // Not really a path step but an object-like function call
         if (s.func)
-          return `${s.func}(${renderArgs(s.args, '=>', env)})`;
+          return `${s.func}(${renderArgs(s, '=>', env)})`;
 
         // Path step, possibly with view parameters and/or filters
-        let result = `${quoteOrUppercaseId(s.id)}`;
+        let result = `${formatIdentifier(s.id)}`;
         if (s.args) {
           // View parameters
-          result += `(${renderArgs(s.args, ':', env)})`;
+          result += `(${renderArgs(s, ':', env)})`;
         }
         if (s.where) {
           // Filter, possibly with cardinality
@@ -1300,19 +1324,21 @@ function toHdbcdsSource(csn, options) {
    * Render function arguments or view parameters (positional if array, named if object/dict),
    * using 'sep' as separator for positional parameters
    *
-   * @param {object[]|object} args (Un)Named arguments
+   * @param {object} node with `args` to render
    * @param {string} sep Seperator between arguments
    * @param {CdlRenderEnvironment} env Environment
    * @returns {string} Rendered arguments
    */
-  function renderArgs(args, sep, env) {
+  function renderArgs(node, sep, env) {
+    const args = node.args ? node.args : {};
     // Positional arguments
     if (Array.isArray(args))
       return args.map(arg => renderExpr(arg, env)).join(', ');
 
     // Named arguments (object/dict)
     else if (typeof args === 'object')
-      return Object.keys(args).map(key => `${quoteOrUppercaseId(key)} ${sep} ${renderExpr(args[key], env)}`).join(', ');
+      // if this is a function param which is not a reference to the model, we must not quote it
+      return Object.keys(args).map(key => `${node.func ? key : formatIdentifier(key)} ${sep} ${renderExpr(args[key], env)}`).join(', ');
 
 
     throw new Error(`Unknown args: ${JSON.stringify(args)}`);
@@ -1405,10 +1431,10 @@ function toHdbcdsSource(csn, options) {
   function renderAbsoluteNamePlain(absName, env) {
     // Add using declaration
     env.topLevelAliases[absName] = {
-      quotedName: uppercaseAndUnderscore(absName),
-      quotedAlias: uppercaseAndUnderscore(absName),
+      quotedName: formatIdentifier(uppercaseAndUnderscore(absName)),
+      quotedAlias: formatIdentifier(uppercaseAndUnderscore(absName)),
     };
-    return uppercaseAndUnderscore(absName);
+    return formatIdentifier(uppercaseAndUnderscore(absName));
   }
 
   /**
@@ -1493,7 +1519,7 @@ function toHdbcdsSource(csn, options) {
   function renderUsings(artifactName, env) {
     const distinct = {};
     Object.keys(env.topLevelAliases)
-      .filter(name => !(plainNames && env.topLevelAliases[name].quotedName === uppercaseAndUnderscore(artifactName))) // avoid "using FOO as FOO" in FOO.cds
+      .filter(name => env.topLevelAliases[name].quotedAlias !== formatIdentifier(uppercaseAndUnderscore(artifactName))) // avoid "using FOO as FOO" in FOO.cds
       .forEach((name) => {
         distinct[`using ${env.topLevelAliases[name].quotedName} as ${env.topLevelAliases[name].quotedAlias};\n`] = '';
       });
@@ -1564,6 +1590,8 @@ function toHdbcdsSource(csn, options) {
       topLevelAliases: Object.create(null),
       // Current name prefix (including trailing dot if not empty)
       namePrefix: '',
+      // CSN path - should at least point to the correct artifact
+      path: [],
     };
   }
 
@@ -1608,7 +1636,7 @@ function toHdbcdsSource(csn, options) {
    */
   function quoteAbsolutePathString(abspath) {
     const namespace = getNamespace(csn, abspath);
-    const resultingName = getResultingName(csn, options.toHana.names, abspath);
+    const resultingName = getResultingName(csn, options.sqlMapping, abspath);
 
     if (hdbcdsNames && namespace)
       return `${quotePathString(namespace)}::${quotePathString(resultingName.slice(namespace.length + 2))}`;
@@ -1633,10 +1661,19 @@ function toHdbcdsSource(csn, options) {
       return id;
 
 
-    return `"${id.replace(/"/g, '""')}"`;
+    switch (options.forHana.names) {
+      case 'plain':
+        return smartId(id, 'hdbcds');
+      case 'quoted':
+        return delimitedId(id, 'hdbcds');
+      case 'hdbcds':
+        return delimitedId(id, 'hdbcds');
+      default:
+        return null;
+    }
   }
 
-  /**
+  /*
    * 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)
    *
@@ -1654,21 +1691,34 @@ function toHdbcdsSource(csn, options) {
   }
 
   /**
-   * Quote or uppercase an identifier 'id', depending on naming strategy
+   * Quote and/or uppercase an identifier 'id', depending on naming strategy
    *
    * @param {string} id Identifier
-   * @param {CSN.Location} [location] Optional location for the warning.
    * @returns {string} Quoted/uppercased id
    */
-  function quoteOrUppercaseId(id, location = null) {
-    if (plainNames) {
-      const result = uppercaseAndUnderscore(id);
-      // Warn if colliding with HANA keyword
-      if (keywords.hana.includes(result))
-        warning(null, location, `The identifier "${id}" is a SAP HANA keyword`);
+  function formatIdentifier(id) {
+    id = options.forHana.names === 'plain' ? id.toUpperCase() : id;
+    return quoteId(id);
+  }
+
+  /**
+   * Quote or uppercase a parameter identifier 'id', depending on naming strategy
+   * Smart quoting cannot be applied to the parameter identifiers, issue warning instead.
+   *
+   *
+   * @param {string} id Identifier
+   * @param {CSN.Path} [location] Optional location for the warning.
+   * @returns {string} Quoted/uppercased id
+   */
+  function formatParamIdentifier(id, location) {
+    // Warn if colliding with HANA keyword, but do not quote for plain
+    // --> quoted reserved words as param lead to a weird deployment error
+    if (keywords.hdbcds.includes(uppercaseAndUnderscore(id)))
+      warning(null, location, { id }, 'The identifier $(ID) is a SAP HANA keyword');
+
+    if (plainNames)
+      return uppercaseAndUnderscore(id);
 
-      return result;
-    }
     return quoteId(id);
   }
 
@@ -1691,7 +1741,7 @@ function toHdbcdsSource(csn, options) {
    */
   function renderArtifactName(artifactName, env, fallthrough = false) {
     if (plainNames && !fallthrough)
-      return uppercaseAndUnderscore(artifactName);
+      return formatIdentifier(uppercaseAndUnderscore(artifactName));
       // hdbcds with quoted or hdbcds naming
     return env.namePrefix + quoteId(getRealName(csn, artifactName).replace(/\./g, '_'));
   }