@sap/cds-compiler 4.2.2 → 4.3.0

package/lib/transform/db/backlinks.js

@@ -0,0 +1,293 @@
+'use strict';
+
+const {
+  cloneCsnNonDict, applyTransformationsOnNonDictionary, isAssociationOperand, isDollarSelfOrProjectionOperand,
+} = require('../../model/csnUtils');
+
+const { setProp } = require('../../base/model');
+const { ModelError } = require('../../base/error');
+const { forEach } = require('../../utils/objectUtils');
+
+/**
+ * Get a function that transforms $self backlinks
+ * @param {object} csnUtils
+ * @param {object} messageFunctions
+ * @param {CSN.Options} options
+ * @param {string} pathDelimiter
+ * @param {boolean} doA2J
+ * @returns {import('../../model/csnUtils').genericCallback} callback for forEachDefinition
+ */
+function getBacklinkTransformer( csnUtils, messageFunctions, options, pathDelimiter, doA2J = true ) {
+  return transformSelfInBacklinks;
+  /**
+   * @param {CSN.Artifact} artifact
+   * @param {string} artifactName
+   * @param {any} dummy unused Parameter
+   * @param {CSN.Path} path
+   */
+  function transformSelfInBacklinks( artifact, artifactName, dummy, path ) {
+    // Fixme: For toHana mixins must be transformed, for toSql -d hana
+    // mixin elements must be transformed, why can't toSql also use mixins?
+    if (artifact.kind === 'entity' || artifact.query || (options.forHana && options.sqlMapping === 'hdbcds' && artifact.kind === 'type'))
+      processDict(artifact.elements, path.concat([ 'elements' ]));
+    if (artifact.query?.SELECT?.mixin)
+      processDict(artifact.query.SELECT.mixin, path.concat([ 'query', 'SELECT', 'mixin' ]));
+
+    /**
+     * Loop over the dict and start the processing.
+     *
+     * @param {object} dict .elements or .mixin
+     * @param {Array} subPath Path into the dict
+     */
+    function processDict( dict, subPath ) {
+      forEach(dict, (elemName, elem) => {
+        if (elem.on && csnUtils.isAssocOrComposition(elem))
+          processBacklinkAssoc(elem, elemName, artifact, artifactName, subPath.concat([ elemName, 'on' ]));
+      });
+    }
+  }
+
+
+  /**
+   * If the association element 'elem' of 'art' is a backlink association, massage its ON-condition
+   * (in place) so that it
+   * - compares the generated foreign key fields of the corresponding forward
+   *   association with their respective keys in 'art' (for managed forward associations)
+   * - contains the corresponding forward association's ON-condition in "reversed" form,
+   *   i.e. as seen from 'elem' (for unmanaged associations)
+   * Otherwise, do nothing.
+   * @param {CSN.Element} elem
+   * @param {string} elemName
+   * @param {CSN.Artifact} art
+   * @param {string} artName
+   * @param {CSN.Path} pathToOn
+   */
+  function processBacklinkAssoc( elem, elemName, art, artName, pathToOn ) {
+    // Don't add braces if it is a single expression (ignoring superfluous braces)
+    const multipleExprs = elem.on.filter(x => x !== '(' && x !== ')' ).length > 3;
+    elem.on = processExpressionArgs(elem.on, pathToOn);
+
+    /**
+     * Process the args
+     *
+     * @param {Array} xprArgs
+     * @param {CSN.Path} path
+     * @returns {Array} Array of parsed expression
+     */
+    function processExpressionArgs( xprArgs, path ) {
+      const result = [];
+      let i = 0;
+      while (i < xprArgs.length) {
+      // Only token tripel `<path>, '=', <path>` are of interest here
+        if (i < xprArgs.length - 2 && xprArgs[i + 1] === '=') {
+        // Check if one side is $self and the other an association
+        // (if so, replace all three tokens with the condition generated from the other side, in parentheses)
+          if (isDollarSelfOrProjectionOperand(xprArgs[i]) && isAssociationOperand(xprArgs[i + 2], path.concat([ i + 2 ]), csnUtils.inspectRef)) {
+            const assoc = csnUtils.inspectRef(path.concat([ i + 2 ])).art;
+            if (multipleExprs)
+              result.push('(');
+            const backlinkName = xprArgs[i + 2].ref[xprArgs[i + 2].ref.length - 1];
+            result.push(...transformDollarSelfComparison(xprArgs[i + 2],
+                                                         assoc,
+                                                         backlinkName,
+                                                         elem, elemName, art, artName, path.concat([ i ])));
+            if (multipleExprs)
+              result.push(')');
+            i += 3;
+            attachBacklinkInformation(backlinkName);
+          }
+          else if (isDollarSelfOrProjectionOperand(xprArgs[i + 2]) && isAssociationOperand(xprArgs[i], path.concat([ i ]), csnUtils.inspectRef)) {
+            const assoc = csnUtils.inspectRef(path.concat([ i ])).art;
+            if (multipleExprs)
+              result.push('(');
+            const backlinkName = xprArgs[i].ref[xprArgs[i].ref.length - 1];
+            result.push(...transformDollarSelfComparison(xprArgs[i], assoc, backlinkName, elem, elemName, art, artName, path.concat([ i + 2 ])));
+            if (multipleExprs)
+              result.push(')');
+            i += 3;
+            attachBacklinkInformation(backlinkName);
+          }
+          // Otherwise take one (!) token unchanged
+          else {
+            result.push(xprArgs[i]);
+            i++;
+          }
+        }
+        // Process subexpressions - but keep them as subexpressions
+        else if (xprArgs[i].xpr) {
+          result.push({ xpr: processExpressionArgs(xprArgs[i].xpr, path.concat([ i, 'xpr' ])) });
+          i++;
+        }
+        // Take all other tokens unchanged
+        else {
+          result.push(xprArgs[i]);
+          i++;
+        }
+      }
+      return result;
+
+      /**
+       * The knowledge whether an association was an `<up_>` association in a
+       * `$self = <comp>.<up_>` comparison, is important for the foreign key constraints.
+       * By the time we generate them, such on-conditions are already transformed
+       * --> no more `$self` in the on-conditions, that is why we need to remember it here.
+       *
+       * @param {string} backlinkName name of `<up_>` in a `$self = <comp>.<up_>` comparison
+       */
+      function attachBacklinkInformation( backlinkName ) {
+        if (elem.$selfOnCondition) {
+          elem.$selfOnCondition.up_.push(backlinkName);
+        }
+        else {
+          setProp(elem, '$selfOnCondition', {
+            up_: [ backlinkName ],
+          });
+        }
+      }
+    }
+  }
+
+  /**
+   * Return the condition to replace the comparison `<assocOp> = $self` in the ON-condition
+   * of element <elem> of artifact 'art'. If there is anything to complain, use location <loc>
+   *
+   * @param {any} assocOp
+   * @param {CSN.Element} assoc
+   * @param {string} assocName
+   * @param {CSN.Element} elem
+   * @param {string} elemName
+   * @param {CSN.Artifact} art
+   * @param {string} artifactName
+   * @param {CSN.Path} path
+   * @returns {Array} New on-condition
+   */
+  function transformDollarSelfComparison( assocOp, assoc, assocName, elem, elemName, art, artifactName, path ) {
+    // Check: The forward link <assocOp> must point back to this artifact
+    // FIXME: Unfortunately, we can currently only check this for non-views (because when a view selects
+    // a backlink association element from an entity, the forward link will point to the entity,
+    // not to the view).
+    // FIXME: This also means that corresponding key fields should be in the select list etc ...
+    if (!art.query && !art.projection && assoc.target && assoc.target !== artifactName) {
+      messageFunctions.error( null, path, { id: '$self', name: artifactName, target: assoc.target },
+                              'Expected association using $(ID) to point back to $(NAME) but found $(TARGET)' );
+    }
+
+    // Check: The forward link <assocOp> must not contain '$self' in its own ON-condition
+    if (assoc.on) {
+      const containsDollarSelf = assoc.on.some(isDollarSelfOrProjectionOperand);
+
+      if (containsDollarSelf) {
+        messageFunctions.error(null, path, { name: '$self' },
+                               'An association that uses $(NAME) in its ON-condition can\'t be compared to $(NAME)');
+      }
+    }
+
+    // Transform comparison of $self to managed association into AND-combined foreign key comparisons
+    if (assoc.keys) {
+      if (assoc.keys.length)
+        return transformDollarSelfComparisonWithManagedAssoc(assocOp, assoc, assocName, elemName);
+
+      elem.$ignore = true;
+      return [];
+    }
+
+    // Transform comparison of $self to unmanaged association into "reversed" ON-condition
+    else if (assoc.on) {
+      return transformDollarSelfComparisonWithUnmanagedAssoc(assocOp, assoc, assocName, elemName);
+    }
+
+    throw new ModelError(`Expected either managed or unmanaged association in $self-comparison: ${JSON.stringify(elem.on)}`);
+  }
+
+
+  /**
+   * For a condition `<elemName>.<assoc> = $self` in the ON-condition of element <elemName>,
+   * where <assoc> is a managed association, return a condition comparing the generated
+   * foreign key elements <elemName>.<assoc>_<fkey1..n> of <assoc> to the corresponding
+   * keys in this artifact.
+   * For example, `ON elem.ass = $self` becomes `ON elem.ass_key1 = key1 AND elem.ass_key2 = key2`
+   * (assuming that `ass` has the foreign keys `key1` and `key2`)
+   * @param {any} assocOp
+   * @param {CSN.Element} assoc
+   * @param {string} originalAssocName
+   * @param {string} elemName
+   * @returns {Array} New on-condition
+   */
+  function transformDollarSelfComparisonWithManagedAssoc( assocOp, assoc, originalAssocName, elemName ) {
+    const conditions = [];
+    // if the element was structured then it was flattened => change of the delimiter from '.' to '_'
+    // this is done in the flattening, but as we do not alter the onCond itself there should be done here as well
+    const assocName = originalAssocName.replace(/\./g, pathDelimiter);
+    elemName = elemName.replace(/\./g, pathDelimiter);
+
+    assoc.keys.forEach((k) => {
+      // Depending on naming conventions, the foreign key may two path steps (hdbcds) or be a single path step with a flattened name (plain, quoted)
+      // With to.hdbcds in conjunction with hdbcds naming, we need to NOT use the alias - else we get deployment errors
+      const keyName = k.as && doA2J ? [ k.as ] : k.ref;
+      const fKeyPath = !doA2J ? [ assocName, ...keyName ] : [ `${assocName}${pathDelimiter}${keyName[0]}` ];
+      // FIXME: _artifact to the args ???
+      const a = [
+        {
+          ref: [ elemName, ...fKeyPath ],
+        },
+        { ref: k.ref },
+      ];
+
+      conditions.push([ a[0], '=', a[1] ]);
+    });
+
+    return conditions.reduce((prev, current) => {
+      if (prev.length === 0)
+        return [ ...current ];
+
+      return [ ...prev, 'and', ...current ];
+    }, []);
+  }
+
+  /**
+   * For a condition `<elemName>.<assoc> = $self` in the ON-condition of element <elemName>,
+   * where <assoc> is an unmanaged association, return the ON-condition of <assoc> as it would
+   * be written from the perspective of the artifact containing association <elemName>.
+   * For example, `ON elem.ass = $self` becomes `ON a = elem.x AND b = elem.y`
+   * (assuming that `ass` has the ON-condition `ON ass.a = x AND ass.b = y`)
+   *
+   * @param {any} assocOp
+   * @param {CSN.Element} assoc
+   * @param {string} originalAssocName
+   * @param {string} elemName
+   * @returns {Array} New on-condition
+   */
+  function transformDollarSelfComparisonWithUnmanagedAssoc( assocOp, assoc, originalAssocName, elemName ) {
+    // if the element was structured then it may have been flattened => change of the delimiter from '.' to '_'
+    // this is done in the flattening, but as we do not alter the onCond itself there should be done here as well
+    elemName = elemName.replace(/\./g, pathDelimiter);
+    const assocName = originalAssocName.replace(/\./g, pathDelimiter);
+    // clone the onCond for later use in the path transformation
+    const newOnCond = cloneCsnNonDict(assoc.on, options);
+    applyTransformationsOnNonDictionary({ on: newOnCond }, 'on', {
+      ref: (parent, prop, ref) => {
+        // we are in the "path" from the forwarding assoc => need to remove the first part of the path
+        if (ref[0] === assocName) {
+          ref.shift();
+        }
+        else if (ref.length > 1 && ref[0] === '$self' && ref[1] === assocName) {
+          // We could also have a $self in front of the assoc name - so we would need to shift twice
+          ref.shift();
+          ref.shift();
+        }
+        else { // we are in the backlink assoc "path" => need to push at the beginning the association's id
+          ref.unshift(elemName);
+          // if there was a $self identifier in the forwarding association onCond
+          // we do not need it anymore, as we prepended in the previous step the back association's id
+          if (ref[1] === '$self')
+            ref.splice(1, 1);
+        }
+      },
+    });
+    return newOnCond;
+  }
+}
+
+module.exports = {
+  getBacklinkTransformer,
+};

