@sap/cds-compiler 5.8.2 → 5.9.0

package/lib/render/toHdbcds.js

@@ -571,7 +571,7 @@ function toHdbcdsSource( csn, options, messageFunctions ) {
      * @returns {Array} Modified expression array
      */
     function fixFuzzyIndex( fuzzyIndex, columnName ) {
-      return fuzzyIndex.map(token => (token === 'on' ? { xpr: [ 'on', '(', { ref: columnName.split('.') }, ')' ] } : token));
+      return fuzzyIndex.map(token => (token === 'on' ? { xpr: [ 'on', { xpr: { ref: columnName.split('.') } } ] } : token));
     }
   }
 

package/lib/render/toSql.js

@@ -30,6 +30,8 @@ const { manageConstraints, manageConstraint } = require('./manageConstraints');
 const { renderUniqueConstraintString, renderUniqueConstraintDrop, renderUniqueConstraintAdd } = require('./utils/unique');
 const { ModelError, CompilerAssertion } = require('../base/error');
 const { pathId } = require('../model/csnRefs');
+const { transformExprOperators } = require('./utils/operators');
+const { exprAsTree, condAsTree } = require('../model/xprAsTree');
 
 class SqlRenderEnvironment {
   indent = '';
@@ -154,6 +156,12 @@ function toSqlDdl( csn, options, messageFunctions ) {
   });
 
   function renderExpr( x, env ) {
+    // TODO:
+    //   Can we to structurizing upfront?
+    //   Neither condAsTree() nor exprAsTree() traverse `.args` / `.where`.
+    //   This is fine, since renderExpr() calls itself for function arguments and filters.
+    x = Array.isArray(x) ? condAsTree(x) : exprAsTree(x);
+    x = transformExprOperators(x, options, messageFunctions, env);
     return exprRenderer.renderExpr(x, env);
   }
 

package/lib/render/utils/common.js

@@ -81,9 +81,9 @@ function beautifyExprArray( tokens ) {
     // No space after last token, after opening parentheses, before closing parentheses, before comma, before and after dot
     if (i !== tokens.length - 1 &&
         // current token
-        tokens[i] !== '(' && tokens[i] !== '.' &&
+        tokens[i] !== '.' &&
         // next token
-        tokens[i + 1] !== ')' && tokens[i + 1] !== '.' && tokens[i + 1] !== ',')
+        tokens[i + 1] !== '.' && tokens[i + 1] !== ',')
       result += ' ';
   }
   return result;

package/lib/render/utils/operators.js

