@sap/cds-compiler 3.9.4 → 4.0.2

package/lib/render/toHdbcds.js

@@ -26,6 +26,42 @@ const { ModelError, CompilerAssertion } = require('../base/error');
 const $PROJECTION = '$projection';
 const $SELF = '$self';
 
+
+// TODO: Unify with other RenderEnvironments
+class HdbcdsRenderEnvironment {
+  indent = '';
+  path = null;
+  /**
+   * Dictionary of aliases for used artifact names, each entry like 'name' : { quotedName, quotedAlias }
+   * @type {{[name: string]: {
+   *       quotedName: string,
+   *       quotedAlias: string
+   *     }}}
+   */
+  topLevelAliases = Object.create(null);
+  // Current name prefix (including trailing dot if not empty)
+  namePrefix = '';
+  // Skip rendering keys in subqueries
+  skipKeys = false;
+  currentArtifactName = null;
+  // The original view artifact, used when rendering queries
+  _artifact = null;
+
+  constructor(values) {
+    Object.assign(this, values);
+  }
+
+  withIncreasedIndent() {
+    return new HdbcdsRenderEnvironment({ ...this, namePrefix: '', indent: `  ${this.indent}` });
+  }
+  withSubPath(path) {
+    return new HdbcdsRenderEnvironment({ ...this, path: [ ...this.path, ...path ] });
+  }
+  cloneWith(values) {
+    return Object.assign(new HdbcdsRenderEnvironment(this), values);
+  }
+}
+
 /**
  * Get the comment and in addition escape \n and `'` so SAP HANA CDS can handle it.
  *
@@ -33,7 +69,9 @@ const $SELF = '$self';
  * @returns {string}
  */
 function getEscapedHanaComment( obj ) {
-  return getHanaComment(obj).replace(/\n/g, '\\n').replace(/'/g, "''");
+  return getHanaComment(obj)
+    .replace(/\n/g, '\\n')
+    .replace(/'/g, "''");
 }
 
 /**
@@ -66,7 +104,7 @@ function toHdbcdsSource( csn, options ) {
   const exprRenderer = createExpressionRenderer({
     finalize: x => x,
     typeCast(x) {
-      let typeRef = renderTypeReference(x.cast, this.env);
+      let typeRef = renderTypeReference(x.cast, this.env.withSubPath([ 'cast' ]));
       // inside a cast expression, the cds and hana cds types need to be mapped to hana sql types
       const hanaSqlType = cdsToSqlTypes.hana[x.cast.type] || cdsToSqlTypes.standard[x.cast.type];
       if (hanaSqlType) {
@@ -82,17 +120,18 @@ function toHdbcdsSource( csn, options ) {
     windowFunction: renderExpressionFunc,
     func: renderExpressionFunc,
     xpr(x) {
+      const xprEnv = this.env.withSubPath([ 'xpr' ]);
       if (this.isNestedXpr && !x.cast)
-        return `(${this.renderSubExpr(x.xpr)})`;
-      return this.renderSubExpr(x.xpr);
+        return `(${this.renderSubExpr(x.xpr, xprEnv)})`;
+      return this.renderSubExpr(x.xpr, xprEnv);
     },
     SELECT(x) {
-      return `(${renderQuery(x, false, increaseIndent(this.env))})`;
+      return `(${renderQuery(x, false, this.env.withIncreasedIndent())})`;
     },
     SET(x) {
-      return `${renderQuery(x, false, increaseIndent(this.env))}`;
+      return `${renderQuery(x, false, this.env.withIncreasedIndent())}`;
     },
-  });
+  }, true);
 
   function renderExpr( x, env ) {
     return exprRenderer.renderExpr(x, env);
@@ -118,7 +157,7 @@ function toHdbcdsSource( csn, options ) {
     // This environment is passed down the call hierarchy, for dealing with
     // indentation and name resolution issues
     const env = createEnv();
-    const sourceStr = renderArtifact(artifactName, art, env); // Must come first because it populates 'env.topLevelAliases'
+    const sourceStr = renderDefinition(artifactName, art, env); // Must come first because it populates 'env.topLevelAliases'
     if (sourceStr !== '') {
       const name = plainNames ? artifactName.replace(/\./g, '_').toUpperCase() : artifactName;
       hdbcds[name] = [
@@ -138,7 +177,7 @@ function toHdbcdsSource( csn, options ) {
       Object.entries(art.$tableConstraints.referential)
         .forEach(([ fileName, referentialConstraint ]) => {
           referentialConstraints[fileName] = renderReferentialConstraint(
-            referentialConstraint, increaseIndent(createEnv()).indent, false, csn, options
+            referentialConstraint, createEnv().withIncreasedIndent().indent, false, csn, options
           );
         });
       Object.entries(referentialConstraints)
@@ -175,14 +214,14 @@ function toHdbcdsSource( csn, options ) {
   }
 
   /**
-   * Render an artifact. Return the resulting source string.
+   * Render a definition. Return the resulting source string.
    *
    * @param {string} artifactName Name of the artifact to render
    * @param {CSN.Artifact} art Content of the artifact to render
-   * @param {CdlRenderEnvironment} env Environment
+   * @param {HdbcdsRenderEnvironment} env Environment
    * @returns {string} The rendered artifact
    */
-  function renderArtifact( artifactName, art, env ) {
+  function renderDefinition( artifactName, art, env ) {
     // We're always a top-level artifact.
     env.path = [ 'definitions', artifactName ];
     // Ignore whole artifacts if toHana says so
@@ -203,7 +242,7 @@ function toHdbcdsSource( csn, options ) {
 
       case 'context':
       case 'service':
-        return renderContext(artifactName, art, env);
+        return renderContext(artifactName, art, env, false);
       case 'namespace':
         return renderNamespace(artifactName, art, env);
       case 'type':
@@ -322,7 +361,8 @@ function toHdbcdsSource( csn, options ) {
    *
    * @param {string} artifactName Name of the context/service
    * @param {CSN.Artifact} art Content of the context/service
-   * @param {CdlRenderEnvironment} env Environment
+   * @param {HdbcdsRenderEnvironment} env Environment
+   * @param {boolean} isShadowed
    * @returns {string} The rendered context/service
    */
   function renderContext( artifactName, art, env, isShadowed ) {
@@ -332,24 +372,25 @@ function toHdbcdsSource( csn, options ) {
     if (isShadowed) {
       const subArtifacts = getSubArtifacts(artifactName);
       for (const name in subArtifacts)
-        result += renderArtifact(`${artifactName}.${name}`, subArtifacts[name], env);
+        result += renderDefinition(`${artifactName}.${name}`, subArtifacts[name], env);
 
       return `${result}\n`;
     }
 
-    const childEnv = increaseIndent(env);
+    const childEnv = env.withIncreasedIndent();
     result += `${env.indent}context ${renderArtifactName(artifactName, env, true)}`;
     result += ' {\n';
     const subArtifacts = getSubArtifacts(artifactName);
     let renderedSubArtifacts = '';
     for (const name in subArtifacts)
-      renderedSubArtifacts += renderArtifact(`${artifactName}.${name}`, subArtifacts[name], updatePrefixForDottedName(childEnv, name));
+      renderedSubArtifacts += renderDefinition(`${artifactName}.${name}`, subArtifacts[name], updatePrefixForDottedName(childEnv, name));
 
     if (renderedSubArtifacts === '')
       return '';
 
     return `${result + renderedSubArtifacts + env.indent}};\n`;
   }
+
   /**
    * Check whether the given context is shadowed, i.e. part of his name prefix is shared by a
    *  non-context/service/namespace definition
@@ -375,9 +416,9 @@ function toHdbcdsSource( csn, options ) {
    * In case of an artifact with . in the name (that are not a namespace/context part),
    * we need to update the env to correctly render the artifact name.
    *
-   * @param {CdlRenderEnvironment} env Environment
+   * @param {HdbcdsRenderEnvironment} env Environment
    * @param {string} name Possibly dotted artifact name
-   * @returns {CdlRenderEnvironment} Updated env or original instance
+   * @returns {HdbcdsRenderEnvironment} Updated env or original instance
    */
   function updatePrefixForDottedName( env, name ) {
     if (plainNames) {
@@ -398,7 +439,7 @@ function toHdbcdsSource( csn, options ) {
    *
    * @param {string} artifactName Name of the namespace
    * @param {CSN.Artifact} art Content of the namespace
-   * @param {CdlRenderEnvironment} env Environment
+   * @param {HdbcdsRenderEnvironment} env Environment
    * @returns {string} The rendered children of the namespace
    */
   function renderNamespace( artifactName, art, env ) {
@@ -408,22 +449,22 @@ function toHdbcdsSource( csn, options ) {
     const childEnv = addNamePrefix(env, getLastPartOf(artifactName));
     const subArtifacts = getSubArtifacts(artifactName);
     for (const name in subArtifacts)
-      result += renderArtifact(`${artifactName}.${name}`, subArtifacts[name], updatePrefixForDottedName(childEnv, name));
+      result += renderDefinition(`${artifactName}.${name}`, subArtifacts[name], updatePrefixForDottedName(childEnv, name));
 
     return result;
   }
 
   /**
-   * Render a (non-projection, non-view) entity. Return the resulting source string.
+   * Render a non-query entity. Return the resulting source string.
    *
    * @param {string} artifactName Name of the entity
    * @param {CSN.Artifact} art Content of the entity
-   * @param {CdlRenderEnvironment} env Environment
+   * @param {HdbcdsRenderEnvironment} env Environment
    * @returns {string} The rendered entity
    */
   function renderEntity( artifactName, art, env ) {
     let result = '';
-    const childEnv = increaseIndent(env);
+    const childEnv = env.withIncreasedIndent();
     const normalizedArtifactName = renderArtifactName(artifactName, env);
 
     globalDuplicateChecker.addArtifact(art['@cds.persistence.name'], env.path, artifactName);
@@ -440,17 +481,16 @@ function toHdbcdsSource( csn, options ) {
     result += `${env.indent + (art.abstract ? 'abstract ' : '')}entity ${normalizedArtifactName}`;
     if (art.includes) {
       // Includes are never flattened (don't exist in HANA)
-      result += ` : ${art.includes.map(name => renderAbsoluteNameWithQuotes(name, env)).join(', ')}`;
+      result += ` : ${art.includes.map((name, i) => renderAbsoluteNameWithQuotes(name, env.withSubPath([ 'includes', i ]))).join(', ')}`;
     }
     result += ' {\n';
     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);
+      result += renderElement(name, art.elements[name], childEnv.withSubPath([ 'elements', name ]), duplicateChecker);
 
     duplicateChecker.check(error);
     result += `${env.indent}}`;
@@ -464,11 +504,11 @@ function toHdbcdsSource( csn, options ) {
 
   /**
    * 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
+   * we must render a "using target as __target" and use the alias to refer to the target
    *
    * @param {string} artName
    * @param {CSN.Artifact} art
-   * @param {CdlRenderEnvironment} env
+   * @param {HdbcdsRenderEnvironment} env
    */
   function createTopLevelAliasesForArtifact( artName, art, env ) {
     forEachMember(art, (element) => {
@@ -492,22 +532,21 @@ function toHdbcdsSource( csn, options ) {
    * Render the 'technical configuration { ... }' section 'tc' of an entity.
    *
    * @param {object} tc content of the technical configuration
-   * @param {CdlRenderEnvironment} env Environment
+   * @param {HdbcdsRenderEnvironment} env Environment
    * @returns {string} Return the resulting source string.
    */
   function renderTechnicalConfiguration( tc, env ) {
-    let result = '';
-    const childEnv = increaseIndent(env);
-
     if (!tc)
-      return result;
+      return '';
 
+    let result = '';
+    const childEnv = env.withIncreasedIndent();
 
     // FIXME: How to deal with non-HANA technical configurations? We should probably just iterate all entries
     // 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 ModelError('Expecting a HANA technical configuration');
+      throw new ModelError('Expecting a SAP HANA technical configuration');
 
     result += `\n${env.indent}technical ${tc.calculated ? '' : 'hana '}configuration {\n`;
 
@@ -580,7 +619,7 @@ function toHdbcdsSource( csn, options ) {
    *
    * @param {string} elementName Name of the element
    * @param {CSN.Element} elm Content of the element
-   * @param {CdlRenderEnvironment} env Environment
+   * @param {HdbcdsRenderEnvironment} env Environment
    * @param {DuplicateChecker} [duplicateChecker] Utility for detecting duplicates
    * @param {boolean} [isSubElement] Whether the given element is a subelement or not - subelements cannot be key!
    * @returns {string} The rendered element
@@ -603,10 +642,14 @@ function toHdbcdsSource( csn, options ) {
     result += env.indent + (elm.key && !isSubElement ? 'key ' : '') +
       (elm.masked ? 'masked ' : '') +
       quotedElementName + (omitColon ? ' ' : ' : ') +
-      renderTypeReference(elm, env) +
-      renderNullability(elm);
-    if (elm.default)
-      result += ` default ${renderExpr(elm.default, env)}`;
+      renderTypeReference(elm, env);
+    // GENERATED AS ALWAYS() can't have a trailing "[not] null" nor "default".
+    // Because we already emit an error that calc-on-write is not supported, just ignore nullability/default.
+    if (!elm.value?.stored) {
+      result += renderNullability(elm);
+      if (elm.default)
+        result += ` default ${renderExpr(elm.default, env.withSubPath([ 'default' ]))}`;
+    }
 
     // (table) elements can only have a @sql.append
     const { back } = getSqlSnippets(options, elm);
@@ -623,13 +666,13 @@ function toHdbcdsSource( csn, options ) {
    * Returns the source as a string.
    *
    * @param {object} source Source to render
-   * @param {CdlRenderEnvironment} env Environment
+   * @param {HdbcdsRenderEnvironment} env Environment
    * @returns {string} Rendered view source
    */
   function renderViewSource( source, env ) {
     // Sub-SELECT
     if (source.SELECT || source.SET) {
-      let result = `(${renderQuery(source, false, increaseIndent(env))})`;
+      let result = `(${renderQuery(source, false, env.withIncreasedIndent())})`;
       if (source.as)
         result += ` as ${formatIdentifier(source.as)}`;
       return result;
@@ -637,12 +680,12 @@ function toHdbcdsSource( csn, options ) {
     // JOIN
     else if (source.join) {
       // One join operation, possibly with ON-condition
-      let result = `${renderViewSource(source.args[0], env)}`;
+      let result = `${renderViewSource(source.args[0], env.withSubPath([ 'args', 0 ]))}`;
       for (let i = 1; i < source.args.length; i++) {
         result = `(${result} ${source.join} `;
-        result += `join ${renderViewSource(source.args[i], env)}`;
+        result += `join ${renderViewSource(source.args[i], env.withSubPath([ 'args', i ]))}`;
         if (source.on)
-          result += ` on ${renderExpr(source.on, env)}`;
+          result += ` on ${renderExpr(source.on, env.withSubPath([ 'on' ]))}`;
 
         result += ')';
       }
@@ -659,7 +702,7 @@ function toHdbcdsSource( csn, options ) {
    * Returns the name as a string.
    *
    * @param {object} path Path to render
-   * @param {CdlRenderEnvironment} env Environment
+   * @param {HdbcdsRenderEnvironment} env Environment
    * @returns {string} Rendered path
    */
   function renderAbsolutePath( path, env ) {
@@ -680,11 +723,11 @@ 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], ':', env)})`;
+      result += `(${renderArgs(path.ref[0], ':', env.withSubPath([ 'ref', 0 ]))})`;
 
     if (path.ref[0].where) {
       const cardinality = path.ref[0].cardinality ? (`${path.ref[0].cardinality.max}: `) : '';
-      result += `[${cardinality}${renderExpr(path.ref[0].where, env)}]`;
+      result += `[${cardinality}${renderExpr(path.ref[0].where, env.withSubPath([ 'ref', 0, 'where' ]))}]`;
     }
 
     // Add any path steps (possibly with parameters and filters) that may follow after that
@@ -702,7 +745,7 @@ function toHdbcdsSource( csn, options ) {
    * Returns the name and alias as a string.
    *
    * @param {object} path Path to render
-   * @param {CdlRenderEnvironment} env Environment
+   * @param {HdbcdsRenderEnvironment} env Environment
    * @returns {string} Rendered path including alias
    */
   function renderAbsolutePathWithAlias( path, env ) {
@@ -727,37 +770,33 @@ function toHdbcdsSource( csn, options ) {
    *
    * @param {object} col Column to render
    * @param {CSN.Elements} elements where column exists
-   * @param {CdlRenderEnvironment} env Environment
+   * @param {HdbcdsRenderEnvironment} env Environment
    * @returns {string} Rendered column
    */
   function renderViewColumn( col, elements, env ) {
-    // Annotations and column
-    let result = '';
-
     const leaf = col.as || col.ref && col.ref[col.ref.length - 1] || col.func;
     const element = elements[leaf];
 
     // Render 'null as <alias>' only for database and if element is virtual
-    if (element && element.virtual) {
+    if (element?.virtual) {
       if (isDeprecatedEnabled(options, '_renderVirtualElements'))
-        return `${result}${env.indent}null as ${formatIdentifier(leaf)}`;
-    }
-    else {
-      return renderNonVirtualColumn();
+        return `${env.indent}null as ${formatIdentifier(leaf)}`;
+      return '';
     }
 
-    return result;
+    return renderNonVirtualColumn();
+
 
     function renderNonVirtualColumn() {
-      result += env.indent;
+      let result = env.indent;
       // only if column is virtual, keyword virtual was present in the source text
       if (col.virtual)
         result += 'virtual ';
       // If key is explicitly set in a non-leading query, issue an error.
       if (col.key && env.skipKeys)
-        error(null, env.path, { tokensymbol: 'key', $reviewed: true }, 'Unexpected $(TOKENSYMBOL) in subquery');
+        error(null, env.path, { keyword: 'key', $reviewed: true }, 'Unexpected $(KEYWORD) in subquery');
 
-      const key = (!env.skipKeys && (col.key || (element && element.key)) ? 'key ' : '');
+      const key = (!env.skipKeys && (col.key || element?.key) ? 'key ' : '');
       result += key + renderExpr(withoutCast(col), env);
       let alias = col.as || col.func;
       // HANA requires an alias for 'key' columns just for syntactical reasons
@@ -771,12 +810,12 @@ function toHdbcdsSource( csn, options ) {
         result += ` as ${formatIdentifier(alias)}`;
 
       // Explicit type provided for the view element?
-      if (col.cast && col.cast.target) {
+      if (col.cast?.target) {
         // Special case: Explicit association type is actually a redirect
         // Redirections are never flattened (don't exist in HANA)
-        result += ` : redirected to ${renderAbsoluteNameWithQuotes(col.cast.target, env)}`;
+        result += ` : redirected to ${renderAbsoluteNameWithQuotes(col.cast.target, env.withSubPath([ 'cast', 'target' ]))}`;
         if (col.cast.on)
-          result += ` on ${renderExpr(col.cast.on, env)}`;
+          result += ` on ${renderExpr(col.cast.on, env.withSubPath([ 'cast', 'on' ]))}`;
       }
 
       return result;
@@ -790,7 +829,7 @@ function toHdbcdsSource( csn, options ) {
    *
    * @param {string} artifactName Name of the artifact
    * @param {CSN.Artifact} art Content of the artifact
-   * @param {CdlRenderEnvironment} env Environment
+   * @param {HdbcdsRenderEnvironment} env Environment
    * @returns {string} The rendered view
    */
   function renderView( artifactName, art, env ) {
@@ -803,16 +842,18 @@ function toHdbcdsSource( csn, options ) {
 
     result += `${env.indent}${art.abstract ? 'abstract ' : ''}view ${renderArtifactName(artifactName, env)}`;
     if (art.params) {
-      const childEnv = increaseIndent(env);
-      const parameters = Object.keys(art.params).map(name => renderParameter(name, art.params[name], childEnv)).join(',\n');
-      // HANA only understands the 'with parameters' syntax'
+      const childEnv = env.withIncreasedIndent();
+      const parameters = Object.keys(art.params)
+        .map(name => renderParameter(name, art.params[name], childEnv.withSubPath([ 'params', name ])))
+        .join(',\n');
+      // SAP HANA only understands the 'with parameters' syntax'
       result += ` with parameters\n${parameters}\n${env.indent}as `;
     }
     else {
       result += ' as ';
     }
     env._artifact = art;
-    result += renderQuery(getNormalizedQuery(art).query, true, env, artifactPath.concat(art.projection ? 'projection' : 'query'), art.elements);
+    result += renderQuery(getNormalizedQuery(art).query, true, env.withSubPath([ art.projection ? 'projection' : 'query' ]), art.elements);
 
     // views can only have a @sql.append
     const { back } = getSqlSnippets(options, art);
@@ -832,47 +873,52 @@ function toHdbcdsSource( csn, options ) {
    *
    * @param {CSN.Query} query Query object
    * @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 {HdbcdsRenderEnvironment} env Environment
    * @param {object} [elements] For leading query, the elements of the artifact
    * @returns {string} The rendered query
    */
-  function renderQuery( query, isLeadingQuery, env, path = [], elements = null ) {
+  function renderQuery( query, isLeadingQuery, env, elements = null ) {
+    const isProjection = env.path[env.path.length - 1] === 'projection';
     let result = '';
     env.skipKeys = !isLeadingQuery;
     // Set operator, like UNION, INTERSECT, ...
     if (query.SET) {
       // First arg may be leading query
-      result += `(${renderQuery(query.SET.args[0], isLeadingQuery, env, path.concat([ 'SET', 'args', 0 ]), elements || query.SET.elements)}`;
+      result += `(${renderQuery(query.SET.args[0], isLeadingQuery, env.withSubPath([ 'SET', 'args', 0 ]), elements || query.SET.elements)}`;
       // FIXME: Clarify if set operators can be n-ary (assuming binary here)
       if (query.SET.op) {
         // Loop over all other arguments, i.e. for A UNION B UNION C UNION D ...
         for (let i = 1; i < query.SET.args.length; i++)
-          result += `\n${env.indent}${query.SET.op}${query.SET.all ? ' all' : ''} ${renderQuery(query.SET.args[i], false, env, path.concat([ 'SET', 'args', i ]), elements || query.SET.elements)}`;
+          result += `\n${env.indent}${query.SET.op}${query.SET.all ? ' all' : ''} ${renderQuery(query.SET.args[i], false, env.withSubPath([ 'SET', 'args', i ]), elements || query.SET.elements)}`;
       }
       result += ')';
       // Set operation may also have an ORDER BY and LIMIT/OFFSET (in contrast to the ones belonging to
       // each SELECT)
       if (query.SET.orderBy)
-        result += `${continueIndent(result, env)}order by ${query.SET.orderBy.map(entry => renderOrderByEntry(entry, env)).join(', ')}`;
+        result += `${continueIndent(result, env)}order by ${query.SET.orderBy.map((entry, i) => renderOrderByEntry(entry, env.withSubPath([ 'SET', 'orderBy', i ]))).join(', ')}`;
 
       if (query.SET.limit)
-        result += `${continueIndent(result, env)}${renderLimit(query.SET.limit, env)}`;
+        result += `${continueIndent(result, env)}${renderLimit(query.SET.limit, env.withSubPath([ 'SET', 'limit' ]))}`;
 
       return result;
     }
     // Otherwise must have a SELECT
     else if (!query.SELECT) {
-      throw new ModelError(`Unexpected query operation ${JSON.stringify(query)}`);
+      throw new ModelError(`Unexpected query operation ${JSON.stringify(query)} at ${JSON.stringify(env.path)}`);
     }
+
+    if (!isProjection)
+      env = env.withSubPath([ 'SELECT' ]);
+
     const select = query.SELECT;
-    const childEnv = increaseIndent(env);
+    result += `select from ${renderViewSource(select.from, env.withSubPath([ 'from' ]))}`;
+
+    const childEnv = env.withIncreasedIndent();
     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)
-        elems += renderElement(name, select.mixin[name], childEnv);
+        elems += renderElement(name, select.mixin[name], childEnv.withSubPath([ 'mixin', name ]));
 
       if (elems) {
         result += ' mixin {\n';
@@ -883,10 +929,11 @@ function toHdbcdsSource( csn, options ) {
     result += select.distinct ? ' distinct' : '';
     if (select.columns) {
       result += ' {\n';
-      result += `${select.columns.map(col => renderViewColumn(col, elements || select.elements, childEnv))
+      result += select.columns
+        .map((col, i) => renderViewColumn(col, elements || select.elements, childEnv.withSubPath([ 'columns', i ])))
         .filter(s => s !== '')
-        .join(',\n')}\n`;
-      result += `${env.indent}}`;
+        .join(',\n');
+      result += `\n${env.indent}}`;
     }
     if (select.excluding) {
       const excludingList = select.excluding.map(id => `${childEnv.indent}${formatIdentifier(id)}`).join(',\n');
@@ -902,24 +949,24 @@ function toHdbcdsSource( csn, options ) {
    *
    * @param {CSN.QuerySelect} select
    * @param {string} alreadyRendered The query as it has been rendered so far
-   * @param {CdlRenderEnvironment} env Environment
+   * @param {HdbcdsRenderEnvironment} 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)}`;
+      alreadyRendered += `${continueIndent(alreadyRendered, env)}where ${renderExpr(select.where, env.withSubPath([ 'where' ]))}`;
 
     if (select.groupBy)
-      alreadyRendered += `${continueIndent(alreadyRendered, env)}group by ${select.groupBy.map(expr => renderExpr(expr, env)).join(', ')}`;
+      alreadyRendered += `${continueIndent(alreadyRendered, env)}group by ${select.groupBy.map((expr, i) => renderExpr(expr, env.withSubPath([ 'groupBy', i ]))).join(', ')}`;
 
     if (select.having)
-      alreadyRendered += `${continueIndent(alreadyRendered, env)}having ${renderExpr(select.having, env)}`;
+      alreadyRendered += `${continueIndent(alreadyRendered, env)}having ${renderExpr(select.having, env.withSubPath([ 'having' ]))}`;
 
     if (select.orderBy)
-      alreadyRendered += `${continueIndent(alreadyRendered, env)}order by ${select.orderBy.map(entry => renderOrderByEntry(entry, env)).join(', ')}`;
+      alreadyRendered += `${continueIndent(alreadyRendered, env)}order by ${select.orderBy.map((entry, i) => renderOrderByEntry(entry, env.withSubPath([ 'orderBy', i ]))).join(', ')}`;
 
     if (select.limit)
-      alreadyRendered += `${continueIndent(alreadyRendered, env)}${renderLimit(select.limit, env)}`;
+      alreadyRendered += `${continueIndent(alreadyRendered, env)}${renderLimit(select.limit, env.withSubPath([ 'limit' ]))}`;
 
     return alreadyRendered;
   }
@@ -928,7 +975,7 @@ function toHdbcdsSource( csn, options ) {
    * 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
+   * @param {HdbcdsRenderEnvironment} env Environment
    * @returns {string} String to join with
    */
   function continueIndent( result, env ) {
@@ -937,24 +984,24 @@ function toHdbcdsSource( csn, options ) {
       return ' ';
     }
     // Otherwise, start new line and indent normally
-    return `\n${increaseIndent(env).indent}`;
+    return `\n${env.withIncreasedIndent().indent}`;
   }
 
   /**
-   * Render a query's LIMIT clause, which may have also have OFFSET.
+   * Render a query's LIMIT clause, which may also have OFFSET.
    *
    * @param {CSN.QueryLimit} limit CSN limit clause
-   * @param {CdlRenderEnvironment} env Environment
+   * @param {HdbcdsRenderEnvironment} env Environment
    * @returns {string} Rendered limit clause
    */
   function renderLimit( limit, env ) {
     let result = '';
     if (limit.rows !== undefined)
-      result += `limit ${renderExpr(limit.rows, env)}`;
+      result += `limit ${renderExpr(limit.rows, env.withSubPath([ 'rows' ]))}`;
 
     if (limit.offset !== undefined) {
-      const indent = result !== '' ? `\n${increaseIndent(env).indent}` : '';
-      result += `${indent}offset ${renderExpr(limit.offset, env)}`;
+      const indent = result !== '' ? `\n${env.withIncreasedIndent().indent}` : '';
+      result += `${indent}offset ${renderExpr(limit.offset, env.withSubPath([ 'offset' ]))}`;
     }
 
     return result;
@@ -965,7 +1012,7 @@ function toHdbcdsSource( csn, options ) {
    * have a 'sort' property for ASC/DESC and a 'nulls' for FIRST/LAST
    *
    * @param {object} entry CSN order by
-   * @param {CdlRenderEnvironment} env Environment
+   * @param {HdbcdsRenderEnvironment} env Environment
    * @returns {string} Rendered order by
    */
   function renderOrderByEntry( entry, env ) {
@@ -984,13 +1031,13 @@ function toHdbcdsSource( csn, options ) {
    *
    * @param {string} parName Name of the parameter
    * @param {object} par CSN parameter
-   * @param {CdlRenderEnvironment} env Environment
+   * @param {HdbcdsRenderEnvironment} env Environment
    * @returns {string} The resulting parameter as source string (no trailing LF).
    */
   function renderParameter( parName, par, env ) {
     if (par.notNull === true || par.notNull === false)
-      info('query-ignoring-param-nullability', env.path.concat([ 'params', parName ]), { '#': 'std' });
-    return `${env.indent + formatParamIdentifier(parName, env.path.concat([ 'params', parName ]))} : ${renderTypeReference(par, env)}`;
+      info('query-ignoring-param-nullability', env.path, { '#': 'std' });
+    return `${env.indent + formatParamIdentifier(parName, env.path)} : ${renderTypeReference(par, env)}`;
   }
 
   /**
@@ -999,7 +1046,7 @@ function toHdbcdsSource( csn, options ) {
    *
    * @param {string} artifactName Name of the artifact
    * @param {CSN.Artifact} art Content of the artifact
-   * @param {CdlRenderEnvironment} env Environment
+   * @param {HdbcdsRenderEnvironment} env Environment
    * @returns {string} Rendered type/annotation
    */
   function renderType( artifactName, art, env ) {
@@ -1011,12 +1058,12 @@ function toHdbcdsSource( csn, options ) {
       // Includes are never flattened (don't exist in HANA)
       result += ` : ${art.includes.map(name => renderAbsoluteNameWithQuotes(name, env)).join(', ')}`;
     }
-    const childEnv = increaseIndent(env);
     if (art.elements && !art.type) {
+      const childEnv = env.withIncreasedIndent();
       // Structured type or annotation with anonymous struct type
       result += ' {\n';
       for (const name in art.elements)
-        result += renderElement(name, art.elements[name], childEnv);
+        result += renderElement(name, art.elements[name], childEnv.withSubPath([ 'elements', name ]));
 
       result += `${env.indent}};\n`;
     }
@@ -1032,7 +1079,7 @@ function toHdbcdsSource( csn, options ) {
    * Allow suppressing enum-rendering - used in columns for example
    *
    * @param {object} elm Element using the type reference
-   * @param {CdlRenderEnvironment} env Environment
+   * @param {HdbcdsRenderEnvironment} env Environment
    * @returns {string} Rendered type reference
    */
   function renderTypeReference( elm, env ) {
@@ -1041,7 +1088,7 @@ function toHdbcdsSource( csn, options ) {
     // Array type: Render items instead
     if (elm.items && !elm.type) {
       // HANA CDS does not support keyword many
-      let rc = `array of ${renderTypeReference(elm.items, env)}`;
+      let rc = `array of ${renderTypeReference(elm.items, env.withSubPath([ 'items' ]))}`;
       if (elm.items.notNull != null)
         rc += elm.items.notNull ? ' not null' : ' null';
       return rc;
@@ -1056,11 +1103,11 @@ function toHdbcdsSource( csn, options ) {
         throw new ModelError(`Missing type of: ${JSON.stringify(elm)}`);
 
       result += '{\n';
-      const childEnv = increaseIndent(env);
+      const childEnv = env.withIncreasedIndent();
       // omit "key" keyword for nested elements, as this will result in a deployment error in naming mode 'hdbcds'
       const dontRenderKeyForNestedElement = hdbcdsNames;
       for (const name in elm.elements)
-        result += renderElement(name, elm.elements[name], childEnv, null, dontRenderKeyForNestedElement);
+        result += renderElement(name, elm.elements[name], childEnv.withSubPath([ 'elements', name ]), null, dontRenderKeyForNestedElement);
 
       result += `${env.indent}}`;
       return result;
@@ -1070,11 +1117,10 @@ function toHdbcdsSource( csn, options ) {
     if ([ 'cds.Association', 'cds.Composition' ].includes(elm.type))
       return result + renderAssociationType(elm, env);
 
-
     if (elm.type?.ref) {
       // Reference to another element
       // For HANA CDS, we need a 'type of'
-      result += `type of ${renderAbsolutePath(elm.type, env)}`;
+      result += `type of ${renderAbsolutePath(elm.type, env.withSubPath([ 'type' ]))}`;
     }
     else if (isBuiltinType(elm.type)) {
       // If we get here, it must be a named type
@@ -1083,14 +1129,14 @@ function toHdbcdsSource( csn, options ) {
     else {
       // Simple absolute name
       // Type names are never flattened (derived types are unraveled in HANA)
-      result += renderAbsoluteNameWithQuotes(elm.type, env);
+      result += renderAbsoluteNameWithQuotes(elm.type, env.withSubPath([ 'type' ]));
     }
 
     if (elm.value) {
       if (!elm.value.stored)
         throw new CompilerAssertion('Found calculated element on-read in rendering; should have been replaced!');
       message('def-unsupported-calc-elem', env.path, { '#': 'hdbcds' });
-      result += ` GENERATED ALWAYS AS ${renderExpr(elm.value)}`;
+      result += ` GENERATED ALWAYS AS ${renderExpr(elm.value, env.withSubPath([ 'value' ]))}`;
       return result;
     }
 
@@ -1099,7 +1145,7 @@ function toHdbcdsSource( csn, options ) {
 
   /**
    * @param {CSN.Element} elm
-   * @param {CdlRenderEnvironment} env
+   * @param {HdbcdsRenderEnvironment} env
    * @returns {string}
    */
   function renderAssociationType( elm, env ) {
@@ -1108,7 +1154,6 @@ function toHdbcdsSource( csn, options ) {
 
     result += `${renderCardinality(elm.cardinality)} to `;
 
-
     // normal target or named aspect
     if (elm.target || elm.targetAspect && typeof elm.targetAspect === 'string') {
       // we might have a "using target as __target"
@@ -1118,28 +1163,28 @@ function toHdbcdsSource( csn, options ) {
         result += targetAlias.quotedAlias;
       }
       else {
-        result += plainNames ? renderAbsoluteNamePlain(elm.target || elm.targetAspect, env)
-          : renderAbsoluteNameWithQuotes(elm.target || elm.targetAspect, env);
+        const target = elm.target || elm.targetAspect;
+        const childEnv = env.withSubPath([ elm.target ? 'target' : 'targetAspect' ]);
+        result += plainNames ? renderAbsoluteNamePlain(target, childEnv) : renderAbsoluteNameWithQuotes(target, childEnv);
       }
     }
 
     // ON-condition (if any)
     if (elm.on) {
-      result += ` on ${renderExpr(elm.on, env)}`;
+      result += ` on ${renderExpr(elm.on, env.withSubPath([ 'on' ]))}`;
     }
-    else if (elm.targetAspect && elm.targetAspect.elements) { // anonymous aspect
-      const childEnv = increaseIndent(env);
+    else if (elm.targetAspect?.elements) { // anonymous aspect
+      const childEnv = env.withIncreasedIndent();
       result += '{\n';
       for (const name in elm.targetAspect.elements)
-        result += renderElement(name, elm.targetAspect.elements[name], childEnv);
+        result += renderElement(name, elm.targetAspect.elements[name], childEnv.withSubPath([ 'targetAspect', 'elements', name ]));
 
       result += `${env.indent}}`;
     }
 
-
     // 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(', ')} }`;
+      result += ` { ${Object.keys(elm.keys).map(name => renderForeignKey(elm.keys[name], env.withSubPath([ 'keys', name ]))).join(', ')} }`;
 
     return result;
   }
@@ -1164,6 +1209,8 @@ function toHdbcdsSource( csn, options ) {
    *
    * @param {string|object} s Path step
    * @param {number} idx Path position
+   * @param {any[]} ref
+   * @param {HdbcdsRenderEnvironment} env
    * @returns {string} Rendered path step
    */
   function renderPathStep( s, idx, ref, env ) {
@@ -1171,7 +1218,7 @@ function toHdbcdsSource( csn, options ) {
     if (typeof s === 'string') {
       // HANA-specific extra magic (should actually be in forRelationalDB)
       // In HANA, we replace leading $self by the absolute name of the current artifact
-      // (see FIXME at renderArtifact)
+      // (see FIXME at renderDefinition)
       if (idx === 0 && s === $SELF) {
         // do not produce USING for $projection
         if (env.currentArtifactName === $PROJECTION)
@@ -1218,12 +1265,12 @@ function toHdbcdsSource( csn, options ) {
       if (s.where) {
         // Filter, possibly with cardinality
         const cardinality = s.cardinality ? `${s.cardinality.max}: ` : '';
-        result += `[${cardinality}${renderExpr(s.where, env)}]`;
+        result += `[${cardinality}${renderExpr(s.where, env.withSubPath([ 'where' ]))}]`;
       }
       return result;
     }
 
-    throw new ModelError(`Unknown path step: ${JSON.stringify(s)}`);
+    throw new ModelError(`Unknown path step: ${JSON.stringify(s)} at ${JSON.stringify(env.path)}`);
   }
 
   /**
@@ -1265,7 +1312,7 @@ function toHdbcdsSource( csn, options ) {
     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, { id: uppercaseAndUnderscore(funcName) }, 'The identifier $(ID) is a SAP HANA keyword');
+      warning(null, this.env.path, { id: uppercaseAndUnderscore(funcName) }, 'The identifier $(ID) is a SAP HANA keyword');
     return renderFunc(funcName, x, 'hana', a => renderArgs(a, '=>', this.env));
   }
 
@@ -1301,7 +1348,7 @@ function toHdbcdsSource( csn, options ) {
         return renderStringForHdbcds(magicReplacement);
       }
     }
-    return `${(x.param || x.global) ? ':' : ''}${x.ref.map((step, index) => renderPathStep(step, index, x.ref, this.env)).join('.')}`;
+    return `${(x.param || x.global) ? ':' : ''}${x.ref.map((step, index) => renderPathStep(step, index, x.ref, this.env.withSubPath([ 'ref', index ]))).join('.')}`;
   }
 
   /**
@@ -1310,19 +1357,22 @@ function toHdbcdsSource( csn, options ) {
    *
    * @param {object} node with `args` to render
    * @param {string} sep Separator between arguments
-   * @param {CdlRenderEnvironment} env Environment
+   * @param {HdbcdsRenderEnvironment} env Environment
    * @returns {string} Rendered arguments
    */
   function renderArgs( node, sep, env ) {
-    const args = node.args ? node.args : {};
+    const args = node.args || {};
     // Positional arguments
-    if (Array.isArray(args))
-      return args.map(arg => renderExpr(arg, env)).join(', ');
-
+    if (Array.isArray(args)) {
+      return args.map((arg, i) => renderExpr(arg, env.withSubPath([ 'args', i ]))).join(', ');
+    }
     // Named arguments (object/dict)
-    else if (typeof args === 'object')
+    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.withSubPath([ 'args', key ]))}`)
+        .join(', ');
+    }
 
 
     throw new ModelError(`Unknown args: ${JSON.stringify(args)}`);
@@ -1371,7 +1421,7 @@ function toHdbcdsSource( csn, options ) {
    * @todo Can this still happen after Hana transformation?
    *
    * @param {object} fKey Foreign key to render
-   * @param {CdlRenderEnvironment} env Environment
+   * @param {HdbcdsRenderEnvironment} env Environment
    * @returns {string} Rendered foreign key
    */
   function renderForeignKey( fKey, env ) {
@@ -1410,7 +1460,7 @@ function toHdbcdsSource( csn, options ) {
    * if necessary.
    *
    * @param {string} absName Absolute name
-   * @param {CdlRenderEnvironment} env Environment
+   * @param {HdbcdsRenderEnvironment} env Environment
    * @returns {string} Uppercased and underscored absName
    */
   function renderAbsoluteNamePlain( absName, env ) {
@@ -1428,7 +1478,7 @@ function toHdbcdsSource( csn, options ) {
    * if necessary.
    *
    * @param {string} absName absolute name
-   * @param {CdlRenderEnvironment} env Environment
+   * @param {HdbcdsRenderEnvironment} env Environment
    * @returns {string} absName, with correct quotes
    */
   function renderAbsoluteNameWithQuotes( absName, env ) {
@@ -1498,7 +1548,7 @@ function toHdbcdsSource( csn, options ) {
    * Render appropriate USING directives for all artifacts used by artifact 'artifactName' in 'env'.
    *
    * @param {string} artifactName Artifact to render usings for
-   * @param {CdlRenderEnvironment} env Environment
+   * @param {HdbcdsRenderEnvironment} env Environment
    * @returns {string} Usings for the given artifact
    */
   function renderUsings( artifactName, env ) {
@@ -1581,7 +1631,7 @@ function toHdbcdsSource( csn, options ) {
    * Return the namespace declaration (with trailing LF) or an empty string.
    *
    * @param {string} topLevelName Name of a top-level artifact
-   * @param {CdlRenderEnvironment} env Environment
+   * @param {HdbcdsRenderEnvironment} env Environment
    * @returns {string} Rendered namespace declaration
    */
   function renderNamespaceDeclaration( topLevelName, env ) {
@@ -1626,40 +1676,22 @@ function toHdbcdsSource( csn, options ) {
    * Returns a newly created default environment (which keeps track of indentation, required USING
    * declarations and name prefixes.
    *
-   * @returns {CdlRenderEnvironment} Fresh environment
+   * @param {object} [values]
+   * @returns {HdbcdsRenderEnvironment} Fresh environment
    */
-  function createEnv() {
-    return {
-      // Current indentation string
-      indent: '',
-      // Dictionary of aliases for used artifact names, each entry like 'name' : { quotedName, quotedAlias }
-      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: [],
-    };
+  function createEnv( values = {} ) {
+    return new HdbcdsRenderEnvironment(values);
   }
 
   /**
    * Returns a copy of 'env' with (quoted) name prefix 'id' and a dot appended to the current name prefix
    *
-   * @param {CdlRenderEnvironment} env Current environment
+   * @param {HdbcdsRenderEnvironment} env Current environment
    * @param {string} id Name prefix to add
-   * @returns {CdlRenderEnvironment} New environment with added prefix
+   * @returns {HdbcdsRenderEnvironment} New environment with added prefix
    */
   function addNamePrefix( env, id ) {
-    return Object.assign({}, env, { namePrefix: `${env.namePrefix + quoteId(id)}.` });
-  }
-
-  /**
-   * Returns a copy of 'env' with increased indentation - also resets the name prefix
-   *
-   * @param {CdlRenderEnvironment} env Current environment
-   * @returns {CdlRenderEnvironment} New environment with increased indent
-   */
-  function increaseIndent( env ) {
-    return Object.assign({}, env, { namePrefix: '', indent: `${env.indent}  ` });
+    return env.cloneWith({ namePrefix: `${env.namePrefix + quoteId(id)}.` });
   }
 
   /**
@@ -1772,7 +1804,7 @@ function toHdbcdsSource( csn, options ) {
    *
    *
    * @param {string} artifactName Artifact name to render
-   * @param {CdlRenderEnvironment} env Render environment
+   * @param {HdbcdsRenderEnvironment} env Render environment
    * @param {boolean} [fallthrough=false] For certain artifacts, plain-rendering is supposed to look like quoted/hdbcds
    * @returns {string} Artifact name ready for rendering
    */
@@ -1799,20 +1831,4 @@ function toHdbcdsSource( csn, options ) {
   }
 }
 
-/**
- * @typedef CdlRenderEnvironment Rendering environment used throughout the render process.
- *
- * @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}   [currentArtifactName] Name of the current artifact
- * @property {{[name: string]: {
-      quotedName: string,
-      quotedAlias: string
-    }}} [topLevelAliases] Dictionary of aliases for used artifact names
- *
- * @property {string} [namePrefix] Current name prefix (including trailing dot if not empty)
- * @property {boolean} [skipKeys] Skip rendering keys in subqueries
- * @property {CSN.Artifact} [_artifact] The original view artifact, used when rendering queries
- */
-
 module.exports = { toHdbcdsSource };