@sap/cds-compiler 2.11.2 → 2.13.6

package/lib/render/toRename.js

@@ -70,22 +70,19 @@ function toRenameDdl(csn, options) {
 
       resultStr += Object.keys(art.elements).map((name) => {
         const e = art.elements[name];
-        let result = '';
+        let str = '';
 
         const beforeColumnName = quoteSqlId(name);
         const afterColumnName = plainSqlId(name);
 
         if (!e._ignore) {
-          if (e.target) {
-            resultStr += ' ';
-            result = `  EXEC 'ALTER TABLE ${afterTableName} DROP ASSOCIATION ${beforeColumnName}';\n`;
-          }
-          else if (beforeColumnName !== afterColumnName) {
-            resultStr += ' ';
-            result = `    EXEC 'RENAME COLUMN ${afterTableName}.${beforeColumnName} TO ${afterColumnName}';\n`;
-          }
+          if (e.target)
+            str = `  EXEC 'ALTER TABLE ${afterTableName} DROP ASSOCIATION ${beforeColumnName}';\n`;
+
+          else if (beforeColumnName !== afterColumnName)
+            str = `    EXEC 'RENAME COLUMN ${afterTableName}.${beforeColumnName} TO ${afterColumnName}';\n`;
         }
-        return result;
+        return str;
       }).join('');
     }
     return resultStr;

package/lib/render/toSql.js

@@ -8,6 +8,7 @@ const {
 } = require('../model/csnUtils');
 const {
   renderFunc, beautifyExprArray, cdsToSqlTypes, getHanaComment, hasHanaComment,
+  getSqlSnippets,
 } = require('./utils/common');
 const {
   renderReferentialConstraint, getIdentifierUtils,
@@ -19,6 +20,8 @@ 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');
+const { ModelError } = require('../base/error');
 
 
 /**
@@ -170,6 +173,12 @@ function toSqlDdl(csn, options) {
     comment(comment) {
       return comment && `'${comment.replace(/'/g, '\'\'')}'` || 'NULL';
     },
+    /*
+      Alter SQL snippet for entity.
+     */
+    alterEntitySqlSnippet(tableName, snippet) {
+      return [ `ALTER TABLE ${tableName} ${snippet};` ];
+    },
     /*
       Concatenate multiple statements which are to be treated as one by the API caller.
      */
@@ -185,10 +194,10 @@ function toSqlDdl(csn, options) {
   checkCSNVersion(csn, options);
 
   // The final result in hdb-kind-specific form, without leading CREATE, without trailing newlines
-  // (note that the order here is relevant for transmission into 'resultObj.sql' below and that
+  // (note that the order here is relevant for transmission into 'mainResultObj.sql' below and that
   // the attribute names must be the HDI plugin names for --src hdi)
   // The result object may have a `sql` dictionary for `toSql`.
-  const resultObj = {
+  const mainResultObj = {
     hdbtabletype: Object.create(null),
     hdbtable: Object.create(null),
     hdbindex: Object.create(null),
@@ -214,13 +223,12 @@ function toSqlDdl(csn, options) {
       // Current indentation string
       indent: '',
     };
-    renderArtifactInto(artifactName, artifact, resultObj, env);
+    renderArtifactInto(artifactName, artifact, mainResultObj, env);
   });
 
   // Render each deleted artifact
   for (const artifactName in csn.deletions)
-    renderArtifactDeletionInto(artifactName, csn.deletions[artifactName], resultObj);
-
+    renderArtifactDeletionInto(artifactName, csn.deletions[artifactName], mainResultObj);
 
   // Render each artifact extension
   // Only HANA SQL is currently supported.
@@ -231,7 +239,7 @@ function toSqlDdl(csn, options) {
         const artifactName = extension.extend;
         const _artifact = csn.definitions[artifactName];
         const env = { indent: '', _artifact };
-        renderArtifactExtensionInto(artifactName, _artifact, extension, resultObj, env);
+        renderArtifactExtensionInto(artifactName, _artifact, extension, mainResultObj, env);
       }
     }
   }
@@ -244,7 +252,7 @@ function toSqlDdl(csn, options) {
         const artifactName = migration.migrate;
         const _artifact = csn.definitions[artifactName];
         const env = { indent: '', _artifact };
-        renderArtifactMigrationInto(artifactName, migration, resultObj, env);
+        renderArtifactMigrationInto(artifactName, migration, mainResultObj, env);
       }
     }
   }
