@sap/cds-compiler 2.11.2 → 2.13.6

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, getVariableReplacement,
+  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,
@@ -20,6 +20,7 @@ const { makeMessageFunction } = require('../base/messages');
 const { timetrace } = require('../utils/timetrace');
 
 const { smartId, delimitedId } = require('../sql-identifier');
+const { ModelError } = require('../base/error');
 
 const $PROJECTION = '$projection';
 const $SELF = '$self';
@@ -60,8 +61,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 +100,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 +119,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
@@ -153,7 +153,6 @@ function toHdbcdsSource(csn, options) {
 
     switch (art.kind) {
       case 'entity':
-      case 'view':
         // FIXME: For HANA CDS, we need to replace $self at the beginning of paths in association ON-condition
         // by the full name of the artifact we are rendering (should actually be done by forHana, but that is
         // somewhat difficult because this kind of absolute path is quite unusual). In order not to have to pass
@@ -178,7 +177,7 @@ function toHdbcdsSource(csn, options) {
       case 'event':
         return '';
       default:
-        throw new Error(`Unknown artifact kind: ${art.kind}`);
+        throw new ModelError(`Unknown artifact kind: ${art.kind}`);
     }
   }
 
@@ -214,7 +213,7 @@ function toHdbcdsSource(csn, options) {
   }
 
   /**
-   * Check wether the given context is the direct parent of the containee.
+   * Check whether the given context is the direct parent of the containee.
    *
    * @param {string} containee Name of the contained artifact
    * @param {string} contextName Name of the (grand?)parent context
@@ -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)
@@ -314,14 +313,13 @@ function toHdbcdsSource(csn, options) {
     return `${result + renderedSubArtifacts + env.indent}};\n`;
   }
   /**
-   * Check wether the given context is shadowed, i.e. part of his name prefix is shared by a
+   * Check whether the given context is shadowed, i.e. part of his name prefix is shared by a
    *  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);
@@ -462,7 +469,7 @@ function toHdbcdsSource(csn, options) {
     // in 'tc' that we find and render them all (is it syntactically allowed yet to have more than one?)
     tc = tc.hana;
     if (!tc)
-      throw new Error('Expecting a HANA technical configuration');
+      throw new ModelError('Expecting a HANA technical configuration');
 
     result += `\n${env.indent}technical ${tc.calculated ? '' : 'hana '}configuration {\n`;
 
@@ -537,7 +544,7 @@ function toHdbcdsSource(csn, options) {
    * @param {CSN.Element} elm Content of the element
    * @param {CdlRenderEnvironment} env Environment
    * @param {DuplicateChecker} [duplicateChecker] Utility for detecting duplicates
-   * @param {boolean} [isSubElement] Wether the given element is a subelement or not - subelements cannot be key!
+   * @param {boolean} [isSubElement] Whether the given element is a subelement or not - subelements cannot be key!
    * @returns {string} The rendered element
    */
   function renderElement(elementName, elm, env, duplicateChecker, isSubElement) {
@@ -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) +
-                         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`;
   }
 
@@ -615,7 +628,7 @@ function toHdbcdsSource(csn, options) {
   function renderAbsolutePath(path, env) {
     // Sanity checks
     if (!path.ref)
-      throw new Error(`Expecting ref in path: ${JSON.stringify(path)}`);
+      throw new ModelError(`Expecting ref in path: ${JSON.stringify(path)}`);
 
 
     // Determine the absolute name of the first artifact on the path (before any associations or element traversals)
@@ -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;
   }
 
@@ -771,7 +791,7 @@ function toHdbcdsSource(csn, options) {
    * or 'entity')
    *
    * @param {CSN.Query} query Query object
-   * @param {boolean} isLeadingQuery Wether the query is the leading query or not
+   * @param {boolean} isLeadingQuery Whether the query is the leading query or not
    * @param {CdlRenderEnvironment} env Environment
    * @param {CSN.Path} [path=[]] CSN path to the query
    * @param {object} [elements] For leading query, the elements of the artifact
@@ -803,7 +823,7 @@ function toHdbcdsSource(csn, options) {
     }
     // Otherwise must have a SELECT
     else if (!query.SELECT) {
-      throw new Error(`Unexpected query operation ${JSON.stringify(query)}`);
+      throw new ModelError(`Unexpected query operation ${JSON.stringify(query)}`);
     }
     const select = query.SELECT;
     const childEnv = increaseIndent(env);
@@ -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, true, false, true)).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;
   }
 
   /**
@@ -906,7 +927,7 @@ function toHdbcdsSource(csn, options) {
    * @returns {string} Rendered order by
    */
   function renderOrderByEntry(entry, env) {
-    let result = renderExpr(entry, env);
+    let result = renderExpr(entry, env, true, false, true);
     if (entry.sort)
       result += ` ${entry.sort}`;
 
@@ -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(', ')}`;
@@ -968,7 +989,7 @@ 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
    * @returns {string} Rendered type reference
    */
@@ -990,7 +1011,7 @@ function toHdbcdsSource(csn, options) {
     // Anonymous structured type
     if (!elm.type) {
       if (!elm.elements)
-        throw new Error(`Missing type of: ${JSON.stringify(elm)}`);
+        throw new ModelError(`Missing type of: ${JSON.stringify(elm)}`);
 
       result += '{\n';
       const childEnv = increaseIndent(env);
@@ -1091,33 +1112,36 @@ function toHdbcdsSource(csn, options) {
    * 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
+   * @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
    */
-  function renderExpr(x, env, inline = true, inExpr = false) {
+  function renderExpr(expr, env, inline = true, inExpr = false, alwaysRenderCast = 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 || alwaysRenderCast) && 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(', ')})`;
@@ -1145,7 +1169,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) {
@@ -1164,7 +1188,7 @@ function toHdbcdsSource(csn, options) {
         return `${renderQuery(x, false, increaseIndent(env))}`;
       }
 
-      throw new Error(`Unknown expression: ${JSON.stringify(x)}`);
+      throw new ModelError(`Unknown expression: ${JSON.stringify(x)}`);
     }
     /**
      * @param {object} x Expression with a val and/or literal property
@@ -1190,7 +1214,7 @@ function toHdbcdsSource(csn, options) {
 
         // otherwise fall through to
         default:
-          throw new Error(`Unknown literal or type: ${JSON.stringify(x)}`);
+          throw new ModelError(`Unknown literal or type: ${JSON.stringify(x)}`);
       }
     }
 
@@ -1242,10 +1266,10 @@ function toHdbcdsSource(csn, options) {
      * @returns {string} Rendered cast()
      */
     function renderExplicitTypeCast(value) {
-      let typeRef = renderTypeReference(x.cast, env);
+      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);
@@ -1268,7 +1292,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)
@@ -1297,7 +1321,7 @@ function toHdbcdsSource(csn, options) {
       else if (typeof s === 'object') {
         // Sanity check
         if (!s.func && !s.id)
-          throw new Error(`Unknown path step object: ${JSON.stringify(s)}`);
+          throw new ModelError(`Unknown path step object: ${JSON.stringify(s)}`);
 
         // Not really a path step but an object-like function call
         if (s.func)
@@ -1316,7 +1340,7 @@ function toHdbcdsSource(csn, options) {
         return result;
       }
 
-      throw new Error(`Unknown path step: ${JSON.stringify(s)}`);
+      throw new ModelError(`Unknown path step: ${JSON.stringify(s)}`);
     }
   }
 
@@ -1333,15 +1357,15 @@ function toHdbcdsSource(csn, options) {
     const args = node.args ? node.args : {};
     // Positional arguments
     if (Array.isArray(args))
-      return args.map(arg => renderExpr(arg, env)).join(', ');
+      return args.map(arg => renderExpr(arg, env, true, false, true)).join(', ');
 
     // Named arguments (object/dict)
     else if (typeof args === 'object')
       // 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(', ');
+      return Object.keys(args).map(key => `${node.func ? key : formatIdentifier(key)} ${sep} ${renderExpr(args[key], env, true, false, true)}`).join(', ');
 
 
-    throw new Error(`Unknown args: ${JSON.stringify(args)}`);
+    throw new ModelError(`Unknown args: ${JSON.stringify(args)}`);
   }
 
   /**
@@ -1521,9 +1545,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('');
   }
 
@@ -1562,7 +1647,7 @@ function toHdbcdsSource(csn, options) {
       if (plainNames) {
         const art = csn.definitions[name];
         // For 'plain' naming, take all entities and views, nothing else
-        if (art.kind === 'entity' || art.kind === 'view')
+        if (art.kind === 'entity')
           result[name] = art;
       }
       else {
@@ -1653,12 +1738,7 @@ 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 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;
+      throw new ModelError(id);
 
 
     switch (options.forHana.names) {
@@ -1681,13 +1761,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, '""')}"`;
   }
 
   /**
@@ -1742,7 +1823,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, '_'));
   }