@sap/cds-compiler 2.13.8 → 3.0.0

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,
@@ -77,9 +77,37 @@ const { ModelError } = require('../base/error');
 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.sqlDialect), x, env),
+    func: (x, env) => renderFunc(smartFuncId(prepareIdentifier(x.func), options.sqlDialect), x, options.sqlDialect, 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 = {
@@ -89,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
@@ -171,7 +200,7 @@ 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.
@@ -209,7 +238,7 @@ function toSqlDdl(csn, options) {
   };
 
   // Registries for artifact and element names per CSN section
-  const definitionsDuplicateChecker = new DuplicateChecker(options.toSql.names);
+  const definitionsDuplicateChecker = new DuplicateChecker(options.sqlMapping);
   const deletionsDuplicateChecker = new DuplicateChecker();
   const extensionsDuplicateChecker = new DuplicateChecker();
   const removeElementsDuplicateChecker = new DuplicateChecker();
@@ -233,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.sqlDialect === 'hana' || isBetaEnabled(options, 'sqlExtensions'))) {
     for (const extension of options && options.testMode ? sortCsn(csn.extensions) : csn.extensions) {
       if (extension.extend) {
         const artifactName = extension.extend;
@@ -246,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.sqlDialect === 'hana' || isBetaEnabled(options, 'sqlExtensions'))) {
     for (const migration of options && options.testMode ? sortCsn(csn.migrations) : csn.migrations) {
       if (migration.migrate) {
         const artifactName = migration.migrate;
@@ -263,9 +292,9 @@ 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'
+  // Transfer results from hdb-specific dictionaries into 'sql' dictionary in proper order if src === 'sql'
   // (relying on the order of dictionaries above)
   // FIXME: Should consider inter-view dependencies, too
   const sql = Object.create(null);
@@ -276,10 +305,10 @@ function toSqlDdl(csn, options) {
   const { deletions, migrations: _, ...hdbKinds } = mainResultObj;
   for (const hdbKind of Object.keys(hdbKinds)) {
     for (const name in mainResultObj[hdbKind]) {
-      if (options.toSql.src === 'sql') {
+      if (options.src === 'sql') {
         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 '))
+        if (options.sqlDialect === 'hana' && hdbKind === 'hdbtable' && sourceString.startsWith('COLUMN '))
           sourceString = sourceString.slice('COLUMN '.length);
         sql[name] = `${options.testMode ? '' : sqlVersionLine}CREATE ${sourceString};`;
       }
@@ -287,7 +316,7 @@ function toSqlDdl(csn, options) {
         mainResultObj[hdbKind][name] = sqlVersionLine + mainResultObj[hdbKind][name];
       }
     }
-    if (options.toSql.src === 'sql')
+    if (options.src === 'sql')
       delete mainResultObj[hdbKind];
   }
 
@@ -300,7 +329,7 @@ function toSqlDdl(csn, options) {
     mainResultObj.sql = sql;
   }
 
-  if (options.toSql.src === 'sql')
+  if (options.src === 'sql')
     mainResultObj.sql = sql;
 
   for (const name in deletions)
@@ -391,7 +420,7 @@ function toSqlDdl(csn, options) {
    * @returns {string} Artifact name
    */
   function renderArtifactName(artifactName) {
-    return quoteSqlId(getResultingName(csn, options.toSql.names, artifactName));
+    return quoteSqlId(getResultingName(csn, options.sqlMapping, artifactName));
   }
 
   // Render an artifact migration into the appropriate dictionary of 'resultObj'.
@@ -416,13 +445,13 @@ function toSqlDdl(csn, options) {
     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) {
+    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 ${artifactName}:${eltName} has been ${changeKind}`
-        : `annotation ${anno} of artifact ${artifactName} has been ${changeKind}`;
+        ? `annotation ${anno} of element ${artName}:${eltName} has been ${changeKind}`
+        : `annotation ${anno} of artifact ${artName} has been ${changeKind}`;
     }
 
     const sqlSnippetAnnos = [ '@sql.prepend', '@sql.append' ];
@@ -544,7 +573,7 @@ function toSqlDdl(csn, options) {
     const { front, back } = getSqlSnippets(options, art);
     let result = front;
     // Only HANA has row/column tables
-    if (options.toSql.dialect === 'hana') {
+    if (options.sqlDialect === 'hana') {
       if (hanaTc && hanaTc.storeType) {
         // Explicitly specified
         result += `${art.technicalConfig.hana.storeType.toUpperCase()} `;
@@ -575,7 +604,7 @@ function toSqlDdl(csn, options) {
     // 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 renderReferentialConstraintsAsHdbconstraint = options.src === 'hdi';
       const referentialConstraints = {};
       Object.entries(art.$tableConstraints.referential)
         .forEach(([ fileName, referentialConstraint ]) => {
@@ -598,7 +627,7 @@ function toSqlDdl(csn, options) {
     const uniqueConstraints = art.$tableConstraints && art.$tableConstraints.unique;
     for (const cn in uniqueConstraints) {
       const c = uniqueConstraints[cn];
-      if (options.toSql.src === 'hdi') {
+      if (options.src === 'hdi') {
         resultObj.hdbindex[`${artifactName}.${cn}`]
           = `UNIQUE INVERTED INDEX ${renderArtifactName(`${artifactName}_${cn}`)} ON ${tableName} (${c.map(cpath => quoteSqlId(cpath.ref[0])).join(', ')})`;
       }
@@ -608,24 +637,24 @@ function toSqlDdl(csn, options) {
     }
     result += `${env.indent}\n)`;
 
-    if (options.toSql.dialect === 'hana')
+    if (options.sqlDialect === 'hana')
       result += renderTechnicalConfiguration(art.technicalConfig, childEnv);
 
 
     const associations = Object.keys(art.elements).map(name => renderAssociationElement(name, art.elements[name], childEnv))
       .filter(s => s !== '')
       .join(',\n');
-    if (associations !== '' && options.toSql.dialect === 'hana') {
+    if (associations !== '' && options.sqlDialect === 'hana') {
       result += `${env.indent} WITH ASSOCIATIONS (\n${associations}\n`;
       result += `${env.indent})`;
     }
     // Only HANA has indices
     // FIXME: Really? We should provide a DB-agnostic way to specify that
-    if (options.toSql.dialect === 'hana')
+    if (options.sqlDialect === '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;
@@ -729,7 +758,7 @@ function toSqlDdl(csn, options) {
       result += ` DEFAULT ${renderExpr(elm.default, env)}`;
 
     // Only HANA has fuzzy indices
-    if (fzindex && options.toSql.dialect === 'hana')
+    if (fzindex && options.sqlDialect === 'hana')
       result += ` ${renderExpr(fzindex, env)}`;
 
     // (table) elements can only have a @sql.append
@@ -738,8 +767,8 @@ function toSqlDdl(csn, options) {
     if (back !== '') // Needs to be rendered before the COMMENT
       result += back;
 
-    if (options.toSql.dialect === 'hana' && hasHanaComment(elm, options))
-      result += ` COMMENT '${getHanaComment(elm)}'`;
+    if (options.sqlDialect === 'hana' && hasHanaComment(elm, options))
+      result += ` COMMENT ${renderStringForSql(getHanaComment(elm), options.sqlDialect)}`;
 
     return result;
   }
@@ -877,7 +906,7 @@ function toSqlDdl(csn, options) {
         throw new ModelError(`Unexpected form of index: "${index}"`);
 
       let indexName = renderArtifactName(`${artifactName}.${index[i + 1].ref}`);
-      if (options.toSql.names === 'plain')
+      if (options.sqlMapping === 'plain')
         indexName = indexName.replace(/(\.|::)/g, '_');
 
       const result = index.slice(0, i + 1); // CREATE UNIQUE INDEX
@@ -916,7 +945,7 @@ function toSqlDdl(csn, options) {
       let result = `${renderViewSource(artifactName, source.args[0], env)}`;
       for (let i = 1; i < source.args.length; i++) {
         result = `(${result} ${source.join.toUpperCase()} `;
-        if (options.toSql.dialect === 'hana')
+        if (options.sqlDialect === 'hana')
           result += renderJoinCardinality(source.cardinality);
         result += `JOIN ${renderViewSource(artifactName, source.args[i], env)}`;
         if (source.on)
@@ -979,7 +1008,7 @@ function toSqlDdl(csn, options) {
     let result = renderAbsolutePath(path, ':', env);
 
     // Take care of aliases
-    const implicitAlias = path.ref.length === 0 ? getLastPartOf(getResultingName(csn, options.toSql.names, path.ref[0])) : getLastPartOfRef(path.ref);
+    const implicitAlias = path.ref.length === 0 ? getLastPartOf(getResultingName(csn, options.sqlMapping, path.ref[0])) : getLastPartOfRef(path.ref);
     if (path.as) {
       // Source had an alias - render it
       result += ` AS ${quoteSqlId(path.as)}`;
@@ -1089,14 +1118,15 @@ 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 (isDeprecatedEnabled(options, 'renderVirtualElements'))
+    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)}`;
     }
@@ -1124,18 +1154,18 @@ 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)
       .map(name => renderAssociationElement(name, art.elements[name], childEnv))
       .filter(s => s !== '')
       .join(',\n');
-    if (associations !== '' && options.toSql.dialect === 'hana') {
+    if (associations !== '' && options.sqlDialect === 'hana') {
       result += `${env.indent}\nWITH ASSOCIATIONS (\n${associations}\n`;
       result += `${env.indent})`;
     }
@@ -1167,7 +1197,7 @@ function toSqlDdl(csn, options) {
         // this would be an incompatible change, as non-uppercased, quoted identifiers
         // are rejected by the HANA compiler.
         let pIdentifier;
-        if (options.toSql.names === 'quoted' || options.toSql.names === 'hdbcds')
+        if (options.sqlMapping === 'quoted' || options.sqlMapping === 'hdbcds')
           pIdentifier = prepareIdentifier(pn);
         else
           pIdentifier = quoteSqlId(pn);
@@ -1188,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) {
@@ -1199,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 ' : ' '}`);
@@ -1228,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)}`;
@@ -1355,7 +1386,7 @@ function toSqlDdl(csn, options) {
       'cds.LocalTime': 'cds.Time',
     };
     const tName = forHanaRenamesToEarly[typeName] || typeName;
-    const types = cdsToSqlTypes[options.toSql.dialect];
+    const types = cdsToSqlTypes[options.sqlDialect];
     return types && types[tName] || cdsToSqlTypes.standard[tName] || 'CHAR';
   }
 
@@ -1395,7 +1426,7 @@ function toSqlDdl(csn, options) {
 
     if (elm.srid !== undefined) {
       // SAP HANA Geometry types translate into CHAR in plain/sqlite (give them the default length of 2000)
-      if (options.toSql.dialect !== 'hana')
+      if (options.sqlDialect !== 'hana')
         params.push(2000);
       else
         params.push(elm.srid);
@@ -1403,218 +1434,128 @@ 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=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, 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 || alwaysRenderCast) && expr.cast && expr.cast.type)
-        return renderExplicitTypeCast(expr, renderExprObject(expr));
-      return renderExprObject(expr);
+  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.sqlDialect === '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 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)}`);
     }
-    // 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(expr).toUpperCase();
+  function renderExpressionRef(x, env) {
+    if (!x.param && !x.global) {
+      const magicReplacement = getVariableReplacement(x.ref, options);
 
+      if (x.ref[0] === '$user') {
+        if (magicReplacement !== null)
+          return renderStringForSql(magicReplacement, options.sqlDialect);
 
-    /**
-     * Various special cases represented as objects
-     *
-     * @param {object} x Expression
-     * @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 '';
+        const result = render$user();
+        // Invalid second path step doesn't cause a return
+        if (result)
+          return result;
       }
-      // Reference: Array of path steps, possibly preceded by ':'
-      else if (x.ref) {
-        return renderExpressionRef(x);
+      else if (x.ref[0] === '$at') {
+        const result = render$at();
+        // Invalid second path step doesn't cause a return
+        if (result)
+          return result;
       }
-      // 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));
+      else if (x.ref[0] === '$session' && magicReplacement !== null) {
+        return renderStringForSql(magicReplacement, options.sqlDialect);
       }
-      // Nested expression
-      else if (x.xpr) {
-        if (nestedExpr && !x.cast)
-          return `(${renderExpr(x.xpr, env, inline, true)})`;
-
-        return renderExpr(x.xpr, env, inline, true);
-      }
-      // Sub-select
-      else if (x.SELECT) {
-        // renderQuery for SELECT does not bring its own parentheses (because it is also used in renderView)
-        return `(${renderQuery('<subselect>', x, increaseIndent(env))})`;
-      }
-      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] === '$now') { // TODO: Can there be cases where $now is followed by something?
+        switch (options.sqlDialect) {
+          case 'sqlite':
+          case 'hana':
+            return 'CURRENT_TIMESTAMP';
+          case 'postgres':
+            return 'current_timestamp';
+          default:
+            return quoteSqlId(x.ref[0]);
+        }
       }
-
-      throw new ModelError(`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;
-    }
-
-    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 ModelError(`Unknown literal or type: ${JSON.stringify(x)}`);
-      }
+    // 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 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) {
-      // FIXME: this is all not enough: we might need an explicit select item alias
+    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...
-        if (options.toSql.user && typeof options.toSql.user === 'string' || options.toSql.user instanceof String)
-          return `'${options.toSql.user}'`;
-
-        else if ((options.toSql.user && options.toSql.user.id) && (typeof options.toSql.user.id === 'string' || options.toSql.user.id instanceof String))
-          return `'${options.toSql.user.id}'`;
-
-        if (options.toSql.dialect === 'sqlite' || options.toSql.dialect === 'plain') {
-          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\')';
+        if (options.sqlDialect === 'hana')
+          return 'SESSION_CONTEXT(\'APPLICATIONUSER\')';
+        warning(null, null, 'The "$user" variable is not supported. Use option "variableReplacements" to specify a value for "$user.id"');
+        return '\'$user.id\'';
       }
       else if (x.ref[1] === 'locale') {
-        if (options.toSql.dialect === 'sqlite' || options.toSql.dialect === 'plain') {
-          return (options.toSql.user && options.toSql.user.locale)
-            ? `'${options.toSql.user && options.toSql.user.locale}'` : '\'en\'';
-        }
-        return 'SESSION_CONTEXT(\'LOCALE\')';
+        if (options.sqlDialect === 'hana')
+          return 'SESSION_CONTEXT(\'LOCALE\')';
+        return '\'en\''; // default language
       }
       // Basically: Second path step was invalid, do nothing - should not happen, see 'unknownMagic.js'
       return null;
     }
     /**
      * 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) {
+        switch (options.sqlDialect) {
           case 'sqlite': {
             const dateFromFormat = '%Y-%m-%dT%H:%M:%S.000Z';
             return `strftime('${dateFromFormat}', 'now')`;
           }
           case 'hana':
             return 'TO_TIMESTAMP(SESSION_CONTEXT(\'VALID-FROM\'))';
+          case 'postgres':
           case 'plain':
             return 'current_timestamp';
           default:
@@ -1623,7 +1564,7 @@ function toSqlDdl(csn, options) {
       }
 
       if (x.ref[1] === 'to') {
-        switch (options.toSql.dialect) {
+        switch (options.sqlDialect) {
           case 'sqlite': {
             // + 1ms compared to $at.from
             const dateToFormat = '%Y-%m-%dT%H:%M:%S.001Z';
@@ -1631,6 +1572,7 @@ function toSqlDdl(csn, options) {
           }
           case 'hana':
             return 'TO_TIMESTAMP(SESSION_CONTEXT(\'VALID-TO\'))';
+          case 'postgres':
           case 'plain':
             return 'current_timestamp';
           default:
@@ -1640,18 +1582,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
      *
@@ -1664,7 +1594,6 @@ function toSqlDdl(csn, options) {
       if (typeof (s) === 'string') {
         // TODO: When is this actually executed and not handled already in renderExpr?
         const magicForHana = {
-          $now: 'CURRENT_TIMESTAMP',
           '$user.id': 'SESSION_CONTEXT(\'APPLICATIONUSER\')',
           '$user.locale': 'SESSION_CONTEXT(\'LOCALE\')',
         };
@@ -1672,7 +1601,7 @@ function toSqlDdl(csn, options) {
         if (idx === 0) {
           // HANA-specific translation of '$now' and '$user'
           // FIXME: this is all not enough: we might need an explicit select item alias
-          if (magicForHana[s])
+          if (options.sqlDialect === 'hana' && magicForHana[s])
             return magicForHana[s];
 
           // Ignore initial $projection and initial $self
@@ -1709,6 +1638,13 @@ function toSqlDdl(csn, options) {
     }
   }
 
+  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
    *
@@ -1720,6 +1656,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,
 };