@cap-js/db-service 2.4.0 → 2.5.0

package/CHANGELOG.md

@@ -4,6 +4,21 @@
 - The format is based on [Keep a Changelog](http://keepachangelog.com/).
 - This project adheres to [Semantic Versioning](http://semver.org/).
 
+## [2.5.0](https://github.com/cap-js/cds-dbs/compare/db-service-v2.4.0...db-service-v2.5.0) (2025-09-30)
+
+
+### Added
+
+* make hana server version accessible to sub classes ([#1263](https://github.com/cap-js/cds-dbs/issues/1263)) ([a3ccc3e](https://github.com/cap-js/cds-dbs/commit/a3ccc3ed2fd6a65f1fd5924756a4a7b965adf9a3))
+* sets default to hana cloud if server version cannot be detected ([a3ccc3e](https://github.com/cap-js/cds-dbs/commit/a3ccc3ed2fd6a65f1fd5924756a4a7b965adf9a3))
+
+
+### Fixed
+
+* **`@cds.search`:** no duplicates for search along `to-many` paths ([#1341](https://github.com/cap-js/cds-dbs/issues/1341)) ([5c5f4fb](https://github.com/cap-js/cds-dbs/commit/5c5f4fbf790f718c3cf1bcb6f3bf7be421be598f))
+* associations in `[@cds](https://github.com/cds).search` are additive ([#1355](https://github.com/cap-js/cds-dbs/issues/1355)) ([ea931cb](https://github.com/cap-js/cds-dbs/commit/ea931cb120c2857aa18a4eb68b893926c0999a9f))
+* set proper element link for path into fk ([#1344](https://github.com/cap-js/cds-dbs/issues/1344)) ([9f365d3](https://github.com/cap-js/cds-dbs/commit/9f365d35ac614969d8fd2c2a9a1a2e0cd643969d))
+
 ## [2.4.0](https://github.com/cap-js/cds-dbs/compare/db-service-v2.3.0...db-service-v2.4.0) (2025-08-27)
 
 

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 { resolveView, getDBTable, getTransition } = require('@sap/cds/libx/_runtime/common/utils/resolveView')
+const { getDBTable, getTransition } = require('@sap/cds/libx/_runtime/common/utils/resolveView')
 const DatabaseService = require('./common/DatabaseService')
 const cqn4sql = require('./cqn4sql')
 
@@ -230,7 +230,9 @@ 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 transitions = getTransition(req.target, this, false, req.query.cmd || 'DELETE')
+      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')
       if (transitions.target !== transitions.queryTarget) {
         const keys = []
         const transitionsTarget = transitions.queryTarget.keys || transitions.queryTarget.elements
@@ -253,7 +255,8 @@ class SQLService extends DatabaseService {
         })
         return this.onDELETE({ query, target: transitions.target })
       }
-      const table = getDBTable(req.target)
+      // REVISIT: remove fallback when cds.dbs requires cds >= 9.3
+      const table = resolve?.table ? resolve.table(req.target) : getDBTable(req.target)
       const { compositions } = table
       if (compositions) {
         // Transform CQL`DELETE from Foo[p1] WHERE p2` into CQL`DELETE from Foo[p1 and p2]`
@@ -404,10 +407,6 @@ 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/cql-functions.js

@@ -21,7 +21,7 @@ const StandardFunctions = {
       val = sub[2] || sub[3] || ''
     }
     arg.val = val
-    const refs = ref.list
+    const refs = ref.list || [ref]
     return `(${refs.map(ref => this.expr({
       func: 'contains',
       args: [

package/lib/cqn2sql.js

@@ -1,6 +1,7 @@
 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
 
@@ -17,6 +18,7 @@ class CQN2SQLRenderer {
    * @param {import('@sap/cds/apis/services').ContextProperties} context the cds.context of the request
    */
   constructor(srv) {
+    this.srv = srv
     this.context = srv?.context || cds.context // Using srv.context is required due to stakeholders doing unmanaged txs without cds.context being set
     this.class = new.target // for IntelliSense
     this.class._init() // is a noop for subsequent calls
@@ -25,7 +27,7 @@ class CQN2SQLRenderer {
     if (cds.env.sql.names === 'quoted') {
       this.class.prototype.name = (name, query) => {
         const e = name.id || name
-        return (query?._target || this.model?.definitions[e])?.['@cds.persistence.name'] || e
+        return (this.model?.definitions[e])?.['@cds.persistence.name'] || e || query?._target
       }
       this.class.prototype.quote = (s) => `"${String(s).replace(/"/g, '""')}"`
     }
@@ -89,7 +91,6 @@ 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)) {
@@ -721,6 +722,49 @@ 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
@@ -826,15 +870,22 @@ 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 in elements && !elements[c].virtual && !elements[c].value && !elements[c].isAssociation)
+      ? 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(INSERT.entries[0])
 
     /** @type {string[]} */
     this.columns = columns
 
     const alias = INSERT.into.as
-    const entity = this.name(q._target?.name || INSERT.into.ref[0], q)
+    const entity = q._target ? this.table_name(q) : INSERT.into.ref[0]
     if (!elements) {
       this.entries = INSERT.entries.map(e => columns.map(c => e[c]))
       const param = this.param.bind(this, { ref: ['?'] })
@@ -856,8 +907,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(c))
-      }) SELECT ${extractions.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(transitions.mapping.get(c)?.ref?.[0] || c))
+      }) SELECT ${extractions.slice(0, columns.length).map(c => c.insert)} FROM json_each(?)`)
   }
 
   async *INSERT_entries_stream(entries, binaryEncoding = 'base64') {
@@ -963,7 +1014,7 @@ class CQN2SQLRenderer {
    */
   INSERT_rows(q) {
     const { INSERT } = q
-    const entity = this.name(q._target?.name || INSERT.into.ref[0], q)
+    const entity = q._target ? this.table_name(q) : INSERT.into.ref[0]
     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`
@@ -987,8 +1038,10 @@ class CQN2SQLRenderer {
     const extraction = (this._managed = this.managed(columns.map(c => ({ name: c })), elements))
       .slice(0, columns.length)
       .map(c => c.converter(c.extract))
-
-    return (this.sql = `INSERT INTO ${this.quote(entity)}${alias ? ' as ' + this.quote(alias) : ''} (${this.columns.map(c => 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, '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))
       }) SELECT ${extraction} FROM json_each(?)`)
   }
 
@@ -1009,15 +1062,26 @@ class CQN2SQLRenderer {
    */
   INSERT_select(q) {
     const { INSERT } = q
-    const entity = this.name(q._target.name, q)
+    const entity = q._target ? this.table_name(q) : INSERT.into.ref[0]
     const alias = INSERT.into.as
+    const src = this.cqn4sql(INSERT.from)
     const elements = q.elements || q._target?.elements || {}
-    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),
-    )}`
+    // 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}`
     this.entries = [this.values]
     return this.sql
   }
@@ -1077,7 +1141,7 @@ class CQN2SQLRenderer {
       .filter(c => keys.includes(c.name))
       .map(c => `${c.onInsert || c.sql} as ${this.quote(c.name)}`)
 
-    const entity = this.name(q._target?.name || UPSERT.into.ref[0], q)
+    const entity = q._target ? this.table_name(q) : INSERT.into.ref[0]
     sql = `SELECT ${managed.map(c => c.upsert
       .replace(/value->/g, '"$$$$value$$$$"->')
       .replace(/json_type\(value,/g, 'json_type("$$$$value$$$$",'))
@@ -1093,7 +1157,9 @@ class CQN2SQLRenderer {
       else return true
     }).map(c => `${this.quote(c)} = excluded.${this.quote(c)}`)
 
-    return (this.sql = `INSERT INTO ${this.quote(entity)} (${columns.map(c => this.quote(c))}) ${sql
+    // 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
       } WHERE TRUE ON CONFLICT(${keys.map(c => this.quote(c))}) DO ${updateColumns.length ? `UPDATE SET ${updateColumns}` : 'NOTHING'}`)
   }
 
@@ -1106,29 +1172,37 @@ class CQN2SQLRenderer {
    */
   UPDATE(q) {
     const { entity, with: _with, data, where } = q.UPDATE
-    const elements = q._target?.elements
-    let sql = `UPDATE ${this.quote(this.name(entity.ref?.[0] || entity, q))}`
+    // 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))}`
     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 c in data) {
-        const columnExistsInDatabase =
-          elements && c in elements && !elements[c].virtual && !elements[c].isAssociation && !elements[c].value
+      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
         if (!elements || columnExistsInDatabase) {
-          columns.push({ name: c, sql: sql4(data[c]) })
+          columns.push({ name: c, sql: sql4(data[col], col) })
         }
       }
     }
 
     const extraction = this.managed(columns, elements)
