@cap-js/db-service 2.5.0 → 2.6.0

package/CHANGELOG.md

@@ -4,6 +4,27 @@
 - The format is based on [Keep a Changelog](http://keepachangelog.com/).
 - This project adheres to [Semantic Versioning](http://semver.org/).
 
+## [2.6.0](https://github.com/cap-js/cds-dbs/compare/db-service-v2.5.1...db-service-v2.6.0) (2025-10-23)
+
+
+### Added
+
+* **`flattening`:** allow flattening of `n`-ary structures in `list` ([#1337](https://github.com/cap-js/cds-dbs/issues/1337)) ([7ec18f2](https://github.com/cap-js/cds-dbs/commit/7ec18f24dba80ba31ad4e46f816c17fa64cba91a))
+* **`flattening`:** allow flattening of structures with exactly one leaf ([7ec18f2](https://github.com/cap-js/cds-dbs/commit/7ec18f24dba80ba31ad4e46f816c17fa64cba91a))
+
+
+### Fixed
+
+* **`@cds.search`:** properly exclude an association from being searched ([#1385](https://github.com/cap-js/cds-dbs/issues/1385)) ([9ed4245](https://github.com/cap-js/cds-dbs/commit/9ed42458417c15dc33409befd0ef40889f04a69f))
+* tree table with expand ([#1363](https://github.com/cap-js/cds-dbs/issues/1363)) ([bdad412](https://github.com/cap-js/cds-dbs/commit/bdad412f0362165b532ce35261773e5ecc7c696a))
+
+## [2.5.1](https://github.com/cap-js/cds-dbs/compare/db-service-v2.5.0...db-service-v2.5.1) (2025-09-30)
+
+
+### Fixed
+
+* revert own resolve ([#1366](https://github.com/cap-js/cds-dbs/issues/1366)) ([9037570](https://github.com/cap-js/cds-dbs/commit/9037570c5dda08eb8bc168c0a68045ef9fc85a9f))
+
 ## [2.5.0](https://github.com/cap-js/cds-dbs/compare/db-service-v2.4.0...db-service-v2.5.0) (2025-09-30)
 
 

package/lib/SQLService.js

@@ -2,7 +2,7 @@ const cds = require('@sap/cds'),
   DEBUG = cds.debug('sql|db')
 const { Readable, Transform } = require('stream')
 const { pipeline } = require('stream/promises')
-const { getDBTable, getTransition } = require('@sap/cds/libx/_runtime/common/utils/resolveView')
+const { resolveView, getDBTable, getTransition } = require('@sap/cds/libx/_runtime/common/utils/resolveView')
 const DatabaseService = require('./common/DatabaseService')
 const cqn4sql = require('./cqn4sql')
 
@@ -230,9 +230,7 @@ class SQLService extends DatabaseService {
     // REVISIT: It's not yet 100 % clear under which circumstances we can rely on db constraints
     return (super.onDELETE = /* cds.env.features.assert_integrity === 'db' ? this.onSIMPLE : */ deep_delete)
     async function deep_delete(/** @type {Request} */ req) {
-      const resolve = this.resolve
-      // REVISIT: remove fallback when cds.dbs requires cds >= 9.3
-      const transitions = resolve?.transitions4db ? resolve.transitions4db(req.query, false) : getTransition(req.target, this, false, req.query.cmd || 'DELETE')
+      const transitions = getTransition(req.target, this, false, req.query.cmd || 'DELETE')
       if (transitions.target !== transitions.queryTarget) {
         const keys = []
         const transitionsTarget = transitions.queryTarget.keys || transitions.queryTarget.elements
@@ -255,8 +253,7 @@ class SQLService extends DatabaseService {
         })
         return this.onDELETE({ query, target: transitions.target })
       }
-      // REVISIT: remove fallback when cds.dbs requires cds >= 9.3
-      const table = resolve?.table ? resolve.table(req.target) : getDBTable(req.target)
+      const table = getDBTable(req.target)
       const { compositions } = table
       if (compositions) {
         // Transform CQL`DELETE from Foo[p1] WHERE p2` into CQL`DELETE from Foo[p1 and p2]`
@@ -407,6 +404,10 @@ class SQLService extends DatabaseService {
    */
   cqn2sql(query, values) {
     let q = this.cqn4sql(query)
+    let kind = q.kind || Object.keys(q)[0]
+    if (kind in { INSERT: 1, DELETE: 1, UPSERT: 1, UPDATE: 1 }) {
+      q = resolveView(q, this.model, this) // REVISIT: before resolveView was called on flat cqn obtained from cqn4sql -> is it correct to call on original q instead?
+    }
     let cqn2sql = new this.class.CQN2SQL(this)
     return cqn2sql.render(q, values)
   }

package/lib/cqn2sql.js

@@ -1,7 +1,6 @@
 const cds = require('@sap/cds')
 const cds_infer = require('./infer')
 const cqn4sql = require('./cqn4sql')
-const { getDBTable, getTransition } = require('@sap/cds/libx/_runtime/common/utils/resolveView')
 const _simple_queries = cds.env.features.sql_simple_queries
 const _strict_booleans = _simple_queries < 2
 
@@ -27,7 +26,7 @@ class CQN2SQLRenderer {
     if (cds.env.sql.names === 'quoted') {
       this.class.prototype.name = (name, query) => {
         const e = name.id || name
-        return (this.model?.definitions[e])?.['@cds.persistence.name'] || e || query?._target
+        return (query?._target || this.model?.definitions[e])?.['@cds.persistence.name'] || e
       }
       this.class.prototype.quote = (s) => `"${String(s).replace(/"/g, '""')}"`
     }
@@ -91,6 +90,7 @@ class CQN2SQLRenderer {
     if (vars && Object.keys(vars).length && !this.values?.length) this.values = vars
     const sanitize_values = process.env.NODE_ENV === 'production' && cds.env.log.sanitize_values !== false
 
+
     if (DEBUG && (LOG_SQL._debug || LOG_SQLITE._debug)) {
       let values = sanitize_values && (this.entries || this.values?.length > 0) ? ['***'] : this.entries || this.values || []
       if (values && !Array.isArray(values)) {
@@ -350,7 +350,13 @@ class CQN2SQLRenderer {
       if (element['@Core.Computed'] && name in availableComputedColumns) continue
       if (name.toUpperCase() in reservedColumnNames) ref.as = `$$${name}$$`
       columnsIn.push(ref)
-      if (from.args || columnsFiltered.find(c => this.column_name(c) === name)) {
+      const foreignkey4 = element._foreignKey4
+      if (
+        from.args ||
+        columnsFiltered.find(c => this.column_name(c) === name) ||
+        // foreignkey needs to be included when the association is expanded
+        (foreignkey4 && q.SELECT.columns.some(c => c.element?.isAssociation && c.element.name === foreignkey4))
+      ) {
         columnsOut.push(ref.as ? { ref: [ref.as], as: name } : ref)
       }
     }
@@ -722,49 +728,6 @@ class CQN2SQLRenderer {
     return this.xpr({ xpr })
   }
 
-  /**
-   * Renders a transformed where clause that maps the query target view to the source table
-   * @param {import('./infer/cqn').source} from
-   * @param {import('./infer/cqn').predicate} where
-   * @param {import('./infer/cqn').query} q
-   * @returns SQL
-   */
-  where_resolved(from, where, q) {
-    // REVISIT: remove fallback when cds.dbs requires cds >= 9.3
-    const kind = q.kind || (
-      q.SELECT ? 'SELECT' :
-      q.INSERT ? 'INSERT' :
-      q.UPSERT ? 'UPSERT' :
-      q.UPDATE ? 'UPDATE' :
-      q.DELETE ? 'DELETE' :
-      undefined
-    )
-    const transitions = this.srv.resolve?.transitions4db ? this.srv.resolve.transitions4db(q) : getTransition(q._target, this.srv, false, kind)
-    if (transitions.target === transitions.queryTarget) return this.where(where)
-
-    // view and table column refs to be matched
-    const viewCols = []
-    const tableCols = []
-
-    // Only match key columns when possible
-    const elements = q._target.keys || q._target.elements
-    for (const c in elements) {
-      if (
-        c in elements
-        && transitions.mapping.has(c)
-        && !elements[c].virtual
-        && !elements[c].value
-        && !elements[c].isAssociation
-      ) {
-        viewCols.push({ ref: [c] })
-        tableCols.push(transitions.mapping.get(c))
-      }
-    }
-    return tableCols.length > 0
-      ? this.where([{ list: tableCols }, 'in', SELECT.from(from).columns(viewCols).where(where)])
-      : this.where(where)
-  }
-
   /**
    * Renders a HAVING clause into generic SQL
    * @param {import('./infer/cqn').predicate} xpr
@@ -870,22 +833,15 @@ class CQN2SQLRenderer {
     if (!elements && !INSERT.entries?.length) {
       return // REVISIT: mtx sends an insert statement without entries and no reference entity
     }
-    // REVISIT: remove fallback when cds.dbs requires cds >= 9.3
-    const transitions = this.srv.resolve?.transitions4db ? this.srv.resolve.transitions4db(q) : getTransition(q._target, this.srv, false, 'INSERT')
     const columns = elements
-      ? ObjectKeys(elements).filter(c => (c = transitions.mapping.get(c)?.ref?.[0] || c)
-        && c in transitions.target.elements
-        && !transitions.target.elements[c].virtual
-        && !transitions.target.elements[c].value
-        && !transitions.target.elements[c].isAssociation
-      )
+      ? ObjectKeys(elements).filter(c => c in elements && !elements[c].virtual && !elements[c].value && !elements[c].isAssociation)
       : ObjectKeys(INSERT.entries[0])
 
     /** @type {string[]} */
     this.columns = columns
 
     const alias = INSERT.into.as
-    const entity = q._target ? this.table_name(q) : INSERT.into.ref[0]
+    const entity = this.name(q._target?.name || INSERT.into.ref[0], q)
     if (!elements) {
       this.entries = INSERT.entries.map(e => columns.map(c => e[c]))
       const param = this.param.bind(this, { ref: ['?'] })
@@ -907,8 +863,8 @@ class CQN2SQLRenderer {
     }
 
     const extractions = this._managed = this.managed(columns.map(c => ({ name: c })), elements)
-    return (this.sql = `INSERT INTO ${this.quote(entity)}${alias ? ' as ' + this.quote(alias) : ''} (${this.columns.map(c => this.quote(transitions.mapping.get(c)?.ref?.[0] || c))
-      }) SELECT ${extractions.slice(0, columns.length).map(c => c.insert)} FROM json_each(?)`)
+    return (this.sql = `INSERT INTO ${this.quote(entity)}${alias ? ' as ' + this.quote(alias) : ''} (${this.columns.map(c => this.quote(c))
+      }) SELECT ${extractions.map(c => c.insert)} FROM json_each(?)`)
   }
 
   async *INSERT_entries_stream(entries, binaryEncoding = 'base64') {
@@ -1014,7 +970,7 @@ class CQN2SQLRenderer {
    */
   INSERT_rows(q) {
     const { INSERT } = q
-    const entity = q._target ? this.table_name(q) : INSERT.into.ref[0]
+    const entity = this.name(q._target?.name || INSERT.into.ref[0], q)
     const alias = INSERT.into.as
     const elements = q.elements || q._target?.elements
     const columns = this.columns = INSERT.columns || cds.error`Cannot insert rows without columns or elements`
@@ -1038,10 +994,8 @@ class CQN2SQLRenderer {
     const extraction = (this._managed = this.managed(columns.map(c => ({ name: c })), elements))
       .slice(0, columns.length)
       .map(c => c.converter(c.extract))
-    
-    // REVISIT: remove fallback when cds.dbs requires cds >= 9.3
-    const transitions = this.srv.resolve?.transitions4db ? this.srv.resolve.transitions4db(q) : getTransition(q._target, this.srv, false, 'INSERT')
-    return (this.sql = `INSERT INTO ${this.quote(entity)}${alias ? ' as ' + this.quote(alias) : ''} (${this.columns.map(c => this.quote(transitions.mapping.get(c)?.ref?.[0] || c))
+
+    return (this.sql = `INSERT INTO ${this.quote(entity)}${alias ? ' as ' + this.quote(alias) : ''} (${this.columns.map(c => this.quote(c))
       }) SELECT ${extraction} FROM json_each(?)`)
   }
 
@@ -1062,26 +1016,15 @@ class CQN2SQLRenderer {
    */
   INSERT_select(q) {
     const { INSERT } = q
-    const entity = q._target ? this.table_name(q) : INSERT.into.ref[0]
+    const entity = this.name(q._target.name, q)
     const alias = INSERT.into.as
-    const src = this.cqn4sql(INSERT.from)
     const elements = q.elements || q._target?.elements || {}
-    // REVISIT: remove fallback when cds.dbs requires cds >= 9.3
-    const transitions = this.srv.resolve?.transitions4db ? this.srv.resolve.transitions4db(q, this.srv) : getTransition(q._target, this.srv, false, 'INSERT')
-    let columns = (this.columns = (INSERT.columns || src.SELECT.columns?.map(c => this.column_name(c)) || ObjectKeys(src.elements) || ObjectKeys(elements))
-      .filter(c => (c = transitions.mapping.get(c)?.ref?.[0] || c)
-        && c in transitions.target.elements
-        && !transitions.target.elements[c].virtual
-        && !transitions.target.elements[c].value
-        && !transitions.target.elements[c].isAssociation
-      ))
-
-    const extractions = this._managed = this.managed(columns.map(c => ({ name: c, sql: `NEW.${this.quote(c)}` })), elements)
-    const sql = extractions.length > columns.length
-      ? `SELECT ${extractions.map(c => `${c.insert} AS ${this.quote(c.name)}`)} FROM (${this.SELECT(src)}) AS NEW`
-      : this.SELECT(src)
-    if (extractions.length > columns.length) columns = this.columns = extractions.map(c => c.name)
-    this.sql = `INSERT INTO ${this.quote(entity)}${alias ? ' as ' + this.quote(alias) : ''} (${columns.map(c => this.quote(transitions.mapping.get(c)?.ref?.[0] || c))}) ${sql}`
+    const columns = (this.columns = (INSERT.columns || ObjectKeys(elements)).filter(
+      c => c in elements && !elements[c].virtual && !elements[c].isAssociation,
+    ))
+    this.sql = `INSERT INTO ${this.quote(entity)}${alias ? ' as ' + this.quote(alias) : ''} (${columns.map(c => this.quote(c))}) ${this.SELECT(
+      this.cqn4sql(INSERT.from || INSERT.as),
+    )}`
     this.entries = [this.values]
     return this.sql
   }
@@ -1141,7 +1084,7 @@ class CQN2SQLRenderer {
       .filter(c => keys.includes(c.name))
       .map(c => `${c.onInsert || c.sql} as ${this.quote(c.name)}`)
 
-    const entity = q._target ? this.table_name(q) : INSERT.into.ref[0]
+    const entity = this.name(q._target?.name || UPSERT.into.ref[0], q)
     sql = `SELECT ${managed.map(c => c.upsert
       .replace(/value->/g, '"$$$$value$$$$"->')
       .replace(/json_type\(value,/g, 'json_type("$$$$value$$$$",'))
@@ -1157,9 +1100,7 @@ class CQN2SQLRenderer {
       else return true
     }).map(c => `${this.quote(c)} = excluded.${this.quote(c)}`)
 
-    // REVISIT: remove fallback when cds.dbs requires cds >= 9.3
-    const transitions = this.srv.resolve.transitions4db ? this.srv.resolve.transitions4db(q) : getTransition(q._target, this.srv, false, 'UPDATE')
-    return (this.sql = `INSERT INTO ${this.quote(entity)} (${columns.map(c => this.quote(transitions.mapping.get(c)?.ref?.[0] || c))}) ${sql
+    return (this.sql = `INSERT INTO ${this.quote(entity)} (${columns.map(c => this.quote(c))}) ${sql
       } WHERE TRUE ON CONFLICT(${keys.map(c => this.quote(c))}) DO ${updateColumns.length ? `UPDATE SET ${updateColumns}` : 'NOTHING'}`)
   }
 
@@ -1172,37 +1113,29 @@ class CQN2SQLRenderer {
    */
   UPDATE(q) {
     const { entity, with: _with, data, where } = q.UPDATE
-    // REVISIT: remove fallback when cds.dbs requires cds >= 9.3
-    const transitions = this.srv.resolve?.transitions4db ? this.srv.resolve.transitions4db(q) : getTransition(q._target, this.srv, false, 'UPDATE')
-    const elements = q._target?.elements    
-    let sql = `UPDATE ${this.quote(this.table_name(q))}`
+    const elements = q._target?.elements
+    let sql = `UPDATE ${this.quote(this.name(entity.ref?.[0] || entity, q))}`
     if (entity.as) sql += ` AS ${this.quote(entity.as)}`
 
     let columns = []
     if (data) _add(data, val => this.val({ val }))
     if (_with) _add(_with, x => this.expr(x))
     function _add(data, sql4) {
-      for (let col in data) {
-        const c = transitions.mapping.get(col)?.ref?.[0] || col
-        const columnExistsInDatabase = elements
-          && c in transitions.target.elements
-          && !transitions.target.elements[c].virtual
-          && !transitions.target.elements[c].value
-          && !transitions.target.elements[c].isAssociation
+      for (let c in data) {
+        const columnExistsInDatabase =
+          elements && c in elements && !elements[c].virtual && !elements[c].isAssociation && !elements[c].value
         if (!elements || columnExistsInDatabase) {
-          columns.push({ name: c, sql: sql4(data[col], col) })
+          columns.push({ name: c, sql: sql4(data[c]) })
         }
       }
     }
 
     const extraction = this.managed(columns, elements)
-      .filter((c, i) => {
-        if(transitions.mapping.get(c.name)?.ref?.length > 1) return false
-        return columns[i] || c.onUpdate
-      }).map((c, i) => `${this.quote(transitions.mapping.get(c.name)?.ref?.[0] || c.name)}=${!columns[i] ? c.onUpdate : c.sql}`)
+      .filter((c, i) => columns[i] || c.onUpdate)
+      .map((c, i) => `${this.quote(c.name)}=${!columns[i] ? c.onUpdate : c.sql}`)
 
     sql += ` SET ${extraction}`
-    if (where) sql += ` WHERE ${this.where_resolved(entity, where, q)}`
+    if (where) sql += ` WHERE ${this.where(where)}`
     return (this.sql = sql)
   }
 
@@ -1214,9 +1147,8 @@ class CQN2SQLRenderer {
    * @returns {string} SQL
    */
   DELETE(q) {
-    const { DELETE: { where, from } } = q
-    let sql = `DELETE FROM ${this.quote(this.table_name(q))}`
-    if (from.as) sql += ` AS ${this.quote(from.as)}`
+    const { DELETE: { from, where } } = q
+    let sql = `DELETE FROM ${this.from(from, q)}`
     if (where) sql += ` WHERE ${this.where(where)}`
     return (this.sql = sql)
   }
@@ -1429,17 +1361,6 @@ class CQN2SQLRenderer {
     return (typeof col.as === 'string' && col.as) || ('val' in col && col.val + '') || col.func || col.ref.at(-1)
   }
 
-  /**
-   * Calculates the Database table name of the query target
-   * @param {import('./infer/cqn').Query} query
-   * @returns {string} Database table name
-   */
-  table_name(q) {
-    // REVISIT: remove fallback when cds.dbs requires cds >= 9.3
-    const table = cds.db.resolve?.table ? cds.db.resolve.table(q._target) : getDBTable(q._target)
-    return this.name(table.name, q)
-  }
-
   /**
    * Calculates the Database name of the given name
    * @param {string|import('./infer/cqn').ref} name

package/lib/cqn4sql.js

@@ -96,7 +96,7 @@ function cqn4sql(originalQuery, model) {
 
     // Transform the existing where, prepend table aliases, and so on...
     if (where) {
-      transformedProp.where = getTransformedTokenStream(where)
+      transformedProp.where = getTransformedTokenStream(where, { prop: 'where' })
     }
 
     // Transform the from clause: association path steps turn into `WHERE EXISTS` subqueries.
@@ -191,7 +191,7 @@ function cqn4sql(originalQuery, model) {
 
     // Like the WHERE clause, aliases from the SELECT list are not accessible for `group by`/`having` (in most DB's)
     if (having) {
-      transformedQuery.SELECT.having = getTransformedTokenStream(having)
+      transformedQuery.SELECT.having = getTransformedTokenStream(having, { prop: 'having' })
     }
 
     if (groupBy) {
@@ -314,7 +314,7 @@ function cqn4sql(originalQuery, model) {
       lhs.args.push(arg)
       alreadySeen.set(nextAssoc.$refLink.alias, true)
       if (nextAssoc.where) {
-        const filter = getTransformedTokenStream(nextAssoc.where, nextAssoc.$refLink)
+        const filter = getTransformedTokenStream(nextAssoc.where, { $baseLink: nextAssoc.$refLink })
         lhs.on = [
           ...(hasLogicalOr(lhs.on) ? [asXpr(lhs.on)] : lhs.on),
           'and',
@@ -521,14 +521,14 @@ function cqn4sql(originalQuery, model) {
     }
   }
 
-  function resolveCalculatedElement(column, omitAlias = false, baseLink = null) {
+  function resolveCalculatedElement(column, omitAlias = false, $baseLink = null) {
     let value
 
     if (column.$refLinks) {
       const { $refLinks } = column
       value = $refLinks[$refLinks.length - 1].definition.value
       if (column.$refLinks.length > 1) {
-        baseLink =
+        $baseLink =
           [...$refLinks].reverse().find($refLink => $refLink.definition.isAssociation) ||
           // if there is no association in the path, the table alias is the base link
           // TA might refer to subquery -> we need to propagate the alias to all paths of the calc element
@@ -541,13 +541,13 @@ function cqn4sql(originalQuery, model) {
 
     let res
     if (ref) {
-      res = getTransformedTokenStream([value], baseLink)[0]
+      res = getTransformedTokenStream([value], { $baseLink })[0]
     } else if (xpr) {
-      res = { xpr: getTransformedTokenStream(value.xpr, baseLink) }
+      res = { xpr: getTransformedTokenStream(value.xpr, { $baseLink }) }
     } else if (val !== undefined) {
       res = { val }
     } else if (func) {
-      res = { args: getTransformedFunctionArgs(value.args, baseLink), func: value.func }
+      res = { args: getTransformedFunctionArgs(value.args, $baseLink), func: value.func }
     }
     if (!omitAlias) res.as = column.as || column.name || column.flatName
     return res
@@ -1018,7 +1018,7 @@ function cqn4sql(originalQuery, model) {
          * the result.
          */
         if (inOrderBy && flatColumns.length > 1)
-          throw new Error(`"${getFullName(leaf)}" can't be used in order by as it expands to multiple fields`)
+          throw new Error(`Structured element “${getFullName(leaf)}” expands to multiple fields and can't be used in order by`)
         flatColumns.forEach(fc => {
           if (col.nulls) fc.nulls = col.nulls
           if (col.sort) fc.sort = col.sort
@@ -1182,7 +1182,7 @@ function cqn4sql(originalQuery, model) {
     if (column.val || column.func || column.SELECT) return [column]
 
     const structsAreUnfoldedAlready = model.meta.unfolded?.includes('structs')
-    let { baseName, columnAlias = column.as, tableAlias } = names
+    let { baseName, columnAlias = column.as, tableAlias } = names || {}
     const { exclude, replace } = excludeAndReplace || {}
     const { $refLinks, flatName, isJoinRelevant } = column
     let firstNonJoinRelevantAssoc, stepAfterAssoc
@@ -1360,14 +1360,18 @@ function cqn4sql(originalQuery, model) {
    * @param {object[]} tokenStream - The token stream to transform. Each token in the stream is an
    *                                 object representing a CQN construct such as a column, an operator,
    *                                 or a subquery.
-   * @param {object} [$baseLink=null] - The context in which the `ref`s in the token stream are resolvable.
-   *                                    It serves as the reference point for resolving associations in
-   *                                    statements like `{…} WHERE exists assoc[exists anotherAssoc]`.
-   *                                    Here, the $baseLink for `anotherAssoc` would be `assoc`.
+   * @param {object} [context] - Optional context object.
+   * @param {object} [context.$baseLink] - The context in which the `ref`s in the token stream are resolvable.
+   *                                   It serves as the reference point for resolving associations in
+   *                                   statements like `{…} WHERE exists assoc[exists anotherAssoc]`.
+   *                                   Here, the $baseLink for `anotherAssoc` would be `assoc`.
+   * @param {string} [context.prop] - The query property which holds the token stream which shall be
+   *                                  transformed by this function, e.g. "where".
    * @returns {object[]} - The transformed token stream.
    */
-  function getTransformedTokenStream(tokenStream, $baseLink = null) {
+  function getTransformedTokenStream(tokenStream, context = {}) {
     const transformedTokenStream = []
+    const { $baseLink, /* prop */ } = context
     for (let i = 0; i < tokenStream.length; i++) {
       const token = tokenStream[i]
       if (token === 'exists') {
@@ -1453,7 +1457,7 @@ function cqn4sql(originalQuery, model) {
           if (list.every(e => e.val))
             // no need for transformation
             transformedTokenStream.push({ list })
-          else transformedTokenStream.push({ list: getTransformedTokenStream(list, $baseLink) })
+          else transformedTokenStream.push({ list: getTransformedTokenStream(list, { $baseLink, prop: 'list' }) })
         }
       } else if (tokenStream.length === 1 && token.val && $baseLink) {
         // infix filter - OData variant w/o mentioning key --> flatten out and compare each leaf to token.val
@@ -1509,13 +1513,13 @@ function cqn4sql(originalQuery, model) {
           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)
+          assertNoStructInXpr(token, context)
           // reject virtual elements in expressions as they will lead to a sql error down the line
           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) {
-            const { definition } = token.$refLinks[token.$refLinks.length - 1]
+            const { definition } = token.$refLinks.at(-1)
             // Add definition to result
             setElementOnColumns(result, definition)
             if (isCalculatedOnRead(definition)) {
@@ -1536,7 +1540,15 @@ function cqn4sql(originalQuery, model) {
             const lastAssoc =
               token.isJoinRelevant && [...token.$refLinks].reverse().find(l => l.definition.isAssociation)
             const tableAlias = getTableAlias(token, (!lastAssoc?.onlyForeignKeyAccess && lastAssoc) || $baseLink)
-            if ((!$baseLink || lastAssoc) && token.isJoinRelevant) {
+            if(isAssocOrStruct(definition)) {
+              const flat =  getFlatColumnsFor(token, { tableAlias: $baseLink?.alias || tableAlias })
+              if(flat.length === 0)
+                throw new Error(`Structured element “${getFullName(definition)}” expands to nothing and can't be used in expressions`)
+              else if (flat.length > 1 && context.prop !== 'list') // only acceptable in `list`
+                throw new Error(`Structured element “${getFullName(definition)}” expands to multiple fields and can't be used in expressions`)
+              transformedTokenStream.push(...flat)
+              continue
+            } else if ((!$baseLink || lastAssoc) && token.isJoinRelevant) {
               let name = calculateElementName(token)
               result.ref = [tableAlias, name]
             } else if (tableAlias) {
@@ -1549,7 +1561,7 @@ function cqn4sql(originalQuery, model) {
             result = transformSubquery(token)
           } else {
             if (token.xpr) {
-              result.xpr = getTransformedTokenStream(token.xpr, $baseLink)
+              result.xpr = getTransformedTokenStream(token.xpr, { $baseLink })
             }
             if (token.func && token.args) {
               result.args = getTransformedFunctionArgs(token.args, $baseLink)
@@ -1661,11 +1673,15 @@ function cqn4sql(originalQuery, model) {
     }
   }
 
-  function assertNoStructInXpr(token, inInfixFilter = false) {
-    if (!inInfixFilter && token.$refLinks?.[token.$refLinks.length - 1].definition.target)
-      // REVISIT: let this through if not requested otherwise
+  function assertNoStructInXpr(token, context) {
+    const definition = token.$refLinks?.at(-1).definition
+    if(!definition) return
+    const rejectStructs = context && (context.prop in { where: 1, having: 1 })
+    // unmanaged is always forbidden
+    // expanding a ref in a `where`/`having` context
+    if ((rejectStructs && definition?.target) || definition?.on)
       rejectAssocInExpression()
-    if (isStructured(token.$refLinks?.[token.$refLinks.length - 1].definition))
+    if (rejectStructs && isStructured(definition))
       // REVISIT: let this through if not requested otherwise
       rejectStructInExpression()
 
@@ -1771,7 +1787,7 @@ function cqn4sql(originalQuery, model) {
 
       // only append infix filter to outer where if it is the leaf of the from ref
       if (refReverse[0].where)
-        filterConditions.push(getTransformedTokenStream(refReverse[0].where, $refLinksReverse[0]))
+        filterConditions.push(getTransformedTokenStream(refReverse[0].where,{ $baseLink: $refLinksReverse[0] }))
 
       if (existingWhere.length > 0) filterConditions.push(existingWhere)
       if (whereExistsSubSelects.length > 0) {
@@ -2209,7 +2225,7 @@ function cqn4sql(originalQuery, model) {
     }
 
     if (customWhere) {
-      const filter = getTransformedTokenStream(customWhere, next)
+      const filter = getTransformedTokenStream(customWhere, { $baseLink: next })
       const wrappedFilter = hasLogicalOr(filter) ? [asXpr(filter)] : filter
       on.push('and', ...wrappedFilter)
     }
@@ -2315,10 +2331,10 @@ function cqn4sql(originalQuery, model) {
   function getTransformedFunctionArgs(args, $baseLink = null) {
     let result = null
     if (Array.isArray(args)) {
-      result = args.map(t => {
+      result = args.flatMap(t => {
         if (!t.val)
           // this must not be touched
-          return getTransformedTokenStream([t], $baseLink)[0]
+          return getTransformedTokenStream([t], { $baseLink })
         return t
       })
     } else if (typeof args === 'object') {
@@ -2327,7 +2343,7 @@ function cqn4sql(originalQuery, model) {
         const t = args[prop]
         if (!t.val)
           // this must not be touched
-          result[prop] = getTransformedTokenStream([t], $baseLink)[0]
+          result[prop] = getTransformedTokenStream([t], { $baseLink })[0]
         else result[prop] = t
       }
     }

package/lib/deep-queries.js

@@ -3,20 +3,7 @@ const { _target_name4 } = require('./SQLService')
 
 const ROOT = Symbol('root')
 
-// REVISIT: remove old path with cds^8
-let _compareJson
-const compareJson = (...args) => {
-  if (!_compareJson) {
-    try {
-      // new path
-      _compareJson = require('@sap/cds/libx/_runtime/common/utils/compareJson').compareJson
-    } catch {
-      // old path
-      _compareJson = require('@sap/cds/libx/_runtime/cds-services/services/utils/compareJson').compareJson
-    }
-  }
-  return _compareJson(...args)
-}
+const compareJson = require('@sap/cds/libx/_runtime/common/utils/compareJson').compareJson
 
 const handledDeep = Symbol('handledDeep')
 

package/lib/search.js

@@ -79,6 +79,9 @@ const _getSearchableColumns = entity => {
     // always ignore virtual elements from search
     if(column?.virtual) continue
     if (column?.isAssociation || columnName.includes('.')) {
+      if(!annotationValue)
+        continue
+
       const ref = columnName.split('.')
       if(ref.length > 1) skipDefaultSearchableElements = true
       deepSearchCandidates.push({ ref })

package/package.json

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