@sap/cds-compiler 3.6.2 → 3.8.0

package/lib/render/toRename.js

@@ -3,10 +3,11 @@
 
 const { makeMessageFunction } = require('../base/messages');
 const { checkCSNVersion } = require('../json/csnVersion');
-const { getNamespace, forEachDefinition } = require('../model/csnUtils');
+const { forEachDefinition } = require('../model/csnUtils');
 const { optionProcessor } = require('../optionProcessor');
 const { isBetaEnabled } = require('../base/model');
 const { transformForRelationalDBWithCsn } = require('../transform/forRelationalDB');
+const { getIdentifierUtils } = require('./utils/sql');
 
 
 /**
@@ -46,6 +47,9 @@ function toRename( inputCsn, options ) {
 
   // FIXME: Currently, 'toRename' implies transformation for HANA (transferring the options to forRelationalDB)
   const csn = transformForRelationalDBWithCsn(inputCsn, options, 'to.rename');
+  const hdbcdsOrQuotedIdentifiers = getIdentifierUtils(csn, options);
+  const plainIdentifiers = getIdentifierUtils(csn, { sqlDialect: 'hana', sqlMapping: 'plain' });
+
   // forRelationalDB looses empty contexts and services, add them again so that toRename can calculate the namespaces
   forEachDefinition(csn, (artifact, artifactName) => {
     if ((artifact.kind === 'context' || artifact.kind === 'service') && csn.definitions[artifactName] === undefined)
@@ -82,10 +86,12 @@ function toRename( inputCsn, options ) {
   function renameTableAndColumns( artifactName, art ) {
     let resultStr = '';
     if (art.kind === 'entity' && !art.query) {
-      const beforeTableName = quoteSqlId(absoluteCdsName(artifactName));
-      const afterTableName = plainSqlId(artifactName);
+      const beforeTableName = hdbcdsOrQuotedIdentifiers.renderArtifactName(artifactName);
+      const afterTableName = plainIdentifiers.renderArtifactName(artifactName);
 
-      if (beforeTableName !== afterTableName)
+      if (beforeTableName.toUpperCase() === `"${afterTableName}"`)
+        resultStr += `  --EXEC 'RENAME TABLE ${beforeTableName} TO ${afterTableName}';\n`;
+      else if (beforeTableName !== afterTableName)
         resultStr += `  EXEC 'RENAME TABLE ${beforeTableName} TO ${afterTableName}';\n`;
 
 
@@ -93,13 +99,14 @@ function toRename( inputCsn, options ) {
         const e = art.elements[name];
         let str = '';
 
-        const beforeColumnName = quoteSqlId(name);
-        const afterColumnName = plainSqlId(name);
+        const beforeColumnName = hdbcdsOrQuotedIdentifiers.quoteSqlId(name);
+        const afterColumnName = plainIdentifiers.quoteSqlId(name);
 
         if (!e._ignore) {
           if (e.target)
             str = `  EXEC 'ALTER TABLE ${afterTableName} DROP ASSOCIATION ${beforeColumnName}';\n`;
-
+          else if (beforeColumnName.toUpperCase() === `"${afterColumnName}"` ) // Basically a no-op - render commented out
+            str = `    --EXEC 'RENAME COLUMN ${afterTableName}.${beforeColumnName} TO ${afterColumnName}';\n`;
           else if (beforeColumnName !== afterColumnName)
             str = `    EXEC 'RENAME COLUMN ${afterTableName}.${beforeColumnName} TO ${afterColumnName}';\n`;
         }
@@ -108,50 +115,6 @@ function toRename( inputCsn, options ) {
     }
     return resultStr;
   }
-
-  /**
-   * Return 'name' in the form of an absolute CDS name - for the 'hdbcds' naming convention,
-   * this means converting '.' to '::' on the border between namespace and top-level artifact.
-   * For all other naming conventions, this is a no-op.
-   *
-   * @param {string} name Name to absolutify
-   * @returns {string} Absolute name
-   */
-  function absoluteCdsName( name ) {
-    if (options.sqlMapping !== 'hdbcds')
-      return name;
-
-    const namespaceName = getNamespace(inputCsn, name);
-    if (namespaceName)
-      return `${namespaceName}::${name.substring(namespaceName.length + 1)}`;
-
-    return name;
-  }
-
-  /**
-   * Return 'name' with appropriate "-quotes, also replacing '::' by '.' if 'options.sqlMapping'
-   * is 'quoted'
-   *
-   * @param {string} name Name to quote
-   * @returns {string} Quoted string
-   */
-  function quoteSqlId( name ) {
-    if (options.sqlMapping === 'quoted')
-      name = name.replace(/::/g, '.');
-
-    return `"${name.replace(/"/g, '""')}"`;
-  }
-
-  /**
-   * Return 'name' with uppercasing and appropriate "-quotes, also replacing '::' and '.' by '_'
-   * (to be used by 'plain' naming convention).
-   *
-   * @param {string} name Name to turn into a plain identifier
-   * @returns {string} A plain SQL identifier
-   */
-  function plainSqlId( name ) {
-    return `"${name.toUpperCase().replace(/(::|\.)/g, '_').replace(/"/g, '""')}"`;
-  }
 }
 
 module.exports = {

package/lib/render/toSql.js

@@ -93,10 +93,11 @@ function toSqlDdl( csn, options ) {
       return `CAST(${this.renderExpr(withoutCast(x))} AS ${typeRef})`;
     },
     val: renderExpressionLiteral,
-    enum: (x) => {
-      // TODO: Signal is not covered by tests + better location
+    enum(x) {
+      // TODO: better location; callers should set env.$path
       // 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');
+      const loc = x.$location || this.env?._artifact?.$location;
+      error('expr-unexpected-enum', [ loc, null ], 'Enum values are not yet supported for conversion to SQL');
       return '';
     },
     ref: renderExpressionRef,

package/lib/render/utils/common.js

@@ -54,10 +54,10 @@ function funcWithoutParen( node, dialect ) {
 }
 
 /**
- * Process already rendered expression parts by joining them nicely
- *
- * @param {Array} tokens Array of expression tokens
+ * Process already rendered expression parts by joining them nicely.
+ * For example, it adds spaces around operators such as `+`, but not around `.`.
  *
+ * @param {any[]} tokens Array of expression tokens
  * @returns {string} The rendered xpr
  */
 function beautifyExprArray( tokens ) {
@@ -65,8 +65,12 @@ function beautifyExprArray( tokens ) {
   let result = '';
   for (let i = 0; i < tokens.length; i++) {
     result += tokens[i];
-    // No space after last token, after opening parentheses, before closing parentheses, before comma
-    if (i !== tokens.length - 1 && tokens[i] !== '(' && ![ ')', ',' ].includes(tokens[i + 1]))
+    // 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] !== '.' &&
+        // next token
+        tokens[i + 1] !== ')' && tokens[i + 1] !== '.' && tokens[i + 1] !== ',')
       result += ' ';
   }
   return result;

package/lib/transform/braceExpression.js

@@ -1,3 +1,9 @@
+// Currently unused, but may become useful again if HDBCDS -> HDBTABLE
+// handover becomes more prominent.  Historically used with the no longer
+// existent option `--compatibility`.
+// If necessary, more complex expressions could be parsed with parseExpr.js
+// and then stringified with parentheses again.
+
 'use strict';
 
 function isAlreadyBraced(expression, start, end){

package/lib/transform/db/assertUnique.js

@@ -19,11 +19,12 @@ const { pathName } = require('../../compiler/utils');
  * @param {CSN.Options} options Options
  * @param {Function} error Message function for errors
  * @param {Function} info Message function for info
+ * @returns {Function} forEachDefinition callback
  */
 function processAssertUnique( csn, options, error, info ) {
   const { resolvePath, flattenPath } = getTransformers(csn, options);
 
-  forEachDefinition(csn, handleAssertUnique);
+  return handleAssertUnique;
   /**
    * The detailed processing - see comment above for what is going on here
    *

package/lib/transform/db/expansion.js

@@ -361,6 +361,8 @@ function expandStructureReferences( csn, options, pathDelimiter, { error, info,
           expanded.push(Object.assign({}, current, { as: currentAlias.join(pathDelimiter) } ));
         }
         else { // preserve stuff like .cast for redirection
+          if (base[currentAlias[currentAlias.length - 1]]?.value)
+            error('query-unsupported-calc', col.$path, { '#': 'inside' });
           expanded.push(Object.assign({}, current, { ref: currentRef, as: currentAlias.join(pathDelimiter) } ));
         }
       }

package/lib/transform/db/flattening.js

@@ -293,7 +293,7 @@ function flattenElements( csn, options, pathDelimiter, error, iterateOptions = {
         // TODO: use $ignore - _ is for links
         element._ignore = true;
 
-        const branches = getBranches(element, elementName);
+        const branches = getBranches(element, elementName, effectiveType, pathDelimiter);
         const flatElems = flattenStructuredElement(element, elementName, [], path.concat([ 'elements', elementName ]));
 
         for (const flatElemName in flatElems) {
@@ -308,7 +308,7 @@ function flattenElements( csn, options, pathDelimiter, error, iterateOptions = {
           const flatElement = flatElems[flatElemName];
 
           // Check if we have a valid notNull chain
-          const branch = branches[flatElemName];
+          const branch = branches[flatElemName].steps;
           if (flatElement.notNull !== false && !branch.some(s => !s.notNull))
             flatElement.notNull = true;
 
@@ -357,49 +357,49 @@ function flattenElements( csn, options, pathDelimiter, error, iterateOptions = {
       return elements;
     }, Object.create(null));
   }
+}
 
-
+/**
+ * Get not just the leaves, but all branches of a structured element.
+ *
+ * @param {object} element Structured element
+ * @param {string} elementName Name of the structured element
+ * @param {Function} effectiveType
+ * @param {string} pathDelimiter
+ * @returns {object} Returns a dictionary, where the key is the flat name of the branch and the value is an array of element-steps.
+ */
+function getBranches( element, elementName, effectiveType, pathDelimiter ) {
+  const branches = {};
+  const subbranchNames = [];
+  const subbranchElements = [];
+  walkElements(element, elementName);
   /**
-   * Get not just the leafs, but all the branches of a structured element
+   * Walk the element chain
    *
-   * @param {object} element Structured element
-   * @param {string} elementName Name of the structured element
-   * @returns {object} Returns a dictionary, where the key is the flat name of the branch and the value is an array of element-steps.
+   * @param {object} e
+   * @param {string} name
    */
-  function getBranches( element, elementName ) {
-    const branches = {};
-    const subbranchNames = [];
-    const subbranchElements = [];
-    walkElements(element, elementName);
-    /**
-     * Walk the element chain
-     *
-     * @param {object} e
-     * @param {string} name
-     */
-    function walkElements( e, name ) {
-      if (isBuiltinType(e.type)) {
-        branches[subbranchNames.concat(name).join(pathDelimiter)] = subbranchElements.concat(e);
+  function walkElements( e, name ) {
+    if (isBuiltinType(e.type)) {
+      branches[subbranchNames.concat(name).join(pathDelimiter)] = { steps: subbranchElements.concat(e), ref: subbranchNames.concat(name) };
+    }
+    else {
+      const subelements = e.elements || effectiveType(e).elements;
+      if (subelements) {
+        subbranchElements.push(e);
+        subbranchNames.push(name);
+        for (const [ subelementName, subelement ] of Object.entries(subelements))
+          walkElements(subelement, subelementName);
+
+        subbranchNames.pop();
+        subbranchElements.pop();
       }
       else {
-        const eType = effectiveType(e);
-        const subelements = e.elements || eType.elements;
-        if (subelements) {
-          subbranchElements.push(e);
-          subbranchNames.push(name);
-          for (const [ subelementName, subelement ] of Object.entries(subelements))
-            walkElements(subelement, subelementName);
-
-          subbranchNames.pop();
-          subbranchElements.pop();
-        }
-        else {
-          branches[subbranchNames.concat(name).join(pathDelimiter)] = subbranchElements.concat(e);
-        }
+        branches[subbranchNames.concat(name).join(pathDelimiter)] = { steps: subbranchElements.concat(e), ref: subbranchNames.concat(name) };
       }
     }
-    return branches;
   }
+  return branches;
 }
 
 /**
@@ -792,4 +792,5 @@ module.exports = {
   flattenElements,
   removeLeadingSelf,
   handleManagedAssociationsAndCreateForeignKeys,
+  getBranches,
 };