-      .filter((c, i) => columns[i] || c.onUpdate)
-      .map((c, i) => `${this.quote(c.name)}=${!columns[i] ? c.onUpdate : c.sql}`)
+      .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}`)
 
     sql += ` SET ${extraction}`
-    if (where) sql += ` WHERE ${this.where(where)}`
+    if (where) sql += ` WHERE ${this.where_resolved(entity, where, q)}`
     return (this.sql = sql)
   }
 
@@ -1140,8 +1214,9 @@ class CQN2SQLRenderer {
    * @returns {string} SQL
    */
   DELETE(q) {
-    const { DELETE: { from, where } } = q
-    let sql = `DELETE FROM ${this.from(from, 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)}`
     if (where) sql += ` WHERE ${this.where(where)}`
     return (this.sql = sql)
   }
@@ -1354,6 +1429,17 @@ 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

@@ -61,7 +61,7 @@ function cqn4sql(originalQuery, model) {
   if (!hasCustomJoins && inferred.SELECT?.search) {
     // we need an instance of query because the elements of the query are needed for the calculation of the search columns
     if (!inferred.SELECT.elements) Object.setPrototypeOf(inferred, SELECT.class.prototype)
-    const searchTerm = getSearchTerm(inferred.SELECT.search, inferred)
+    const searchTerm = getSearch(inferred.SELECT.search, inferred)
     if (searchTerm) {
       // Search target can be a navigation, in that case use _target to get the correct entity
       const { where, having } = transformSearch(searchTerm)
@@ -123,14 +123,9 @@ function cqn4sql(originalQuery, model) {
       // calculate the primary keys of the target entity, there is always exactly
       // one query source for UPDATE / DELETE
       const queryTarget = Object.values(inferred.sources)[0].definition
-      const primaryKey = { list: [] }
-      for (const k of Object.keys(queryTarget.elements)) {
-        const e = queryTarget.elements[k]
-        if (e.key === true && !e.virtual && e.isAssociation !== true) {
-          subquery.SELECT.columns.push({ ref: [e.name] })
-          primaryKey.list.push({ ref: [transformedFrom.as, e.name] })
-        }
-      }
+      const primaryKey = { list: getPrimaryKey(queryTarget, uniqueSubqueryAlias) }
+      // match primary keys of the target entity with the subquery
+      primaryKey.list.forEach(k => subquery.SELECT.columns.push({ ref: k.ref.slice(1) }))
 
       const transformedSubquery = cqn4sql(subquery, model)
 
@@ -258,7 +253,7 @@ function cqn4sql(originalQuery, model) {
     if (inferred.SELECT[prop]) {
       return { [prop]: [asXpr(inferred.SELECT.where), 'and', searchTerm] }
     } else {
-      return { [prop]: [searchTerm] }
+      return { [prop]: searchTerm.xpr ? [...searchTerm.xpr] : [searchTerm] }
     }
   }
 
@@ -1211,7 +1206,7 @@ function cqn4sql(originalQuery, model) {
       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)
+        setElementOnColumns(res, column.element)
         return [res]
       }
 
@@ -1789,7 +1784,7 @@ function cqn4sql(originalQuery, model) {
         filterConditions.forEach(f => {
           transformedWhere.push('and')
           if (filterConditions.length > 1) transformedWhere.push(asXpr(f))
-          else if (f.length > 3 || f.includes('or') || f.includes('and')) transformedWhere.push(asXpr(f))
+          else if (f.length > 3 || f.includes('or') || f.includes('and') || f.includes('in')) transformedWhere.push(asXpr(f))
           else transformedWhere.push(...f)
         })
       } else {
@@ -2221,30 +2216,41 @@ function cqn4sql(originalQuery, model) {
     return SELECT
   }
 
-  /**
-   * For a given search expression return a function "search" which holds the search expression
-   * as well as the searchable columns as arguments.
+/**
+   * For a given search term calculate a search expression which can be used in a where clause.
+   * The search function is pushed to a subquery and the primary key(s) of the entity is/are used to match
+   * the search results of the subquery.
    *
-   * @param {object} search - The search expression which shall be applied to the searchable columns on the query source.
+   * @param {object} searchTerm - The search expression which shall be applied to the searchable columns on the query source.
    * @param {object} query - The FROM clause of the CQN statement.
    *
    * @returns {(Object|null)} returns either:
+   * - an expression of the form `<primaryKey> in (select <primaryKey> from <entity> where search(<searchableColumns>, <searchTerm>))`
    * - a function with two arguments: The first one being the list of searchable columns, the second argument holds the search expression.
    * - or null, if no searchable columns are found in neither in `@cds.search` nor in the target entity itself.
    */
-  function getSearchTerm(search, query) {
+  function getSearch(searchTerm, query) {
     const entity = query.SELECT.from.SELECT ? query.SELECT.from : cds.infer.target(query) // REVISIT: we should reliably use inferred._target instead
     const searchIn = computeColumnsToBeSearched(inferred, entity)
-    if (searchIn.length > 0) {
-      const xpr = search
-      const searchFunc = {
-        func: 'search',
-        args: [{ list: searchIn }, xpr.length === 1 && 'val' in xpr[0] ? xpr[0] : { xpr }],
-      }
-      return searchFunc
-    } else {
-      return null
+    if (searchIn.length === 0) return null
+
+    const searchFunc = {
+      func: 'search',
+      args: [
+        searchIn.length === 1 ? searchIn[0] : { list: searchIn },
+        searchTerm.length === 1 && 'val' in searchTerm[0] ? searchTerm[0] : { xpr: searchTerm },
+      ],
     }
+    // for aggregated queries / search on subqueries we do not do a subquery search
+    if (inferred.SELECT.groupBy || entity.SELECT)
+      return searchFunc
+    
+    const matchColumns = getPrimaryKey(entity)
+    if (matchColumns.length === 0 || searchIn.every(r => r.ref.length === 1)) // keyless or not deep, fallback to old behavior
+      return searchFunc
+    
+      const subquery = SELECT.from(entity).columns(...matchColumns).where(searchFunc)
+    return { xpr: [ matchColumns.length === 1 ? matchColumns[0] : {list: matchColumns}, 'in', subquery] }
   }
 
   /**
@@ -2410,6 +2416,17 @@ function setElementOnColumns(col, element) {
   defineProperty(col, 'element', element)
 }
 
+function getPrimaryKey(entity, tableAlias = null) {
+  const primaryKey = []
+  for (const k of Object.keys(entity.elements)) {
+    const e = entity.elements[k]
+    if (e.key === true && !e.virtual && e.isAssociation !== true) {
+      primaryKey.push({ ref: tableAlias ? [tableAlias, e.name] : [e.name] })
+    }
+  }
+  return primaryKey
+}
+
 const getName = col => col.as || col.ref?.at(-1)
 const idOnly = ref => ref.id || ref
 const refWithConditions = step => {

package/lib/search.js

@@ -66,7 +66,7 @@ const _getSearchableColumns = entity => {
     if (key.startsWith(cdsSearchTerm)) cdsSearchKeys.push(key)
   }
 
-  let atLeastOneColumnIsSearchable = false
+  let skipDefaultSearchableElements = false
   const deepSearchCandidates = []
 
   // build a map of columns annotated with the @cds.search annotation
@@ -74,13 +74,18 @@ const _getSearchableColumns = entity => {
     const columnName = key.split(cdsSearchTerm + '.').pop()
     const annotationKey = `${cdsSearchTerm}.${columnName}`
     const annotationValue = entity[annotationKey]
-    if (annotationValue) atLeastOneColumnIsSearchable = true
 
     const column = entity.elements[columnName]
+    // always ignore virtual elements from search
+    if(column?.virtual) continue
     if (column?.isAssociation || columnName.includes('.')) {
-      deepSearchCandidates.push({ ref: columnName.split('.') })
+      const ref = columnName.split('.')
+      if(ref.length > 1) skipDefaultSearchableElements = true
+      deepSearchCandidates.push({ ref })
       continue
     }
+
+    if(annotationValue) skipDefaultSearchableElements = true
     cdsSearchColumnMap.set(columnName, annotationValue)
   }
 
@@ -99,7 +104,7 @@ const _getSearchableColumns = entity => {
     // if at least one element is explicitly annotated as searchable, e.g.:
     // `@cds.search { element1: true }` or `@cds.search { element1 }`
     // and it is not the current column name, then it must be excluded from the search
-    if (atLeastOneColumnIsSearchable) return false
+    if (skipDefaultSearchableElements) return false
 
     // the element is considered searchable if it is explicitly annotated as such or
     // if it is not annotated and the column is typed as a string (excluding elements/elements expressions)

package/package.json

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