package/lib/transform/db/expansion.js

@@ -7,7 +7,7 @@ const {
   walkCsnPath,
   getUtils,
 } = require('../../model/csnUtils');
-const { implicitAs, columnAlias } = require('../../model/csnRefs');
+const { implicitAs, columnAlias, pathId } = require('../../model/csnRefs');
 const { setProp } = require('../../base/model');
 const { forEach } = require('../../utils/objectUtils');
 
@@ -39,9 +39,12 @@ function expandStructureReferences( csn, options, pathDelimiter, messageFunction
         // TODO: replace with the correct options.transformation?
         // Do not expand the * in OData for a moment, not to introduce changes
         // while the OData CSN is still official
+        const isComplexQuery = parent.from.join !== undefined;
         if (!options.toOdata)
-          parent.columns = replaceStar(root, columns, parent.excluding, parent.from.join !== undefined);
-        parent.columns = expand(parent.columns, path.concat('columns'), true);
+          parent.columns = replaceStar(root, columns, parent.excluding, isComplexQuery);
+        // FIXME(v5): Remove argument "isComplexOrNestedQuery"; we use path.length > 4 to check
+        // if we're inside the outermost "columns". If so, always prepend a table alias. See #11662
+        parent.columns = expand(parent.columns, path.concat('columns'), true, isComplexQuery || path.length > 4);
       }
     },
     groupBy: (parent, name, groupBy, path) => {
@@ -512,16 +515,17 @@ function expandStructureReferences( csn, options, pathDelimiter, messageFunction
    * @param {Array} thing
    * @param {CSN.Path} path
    * @param {boolean} [withAlias=false] Whether to "expand" the (implicit) alias as well.
+   * @param {boolean} [isComplexOrNestedQuery]
    * @returns {Array} New array - with all structured things expanded
    */
-  function expand( thing, path, withAlias = false ) {
+  function expand( thing, path, withAlias = false, isComplexOrNestedQuery = false ) {
     const newThing = [];
     for (let i = 0; i < thing.length; i++) {
       const col = thing[i];
       if (col.ref && col.$scope !== '$magic') {
         const _art = col._art || csnUtils.inspectRef(path.concat(i)).art;
         if (_art && csnUtils.isStructured(_art))
-          newThing.push(...expandRef(_art, col, withAlias));
+          newThing.push(...expandRef(_art, col, withAlias, isComplexOrNestedQuery));
         else
           newThing.push(col);
       }
@@ -596,9 +600,10 @@ function expandStructureReferences( csn, options, pathDelimiter, messageFunction
    * @param {CSN.Element} art
    * @param {object} root Column, ref in order by, etc.
    * @param {boolean} withAlias Whether to add an explicit flattened alias to the expanded columns/references.
+   * @param {boolean} [isComplexOrNestedQuery]
    * @returns {Array}
    */
-  function expandRef( art, root, withAlias ) {
+  function expandRef( art, root, withAlias, isComplexOrNestedQuery ) {
     return _expandStructCol(art, columnAlias(root), root.ref, ( currentRef, currentAlias) => {
       const obj = { ...root, ref: currentRef };
       if (withAlias) {
@@ -613,7 +618,13 @@ function expandStructureReferences( csn, options, pathDelimiter, messageFunction
           setProp(obj, '$implicitAlias', true);
       }
 
-      if (typeof root.$env === 'string')
+      // The Java runtime, as of 2023-09-13, assumes that for _simple projections_, all references
+      // are relative to the query source.  To avoid breaking that assumption unless necessary,
+      // we only add the table alias if:
+      //  - it is a complex query with possibly multiple available table aliases, or
+      //  - the transformation is not for OData (which is used by Java), or
+      //  - the first path step has the same name as the table alias (only one, as otherwise the query would be complex)
+      if (typeof root.$env === 'string' && (isComplexOrNestedQuery || options.transformation !== 'odata' || root.$env === pathId(obj.ref[0])))
         obj.ref = [ root.$env, ...obj.ref ];
 
       return obj;

package/lib/transform/db/flattening.js

@@ -840,8 +840,9 @@ function createForeignKeys( csnUtils, path, element, prefix, csn, options, pathD
     fk[0] = `${prefix}${pathDelimiter}${fk[0]}`;
     // if this is the entry association, decorate the final foreign keys with the association props
     if (lvl === 0) {
-      fk[1]['@odata.foreignKey4'] = prefix;
-      if (!options.forHana)
+      if (options.transformation !== 'effective')
+        fk[1]['@odata.foreignKey4'] = prefix;
+      if (options.transformation === 'odata' || options.transformation === 'effective')
         copyAnnotations(element, fk[1], true);
 
       // propagate not null to final foreign key

package/lib/transform/db/rewriteCalculatedElements.js

@@ -8,11 +8,9 @@ const {
   applyTransformationsOnDictionary,
   implicitAs,
   cloneCsnNonDict,
-  forEachMemberRecursively,
 } = require('../../model/csnUtils');
 const { getBranches } = require('./flattening');
 const { getColumnMap } = require('./views');
-const { requireForeignKeyAccess } = require('../../checks/onConditions');
 
 const cloneCsnOptions = { hiddenPropertiesToClone: [ '_art', '_links', '$env', '$scope' ] };
 
@@ -96,73 +94,9 @@ function rewriteCalculatedElementsInViews( csn, options, csnUtils, pathDelimiter
     }, {}, [ 'definitions' ]);
   });
 
-  /**
-   * Check that all paths in calculated elements-on write either access normal fields
-   * (structures are already rejected by the compiler) or access the foreign keys of
-   * associations. Non-fk fields must be rejected.
-   * Filters and parameters are not allowed.
-   *
-   * Note: This coding is similar to checks/onConditions.js, but does not check $self or other
-   *       ON-condition related stuff.
-   *
-   * @param {object} parent
-   * @param {(string|object)[]} value
-   * @param {CSN.Path} csnPath
-   */
-  function checkPathsInStoredCalcElement( parent, value, csnPath ) {
-    const { _links } = parent;
-
-    // If there is only one path step, it's been checked before.
-    for (let i = 0; i < value.length - 1; ++i) {
-      let hasPathError = false;
-      const step = value[i];
-      const stepArt = _links[i].art;
-
-      if (stepArt.target) {
-        const id = step.id || step;
-        if (stepArt.on) {
-          // It's an unmanaged association - traversal is always forbidden
-          error('ref-unexpected-navigation', csnPath, { '#': 'calc-unmanaged', id, elemref: parent });
-          hasPathError = true;
-        }
-        else {
-          // It's a managed association - access of the foreign keys is allowed
-          requireForeignKeyAccess(parent, i, (errorIndex) => {
-            error('ref-unexpected-navigation', csnPath, {
-              '#': 'calc-non-fk', id, elemref: parent, name: value[errorIndex].id || value[errorIndex],
-            });
-            hasPathError = true;
-          });
-        }
-      }
-      if (typeof step === 'object') {
-        if (step.where) {
-          error('ref-unexpected-filter', csnPath, { '#': 'calc', elemref: parent });
-          hasPathError = true;
-        }
-        if (step.args) {
-          error('ref-unexpected-args', csnPath, { '#': 'calc', elemref: parent });
-          hasPathError = true;
-        }
-      }
-      if (hasPathError)
-        break; // avoid too many consequent errors
-    }
-  }
-
   // Last pass, turn .value in tables into a simple 'val' so we don't need to rewrite/flatten properly - will kill them later
   entities.forEach(({ artifact, artifactName }) => {
     dummifyInEntity(artifact, [ 'definitions', artifactName ]);
-
-    forEachMemberRecursively({ elements: artifact.elements }, (element, elementName, _prop, path) => {
-      if (element.value?.stored) {
-        applyTransformationsOnNonDictionary(element, 'value', {
-          ref(parent, prop, value, csnPath) {
-            checkPathsInStoredCalcElement(parent, value, csnPath);
-          },
-        }, {}, path);
-      }
-    }, [ 'definitions', artifactName ]);
   });
 
   /**
@@ -329,7 +263,7 @@ function rewriteCalculatedElementsInViews( csn, options, csnUtils, pathDelimiter
               linksBase: current.linksBase,
             });
           },
-        });
+        }, { skipStandard: { where: true } });
       }
       else if (current.value.ref && current.value._art?.value && !current.value._art?.value.stored) {
         const linksBase = current.value._links;

package/lib/transform/db/transformExists.js

@@ -66,6 +66,9 @@ function handleExists( csn, options, error, inspectRef, initDefinition, dropDefi
           if (query.SELECT?.where?.length > 1)
             toProcess.push([ path.slice(0, -1), path.concat('where') ]);
 
+          if (query.SELECT?.having?.length > 1)
+            toProcess.push([ path.slice(0, -1), path.concat('having') ]);
+
           if (query.SELECT?.columns)
             toProcess.push([ path.slice(0, -1), path.concat('columns') ]);
 
@@ -73,7 +76,6 @@ function handleExists( csn, options, error, inspectRef, initDefinition, dropDefi
             toProcess.push([ path.slice(0, -1), path.concat([ 'from', 'on' ]) ]);
 
           for (const [ , exprPath ] of toProcess) {
-            forbidAssocInExists(exprPath);
             const expr = nestExists(exprPath);
             walkCsnPath(csn, exprPath.slice(0, -1))[exprPath[exprPath.length - 1]] = expr;
           }
@@ -254,63 +256,6 @@ function handleExists( csn, options, error, inspectRef, initDefinition, dropDefi
     return startAssoc;
   }
 
-  /**
-   * Check that associations in filters (in an exists expression) are only fk-accesses. Everything else is forbidden.
-   *
-   * @param {CSN.Path} exprPath
-   * @returns {void}
-   */
-  function forbidAssocInExists( exprPath ) {
-    const expr = walkCsnPath(csn, exprPath);
-    for (let i = 0; i < expr.length; i++) {
-      if (i < expr.length - 1 && expr[i] === 'exists' && expr[i + 1].ref) {
-        i++;
-        const current = expr[i];
-
-        const { links } = inspectRef(exprPath.concat(i));
-
-        const assocs = links.filter(link => link.art?.target).map(link => current.ref[link.idx]);
-
-        checkForInvalidAssoc(assocs);
-      }
-    }
-  }
-
-  /**
-   * @param {object[]} assocs Array of refs of assocs - possibly with a .where to check
-   */
-  function checkForInvalidAssoc( assocs ) {
-    for (const assoc of assocs) {
-      if (assoc.where) {
-        for (let i = 0; i < assoc.where.length; i++) {
-          const part = assoc.where[i];
-
-          if (part._links && !(assoc.where[i - 1] && assoc.where[i - 1] === 'exists')) {
-            for (const link of part._links) {
-              if (link.art && link.art.target) {
-                if (link.art.keys) { // managed - allow FK access
-                  if (part._links[link.idx + 1] !== undefined) { // there is a next path step - check if it is a fk
-                    if (!(part._links[link.idx + 1] && link.art.keys.some(fk => fk._art === part._links[link.idx + 1].art)))
-                      error(null, part.$path, { id: assoc.id, name: assoc.where[part.$path[part.$path.length - 1]].ref[link.idx] }, 'Unexpected non foreign key access after managed association $(NAME) in filter expression of $(ID)');
-                  }
-                  else { // no traversal, ends on managed
-                    error(null, part.$path, { id: assoc.id, name: assoc.where[part.$path[part.$path.length - 1]].ref[link.idx] }, 'Unexpected managed association $(NAME) in filter expression of $(ID)');
-                  }
-                }
-                else { // unmanaged - always wrong
-                  error(null, part.$path, { id: assoc.id, name: assoc.where[part.$path[part.$path.length - 1]].ref[link.idx] }, 'Unexpected unmanaged association $(NAME) in filter expression of $(ID)');
-                }
-                // Recursively drill down if the assoc-step has a filter
-                if (part.ref[link.idx].where)
-                  checkForInvalidAssoc([ part.ref[link.idx] ]);
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-
   /**
    * Walk to the expr using the given path and scan it for the "exists" + "ref" pattern.
    * If such a pattern is found, nest association steps therein into filters.

package/lib/transform/db/views.js

@@ -3,7 +3,7 @@
 const {
   getUtils, cloneCsnNonDict, applyTransformationsOnNonDictionary, forEachDefinition,
 } = require('../../model/csnUtils');
-const { implicitAs, columnAlias } = require('../../model/csnRefs');
+const { implicitAs, columnAlias, pathId } = require('../../model/csnRefs');
 const { ModelError } = require('../../base/error');
 const { setProp } = require('../../base/model');
 
@@ -16,20 +16,18 @@ const { setProp } = require('../../base/model');
  * @returns {object} The mixin association
  */
 function getMixinAssocOfQueryIfPublished( query, association, associationName ) {
-  if (query && query.SELECT && query.SELECT.mixin) {
+  if (query?.SELECT?.mixin) {
     const aliasedColumnsMap = Object.create(null);
-    if (query.SELECT.columns) {
-      for (const column of query.SELECT.columns) {
-        if (column.as && column.ref && column.ref.length === 1)
-          aliasedColumnsMap[column.as] = column;
-      }
+    for (const column of query.SELECT.columns || []) {
+      if (column.as && column.ref?.length === 1)
+        aliasedColumnsMap[column.as] = column;
     }
 
     for (const elem of Object.keys(query.SELECT.mixin)) {
       const mixinElement = query.SELECT.mixin[elem];
       let originalName = associationName;
       if (aliasedColumnsMap[associationName])
-        originalName = aliasedColumnsMap[associationName].ref[0];
+        originalName = pathId(aliasedColumnsMap[associationName].ref[0]);
 
       if (elem === originalName)
         return { mixinElement, mixinName: originalName };
@@ -210,11 +208,7 @@ function getViewTransformer( csn, options, messageFunctions, transformCommon ) {
   function handleAssociationElement( query, elements, columnMap, publishedMixins, elem, elemName, elementsPath, queryPath ) {
     if (isUnion(queryPath) && options.transformation === 'hdbcds') {
       if (doA2J) {
-        if (elem.keys)
-          info('query-ignoring-assoc-in-union', queryPath, { name: elemName, '#': 'managed' });
-        else
-          info('query-ignoring-assoc-in-union', queryPath, { name: elemName, '#': 'std' });
-
+        info('query-ignoring-assoc-in-union', queryPath, { name: elemName, '#': elem.keys ? 'managed' : 'std' });
         elem.$ignore = true;
       }
       else {
@@ -448,7 +442,7 @@ function stripLeadingSelf( col ) {
  * @returns {boolean}
  */
 function checkIsNotMixinByItself( query, columnMap, elementName ) {
-  if (query && query.SELECT && query.SELECT.mixin) {
+  if (query?.SELECT?.mixin) {
     const col = columnMap[elementName];
 
     if (!col.ref) // No ref -> new association, but not a mixin.

package/lib/transform/effective/.eslintrc.json

@@ -0,0 +1,4 @@
+{
+  "root": true,
+  "extends": ["../db/.eslintrc.json"]
+}