@cap-js/db-service 1.2.0 → 1.3.0

package/CHANGELOG.md

@@ -4,6 +4,26 @@
 - The format is based on [Keep a Changelog](http://keepachangelog.com/).
 - This project adheres to [Semantic Versioning](http://semver.org/).
 
+## Version 1.3.0 - 2023-10-06
+
+### Changed
+
+- `INSERT.into(...).rows/values()` is not allowed anymore without specifying `.columns(...)`. #209
+- Deep deletion uses correlated subqueries instead of materializing the to be deleted object before. #212
+
+### Fixed
+
+- Various fixes for calculated elements on read. #220 #223 #233
+- Don't release to pool connections twice. #243
+- Syntax error in `matchesPattern` function. #237
+- SELECTs with more than 50 columns does not return `null` values. #238 #261
+
+## Version 1.2.1 - 2023-09-08
+
+### Fixed
+
+- Association expansion in infix filters. #213
+
 ## Version 1.2.0 - 2023-09-06
 
 ### Added

package/README.md

@@ -2,4 +2,20 @@
 
 Welcome to the new base database service for [SAP Cloud Application Programming Model](https://cap.cloud.sap) Node.js, based on new, streamlined database architecture.
 
-Find documentation at https://cap.cloud.sap/docs/guides/databases.
+Find documentation at https://cap.cloud.sap/docs/guides/databases
+
+## Support
+
+This project is open to feature requests/suggestions, bug reports etc. via [GitHub issues](https://github.com/cap-js/cds-dbs/issues).
+
+## Contribution
+
+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).
+
+## 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.
+
+## Licensing
+
+Copyright 2023 SAP SE or an SAP affiliate company and cds-dbs contributors. Please see our [LICENSE](LICENSE) for copyright and license information. Detailed information including third-party components and their licensing/copyright information is available [via the REUSE tool](https://api.reuse.software/info/github.com/cap-js/cds-dbs).

package/lib/SQLService.js

@@ -4,16 +4,12 @@ const { resolveView } = require('@sap/cds/libx/_runtime/common/utils/resolveView
 const DatabaseService = require('./common/DatabaseService')
 const cqn4sql = require('./cqn4sql')
 
-/**
- * @callback next
- * @param {Error} param0
- * @returns {Promise<unknown>}
- */
+/** @typedef {import('@sap/cds/apis/services').Request} Request */
 
 /**
  * @callback Handler
- * @param {import('@sap/cds/apis/services').Request} param0
- * @param {next} param1
+ * @param {Request} req
+ * @param {(err? : Error) => {Promise<unknown>}} next
  * @returns {Promise<unknown>}
  */
 
@@ -22,13 +18,14 @@ class SQLService extends DatabaseService {
   init() {
     this.on(['SELECT'], this.transformStreamFromCQN)
     this.on(['UPDATE'], this.transformStreamIntoCQN)
-    this.on(['INSERT', 'UPSERT', 'UPDATE', 'DELETE'], require('./fill-in-keys')) // REVISIT should be replaced by correct input processing eventually
-    this.on(['INSERT', 'UPSERT', 'UPDATE', 'DELETE'], require('./deep-queries').onDeep)
+    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)
     this.on(['UPSERT'], this.onUPSERT)
     this.on(['UPDATE'], this.onUPDATE)
-    this.on(['DELETE', 'CREATE ENTITY', 'DROP ENTITY'], this.onSIMPLE)
+    this.on(['DELETE'], this.onDELETE)
+    this.on(['CREATE ENTITY', 'DROP ENTITY'], this.onSIMPLE)
     this.on(['BEGIN', 'COMMIT', 'ROLLBACK'], this.onEVENT)
     this.on(['STREAM'], this.onSTREAM)
     this.on(['*'], this.onPlainSQL)
@@ -152,6 +149,39 @@ class SQLService extends DatabaseService {
     return (await ps.run(values)).changes
   }
 
+  get onDELETE() {
+    return super.onDELETE = cds.env.features.assert_integrity === 'db' ? this.onSIMPLE : deep_delete
+    async function deep_delete(/** @type {Request} */ req) {
+      let { compositions } = req.target
+      if (compositions) {
+        // Transform CQL`DELETE from Foo[p1] WHERE p2` into CQL`DELETE from Foo[p1 and p2]`
+        let { from, where } = req.query.DELETE
+        if (typeof from === 'string') from = { ref: [from] }
+        if (where) {
+          let last = from.ref.at(-1)
+          if (last.where) [ last, where ] = [ last.id, [ { xpr: last.where }, 'and', { xpr: where } ] ]
+          from = {ref:[ ...from.ref.slice(0,-1), { id: last, where }]}
+        }
+        // Process child compositions depth-first
+        let { depth=0, visited=[] } = req
+        visited.push (req.target.name)
+        await Promise.all (Object.values(compositions).map(c => {
+          if (c._target['@cds.persistence.skip'] === true) return
+          if (c._target === req.target) { // the Genre.children case
+            if (++depth > (c['@depth'] || 3)) return
+          } else if (visited.includes(c._target.name)) throw new Error(
+            `Transitive circular composition detected: \n\n`+
+            `  ${visited.join(' > ')} > ${c._target.name} \n\n`+
+            `These are not supported by deep delete.`)
+          // Prepare and run deep query, à la CQL`DELETE from Foo[pred]:comp1.comp2...`
+          const query = DELETE.from({ref:[ ...from.ref, c.name ]})
+          return this.onDELETE({ query, depth, visited: [...visited], target: c._target })
+        }))
+      }
+      return this.onSIMPLE(req)
+    }
+  }
+
   /**
    * Handler for BEGIN, COMMIT, ROLLBACK, which don't have any CQN
    * @type {Handler}
@@ -167,11 +197,6 @@ class SQLService extends DatabaseService {
    */
   async onPlainSQL({ query, data }, next) {
     if (typeof query === 'string') {
-      // REVISIT: this is a hack the target of $now might not be a timestamp or date time
-      // Add input converter to CURRENT_TIMESTAMP inside views using $now
-      if(/^CREATE VIEW.* CURRENT_TIMESTAMP[( ]/is.test(query)) {
-        query = query.replace(/CURRENT_TIMESTAMP/gi, 'ISO(CURRENT_TIMESTAMP)')
-      }
       DEBUG?.(query, data)
       const ps = await this.prepare(query)
       const exec = this.hasResults(query) ? d => ps.all(d) : d => ps.run(d)

package/lib/common/DatabaseService.js

@@ -81,12 +81,11 @@ class DatabaseService extends cds.Service {
    */
   async rollback() {
     if (!this.dbc) return
-    else
-      try {
-        await this.send('ROLLBACK')
-      } finally {
-        this.release()
-      }
+    try {
+      await this.send('ROLLBACK')
+    } finally {
+      this.release()
+    }
   }
 
   /**
@@ -102,7 +101,9 @@ class DatabaseService extends cds.Service {
    * This is for subclasses to intercept, if required.
    */
   async release() {
-    return this.pool.release(this.dbc)
+    if (!this.dbc) return
+    await this.pool.release(this.dbc)
+    this.dbc = undefined
   }
 
   // REVISIT: should happen automatically after a configurable time

package/lib/cql-functions.js

@@ -98,7 +98,7 @@ const StandardFunctions = {
    * @param {string} y
    * @returns {string}
    */
-  matchesPattern: (x, y) => `${x} regexp ${y})`,
+  matchesPattern: (x, y) => `(${x} regexp ${y})`,
   /**
    * Generates SQL statement that produces the lower case value of a given string
    * @param {string} x
@@ -341,7 +341,7 @@ const HANAFunctions = {
    */
   years_between(x, y) {
     return `floor(${this.months_between(x, y)} / 12)`
-  },
+  }
 }
 
 for (let each in HANAFunctions) HANAFunctions[each.toUpperCase()] = HANAFunctions[each]

package/lib/cqn2sql.js

@@ -233,23 +233,33 @@ class CQN2SQLRenderer {
   SELECT_expand({ SELECT, elements }, sql) {
     if (!SELECT.columns) return sql
     if (!elements) return sql // REVISIT: Above we say this is an error condition, but here we say it's ok?
+    
     let cols = SELECT.columns.map(x => {
       const name = this.column_name(x)
-      let col = `'$."${name}"',${this.output_converter4(x.element, this.quote(name))}`
+      let col = `'${name}',${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 })
-        col += `, '$."${name}@odata.count"',${this.expr(qc)}`
+        return [col, `'${name}@odata.count',${this.expr(qc)}`]
       }
       return col
-    })
+    }).flat()
 
     // Prevent SQLite from hitting function argument limit of 100
-    let obj = "'{}'"
-    for (let i = 0; i < cols.length; i += 48) {
-      obj = `json_insert(${obj},${cols.slice(i, i + 48)})`
-    }
-    return `SELECT ${SELECT.one || SELECT.expand === 'root' ? obj : `json_group_array(${obj})`} as _json_ FROM (${sql})`
+    let obj = ''
+
+    if(cols.length < 50) obj =  `json_object(${cols.slice(0, 50)})`
+    else {
+      const chunks = []
+      for (let i = 0; i < cols.length; i += 50) {
+        chunks.push(`json_object(${cols.slice(i, i + 50)})`)
+      }
+      // REVISIT: json_merge is a user defined function, bad performance!
+      obj = `json_merge(${chunks})`
+    } 
+
+
+    return `SELECT ${SELECT.one || SELECT.expand === 'root' ? obj : `json_group_array(${obj.includes('json_merge') ? `json_insert(${obj})` : obj})`} as _json_ FROM (${sql})`
   }
 
   /**
@@ -431,20 +441,18 @@ class CQN2SQLRenderer {
     const entity = this.name(q.target?.name || INSERT.into.ref[0])
     const alias = INSERT.into.as
     const elements = q.elements || q.target?.elements
-    if (!INSERT.columns && !elements) {
-      throw cds.error`Cannot insert rows without columns or elements`
-    }
-    let columns = INSERT.columns || (elements && ObjectKeys(elements).filter(c => !elements[c].virtual && !elements[c].isAssociation))
-    this.columns = columns.map(c => this.quote(c))
+    const columns = INSERT.columns
+    || cds.error`Cannot insert rows without columns or elements`
 
-    const inputConverterKey = this.class._convertInput
+    const inputConverter = this.class._convertInput
     const extraction = columns.map((c,i) => {
-      const element = elements?.[c] || {}
       const extract = `value->>'$[${i}]'`
-      const converter = element[inputConverterKey] || (e => e)
-      return converter(extract, element)
+      const element = elements?.[c]
+      const converter = element?.[inputConverter]
+      return converter?.(extract,element) || extract
     })
 
+    this.columns = columns.map(c => this.quote(c))
     this.entries = [[JSON.stringify(INSERT.rows)]]
     return (this.sql = `INSERT INTO ${this.quote(entity)}${alias ? ' as ' + this.quote(alias) : ''} (${
       this.columns

package/lib/cqn4sql.js

@@ -310,8 +310,11 @@ function cqn4sql(originalQuery, model = cds.context?.model || cds.model) {
       const col = columns[i]
 
       if (isCalculatedOnRead(col.$refLinks?.[col.$refLinks.length - 1].definition)) {
-        const calcElement = resolveCalculatedElement(col)
-        transformedColumns.push(calcElement)
+        const name = getName(col)
+        if (!transformedColumns.some(inserted => getName(inserted) === name)) {
+          const calcElement = resolveCalculatedElement(col)
+          transformedColumns.push(calcElement)
+        }
       } else if (col.expand) {
         if (col.ref?.length > 1 && col.ref[0] === '$self' && !col.$refLinks[0].definition.kind) {
           const dollarSelfReplacement = calculateDollarSelfColumn(col)
@@ -433,7 +436,6 @@ function cqn4sql(originalQuery, model = cds.context?.model || cds.model) {
 
       if (col.$refLinks.some(link => link.definition._target?.['@cds.persistence.skip'] === true)) return
 
-      const getName = col => col.as || col.ref?.at(-1)
       const flatColumns = getFlatColumnsFor(col, { baseName, columnAlias, tableAlias })
       flatColumns.forEach(flatColumn => {
         const name = getName(flatColumn)
@@ -480,7 +482,7 @@ function cqn4sql(originalQuery, model = cds.context?.model || cds.model) {
 
     function handleEmptyColumns(columns) {
       if (columns.some(c => c.$refLinks?.[c.$refLinks.length - 1].definition.type === 'cds.Composition')) return
-      throw new cds.error('Queries must have at least one non-virtual column')
+      throw new Error('Queries must have at least one non-virtual column')
     }
   }
 
@@ -509,7 +511,9 @@ function cqn4sql(originalQuery, model = cds.context?.model || cds.model) {
       res = { xpr: getTransformedTokenStream(value.xpr, baseLink) }
     } else if (val) {
       res = { val }
-    } else if (func) res = { args: getTransformedTokenStream(value.args, baseLink), func: value.func }
+    } else if (func) {
+      res = { args: getTransformedTokenStream(value.args, baseLink), func: value.func }
+    }
     if (!omitAlias) res.as = column.as || column.name || column.flatName
     return res
   }
@@ -548,7 +552,10 @@ function cqn4sql(originalQuery, model = cds.context?.model || cds.model) {
         dollarSelfColumn.ref = [...referencedColumn.ref, ...dollarSelfColumn.ref.slice(2)]
         Object.defineProperties(dollarSelfColumn, {
           flatName: {
-            value: referencedColumn.$refLinks[0].definition.kind === 'entity' ?  dollarSelfColumn.ref.slice(1).join('_') : dollarSelfColumn.ref.join('_'),
+            value:
+              referencedColumn.$refLinks[0].definition.kind === 'entity'
+                ? dollarSelfColumn.ref.slice(1).join('_')
+                : dollarSelfColumn.ref.join('_'),
           },
           isJoinRelevant: {
             value: referencedColumn.isJoinRelevant,
@@ -661,7 +668,7 @@ function cqn4sql(originalQuery, model = cds.context?.model || cds.model) {
     // everything after the wildcard, is a potential replacement
     // in the wildcard expansion
     const replace = []
-    // we need to absolutefy the refs
+    // we need to make the refs absolute
     col[prop].slice(wildcardIndex + 1).forEach(c => {
       const fakeColumn = { ...c }
       if (fakeColumn.ref) {
@@ -849,7 +856,7 @@ function cqn4sql(originalQuery, model = cds.context?.model || cds.model) {
          * the result.
          */
         if (inOrderBy && flatColumns.length > 1)
-          cds.error(`"${getFullName(leaf)}" can't be used in order by as it expands to multiple fields`)
+          throw new Error(`"${getFullName(leaf)}" can't be used in order by as it expands to multiple fields`)
         if (col.nulls) flatColumns[0].nulls = col.nulls
         if (col.sort) flatColumns[0].sort = col.sort
         res.push(...flatColumns)
@@ -907,21 +914,23 @@ function cqn4sql(originalQuery, model = cds.context?.model || cds.model) {
    */
   function getColumnsForWildcard(exclude = [], replace = []) {
     const wildcardColumns = []
-    Object.keys(inferred.$combinedElements).forEach(k => {
-      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
-      // 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] })
-      } else if (isCalculatedOnRead(element)) {
-        wildcardColumns.push(resolveCalculatedElement(element))
-      } else {
-        const flatColumns = getFlatColumnsFor(element, { tableAlias: index }, [], { exclude, replace }, true)
-        wildcardColumns.push(...flatColumns)
-      }
-    })
+    Object.keys(inferred.$combinedElements)
+      .filter(k => !exclude.includes(k))
+      .forEach(k => {
+        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
+        // 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] })
+        } else if (isCalculatedOnRead(element)) {
+          wildcardColumns.push(resolveCalculatedElement(replace.find(r => r.as === k) || element))
+        } else {
+          const flatColumns = getFlatColumnsFor(element, { tableAlias: index }, [], { exclude, replace }, true)
+          wildcardColumns.push(...flatColumns)
+        }
+      })
     return wildcardColumns
 
     /**
@@ -1140,7 +1149,7 @@ function cqn4sql(originalQuery, model = cds.context?.model || cds.model) {
         const { ref, $refLinks } = tokenStream[i + 1]
         if (!ref) continue
         if (ref[0] in { $self: true, $projection: true })
-          cds.error(`Unexpected "${ref[0]}" following "exists", remove it or add a table alias instead`)
+          throw new Error(`Unexpected "${ref[0]}" following "exists", remove it or add a table alias instead`)
         const firstStepIsTableAlias = ref.length > 1 && ref[0] in inferred.sources
         for (let j = 0; j < ref.length; j += 1) {
           let current, next
@@ -1173,6 +1182,22 @@ function cqn4sql(originalQuery, model = cds.context?.model || cds.model) {
 
           const as = getNextAvailableTableAlias(getLastStringSegment(next.alias))
           next.alias = as
+          if (next.definition.value) {
+            throw new Error(
+              `Calculated elements cannot be used in “exists” predicates in: “exists ${tokenStream[i + 1].ref
+                .map(idOnly)
+                .join('.')}”`,
+            )
+          }
+          if (!next.definition.target) {
+            throw new Error(
+              `Expecting path “${tokenStream[i + 1].ref
+                .map(idOnly)
+                .join('.')}” following “EXISTS” predicate to end with association/composition, found “${
+                next.definition.type
+              }”`,
+            )
+          }
           whereExistsSubSelects.push(getWhereExistsSubquery(current, next, step.where, true))
         }
 
@@ -1241,8 +1266,8 @@ function cqn4sql(originalQuery, model = cds.context?.model || cds.model) {
             rhs === 'null'
           ) {
             if (notSupportedOps.some(([firstOp]) => firstOp === next))
-              cds.error(`The operator "${next}" is not supported for structure comparison`)
-            const newTokens = expandComparison(token, ops, rhs)
+              throw new Error(`The operator "${next}" is not supported for structure comparison`)
+            const newTokens = expandComparison(token, ops, rhs, $baseLink)
             const needXpr = Boolean(tokenStream[i - 1] || tokenStream[indexRhs + 1])
             transformedTokenStream.push(...(needXpr ? [asXpr(newTokens)] : newTokens))
             i = indexRhs // jump to next relevant index
@@ -1266,8 +1291,15 @@ function cqn4sql(originalQuery, model = cds.context?.model || cds.model) {
               transformedTokenStream.push(...getTransformedTokenStream(dollarSelfReplacement))
               continue
             }
-            const tableAlias = getQuerySourceName(token, $baseLink)
-            if (!$baseLink && token.isJoinRelevant) {
+            // if we have e.g. a calculated element like `books.authorLastName,`
+            // we have effectively a ref ['books', 'author', 'lastName']
+            // in that case, we have a baseLink `books` which we need to resolve the following steps
+            // however, the correct table alias has been assigned to the `author` step
+            // hence we need to ignore the alias of the `$baseLink`
+            const refHasOwnAssoc =
+              token.isJoinRelevant && [...token.$refLinks].reverse().find(l => l.definition.isAssociation)
+            const tableAlias = getQuerySourceName(token, refHasOwnAssoc || $baseLink)
+            if ((!$baseLink || refHasOwnAssoc) && token.isJoinRelevant) {
               result.ref = [tableAlias, getFullName(token.$refLinks[token.$refLinks.length - 1].definition)]
             } else if (tableAlias) {
               result.ref = [tableAlias, token.flatName]
@@ -1301,9 +1333,14 @@ function cqn4sql(originalQuery, model = cds.context?.model || cds.model) {
    * @param {object} token with $refLinks
    * @param {string} operator one of allOps
    * @param {object} value either `null` or a column (with `ref` and `$refLinks`)
+   * @param {object} $baseLink optional base `$refLink`, e.g. for infix filters of scoped queries.
+   *                           In the following example, we must pass `bookshop:Reproduce` as $baseLink for `author`:
+   *
+   *                           `DELETE.from('bookshop.Reproduce[author = null]:accessGroup')`
+   *                                                            ^^^^^^
    * @returns {array}
    */
-  function expandComparison(token, operator, value) {
+  function expandComparison(token, operator, value, $baseLink = null) {
     const { definition } = token.$refLinks[token.$refLinks.length - 1]
     let flatRhs
     const result = []
@@ -1319,7 +1356,7 @@ function cqn4sql(originalQuery, model = cds.context?.model || cds.model) {
       //        --> 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
-        cds.error(
+        throw new Error(
           `Can't compare "${definition.name}" with "${
             value.$refLinks[value.$refLinks.length - 1].definition.name
           }": the operands must have the same structure`,
@@ -1347,13 +1384,13 @@ function cqn4sql(originalQuery, model = cds.context?.model || cds.model) {
         // if we still have elements in flatRhs -> those were not found in lhs
         const lhsPath = token.ref.join('.') // original path of the comparison, used in error message
         flatRhs.forEach(t => pathNotFoundErr.push(`Path "${t._csnPath.slice(1).join('.')}" not found in "${lhsPath}"`))
-        cds.error(`Can't compare "${lhsPath}" with "${rhsPath}": ${pathNotFoundErr.join(', ')}`)
+        throw new Error(`Can't compare "${lhsPath}" with "${rhsPath}": ${pathNotFoundErr.join(', ')}`)
       }
     } else {
       // compare with value
       const flatLhs = flattenWithBaseName(token)
       if (flatLhs.length > 1 && value.val !== null && value !== 'null')
-        cds.error(`Can't compare structure "${token.ref.join('.')}" with value "${value.val}"`)
+        throw new Error(`Can't compare structure "${token.ref.join('.')}" with value "${value.val}"`)
       const boolOp = notEqOps.some(([f, s]) => operator[0] === f && operator[1] === s) ? 'or' : 'and'
       flatLhs.forEach((column, i) => {
         result.push(column, ...operator, value)
@@ -1366,7 +1403,10 @@ function cqn4sql(originalQuery, model = cds.context?.model || cds.model) {
       if (!def.$refLinks) return def
       const leaf = def.$refLinks[def.$refLinks.length - 1]
       const first = def.$refLinks[0]
-      const tableAlias = getQuerySourceName(def, def.ref.length > 1 && first.definition.isAssociation ? first : null)
+      const tableAlias = getQuerySourceName(
+        def,
+        def.ref.length > 1 && first.definition.isAssociation ? first : $baseLink,
+      )
       if (leaf.definition.parent.kind !== 'entity')
         // we need the base name
         return getFlatColumnsFor(leaf.definition, {
@@ -1386,10 +1426,10 @@ function cqn4sql(originalQuery, model = cds.context?.model || cds.model) {
       rejectStructInExpression()
 
     function rejectAssocInExpression() {
-      throw new Error(/An association can't be used as a value in an expression/)
+      throw new Error("An association can't be used as a value in an expression")
     }
     function rejectStructInExpression() {
-      throw new Error(/A structured element can't be used as a value in an expression/)
+      throw new Error("A structured element can't be used as a value in an expression")
     }
   }
 
@@ -1935,7 +1975,6 @@ function cqn4sql(originalQuery, model = cds.context?.model || cds.model) {
     if ($baseLink) {
       return getBaseLinkAlias($baseLink)
     }
-
     if (node.isJoinRelevant) {
       return getJoinRelevantAlias(node)
     }
@@ -2037,6 +2076,6 @@ function setElementOnColumns(col, element) {
     writable: true,
   })
 }
-
+const getName = col => col.as || col.ref?.at(-1)
 const idOnly = ref => ref.id || ref
 const is_regexp = x => x?.constructor?.name === 'RegExp' // NOTE: x instanceof RegExp doesn't work in repl

package/lib/deep-queries.js

@@ -17,38 +17,29 @@ const handledDeep = Symbol('handledDeep')
  */
 async function onDeep(req, next) {
   const { query } = req
+  if (handledDeep in query) return next()
+
   // REVISIT: req.target does not match the query.INSERT target for path insert
   // const target = query.sources[Object.keys(query.sources)[0]]
-  if (!this.model?.definitions[_target_name4(req.query)]) {
-    return next()
-  }
+  if (!this.model?.definitions[_target_name4(req.query)]) return next()
+
   const { target } = this.infer(query)
   if (!hasDeep(query, target)) return next()
-  const beforeData = query.INSERT ? [] : await this.run(getExpandForDeep(query, target, true))
 
-  if (query.UPDATE && !beforeData.length) {
-    return 0
-  }
+  const beforeData = query.INSERT ? [] : await this.run(getExpandForDeep(query, target, true))
+  if (query.UPDATE && !beforeData.length) return 0
 
   const queries = getDeepQueries(query, beforeData, target)
-  const res = await Promise.all(
-    queries.map(query => {
-      if (query.INSERT) return this.onINSERT({ query })
-      if (query.UPDATE) return this.onUPDATE({ query })
-      if (query.DELETE) return this.onSIMPLE({ query })
-    }),
-  )
+  const res = await Promise.all(queries.map(query => {
+    if (query.INSERT) return this.onINSERT({ query })
+    if (query.UPDATE) return this.onUPDATE({ query })
+    if (query.DELETE) return this.onSIMPLE({ query })
+  }))
   return res[0] ?? 0 // TODO what todo with multiple result responses?
 }
 
-const hasDeep = (query, target) => {
-  if (handledDeep in query) return
-  if (query.DELETE) {
-    for (let c in target?.compositions) return true
-    return false
-  }
-  const data =
-    query.INSERT?.entries || (query.UPDATE?.data && [query.UPDATE.data]) || (query.UPDATE?.with && [query.UPDATE.with])
+const hasDeep = (q, target) => {
+  const data = q.INSERT?.entries || (q.UPDATE?.data && [q.UPDATE.data]) || (q.UPDATE?.with && [q.UPDATE.with])
   if (data)
     for (const c in target.compositions) {
       for (const row of data) if (row[c] !== undefined) return true
@@ -110,7 +101,7 @@ const _calculateExpandColumns = (target, data, expandColumns = [], elementMap =
     const seen = elementMap.get(fqn)
     if (seen && seen >= DEEP_DELETE_MAX_RECURSION_DEPTH) {
       // recursion -> abort
-      return
+      return expandColumns
     }
 
     let expandColumn = expandColumns.find(expandColumn => expandColumn.ref[0] === composition.name)
@@ -145,6 +136,7 @@ const _calculateExpandColumns = (target, data, expandColumns = [], elementMap =
       _calculateExpandColumns(composition._target, compositionData, expandColumn.expand, newElementMap)
     }
   }
+  return expandColumns
 }
 
 /**
@@ -152,18 +144,9 @@ const _calculateExpandColumns = (target, data, expandColumns = [], elementMap =
  * @param {import('@sap/cds/apis/csn').Definition} target
  */
 const getExpandForDeep = (query, target) => {
-  const from = query.DELETE?.from || query.UPDATE?.entity
-  const data = query.UPDATE?.data || null
-  const where = query.DELETE?.where || query.UPDATE?.where
-
-  /** @type {import("@sap/cds/apis/ql").SELECT<unknown>} */
-  const cqn = SELECT.from(from)
-  if (where) cqn.SELECT.where = where
-
-  const columns = []
-  _calculateExpandColumns(target, data, columns)
-  cqn.columns(columns)
-  return cqn
+  const { entity, data = null, where } = query.UPDATE
+  const columns = _calculateExpandColumns(target, data)
+  return SELECT(columns).from(entity).where(where)
 }
 
 /**

package/lib/fill-in-keys.js

@@ -62,7 +62,7 @@ module.exports = async function fill_in_keys(req, next) {
   }
 
   // REVISIT no input processing for INPUT with rows/values
-  if (req.event !== 'DELETE' && !(req.query.INSERT?.rows || req.query.INSERT?.values)) {
+  if (!(req.query.INSERT?.rows || req.query.INSERT?.values)) {
     if (Array.isArray(req.data)) {
       for (const d of req.data) {
         generateUUIDandPropagateKeys(req.target, d, req.event)

package/lib/infer/index.js

@@ -23,12 +23,12 @@ for (const each in cdsTypes) cdsTypes[`cds.${each}`] = cdsTypes[each]
  * @returns {import('./cqn').Query} = q with .target and .elements
  */
 function infer(originalQuery, model = cds.context?.model || cds.model) {
-  if (!model) cds.error('Please specify a model')
+  if (!model) throw new Error('Please specify a model')
   const inferred = typeof originalQuery === 'string' ? cds.parse.cql(originalQuery) : cds.ql.clone(originalQuery)
 
   // REVISIT: The more edge use cases we support, thes less optimized are we for the 90+% use cases
   // e.g. there's a lot of overhead for infer( SELECT.from(Books) )
-  if (originalQuery.SET) cds.error('”UNION” based queries are not supported')
+  if (originalQuery.SET) throw new Error('”UNION” based queries are not supported')
   const _ =
     inferred.SELECT ||
     inferred.INSERT ||
@@ -97,16 +97,16 @@ function infer(originalQuery, model = cds.context?.model || cds.model) {
     if (ref) {
       const first = ref[0].id || ref[0]
       let target = getDefinition(first, model)
-      if (!target) 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]?.elements ? d.elements[r.id || r] : d.elements[r.id || r]?._target
-          if (!next) cds.error(`No association "${r.id || r}" in ${d.kind} "${d.name}": ${d}`)
+          if (!next) throw new Error(`No association “${r.id || r}” in ${d.kind} “${d.name}”`)
           return next
         }, target)
       }
       if (target.kind !== 'entity' && !target._isAssociation)
-        throw new Error(/Query source must be a an entity or an association/)
+        throw new Error('Query source must be a an entity or an association')
 
       attachRefLinksToArg(from) // REVISIT: remove
       const alias =
@@ -154,8 +154,9 @@ function infer(originalQuery, model = cds.context?.model || cds.model) {
    * @returns {void} This function does not return a value; it mutates the 'arg' object directly.
    */
   function attachRefLinksToArg(arg, $baseLink = null, expandOrExists = false) {
-    const { ref, xpr } = arg
+    const { ref, xpr, args } = arg
     if (xpr) xpr.forEach(t => attachRefLinksToArg(t, $baseLink, expandOrExists))
+    if (args) args.forEach(arg => attachRefLinksToArg(arg, $baseLink, expandOrExists))
     if (!ref) return
     init$refLinks(arg)
     ref.forEach((step, i) => {
@@ -172,9 +173,7 @@ 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`)
@@ -288,8 +287,8 @@ function infer(originalQuery, model = cds.context?.model || cds.model) {
           wildcardSelect = true
         } else if (col.val !== undefined || col.xpr || col.SELECT || col.func || col.param) {
           const as = col.as || col.func || col.val
-          if (as === undefined) throw cds.error`Expecting expression to have an alias name`
-          if (queryElements[as]) throw cds.error`Duplicate definition of element “${as}”`
+          if (as === undefined) cds.error`Expecting expression to have an alias name`
+          if (queryElements[as]) cds.error`Duplicate definition of element “${as}”`
           if (col.xpr || col.SELECT) {
             queryElements[as] = getElementForXprOrSubquery(col)
           } else if (col.func) {
@@ -313,7 +312,7 @@ function infer(originalQuery, model = cds.context?.model || cds.model) {
         } else if (col.expand) {
           inferQueryElement(col)
         } else {
-          throw cds.error`Not supported: ${JSON.stringify(col)}`
+          cds.error`Not supported: ${JSON.stringify(col)}`
         }
       })
 
@@ -338,34 +337,43 @@ function infer(originalQuery, model = cds.context?.model || cds.model) {
         inferQueryElement(token, false, $baseLink)
       })
     }
-    if (where) {
+
+    // 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
+      Object.values(_.with).forEach(val => inferQueryElement(val, false))
+
+    return queryElements
+
+    /**
+     * Recursively drill down into a tokenStream (`where` or `having`) and pass
+     * 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 
+     */
+    function walkTokenStream(tokenStream) {
       let skipJoins
-      const walkTokenStream = token => {
-        if (token === 'exists') {
+      const processToken = t => {
+        if (t === 'exists') {
           // no joins for infix filters along `exists <path>`
           skipJoins = true
-        } else if (token.xpr) {
+        } else if (t.xpr) {
           // don't miss an exists within an expression
-          token.xpr.forEach(walkTokenStream)
+          t.xpr.forEach(processToken)
         } else {
-          inferQueryElement(token, false, null, { inExists: skipJoins, inExpr: true })
+          inferQueryElement(t, false, null, { inExists: skipJoins, inExpr: true })
           skipJoins = false
         }
       }
-      where.forEach(walkTokenStream)
+      tokenStream.forEach(processToken)
     }
-    if (groupBy)
-      // link $refLinks
-      groupBy.forEach(token => inferQueryElement(token, false))
-    if (having)
-      // link $refLinks
-      having.forEach(token => inferQueryElement(token, false))
-    if (_.with)
-      // consider UPDATE.with
-      Object.values(_.with).forEach(val => inferQueryElement(val, false))
-
-    return queryElements
-
     /**
      * Processes references starting with `$self`, which are intended to target other query elements.
      * These `$self` paths must be handled after processing the "regular" columns since they are dependent on other query elements.
@@ -504,7 +512,7 @@ function infer(originalQuery, model = cds.context?.model || cds.model) {
                       .join('.')}" must not be an unmanaged association`,
                   )
                 // no non-fk traversal in infix filter
-                if (nextStep && !(nextStep in element.foreignKeys))
+                if (nextStep && element.foreignKeys && !(nextStep in element.foreignKeys))
                   throw new Error(`Only foreign keys of "${element.name}" can be accessed in infix filter`)
               }
               const resolvableIn = definition.target ? definition._target : target
@@ -536,10 +544,10 @@ function infer(originalQuery, model = cds.context?.model || cds.model) {
           const element = elements?.[id]
 
           if (firstStepIsSelf && element?.isAssociation) {
-            throw cds.error(
+            throw new Error(
               `Paths starting with “$self” must not contain steps of type “cds.Association”: ref: [ ${column.ref.map(
                 idOnly,
-              )} ]`,
+              ).join(', ')} ]`,
             )
           }
 
@@ -579,7 +587,7 @@ function infer(originalQuery, model = cds.context?.model || cds.model) {
         if (step.where) {
           const danglingFilter = !(column.ref[i + 1] || column.expand || column.inline || inExists)
           if (!column.$refLinks[i].definition.target || danglingFilter)
-            throw new Error(/A filter can only be provided when navigating along associations/)
+            throw new Error('A filter can only be provided when navigating along associations')
           if (!column.expand) Object.defineProperty(column, 'isJoinRelevant', { value: true })
           // books[exists genre[code='A']].title --> column is join relevant but inner exists filter is not
           let skipJoinsForFilter = inExists
@@ -664,7 +672,7 @@ function infer(originalQuery, model = cds.context?.model || cds.model) {
           : column
         if (isColumnJoinRelevant(colWithBase)) {
           if (originalQuery.UPDATE)
-            throw cds.error(
+            throw new Error(
               'Path expressions for UPDATE statements are not supported. Use “where exists” with infix filters instead.',
             )
           Object.defineProperty(column, 'isJoinRelevant', { value: true })
@@ -672,7 +680,7 @@ function infer(originalQuery, model = cds.context?.model || cds.model) {
         }
       }
       if (leafArt.value && !leafArt.value.stored) {
-        resolveCalculatedElement(column, $baseLink, baseColumn)
+        linkCalculatedElement(column, $baseLink, baseColumn)
       }
 
       /**
@@ -752,6 +760,7 @@ function infer(originalQuery, model = cds.context?.model || cds.model) {
               columns: expand.filter(c => !c.inline),
             },
           }
+          if (col.excluding) expandSubquery.SELECT.excluding = col.excluding
           if (col.as) expandSubquery.SELECT.as = col.as
           const inferredExpandSubquery = infer(expandSubquery, model)
           const res = $leafLink.definition.is2one
@@ -798,10 +807,10 @@ function infer(originalQuery, model = cds.context?.model || cds.model) {
         // if the `elt` from a `$self.elt` path is found in the `$combinedElements` -> hint to remove `$self`
         if (step in $combinedElements)
           err.push(` did you mean ${$combinedElements[step].map(ta => `"${ta.index || ta.as}.${step}"`).join(',')}?`)
-        throw new Error(err)
+        throw new Error(err.join(','))
       }
     }
-    function resolveCalculatedElement(column, baseLink, baseColumn) {
+    function linkCalculatedElement(column, baseLink, baseColumn) {
       const calcElement = column.$refLinks?.[column.$refLinks.length - 1].definition || column
       if (alreadySeenCalcElements.has(calcElement)) return
       else alreadySeenCalcElements.add(calcElement)
@@ -809,35 +818,54 @@ function infer(originalQuery, model = cds.context?.model || cds.model) {
       if (ref || xpr) {
         baseLink = baseLink || { definition: calcElement.parent, target: calcElement.parent }
         attachRefLinksToArg(calcElement.value, baseLink, true)
-        const basePath = { $refLinks: [], ref: [] }
+        const basePath =
+          column.$refLinks?.length > 1
+            ? { $refLinks: column.$refLinks.slice(0, -1), ref: column.ref.slice(0, -1) }
+            : { $refLinks: [], ref: [] }
         if (baseColumn) {
           basePath.$refLinks.push(...baseColumn.$refLinks)
           basePath.ref.push(...baseColumn.ref)
         }
-        // column is now fully linked, now we need to find out if we need to merge it into the join tree
-        // for that, we calculate all paths from a calc element and merge them into the join tree
         mergePathsIntoJoinTree(calcElement.value, basePath)
       }
       if (func)
-        calcElement.value.args?.forEach(arg =>
-          inferQueryElement(arg, false, { definition: calcElement.parent, target: calcElement.parent }),
-        ) // {func}.args are optional
-      function mergePathsIntoJoinTree(e, basePath = null) {
+        calcElement.value.args?.forEach(arg => {
+          inferQueryElement(
+            arg,
+            false,
+            { definition: calcElement.parent, target: calcElement.parent },
+            { inCalcElement: true },
+          )
+          const basePath =
+            column.$refLinks?.length > 1
+              ? { $refLinks: column.$refLinks.slice(0, -1), ref: column.ref.slice(0, -1) }
+              : { $refLinks: [], ref: [] }
+          mergePathsIntoJoinTree(arg, basePath)
+        }) // {func}.args are optional
+
+      /**
+       * Calculates all paths from a given ref and merges them into the join tree.
+       * Recursively walks into refs of calculated elements.
+       *
+       * @param {object} arg with a ref and sibling $refLinks
+       * @param {object} basePath with a ref and sibling $refLinks, used for recursion
+       */
+      function mergePathsIntoJoinTree(arg, basePath = null) {
         basePath = basePath || { $refLinks: [], ref: [] }
-        if (e.ref) {
-          e.$refLinks.forEach((link, i) => {
+        if (arg.ref) {
+          arg.$refLinks.forEach((link, i) => {
             const { definition } = link
             if (!definition.value) {
               basePath.$refLinks.push(link)
-              basePath.ref.push(e.ref[i])
+              basePath.ref.push(arg.ref[i])
             }
           })
-          const leafOfCalculatedElementRef = e.$refLinks[e.$refLinks.length - 1].definition
+          const leafOfCalculatedElementRef = arg.$refLinks[arg.$refLinks.length - 1].definition
           if (leafOfCalculatedElementRef.value) mergePathsIntoJoinTree(leafOfCalculatedElementRef.value, basePath)
 
-          mergePathIfNecessary(basePath, e)
-        } else if (e.xpr) {
-          e.xpr.forEach(step => {
+          mergePathIfNecessary(basePath, arg)
+        } else if (arg.xpr) {
+          arg.xpr.forEach(step => {
             if (step.ref) {
               const subPath = { $refLinks: [...basePath.$refLinks], ref: [...basePath.ref] }
               step.$refLinks.forEach((link, i) => {
@@ -923,14 +951,17 @@ function infer(originalQuery, model = cds.context?.model || cds.model) {
       const exclude = _.excluding ? x => _.excluding.includes(x) : () => false
 
       if (Object.keys(queryElements).length === 0 && aliases.length === 1) {
+        const { elements } = sources[aliases[0]]
         // only one query source and no overwritten columns
-        Object.entries(sources[aliases[0]].elements).forEach(([name, element]) => {
-          if (!exclude(name) && element.type !== 'cds.LargeBinary') queryElements[name] = element
-          if (element.value) {
-            // we might have join relevant calculated elements
-            resolveCalculatedElement(element)
-          }
-        })
+        Object.keys(elements)
+          .filter(k => !exclude(k))
+          .forEach(k => {
+            const element = sources[aliases[0]].elements[k]
+            if (element.type !== 'cds.LargeBinary') queryElements[k] = element
+            if (element.value) {
+              linkCalculatedElement(element)
+            }
+          })
         return
       }
 
@@ -943,6 +974,9 @@ function infer(originalQuery, model = cds.context?.model || cds.model) {
         if (exclude(name) || name in queryElements) return true
         const element = tableAliases[0].tableAlias.elements[name]
         if (element.type !== 'cds.LargeBinary') queryElements[name] = element
+        if (element.value) {
+          linkCalculatedElement(element)
+        }
       })
 
       if (Object.keys(ambiguousElements).length > 0) throwAmbiguousWildcardError()

package/lib/infer/join-tree.js

@@ -181,7 +181,10 @@ class JoinTree {
       if (next) {
         // step already seen before
         node = next
-        col.$refLinks[i] = node.$refLink // re-set $refLink to point to already merged $refLink
+        // re-set $refLink to equal the one which got already merged
+        col.$refLinks[i].alias = node.$refLink.alias
+        col.$refLinks[i].definition = node.$refLink.definition
+        col.$refLinks[i].target = node.$refLink.target
       } else {
         if (col.expand && !col.ref[i + 1]) {
           node.$refLink.onlyForeignKeyAccess = false

package/package.json

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