@@ -265,34 +273,42 @@ function toSqlDdl(csn, options) {
 
   // Handle hdbKinds separately from alterTable case
   // eslint-disable-next-line no-unused-vars
-  const { deletions, migrations, ...hdbKinds } = resultObj;
+  const { deletions, migrations: _, ...hdbKinds } = mainResultObj;
   for (const hdbKind of Object.keys(hdbKinds)) {
-    for (const name in resultObj[hdbKind]) {
+    for (const name in mainResultObj[hdbKind]) {
       if (options.toSql.src === 'sql') {
-        let sourceString = resultObj[hdbKind][name];
+        let sourceString = mainResultObj[hdbKind][name];
         // 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) {
-        resultObj[hdbKind][name] = sqlVersionLine + resultObj[hdbKind][name];
+        mainResultObj[hdbKind][name] = sqlVersionLine + mainResultObj[hdbKind][name];
       }
     }
     if (options.toSql.src === 'sql')
-      delete resultObj[hdbKind];
+      delete mainResultObj[hdbKind];
+  }
+
+  // add `ALTER TABLE ADD CONSTRAINT` statements per default for `to.sql` w/ dialect `hana`
+  if (!options.constraintsInCreateTable && options.src === 'sql' && options.sqlDialect === 'hana') {
+    const alterStmts = manageConstraints(csn, options);
+
+    for ( const constraintName of Object.keys(alterStmts))
+      sql[constraintName] = `${options.testMode ? '' : sqlVersionLine}${alterStmts[constraintName]}`;
+    mainResultObj.sql = sql;
   }
 
   if (options.toSql.src === 'sql')
-    resultObj.sql = sql;
+    mainResultObj.sql = sql;
 
   for (const name in deletions)
     deletions[name] = `${options.testMode ? '' : sqlVersionLine}${deletions[name]}`;
 
 
   timetrace.stop();
-  return resultObj;
+  return mainResultObj;
 
   /**
    * Render an artifact into the appropriate dictionary of 'resultObj'.
@@ -309,7 +325,6 @@ function toSqlDdl(csn, options) {
 
     switch (art.kind) {
       case 'entity':
-      case 'view':
         if (getNormalizedQuery(art).query) {
           const result = renderView(artifactName, art, env);
           if (result)
@@ -331,7 +346,7 @@ function toSqlDdl(csn, options) {
         // Ignore: not SQL-relevant
         return;
       default:
-        throw new Error(`Unknown artifact kind: ${art.kind}`);
+        throw new ModelError(`Unknown artifact kind: ${art.kind}`);
     }
   }
 
@@ -352,7 +367,7 @@ function toSqlDdl(csn, options) {
       renderExtendInto(artifactName, artifact.elements, ext.elements, resultObj, env, extensionsDuplicateChecker);
 
     if (!artifactName)
-      throw new Error(`Undefined artifact name: ${artifactName}`);
+      throw new ModelError(`Undefined artifact name: ${artifactName}`);
   }
 
   // Render an artifact deletion into the appropriate dictionary of 'resultObj'.
@@ -392,12 +407,26 @@ function toSqlDdl(csn, options) {
         ? renderAssociationElement(eltName, defVariant, env)
         : renderElement(artifactName, eltName, defVariant, null, null, env);
     }
-    function getEltStrNoProp(defVariant, prop, eltName) {
-      const defNoProp = Object.assign({}, defVariant);
-      delete defNoProp[prop];
-      return getEltStr(defNoProp, eltName);
+    function getEltStrNoProps(defVariant, eltName, ...props) {
+      const defNoProps = Object.assign({}, defVariant);
+      for (const prop of props)
+        delete defNoProps[prop];
+      return getEltStr(defNoProps, eltName);
+    }
+    function oldAnnoChangedIncompatibly(defOld, defNew) {
+      return typeof defOld === 'string' && defOld.trim().length && !(typeof defNew === 'string' && defNew.trim().startsWith(`${defOld.trim()} `));
+    }
+    function getUnknownSqlReason(anno, artifactName, defOld, defNew, eltName) {
+      const changeKind = defNew === undefined
+        ? `removed (previous value: ${JSON.stringify(defOld)})`
+        : `changed from ${JSON.stringify(defOld)} to ${JSON.stringify(defNew)}`;
+      return eltName
+        ? `annotation ${anno} of element ${artifactName}:${eltName} has been ${changeKind}`
+        : `annotation ${anno} of artifact ${artifactName} has been ${changeKind}`;
     }
 
+    const sqlSnippetAnnos = [ '@sql.prepend', '@sql.append' ];
+
     const tableName = renderArtifactName(artifactName);
 
     // Change entity properties
@@ -407,6 +436,15 @@ function toSqlDdl(csn, options) {
           const alterComment = render.alterEntityComment(tableName, def.new);
           addMigration(resultObj, artifactName, false, alterComment);
         }
+        else if (sqlSnippetAnnos.includes(prop)) { // NOTE: @sql.replace may be supported in the future
+          if (oldAnnoChangedIncompatibly(def.old, def.new)) {
+            // anno was previously set and current change is not simply an appendix → previous anno would have to be reverted → unknown SQL
+            addMigration(resultObj, artifactName, false, null, getUnknownSqlReason(prop, artifactName, def.old, def.new));
+          }
+          else {
+            addMigration(resultObj, artifactName, false, render.alterEntitySqlSnippet(tableName, def.new));
+          }
+        }
       }
     }
 
@@ -441,9 +479,28 @@ function toSqlDdl(csn, options) {
         if (eltStrNew === eltStrOld)
           return; // Prevent spurious migrations, where the column DDL does not change.
 
+        const annosIncompat = [];
+        sqlSnippetAnnos
+          .filter(anno => def.old[anno] !== def.new[anno])
+          .forEach((anno) => { // NOTE: @sql.replace may be supported in the future
+            if (oldAnnoChangedIncompatibly(def.old[anno], def.new[anno])) {
+              annosIncompat.push(anno);
+              // anno was previously set and current change is not simply an appendix → previous anno would have to be reverted → unknown SQL
+              addMigration(resultObj, artifactName, false, null, getUnknownSqlReason(anno, artifactName, def.old[anno], def.new[anno], eltName));
+            }
+          });
+
+        if (annosIncompat.length) {
+          const eltStrOldNoAnnos = getEltStrNoProps(def.old, eltName, ...annosIncompat);
+          const eltStrNewNoAnnos = getEltStrNoProps(def.new, eltName, ...annosIncompat);
+          if (eltStrOldNoAnnos === eltStrNewNoAnnos) { // only incompatibly-changed annos were modified
+            continue;
+          }
+        }
+
         if (def.old.doc !== def.new.doc) {
-          const eltStrOldNoDoc = getEltStrNoProp(def.old, 'doc', eltName);
-          const eltStrNewNoDoc = getEltStrNoProp(def.new, 'doc', eltName);
+          const eltStrOldNoDoc = getEltStrNoProps(def.old, eltName, 'doc');
+          const eltStrNewNoDoc = getEltStrNoProps(def.new, eltName, 'doc');
           if (eltStrOldNoDoc === eltStrNewNoDoc) { // only `doc` changed
             const alterComment = render.alterColumnComment(tableName, sqlId, def.new.doc);
             addMigration(resultObj, artifactName, false, alterComment);
@@ -483,14 +540,16 @@ function toSqlDdl(csn, options) {
     env._artifact = art;
     const childEnv = increaseIndent(env);
     const hanaTc = art.technicalConfig && art.technicalConfig.hana;
-    let result = '';
+    // tables can have @sql.prepend and @sql.append
+    const { front, back } = getSqlSnippets(options, art);
+    let result = front;
     // Only HANA has row/column tables
     if (options.toSql.dialect === 'hana') {
       if (hanaTc && hanaTc.storeType) {
         // Explicitly specified
         result += `${art.technicalConfig.hana.storeType.toUpperCase()} `;
       }
-      else {
+      else if (!front) {
         // in 'hdbtable' files, COLUMN or ROW is mandatory, and COLUMN is the default
         result += 'COLUMN ';
       }
@@ -500,13 +559,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 +572,9 @@ function toSqlDdl(csn, options) {
     if (primaryKeys !== '')
       result += `,\n${childEnv.indent}${primaryKeys}`;
 
-    if (art.$tableConstraints && art.$tableConstraints.referential) {
+    // for `to.sql` w/ dialect `hana` the constraints will be part of the
+    const constraintsAsAlter = !options.constraintsInCreateTable && options.src === 'sql' && options.sqlDialect === 'hana';
+    if ( !constraintsAsAlter && art.$tableConstraints && art.$tableConstraints.referential) {
       const renderReferentialConstraintsAsHdbconstraint = options.toSql.src === 'hdi';
       const referentialConstraints = {};
       Object.entries(art.$tableConstraints.referential)
@@ -570,6 +627,9 @@ function toSqlDdl(csn, options) {
     if (options.toSql.dialect === 'hana' && hasHanaComment(art, options))
       result += ` COMMENT '${getHanaComment(art)}'`;
 
+    if (back)
+      result += back;
+
     resultObj.hdbtable[artifactName] = result;
   }
 
@@ -601,16 +661,21 @@ function toSqlDdl(csn, options) {
     }
   }
 
-  function addMigration(resultObj, artifactName, drop, sqlArray) {
+  function addMigration(resultObj, artifactName, drop, sqlArray, description) {
     if (!(artifactName in resultObj.migrations))
       resultObj.migrations[artifactName] = [];
 
-    const migrations = sqlArray.map(sql => ({ drop, sql }));
+    if (!sqlArray) {
+      if (description)
+        resultObj.migrations[artifactName].push({ description });
+      return;
+    }
+    const migrations = sqlArray.map(migrationSql => ({ drop, sql: migrationSql }));
     resultObj.migrations[artifactName].push(...migrations);
   }
 
-  function addDeletion(resultObj, artifactName, sql) {
-    resultObj.deletions[artifactName] = sql;
+  function addDeletion(resultObj, artifactName, deletionSql) {
+    resultObj.deletions[artifactName] = deletionSql;
   }
 
   /**
@@ -667,7 +732,13 @@ function toSqlDdl(csn, options) {
     if (fzindex && options.toSql.dialect === 'hana')
       result += ` ${renderExpr(fzindex, env)}`;
 
-    if (options.toSql.dialect === 'hana' && hasHanaComment(elm, options, env._artifact))
+    // (table) elements can only have a @sql.append
+    const { back } = getSqlSnippets(options, elm);
+
+    if (back !== '') // Needs to be rendered before the COMMENT
+      result += back;
+
+    if (options.toSql.dialect === 'hana' && hasHanaComment(elm, options))
       result += ` COMMENT '${getHanaComment(elm)}'`;
 
     return result;
@@ -734,7 +805,7 @@ function toSqlDdl(csn, options) {
     // This also affects renderIndexes
     tc = tc.hana;
     if (!tc)
-      throw new Error('Expecting a HANA technical configuration');
+      throw new ModelError('Expecting a HANA technical configuration');
 
     if (tc.tableSuffix) {
       // Although we could just render the whole bandwurm as one stream of tokens, the
@@ -803,7 +874,7 @@ function toSqlDdl(csn, options) {
       const i = index.indexOf('index');
       const j = index.indexOf('(');
       if (i > index.length - 2 || !index[i + 1].ref || j < i || j > index.length - 2)
-        throw new Error(`Unexpected form of index: "${index}"`);
+        throw new ModelError(`Unexpected form of index: "${index}"`);
 
       let indexName = renderArtifactName(`${artifactName}.${index[i + 1].ref}`);
       if (options.toSql.names === 'plain')
@@ -859,7 +930,7 @@ function toSqlDdl(csn, options) {
 
     // Sanity check
     if (!source.ref)
-      throw new Error(`Expecting ref in ${JSON.stringify(source)}`);
+      throw new ModelError(`Expecting ref in ${JSON.stringify(source)}`);
 
     return renderAbsolutePathWithAlias(artifactName, source, env);
   }
@@ -901,7 +972,7 @@ function toSqlDdl(csn, options) {
   function renderAbsolutePathWithAlias(artifactName, path, env) {
     // This actually can't happen anymore because assoc2joins should have taken care of it
     if (path.ref[0].where)
-      throw new Error(`"${artifactName}": Filters in FROM are not supported for conversion to SQL`);
+      throw new ModelError(`"${artifactName}": Filters in FROM are not supported for conversion to SQL`);
 
 
     // SQL needs a ':' after path.ref[0] to separate associations
@@ -939,7 +1010,7 @@ function toSqlDdl(csn, options) {
   function renderAbsolutePath(path, sep, 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)
     const firstArtifactName = path.ref[0].id || path.ref[0];
@@ -956,7 +1027,7 @@ function toSqlDdl(csn, options) {
     if (ref && ref.params) {
       result += `(${renderArgs(path.ref[0] || {}, '=>', env, syntax)})`;
     }
-    else if ([ 'udf' ].includes(syntax)) {
+    else if (syntax === 'udf') {
       // if syntax is user defined function, render empty argument list
       // CV without parameters is called as simple view
       result += '()';
@@ -979,7 +1050,7 @@ function toSqlDdl(csn, options) {
    * @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
+   * @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.
    */
@@ -987,29 +1058,28 @@ function toSqlDdl(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 : decorateParameter(key, syntax)} ${sep} ${renderExpr(args[key], env)}`).join(', ');
+      return Object.keys(args).map(key => `${node.func ? key : decorateParameter(key, syntax)} ${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)}`);
 
 
     /**
      * Render the given argument/parameter correctly.
      *
      * @param {string} arg Argument to render
-     * @param {string} syntax Some magic A2J paramter - for calcview parameter rendering
+     * @param {string|null} parameterSyntax Some magic A2J parameter - for calcview parameter rendering
      * @returns {string} Rendered argument
      */
-    function decorateParameter(arg, syntax) {
-      if (syntax === 'calcview')
+    function decorateParameter(arg, parameterSyntax) {
+      if (parameterSyntax === 'calcview')
         return `PLACEHOLDER."$$${arg}$$"`;
 
-
       return quoteSqlId(arg);
     }
   }
@@ -1070,6 +1140,11 @@ function toSqlDdl(csn, options) {
       result += `${env.indent})`;
     }
 
+    // views can only have a @sql.append
+    const { back } = getSqlSnippets(options, art);
+    if (back)
+      result += back;
+
     return result;
   }
 
@@ -1077,7 +1152,7 @@ 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 {Array} params Array of parameters
+   * @param {Object} params Dictionary of parameters
    * @returns {string} Rendered parameters
    */
   function renderParameterDefinitions(artifactName, params) {
@@ -1087,7 +1162,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.
@@ -1145,7 +1220,7 @@ function toSqlDdl(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);
@@ -1161,7 +1236,7 @@ function toSqlDdl(csn, options) {
       result += `\n${env.indent}WHERE ${renderExpr(select.where, env, true, true)}`;
 
     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 => renderExpr(expr, env, true, false, true)).join(', ')}`;
 
     if (select.having)
       result += `\n${env.indent}HAVING ${renderExpr(select.having, env, true, true)}`;
