@sap/cds-compiler 5.6.0 → 5.7.2

package/lib/render/toCdl.js

@@ -604,12 +604,12 @@ function csnToCdl( csn, options, msg ) {
     result += element.key ? 'key ' : '';
     result += element.masked ? 'masked ' : '';
     result += quoteNonIdentifierOrKeyword(elementName, env);
-    if (element.val !== undefined) { // enum value
-      result += ` = ${exprRenderer.renderExpr(element, env)}`;
-    }
-    else if (element['#'] !== undefined) { // enum symbol reference
+    if (element['#'] !== undefined) { // enum symbol reference
       result += ` = #${element['#']}`;
     }
+    else if (element.val !== undefined) { // enum value
+      result += ` = ${exprRenderer.renderExpr(element, env)}`;
+    }
     else if (!isCalcElement || !isDirectAssocOrComp(element.type) && !element.$filtered && !element.$enclosed) {
       // If the element is a calculated element _and_ a direct association or
       // composition, we'd render `Association to F on (cond) = calcValue;` which
@@ -1366,7 +1366,8 @@ function csnToCdl( csn, options, msg ) {
       // If a name exists (either in target or targetAspect), prefer it over rendering elements.
       const elements = artifact.target?.elements || artifact.targetAspect?.elements;
       if (typeof artifact.target === 'string' || typeof artifact.targetAspect === 'string') {
-        result += renderAbsolutePath({ ref: [ artifact.target || artifact.targetAspect ] }, env);
+        result += renderAbsolutePath({ ref: [ artifact.target || artifact.targetAspect ] },
+                                     { ...env, additionalKeywords: [ 'MANY', 'ONE' ] });
       }
       else if (elements) {
         // anonymous aspect, either parseCdl or client CSN.

package/lib/render/toHdbcds.js

@@ -1266,7 +1266,7 @@ function toHdbcdsSource( csn, options, messageFunctions ) {
     // 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, this.env.path, { id: uppercaseAndUnderscore(funcName) }, 'The identifier $(ID) is a SAP HANA keyword');
-    return renderFunc(funcName, x, 'hana', a => renderArgs(a, '=>', this.env));
+    return renderFunc(funcName, x, a => renderArgs(a, '=>', this.env), { options });
   }
 
 

package/lib/render/toSql.js

@@ -122,8 +122,10 @@ function toSqlDdl( csn, options, messageFunctions ) {
       return `CAST(${this.renderExpr(withoutCast(x))} AS ${typeRef})`;
     },
     val: renderExpressionLiteral,
-    enum() {
-      // FIXME: We can't do enums yet because they are not resolved (and we don't bother finding their value by hand)
+    enum(x) {
+      // visitExpr first checks for `#`, then `val`:
+      if (x.val !== undefined)
+        return renderExpressionLiteral(x);
       error('expr-unexpected-enum', this.env.path, 'Enum values are not yet supported for conversion to SQL');
       return '';
     },
@@ -135,7 +137,7 @@ function toSqlDdl( csn, options, messageFunctions ) {
       return renderWindowFunction(smartFuncId(prepareIdentifier(x.func), options.sqlDialect), x, this.env);
     },
     func(x) {
-      return renderFunc(smartFuncId(prepareIdentifier(x.func), options.sqlDialect), x, options.sqlDialect, a => renderArgs(a, '=>', this.env, null));
+      return renderFunc(smartFuncId(prepareIdentifier(x.func), options.sqlDialect), x, a => renderArgs(a, '=>', this.env, null), { messageFunctions, options, path: this.env.path });
     },
     xpr(x) {
       const env = this.env.withSubPath([ 'xpr' ]);

package/lib/render/utils/common.js

@@ -3,6 +3,7 @@
 'use strict';
 
 const { ModelError } = require('../../base/error');
+const { standardDatabaseFunctions } = require('./standardDatabaseFunctions');
 
 const functionsWithoutParams = {
   hana: {
@@ -27,13 +28,25 @@ const { implicitAs } = require('../../model/csnRefs');
  *
  * @param {string} funcName Name of the function
  * @param {object} node Content of the function
- * @param {string} dialect One of 'hana', 'cap' or 'sqlite' - only 'hana' is relevant atm
  * @param {(a: string) => string} renderArgs Function to render function arguments
+ * @param {object} utils Utility object containing options, path, and message functions
  * @returns {string} Function string
  */
-function renderFunc( funcName, node, dialect, renderArgs ) {
-  if (funcWithoutParen( node, dialect ))
+function renderFunc( funcName, node, renderArgs, utils ) {
+  const { options, path, messageFunctions } = utils || {};
+  const { sqlDialect } = options;
+  if (funcWithoutParen( node, sqlDialect ))
     return funcName;
+  const rewriteStandardFunctions = options.transformation !== 'hdbcds' && sqlDialect !== 'plain' && options.standardDatabaseFunctions;
+  if (rewriteStandardFunctions) {
+    // we check function arguments for correctness
+    const { error } = messageFunctions;
+    const that = { renderArgs, error, path };
+    if (standardDatabaseFunctions[sqlDialect]?.[funcName])
+      return standardDatabaseFunctions[sqlDialect][funcName].call(that, node);
+    else if (standardDatabaseFunctions.common[funcName])
+      return standardDatabaseFunctions.common[funcName].call(that, node);
+  }
   return `${funcName}(${renderArgs( node )})`;
 }
 
@@ -682,13 +695,13 @@ function visitExpr( x ) {
       return result;
     }).join(', ')})`;
   }
-  else if (x.val !== undefined) {
-    return this.val(x);
-  }
   else if (x['#']) {
     // Enum symbol
     return this.enum(x);
   }
+  else if (x.val !== undefined) {
+    return this.val(x);
+  }
   else if (x.ref) {
     // Reference: Array of path steps, possibly preceded by ':'
     return this.ref(x);

package/lib/render/utils/delta.js

@@ -74,9 +74,7 @@ class DeltaRenderer {
   alterColumns(artifactName, columnName, delta, definitionsStr, _eltName, _env) {
     if (Array.isArray(definitionsStr)) {
       const prefix = `ALTER TABLE ${this.scopedFunctions.renderArtifactName(artifactName)} ALTER (`;
-      let padding = '';
-      for (let i = 0; i < prefix.length; i++)
-        padding += ' ';
+      const padding = ' '.repeat(prefix.length);
       const body = definitionsStr.map(s => padding + s).join(',\n').slice(padding.length); // no padding for first part
       const postfix = ');';
       return [ prefix + body + postfix ];