@sap/cds-compiler 3.9.4 → 4.0.0

package/lib/render/toSql.js

@@ -27,6 +27,27 @@ const { sortCsn } = require('../json/to-csn');
 const { manageConstraints } = require('./manageConstraints');
 const { ModelError, CompilerAssertion } = require('../base/error');
 
+class SqlRenderEnvironment {
+  indent = '';
+  path = null;
+  alterMode = false;
+  changeType = null;
+
+  constructor(values) {
+    Object.assign(this, values);
+  }
+
+  withIncreasedIndent() {
+    return new SqlRenderEnvironment({ ...this, indent: `  ${this.indent}` });
+  }
+  withSubPath(path) {
+    return new SqlRenderEnvironment({ ...this, path: [ ...this.path, ...path ] });
+  }
+  cloneWith(values) {
+    return Object.assign(new SqlRenderEnvironment(this), values);
+  }
+}
+
 
 /**
  * Render the CSN model 'model' to SQL DDL statements. One statement is created
@@ -93,14 +114,14 @@ function toSqlDdl( csn, options ) {
       return `CAST(${this.renderExpr(withoutCast(x))} AS ${typeRef})`;
     },
     val: renderExpressionLiteral,
-    enum(x) {
-      // TODO: better location; callers should set env.$path
+    enum() {
       // FIXME: We can't do enums yet because they are not resolved (and we don't bother finding their value by hand)
-      const loc = x.$location || this.env?._artifact?.$location;
-      error('expr-unexpected-enum', [ loc, null ], 'Enum values are not yet supported for conversion to SQL');
+      error('expr-unexpected-enum', this.env.path, 'Enum values are not yet supported for conversion to SQL');
       return '';
     },
-    ref: renderExpressionRef,
+    ref(x) {
+      return renderExpressionRef(x, this.env);
+    },
     aliasOnly: x => x.as,
     windowFunction( x) {
       return renderWindowFunction(smartFuncId(prepareIdentifier(x.func), options.sqlDialect), x, this.env);
@@ -109,17 +130,18 @@ function toSqlDdl( csn, options ) {
       return renderFunc(smartFuncId(prepareIdentifier(x.func), options.sqlDialect), x, options.sqlDialect, a => renderArgs(a, '=>', this.env, null));
     },
     xpr(x) {
+      const env = this.env.withSubPath([ 'xpr' ]);
       if (this.isNestedXpr && !x.cast)
-        return `(${this.renderSubExpr(x.xpr)})`;
-      return this.renderSubExpr(x.xpr);
+        return `(${this.renderSubExpr(x.xpr, env)})`;
+      return this.renderSubExpr(x.xpr, env);
     },
     SELECT( x) {
-      return `(${renderQuery('<subselect>', x, increaseIndent(this.env))})`;
+      return `(${renderQuery(x, this.env.withIncreasedIndent())})`;
     },
     SET( x) {
-      return `(${renderQuery('<union>', x, increaseIndent(this.env))})`;
+      return `(${renderQuery(x, this.env.withIncreasedIndent())})`;
     },
-  });
+  }, true);
 
   function renderExpr( x, env ) {
     return exprRenderer.renderExpr(x, env);
@@ -137,7 +159,7 @@ function toSqlDdl( csn, options ) {
 
   // FIXME: Currently requires 'options.forHana', because it can only render HANA-ish SQL dialect
   if (!options.forHana && !isBetaEnabled(options, 'sqlExtensions'))
-    throw new CompilerAssertion('toSql can currently only be used with HANA preprocessing');
+    throw new CompilerAssertion('to.sql can currently only be used with SAP HANA preprocessing');
 
   checkCSNVersion(csn, options);
 
@@ -165,13 +187,7 @@ function toSqlDdl( csn, options ) {
 
   // Render each artifact on its own
   forEachDefinition((options && options.testMode) ? sortCsn(csn, options) : csn, (artifact, artifactName) => {
-    // This environment is passed down the call hierarchy, for dealing with
-    // indentation issues
-    const env = {
-      // Current indentation string
-      indent: '',
-    };
-    renderArtifactInto(artifactName, artifact, mainResultObj, env);
+    renderDefinitionInto(artifactName, artifact, mainResultObj, new SqlRenderEnvironment());
   });
 
   // Render each deleted artifact
@@ -179,27 +195,31 @@ function toSqlDdl( csn, options ) {
     renderArtifactDeletionInto(artifactName, csn.deletions[artifactName], mainResultObj);
 
   // Render each artifact extension
-  // Only HANA SQL is currently supported.
+  // Only SAP HANA SQL is currently supported.
   // Note that extensions may contain new elements referenced in migrations, thus should be compiled first.
   if (csn.extensions && (options.sqlDialect === 'hana' || isBetaEnabled(options, 'sqlExtensions'))) {
-    for (const extension of options && options.testMode ? sortCsn(csn.extensions) : csn.extensions) {
+    csn.extensions = options.testMode ? sortCsn(csn.extensions) : csn.extensions;
+    for (let i = 0; i < csn.extensions.length; ++i) {
+      const extension = csn.extensions[i];
       if (extension.extend) {
         const artifactName = extension.extend;
-        const _artifact = csn.definitions[artifactName];
-        const env = { indent: '', _artifact };
-        renderArtifactExtensionInto(artifactName, _artifact, extension, mainResultObj, env);
+        const artifact = csn.definitions[artifactName];
+        const env = new SqlRenderEnvironment({ path: [ 'extensions', i ] });
+        renderArtifactExtensionInto(artifactName, artifact, extension, mainResultObj, env);
       }
     }
   }
 
   // Render each artifact change
-  // Only HANA SQL is currently supported.
+  // Only SAP HANA SQL is currently supported.
   if (csn.migrations && (options.sqlDialect === 'hana' || isBetaEnabled(options, 'sqlExtensions'))) {
-    for (const migration of options && options.testMode ? sortCsn(csn.migrations) : csn.migrations) {
+    csn.migrations = options.testMode ? sortCsn(csn.migrations) : csn.migrations;
+    for (const migration of csn.migrations) {
       if (migration.migrate) {
         const artifactName = migration.migrate;
-        const _artifact = csn.definitions[artifactName];
-        const env = { indent: '', _artifact };
+        // There is no "migrations" property in client CSN, so for better locations, use
+        // a path to the definition.
+        const env = new SqlRenderEnvironment({ path: [ 'definitions', artifactName ] });
         renderArtifactMigrationInto(artifactName, migration, mainResultObj, env);
       }
     }
@@ -260,21 +280,22 @@ function toSqlDdl( csn, options ) {
   return mainResultObj;
 
   /**
-   * Render an artifact into the appropriate dictionary of 'resultObj'.
+   * Render a definition into the appropriate dictionary of 'resultObj'.
    *
    * @param {string} artifactName Name of the artifact to render
    * @param {CSN.Artifact} art Artifact to render
    * @param {object} resultObj Result collector
-   * @param {object} env Render environment
+   * @param {SqlRenderEnvironment} env Render environment
    */
