@sap/cds-compiler 2.7.0 → 2.10.2

package/lib/render/toHdbcds.js

@@ -3,12 +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,
-  hasHanaComment, getHanaComment, findElement,
+  renderFunc, beautifyExprArray, getRealName, addContextMarkers, addIntermediateContexts, cdsToSqlTypes,
+  hasHanaComment, getHanaComment, findElement, funcWithoutParen,
 } = require('./utils/common');
 const {
   renderReferentialConstraint,
@@ -19,6 +19,8 @@ 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';
 
@@ -402,6 +404,9 @@ function toHdbcdsSource(csn, options) {
     const duplicateChecker = new DuplicateChecker(); // registry for all artifact names and element names
     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);
 
@@ -411,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.
    *
@@ -516,7 +548,7 @@ 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, env.path);
+    const quotedElementName = formatIdentifier(elementName);
     if (duplicateChecker)
       duplicateChecker.addElement(quotedElementName, env.path, elementName);
 
@@ -548,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, env.path)}`;
+        result += ` as ${formatIdentifier(source.as)}`;
 
       return result;
     }
@@ -627,11 +659,11 @@ function toHdbcdsSource(csn, options) {
     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, env.path)}`;
+      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, env.path)}`;
+      result += ` as ${formatIdentifier(implicitAlias)}`;
     }
     return result;
   }
@@ -655,7 +687,7 @@ function toHdbcdsSource(csn, options) {
 
     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, env.path)}`;
+        return `${result}${env.indent}null as ${formatIdentifier(leaf)}`;
     }
     else {
       return renderNonVirtualColumn();
@@ -683,7 +715,7 @@ function toHdbcdsSource(csn, options) {
         alias = leaf;
 
       if (alias)
-        result += ` as ${quoteOrUppercaseId(alias, env.path)}`;
+        result += ` as ${formatIdentifier(alias)}`;
 
       // Explicit type provided for the view element?
       if (col.cast && col.cast.target) {
@@ -797,7 +829,7 @@ function toHdbcdsSource(csn, options) {
       result += `${env.indent}}`;
     }
     if (select.excluding) {
-      result += ` excluding {\n${select.excluding.map(id => `${childEnv.indent}${quoteOrUppercaseId(id, env.path)}`).join(',\n')}\n`;
+      result += ` excluding {\n${select.excluding.map(id => `${childEnv.indent}${formatIdentifier(id)}`).join(',\n')}\n`;
       result += `${env.indent}}`;
     }
 
@@ -895,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, env.path)} : ${renderTypeReference(par, env)}`;
+    return `${env.indent + formatParamIdentifier(parName, env.path.concat([ 'params', parName ]))} : ${renderTypeReference(par, env)}`;
   }
 
   /**
@@ -1012,10 +1044,19 @@ 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)
@@ -1087,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)
@@ -1129,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
@@ -1267,7 +1311,7 @@ function toHdbcdsSource(csn, options) {
           [ $SELF, $PROJECTION, '$session' ].includes(s))
           return s;
 
-        return quoteOrUppercaseId(s, env.path);
+        return formatIdentifier(s);
       }
       // ID with filters or parameters
       else if (typeof s === 'object') {
@@ -1280,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)})`;
@@ -1312,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)}`);
@@ -1405,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));
   }
 
   /**
@@ -1493,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`] = '';
       });
