@cap-js/db-service 1.0.1 → 1.1.0

package/lib/cqn4sql.js

@@ -70,13 +70,14 @@ function cqn4sql(originalQuery, model = cds.context?.model || cds.model) {
       // Transform the from clause: association path steps turn into `WHERE EXISTS` subqueries.
       // The already transformed `where` clause is then glued together with the resulting subqueries.
       const { transformedWhere, transformedFrom } = getTransformedFrom(from || entity, transformedProp.where)
+      const queryNeedsJoins = inferred.joinTree && !inferred.joinTree.isInitial
 
       if (inferred.SELECT) {
         transformedQuery = transformSelectQuery(queryProp, transformedFrom, transformedWhere, transformedQuery)
       } else {
         if (from) {
           transformedProp.from = transformedFrom
-        } else {
+        } else if (!queryNeedsJoins) {
           transformedProp.entity = transformedFrom
         }
 
@@ -94,7 +95,7 @@ function cqn4sql(originalQuery, model = cds.context?.model || cds.model) {
         }
       }
 
-      if (inferred.joinTree && !inferred.joinTree.isInitial) {
+      if (queryNeedsJoins) {
         transformedQuery[kind].from = translateAssocsToJoins(transformedQuery[kind].from)
       }
     }
@@ -119,7 +120,7 @@ function cqn4sql(originalQuery, model = cds.context?.model || cds.model) {
     if (columns) {
       transformedQuery.SELECT.columns = getTransformedColumns(columns)
     } else {
-      transformedQuery.SELECT.columns = getColumnsForWildcard()
+      transformedQuery.SELECT.columns = getColumnsForWildcard(originalQuery.SELECT?.excluding)
     }
 
     // Like the WHERE clause, aliases from the SELECT list are not accessible for `group by`/`having` (in most DB's)
@@ -158,7 +159,7 @@ function cqn4sql(originalQuery, model = cds.context?.model || cds.model) {
    *
    * @param {string} kind - The type of operation: "INSERT" or "UPSERT".
    *
-   * @returns {Object} - The transformed query with updated `into` clause.
+   * @returns {object} - The transformed query with updated `into` clause.
    */
   function transformQueryForInsertUpsert(kind) {
     const { as } = transformedQuery[kind].into
@@ -170,10 +171,10 @@ function cqn4sql(originalQuery, model = cds.context?.model || cds.model) {
   /**
    * Transforms a stream query, replacing the `where` and `into` clauses after processing.
    *
-   * @param {Object} inferred - The inferred object containing the STREAM query.
-   * @param {Object} transformedQuery - The query object to be transformed.
+   * @param {object} inferred - The inferred object containing the STREAM query.
+   * @param {object} transformedQuery - The query object to be transformed.
    *
-   * @returns {Object} - The transformed query with updated STREAM clauses.
+   * @returns {object} - The transformed query with updated STREAM clauses.
    */
   function transformStreamQuery() {
     const { into, where } = inferred.STREAM
@@ -193,8 +194,8 @@ function cqn4sql(originalQuery, model = cds.context?.model || cds.model) {
   /**
    * Transforms a search expression to a WHERE clause for a SELECT operation.
    *
-   * @param {Object} search - The search expression which shall be applied to the searchable columns on the query source.
-   * @param {Object} from - The FROM clause of the CQN statement.
+   * @param {object} search - The search expression which shall be applied to the searchable columns on the query source.
+   * @param {object} from - The FROM clause of the CQN statement.
    *
    * @returns {(Object|Array|undefined)} - If the target of the query contains searchable elements, the function returns an array that represents the WHERE clause.
    *     If the SELECT query already contains a WHERE clause, this array includes the existing clause and appends an AND condition with the new 'contains' clause.
@@ -293,6 +294,10 @@ function cqn4sql(originalQuery, model = cds.context?.model || cds.model) {
     }
   }
 
+  function isCalculatedOnRead(def) {
+    return def?.value && !def.value.stored
+  }
+
   /**
    * Walks over a list of columns (ref's, xpr, subqueries, val), applies flattening on structured types and expands wildcards.
    *
@@ -304,7 +309,10 @@ function cqn4sql(originalQuery, model = cds.context?.model || cds.model) {
     for (let i = 0; i < columns.length; i++) {
       const col = columns[i]
 
-      if (col.expand) {
+      if (isCalculatedOnRead(col.$refLinks?.[col.$refLinks.length - 1].definition)) {
+        const calcElement = resolveCalculatedElement(col)
+        transformedColumns.push(calcElement)
+      } else if (col.expand) {
         if (col.ref?.length > 1 && col.ref[0] === '$self' && !col.$refLinks[0].definition.kind) {
           const dollarSelfReplacement = calculateDollarSelfColumn(col)
           transformedColumns.push(...getTransformedColumns([dollarSelfReplacement]))
@@ -433,6 +441,30 @@ function cqn4sql(originalQuery, model = cds.context?.model || cds.model) {
     }
   }
 
+  function resolveCalculatedElement(column, omitAlias = false, baseLink = null) {
+    let value
+
+    if (column.$refLinks) {
+      const { $refLinks } = column
+      value = $refLinks[$refLinks.length - 1].definition.value
+      baseLink = [...column.$refLinks].reverse().find(link => link.definition.isAssociation) || baseLink
+    } else {
+      value = column.value
+    }
+    const { ref, val, xpr, func } = value
+
+    let res
+    if (ref) {
+      res = getTransformedTokenStream([value], baseLink)[0]
+    } else if (xpr) {
+      res = { xpr: getTransformedTokenStream(value.xpr, baseLink) }
+    } else if (val) {
+      res = { val }
+    } else if (func) res = { args: getTransformedTokenStream(value.args), func: value.func }
+    if (!omitAlias) res.as = column.as || column.name || column.flatName
+    return res
+  }
+
   /**
    * This function resolves a `ref` starting with a `$self`.
    * Such a path targets another element of the query by it's implicit, or explicit alias.
@@ -632,7 +664,7 @@ function cqn4sql(originalQuery, model = cds.context?.model || cds.model) {
    *
    * @param {CSN.column} column - The column with the 'expand' property to be transformed into a subquery.
    *
-   * @returns {Object} Returns a subquery correlated with the enclosing query, with added properties `expand:true` and `one:true|false`.
+   * @returns {object} Returns a subquery correlated with the enclosing query, with added properties `expand:true` and `one:true|false`.
    */
   function expandColumn(column) {
     let outerAlias
@@ -726,7 +758,10 @@ function cqn4sql(originalQuery, model = cds.context?.model || cds.model) {
     const res = []
     for (let i = 0; i < columns.length; i++) {
       const col = columns[i]
-      if (col.isJoinRelevant) {
+      if (isCalculatedOnRead(col.$refLinks?.[col.$refLinks.length - 1].definition)) {
+        const calcElement = resolveCalculatedElement(col, true)
+        res.push(calcElement)
+      } else if (col.isJoinRelevant) {
         const tableAlias$refLink = getQuerySourceName(col)
         const transformedColumn = {
           ref: [tableAlias$refLink, getFullName(col.$refLinks[col.$refLinks.length - 1].definition)],
@@ -826,6 +861,8 @@ function cqn4sql(originalQuery, model = cds.context?.model || cds.model) {
       // for wildcard on subquery in from, just reference the elements
       if (tableAlias.SELECT && !element.elements && !element.target) {
         wildcardColumns.push(index ? { ref: [index, k] } : { ref: [k] })
+      } else if (isCalculatedOnRead(element)) {
+        wildcardColumns.push(resolveCalculatedElement(element))
       } else {
         const flatColumns = getFlatColumnsFor(element, { tableAlias: index }, [], { exclude, replace }, true)
         wildcardColumns.push(...flatColumns)
@@ -1157,6 +1194,12 @@ function cqn4sql(originalQuery, model = cds.context?.model || cds.model) {
 
           let result = is_regexp(token?.val) ? token : copy(token) // REVISIT: too expensive! //
           if (token.ref) {
+            const { definition } = token.$refLinks[token.$refLinks.length - 1]
+            if (isCalculatedOnRead(definition)) {
+              const calculatedElement = resolveCalculatedElement(token, true, $baseLink)
+              transformedTokenStream.push(calculatedElement)
+              continue
+            }
             if (token.ref.length > 1 && token.ref[0] === '$self' && !token.$refLinks[0].definition.kind) {
               const dollarSelfReplacement = [calculateDollarSelfColumn(token, true)]
               transformedTokenStream.push(...getTransformedTokenStream(dollarSelfReplacement))
@@ -1472,11 +1515,6 @@ function cqn4sql(originalQuery, model = cds.context?.model || cds.model) {
         each.ref[0] in { $self: true, $projection: true } ? getParentEntity(assoc) : target,
       ),
     )
-
-    function getParentEntity(element) {
-      if (element.kind === 'entity') return element
-      else return getParentEntity(element.parent)
-    }
   }
 
   /**
@@ -1920,6 +1958,11 @@ function getLastStringSegment(str) {
   return index != -1 ? str.substring(index + 1) : str
 }
 
+function getParentEntity(element) {
+  if (element.kind === 'entity') return element
+  else return getParentEntity(element.parent)
+}
+
 /**
  * Assigns the given `element` as non-enumerable property 'element' onto `col`.
  *

package/lib/deep-queries.js

@@ -4,6 +4,17 @@ const { _target_name4 } = require('./SQLService')
 
 const handledDeep = Symbol('handledDeep')
 
+/**
+ * @callback nextCallback
+ * @param {Error|undefined} error
+ * @returns {Promise<unknown>}
+ */
+
+/**
+ * @param {import('@sap/cds/apis/services').Request} req
+ * @param {nextCallback} next
+ * @returns {Promise<number>}
+ */
 async function onDeep(req, next) {
   const { query } = req
   // REVISIT: req.target does not match the query.INSERT target for path insert
@@ -136,11 +147,16 @@ const _calculateExpandColumns = (target, data, expandColumns = [], elementMap =
   }
 }
 
+/**
+ * @param {import('@sap/cds/apis/cqn').Query} query
+ * @param {import('@sap/cds/apis/csn').Definition} target
+ */
 const getExpandForDeep = (query, target) => {
   const from = query.DELETE?.from || query.UPDATE?.entity
   const data = query.UPDATE?.data || null
   const where = query.DELETE?.where || query.UPDATE?.where
 
+  /** @type {import("@sap/cds/apis/ql").SELECT<unknown>} */
   const cqn = SELECT.from(from)
   if (where) cqn.SELECT.where = where
 
@@ -150,6 +166,12 @@ const getExpandForDeep = (query, target) => {
   return cqn
 }
 
+/**
+ * @param {import('@sap/cds/apis/cqn').Query} query
+ * @param {unknown[]} dbData
+ * @param {import('@sap/cds/apis/csn').Definition} target
+ * @returns
+ */
 const getDeepQueries = (query, dbData, target) => {
   let queryData
   if (query.INSERT) {
@@ -174,6 +196,11 @@ const _hasManagedElements = target => {
   return Object.keys(target.elements).filter(elementName => target.elements[elementName]['@cds.on.update']).length > 0
 }
 
+/**
+ * @param {unknown[]} diff
+ * @param {import('@sap/cds/apis/csn').Definition} target
+ * @returns {import('@sap/cds/apis/cqn').Query[]}
+ */
 const _getDeepQueries = (diff, target) => {
   const queries = []
 

package/lib/fill-in-keys.js

@@ -41,6 +41,16 @@ const generateUUIDandPropagateKeys = (target, data, event) => {
   }
 }
 
+/**
+ * @callback nextCallback
+ * @param {Error|undefined} error
+ * @returns {Promise<unknown>}
+ */
+
+/**
+ * @param {import('@sap/cds/apis/services').Request} req
+ * @param {nextCallback} next
+ */
 module.exports = async function fill_in_keys(req, next) {
   // REVISIT dummy handler until we have input processing
   if (!req.target || !this.model || req.target._unresolved) return next()

package/lib/infer/cqn.d.ts

@@ -0,0 +1,45 @@
+import * as cqn from '@sap/cds/apis/cqn'
+import * as csn from '@sap/cds/apis/csn'
+
+type linkedQuery = {
+  target: csn.Definition
+  elements: elements
+}
+export type SELECT = cqn.SELECT & linkedQuery
+export type INSERT = cqn.INSERT & linkedQuery
+export type UPSERT = cqn.UPSERT & linkedQuery
+export type UPDATE = cqn.UPDATE & linkedQuery
+export type STREAM = {
+  STREAM: { into: cqn.name | ref; data: ReadableStream<Buffer>; from: cqn.source; column?: ref; where: predicate }
+} & linkedQuery
+export type DELETE = cqn.DELETE & linkedQuery
+export type CREATE = cqn.CREATE & linkedQuery
+export type DROP = cqn.DROP & linkedQuery
+
+export type Query = SELECT | INSERT | UPSERT | UPDATE | DELETE | CREATE | DROP
+
+export type element = csn.Element & {
+  key?: boolean
+  virtual?: boolean
+  unique?: boolean
+  notNull?: boolean
+}
+export type elements = {
+  [name: string]: element
+}
+
+export type col = cqn.column_expr & { element: element }
+
+export type list = {
+  list: cqn.expr[]
+}
+// Passthrough
+export type source = cqn.source
+export type ref = cqn.ref
+export type val = cqn.val
+export type xpr = cqn.xpr
+export type expr = cqn.expr
+export type func = cqn.function_call
+export type predicate = cqn.predicate
+export type ordering_term = cqn.ordering_term
+export type limit = { rows: val; offset: val }

package/lib/infer/index.js

@@ -4,7 +4,6 @@ const cds = require('@sap/cds/lib')
 
 const JoinTree = require('./join-tree')
 const { pseudos } = require('./pseudos')
-// REVISIT: we should always return cds.linked elements
 const cdsTypes = cds.linked({
   definitions: {
     Timestamp: { type: 'cds.Timestamp' },
@@ -18,11 +17,10 @@ const cdsTypes = cds.linked({
   },
 }).definitions
 for (const each in cdsTypes) cdsTypes[`cds.${each}`] = cdsTypes[each]
-
 /**
- * @param {CQN|CQL} originalQuery
- * @param {CSN} [model]
- * @returns {InferredCQN} = q with .target and .elements
+ * @param {import('@sap/cds/apis/cqn').Query|string} originalQuery
+ * @param {import('@sap/cds/apis/csn').CSN} [model]
+ * @returns {import('./cqn').Query} = q with .target and .elements
  */
 function infer(originalQuery, model = cds.context?.model || cds.model) {
   if (!model) cds.error('Please specify a model')
@@ -40,6 +38,10 @@ function infer(originalQuery, model = cds.context?.model || cds.model) {
     inferred.CREATE ||
     inferred.DROP ||
     inferred.STREAM
+
+  // cache for already processed calculated elements
+  const alreadySeenCalcElements = new Set()
+
   const sources = inferTarget(_.from || _.into || _.entity, {})
   const joinTree = new JoinTree(sources)
   const aliases = Object.keys(sources)
@@ -134,11 +136,11 @@ function infer(originalQuery, model = cds.context?.model || cds.model) {
    * next 'ref' step should be looked up.
    *
    *
-   * @param {Object} arg - The argument object that will be augmented with additional properties.
+   * @param {object} arg - The argument object that will be augmented with additional properties.
    *                        It must contain a 'ref' property, which is an array representing the steps to be processed.
    *                        Optionally, it can also contain an 'xpr' property, which is also processed recursively.
    *
-   * @param {Object} $baseLink - Optional parameter. It represents the environment in which the first 'ref' step should be
+   * @param {object} $baseLink - Optional parameter. It represents the environment in which the first 'ref' step should be
    *                             resolved. It's needed for infix filter / expand columns. It must contain a 'definition'
    *                             property, which is an object representing the base environment.
    *
@@ -177,7 +179,7 @@ function infer(originalQuery, model = cds.context?.model || cds.model) {
             if (!expandOrExists && nextStep && !(nextStep in e.foreignKeys))
               throw new Error(`Only foreign keys of "${e.name}" can be accessed in infix filter`)
           }
-          arg.$refLinks.push({ definition: e, target: e._target || e })
+          arg.$refLinks.push({ definition: e, target: definition })
           // filter paths are flattened
           // REVISIT: too much augmentation -> better remove flatName..
           Object.defineProperty(arg, 'flatName', { value: ref.join('_'), writable: true })
@@ -188,7 +190,7 @@ function infer(originalQuery, model = cds.context?.model || cds.model) {
         }
       } else {
         const recent = arg.$refLinks[i - 1]
-        const { elements } = recent.target
+        const { elements } = recent.definition._target || recent.definition
         const e = elements[id]
         if (!e) throw new Error(`"${id}" not found in the elements of "${arg.$refLinks[i - 1].definition.name}"`)
         arg.$refLinks.push({ definition: e, target: e._target || e })
@@ -216,6 +218,11 @@ function infer(originalQuery, model = cds.context?.model || cds.model) {
         } else throw new Error('A filter can only be provided when navigating along associations')
       }
     })
+    const { definition, target } = arg.$refLinks[arg.$refLinks.length - 1]
+    if (definition.value) {
+      // nested calculated element
+      attachRefLinksToArg(definition.value, { definition: definition.parent, target }, true)
+    }
   }
 
   /**
@@ -227,7 +234,7 @@ function infer(originalQuery, model = cds.context?.model || cds.model) {
    * Each entry in the `$combinedElements` dictionary maps from the element name
    * to an array of objects containing the index and table alias where the element can be found.
    *
-   * @returns {Object} The `$combinedElements` dictionary, which maps element names to an array of objects
+   * @returns {object} The `$combinedElements` dictionary, which maps element names to an array of objects
    *                   containing the index and table alias where the element can be found.
    */
   function inferCombinedElements() {
@@ -264,9 +271,9 @@ function infer(originalQuery, model = cds.context?.model || cds.model) {
    * Also walks over other `ref`s in the query, validates them, and attaches `$refLinks`.
    * This includes handling `where`, infix filters within column `refs`, or other `csn` paths.
    *
-   * @param {Object} $combinedElements The `$combinedElements` dictionary of the query, which maps element names
+   * @param {object} $combinedElements The `$combinedElements` dictionary of the query, which maps element names
    *                                   to an array of objects containing the index and table alias where the element can be found.
-   * @returns {Object} The inferred `elements` dictionary of the query, which maps element names to their corresponding definitions.
+   * @returns {object} The inferred `elements` dictionary of the query, which maps element names to their corresponding definitions.
    */
   function inferQueryElements($combinedElements) {
     let queryElements = {}
@@ -444,7 +451,7 @@ function infer(originalQuery, model = cds.context?.model || cds.model) {
      */
 
     function inferQueryElement(column, insertIntoQueryElements = true, $baseLink = null, context) {
-      const { inExists, inExpr, inNestedProjection } = context || {}
+      const { inExists, inExpr, inNestedProjection, inCalcElement } = context || {}
       if (column.param) return // parameter references are only resolved into values on execution e.g. :val, :1 or ?
       if (column.args) column.args.forEach(arg => inferQueryElement(arg, false, $baseLink, context)) // e.g. function in expression
       if (column.list) column.list.forEach(arg => inferQueryElement(arg, false, $baseLink, context))
@@ -486,7 +493,7 @@ function infer(originalQuery, model = cds.context?.model || cds.model) {
             const elements = definition.elements || definition._target?.elements
             if (elements && id in elements) {
               const element = elements[id]
-              if (!inExists && !inNestedProjection && element.target) {
+              if (!inExists && !inNestedProjection && !inCalcElement && element.target) {
                 // only fk access in infix filter
                 const nextStep = column.ref[1]?.id || column.ref[1]
                 // no unmanaged assoc in infix filter path
@@ -500,7 +507,8 @@ function infer(originalQuery, model = cds.context?.model || cds.model) {
                 if (nextStep && !(nextStep in element.foreignKeys))
                   throw new Error(`Only foreign keys of "${element.name}" can be accessed in infix filter`)
               }
-              column.$refLinks.push({ definition: elements[id], target })
+              const resolvableIn = definition.target ? definition._target : target
+              column.$refLinks.push({ definition: elements[id], target: resolvableIn })
             } else {
               stepNotFoundInPredecessor(id, definition.name)
             }
@@ -535,14 +543,15 @@ function infer(originalQuery, model = cds.context?.model || cds.model) {
             )
           }
 
+          const target = definition._target || column.$refLinks[i - 1].target
           if (element) {
-            const $refLink = { definition: elements[id], target: column.$refLinks[i - 1].target }
+            const $refLink = { definition: elements[id], target }
             column.$refLinks.push($refLink)
           } else if (firstStepIsSelf) {
             stepNotFoundInColumnList(id)
           } else if (column.ref[0] === '$user' && pseudoPath) {
             // `$user.some.unknown.element` -> no error
-            column.$refLinks.push({ definition: {}, target: column.$refLinks[i - 1].target })
+            column.$refLinks.push({ definition: {}, target })
           } else if (id === '$dummy') {
             // `some.known.element.$dummy` -> no error; used by cds.ql to simulate joins
             column.$refLinks.push({ definition: { name: '$dummy', parent: column.$refLinks[i - 1].target } })
@@ -627,7 +636,8 @@ function infer(originalQuery, model = cds.context?.model || cds.model) {
               }
               if (queryElements[elementName] !== undefined)
                 throw new Error(`Duplicate definition of element “${elementName}”`)
-              queryElements[elementName] = getCopyWithAnnos(column, leafArt)
+              const element = getCopyWithAnnos(column, leafArt)
+              queryElements[elementName] = element
             }
           }
         }
@@ -644,19 +654,27 @@ function infer(originalQuery, model = cds.context?.model || cds.model) {
           return
         }
       }
-      const virtual = (column.$refLinks[column.$refLinks.length - 1].definition.virtual || !isPersisted) && !inExpr
+      const leafArt = column.$refLinks[column.$refLinks.length - 1].definition
+      const virtual = (leafArt.virtual || !isPersisted) && !inExpr
       // check if we need to merge the column `ref` into the join tree of the query
-      if (!inExists && !virtual && isColumnJoinRelevant(column, firstStepIsSelf)) {
+      if (!inExists && !virtual && !inCalcElement && isColumnJoinRelevant(column, firstStepIsSelf)) {
+        if (originalQuery.UPDATE)
+          throw cds.error(
+            'Path expressions for UPDATE statements are not supported. Use “where exists” with infix filters instead.',
+          )
         Object.defineProperty(column, 'isJoinRelevant', { value: true })
-        joinTree.mergeColumn(column)
+        joinTree.mergeColumn(column, $baseLink)
+      }
+      if (leafArt.value && !leafArt.value.stored) {
+        resolveCalculatedElement(leafArt, column)
       }
 
       /**
        * Resolves and processes the inline attribute of a column in a database query.
        *
-       * @param {Object} col - The column object with properties: `inline` and `$refLinks`.
+       * @param {object} col - The column object with properties: `inline` and `$refLinks`.
        * @param {string} [namePrefix=col.as || col.flatName] - Prefix for naming new columns. Defaults to `col.as` or `col.flatName`.
-       * @returns {Object} - An object with resolved and processed inline column definitions.
+       * @returns {object} - An object with resolved and processed inline column definitions.
        *
        * Procedure:
        * 1. Iterate through `inline` array. For each `inlineCol`:
@@ -710,8 +728,8 @@ function infer(originalQuery, model = cds.context?.model || cds.model) {
       /**
        * Resolves a query column which has an `expand` property.
        *
-       * @param {Object} col - The column object with properties: `expand` and `$refLinks`.
-       * @returns {Object} - A `cds.struct` object with expanded column definitions.
+       * @param {object} col - The column object with properties: `expand` and `$refLinks`.
+       * @returns {object} - A `cds.struct` object with expanded column definitions.
        *
        * Procedure:
        * - if `$leafLink` is an association, constructs an `expandSubquery` and infers a new query structure.
@@ -777,6 +795,58 @@ function infer(originalQuery, model = cds.context?.model || cds.model) {
         throw new Error(err)
       }
     }
+    function resolveCalculatedElement(calcElement) {
+      if (alreadySeenCalcElements.has(calcElement)) return
+      else alreadySeenCalcElements.add(calcElement)
+      const { ref, xpr, func } = calcElement.value
+      if (ref || xpr) {
+        attachRefLinksToArg(calcElement.value, { definition: calcElement.parent, target: calcElement.parent }, true)
+        // column is now fully linked, now we need to find out if we need to merge it into the join tree
+        // for that, we calculate all paths from a calc element and merge them into the join tree
+        mergePathsIntoJoinTree(calcElement.value)
+      }
+      if (func) calcElement.value.args?.forEach(arg => inferQueryElement(arg, false)) // {func}.args are optional
+      function mergePathsIntoJoinTree(e, basePath = null) {
+        basePath = basePath || { $refLinks: [], ref: [] }
+        if (e.ref) {
+          e.$refLinks.forEach((link, i) => {
+            const { definition } = link
+            if (!definition.value) {
+              basePath.$refLinks.push(link)
+              basePath.ref.push(e.ref[i])
+            }
+          })
+          const leafOfCalculatedElementRef = e.$refLinks[e.$refLinks.length - 1].definition
+          if (leafOfCalculatedElementRef.value) mergePathsIntoJoinTree(leafOfCalculatedElementRef.value, basePath)
+
+          mergePathIfNecessary(basePath, e)
+        } else if (e.xpr) {
+          e.xpr.forEach(step => {
+            if (step.ref) {
+              const subPath = { $refLinks: [...basePath.$refLinks], ref: [...basePath.ref] }
+              step.$refLinks.forEach((link, i) => {
+                const { definition } = link
+                if (definition.value) {
+                  mergePathsIntoJoinTree(definition.value)
+                } else {
+                  subPath.$refLinks.push(link)
+                  subPath.ref.push(step.ref[i])
+                }
+              })
+              mergePathIfNecessary(subPath, step)
+            }
+          })
+        }
+
+        function mergePathIfNecessary(p, step) {
+          const calcElementIsJoinRelevant = isColumnJoinRelevant(p)
+          if (calcElementIsJoinRelevant) {
+            if (!calcElement.value.isColumnJoinRelevant) Object.defineProperty(step, 'isJoinRelevant', { value: true })
+            joinTree.mergeColumn(p)
+          }
+        }
+      }
+    }
 
     /**
      * Checks whether or not the `ref` of the given column is join relevant.
@@ -828,15 +898,20 @@ function infer(originalQuery, model = cds.context?.model || cds.model) {
      * if there is not already an element with the same name present.
      */
     function inferElementsFromWildCard() {
+      const exclude = _.excluding ? x => _.excluding.includes(x) : () => false
+
       if (Object.keys(queryElements).length === 0 && aliases.length === 1) {
         // only one query source and no overwritten columns
         Object.entries(sources[aliases[0]].elements).forEach(([name, element]) => {
-          if (element.type !== 'cds.LargeBinary') queryElements[name] = element
+          if (!exclude(name) && element.type !== 'cds.LargeBinary') queryElements[name] = element
+          if (element.value) {
+            // we might have join relevant calculated elements
+            resolveCalculatedElement(element)
+          }
         })
         return
       }
 
-      const exclude = _.excluding ? x => _.excluding.includes(x) : () => false
       const ambiguousElements = {}
       Object.entries($combinedElements).forEach(([name, tableAliases]) => {
         if (Object.keys(tableAliases).length > 1) {