@sap/cds-compiler 2.12.0 → 2.13.6

package/lib/render/toHdbcds.js

@@ -20,6 +20,7 @@ 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';
@@ -152,7 +153,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 +177,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,7 +213,7 @@ 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
@@ -313,7 +313,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 +469,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 +544,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 +628,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)
@@ -791,7 +791,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
@@ -823,7 +823,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);
@@ -870,7 +870,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 +927,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 +1011,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);
@@ -1116,15 +1116,17 @@ function toHdbcdsSource(csn, options) {
    * @param {CdlRenderEnvironment} env Environment
    * @param {boolean} [inline=true] Whether to render inline
    * @param {boolean} [inExpr=false] Whether the expression is already inside another expression
+   * @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(expr, env, inline = true, inExpr = false) {
+  function renderExpr(expr, env, inline = true, inExpr = false, alwaysRenderCast = 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)
+      if ((inExpr || alwaysRenderCast) && expr.cast && expr.cast.type)
         return renderExplicitTypeCast(renderExprObject(expr));
       return renderExprObject(expr);
     }
@@ -1186,7 +1188,7 @@ function toHdbcdsSource(csn, options) {
         return `${renderQuery(x, false, increaseIndent(env))}`;
       }
 
-      throw new Error(`Unknown expression: ${JSON.stringify(x)}`);
+      throw new ModelError(`Unknown expression: ${JSON.stringify(x)}`);
     }
     /**
      * @param {object} x Expression with a val and/or literal property
@@ -1212,7 +1214,7 @@ function toHdbcdsSource(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)}`);
       }
     }
 
@@ -1319,7 +1321,7 @@ function toHdbcdsSource(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)
@@ -1338,7 +1340,7 @@ function toHdbcdsSource(csn, options) {
         return result;
       }
 
-      throw new Error(`Unknown path step: ${JSON.stringify(s)}`);
+      throw new ModelError(`Unknown path step: ${JSON.stringify(s)}`);
     }
   }
 
@@ -1355,15 +1357,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 +1647,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 {
@@ -1736,7 +1738,7 @@ 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(id);
 
 
     switch (options.forHana.names) {

package/lib/render/toSql.js

@@ -21,6 +21,7 @@ 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');
 
 
 /**
@@ -172,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.
      */
@@ -284,8 +291,8 @@ function toSqlDdl(csn, options) {
       delete mainResultObj[hdbKind];
   }
 
-  // add `ALTER TABLE ADD CONSTRAINT` statements if requested
-  if (options.sqlDialect !== 'sqlite' && options.constraintsAsAlter) {
+  // 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))
@@ -318,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)
@@ -340,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}`);
     }
   }
 
@@ -361,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'.
@@ -401,11 +407,25 @@ 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);
 
@@ -416,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));
+          }
+        }
       }
     }
 
@@ -450,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);
@@ -501,7 +549,7 @@ function toSqlDdl(csn, options) {
         // 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 ';
       }
@@ -524,7 +572,8 @@ function toSqlDdl(csn, options) {
     if (primaryKeys !== '')
       result += `,\n${childEnv.indent}${primaryKeys}`;
 
-    const constraintsAsAlter = options.constraintsAsAlter && options.sqlDialect !== 'sqlite';
+    // 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 = {};
@@ -612,10 +661,15 @@ 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] = [];
 
+    if (!sqlArray) {
+      if (description)
+        resultObj.migrations[artifactName].push({ description });
+      return;
+    }
     const migrations = sqlArray.map(migrationSql => ({ drop, sql: migrationSql }));
     resultObj.migrations[artifactName].push(...migrations);
   }
@@ -678,15 +732,15 @@ function toSqlDdl(csn, options) {
     if (fzindex && options.toSql.dialect === 'hana')
       result += ` ${renderExpr(fzindex, env)}`;
 
-    if (options.toSql.dialect === 'hana' && hasHanaComment(elm, options))
-      result += ` COMMENT '${getHanaComment(elm)}'`;
-
     // (table) elements can only have a @sql.append
     const { back } = getSqlSnippets(options, elm);
 
-    if (back !== '')
+    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;
   }
 
@@ -751,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
@@ -820,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')
@@ -876,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);
   }
@@ -918,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
@@ -956,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];
@@ -973,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 += '()';
@@ -1004,15 +1058,15 @@ 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)}`);
 
 
     /**
@@ -1166,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);
@@ -1182,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)}`;
@@ -1233,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()}`;
 
@@ -1257,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 ],
@@ -1280,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;
@@ -1309,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) {
@@ -1356,18 +1410,20 @@ function toSqlDdl(csn, options) {
    * @todo Reuse this with toCdl
    * @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(expr, env, inline = true, nestedExpr = false) {
+  function renderExpr(expr, env, inline = true, nestedExpr = false, alwaysRenderCast = false) {
     // Compound expression
     if (Array.isArray(expr)) {
       const tokens = expr.map(item => renderExpr(item, env, inline, nestedExpr));
       return beautifyExprArray(tokens);
     }
     else if (typeof expr === 'object' && expr !== null) {
-      if (nestedExpr && expr.cast && expr.cast.type)
+      if ((nestedExpr || alwaysRenderCast) && expr.cast && expr.cast.type)
         return renderExplicitTypeCast(expr, renderExprObject(expr));
       return renderExprObject(expr);
     }
@@ -1380,6 +1436,7 @@ function toSqlDdl(csn, options) {
     /**
      * Various special cases represented as objects
      *
+     * @param {object} x Expression
      * @returns {string} String representation of the expression
      */
     function renderExprObject(x) {
@@ -1425,7 +1482,7 @@ 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, fctEnv) {
@@ -1465,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)}`);
       }
     }
 
@@ -1628,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)
@@ -1648,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)}`);
     }
   }
 

