@sap/cds-compiler 2.5.2 → 2.11.0

package/lib/render/toSql.js

@@ -4,10 +4,10 @@
 const {
   getLastPartOf, getLastPartOfRef,
   hasValidSkipOrExists, isBuiltinType, generatedByCompilerVersion, getNormalizedQuery,
-  forEachDefinition, getResultingName,
+  forEachDefinition, getResultingName, getVariableReplacement,
 } = require('../model/csnUtils');
 const {
-  renderFunc, processExprArray, cdsToSqlTypes, getHanaComment, hasHanaComment,
+  renderFunc, beautifyExprArray, cdsToSqlTypes, getHanaComment, hasHanaComment,
 } = require('./utils/common');
 const {
   renderReferentialConstraint, getIdentifierUtils,
@@ -15,7 +15,7 @@ const {
 const DuplicateChecker = require('./DuplicateChecker');
 const { checkCSNVersion } = require('../json/csnVersion');
 const { makeMessageFunction } = require('../base/messages');
-const timetrace = require('../utils/timetrace');
+const { timetrace } = require('../utils/timetrace');
 const { isBetaEnabled, isDeprecatedEnabled } = require('../base/model');
 const { smartFuncId } = require('../sql-identifier');
 const { sortCsn } = require('../json/to-csn');
@@ -152,6 +152,24 @@ function toSqlDdl(csn, options) {
         .join(', ');
       return primaryKeys && `PRIMARY KEY(${primaryKeys})`;
     },
+    /*
+      Render entity-comment modifications as HANA SQL.
+     */
+    alterEntityComment(tableName, comment) {
+      return [ `COMMENT ON TABLE ${tableName} IS ${render.comment(comment)};` ];
+    },
+    /*
+      Render column-comment modifications as HANA SQL.
+     */
+    alterColumnComment(tableName, columnName, comment) {
+      return [ `COMMENT ON COLUMN ${tableName}.${columnName} IS ${render.comment(comment)};` ];
+    },
+    /*
+      Render comment string.
+     */
+    comment(comment) {
+      return comment && `'${comment.replace(/'/g, '\'\'')}'` || 'NULL';
+    },
     /*
       Concatenate multiple statements which are to be treated as one by the API caller.
      */
@@ -211,8 +229,9 @@ function toSqlDdl(csn, options) {
     for (const extension of options && options.testMode ? sortCsn(csn.extensions) : csn.extensions) {
       if (extension.extend) {
         const artifactName = extension.extend;
-        const env = { indent: '' };
-        renderArtifactExtensionInto(artifactName, csn.definitions[artifactName], extension, resultObj, env);
+        const _artifact = csn.definitions[artifactName];
+        const env = { indent: '', _artifact };
+        renderArtifactExtensionInto(artifactName, _artifact, extension, resultObj, env);
       }
     }
   }
@@ -223,7 +242,8 @@ function toSqlDdl(csn, options) {
     for (const migration of options && options.testMode ? sortCsn(csn.migrations) : csn.migrations) {
       if (migration.migrate) {
         const artifactName = migration.migrate;
-        const env = { indent: '' };
+        const _artifact = csn.definitions[artifactName];
+        const env = { indent: '', _artifact };
         renderArtifactMigrationInto(artifactName, migration, resultObj, env);
       }
     }
@@ -365,12 +385,32 @@ function toSqlDdl(csn, options) {
     function reducesTypeSize(def) {
       // HANA does not allow decreasing the value of any of those type parameters.
       return def.old.type === def.new.type &&
-          [ 'length', 'precision', 'scale' ].some(param => def.new[param] < def.old[param]);
+        [ 'length', 'precision', 'scale' ].some(param => def.new[param] < def.old[param]);
+    }
+    function getEltStr(defVariant, eltName) {
+      return defVariant.target
+        ? 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);
     }
 
     const tableName = renderArtifactName(artifactName);
 
-    // Drop column (unsupported in sqlite)
+    // Change entity properties
+    if (migration.properties) {
+      for (const [ prop, def ] of Object.entries(migration.properties)) {
+        if (prop === 'doc') {
+          const alterComment = render.alterEntityComment(tableName, def.new);
+          addMigration(resultObj, artifactName, false, alterComment);
+        }
+      }
+    }
+
+    // Drop columns (unsupported in sqlite)
     if (migration.remove) {
       const entries = Object.entries(migration.remove);
       if (entries.length) {
@@ -389,22 +429,28 @@ function toSqlDdl(csn, options) {
       }
     }
 
-    // Change column type (unsupported in sqlite)
+    // Change column types (unsupported in sqlite)
     if (migration.change) {
       changeElementsDuplicateChecker.addArtifact(tableName, undefined, artifactName);
       for (const [ eltName, def ] of Object.entries(migration.change)) {
         const sqlId = quoteSqlId(eltName);
         changeElementsDuplicateChecker.addElement(sqlId, undefined, eltName);
 
-        const eltStrOld = def.old.target
-          ? renderAssociationElement(eltName, def.old, env)
-          : renderElement(artifactName, eltName, def.old, null, null, env);
-        const eltStrNew = def.new.target
-          ? renderAssociationElement(eltName, def.new, env)
-          : renderElement(artifactName, eltName, def.new, null, null, env);
+        const eltStrOld = getEltStr(def.old, eltName);
+        const eltStrNew = getEltStr(def.new, eltName);
         if (eltStrNew === eltStrOld)
           return; // Prevent spurious migrations, where the column DDL does not change.
 
+        if (def.old.doc !== def.new.doc) {
+          const eltStrOldNoDoc = getEltStrNoProp(def.old, 'doc', eltName);
+          const eltStrNewNoDoc = getEltStrNoProp(def.new, 'doc', eltName);
+          if (eltStrOldNoDoc === eltStrNewNoDoc) { // only `doc` changed
+            const alterComment = render.alterColumnComment(tableName, sqlId, def.new.doc);
+            addMigration(resultObj, artifactName, false, alterComment);
+            continue;
+          }
+        }
+
         if (options.sqlChangeMode === 'drop' || def.old.target || def.new.target || reducesTypeSize(def)) {
           // Lossy change because either an association is removed and/or added, or the type size is reduced.
           // Drop old element and re-add it in its new shape.
@@ -479,12 +525,12 @@ function toSqlDdl(csn, options) {
           referentialConstraints[fileName] = renderReferentialConstraint(referentialConstraint, childEnv.indent, false, csn, options);
         });
       if (renderReferentialConstraintsAsHdbconstraint) {
-        Object.entries(referentialConstraints).forEach( ([ fileName, constraint ]) => {
+        Object.entries(referentialConstraints).forEach(([ fileName, constraint ]) => {
           resultObj.hdbconstraint[fileName] = constraint;
         });
       }
       else {
-        Object.values(referentialConstraints).forEach( (constraint) => {
+        Object.values(referentialConstraints).forEach((constraint) => {
           result += `,\n${constraint}`;
         });
       }
@@ -500,8 +546,7 @@ function toSqlDdl(csn, options) {
           = `UNIQUE INVERTED INDEX ${renderArtifactName(`${artifactName}_${cn}`)} ON ${tableName} (${c.map(cpath => quoteSqlId(cpath.ref[0])).join(', ')})`;
       }
       else {
-        result += `,\n${childEnv.indent}CONSTRAINT ${renderArtifactName(`${artifactName}_${cn}`)} UNIQUE (${
-          c.map(cpath => quoteSqlId(cpath.ref[0])).join(', ')})`;
+        result += `,\n${childEnv.indent}CONSTRAINT ${renderArtifactName(`${artifactName}_${cn}`)} UNIQUE (${c.map(cpath => quoteSqlId(cpath.ref[0])).join(', ')})`;
       }
     }
     result += `${env.indent}\n)`;
@@ -522,7 +567,7 @@ 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, art))
+    if (options.toSql.dialect === 'hana' && hasHanaComment(art, options))
       result += ` COMMENT '${getHanaComment(art)}'`;
 
     resultObj.hdbtable[artifactName] = result;
@@ -613,8 +658,7 @@ function toSqlDdl(csn, options) {
     if (duplicateChecker)
       duplicateChecker.addElement(quotedElementName, elm.$location, elementName);
 
-    let result = `${env.indent + quotedElementName} ${
-      renderTypeReference(artifactName, elementName, elm)
+    let result = `${env.indent + quotedElementName} ${renderTypeReference(artifactName, elementName, elm)
     }${renderNullability(elm, true)}`;
     if (elm.default)
       result += ` DEFAULT ${renderExpr(elm.default, env)}`;
@@ -910,7 +954,7 @@ function toSqlDdl(csn, options) {
     // An empty actual parameter list is rendered as `()`.
     const ref = csn.definitions[path.ref[0].id] || csn.definitions[path.ref[0]];
     if (ref && ref.params) {
-      result += `(${renderArgs(path.ref[0].args || {}, '=>', env, syntax)})`;
+      result += `(${renderArgs(path.ref[0] || {}, '=>', env, syntax)})`;
     }
     else if ([ 'udf' ].includes(syntax)) {
       // if syntax is user defined function, render empty argument list
@@ -932,21 +976,23 @@ function toSqlDdl(csn, options) {
    * Render function arguments or view parameters (positional if array, named if object/dict),
    * using 'sep' as separator for positional parameters
    *
-   * @param {Array|object} args Arguments to render
+   * @param {object} node with `args` to render
    * @param {string} sep Separator between args
    * @param {object} env Render environment
    * @param {string} syntax Some magic A2J paramter - for calcview parameter rendering
    * @returns {string} Rendered arguments
    * @throws Throws if args is not an array or object.
    */
-  function renderArgs(args, sep, env, syntax) {
+  function renderArgs(node, sep, env, syntax) {
+    const args = node.args ? node.args : {};
     // Positional arguments
     if (Array.isArray(args))
       return args.map(arg => renderExpr(arg, env)).join(', ');
 
     // Named arguments (object/dict)
     else if (typeof args === 'object')
-      return Object.keys(args).map(key => `${decorateParameter(key, syntax)} ${sep} ${renderExpr(args[key], env)}`).join(', ');
+      // 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(', ');
 
 
     throw new Error(`Unknown args: ${JSON.stringify(args)}`);
@@ -1008,7 +1054,7 @@ 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, art))
+    if (options.toSql.dialect === 'hana' && hasHanaComment(art, options))
       result += ` COMMENT '${getHanaComment(art)}'`;
 
     result += renderParameterDefinitions(artifactName, art.params);
@@ -1042,8 +1088,15 @@ function toSqlDdl(csn, options) {
         const p = params[pn];
         if (p.notNull === true || p.notNull === false)
           info(null, [ 'definitions', artifactName, 'params', pn ], 'Not Null constraints on SQL view parameters are not allowed and are ignored');
-
-        let pstr = `IN ${prepareIdentifier(pn)} ${renderTypeReference(artifactName, pn, p)}`;
+        // do not quote parameter identifiers for naming mode "quoted" / "hdbcds"
+        // 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')
+          pIdentifier = prepareIdentifier(pn);
+        else
+          pIdentifier = quoteSqlId(pn);
+        let pstr = `IN ${pIdentifier} ${renderTypeReference(artifactName, pn, p)}`;
         if (p.default)
           pstr += ` DEFAULT ${renderExpr(p.default)}`;
 
@@ -1098,12 +1151,11 @@ function toSqlDdl(csn, options) {
     const childEnv = increaseIndent(env);
     result += `SELECT${select.distinct ? ' DISTINCT' : ''}`;
     // 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))
-        .filter(s => s !== '')
-        .join(',\n')}\n`;
+    result += `\n${(select.columns || [ '*' ])
+      .filter(col => !(select.mixin || Object.create(null))[firstPathStepId(col.ref)]) // No mixin columns
+      .map(col => renderViewColumn(col, childEnv))
+      .filter(s => s !== '')
+      .join(',\n')}\n`;
     result += `${env.indent}FROM ${renderViewSource(artifactName, select.from, env)}`;
     if (select.where)
       result += `\n${env.indent}WHERE ${renderExpr(select.where, env, true, true)}`;
@@ -1290,7 +1342,8 @@ function toSqlDdl(csn, options) {
   function renderExpr(x, env, inline = true, nestedExpr = false) {
     // Compound expression
     if (Array.isArray(x)) {
-      return processExprArray(x, renderExpr, env, inline, nestedExpr);
+      const tokens = x.map(item => renderExpr(item, env, inline, nestedExpr));
+      return beautifyExprArray(tokens);
     }
     else if (typeof x === 'object' && x !== null) {
       if (nestedExpr && x.cast && x.cast.type)
@@ -1330,6 +1383,8 @@ function toSqlDdl(csn, options) {
       // 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
@@ -1352,29 +1407,36 @@ function toSqlDdl(csn, options) {
       throw new Error(`Unknown expression: ${JSON.stringify(x)}`);
     }
 
+    function renderWindowFunction(funcName, node, env) {
+      const suffix = node.xpr.shift(); // OVER
+      let r = `${funcName}(${renderArgs(node, '=>', env, null)})`;
+      r += ` ${suffix} (${renderExpr(node.xpr, env)})`;
+      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
+          // 17.42, NULL, TRUE
           return String(x.val).toUpperCase();
         case 'x':
-        // x'f000'
+          // x'f000'
           return `${x.literal}'${x.val}'`;
         case 'date':
         case 'time':
         case 'timestamp':
           if (options.toSql.dialect === 'sqlite') {
-          // simple string literal '2017-11-02'
+            // simple string literal '2017-11-02'
             return `'${x.val}'`;
           }
           // date'2017-11-02'
           return `${x.literal}'${x.val}'`;
 
         case 'string':
-        // 'foo', with proper escaping
+          // 'foo', with proper escaping
           return `'${x.val.replace(/'/g, '\'\'')}'`;
         case 'object':
           if (x.val === null)
@@ -1388,7 +1450,12 @@ function toSqlDdl(csn, options) {
 
     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)
@@ -1400,6 +1467,9 @@ function toSqlDdl(csn, options) {
           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 (
@@ -1422,6 +1492,7 @@ function toSqlDdl(csn, options) {
     function render$user(x) {
       // 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}'`;
 
@@ -1441,7 +1512,7 @@ function toSqlDdl(csn, options) {
         }
         return 'SESSION_CONTEXT(\'LOCALE\')';
       }
-      // Basically: Second path step was invalid, do nothing
+      // Basically: Second path step was invalid, do nothing - should not happen, see 'unknownMagic.js'
       return null;
     }
     /**
@@ -1539,13 +1610,13 @@ function toSqlDdl(csn, options) {
 
         // Not really a path step but an object-like function call
         if (s.func)
-          return `${s.func}(${renderArgs(s.args, '=>', env, null)})`;
+          return `${s.func}(${renderArgs(s, '=>', env, null)})`;
 
         // Path step, possibly with view parameters and/or filters
         let result = `${quoteSqlId(s.id)}`;
         if (s.args) {
           // View parameters
-          result += `(${renderArgs(s.args, '=>', env, null)})`;
+          result += `(${renderArgs(s, '=>', env, null)})`;
         }
         if (s.where) {
           // Filter, possibly with cardinality

package/lib/render/utils/common.js

@@ -33,7 +33,7 @@ const { implicitAs } = require('../../model/csnRefs');
 function renderFunc( funcName, node, dialect, renderArgs) {
   if (funcWithoutParen( node, dialect ))
     return funcName;
-  return `${funcName}(${renderArgs( node.args )})`;
+  return `${funcName}(${renderArgs( node )})`;
 }
 
 /**
@@ -53,19 +53,14 @@ function funcWithoutParen( node, dialect ) {
 }
 
 /**
- * Process an expression array, rendering each subexpression and joining them appropriately
+ * Process already rendered expression parts by joining them nicely
  *
- * @param {Array} xpr Expression array
- * @param {Function} renderExpr Function to render expressions
- * @param {CdlRenderEnvironment} env Environment for rendering
- * @param {boolean} inline Wether to render the expression inline
- * @param {boolean} inExpr Wether to render as if a subexpression
+ * @param {Array} tokens Array of expression tokens
  *
  * @returns {string} The rendered xpr
  */
-function processExprArray(xpr, renderExpr, env, inline, inExpr) {
+function beautifyExprArray(tokens) {
   // Simply concatenate array parts with spaces (with a tiny bit of beautification)
-  const tokens = xpr.map(item => renderExpr(item, env, inline, inExpr));
   let result = '';
   for (let i = 0; i < tokens.length; i++) {
     result += tokens[i];
@@ -342,11 +337,10 @@ function addIntermediateContexts(csn, killList) {
  *
  * @param {CSN.Artifact} obj
  * @param {CSN.Options} options To check for `disableHanaComments`
- * @param {CSN.Artifact} artifact Artifact containing obj (in case of elem or columns)
  * @returns {boolean}
  */
-function hasHanaComment(obj, options, artifact = {}) {
-  return !artifact['@cds.persistence.journal'] && !options.disableHanaComments && typeof obj.doc === 'string';
+function hasHanaComment(obj, options) {
+  return !options.disableHanaComments && typeof obj.doc === 'string';
 }
 /**
    * Return the comment of the given artifact or element.
@@ -379,7 +373,7 @@ function getHanaComment(obj) {
 
 module.exports = {
   renderFunc,
-  processExprArray,
+  beautifyExprArray,
   getNamespace,
   getRealName,
   addIntermediateContexts,
@@ -388,4 +382,5 @@ module.exports = {
   hasHanaComment,
   getHanaComment,
   findElement,
+  funcWithoutParen,
 };

package/lib/render/utils/sql.js

@@ -20,9 +20,9 @@ const { smartId, delimitedId } = require('../../sql-identifier');
 function renderReferentialConstraint(constraint, indent, toUpperCase, csn, options, alterConstraint) {
   let quoteId;
   // for to.hana we can't utilize the sql identifier utils
-  if (options.toHana) {
+  if (options.transformation === 'hdbcds') {
     quoteId = (id) => {
-      if (options.toHana.names === 'plain')
+      if (options.sqlMapping === 'plain')
         return id.replace(/\./g, '_');
       return `"${id}"`;
     };
@@ -38,7 +38,7 @@ function renderReferentialConstraint(constraint, indent, toUpperCase, csn, optio
     constraint.parentTable = constraint.parentTable.toUpperCase();
   }
 
-  const renderAsHdbconstraint = options.toHana ||
+  const renderAsHdbconstraint = options.transformation === 'hdbcds' ||
                                 (options.toSql && options.toSql.src === 'hdi') ||
                                 (options.manageConstraints && options.manageConstraints.src === 'hdi');
 

package/lib/sql-identifier.js

@@ -51,7 +51,12 @@ const sqlDialects = {
     effectiveName: name => name.toUpperCase(),
     asDelimitedId: name => `"${ name.replace(/"/g, '""')}"`,
   },
-  // TODO: hdbcds for HANA CDS
+  hdbcds: {
+    regularRegex: /^[A-Za-z_][A-Za-z_0-9]*$/,
+    reservedWords: keywords.hdbcds,
+    effectiveName: name => name,
+    asDelimitedId: name => `"${ name.replace(/"/g, '""')}"`,
+  },
 };
 
 function smartId( name, dialect ) {

package/lib/transform/db/assertUnique.js

@@ -260,7 +260,7 @@ function processAssertUnique(csn, options, error, info) {
  * If the output format is SQL, the toSql renderer is responsible
  * to render the table constraints from the constraint dictionary.
  *
- * If options.toHana, no path flattening is done and  association
+ * If options.transformation === 'hdbcds', no path flattening is done and  association
  * paths are replaced with the foreign key paths by simply
  * concatenating the foreign key paths (available in element.keys).
  *
@@ -279,11 +279,10 @@ function rewriteUniqueConstraints(csn, options, pathDelimiter) {
    * @param {CSN.Artifact} artifact
    */
   function rewrite(artifact) {
-    const naming = options.forHana.names || options.toSql.names;
     if (artifact.$tableConstraints && artifact.$tableConstraints.unique) {
       const uniqueConstraints = artifact.$tableConstraints.unique;
       // it's safe to add the tc here
-      if (options.toHana) {
+      if (options.transformation === 'hdbcds') {
         if (!artifact.technicalConfig)
           artifact.technicalConfig = Object.create(null);
 
@@ -302,12 +301,12 @@ function rewriteUniqueConstraints(csn, options, pathDelimiter) {
         c.forEach((cpath) => {
           // If 'toSql' or 'toHana' and naming !== 'hdbcds'
           // concatenate path refs with appropriate delimiter
-          if (!options.toHana || (options.toHana && naming !== 'hdbcds'))
+          if (options.transformation !== 'hdbcds' || (options.transformation === 'hdbcds' && options.sqlMapping !== 'hdbcds'))
             cpath.ref = [ cpath.ref.map(p => p.id).join( pathDelimiter ) ];
 
           // Foreign key substitution
           if (cpath._art.target) {
-            if (!options.toHana || (options.toHana && naming !== 'hdbcds')) {
+            if (options.transformation !== 'hdbcds' || (options.transformation === 'hdbcds' && options.sqlMapping !== 'hdbcds')) {
               // read out new association and use $generatedFieldName
               // cpath._art still refers to the assoc definition
               // before the A2J transformation. This assoc
@@ -332,7 +331,7 @@ function rewriteUniqueConstraints(csn, options, pathDelimiter) {
         uniqueConstraints[uniqueConstraint] = rewrittenPaths;
 
         // now add the index for HANA CDS
-        if (options.toHana) {
+        if (options.transformation === 'hdbcds') {
           const index = [ 'unique', 'index', { ref: [ uniqueConstraint ] }, 'on', '(' ];
           let i = 0;
           for (const constraint of rewrittenPaths) {