@@ -1635,7 +1679,16 @@ 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;
+    }
   }
 
   /*
@@ -1656,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);
   }
 
@@ -1693,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, '_'));
   }

package/lib/render/toSql.js

@@ -7,7 +7,7 @@ const {
   forEachDefinition, getResultingName,
 } = require('../model/csnUtils');
 const {
-  renderFunc, processExprArray, cdsToSqlTypes, getHanaComment, hasHanaComment,
+  renderFunc, beautifyExprArray, cdsToSqlTypes, getHanaComment, hasHanaComment,
 } = require('./utils/common');
 const {
   renderReferentialConstraint, getIdentifierUtils,
@@ -1088,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)}`;
 
@@ -1336,7 +1343,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)

package/lib/render/utils/common.js

@@ -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];
@@ -378,7 +373,7 @@ function getHanaComment(obj) {
 
 module.exports = {
   renderFunc,
-  processExprArray,
+  beautifyExprArray,
   getNamespace,
   getRealName,
   addIntermediateContexts,
@@ -387,4 +382,5 @@ module.exports = {
   hasHanaComment,
   getHanaComment,
   findElement,
+  funcWithoutParen,
 };

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/draft.js

@@ -1,8 +1,8 @@
 'use strict';
 
 const {
-  hasAnnotationValue, forEachGeneric, getUtils, getServiceNames, forEachDefinition,
-  getResultingName,
+  hasAnnotationValue, getUtils, getServiceNames, forEachDefinition,
+  getResultingName, forEachMemberRecursively,
 } = require('../../model/csnUtils');
 const { setProp, isDeprecatedEnabled } = require('../../base/model');
 const { getTransformers } = require('../transformUtilsNew');
@@ -117,10 +117,12 @@ function generateDrafts(csn, options, pathDelimiter, messageFunctions) {
 
     // extract keys for UUID inspection
     const keys = [];
-    forEachGeneric( artifact, 'elements', (elt) => {
+    forEachMemberRecursively(artifact, (elt, name, prop, path) => {
+      if (!elt.elements && !elt.type && !elt.virtual) // only check leafs
+        error(null, path, 'Expecting element to have a type when used in a draft-enabled artifact');
       if (elt.key && elt.key === true && !elt.virtual)
         keys.push(elt);
-    });
+    }, [ 'definitions', artifactName ], true, { elementsOnly: true });
 
     // In contrast to EDM, the DB entity may have more than one technical keys but should have idealy exactly one key of type cds.UUID
     if (keys.length !== 1)

package/lib/transform/db/expansion.js

@@ -446,11 +446,15 @@ function expandStructureReferences(csn, options, pathDelimiter, { error, info, t
       if (col.ref && col.$scope !== '$magic') {
         const _art = col._art || inspectRef(path.concat(i)).art;
         if (_art && isStructured(_art))
-          newThing.push(...expandRef(_art, col.ref, [ col.as || col.ref[col.ref.length - 1] ], col.key || false, withAlias));
+          newThing.push(...expandRef(_art, col.ref, col.as, col.key || false, withAlias));
 
         else
           newThing.push(col);
       }
+      else if (col.ref && col.$scope === '$magic' && col.ref[0] === '$user' && !col.as) {
+        col.as = implicitAs(col.ref);
+        newThing.push(col);
+      }
       else {
         newThing.push(col);
       }
@@ -473,7 +477,7 @@ function expandStructureReferences(csn, options, pathDelimiter, { error, info, t
    */
   function expandRef(art, ref, alias, isKey, withAlias) {
     const expanded = [];
-    const stack = [ [ art, ref, alias ] ];
+    const stack = [ [ art, ref, [ alias || ref[ref.length - 1] ] ] ];
     while (stack.length > 0) {
       const [ current, currentRef, currentAlias ] = stack.pop();
       if (isStructured(current)) {
@@ -482,8 +486,14 @@ function expandStructureReferences(csn, options, pathDelimiter, { error, info, t
       }
       else {
         const obj = { ref: currentRef };
-        if (withAlias)
-          obj.as = currentAlias.join(pathDelimiter);
+        if (withAlias) {
+          const newAlias = currentAlias.join(pathDelimiter);
+          // if (alias !== undefined) // explicit alias
+          obj.as = newAlias;
+          // alias was implicit - to later distinguish expanded s -> s.a from explicitly written s.a
+          if (alias === undefined)
+            setProp(obj, '$implicitAlias', true);
+        }
         if (isKey)
           obj.key = true;
         expanded.push(obj);

package/lib/transform/db/flattening.js

@@ -69,8 +69,12 @@ function resolveTypeReferences(csn, options, resolved, pathDelimiter) {
     }
   }
   const { toFinalBaseType } = transformUtils.getTransformers(csn, options, pathDelimiter);
-  // (030) - For all elements, replace derived types by final base type
   applyTransformations(csn, {
+    cast: (parent) => {
+      // Resolve cast already - we otherwise lose .localized
+      if (parent.cast.type && !isBuiltinType(parent.cast.type))
+        toFinalBaseType(parent.cast, resolved, true);
+    },
     type: (parent, prop, type) => {
       if (!isBuiltinType(type)) {
         const directLocalized = parent.localized || false;
@@ -143,13 +147,17 @@ function flattenAllStructStepsInRefs(csn, options, resolved, pathDelimiter) {
 
         parent.ref = flattenStructStepsInRef(ref, scopedPath, links, scope, resolvedLinkTypes );
         resolved.set(parent, { links, art, scope });
-        // Because of expansion we added alias to everything - strip off superflous alias
-        if (parent.as && parent.as === parent.ref[parent.ref.length - 1] && scope !== '$magic')
-          delete parent.as;
         // Explicitly set implicit alias for things that are now flattened - but only in columns
         // TODO: Can this be done elegantly during expand phase already?
-        else if (parent.ref[ref.length - 1] !== lastRef && (insideColumns(scopedPath) || insideKeys(scopedPath)) && !parent.as)
+        if (parent.$implicitAlias) { // an expanded s -> s.a is marked with this - do not add implicit alias "a" there, we want s_a
+          if (parent.ref[parent.ref.length - 1] === parent.as) // for a simple s that was expanded - for s.substructure this would not apply
+            delete parent.as;
+          delete parent.$implicitAlias;
+        }
+        // To handle explicitly written s.a - add implicit alias a, since after flattening it would otherwise be s_a
+        else if (parent.ref[parent.ref.length - 1] !== lastRef && (insideColumns(scopedPath) || insideKeys(scopedPath)) && !parent.as) {
           parent.as = lastRef;
+        }
       };
       // adapt queries later
       adaptRefs.push(fn);