package/lib/render/utils/common.js

@@ -19,8 +19,6 @@ const {
 } = require('../../model/csnUtils');
 
 const { implicitAs } = require('../../model/csnRefs');
-const { isBetaEnabled } = require('../../base/model');
-
 
 /**
  * Render the given function
@@ -38,7 +36,7 @@ function renderFunc( funcName, node, dialect, renderArgs) {
 }
 
 /**
- * Checks wether the given function is to be rendered without parentheses
+ * Checks whether the given function is to be rendered without parentheses
  *
  * @param {object} node Content of the function
  * @param {string} dialect One of 'hana', 'cap' or 'sqlite' - only 'hana' is relevant atm
@@ -332,7 +330,7 @@ function addIntermediateContexts(csn, killList) {
 }
 
 /**
- * Check wether the given artifact or element has a comment that needs to be rendered.
+ * Check whether the given artifact or element has a comment that needs to be rendered.
  * Things annotated with @cds.persistence.journal (for HANA SQL), should not get a comment.
  *
  * @param {CSN.Artifact} obj
@@ -364,13 +362,10 @@ function getHanaComment(obj) {
  * @returns {object} object with .front and .back
  */
 function getSqlSnippets(options, obj) {
-  if (isBetaEnabled(options, 'sqlSnippets')) {
-    const front = obj['@sql.prepend'] ? `${obj['@sql.prepend']} ` : '';
-    const back = obj['@sql.append'] ? ` ${obj['@sql.append']}` : '';
+  const front = obj['@sql.prepend'] ? `${obj['@sql.prepend']} ` : '';
+  const back = obj['@sql.append'] ? ` ${obj['@sql.append']}` : '';
 
-    return { front, back };
-  }
-  return { front: '', back: '' };
+  return { front, back };
 }
 
 /**

package/lib/render/utils/sql.js

@@ -4,13 +4,14 @@
 
 const { getResultingName } = require('../../model/csnUtils');
 const { smartId, delimitedId } = require('../../sql-identifier');
+const { ModelError } = require('../../base/error');
 
 /**
  * Render a given referential constraint as part of a SQL CREATE TABLE statement, or as .hdbconstraint artefact.
  *
  * @param {CSN.ReferentialConstraint} constraint Content of the constraint
  * @param {string} indent Indent to render the SQL with
- * @param {boolean} toUpperCase Wether to uppercase the identifier
+ * @param {boolean} toUpperCase Whether to uppercase the identifier
  * @param {CSN.Model} csn CSN
  * @param {CSN.Options} options is needed for the naming mode and the sql dialect
  * @param {boolean} [alterConstraint=false] whether the constraint should be rendered as part of an ALTER TABLE statement
@@ -121,7 +122,7 @@ function getIdentifierUtils(options) {
   function prepareIdentifier(name) {
     // Sanity check
     if (options.toSql.dialect === 'sqlite' && options.toSql.names !== 'plain')
-      throw new Error(`Not expecting ${options.toSql.names} names for 'sqlite' dialect`);
+      throw new ModelError(`Not expecting ${options.toSql.names} names for 'sqlite' dialect`);
 
 
     switch (options.toSql.names) {
@@ -132,7 +133,7 @@ function getIdentifierUtils(options) {
       case 'hdbcds':
         return name;
       default:
-        throw new Error(`No matching rendering found for naming mode ${options.toSql.names}`);
+        throw new ModelError(`No matching rendering found for naming mode ${options.toSql.names}`);
     }
   }
 }