@sap/cds-compiler 2.12.0 → 2.15.2

package/lib/render/toSql.js

@@ -7,8 +7,8 @@ const {
   forEachDefinition, getResultingName, getVariableReplacement,
 } = require('../model/csnUtils');
 const {
-  renderFunc, beautifyExprArray, cdsToSqlTypes, getHanaComment, hasHanaComment,
-  getSqlSnippets,
+  renderFunc, cdsToSqlTypes, getHanaComment, hasHanaComment,
+  getSqlSnippets, getExpressionRenderer,
 } = require('./utils/common');
 const {
   renderReferentialConstraint, getIdentifierUtils,
@@ -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');
 
 
 /**
@@ -76,9 +77,37 @@ const { manageConstraints } = require('./manageConstraints');
 function toSqlDdl(csn, options) {
   timetrace.start('SQL rendering');
   const {
-    error, warning, info, throwWithError,
+    error, warning, info, throwWithAnyError,
   } = makeMessageFunction(csn, options, 'to.sql');
   const { quoteSqlId, prepareIdentifier } = getIdentifierUtils(options);
+  const renderExpr = getExpressionRenderer({
+    finalize: x => String(x).toUpperCase(),
+    explicitTypeCast: (x, env) => {
+      const typeRef = renderBuiltinType(x.cast.type) + renderTypeParameters(x.cast);
+      return `CAST(${renderExpr(x, env)} AS ${typeRef})`;
+    },
+    val: renderExpressionLiteral,
+    enum: (x) => {
+      // TODO: Signal is not covered by tests + better location
+      // FIXME: We can't do enums yet because they are not resolved (and we don't bother finding their value by hand)
+      error(null, x.$location, 'Enum values are not yet supported for conversion to SQL');
+      return '';
+    },
+    ref: renderExpressionRef,
+    aliasOnly(x, _env) {
+      return x.as;
+    },
+    windowFunction: (x, env) => renderWindowFunction(smartFuncId(prepareIdentifier(x.func), options.toSql.dialect), x, env),
+    func: (x, env) => renderFunc(smartFuncId(prepareIdentifier(x.func), options.toSql.dialect), x, options.toSql.dialect, a => renderArgs(a, '=>', env, null)),
+    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('<subselect>', x, increaseIndent(env))})`,
+    SET: (x, env) => `(${renderQuery('<union>', x, increaseIndent(env))})`,
+  });
 
   // Utils to render SQL statements.
   const render = {
@@ -88,7 +117,8 @@ function toSqlDdl(csn, options) {
      */
     addColumns: {
       fromElementStrings(tableName, eltStrings) {
-        return [ `ALTER TABLE ${tableName} ADD (${eltStrings.join(', ')});` ];
+        const elts = options.sqlDialect === 'hana' ? `(${eltStrings.join(', ')})` : `${eltStrings.join(', ')}`;
+        return [ `ALTER TABLE ${tableName} ADD ${elts};` ];
       },
       fromElementsObj(artifactName, tableName, elementsObj, env, duplicateChecker) {
         // Only extend with 'ADD' for elements/associations
@@ -170,7 +200,13 @@ function toSqlDdl(csn, options) {
       Render comment string.
      */
     comment(comment) {
-      return comment && `'${comment.replace(/'/g, '\'\'')}'` || 'NULL';
+      return comment && renderStringForSql(comment, options.sqlDialect) || '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.
@@ -226,7 +262,7 @@ function toSqlDdl(csn, options) {
   // 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.
-  if (csn.extensions && options.toSql.dialect === 'hana') {
+  if (csn.extensions && (options.toSql.dialect === 'hana' || isBetaEnabled(options, 'sqlExtensions'))) {
     for (const extension of options && options.testMode ? sortCsn(csn.extensions) : csn.extensions) {
       if (extension.extend) {
         const artifactName = extension.extend;
@@ -239,7 +275,7 @@ function toSqlDdl(csn, options) {
 
   // Render each artifact change
   // Only HANA SQL is currently supported.
-  if (csn.migrations && options.toSql.dialect === 'hana') {
+  if (csn.migrations && (options.toSql.dialect === 'hana' || isBetaEnabled(options, 'sqlExtensions'))) {
     for (const migration of options && options.testMode ? sortCsn(csn.migrations) : csn.migrations) {
       if (migration.migrate) {
         const artifactName = migration.migrate;
@@ -256,7 +292,7 @@ function toSqlDdl(csn, options) {
   deletionsDuplicateChecker.check(error);
 
   // Throw exception in case of errors
-  throwWithError();
+  throwWithAnyError();
 
   // Transfer results from hdb-specific dictionaries into 'sql' dictionary in proper order if toSql.src === 'sql'
   // (relying on the order of dictionaries above)
@@ -284,8 +320,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 +354,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 +375,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 +396,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,12 +436,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, artName, 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 ${artName}:${eltName} has been ${changeKind}`
+        : `annotation ${anno} of artifact ${artName} has been ${changeKind}`;
     }
 
+    const sqlSnippetAnnos = [ '@sql.prepend', '@sql.append' ];
+
     const tableName = renderArtifactName(artifactName);
 
     // Change entity properties
@@ -416,6 +465,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 +508,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 +578,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 +601,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 = {};
@@ -575,8 +653,8 @@ 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))
-      result += ` COMMENT '${getHanaComment(art)}'`;
+    if (options.sqlDialect === 'hana' && hasHanaComment(art, options))
+      result += ` COMMENT ${renderStringForSql(getHanaComment(art), options.sqlDialect)}`;
 
     if (back)
       result += back;
@@ -612,10 +690,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 +761,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.sqlDialect === 'hana' && hasHanaComment(elm, options))
+      result += ` COMMENT ${renderStringForSql(getHanaComment(elm), options.sqlDialect)}`;
+
     return result;
   }
 
@@ -751,7 +834,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 +903,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 +959,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 +1001,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 +1039,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 +1056,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 +1087,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)}`);
 
 
     /**
@@ -1035,13 +1118,14 @@ function toSqlDdl(csn, options) {
    * Return the resulting source string (one line per column item, no CR).
    *
    * @param {object} col Column to render
+   * @param {CSN.Elements} elements of leading or subquery
    * @param {object} env Render environment
    * @returns {string} Rendered column
    */
-  function renderViewColumn(col, env) {
+  function renderViewColumn(col, elements, env) {
     let result = '';
     const leaf = col.as || col.ref && col.ref[col.ref.length - 1] || col.func;
-    if (leaf && env._artifact.elements[leaf] && env._artifact.elements[leaf].virtual) {
+    if (leaf && elements[leaf] && elements[leaf].virtual) {
       if (isDeprecatedEnabled(options, 'renderVirtualElements'))
         // render a virtual column 'null as <alias>'
         result += `${env.indent}NULL AS ${quoteSqlId(col.as || leaf)}`;
@@ -1070,11 +1154,11 @@ 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))
-      result += ` COMMENT '${getHanaComment(art)}'`;
+    if (options.sqlDialect === 'hana' && hasHanaComment(art, options))
+      result += ` COMMENT ${renderStringForSql(getHanaComment(art), options.sqlDialect)}`;
 
     result += renderParameterDefinitions(artifactName, art.params);
-    result += ` AS ${renderQuery(artifactName, getNormalizedQuery(art).query, env)}`;
+    result += ` AS ${renderQuery(artifactName, getNormalizedQuery(art).query, env, art.elements)}`;
 
     const childEnv = increaseIndent(env);
     const associations = Object.keys(art.elements).filter(name => !!art.elements[name].target)
@@ -1134,9 +1218,10 @@ function toSqlDdl(csn, options) {
    * @param {string} artifactName Artifact containing the query
    * @param {CSN.Query} query CSN query
    * @param {object} env Render environment
+   * @param {CSN.Elements} [elements] to override direct query elements - e.g. leading union should win
    * @returns {string} Rendered query
    */
-  function renderQuery(artifactName, query, env) {
+  function renderQuery(artifactName, query, env, elements = null) {
     let result = '';
     // Set operator, like UNION, INTERSECT, ...
     if (query.SET) {
@@ -1145,7 +1230,7 @@ function toSqlDdl(csn, options) {
           // Wrap each query in the SET in parentheses that
           // - is a SET itself (to preserve precedence between the different SET operations),
           // - has an ORDER BY/LIMIT (because UNION etc. can't stand directly behind an ORDER BY)
-          const queryString = renderQuery(artifactName, arg, env);
+          const queryString = renderQuery(artifactName, arg, env, elements || query.SET.elements);
           return (arg.SET || arg.SELECT && (arg.SELECT.orderBy || arg.SELECT.limit)) ? `(${queryString})` : queryString;
         })
         .join(`\n${env.indent}${query.SET.op && query.SET.op.toUpperCase()}${query.SET.all ? ' ALL ' : ' '}`);
@@ -1166,7 +1251,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);
@@ -1174,7 +1259,7 @@ function toSqlDdl(csn, options) {
     // 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))
+      .map(col => renderViewColumn(col, elements || select.elements, childEnv))
       .filter(s => s !== '')
       .join(',\n')}\n`;
     result += `${env.indent}FROM ${renderViewSource(artifactName, select.from, env)}`;
@@ -1182,7 +1267,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 +1318,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 +1342,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 +1365,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 +1394,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) {
@@ -1349,168 +1434,80 @@ function toSqlDdl(csn, options) {
     return params.length === 0 ? '' : `(${params.join(', ')})`;
   }
 
-  /**
-   * Render an expression (including paths and values) or condition 'x'.
-   * (no trailing LF, don't indent if inline)
-   *
-   * @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
-   * @returns {string} Rendered expression
-   */
-  function renderExpr(expr, env, inline = true, nestedExpr = 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)
-        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
+  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
+        return String(x.val).toUpperCase();
+      case 'x':
+        // x'f000'
+        return `${x.literal}'${x.val}'`;
+      case 'date':
+      case 'time':
+      case 'timestamp':
+        if (options.toSql.dialect === 'sqlite') {
+          // simple string literal '2017-11-02'
+          return `'${x.val}'`;
+        }
+        // date'2017-11-02'
+        return `${x.literal}'${x.val}'`;
 
-    return String(expr).toUpperCase();
+      case 'string':
+        // 'foo', with proper escaping
+        return renderStringForSql(x.val, options.sqlDialect);
+      case 'object':
+        if (x.val === null)
+          return 'NULL';
 
+      // otherwise fall through to
+      default:
+        throw new ModelError(`Unknown literal or type: ${JSON.stringify(x)}`);
+    }
+  }
 
-    /**
-     * Various special cases represented as objects
-     *
-     * @returns {string} String representation of the expression
-     */
-    function renderExprObject(x) {
-      if (x.list) {
-        return `(${x.list.map(item => renderExpr(item)).join(', ')})`;
-      }
-      else if (x.val !== undefined) {
-        return renderExpressionLiteral(x);
-      }
-      // Enum symbol
-      else if (x['#']) {
-        // #foo
-        // TODO: Signal is not covered by tests + better location
-        // FIXME: We can't do enums yet because they are not resolved (and we don't bother finding their value by hand)
-        error(null, x.$location, 'Enum values are not yet supported for conversion to SQL');
-        return '';
-      }
-      // 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) {
-        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
-      else if (x.xpr) {
-        if (nestedExpr && !x.cast)
-          return `(${renderExpr(x.xpr, env, inline, true)})`;
+  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}'`;
 
-        return renderExpr(x.xpr, env, inline, true);
+        const result = render$user();
+        // Invalid second path step doesn't cause a return
+        if (result)
+          return result;
       }
-      // Sub-select
-      else if (x.SELECT) {
-        // renderQuery for SELECT does not bring its own parentheses (because it is also used in renderView)
-        return `(${renderQuery('<subselect>', x, increaseIndent(env))})`;
+      else if (x.ref[0] === '$at') {
+        const result = render$at();
+        // Invalid second path step doesn't cause a return
+        if (result)
+          return result;
       }
-      else if (x.SET) {
-        // renderQuery for SET always brings its own parentheses (because it is also used in renderViewSource)
-        return `${renderQuery('<union>', x, increaseIndent(env))}`;
+      else if (x.ref[0] === '$session' && magicReplacement !== null) {
+        return `'${magicReplacement}'`;
       }
-
-      throw new Error(`Unknown expression: ${JSON.stringify(x)}`);
     }
-
-    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;
+    // FIXME: We currently cannot distinguish whether '$parameters' was quoted or not - we
+    // assume that it was not if the path has length 2 (
+    if (firstPathStepId(x.ref) === '$parameters' && x.ref.length === 2) {
+      // Parameters must be uppercased and unquoted in SQL
+      return `:${x.ref[1].toUpperCase()}`;
     }
+    if (x.param)
+      return `:${x.ref[0].toUpperCase()}`;
 
-    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
-          return String(x.val).toUpperCase();
-        case 'x':
-          // x'f000'
-          return `${x.literal}'${x.val}'`;
-        case 'date':
-        case 'time':
-        case 'timestamp':
-          if (options.toSql.dialect === 'sqlite') {
-            // simple string literal '2017-11-02'
-            return `'${x.val}'`;
-          }
-          // date'2017-11-02'
-          return `${x.literal}'${x.val}'`;
-
-        case 'string':
-          // 'foo', with proper escaping
-          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)}`);
-      }
-    }
-
-    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)
-            return result;
-        }
-        else if (x.ref[0] === '$at') {
-          const result = render$at(x);
-          // Invalid second path step doesn't cause a return
-          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 (
-      if (firstPathStepId(x.ref) === '$parameters' && x.ref.length === 2) {
-        // Parameters must be uppercased and unquoted in SQL
-        return `:${x.ref[1].toUpperCase()}`;
-      }
-      if (x.param)
-        return `:${x.ref[0].toUpperCase()}`;
-
-      return x.ref.map(renderPathStep)
-        .filter(s => s !== '')
-        .join('.');
-    }
+    return x.ref.map(renderPathStep)
+      .filter(s => s !== '')
+      .join('.');
 
     /**
-     * @param {object} x
      * @returns {string|null} Null in case of an invalid second path step
      */
-    function render$user(x) {
+    function render$user() {
       // 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...
@@ -1538,18 +1535,17 @@ function toSqlDdl(csn, options) {
     }
     /**
      * For a given reference starting with $at, render a 'current_timestamp' literal for plain.
-     * For the sql-dialect hana, we render the TO_TIMESTAMP(SESSION_CONTEXT(..)) function.
-     *
-     *
-     * For sqlite, we render the string-format-time (strftime) function.
-     * Because the format of `current_timestamp` is like that: '2021-05-14 09:17:19' whereas
-     * the format for TimeStamps (at least in Node.js) is like that: '2021-01-01T00:00:00.000Z'
-     * --> Therefore the comparison in the temporal where clause doesn't work properly.
-     *
-     * @param {object} x
-     * @returns {string|null} Null in case of an invalid second path step
-     */
-    function render$at(x) {
+      * For the sql-dialect hana, we render the TO_TIMESTAMP(SESSION_CONTEXT(..)) function.
+      *
+      *
+      * For sqlite, we render the string-format-time (strftime) function.
+      * Because the format of `current_timestamp` is like that: '2021-05-14 09:17:19' whereas
+      * the format for TimeStamps (at least in Node.js) is like that: '2021-01-01T00:00:00.000Z'
+      * --> Therefore the comparison in the temporal where clause doesn't work properly.
+      *
+      * @returns {string|null} Null in case of an invalid second path step
+      */
+    function render$at() {
       if (x.ref[1] === 'from') {
         switch (options.toSql.dialect) {
           case 'sqlite': {
@@ -1583,18 +1579,6 @@ function toSqlDdl(csn, options) {
       return null;
     }
 
-    /**
-     * 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(x, value) {
-      const typeRef = renderBuiltinType(x.cast.type) + renderTypeParameters(x.cast);
-      return `CAST(${value} AS ${typeRef})`;
-    }
-
     /**
      * Render a single path step 's' at path position 'idx', which can have filters or parameters or be a function
      *
@@ -1628,7 +1612,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,10 +1632,17 @@ function toSqlDdl(csn, options) {
         return result;
       }
 
-      throw new Error(`Unknown path step: ${JSON.stringify(s)}`);
+      throw new ModelError(`Unknown path step: ${JSON.stringify(s)}`);
     }
   }
 
+  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;
+  }
+
   /**
    * Returns a copy of 'env' with increased indentation
    *
@@ -1663,6 +1654,54 @@ function toSqlDdl(csn, options) {
   }
 }
 
+/**
+ * Render the given string for SQL databases.
+ *
+ * @param {string} str
+ * @param {string} sqlDialect
+ * @return {string}
+ */
+function renderStringForSql(str, sqlDialect) {
+  if (sqlDialect === 'hana' || sqlDialect === 'sqlite') {
+    // SQLite
+    // ======
+    // SQLite's tokenizer available at
+    // <https://www.sqlite.org/src/file?name=src/tokenize.c>.
+    //
+    // Note that NUL may have side effects, as explained on
+    // <https://sqlite.org/nulinstr.html>.
+    //
+    //
+    // HANA
+    // ====
+    // Respects the specification available at
+    // <https://help.sap.com/doc/9b40bf74f8644b898fb07dabdd2a36ad/2.0.04/en-US/SAP_HANA_SQL_Reference_Guide_en.pdf>.
+    //
+    //   <string_literal> ::= <single_quote>[<any_character>...]<single_quote>
+    //   <single_quote> ::= '
+    //
+    //  and
+    //  > # Quotation marks
+    //  > Single quotation marks are used to delimit string literals.
+    //  > A single quotation mark itself can be represented using two single quotation marks.
+    str = str.replace(/'/g, '\'\'')
+      .replace(/\u{0}/ug, '\' || CHAR(0) || \'');
+  }
+  else {
+    // Generic SQL databases
+    // =====================
+    // While escaping NUL may be useful to avoid the SQL file being identified as binary,
+    // we can't escape it using `CHAR(0)`.  This function is not available on e.g. PostgreSQL.
+    // On top of this, PostgreSQL also has this limitation:
+    // > chr(int) | text | Character with the given code. For UTF8 the argument is treated as a Unicode code point.
+    // >          |      | For other multibyte encodings the argument must designate an ASCII character. The NULL (0)
+    // >          |      | character is not allowed because text data types cannot store such bytes.
+    // - <https://www.postgresql.org/docs/9.1/functions-string.html>
+    str = str.replace(/'/g, '\'\'');
+  }
+  return `'${str}'`;
+}
+
 module.exports = {
   toSqlDdl,
 };