@sap/cds-compiler 2.12.0 → 2.15.2

package/lib/render/toHdbcds.js

@@ -7,8 +7,8 @@ const {
 } = require('../model/csnUtils');
 const keywords = require('../base/keywords');
 const {
-  renderFunc, beautifyExprArray, getRealName, addContextMarkers, addIntermediateContexts, cdsToSqlTypes,
-  hasHanaComment, getHanaComment, findElement, funcWithoutParen, getSqlSnippets,
+  renderFunc, getExpressionRenderer, getRealName, addContextMarkers, addIntermediateContexts, cdsToSqlTypes,
+  hasHanaComment, getHanaComment, funcWithoutParen, getSqlSnippets,
 } = require('./utils/common');
 const {
   renderReferentialConstraint,
@@ -20,18 +20,19 @@ const { makeMessageFunction } = require('../base/messages');
 const { timetrace } = require('../utils/timetrace');
 
 const { smartId, delimitedId } = require('../sql-identifier');
+const { ModelError } = require('../base/error');
 
 const $PROJECTION = '$projection';
 const $SELF = '$self';
 
 /**
- * Get the comment and in addition escape \n so HANA CDS can handle it.
+ * Get the comment and in addition escape \n and `'` so SAP HANA CDS can handle it.
  *
  * @param {CSN.Artifact} obj
  * @returns {string}
  */
 function getEscapedHanaComment(obj) {
-  return getHanaComment(obj).replace(/\n/g, '\\n');
+  return getHanaComment(obj).replace(/\n/g, '\\n').replace(/'/g, "''");
 }
 
 /**
@@ -55,9 +56,40 @@ function toHdbcdsSource(csn, options) {
   const hdbcdsNames = options.sqlMapping === 'hdbcds';
 
   const {
-    info, warning, error, throwWithError,
+    info, warning, error, throwWithAnyError,
   } = makeMessageFunction(csn, options, 'to.hdbcds');
 
+  const renderExpr = getExpressionRenderer({
+    finalize: x => x,
+    explicitTypeCast(x, env) {
+      let typeRef = renderTypeReference(x.cast, env);
+
+      // inside a cast expression, the cds and hana cds types need to be mapped to hana sql types
+      const hanaSqlType = cdsToSqlTypes.hana[x.cast.type] || cdsToSqlTypes.standard[x.cast.type];
+      if (hanaSqlType) {
+        const typeRefWithoutParams = typeRef.substring(0, typeRef.indexOf('(')) || typeRef;
+        typeRef = typeRef.replace(typeRefWithoutParams, hanaSqlType);
+      }
+      return `CAST(${renderExpr(x, env)} AS ${typeRef})`;
+    },
+    val: renderExpressionLiteral,
+    enum: x => `#${x['#']}`,
+    ref: renderExpressionRef,
+    aliasOnly(x, _env) {
+      return x.as;
+    },
+    windowFunction: renderExpressionFunc,
+    func: renderExpressionFunc,
+    xpr(x, env) {
+      if (this.nestedExpr && !x.cast)
+        return `(${renderExpr(x.xpr, env, this.inline, true)})`;
+
+      return renderExpr(x.xpr, env, this.inline, true);
+    },
+    SELECT: (x, env) => `(${renderQuery(x, false, increaseIndent(env))})`,
+    SET: (x, env) => `${renderQuery(x, false, increaseIndent(env))}`,
+  });
+
   checkCSNVersion(csn, options);
 
   const hdbcdsResult = Object.create(null);
@@ -116,7 +148,7 @@ function toHdbcdsSource(csn, options) {
 
   killList.forEach(fn => fn());
 
-  throwWithError();
+  throwWithAnyError();
   timetrace.stop();
   return options.testMode ? sort(hdbcdsResult) : hdbcdsResult;
 
@@ -152,7 +184,6 @@ function toHdbcdsSource(csn, options) {
 
     switch (art.kind) {
       case 'entity':
-      case 'view':
         // FIXME: For HANA CDS, we need to replace $self at the beginning of paths in association ON-condition
         // by the full name of the artifact we are rendering (should actually be done by forHana, but that is
         // somewhat difficult because this kind of absolute path is quite unusual). In order not to have to pass
@@ -177,7 +208,7 @@ function toHdbcdsSource(csn, options) {
       case 'event':
         return '';
       default:
-        throw new Error(`Unknown artifact kind: ${art.kind}`);
+        throw new ModelError(`Unknown artifact kind: ${art.kind}`);
     }
   }
 
@@ -213,11 +244,11 @@ function toHdbcdsSource(csn, options) {
   }
 
   /**
-   * Check wether the given context is the direct parent of the containee.
+   * Check whether the given context is the direct parent of the containee.
    *
    * @param {string} containee Name of the contained artifact
    * @param {string} contextName Name of the (grand?)parent context
-   * @returns {boolean} True if there is another context inbetween
+   * @returns {boolean} True if there is another context in between
    */
   function isContainedInOtherContext(containee, contextName) {
     const parts = containee.split('.');
@@ -280,7 +311,7 @@ function toHdbcdsSource(csn, options) {
    * Render a context or service. Return the resulting source string.
    *
    * If the context is shadowed by another entity, the context itself is not rendered,
-   * but any contained (and transitively contained) entites and views are.
+   * but any contained (and transitively contained) entities and views are.
    *
    * @param {string} artifactName Name of the context/service
    * @param {CSN.Artifact} art Content of the context/service
@@ -313,7 +344,7 @@ function toHdbcdsSource(csn, options) {
     return `${result + renderedSubArtifacts + env.indent}};\n`;
   }
   /**
-   * Check wether the given context is shadowed, i.e. part of his name prefix is shared by a
+   * Check whether the given context is shadowed, i.e. part of his name prefix is shared by a
    *  non-context/service/namespace definition
    *
    * @param {string} artifactName
@@ -469,7 +500,7 @@ function toHdbcdsSource(csn, options) {
     // in 'tc' that we find and render them all (is it syntactically allowed yet to have more than one?)
     tc = tc.hana;
     if (!tc)
-      throw new Error('Expecting a HANA technical configuration');
+      throw new ModelError('Expecting a HANA technical configuration');
 
     result += `\n${env.indent}technical ${tc.calculated ? '' : 'hana '}configuration {\n`;
 
@@ -544,7 +575,7 @@ function toHdbcdsSource(csn, options) {
    * @param {CSN.Element} elm Content of the element
    * @param {CdlRenderEnvironment} env Environment
    * @param {DuplicateChecker} [duplicateChecker] Utility for detecting duplicates
-   * @param {boolean} [isSubElement] Wether the given element is a subelement or not - subelements cannot be key!
+   * @param {boolean} [isSubElement] Whether the given element is a subelement or not - subelements cannot be key!
    * @returns {string} The rendered element
    */
   function renderElement(elementName, elm, env, duplicateChecker, isSubElement) {
@@ -628,7 +659,7 @@ function toHdbcdsSource(csn, options) {
   function renderAbsolutePath(path, env) {
     // Sanity checks
     if (!path.ref)
-      throw new Error(`Expecting ref in path: ${JSON.stringify(path)}`);
+      throw new ModelError(`Expecting ref in path: ${JSON.stringify(path)}`);
 
 
     // Determine the absolute name of the first artifact on the path (before any associations or element traversals)
@@ -687,18 +718,19 @@ function toHdbcdsSource(csn, options) {
    * Return the resulting source string (no trailing LF).
    *
    * @param {object} col Column to render
+   * @param {CSN.Elements} elements where column exists
    * @param {CdlRenderEnvironment} env Environment
-   * @param {CSN.Element} [element] Element (non-enum from subquery possibly) corresponding to the column ref
    * @returns {string} Rendered column
    */
-  function renderViewColumn(col, env, element) {
+  function renderViewColumn(col, elements, env ) {
     // Annotations and column
     let result = '';
 
-    const leaf = col.as || col.ref && col.ref[col.ref.length - 1];
-    // Render 'null as <alias>' only for database and if element is virtual
+    const leaf = col.as || col.ref && col.ref[col.ref.length - 1] || col.func;
+    const element = elements[leaf];
 
-    if (element && element.virtual || env._artifact.elements[leaf] && env._artifact.elements[leaf].virtual) {
+    // Render 'null as <alias>' only for database and if element is virtual
+    if (element && element.virtual) {
       if (isDeprecatedEnabled(options, 'renderVirtualElements'))
         return `${result}${env.indent}null as ${formatIdentifier(leaf)}`;
     }
@@ -791,7 +823,7 @@ function toHdbcdsSource(csn, options) {
    * or 'entity')
    *
    * @param {CSN.Query} query Query object
-   * @param {boolean} isLeadingQuery Wether the query is the leading query or not
+   * @param {boolean} isLeadingQuery Whether the query is the leading query or not
    * @param {CdlRenderEnvironment} env Environment
    * @param {CSN.Path} [path=[]] CSN path to the query
    * @param {object} [elements] For leading query, the elements of the artifact
@@ -803,12 +835,12 @@ function toHdbcdsSource(csn, options) {
     // 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)}`;
+      result += `(${renderQuery(query.SET.args[0], isLeadingQuery, env, path.concat([ '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 ]))}`;
+          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 += ')';
       // Set operation may also have an ORDER BY and LIMIT/OFFSET (in contrast to the ones belonging to
@@ -823,7 +855,7 @@ function toHdbcdsSource(csn, options) {
     }
     // Otherwise must have a SELECT
     else if (!query.SELECT) {
-      throw new Error(`Unexpected query operation ${JSON.stringify(query)}`);
+      throw new ModelError(`Unexpected query operation ${JSON.stringify(query)}`);
     }
     const select = query.SELECT;
     const childEnv = increaseIndent(env);
@@ -843,7 +875,7 @@ function toHdbcdsSource(csn, options) {
     result += select.distinct ? ' distinct' : '';
     if (select.columns) {
       result += ' {\n';
-      result += `${select.columns.map(col => renderViewColumn(col, childEnv, findElement(elements, col)))
+      result += `${select.columns.map(col => renderViewColumn(col, elements || select.elements, childEnv))
         .filter(s => s !== '')
         .join(',\n')}\n`;
       result += `${env.indent}}`;
@@ -870,7 +902,7 @@ function toHdbcdsSource(csn, options) {
       alreadyRendered += `${continueIndent(alreadyRendered, env)}where ${renderExpr(select.where, env, true, true)}`;
 
     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 => renderExpr(expr, env, true, false, true)).join(', ')}`;
 
     if (select.having)
       alreadyRendered += `${continueIndent(alreadyRendered, env)}having ${renderExpr(select.having, env, true, true)}`;
@@ -927,7 +959,7 @@ function toHdbcdsSource(csn, options) {
    * @returns {string} Rendered order by
    */
   function renderOrderByEntry(entry, env) {
-    let result = renderExpr(entry, env);
+    let result = renderExpr(entry, env, true, false, true);
     if (entry.sort)
       result += ` ${entry.sort}`;
 
@@ -1011,7 +1043,7 @@ function toHdbcdsSource(csn, options) {
     // Anonymous structured type
     if (!elm.type) {
       if (!elm.elements)
-        throw new Error(`Missing type of: ${JSON.stringify(elm)}`);
+        throw new ModelError(`Missing type of: ${JSON.stringify(elm)}`);
 
       result += '{\n';
       const childEnv = increaseIndent(env);
@@ -1109,237 +1141,154 @@ function toHdbcdsSource(csn, options) {
   }
 
   /**
-   * Render an expression (including paths and values) or condition 'x'.
-   * (no trailing LF, don't indent if inline)
+   * Render a single path step 's' at path position 'idx', which can have filters or parameters or be a function
    *
-   * @param {any} expr Expression to render
-   * @param {CdlRenderEnvironment} env Environment
-   * @param {boolean} [inline=true] Whether to render inline
-   * @param {boolean} [inExpr=false] Whether the expression is already inside another expression
-   * @returns {string} Rendered expression
+   * @param {string|object} s Path step
+   * @param {number} idx Path position
+   * @returns {string} Rendered path step
    */
-  function renderExpr(expr, env, inline = true, inExpr = false) {
-    // Compound expression
-    if (Array.isArray(expr))
-      return beautifyExprArray(expr.map(item => renderExpr(item, env, inline, inExpr)));
-
-    if (typeof expr === 'object' && expr !== null) {
-      if (inExpr && expr.cast && expr.cast.type)
-        return renderExplicitTypeCast(renderExprObject(expr));
-      return renderExprObject(expr);
-    }
+  function renderPathStep(s, idx, ref, env, inline) {
+    // Simple id or absolute name
+    if (typeof s === 'string') {
+      // HANA-specific extra magic (should actually be in forHana)
+      // In HANA, we replace leading $self by the absolute name of the current artifact
+      // (see FIXME at renderArtifact)
+      if (idx === 0 && s === $SELF) {
+        // do not produce USING for $projection
+        if (env.currentArtifactName === $PROJECTION)
+          return env.currentArtifactName;
+
+        return plainNames ? renderAbsoluteNamePlain(env.currentArtifactName, env)
+          : renderAbsoluteNameWithQuotes(env.currentArtifactName, env);
+      }
+      // HANA-specific translation of '$now' and '$user'
+      if (s === '$now' && ref.length === 1)
+        return 'CURRENT_TIMESTAMP';
 
-    // Not a literal value but part of an operator, function etc - just leave as it is
-    return expr;
+      // In first path position, do not quote $projection and magic $-variables like CURRENT_DATE, $now etc.
+      // FIXME: We should rather explicitly recognize quoting somehow
 
+      // TODO: quote $parameters if it doesn't reference a parameter, this requires knowledge about the kind
+      // Example: both views are correct in HANA CDS
+      // entity E { key id: Integer; }
+      // view EV with parameters P1: Integer as select from E { id, $parameters.P1 };
+      // view EVp as select from E as "$parameters" { "$parameters".id };
 
-    /**
-     * Various special cases represented as objects
-     *
-     * @param {object} x Expression
-     * @returns {string} Rendered expression object
-     */
-    function renderExprObject(x) {
-      if (x.list) {
-        // set "inExpr" to false: treat list elements as new expressions
-        return `(${x.list.map(item => renderExpr(item, env, inline, false)).join(', ')})`;
-      }
-      else if (x.val !== undefined) {
-        return renderExpressionLiteral(x);
-      }
-      // Enum symbol
-      else if (x['#']) {
-        return `#${x['#']}`;
-      }
-      // Reference: Array of path steps, possibly preceded by ':'
-      else if (x.ref) {
-        return renderExpressionRef(x);
-      }
-      // Function call, possibly with args (use '=>' for named args)
-      else if (x.func) {
-        // test for non-regular HANA identifier that needs to be quoted
-        // identifier                  {letter}({letter_or_digit}|[#$])*
-        // letter                      [A-Za-z_]
-        // letter_or_digit             [A-Za-z_0-9]
-
-        const regex = RegExp(/^[a-zA-Z][\w#$]*$/, 'g');
-        const funcName = regex.test(x.func) ? x.func : quoteId(x.func);
-        // we can't quote functions with parens, issue warning if it is a reserved keyword
-        if (!funcWithoutParen(x, 'hana') && keywords.hdbcds.includes(uppercaseAndUnderscore(funcName)))
-          warning(null, x.$location, `The identifier “${uppercaseAndUnderscore(funcName)}“ is a SAP HANA keyword`);
-        return renderFunc(funcName, x, 'hana', a => renderArgs(a, '=>', env));
-      }
-      // Nested expression
-      else if (x.xpr) {
-        if (inExpr && !x.cast)
-          return `(${renderExpr(x.xpr, env, inline, true)})`;
-
-        return renderExpr(x.xpr, env, inline, true);
-      }
-      // Sub-select
-      else if (x.SELECT) {
-        // renderQuery for SELECT does not bring its own parentheses (because it is also used in renderView)
-        return `(${renderQuery(x, false, increaseIndent(env))})`;
-      }
-      else if (x.SET) {
-        // renderQuery for SET always brings its own parentheses (because it is also used in renderViewSource)
-        return `${renderQuery(x, false, increaseIndent(env))}`;
-      }
+      if (idx === 0 &&
+            [ $SELF, $PROJECTION, '$session' ].includes(s))
+        return s;
 
-      throw new Error(`Unknown expression: ${JSON.stringify(x)}`);
+      return formatIdentifier(s);
     }
-    /**
-     * @param {object} x Expression with a val and/or literal property
-     * @returns {string} Rendered expression
-     */
-    function renderExpressionLiteral(x) {
-      // Literal value, possibly with explicit 'literal' property
-      switch (x.literal || typeof x.val) {
-        case 'number':
-        case 'boolean':
-        case 'null':
-          return x.val;
-        case 'x':
-        case 'date':
-        case 'time':
-        case 'timestamp':
-          return `${x.literal}'${x.val}'`;
-        case 'string':
-          return `'${x.val.replace(/'/g, '\'\'')}'`;
-        case 'object':
-          if (x.val === null)
-            return 'null';
-
-        // otherwise fall through to
-        default:
-          throw new Error(`Unknown literal or type: ${JSON.stringify(x)}`);
+    // 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)})`;
+
+      // Path step, possibly with view parameters and/or filters
+      let result = `${formatIdentifier(s.id)}`;
+      if (s.args) {
+        // View parameters
+        result += `(${renderArgs(s, ':', env)})`;
       }
-    }
-
-    /**
-     * @param {object} x Expression with a ref property
-     * @returns {string} Rendered expression
-     * @todo no extra magic with x.param or x.global
-     */
-    function renderExpressionRef(x) {
-      if (!x.param && !x.global) {
-        const magicReplacement = getVariableReplacement(x.ref, options);
-        if (x.ref[0] === '$user') {
-          if (magicReplacement !== null)
-            return `'${magicReplacement}'`;
-
-          // Keep old way of solving this to remain backwards compatible
-          // FIXME: this is all not enough: we might need an explicit select item alias
-          if (x.ref[1] === 'id') {
-            if (options.magicVars && options.magicVars.user && (typeof options.magicVars.user === 'string' || options.magicVars.user instanceof String))
-              return `'${options.magicVars.user}'`;
-
-            else if ((options.magicVars && options.magicVars.user && options.magicVars.user.id) && (typeof options.magicVars.user.id === 'string' || options.magicVars.user.id instanceof String))
-              return `'${options.magicVars.user.id}'`;
-
-            return 'SESSION_CONTEXT(\'APPLICATIONUSER\')';
-          }
-          else if (x.ref[1] === 'locale') {
-            return 'SESSION_CONTEXT(\'LOCALE\')';
-          }
-        }
-        else if (x.ref[0] === '$at') {
-          if (x.ref[1] === 'from')
-            return 'TO_TIMESTAMP(SESSION_CONTEXT(\'VALID-FROM\'))';
-
-          else if (x.ref[1] === 'to')
-            return 'TO_TIMESTAMP(SESSION_CONTEXT(\'VALID-TO\'))';
-        }
-        else if (x.ref[0] === '$session' && magicReplacement !== null) {
-          return `'${magicReplacement}'`;
-        }
+      if (s.where) {
+        // Filter, possibly with cardinality
+        result += `[${s.cardinality ? (`${s.cardinality.max}: `) : ''}${renderExpr(s.where, env, inline, true)}]`;
       }
-      return `${(x.param || x.global) ? ':' : ''}${x.ref.map((step, index) => renderPathStep(step, index, x.ref)).join('.')}`;
+      return result;
     }
 
-    /**
-     * Renders an explicit `cast()` inside an 'xpr'.
-     *
-     * @param {string} value Value to cast
-     * @returns {string} Rendered cast()
-     */
-    function renderExplicitTypeCast(value) {
-      let typeRef = renderTypeReference(expr.cast, env);
+    throw new ModelError(`Unknown path step: ${JSON.stringify(s)}`);
+  }
 
-      // inside a cast expression, the cds and hana cds types need to be mapped to hana sql types
-      const hanaSqlType = cdsToSqlTypes.hana[expr.cast.type] || cdsToSqlTypes.standard[expr.cast.type];
-      if (hanaSqlType) {
-        const typeRefWithoutParams = typeRef.substring(0, typeRef.indexOf('(')) || typeRef;
-        typeRef = typeRef.replace(typeRefWithoutParams, hanaSqlType);
-      }
-      return `CAST(${value} AS ${typeRef})`;
+  /**
+   * @param {object} x Expression with a val and/or literal property
+   * @returns {string} Rendered expression
+   */
+  function renderExpressionLiteral(x) {
+    // Literal value, possibly with explicit 'literal' property
+    switch (x.literal || typeof x.val) {
+      case 'number':
+      case 'boolean':
+      case 'null':
+        return x.val;
+      case 'x':
+      case 'date':
+      case 'time':
+      case 'timestamp':
+        return `${x.literal}'${x.val}'`;
+      case 'string':
+        return `'${x.val.replace(/'/g, '\'\'')}'`;
+      case 'object':
+        if (x.val === null)
+          return 'null';
+
+        // otherwise fall through to
+      default:
+        throw new ModelError(`Unknown literal or type: ${JSON.stringify(x)}`);
     }
+  }
 
-    /**
-     * 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
-     * @param {number} idx Path position
-     * @returns {string} Rendered path step
-     */
-    function renderPathStep(s, idx, ref) {
-      // Simple id or absolute name
-      if (typeof s === 'string') {
-        // HANA-specific extra magic (should actually be in forHana)
-        // In HANA, we replace leading $self by the absolute name of the current artifact
-        // (see FIXME at renderArtifact)
-        if (idx === 0 && s === $SELF) {
-          // do not produce USING for $projection
-          if (env.currentArtifactName === $PROJECTION)
-            return env.currentArtifactName;
-
-          return plainNames ? renderAbsoluteNamePlain(env.currentArtifactName, env)
-            : renderAbsoluteNameWithQuotes(env.currentArtifactName, env);
-        }
-        // HANA-specific translation of '$now' and '$user'
-        if (s === '$now' && ref.length === 1)
-          return 'CURRENT_TIMESTAMP';
+  /**
+   * Render the given expression x - which has a .func property
+   *
+   * @param {object} x
+   * @param {CdlRenderEnvironment} env
+   * @returns {string}
+   */
+  function renderExpressionFunc(x, env) {
+    const regex = RegExp(/^[a-zA-Z][\w#$]*$/, 'g');
+    const funcName = regex.test(x.func) ? x.func : quoteId(x.func);
+    // we can't quote functions with parens, issue warning if it is a reserved keyword
+    if (!funcWithoutParen(x, 'hana') && keywords.hdbcds.includes(uppercaseAndUnderscore(funcName)))
+      warning(null, x.$location, `The identifier “${uppercaseAndUnderscore(funcName)}“ is a SAP HANA keyword`);
+    return renderFunc(funcName, x, 'hana', a => renderArgs(a, '=>', env));
+  }
 
-        // In first path position, do not quote $projection and magic $-variables like CURRENT_DATE, $now etc.
-        // FIXME: We should rather explicitly recognize quoting somehow
+  /**
+   * @param {object} x Expression with a ref property
+   * @returns {string} Rendered expression
+   * @todo no extra magic with x.param or x.global
+   */
+  function renderExpressionRef(x, env) {
+    if (!x.param && !x.global) {
+      const magicReplacement = getVariableReplacement(x.ref, options);
+      if (x.ref[0] === '$user') {
+        if (magicReplacement !== null)
+          return `'${magicReplacement}'`;
 
-        // TODO: quote $parameters if it doesn't reference a parameter, this requires knowledge about the kind
-        // Example: both views are correct in HANA CDS
-        // entity E { key id: Integer; }
-        // view EV with parameters P1: Integer as select from E { id, $parameters.P1 };
-        // view EVp as select from E as "$parameters" { "$parameters".id };
+        // Keep old way of solving this to remain backwards compatible
+        // FIXME: this is all not enough: we might need an explicit select item alias
+        if (x.ref[1] === 'id') {
+          if (options.magicVars && options.magicVars.user && (typeof options.magicVars.user === 'string' || options.magicVars.user instanceof String))
+            return `'${options.magicVars.user}'`;
 
-        if (idx === 0 &&
-          [ $SELF, $PROJECTION, '$session' ].includes(s))
-          return s;
+          else if ((options.magicVars && options.magicVars.user && options.magicVars.user.id) && (typeof options.magicVars.user.id === 'string' || options.magicVars.user.id instanceof String))
+            return `'${options.magicVars.user.id}'`;
 
-        return formatIdentifier(s);
-      }
-      // ID with filters or parameters
-      else if (typeof s === 'object') {
-        // Sanity check
-        if (!s.func && !s.id)
-          throw new Error(`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)})`;
-
-        // Path step, possibly with view parameters and/or filters
-        let result = `${formatIdentifier(s.id)}`;
-        if (s.args) {
-          // View parameters
-          result += `(${renderArgs(s, ':', env)})`;
+          return 'SESSION_CONTEXT(\'APPLICATIONUSER\')';
         }
-        if (s.where) {
-          // Filter, possibly with cardinality
-          result += `[${s.cardinality ? (`${s.cardinality.max}: `) : ''}${renderExpr(s.where, env, inline, true)}]`;
+        else if (x.ref[1] === 'locale') {
+          return 'SESSION_CONTEXT(\'LOCALE\')';
         }
-        return result;
       }
+      else if (x.ref[0] === '$at') {
+        if (x.ref[1] === 'from')
+          return 'TO_TIMESTAMP(SESSION_CONTEXT(\'VALID-FROM\'))';
 
-      throw new Error(`Unknown path step: ${JSON.stringify(s)}`);
+        else if (x.ref[1] === 'to')
+          return 'TO_TIMESTAMP(SESSION_CONTEXT(\'VALID-TO\'))';
+      }
+      else if (x.ref[0] === '$session' && magicReplacement !== null) {
+        return `'${magicReplacement}'`;
+      }
     }
+    return `${(x.param || x.global) ? ':' : ''}${x.ref.map((step, index) => renderPathStep(step, index, x.ref, env, this.inline)).join('.')}`;
   }
 
   /**
@@ -1347,7 +1296,7 @@ function toHdbcdsSource(csn, options) {
    * using 'sep' as separator for positional parameters
    *
    * @param {object} node with `args` to render
-   * @param {string} sep Seperator between arguments
+   * @param {string} sep Separator between arguments
    * @param {CdlRenderEnvironment} env Environment
    * @returns {string} Rendered arguments
    */
@@ -1355,15 +1304,15 @@ function toHdbcdsSource(csn, options) {
     const args = node.args ? node.args : {};
     // Positional arguments
     if (Array.isArray(args))
-      return args.map(arg => renderExpr(arg, env)).join(', ');
+      return args.map(arg => renderExpr(arg, env, true, false, true)).join(', ');
 
     // Named arguments (object/dict)
     else if (typeof args === 'object')
       // if this is a function param which is not a reference to the model, we must not quote it
-      return Object.keys(args).map(key => `${node.func ? key : formatIdentifier(key)} ${sep} ${renderExpr(args[key], env)}`).join(', ');
+      return Object.keys(args).map(key => `${node.func ? key : formatIdentifier(key)} ${sep} ${renderExpr(args[key], env, true, false, true)}`).join(', ');
 
 
-    throw new Error(`Unknown args: ${JSON.stringify(args)}`);
+    throw new ModelError(`Unknown args: ${JSON.stringify(args)}`);
   }
 
   /**
@@ -1645,7 +1594,7 @@ function toHdbcdsSource(csn, options) {
       if (plainNames) {
         const art = csn.definitions[name];
         // For 'plain' naming, take all entities and views, nothing else
-        if (art.kind === 'entity' || art.kind === 'view')
+        if (art.kind === 'entity')
           result[name] = art;
       }
       else {
@@ -1690,7 +1639,7 @@ function toHdbcdsSource(csn, options) {
   }
 
   /**
-   * Returns a copy of 'env' with increased indentation (and resetted name prefix)
+   * 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
@@ -1711,15 +1660,15 @@ function toHdbcdsSource(csn, options) {
   }
 
   /**
-   * Return an absolute path 'abspath', with '::' inserted if required by naming strategy 'hdbcds',
+   * Return an absolute path 'absPath', with '::' inserted if required by naming strategy 'hdbcds',
    * with appropriate "-quotes
    *
-   * @param {string} abspath Absolute path to quote
+   * @param {string} absPath Absolute path to quote
    * @returns {string} Quoted path
    */
-  function quoteAbsolutePathString(abspath) {
-    const namespace = getNamespace(csn, abspath);
-    const resultingName = getResultingName(csn, options.sqlMapping, abspath);
+  function quoteAbsolutePathString(absPath) {
+    const namespace = getNamespace(csn, absPath);
+    const resultingName = getResultingName(csn, options.sqlMapping, absPath);
 
     if (hdbcdsNames && namespace)
       return `${quotePathString(namespace)}::${quotePathString(resultingName.slice(namespace.length + 2))}`;
@@ -1736,14 +1685,13 @@ function toHdbcdsSource(csn, options) {
   function quoteId(id) {
     // Should only ever be called for real IDs (i.e. no dots inside)
     if (id.indexOf('.') !== -1)
-      throw new Error(id);
+      throw new ModelError(`HDBCDS: Tried to quote id with dot: ${id}`);
 
 
-    switch (options.forHana.names) {
+    switch (options.sqlMapping) {
       case 'plain':
         return smartId(id, 'hdbcds');
       case 'quoted':
-        return delimitedId(id, 'hdbcds');
       case 'hdbcds':
         return delimitedId(id, 'hdbcds');
       default:
@@ -1752,17 +1700,17 @@ function toHdbcdsSource(csn, options) {
   }
 
   /*
-   * Return an absolute name 'absname', with '::' inserted if required by naming strategy 'hdbcds', quoted
+   * Return an absolute name 'absName', with '::' inserted if required by naming strategy 'hdbcds', quoted
    * as if it was a single identifier (required only for native USINGs)
    *
-   * @param {string} absname Absolute name
-   * @returns {string} Correctly quoted absname
+   * @param {string} absName Absolute name
+   * @returns {string} Correctly quoted absName
    */
-  function quoteAbsoluteNameAsId(absname) {
-    const resultingName = getResultingName(csn, options.sqlMapping, absname);
+  function quoteAbsoluteNameAsId(absName) {
+    const resultingName = getResultingName(csn, options.sqlMapping, absName);
 
     if (hdbcdsNames) {
-      const namespace = getNamespace(csn, absname);
+      const namespace = getNamespace(csn, absName);
       if (namespace)
         return `"${(`${namespace}::${resultingName.substring(namespace.length + 2)}`).replace(/"/g, '""')}"`;
     }
@@ -1776,7 +1724,7 @@ function toHdbcdsSource(csn, options) {
    * @returns {string} Quoted/uppercased id
    */
   function formatIdentifier(id) {
-    id = options.forHana.names === 'plain' ? id.toUpperCase() : id;
+    id = plainNames ? id.toUpperCase() : id;
     return quoteId(id);
   }