@sap/cds-compiler 5.4.2 → 5.5.0

package/lib/transform/db/{transformExists.js → assocsToQueries/transformExists.js}

@@ -1,9 +1,8 @@
 'use strict';
 
-const { forAllQueries, forEachDefinition, walkCsnPath } = require('../../model/csnUtils');
-const { setProp } = require('../../base/model');
-const { getRealName } = require('../../render/utils/common');
-const { ModelError } = require('../../base/error');
+const { forAllQueries, forEachDefinition, walkCsnPath } = require('../../../model/csnUtils');
+const { setProp } = require('../../../base/model');
+const { getHelpers } = require('./utils');
 
 /**
  * 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)`.
@@ -51,6 +50,14 @@ const { ModelError } = require('../../base/error');
  * @param {Function} dropDefinitionCache
  */
 function handleExists( csn, options, error, inspectRef, initDefinition, dropDefinitionCache ) {
+  const {
+    getBase,
+    firstLinkIsEntityOrQuerySource,
+    getFirstAssoc,
+    translateManagedAssocToWhere,
+    getQuerySources,
+    translateUnmanagedAssocToWhere,
+  } = getHelpers(csn, inspectRef, error);
   const generatedExists = new WeakMap();
   forEachDefinition(csn, (artifact, artifactName) => {
     // drop cache: Otherwise, the projection/query hack below won't work, because csnRefs
@@ -106,48 +113,6 @@ function handleExists( csn, options, error, inspectRef, initDefinition, dropDefi
     }
   });
 
-  /**
-   * Get the source aliases from a join
-   *
-   * @param {Array} args Join args
-   * @returns {object}
-   */
-  function getJoinSources( args ) {
-    let sources = Object.create(null);
-    for (const join of args) {
-      if (join.as) {
-        sources[join.as] = join.as;
-      }
-      else if (join.args) {
-        const subSources = getJoinSources(join.args);
-        sources = Object.assign(sources, subSources);
-      }
-      else if (join.ref) {
-        sources[join.ref[join.ref.length - 1]] = join.ref[join.ref.length - 1];
-      }
-    }
-
-    return sources;
-  }
-
-  /**
-   * Get the source aliases from a query - drill down somewhat into joins (is that correct?)
-   *
-   * @param {CSN.Query} query
-   * @returns {object}
-   */
-  function getQuerySources( query ) {
-    const sources = Object.create(null);
-    if (query.from.as)
-      sources[query.from.as] = query.from.as;
-    else if (query.from.args)
-      return Object.assign(sources, getJoinSources(query.from.args));
-    else if (query.from.ref)
-      sources[query.from.ref[query.from.ref.length - 1]] = query.from.ref[query.from.ref.length - 1];
-
-    return sources;
-  }
-
   /**
    * Get the index of the first association that is found - starting the
    * search at the given startIndex.
@@ -300,7 +265,7 @@ function handleExists( csn, options, error, inspectRef, initDefinition, dropDefi
       if (i < expr.length - 1 && expr[i] === 'exists' && expr[i + 1].ref) {
         i++;
         const current = expr[i];
-        const isPrefixedWithTableAlias = firstLinkIsEntityOrQuerySource(exprPath.concat(i));
+        const isPrefixedWithTableAlias = firstLinkIsEntityOrQuerySource({}, exprPath.concat(i));
         const base = getBase(queryBase, isPrefixedWithTableAlias, current, exprPath.concat(i));
         const { root, ref } = getFirstAssoc(current, exprPath.concat(i));
 
@@ -358,300 +323,6 @@ function handleExists( csn, options, error, inspectRef, initDefinition, dropDefi
     return { result: newExpr, leftovers: toContinue };
   }
 
-  /**
-   * Translate an `EXISTS <managed assoc>` into a part of a WHERE condition.
-   *
-   * For each of the foreign keys, do:
-   * + build the target side by prefixing `target` in front of the ref
-   * + build the source side by prefixing `base` (if not already part of `current`)
-   *  and the assoc name itself (current) in front of the ref
-   * + Compare source and target with `=`
-   *
-   * If there is more than one foreign key, join with `and`.
-   *
-   * The new tokens are immediately added to the WHERE of the subselect
-   *
-   * @param {CSN.Element} root
-   * @param {string} target
-   * @param {boolean} isPrefixedWithTableAlias
-   * @param {string} base
-   * @param {Token} current
-   * @returns {object[]} The stuff to add to the where
-   */
-  function translateManagedAssocToWhere( root, target, isPrefixedWithTableAlias, base, current ) {
-    if (current.$scope === '$self') {
-      error('ref-unexpected-self', current.$path, { '#': 'exists', id: current.ref[0], name: 'exists' });
-      return [];
-    }
-
-    const whereExtension = [];
-    for (let j = 0; j < root.keys.length; j++) {
-      const lop = { ref: [ target, ...root.keys[j].ref ] }; // target side
-      const rop = { ref: (isPrefixedWithTableAlias ? [] : [ base ]).concat([ ...toRawRef(current.ref), ...root.keys[j].ref ]) }; // source side
-
-      if (j > 0)
-        whereExtension.push('and');
-
-      whereExtension.push(...[ lop, '=', rop ]);
-    }
-
-    return whereExtension;
-  }
-
-  /**
-   * Turn a ref-array into an array of strings.
-   *
-   * @param {Array} ref Array of strings or objects with `id`
-   * @returns {string[]}
-   */
-  function toRawRef( ref ) {
-    return ref.map(r => (r.id ? r.id : r));
-  }
-
-  /**
-   *
-   * Translate an `EXISTS <unmanaged assoc>` into a part of a WHERE condition.
-   *
-   * A valid $self-backlink is handled in translateDollarSelfToWhere.
-   *
-   * For an ordinary unmanaged association, we do the following for each part of the on-condition:
-   * - target side: We prefix the real target and cut off the assoc-name from the ref
-   * - source side w/ leading $self: We remove the $self and add the source side entity/query source
-   * - source side w/o leading $self: We simply add the source side entity/query source in front of the ref
-   * - all other: Leave intact, usually operators
-   *
-   * @param {CSN.Element} root
-   * @param {string} target
-   * @param {boolean} isPrefixedWithTableAlias
-   * @param {string} base
-   * @param {Token} current
-   * @returns {object[]} The stuff to add to the where
-   */
-  function translateUnmanagedAssocToWhere( root, target, isPrefixedWithTableAlias, base, current ) {
-    const whereExtension = [];
-
-    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)) {
-        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(path.concat(expressionIndex));
-      // Dollar Self Backlink
-      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
-          collector.push(...translateDollarSelfToWhere(base, target, expression[expressionIndex], path.concat(expressionIndex)));
-
-        return expressionIndex + 2;
-      }
-      else if (links && links[0].art === root) { // target side
-        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.)
-          collector.push(translateToSourceSide(column));
-        }
-        else {
-          collector.push(assignAndDeleteAsAndKey({}, part, { ref: [ base, ...part.ref.slice(1) ] }));
-        }
-      }
-      else if (art) { // source side - with local scope
-        if (isPrefixedWithTableAlias || part.$scope === 'alias')
-          collector.push({ ref: [ ...current.ref.slice(0, -1), ...part.ref ] });
-        else
-          collector.push({ ref: [ base, ...current.ref.slice(0, -1), ...part.ref ] });
-      }
-      else { // operator - or any other leftover
-        collector.push(part);
-      }
-
-      return expressionIndex;
-    }
-
-
-    /**
-     * Run Object.assign on all of the passed in parameters and delete a .as and .key at the end
-     *
-     * @param {...any} args
-     * @returns {object} The merged args without an .as and .key property
-     */
-    function assignAndDeleteAsAndKey( ...args ) {
-      const obj = Object.assign.apply(null, args);
-      delete obj.as;
-      delete obj.key;
-      return obj;
-    }
-    /**
-     * Translate the given obj (a column-like thing) into an expression that we can use in the WHERE.
-     * - Strip off $self/$projection and correctly replace with source expression
-     * - Drill further down into .xpr
-     * - Correctly set table alias in front of ref
-     *
-     * @param {object} obj
-     * @returns {object}
-     */
-    function translateToSourceSide( obj ) {
-      if (obj.ref) {
-        if (obj.$scope === '$self') { // TODO: Check with this way down, do we keep the links?
-          const column = obj._art._column;
-          if (column && column.as)
-            return translateToSourceSide(column);
-          return assignAndDeleteAsAndKey({}, obj, { ref: [ base, ...obj.ref.slice(1) ] });
-        }
-        else if (typeof obj.$env === 'string') {
-          return assignAndDeleteAsAndKey({}, obj, { ref: [ obj.$env, ...obj.ref ] });
-        }
-
-        return assignAndDeleteAsAndKey({}, obj, { ref: [ ...obj.ref ] });
-      }
-      else if (obj.xpr) { // we need to drill further down into .xpr
-        return assignAndDeleteAsAndKey({}, obj, { xpr: obj.xpr.map(translateToSourceSide) });
-      }
-      else if (obj.args) {
-        return assignAndDeleteAsAndKey({}, obj, { args: obj.args.map(translateToSourceSide) });
-      }
-
-      return obj;
-    }
-
-    /**
-     * 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, 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 inspectRef -> links), find the first association.
-   *
-   * @param {object} xprPart
-   * @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, path ) {
-    const { links, art } = inspectRef(path);
-    for (let i = 0; i < xprPart.ref.length - 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 inspectRef -> links), whether the first path step is an entity or query source
-   *
-   * @param {CSN.Path} path
-   * @returns {boolean}
-   */
-  function firstLinkIsEntityOrQuerySource( path ) {
-    const { links } = inspectRef(path);
-    return links && (links[0].art.kind === 'entity' || links[0].art.query || links[0].art.from);
-  }
-
-  /**
-   * For a given xpr, check in which entity/query source the ref "is".
-   *
-   * If the ref already starts with an entity/query source, simply return the first ref step.
-   * Otherwise, use $env to figure it out:
-   * - $env=<string> -> the string is the source
-   * - $env=<number> && $scope='mixin' -> the current query is the source
-   * - $env=<number> && $scope!=='mixin' -> such refs start with entity/query source, are already handled
-   * - $env=true -> does not apply for "EXISTS" handling, only happens in ORDER BY or explicit on-cond redirection
-   *
-   * If we have a ref but no $env, throw to trigger recompile - but such cases should have already led to a recompile with
-   * the validator/enricher.
-   *
-   * Since we only call this function when it is not just a simple SELECT FROM X,
-   * 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, path ) {
-    if (firstLinkIsEntityOrQuerySource(path)) {
-      return xpr.ref[0];
-    }
-    else if (xpr.$env) {
-      if (typeof xpr.$env === 'string') {
-        return xpr.$env;
-      }
-      else if (typeof xpr.$env === 'number') {
-        if (xpr.$scope === 'mixin')
-          return '';
-        return error(null, xpr.$path, '$env with number is not handled yet - report this error!');
-      }
-
-      return error(null, xpr.$path, 'Boolean $env is not handled yet - report this error!');
-    }
-    else if (xpr.ref) {
-      throw new ModelError('Missing $env and missing leading artifact ref - throwing to trigger recompilation!');
-    }
-  }
-
   /**
    * Build an initial subselect for the final `EXISTS <subselect>`.
    *
@@ -692,25 +363,6 @@ function handleExists( csn, options, error, inspectRef, initDefinition, dropDefi
     return subselect;
   }
 
-  /**
-   * Get the name of the source-side query source
-   *
-   * @param {string | Array | null} queryBase
-   * @param {boolean} isPrefixedWithTableAlias
-   * @param {CSN.Column} current
-   * @param {CSN.Path} path
-   * @returns {string}
-   */
-  function getBase( queryBase, isPrefixedWithTableAlias, current, path ) {
-    if (typeof queryBase === 'string') // alias
-      return queryBase;
-    else if (queryBase) // ref
-      return queryBase.length > 1 ? queryBase[queryBase.length - 1] : getRealName(csn, queryBase[0]);
-    else if (isPrefixedWithTableAlias)
-      return current.ref[0];
-    return getParent(current, path);
-  }
-
 
   /**
    * If the assoc-base for EXISTS <assoc> has a filter, we need to merge this filter into the WHERE-clause of the subquery.
@@ -739,53 +391,6 @@ function handleExists( csn, options, error, inspectRef, initDefinition, dropDefi
       return part;
     });
   }
-
-  /**
-   * Turn the would-be on-condition of a $self backlink into a WHERE condition.
-   *
-   * Prefix the target/source side base accordingly and build the source = target comparisons.
-   *
-   * @param {string} base The source entity/query source name
-   * @param {string} target The target entity/query source name
-   * @param {object} 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, path ) {
-    const where = [];
-    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 (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 forRelationalDB/transformDollarSelfComparisonWithUnmanagedAssoc
-          error(null, part.$path, { name: '$self' },
-                'An association that uses $(NAME) in its ON-condition can\'t be compared to "$self"');
-        }
-        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
-          where.push(part);
-        }
-      }
-    }
-    return where;
-  }
 }