-  function renderArtifactInto( artifactName, art, resultObj, env ) {
+  function renderDefinitionInto( artifactName, art, resultObj, env ) {
+    env.path = [ 'definitions', artifactName ];
     // Ignore whole artifacts if forRelationalDB says so
     if (art.abstract || hasValidSkipOrExists(art))
       return;
 
     switch (art.kind) {
       case 'entity':
-        if (getNormalizedQuery(art).query) {
+        if (art.query || art.projection) {
           const result = renderView(artifactName, art, env);
           if (result)
             resultObj.hdbview[artifactName] = result;
@@ -301,13 +322,13 @@ function toSqlDdl( csn, options ) {
 
   /**
    * Render an artifact extension into the appropriate dictionary of 'resultObj'.
-   * Only HANA SQL is currently supported.
+   * Only SAP HANA SQL is currently supported.
    *
    * @param {string} artifactName Name of the artifact to render
    * @param {CSN.Artifact} artifact The complete artifact
    * @param {CSN.Artifact} ext Extension to render
    * @param {object} resultObj Result collector
-   * @param {object} env Render environment
+   * @param {SqlRenderEnvironment} env Render environment
    */
   function renderArtifactExtensionInto( artifactName, artifact, ext, resultObj, env ) {
     // Property kind is always omitted for elements and can be omitted for
@@ -328,7 +349,7 @@ function toSqlDdl( csn, options ) {
   }
 
   // Render an artifact migration into the appropriate dictionary of 'resultObj'.
-  // Only HANA SQL is currently supported.
+  // Only SAP HANA SQL is currently supported.
   function renderArtifactMigrationInto( artifactName, migration, resultObj, env ) {
     function reducesTypeSize( def ) {
       // HANA does not allow decreasing the value of any of those type parameters.
@@ -338,7 +359,7 @@ function toSqlDdl( csn, options ) {
     function getEltStr( defVariant, eltName, changeType = 'extension' ) {
       return defVariant.target
         ? renderAssociationElement(eltName, defVariant, env)
-        : renderElement(artifactName, eltName, defVariant, null, null, activateAlterMode(env, changeType));
+        : renderElement(eltName, defVariant, null, null, activateAlterMode(env, changeType));
     }
     function getEltStrNoProps( defVariant, eltName, ...props ) {
       const defNoProps = Object.assign({}, defVariant);
@@ -467,16 +488,15 @@ function toSqlDdl( csn, options ) {
    * @param {string} artifactName Name of the artifact to render
    * @param {CSN.Artifact} art Artifact to render
    * @param {object} resultObj Result collector
-   * @param {object} env Render environment
+   * @param {SqlRenderEnvironment} env Render environment
    */
   function renderEntityInto( artifactName, art, resultObj, env ) {
-    env._artifact = art;
-    const childEnv = increaseIndent(env);
+    const childEnv = env.withIncreasedIndent();
     const hanaTc = art.technicalConfig && art.technicalConfig.hana;
     // tables can have @sql.prepend and @sql.append
     const { front, back } = getSqlSnippets(options, art);
     let result = front;
-    // Only HANA has row/column tables
+    // Only SAP HANA has row/column tables
     if (options.sqlDialect === 'hana') {
       if (hanaTc && hanaTc.storeType) {
         // Explicitly specified
@@ -491,9 +511,10 @@ function toSqlDdl( csn, options ) {
     definitionsDuplicateChecker.addArtifact(art['@cds.persistence.name'], art.$location, artifactName);
     result += `TABLE ${tableName}`;
     result += ' (\n';
-    const elements = Object.keys(art.elements).map(eltName => renderElement(artifactName, eltName, art.elements[eltName], definitionsDuplicateChecker, getFzIndex(eltName, hanaTc), childEnv)).filter(s => s !== '').join(',\n');
-    if (elements !== '')
-      result += elements;
+    result += Object.keys(art.elements)
+      .map(eltName => renderElement(eltName, art.elements[eltName], definitionsDuplicateChecker, getFzIndex(eltName, hanaTc), childEnv))
+      .filter(s => s !== '')
+      .join(',\n');
 
     const uniqueFields = Object.keys(art.elements).filter(name => art.elements[name].unique && !art.elements[name].virtual)
       .map(name => quoteSqlId(name))
@@ -507,7 +528,7 @@ function toSqlDdl( csn, options ) {
 
     // for `to.sql` w/ dialect `hana` the constraints will be part of the alter statement
     const constraintsAsAlter = !options.constraintsInCreateTable && options.src === 'sql' && (options.sqlDialect === 'hana' || options.sqlDialect === 'postgres');
-    if ( !constraintsAsAlter && art.$tableConstraints && art.$tableConstraints.referential) {
+    if (!constraintsAsAlter && art.$tableConstraints?.referential) {
       const renderReferentialConstraintsAsHdbconstraint = options.src === 'hdi';
       const referentialConstraints = {};
       forEach(art.$tableConstraints.referential, ( fileName, referentialConstraint ) => {
@@ -546,12 +567,15 @@ function toSqlDdl( csn, options ) {
       result += renderTechnicalConfiguration(art.technicalConfig, childEnv);
 
 
-    const associations = Object.keys(art.elements).map(name => renderAssociationElement(name, art.elements[name], childEnv))
-      .filter(s => s !== '')
-      .join(',\n');
-    if (associations !== '' && options.sqlDialect === 'hana') {
-      result += `${env.indent} WITH ASSOCIATIONS (\n${associations}\n`;
-      result += `${env.indent})`;
+    if (options.sqlDialect === 'hana') {
+      const associations = Object.keys(art.elements)
+        .map(name => renderAssociationElement(name, art.elements[name], childEnv))
+        .filter(s => s !== '')
+        .join(',\n');
+      if (associations !== '') {
+        result += `${env.indent} WITH ASSOCIATIONS (\n${associations}\n`;
+        result += `${env.indent})`;
+      }
     }
     // Only HANA has indices
     // FIXME: Really? We should provide a DB-agnostic way to specify that
@@ -570,13 +594,13 @@ function toSqlDdl( csn, options ) {
 
   /**
    * Render an extended entity into the appropriate dictionaries of 'resultObj'.
-   * Only HANA SQL is currently supported.
+   * Only SAP HANA SQL is currently supported.
    *
    * @param {string} artifactName Name of the artifact to render
    * @param {object} artifactElements Elements comprising the artifact
    * @param {object} extElements Elements comprising the extension
    * @param {object} resultObj Result collector
-   * @param {object} env Render environment
+   * @param {SqlRenderEnvironment} env Render environment
    * @param {DuplicateChecker} duplicateChecker
    */
   function renderExtendInto( artifactName, artifactElements, extElements, resultObj, env, duplicateChecker ) {
@@ -638,40 +662,37 @@ function toSqlDdl( csn, options ) {
    * projection or view), optionally with corresponding fuzzy index 'fzindex' from the
    * technical configuration.
    * Ignore association elements (those are rendered later by renderAssociationElement).
-   * Use 'artifactName' only for error output.
    * Return the resulting source string (no trailing LF).
    *
-   * @param {string} artifactName Name of the artifact containing the element
    * @param {string} elementName Name of the element to render
    * @param {CSN.Element} elm CSN element
    * @param {DuplicateChecker} duplicateChecker Utility for detecting duplicates
    * @param {object} fzindex Fzindex object for the element
-   * @param {object} env Render environment
+   * @param {SqlRenderEnvironment} env Render environment
    * @returns {string} Rendered element
    */
-  function renderElement( artifactName, elementName, elm, duplicateChecker, fzindex, env ) {
+  function renderElement( elementName, elm, duplicateChecker, fzindex, env ) {
     if (elm.virtual || elm.target)
       return '';
-
+    env = env.withSubPath([ 'elements', elementName ]);
     const isPostgresAlterColumn = env.alterMode && env.changeType === 'migration' && options.sqlDialect === 'postgres';
     const quotedElementName = quoteSqlId(elementName);
     if (duplicateChecker)
       duplicateChecker.addElement(quotedElementName, elm.$location, elementName);
 
-    let result = `${env.indent + quotedElementName}${isPostgresAlterColumn ? ' TYPE' : ''} ${renderTypeReference(artifactName, elementName, elm)
+    let result = `${env.indent + quotedElementName}${isPostgresAlterColumn ? ' TYPE' : ''} ${renderTypeReference(elm, env)
     }${renderNullability(elm, true, env.alterMode)}`;
-    if (elm.default)
-      result += ` DEFAULT ${renderExpr(elm.default, env)}`;
+    // calculated elements (on write) can't have a default; ignore it
+    if (elm.default && !elm.value)
+      result += ` DEFAULT ${renderExpr(elm.default, env.withSubPath([ 'default' ]))}`;
 
-    // Only HANA has fuzzy indices
+    // Only SAP HANA has fuzzy indices
     if (fzindex && options.sqlDialect === 'hana')
       result += ` ${renderExpr(fzindex, env)}`;
 
     // (table) elements can only have a @sql.append
     const { back } = getSqlSnippets(options, elm);
-
-    if (back !== '') // Needs to be rendered before the COMMENT
-      result += back;
+    result += back; // Needs to be rendered before the COMMENT
 
     if (options.sqlDialect === 'hana' && hasHanaComment(elm, options))
       result += ` COMMENT ${renderStringForSql(getHanaComment(elm), options.sqlDialect)}`;
@@ -690,10 +711,11 @@ function toSqlDdl( csn, options ) {
    * @todo Duplicate check
    * @param {string} elementName Name of the element to render
    * @param {CSN.Element} elm CSN element
-   * @param {object} env Render environment
+   * @param {SqlRenderEnvironment} env Render environment
    * @returns {string} Rendered association element
    */
   function renderAssociationElement( elementName, elm, env ) {
+    env = env.withSubPath([ 'elements', elementName ]);
     let result = '';
     if (elm.target) {
       result += env.indent;
@@ -713,7 +735,7 @@ function toSqlDdl( csn, options ) {
       }
       result += ' JOIN ';
       result += `${renderArtifactName(elm.target)} AS ${quoteSqlId(elementName)} ON (`;
-      result += `${renderExpr(elm.on, env)})`;
+      result += `${renderExpr(elm.on, env.withSubPath([ 'on' ]))})`;
     }
     return result;
   }
@@ -726,7 +748,7 @@ function toSqlDdl( csn, options ) {
    * Return the resulting source string.
    *
    * @param {object} tc Technical configuration
-   * @param {object} env Render environment
+   * @param {SqlRenderEnvironment} env Render environment
    * @returns {string} Rendered technical configuration
    */
   function renderTechnicalConfiguration( tc, env ) {
@@ -740,15 +762,15 @@ function toSqlDdl( csn, options ) {
     // This also affects renderIndexes
     tc = tc.hana;
     if (!tc)
-      throw new ModelError('Expecting a HANA technical configuration');
+      throw new ModelError('Expecting a SAP HANA technical configuration');
 
     if (tc.tableSuffix) {
       // Although we could just render the whole bandwurm as one stream of tokens, the
       // compactor has kindly stored each part (e.g. `migration enabled` `row store`, ...)
       // in its own `xpr` (for the benefit of the `toCdl` renderer, which needs semicolons
-      // between parts). We use this here for putting each one one line)
+      // between parts). We use this here for putting each one line)
 
-      // The ignore array contains technical configurations that are illegal in HANA SQL
+      // This array contains technical configurations that are illegal in HANA SQL
       const ignore = [
         'PARTITION BY KEEPING EXISTING LAYOUT',
         'ROW STORE',
@@ -771,7 +793,7 @@ function toSqlDdl( csn, options ) {
    * @param {object} indexes Indices to render
    * @param {string} artifactName Artifact to render indices for
    * @param {object} resultObj Result collector
-   * @param {object} env Render environment
+   * @param {SqlRenderEnvironment} env Render environment
    */
   function renderIndexesInto( indexes, artifactName, resultObj, env ) {
     // Indices and full-text indices
@@ -826,20 +848,19 @@ function toSqlDdl( csn, options ) {
 
   /**
    * Render the source of a query, which may be a path reference, possibly with an alias,
-   * or a subselect, or a join operation. Use 'artifactName' only for error output.
+   * or a sub-select, or a join operation.
    *
    * Returns the source as a string.
    *
    * @todo Misleading name, should be something like 'renderQueryFrom'. All the query parts should probably also be rearranged.
-   * @param {string} artifactName Name of the artifact containing the query
    * @param {object} source Query source
-   * @param {object} env Render environment
+   * @param {SqlRenderEnvironment} env Render environment
    * @returns {string} Rendered view source
    */
-  function renderViewSource( artifactName, source, env ) {
+  function renderViewSource( source, env ) {
     // Sub-SELECT
     if (source.SELECT || source.SET) {
-      let result = `(${renderQuery(artifactName, source, increaseIndent(env))})`;
+      let result = `(${renderQuery(source, env.withIncreasedIndent())})`;
       if (source.as)
         result += ` AS ${quoteSqlId(source.as)}`;
 
@@ -848,14 +869,14 @@ function toSqlDdl( csn, options ) {
     // JOIN
     else if (source.join) {
       // One join operation, possibly with ON-condition
-      let result = `${renderViewSource(artifactName, 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.toUpperCase()} `;
         if (options.sqlDialect === 'hana')
           result += renderJoinCardinality(source.cardinality);
-        result += `JOIN ${renderViewSource(artifactName, 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 += ')';
       }
@@ -867,7 +888,7 @@ function toSqlDdl( csn, options ) {
     if (!source.ref)
       throw new ModelError(`Expecting ref in ${JSON.stringify(source)}`);
 
-    return renderAbsolutePathWithAlias(artifactName, source, env);
+    return renderAbsolutePathWithAlias(source, env);
   }
 
   /**
@@ -896,19 +917,17 @@ function toSqlDdl( csn, options ) {
    * Render a path that starts with an absolute name (as used for the source of a query),
    * possibly with an alias, with plain or quoted names, depending on options. Expects an object 'path' that has a
    * 'ref' and (in case of an alias) an 'as'. If necessary, an artificial alias
-   * is created to the original implicit name.  Use 'artifactName' only for error output.
+   * is created to the original implicit name.
    * Returns the name and alias as a string.
    *
-   * @param {string} artifactName Name of the artifact containing the path - used for error output
    * @param {object} path Path to render
-   * @param {object} env Render environment
+   * @param {SqlRenderEnvironment} env Render environment
    * @returns {string} Rendered path
    */
-  function renderAbsolutePathWithAlias( artifactName, path, env ) {
+  function renderAbsolutePathWithAlias( path, env ) {
     // This actually can't happen anymore because assoc2joins should have taken care of it
     if (path.ref[0].where)
-      throw new ModelError(`"${artifactName}": Filters in FROM are not supported for conversion to SQL`);
-
+      throw new ModelError(`"At ${JSON.stringify(env.path)}": Filters in FROM are not supported for conversion to SQL (path: ${JSON.stringify(path)})`);
 
     // SQL needs a ':' after path.ref[0] to separate associations
     let result = renderAbsolutePath(path, ':', env);
@@ -939,7 +958,7 @@ function toSqlDdl( csn, options ) {
    *
    * @param {object} path Path to render
    * @param {string} sep Separator between path steps
-   * @param {object} env Render environment
+   * @param {SqlRenderEnvironment} env Render environment
    * @returns {string} Rendered path
    */
   function renderAbsolutePath( path, sep, env ) {
@@ -960,7 +979,9 @@ function toSqlDdl( csn, options ) {
     // An empty actual parameter list is rendered as `()`.
     const ref = csn.definitions[path.ref[0].id] || csn.definitions[path.ref[0]];
     if (ref && ref.params) {
-      result += `(${renderArgs(path.ref[0] || {}, '=>', env, syntax)})`;
+      result += path.ref[0]?.args
+        ? `(${renderArgs(path.ref[0], '=>', env.withSubPath([ 'ref', 0 ]), syntax)})`
+        : '()';
     }
     else if (syntax === 'udf') {
       // if syntax is user defined function, render empty argument list
@@ -969,7 +990,7 @@ function toSqlDdl( csn, options ) {
     }
     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
@@ -986,24 +1007,25 @@ function toSqlDdl( csn, options ) {
    *
    * @param {object} node with `args` to render
    * @param {string} sep Separator between args
-   * @param {object} env Render environment
+   * @param {SqlRenderEnvironment} env Render environment
    * @param {string|null} syntax Some magic A2J parameter - for calcview parameter rendering
    * @returns {string} Rendered arguments
    * @throws Throws if args is not an array or object.
    */
   function renderArgs( node, sep, env, syntax ) {
-    const args = node.args ? node.args : {};
+    if (!node.args)
+      return '';
     // Positional arguments
-    if (Array.isArray(args))
-      return args.map(arg => renderExpr(arg, env)).join(', ');
+    if (Array.isArray(node.args))
+      return node.args.map((arg, i) => renderExpr(arg, env.withSubPath([ 'args', i ]))).join(', ');
 
     // Named arguments (object/dict)
-    else if (typeof args === 'object')
+    else if (typeof node.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 : decorateParameter(key, syntax)} ${sep} ${renderExpr(args[key], env)}`).join(', ');
+      return Object.keys(node.args).map(key => `${node.func ? key : decorateParameter(key, syntax)} ${sep} ${renderExpr(node.args[key], env.withSubPath([ 'args', key ]))}`).join(', ');
 
 
-    throw new ModelError(`Unknown args: ${JSON.stringify(args)}`);
+    throw new ModelError(`Unknown args: ${JSON.stringify(node.args)}`);
 
 
     /**
@@ -1027,7 +1049,7 @@ function toSqlDdl( csn, options ) {
    *
    * @param {object} col Column to render
    * @param {CSN.Elements} elements of leading or subquery
-   * @param {object} env Render environment
+   * @param {SqlRenderEnvironment} env Render environment
    * @returns {string} Rendered column
    */
   function renderViewColumn( col, elements, env ) {
@@ -1053,11 +1075,10 @@ function toSqlDdl( csn, options ) {
    *
    * @param {string} artifactName Name of the view
    * @param {CSN.Artifact} art CSN view
-   * @param {object} env Render environment
+   * @param {SqlRenderEnvironment} env Render environment
    * @returns {string} Rendered view
    */
   function renderView( artifactName, art, env ) {
-    env._artifact = art;
     const viewName = renderArtifactName(artifactName);
     definitionsDuplicateChecker.addArtifact(art['@cds.persistence.name'], art && art.$location, artifactName);
     let result = `VIEW ${viewName}`;
@@ -1065,11 +1086,14 @@ function toSqlDdl( csn, options ) {
     if (options.sqlDialect === 'hana' && hasHanaComment(art, options))
       result += ` COMMENT ${renderStringForSql(getHanaComment(art), options.sqlDialect)}`;
 
-    result += renderParameterDefinitions(artifactName, art.params);
-    result += ` AS ${renderQuery(artifactName, getNormalizedQuery(art).query, env, art.elements)}`;
+    result += renderParameterDefinitions(art.params, env);
+    result += ` AS ${renderQuery(getNormalizedQuery(art).query,
+                                 env.withSubPath([ art.projection ? 'projection' : 'query' ]),
+                                 art.elements, !!art.projection)}`;
 
-    const childEnv = increaseIndent(env);
-    const associations = Object.keys(art.elements).filter(name => !!art.elements[name].target)
+    const childEnv = env.withIncreasedIndent();
+    const associations = Object.keys(art.elements)
+      .filter(name => !!art.elements[name].target)
       .map(name => renderAssociationElement(name, art.elements[name], childEnv))
       .filter(s => s !== '')
       .join(',\n');
@@ -1089,18 +1113,19 @@ function toSqlDdl( csn, options ) {
   /**
    * Render the parameter definition of a view if any. Return the parameters in parentheses, or an empty string
    *
-   * @param {string} artifactName Name of the view
    * @param {Object} params Dictionary of parameters
+   * @param {SqlRenderEnvironment} env
    * @returns {string} Rendered parameters
    */
-  function renderParameterDefinitions( artifactName, params ) {
+  function renderParameterDefinitions( params, env ) {
     let result = '';
     if (params) {
       const parray = [];
       for (const pn in params) {
+        const paramEnv = env.withSubPath([ 'params', pn ]);
         const p = params[pn];
         if (p.notNull === true || p.notNull === false)
-          info('query-ignoring-param-nullability', [ 'definitions', artifactName, 'params', pn ], { '#': 'sql' });
+          info('query-ignoring-param-nullability', paramEnv.path, { '#': 'sql' });
         // do not quote parameter identifiers for naming mode "quoted" / "hdbcds"
         // this would be an incompatible change, as non-uppercased, quoted identifiers
         // are rejected by the HANA compiler.
@@ -1109,9 +1134,9 @@ function toSqlDdl( csn, options ) {
           pIdentifier = prepareIdentifier(pn);
         else
           pIdentifier = quoteSqlId(pn);
-        let pstr = `IN ${pIdentifier} ${renderTypeReference(artifactName, pn, p)}`;
+        let pstr = `IN ${pIdentifier} ${renderTypeReference(p, paramEnv)}`;
         if (p.default)
-          pstr += ` DEFAULT ${renderExpr(p.default, { indent: '' })}`;
+          pstr += ` DEFAULT ${renderExpr(p.default, new SqlRenderEnvironment({ ...env, indent: '' }))}`;
 
         parray.push(pstr);
       }
@@ -1121,24 +1146,26 @@ function toSqlDdl( csn, options ) {
   }
 
   /**
-   * Render a query 'query', i.e. a select statement with where-condition etc. Use 'artifactName' only for error messages.
+   * Render a query 'query', i.e. a select statement with where-condition etc.
    *
-   * @param {string} artifactName Artifact containing the query
    * @param {CSN.Query} query CSN query
-   * @param {object} env Render environment
+   * @param {SqlRenderEnvironment} env Render environment
    * @param {CSN.Elements} [elements] to override direct query elements - e.g. leading union should win
+   * @param {boolean} [isProjection]
    * @returns {string} Rendered query
    */
-  function renderQuery( artifactName, query, env, elements = null ) {
+  function renderQuery( query, env, elements = null, isProjection = false ) {
     let result = '';
     // Set operator, like UNION, INTERSECT, ...
     if (query.SET) {
+      env = env.withSubPath([ 'SET' ]);
       result += query.SET.args
-        .map((arg) => {
+        .map((arg, index) => {
           // Wrap each query in the SET in parentheses that
           // - is a SET itself (to preserve precedence between the different SET operations),
           // - has an ORDER BY/LIMIT (because UNION etc. can't stand directly behind an ORDER BY)
-          const queryString = renderQuery(artifactName, arg, env, elements || query.SET.elements);
+          const argEnv = env.withSubPath([ 'args', index ]);
+          const queryString = renderQuery( arg, argEnv, elements || query.SET.elements, false);
           return (arg.SET || arg.SELECT && (arg.SELECT.orderBy || arg.SELECT.limit)) ? `(${queryString})` : queryString;
         })
         .join(`\n${env.indent}${query.SET.op && query.SET.op.toUpperCase()}${query.SET.all ? ' ALL ' : ' '}`);
@@ -1150,10 +1177,10 @@ function toSqlDdl( csn, options ) {
       if (query.SET.orderBy || query.SET.limit) {
         result = `(${result})`;
         if (query.SET.orderBy)
-          result += `\n${env.indent}ORDER BY ${query.SET.orderBy.map(entry => renderOrderByEntry(entry, env)).join(', ')}`;
+          result += `\n${env.indent}ORDER BY ${query.SET.orderBy.map(entry => renderOrderByEntry(entry, env.withSubPath([ 'orderBy' ]))).join(', ')}`;
 
         if (query.SET.limit)
-          result += `\n${env.indent}${renderLimit(query.SET.limit, env)}`;
+          result += `\n${env.indent}${renderLimit(query.SET.limit, env.withSubPath([ 'limit' ]))}`;
       }
       return result;
     }
@@ -1161,30 +1188,37 @@ function toSqlDdl( csn, options ) {
     else if (!query.SELECT) {
       throw new ModelError(`Unexpected query operation ${JSON.stringify(query)}`);
     }
+    if (!isProjection)
+      env = env.withSubPath([ 'SELECT' ]);
     const select = query.SELECT;
-    const childEnv = increaseIndent(env);
+    const childEnv = env.withIncreasedIndent();
     result += `SELECT${select.distinct ? ' DISTINCT' : ''}`;
     // FIXME: We probably also need to consider `excluding` here ?
     result += `\n${(select.columns || [ '*' ])
-      .filter(col => !select.mixin?.[firstPathStepId(col.ref)]) // No mixin columns
-      .map(col => renderViewColumn(col, elements || select.elements, childEnv))
+      .map((col, index) => {
+        if (!select.mixin?.[firstPathStepId(col.ref)]) {
+          const colEnv = select.columns ? childEnv.withSubPath([ 'columns', index ]) : childEnv;
+          return renderViewColumn(col, elements || select.elements, colEnv);
+        }
+        return ''; // No mixin columns
+      })
       .filter(s => s !== '')
       .join(',\n')}\n`;
-    result += `${env.indent}FROM ${renderViewSource(artifactName, select.from, env)}`;
+    result += `${env.indent}FROM ${renderViewSource( select.from, env.withSubPath([ 'from' ]))}`;
     if (select.where)
-      result += `\n${env.indent}WHERE ${renderExpr(select.where, env)}`;
+      result += `\n${env.indent}WHERE ${renderExpr(select.where, env.withSubPath([ 'where' ]))}`;
 
     if (select.groupBy)
-      result += `\n${env.indent}GROUP BY ${select.groupBy.map(expr => renderExpr(expr, env)).join(', ')}`;
+      result += `\n${env.indent}GROUP BY ${select.groupBy.map((expr, i) => renderExpr(expr, env.withSubPath([ 'groupBy', i ]))).join(', ')}`;
 
     if (select.having)
-      result += `\n${env.indent}HAVING ${renderExpr(select.having, env)}`;
+      result += `\n${env.indent}HAVING ${renderExpr(select.having, env.withSubPath([ 'having' ]))}`;
 
     if (select.orderBy)
-      result += `\n${env.indent}ORDER BY ${select.orderBy.map(entry => renderOrderByEntry(entry, env)).join(', ')}`;
+      result += `\n${env.indent}ORDER BY ${select.orderBy.map((entry, i) => renderOrderByEntry(entry, env.withSubPath([ 'orderBy', i ]))).join(', ')}`;
 
     if (select.limit)
-      result += `\n${env.indent}${renderLimit(select.limit, env)}`;
+      result += `\n${env.indent}${renderLimit(select.limit, env.withSubPath([ 'limit' ]))}`;
 
     return result;
   }
@@ -1203,17 +1237,17 @@ function toSqlDdl( csn, options ) {
    * Render a query's LIMIT clause, which may also have OFFSET.
    *
    * @param {CSN.QueryLimit} limit Limit clause
-   * @param {object} env Render environment
+   * @param {SqlRenderEnvironment} env Render 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${env.indent}` : '';
-      result += `${indent}OFFSET ${renderExpr(limit.offset, env)}`;
+      result += `${indent}OFFSET ${renderExpr(limit.offset, env.withSubPath([ 'offset' ]))}`;
     }
 
     return result;
@@ -1224,7 +1258,7 @@ function toSqlDdl( csn, options ) {
    * have a 'sort' property for ASC/DESC and a 'nulls' for FIRST/LAST
    *
    * @param {object} entry Part of an ORDER BY
-   * @param {object} env Render environment
+   * @param {SqlRenderEnvironment} env Render environment
    * @returns {string} Rendered ORDER BY entry
    */
   function renderOrderByEntry( entry, env ) {
@@ -1239,45 +1273,46 @@ function toSqlDdl( csn, options ) {
   }
 
   /**
-   * Render a reference to the type used by 'elm' (with name 'elementName' in 'artifactName', both used only for error messages).
+   * Render a reference to the type used by 'elm'. env.path must point to the element/param.
    *
-   * @param {string} artifactName Artifact containing the element
-   * @param {string} elementName Element referencing the type
    * @param {CSN.Element} elm CSN element
+   * @param {SqlRenderEnvironment} env
    * @returns {string} Rendered type reference
    */
-  function renderTypeReference( artifactName, elementName, elm ) {
+  function renderTypeReference( elm, env ) {
     let result = '';
 
     // Anonymous structured type: Not supported with SQL (but shouldn't happen anyway after forHana flattened them)
     if (!elm.type && !elm.value) {
       if (!elm.elements)
-        throw new ModelError(`Missing type of: ${elementName}`);
+        throw new ModelError(`to.sql(): Missing type of: ${JSON.stringify(env.path)}`);
 
-      // TODO: Signal is not covered by tests + better location
-      error(null, [ 'definitions', artifactName, 'elements', elementName ],
+      // TODO: Signal is not covered by tests
+      error(null, env.path,
             'Anonymous structured types are not supported for conversion to SQL');
       return result;
     }
 
     // Association type
     if (elm.target) {
-      // TODO: Signal is not covered by tests + better location
+      // TODO: Signal is not covered by tests
       // We can't do associations yet
-      error(null, [ 'definitions', artifactName, 'elements', elementName ],
+      error(null, env.path,
             'Association and composition types are not yet supported for conversion to SQL');
       return result;
     }
 
-    // If we get here, it must be a primitive (i.e. builtin) type
-    if (isBuiltinType(elm.type)) {
-      // cds.Integer => render as INTEGER (no quotes)
-      result += renderBuiltinType(elm.type);
-    }
-    else {
-      throw new ModelError(`Unexpected non-primitive type of: ${artifactName}.${elementName}`);
+    if (elm.type) {
+      // If we get here, it must be a primitive (i.e. builtin) type
+      if (isBuiltinType(elm.type)) {
+        // cds.Integer => render as INTEGER (no quotes)
+        result += renderBuiltinType(elm.type);
+        result += renderTypeParameters(elm);
+      }
+      else {
+        throw new ModelError(`Unexpected non-primitive type of: ${JSON.stringify(env.path)}`);
+      }
     }
-    result += renderTypeParameters(elm);
 
     if (elm.value) {
       if (!elm.value.stored)
@@ -1286,7 +1321,7 @@ function toSqlDdl( csn, options ) {
       // The SQL standard 2016 describes the syntax in section 11.3 - 11.4
       // of the SQL Foundation spec (for 2003 in 5WD-02-Foundation-2003-09.pdf). Summarized:
       //   <generation clause> ::= GENERATED ALWAYS AS '(' <value expression> ')'
-      result += ` GENERATED ALWAYS AS (${renderExpr(elm.value)})`;
+      result += ` GENERATED ALWAYS AS (${renderExpr(elm.value, env.withSubPath([ 'value' ]))})`;
       // However, it appears many databases require a trailing "STORED".
       if (options.sqlDialect === 'sqlite' || options.sqlDialect === 'postgres')
         result += ' STORED';
@@ -1327,7 +1362,6 @@ function toSqlDdl( csn, options ) {
       return obj.$notNull ? ' NOT NULL' : ' NULL';
     }
 
-
     if (obj.notNull === undefined && !(obj.key && treatKeyAsNotNull)) {
       // Attribute not set at all
       return '';
@@ -1398,6 +1432,11 @@ function toSqlDdl( csn, options ) {
     }
   }
 
+  /**
+   * @param {object} x
+   * @param {object} env
+   * @return {string}
+   */
   function renderExpressionRef( x, env ) {
     if (!x.param && !x.global) {
       const magicReplacement = getVariableReplacement(x.ref, options);
@@ -1406,13 +1445,13 @@ function toSqlDdl( csn, options ) {
         if (magicReplacement !== null)
           return renderStringForSql(magicReplacement, options.sqlDialect);
 
-        const result = render$user();
+        const result = render$user(x);
         // Invalid second path step doesn't cause a return
         if (result)
           return result;
       }
       else if (x.ref[0] === '$at' || x.ref[0] === '$valid') {
-        const result = render$at();
+        const result = render$at(x);
         // Invalid second path step doesn't cause a return
         if (result)
           return result;
@@ -1444,174 +1483,171 @@ function toSqlDdl( csn, options ) {
     if (x.param)
       return `:${x.ref[0].toUpperCase()}`;
 
-    return x.ref.map(renderPathStep)
+    return x.ref.map((step, i) => renderPathStep(step, i, env.withSubPath([ 'ref', i ])))
       .filter(s => s !== '')
       .join('.');
+  }
 
-    /**
-     * @returns {string|null} Null in case of an invalid second path step
-     */
-    function render$user() {
-      // FIXME: this is all not enough: we might need an explicit select item alias (?)
-      if (x.ref[1] === 'id') {
-        if (options.sqlDialect === 'hana')
-          return 'SESSION_CONTEXT(\'APPLICATIONUSER\')';
-        else if (options.sqlDialect === 'postgres')
-          return 'current_setting(\'CAP.APPLICATIONUSER\')';
-        else if (options.betterSqliteSessionVariables && options.sqlDialect === 'sqlite')
-          return 'session_context( \'$user.id\' )';
-        warning(null, null, 'The "$user" variable is not supported. Use option "variableReplacements" to specify a value for "$user.id"');
-        return '\'$user.id\'';
-      }
-      else if (x.ref[1] === 'locale') {
-        if (options.sqlDialect === 'hana')
-          return 'SESSION_CONTEXT(\'LOCALE\')';
-        else if (options.sqlDialect === 'postgres')
-          return 'current_setting(\'CAP.LOCALE\')';
-        else if (options.betterSqliteSessionVariables && options.sqlDialect === 'sqlite')
-          return 'session_context( \'$user.locale\' )';
-        return '\'en\''; // default language
-      }
-      // Basically: Second path step was invalid, do nothing - should not happen.
-      return null;
+  /**
+   * @param {object} x
+   * @returns {string|null} Null in case of an invalid second path step
+   */
+  function render$user( x ) {
+    // FIXME: this is all not enough: we might need an explicit select item alias (?)
+    if (x.ref[1] === 'id') {
+      if (options.sqlDialect === 'hana')
+        return 'SESSION_CONTEXT(\'APPLICATIONUSER\')';
+      else if (options.sqlDialect === 'postgres')
+        return 'current_setting(\'CAP.APPLICATIONUSER\')';
+      else if (options.betterSqliteSessionVariables && options.sqlDialect === 'sqlite')
+        return 'session_context( \'$user.id\' )';
+      warning(null, null, 'The "$user" variable is not supported. Use option "variableReplacements" to specify a value for "$user.id"');
+      return '\'$user.id\'';
     }
-    /**
-     * For a given reference starting with $at, render a 'current_timestamp' literal for plain.
-      * For the sql-dialect hana, we render the TO_TIMESTAMP(SESSION_CONTEXT(..)) function.
-      *
-      *
-      * For sqlite, we render the string-format-time (strftime) function.
-      * Because the format of `current_timestamp` is like that: '2021-05-14 09:17:19' whereas
-      * the format for TimeStamps (at least in Node.js) is like that: '2021-01-01T00:00:00.000Z'
-      * --> Therefore the comparison in the temporal where clause doesn't work properly.
-      *
-      * @returns {string|null} Null in case of an invalid second path step
-      */
-    function render$at() {
-      if (x.ref[1] === 'from') {
-        switch (options.sqlDialect) {
-          case 'sqlite': {
-            if (options.betterSqliteSessionVariables)
-              return 'session_context( \'$valid.from\' )';
-            const dateFromFormat = '%Y-%m-%dT%H:%M:%S.000Z';
-            return `strftime('${dateFromFormat}', 'now')`;
-          }
-          case 'hana':
-            return 'TO_TIMESTAMP(SESSION_CONTEXT(\'VALID-FROM\'))';
-          case 'postgres':
-            return '(to_timestamp(current_setting(\'CAP.VALID_FROM\'), \'YYYY-MM-DD HH24:MI:SS.FF6\') at time zone \'UTC\')';
-          case 'h2':
-          case 'plain':
-            return 'current_timestamp';
-          default:
-            break;
+    else if (x.ref[1] === 'locale') {
+      if (options.sqlDialect === 'hana')
+        return 'SESSION_CONTEXT(\'LOCALE\')';
+      else if (options.sqlDialect === 'postgres')
+        return 'current_setting(\'CAP.LOCALE\')';
+      else if (options.betterSqliteSessionVariables && options.sqlDialect === 'sqlite')
+        return 'session_context( \'$user.locale\' )';
+      return '\'en\''; // default language
+    }
+    // Basically: Second path step was invalid, do nothing - should not happen.
+    return null;
+  }
+
+  /**
+   * For a given reference starting with $at, render a 'current_timestamp' literal for plain.
+   * For the sql-dialect hana, we render the TO_TIMESTAMP(SESSION_CONTEXT(..)) function.
+   *
+   *
+   * For sqlite, we render the string-format-time (strftime) function.
+   * Because the format of `current_timestamp` is like that: '2021-05-14 09:17:19' whereas
+   * the format for TimeStamps (at least in Node.js) is like that: '2021-01-01T00:00:00.000Z'
+   * --> Therefore the comparison in the temporal where clause doesn't work properly.
+   *
+   * @param {object} x
+   * @returns {string|null} Null in case of an invalid second path step
+   */
+  function render$at( x ) {
+    if (x.ref[1] === 'from') {
+      switch (options.sqlDialect) {
+        case 'sqlite': {
+          if (options.betterSqliteSessionVariables)
+            return 'session_context( \'$valid.from\' )';
+          const dateFromFormat = '%Y-%m-%dT%H:%M:%S.000Z';
+          return `strftime('${dateFromFormat}', 'now')`;
         }
+        case 'hana':
+          return 'TO_TIMESTAMP(SESSION_CONTEXT(\'VALID-FROM\'))';
+        case 'postgres':
+          return '(to_timestamp(current_setting(\'CAP.VALID_FROM\'), \'YYYY-MM-DD HH24:MI:SS.FF6\') at time zone \'UTC\')';
+        case 'h2':
+        case 'plain':
+          return 'current_timestamp';
+        default:
+          break;
       }
+    }
 
-      if (x.ref[1] === 'to') {
-        switch (options.sqlDialect) {
-          case 'sqlite': {
-            if (options.betterSqliteSessionVariables)
-              return 'session_context( \'$valid.to\' )';
-            // + 1ms compared to $at.from
-            const dateToFormat = '%Y-%m-%dT%H:%M:%S.001Z';
-            return `strftime('${dateToFormat}', 'now')`;
-          }
-          case 'hana':
-            return 'TO_TIMESTAMP(SESSION_CONTEXT(\'VALID-TO\'))';
-          case 'postgres':
-            return '(to_timestamp(current_setting(\'CAP.VALID_TO\'), \'YYYY-MM-DD HH24:MI:SS.FF6\') at time zone \'UTC\')';
-          case 'h2':
-          case 'plain':
-            return 'current_timestamp';
-          default:
-            break;
+    if (x.ref[1] === 'to') {
+      switch (options.sqlDialect) {
+        case 'sqlite': {
+          if (options.betterSqliteSessionVariables)
+            return 'session_context( \'$valid.to\' )';
+          // + 1ms compared to $at.from
+          const dateToFormat = '%Y-%m-%dT%H:%M:%S.001Z';
+          return `strftime('${dateToFormat}', 'now')`;
         }
+        case 'hana':
+          return 'TO_TIMESTAMP(SESSION_CONTEXT(\'VALID-TO\'))';
+        case 'postgres':
+          return '(to_timestamp(current_setting(\'CAP.VALID_TO\'), \'YYYY-MM-DD HH24:MI:SS.FF6\') at time zone \'UTC\')';
+        case 'h2':
+        case 'plain':
+          return 'current_timestamp';
+        default:
+          break;
       }
-      return null;
     }
+    return null;
+  }
 
-    /**
-     * Render a single path step 's' at path position 'idx', which can have filters or parameters or be a function
-     *
-     * @param {string|object} s Path step to render
-     * @param {number} idx index of the path step in the overall path
-     * @returns {string} Rendered path step
-     */
-    function renderPathStep( s, idx ) {
-      // Simple id or absolute name
-      if (typeof (s) === 'string') {
-        // TODO: When is this actually executed and not handled already in renderExpr?
-        const magicForHana = {
-          '$user.id': 'SESSION_CONTEXT(\'APPLICATIONUSER\')',
-          '$user.locale': 'SESSION_CONTEXT(\'LOCALE\')',
-        };
-        // Some magic for first path steps
-        if (idx === 0) {
-          // HANA-specific translation of '$now' and '$user'
-          // FIXME: this is all not enough: we might need an explicit select item alias
-          if (options.sqlDialect === 'hana' && magicForHana[s])
-            return magicForHana[s];
-
-          // Ignore initial $projection and initial $self
-          if (s === '$projection' || s === '$self')
-            return '';
-        }
-        return quoteSqlId(s);
+  /**
+   * Render a single path step 's' at path position 'idx', which can have filters or parameters or be a function
+   *
+   * @param {string|object} s Path step to render
+   * @param {number} idx index of the path step in the overall path
+   * @param {object} env
+   * @returns {string} Rendered path step
+   */
+  function renderPathStep( s, idx, env ) {
+    // Simple id or absolute name
+    if (typeof (s) === 'string') {
+      // TODO: When is this actually executed and not handled already in renderExpr?
+      const magicForHana = {
+        '$user.id': 'SESSION_CONTEXT(\'APPLICATIONUSER\')',
+        '$user.locale': 'SESSION_CONTEXT(\'LOCALE\')',
+      };
+      // Some magic for first path steps
+      if (idx === 0) {
+        // HANA-specific translation of '$now' and '$user'
+        // FIXME: this is all not enough: we might need an explicit select item alias
+        if (options.sqlDialect === 'hana' && magicForHana[s])
+          return magicForHana[s];
+
+        // Ignore initial $projection and initial $self
+        if (s === '$projection' || s === '$self')
+          return '';
       }
-      // ID with filters or parameters
-      else if (typeof s === 'object') {
-        // Sanity check
-        if (!s.func && !s.id)
-          throw new ModelError(`Unknown path step object: ${JSON.stringify(s)}`);
-
-        // Not really a path step but an object-like function call
-        if (s.func)
-          return `${s.func}(${renderArgs(s, '=>', env, null)})`;
-
-        // Path step, possibly with view parameters and/or filters
-        let result = `${quoteSqlId(s.id)}`;
-        if (s.args) {
-          // View parameters
-          result += `(${renderArgs(s, '=>', env, null)})`;
-        }
-        if (s.where) {
-          // Filter, possibly with cardinality
-          // FIXME: Does SQL understand filter cardinalities?
-          const cardinality = s.cardinality ? (`${s.cardinality.max}: `) : '';
-          result += `[${cardinality}${renderExpr(s.where, env)}]`;
-        }
-        return result;
+      return quoteSqlId(s);
+    }
+    // ID with filters or parameters
+    else if (typeof s === 'object') {
+      // Sanity check
+      if (!s.func && !s.id)
+        throw new ModelError(`Unknown path step object: ${JSON.stringify(s)}`);
+
+      // Not really a path step but an object-like function call
+      if (s.func)
+        return `${s.func}(${renderArgs(s, '=>', env, null)})`;
+
+      // Path step, possibly with view parameters and/or filters
+      let result = `${quoteSqlId(s.id)}`;
+      if (s.args) {
+        // View parameters
+        result += `(${renderArgs(s, '=>', env, null)})`;
       }
-
-      throw new ModelError(`Unknown path step: ${JSON.stringify(s)}`);
+      if (s.where) {
+        // Filter, possibly with cardinality
+        // FIXME: Does SQL understand filter cardinalities?
+        const cardinality = s.cardinality ? (`${s.cardinality.max}: `) : '';
+        result += `[${cardinality}${renderExpr(s.where, env.withSubPath([ 'where' ]))}]`;
+      }
+      return result;
     }
+
+    throw new ModelError(`Unknown path step: ${JSON.stringify(s)}`);
   }
 
+
   function renderWindowFunction( funcName, node, fctEnv ) {
     let r = `${funcName}(${renderArgs(node, '=>', fctEnv, null)}) `;
-    r += renderExpr(node.xpr, fctEnv); // xpr[0] is 'over'
+    r += renderExpr(node.xpr, fctEnv.withSubPath([ 'xpr' ])); // xpr[0] is 'over'
     return r;
   }
 
-  /**
-   * Returns a copy of 'env' with increased indentation
-   *
-   * @param {object} env Render environment
-   * @returns {object} Render environment with increased indent
-   */
-  function increaseIndent( env ) {
-    return Object.assign({}, env, { indent: `${env.indent}  ` });
-  }
+
   /**
    * Returns a copy of 'env' with alterMode set to true
    *
-   * @param {object} env Render environment
+   * @param {SqlRenderEnvironment} env Render environment
    * @param {string} changeType 'extension' or 'migration'
    * @returns {object} Render environment with alterMode
    */
   function activateAlterMode( env, changeType ) {
-    return Object.assign({ alterMode: true, changeType }, env);
+    return env.cloneWith({ alterMode: true, changeType });
   }
 }