@@ -0,0 +1,160 @@
+'use strict';
+
+// Utilities to transform operators in expressions for SQL rendering.
+
+const operatorsPerDialect = {
+  __proto__: null,
+  plain: {
+    __proto__: null,
+    '==': function equals(xpr) {
+      const lhs = xpr[0];
+      const rhs = xpr[2];
+      xpr.length = 0;
+      if (lhs?.val === null) // shorthand
+        xpr.push(rhs, 'is', 'null');
+      else if (rhs?.val === null)
+        xpr.push(lhs, 'is', 'null');
+      else
+        xpr.push(lhs, 'is', 'not', 'distinct', 'from', rhs);
+    },
+    '!=': function unequal(xpr) {
+      const lhs = xpr[0];
+      const rhs = xpr[2];
+      xpr.length = 0;
+      if (lhs?.val === null) // shorthand
+        xpr.push(rhs, 'is', 'not', 'null');
+      else if (rhs?.val === null)
+        xpr.push(lhs, 'is', 'not', 'null');
+      else
+        xpr.push(lhs, 'is', 'distinct', 'from', rhs);
+    },
+  },
+  hana: {
+    __proto__: null,
+    '==': function equals(xpr) {
+      const lhs = xpr[0];
+      const rhs = xpr[2];
+      xpr.length = 0;
+      if (lhs?.val === null) { // shorthand
+        xpr.push(rhs, 'is', 'null');
+      }
+      else if (rhs?.val === null) {
+        xpr.push(lhs, 'is', 'null');
+      }
+      else {
+        // (a IS NOT NULL AND b IS NOT NULL AND a = b) OR (a IS NULL AND b IS NULL)
+        xpr.push({
+          xpr: [
+            {
+              xpr: [ [ lhs, 'is', 'not', 'null' ], 'and', [ rhs, 'is', 'not', 'null' ], 'and', [ lhs, '=', rhs ] ],
+            },
+            'or',
+            {
+              xpr: [ [ lhs, 'is', 'null' ], 'and', [ rhs, 'is', 'null' ] ],
+            },
+          ],
+        });
+      }
+    },
+    '!=': function unequal(xpr) {
+      const lhs = xpr[0];
+      const rhs = xpr[2];
+      xpr.length = 0;
+
+      if (lhs?.val === null) { // shorthand
+        xpr.push(rhs, 'is', 'not', 'null');
+      }
+      else if (rhs?.val === null) {
+        xpr.push(lhs, 'is', 'not', 'null');
+      }
+      else {
+        // `(a IS NULL OR b IS NULL OR a <> b) AND (a IS NOT NULL OR b IS NOT NULL)`
+        xpr.push({
+          xpr: [
+            {
+              xpr: [ [ lhs, 'is', 'null' ], 'or', [ rhs, 'is', 'null' ], 'or', [ lhs, '<>', rhs ] ],
+            },
+            'and',
+            {
+              xpr: [ [ lhs, 'is', 'not', 'null' ], 'or', [ rhs, 'is', 'not', 'null' ] ],
+            },
+          ],
+        });
+      }
+    },
+  },
+  sqlite: {
+    __proto__: null,
+    '==': function equals(xpr) {
+      const rhs = xpr[2];
+      xpr.length = 1;
+      xpr.push('is', rhs);
+    },
+    '!=': function unequal(xpr) {
+      const rhs = xpr[2];
+      xpr.length = 1;
+      xpr.push('is', 'not', rhs);
+    },
+  },
+};
+
+operatorsPerDialect.postgres = operatorsPerDialect.plain;
+operatorsPerDialect.h2 = operatorsPerDialect.plain;
+
+/**
+ * Transform non-SQL operators to ones known by SQL.  This includes `==` and `!=`.
+ * Expects structurized CSN! See xprAsTree.js
+ *
+ * @param {object[]|object} xpr
+ * @param {SqlOptions} options
+ * @param {object} messageFunctions
+ * @param {object} env
+ * @returns {object[]}
+ */
+function transformExprOperators( xpr, options, messageFunctions, env ) {
+  // TODO: Reduce number of function arguments
+  const sqlDialect = options.sqlDialect || 'plain';
+  const operators = Object.assign(Object.create(null), operatorsPerDialect[sqlDialect] || operatorsPerDialect.plain);
+
+  if (!options.booleanEquality) {
+    // don't translate `!=` if the option isn't set; default to be changed in v6
+    delete operators['!='];
+  }
+
+  transformBinary(xpr);
+  return xpr;
+
+  function transformBinary( x ) {
+    if (!x || typeof x !== 'object')
+      return;
+
+    if (Array.isArray(x)) {
+      const op = x[1];
+      if (x.length === 3 && op in operators) {
+        transformBinary(x[0]); // left-hand-side
+        transformBinary(x[2]); // right-hand-side
+        operators[op](x);
+      }
+      else {
+        x.forEach(transformBinary);
+      }
+
+      if (x.length > 3 && op in operators) {
+        const keyword = typeof x[2] === 'string' && x[2].toLowerCase();
+        // e.g. `ref != SOME (SELECT num from Base)`
+        // Since semantics are unclear, reject it.
+        if (keyword === 'all' || keyword === 'some' || keyword === 'any') {
+          messageFunctions.error('expr-unsupported-equality', env.path, { op, keyword },
+                                 'Operator $(OP) can\'t be used in combination with $(KEYWORD)');
+        }
+      }
+    }
+    else if (x.xpr) {
+      transformBinary(x.xpr);
+    }
+  }
+}
+
+module.exports = {
+  transformExprOperators,
+};

package/lib/render/utils/pretty.js

