@sap/cds-compiler 2.10.2 → 2.11.4

package/lib/transform/db/transformExists.js

@@ -49,10 +49,14 @@ const { csnRefs } = require('../../model/csnRefs');
  */
 function handleExists(csn, options, error) {
   const { inspectRef } = csnRefs(csn);
+  const generatedExists = new WeakMap();
   forEachDefinition(csn, (artifact, artifactName) => {
+    if (artifact.projection) // do the same hack we do for the other stuff...
+      artifact.query = { SELECT: artifact.projection };
+
     if (artifact.query) {
       forAllQueries(artifact.query, (query, path) => {
-        if (!query.$generatedExists) {
+        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)
             toProcess.push([ path.slice(0, -1), path.concat('where') ]);
@@ -66,6 +70,7 @@ function handleExists(csn, options, error) {
             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;
           }
@@ -81,6 +86,12 @@ function handleExists(csn, options, error) {
         }
       }, [ 'definitions', artifactName, 'query' ]);
     }
+
+    if (artifact.projection) { // undo our hack
+      artifact.projection = artifact.query.SELECT;
+
+      delete artifact.query;
+    }
   });
 
   /**
@@ -233,6 +244,63 @@ function handleExists(csn, options, error) {
     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 && 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.
@@ -249,6 +317,15 @@ function handleExists(csn, options, error) {
         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;
       }
@@ -278,15 +355,10 @@ function handleExists(csn, options, error) {
         const current = expr[i];
         const isPrefixedWithTableAlias = firstLinkIsEntityOrQuerySource(exprPath.concat(i));
         const base = getBase(queryBase, isPrefixedWithTableAlias, current, exprPath.concat(i));
-        const { root, ref, tail } = getFirstAssoc(current, exprPath.concat(i));
-
-        if (tail.length > 0) {
-          error(null, current.$path, { id: tail[0].id ? tail[0].id : tail[0], name: ref.id ? ref.id : ref }, 'Unexpected path step $(ID) after association $(NAME) in "EXISTS"');
-          continue;
-        }
+        const { root, ref } = getFirstAssoc(current, exprPath.concat(i));
 
         if (!root.target) {
-          error(null, current.$path, { type: root.type }, '“EXISTS” can only be used with associations/compositions, found $(TYPE)');
+          error(null, exprPath.concat(i), { type: root.type }, '“EXISTS” can only be used with associations/compositions, found $(TYPE)');
           return { result: [], leftovers: [] };
         }
 
@@ -477,6 +549,27 @@ function handleExists(csn, options, error) {
     };
   }
 
+  /**
+   * 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 inspectRef -> links), wether the first path step is an entity or query source
    *
@@ -556,7 +649,7 @@ function handleExists(csn, options, 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 = {

package/lib/transform/db/views.js

@@ -0,0 +1,485 @@
+'use strict';
+
+const {
+  getUtils, cloneCsn, applyTransformationsOnNonDictionary,
+} = require('../../model/csnUtils');
+const { implicitAs, csnRefs } = require('../../model/csnRefs');
+const { isBetaEnabled } = require('../../base/model');
+
+/**
+ * If a mixin association is published, return the mixin association.
+ *
+ * @param {CSN.Query} query Query of the artifact to check
+ * @param {object} association Association (Element) published by the view
+ * @param {string} associationName
+ * @returns {object} The mixin association
+ */
+function getMixinAssocOfQueryIfPublished(query, association, associationName) {
+  if (query && query.SELECT && 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 elem of Object.keys(query.SELECT.mixin)) {
+      const mixinElement = query.SELECT.mixin[elem];
+      let originalName = associationName;
+      if (aliasedColumnsMap[associationName])
+        originalName = aliasedColumnsMap[associationName].ref[0];
+
+      if (elem === originalName)
+        return { mixinElement, mixinName: originalName };
+    }
+  }
+  return {};
+}
+
+/**
+ * Check wether the given artifact uses the given mixin association.
+ *
+ * We can rely on the fact that there can be no usage starting with $self/$projection,
+ * since lib/checks/selectItems.js forbids that.
+ *
+ * @param {CSN.Query} query Query of the artifact to check
+ * @param {object} association Mixin association (Element) to check for
+ * @param {string} associationName
+ * @returns {boolean} True if used
+ */
+function usesMixinAssociation(query, association, associationName) {
+  if (query && query.SELECT && query.SELECT.columns) {
+    for (const column of query.SELECT.columns) {
+      if (typeof column === 'object' && column.ref && column.ref.length > 1 && (column.ref[0] === associationName || column.ref[0].id === associationName))
+        return true;
+    }
+  }
+  return false;
+}
+
+/**
+ * @param {CSN.Model} csn
+ * @param {CSN.Options} options
+ * @param {{error: Function, info: Function}} messageFunctions
+ * @param {Function} transformCommon For the time being: Pass from outside
+ * @returns {(query: CSN.Query, artifact: CSN.Artifact, artName: string, path: CSN.Path) => void} Transformer function for views
+ */
+function getViewTransformer(csn, options, messageFunctions, transformCommon) {
+  const {
+    get$combined, isAssocOrComposition,
+  } = getUtils(csn);
+  const { inspectRef, queryOrMain } = csnRefs(csn);
+  const pathDelimiter = (options.forHana.names === 'hdbcds') ? '.' : '_';
+  const { error, info } = messageFunctions;
+  const doA2J = !(options.transformation === 'hdbcds' && options.sqlMapping === 'hdbcds');
+
+  return transformViewOrEntity;
+
+  /**
+   *
+   * check all queries/subqueries for mixin publishing inside of unions -> forbidden in hdbcds
+   *
+   * @param {CSN.Query} query
+   * @param {CSN.Elements} elements
+   * @param {CSN.Path} path
+   */
+  function checkForMixinPublishing(query, elements, path) {
+    for (const elementName in elements) {
+      const element = elements[elementName];
+      if (element.target) {
+        let colLocation;
+        for (let i = 0; i < query.SELECT.columns.length; i++) {
+          const col = query.SELECT.columns[i];
+          if (col.ref && col.ref.length === 1) {
+            if (!colLocation && col.ref[0] === elementName)
+              colLocation = i;
+
+
+            if (col.as === elementName)
+              colLocation = i;
+          }
+        }
+        if (colLocation) {
+          const matchingCol = query.SELECT.columns[colLocation];
+          const possibleMixinName = matchingCol.ref[0];
+          const isMixin = query.SELECT.mixin[possibleMixinName] !== undefined;
+          if (element.target && isMixin) {
+            error(null, path.concat([ 'columns', colLocation ]), { id: elementName, name: possibleMixinName, '#': possibleMixinName === elementName ? 'std' : 'renamed' }, {
+              std: 'Element $(ID) is a mixin association and can\'t be published in a UNION',
+              renamed: 'Element $(ID) is a mixin association ($(NAME))and can\'t be published in a UNION',
+            });
+          }
+        }
+      }
+    }
+  }
+  /**
+   * Build a map of the resulting names (i.e. the element name of the column) and references to the respective columns
+   *
+   * This can later be used to match from elements to columns.
+   *
+   * @param {CSN.Query} query
+   * @returns {object}
+   */
+  function getColumnMap(query) {
+    const map = Object.create(null);
+    if (query && query.SELECT && query.SELECT.columns) {
+      query.SELECT.columns.forEach((col) => {
+        if (col === '*') {
+          // do nothing
+        }
+        else if (col.as) {
+          if (!map[col.as])
+            map[col.as] = col;
+        }
+        else if (col.ref) {
+          // .id on last path step can happen with hdbcds.hdbcds and malicious CSN input - maybe also with params?
+          // We made things right in the end with the second add of missing stuff, but why not do it
+          // right from the getgo
+          const last = getLastRefStepString(col.ref);
+          if (!map[last])
+            map[last] = col;
+        }
+        else if (col.func) {
+          map[col.func] = col;
+        }
+        else if (!map[col]) {
+          map[col] = col;
+        }
+      });
+    }
+
+    return map;
+  }
+  /**
+   * For things that are not explicitly found in the columns but still present in the elements, add them to the columnMap.
+   *
+   * This can happen for:
+   * - projections, as we might not have .columns at all
+   * - *, as we don't resolve it for hdbcds with hdbcds-naming
+   *
+   * We ensure that we attach a table alias before each column
+   *
+   * @param {CSN.Query} query
+   * @param {boolean} isProjection
+   * @param {boolean} isSelectStar
+   * @param {object} $combined
+   * @param {object} columnMap
+   * @param {string} elemName
+   */
+  function addProjectionOrStarElement(query, isProjection, isSelectStar, $combined, columnMap, elemName) {
+    // Prepend an alias if present
+    let alias = (isProjection || isSelectStar) &&
+    (query.SELECT.from.as || (query.SELECT.from.ref && implicitAs(query.SELECT.from.ref)));
+    // In case of * and no explicit alias
+    // find the source of the col by looking at $combined and prepend it
+    if (isSelectStar && !alias && !isProjection) {
+      if (!$combined)
+        $combined = get$combined(query);
+
+
+      const matchingCombined = $combined[elemName];
+      // Internal errors - this should never happen!
+      if (matchingCombined.length > 1) { // should already be caught by compiler
+        throw new Error(`Ambiguous name - can't be resolved: ${elemName}. Found in: ${matchingCombined.map(o => o.parent)}`);
+      }
+      else if (matchingCombined.length === 0) { // no clue how this could happen? Invalid CSN?
+        throw new Error(`No matching entry found in UNION of all elements for: ${elemName}`);
+      }
+      alias = matchingCombined[0].parent;
+    }
+    if (alias)
+      columnMap[elemName] = { ref: [ alias, elemName ] };
+    else
+      columnMap[elemName] = { ref: [ elemName ] };
+  }
+
+  /**
+   * So far, we only added foreign keys to elements - we also need to create corresponding columns
+   * and respect aliasing etc.
+   *
+   * @todo Maybe this can be done earlier, during flattening/expansion already?
+   * @param {object} columnMap
+   * @param {CSN.Element} elem
+   * @param {string} elemName
+   */
+  function addForeignKeysToColumns(columnMap, elem, elemName) {
+    const assocCol = columnMap[elemName];
+    if (assocCol && assocCol.ref) {
+      elem.keys.forEach((foreignKey) => {
+        const ref = cloneCsn(assocCol.ref, options);
+        ref[ref.length - 1] = [ getLastRefStepString(ref) ].concat(foreignKey.as).join(pathDelimiter);
+        const result = {
+          ref,
+        };
+        if (assocCol.as) {
+          const columnName = `${assocCol.as}${pathDelimiter}${foreignKey.as}`;
+          result.as = columnName;
+        }
+
+        if (assocCol.key)
+          result.key = true;
+
+        const colName = result.as || getLastRefStepString(ref);
+        columnMap[colName] = result;
+      });
+    }
+  }
+
+
+  /**
+   * Check for invalid association publishing (in Union or in Subquery) (for hdbcds) and
+   * create the __clone for publishing stuff.
+   *
+   * @todo Factor out the checks
+   * @param {CSN.Query} query
+   * @param {object} elements
+   * @param {object} columnMap
+   * @param {WeakMap} publishedMixins Map to collect the published mixins
+   * @param {CSN.Element} elem
+   * @param {string} elemName
+   * @param {CSN.Path} elementsPath Path pointing to elements
+   * @param {CSN.Path} queryPath Path pointing to the query
+   */
+  function handleAssociationElement(query, elements, columnMap, publishedMixins, elem, elemName, elementsPath, queryPath) {
+    if (isUnion(queryPath) && options.transformation === 'hdbcds') {
+      if (isBetaEnabled(options, 'ignoreAssocPublishingInUnion') && doA2J) {
+        if (elem.keys)
+          info(null, queryPath, `Managed association "${elemName}", published in a UNION, will be ignored`);
+        else
+          info(null, queryPath, `Association "${elemName}", published in a UNION, will be ignored`);
+
+        elem._ignore = true;
+      }
+      else {
+        error(null, queryPath, `Association "${elemName}" can't be published in a SAP HANA CDS UNION`);
+      }
+    }
+    else if (queryPath.length > 4 && options.transformation === 'hdbcds') { // path.length > 4 -> is a subquery
+      error(null, queryPath, { name: elemName },
+            'Association $(NAME) can\'t be published in a subquery');
+    }
+    else {
+      const isNotMixinByItself = checkIsNotMixinByItself(query, columnMap, elemName);
+      const { mixinElement, mixinName } = getMixinAssocOfQueryIfPublished(query, elem, elemName);
+      if (isNotMixinByItself || mixinElement !== undefined) {
+        // If the mixin is only published and not used, only display the __ clone. Kill the "original".
+        if (mixinElement !== undefined && !usesMixinAssociation(query, elem, elemName))
+          delete query.SELECT.mixin[mixinName];
+
+
+        // Create an unused alias name for the MIXIN - use 3 _ to avoid collision with usings
+        let mixinElemName = `___${mixinName || elemName}`;
+        while (elements[mixinElemName])
+          mixinElemName = `_${mixinElemName}`;
+
+        // Copy the association element to the MIXIN clause under its alias name
+        // Needs to be a deep copy, as we transform the on-condition
+        const mixinElem = cloneCsn(elem, options);
+        // Perform common transformations on the newly generated MIXIN element (won't be reached otherwise)
+        transformCommon(mixinElem, mixinElemName);
+
+        if (query.SELECT && !query.SELECT.mixin)
+          query.SELECT.mixin = Object.create(null);
+
+        // Clone 'on'-condition, pre-pending '$projection' to paths where appropriate,
+        // and fixing the association alias just created
+
+        if (mixinElem.on) {
+          mixinElem.on = applyTransformationsOnNonDictionary(mixinElem, 'on', {
+            ref: (parent, prop, ref, refpath) => {
+              if (ref[0] === elemName) {
+                ref[0] = mixinElemName;
+              }
+              else if (!(ref[0] && ref[0].startsWith('$'))) {
+                ref.unshift('$projection');
+              }
+              else if (ref[0] && ref[0].startsWith('$')) {
+                // TODO: I think this is non-sense. Stuff with $ is either magic or must start with $self, right?
+                const { scope } = inspectRef(refpath);
+                if (scope !== '$magic' && scope !== '$self')
+                  ref.unshift('$projection');
+              }
+              parent.ref = ref;
+              return ref;
+            },
+          }, elementsPath.concat(elemName));
+        }
+
+        if (!mixinElem._ignore)
+          columnMap[elemName] = { ref: [ mixinElemName ], as: elemName };
+
+        if (query.SELECT) {
+          query.SELECT.mixin[mixinElemName] = mixinElem;
+
+          publishedMixins.set(mixinElem, true);
+        }
+      }
+    }
+  }
+
+  /**
+   * If following an association, explicitly set the implicit alias
+   * due to an issue with HANA - only for hdbcds-hdbcds, I assume flattening
+   * takes care of this for the other cases already
+   *
+   * @param {CSN.Query} query
+   * @param {CSN.Path} path
+   */
+  function addImplicitAliasWithAssoc(query, path) {
+    for (let i = 0; i < query.SELECT.columns.length; i++) {
+      const col = query.SELECT.columns[i];
+      if (!col.as && col.ref && col.ref.length > 1) {
+        const { links } = inspectRef(path.concat([ 'columns', i ]));
+        if (links && links.slice(0, -1).some(({ art }) => isAssocOrComposition(art && art.type || '')))
+          col.as = getLastRefStepString(col.ref);
+      }
+    }
+  }
+
+  /**
+   * @param {CSN.Query} query
+   * @param {CSN.Artifact} artifact
+   * @param {string} artName
+   * @param {CSN.Path} path
+   */
+  // eslint-disable-next-line complexity
+  function transformViewOrEntity(query, artifact, artName, path) {
+    const { elements } = queryOrMain(query, artifact);
+    // We use the elements from the leading query/main artifact - adapt the path
+    const elementsPath = elements === artifact.elements ? path.slice(0, 2).concat('elements') : path.concat('elements');
+    const queryPath = path;
+
+    let hasNonAssocElements = false;
+    const isSelect = query && query.SELECT;
+    const isProjection = !!artifact.projection || query && query.SELECT && !query.SELECT.columns;
+    const columnMap = getColumnMap(query);
+    const isSelectStar = query && query.SELECT && query.SELECT.columns && query.SELECT.columns.indexOf('*') !== -1;
+
+    // check all queries/subqueries for mixin publishing inside of unions -> forbidden in hdbcds
+    if (query && options.transformation === 'hdbcds' && query.SELECT && query.SELECT.mixin && path.indexOf('SET') !== -1)
+      checkForMixinPublishing(query, elements, path);
+
+    // Second walk through the entity elements: Deal with associations (might also result in new elements)
+    // Will be initialized JIT inside the elements-loop
+    let $combined;
+
+    const publishedMixins = new WeakMap();
+
+    for (const elemName in elements) {
+      const elem = elements[elemName];
+      if (isSelect) {
+        if (!columnMap[elemName])
+          addProjectionOrStarElement(query, isProjection, isSelectStar, $combined, columnMap, elemName);
+
+        // For associations - make sure that the foreign keys have the same "style"
+        // If A.assoc => A.assoc_id, else if assoc => assoc_id or assoc as Assoc => Assoc_id
+        if (elem.keys && doA2J)
+          addForeignKeysToColumns(columnMap, elem, elemName);
+      }
+      // Views must have at least one element that is not an unmanaged assoc
+      if (!elem.on && !elem._ignore)
+        hasNonAssocElements = true;
+
+      // (180 b) Create MIXINs for association elements in projections or views (those that are not mixins by themselves)
+      // CDXCORE-585: Allow mixin associations to be used and published in parallel
+      if (query !== undefined && elem.target)
+        handleAssociationElement(query, elements, columnMap, publishedMixins, elem, elemName, elementsPath, queryPath);
+    }
+
+    if (query && !hasNonAssocElements) {
+      // Complain if there are no elements other than unmanaged associations
+      // Allow with plain
+      error(null, [ 'definitions', artName ], { $reviewed: true },
+            'Expecting view or projection to have at least one element that is not an unmanaged association');
+    }
+
+    if (isSelect) {
+      // Build new columns from the column map - bring elements and columns back in sync basically
+      query.SELECT.columns = Object.keys(elements).filter(elem => !elements[elem]._ignore).map(key => stripLeadingSelf(columnMap[key]));
+      // If following an association, explicitly set the implicit alias
+      // due to an issue with HANA - this seems to only have an effect on ref files with hdbcds-hdbcds, so only run then
+      if (options.transformation === 'hdbcds' && options.sqlMapping === 'hdbcds')
+        addImplicitAliasWithAssoc(query, path);
+
+      delete query.SELECT.excluding;  // just to make the output of the new transformer the same as the old
+
+      // A2J turned usages into JOINs, we must now remove all non-published mixins (i.e. only keep the clones)
+      if (query.SELECT.mixin && doA2J) {
+        for (const [ name, mixin ] of Object.entries(query.SELECT.mixin)) {
+          if (!publishedMixins.has(mixin))
+            delete query.SELECT.mixin[name];
+        }
+      }
+    }
+  }
+}
+
+/**
+ * Walk the given path and check if we are in a UNION.
+ * This will return true when it is called on the subquery inside of a SET.args property.
+ *
+ * @param {CSN.Path} path
+ * @returns {boolean}
+ */
+function isUnion(path) {
+  const subquery = path[path.length - 1];
+  const queryIndex = path[path.length - 2];
+  const args = path[path.length - 3];
+  const unionOperator = path[path.length - 4];
+  return path.length > 3 && (subquery === 'SET' || subquery === 'SELECT') && typeof queryIndex === 'number' && queryIndex >= 0 && args === 'args' && unionOperator === 'SET';
+}
+
+/**
+ * Strip of leading $self of the ref
+ *
+ * @param {object} col A column
+ * @returns {object}
+ */
+function stripLeadingSelf(col) {
+  if (col.ref && col.ref.length > 1 && col.ref[0] === '$self')
+    col.ref = col.ref.slice(1);
+
+  return col;
+}
+
+/**
+ * Check that the given element is not a simple mixin-publishing
+ *
+ * @param {CSN.Query} query
+ * @param {object} columnMap
+ * @param {string} elementName
+ * @returns {boolean}
+ */
+function checkIsNotMixinByItself(query, columnMap, elementName) {
+  if (query && query.SELECT && query.SELECT.mixin) {
+    const col = columnMap[elementName];
+
+    // Use getLastRefStepString - with hdbcds.hdbcds and malicious CSN input we might have .id
+    const realName = getLastRefStepString(col.ref);
+    // If the element is not part of the mixin => True
+    return query.SELECT.mixin[realName] === undefined;
+  }
+  // the artifact does not define any mixins, the element cannot be a mixin
+  return true;
+}
+
+/**
+ * Return the string value of the last ref step - so either the .id or the last step.
+ *
+ * We cannot use implicitAs, as this causes problems for structured things with hdi-hdbcds naming
+ *
+ * @param {Array} ref
+ * @returns {string}
+ */
+function getLastRefStepString(ref) {
+  const last = ref[ref.length - 1];
+  if (last.id)
+    return last.id;
+  return last;
+}
+
+module.exports = {
+  getViewTransformer,
+};