@sap/cds-compiler 2.10.2 → 2.11.4

package/lib/render/toHdbcds.js

@@ -3,7 +3,7 @@
 const {
   getParentNameOf, getLastPartOf, getLastPartOfRef,
   hasValidSkipOrExists, isBuiltinType, generatedByCompilerVersion, getNormalizedQuery,
-  getRootArtifactName, getResultingName, getNamespace, forEachMember,
+  getRootArtifactName, getResultingName, getNamespace, forEachMember, getVariableReplacement,
 } = require('../model/csnUtils');
 const keywords = require('../base/keywords');
 const {
@@ -17,7 +17,7 @@ const DuplicateChecker = require('./DuplicateChecker');
 const { isDeprecatedEnabled, forEachDefinition } = require('../base/model');
 const { checkCSNVersion } = require('../json/csnVersion');
 const { makeMessageFunction } = require('../base/messages');
-const timetrace = require('../utils/timetrace');
+const { timetrace } = require('../utils/timetrace');
 
 const { smartId, delimitedId } = require('../sql-identifier');
 
@@ -558,7 +558,7 @@ function toHdbcdsSource(csn, options) {
     result += env.indent + (elm.key && !isSubElement ? 'key ' : '') +
                          (elm.masked ? 'masked ' : '') +
                          quotedElementName + (omitColon ? ' ' : ' : ') +
-                         renderTypeReference(elm, env, undefined) +
+                         renderTypeReference(elm, env) +
                          renderNullability(elm);
     if (elm.default)
       result += ` default ${renderExpr(elm.default, env)}`;
@@ -630,7 +630,7 @@ 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].args, ':', env)})`;
+      result += `(${renderArgs(path.ref[0], ':', env)})`;
 
     if (path.ref[0].where)
       result += `[${path.ref[0].cardinality ? (`${path.ref[0].cardinality.max}: `) : ''}${renderExpr(path.ref[0].where, env, true, true)}]`;
@@ -680,7 +680,7 @@ function toHdbcdsSource(csn, options) {
    */
   function renderViewColumn(col, env, element) {
     // Annotations and column
-    let result = element && hasHanaComment(element, options) ? `${env.indent}@Comment: '${getEscapedHanaComment(element)}'\n` : '';
+    let result = '';
 
     const leaf = col.as || col.ref && col.ref[col.ref.length - 1];
     // Render 'null as <alias>' only for database and if element is virtual
@@ -926,7 +926,7 @@ function toHdbcdsSource(csn, options) {
    */
   function renderParameter(parName, par, env) {
     if (par.notNull === true || par.notNull === false)
-      info(null, env.path.concat([ 'params', parName ]), 'Not Null constraints on HDBCDS view parameters are not allowed and are ignored');
+      info('query-ignoring-param-nullability', env.path.concat([ 'params', parName ]), { '#': 'std' });
     return `${env.indent + formatParamIdentifier(parName, env.path.concat([ 'params', parName ]))} : ${renderTypeReference(par, env)}`;
   }
 
@@ -959,7 +959,7 @@ function toHdbcdsSource(csn, options) {
     }
     else {
       // Derived type or annotation with non-anonymous type
-      result += ` : ${renderTypeReference(art, env, false)};\n`;
+      result += ` : ${renderTypeReference(art, env)};\n`;
     }
     return result;
   }
@@ -970,10 +970,9 @@ function toHdbcdsSource(csn, options) {
    *
    * @param {CSN.Element} elm Element using the type reference
    * @param {CdlRenderEnvironment} env Environment
-   * @param {boolean} [noEnum=false] If true, do not render enums
    * @returns {string} Rendered type reference
    */
-  function renderTypeReference(elm, env, noEnum = false) {
+  function renderTypeReference(elm, env) {
     let result = '';
 
     // Array type: Render items instead
@@ -1011,11 +1010,7 @@ function toHdbcdsSource(csn, options) {
     // Reference to another element
     if (elm.type.ref) {
       // For HANA CDS, we need a 'type of'
-      let result = `type of ${renderAbsolutePath(elm.type, env)}`;
-      if (elm.enum)
-        result += renderEnum(elm.enum, env);
-
-      return result;
+      return `type of ${renderAbsolutePath(elm.type, env)}`;
     }
 
     // If we get here, it must be a named type
@@ -1027,8 +1022,6 @@ function toHdbcdsSource(csn, options) {
       // Type names are never flattened (derived types are unraveled in HANA)
       result += renderAbsoluteNameWithQuotes(elm.type, env);
     }
-    if (elm.enum && !noEnum)
-      result += renderEnum(elm.enum, env);
 
     return result;
   }
@@ -1094,27 +1087,6 @@ function toHdbcdsSource(csn, options) {
     return elm.type.replace(/^cds\./, '') + renderTypeParameters(elm);
   }
 
-  /**
-   * Render the 'enum { ... } part of a type declaration
-   *
-   * @param {CSN.EnumElements} enumPart Enum part of a type declaration
-   * @param {CdlRenderEnvironment} env Environment
-   * @returns {string} Rendered enum
-   */
-  function renderEnum(enumPart, env) {
-    let result = ' enum {\n';
-    const childEnv = increaseIndent(env);
-    for (const name in enumPart) {
-      const enumConst = enumPart[name];
-      result += childEnv.indent + quoteId(name);
-      if (enumConst.val !== undefined)
-        result += ` = ${renderExpr(enumConst, childEnv)}`;
-      result += ';\n';
-    }
-    result += `${env.indent}}`;
-    return result;
-  }
-
   /**
    * Render an expression (including paths and values) or condition 'x'.
    * (no trailing LF, don't indent if inline)
@@ -1229,7 +1201,12 @@ function toHdbcdsSource(csn, options) {
      */
     function renderExpressionRef(x) {
       if (!x.param && !x.global) {
+        const magicReplacement = getVariableReplacement(x.ref, options);
         if (x.ref[0] === '$user') {
+          if (magicReplacement !== null)
+            return `'${magicReplacement}'`;
+
+          // Keep old way of solving this to remain backwards compatible
           // FIXME: this is all not enough: we might need an explicit select item alias
           if (x.ref[1] === 'id') {
             if (options.magicVars && options.magicVars.user && (typeof options.magicVars.user === 'string' || options.magicVars.user instanceof String))
@@ -1251,6 +1228,9 @@ function toHdbcdsSource(csn, options) {
           else if (x.ref[1] === 'to')
             return 'TO_TIMESTAMP(SESSION_CONTEXT(\'VALID-TO\'))';
         }
+        else if (x.ref[0] === '$session' && magicReplacement !== null) {
+          return `'${magicReplacement}'`;
+        }
       }
       return `${(x.param || x.global) ? ':' : ''}${x.ref.map((step, index) => renderPathStep(step, index, x.ref)).join('.')}`;
     }
@@ -1262,7 +1242,7 @@ function toHdbcdsSource(csn, options) {
      * @returns {string} Rendered cast()
      */
     function renderExplicitTypeCast(value) {
-      let typeRef = renderTypeReference(x.cast, env, true);
+      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];
@@ -1288,7 +1268,7 @@ function toHdbcdsSource(csn, options) {
         // (see FIXME at renderArtifact)
         if (idx === 0 && s === $SELF) {
           // do not produce USING for $projection
-          if (env.currentArtifactName === $PROJECTION && env._artifact && env._artifact.projection)
+          if (env.currentArtifactName === $PROJECTION)
             return env.currentArtifactName;
 
           return plainNames ? renderAbsoluteNamePlain(env.currentArtifactName, env)
@@ -1321,13 +1301,13 @@ function toHdbcdsSource(csn, options) {
 
         // Not really a path step but an object-like function call
         if (s.func)
-          return `${s.func}(${renderArgs(s.args, '=>', env)})`;
+          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.args, ':', env)})`;
+          result += `(${renderArgs(s, ':', env)})`;
         }
         if (s.where) {
           // Filter, possibly with cardinality
@@ -1344,19 +1324,21 @@ function toHdbcdsSource(csn, options) {
    * Render function arguments or view parameters (positional if array, named if object/dict),
    * using 'sep' as separator for positional parameters
    *
-   * @param {object[]|object} args (Un)Named arguments
+   * @param {object} node with `args` to render
    * @param {string} sep Seperator between arguments
    * @param {CdlRenderEnvironment} env Environment
    * @returns {string} Rendered arguments
    */
-  function renderArgs(args, sep, env) {
+  function renderArgs(node, sep, env) {
+    const args = node.args ? node.args : {};
     // Positional arguments
     if (Array.isArray(args))
       return args.map(arg => renderExpr(arg, env)).join(', ');
 
     // Named arguments (object/dict)
     else if (typeof args === 'object')
-      return Object.keys(args).map(key => `${formatIdentifier(key)} ${sep} ${renderExpr(args[key], env)}`).join(', ');
+      // 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(', ');
 
 
     throw new Error(`Unknown args: ${JSON.stringify(args)}`);
@@ -1673,11 +1655,6 @@ function toHdbcdsSource(csn, options) {
     if (id.indexOf('.') !== -1)
       throw new Error(id);
 
-    // FIXME: Somewhat arbitrary magic: Do not quote $projection (because HANA CDS doesn't recognize it otherwise).  Similar for $self.
-    // FIXME: The test should not be on the name, but by checking the _artifact.
-    if (id === $PROJECTION || id === $SELF)
-      return id;
-
 
     switch (options.forHana.names) {
       case 'plain':

package/lib/render/toSql.js

@@ -4,7 +4,7 @@
 const {
   getLastPartOf, getLastPartOfRef,
   hasValidSkipOrExists, isBuiltinType, generatedByCompilerVersion, getNormalizedQuery,
-  forEachDefinition, getResultingName,
+  forEachDefinition, getResultingName, getVariableReplacement,
 } = require('../model/csnUtils');
 const {
   renderFunc, beautifyExprArray, cdsToSqlTypes, getHanaComment, hasHanaComment,
@@ -15,10 +15,11 @@ const {
 const DuplicateChecker = require('./DuplicateChecker');
 const { checkCSNVersion } = require('../json/csnVersion');
 const { makeMessageFunction } = require('../base/messages');
-const timetrace = require('../utils/timetrace');
+const { timetrace } = require('../utils/timetrace');
 const { isBetaEnabled, isDeprecatedEnabled } = require('../base/model');
 const { smartFuncId } = require('../sql-identifier');
 const { sortCsn } = require('../json/to-csn');
+const { manageConstraints } = require('./manageConstraints');
 
 
 /**
@@ -221,7 +222,6 @@ function toSqlDdl(csn, options) {
   for (const artifactName in csn.deletions)
     renderArtifactDeletionInto(artifactName, csn.deletions[artifactName], resultObj);
 
-
   // Render each artifact extension
   // Only HANA SQL is currently supported.
   // Note that extensions may contain new elements referenced in migrations, thus should be compiled first.
@@ -273,7 +273,6 @@ function toSqlDdl(csn, options) {
         // Hack: Other than in 'hdbtable' files, in HANA SQL COLUMN is not mandatory but default.
         if (options.toSql.dialect === 'hana' && hdbKind === 'hdbtable' && sourceString.startsWith('COLUMN '))
           sourceString = sourceString.slice('COLUMN '.length);
-
         sql[name] = `${options.testMode ? '' : sqlVersionLine}CREATE ${sourceString};`;
       }
       else if (!options.testMode) {
@@ -284,6 +283,15 @@ function toSqlDdl(csn, options) {
       delete resultObj[hdbKind];
   }
 
+  // add `ALTER TABLE ADD CONSTRAINT` statements if requested
+  if (options.sqlDialect !== 'sqlite' && options.constraintsAsAlter) {
+    const alterStmts = manageConstraints(csn, options);
+
+    for ( const constraintName of Object.keys(alterStmts))
+      sql[constraintName] = `${options.testMode ? '' : sqlVersionLine}${alterStmts[constraintName]}`;
+    resultObj.sql = sql;
+  }
+
   if (options.toSql.src === 'sql')
     resultObj.sql = sql;
 
@@ -385,7 +393,7 @@ function toSqlDdl(csn, options) {
     function reducesTypeSize(def) {
       // HANA does not allow decreasing the value of any of those type parameters.
       return def.old.type === def.new.type &&
-          [ 'length', 'precision', 'scale' ].some(param => def.new[param] < def.old[param]);
+        [ 'length', 'precision', 'scale' ].some(param => def.new[param] < def.old[param]);
     }
     function getEltStr(defVariant, eltName) {
       return defVariant.target
@@ -500,13 +508,9 @@ function toSqlDdl(csn, options) {
     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 !== '') {
+    if (elements !== '')
       result += elements;
-    }
-    else {
-      // TODO: Already be handled by 'empty-entity' reclassification; better location
-      error(null, [ 'definitions', artifactName ], 'Entities must have at least one element that is non-virtual');
-    }
+
     const uniqueFields = Object.keys(art.elements).filter(name => art.elements[name].unique && !art.elements[name].virtual)
       .map(name => quoteSqlId(name))
       .join(', ');
@@ -517,7 +521,8 @@ function toSqlDdl(csn, options) {
     if (primaryKeys !== '')
       result += `,\n${childEnv.indent}${primaryKeys}`;
 
-    if (art.$tableConstraints && art.$tableConstraints.referential) {
+    const constraintsAsAlter = options.constraintsAsAlter && options.sqlDialect !== 'sqlite';
+    if ( !constraintsAsAlter && art.$tableConstraints && art.$tableConstraints.referential) {
       const renderReferentialConstraintsAsHdbconstraint = options.toSql.src === 'hdi';
       const referentialConstraints = {};
       Object.entries(art.$tableConstraints.referential)
@@ -525,12 +530,12 @@ function toSqlDdl(csn, options) {
           referentialConstraints[fileName] = renderReferentialConstraint(referentialConstraint, childEnv.indent, false, csn, options);
         });
       if (renderReferentialConstraintsAsHdbconstraint) {
-        Object.entries(referentialConstraints).forEach( ([ fileName, constraint ]) => {
+        Object.entries(referentialConstraints).forEach(([ fileName, constraint ]) => {
           resultObj.hdbconstraint[fileName] = constraint;
         });
       }
       else {
-        Object.values(referentialConstraints).forEach( (constraint) => {
+        Object.values(referentialConstraints).forEach((constraint) => {
           result += `,\n${constraint}`;
         });
       }
@@ -546,8 +551,7 @@ function toSqlDdl(csn, options) {
           = `UNIQUE INVERTED INDEX ${renderArtifactName(`${artifactName}_${cn}`)} ON ${tableName} (${c.map(cpath => quoteSqlId(cpath.ref[0])).join(', ')})`;
       }
       else {
-        result += `,\n${childEnv.indent}CONSTRAINT ${renderArtifactName(`${artifactName}_${cn}`)} UNIQUE (${
-          c.map(cpath => quoteSqlId(cpath.ref[0])).join(', ')})`;
+        result += `,\n${childEnv.indent}CONSTRAINT ${renderArtifactName(`${artifactName}_${cn}`)} UNIQUE (${c.map(cpath => quoteSqlId(cpath.ref[0])).join(', ')})`;
       }
     }
     result += `${env.indent}\n)`;
@@ -568,7 +572,7 @@ function toSqlDdl(csn, options) {
     if (options.toSql.dialect === 'hana')
       renderIndexesInto(art.technicalConfig && art.technicalConfig.hana.indexes, artifactName, resultObj, env);
 
-    if (options.toSql.dialect === 'hana' && hasHanaComment(art, options, art))
+    if (options.toSql.dialect === 'hana' && hasHanaComment(art, options))
       result += ` COMMENT '${getHanaComment(art)}'`;
 
     resultObj.hdbtable[artifactName] = result;
@@ -659,8 +663,7 @@ function toSqlDdl(csn, options) {
     if (duplicateChecker)
       duplicateChecker.addElement(quotedElementName, elm.$location, elementName);
 
-    let result = `${env.indent + quotedElementName} ${
-      renderTypeReference(artifactName, elementName, elm)
+    let result = `${env.indent + quotedElementName} ${renderTypeReference(artifactName, elementName, elm)
     }${renderNullability(elm, true)}`;
     if (elm.default)
       result += ` DEFAULT ${renderExpr(elm.default, env)}`;
@@ -956,7 +959,7 @@ 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].args || {}, '=>', env, syntax)})`;
+      result += `(${renderArgs(path.ref[0] || {}, '=>', env, syntax)})`;
     }
     else if ([ 'udf' ].includes(syntax)) {
       // if syntax is user defined function, render empty argument list
@@ -978,21 +981,23 @@ function toSqlDdl(csn, options) {
    * Render function arguments or view parameters (positional if array, named if object/dict),
    * using 'sep' as separator for positional parameters
    *
-   * @param {Array|object} args Arguments to render
+   * @param {object} node with `args` to render
    * @param {string} sep Separator between args
    * @param {object} env Render environment
    * @param {string} syntax Some magic A2J paramter - for calcview parameter rendering
    * @returns {string} Rendered arguments
    * @throws Throws if args is not an array or object.
    */
-  function renderArgs(args, sep, env, syntax) {
+  function renderArgs(node, sep, env, syntax) {
+    const args = node.args ? node.args : {};
     // Positional arguments
     if (Array.isArray(args))
       return args.map(arg => renderExpr(arg, env)).join(', ');
 
     // Named arguments (object/dict)
     else if (typeof args === 'object')
-      return Object.keys(args).map(key => `${decorateParameter(key, syntax)} ${sep} ${renderExpr(args[key], env)}`).join(', ');
+      // 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(', ');
 
 
     throw new Error(`Unknown args: ${JSON.stringify(args)}`);
@@ -1054,7 +1059,7 @@ function toSqlDdl(csn, options) {
     definitionsDuplicateChecker.addArtifact(art['@cds.persistence.name'], art && art.$location, artifactName);
     let result = `VIEW ${viewName}`;
 
-    if (options.toSql.dialect === 'hana' && hasHanaComment(art, options, art))
+    if (options.toSql.dialect === 'hana' && hasHanaComment(art, options))
       result += ` COMMENT '${getHanaComment(art)}'`;
 
     result += renderParameterDefinitions(artifactName, art.params);
@@ -1087,7 +1092,7 @@ function toSqlDdl(csn, options) {
       for (const pn in params) {
         const p = params[pn];
         if (p.notNull === true || p.notNull === false)
-          info(null, [ 'definitions', artifactName, 'params', pn ], 'Not Null constraints on SQL view parameters are not allowed and are ignored');
+          info('query-ignoring-param-nullability', [ 'definitions', artifactName, 'params', pn ], { '#': '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.
@@ -1151,12 +1156,11 @@ function toSqlDdl(csn, options) {
     const childEnv = increaseIndent(env);
     result += `SELECT${select.distinct ? ' DISTINCT' : ''}`;
     // FIXME: We probably also need to consider `excluding` here ?
-    result += `\n${
-      (select.columns || [ '*' ])
-        .filter(col => !(select.mixin || Object.create(null))[firstPathStepId(col.ref)]) // No mixin columns
-        .map(col => renderViewColumn(col, childEnv))
-        .filter(s => s !== '')
-        .join(',\n')}\n`;
+    result += `\n${(select.columns || [ '*' ])
+      .filter(col => !(select.mixin || Object.create(null))[firstPathStepId(col.ref)]) // No mixin columns
+      .map(col => renderViewColumn(col, childEnv))
+      .filter(s => s !== '')
+      .join(',\n')}\n`;
     result += `${env.indent}FROM ${renderViewSource(artifactName, select.from, env)}`;
     if (select.where)
       result += `\n${env.indent}WHERE ${renderExpr(select.where, env, true, true)}`;
@@ -1384,6 +1388,8 @@ function toSqlDdl(csn, options) {
       // Function call, possibly with args (use '=>' for named args)
       else if (x.func) {
         const funcName = smartFuncId(prepareIdentifier(x.func), options.toSql.dialect);
+        if (x.xpr)
+          return renderWindowFunction(funcName, x, env);
         return renderFunc(funcName, x, options.toSql.dialect, a => renderArgs(a, '=>', env, null));
       }
       // Nested expression
@@ -1406,29 +1412,36 @@ function toSqlDdl(csn, options) {
       throw new Error(`Unknown expression: ${JSON.stringify(x)}`);
     }
 
+    function renderWindowFunction(funcName, node, env) {
+      const suffix = node.xpr.shift(); // OVER
+      let r = `${funcName}(${renderArgs(node, '=>', env, null)})`;
+      r += ` ${suffix} (${renderExpr(node.xpr, env)})`;
+      return r;
+    }
+
     function renderExpressionLiteral(x) {
       // Literal value, possibly with explicit 'literal' property
       switch (x.literal || typeof x.val) {
         case 'number':
         case 'boolean':
         case 'null':
-        // 17.42, NULL, TRUE
+          // 17.42, NULL, TRUE
           return String(x.val).toUpperCase();
         case 'x':
-        // x'f000'
+          // x'f000'
           return `${x.literal}'${x.val}'`;
         case 'date':
         case 'time':
         case 'timestamp':
           if (options.toSql.dialect === 'sqlite') {
-          // simple string literal '2017-11-02'
+            // simple string literal '2017-11-02'
             return `'${x.val}'`;
           }
           // date'2017-11-02'
           return `${x.literal}'${x.val}'`;
 
         case 'string':
-        // 'foo', with proper escaping
+          // 'foo', with proper escaping
           return `'${x.val.replace(/'/g, '\'\'')}'`;
         case 'object':
           if (x.val === null)
@@ -1442,7 +1455,12 @@ function toSqlDdl(csn, options) {
 
     function renderExpressionRef(x) {
       if (!x.param && !x.global) {
+        const magicReplacement = getVariableReplacement(x.ref, options);
+
         if (x.ref[0] === '$user') {
+          if (magicReplacement !== null)
+            return `'${magicReplacement}'`;
+
           const result = render$user(x);
           // Invalid second path step doesn't cause a return
           if (result)
@@ -1454,6 +1472,9 @@ function toSqlDdl(csn, options) {
           if (result)
             return result;
         }
+        else if (x.ref[0] === '$session' && magicReplacement !== null) {
+          return `'${magicReplacement}'`;
+        }
       }
       // FIXME: We currently cannot distinguish whether '$parameters' was quoted or not - we
       // assume that it was not if the path has length 2 (
@@ -1476,6 +1497,7 @@ function toSqlDdl(csn, options) {
     function render$user(x) {
       // FIXME: this is all not enough: we might need an explicit select item alias
       if (x.ref[1] === 'id') {
+        // Keep the old-style for compatibilty with magicVars.id - instead of magicVars.user.id...
         if (options.toSql.user && typeof options.toSql.user === 'string' || options.toSql.user instanceof String)
           return `'${options.toSql.user}'`;
 
@@ -1483,7 +1505,7 @@ function toSqlDdl(csn, options) {
           return `'${options.toSql.user.id}'`;
 
         if (options.toSql.dialect === 'sqlite' || options.toSql.dialect === 'plain') {
-          warning(null, null, 'The "$user" variable is not supported. Use the "toSql.user" option to set a value for "$user.id"');
+          warning(null, null, 'The "$user" variable is not supported. Use option "variableReplacements" to specify a value for "$user.id"');
           return '\'$user.id\'';
         }
         return 'SESSION_CONTEXT(\'APPLICATIONUSER\')';
@@ -1495,7 +1517,7 @@ function toSqlDdl(csn, options) {
         }
         return 'SESSION_CONTEXT(\'LOCALE\')';
       }
-      // Basically: Second path step was invalid, do nothing
+      // Basically: Second path step was invalid, do nothing - should not happen, see 'unknownMagic.js'
       return null;
     }
     /**
@@ -1593,13 +1615,13 @@ function toSqlDdl(csn, options) {
 
         // Not really a path step but an object-like function call
         if (s.func)
-          return `${s.func}(${renderArgs(s.args, '=>', env, null)})`;
+          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.args, '=>', env, null)})`;
+          result += `(${renderArgs(s, '=>', env, null)})`;
         }
         if (s.where) {
           // Filter, possibly with cardinality

package/lib/render/utils/common.js

@@ -33,7 +33,7 @@ const { implicitAs } = require('../../model/csnRefs');
 function renderFunc( funcName, node, dialect, renderArgs) {
   if (funcWithoutParen( node, dialect ))
     return funcName;
-  return `${funcName}(${renderArgs( node.args )})`;
+  return `${funcName}(${renderArgs( node )})`;
 }
 
 /**