@cap-js/db-service 1.3.1 → 1.4.0

package/CHANGELOG.md

@@ -1,10 +1,35 @@
-# Change Log
+# Changelog
 
 - All notable changes to this project are documented in this file.
 - The format is based on [Keep a Changelog](http://keepachangelog.com/).
 - This project adheres to [Semantic Versioning](http://semver.org/).
 
-## Version 1.3.1 - 2023-10-10
+## [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)
+
+
+### Fixed
+
+- preserve $count for result of SELECT queries ([#280](https://github.com/cap-js/cds-dbs/issues/280)) ([23bef24](https://github.com/cap-js/cds-dbs/commit/23bef245e62952a57ed82afcfd238c0b294b2e9e))
+
+## [1.3.1](https://github.com/cap-js/cds-dbs/compare/db-service-v1.3.0...db-service-v1.3.1) (2023-10-10)
 
 ### Fixed
 

package/README.md

@@ -12,6 +12,11 @@ This project is open to feature requests/suggestions, bug reports etc. via [GitH
 
 Contribution and feedback are encouraged and always welcome. For more information about how to contribute, the project structure, as well as additional contribution information, see our [Contribution Guidelines](CONTRIBUTING.md).
 
+## Versioning
+
+This library follows [Semantic Versioning](https://semver.org/).
+All notable changes are documented in [CHANGELOG.md](CHANGELOG.md).
+
 ## Code of Conduct
 
 We as members, contributors, and leaders pledge to make participation in our community a harassment-free experience for everyone. By participating in this project, you agree to abide by its [Code of Conduct](CODE_OF_CONDUCT.md) at all times.

package/lib/SQLService.js

@@ -18,7 +18,7 @@ class SQLService extends DatabaseService {
   init() {
     this.on(['SELECT'], this.transformStreamFromCQN)
     this.on(['UPDATE'], this.transformStreamIntoCQN)
-    this.on(['INSERT', 'UPSERT', 'UPDATE'], require('./fill-in-keys')) // REVISIT should be replaced by correct input processing eventually
+    this.on(['INSERT', 'UPSERT', 'UPDATE'], require('./fill-in-keys')) // REVISIT: should be replaced by correct input processing eventually
     this.on(['INSERT', 'UPSERT', 'UPDATE'], require('./deep-queries').onDeep)
     this.on(['SELECT'], this.onSELECT)
     this.on(['INSERT'], this.onINSERT)
@@ -79,7 +79,10 @@ class SQLService extends DatabaseService {
     let rows = await ps.all(values)
     if (rows.length)
       if (cqn.SELECT.expand) rows = rows.map(r => (typeof r._json_ === 'string' ? JSON.parse(r._json_) : r._json_ || r))
-    if (cqn.SELECT.count) rows.$count = await this.count(query, rows)
+    if (cqn.SELECT.count) {
+      // REVISIT: the runtime always expects that the count is preserved with .map, required for renaming in mocks
+      return SQLService._arrayWithCount(rows, await this.count(query, rows))
+    }
     return cqn.SELECT.one || query.SELECT.from?.ref?.[0].cardinality?.max === 1 ? rows[0] : rows
   }
 
@@ -252,6 +255,17 @@ class SQLService extends DatabaseService {
    */
   static CQN2SQL = require('./cqn2sql').class
 
+  // REVISIT: There must be a better way!
+  // preserves $count for .map calls on array
+  static _arrayWithCount = function (a, count) {
+    const _map = a.map
+    const map = function (..._) { return SQLService._arrayWithCount(_map.call(a, ..._), count) }
+    return Object.defineProperties(a, {
+      $count: { value: count, enumerable: false, configurable: true, writable: true },
+      map: { value: map, enumerable: false, configurable: true, writable: true }
+    })
+  }
+
   /** @param {unknown[]} args */
   constructor(...args) {
     super(...args)
@@ -387,6 +401,7 @@ const _unquirked = q => {
   return q
 }
 
+
 const sqls = new class extends SQLService { get factory() { return null } }
 cds.extend(cds.ql.Query).with(
   class {

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
@@ -111,11 +119,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

@@ -70,7 +70,7 @@ class CQN2SQLRenderer {
     /** @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
+    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,
@@ -527,6 +527,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 +875,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')
 
@@ -12,7 +12,7 @@ const infer = require('./infer')
 const eqOps = [['is'], ['='] /* ['=='] */]
 /**
  * For operators of <notEqOps>, do the same but use or instead of and.
- * This ensures that not struc == <value> is the same as struc != <value>.
+ * This ensures that not struct == <value> is the same as struct != <value>.
  */
 const notEqOps = [['is', 'not'], ['<>'], ['!=']]
 /**
@@ -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)
+        }
       }
     }
   }
@@ -668,12 +707,24 @@ function cqn4sql(originalQuery, model = cds.context?.model || cds.model) {
     // everything after the wildcard, is a potential replacement
     // in the wildcard expansion
     const replace = []
+
+    const baseRef = col.ref || []
+    const baseRefLinks = col.$refLinks || []
+
+    // column has no ref, then it is an anonymous expand:
+    // select from books { { * } as bar }
+    // only possible if there is exactly one query source
+    if (!baseRef.length) {
+      const [tableAlias, definition] = Object.entries(inferred.sources)[0]
+      baseRef.push(tableAlias)
+      baseRefLinks.push({ definition, source: definition })
+    }
     // we need to make the refs absolute
     col[prop].slice(wildcardIndex + 1).forEach(c => {
       const fakeColumn = { ...c }
       if (fakeColumn.ref) {
-        fakeColumn.ref = [...col.ref, ...fakeColumn.ref]
-        fakeColumn.$refLinks = [...col.$refLinks, ...c.$refLinks]
+        fakeColumn.ref = [...baseRef, ...fakeColumn.ref]
+        fakeColumn.$refLinks = [...baseRefLinks, ...c.$refLinks]
       }
       replace.push(fakeColumn)
     })
@@ -682,15 +733,15 @@ function cqn4sql(originalQuery, model = cds.context?.model || cds.model) {
       // fake the ref since excluding only has strings
       col.excluding.forEach(c => {
         const fakeColumn = {
-          ref: [...col.ref, c],
+          ref: [...baseRef, c],
         }
         exclude.push(fakeColumn)
       })
     }
 
-    if (col.$refLinks[col.$refLinks.length - 1].definition.kind === 'entity')
-      res.push(...getColumnsForWildcard(exclude, replace))
-    else
+    if (baseRefLinks.at(-1).definition.kind === 'entity') {
+      res.push(...getColumnsForWildcard(exclude, replace, col.as))
+    } else
       res.push(
         ...getFlatColumnsFor(col, { columnAlias: col.as, tableAlias: getQuerySourceName(col) }, [], {
           exclude,
@@ -907,12 +958,14 @@ function cqn4sql(originalQuery, model = cds.context?.model || cds.model) {
    *
    * Furthermore, foreign keys (FK) for OData CSN and blobs are excluded from the wildcard expansion.
    *
-   * @param {Array} exclude - An optional list of columns to be excluded during the wildcard expansion.
-   * @param {Array} replace - An optional list of columns to replace during the wildcard expansion.
+   * @param {array} exclude - An optional list of columns to be excluded during the wildcard expansion.
+   * @param {array} replace - An optional list of columns to replace during the wildcard expansion.
+   * @param {string} baseName - the explicit alias of the column.
+   * Only possible for anonymous expands on implicit table alias: `select from books { { * } as FOO }`
    *
    * @returns {Array} Returns an array of explicit columns derived from the wildcard.
    */
-  function getColumnsForWildcard(exclude = [], replace = []) {
+  function getColumnsForWildcard(exclude = [], replace = [], baseName = null) {
     const wildcardColumns = []
     Object.keys(inferred.$combinedElements)
       .filter(k => !exclude.includes(k))
@@ -927,7 +980,13 @@ function cqn4sql(originalQuery, model = cds.context?.model || cds.model) {
         } else if (isCalculatedOnRead(element)) {
           wildcardColumns.push(resolveCalculatedElement(replace.find(r => r.as === k) || element))
         } else {
-          const flatColumns = getFlatColumnsFor(element, { tableAlias: index }, [], { exclude, replace }, true)
+          const flatColumns = getFlatColumnsFor(
+            element,
+            { tableAlias: index, baseName },
+            [],
+            { exclude, replace },
+            true,
+          )
           wildcardColumns.push(...flatColumns)
         }
       })
@@ -969,7 +1028,16 @@ function cqn4sql(originalQuery, model = cds.context?.model || cds.model) {
    * Columns excluded in a wildcard expansion or replaced by other columns are also handled accordingly.
    *
    * @param {object} column - The structured element which needs to be expanded.
-   * @param {string} baseName - The prefixes of the column reference (joined with '_'). Optional.
+   * @param {{
+   *  columnAlias: string
+   *  tableAlias: string
+   *  baseName: string
+   * }} names - configuration object for naming parameters:
+   * columnAlias - The explicit alias which the user has defined for the column.
+   *                               For instance `{ struct.foo as bar}` will be transformed into
+   *                               `{ struct_foo_leaf1 as bar_foo_leaf1, struct_foo_leaf2 as bar_foo_leaf2 }`.
+   * tableAlias - The table alias to prepend to the column name. Optional.
+   * baseName - The prefixes of the column reference (joined with '_'). Optional.
    * @param {string} columnAlias - The explicit alias which the user has defined for the column.
    *                               For instance `{ struct.foo as bar}` will be transformed into
    *                               `{ struct_foo_leaf1 as bar_foo_leaf1, struct_foo_leaf2 as bar_foo_leaf2 }`.
@@ -1352,7 +1420,7 @@ function cqn4sql(originalQuery, model = cds.context?.model || cds.model) {
     if (flatRhs) {
       const flatLhs = flattenWithBaseName(token)
 
-      //Revisit: Early exit here? We kndow we cant compare the structs, however we do not know exactly why
+      //REVISIT: Early exit here? We kndow we cant compare the structs, however we do not know exactly why
       //        --> calculate error message or exit early? See test "proper error if structures cannot be compared / too many elements on lhs"
       if (flatRhs.length !== flatLhs.length)
         // make sure we can compare both structures
@@ -1419,10 +1487,10 @@ function cqn4sql(originalQuery, model = cds.context?.model || cds.model) {
 
   function assertNoStructInXpr(token, inInfixFilter = false) {
     if (!inInfixFilter && token.$refLinks?.[token.$refLinks.length - 1].definition.target)
-      // revisit: let this through if not requested otherwise
+      // REVISIT: let this through if not requested otherwise
       rejectAssocInExpression()
     if (isStructured(token.$refLinks?.[token.$refLinks.length - 1].definition))
-      // revisit: let this through if not requested otherwise
+      // REVISIT: let this through if not requested otherwise
       rejectStructInExpression()
 
     function rejectAssocInExpression() {

package/lib/infer/index.js

@@ -173,7 +173,9 @@ function infer(originalQuery, model = cds.context?.model || cds.model) {
             const nextStep = ref[1]?.id || ref[1]
             // no unmanaged assoc in infix filter path
             if (!expandOrExists && e.on)
-              throw new Error(`"${e.name}" in path "${arg.ref.map(idOnly).join('.')}" must not be an unmanaged association`)
+              throw new Error(
+                `"${e.name}" in path "${arg.ref.map(idOnly).join('.')}" must not be an unmanaged association`,
+              )
             // no non-fk traversal in infix filter
             if (!expandOrExists && nextStep && !(nextStep in e.foreignKeys))
               throw new Error(`Only foreign keys of "${e.name}" can be accessed in infix filter`)
@@ -339,13 +341,11 @@ function infer(originalQuery, model = cds.context?.model || cds.model) {
     }
 
     // walk over all paths in other query properties
-    if (where)
-      walkTokenStream(where)
-    if (groupBy)
-      groupBy.forEach(token => inferQueryElement(token, false))
-    if (having)
-      walkTokenStream(having)
-    if (_.with) // consider UPDATE.with
+    if (where) walkTokenStream(where)
+    if (groupBy) groupBy.forEach(token => inferQueryElement(token, false))
+    if (having) walkTokenStream(having)
+    if (_.with)
+      // consider UPDATE.with
       Object.values(_.with).forEach(val => inferQueryElement(val, false))
 
     return queryElements
@@ -355,8 +355,8 @@ function infer(originalQuery, model = cds.context?.model || cds.model) {
      * on the information whether the next token is resolved within an `exists` predicates.
      * If such a token has an infix filter, it is not join relevant, because the filter
      * condition is applied to the generated `exists <subquery>` condition.
-     * 
-     * @param {array} tokenStream 
+     *
+     * @param {array} tokenStream
      */
     function walkTokenStream(tokenStream) {
       let skipJoins
@@ -476,12 +476,10 @@ function infer(originalQuery, model = cds.context?.model || cds.model) {
       // if any path step points to an artifact with `@cds.persistence.skip`
       // we must ignore the element from the queries elements
       let isPersisted = true
-      const firstStepIsTableAlias =
-        (column.ref.length > 1 && column.ref[0] in sources) ||
-        // nested projection on table alias
-        (column.ref.length === 1 && column.ref[0] in sources && column.inline)
+      const firstStepIsTableAlias = column.ref.length > 1 && column.ref[0] in sources
       const firstStepIsSelf =
         !firstStepIsTableAlias && column.ref.length > 1 && ['$self', '$projection'].includes(column.ref[0])
+      const expandOnTableAlias = column.ref.length === 1 && column.ref[0] in sources && (column.expand || column.inline)
       const nameSegments = []
       // if a (segment) of a (structured) foreign key is renamed, we must not include
       // the aliased ref segments into the name of the final foreign key which is e.g. used in
@@ -501,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 {
@@ -535,6 +520,12 @@ function infer(originalQuery, model = cds.context?.model || cds.model) {
             const $refLink = { definition, target: $combinedElements[id][0].tableAlias }
             column.$refLinks.push($refLink)
             nameSegments.push(id)
+          } else if (expandOnTableAlias) {
+            // expand on table alias
+            column.$refLinks.push({
+              definition: sources[id],
+              target: sources[id],
+            })
           } else {
             stepNotFoundInCombinedElements(id) // REVISIT: fails with {__proto__:elements)
           }
@@ -545,14 +536,16 @@ function infer(originalQuery, model = cds.context?.model || cds.model) {
 
           if (firstStepIsSelf && element?.isAssociation) {
             throw new Error(
-              `Paths starting with “$self” must not contain steps of type “cds.Association”: ref: [ ${column.ref.map(
-                idOnly,
-              ).join(', ')} ]`,
+              `Paths starting with “$self” must not contain steps of type “cds.Association”: ref: [ ${column.ref
+                .map(idOnly)
+                .join(', ')} ]`,
             )
           }
 
           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) {
@@ -619,7 +612,12 @@ function infer(originalQuery, model = cds.context?.model || cds.model) {
             if (insertIntoQueryElements) queryElements[column.as || flatName] = getCopyWithAnnos(column, base)
           } else if (column.expand) {
             const elements = resolveExpand(column)
-            if (insertIntoQueryElements) queryElements[column.as || flatName] = elements
+            let elementName
+            // expand on table alias
+            if (column.$refLinks.length === 1 && column.$refLinks[0].definition.kind === 'entity')
+              elementName = column.$refLinks[0].alias
+            else elementName = column.as || flatName
+            if (insertIntoQueryElements) queryElements[elementName] = elements
           } else if (column.inline && insertIntoQueryElements) {
             const elements = resolveInline(column)
             queryElements = { ...queryElements, ...elements }
@@ -649,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”
@@ -671,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)
         }
@@ -752,8 +769,8 @@ function infer(originalQuery, model = cds.context?.model || cds.model) {
        */
       function resolveExpand(col) {
         const { expand, $refLinks } = col
-        const $leafLink = $refLinks?.[$refLinks.length - 1]
-        if ($leafLink?.definition._target) {
+        const $leafLink = $refLinks?.[$refLinks.length - 1] || inferred.SELECT.from.$refLinks.at(-1) // fallback to anonymous expand
+        if ($leafLink.definition._target) {
           const expandSubquery = {
             SELECT: {
               from: $leafLink.definition._target.name,
@@ -864,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/infer/join-tree.js

@@ -148,7 +148,6 @@ class JoinTree {
    *
    * It begins by inferring the source of the given column, which is the table alias where the column is resolvable.
    * Each step during this process represents a node in the join tree. If a node already exists in the tree, the current step is replaced by the already merged node.
-   * For each step, it checks whether it has been seen before. If so, it resets the $refLink to point to the already merged $refLink.
    * If not, it creates a new Node and ensures proper aliasing and foreign key access.
    *
    * @param {object} col - The column object to be merged into the existing join tree. This object should have the properties $refLinks and ref.

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.1",
+  "version": "1.4.0",
   "description": "CDS base database service",
   "homepage": "https://github.com/cap-js/cds-dbs/tree/main/db-service#cds-base-database-service",
   "repository": {