@sap/cds-compiler 2.11.0 → 2.11.2

package/CHANGELOG.md

@@ -7,6 +7,14 @@
 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 2.11.2 - 2021-12-06
+
+### Fixed
+
+- to.sql/hdi/hdbcds:
+  + No foreign key constraint will be rendered for managed `composition of one` if annotated with `@assert.integrity: false`
+  + Correctly handle managed associations with other managed associations as foreign keys in conjunction with `exists`
+
 ## Version 2.11.0 - 2021-12-02
 
 ### Added

package/lib/transform/db/constraints.js

@@ -294,13 +294,8 @@ function createReferentialConstraints(csn, options) {
       // for "auto-generated" associations like for the up_ of a composition of aspects,
       // the annotation on the composition influences the referential constraint for the
       // up_ association
-      if (element.$selfOnCondition && element.targetAspect) {
+      if (element.$selfOnCondition && element.targetAspect)
         assignPropOnBacklinkIfPossible(SKIP_FOR_UP, true);
-        return true;
-      }
-
-      if (element.type === 'cds.Composition')
-        return false;
 
       return true;
     }

package/lib/transform/forHanaNew.js

@@ -137,6 +137,9 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
     error, warning, info, inspectRef, effectiveType, artifactRef, csnUtils: getUtils(csn), csn, options, getFinalBaseType, isAspect
   });
 
+  // Needs to happen before tuple expansion, so the newly generated WHERE-conditions have it applied
+  handleExists(csn, options, error);
+
   // Check if structured elements and managed associations are compared in an expression
   // and expand these structured elements. This tuple expansion allows all other
   // subsequent procession steps (especially a2j) to see plain paths in expressions.
@@ -149,7 +152,6 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
   // FIXME: This does something very similar to cloneWithTransformations -> refactor?
   const transformCsn = transformUtils.transformModel;
 
-  handleExists(csn, options, error);
 
   // (001) Add a temporal where condition to views where applicable before assoc2join
   //       assoc2join eventually rewrites the table aliases

package/lib/transform/transformUtilsNew.js

@@ -1094,16 +1094,16 @@ function getTransformers(model, options, pathDelimiter = '_') {
   function expandStructsInExpression(csn, options = {}) {
     applyTransformations(csn, {
       'on': (parent, name, on, path) => {
-        parent.on = expand(parent.on, path);
+        parent.on = expand(parent.on, path.concat(name));
       },
       'having': (parent, name, having, path) => {
-        parent.having = expand(parent.having, path);
+        parent.having = expand(parent.having, path.concat(name));
       },
       'where': (parent, name, where, path) => {
-        parent.where = expand(parent.where, path);
+        parent.where = expand(parent.where, path.concat(name));
       },
       'xpr': (parent, name, xpr, path) => {
-        parent.xpr = expand(parent.xpr, path);
+        parent.xpr = expand(parent.xpr, path.concat(name));
       }
     }, undefined, undefined, options);
 
@@ -1121,17 +1121,21 @@ function getTransformers(model, options, pathDelimiter = '_') {
         if(i < expr.length-2)
         {
           const [lhs, op, rhs] = expr.slice(i);
+
+          // we might have to ad-hoc resolve a ref, since handleExists is run before hand and generates new refs.
+          const lhsArt = lhs._art || lhs.ref && !lhs.$scope && inspectRef(location.concat(i)).art;
+          const rhsArt = rhs._art || rhs.ref && !rhs.$scope && inspectRef(location.concat(i+2)).art;
           // lhs & rhs must be expandable types (structures or managed associations)
-          if(lhs._art && rhs._art &&
+          if(lhsArt && rhsArt &&
              lhs.ref && rhs.ref &&
-             isExpandable(lhs._art) && isExpandable(rhs._art) &&
+             isExpandable(lhsArt) && isExpandable(rhsArt) &&
              ['=', '<', '>', '>=', '<=', '!=', '<>'].includes(op) &&
              !(isDollarSelfOrProjectionOperand(lhs) || isDollarSelfOrProjectionOperand(rhs))) {
 
             // if path is scalar and no assoc or has no type (@Core.Computed) use original expression
             // only do the expansion on (managed) assocs and (items.)elements, array of check in ON cond is done elsewhere
-            const lhspaths = /*isScalarOrNoType(lhs._art) ? [ lhs ] : */ flattenPath({ _art: lhs._art, ref: lhs.ref }, false, true );
-            const rhspaths = /*isScalarOrNoType(rhs._art) ? [ rhs ] : */ flattenPath({ _art: rhs._art, ref: rhs.ref }, false, true );
+            const lhspaths = /*isScalarOrNoType(lhs._art) ? [ lhs ] : */ flattenPath({ _art: lhsArt, ref: lhs.ref }, false, true );
+            const rhspaths = /*isScalarOrNoType(rhs._art) ? [ rhs ] : */ flattenPath({ _art: rhsArt, ref: rhs.ref }, false, true );
 
             // mapping dict for lhs/rhs for mismatch check
             // strip lhs/rhs prefix from flattened paths to check remaining common trailing path

package/package.json

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