@sap/cds-compiler 5.3.0 → 5.3.2

package/CHANGELOG.md

@@ -7,6 +7,13 @@
 Note: `beta` fixes, changes and features are usually not listed in this ChangeLog but [here](doc/CHANGELOG_BETA.md).
 The compiler behavior concerning `beta` features can change at any time without notice.
 
+## Version 5.3.2 - 2024-10-08
+
+### Fixed
+
+- to.sql|hdi|hdbcds|effective: Handle subexpressions in conjunction with exists predicate.
+
+
 ## Version 5.3.0 - 2024-09-25
 
 ### Added

package/lib/transform/db/rewriteCalculatedElements.js

@@ -660,11 +660,12 @@ function rewriteCalculatedElementsInViews( csn, options, csnUtils, pathDelimiter
 
 /**
  * @param {CSN.Model} csn
+ * @param {CSN.Options} options
  */
-function processCalculatedElementsInEntities( csn ) {
+function processCalculatedElementsInEntities( csn, options ) {
   forEachDefinition(csn, (artifact, definitionName) => {
     if (artifact.kind === 'entity' && !(artifact.query || artifact.projection))
-      removeDummyValueInEntity(artifact, [ 'definitions', definitionName ]);
+      removeDummyValueInEntity(artifact, [ 'definitions', definitionName ], options);
   });
 }
 
@@ -674,14 +675,19 @@ function processCalculatedElementsInEntities( csn ) {
  *
  * @param {CSN.Artifact} artifact
  * @param {CSN.Path} path
+ * @param {CSN.Options} options
  * @todo calculated elements that "live" on the database?
  * @todo error when artifact is empty afterwards? Probably better as a CSN check!
  */
-function removeDummyValueInEntity( artifact, path ) {
+function removeDummyValueInEntity( artifact, path, options ) {
   applyTransformationsOnDictionary(artifact.elements, {
     value: (parent, prop, value, p, elements) => {
-      if (!value.stored)
-        delete elements[p[p.length - 1]];
+      if (!value.stored) {
+        if (options.transformation === 'effective' && parent.on)
+          delete parent.value;
+        else
+          delete elements[p.at(-1)];
+      }
     },
   }, {}, path.concat( 'elements' ));
 }

package/lib/transform/db/transformExists.js

@@ -409,6 +409,7 @@ function handleExists( csn, options, error, inspectRef, initDefinition, dropDefi
   }
 
   /**
+   *
    * Translate an `EXISTS <unmanaged assoc>` into a part of a WHERE condition.
    *
    * A valid $self-backlink is handled in translateDollarSelfToWhere.
@@ -428,53 +429,77 @@ function handleExists( csn, options, error, inspectRef, initDefinition, dropDefi
    */
   function translateUnmanagedAssocToWhere( root, target, isPrefixedWithTableAlias, base, current ) {
     const whereExtension = [];
-    for (let j = 0; j < root.on.length; j++) {
-      const part = root.on[j];
+
+    for (let j = 0; j < root.on.length; j++)
+      j = processExpressionPart(root.on, root.$path.concat('on'), j, whereExtension);
+
+    return whereExtension;
+
+    /**
+     * Process the given expression and apply the steps described above.
+     *
+     * @param {Array} expression Expression we are processing
+     * @param {CSN.Path} path Path to the expression
+     * @param {number} expressionIndex Index in the current expression, imporant for paths and stuff
+     * @param {Array} collector Array to collect the processed expressionparts into
+     * @returns {number} How far along expression we have processed - so the main loop can jump ahead
+     */
+    function processExpressionPart(expression, path, expressionIndex, collector) {
+      const part = expression[expressionIndex];
+
+      if (part?.xpr) {
+        const xpr = { xpr: [] };
+        for (let i = 0; i < part.xpr.length; i++)
+          i = processExpressionPart(part.xpr, path.concat(expressionIndex, 'xpr'), i, xpr.xpr);
+
+        collector.push(xpr);
+        return expressionIndex;
+      }
 
       // we can only resolve stuff on refs - skip literals like =
       // but also keep along stuff like null and undefined, so compiler
       // can have a chance to complain/ we can fail later nicely maybe
       if (!(part && part.ref)) {
-        whereExtension.push(part);
-        continue;
+        collector.push(part);
+        return expressionIndex;
       }
 
       // root.$path should be safe - we can only reference things in exists that exist when we enrich
       // so all of them should have a $path.
-      const { art, links } = inspectRef(root.$path.concat([ 'on', j ]));
+      const { art, links } = inspectRef(path.concat(expressionIndex));
       // Dollar Self Backlink
-      if (isValidDollarSelf(root.on[j], root.$path.concat([ 'on', j ]), root.on[j + 1], root.on[j + 2], root.$path.concat([ 'on', j + 2 ]))) {
-        if (root.on[j].ref[0] === '$self' && root.on[j].ref.length === 1)
-          whereExtension.push(...translateDollarSelfToWhere(base, target, root.on[j + 2], root.$path.concat([ 'on', j + 2 ])));
+      if (isValidDollarSelf(expression[expressionIndex], path.concat(expressionIndex), expression[expressionIndex + 1], expression[expressionIndex + 2], path.concat(expressionIndex + 2 ))) {
+        if (expression[expressionIndex].ref[0] === '$self' && expression[expressionIndex].ref.length === 1)
+          collector.push(...translateDollarSelfToWhere(base, target, expression[expressionIndex + 2], path.concat(expressionIndex + 2 )));
         else
-          whereExtension.push(...translateDollarSelfToWhere(base, target, root.on[j], root.$path.concat([ 'on', j ])));
+          collector.push(...translateDollarSelfToWhere(base, target, expression[expressionIndex], path.concat(expressionIndex)));
 
-        j += 2;
+        return expressionIndex + 2;
       }
       else if (links && links[0].art === root) { // target side
-        whereExtension.push({ ref: [ target, ...part.ref.slice(1) ] });
+        collector.push({ ref: [ target, ...part.ref.slice(1) ] });
       }
       else if (part.$scope === '$self') { // source side - "absolute" scope
         const column = part._art._column;
         if (column && column.as) { // Replace with the "original" expression (the .ref, .xpr etc.)
-          whereExtension.push(translateToSourceSide(column));
+          collector.push(translateToSourceSide(column));
         }
         else {
-          whereExtension.push(assignAndDeleteAs({}, part, { ref: [ base, ...part.ref.slice(1) ] }));
+          collector.push(assignAndDeleteAs({}, part, { ref: [ base, ...part.ref.slice(1) ] }));
         }
       }
       else if (art) { // source side - with local scope
         if (isPrefixedWithTableAlias || part.$scope === 'alias')
-          whereExtension.push({ ref: [ ...current.ref.slice(0, -1), ...part.ref ] });
+          collector.push({ ref: [ ...current.ref.slice(0, -1), ...part.ref ] });
         else
-          whereExtension.push({ ref: [ base, ...current.ref.slice(0, -1), ...part.ref ] });
+          collector.push({ ref: [ base, ...current.ref.slice(0, -1), ...part.ref ] });
       }
       else { // operator - or any other leftover
-        whereExtension.push(part);
+        collector.push(part);
       }
-    }
 
-    return whereExtension;
+      return expressionIndex;
+    }
 
 
     /**

package/lib/transform/effective/main.js

@@ -75,7 +75,7 @@ function effectiveCsn( model, options, messageFunctions ) {
   // ensure getElement works on flattened struct_assoc columns
   csnUtils = getUtils(csn, 'init-all');
 
-  processCalculatedElementsInEntities(csn);
+  processCalculatedElementsInEntities(csn, options);
   associations.managedToUnmanaged(csn, options, csnUtils, messageFunctions);
   associations.transformBacklinks(csn, options, csnUtils, messageFunctions);
   const transformers = mergeTransformers([ options.addCdsPersistenceName ? misc.attachPersistenceName(csn, options, csnUtils) : {}, options.remapOdataAnnotations ? annotations.remapODataAnnotations(csn) : {}, misc.removeDefinitionsAndProperties(csn, options) ], null);

package/lib/transform/forRelationalDB.js

@@ -248,7 +248,7 @@ function transformForRelationalDBWithCsn(csn, options, messageFunctions) {
     }
   });
 
-  processCalculatedElementsInEntities(csn);
+  processCalculatedElementsInEntities(csn, options);
 
   timetrace.start('Transform CSN')
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sap/cds-compiler",
-  "version": "5.3.0",
+  "version": "5.3.2",
   "description": "CDS (Core Data Services) compiler and backends",
   "homepage": "https://cap.cloud.sap/",
   "author": "SAP SE (https://www.sap.com)",