@@ -1212,7 +1287,7 @@ function toSqlDdl(csn, options) {
    * @returns {string} Rendered ORDER BY entry
    */
   function renderOrderByEntry(entry, env) {
-    let result = renderExpr(entry, env);
+    let result = renderExpr(entry, env, true, false, true);
     if (entry.sort)
       result += ` ${entry.sort.toUpperCase()}`;
 
@@ -1236,7 +1311,7 @@ function toSqlDdl(csn, options) {
     // Anonymous structured type: Not supported with SQL (but shouldn't happen anyway after forHana flattened them)
     if (!elm.type) {
       if (!elm.elements)
-        throw new Error(`Missing type of: ${elementName}`);
+        throw new ModelError(`Missing type of: ${elementName}`);
 
       // TODO: Signal is not covered by tests + better location
       error(null, [ 'definitions', artifactName, 'elements', elementName ],
@@ -1259,7 +1334,7 @@ function toSqlDdl(csn, options) {
       result += renderBuiltinType(elm.type);
     }
     else {
-      throw new Error(`Unexpected non-primitive type of: ${artifactName}.${elementName}`);
+      throw new ModelError(`Unexpected non-primitive type of: ${artifactName}.${elementName}`);
     }
     result += renderTypeParameters(elm);
     return result;
@@ -1288,7 +1363,7 @@ function toSqlDdl(csn, options) {
    * Render the nullability of an element or parameter (can be unset, true, or false)
    *
    * @param {object} obj Object to render for
-   * @param {boolean} treatKeyAsNotNull Wether to render KEY as not null
+   * @param {boolean} treatKeyAsNotNull Whether to render KEY as not null
    * @returns {string} NULL/NOT NULL or ''
    */
   function renderNullability(obj, treatKeyAsNotNull = false) {
@@ -1333,35 +1408,38 @@ function toSqlDdl(csn, options) {
    * (no trailing LF, don't indent if inline)
    *
    * @todo Reuse this with toCdl
-   * @param {Array|object|string} x Expression to render
+   * @param {Array|object|string} expr Expression to render
    * @param {object} env Render environment
-   * @param {boolean} inline Wether to render the expression inline
-   * @param {boolean} nestedExpr Wether to treat the expression as nested
+   * @param {boolean} [inline=true] Whether to render the expression inline
+   * @param {boolean} [nestedExpr=false] Whether to treat the expression as nested
+   * @param {boolean} [alwaysRenderCast=false] Whether to _always_ render SQL-style casts, even if `nestedExpr === false`.
+   *                                           Note: This is a hack for casts() inside groupBy.
    * @returns {string} Rendered expression
    */
-  function renderExpr(x, env, inline = true, nestedExpr = false) {
+  function renderExpr(expr, env, inline = true, nestedExpr = false, alwaysRenderCast = false) {
     // Compound expression
-    if (Array.isArray(x)) {
-      const tokens = x.map(item => renderExpr(item, env, inline, nestedExpr));
+    if (Array.isArray(expr)) {
+      const tokens = expr.map(item => renderExpr(item, env, inline, nestedExpr));
       return beautifyExprArray(tokens);
     }
-    else if (typeof x === 'object' && x !== null) {
-      if (nestedExpr && x.cast && x.cast.type)
-        return renderExplicitTypeCast(renderExprObject());
-      return renderExprObject();
+    else if (typeof expr === 'object' && expr !== null) {
+      if ((nestedExpr || alwaysRenderCast) && expr.cast && expr.cast.type)
+        return renderExplicitTypeCast(expr, renderExprObject(expr));
+      return renderExprObject(expr);
     }
     // Not a literal value but part of an operator, function etc - just leave as it is
     // FIXME: For the sake of simplicity, we should get away from all this uppercasing in toSql
 
-    return String(x).toUpperCase();
+    return String(expr).toUpperCase();
 
 
     /**
      * Various special cases represented as objects
      *
+     * @param {object} x Expression
      * @returns {string} String representation of the expression
      */
-    function renderExprObject() {
+    function renderExprObject(x) {
       if (x.list) {
         return `(${x.list.map(item => renderExpr(item)).join(', ')})`;
       }
@@ -1404,13 +1482,13 @@ function toSqlDdl(csn, options) {
         return `${renderQuery('<union>', x, increaseIndent(env))}`;
       }
 
-      throw new Error(`Unknown expression: ${JSON.stringify(x)}`);
+      throw new ModelError(`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)})`;
+    function renderWindowFunction(funcName, node, fctEnv) {
+      const suffix = node.xpr[0]; // OVER
+      let r = `${funcName}(${renderArgs(node, '=>', fctEnv, null)})`;
+      r += ` ${suffix} (${renderExpr(node.xpr.slice(1), fctEnv)})`; // do not pass suffix in renderExpr
       return r;
     }
 
@@ -1444,7 +1522,7 @@ function toSqlDdl(csn, options) {
 
         // otherwise fall through to
         default:
-          throw new Error(`Unknown literal or type: ${JSON.stringify(x)}`);
+          throw new ModelError(`Unknown literal or type: ${JSON.stringify(x)}`);
       }
     }
 
@@ -1500,7 +1578,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\')';
@@ -1565,10 +1643,11 @@ function toSqlDdl(csn, options) {
     /**
      * Renders an explicit `cast()` inside an 'xpr'.
      *
+     * @param {object} x Expression with cast
      * @param {string} value Value to cast
      * @returns {string} CAST statement
      */
-    function renderExplicitTypeCast(value) {
+    function renderExplicitTypeCast(x, value) {
       const typeRef = renderBuiltinType(x.cast.type) + renderTypeParameters(x.cast);
       return `CAST(${value} AS ${typeRef})`;
     }
@@ -1606,7 +1685,7 @@ function toSqlDdl(csn, options) {
       else if (typeof s === 'object') {
         // Sanity check
         if (!s.func && !s.id)
-          throw new Error(`Unknown path step object: ${JSON.stringify(s)}`);
+          throw new ModelError(`Unknown path step object: ${JSON.stringify(s)}`);
 
         // Not really a path step but an object-like function call
         if (s.func)
@@ -1626,7 +1705,7 @@ function toSqlDdl(csn, options) {
         return result;
       }
 
-      throw new Error(`Unknown path step: ${JSON.stringify(s)}`);
+      throw new ModelError(`Unknown path step: ${JSON.stringify(s)}`);
     }
   }