@sap/cds-compiler 2.7.0 → 2.11.2

package/lib/render/toCdl.js

@@ -8,11 +8,13 @@ const {
   isBuiltinType, generatedByCompilerVersion, getNormalizedQuery,
 } = require('../model/csnUtils');
 const keywords = require('../base/keywords');
-const { renderFunc, processExprArray, findElement } = require('./utils/common');
+const { renderFunc, beautifyExprArray, findElement } = require('./utils/common');
 const { checkCSNVersion } = require('../json/csnVersion');
-const timetrace = require('../utils/timetrace');
+const { timetrace } = require('../utils/timetrace');
 const { csnRefs } = require('../model/csnRefs');
 const { forEachDefinition } = require('../model/csnUtils');
+const enrichUniversalCsn = require('../transform/universalCsnEnricher');
+const { isBetaEnabled } = require('../base/model');
 
 /**
  * Render the CSN model 'model' to CDS source text. One source is created per
@@ -33,6 +35,9 @@ function toCdsSourceCsn(csn, options) {
   // Skip compactModel if already using CSN
   // const csn = cloneCsn(model, options);
 
+  if (options.csnFlavor === 'universal' && isBetaEnabled(options, 'enableUniversalCsn'))
+    enrichUniversalCsn(csn, options);
+
   checkCSNVersion(csn, options);
 
   const result = Object.create(null);
@@ -50,16 +55,20 @@ function toCdsSourceCsn(csn, options) {
       result[main] += `${sourceStr}\n`;
   });
 
-  // Apply possible subelement annotations with an "annotate X with"
+  // Apply possible subelement/action return annotations with an "annotate X with"
+  // Some of them appear in csn.extensions, some not...
   if (subelementAnnotates.length > 0) {
-    for (const [ artName, element, elementName ] of subelementAnnotates) {
-      let sourceStr = `annotate ${artName} with {\n`;
-      sourceStr += `  ${elementName} {\n`;
+    for (const [ artName, element, elementName, suffix ] of subelementAnnotates) {
+      // Suffix is used with action return annotations
+      let sourceStr = `annotate ${artName} with ${suffix ? `${suffix} ` : ''}{\n`;
+      if (elementName) // action returns do not have element name - we need less {} there
+        sourceStr += `  ${elementName} {\n`;
       const env = increaseIndent(increaseIndent(createEnv()));
       const subelements = renderSubelementAnnotates(element, env);
       if (subelements !== '') {
         sourceStr += `${subelements}\n`;
-        sourceStr += '  }\n';
+        if (elementName) // action returns do not have element name - we need less {} there
+          sourceStr += '  }\n';
         sourceStr += '}\n';
         result[main] += `${sourceStr}\n`;
       }
@@ -145,6 +154,12 @@ function toCdsSourceCsn(csn, options) {
       if (ext.elements)
         result += renderElementExtensions(ext.elements, env);
 
+      // Returns annotations
+      if (ext.returns) {
+        const childEnv = increaseIndent(env);
+        result += ` with returns${renderElementExtensions(ext.returns.elements, childEnv)}`;
+      }
+
       // Action annotations
       if (ext.actions) {
         result += ' actions {\n';
@@ -162,10 +177,19 @@ function toCdsSourceCsn(csn, options) {
 
             result += `${paramAnnotations.join(',\n')}\n${childEnv.indent})`;
           }
+          // Annotations on action returns
+          if (action.returns && action.returns.elements) {
+            const grandChildEnv = increaseIndent(childEnv);
+            result += ` returns${renderElementExtensions(action.returns.elements, grandChildEnv)}`;
+          }
+
+
           result += ';\n';
         }
         result += `${env.indent}}`;
       }
+
+
       result += ';';
       return result;
     }).join('\n');
@@ -205,6 +229,7 @@ function toCdsSourceCsn(csn, options) {
   function renderArtifact(artifactName, art, env) {
     // FIXME: Correctly build the paths during runtime to give better locations
     env.path = [ 'definitions', artifactName ];
+    env.artifactName = artifactName;
 
     switch (art.kind) {
       case 'entity':
@@ -509,6 +534,7 @@ function toCdsSourceCsn(csn, options) {
    * @param {Boolean} [isSubElement]
    */
   function renderElement(elementName, elm, env, isSubElement) {
+    env.elementName = elementName;
     let result = renderDocComment(elm, env) + renderAnnotationAssignments(elm, env);
     const quotedElementName = quoteOrUppercaseId(elementName);
     result += `${env.indent + (elm.virtual ? 'virtual ' : '') +
@@ -516,10 +542,11 @@ function toCdsSourceCsn(csn, options) {
                          ((elm.masked && !elm._ignoreMasked) ? 'masked ' : '') +
                          quotedElementName} : ${
       renderTypeReference(elm, env, undefined)
-    }${renderNullability(elm)}`;
+    }${elm.on ? '' : renderNullability(elm)}`;
     if (elm.default)
       result += ` default ${renderExpr(elm.default, env)}`;
 
+    delete env.elementName;
     return `${result};\n`;
   }
 
@@ -552,7 +579,7 @@ function toCdsSourceCsn(csn, options) {
    * @return {string}
    */
   function renderQueryActionsAndFunctions(artifactName, art, env) {
-    let result = renderDocComment(art, env) + renderActionsAndFunctions(art, env);
+    let result = renderActionsAndFunctions(art, env);
     // Even if we have seen actions/functions, they might all have been ignored
     if (result !== '')
       result = `${env.indent}extend entity ${artifactName} with${result};`;
@@ -585,7 +612,7 @@ function toCdsSourceCsn(csn, options) {
     }
     // Now iterate elements - render an annotation if it is different from the column's
     const childEnv = increaseIndent(env);
-    let result = renderDocComment(art, env);
+    let result = '';
     for (const elemName in art.elements) {
       let elemAnnotations = '';
       const elem = art.elements[elemName];
@@ -688,7 +715,7 @@ function toCdsSourceCsn(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)}]`;
@@ -1056,8 +1083,11 @@ function toCdsSourceCsn(csn, options) {
     const childEnv = increaseIndent(env);
     const parameters = Object.keys(act.params || []).map(name => renderParameter(name, act.params[name], childEnv)).join(',\n');
     result += (parameters === '') ? '()' : `(\n${parameters}\n${env.indent})`;
-    if (act.returns)
+    if (act.returns) {
+      if (act.returns.type && act.returns.elements) // action returns annotations
+        subelementAnnotates.push([ actionName, act.returns, '', 'returns' ]);
       result += ` returns ${renderTypeReference(act.returns, env)}${renderNullability(act.returns)}`;
+    }
 
     result += ';\n';
     return result;
@@ -1133,6 +1163,10 @@ function toCdsSourceCsn(csn, options) {
       let rc = `many ${renderTypeReference(elm.items, env)}`;
       if (elm.items.notNull != null)
         rc += elm.items.notNull ? ' not null' : ' null';
+      // many sub element annotates
+      if (elm.items.type && elm.items.elements && env.artifactName)
+        subelementAnnotates.push([ env.artifactName, elm.items, env.elementName ]);
+
       return rc;
     }
 
@@ -1316,7 +1350,7 @@ function toCdsSourceCsn(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)
@@ -1370,6 +1404,12 @@ function toCdsSourceCsn(csn, options) {
         // FIXME: no extra magic with x.param or x.global
         return `${(x.param || x.global) ? ':' : ''}${x.ref.map(renderPathStep).join('.')}`;
       }
+      else if (x.xpr && x.func) {
+        // window function
+        const funcDef = renderFunc( x.func, x, null, a => renderArgs(a, '=>', env) );
+        const windowFunctionOperator = x.xpr.shift(); // OVER ...
+        return `${funcDef} ${windowFunctionOperator} ( ${renderExpr(x.xpr, env, true)} )`;
+      }
       // Function call, possibly with args (use '=>' for named args)
       else if (x.func) {
         // test for non-regular HANA identifier that needs to be quoted
@@ -1440,13 +1480,13 @@ function toCdsSourceCsn(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)}`;
         if (s.args) {
           // View parameters
-          result += `(${renderArgs(s.args, ':', env)})`;
+          result += `(${renderArgs(s, ':', env)})`;
         }
         if (s.where) {
           // Filter, possibly with cardinality
@@ -1464,12 +1504,13 @@ function toCdsSourceCsn(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
    * @param {CdlRenderEnvironment} env
    * @returns {string}
    */
-  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(', ');
@@ -1861,6 +1902,8 @@ function toCdsSourceCsn(csn, options) {
  *
  * @property {string}   indent Current indentation as a string, e.g. '  ' for two spaces.
  * @property {CSN.Path} [path] CSN path to the current artifact
+ * @property {string}   artifactName Name of the artifact - set in renderArtifact
+ * @property {string}   elementName Name of the element being rendered - set in renderElement
  * @property {{[name: string]: {
       quotedName: string,
       quotedAlias: string

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';
@@ -402,6 +404,9 @@ function toHdbcdsSource(csn, options) {
     const duplicateChecker = new DuplicateChecker(); // registry for all artifact names and element names
     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,7 +548,7 @@ 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, env.path);
+    const quotedElementName = formatIdentifier(elementName);
     if (duplicateChecker)
       duplicateChecker.addElement(quotedElementName, env.path, elementName);
 
@@ -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, env.path)}`;
+        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)}]`;
@@ -627,11 +659,11 @@ function toHdbcdsSource(csn, options) {
     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, env.path)}`;
+      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, env.path)}`;
+      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, env.path)}`;
+        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, env.path)}`;
+        result += ` as ${formatIdentifier(alias)}`;
 
       // Explicit type provided for the view element?
       if (col.cast && col.cast.target) {
@@ -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, env.path)}`).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, env.path)} : ${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,19 @@ 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)
@@ -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,7 +1201,12 @@ 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.magicVars && options.magicVars.user && (typeof options.magicVars.user === 'string' || options.magicVars.user instanceof String))
@@ -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, env.path);
+        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`] = '';
       });
@@ -1635,7 +1661,16 @@ 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;
+    }
   }
 
   /*
@@ -1656,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);
   }
 
@@ -1693,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, '_'));
   }