@cap-js/db-service 1.17.2 → 1.18.0

package/CHANGELOG.md

@@ -4,6 +4,21 @@
 - The format is based on [Keep a Changelog](http://keepachangelog.com/).
 - This project adheres to [Semantic Versioning](http://semver.org/).
 
+## [1.18.0](https://github.com/cap-js/cds-dbs/compare/db-service-v1.17.2...db-service-v1.18.0) (2025-03-04)
+
+
+### Added
+
+* query modifiers on expand `ref` are propagated to subquery ([#1049](https://github.com/cap-js/cds-dbs/issues/1049)) ([39fbadf](https://github.com/cap-js/cds-dbs/commit/39fbadf25a874f810ac2795f2e6b0a46c3678058))
+* support query modifiers at leaf of from ref ([#1050](https://github.com/cap-js/cds-dbs/issues/1050)) ([500a666](https://github.com/cap-js/cds-dbs/commit/500a666a9a054dd72d6ec8ccba0c6a6ddc263cd3))
+
+
+### Fixed
+
+* `<expand>[@odata](https://github.com/odata).count` queries ([#966](https://github.com/cap-js/cds-dbs/issues/966)) ([6607a84](https://github.com/cap-js/cds-dbs/commit/6607a8404aa70f2f3f7c6c65c7e9b1c324a5230b))
+* align debug log format of stmt values ([#1052](https://github.com/cap-js/cds-dbs/issues/1052)) ([93af0fe](https://github.com/cap-js/cds-dbs/commit/93af0fe5f93a0c1b91f592417b31fdb6266fdd79))
+* expand + groupby may return null, dont attach `.element` ([#1042](https://github.com/cap-js/cds-dbs/issues/1042)) ([cf2e0a2](https://github.com/cap-js/cds-dbs/commit/cf2e0a215e89f9055e28d9f0984adf292e220aee))
+
 ## [1.17.2](https://github.com/cap-js/cds-dbs/compare/db-service-v1.17.1...db-service-v1.17.2) (2025-02-09)
 
 

package/lib/cql-functions.js

@@ -1,30 +1,16 @@
-const cds = require("@sap/cds")
+'use strict'
 
+// OData: https://docs.oasis-open.org/odata/odata/v4.01/odata-v4.01-part2-url-conventions.html#sec_CanonicalFunctions
 const StandardFunctions = {
-  // OData: https://docs.oasis-open.org/odata/odata/v4.01/odata-v4.01-part2-url-conventions.html#sec_CanonicalFunctions
-
-  // String and Collection Functions
-  /**
-   * Generates SQL statement that produces the length of a given string
-   * @param {string} x
-   * @returns {string}
-   */
-  length: x => `length(${x})`,
-  /**
-   * Generates SQL statement that produces the average of a given expression
-   * @param {string} x
-   * @returns {string}
-   */
-  average: x => `avg(${x})`,
   /**
    * Generates SQL statement that produces a boolean value indicating whether the search term is contained in the given columns
-   * @param {string} ref
-   * @param {string} arg
-   * @returns {string}
+   * @param {string} ref - The reference object containing column information
+   * @param {string} arg - The argument object containing the search value
+   * @returns {string} - SQL statement
    */
   search: function (ref, arg) {
-    if (!('val' in arg)) throw new Error(`Only single value arguments are allowed for $search`)
-    // only apply first search term, rest is ignored
+    if (!('val' in arg)) throw new Error('Only single value arguments are allowed for $search')
+    // Only apply first search term, rest is ignored
     const sub = /("")|("(?:[^"]|\\")*(?:[^\\]|\\\\)")|(\S*)/.exec(arg.val)
     let val
     try {
@@ -37,53 +23,50 @@ const StandardFunctions = {
     const { toString } = ref
     return '(' + refs.map(ref2 => this.contains(this.tolower(toString(ref2)), this.tolower(arg))).join(' or ') + ')'
   },
-  /**
-   * Generates SQL statement that produces a string with all provided strings concatenated
-   * @param  {...string} args
-   * @returns {string}
-   */
-  concat: (...args) => args.map(a => (a.xpr ? `(${a})` : a)).join(' || '),
+
+  // ==============================
+  // Aggregation Functions
+  // ==============================
 
   /**
-   * Generates SQL statement that produces a boolean value indicating whether the first string contains the second string
-   * @param  {...string} args
-   * @returns {string}
+   * Generates SQL statement that produces the average of a given expression
+   * @param {string} x - The expression to average
+   * @returns {string} - SQL statement
    */
-  contains: (...args) => `(ifnull(instr(${args}),0) > 0)`,
+  average: x => `avg(${x})`,
+
   /**
    * Generates SQL statement that produces the number of elements in a given collection
-   * @param {string} x
-   * @returns {string}
+   * @param {string} x - The collection input
+   * @returns {string} - SQL statement
    */
-  count: x => `count(${x || '*'})`,
+  count: x => `count(${x?.val || x || '*'})`,
+
   /**
    * Generates SQL statement that produces the number of distinct values of a given expression
-   * @param {string} x
-   * @returns {string}
-   */
-  countdistinct: x => `count(distinct ${x || cds.error`countdistinct requires a ref to be counted`})`,
-  /**
-   * Generates SQL statement that produces the index of the first occurrence of the second string in the first string
-   * @param {string} x
-   * @param {string} y
-   * @returns {string}
+   * @param {string} x - The expression input
+   * @returns {string} - SQL statement
    */
-  indexof: (x, y) => `instr(${x},${y}) - 1`, // sqlite instr is 1 indexed
+  countdistinct: x => `count(distinct ${x.val || x || '*'})`,
+
+  // ==============================
+  // String Functions
+  // ==============================
+
   /**
-   * Generates SQL statement that produces a boolean value indicating whether the first string starts with the second string
-   * @param {string} x
-   * @param {string} y
-   * @returns {string}
+   * Generates SQL statement that produces the length of a given string
+   * @param {string} x - The string input
+   * @returns {string} - SQL statement
    */
-  startswith: (x, y) => `coalesce(instr(${x},${y}) = 1,false)`, // sqlite instr is 1 indexed
-  // takes the end of the string of the size of the target and compares it with the target
+  length: x => `length(${x})`,
+
   /**
-   * Generates SQL statement that produces a boolean value indicating whether the first string ends with the second string
-   * @param {string} x
-   * @param {string} y
-   * @returns {string}
+   * Generates SQL statement that produces a string with all provided strings concatenated
+   * @param  {...string} args - The strings to concatenate
+   * @returns {string} - SQL statement
    */
-  endswith: (x, y) => `coalesce(substr(${x}, length(${x}) + 1 - length(${y})) = ${y},false)`,
+  concat: (...args) => args.map(a => (a.xpr ? `(${a})` : a)).join(' || '),
+
   /**
    * Generates SQL statement that produces the substring of a given string
    * @example
@@ -92,266 +75,115 @@ const StandardFunctions = {
    * @example
    * // returns 'b'
    * {func:'substring',args:[{val:'abc'},{val:1},{val:1}]}
-   * @param {string} x
-   * @param {string} y
-   * @param {string} z
-   * @returns {string}
+   * @param {string} x - The string input
+   * @param {string} y - The starting position
+   * @param {string} [z] - Optional length of the substring
+   * @returns {string} - SQL statement
    */
   substring: (x, y, z) =>
     z
-      ? `substr( ${x}, case when ${y} < 0 then length(${x}) + ${y} + 1 else ${y} + 1 end, ${z} )`
-      : `substr( ${x}, case when ${y} < 0 then length(${x}) + ${y} + 1 else ${y} + 1 end )`,
+      ? `substr(${x}, case when ${y} < 0 then length(${x}) + ${y} + 1 else ${y} + 1 end, ${z})`
+      : `substr(${x}, case when ${y} < 0 then length(${x}) + ${y} + 1 else ${y} + 1 end)`,
 
-  // String Functions
-  /**
-   * 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 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
-   * @returns {string}
+   * @param {string} x - The string input
+   * @returns {string} - SQL statement
    */
   tolower: x => `lower(${x})`,
+
   /**
    * Generates SQL statement that produces the upper case value of a given string
-   * @param {string} x
-   * @returns {string}
+   * @param {string} x - The string input
+   * @returns {string} - SQL statement
    */
   toupper: x => `upper(${x})`,
+
   /**
    * Generates SQL statement that produces the trimmed value of a given string
-   * @param {string} x
-   * @returns {string}
+   * @param {string} x - The string input
+   * @returns {string} - SQL statement
    */
   trim: x => `trim(${x})`,
 
+  // ==============================
   // Arithmetic Functions
+  // ==============================
+
   /**
    * Generates SQL statement that produces the rounded up value of a given number
-   * @param {string} x
-   * @returns {string}
+   * @param {string} x - The number input
+   * @returns {string} - SQL statement
    */
   ceiling: x => `ceil(${x})`,
+
   /**
    * Generates SQL statement that produces the rounded down value of a given number
-   * @param {string} x
-   * @returns {string}
+   * @param {string} x - The number input
+   * @returns {string} - SQL statement
    */
   floor: x => `floor(${x})`,
+
   /**
    * Generates SQL statement that produces the rounded value of a given number
-   * @param {string} x
-   * @param {string} p precision
-   * @returns {string}
+   * @param {string} x - The number input
+   * @param {string} p - The precision
+   * @returns {string} - SQL statement
    */
   round: (x, p) => `round(${x}${p ? `,${p}` : ''})`,
 
+  // ==============================
   // Date and Time Functions
+  // ==============================
 
   /**
    * Generates SQL statement that produces current point in time (date and time with time zone)
-   * @returns {string}
+   * @returns {string} - SQL statement
    */
   now: function () {
     return this.session_context({ val: '$now' })
   },
-  /**
-   * 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 )`,
 
-  // REVISIT: make precision configurable
   /**
-   * Generates SQL statement that produces the fractional seconds of a given timestamp
-   * @param {string} x
-   * @returns {string}
+   * Maximum date time value
+   * @returns {string} - SQL statement
    */
-  fractionalseconds: x => `cast( substr( strftime('%f', ${x}), length(strftime('%f', ${x})) - 3) as REAL)`,
+  maxdatetime: () => `'9999-12-31T23:59:59.999Z'`,
 
   /**
-   * maximum date time value
-   * @returns {string}
-   */
-  maxdatetime: () => "'9999-12-31T23:59:59.999Z'",
-  /**
-   * minimum date time value
-   * @returns {string}
+   * Minimum date time value
+   * @returns {string} - SQL statement
    */
-  mindatetime: () => "'0001-01-01T00:00:00.000Z'",
-
-  // odata spec defines the value format for totalseconds as a duration like: P12DT23H59M59.999999999999S
-  // P -> duration indicator
-  // D -> days, T -> Time seperator, H -> hours, M -> minutes, S -> fractional seconds
-  // By splitting the DT and calculating the seconds of the time separate from the day
-  // it possible to determine the full amount of seconds by adding them together as fractionals and multiplying
-  // the number of seconds in a day
-  // As sqlite is most accurate with juliandays it is better to do then then using actual second function
-  // while the odata specification states that the seconds has to be fractional which only julianday allows
-  /**
-   * Generates SQL statement that produces an OData compliant duration string like: P12DT23H59M59.999999999999S
-   * @param {string} x
-   * @returns {string}
-   */
-  totalseconds: x => `(
-    (
-      (
-        cast(substr(${x},2,instr(${x},'DT') - 2) as Integer)
-      ) + (
-        julianday(
-          '-4713-11-25T' ||
-          replace(
-          replace(
-          replace(
-            substr(${x},instr(${x},'DT') + 2),
-            'H',':'
-          ),'M',':'
-          ),'S','Z'
-          )
-        ) - 0.5
-      )
-    ) * 86400
-  )`
+  mindatetime: () => `'0001-01-01T00:00:00.000Z'`,
 }
 
 const HANAFunctions = {
-  // https://help.sap.com/docs/SAP_HANA_PLATFORM/4fe29514fd584807ac9f2a04f6754767/f12b86a6284c4aeeb449e57eb5dd3ebd.html
-
   /**
    * Generates SQL statement that calls the session_context function with the given parameter
-   * @param {string} x session variable name or SQL expression
-   * @returns {string}
+   * @param {string} x - The session variable name or SQL expression
+   * @returns {string} - SQL statement
    */
-    session_context: x => `session_context('${x.val}')`,
+  session_context: x => `session_context('${x.val}')`,
 
-  // Time functions
-  current_date: p => (p ? `current_date(${p})` : 'current_date'),
-  current_time: p => (p ? `current_time(${p})` : 'current_time'),
-  current_timestamp: p => (p ? `current_timestamp(${p})` : 'current_timestamp'),
-  /**
-   * Generates SQL statement that calculates the difference in 100nanoseconds between two timestamps
-   * @param {string} x left timestamp
-   * @param {string} y right timestamp
-   * @returns {string}
-   */
-  nano100_between: (x, y) => `(julianday(${y}) - julianday(${x})) * 864000000000`,
   /**
-   * Generates SQL statement that calculates the difference in seconds between two timestamps
-   * @param {string} x left timestamp
-   * @param {string} y right timestamp
-   * @returns {string}
+   * Generates SQL statement for the current date
+   * @returns {string} - SQL statement
    */
-  seconds_between: (x, y) => `(julianday(${y}) - julianday(${x})) * 86400`,
-  // Calculates the difference in full days using julian day
-  // Using the exact time of the day to determine whether 24 hours have passed or not to add the final day
-  // When just comparing the julianday values with each other there are leap seconds included
-  // Which on the day resolution are included as the individual days therefor ignoring them to match HANA
-  /**
-   * Generates SQL statement that calculates the difference in days between two timestamps
-   * @param {string} x left timestamp
-   * @param {string} y right timestamp
-   * @returns {string}
-   */
-  days_between: (x, y) => `(
-    cast ( julianday(${y}) as Integer ) - cast ( julianday(${x}) as Integer )
-  ) + (
-    case
-      when ( julianday(${y}) < julianday(${x}) ) then
-        (cast( strftime('%H%M%S%f0000', ${y}) as Integer ) < cast( strftime('%H%M%S%f0000', ${x}) as Integer ))
-      else
-        (cast( strftime('%H%M%S%f0000', ${y}) as Integer ) > cast( strftime('%H%M%S%f0000', ${x}) as Integer )) * -1
-    end
-  )`,
+  current_date: () => 'current_date',
 
-  // (y1 - y0) * 12 + (m1 - m0) + (t1 < t0) * -1
-  /* '%d%H%M%S%f' returns as a number like which results in an equal check to:
-  (
-    d1 < d0 ||
-    (d1 = d0 && h1 < h0) ||
-    (d1 = d0 && h1 = h0 && m1 < m0) ||
-    (d1 = d0 && h1 = h0 && m1 = m0 && s1 < s0) ||
-    (d1 = d0 && h1 = h0 && m1 = m0 && s1 = s0 && ms1 < ms0)
-  )
-  Which will remove the current month if the time of the month is below the time of the month of the start date
-  It should not matter that the number of days in the month is different as for a month to have passed
-  the time of the month would have to be higher then the time of the month of the start date
-
-  Also check whether the result will be positive or negative to make sure to not subtract an extra month
-  */
   /**
-   * Generates SQL statement that calculates the difference in months between two timestamps
-   * @param {string} x left timestamp
-   * @param {string} y right timestamp
-   * @returns {string}
+   * Generates SQL statement for the current time
+   * @param {string} [p] - Optional precision parameter
+   * @returns {string} - SQL statement
    */
-  months_between: (x, y) => `
-  (
-    (
-      ( cast( strftime('%Y', ${y}) as Integer ) - cast( strftime('%Y', ${x}) as Integer ) ) * 12
-    ) + (
-      cast( strftime('%m', ${y}) as Integer ) - cast( strftime('%m', ${x}) as Integer )
-    ) + (
-      (
-        case
-          when ( cast( strftime('%Y%m', ${y}) as Integer ) < cast( strftime('%Y%m', ${x}) as Integer ) ) then
-            (cast( strftime('%d%H%M%S%f0000', ${y}) as Integer ) > cast( strftime('%d%H%M%S%f0000', ${x}) as Integer ))
-          else
-            (cast( strftime('%d%H%M%S%f0000', ${y}) as Integer ) < cast( strftime('%d%H%M%S%f0000', ${x}) as Integer )) * -1
-        end
-      )
-    )
-  )`,
+  current_time: p => (p ? `current_time(${p})` : 'current_time'),
+
   /**
-   * Generates SQL statement that calculates the difference in years between two timestamps
-   * @param {string} x left timestamp
-   * @param {string} y right timestamp
-   * @returns {string}
+   * Generates SQL statement for the current timestamp
+   * @param {string} [p] - Optional precision parameter
+   * @returns {string} - SQL statement
    */
-  years_between(x, y) {
-    return `floor(${this.months_between(x, y)} / 12)`
-  },
+  current_timestamp: p => (p ? `current_timestamp(${p})` : 'current_timestamp'),
 }
 
 for (let each in HANAFunctions) HANAFunctions[each.toUpperCase()] = HANAFunctions[each]

package/lib/cqn2sql.js

@@ -92,7 +92,7 @@ class CQN2SQLRenderer {
       if (values && !Array.isArray(values)) {
         values = [values]
       }
-      DEBUG(this.sql, ...values)
+      DEBUG(this.sql, values)
     }
 
 
@@ -263,7 +263,13 @@ class CQN2SQLRenderer {
    * @returns {string} SQL
    */
   SELECT_columns(q) {
-    return (q.SELECT.columns ?? ['*']).map(x => this.column_expr(x, q))
+    const ret = []
+    const arr = q.SELECT.columns ?? ['*']
+    for (const x of arr) {
+      if (x.SELECT?.count) arr.push(this.SELECT_count(x))
+      ret.push(this.column_expr(x, q))
+    }
+    return ret
   }
 
   /**
@@ -292,24 +298,12 @@ class CQN2SQLRenderer {
       ? x => {
         const name = this.column_name(x)
         const escaped = `${name.replace(/"/g, '""')}`
-        let col = `${this.output_converter4(x.element, this.quote(name))} AS "${escaped}"`
-        if (x.SELECT?.count) {
-          // Return both the sub select and the count for @odata.count
-          const qc = cds.ql.clone(x, { columns: [{ func: 'count' }], one: 1, limit: 0, orderBy: 0 })
-          return [col, `${this.expr(qc)} AS "${escaped}@odata.count"`]
-        }
-        return col
+        return `${this.output_converter4(x.element, this.quote(name))} AS "${escaped}"`
       }
       : x => {
         const name = this.column_name(x)
         const escaped = `${name.replace(/"/g, '""')}`
-        let col = `'$."${escaped}"',${this.output_converter4(x.element, this.quote(name))}`
-        if (x.SELECT?.count) {
-          // Return both the sub select and the count for @odata.count
-          const qc = cds.ql.clone(x, { columns: [{ func: 'count' }], one: 1, limit: 0, orderBy: 0 })
-          return [col, `'$."${escaped}@odata.count"',${this.expr(qc)}`]
-        }
-        return col
+        return `'$."${escaped}"',${this.output_converter4(x.element, this.quote(name))}`
       }).flat()
 
     if (isSimple) return `SELECT ${cols} FROM (${sql})`
@@ -322,6 +316,17 @@ class CQN2SQLRenderer {
     return `SELECT ${isRoot || SELECT.one ? obj.replace('jsonb', 'json') : `jsonb_group_array(${obj})`} as _json_ FROM (${sql})`
   }
 
+  SELECT_count(q) {
+    const countQuery = cds.ql.clone(q, {
+      columns: [{ func: 'count' }],
+      one: 0, limit: 0, orderBy: 0, expand: 0, count: 0
+    })
+    countQuery.as = q.as + '@odata.count'
+    countQuery.elements = undefined
+    countQuery.element = cds.builtin.types.Int64
+    return countQuery
+  }
+
   /**
    * Renders a SELECT column expression into generic SQL
    * @param {import('./infer/cqn').col} x

package/lib/cqn4sql.js

@@ -60,6 +60,22 @@ function cqn4sql(originalQuery, model) {
       else if (having) inferred.SELECT.having = having
     }
   }
+  // query modifiers can also be defined in from ref leaf infix filter
+  // > SELECT from bookshop.Books[order by price] {ID}
+  if(inferred.SELECT?.from.ref) {
+    for(const [key, val] of Object.entries(inferred.SELECT.from.ref.at(-1))) {
+      if(key in { orderBy: 1, groupBy: 1 }) {
+        if(inferred.SELECT[key]) inferred.SELECT[key].push(...val)
+        else inferred.SELECT[key] = val
+      } else if(key === 'limit') {
+        // limit defined on the query has precedence
+        if(!inferred.SELECT.limit) inferred.SELECT.limit = val
+      } else if(key === 'having') {
+        if(!inferred.SELECT.having) inferred.SELECT.having = val
+        else inferred.SELECT.having.push('and', ...val)
+      }
+    }
+  }
   inferred = infer(inferred, model)
   // if the query has custom joins we don't want to transform it
   // TODO: move all the way to the top of this function once cds.infer supports joins as well
@@ -807,11 +823,11 @@ function cqn4sql(originalQuery, model) {
     // `SELECT from Authors {  books.genre as genreOfBooks { name } } becomes `SELECT from Books:genre as genreOfBooks`
     const from = { ref: subqueryFromRef, as: uniqueSubqueryAlias }
     const subqueryBase = {}
-    for (const [key, value] of Object.entries(column)) {
-      if (!(key in { ref: true, expand: true })) {
-        subqueryBase[key] = value
-      }
+    const queryModifiers = { ...column }
+    for (const [key, value] of Object.entries(queryModifiers)) {
+      if (key in { limit: 1, orderBy: 1, groupBy: 1, excluding: 1, where: 1, having: 1, count: 1 }) subqueryBase[key] = value
     }
+
     const subquery = {
       SELECT: {
         ...subqueryBase,
@@ -877,8 +893,8 @@ function cqn4sql(originalQuery, model) {
 
       // to be attached to dummy query
       const elements = {}
-      const wildcardIndex = column.expand.findIndex(e => e === '*')
-      if (wildcardIndex !== -1) {
+      const containsWildcard = column.expand.includes('*')
+      if (containsWildcard) {
         // expand with wildcard vanishes as expand is part of the group by (OData $apply + $expand)
         return null
       }
@@ -888,8 +904,10 @@ function cqn4sql(originalQuery, model) {
 
         if (expand.expand) {
           const nested = _subqueryForGroupBy(expand, fullRef, expand.as || expand.ref.map(idOnly).join('_'))
-          setElementOnColumns(nested, expand.element)
-          elements[expand.as || expand.ref.map(idOnly).join('_')] = nested
+          if(nested) {
+            setElementOnColumns(nested, expand.element)
+            elements[expand.as || expand.ref.map(idOnly).join('_')] = nested
+          }
           return nested
         }
 
@@ -910,7 +928,11 @@ function cqn4sql(originalQuery, model) {
           elements[c.as || c.ref.at(-1)] = c.element
         })
         return res
-      })
+      }).filter(c => c)
+
+      if (expandedColumns.length === 0) {
+        return null
+      }
 
       const SELECT = {
         from: null,
@@ -1225,8 +1247,7 @@ function cqn4sql(originalQuery, model) {
         if (flattenThisForeignKey) {
           const fkElement = getElementForRef(k.ref, getDefinition(element.target))
           let fkBaseName
-          if (!leafAssoc || leafAssoc.onlyForeignKeyAccess)
-            fkBaseName = `${baseName}_${k.as || k.ref.at(-1)}`
+          if (!leafAssoc || leafAssoc.onlyForeignKeyAccess) fkBaseName = `${baseName}_${k.as || k.ref.at(-1)}`
           // e.g. if foreign key is accessed via infix filter - use join alias to access key in target
           else fkBaseName = k.ref.at(-1)
           const fkPath = [...csnPath, k.ref.at(-1)]
@@ -1478,8 +1499,7 @@ function cqn4sql(originalQuery, model) {
           // reject associations in expression, except if we are in an infix filter -> $baseLink is set
           assertNoStructInXpr(token, $baseLink)
           // reject virtual elements in expressions as they will lead to a sql error down the line
-          if(definition?.virtual)
-            throw new Error(`Virtual elements are not allowed in expressions`)
+          if (definition?.virtual) throw new Error(`Virtual elements are not allowed in expressions`)
 
           let result = is_regexp(token?.val) ? token : copy(token) // REVISIT: too expensive! //
           if (token.ref) {

package/package.json

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