@@ -0,0 +1,337 @@
+'use strict';
+
+// Pretty Printer
+//
+// Based on https://homepages.inf.ed.ac.uk/wadler/papers/prettier/prettier.pdf
+// by Philip Wadler.  Implemented up to section 3, which includes some
+// efficiency improvements.
+//
+// A similar algorithm is also used by the cds-lsp package, though more advanced
+// and based on a formatting stream instead of these nested structures.
+//
+// The basic idea is that you can define the maximum width and the document
+// is formatted best to fill that space.
+// Groups should appear on a single line if possible.
+//
+// All function names come directly from the above paper and its
+// Haskell implementation.  Variable names have been changed to improve
+// readability, e.g. `x` -> `doc`, etc.
+
+/** Base document class. */
+class Doc {}
+
+const LINE_OR_SPACE = ' ';
+const LINE_OR_EMPTY = '';
+
+/**
+ * This class represents a newline which may or may not be inserted into
+ * the document, depending on the width.
+ * If no newline is to be inserted, `kind` stores whether we insert
+ * a space or no space instead.  It is used by `flatten()`.
+ * If a newline is to be inserted, nesting is added, which may have been
+ * applied by `best()`/`be()`.
+ */
+class Line extends Doc {
+  /**
+   * @param {string} kind LINE_OR_SPACE or LINE_OR_EMPTY
+   */
+  constructor(kind = LINE_OR_SPACE) {
+    super();
+    this.kind = kind;
+    this._indent = 0;
+  }
+  applyNest(n) {
+    this._indent = n;
+  }
+  toString() {
+    return `\n${' '.repeat(this._indent)}`;
+  }
+}
+
+/**
+ * Adds nesting to the given document.  Nesting is applied to the underlying
+ * lines in `flatten()`.  But when creating a document, Nest is useful
+ * to easily indent blocks.
+ */
+class Nest extends Doc {
+  /**
+   * @param {number} indent
+   * @param {Doc|Doc[]|string} x
+   */
+  constructor(indent, x) {
+    super();
+    this.indent = indent;
+    this.x = x;
+  }
+}
+
+/**
+ * Represents a union of two documents. One flattened and the other structured.
+ * A Union is created by `group()`.
+ */
+class Union extends Doc {
+  /**
+   * @param {Doc|Doc[]|string} x Flattened document.
+   * @param {Doc|Doc[]|string} y Structured document.
+   */
+  constructor(x, y) {
+    super();
+    this.x = x;
+    this.y = y;
+  }
+}
+
+/**
+ * A newline if no space is available or a single space if enough space is available.
+ *
+ * @return {Line}
+ */
+function line() {
+  return new Line(LINE_OR_SPACE);
+}
+/**
+ * A newline if no space is available or an empty string if enough space is available.
+ *
+ * @return {Line}
+ */
+function lineOrEmpty() {
+  return new Line(LINE_OR_EMPTY);
+}
+
+/**
+ * Group the given document.
+ *
+ * @param {Doc|Doc[]|string} x
+ * @returns {Union}
+ */
+function group( x ) {
+  return new Union(flatten(x), x);
+}
+
+/**
+ * Flatten the given document, with no regard to line width.
+ *
+ * @param {Doc|Doc[]|string} doc
+ * @returns {Doc|Doc[]|string}
+ */
+function flatten( doc ) {
+  if (!doc)
+    return doc;
+  else if (Array.isArray(doc))
+    return doc.map(flatten).flat(Infinity);
+  else if (doc instanceof Line)
+    return doc.kind;
+  else if (doc instanceof Nest)
+    return flatten(doc.x);
+  else if (doc instanceof Union)
+    return doc.x;
+  else if (typeof doc === 'string')
+    return doc;
+  throw new Error(`unhandled case: ${typeof doc}`);
+}
+
+/**
+ * Nest the given document by `n` spaces.
+ *
+ * @param {number} n
+ * @param {Doc|Doc[]|string} doc
+ * @returns {Doc|string}
+ */
+function nestBy( n, doc ) {
+  if (Array.isArray(doc) || doc instanceof Line) {
+    return new Nest(n, doc);
+  }
+  else if (doc instanceof Union) {
+    doc.y = nestBy(n, doc.y);
+    return doc;
+  }
+  else if (typeof doc === 'string') {
+    return doc; // nesting absorbed by string
+  }
+  else if (typeof doc === 'number' || typeof doc === 'boolean' || doc === null) {
+    return String(doc); // nesting absorbed by string
+  }
+
+  throw new Error(`unhandled case: ${typeof doc}`);
+}
+
+/**
+ * Convenience function which nests the given lines while making the last
+ * line not indented.  Consider e.g. `[ 1, 2, 3 ]`, where each number should
+ * be on a separate line:
+ *
+ * ```
+ * [
+ *   1,
+ *   2,
+ *   3
+ * ]
+ * ```
+ *
+ * The last inserted Line must not be indented.
+ *
+ * @param {number} indent
+ * @param {string} open
+ * @param {Doc|Doc[]|string} content
+ * @param {string} close
+ * @return {Union}
+ */
+function bracketBlock( indent, open, content, close ) {
+  return group([
+    open,
+    group([ nestBy(indent, [ line(), content ]), line() ] ),
+    close,
+  ]);
+}
+
+/**
+ * Returns the document that better fits the desired width and current column.
+ *
+ * @param {number} width The desired width of the document.
+ * @param {number} k Current with of the line. (width-k) is the remaining width.
+ * @param {Doc|Doc[]|string} x
+ * @param {Doc|Doc[]|string} y
+ * @returns {Doc|Doc[]|string}
+ */
+function better( width, k, x, y ) {
+  if (fits(width - k, x))
+    return x;
+  return y;
+}
+
+/**
+ * Find the best version of the given document that fits the given
+ * width.  This function returns a document that has no Union or Nest
+ * anymore, only strings and Line.
+ *
+ * @param {number} width The desired width of the document.
+ * @param {number} k Current with of the line. (width-k) is the remaining width.
+ * @param {Doc|Doc[]|string} doc
+ * @returns {Doc|Doc[]|string}
+ */
+function best( width, k, doc ) {
+  return be(width, k, 0, doc);
+}
+
+/**
+ * Same as `best()`, but keeps track of the current nesting `i`.
+ *
+ * @param {number} width The desired width of the document.
+ * @param {number} k Current with of the line. (width-k) is the remaining width.
+ * @param {number} i Current nesting.
+ * @param {Doc|Doc[]|string} doc
+ * @returns {Doc|Doc[]|string|string|Line|*|*[]}
+ */
+function be( width, k, i, doc ) {
+  if (!doc || typeof doc === 'string')
+    return doc;
+  if (doc instanceof Line) {
+    doc.applyNest(i);
+    return doc;
+  }
+  if (doc instanceof Nest)
+    return be(width, k, i + doc.indent, doc.x);
+  if (doc instanceof Union)
+    return better(width, k, be(width, k, i, doc.x), be(width, k, i, doc.y));
+  if (Array.isArray(doc)) {
+    const result = [];
+    for (const entry of doc) {
+      const b = be(width, k, i, entry);
+      if (typeof b === 'string')
+        k += b.length;
+      result.push(b);
+    }
+    return result;
+  }
+  throw new Error(`unhandled case: ${typeof doc}`);
+}
+
+/**
+ * Determines if the document fits into the line.
+ *
+ * @param {number} width The desired width of the document.
+ * @param {Doc|Doc[]|string} doc
+ * @returns {boolean}
+ */
+function fits( width, doc ) {
+  const list = Array.isArray(doc) ? doc : [ doc ];
+  for (const entry of list) {
+    if (!entry || entry instanceof Line)
+      return true;
+    else if (entry instanceof Union)
+      throw new Error('fits() must only be called via best() which resolves Unions already');
+    else if (entry instanceof Nest)
+      throw new Error('fits() must only be called via best() which resolves Nest already');
+    else if (typeof entry === 'string')
+      width -= entry.length;
+
+    if (width < 0)
+      return false;
+  }
+  return true;
+}
+
+/**
+ * Layouts the given document without trying to use as few lines as possible,
+ * i.e. each Line is rendered as a newline.
+ * Requires Nest nodes to be resolved, i.e. pretty() was applied.
+ *
+ * @param {Doc[]|Doc} doc
+ * @return {string}
+ */
+function layout( doc ) {
+  if (!doc)
+    return '';
+  else if (Array.isArray(doc))
+    return doc.map(layout).join('');
+  else if (doc instanceof Line)
+    return doc.toString();
+  else if (typeof doc === 'string')
+    return doc;
+  throw new Error(`unhandled case: ${typeof doc}`);
+}
+
+/**
+ * Layouts the given document is a "pretty way", that is: it tries
+ * to fill up the space of maxWidth characters while keeping it pretty.
+ * Adds a final newline character.
+ *
+ * @param {Doc[]|Doc} doc
+ * @param {Number} [maxWidth]
+ * @return {string}
+ */
+function pretty( doc, maxWidth = 80 ) {
+  const b = best(maxWidth, 0, doc);
+  return layout(b);
+}
+
+/**
+ * Join the given list of documents by adding tokens between them.
+ * Example:
+ *   joinDocuments([ 'foo', 'bar', 'foobar' ], [ ',', line() ])
+ * returns:
+ *   [ 'foo', ',', line(), 'bar', ',', line(), 'foobar' ]
+ *
+ * @param {Doc[]} values
+ * @param {Doc[]} tokens
+ * @returns {Doc[]}
+ */
+function joinDocuments( values, tokens ) {
+  const result = [];
+  for (let i = 0; i < values.length; i++) {
+    result.push(values[i]);
+    if (i !== values.length - 1)
+      result.push(...tokens);
+  }
+  return result;
+}
+
+module.exports = {
+  pretty,
+  nestBy,
+  line,
+  lineOrEmpty,
+  group,
+  bracketBlock,
+  joinDocuments,
+};

