@sap/cds-compiler 2.5.2 → 2.11.0

package/lib/transform/db/transformExists.js

@@ -1,8 +1,9 @@
 'use strict';
 
-const { forAllQueries, forEachDefinition } = require('../../model/csnUtils');
+const { forAllQueries, forEachDefinition, walkCsnPath } = require('../../model/csnUtils');
 const { setProp } = require('../../base/model');
 const { getRealName } = require('../../render/utils/common');
+const { csnRefs } = require('../../model/csnRefs');
 
 /**
  * Turn a `exists assoc[filter = 100]` into a `exists (select 1 as dummy from assoc.target where <assoc on condition> and assoc.target.filter = 100)`.
@@ -43,23 +44,42 @@ const { getRealName } = require('../../render/utils/common');
  * The final subselect looks like (select 1 as dummy from E where F.backToE.id = E.id and filter = 100).
  *
  * @param {CSN.Model} csn
+ * @param {CSN.Options} options
  * @param {Function} error
  */
-function handleExists(csn, error) {
+function handleExists(csn, options, error) {
+  const { inspectRef } = csnRefs(csn);
+  const generatedExists = new WeakMap();
   forEachDefinition(csn, (artifact, artifactName) => {
     if (artifact.query) {
-      forAllQueries(artifact.query, (query) => {
-        if (!query.$generatedExists) {
+      forAllQueries(artifact.query, (query, path) => {
+        if (!generatedExists.has(query)) {
+          const toProcess = []; // Collect all expressions we need to process here
           if (query.SELECT && query.SELECT.where && query.SELECT.where.length > 1)
-            query.SELECT.where = processExists(query, query.SELECT.where);
+            toProcess.push([ path.slice(0, -1), path.concat('where') ]);
 
 
           if (query.SELECT && query.SELECT.columns)
-            query.SELECT.columns = processExists(query, query.SELECT.columns);
+            toProcess.push([ path.slice(0, -1), path.concat('columns') ]);
 
 
           if (query.SELECT && query.SELECT.from.on )
-            query.SELECT.from.on = processExists(query, query.SELECT.from.on);
+            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;
+          }
+
+          while (toProcess.length > 0) {
+            const [ queryPath, exprPath ] = toProcess.pop();
+            // leftovers can happen with nested exists - we then need to drill down into the created SELECT
+            // to check for further exists
+            const { result, leftovers } = processExists(queryPath, exprPath);
+            walkCsnPath(csn, exprPath.slice(0, -1))[exprPath[exprPath.length - 1]] = result;
+            toProcess.push(...leftovers.reverse()); // any leftovers - schedule for further processing
+          }
         }
       }, [ 'definitions', artifactName, 'query' ]);
     }
@@ -108,14 +128,215 @@ function handleExists(csn, error) {
   }
 
   /**
-   * Process the given expr of the given query and translate a `EXISTS assoc` into a `EXISTS (subquery)`.
+   * Get the index of the first association that is found - starting the
+   * search at the given startIndex.
    *
-   * @param {CSN.Query} query
-   * @param {TokenStream} expr
-   * @returns {TokenStream} A new token stream expression - the same as expr, but with the expanded EXISTS
+   * @param {number} startIndex Where to start searching
+   * @param {object[]} links links for a ref, produced by inspectRef
+   * @returns {number|null} Null if no association was found
+   */
+  function getFirstAssocIndex(startIndex, links) {
+    for (let i = startIndex; i < links.length; i++) {
+      if (links[i] && links[i].art && links[i].art.target)
+        return i;
+    }
+
+    return null;
+  }
+
+  /**
+   * For a given ref-array, this function is called for the first assoc-ref in the array.
+   *
+   * It then runs over the rest of the array and puts all other steps in the first assocs filter.
+   * If the rest contains another assoc, we put all following things into that assocs filter and
+   * add the sub-assoc to the previous assoc filter.
+   *
+   * Or in other words:
+   * - exists toF[1=1].toG[1=1].toH[1=1] is found
+   * - we get called with toF[1=1].toG[1=1].toH[1=1]
+   * - we return toF[1=1 and exists toG[1=1 and exists toH[1=1]]]
+   *
+   * @param {number} startIndex The index of the thing AFTER _main in the ref-array
+   * @param {string|object} startAssoc The path step that is the first assoc
+   * @param {Array} startRest Any path steps after startAssoc
+   * @param {CSN.Path} path to the overall ref where _main is contained
+   * @returns {Array} Return the now-nested ref-array
+   */
+  function nestFilters(startIndex, startAssoc, startRest, path) {
+    let revert;
+    if (!startAssoc.where) { // initialize first filter if not present
+      if (typeof startAssoc === 'string') {
+        startAssoc = {
+          id: startAssoc,
+          where: [],
+        };
+        revert = () => {
+          startAssoc = startAssoc.id;
+        };
+      }
+      else {
+        startAssoc.where = [];
+        revert = () => {
+          delete startAssoc.where;
+        };
+      }
+    }
+    const stack = [ [ null, startAssoc, startRest, startIndex ] ];
+    const { links } = inspectRef(path);
+    while (stack.length > 0) {
+      // previous: to nest "up" if the previous assoc did not originaly have a filter
+      // assoc: the assoc path step
+      // rest: path steps after assoc
+      // index: index of after-assoc in the overall ref-array - so we know where to start looking for the next assoc
+      const workPackage = stack.pop();
+      const [ previous, , rest, index ] = workPackage;
+      let [ , assoc, , ] = workPackage;
+
+      const firstAssocIndex = getFirstAssocIndex(index, links);
+
+      const head = rest.slice(0, firstAssocIndex - index);
+      const nextAssoc = rest[firstAssocIndex - index];
+      const tail = rest.slice(firstAssocIndex - index + 1);
+
+      const hasAssoc = nextAssoc !== undefined;
+
+      if (!assoc.where && hasAssoc) { // no existing filter - and there is stuff we need to nest afterwards
+        if (typeof assoc === 'string') {
+          assoc = {
+            id: assoc,
+            where: [],
+          };
+          // We need to "hook" this into the previous filter.
+          // Since we create a new object, we don't have a handy reference we can just manipulate
+          if (previous)
+            previous.where[previous.where.length - 1] = { ref: [ assoc ] };
+        }
+        else {
+          assoc.where = [];
+        }
+      }
+      else if (assoc.where && assoc.where.length > 0 && (hasAssoc || rest.length > 0)) {
+        assoc.where.push('and');
+      } // merge with existing filter
+
+      if (hasAssoc)
+        assoc.where.push('exists', { ref: [ ...head, nextAssoc ] });
+      else if (rest.length > 0)
+        assoc.where.push({ ref: rest });
+
+      if (hasAssoc)
+        stack.push([ assoc, nextAssoc, tail, firstAssocIndex ]);
+    }
+
+    // Seems like we did not have anything to nest into the filter - then kill it
+    if (startAssoc.where.length === 0 && revert !== undefined)
+      revert();
+
+    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 processExists(query, expr) {
+  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 && 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.
+   *
+   * @param {CSN.Path} exprPath
+   * @returns {Array}
+   */
+  function nestExists(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 {
+          ref, head, tail,
+        } = getFirstAssoc(current, exprPath.concat(i));
+
+        const lastAssoc = getLastAssoc(current, exprPath.concat(i));
+        // toE.toF.id -> we must not end on a non-assoc - this will also be caught downstream by
+        // '“EXISTS” can only be used with associations/compositions, found $(TYPE)'
+        // But the error might not be clear, since it could be because of our rewritten stuff. The later check
+        // checks for exists id -> our rewrite turns toE.toF.id into toE[exists toF[exists id]], leading to the same error
+        if (lastAssoc.tail.length > 0)
+          error(null, current.$path, { id: lastAssoc.tail[0].id ? lastAssoc.tail[0].id : lastAssoc.tail[0], name: lastAssoc.ref.id ? lastAssoc.ref.id : lastAssoc.ref }, 'Unexpected path step $(ID) after association $(NAME) in "EXISTS"');
+
+        const newThing = [ ...head, nestFilters(head.length + 1, ref, tail, exprPath.concat([ i ])) ];
+        expr[i].ref = newThing;
+      }
+    }
+
+    return expr;
+  }
+
+  /**
+   * Process the given expr of the given query and translate a `EXISTS assoc` into a `EXISTS (subquery)`. Also, return paths to things we need to process in a second step.
+   *
+   * @param {CSN.Path} queryPath Path to the query-object
+   * @param {CSN.Path} exprPath Path to the expression-array to process
+   * @returns {{result: TokenStream, leftovers: Array[]}} result: A new token stream expression - the same as expr, but with the expanded EXISTS, leftovers: path-tuples to further subqueries to process.
+   */
+  function processExists(queryPath, exprPath) {
+    const toContinue = [];
     const newExpr = [];
+    const query = walkCsnPath(csn, queryPath);
+    const expr = walkCsnPath(csn, exprPath);
     const queryBase = query.SELECT.from.ref ? (query.SELECT.from.as || query.SELECT.from.ref[0]) : null;
     const sources = getQuerySources(query.SELECT);
 
@@ -123,18 +344,15 @@ function handleExists(csn, error) {
       if (i < expr.length - 1 && expr[i] === 'exists' && expr[i + 1].ref) {
         i++;
         const current = expr[i];
-        const isPrefixedWithTableAlias = firstLinkIsEntityOrQuerySource(current);
-        const base = getBase(queryBase, isPrefixedWithTableAlias, current);
-        const { root, ref, tail } = getFirstAssoc(current);
+        const isPrefixedWithTableAlias = firstLinkIsEntityOrQuerySource(exprPath.concat(i));
+        const base = getBase(queryBase, isPrefixedWithTableAlias, current, exprPath.concat(i));
+        const { root, ref } = getFirstAssoc(current, exprPath.concat(i));
 
-        if (tail.length > 0) {
-          error(null, current.$path, { id: tail[0], name: ref.id ? ref.id : ref }, 'Unexpected path step $(ID) after association $(NAME) in "EXISTS"');
-          continue;
+        if (!root.target) {
+          error(null, exprPath.concat(i), { type: root.type }, '“EXISTS” can only be used with associations/compositions, found $(TYPE)');
+          return { result: [], leftovers: [] };
         }
 
-        if (!root.target)
-          return error(null, current.$path, { type: root.type }, '"EXISTS" can only be used with associations/compositions, found $(TYPE)');
-
         const subselect = getSubselect(root.target, ref, sources);
 
         const target = subselect.SELECT.from.as; // use subquery alias as target - prevent shadowing
@@ -150,18 +368,24 @@ function handleExists(csn, error) {
           subselect.SELECT.where.push(...[ 'and', ...remapExistingWhere(target, ref.where) ]);
 
         newExpr.push(subselect);
+        toContinue.push([ exprPath.concat(newExpr.length - 1), exprPath.concat([ newExpr.length - 1, 'SELECT', 'where' ]) ]);
       }
       else { // Drill down into other places that might contain a `EXISTS <assoc>`
-        if (expr[i].xpr)
-          expr[i].xpr = processExists(query, expr[i].xpr);
-        if (expr[i].args && Array.isArray(expr[i].args))
-          expr[i].args = processExists(query, expr[i].args);
-
+        if (expr[i].xpr) {
+          const { result, leftovers } = processExists(queryPath, exprPath.concat([ i, 'xpr' ]));
+          expr[i].xpr = result;
+          toContinue.push(...leftovers);
+        }
+        if (expr[i].args && Array.isArray(expr[i].args)) {
+          const { result, leftovers } = processExists(queryPath, exprPath.concat([ i, 'args' ]));
+          expr[i].args = result;
+          toContinue.push(...leftovers);
+        }
         newExpr.push(expr[i]);
       }
     }
 
-    return newExpr;
+    return { result: newExpr, leftovers: toContinue };
   }
 
   /**
@@ -227,23 +451,35 @@ function handleExists(csn, error) {
   function translateUnmanagedAssocToWhere(root, target, subselect, isPrefixedWithTableAlias, base, current) {
     for (let j = 0; j < root.on.length; j++) {
       const part = root.on[j];
+
+      // 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)) {
+        subselect.SELECT.where.push(part);
+        continue;
+      }
+
+      // 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 ]));
       // Dollar Self Backlink
-      if (isValidDollarSelf(root.on[j], root.on[j + 1], root.on[j + 2])) {
+      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)
-          subselect.SELECT.where.push(...translateDollarSelfToWhere(base, target, root.on[j + 2]));
+          subselect.SELECT.where.push(...translateDollarSelfToWhere(base, target, root.on[j + 2], root.$path.concat([ 'on', j + 2 ])));
         else
-          subselect.SELECT.where.push(...translateDollarSelfToWhere(base, target, root.on[j]));
+          subselect.SELECT.where.push(...translateDollarSelfToWhere(base, target, root.on[j], root.$path.concat([ 'on', j ])));
 
         j += 2;
       }
-      else if (part._links && part._links[0].art === root) { // target side
+      else if (links && links[0].art === root) { // target side
         subselect.SELECT.where.push({ ref: [ target, ...part.ref.slice(1) ] });
       }
       else if (part.$scope === '$self') { // source side - "absolute" scope
         // cut off the $self, as we prefix the entity name now
         subselect.SELECT.where.push({ ref: [ base, ...part.ref.slice(1) ] });
       }
-      else if (part._art) { // source side - with local scope
+      else if (art) { // source side - with local scope
         if (isPrefixedWithTableAlias)
           subselect.SELECT.where.push({ ref: [ ...current.ref.slice(0, -1), ...part.ref ] });
         else
@@ -258,43 +494,82 @@ function handleExists(csn, error) {
      * Check that an expression triple is a valid $self
      *
      * @param {Token} leftSide
+     * @param {CSN.Path} pathLeft
      * @param {Token} middle
      * @param {Token} rightSide
+     * @param {CSN.Path} pathRight
      * @returns {boolean}
      */
-    function isValidDollarSelf(leftSide, middle, rightSide) {
-      return leftSide && leftSide.ref &&
-      rightSide && rightSide.ref &&
-      middle === '=' &&
-                      (
-                        leftSide.ref[0] === '$self' && leftSide.ref.length === 1 && rightSide._art && rightSide._art.target ||
-                        rightSide.ref[0] === '$self' && rightSide.ref.length === 1 && leftSide._art && leftSide._art.target
-                      );
+    function isValidDollarSelf(leftSide, pathLeft, middle, rightSide, pathRight) {
+      if (leftSide && leftSide.ref && rightSide && rightSide.ref && middle === '=') {
+        const right = inspectRef(pathRight);
+        const left = inspectRef(pathLeft);
+
+        if (!right || !left)
+          return false;
+
+        const rightSideArt = right.art;
+        const leftSideArt = left.art;
+
+        return leftSide.ref[0] === '$self' && leftSide.ref.length === 1 && rightSideArt && rightSideArt.target ||
+               rightSide.ref[0] === '$self' && rightSide.ref.length === 1 && leftSideArt && leftSideArt.target;
+      }
+
+      return false;
     }
   }
 
   /**
-   * From the given expression (having _links), find the first association.
+   * From the given expression (having inspectRef -> links), find the first association.
    *
    * @param {object} xprPart
-   * @returns {{root: CSN.Element, ref: string|object, tail: Array}} The first assoc (root), the corresponding ref (ref) and the rest of the ref (tail).
+   * @param {CSN.Path} path
+   * @returns {{head: Array, root: CSN.Element, ref: string|object, tail: Array}} The first assoc (root), the corresponding ref (ref), anything before the ref (head) and the rest of the ref (tail).
    */
-  function getFirstAssoc(xprPart) {
+  function getFirstAssoc(xprPart, path) {
+    const { links, art } = inspectRef(path);
     for (let i = 0; i < xprPart.ref.length - 1; i++) {
-      if (xprPart._links[i].art && xprPart._links[i].art.target)
-        return { root: xprPart._links[i].art, ref: xprPart.ref[i], tail: xprPart.ref.slice(i + 1) };
+      if (links[i].art && links[i].art.target) {
+        return {
+          head: (i === 0 ? [] : xprPart.ref.slice(0, i)), root: links[i].art, ref: xprPart.ref[i], tail: xprPart.ref.slice(i + 1),
+        };
+      }
     }
-    return { root: xprPart._art, ref: xprPart.ref[xprPart.ref.length - 1], tail: [] };
+    return {
+      head: (xprPart.ref.length === 1 ? [] : xprPart.ref.slice(0, xprPart.ref.length - 1)), root: art, ref: xprPart.ref[xprPart.ref.length - 1], tail: [],
+    };
+  }
+
+  /**
+   * Get the last association from the expression part - similar to getFirstAssoc
+   *
+   * @param {object} xprPart
+   * @param {CSN.Path} path
+   * @returns {{head: Array, root: CSN.Element, ref: string|object, tail: Array}} The last assoc (root), the corresponding ref (ref), anything before the ref (head) and the rest of the ref (tail).
+   */
+  function getLastAssoc(xprPart, path) {
+    const { links, art } = inspectRef(path);
+    for (let i = xprPart.ref.length - 1; i > -1; i--) {
+      if (links[i].art && links[i].art.target) {
+        return {
+          head: (i === 0 ? [] : xprPart.ref.slice(0, i)), root: links[i].art, ref: xprPart.ref[i], tail: xprPart.ref.slice(i + 1),
+        };
+      }
+    }
+    return {
+      head: (xprPart.ref.length === 1 ? [] : xprPart.ref.slice(0, xprPart.ref.length - 1)), root: art, ref: xprPart.ref[xprPart.ref.length - 1], tail: [],
+    };
   }
 
   /**
-   * Check (using _links), wether the first path step is an entity or query source
+   * Check (using inspectRef -> links), wether the first path step is an entity or query source
    *
-   * @param {object} o
+   * @param {CSN.Path} path
    * @returns {boolean}
    */
-  function firstLinkIsEntityOrQuerySource(o) {
-    return o._links && (o._links[0].art.kind === 'entity' || o._links[0].art.query || o._links[0].art.from);
+  function firstLinkIsEntityOrQuerySource(path) {
+    const { links } = inspectRef(path);
+    return links && (links[0].art.kind === 'entity' || links[0].art.query || links[0].art.from);
   }
 
   /**
@@ -314,13 +589,14 @@ function handleExists(csn, error) {
    * we can be sure that resolving the ref requires $env information.
    *
    * @param {object} xpr
+   * @param {CSN.Path} path
    * @returns {string|undefined} undefined in case of errors
    * @throws {Error} Throws if xpr.ref but no xpr.$env
    * @todo $env is going to be removed from CSN, but csnRefs will provide it
    */
   // eslint-disable-next-line consistent-return
-  function getParent(xpr) {
-    if (firstLinkIsEntityOrQuerySource(xpr)) {
+  function getParent(xpr, path) {
+    if (firstLinkIsEntityOrQuerySource(path)) {
       return xpr.ref[0];
     }
     else if (xpr.$env) {
@@ -364,7 +640,7 @@ function handleExists(csn, error) {
     };
     // Because the generated things don't have _links, _art etc. set
     // We could also make getParent more robust to calculate the links JIT if they are missing
-    setProp(subselect, '$generatedExists', true);
+    generatedExists.set(subselect, true);
 
     const nonEnumElements = Object.create(null);
     nonEnumElements.dummy = {
@@ -382,14 +658,15 @@ function handleExists(csn, error) {
    * @param {string|null} queryBase
    * @param {boolean} isPrefixedWithTableAlias
    * @param {CSN.Column} current
+   * @param {CSN.Path} path
    * @returns {string}
    */
-  function getBase(queryBase, isPrefixedWithTableAlias, current) {
+  function getBase(queryBase, isPrefixedWithTableAlias, current, path) {
     if (queryBase)
       return getRealName(csn, queryBase);
     else if (isPrefixedWithTableAlias)
       return current.ref[0];
-    return getParent(current);
+    return getParent(current, path);
   }
 
 
@@ -421,31 +698,34 @@ function handleExists(csn, error) {
    * @param {string} base The source entity/query source name
    * @param {string} target The target entity/query source name
    * @param {CSN.Element} assoc The association element - the "not-$self" side of the comparison
+   * @param {CSN.Path} path
    * @returns {TokenStream} The WHERE representing the $self comparison
    */
-  function translateDollarSelfToWhere(base, target, assoc) {
+  function translateDollarSelfToWhere(base, target, assoc, path) {
     const where = [];
-    if (assoc._art.keys) {
-      for (let i = 0; i < assoc._art.keys.length; i++) {
-        const lop = { ref: [ target, ...assoc.ref.slice(1), ...assoc._art.keys[i].ref ] }; // target side
-        const rop = { ref: [ base, ...assoc._art.keys[i].ref ] }; // source side
+    const { art } = inspectRef(path);
+    if (art.keys) {
+      for (let i = 0; i < art.keys.length; i++) {
+        const lop = { ref: [ target, ...assoc.ref.slice(1), ...art.keys[i].ref ] }; // target side
+        const rop = { ref: [ base, ...art.keys[i].ref ] }; // source side
         if (i > 0)
           where.push('and');
 
         where.push(...[ lop, '=', rop ]);
       }
     }
-    else if (assoc._art.on) {
-      for (let i = 0; i < assoc._art.on.length; i++) {
-        const part = assoc._art.on[i];
-        if (part._links && part._links[0].art === assoc._art) { // target side
+    else if (art.on) {
+      for (let i = 0; i < art.on.length; i++) {
+        const part = art.on[i];
+        const partInspect = inspectRef(art.$path.concat([ 'on', i ]));
+        if (partInspect.links && partInspect.links[0].art === art) { // target side
           where.push({ ref: [ base, ...part.ref.slice(1) ] });
         }
         else if (part.$scope === '$self') { // source side - "absolute" scope
           // Same message as in forHanaNew/transformDollarSelfComparisonWithUnmanagedAssoc
           error(null, part.$path, 'An association that uses "$self" in its ON-condition can\'t be compared to "$self"');
         }
-        else if (part._art) { // source side - with local scope
+        else if (partInspect.art) { // source side - with local scope
           where.push({ ref: [ target, ...assoc.ref.slice(1, -1), ...part.ref ] });
         }
         else { // operator - or any other leftover