@cap-js/db-service 2.3.0 → 2.4.0

package/CHANGELOG.md

@@ -4,6 +4,24 @@
 - The format is based on [Keep a Changelog](http://keepachangelog.com/).
 - This project adheres to [Semantic Versioning](http://semver.org/).
 
+## [2.4.0](https://github.com/cap-js/cds-dbs/compare/db-service-v2.3.0...db-service-v2.4.0) (2025-08-27)
+
+
+### Added
+
+* **`tuple expansion`:** allow structs with exactly one element/fk in comparison ([#1291](https://github.com/cap-js/cds-dbs/issues/1291)) ([75ea826](https://github.com/cap-js/cds-dbs/commit/75ea82694faeafcaf78df9d4b0bbce37b4f65b63))
+* cds.db.foreach uses real object mode streaming ([#1318](https://github.com/cap-js/cds-dbs/issues/1318)) ([cd28b53](https://github.com/cap-js/cds-dbs/commit/cd28b53966dbe28ad1d5ef3827767e78742e0fbd))
+
+
+### Fixed
+
+* **`assoc2join`:** target side access detection ([#1282](https://github.com/cap-js/cds-dbs/issues/1282)) ([6f9befa](https://github.com/cap-js/cds-dbs/commit/6f9befa24a06bcc629fe853aa66290613734c3ef))
+* **`cqn4sql`:** only consider `own` property `[@cds](https://github.com/cds).persistence.skip` ([#1324](https://github.com/cap-js/cds-dbs/issues/1324)) ([bd1f52f](https://github.com/cap-js/cds-dbs/commit/bd1f52f67fb4709dce3a27fea8856cb9b875da6b))
+* **`exists`:** do not loose custom where ([#1322](https://github.com/cap-js/cds-dbs/issues/1322)) ([644918c](https://github.com/cap-js/cds-dbs/commit/644918c56d9d939f43f4a0346f42e16722bd6fe9))
+* arithmetic operators can only be used with scalar operands ([#1307](https://github.com/cap-js/cds-dbs/issues/1307)) ([d58d335](https://github.com/cap-js/cds-dbs/commit/d58d33539e22f818d18240bb86ba596fc6fe21d1))
+* detect path expression inside nested xpr after `exists` ([#1292](https://github.com/cap-js/cds-dbs/issues/1292)) ([852d915](https://github.com/cap-js/cds-dbs/commit/852d9155d5bb09a56a6c152259c8282662ceb29d)), closes [#1225](https://github.com/cap-js/cds-dbs/issues/1225)
+* reject comparison of two empty structures ([#1306](https://github.com/cap-js/cds-dbs/issues/1306)) ([d97304d](https://github.com/cap-js/cds-dbs/commit/d97304d95c7f629afe75aba57192277b7124eb3e))
+
 ## [2.3.0](https://github.com/cap-js/cds-dbs/compare/db-service-v2.2.0...db-service-v2.3.0) (2025-07-28)
 
 

package/lib/SQLService.js

@@ -355,6 +355,15 @@ class SQLService extends DatabaseService {
     return count
   }
 
+  /**
+   * Streaming API variant of .run().
+   * @param {import('@sap/cds/apis/cqn').SELECT} query - SELECT CQN
+   * @param {function} callback - Function to be invoked for each row
+   */
+  foreach (query, callback) {
+    return query.foreach(callback)
+  }
+
   /**
    * Helper class for results of INSERTs.
    * Subclasses may override this.

package/lib/cqn4sql.js

@@ -12,6 +12,7 @@ const {
   getImplicitAlias,
   defineProperty,
   getModelUtils,
+  hasOwnSkip,
 } = require('./utils')
 
 /**
@@ -20,14 +21,14 @@ const {
  */
 const eqOps = [['is'], ['='] /* ['=='] */]
 /**
- * For operators of <notEqOps>, do the same but use or instead of and.
- * This ensures that not struct == <value> is the same as struct != <value>.
+ * For operators of <notEqOps>, do the same but use `or` instead of `and`.
+ * This ensures that `not struct == <value>` is the same as `struct != <value>`.
  */
 const notEqOps = [['is', 'not'], ['<>'], ['!=']]
 /**
  * not supported in comparison w/ struct because of unclear semantics
  */
-const notSupportedOps = [['>'], ['<'], ['>='], ['<=']]
+const notSupportedOps = [['>'], ['<'], ['>='], ['<='], ['*'], ['+'], ['-'], ['/']]
 
 const allOps = eqOps.concat(eqOps).concat(notEqOps).concat(notSupportedOps)
 
@@ -467,7 +468,7 @@ function cqn4sql(originalQuery, model) {
       const refNavigation = col.ref.slice(col.$refLinks[0].definition.kind !== 'element' ? 1 : 0).join('_')
       if (!columnAlias && col.flatName && col.flatName !== refNavigation) columnAlias = refNavigation
 
-      if (col.$refLinks.some(link => getDefinition(link.definition.target)?.['@cds.persistence.skip'] === true)) return
+      if (col.$refLinks.some(link => hasOwnSkip(getDefinition(link.definition.target)))) return
 
       const flatColumns = getFlatColumnsFor(col, { baseName, columnAlias, tableAlias })
       flatColumns.forEach(flatColumn => {
@@ -966,7 +967,7 @@ function cqn4sql(originalQuery, model) {
       } else if (pseudos.elements[col.ref?.[0]]) {
         res.push({ ...col })
       } else if (col.ref) {
-        if (col.$refLinks.some(link => getDefinition(link.definition.target)?.['@cds.persistence.skip'] === true))
+        if (col.$refLinks.some(link => hasOwnSkip(getDefinition(link.definition.target))))
           continue
         if (col.ref.length > 1 && col.ref[0] === '$self' && !col.$refLinks[0].definition.kind) {
           const dollarSelfReplacement = calculateDollarSelfColumn(col)
@@ -1189,7 +1190,7 @@ function cqn4sql(originalQuery, model) {
     let { baseName, columnAlias = column.as, tableAlias } = names
     const { exclude, replace } = excludeAndReplace || {}
     const { $refLinks, flatName, isJoinRelevant } = column
-    let leafAssoc
+    let firstNonJoinRelevantAssoc, stepAfterAssoc
     let element = $refLinks ? $refLinks[$refLinks.length - 1].definition : column
     if (isWildcard && element.type === 'cds.LargeBinary') return []
     if (element.on && !element.keys)
@@ -1197,14 +1198,23 @@ function cqn4sql(originalQuery, model) {
     else if (element.virtual === true) return []
     else if (!isJoinRelevant && flatName) baseName = flatName
     else if (isJoinRelevant) {
-      const leaf = column.$refLinks.at(-1)
-      leafAssoc = [...column.$refLinks].reverse().find(link => link.definition.isAssociation)
-      let elements = leafAssoc.definition.elements || leafAssoc.definition.foreignKeys
-      if (elements && leaf.definition.name in elements) {
-        element = leafAssoc.definition
-        baseName = getFullName(leafAssoc.definition)
+      const leafAssocIndex = column.$refLinks.findIndex(link => link.definition.isAssociation && link.onlyForeignKeyAccess)
+      firstNonJoinRelevantAssoc = column.$refLinks[leafAssocIndex] || [...column.$refLinks].reverse().find(link => link.definition.isAssociation)
+      stepAfterAssoc = column.$refLinks.at(leafAssocIndex + 1) || column.$refLinks.at(-1)
+      let elements = firstNonJoinRelevantAssoc.definition.elements || firstNonJoinRelevantAssoc.definition.foreignKeys
+      if (elements && stepAfterAssoc.definition.name in elements) {
+        element = firstNonJoinRelevantAssoc.definition
+        baseName = getFullName(firstNonJoinRelevantAssoc.definition)
         columnAlias = column.as || column.ref.slice(0, -1).map(idOnly).join('_')
       } else baseName = getFullName(column.$refLinks[column.$refLinks.length - 1].definition)
+
+      if(column.element && !isAssocOrStruct(column.element)) {
+        columnAlias = column.as || leafAssocIndex === -1 ? columnAlias : column.ref.slice(leafAssocIndex - 1).map(idOnly).join('_')
+        const res = { ref: [tableAlias, calculateElementName(column)], as: columnAlias }
+        setElementOnColumns(res, element)
+        return [res]
+      }
+
     } else if (!baseName && structsAreUnfoldedAlready) {
       baseName = element.name // name is already fully constructed
     } else {
@@ -1245,11 +1255,11 @@ function cqn4sql(originalQuery, model) {
         const flattenThisForeignKey =
           !$refLinks || // the association is passed as element, not as ref --> flatten full foreign key
           element === $refLinks.at(-1).definition || // the association is the leaf of the ref --> flatten full foreign key
-          keyElement === $refLinks.at(-1).definition // the foreign key is the leaf of the ref --> only flatten this specific foreign key
+          keyElement === stepAfterAssoc.definition // the foreign key is the leaf of the ref --> only flatten this specific foreign key
         if (flattenThisForeignKey) {
           const fkElement = getElementForRef(k.ref, getDefinition(element.target))
           let fkBaseName
-          if (!leafAssoc || leafAssoc.onlyForeignKeyAccess) fkBaseName = `${baseName}_${k.as || k.ref.at(-1)}`
+          if (!firstNonJoinRelevantAssoc || firstNonJoinRelevantAssoc.onlyForeignKeyAccess) fkBaseName = `${baseName}_${k.as || k.ref.at(-1)}`
           // e.g. if foreign key is accessed via infix filter - use join alias to access key in target
           else fkBaseName = k.ref.at(-1)
           const fkPath = [...csnPath, k.ref.at(-1)]
@@ -1462,6 +1472,7 @@ function cqn4sql(originalQuery, model) {
             flatKeys.push(...getFlatColumnsFor(v, { tableAlias: $baseLink.alias }))
           }
         }
+        // TODO: improve error message, the current message is generally not true (only for OData shortcut notation)
         if (flatKeys.length > 1)
           throw new Error('Filters can only be applied to managed associations which result in a single foreign key')
         flatKeys.forEach(c => keyValComparisons.push([...[c, '=', token]]))
@@ -1474,35 +1485,38 @@ function cqn4sql(originalQuery, model) {
         transformedTokenStream.push({ ...token })
       } else {
         // expand `struct = null | struct2`
-        const definition = token.$refLinks?.at(-1).definition
         const next = tokenStream[i + 1]
-        if (allOps.some(([firstOp]) => firstOp === next) && (definition?.elements || definition?.keys)) {
+        let indexRhs = i + 2
+        let rhs = tokenStream[indexRhs] // either another operator (i.e. `not like` et. al.) or the operand, i.e. the val | null
+        const lhsDef = token.$refLinks?.at(-1).definition
+        let rhsDef = rhs?.$refLinks?.at(-1)?.definition
+        if (
+          allOps.some(([firstOp]) => firstOp === next) &&
+          (lhsDef?.elements || lhsDef?.keys || rhsDef?.elements || rhsDef?.keys)
+        ) {
           const ops = [next]
-          let indexRhs = i + 2
-          let rhs = tokenStream[i + 2] // either another operator (i.e. `not like` et. al.) or the operand, i.e. the val | null
           if (allOps.some(([, secondOp]) => secondOp === rhs)) {
             ops.push(rhs)
             rhs = tokenStream[i + 3]
             indexRhs += 1
+            rhsDef = rhs?.$refLinks?.at(-1)?.definition
           }
-          if (
-            isAssocOrStruct(rhs.$refLinks?.[rhs.$refLinks.length - 1].definition) ||
-            rhs.val !== undefined ||
-            /* unary operator `is null` parsed as string */
-            rhs === 'null'
-          ) {
-            if (notSupportedOps.some(([firstOp]) => firstOp === next))
-              throw new Error(`The operator "${next}" is not supported for structure comparison`)
-            const newTokens = expandComparison(token, ops, rhs, $baseLink)
-            const needXpr = Boolean(tokenStream[i - 1] || tokenStream[indexRhs + 1])
-            transformedTokenStream.push(...(needXpr ? [asXpr(newTokens)] : newTokens))
-            i = indexRhs // jump to next relevant index
-          }
+
+          if (notSupportedOps.some(([firstOp]) => firstOp === next))
+            throw new Error(`The operator "${next}" can only be used with scalar operands`)
+
+          const newTokens = expandComparison(token, ops, rhs, $baseLink)
+          if(newTokens.length === 0)
+            throw new Error(`Can't compare two empty structures`)
+
+          const needXpr = Boolean(tokenStream[i - 1] || tokenStream[indexRhs + 1])
+          transformedTokenStream.push(...(needXpr ? [asXpr(newTokens)] : newTokens))
+          i = indexRhs // jump to next relevant index
         } else {
           // reject associations in expression, except if we are in an infix filter -> $baseLink is set
           assertNoStructInXpr(token, $baseLink)
           // reject virtual elements in expressions as they will lead to a sql error down the line
-          if (definition?.virtual) throw new Error(`Virtual elements are not allowed in expressions`)
+          if (lhsDef?.virtual) throw new Error(`Virtual elements are not allowed in expressions`)
 
           let result = is_regexp(token?.val) ? token : copy(token) // REVISIT: too expensive! //
           if (token.ref) {
@@ -1528,7 +1542,7 @@ function cqn4sql(originalQuery, model) {
               token.isJoinRelevant && [...token.$refLinks].reverse().find(l => l.definition.isAssociation)
             const tableAlias = getTableAlias(token, (!lastAssoc?.onlyForeignKeyAccess && lastAssoc) || $baseLink)
             if ((!$baseLink || lastAssoc) && token.isJoinRelevant) {
-              let name = calculateElementName(token, getFullName)
+              let name = calculateElementName(token)
               result.ref = [tableAlias, name]
             } else if (tableAlias) {
               result.ref = [tableAlias, token.flatName]
@@ -1557,9 +1571,9 @@ function cqn4sql(originalQuery, model) {
   /**
    * Expand the given definition and compare all leafs to `val`.
    *
-   * @param {object} token with $refLinks
+   * @param {object} lhs with $refLinks
    * @param {string} operator one of allOps
-   * @param {object} value either `null` or a column (with `ref` and `$refLinks`)
+   * @param {object} rhs either `null` or a column (with `ref` and `$refLinks`)
    * @param {object} $baseLink optional base `$refLink`, e.g. for infix filters of scoped queries.
    *                           In the following example, we must pass `bookshop:Reproduce` as $baseLink for `author`:
    *
@@ -1567,26 +1581,21 @@ function cqn4sql(originalQuery, model) {
    *                                                            ^^^^^^
    * @returns {array}
    */
-  function expandComparison(token, operator, value, $baseLink = null) {
-    const { definition } = token.$refLinks[token.$refLinks.length - 1]
-    let flatRhs
+  function expandComparison(lhs, operator, rhs, $baseLink = null) {
+    const { definition: lhsDef, val: lhsVal } = lhs.val ? lhs : lhs.$refLinks.at(-1)
+    const { definition: rhsDef, val: rhsVal } = rhs.val ? rhs : rhs.$refLinks?.at(-1) || {}
     const result = []
-    if (value.$refLinks) {
-      // structural comparison
-      flatRhs = flattenWithBaseName(value)
-    }
-
-    if (flatRhs) {
-      const flatLhs = flattenWithBaseName(token)
-      // make sure we can compare both structures
-      if (flatRhs.length !== flatLhs.length) {
-        throw new Error(
-          `Can't compare "${definition.name}" with "${
-            value.$refLinks[value.$refLinks.length - 1].definition.name
-          }": the operands must have the same structure`,
-        )
-      }
-
+    if (lhsDef && rhsDef) {
+      // both must be structured
+      const lhsIsStructured = isAssocOrStruct(lhsDef)
+      const rhsIsStructured = isAssocOrStruct(rhsDef)
+      if (!lhsIsStructured)
+        throw new Error(`Can't compare structure “${rhs.ref.map(idOnly).join('.')}” with non-structure “${lhs.ref.map(idOnly).join('.')}”`)
+      if (!rhsIsStructured)
+        throw new Error(`Can't compare structure “${lhs.ref.map(idOnly).join('.')}” with non-structure “${rhs.ref.map(idOnly).join('.')}”`)
+
+      const flatLhs = flattenWithBaseName(lhs)
+      const flatRhs = flattenWithBaseName(rhs)
       const boolOp = notEqOps.some(([f, s]) => operator[0] === f && operator[1] === s) ? 'or' : 'and'
       while (flatLhs.length > 0) {
         // retrieve and remove one flat element from LHS and search for it in RHS (remove it there too)
@@ -1598,27 +1607,47 @@ function cqn4sql(originalQuery, model) {
         })
         // not found in rhs --> exit
         if (indexOfElementOnRhs === -1) {
-          const lhsPath = token.ref.join('.')
-          const rhsPath = value.ref.join('.')
+          const lhsPath = lhs.ref.map(idOnly).join('.')
+          const rhsPath = rhs.ref.map(idOnly).join('.')
           throw new Error(`Can't compare "${lhsPath}" with "${rhsPath}": the operands must have the same structure`)
         }
-        const rhs = flatRhs.splice(indexOfElementOnRhs, 1)[0] // remove the element also from RHS
-        result.push({ ref }, ...operator, rhs)
+        const cleansedRhs = flatRhs.splice(indexOfElementOnRhs, 1)[0] // remove the element also from RHS
+        result.push({ ref }, ...operator, cleansedRhs)
         if (flatLhs.length > 0) result.push(boolOp)
       }
-    } else {
+    } else if (lhsDef && (rhsVal || rhs === 'null' || rhs.val === null)) {
       // compare with value
-      const flatLhs = flattenWithBaseName(token)
-      if (flatLhs.length > 1 && value.val !== null && value !== 'null')
-        throw new Error(`Can't compare structure "${token.ref.join('.')}" with value "${value.val}"`)
+      const flatLhs = flattenWithBaseName(lhs)
+      if (flatLhs.length !== 1 && rhsVal && rhs !== 'null')
+        canOnlyCompareToExactlyOneLeaf(lhsDef, lhs.ref, rhsVal)
+
       const boolOp = notEqOps.some(([f, s]) => operator[0] === f && operator[1] === s) ? 'or' : 'and'
       flatLhs.forEach((column, i) => {
-        result.push(column, ...operator, value)
+        result.push(column, ...operator, rhs)
         if (flatLhs[i + 1]) result.push(boolOp)
       })
+    } else if (lhsVal && rhsDef) {
+      const flatRhs = flattenWithBaseName(rhs)
+      // comparing a struct to a value is ok if structure has exactly one leaf
+      if (flatRhs.length !== 1 && lhsVal)
+        canOnlyCompareToExactlyOneLeaf(rhsDef, rhs.ref, lhsVal)
+
+      const boolOp = notEqOps.some(([f, s]) => operator[0] === f && operator[1] === s) ? 'or' : 'and'
+      flatRhs.forEach((column, i) => {
+        result.push(lhs, ...operator, column)
+        if (flatRhs[i + 1]) result.push(boolOp)
+      })
     }
     return result
 
+    function canOnlyCompareToExactlyOneLeaf(struct, structRef, val) {
+      const what = struct.isAssociation ? 'association' : 'structure'
+      const postfix = struct.isAssociation ? 'associations with one foreign key' : 'structures with one sub-element'
+      throw new Error(
+        `Can't compare ${what} "${structRef.map(idOnly).join('.')}" to value "${val}"; only possible for ${postfix}`
+      )
+    }
+
     function flattenWithBaseName(def) {
       if (!def.$refLinks) return def
       const leaf = def.$refLinks[def.$refLinks.length - 1]
@@ -2127,7 +2156,7 @@ function cqn4sql(originalQuery, model) {
    * @param {boolean} inWhere whether or not the path is part of the queries where clause
    *                    -> if it is, target and source side are flipped in the where exists subquery
    * @param {object} queryModifier optional query modifiers: group by, order by, limit, offset
-   * 
+   *
    * @returns {CQN.SELECT}
    */
   function getWhereExistsSubquery(current, next, customWhere = null, inWhere = false, queryModifier = null) {
@@ -2165,26 +2194,29 @@ function cqn4sql(originalQuery, model) {
       where: on,
     }
     // this requires sub-sequent transformation of the subquery
-    if (next.pathExpressionInsideFilter || (queryModifier && ['orderBy', 'groupBy', 'having', 'limit', 'offset'].some(key => key in queryModifier))) {
-      SELECT.where = next.pathExpressionInsideFilter ? customWhere : [];
-      if (queryModifier) assignQueryModifiers(SELECT, queryModifier);
-
-      const transformedExists = transformSubquery({ SELECT });
+    if (
+      next.pathExpressionInsideFilter ||
+      (queryModifier && ['orderBy', 'groupBy', 'having', 'limit', 'offset'].some(key => key in queryModifier))
+    ) {
+      SELECT.where = customWhere || []
+      if (queryModifier) assignQueryModifiers(SELECT, queryModifier)
+
+      const transformedExists = transformSubquery({ SELECT })
       if (transformedExists.SELECT.where?.length) {
-      const wrappedWhere = hasLogicalOr(transformedExists.SELECT.where)
-        ? [asXpr(transformedExists.SELECT.where)]
-        : transformedExists.SELECT.where;
+        const wrappedWhere = hasLogicalOr(transformedExists.SELECT.where)
+          ? [asXpr(transformedExists.SELECT.where)]
+          : transformedExists.SELECT.where
 
-      on.push('and', ...wrappedWhere);
+        on.push('and', ...wrappedWhere)
       }
-      transformedExists.SELECT.where = on;
-      return transformedExists.SELECT;
+      transformedExists.SELECT.where = on
+      return transformedExists.SELECT
     }
 
     if (customWhere) {
-      const filter = getTransformedTokenStream(customWhere, next);
-      const wrappedFilter = hasLogicalOr(filter) ? [asXpr(filter)] : filter;
-      on.push('and', ...wrappedFilter);
+      const filter = getTransformedTokenStream(customWhere, next)
+      const wrappedFilter = hasLogicalOr(filter) ? [asXpr(filter)] : filter
+      on.push('and', ...wrappedFilter)
     }
     return SELECT
   }
@@ -2349,7 +2381,6 @@ function getParentEntity(element) {
   else return getParentEntity(element.parent)
 }
 
-
 function asXpr(thing) {
   return { xpr: thing }
 }

package/lib/infer/index.js

@@ -4,7 +4,7 @@ const cds = require('@sap/cds')
 
 const JoinTree = require('./join-tree')
 const { pseudos } = require('./pseudos')
-const { isCalculatedOnRead, getImplicitAlias, getModelUtils, defineProperty } = require('../utils')
+const { isCalculatedOnRead, getImplicitAlias, getModelUtils, defineProperty, hasOwnSkip } = require('../utils')
 const cdsTypes = cds.linked({
   definitions: {
     Timestamp: { type: 'cds.Timestamp' },
@@ -404,7 +404,7 @@ function infer(originalQuery, model) {
     if (arg.list) arg.list.forEach(arg => inferArg(arg, null, $baseLink, context))
     if (arg.xpr)
       arg.xpr.forEach((token, i) =>
-        inferArg(token, queryElements, $baseLink, { ...context, inXpr: true, inExists: arg.xpr[i - 1] === 'exists' }),
+        inferArg(token, queryElements, $baseLink, { ...context, inXpr: true, inExists: inExists || arg.xpr[i - 1] === 'exists' }),
       ) // e.g. function in expression
 
     if (!arg.ref) {
@@ -587,7 +587,7 @@ function infer(originalQuery, model) {
       }
 
       arg.$refLinks[i].alias = !arg.ref[i + 1] && arg.as ? arg.as : id.split('.').pop()
-      if (getDefinition(arg.$refLinks[i].definition.target)?.['@cds.persistence.skip'] === true) isPersisted = false
+      if (hasOwnSkip(getDefinition(arg.$refLinks[i].definition.target))) isPersisted = false
       if (!arg.ref[i + 1]) {
         const flatName = nameSegments.join('_')
         defineProperty(arg, 'flatName', flatName)
@@ -640,7 +640,7 @@ function infer(originalQuery, model) {
     // ignore whole expand if target of assoc along path has ”@cds.persistence.skip”
     if (arg.expand) {
       const { $refLinks } = arg
-      const skip = $refLinks.some(link => getDefinition(link.definition.target)?.['@cds.persistence.skip'] === true)
+      const skip = $refLinks.some(link => hasOwnSkip(getDefinition(link.definition.target)))
       if (skip) {
         $refLinks[$refLinks.length - 1].skipExpand = true
         return
@@ -937,8 +937,15 @@ function infer(originalQuery, model) {
         return true
       }
       if (assoc) {
+        // if(!link.definition.isAssociation) continue
+        let fkIndex = assoc.keys?.findIndex(key => key.ref.every((step, j) => column.ref[i + j] === step))
         // foreign key access without filters never join relevant
-        if (assoc.keys?.some(key => key.ref.every((step, j) => column.ref[i + j] === step))) return false
+        if (fkIndex !== -1) {
+          if(column.ref.slice(i).some(s => s.where)) continue // probably join relevant later on
+          fkAccess = true
+          assoc = null
+          continue
+        }
         // <assoc>.<anotherAssoc>.<…> is join relevant as <anotherAssoc> is not fk of <assoc>
         return true
       }

package/lib/infer/join-tree.js

@@ -212,6 +212,8 @@ class JoinTree {
             // filter is always join relevant
             // if the column ends up in an `inline` -> each assoc step is join relevant
             child.$refLink.onlyForeignKeyAccess = false
+            // all parents are now also join relevant
+            markParentAsJoinRelevant(child.parent)
           } else {
             child.$refLink.onlyForeignKeyAccess = true
           }
@@ -223,6 +225,8 @@ class JoinTree {
         if (node.$refLink && (!elements || !(child.$refLink.definition.name in elements))) {
           // no foreign key access
           node.$refLink.onlyForeignKeyAccess = false
+          markParentAsJoinRelevant(node.parent)
+
           col.$refLinks[i - 1] = node.$refLink
         }
 
@@ -233,6 +237,15 @@ class JoinTree {
     }
     return true
 
+    function markParentAsJoinRelevant(parent) {
+      while (parent) {
+        if (parent.$refLink?.definition.isAssociation) {
+          parent.$refLink.onlyForeignKeyAccess = false
+        }
+        parent = parent.parent
+      }
+    }
+
     function joinId(step, args, where) {
       let appendix
       if (where && args) appendix = JSON.stringify(where) + JSON.stringify(args)

package/lib/utils.js

@@ -21,6 +21,12 @@ function prettyPrintRef(ref, model = null) {
   }, '')
 }
 
+function hasOwnSkip(definition) {
+  return (
+    definition && Object.hasOwn(definition, '@cds.persistence.skip') && definition['@cds.persistence.skip'] === true
+  )
+}
+
 /**
  * Determines if a definition is calculated on read.
  * - Stored calculated elements are not unfolded
@@ -123,7 +129,6 @@ function getModelUtils(model, query) {
     if (!def || !isLocalized(def)) return def
     return model.definitions[`localized.${def.name}`] || def
   }
-
   return {
     getLocalizedName,
     isLocalized,
@@ -139,4 +144,5 @@ module.exports = {
   getImplicitAlias,
   defineProperty,
   getModelUtils,
+  hasOwnSkip,
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cap-js/db-service",
-  "version": "2.3.0",
+  "version": "2.4.0",
   "description": "CDS base database service",
   "homepage": "https://github.com/cap-js/cds-dbs/tree/main/db-service#cds-base-database-service",
   "repository": {