@sap/cds-compiler 2.13.8 → 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,
@@ -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.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 = {
@@ -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.
@@ -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.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;
@@ -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.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;
@@ -263,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)
@@ -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' ];
@@ -624,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;
@@ -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;
   }
@@ -1089,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)}`;
@@ -1124,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)
@@ -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)}`;
@@ -1403,171 +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=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);
-    }
-    // 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
-     *
-     * @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 '';
-      }
-      // 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);
 
-        return renderExpr(x.xpr, env, inline, true);
+      if (x.ref[0] === '$user') {
+        if (magicReplacement !== null)
+          return `'${magicReplacement}'`;
+
+        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 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) {
+    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...
@@ -1595,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': {
@@ -1640,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
      *
@@ -1709,6 +1636,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 +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,
 };