@cap-js/db-service 1.3.2 → 1.5.0

package/CHANGELOG.md

@@ -4,6 +4,37 @@
 - The format is based on [Keep a Changelog](http://keepachangelog.com/).
 - This project adheres to [Semantic Versioning](http://semver.org/).
 
+## [1.5.0](https://github.com/cap-js/cds-dbs/compare/db-service-v1.4.0...db-service-v1.5.0) (2023-12-06)
+
+
+### Added
+
+* Improved connection pool for HANAService ([#349](https://github.com/cap-js/cds-dbs/issues/349)) ([1c284e6](https://github.com/cap-js/cds-dbs/commit/1c284e69cccd76daad52249c0462bc62aa4d11a8))
+
+
+### Fixed
+
+* **localized:** `ref`s in subqueries in `from` are translated ([#366](https://github.com/cap-js/cds-dbs/issues/366)) ([cfe4897](https://github.com/cap-js/cds-dbs/commit/cfe489715db0854d30b90b7f13c024e6e90be497))
+* wrong odata count in filter with groupby ([#352](https://github.com/cap-js/cds-dbs/issues/352)) ([70690a1](https://github.com/cap-js/cds-dbs/commit/70690a1a13e72bfbb66f03bf315d3f2d48672bf6))
+
+## [1.4.0](https://github.com/cap-js/cds-dbs/compare/db-service-v1.3.2...db-service-v1.4.0) (2023-11-20)
+
+
+### Added
+
+* **`UPDATE`/`DELETE`:** Enable path expressions for improved data manipulation ([#325](https://github.com/cap-js/cds-dbs/issues/325)) ([94f0776](https://github.com/cap-js/cds-dbs/commit/94f077661cffad8f137dc692a2cb9b0ae5e4d75b))
+* **temporal data:** add time slice key to conflict clause ([#249](https://github.com/cap-js/cds-dbs/issues/249)) ([67b8edf](https://github.com/cap-js/cds-dbs/commit/67b8edf9b7f6b0fbab0010d7c93ed03a01e103ed))
+* use place holders for update and delete ([#323](https://github.com/cap-js/cds-dbs/issues/323)) ([81472b9](https://github.com/cap-js/cds-dbs/commit/81472b971183f701e401247611310be56745a87a))
+
+
+### Fixed
+
+* align time function behavior ([#322](https://github.com/cap-js/cds-dbs/issues/322)) ([c3ab40a](https://github.com/cap-js/cds-dbs/commit/c3ab40a007c105465349dd2f612178367b8e713a))
+* **calculated elements:** path expressions in `func.args` within `xpr` ([#321](https://github.com/cap-js/cds-dbs/issues/321)) ([cee25e3](https://github.com/cap-js/cds-dbs/commit/cee25e33cf289592a87779cfa34dddc53e467676))
+* Disconnect db service on shutdown ([#327](https://github.com/cap-js/cds-dbs/issues/327)) ([8471bda](https://github.com/cap-js/cds-dbs/commit/8471bda44fc030205abec45b1581b2cf6ed7c800))
+* non-fk access in filter conditions are properly rejected ([#336](https://github.com/cap-js/cds-dbs/issues/336)) ([4c948fe](https://github.com/cap-js/cds-dbs/commit/4c948fecead1de562e1583886516413e131a39aa))
+* **search:** check calculated columns at any depth ([#310](https://github.com/cap-js/cds-dbs/issues/310)) ([8fd6153](https://github.com/cap-js/cds-dbs/commit/8fd6153dfcd472a6d95c33faa58c4b3f96f485df))
+
 ## [1.3.2](https://github.com/cap-js/cds-dbs/compare/db-service-v1.3.1...db-service-v1.3.2) (2023-10-13)
 
 

package/lib/SQLService.js

@@ -230,16 +230,15 @@ class SQLService extends DatabaseService {
       if (max === undefined || (n < max && (n || !offset))) return n + offset
     }
     // REVISIT: made uppercase count because of HANA reserved word quoting
-    const cq = cds.ql.clone(query, {
-      columns: [{ func: 'count', as: 'COUNT' }],
+    const cq = SELECT.one([{ func: 'count', as: 'COUNT' }]).from(
+      cds.ql.clone(query, {
       localized: false,
       expand: false,
-      limit: 0,
-      orderBy: 0,
-    })
-    const { sql, values } = this.cqn2sql(cq)
-    const ps = await this.prepare(sql)
-    const { count, COUNT } = await ps.get(values)
+        limit: undefined,
+        orderBy: undefined,
+      }),
+    )
+    const { count, COUNT } = await this.onSELECT({ query: cq })
     return count ?? COUNT
   }
 
@@ -280,12 +279,12 @@ class SQLService extends DatabaseService {
    */
   cqn2sql(query, values) {
     let q = this.cqn4sql(query)
-    if (q.SELECT && q.elements) q.SELECT.expand = q.SELECT.expand ?? 'root'
+    if (q.SELECT && 'elements' in q) q.SELECT.expand ??= 'root'
 
-    let cmd = q.cmd || Object.keys(q)[0]
-    if (cmd in { INSERT: 1, DELETE: 1, UPSERT: 1, UPDATE: 1 } || q.STREAM?.into) {
+    let kind = q.kind || Object.keys(q)[0]
+    if (kind in { INSERT: 1, DELETE: 1, UPSERT: 1, UPDATE: 1 } || q.STREAM?.into) {
       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 target = q[cmd]._transitions?.[0].target
+      let target = q[kind]._transitions?.[0].target
       if (target) q.target = target // REVISIT: Why isn't that done in resolveView?
     }
     let cqn2sql = new this.class.CQN2SQL(this)

package/lib/common/DatabaseService.js

@@ -6,10 +6,16 @@ const cds = require('@sap/cds/lib')
 /** @typedef {unknown} DatabaseDriver */
 
 class DatabaseService extends cds.Service {
+
+  init() {
+    cds.on('shutdown', () => this.disconnect())
+    return super.init()
+  }
+
   /**
    * Dictionary of connection pools per tenant
    */
-  pools = { _factory: this.factory }
+  pools = Object.setPrototypeOf({}, { _factory: this.factory })
 
   /**
    * Return a pool factory + options property as expected by
@@ -44,7 +50,9 @@ class DatabaseService extends cds.Service {
   async begin() {
     // We expect tx.begin() being called for an txed db service
     const ctx = this.context
-    if (!ctx) return this.tx().begin() // REVISIT: Is this correct? When does this happen?
+
+    // If .begin is called explicitly it starts a new transaction and executes begin
+    if (!ctx) return this.tx().begin()
 
     // REVISIT: tenant should be undefined if !this.isMultitenant
     let isMultitenant = 'multiTenant' in this.options ? this.options.multiTenant : cds.env.requires.multitenancy
@@ -55,6 +63,7 @@ class DatabaseService extends cds.Service {
 
     // Acquire a pooled connection
     this.dbc = await this.acquire()
+    this.dbc.destroy = this.destroy.bind(this)
 
     // Begin a session...
     try {
@@ -102,8 +111,20 @@ class DatabaseService extends cds.Service {
    */
   async release() {
     if (!this.dbc) return
-    await this.pool.release(this.dbc)
+    const dbc = this.dbc
+    this.dbc = undefined
+    await this.pool.release(dbc)
+  }
+
+  /**
+   * Destroys own connection, i.e. tix.dbc, from this.pool
+   * This is for subclasses to intercept, if required.
+   */
+  async destroy() {
+    if (!this.dbc) return
+    const dbc = this.dbc
     this.dbc = undefined
+    await this.pool.destroy(dbc)
   }
 
   // REVISIT: should happen automatically after a configurable time
@@ -111,11 +132,18 @@ class DatabaseService extends cds.Service {
    * @param {string} tenant
    */
   async disconnect(tenant) {
-    const pool = this.pools[tenant]
-    if (!pool) return
-    await pool.drain()
-    await pool.clear()
-    delete this.pools[tenant]
+    const _disconnect = async tenant => {
+      const pool = this.pools[tenant]
+      if (!pool) {
+        return
+      }
+      await pool.drain()
+      await pool.clear()
+      delete this.pools[tenant]
+    }
+    if (tenant == null)
+      return Promise.all(Object.keys(this.pools).map(_disconnect))
+    return _disconnect(tenant)
   }
 
   /**

package/lib/cql-functions.js

@@ -149,37 +149,37 @@ const StandardFunctions = {
    * Generates SQL statement that produces the year of a given timestamp
    * @param {string} x
    * @returns {string}
-   */
+   * /
   year: x => `cast( strftime('%Y',${x}) as Integer )`,
   /**
    * Generates SQL statement that produces the month of a given timestamp
    * @param {string} x
    * @returns {string}
-   */
+   * /
   month: x => `cast( strftime('%m',${x}) as Integer )`,
   /**
    * Generates SQL statement that produces the day of a given timestamp
    * @param {string} x
    * @returns {string}
-   */
+   * /
   day: x => `cast( strftime('%d',${x}) as Integer )`,
   /**
    * Generates SQL statement that produces the hours of a given timestamp
    * @param {string} x
    * @returns {string}
-   */
+   * /
   hour: x => `cast( strftime('%H',${x}) as Integer )`,
   /**
    * Generates SQL statement that produces the minutes of a given timestamp
    * @param {string} x
    * @returns {string}
-   */
+   * /
   minute: x => `cast( strftime('%M',${x}) as Integer )`,
   /**
    * Generates SQL statement that produces the seconds of a given timestamp
    * @param {string} x
    * @returns {string}
-   */
+   * /
   second: x => `cast( strftime('%S',${x}) as Integer )`,
 
   /**

package/lib/cqn2sql.js

@@ -62,15 +62,15 @@ class CQN2SQLRenderer {
    * @returns {CQN2SQLRenderer|unknown}
    */
   render(q, vars) {
-    const cmd = q.cmd || Object.keys(q)[0] // SELECT, INSERT, ...
+    const kind = q.kind || Object.keys(q)[0] // SELECT, INSERT, ...
     /**
      * @type {string} the rendered SQL string
      */
     this.sql = '' // to have it as first property for debugging
     /** @type {unknown[]} */
     this.values = [] // prepare values, filled in by subroutines
-    this[cmd]((this.cqn = q)) // actual sql rendering happens here
-    if (vars?.length && !this.values.length) this.values = vars
+    this[kind]((this.cqn = q)) // actual sql rendering happens here
+    if (vars?.length && !this.values?.length) this.values = vars
     const sanitize_values = process.env.NODE_ENV === 'production' && cds.env.log.sanitize_values !== false
     DEBUG?.(
       this.sql,
@@ -208,9 +208,8 @@ class CQN2SQLRenderer {
     if (limit) sql += ` LIMIT ${this.limit(limit)}`
     // Expand cannot work without an inferred query
     if (expand) {
-      // REVISIT: Why don't we handle that as an error in SELECT_expand?
-      if (!q.elements) cds.error`Query was not inferred and includes expand. For which the metadata is missing.`
-      sql = this.SELECT_expand(q, sql)
+      if ('elements' in q) sql = this.SELECT_expand (q,sql)
+      else cds.error`Query was not inferred and includes expand. For which the metadata is missing.`
     }
     return (this.sql = sql)
   }
@@ -230,10 +229,12 @@ class CQN2SQLRenderer {
    * @param {string} sql
    * @returns {string} SQL
    */
-  SELECT_expand({ SELECT, elements }, sql) {
+  SELECT_expand(q, sql) {
+    if (!('elements' in q)) return sql
+
+    const SELECT = q.SELECT
     if (!SELECT.columns) return sql
-    if (!elements) return sql // REVISIT: Above we say this is an error condition, but here we say it's ok?
-    
+
     let cols = SELECT.columns.map(x => {
       const name = this.column_name(x)
       let col = `'${name}',${this.output_converter4(x.element, this.quote(name))}`
@@ -256,7 +257,7 @@ class CQN2SQLRenderer {
       }
       // REVISIT: json_merge is a user defined function, bad performance!
       obj = `json_merge(${chunks})`
-    } 
+    }
 
 
     return `SELECT ${SELECT.one || SELECT.expand === 'root' ? obj : `json_group_array(${obj.includes('json_merge') ? `json_insert(${obj})` : obj})`} as _json_ FROM (${sql})`
@@ -527,6 +528,9 @@ class CQN2SQLRenderer {
       .filter(c => !keys.includes(c))
       .map(c => `${this.quote(c)} = excluded.${this.quote(c)}`)
 
+    // temporal data
+    keys.push(...Object.values(q.target.elements).filter(e => e['@cds.valid.from']).map(e => e.name))
+
     keys = keys.map(k => this.quote(k))
     const conflict = updateColumns.length
       ? `ON CONFLICT(${keys}) DO UPDATE SET ` + updateColumns
@@ -872,7 +876,6 @@ class CQN2SQLRenderer {
 
       let val = _managed[element[annotation]?.['=']]
       if (val) sql = `coalesce(${sql}, ${this.func({ func: 'session_context', args: [{ val }] })})`
-
       else if (!isUpdate && element.default) {
         const d = element.default
         if (d.val !== undefined || d.ref?.[0] === '$now') {

package/lib/cqn4sql.js

@@ -1,7 +1,7 @@
 'use strict'
 
 const cds = require('@sap/cds/lib')
-const { computeColumnsToBeSearched } = require('@sap/cds/libx/_runtime/cds-services/services/utils/columns.js')
+const { computeColumnsToBeSearched } = require('./search')
 
 const infer = require('./infer')
 
@@ -48,7 +48,7 @@ function cqn4sql(originalQuery, model = cds.context?.model || cds.model) {
   if (originalQuery.SELECT?.from.args && !originalQuery.joinTree) return inferred
 
   let transformedQuery = cds.ql.clone(inferred)
-  const kind = inferred.cmd || Object.keys(inferred)[0]
+  const kind = inferred.kind || Object.keys(inferred)[0]
 
   if (inferred.INSERT || inferred.UPSERT) {
     transformedQuery = transformQueryForInsertUpsert(kind)
@@ -96,7 +96,46 @@ function cqn4sql(originalQuery, model = cds.context?.model || cds.model) {
       }
 
       if (queryNeedsJoins) {
-        transformedQuery[kind].from = translateAssocsToJoins(transformedQuery[kind].from)
+        if (inferred.UPDATE || inferred.DELETE) {
+          const prop = inferred.UPDATE ? 'UPDATE' : 'DELETE'
+          const subquery = {
+            SELECT: {
+              from: { ...transformedFrom },
+              columns: [], // primary keys of the query target will be added later
+              where: [...transformedProp.where],
+            },
+          }
+          // The alias of the original query is now the alias for the subquery
+          // so that potential references in the where clause to the alias match.
+          // Hence, replace the alias of the original query with the next
+          // available alias, so that each alias is unique.
+          const uniqueSubqueryAlias = getNextAvailableTableAlias(transformedFrom.as)
+          transformedFrom.as = uniqueSubqueryAlias
+
+          // calculate the primary keys of the target entity, there is always exactly
+          // one query source for UPDATE / DELETE
+          const queryTarget = Object.values(originalQuery.sources)[0]
+          const keys = Object.values(queryTarget.elements).filter(e => e.key === true)
+          const primaryKey = { list: [] }
+          keys.forEach(k => {
+            // cqn4sql will add the table alias to the column later, no need to add it here
+            subquery.SELECT.columns.push({ ref: [k.name] })
+
+            // add the alias of the main query to the list of primary key references
+            primaryKey.list.push({ ref: [transformedFrom.as, k.name] })
+          })
+
+          const transformedSubquery = cqn4sql(subquery)
+
+          // replace where condition of original query with the transformed subquery
+          // correlate UPDATE / DELETE query with subquery by primary key matches
+          transformedQuery[prop].where = [primaryKey, 'in', transformedSubquery]
+
+          if (prop === 'UPDATE') transformedQuery.UPDATE.entity = transformedFrom
+          else transformedQuery.DELETE.from = transformedFrom
+        } else {
+          transformedQuery[kind].from = translateAssocsToJoins(transformedQuery[kind].from)
+        }
       }
     }
   }
@@ -376,7 +415,6 @@ function cqn4sql(originalQuery, model = cds.context?.model || cds.model) {
     return transformedColumns
 
     function handleSubquery(col) {
-      if (isLocalized(inferred.target)) col.SELECT.localized = true
       if (!col.SELECT.from.as) {
         const uniqueSubqueryAlias = inferred.joinTree.addNextAvailableTableAlias(
           getLastStringSegment(col.SELECT.from.ref[col.SELECT.from.ref.length - 1]),
@@ -791,7 +829,6 @@ function cqn4sql(originalQuery, model = cds.context?.model || cds.model) {
         one: column.$refLinks[column.$refLinks.length - 1].definition.is2one,
       },
     }
-    if (isLocalized(inferred.target)) subquery.SELECT.localized = true
     const expanded = transformSubquery(subquery)
     const correlated = _correlate({ ...expanded, as: columnAlias }, outerAlias)
     Object.defineProperty(correlated, 'elements', { value: subquery.elements, writable: true })
@@ -907,6 +944,7 @@ function cqn4sql(originalQuery, model = cds.context?.model || cds.model) {
       outerQueries.push(inferred)
       Object.defineProperty(q, 'outerQueries', { value: outerQueries })
     }
+    if (isLocalized(inferred.target)) q.SELECT.localized = true
     return cqn4sql(q, model)
   }
 

package/lib/infer/index.js

@@ -499,20 +499,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 (!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
-                if (!inExists && element.on)
-                  throw new Error(
-                    `"${element.name}" in path "${column.ref
-                      .map(idOnly)
-                      .join('.')}" must not be an unmanaged association`,
-                  )
-                // no non-fk traversal in infix filter
-                if (nextStep && element.foreignKeys && !(nextStep in element.foreignKeys))
-                  throw new Error(`Only foreign keys of "${element.name}" can be accessed in infix filter`)
-              }
+              rejectNonFkAccess(element)
               const resolvableIn = definition.target ? definition._target : target
               column.$refLinks.push({ definition: elements[id], target: resolvableIn })
             } else {
@@ -557,6 +544,8 @@ function infer(originalQuery, model = cds.context?.model || cds.model) {
 
           const target = definition._target || column.$refLinks[i - 1].target
           if (element) {
+            if($baseLink)
+              rejectNonFkAccess(element)
             const $refLink = { definition: elements[id], target }
             column.$refLinks.push($refLink)
           } else if (firstStepIsSelf) {
@@ -658,6 +647,29 @@ function infer(originalQuery, model = cds.context?.model || cds.model) {
             }
           }
         }
+
+        /**
+         * Check if the next step in the ref is foreign key of `element`
+         * if not, an error is thrown.
+         * 
+         * @param {CSN.Element} element if this is an association, the next step must be a foreign key of the element.
+         */
+        function rejectNonFkAccess(element) {
+          if (!inNestedProjection && !inCalcElement && element.target) {
+            // only fk access in infix filter
+            const nextStep = column.ref[i + 1]?.id || column.ref[i + 1]
+            // no unmanaged assoc in infix filter path
+            if (!inExists && element.on)
+              throw new Error(
+                `"${element.name}" in path "${column.ref
+                  .map(idOnly)
+                  .join('.')}" must not be an unmanaged association`
+              )
+            // no non-fk traversal in infix filter
+            if (nextStep && element.foreignKeys && !(nextStep in element.foreignKeys))
+              throw new Error(`Only foreign keys of "${element.name}" can be accessed in infix filter`)
+          }
+        }
       })
 
       // ignore whole expand if target of assoc along path has ”@cds.persistence.skip”
@@ -680,10 +692,6 @@ function infer(originalQuery, model = cds.context?.model || cds.model) {
           ? { ref: [...baseColumn.ref, ...column.ref], $refLinks: [...baseColumn.$refLinks, ...column.$refLinks] }
           : column
         if (isColumnJoinRelevant(colWithBase)) {
-          if (originalQuery.UPDATE)
-            throw new Error(
-              'Path expressions for UPDATE statements are not supported. Use “where exists” with infix filters instead.',
-            )
           Object.defineProperty(column, 'isJoinRelevant', { value: true })
           joinTree.mergeColumn(colWithBase, originalQuery.outerQueries)
         }
@@ -873,20 +881,26 @@ function infer(originalQuery, model = cds.context?.model || cds.model) {
           if (leafOfCalculatedElementRef.value) mergePathsIntoJoinTree(leafOfCalculatedElementRef.value, basePath)
 
           mergePathIfNecessary(basePath, arg)
-        } else if (arg.xpr) {
-          arg.xpr.forEach(step => {
+        } else if (arg.xpr || arg.args) {
+          const prop = arg.xpr ? 'xpr' : 'args'
+          arg[prop].forEach(step => {
+            const subPath = { $refLinks: [...basePath.$refLinks], ref: [...basePath.ref] }
             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)
+                  mergePathsIntoJoinTree(definition.value, subPath)
                 } else {
                   subPath.$refLinks.push(link)
                   subPath.ref.push(step.ref[i])
                 }
               })
               mergePathIfNecessary(subPath, step)
+            } else if (step.args || step.xpr) {
+              const nestedProp  = step.xpr ? 'xpr' : 'args'
+              step[nestedProp].forEach(a => {
+                mergePathsIntoJoinTree(a, subPath)
+              })
             }
           })
         }

package/lib/search.js

@@ -0,0 +1,164 @@
+'use strict'
+
+const DRAFT_COLUMNS_UNION = {
+  IsActiveEntity: 1,
+  HasActiveEntity: 1,
+  HasDraftEntity: 1,
+  DraftAdministrativeData_DraftUUID: 1,
+  SiblingEntity: 1,
+  DraftAdministrativeData: 1,
+}
+const DEFAULT_SEARCHABLE_TYPE = 'cds.String'
+
+/**
+ * This method gets all columns for an entity.
+ * It includes the generated foreign keys from managed associations, structured elements and complex and custom types.
+ * As well, it provides the annotations starting with '@' for each column.
+ *
+ * @param {object} entity - the csn entity
+ * @param {object} [options]
+ * @param [options.onlyNames=false] - decides if the column name or the csn representation of the column should be returned
+ * @param [options.filterDraft=false] - indicates whether the draft columns should be filtered if the entity is draft enabled
+ * @param [options.removeIgnore=false]
+ * @param [options.filterVirtual=false]
+ * @param [options.keysOnly=false]
+ * @returns {Array<object>} - array of columns
+ */
+const getColumns = (
+  entity,
+  { onlyNames = false, removeIgnore = false, filterDraft = true, filterVirtual = false, keysOnly = false },
+) => {
+  const skipDraft = filterDraft && entity._isDraftEnabled
+  const columns = []
+  const elements = entity.elements
+
+  for (const each in elements) {
+    const element = elements[each]
+    if (element.isAssociation) continue
+    if (filterVirtual && element.virtual) continue
+    if (removeIgnore && element['@cds.api.ignore']) continue
+    if (skipDraft && each in DRAFT_COLUMNS_UNION) continue
+    if (keysOnly && !element.key) continue
+    columns.push(onlyNames ? each : element)
+  }
+
+  return columns
+}
+
+const _isColumnCalculated = (query, columnName) => {
+  if (!query) return false
+  if (query.SELECT?.columns?.find(col => col.xpr && col.as === columnName)) return true
+  return _isColumnCalculated(query._target?.query, columnName)
+}
+
+const _getSearchableColumns = entity => {
+  const columnsOptions = { removeIgnore: true, filterVirtual: true }
+  const columns = getColumns(entity, columnsOptions)
+  const cdsSearchTerm = '@cds.search'
+  const cdsSearchKeys = []
+  const cdsSearchColumnMap = new Map()
+
+  for (const key in entity) {
+    if (key.startsWith(cdsSearchTerm)) cdsSearchKeys.push(key)
+  }
+
+  let atLeastOneColumnIsSearchable = false
+
+  // build a map of columns annotated with the @cds.search annotation
+  for (const key of cdsSearchKeys) {
+    const columnName = key.split(cdsSearchTerm + '.').pop()
+
+    // REVISIT: for now, exclude search using path expression, as deep search is not currently
+    // supported
+    if (columnName.includes('.')) {
+      continue
+    }
+
+    const annotationKey = `${cdsSearchTerm}.${columnName}`
+    const annotationValue = entity[annotationKey]
+    if (annotationValue) atLeastOneColumnIsSearchable = true
+    cdsSearchColumnMap.set(columnName, annotationValue)
+  }
+
+  const searchableColumns = columns.filter(column => {
+    const annotatedColumnValue = cdsSearchColumnMap.get(column.name)
+
+    // the element is searchable if it is annotated with the @cds.search, e.g.:
+    // `@cds.search { element1: true }` or `@cds.search { element1 }`
+    if (annotatedColumnValue) return true
+
+    // 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
+
+    // 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)
+    return (
+      annotatedColumnValue === undefined &&
+      column._type === DEFAULT_SEARCHABLE_TYPE &&
+      !_isColumnCalculated(entity?.query, column.name)
+    )
+  })
+
+  // if the @cds.search annotation is provided -->
+  // Early return to ignore the interpretation of the @Search.defaultSearchElement
+  // annotation when an entity is annotated with the @cds.search annotation.
+  // The @cds.search annotation overrules the @Search.defaultSearchElement annotation.
+  if (cdsSearchKeys.length > 0) {
+    return searchableColumns.map(column => column.name)
+  }
+
+  return searchableColumns.map(column => column.name)
+}
+
+/**
+ * @returns {Array<object>} - array of columns
+ */
+const computeColumnsToBeSearched = (cqn, entity = { __searchableColumns: [] }, alias) => {
+  let toBeSearched = []
+
+  // aggregations case
+  // in the new parser groupBy is moved to sub select.
+  if (cqn._aggregated || /* new parser */ cqn.SELECT.groupBy || cqn.SELECT?.from?.SELECT?.groupBy) {
+    cqn.SELECT.columns &&
+      cqn.SELECT.columns.forEach(column => {
+        if (column.func) {
+          // exclude $count by SELECT of number of Items in a Collection
+          if (
+            cqn.SELECT.columns.length === 1 &&
+            column.func === 'count' &&
+            (column.as === '_counted_' || column.as === '$count')
+          ) {
+            return
+          }
+
+          toBeSearched.push(column)
+          return
+        }
+
+        const columnRef = column.ref
+        if (columnRef) {
+          if (entity.elements[columnRef[columnRef.length - 1]]?._type !== DEFAULT_SEARCHABLE_TYPE) return
+          column = { ref: [...column.ref] }
+          if (alias) column.ref.unshift(alias)
+          toBeSearched.push(column)
+        }
+      })
+  } else {
+    toBeSearched = entity.own('__searchableColumns') || entity.set('__searchableColumns', _getSearchableColumns(entity))
+    if (cqn.SELECT.groupBy) toBeSearched = toBeSearched.filter(tbs => cqn.SELECT.groupBy.some(gb => gb.ref[0] === tbs))
+    toBeSearched = toBeSearched.map(c => {
+      const col = { ref: [c] }
+      if (alias) col.ref.unshift(alias)
+      return col
+    })
+  }
+
+  return toBeSearched
+}
+
+module.exports = {
+  getColumns,
+  computeColumnsToBeSearched,
+}

package/package.json

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