@sap/cds-compiler 2.10.4 → 2.12.0

package/lib/render/toHdbcds.js

@@ -1,14 +1,14 @@
 'use strict';
 
 const {
-  getParentNameOf, getLastPartOf, getLastPartOfRef,
+  getLastPartOf, getLastPartOfRef,
   hasValidSkipOrExists, isBuiltinType, generatedByCompilerVersion, getNormalizedQuery,
-  getRootArtifactName, getResultingName, getNamespace, forEachMember,
+  getRootArtifactName, getResultingName, getNamespace, forEachMember, getVariableReplacement, hasAnnotationValue,
 } = require('../model/csnUtils');
 const keywords = require('../base/keywords');
 const {
   renderFunc, beautifyExprArray, getRealName, addContextMarkers, addIntermediateContexts, cdsToSqlTypes,
-  hasHanaComment, getHanaComment, findElement, funcWithoutParen,
+  hasHanaComment, getHanaComment, findElement, funcWithoutParen, getSqlSnippets,
 } = require('./utils/common');
 const {
   renderReferentialConstraint,
@@ -17,7 +17,7 @@ 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');
 
@@ -60,8 +60,7 @@ function toHdbcdsSource(csn, options) {
 
   checkCSNVersion(csn, options);
 
-  const result = Object.create(null);
-
+  const hdbcdsResult = Object.create(null);
 
   const globalDuplicateChecker = new DuplicateChecker(options.sqlMapping); // registry for all artifact names and element names
 
@@ -100,17 +99,17 @@ function toHdbcdsSource(csn, options) {
       Object.entries(art.$tableConstraints.referential)
         .forEach(([ fileName, referentialConstraint ]) => {
           referentialConstraints[fileName] = renderReferentialConstraint(
-            referentialConstraint, '', renderToUppercase, csn, options, false
+            referentialConstraint, '', renderToUppercase, csn, options
           );
         });
       Object.entries(referentialConstraints)
-        .forEach( ([ fileName, constraint ]) => {
+        .forEach(([ fileName, constraint ]) => {
           hdbconstraint[fileName] = constraint;
         });
     }
   });
-  result.hdbcds = hdbcds;
-  result.hdbconstraint = hdbconstraint;
+  hdbcdsResult.hdbcds = hdbcds;
+  hdbcdsResult.hdbconstraint = hdbconstraint;
 
   if (globalDuplicateChecker)
     globalDuplicateChecker.check(error, options); // perform duplicates check
@@ -119,7 +118,7 @@ function toHdbcdsSource(csn, options) {
 
   throwWithError();
   timetrace.stop();
-  return options.testMode ? sort(result) : result;
+  return options.testMode ? sort(hdbcdsResult) : hdbcdsResult;
 
   /**
    * Sort the given object alphabetically
@@ -224,7 +223,7 @@ function toHdbcdsSource(csn, options) {
     const parts = containee.split('.');
     const prefixLength = contextName.split('.').length;
 
-    for (let i = parts.length - 1; i > prefixLength; i-- ) {
+    for (let i = parts.length - 1; i > prefixLength; i--) {
       const prefix = parts.slice(0, i).join('.');
       const art = csn.definitions[prefix];
       if (art && (art.kind === 'context' || art.kind === 'service'))
@@ -291,7 +290,7 @@ function toHdbcdsSource(csn, options) {
   function renderContext(artifactName, art, env, isShadowed) {
     let result = '';
     if (!isShadowed)
-      isShadowed = contextIsShadowed(artifactName, csn);
+      isShadowed = contextIsShadowed(artifactName);
     if (isShadowed) {
       const subArtifacts = getSubArtifacts(artifactName);
       for (const name in subArtifacts)
@@ -318,10 +317,9 @@ function toHdbcdsSource(csn, options) {
    *  non-context/service/namespace definition
    *
    * @param {string} artifactName
-   * @param {CSN.Model} csn
    * @returns {boolean}
    */
-  function contextIsShadowed(artifactName, csn) {
+  function contextIsShadowed(artifactName) {
     if (artifactName.indexOf('.') === -1)
       return false;
 
@@ -395,6 +393,12 @@ function toHdbcdsSource(csn, options) {
     if (hasHanaComment(art, options))
       result += `${env.indent}@Comment: '${getEscapedHanaComment(art)}'\n`;
 
+    // tables can have @sql.prepend and @sql.append
+    const { front, back } = getSqlSnippets(options, art);
+
+    if (front) // attach @sql.prepend after adding @Comment annotation
+      result += front;
+
     result += `${env.indent + (art.abstract ? 'abstract ' : '')}entity ${normalizedArtifactName}`;
     if (art.includes) {
       // Includes are never flattened (don't exist in HANA)
@@ -412,8 +416,12 @@ function toHdbcdsSource(csn, options) {
 
     duplicateChecker.check(error);
     result += `${env.indent}}`;
-    result += `${renderTechnicalConfiguration(art.technicalConfig, env)};\n`;
-    return result;
+    result += `${renderTechnicalConfiguration(art.technicalConfig, env)}`;
+
+    if (back)
+      result += back;
+
+    return `${result};\n`;
   }
 
   /**
@@ -429,9 +437,8 @@ function toHdbcdsSource(csn, options) {
       if (!element.target)
         return;
 
-      let alias = element['@cds.persistence.name'];
       if (uppercaseAndUnderscore(element.target) === element['@cds.persistence.name']) {
-        alias = createTopLevelAliasName(element['@cds.persistence.name']);
+        let alias = createTopLevelAliasName(element['@cds.persistence.name']);
         // calculate new alias if it would conflict with other csn.Artifact
         while (csn.definitions[alias])
           alias = createTopLevelAliasName(alias);
@@ -556,13 +563,19 @@ function toHdbcdsSource(csn, options) {
       result += `${env.indent}@Comment: '${getEscapedHanaComment(elm)}'\n`;
 
     result += env.indent + (elm.key && !isSubElement ? 'key ' : '') +
-                         (elm.masked ? 'masked ' : '') +
-                         quotedElementName + (omitColon ? ' ' : ' : ') +
-                         renderTypeReference(elm, env, undefined) +
-                         renderNullability(elm);
+      (elm.masked ? 'masked ' : '') +
+      quotedElementName + (omitColon ? ' ' : ' : ') +
+      renderTypeReference(elm, env) +
+      renderNullability(elm);
     if (elm.default)
       result += ` default ${renderExpr(elm.default, env)}`;
 
+    // (table) elements can only have a @sql.append
+    const { back } = getSqlSnippets(options, elm);
+
+    if (back)
+      result += back;
+
     return `${result};\n`;
   }
 
@@ -680,7 +693,7 @@ 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
@@ -760,7 +773,14 @@ function toHdbcdsSource(csn, options) {
     }
     env._artifact = art;
     result += renderQuery(getNormalizedQuery(art).query, true, env, artifactPath.concat(art.projection ? 'projection' : 'query'), art.elements);
+
+    // views can only have a @sql.append
+    const { back } = getSqlSnippets(options, art);
+    if (back)
+      result += back;
+
     result += ';\n';
+
     return result;
   }
 
@@ -829,72 +849,73 @@ function toHdbcdsSource(csn, options) {
       result += `${env.indent}}`;
     }
     if (select.excluding) {
-      result += ` excluding {\n${select.excluding.map(id => `${childEnv.indent}${formatIdentifier(id)}`).join(',\n')}\n`;
+      const excludingList = select.excluding.map(id => `${childEnv.indent}${formatIdentifier(id)}`).join(',\n');
+      result += ` excluding {\n${excludingList}\n`;
       result += `${env.indent}}`;
     }
 
-    return renderSelectProperties(select, result);
-
-    /**
-     * Render WHERE, GROUP BY, HAVING, ORDER BY and LIMIT clause
-     *
-     * @param {CSN.QuerySelect} select
-     * @param {string} alreadyRendered The query as it has been rendered so far
-     * @returns {string} The query with WHERE etc. added
-     */
-    function renderSelectProperties(select, alreadyRendered) {
-      if (select.where)
-        alreadyRendered += `${continueIndent(alreadyRendered, env)}where ${renderExpr(select.where, env, true, true)}`;
+    return renderSelectProperties(select, result, env);
+  }
 
-      if (select.groupBy)
-        alreadyRendered += `${continueIndent(alreadyRendered, env)}group by ${select.groupBy.map(expr => renderExpr(expr, env)).join(', ')}`;
+  /**
+   * Render WHERE, GROUP BY, HAVING, ORDER BY and LIMIT clause
+   *
+   * @param {CSN.QuerySelect} select
+   * @param {string} alreadyRendered The query as it has been rendered so far
+   * @param {CdlRenderEnvironment} env Environment
+   * @returns {string} The query with WHERE etc. added
+   */
+  function renderSelectProperties(select, alreadyRendered, env) {
+    if (select.where)
+      alreadyRendered += `${continueIndent(alreadyRendered, env)}where ${renderExpr(select.where, env, true, true)}`;
 
-      if (select.having)
-        alreadyRendered += `${continueIndent(alreadyRendered, env)}having ${renderExpr(select.having, env, true, true)}`;
+    if (select.groupBy)
+      alreadyRendered += `${continueIndent(alreadyRendered, env)}group by ${select.groupBy.map(expr => renderExpr(expr, env)).join(', ')}`;
 
-      if (select.orderBy)
-        alreadyRendered += `${continueIndent(alreadyRendered, env)}order by ${select.orderBy.map(entry => renderOrderByEntry(entry, env)).join(', ')}`;
+    if (select.having)
+      alreadyRendered += `${continueIndent(alreadyRendered, env)}having ${renderExpr(select.having, env, true, true)}`;
 
-      if (select.limit)
-        alreadyRendered += `${continueIndent(alreadyRendered, env)}${renderLimit(select.limit, env)}`;
+    if (select.orderBy)
+      alreadyRendered += `${continueIndent(alreadyRendered, env)}order by ${select.orderBy.map(entry => renderOrderByEntry(entry, env)).join(', ')}`;
 
-      return alreadyRendered;
-    }
+    if (select.limit)
+      alreadyRendered += `${continueIndent(alreadyRendered, env)}${renderLimit(select.limit, env)}`;
 
+    return alreadyRendered;
+  }
 
-    /**
-     * Utility function to make sure that we continue with the same indentation in WHERE, GROUP BY, ... after a closing curly brace and beyond
-     *
-     * @param {string} result Result of a previous render step
-     * @param {CdlRenderEnvironment} env Environment
-     * @returns {string} String to join with
-     */
-    function continueIndent(result, env) {
-      if (result.endsWith('}') || result.endsWith('})')) {
-        // The preceding clause ended with '}', just append after that
-        return ' ';
-      }
-      // Otherwise, start new line and indent normally
-      return `\n${increaseIndent(env).indent}`;
+  /**
+   * Utility function to make sure that we continue with the same indentation in WHERE, GROUP BY, ... after a closing curly brace and beyond
+   *
+   * @param {string} result Result of a previous render step
+   * @param {CdlRenderEnvironment} env Environment
+   * @returns {string} String to join with
+   */
+  function continueIndent(result, env) {
+    if (result.endsWith('}') || result.endsWith('})')) {
+      // The preceding clause ended with '}', just append after that
+      return ' ';
     }
+    // Otherwise, start new line and indent normally
+    return `\n${increaseIndent(env).indent}`;
+  }
 
-    /**
-     * Render a query's LIMIT clause, which may have also have OFFSET.
-     *
-     * @param {CSN.QueryLimit} limit CSN limit clause
-     * @param {CdlRenderEnvironment} env Environment
-     * @returns {string} Rendered limit clause
-     */
-    function renderLimit(limit, env) {
-      let result = '';
-      if (limit.rows !== undefined)
-        result += `limit ${renderExpr(limit.rows, env)}`;
+  /**
+   * Render a query's LIMIT clause, which may have also have OFFSET.
+   *
+   * @param {CSN.QueryLimit} limit CSN limit clause
+   * @param {CdlRenderEnvironment} env Environment
+   * @returns {string} Rendered limit clause
+   */
+  function renderLimit(limit, env) {
+    let result = '';
+    if (limit.rows !== undefined)
+      result += `limit ${renderExpr(limit.rows, env)}`;
 
-      if (limit.offset !== undefined)
-        result += `${result !== '' ? `\n${increaseIndent(env).indent}` : ''}offset ${renderExpr(limit.offset, env)}`;
+    if (limit.offset !== undefined)
+      result += `${result !== '' ? `\n${increaseIndent(env).indent}` : ''}offset ${renderExpr(limit.offset, env)}`;
 
-      return result;
-    }
+    return result;
   }
 
   /**
@@ -926,7 +947,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');
+      info('query-ignoring-param-nullability', env.path.concat([ 'params', parName ]), { '#': 'std' });
     return `${env.indent + formatParamIdentifier(parName, env.path.concat([ 'params', parName ]))} : ${renderTypeReference(par, env)}`;
   }
 
@@ -943,7 +964,7 @@ function toHdbcdsSource(csn, options) {
     if (art.kind === 'aspect' || art.kind === 'type' && !hdbcdsNames || art.kind === 'type' && hdbcdsNames && !art.elements)
       return '';
     let result = '';
-    result += `${env.indent + (art.kind )} ${renderArtifactName(artifactName, env, true)}`;
+    result += `${env.indent + (art.kind)} ${renderArtifactName(artifactName, env, true)}`;
     if (art.includes) {
       // Includes are never flattened (don't exist in HANA)
       result += ` : ${art.includes.map(name => renderAbsoluteNameWithQuotes(name, env)).join(', ')}`;
@@ -959,7 +980,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;
   }
@@ -968,12 +989,11 @@ function toHdbcdsSource(csn, options) {
    * Render a reference to a type used by 'elm' (named or inline)
    * Allow suppressing enum-rendering - used in columns for example
    *
-   * @param {CSN.Element} elm Element using the type reference
+   * @param {object} 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
@@ -1011,11 +1031,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
@@ -1027,8 +1043,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;
   }
@@ -1094,58 +1108,38 @@ 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)
    *
-   * @param {any} x Expression to render
+   * @param {any} expr Expression to render
    * @param {CdlRenderEnvironment} env Environment
-   * @param {boolean} [inline=true] Wether to render inline
+   * @param {boolean} [inline=true] Whether to render inline
    * @param {boolean} [inExpr=false] Whether the expression is already inside another expression
    * @returns {string} Rendered expression
    */
-  function renderExpr(x, env, inline = true, inExpr = false) {
+  function renderExpr(expr, env, inline = true, inExpr = false) {
     // Compound expression
-    if (Array.isArray(x))
-      return beautifyExprArray(x.map(item => renderExpr(item, env, inline, inExpr)));
+    if (Array.isArray(expr))
+      return beautifyExprArray(expr.map(item => renderExpr(item, env, inline, inExpr)));
 
-    if (typeof x === 'object' && x !== null) {
-      if (inExpr && x.cast && x.cast.type)
-        return renderExplicitTypeCast(renderExprObject());
-      return renderExprObject();
+    if (typeof expr === 'object' && expr !== null) {
+      if (inExpr && expr.cast && expr.cast.type)
+        return renderExplicitTypeCast(renderExprObject(expr));
+      return renderExprObject(expr);
     }
 
     // Not a literal value but part of an operator, function etc - just leave as it is
-    return x;
+    return expr;
 
 
     /**
      * Various special cases represented as objects
      *
+     * @param {object} x Expression
      * @returns {string} Rendered expression object
      */
-    function renderExprObject() {
+    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(', ')})`;
@@ -1173,7 +1167,7 @@ function toHdbcdsSource(csn, options) {
         // 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) );
+        return renderFunc(funcName, x, 'hana', a => renderArgs(a, '=>', env));
       }
       // Nested expression
       else if (x.xpr) {
@@ -1229,7 +1223,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))
@@ -1251,6 +1250,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('.')}`;
     }
@@ -1262,10 +1264,10 @@ function toHdbcdsSource(csn, options) {
      * @returns {string} Rendered cast()
      */
     function renderExplicitTypeCast(value) {
-      let typeRef = renderTypeReference(x.cast, env, true);
+      let typeRef = renderTypeReference(expr.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];
+      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);
@@ -1288,7 +1290,7 @@ function toHdbcdsSource(csn, options) {
         // (see FIXME at renderArtifact)
         if (idx === 0 && s === $SELF) {
           // do not produce USING for $projection
-          if (env.currentArtifactName === $PROJECTION && env._artifact && env._artifact.projection)
+          if (env.currentArtifactName === $PROJECTION)
             return env.currentArtifactName;
 
           return plainNames ? renderAbsoluteNamePlain(env.currentArtifactName, env)
@@ -1541,9 +1543,70 @@ function toHdbcdsSource(csn, options) {
     Object.keys(env.topLevelAliases)
       .filter(name => env.topLevelAliases[name].quotedAlias !== formatIdentifier(uppercaseAndUnderscore(artifactName))) // avoid "using FOO as FOO" in FOO.cds
       .forEach((name) => {
+        const nativeObjectExists = csn.definitions[name] && hasAnnotationValue(csn.definitions[name], '@cds.persistence.exists');
+        if (!plainNames && nativeObjectExists)
+          checkForNameClashesWithNativeObject(name);
         distinct[`using ${env.topLevelAliases[name].quotedName} as ${env.topLevelAliases[name].quotedAlias};\n`] = '';
       });
+    /**
+     * If we generate a `using <native object> from <bar>` clause,
+     * we warn if we generate a SAP HANA CDS artifact which would hide the
+     * native DB object from being found by the SAP HANA CDS compiler
+     * see cap/cds-compiler#8269 for details
+     * @param {string} name of the native db object
+     */
+    function checkForNameClashesWithNativeObject(name) {
+      const possibleShadowName = getNamePrefix(env.topLevelAliases[name].quotedName);
+      const mightBeShadowedBy = csn.definitions[possibleShadowName];
+      if (mightBeShadowedBy) {
+        const artifactWillBeRendered = isArtifactRendered(mightBeShadowedBy, possibleShadowName);
+        // only warn if actually rendered to HANA CDS
+        if (artifactWillBeRendered)
+          warning('anno-hidden-exists', [ 'definitions', name ], { name: possibleShadowName }, 'Native database object is hidden by a definition starting with $(NAME)');
+      }
+    }
 
+    function isArtifactRendered(art, artName) {
+      const isHanaCdsContext = art.kind === 'service' || art.kind === 'context';
+      if (isHanaCdsContext)
+        return isContextRendered(artName);
+      if ([ 'action', 'function', 'event' ].includes(art.kind) || options.sqlMapping !== 'hdbcds' && art.kind === 'type')
+        return false;
+      return !(hasAnnotationValue(art, '@cds.persistence.exists') || hasAnnotationValue(art, '@cds.persistence.skip'));
+    }
+
+    /**
+     * Check if there is at least one entity which will be rendered as SAP HANA CDS entity
+     * inside the given context (or in its sub-contexts).
+     * Or in other words: If the context will be rendered as a SAP HANA CDS context in the end.
+     *
+     * @param {string} contextName
+     * @returns {boolean} true if a context/service will be rendered as a SAP HANA CDS context.
+     */
+    function isContextRendered(contextName) {
+      const subArtifacts = getSubArtifacts(contextName);
+      return Object.entries(subArtifacts).some(([ artName, art ]) => {
+        if (art.kind === 'context')
+          return isContextRendered(`${contextName}.${artName}`);
+        return isArtifactRendered(art, artName);
+      });
+    }
+
+    /**
+     * @param {string} usingName the string which appears in the `using <string> from ..` including the quotes
+     * @returns the prefix of the `using` name.
+     * @example
+     *  "com.sap.foo.native.object"  -->  com
+     *  "com.sap.foo::native.object" -->  com.sap.foo.native
+     */
+    function getNamePrefix(usingName) {
+      usingName = usingName.replace(/"/g, '');
+      if (usingName.indexOf('::') !== -1) {
+        const parts = usingName.split('::');
+        return `${parts[0]}.${parts[1].split('.')[0]}`;
+      }
+      return usingName.split('.')[0];
+    }
     return Object.keys(distinct).join('');
   }
 
@@ -1675,11 +1738,6 @@ function toHdbcdsSource(csn, options) {
     if (id.indexOf('.') !== -1)
       throw new Error(id);
 
-    // FIXME: Somewhat arbitrary magic: Do not quote $projection (because HANA CDS doesn't recognize it otherwise).  Similar for $self.
-    // FIXME: The test should not be on the name, but by checking the _artifact.
-    if (id === $PROJECTION || id === $SELF)
-      return id;
-
 
     switch (options.forHana.names) {
       case 'plain':
@@ -1701,13 +1759,14 @@ function toHdbcdsSource(csn, options) {
    * @returns {string} Correctly quoted absname
    */
   function quoteAbsoluteNameAsId(absname) {
+    const resultingName = getResultingName(csn, options.sqlMapping, absname);
+
     if (hdbcdsNames) {
-      const topLevelName = getRootArtifactName(absname, csn);
-      const namespace = getParentNameOf(topLevelName);
+      const namespace = getNamespace(csn, absname);
       if (namespace)
-        return `"${(`${namespace}::${absname.substring(namespace.length + 1)}`).replace(/"/g, '""')}"`;
+        return `"${(`${namespace}::${resultingName.substring(namespace.length + 2)}`).replace(/"/g, '""')}"`;
     }
-    return `"${absname.replace(/"/g, '""')}"`;
+    return `"${resultingName.replace(/"/g, '""')}"`;
   }
 
   /**
@@ -1762,7 +1821,7 @@ function toHdbcdsSource(csn, options) {
   function renderArtifactName(artifactName, env, fallthrough = false) {
     if (plainNames && !fallthrough)
       return formatIdentifier(uppercaseAndUnderscore(artifactName));
-      // hdbcds with quoted or hdbcds naming
+    // hdbcds with quoted or hdbcds naming
     return env.namePrefix + quoteId(getRealName(csn, artifactName).replace(/\./g, '_'));
   }
 

package/lib/render/toRename.js

@@ -70,22 +70,19 @@ function toRenameDdl(csn, options) {
 
       resultStr += Object.keys(art.elements).map((name) => {
         const e = art.elements[name];
-        let result = '';
+        let str = '';
 
         const beforeColumnName = quoteSqlId(name);
         const afterColumnName = plainSqlId(name);
 
         if (!e._ignore) {
-          if (e.target) {
-            resultStr += ' ';
-            result = `  EXEC 'ALTER TABLE ${afterTableName} DROP ASSOCIATION ${beforeColumnName}';\n`;
-          }
-          else if (beforeColumnName !== afterColumnName) {
-            resultStr += ' ';
-            result = `    EXEC 'RENAME COLUMN ${afterTableName}.${beforeColumnName} TO ${afterColumnName}';\n`;
-          }
+          if (e.target)
+            str = `  EXEC 'ALTER TABLE ${afterTableName} DROP ASSOCIATION ${beforeColumnName}';\n`;
+
+          else if (beforeColumnName !== afterColumnName)
+            str = `    EXEC 'RENAME COLUMN ${afterTableName}.${beforeColumnName} TO ${afterColumnName}';\n`;
         }
-        return result;
+        return str;
       }).join('');
     }
     return resultStr;