@cap-js/db-service 1.6.4 → 1.8.0

package/CHANGELOG.md

@@ -4,6 +4,45 @@
 - The format is based on [Keep a Changelog](http://keepachangelog.com/).
 - This project adheres to [Semantic Versioning](http://semver.org/).
 
+## [1.8.0](https://github.com/cap-js/cds-dbs/compare/db-service-v1.7.0...db-service-v1.8.0) (2024-04-12)
+
+
+### Added
+
+* Odata built-in query functions ([#558](https://github.com/cap-js/cds-dbs/issues/558)) ([6e63367](https://github.com/cap-js/cds-dbs/commit/6e6336757129c4a9dac56f93fd768bb41d071c46))
+* support HANA stored procedures ([#542](https://github.com/cap-js/cds-dbs/issues/542)) ([52a00a0](https://github.com/cap-js/cds-dbs/commit/52a00a0d642ba3c58dcad97b3ea1456f1bf3b04a))
+
+
+### Fixed
+
+* **`expand`:** Only accept on structures, assocs or table aliases ([#551](https://github.com/cap-js/cds-dbs/issues/551)) ([3248512](https://github.com/cap-js/cds-dbs/commit/32485129147cd1b376f1d2faf2ea7c7232ba3794))
+* **`order by`:** for localized sorting, prepend table alias ([#546](https://github.com/cap-js/cds-dbs/issues/546)) ([a273a92](https://github.com/cap-js/cds-dbs/commit/a273a9278b2551ed3381795effe28cf8de41b1bd))
+* etag with stream_compat ([#562](https://github.com/cap-js/cds-dbs/issues/562)) ([b0a3a41](https://github.com/cap-js/cds-dbs/commit/b0a3a418fbcff7eb7e7b8fa4ff031e1c0c0faac4))
+* exclude `cds.LargeBinary` from wildcard expansion ([#577](https://github.com/cap-js/cds-dbs/issues/577)) ([6661d63](https://github.com/cap-js/cds-dbs/commit/6661d635b2895a13d47e42495acf6fbd7247c535))
+* Reduce insert queries for deep update ([#568](https://github.com/cap-js/cds-dbs/issues/568)) ([55e5114](https://github.com/cap-js/cds-dbs/commit/55e511471743c0445d41e8297f5530abe167a270))
+* Reduced count query complexity when possible ([#553](https://github.com/cap-js/cds-dbs/issues/553)) ([3331f02](https://github.com/cap-js/cds-dbs/commit/3331f0224f02bd2e6cc9c6d2cd5f1c37a36ec8dd))
+
+## [1.7.0](https://github.com/cap-js/cds-dbs/compare/db-service-v1.6.4...db-service-v1.7.0) (2024-03-22)
+
+
+### Added
+
+* also support lowercase matchespattern function ([#528](https://github.com/cap-js/cds-dbs/issues/528)) ([6ea574e](https://github.com/cap-js/cds-dbs/commit/6ea574ee67ef5e42e4f8ccbe4fe91b46097de129))
+* forUpdate and forShareLock ([#148](https://github.com/cap-js/cds-dbs/issues/148)) ([99a1170](https://github.com/cap-js/cds-dbs/commit/99a1170e61de4fd0c505834c25a9c03fc34da85b))
+* **hana:** drop prepared statements after end of transaction ([#537](https://github.com/cap-js/cds-dbs/issues/537)) ([b1f864e](https://github.com/cap-js/cds-dbs/commit/b1f864e0a3a0e5efacd803d3709379cab76d61cc))
+* **hana:** Add views with parameters support ([#488](https://github.com/cap-js/cds-dbs/issues/488)) ([3790ec0](https://github.com/cap-js/cds-dbs/commit/3790ec0178aab2cdb429272bb3e813b13441785c))
+* **orderby:** allow to disable collations with [@cds](https://github.com/cds).collate: false ([#492](https://github.com/cap-js/cds-dbs/issues/492)) ([820f971](https://github.com/cap-js/cds-dbs/commit/820f971e1ad21fa8f8ca289c1e29b373365df484))
+
+
+### Fixed
+
+* **cqn2sql:** Smart quoting of columns inside UPSERT rows ([#519](https://github.com/cap-js/cds-dbs/issues/519)) ([78fe10b](https://github.com/cap-js/cds-dbs/commit/78fe10b1df3691614dc77b1d4f82df10a1d641d3))
+* Getting rid of quirks mode ([#514](https://github.com/cap-js/cds-dbs/issues/514)) ([c9aa6e8](https://github.com/cap-js/cds-dbs/commit/c9aa6e835761ace38447f37cad6a5f39cb0b910c))
+* issue with reused select cqns ([#505](https://github.com/cap-js/cds-dbs/issues/505)) ([916d175](https://github.com/cap-js/cds-dbs/commit/916d1756422f0caf02c323052f2addafed39182a))
+* joins without columns are rejected ([#535](https://github.com/cap-js/cds-dbs/issues/535)) ([eb9beda](https://github.com/cap-js/cds-dbs/commit/eb9beda728de60081d7afbfcd49305eeb241f3fb))
+* **search:** dont search non string aggregations ([#527](https://github.com/cap-js/cds-dbs/issues/527)) ([c87900c](https://github.com/cap-js/cds-dbs/commit/c87900cb157041a6ff76c45192c1d33180840d0f))
+* **search:** search on aggregated results in HAVING clause  ([#524](https://github.com/cap-js/cds-dbs/issues/524)) ([61d348e](https://github.com/cap-js/cds-dbs/commit/61d348ebc2528b7f1c6da8c78a7455a438e1b7cf))
+
 ## [1.6.4](https://github.com/cap-js/cds-dbs/compare/db-service-v1.6.3...db-service-v1.6.4) (2024-02-28)
 
 

package/lib/SQLService.js

@@ -123,15 +123,26 @@ class SQLService extends DatabaseService {
     }
 
     const { sql, values, cqn } = this.cqn2sql(query, data)
+    const expand = query.SELECT.expand
+    delete query.SELECT.expand
+
     let ps = await this.prepare(sql)
     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 (expand) rows = rows.map(r => (typeof r._json_ === 'string' ? JSON.parse(r._json_) : r._json_ || r))
 
     if (cds.env.features.stream_compat) {
       if (query._streaming) {
         this._changeToStreams(cqn.SELECT.columns, rows, true, true)
-        return rows.length ? { value: Object.values(rows[0])[0] } : undefined
+        if (!rows.length) return
+        
+        const result = rows[0]
+        // stream is always on position 0. Further properties like etag are inserted later.
+        let [key, val] = Object.entries(result)[0]
+        result.value = val
+        delete result[key]
+
+        return result
       }
     } else {
       this._changeToStreams(cqn.SELECT.columns, rows, query.SELECT.one, false)
@@ -262,7 +273,7 @@ class SQLService extends DatabaseService {
    * @param {string} sql
    */
   hasResults(sql) {
-    return /^(SELECT|WITH|CALL|PRAGMA table_info)/i.test(sql)
+    return /^\s*(SELECT|WITH|CALL|PRAGMA table_info)/i.test(sql)
   }
 
   /**
@@ -278,17 +289,23 @@ class SQLService extends DatabaseService {
       const [max, offset = 0] = one ? [1] : _ ? [_.rows?.val, _.offset?.val] : []
       if (max === undefined || (n < max && (n || !offset))) return n + offset
     }
-    // REVISIT: made uppercase count because of HANA reserved word quoting
-    const cq = SELECT.one([{ func: 'count', as: 'COUNT' }]).from(
+
+    // Keep original query columns when potentially used insde conditions
+    const { having, groupBy } = query.SELECT
+    const columns = (having?.length || groupBy?.length)
+      ? query.SELECT.columns.filter(c => !c.expand)
+      : [{ val: 1 }]
+    const cq = SELECT.one([{ func: 'count' }]).from(
       cds.ql.clone(query, {
+        columns,
         localized: false,
         expand: false,
         limit: undefined,
         orderBy: undefined,
       }),
     )
-    const { count, COUNT } = await this.onSELECT({ query: cq })
-    return count ?? COUNT
+    const { count } = await this.onSELECT({ query: cq })
+    return count
   }
 
   /**
@@ -428,6 +445,8 @@ SQLService.prototype.PreparedStatement = PreparedStatement
 
 const _target_name4 = q => {
   const target =
+    q._target_ref ||
+    q.from_into_ntt ||
     q.SELECT?.from ||
     q.INSERT?.into ||
     q.UPSERT?.into ||
@@ -441,7 +460,7 @@ const _target_name4 = q => {
   return first.id || first
 }
 
-const _unquirked = q => {
+const _unquirked = !cds.env.ql.quirks_mode ? q => q : q => {
   if (!q) return q
   else if (typeof q.SELECT?.from === 'string') q.SELECT.from = { ref: [q.SELECT.from] }
   else if (typeof q.INSERT?.into === 'string') q.INSERT.into = { ref: [q.INSERT.into] }

package/lib/common/DatabaseService.js

@@ -132,9 +132,9 @@ class DatabaseService extends cds.Service {
     const tenants = tenant ? [tenant] : Object.keys(this.pools)
     await Promise.all (tenants.map (async t => {
       const pool = this.pools[t]; if (!pool) return
+      delete this.pools[t]
       await pool.drain()
       await pool.clear()
-      delete this.pools[t]
     }))
   }
 

package/lib/cql-functions.js

@@ -99,6 +99,13 @@ const StandardFunctions = {
    * @returns {string}
    */
   matchesPattern: (x, y) => `(${x} regexp ${y})`,
+  /**
+   * Generates SQL statement that matches the given string against a regular expression
+   * @param {string} x
+   * @param {string} y
+   * @returns {string}
+   */
+  matchespattern: (x, y) => `(${x} regexp ${y})`,
   /**
    * Generates SQL statement that produces the lower case value of a given string
    * @param {string} x
@@ -145,6 +152,13 @@ const StandardFunctions = {
   current_time: p => (p ? `current_time(${p})` : 'current_time'),
   current_timestamp: p => (p ? `current_timestamp(${p})` : 'current_timestamp'),
 
+  /**
+   * Generates SQL statement that produces current point in time (date and time with time zone)
+   * @returns {string}
+   */
+   now: function() {
+    return this.session_context({val: '$now'})
+  },
   /**
    * Generates SQL statement that produces the year of a given timestamp
    * @param {string} x
@@ -182,29 +196,27 @@ const StandardFunctions = {
    * /
   second: x => `cast( strftime('%S',${x}) as Integer )`,
 
+  // REVISIT: make precision configurable
   /**
    * Generates SQL statement that produces the fractional seconds of a given timestamp
    * @param {string} x
    * @returns {string}
    */
-  fractionalseconds: x => `cast( strftime('%f0000',${x}) as Integer )`,
+  fractionalseconds: x => `cast( substr( strftime('%f', ${x}), length(strftime('%f', ${x})) - 3) as REAL)`,
 
   /**
    * maximum date time value
    * @returns {string}
    */
-  maxdatetime: () => '9999-12-31 23:59:59.999',
+  maxdatetime: () => "'9999-12-31T23:59:59.999Z'",
   /**
    * minimum date time value
    * @returns {string}
    */
-  mindatetime: () => '0001-01-01 00:00:00.000',
+  mindatetime: () => "'0001-01-01T00:00:00.000Z'",
 
   // odata spec defines the date time offset type as a normal ISO time stamp
   // Where the timezone can either be 'Z' (for UTC) or [+|-]xx:xx for the time offset
-  // sqlite understands this so by splitting the timezone from the actual date
-  // prefixing it with 1970 it allows sqlite to give back the number of seconds
-  // which can be divided by 60 back to minutes
   /**
    * Generates SQL statement that produces the offset in minutes of a given date time offset string
    * @param {string} x
@@ -212,7 +224,9 @@ const StandardFunctions = {
    */
   totaloffsetminutes: x => `case
     when substr(${x}, length(${x})) = 'z' then 0
-    else strftime('%s', '1970-01-01T00:00:00' || substr(${x}, length(${x}) - 5)) / 60
+    else sign( cast( substr(${x}, length(${x}) - 5) as Integer )) *
+    ( cast( strftime('%H', substr(${x}, length(${x}) - 4 )) as Integer ) * 60 +
+    cast( strftime('%M', substr(${x},length(${x}) - 4 )) as Integer ))
   end`,
 
   // odata spec defines the value format for totalseconds as a duration like: P12DT23H59M59.999999999999S

package/lib/cqn2sql.js

@@ -40,7 +40,9 @@ class CQN2SQLRenderer {
     for (let each in mixins) {
       const def = types[each]
       if (!def) continue
-      Object.defineProperty(def, fqn, { value: mixins[each] })
+      const value = mixins[each]
+      if (value?.get) Object.defineProperty(def, fqn, { get: value.get })
+      else Object.defineProperty(def, fqn, { value })
     }
     return fqn
   }
@@ -193,7 +195,7 @@ class CQN2SQLRenderer {
   DROP(q) {
     const { target } = q
     const isView = target.query || target.projection
-    return (this.sql = `DROP ${isView ? 'VIEW' : 'TABLE'} IF EXISTS ${this.name(target.name)}`)
+    return (this.sql = `DROP ${isView ? 'VIEW' : 'TABLE'} IF EXISTS ${this.quote(this.name(target.name))}`)
   }
 
   // SELECT Statements ------------------------------------------------
@@ -203,7 +205,13 @@ class CQN2SQLRenderer {
    * @param {import('./infer/cqn').SELECT} q
    */
   SELECT(q) {
-    let { from, expand, where, groupBy, having, orderBy, limit, one, distinct, localized } = q.SELECT
+    let { from, expand, where, groupBy, having, orderBy, limit, one, distinct, localized, forUpdate, forShareLock } =
+      q.SELECT
+
+    if (from?.join && !q.SELECT.columns) {
+      throw new Error('CQN query using joins must specify the selected columns.')
+    }
+    
     // REVISIT: When selecting from an entity that is not in the model the from.where are not normalized (as cqn4sql is skipped)
     if (!where && from?.ref?.length === 1 && from.ref[0]?.where) where = from.ref[0]?.where
     let columns = this.SELECT_columns(q)
@@ -217,6 +225,8 @@ class CQN2SQLRenderer {
     if (!_empty(orderBy)) sql += ` ORDER BY ${this.orderBy(orderBy, localized)}`
     if (one) limit = Object.assign({}, limit, { rows: { val: 1 } })
     if (limit) sql += ` LIMIT ${this.limit(limit)}`
+    if (forUpdate) sql += ` ${this.forUpdate(forUpdate)}`
+    else if (forShareLock) sql += ` ${this.forShareLock(forShareLock)}`
     // Expand cannot work without an inferred query
     if (expand) {
       if ('elements' in q) sql = this.SELECT_expand(q, sql)
@@ -303,12 +313,28 @@ class CQN2SQLRenderer {
   from(from) {
     const { ref, as } = from
     const _aliased = as ? s => s + ` as ${this.quote(as)}` : s => s
-    if (ref) return _aliased(this.quote(this.name(ref[0])))
+    if (ref) {
+      const z = ref[0]
+      if (z.args) {
+        return _aliased(`${this.quote(this.name(z))}${this.from_args(z.args)}`)
+      }
+      return _aliased(this.quote(this.name(z)))
+    }
     if (from.SELECT) return _aliased(`(${this.SELECT(from)})`)
     if (from.join)
       return `${this.from(from.args[0])} ${from.join} JOIN ${this.from(from.args[1])} ON ${this.where(from.on)}`
   }
 
+  /**
+   * Renders a FROM clause into generic SQL
+   * @param {import('./infer/cqn').ref['ref'][0]['args']} args
+   * @returns {string} SQL
+   */
+  from_args(args) {
+    args
+    cds.error`Parameterized views are not supported by ${this.constructor.name}`
+  }
+
   /**
    * Renders a WHERE clause into generic SQL
    * @param {import('./infer/cqn').predicate} xpr
@@ -364,6 +390,32 @@ class CQN2SQLRenderer {
     return !offset ? rows.val : `${rows.val} OFFSET ${offset.val}`
   }
 
+  /**
+   * Renders an forUpdate clause into generic SQL
+   * @param {import('./infer/cqn').SELECT["SELECT"]["forUpdate"]} update
+   * @returns {string} SQL
+   */
+  forUpdate(update) {
+    const { wait, of } = update
+    let sql = 'FOR UPDATE'
+    if (!_empty(of)) sql += ` OF ${of.map(x => this.expr(x)).join(', ')}`
+    if (typeof wait === 'number') sql += ` WAIT ${wait}`
+    return sql
+  }
+
+  /**
+   * Renders an forShareLock clause into generic SQL
+   * @param {import('./infer/cqn').SELECT["SELECT"]["forShareLock"]} update
+   * @returns {string} SQL
+   */
+  forShareLock(lock) {
+    const { wait, of } = lock
+    let sql = 'FOR SHARE LOCK'
+    if (!_empty(of)) sql += ` OF ${of.map(x => this.expr(x)).join(', ')}`
+    if (typeof wait === 'number') sql += ` WAIT ${wait}`
+    return sql
+  }
+
   // INSERT Statements ------------------------------------------------
 
   /**
@@ -402,12 +454,12 @@ class CQN2SQLRenderer {
       : ObjectKeys(INSERT.entries[0])
 
     /** @type {string[]} */
-    this.columns = columns.filter(elements ? c => !elements[c]?.['@cds.extension'] : () => true).map(c => this.quote(c))
+    this.columns = columns.filter(elements ? c => !elements[c]?.['@cds.extension'] : () => true)
 
     if (!elements) {
       this.entries = INSERT.entries.map(e => columns.map(c => e[c]))
       const param = this.param.bind(this, { ref: ['?'] })
-      return (this.sql = `INSERT INTO ${this.quote(entity)}${alias ? ' as ' + this.quote(alias) : ''} (${this.columns}) VALUES (${columns.map(param)})`)
+      return (this.sql = `INSERT INTO ${this.quote(entity)}${alias ? ' as ' + this.quote(alias) : ''} (${this.columns.map(c => this.quote(c))}) VALUES (${columns.map(param)})`)
     }
 
     const extractions = this.managed(
@@ -446,7 +498,7 @@ class CQN2SQLRenderer {
       this.entries = [[...this.values, stream]]
     }
 
-    return (this.sql = `INSERT INTO ${this.quote(entity)}${alias ? ' as ' + this.quote(alias) : ''} (${this.columns
+    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(?)`)
   }
 
@@ -573,12 +625,12 @@ class CQN2SQLRenderer {
       return converter?.(extract, element) || extract
     })
 
-    this.columns = columns.map(c => this.quote(c))
+    this.columns = columns
 
     if (!elements) {
       this.entries = INSERT.rows
       const param = this.param.bind(this, { ref: ['?'] })
-      return (this.sql = `INSERT INTO ${this.quote(entity)}${alias ? ' as ' + this.quote(alias) : ''} (${this.columns}) VALUES (${columns.map(param)})`)
+      return (this.sql = `INSERT INTO ${this.quote(entity)}${alias ? ' as ' + this.quote(alias) : ''} (${this.columns.map(c => this.quote(c))}) VALUES (${columns.map(param)})`)
     }
 
     if (INSERT.rows[0] instanceof Readable) {
@@ -590,7 +642,7 @@ class CQN2SQLRenderer {
       this.entries = [[...this.values, stream]]
     }
 
-    return (this.sql = `INSERT INTO ${this.quote(entity)}${alias ? ' as ' + this.quote(alias) : ''} (${this.columns
+    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(?)`)
   }
 
@@ -617,7 +669,7 @@ class CQN2SQLRenderer {
     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}) ${this.SELECT(
+    this.sql = `INSERT INTO ${this.quote(entity)}${alias ? ' as ' + this.quote(alias) : ''} (${columns.map(c => this.quote(c))}) ${this.SELECT(
       this.cqn4sql(INSERT.as),
     )}`
     this.entries = [this.values]
@@ -641,7 +693,7 @@ class CQN2SQLRenderer {
   /** @type {import('./converters').Converters} */
   static OutputConverters = {} // subclasses to override
 
-  static localized = { String: true, UUID: false }
+  static localized = { String: { get() { return this['@cds.collate'] !== false } }, UUID: false }
 
   // UPSERT Statements ------------------------------------------------
 

package/lib/cqn4sql.js

@@ -111,7 +111,7 @@ 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(originalQuery.sources)[0]
+        const queryTarget = Object.values(originalQuery.sources)[0].definition
         const keys = Object.values(queryTarget.elements).filter(e => e.key === true)
         const primaryKey = { list: [] }
         keys.forEach(k => {
@@ -181,10 +181,9 @@ function cqn4sql(originalQuery, model) {
 
     if (inferred.SELECT.search) {
       // Search target can be a navigation, in that case use _target to get the correct entity
-      const where = transformSearchToWhere(inferred.SELECT.search, transformedFrom)
-      if (where) {
-        transformedQuery.SELECT.where = where
-      }
+      const { where, having } = transformSearch(inferred.SELECT.search, transformedFrom) || {}
+      if (where) transformedQuery.SELECT.where = where
+      else if (having) transformedQuery.SELECT.having = having
     }
     return transformedQuery
   }
@@ -204,20 +203,26 @@ function cqn4sql(originalQuery, model) {
   }
 
   /**
-   * Transforms a search expression to a WHERE clause for a SELECT operation.
+   * Transforms a search expression into a WHERE or HAVING clause for a SELECT operation, depending on the context of the query.
+   * The function decides whether to use a WHERE or HAVING clause based on the presence of aggregated columns in the search criteria.
    *
-   * @param {object} search - The search expression which shall be applied to the searchable columns on the query source.
+   * @param {object} search - The search expression to be applied to the searchable columns within the query source.
    * @param {object} from - The FROM clause of the CQN statement.
    *
-   * @returns {(Object|Array|undefined)} - If the target of the query contains searchable elements, the function returns an array that represents the WHERE clause.
-   *     If the SELECT query already contains a WHERE clause, this array includes the existing clause and appends an AND condition with the new 'contains' clause.
-   *     If the SELECT query does not contain a WHERE clause, the returned array solely consists of the 'contains' clause.
-   *     If the target entity of the query does not contain searchable elements, the function returns null.
+   * @returns {(Object|Array|null)} - The function returns an object representing the WHERE or HAVING clause of the query:
+   *     - If the target of the query contains searchable elements, an array representing the WHERE or HAVING clause is returned.
+   *       This includes appending to an existing clause with an AND condition or creating a new clause solely with the 'contains' clause.
+   *     - If the SELECT query does not initially contain a WHERE or HAVING clause, the returned object solely consists of the 'contains' clause.
+   *     - If the target entity of the query does not contain searchable elements, the function returns null.
    *
+   * Note: The WHERE clause is used for filtering individual rows before any aggregation occurs.
+   * The HAVING clause is utilized for conditions on aggregated data, applied after grouping operations.
    */
-  function transformSearchToWhere(search, from) {
-    const entity = from.$refLinks[0].definition._target || from.$refLinks[0].definition
-    const searchIn = computeColumnsToBeSearched(inferred, entity, from.as)
+  function transformSearch(search, from) {
+    const entity = getDefinition(from.$refLinks[0].definition.target) || from.$refLinks[0].definition
+    // pass transformedQuery because we may need to search in the columns directly
+    // in case of aggregation
+    const searchIn = computeColumnsToBeSearched(transformedQuery, entity, from.as)
     if (searchIn.length > 0) {
       const xpr = search
       const contains = {
@@ -228,10 +233,16 @@ function cqn4sql(originalQuery, model) {
         ],
       }
 
-      if (transformedQuery.SELECT.where) {
-        return [asXpr(transformedQuery.SELECT.where), 'and', contains]
+      // if the query is grouped and the queries columns contain an aggregate function,
+      // we must put the search term into the `having` clause, as the search expression
+      // is defined on the aggregated result, not on the individual rows
+      let prop = 'where'
+
+      if (inferred.SELECT.groupBy && searchIn.some(c => c.func || c.xpr)) prop = 'having'
+      if (transformedQuery.SELECT[prop]) {
+        return { [prop]: [asXpr(transformedQuery.SELECT.where), 'and', contains] }
       } else {
-        return [contains]
+        return { [prop]: [contains] }
       }
     } else {
       return null
@@ -255,9 +266,12 @@ function cqn4sql(originalQuery, model) {
      */
     const alreadySeen = new Map()
     inferred.joinTree._roots.forEach(r => {
-      const args = r.queryArtifact.SELECT
-        ? [{ SELECT: transformSubquery(r.queryArtifact).SELECT, as: r.alias }]
-        : [{ ref: [localized(r.queryArtifact)], as: r.alias }]
+      const args = []
+      if (r.queryArtifact.SELECT) args.push({ SELECT: transformSubquery(r.queryArtifact).SELECT, as: r.alias })
+      else {
+        const id = localized(r.queryArtifact)
+        args.push({ ref: [r.args ? { id, args: r.args } : id], as: r.alias })
+      }
       from = { join: 'left', args, on: [] }
       r.children.forEach(c => {
         from = joinForBranch(from, c)
@@ -282,10 +296,13 @@ function cqn4sql(originalQuery, model) {
         ),
       )
 
+      const id = localized(getDefinition(nextAssoc.$refLink.definition.target))
+      const { args } = nextAssoc
       const arg = {
-        ref: [localized(model.definitions[nextAssoc.$refLink.definition.target])],
+        ref: [args ? { id, args } : id],
         as: nextAssoc.$refLink.alias,
       }
+
       lhs.args.push(arg)
       alreadySeen.set(nextAssoc.$refLink.alias, true)
       if (nextAssoc.where) {
@@ -438,7 +455,7 @@ function cqn4sql(originalQuery, model) {
       const refNavigation = col.ref.slice(col.$refLinks[0].definition.kind !== 'element' ? 1 : 0).join('_')
       if (!columnAlias && col.flatName && col.flatName !== refNavigation) columnAlias = refNavigation
 
-      if (col.$refLinks.some(link => link.definition._target?.['@cds.persistence.skip'] === true)) return
+      if (col.$refLinks.some(link => getDefinition(link.definition.target)?.['@cds.persistence.skip'] === true)) return
 
       const flatColumns = getFlatColumnsFor(col, { baseName, columnAlias, tableAlias })
       flatColumns.forEach(flatColumn => {
@@ -472,13 +489,17 @@ function cqn4sql(originalQuery, model) {
 
     function getTransformedColumn(col) {
       if (col.xpr) {
-        return { xpr: getTransformedTokenStream(col.xpr) }
+        const xpr = { xpr: getTransformedTokenStream(col.xpr) }
+        if (col.cast) xpr.cast = col.cast
+        return xpr
       } else if (col.func) {
-        return {
+        const func = {
           func: col.func,
           args: col.args && getTransformedTokenStream(col.args),
-          as: col.func,
+          as: col.func, // may be overwritten by the explicit alias
         }
+        if (col.cast) func.cast = col.cast
+        return func
       } else {
         return copy(col)
       }
@@ -680,7 +701,7 @@ function cqn4sql(originalQuery, model) {
     // 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]
+      const [tableAlias, { definition }] = Object.entries(inferred.sources)[0]
       baseRef.push(tableAlias)
       baseRefLinks.push({ definition, source: definition })
     }
@@ -833,7 +854,7 @@ function cqn4sql(originalQuery, model) {
   function getTransformedOrderByGroupBy(columns, inOrderBy = false) {
     const res = []
     for (let i = 0; i < columns.length; i++) {
-      const col = columns[i]
+      let col = columns[i]
       if (isCalculatedOnRead(col.$refLinks?.[col.$refLinks.length - 1].definition)) {
         const calcElement = resolveCalculatedElement(col, true)
         res.push(calcElement)
@@ -849,14 +870,44 @@ function cqn4sql(originalQuery, model) {
       } else if (pseudos.elements[col.ref?.[0]]) {
         res.push({ ...col })
       } else if (col.ref) {
-        if (col.$refLinks.some(link => link.definition._target?.['@cds.persistence.skip'] === true)) continue
+        if (col.$refLinks.some(link => getDefinition(link.definition.target)?.['@cds.persistence.skip'] === true))
+          continue
         if (col.ref.length > 1 && col.ref[0] === '$self' && !col.$refLinks[0].definition.kind) {
           const dollarSelfReplacement = calculateDollarSelfColumn(col)
           res.push(...getTransformedOrderByGroupBy([dollarSelfReplacement], inOrderBy))
           continue
         }
-        const { target } = col.$refLinks[0]
-        const tableAlias = target.SELECT ? null : getQuerySourceName(col) // do not prepend TA if orderBy column addresses element of query
+        const { target, definition } = col.$refLinks[0]
+        let tableAlias = null
+        if (target.SELECT?.columns && inOrderBy) {
+          // usually TA is omitted if order by ref is a column
+          // if a localized sorting is requested, we add `COLLATE`s
+          // later on, which transforms the simple name to an expression
+          // --> in an expression, only source elements can be addressed, hence we must add TA
+          if (target.SELECT.localized && definition.type === 'cds.String') {
+            const referredCol = target.SELECT.columns.find(c => {
+              return c.as === col.ref[0] || c.ref?.at(-1) === col.ref[0]
+            })
+            if (referredCol) {
+              // keep sort and nulls properties
+              referredCol.sort = col.sort
+              referredCol.nulls = col.nulls
+              col = referredCol
+              if (definition.kind === 'element') {
+                tableAlias = getQuerySourceName(col)
+              } else {
+                // we must replace the reference with the underlying expression
+                const { val, func, args, xpr } = col
+                if (val) res.push({ val })
+                if (func) res.push({ func, args })
+                if (xpr) res.push({ xpr })
+                continue
+              }
+            }
+          }
+        } else {
+          tableAlias = getQuerySourceName(col) // do not prepend TA if orderBy column addresses element of query
+        }
         const leaf = col.$refLinks[col.$refLinks.length - 1].definition
         if (leaf.virtual === true) continue // already in getFlatColumnForElement
         let baseName
@@ -950,7 +1001,7 @@ function cqn4sql(originalQuery, model) {
         const { index, tableAlias } = inferred.$combinedElements[k][0]
         const element = tableAlias.elements[k]
         // ignore FK for odata csn / ignore blobs from wildcard expansion
-        if (isManagedAssocInFlatMode(element) || (element['@Core.MediaType'] && !element['@Core.IsURL'])) return
+        if (isManagedAssocInFlatMode(element) || element.type === 'cds.LargeBinary') return
         // for wildcard on subquery in from, just reference the elements
         if (tableAlias.SELECT && !element.elements && !element.target) {
           wildcardColumns.push(index ? { ref: [index, k] } : { ref: [k] })
@@ -991,7 +1042,7 @@ function cqn4sql(originalQuery, model) {
    */
   function getElementForRef(ref, def) {
     return ref.reduce((prev, res) => {
-      return (prev?.elements || prev?.foreignKeys)?.[res] || prev?._target?.elements[res] // PLEASE REVIEW: should we add the .foreignKey check here for the non-ucsn case?
+      return (prev?.elements || prev?.foreignKeys)?.[res] || getDefinition(prev?.target)?.elements[res] // PLEASE REVIEW: should we add the .foreignKey check here for the non-ucsn case?
     }, def)
   }
 
@@ -1087,7 +1138,7 @@ function cqn4sql(originalQuery, model) {
     if (element.keys) {
       const flatColumns = []
       element.keys.forEach(fk => {
-        const fkElement = getElementForRef(fk.ref, element._target)
+        const fkElement = getElementForRef(fk.ref, getDefinition(element.target))
         let fkBaseName
         if (!leafAssoc || leafAssoc.onlyForeignKeyAccess)
           fkBaseName = `${baseName}_${fk.as || fk.ref[fk.ref.length - 1]}`
@@ -1141,7 +1192,7 @@ function cqn4sql(originalQuery, model) {
           if (tableAlias) flatColumn.ref.unshift(tableAlias)
 
           // in a flat model, we must assign the foreign key rather than the key in the target
-          const flatForeignKey = model.definitions[element.parent.name]?.elements[fkBaseName]
+          const flatForeignKey = getDefinition(element.parent.name)?.elements[fkBaseName]
 
           setElementOnColumns(flatColumn, flatForeignKey || fkElement)
           Object.defineProperty(flatColumn, '_csnPath', { value: csnPath, writable: true })
@@ -1260,7 +1311,7 @@ function cqn4sql(originalQuery, model) {
               }”`,
             )
           }
-          whereExistsSubSelects.push(getWhereExistsSubquery(current, next, step.where, true))
+          whereExistsSubSelects.push(getWhereExistsSubquery(current, next, step.where, true, step.args))
         }
 
         const whereExists = { SELECT: whereExistsSubqueries(whereExistsSubSelects) }
@@ -1292,7 +1343,7 @@ function cqn4sql(originalQuery, model) {
         }
       } 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
-        const def = $baseLink.definition._target || $baseLink.definition
+        const def = getDefinition($baseLink.definition.target) || $baseLink.definition
         const keys = def.keys // use key aspect on entity
         const keyValComparisons = []
         const flatKeys = []
@@ -1552,7 +1603,7 @@ function cqn4sql(originalQuery, model) {
         const nextStep = refReverse[i + 1] // only because we want the filter condition
 
         if (stepLink.definition.target && nextStepLink) {
-          const { where } = nextStep
+          const { where, args } = nextStep
           if (isStructured(nextStepLink.definition)) {
             // find next association / entity in the ref because this is actually our real nextStep
             const nextStepIndex =
@@ -1573,7 +1624,7 @@ function cqn4sql(originalQuery, model) {
             as = getNextAvailableTableAlias(as)
           }
           nextStepLink.alias = as
-          whereExistsSubSelects.push(getWhereExistsSubquery(stepLink, nextStepLink, where))
+          whereExistsSubSelects.push(getWhereExistsSubquery(stepLink, nextStepLink, where, false, args))
         }
       }
 
@@ -1607,7 +1658,12 @@ function cqn4sql(originalQuery, model) {
 
       // adjust ref & $refLinks after associations have turned into where exists subqueries
       transformedFrom.$refLinks.splice(0, transformedFrom.$refLinks.length - 1)
-      transformedFrom.ref = [localized(transformedFrom.$refLinks[0].target)]
+
+      let args = from.ref.at(-1).args
+      const subquerySource = transformedFrom.$refLinks[0].target
+      if (subquerySource.params && !args) args = {}
+      const id = localized(subquerySource)
+      transformedFrom.ref = [args ? { id, args } : id]
 
       return { transformedWhere, transformedFrom }
     }
@@ -1661,7 +1717,7 @@ function cqn4sql(originalQuery, model) {
    */
   function backlinkFor(assoc) {
     if (!assoc.on) return null
-    const target = model.definitions[assoc.target]
+    const target = getDefinition(assoc.target)
     // technically we could have multiple backlinks
     const backlinks = []
     for (let i = 0; i < assoc.on.length; i += 3) {
@@ -1687,7 +1743,7 @@ function cqn4sql(originalQuery, model) {
    */
   function onCondFor(assocRefLink, targetSideRefLink, inWhereOrJoin) {
     const { on, keys } = assocRefLink.definition
-    const target = model.definitions[assocRefLink.definition.target]
+    const target = getDefinition(assocRefLink.definition.target)
     let res
     // technically we could have multiple backlinks
     if (keys) {
@@ -1738,10 +1794,11 @@ function cqn4sql(originalQuery, model) {
               if (res === '$self')
                 // next is resolvable in entity
                 return prev
-              const definition = prev?.elements?.[res] || prev?._target?.elements[res] || pseudos.elements[res]
+              const definition =
+                prev?.elements?.[res] || getDefinition(prev?.target)?.elements[res] || pseudos.elements[res]
               const target = getParentEntity(definition)
               thing.$refLinks[i] = { definition, target, alias: definition.name }
-              return prev?.elements?.[res] || prev?._target?.elements[res] || pseudos.elements[res]
+              return prev?.elements?.[res] || getDefinition(prev?.target)?.elements[res] || pseudos.elements[res]
             }, assocHost)
           }
 
@@ -1843,7 +1900,7 @@ function cqn4sql(originalQuery, model) {
                 result[i].ref.splice(0, 1, assocRefLink.alias)
               } else if (
                 definition.name in
-                (targetSideRefLink.definition.elements || targetSideRefLink.definition._target.elements)
+                (targetSideRefLink.definition.elements || getDefinition(targetSideRefLink.definition.target).elements)
               ) {
                 // first step is association which refers to its foreign key by dot notation
                 result[i].ref = [targetSideRefLink.alias, lhs.ref.join('_')]
@@ -1865,7 +1922,7 @@ function cqn4sql(originalQuery, model) {
         // pseudo element
         return element
       if (element.kind === 'entity') return element
-      else return model.definitions[localized(getParentEntity(element.parent))]
+      else return getDefinition(localized(getParentEntity(element.parent)))
     }
   }
 
@@ -1880,11 +1937,11 @@ function cqn4sql(originalQuery, model) {
   function getParentKeyForeignKeyPairs(assoc, targetSideRefLink, flipSourceAndTarget = false) {
     const res = []
     const backlink = backlinkFor(assoc)?.[0]
-    const { keys, _target } = backlink || assoc
+    const { keys, target } = backlink || assoc
     if (keys) {
       keys.forEach(fk => {
         const { ref, as } = fk
-        const elem = getElementForRef(ref, _target) // find the element (the target element of the foreign key) in the target of the (backlink) association
+        const elem = getElementForRef(ref, getDefinition(target)) // find the element (the target element of the foreign key) in the target of the (backlink) association
         const flatParentKeys = getFlatColumnsFor(elem, { baseName: ref.slice(0, ref.length - 1).join('_') }) // it might be a structured element, so expand it into the full parent key tuple
         const flatAssociationName = getFullName(backlink || assoc) // get the name of the (backlink) association
         const flatForeignKeys = getFlatColumnsFor(elem, { baseName: flatAssociationName, columnAlias: as }) // the name of the (backlink) association is the base of the foreign key tuple, also respect aliased fk.
@@ -1933,7 +1990,7 @@ function cqn4sql(originalQuery, model) {
    *                    -> if it is, target and source side are flipped in the where exists subquery
    * @returns {CQN.SELECT}
    */
-  function getWhereExistsSubquery(current, next, customWhere = null, inWhere = false) {
+  function getWhereExistsSubquery(current, next, customWhere = null, inWhere = false, customArgs = null) {
     const { definition } = current
     const { definition: nextDefinition } = next
     const on = []
@@ -1957,9 +2014,12 @@ function cqn4sql(originalQuery, model) {
       on.push(...['and', ...(hasLogicalOr(filter) ? [asXpr(filter)] : filter)])
     }
 
+    const subquerySource = assocTarget(nextDefinition) || nextDefinition
+    const id = localized(subquerySource)
+    if (subquerySource.params && !customArgs) customArgs = {}
     const SELECT = {
       from: {
-        ref: [localized(assocTarget(nextDefinition) || nextDefinition)],
+        ref: [customArgs ? { id, args: customArgs } : id],
         as: next.alias,
       },
       columns: [
@@ -1982,7 +2042,7 @@ function cqn4sql(originalQuery, model) {
    */
   function localized(definition) {
     if (!isLocalized(definition)) return definition.name
-    const view = model.definitions[`localized.${definition.name}`]
+    const view = getDefinition(`localized.${definition.name}`)
     return view?.name || definition.name
   }
 
@@ -1995,7 +2055,18 @@ function cqn4sql(originalQuery, model) {
    * @returns true if the given definition shall be localized
    */
   function isLocalized(definition) {
-    return inferred.SELECT?.localized && definition['@cds.localized'] !== false
+    return (
+      inferred.SELECT?.localized &&
+      definition['@cds.localized'] !== false &&
+      !inferred.SELECT.forUpdate &&
+      !inferred.SELECT.forShareLock
+    )
+  }
+
+  /** returns the CSN definition for the given name from the model */
+  function getDefinition(name) {
+    if (!name) return null
+    return model.definitions[name]
   }
 
   /**
@@ -2005,7 +2076,7 @@ function cqn4sql(originalQuery, model) {
    * @returns the csn definition of the association target or null if it is not an association
    */
   function assocTarget(assoc) {
-    return model.definitions[assoc.target] || null
+    return getDefinition(assoc.target) || null
   }
 
   /**

package/lib/deep-queries.js

@@ -242,10 +242,23 @@ const _getDeepQueries = (diff, target, root = false) => {
     queries.push(...subQueries)
   }
 
-  queries.forEach(q => {
+  const insertQueries = new Map()
+
+  return queries.map(q => {
+    // Merge all INSERT statements for each target
+    if (q.INSERT) {
+      const target = q.target
+      if (insertQueries.has(target)) {
+        insertQueries.get(target).INSERT.entries.push(...q.INSERT.entries)
+        return
+      } else {
+        insertQueries.set(target, q)
+      }
+    }
     Object.defineProperty(q, handledDeep, { value: true })
+    return q
   })
-  return queries
+    .filter(a => a)
 }
 
 module.exports = {

package/lib/infer/index.js

@@ -47,13 +47,16 @@ function infer(originalQuery, model) {
   Object.defineProperties(inferred, {
     // REVISIT: public, or for local reuse, or in cqn4sql only?
     sources: { value: sources, writable: true },
-    target: { value: aliases.length === 1 ? sources[aliases[0]] : originalQuery, writable: true }, // REVISIT: legacy?
+    target: {
+      value: aliases.length === 1 ? getDefinitionFromSources(sources, aliases[0]) : originalQuery,
+      writable: true,
+    }, // REVISIT: legacy?
   })
   // also enrich original query -> writable because it may be inferred again
   Object.defineProperties(originalQuery, {
     sources: { value: sources, writable: true },
     target: {
-      value: aliases.length === 1 ? sources[aliases[0]] : originalQuery,
+      value: aliases.length === 1 ? getDefinitionFromSources(sources, aliases[0]) : originalQuery,
       writable: true,
     },
   })
@@ -94,12 +97,13 @@ function infer(originalQuery, model) {
   function inferTarget(from, querySources) {
     const { ref } = from
     if (ref) {
-      const first = ref[0].id || ref[0]
-      let target = getDefinition(first, model)
+      const { id, args } = ref[0]
+      const first = id || ref[0]
+      let target = getDefinition(first) || cds.error`"${first}" not found in the definitions of your model`
       if (!target) throw new Error(`"${first}" not found in the definitions of your model`)
       if (ref.length > 1) {
         target = from.ref.slice(1).reduce((d, r) => {
-          const next = d.elements[r.id || r]?._target || d.elements[r.id || r]
+          const next = getDefinition(d.elements[r.id || r]?.target) || d.elements[r.id || r]
           if (!next) throw new Error(`No association “${r.id || r}” in ${d.kind} “${d.name}”`)
           return next
         }, target)
@@ -113,16 +117,18 @@ function infer(originalQuery, model) {
         from.as ||
         (ref.length === 1 ? first.match(/[^.]+$/)[0] : ref[ref.length - 1].id || ref[ref.length - 1])
       if (alias in querySources) throw new Error(`Duplicate alias "${alias}"`)
-      querySources[alias] = target
+      querySources[alias] = { definition: target, args }
       const last = from.$refLinks.at(-1)
       last.alias = alias
     } else if (from.args) {
       from.args.forEach(a => inferTarget(a, querySources))
     } else if (from.SELECT) {
       infer(from, model) // we need the .elements in the sources
-      querySources[from.as || ''] = from
+      querySources[from.as || ''] = { definition: from }
     } else if (typeof from === 'string') {
-      querySources[/([^.]*)$/.exec(from)[0]] = getDefinition(from, model)
+      // TODO: Create unique alias, what about duplicates?
+      const definition = getDefinition(from) || cds.error`"${from}" not found in the definitions of your model`
+      querySources[/([^.]*)$/.exec(from)[0]] = { definition }
     } else if (from.SET) {
       infer(from, model)
     }
@@ -168,7 +174,7 @@ function infer(originalQuery, model) {
         // we need to search for first step in ´model.definitions[infixAlias]`
         if ($baseLink) {
           const { definition } = $baseLink
-          const elements = definition._target?.elements || definition.elements
+          const elements = getDefinition(definition.target)?.elements || definition.elements
           const e = elements?.[id] || cds.error`"${id}" not found in the elements of "${definition.name}"`
           if (e.target) {
             // only fk access in infix filter
@@ -188,22 +194,22 @@ function infer(originalQuery, model) {
           Object.defineProperty(arg, 'flatName', { value: ref.join('_'), writable: true })
         } else {
           // must be in model.definitions
-          const definition = getDefinition(id, model)
+          const definition = getDefinition(id) || cds.error`"${id}" not found in the definitions of your model`
           arg.$refLinks[0] = { definition, target: definition }
         }
       } else {
         const recent = arg.$refLinks[i - 1]
-        const { elements } = recent.definition._target || recent.definition
+        const { elements } = getDefinition(recent.definition.target) || recent.definition
         const e = elements[id]
         if (!e) throw new Error(`"${id}" not found in the elements of "${arg.$refLinks[i - 1].definition.name}"`)
-        arg.$refLinks.push({ definition: e, target: e._target || e })
+        arg.$refLinks.push({ definition: e, target: getDefinition(e.target) || e })
       }
       arg.$refLinks[i].alias = !ref[i + 1] && arg.as ? arg.as : id.split('.').pop()
 
       // link refs in where
       if (step.where) {
         // REVISIT: why do we need to walk through these so early?
-        if (arg.$refLinks[i].definition.kind === 'entity' || arg.$refLinks[i].definition._target) {
+        if (arg.$refLinks[i].definition.kind === 'entity' || getDefinition(arg.$refLinks[i].definition.target)) {
           let existsPredicate = false
           const walkTokenStream = token => {
             if (token === 'exists') {
@@ -243,7 +249,7 @@ function infer(originalQuery, model) {
   function inferCombinedElements() {
     const combinedElements = {}
     for (const index in sources) {
-      const tableAlias = sources[index]
+      const tableAlias = getDefinitionFromSources(sources, index)
       for (const key in tableAlias.elements) {
         if (key in combinedElements) combinedElements[key].push({ index, tableAlias })
         else combinedElements[key] = [{ index, tableAlias }]
@@ -497,24 +503,30 @@ function infer(originalQuery, model) {
             nameSegments.push(id)
           } else if ($baseLink) {
             const { definition, target } = $baseLink
-            const elements = definition._target?.elements || definition.elements
+            const elements = getDefinition(definition.target)?.elements || definition.elements
             if (elements && id in elements) {
               const element = elements[id]
               rejectNonFkAccess(element)
-              const resolvableIn = definition.target ? definition._target : target
+              const resolvableIn = getDefinition(definition.target) || target
               column.$refLinks.push({ definition: elements[id], target: resolvableIn })
             } else {
               stepNotFoundInPredecessor(id, definition.name)
             }
             nameSegments.push(id)
           } else if (firstStepIsTableAlias) {
-            column.$refLinks.push({ definition: sources[id], target: sources[id] })
+            column.$refLinks.push({
+              definition: getDefinitionFromSources(sources, id),
+              target: getDefinitionFromSources(sources, id),
+            })
           } else if (firstStepIsSelf) {
             column.$refLinks.push({ definition: { elements: queryElements }, target: { elements: queryElements } })
           } else if (column.ref.length > 1 && inferred.outerQueries?.find(outer => id in outer.sources)) {
             // outer query accessed via alias
             const outerAlias = inferred.outerQueries.find(outer => id in outer.sources)
-            column.$refLinks.push({ definition: outerAlias.sources[id], target: outerAlias.sources[id] })
+            column.$refLinks.push({
+              definition: getDefinitionFromSources(outerAlias.sources, id),
+              target: getDefinitionFromSources(outerAlias.sources, id),
+            })
           } else if (id in $combinedElements) {
             if ($combinedElements[id].length > 1) stepIsAmbiguous(id) // exit
             const definition = $combinedElements[id][0].tableAlias.elements[id]
@@ -524,15 +536,15 @@ function infer(originalQuery, model) {
           } else if (expandOnTableAlias) {
             // expand on table alias
             column.$refLinks.push({
-              definition: sources[id],
-              target: sources[id],
+              definition: getDefinitionFromSources(sources, id),
+              target: getDefinitionFromSources(sources, id),
             })
           } else {
             stepNotFoundInCombinedElements(id) // REVISIT: fails with {__proto__:elements)
           }
         } else {
           const { definition } = column.$refLinks[i - 1]
-          const elements = definition._target?.elements || definition.elements //> go for assoc._target first, instead of assoc as struct
+          const elements = getDefinition(definition.target)?.elements || definition.elements //> go for assoc._target first, instead of assoc as struct
           const element = elements?.[id]
 
           if (firstStepIsSelf && element?.isAssociation) {
@@ -543,7 +555,7 @@ function infer(originalQuery, model) {
             )
           }
 
-          const target = definition._target || column.$refLinks[i - 1].target
+          const target = getDefinition(definition.target) || column.$refLinks[i - 1].target
           if (element) {
             if ($baseLink) rejectNonFkAccess(element)
             const $refLink = { definition: elements[id], target }
@@ -602,7 +614,8 @@ function infer(originalQuery, model) {
         }
 
         column.$refLinks[i].alias = !column.ref[i + 1] && column.as ? column.as : id.split('.').pop()
-        if (column.$refLinks[i].definition._target?.['@cds.persistence.skip'] === true) isPersisted = false
+        if (getDefinition(column.$refLinks[i].definition.target)?.['@cds.persistence.skip'] === true)
+          isPersisted = false
         if (!column.ref[i + 1]) {
           const flatName = nameSegments.join('_')
           Object.defineProperty(column, 'flatName', { value: flatName, writable: true })
@@ -673,9 +686,7 @@ function infer(originalQuery, model) {
       // ignore whole expand if target of assoc along path has ”@cds.persistence.skip”
       if (column.expand) {
         const { $refLinks } = column
-        const skip = $refLinks.some(
-          link => model.definitions[link.definition.target]?.['@cds.persistence.skip'] === true,
-        )
+        const skip = $refLinks.some(link => getDefinition(link.definition.target)?.['@cds.persistence.skip'] === true)
         if (skip) {
           $refLinks[$refLinks.length - 1].skipExpand = true
           return
@@ -716,13 +727,17 @@ function infer(originalQuery, model) {
       function resolveInline(col, namePrefix = col.as || col.flatName) {
         const { inline, $refLinks } = col
         const $leafLink = $refLinks[$refLinks.length - 1]
+        if(!$leafLink.definition.target && !$leafLink.definition.elements) {
+          throw new Error(`Unexpected “inline” on “${col.ref.map(idOnly)}”; can only be used after a reference to a structure, association or table alias`)
+        }
         let elements = {}
         inline.forEach(inlineCol => {
           inferQueryElement(inlineCol, false, $leafLink, { inExpr: true, inNestedProjection: true, baseColumn: col })
           if (inlineCol === '*') {
             const wildCardElements = {}
             // either the `.elements´ of the struct or the `.elements` of the assoc target
-            const leafLinkElements = $leafLink.definition._target?.elements || $leafLink.definition.elements
+            const leafLinkElements =
+              getDefinition($leafLink.definition.target)?.elements || $leafLink.definition.elements
             Object.entries(leafLinkElements).forEach(([k, v]) => {
               const name = namePrefix ? `${namePrefix}_${k}` : k
               // if overwritten/excluded omit from wildcard elements
@@ -768,10 +783,14 @@ function infer(originalQuery, model) {
       function resolveExpand(col) {
         const { expand, $refLinks } = col
         const $leafLink = $refLinks?.[$refLinks.length - 1] || inferred.SELECT.from.$refLinks.at(-1) // fallback to anonymous expand
-        if ($leafLink.definition._target) {
+        if(!$leafLink.definition.target && !$leafLink.definition.elements) {
+          throw new Error(`Unexpected “expand” on “${col.ref.map(idOnly)}”; can only be used after a reference to a structure, association or table alias`)
+        }
+        const target = getDefinition($leafLink.definition.target)
+        if (target) {
           const expandSubquery = {
             SELECT: {
-              from: $leafLink.definition._target.name,
+              from: target.name,
               columns: expand.filter(c => !c.inline),
             },
           }
@@ -782,19 +801,20 @@ function infer(originalQuery, model) {
             ? new cds.struct({ elements: inferredExpandSubquery.elements })
             : new cds.array({ items: new cds.struct({ elements: inferredExpandSubquery.elements }) })
           return Object.defineProperty(res, '$assocExpand', { value: true })
-        } // struct
-        let elements = {}
-        expand.forEach(e => {
-          if (e === '*') {
-            elements = { ...elements, ...$leafLink.definition.elements }
-          } else {
-            inferQueryElement(e, false, $leafLink, { inExpr: true, inNestedProjection: true })
-            if (e.expand) elements[e.as || e.flatName] = resolveExpand(e)
-            if (e.inline) elements = { ...elements, ...resolveInline(e) }
-            else elements[e.as || e.flatName] = e.$refLinks ? e.$refLinks[e.$refLinks.length - 1].definition : e
-          }
-        })
-        return new cds.struct({ elements })
+        } else if ($leafLink.definition.elements) {
+          let elements = {}
+          expand.forEach(e => {
+            if (e === '*') {
+              elements = { ...elements, ...$leafLink.definition.elements }
+            } else {
+              inferQueryElement(e, false, $leafLink, { inExpr: true, inNestedProjection: true })
+              if (e.expand) elements[e.as || e.flatName] = resolveExpand(e)
+              if (e.inline) elements = { ...elements, ...resolveInline(e) }
+              else elements[e.as || e.flatName] = e.$refLinks ? e.$refLinks[e.$refLinks.length - 1].definition : e
+            }
+          })
+          return new cds.struct({ elements })
+        }
       }
 
       function stepNotFoundInPredecessor(step, def) {
@@ -812,6 +832,7 @@ function infer(originalQuery, model) {
       function stepNotFoundInCombinedElements(step) {
         throw new Error(
           `"${step}" not found in the elements of ${Object.values(sources)
+            .map(s => s.definition)
             .map(def => `"${def.name || /* subquery */ def.as}"`)
             .join(', ')}`,
         )
@@ -972,12 +993,12 @@ function infer(originalQuery, model) {
       const exclude = _.excluding ? x => _.excluding.includes(x) : () => false
 
       if (Object.keys(queryElements).length === 0 && aliases.length === 1) {
-        const { elements } = sources[aliases[0]]
+        const { elements } = getDefinitionFromSources(sources, aliases[0])
         // only one query source and no overwritten columns
         Object.keys(elements)
           .filter(k => !exclude(k))
           .forEach(k => {
-            const element = sources[aliases[0]].elements[k]
+            const element = elements[k]
             if (element.type !== 'cds.LargeBinary') queryElements[k] = element
             if (element.value) {
               linkCalculatedElement(element)
@@ -1105,9 +1126,14 @@ function infer(originalQuery, model) {
     }
   }
 
-  /** gets the CSN element for the given name from the model */
-  function getDefinition(name, model) {
-    return model.definitions[name] || cds.error`"${name}" not found in the definitions of your model`
+  /** returns the CSN definition for the given name from the model */
+  function getDefinition(name) {
+    if (!name) return null
+    return model.definitions[name]
+  }
+
+  function getDefinitionFromSources(sources, id) {
+    return sources[id].definition
   }
 
   /**
@@ -1129,6 +1155,7 @@ function infer(originalQuery, model) {
     }, '')
   }
 }
+
 /**
  * Returns true if e is a foreign key of assoc.
  * this function is also compatible with unfolded csn (UCSN),

package/lib/infer/join-tree.js

@@ -43,13 +43,17 @@ class Node {
    * @param {parent} parent
    * @param {where} where
    */
-  constructor($refLink, parent, where = null) {
+  constructor($refLink, parent, where = null, args = null) {
     /** @type {$refLink} - A reference link to this node. */
     this.$refLink = $refLink
     /** @type {parent} - The parent Node of this node. */
     this.parent = parent
     /** @type {where} - An optional condition to be applied to this node. */
     this.where = where
+    /** @type {args} - optional parameter object to be applied to this node. */
+    const targetHasParams = $refLink.definition._target?.params || $refLink.definition._target?.['@cds.persistence.udf']
+    if (!args && targetHasParams) args = {} // if no args are provided, provide empty argument list
+    this.args = args
     /** @type {children} - A Map of children nodes belonging to this node. */
     this.children = new Map()
   }
@@ -63,9 +67,13 @@ class Root {
    * @param {[alias, queryArtifact]} querySource
    */
   constructor(querySource) {
-    const [alias, queryArtifact] = querySource
+    let [alias, { definition, args }] = querySource
     /** @type {queryArtifact} - The artifact used to make the query. */
-    this.queryArtifact = queryArtifact
+    this.queryArtifact = definition
+    /** @type {args} - optional parameter object to be applied to this node. */
+    const definitionHasParams = definition.params || definition['@cds.persistence.udf']
+    if (!args && definitionHasParams) args = {} // if no args are provided, provide empty argument list
+    this.args = args
     /** @type {alias} - The alias of the artifact. */
     this.alias = alias
     /** @type {parent} - The parent Node of this root, null for the root Node. */
@@ -170,8 +178,8 @@ class JoinTree {
 
     while (i < col.ref.length) {
       const step = col.ref[i]
-      const { where } = step
-      const id = where ? step.id + JSON.stringify(where) : step
+      const { where, args } = step
+      const id = joinId(step, args, where)
       const next = node.children.get(id)
       const $refLink = col.$refLinks[i]
       if (next) {
@@ -187,7 +195,7 @@ class JoinTree {
           node.$refLink.onlyForeignKeyAccess = false
           return true
         }
-        const child = new Node($refLink, node, where)
+        const child = new Node($refLink, node, where, args)
         if (child.$refLink.definition.isAssociation) {
           if (child.where || col.inline) {
             // filter is always join relevant
@@ -212,6 +220,14 @@ class JoinTree {
       i += 1
     }
     return true
+
+    function joinId(step, args, where) {
+      let appendix
+      if (where && args) appendix = JSON.stringify(where) + JSON.stringify(args)
+      else if (where) appendix = JSON.stringify(where)
+      else if (args) appendix = JSON.stringify(args)
+      return appendix ? step.id + appendix : step
+    }
   }
 
   /**

package/lib/search.js

@@ -10,10 +10,16 @@ const DRAFT_COLUMNS_UNION = {
 }
 const DEFAULT_SEARCHABLE_TYPE = 'cds.String'
 
+// only those which return strings are relevant for search
+const aggregateFunctions = {
+  MAX: true,
+  MIN: true,
+}
+
 /**
  * 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.
+ * Moreover, it provides the annotations starting with '@' for each column.
  *
  * @param {object} entity - the csn entity
  * @param {object} [options]
@@ -120,37 +126,49 @@ const computeColumnsToBeSearched = (cqn, entity = { __searchableColumns: [] }, a
   // 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)
+    cqn.SELECT.columns?.forEach(column => {
+      if (column.func || column.xpr) {
+        // 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
         }
 
-        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)
+        // only strings can be searched
+        if (column.element.type !== DEFAULT_SEARCHABLE_TYPE) {
+          if (column.xpr) return
+          if (column.func && !(column.func in aggregateFunctions)) return
         }
-      })
+
+        const searchTerm = {}
+        if (column.func) {
+          searchTerm.func = column.func
+          searchTerm.args = column.args
+        } else if (column.xpr) {
+          searchTerm.xpr = column.xpr
+        }
+        toBeSearched.push(searchTerm)
+        return
+      }
+
+      // no need to set ref[0] to alias, because columns were already properly transformed
+      if (column.ref) {
+        if (column.element.type !== DEFAULT_SEARCHABLE_TYPE) return
+        column = { ref: [...column.ref] }
+        toBeSearched.push(column)
+        return
+      }
+    })
   } 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
+      const column = { ref: [c] }
+      if (alias) column.ref.unshift(alias)
+      return column
     })
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cap-js/db-service",
-  "version": "1.6.4",
+  "version": "1.8.0",
   "description": "CDS base database service",
   "homepage": "https://github.com/cap-js/cds-dbs/tree/main/db-service#cds-base-database-service",
   "repository": {
@@ -31,9 +31,5 @@
   "peerDependencies": {
     "@sap/cds": ">=7.6"
   },
-  "license": "SEE LICENSE",
-  "devDependencies": {
-    "@typescript-eslint/eslint-plugin": "^6.2.0",
-    "typescript": "^5.1.6"
-  }
+  "license": "SEE LICENSE"
 }