@sap/cds-compiler 2.4.4 → 2.10.2

package/lib/render/toHdbcds.js

@@ -3,11 +3,12 @@
 const {
   getParentNameOf, getLastPartOf, getLastPartOfRef,
   hasValidSkipOrExists, isBuiltinType, generatedByCompilerVersion, getNormalizedQuery,
-  getRootArtifactName, getResultingName, getNamespace,
+  getRootArtifactName, getResultingName, getNamespace, forEachMember,
 } = require('../model/csnUtils');
 const keywords = require('../base/keywords');
 const {
-  renderFunc, processExprArray, getRealName, addContextMarkers, addIntermediateContexts, cdsToSqlTypes,
+  renderFunc, beautifyExprArray, getRealName, addContextMarkers, addIntermediateContexts, cdsToSqlTypes,
+  hasHanaComment, getHanaComment, findElement, funcWithoutParen,
 } = require('./utils/common');
 const {
   renderReferentialConstraint,
@@ -18,9 +19,21 @@ const { checkCSNVersion } = require('../json/csnVersion');
 const { makeMessageFunction } = require('../base/messages');
 const timetrace = require('../utils/timetrace');
 
+const { smartId, delimitedId } = require('../sql-identifier');
+
 const $PROJECTION = '$projection';
 const $SELF = '$self';
 
+/**
+ * Get the comment and in addition escape \n so HANA CDS can handle it.
+ *
+ * @param {CSN.Artifact} obj
+ * @returns {string}
+ */
+function getEscapedHanaComment(obj) {
+  return getHanaComment(obj).replace(/\n/g, '\\n');
+}
+
 /**
  * Render the CSN model 'model' to CDS source text. One source is created per
  * top-level artifact. Return a dictionary of top-level artifacts
@@ -28,8 +41,7 @@ const $SELF = '$self';
  * { "foo" : "using XY; context foo {...};",
  *   "bar::wiz" : "namespace bar::; entity wiz {...};"
  * }
- * If 'options.toHana' is set, render HANA-ish source dialect (currently
- * only affects translation of '$self.foo' in paths and ::-ish namespace declarations)
+ *
  * FIXME: This comment no longer tells the whole truth
  *
  * @param {CSN.Model} csn HANA transformed CSN
@@ -38,9 +50,9 @@ const $SELF = '$self';
  */
 function toHdbcdsSource(csn, options) {
   timetrace.start('HDBCDS rendering');
-  const plainNames = options.toHana && options.toHana.names === 'plain';
-  const quotedNames = options.toHana && options.toHana.names === 'quoted';
-  const hdbcdsNames = options.toHana && options.toHana.names === 'hdbcds';
+  const plainNames = options.sqlMapping === 'plain';
+  const quotedNames = options.sqlMapping === 'quoted';
+  const hdbcdsNames = options.sqlMapping === 'hdbcds';
 
   const {
     info, warning, error, throwWithError,
@@ -51,7 +63,7 @@ function toHdbcdsSource(csn, options) {
   const result = Object.create(null);
 
 
-  const globalDuplicateChecker = new DuplicateChecker(options.toHana.names); // registry for all artifact names and element names
+  const globalDuplicateChecker = new DuplicateChecker(options.sqlMapping); // registry for all artifact names and element names
 
   const killList = [];
   if (quotedNames)
@@ -378,7 +390,10 @@ function toHdbcdsSource(csn, options) {
     const childEnv = increaseIndent(env);
     const normalizedArtifactName = renderArtifactName(artifactName, env);
 
-    globalDuplicateChecker.addArtifact(art['@cds.persistence.name'], art && art.$location, artifactName);
+    globalDuplicateChecker.addArtifact(art['@cds.persistence.name'], env.path, artifactName);
+
+    if (hasHanaComment(art, options))
+      result += `${env.indent}@Comment: '${getEscapedHanaComment(art)}'\n`;
 
     result += `${env.indent + (art.abstract ? 'abstract ' : '')}entity ${normalizedArtifactName}`;
     if (art.includes) {
@@ -387,7 +402,11 @@ function toHdbcdsSource(csn, options) {
     }
     result += ' {\n';
     const duplicateChecker = new DuplicateChecker(); // registry for all artifact names and element names
-    duplicateChecker.addArtifact(artifactName, art && art.$location, artifactName);
+    duplicateChecker.addArtifact(artifactName, env.path, artifactName);
+    childEnv.path = env.path.concat('elements');
+    // calculate __aliases which must be used in case an association
+    // has the same identifier as it's target
+    createTopLevelAliasesForArtifact(artifactName, art, env);
     for (const name in art.elements)
       result += renderElement(name, art.elements[name], childEnv, duplicateChecker);
 
@@ -397,6 +416,33 @@ function toHdbcdsSource(csn, options) {
     return result;
   }
 
+  /**
+   * If an association/composition has the same identifier as it's target
+   * we must render an "using target as __target" and use the alias to refer to the target
+   *
+   * @param {string} artName
+   * @param {CSN.Artifact} art
+   * @param {CdlRenderEnvironment} env
+   */
+  function createTopLevelAliasesForArtifact(artName, art, env) {
+    forEachMember(art, (element) => {
+      if (!element.target)
+        return;
+
+      let alias = element['@cds.persistence.name'];
+      if (uppercaseAndUnderscore(element.target) === element['@cds.persistence.name']) {
+        alias = createTopLevelAliasName(element['@cds.persistence.name']);
+        // calculate new alias if it would conflict with other csn.Artifact
+        while (csn.definitions[alias])
+          alias = createTopLevelAliasName(alias);
+        env.topLevelAliases[element['@cds.persistence.name']] = {
+          quotedName: formatIdentifier(element['@cds.persistence.name']),
+          quotedAlias: formatIdentifier(alias),
+        };
+      }
+    });
+  }
+
   /**
    * Render the 'technical configuration { ... }' section 'tc' of an entity.
    *
@@ -502,9 +548,13 @@ function toHdbcdsSource(csn, options) {
     // Special handling for HANA CDS: Must omit the ':' before anonymous structured types (for historical reasons)
     const omitColon = (!elm.type && elm.elements);
     let result = '';
-    const quotedElementName = quoteOrUppercaseId(elementName, elm.$location);
+    const quotedElementName = formatIdentifier(elementName);
     if (duplicateChecker)
-      duplicateChecker.addElement(quotedElementName, elm && elm.$location, elementName);
+      duplicateChecker.addElement(quotedElementName, env.path, elementName);
+
+    if (hasHanaComment(elm, options))
+      result += `${env.indent}@Comment: '${getEscapedHanaComment(elm)}'\n`;
+
     result += env.indent + (elm.key && !isSubElement ? 'key ' : '') +
                          (elm.masked ? 'masked ' : '') +
                          quotedElementName + (omitColon ? ' ' : ' : ') +
@@ -530,7 +580,7 @@ function toHdbcdsSource(csn, options) {
     if (source.SELECT || source.SET) {
       let result = `(${renderQuery(source, false, increaseIndent(env))})`;
       if (source.as)
-        result += ` as ${quoteOrUppercaseId(source.as)}`;
+        result += ` as ${formatIdentifier(source.as)}`;
 
       return result;
     }
@@ -606,14 +656,14 @@ function toHdbcdsSource(csn, options) {
   function renderAbsolutePathWithAlias(path, env) {
     let result = renderAbsolutePath(path, env);
     // Take care of aliases - for artifact references, use the resulting name (multi-dot joined with _)
-    const implicitAlias = path.ref.length === 0 ? getLastPartOf(getResultingName(csn, options.toHana.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 ${quoteOrUppercaseId(path.as)}`;
+      result += ` as ${formatIdentifier(path.as)}`;
     }
-    else if (getLastPartOf(result) !== quoteOrUppercaseId(implicitAlias)) {
+    else if (getLastPartOf(result) !== formatIdentifier(implicitAlias)) {
       // Render an artificial alias if the result would produce a different one
-      result += ` as ${quoteOrUppercaseId(implicitAlias)}`;
+      result += ` as ${formatIdentifier(implicitAlias)}`;
     }
     return result;
   }
@@ -625,19 +675,19 @@ function toHdbcdsSource(csn, options) {
    *
    * @param {object} col Column to render
    * @param {CdlRenderEnvironment} env Environment
+   * @param {CSN.Element} [element] Element (non-enum from subquery possibly) corresponding to the column ref
    * @returns {string} Rendered column
    */
-  function renderViewColumn(col, env) {
+  function renderViewColumn(col, env, element) {
     // Annotations and column
-    let result = '';
+    let result = element && hasHanaComment(element, options) ? `${env.indent}@Comment: '${getEscapedHanaComment(element)}'\n` : '';
 
     const leaf = col.as || col.ref && col.ref[col.ref.length - 1];
-    const element = env._artifact.elements[leaf];
     // Render 'null as <alias>' only for database and if element is virtual
 
-    if (element && element.virtual) {
+    if (element && element.virtual || env._artifact.elements[leaf] && env._artifact.elements[leaf].virtual) {
       if (isDeprecatedEnabled(options, 'renderVirtualElements'))
-        return `${result}${env.indent}null as ${quoteOrUppercaseId(leaf)}`;
+        return `${result}${env.indent}null as ${formatIdentifier(leaf)}`;
     }
     else {
       return renderNonVirtualColumn();
@@ -652,7 +702,7 @@ function toHdbcdsSource(csn, options) {
         result += 'virtual ';
       // If key is explicitly set in a non-leading query, issue an error.
       if (col.key && env.skipKeys)
-        error(null, env.path, 'KEY must only be added in the leading query');
+        error(null, env.path, { tokensymbol: 'key', $reviewed: true }, 'Unexpected $(TOKENSYMBOL) in subquery');
 
       const key = (!env.skipKeys && (col.key || (element && element.key)) ? 'key ' : '');
       result += key + renderExpr(col, env, true);
@@ -665,7 +715,7 @@ function toHdbcdsSource(csn, options) {
         alias = leaf;
 
       if (alias)
-        result += ` as ${quoteOrUppercaseId(alias)}`;
+        result += ` as ${formatIdentifier(alias)}`;
 
       // Explicit type provided for the view element?
       if (col.cast && col.cast.target) {
@@ -692,7 +742,12 @@ function toHdbcdsSource(csn, options) {
    */
   function renderView(artifactName, art, env) {
     let result = '';
-    globalDuplicateChecker.addArtifact(art['@cds.persistence.name'], art.$location, artifactName);
+    const artifactPath = [ 'definitions', artifactName ];
+    globalDuplicateChecker.addArtifact(art['@cds.persistence.name'], artifactPath, artifactName);
+
+    if (hasHanaComment(art, options))
+      result += `${env.indent}@Comment: '${getEscapedHanaComment(art)}'\n`;
+
     result += `${env.indent}${art.abstract ? 'abstract ' : ''}view ${renderArtifactName(artifactName, env)}`;
     if (art.params) {
       const childEnv = increaseIndent(env);
@@ -704,7 +759,7 @@ function toHdbcdsSource(csn, options) {
       result += ' as ';
     }
     env._artifact = art;
-    result += renderQuery(getNormalizedQuery(art).query, true, env, [ 'definitions', artifactName, 'query' ]);
+    result += renderQuery(getNormalizedQuery(art).query, true, env, artifactPath.concat(art.projection ? 'projection' : 'query'), art.elements);
     result += ';\n';
     return result;
   }
@@ -719,15 +774,16 @@ function toHdbcdsSource(csn, options) {
    * @param {boolean} isLeadingQuery Wether the query is the leading query or not
    * @param {CdlRenderEnvironment} env Environment
    * @param {CSN.Path} [path=[]] CSN path to the query
+   * @param {object} [elements] For leading query, the elements of the artifact
    * @returns {string} The rendered query
    */
-  function renderQuery(query, isLeadingQuery, env, path = []) {
+  function renderQuery(query, isLeadingQuery, env, path = [], elements) {
     let result = '';
     env.skipKeys = !isLeadingQuery;
     // Set operator, like UNION, INTERSECT, ...
     if (query.SET) {
       // First arg may be leading query
-      result += `(${renderQuery(query.SET.args[0], isLeadingQuery, env, path.concat([ 'SET', 'args', 0 ]))}`;
+      result += `(${renderQuery(query.SET.args[0], isLeadingQuery, env, path.concat([ 'SET', 'args', 0 ]), elements)}`;
       // FIXME: Clarify if set operators can be n-ary (assuming binary here)
       if (query.SET.op) {
         // Loop over all other arguments, i.e. for A UNION B UNION C UNION D ...
@@ -753,7 +809,6 @@ function toHdbcdsSource(csn, options) {
     const childEnv = increaseIndent(env);
     childEnv.currentArtifactName = $PROJECTION; // $self to be replaced by $projection
     result += `select from ${renderViewSource(select.from, env)}`;
-
     if (select.mixin) {
       let elems = '';
       for (const name in select.mixin)
@@ -768,13 +823,13 @@ function toHdbcdsSource(csn, options) {
     result += select.distinct ? ' distinct' : '';
     if (select.columns) {
       result += ' {\n';
-      result += `${select.columns.map(col => renderViewColumn(col, childEnv))
+      result += `${select.columns.map(col => renderViewColumn(col, childEnv, findElement(elements, col)))
         .filter(s => s !== '')
         .join(',\n')}\n`;
       result += `${env.indent}}`;
     }
     if (select.excluding) {
-      result += ` excluding {\n${select.excluding.map(id => `${childEnv.indent}${quoteOrUppercaseId(id)}`).join(',\n')}\n`;
+      result += ` excluding {\n${select.excluding.map(id => `${childEnv.indent}${formatIdentifier(id)}`).join(',\n')}\n`;
       result += `${env.indent}}`;
     }
 
@@ -872,7 +927,7 @@ function toHdbcdsSource(csn, options) {
   function renderParameter(parName, par, env) {
     if (par.notNull === true || par.notNull === false)
       info(null, env.path.concat([ 'params', parName ]), 'Not Null constraints on HDBCDS view parameters are not allowed and are ignored');
-    return `${env.indent + quoteOrUppercaseId(parName)} : ${renderTypeReference(par, env)}`;
+    return `${env.indent + formatParamIdentifier(parName, env.path.concat([ 'params', parName ]))} : ${renderTypeReference(par, env)}`;
   }
 
   /**
@@ -989,10 +1044,24 @@ function toHdbcdsSource(csn, options) {
 
     result += `${renderCardinality(elm.cardinality)} to `;
 
+
     // normal target or named aspect
     if (elm.target || elm.targetAspect && typeof elm.targetAspect === 'string') {
-      result += plainNames ? renderAbsoluteNamePlain(elm.target || elm.targetAspect, env)
-        : renderAbsoluteNameWithQuotes(elm.target || elm.targetAspect, env);
+      // we might have a "using target as __target"
+      const targetArtifact = csn.definitions[elm.target];
+      const targetAlias = env.topLevelAliases[targetArtifact['@cds.persistence.name']];
+      if (targetAlias) {
+        result += targetAlias.quotedAlias;
+      }
+      else {
+        result += plainNames ? renderAbsoluteNamePlain(elm.target || elm.targetAspect, env)
+          : renderAbsoluteNameWithQuotes(elm.target || elm.targetAspect, env);
+      }
+    }
+
+    // ON-condition (if any)
+    if (elm.on) {
+      result += ` on ${renderExpr(elm.on, env, true, true)}`;
     }
     else if (elm.targetAspect && elm.targetAspect.elements) { // anonymous aspect
       const childEnv = increaseIndent(env);
@@ -1004,11 +1073,6 @@ function toHdbcdsSource(csn, options) {
     }
 
 
-    // ON-condition (if any)
-    if (elm.on)
-      result += ` on ${renderExpr(elm.on, env, true, true)}`;
-
-
     // Foreign keys (if any, unless we also have an ON_condition (which means we have been transformed from managed to unmanaged)
     if (elm.keys && !elm.on)
       result += ` { ${Object.keys(elm.keys).map(name => renderForeignKey(elm.keys[name], env)).join(', ')} }`;
@@ -1064,7 +1128,7 @@ function toHdbcdsSource(csn, options) {
   function renderExpr(x, env, inline = true, inExpr = false) {
     // Compound expression
     if (Array.isArray(x))
-      return processExprArray(x, renderExpr, env, inline, inExpr);
+      return beautifyExprArray(x.map(item => renderExpr(item, env, inline, inExpr)));
 
     if (typeof x === 'object' && x !== null) {
       if (inExpr && x.cast && x.cast.type)
@@ -1106,6 +1170,9 @@ function toHdbcdsSource(csn, options) {
 
         const regex = RegExp(/^[a-zA-Z][\w#$]*$/, 'g');
         const funcName = regex.test(x.func) ? x.func : quoteId(x.func);
+        // we can't quote functions with parens, issue warning if it is a reserved keyword
+        if (!funcWithoutParen(x, 'hana') && keywords.hdbcds.includes(uppercaseAndUnderscore(funcName)))
+          warning(null, x.$location, `The identifier “${uppercaseAndUnderscore(funcName)}“ is a SAP HANA keyword`);
         return renderFunc( funcName, x, 'hana', a => renderArgs(a, '=>', env) );
       }
       // Nested expression
@@ -1165,11 +1232,11 @@ function toHdbcdsSource(csn, options) {
         if (x.ref[0] === '$user') {
           // FIXME: this is all not enough: we might need an explicit select item alias
           if (x.ref[1] === 'id') {
-            if (options.toHana.user && typeof options.toHana.user === 'string' || options.toHana.user instanceof String)
-              return `'${options.toHana.user}'`;
+            if (options.magicVars && options.magicVars.user && (typeof options.magicVars.user === 'string' || options.magicVars.user instanceof String))
+              return `'${options.magicVars.user}'`;
 
-            else if ((options.toHana.user && options.toHana.user.id) && (typeof options.toHana.user.id === 'string' || options.toHana.user.id instanceof String))
-              return `'${options.toHana.user.id}'`;
+            else if ((options.magicVars && options.magicVars.user && options.magicVars.user.id) && (typeof options.magicVars.user.id === 'string' || options.magicVars.user.id instanceof String))
+              return `'${options.magicVars.user.id}'`;
 
             return 'SESSION_CONTEXT(\'APPLICATIONUSER\')';
           }
@@ -1244,7 +1311,7 @@ function toHdbcdsSource(csn, options) {
           [ $SELF, $PROJECTION, '$session' ].includes(s))
           return s;
 
-        return quoteOrUppercaseId(s);
+        return formatIdentifier(s);
       }
       // ID with filters or parameters
       else if (typeof s === 'object') {
@@ -1257,7 +1324,7 @@ function toHdbcdsSource(csn, options) {
           return `${s.func}(${renderArgs(s.args, '=>', env)})`;
 
         // Path step, possibly with view parameters and/or filters
-        let result = `${quoteOrUppercaseId(s.id)}`;
+        let result = `${formatIdentifier(s.id)}`;
         if (s.args) {
           // View parameters
           result += `(${renderArgs(s.args, ':', env)})`;
@@ -1289,7 +1356,7 @@ function toHdbcdsSource(csn, options) {
 
     // Named arguments (object/dict)
     else if (typeof args === 'object')
-      return Object.keys(args).map(key => `${quoteOrUppercaseId(key)} ${sep} ${renderExpr(args[key], env)}`).join(', ');
+      return Object.keys(args).map(key => `${formatIdentifier(key)} ${sep} ${renderExpr(args[key], env)}`).join(', ');
 
 
     throw new Error(`Unknown args: ${JSON.stringify(args)}`);
@@ -1382,10 +1449,10 @@ function toHdbcdsSource(csn, options) {
   function renderAbsoluteNamePlain(absName, env) {
     // Add using declaration
     env.topLevelAliases[absName] = {
-      quotedName: uppercaseAndUnderscore(absName),
-      quotedAlias: uppercaseAndUnderscore(absName),
+      quotedName: formatIdentifier(uppercaseAndUnderscore(absName)),
+      quotedAlias: formatIdentifier(uppercaseAndUnderscore(absName)),
     };
-    return uppercaseAndUnderscore(absName);
+    return formatIdentifier(uppercaseAndUnderscore(absName));
   }
 
   /**
@@ -1470,7 +1537,7 @@ function toHdbcdsSource(csn, options) {
   function renderUsings(artifactName, env) {
     const distinct = {};
     Object.keys(env.topLevelAliases)
-      .filter(name => !(plainNames && env.topLevelAliases[name].quotedName === uppercaseAndUnderscore(artifactName))) // avoid "using FOO as FOO" in FOO.cds
+      .filter(name => env.topLevelAliases[name].quotedAlias !== formatIdentifier(uppercaseAndUnderscore(artifactName))) // avoid "using FOO as FOO" in FOO.cds
       .forEach((name) => {
         distinct[`using ${env.topLevelAliases[name].quotedName} as ${env.topLevelAliases[name].quotedAlias};\n`] = '';
       });
@@ -1541,6 +1608,8 @@ function toHdbcdsSource(csn, options) {
       topLevelAliases: Object.create(null),
       // Current name prefix (including trailing dot if not empty)
       namePrefix: '',
+      // CSN path - should at least point to the correct artifact
+      path: [],
     };
   }
 
@@ -1585,7 +1654,7 @@ function toHdbcdsSource(csn, options) {
    */
   function quoteAbsolutePathString(abspath) {
     const namespace = getNamespace(csn, abspath);
-    const resultingName = getResultingName(csn, options.toHana.names, abspath);
+    const resultingName = getResultingName(csn, options.sqlMapping, abspath);
 
     if (hdbcdsNames && namespace)
       return `${quotePathString(namespace)}::${quotePathString(resultingName.slice(namespace.length + 2))}`;
@@ -1610,10 +1679,19 @@ function toHdbcdsSource(csn, options) {
       return id;
 
 
-    return `"${id.replace(/"/g, '""')}"`;
+    switch (options.forHana.names) {
+      case 'plain':
+        return smartId(id, 'hdbcds');
+      case 'quoted':
+        return delimitedId(id, 'hdbcds');
+      case 'hdbcds':
+        return delimitedId(id, 'hdbcds');
+      default:
+        return null;
+    }
   }
 
-  /**
+  /*
    * Return an absolute name 'absname', with '::' inserted if required by naming strategy 'hdbcds', quoted
    * as if it was a single identifier (required only for native USINGs)
    *
@@ -1631,21 +1709,34 @@ function toHdbcdsSource(csn, options) {
   }
 
   /**
-   * Quote or uppercase an identifier 'id', depending on naming strategy
+   * Quote and/or uppercase an identifier 'id', depending on naming strategy
    *
    * @param {string} id Identifier
-   * @param {CSN.Location} [location] Optional location for the warning.
    * @returns {string} Quoted/uppercased id
    */
-  function quoteOrUppercaseId(id, location = null) {
-    if (plainNames) {
-      const result = uppercaseAndUnderscore(id);
-      // Warn if colliding with HANA keyword
-      if (keywords.hana.includes(result))
-        warning(null, location, `The identifier "${id}" is a SAP HANA keyword`);
+  function formatIdentifier(id) {
+    id = options.forHana.names === 'plain' ? id.toUpperCase() : id;
+    return quoteId(id);
+  }
+
+  /**
+   * Quote or uppercase a parameter identifier 'id', depending on naming strategy
+   * Smart quoting cannot be applied to the parameter identifiers, issue warning instead.
+   *
+   *
+   * @param {string} id Identifier
+   * @param {CSN.Path} [location] Optional location for the warning.
+   * @returns {string} Quoted/uppercased id
+   */
+  function formatParamIdentifier(id, location) {
+    // Warn if colliding with HANA keyword, but do not quote for plain
+    // --> quoted reserved words as param lead to a weird deployment error
+    if (keywords.hdbcds.includes(uppercaseAndUnderscore(id)))
+      warning(null, location, { id }, 'The identifier $(ID) is a SAP HANA keyword');
+
+    if (plainNames)
+      return uppercaseAndUnderscore(id);
 
-      return result;
-    }
     return quoteId(id);
   }
 
@@ -1668,7 +1759,7 @@ function toHdbcdsSource(csn, options) {
    */
   function renderArtifactName(artifactName, env, fallthrough = false) {
     if (plainNames && !fallthrough)
-      return uppercaseAndUnderscore(artifactName);
+      return formatIdentifier(uppercaseAndUnderscore(artifactName));
       // hdbcds with quoted or hdbcds naming
     return env.namePrefix + quoteId(getRealName(csn, artifactName).replace(/\./g, '_'));
   }