package/lib/sql-identifier.js

@@ -44,31 +44,31 @@ const sqlDialects = {
     regularRegex: /^[A-Za-z_][A-Za-z_0-9]*$/,
     reservedWords: keywords.h2,
     effectiveName: name => name.toUpperCase(),
-    asDelimitedId: name => `"${ name.replace(/"/g, '""')}"`,
+    asDelimitedId: name => `"${ name.replace(/"/g, '""') }"`,
   },
   sqlite: {
     regularRegex: /^[A-Za-z_][A-Za-z_$0-9]*$/,
     reservedWords: keywords.sqlite,
     effectiveName: name => name,
-    asDelimitedId: name => `"${ name.replace(/"/g, '""')}"`,
+    asDelimitedId: name => `"${ name.replace(/"/g, '""') }"`,
   },
   postgres: {
     regularRegex: /^[A-Za-z_][A-Za-z_$0-9]*$/,
     reservedWords: keywords.postgres,
     effectiveName: name => name.toLowerCase(),
-    asDelimitedId: name => `"${ name.replace(/"/g, '""')}"`,
+    asDelimitedId: name => `"${ name.replace(/"/g, '""') }"`,
   },
   hana: {
     regularRegex: /^[A-Za-z_][A-Za-z_$#0-9]*$/,
     reservedWords: keywords.hana,
     effectiveName: name => name.toUpperCase(),
-    asDelimitedId: name => `"${ name.replace(/"/g, '""')}"`,
+    asDelimitedId: name => `"${ name.replace(/"/g, '""') }"`,
   },
   hdbcds: {
     regularRegex: /^[A-Za-z_][A-Za-z_0-9]*$/,
     reservedWords: keywords.hdbcds,
     effectiveName: name => name,
-    asDelimitedId: name => `"${ name.replace(/"/g, '""')}"`,
+    asDelimitedId: name => `"${ name.replace(/"/g, '""') }"`,
   },
 };
 
@@ -79,8 +79,7 @@ function smartId( name, dialect ) {
   if (s.regularRegex && !s.regularRegex.test( name ) ||
       s.reservedWords && s.reservedWords.includes( name.toUpperCase() ))
     return s.asDelimitedId( s.effectiveName( name ) );
-  else
-    return name;
+  return name;
 }
 
 function smartFuncId( name, dialect ) {
@@ -89,8 +88,7 @@ function smartFuncId( name, dialect ) {
     : dialect;
   if (s.regularRegex && !s.regularRegex.test( name ))
     return s.asDelimitedId( s.effectiveName( name ) );
-  else
-    return name;
+  return name;
 }
 
 function delimitedId( name, dialect ) {