@cap-js/db-service 1.12.0 → 1.13.0

package/CHANGELOG.md

@@ -4,19 +4,44 @@
 - The format is based on [Keep a Changelog](http://keepachangelog.com/).
 - This project adheres to [Semantic Versioning](http://semver.org/).
 
+## [1.13.0](https://github.com/cap-js/cds-dbs/compare/db-service-v1.12.1...db-service-v1.13.0) (2024-10-01)
+
+
+### Added
+
+* Add quoted mode support ([#681](https://github.com/cap-js/cds-dbs/issues/681)) ([43c7a6c](https://github.com/cap-js/cds-dbs/commit/43c7a6c1bed836a1210eb9c2ff5c7ffc0e498d76))
+
+
+### Fixed
+
+* **deep-queries:** properly return insert result ([#803](https://github.com/cap-js/cds-dbs/issues/803)) ([8d800e2](https://github.com/cap-js/cds-dbs/commit/8d800e2858f02663b8ed3845909e5891af390517))
+* dont use virtual key for `UPDATE … where (&lt;key&gt;) in <subquery>` ([#800](https://github.com/cap-js/cds-dbs/issues/800)) ([d25af70](https://github.com/cap-js/cds-dbs/commit/d25af70b23688cd22c7b87f20a7848c9653ae9a9))
+* reject all path expressions w/o foreign keys ([#806](https://github.com/cap-js/cds-dbs/issues/806)) ([cd271a8](https://github.com/cap-js/cds-dbs/commit/cd271a8aa973afe0926ac1fa956cc64260140b98))
+
+## [1.12.1](https://github.com/cap-js/cds-dbs/compare/db-service-v1.12.0...db-service-v1.12.1) (2024-09-03)
+
+
+### Fixed
+
+* deep `groupby` expand queries ([#768](https://github.com/cap-js/cds-dbs/issues/768)) ([5423cf3](https://github.com/cap-js/cds-dbs/commit/5423cf38574962c09b94febab95f2e3dc118d2c9))
+* **deep:** prevent false unique constraint errors and combine delete queries ([#781](https://github.com/cap-js/cds-dbs/issues/781)) ([01de95f](https://github.com/cap-js/cds-dbs/commit/01de95f5050a1d3325459ccb78a4e9a1e0dbcfde))
+* **logging:** from changes in @sap/cds ([#791](https://github.com/cap-js/cds-dbs/issues/791)) ([1e8bf06](https://github.com/cap-js/cds-dbs/commit/1e8bf06c9ae92ba55d13fe9e3297d6a54c4fc8fe))
+* prepend aliases to refs within function args in on conditions ([#795](https://github.com/cap-js/cds-dbs/issues/795)) ([9b34314](https://github.com/cap-js/cds-dbs/commit/9b34314d1ef8c6fd7e77451fe9bf0abdc12c27ea)), closes [#779](https://github.com/cap-js/cds-dbs/issues/779)
+* prevent $search queries from throwing ([#772](https://github.com/cap-js/cds-dbs/issues/772)) ([cdf4d37](https://github.com/cap-js/cds-dbs/commit/cdf4d37590c2949cdfd6c6533370bc96cd8fd0fc))
+
 ## [1.12.0](https://github.com/cap-js/cds-dbs/compare/db-service-v1.11.0...db-service-v1.12.0) (2024-07-25)
 
 
 ### Fixed
 
-*** add placeholder for string values ([#733](https://github.com/cap-js/cds-dbs/issues/733)) ([8136a45](https://github.com/cap-js/cds-dbs/commit/8136a4526f596b67932908b8ab1336cb052100f3))
-*** for aggregated `expand` always set explicit alias ([#739](https://github.com/cap-js/cds-dbs/issues/739)) ([53a8075](https://github.com/cap-js/cds-dbs/commit/53a8075a609666a896296401a28b6183ff5aa487)), closes [#708](https://github.com/cap-js/cds-dbs/issues/708)
-*** quotations in vals ([#754](https://github.com/cap-js/cds-dbs/issues/754)) ([94d8e97](https://github.com/cap-js/cds-dbs/commit/94d8e977ed00776ff494287ce505d6b7e8017d2e))
+* add placeholder for string values ([#733](https://github.com/cap-js/cds-dbs/issues/733)) ([8136a45](https://github.com/cap-js/cds-dbs/commit/8136a4526f596b67932908b8ab1336cb052100f3))
+* for aggregated `expand` always set explicit alias ([#739](https://github.com/cap-js/cds-dbs/issues/739)) ([53a8075](https://github.com/cap-js/cds-dbs/commit/53a8075a609666a896296401a28b6183ff5aa487)), closes [#708](https://github.com/cap-js/cds-dbs/issues/708)
+* quotations in vals ([#754](https://github.com/cap-js/cds-dbs/issues/754)) ([94d8e97](https://github.com/cap-js/cds-dbs/commit/94d8e977ed00776ff494287ce505d6b7e8017d2e))
 
 
 ### Changed
 
-*** generic-pool as real dep ([#750](https://github.com/cap-js/cds-dbs/issues/750)) ([b50c907](https://github.com/cap-js/cds-dbs/commit/b50c907880455a41a73826a736bc17ca17e5b9ae))
+* generic-pool as real dep ([#750](https://github.com/cap-js/cds-dbs/issues/750)) ([b50c907](https://github.com/cap-js/cds-dbs/commit/b50c907880455a41a73826a736bc17ca17e5b9ae))
 
 
 ## [1.11.0](https://github.com/cap-js/cds-dbs/compare/db-service-v1.10.3...db-service-v1.11.0) (2024-07-08)

package/lib/cql-functions.js

@@ -23,10 +23,16 @@ const StandardFunctions = {
   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
-    const sub= /("")|("(?:[^"]|\\")*(?:[^\\]|\\\\)")|(\S*)/.exec(arg.val)
-    arg.val = arg.__proto__.val = (sub[2] ? JSON.parse(sub[2]) : sub[3]) || ''    
-    const refs = ref.list || [ref],
-      { toString } = ref
+    const sub = /("")|("(?:[^"]|\\")*(?:[^\\]|\\\\)")|(\S*)/.exec(arg.val)
+    let val
+    try {
+      val = (sub[2] ? JSON.parse(sub[2]) : sub[3]) || ''
+    } catch {
+      val = sub[2] || sub[3] || ''
+    }
+    arg.val = arg.__proto__.val = val
+    const refs = ref.list || [ref]
+    const { toString } = ref
     return '(' + refs.map(ref2 => this.contains(this.tolower(toString(ref2)), this.tolower(arg))).join(' or ') + ')'
   },
   /**
@@ -159,8 +165,8 @@ const StandardFunctions = {
    * 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'})
+  now: function () {
+    return this.session_context({ val: '$now' })
   },
   /**
    * Generates SQL statement that produces the year of a given timestamp

package/lib/cqn2sql.js

@@ -13,14 +13,14 @@ const BINARY_TYPES = {
 const { Readable } = require('stream')
 
 const DEBUG = (() => {
-  let DEBUG = cds.debug('sql-json')
-  if (DEBUG) return DEBUG
-  else DEBUG = cds.debug('sql|sqlite')
-  if (DEBUG) {
-    return DEBUG
+  const LOG = cds.log('sql-json')
+  if (LOG._debug) return cds.debug('sql-json')
+  return cds.debug('sql|sqlite')
+  //if (DEBUG) {
+  //  return DEBUG
     // (sql, ...more) => DEBUG (sql.replace(/(?:SELECT[\n\r\s]+(json_group_array\()?[\n\r\s]*json_insert\((\n|\r|.)*?\)[\n\r\s]*\)?[\n\r\s]+as[\n\r\s]+_json_[\n\r\s]+FROM[\n\r\s]*\(|\)[\n\r\s]*(\)[\n\r\s]+AS )|\)$)/gim,(a,b,c,d) => d || ''), ...more)
     // FIXME: looses closing ) on INSERT queries
-  }
+  //}
 })()
 
 class CQN2SQLRenderer {
@@ -34,6 +34,12 @@ class CQN2SQLRenderer {
     this.class = new.target // for IntelliSense
     this.class._init() // is a noop for subsequent calls
     this.model = srv?.model
+
+    // Overwrite smart quoting
+    if (cds.env.sql.names === 'quoted') {
+      this.class.prototype.name = (name) => name.id || name
+      this.class.prototype.quote = (s) => `"${String(s).replace(/"/g, '""')}"`
+    }
   }
 
   static _add_mixins(aspect, mixins) {
@@ -221,7 +227,7 @@ class CQN2SQLRenderer {
     let sql = `SELECT`
     if (distinct) sql += ` DISTINCT`
     if (!_empty(columns)) sql += ` ${columns}`
-    if (!_empty(from)) sql += ` FROM ${this.from(from)}`
+    if (!_empty(from)) sql += ` FROM ${this.from(from, q)}`
     else sql += this.from_dummy()
     if (!_empty(where)) sql += ` WHERE ${this.where(where)}`
     if (!_empty(groupBy)) sql += ` GROUP BY ${this.groupBy(groupBy)}`
@@ -311,8 +317,8 @@ class CQN2SQLRenderer {
    */
   column_expr(x, q) {
     if (x === '*') return '*'
-  
-    let sql = x.param !== true && typeof x.val === 'number' ? this.expr({ param: false, __proto__: x }): this.expr(x)
+
+    let sql = x.param !== true && typeof x.val === 'number' ? this.expr({ param: false, __proto__: x }) : this.expr(x)
     let alias = this.column_alias4(x, q)
     if (alias) sql += ' as ' + this.quote(alias)
     return sql
@@ -332,11 +338,16 @@ class CQN2SQLRenderer {
    * @param {import('./infer/cqn').source} from
    * @returns {string} SQL
    */
-  from(from) {
+  from(from, q) {
     const { ref, as } = from
     const _aliased = as ? s => s + ` as ${this.quote(as)}` : s => s
     if (ref) {
-      const z = ref[0]
+      let z = ref[0]
+      if (cds.env.sql.names === 'quoted') {
+        // use SELECT.from to infer query, cds.infer also expects a query
+        const { target } = q || SELECT.from(from)
+        z = target?.['@cds.persistence.name'] || ref[0]
+      }
       if (z.args) {
         return _aliased(`${this.quote(this.name(z))}${this.from_args(z.args)}`)
       }

package/lib/cqn4sql.js

@@ -4,6 +4,7 @@ const cds = require('@sap/cds')
 
 const infer = require('./infer')
 const { computeColumnsToBeSearched } = require('./search')
+const { prettyPrintRef } = require('./utils')
 
 /**
  * For operators of <eqOps>, this is replaced by comparing all leaf elements with null, combined with and.
@@ -130,15 +131,14 @@ 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(inferred.sources)[0].definition
-        const keys = Object.values(queryTarget.elements).filter(e => e.key === true)
         const primaryKey = { list: [] }
-        keys.forEach(k => {
-          // cqn4sql will add the table alias to the column later, no need to add it here
-          subquery.SELECT.columns.push({ ref: [k.name] })
-
-          // add the alias of the main query to the list of primary key references
-          primaryKey.list.push({ ref: [transformedFrom.as, k.name] })
-        })
+        for (const k of Object.keys(queryTarget.elements)) {
+          const e = queryTarget.elements[k]
+          if (e.key === true && !e.virtual) {
+            subquery.SELECT.columns.push({ ref: [e.name] })
+            primaryKey.list.push({ ref: [transformedFrom.as, e.name] })
+          }
+        }
 
         const transformedSubquery = cqn4sql(subquery, model)
 
@@ -530,7 +530,7 @@ function cqn4sql(originalQuery, model) {
       res = getTransformedTokenStream([value], baseLink)[0]
     } else if (xpr) {
       res = { xpr: getTransformedTokenStream(value.xpr, baseLink) }
-    } else if (val) {
+    } else if (val !== undefined) {
       res = { val }
     } else if (func) {
       res = { args: getTransformedFunctionArgs(value.args, baseLink), func: value.func }
@@ -763,6 +763,9 @@ function cqn4sql(originalQuery, model) {
   function expandColumn(column) {
     let outerAlias
     let subqueryFromRef
+    const ref = column.$refLinks[0].definition.kind === 'entity' ? column.ref.slice(1) : column.ref
+    const assoc = column.$refLinks.at(-1)
+    ensureValidForeignKeys(assoc.definition, column.ref, 'expand')
     if (column.isJoinRelevant) {
       // all n-1 steps of the expand column are already transformed into joins
       // find the last join relevant association. That is the n-1 assoc in the ref path.
@@ -782,24 +785,17 @@ function cqn4sql(originalQuery, model) {
       outerAlias = transformedQuery.SELECT.from.as
       subqueryFromRef = [
         ...(transformedQuery.SELECT.from.ref || /* subq in from */ [transformedQuery.SELECT.from.target.name]),
-        ...(column.$refLinks[0].definition.kind === 'entity' ? column.ref.slice(1) : column.ref),
+        ...ref,
       ]
     }
 
     // this is the alias of the column which holds the correlated subquery
-    const columnAlias =
-      column.as ||
-      (column.$refLinks[0].definition.kind === 'entity'
-        ? column.ref.slice(1).map(idOnly).join('_') // omit explicit table alias from name of column
-        : column.ref.map(idOnly).join('_'))
+    const columnAlias = column.as || ref.map(idOnly).join('_')
 
     // if there is a group by on the main query, all
     // columns of the expand must be in the groupBy
     if (transformedQuery.SELECT.groupBy) {
-      const baseRef =
-        column.$refLinks[0].definition.SELECT || column.$refLinks[0].definition.kind === 'entity'
-          ? column.ref.slice(1)
-          : column.ref
+      const baseRef = column.$refLinks[0].definition.SELECT || ref
 
       return _subqueryForGroupBy(column, baseRef, columnAlias)
     }
@@ -810,10 +806,12 @@ 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 = Object.fromEntries(
-      // preserve all props on subquery (`limit`, `order by`, …) but `expand` and `ref`
-      Object.entries(column).filter(([key]) => !(key in { ref: true, expand: true })),
-    )
+    const subqueryBase = {}
+    for (const [key, value] of Object.entries(column)) {
+      if (!(key in { ref: true, expand: true })) {
+      subqueryBase[key] = value;
+      }
+    }
     const subquery = {
       SELECT: {
         ...subqueryBase,
@@ -884,6 +882,7 @@ 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
           return nested
         }
@@ -1066,13 +1065,12 @@ function cqn4sql(originalQuery, model) {
    */
   function getColumnsForWildcard(exclude = [], replace = [], baseName = null) {
     const wildcardColumns = []
-    Object.keys(inferred.$combinedElements)
-      .filter(k => !exclude.includes(k))
-      .forEach(k => {
+    for (const k of Object.keys(inferred.$combinedElements)) {
+      if (!exclude.includes(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.type === 'cds.LargeBinary') return
+        if (isManagedAssocInFlatMode(element) || element.type === 'cds.LargeBinary') continue
         // 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] })
@@ -1088,7 +1086,8 @@ function cqn4sql(originalQuery, model) {
           )
           wildcardColumns.push(...flatColumns)
         }
-      })
+      }
+    }
     return wildcardColumns
 
     /**
@@ -1382,6 +1381,8 @@ function cqn4sql(originalQuery, model) {
               }”`,
             )
           }
+          const { definition: fkSource } = next
+          ensureValidForeignKeys(fkSource, ref)
           whereExistsSubSelects.push(getWhereExistsSubquery(current, next, step.where, true, step.args))
         }
 
@@ -1418,12 +1419,12 @@ function cqn4sql(originalQuery, model) {
         const keys = def.keys // use key aspect on entity
         const keyValComparisons = []
         const flatKeys = []
-        Object.values(keys)
-          // up__ID already part of inner where exists, no need to add it explicitly here
-          .filter(k => k !== backlinkFor($baseLink.definition)?.[0])
-          .forEach(v => {
+        for (const v of Object.values(keys)) {
+          if (v !== backlinkFor($baseLink.definition)?.[0]) {
+            // up__ID already part of inner where exists, no need to add it explicitly here
             flatKeys.push(...getFlatColumnsFor(v, { tableAlias: $baseLink.alias }))
-          })
+          }
+        }
         if (flatKeys.length > 1)
           throw new Error('Filters can only be applied to managed associations which result in a single foreign key')
         flatKeys.forEach(c => keyValComparisons.push([...[c, '=', token]]))
@@ -1583,10 +1584,7 @@ function cqn4sql(originalQuery, model) {
       if (!def.$refLinks) return def
       const leaf = def.$refLinks[def.$refLinks.length - 1]
       const first = def.$refLinks[0]
-      const tableAlias = getTableAlias(
-        def,
-        def.ref.length > 1 && first.definition.isAssociation ? first : $baseLink,
-      )
+      const tableAlias = getTableAlias(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, {
@@ -1670,23 +1668,23 @@ function cqn4sql(originalQuery, model) {
       const refReverse = [...from.ref].reverse()
       const $refLinksReverse = [...transformedFrom.$refLinks].reverse()
       for (let i = 0; i < refReverse.length; i += 1) {
-        const stepLink = $refLinksReverse[i]
+        const current = $refLinksReverse[i]
 
-        let nextStepLink = $refLinksReverse[i + 1]
+        let next = $refLinksReverse[i + 1]
         const nextStep = refReverse[i + 1] // only because we want the filter condition
 
-        if (stepLink.definition.target && nextStepLink) {
+        if (current.definition.target && next) {
           const { where, args } = nextStep
-          if (isStructured(nextStepLink.definition)) {
+          if (isStructured(next.definition)) {
             // find next association / entity in the ref because this is actually our real nextStep
             const nextStepIndex =
               2 +
               $refLinksReverse
                 .slice(i + 2)
                 .findIndex(rl => rl.definition.isAssociation || rl.definition.kind === 'entity')
-            nextStepLink = $refLinksReverse[nextStepIndex]
+            next = $refLinksReverse[nextStepIndex]
           }
-          let as = getLastStringSegment(nextStepLink.alias)
+          let as = getLastStringSegment(next.alias)
           /**
            * for an `expand` subquery, we do not need to add
            * the table alias of the `expand` host to the join tree
@@ -1696,8 +1694,10 @@ function cqn4sql(originalQuery, model) {
           if (!(inferred.SELECT?.expand === true)) {
             as = getNextAvailableTableAlias(as)
           }
-          nextStepLink.alias = as
-          whereExistsSubSelects.push(getWhereExistsSubquery(stepLink, nextStepLink, where, false, args))
+          next.alias = as
+          const { definition: fkSource } = current
+          ensureValidForeignKeys(fkSource, from.ref)
+          whereExistsSubSelects.push(getWhereExistsSubquery(current, next, where, false, args))
         }
       }
 
@@ -1742,6 +1742,14 @@ function cqn4sql(originalQuery, model) {
     }
   }
 
+  function ensureValidForeignKeys(fkSource, ref, kind = null) {
+    if (fkSource.keys && fkSource.keys.length === 0) {
+      const path = prettyPrintRef(ref, model)
+      if (kind === 'expand') throw new Error(`Can't expand “${fkSource.name}” as it has no foreign keys`)
+      throw new Error(`Path step “${fkSource.name}” of “${path}” has no foreign keys`)
+    }
+  }
+
   function whereExistsSubqueries(whereExistsSubSelects) {
     if (whereExistsSubSelects.length === 1) return whereExistsSubSelects[0]
     whereExistsSubSelects.reduce((prev, cur) => {
@@ -1818,7 +1826,6 @@ function cqn4sql(originalQuery, model) {
     const { on, keys } = assocRefLink.definition
     const target = getDefinition(assocRefLink.definition.target)
     let res
-    // technically we could have multiple backlinks
     if (keys) {
       const fkPkPairs = getParentKeyForeignKeyPairs(assocRefLink.definition, targetSideRefLink, true)
       const transformedOn = []
@@ -1852,6 +1859,11 @@ function cqn4sql(originalQuery, model) {
           result[i] = asXpr(xpr)
           continue
         }
+        if (lhs.args) {
+          const args = calculateOnCondition(lhs.args)
+          result[i] = { ...lhs, args }
+          continue
+        }
         const rhs = result[i + 2]
         if (rhs?.ref || lhs.ref) {
           // if we have refs on each side of the comparison, we might need to perform tuple expansion
@@ -1946,6 +1958,12 @@ function cqn4sql(originalQuery, model) {
               }
             })
           } else if (backlink.keys) {
+            // sanity check: error out if we can't produce a join
+            if (backlink.keys.length === 0) {
+              throw new Error(
+                `Path step “${assocRefLink.alias}” is a self comparison with “${getFullName(backlink)}” that has no foreign keys`,
+              )
+            }
             // managed backlink -> calculate fk-pk pairs
             const fkPkPairs = getParentKeyForeignKeyPairs(backlink, targetSideRefLink)
             fkPkPairs.forEach((pair, j) => {
@@ -2264,13 +2282,6 @@ function cqn4sql(originalQuery, model) {
   }
 }
 
-module.exports = Object.assign(cqn4sql, {
-  // for own tests only:
-  eqOps,
-  notEqOps,
-  notSupportedOps,
-})
-
 function calculateElementName(token) {
   const nonJoinRelevantAssoc = [...token.$refLinks].findIndex(l => l.definition.isAssociation && l.onlyForeignKeyAccess)
   let name
@@ -2358,3 +2369,10 @@ const refWithConditions = step => {
   return appendix ? step.id + appendix : step
 }
 const is_regexp = x => x?.constructor?.name === 'RegExp' // NOTE: x instanceof RegExp doesn't work in repl
+
+module.exports = Object.assign(cqn4sql, {
+  // for own tests only:
+  eqOps,
+  notEqOps,
+  notSupportedOps,
+})

package/lib/deep-queries.js

@@ -1,6 +1,7 @@
 const cds = require('@sap/cds')
 const { _target_name4 } = require('./SQLService')
-const InsertResult = require('../lib/InsertResults')
+
+const ROOT = Symbol('root')
 
 // REVISIT: remove old path with cds^8
 let _compareJson
@@ -45,20 +46,22 @@ async function onDeep(req, next) {
   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 })
-  }))
-  return (
-    beforeData.length ||
-    new InsertResult(query, [
-      {
-        changes: Array.isArray(req.data) ? req.data.length : 1,
-        ...(res[0]?.results[0]?.lastInsertRowid ? { lastInsertRowid: res[0].results[0].lastInsertRowid } : {}),
-      },
-    ])
-  )
+
+  // first delete, then update, then insert because of potential unique constraints:
+  // - deletes never trigger unique constraints, but can prevent them -> execute first
+  // - updates can trigger and prevent unique constraints -> execute second
+  // - inserts can only trigger unique constraints -> execute last
+  await Promise.all(Array.from(queries.deletes.values()).map(query => this.onSIMPLE({ query })))
+  await Promise.all(queries.updates.map(query => this.onUPDATE({ query })))
+
+  const rootQuery = queries.inserts.get(ROOT)
+  queries.inserts.delete(ROOT)
+  const [rootResult] = await Promise.all([
+    rootQuery && this.onINSERT({ query: rootQuery }),
+    ...Array.from(queries.inserts.values()).map(query => this.onINSERT({ query })),
+  ])
+
+  return rootResult ?? beforeData.length
 }
 
 const hasDeep = (q, target) => {
@@ -195,7 +198,7 @@ const getDeepQueries = (query, dbData, target) => {
     diff = [diff]
   }
 
-  return _getDeepQueries(diff, target, true)
+  return _getDeepQueries(diff, target)
 }
 
 const _hasManagedElements = target => {
@@ -205,16 +208,19 @@ const _hasManagedElements = target => {
 /**
  * @param {unknown[]} diff
  * @param {import('@sap/cds/apis/csn').Definition} target
- * @param {boolean} [root=false]
- * @returns {import('@sap/cds/apis/cqn').Query[]}
+ * @param {Map<String, Object>} deletes
+ * @param {Map<String, Object>} inserts
+ * @param {Object[]} updates
+ * @param {boolean} [root=true]
+ * @returns {Object|Boolean}
  */
-const _getDeepQueries = (diff, target, root = false) => {
-  const queries = []
-
+const _getDeepQueries = (diff, target, deletes = new Map(), inserts = new Map(), updates = [], root = true) => {
+  // flag to determine if queries were created
+  let dirty = false
   for (const diffEntry of diff) {
     if (diffEntry === undefined) continue
-    const subQueries = []
 
+    let childrenDirty = false
     for (const prop in diffEntry) {
       // handle deep operations
 
@@ -224,9 +230,12 @@ const _getDeepQueries = (diff, target, root = false) => {
         delete diffEntry[prop]
       } else if (target.compositions?.[prop]) {
         const arrayed = Array.isArray(propData) ? propData : [propData]
-        arrayed.forEach(subEntry => {
-          subQueries.push(..._getDeepQueries([subEntry], target.elements[prop]._target))
-        })
+        childrenDirty =
+          arrayed
+            .map(subEntry =>
+              _getDeepQueries([subEntry], target.elements[prop]._target, deletes, inserts, updates, false),
+            )
+            .some(a => a) || childrenDirty
         delete diffEntry[prop]
       } else if (diffEntry[prop] === undefined) {
         // restore current behavior, if property is undefined, not part of payload
@@ -242,12 +251,32 @@ const _getDeepQueries = (diff, target, root = false) => {
       delete diffEntry._old
     }
 
-    // first calculate subqueries and rm their properties, then build root query
     if (op === 'create') {
-      queries.push(INSERT.into(target).entries(diffEntry))
+      dirty = true
+      const id = root ? ROOT : target.name
+      const insert = inserts.get(id)
+      if (insert) {
+        insert.INSERT.entries.push(diffEntry)
+      } else {
+        const q = INSERT.into(target).entries(diffEntry)
+        inserts.set(id, q)
+      }
     } else if (op === 'delete') {
-      queries.push(DELETE.from(target).where(diffEntry))
-    } else if (op === 'update' || (op === undefined && (root || subQueries.length) && _hasManagedElements(target))) {
+      dirty = true
+      const keys = cds.utils
+        .Object_keys(target.keys)
+        .filter(key => !target.keys[key].virtual && !target.keys[key].isAssociation)
+
+      const keyVals = keys.map(k => ({ val: diffEntry[k] }))
+      const currDelete = deletes.get(target.name)
+      if (currDelete) currDelete.DELETE.where[2].list.push({ list: keyVals })
+      else {
+        const left = { list: keys.map(k => ({ ref: [k] })) }
+        const right = { list: [{ list: keyVals }] }
+        deletes.set(target.name, DELETE.from(target).where([left, 'in', right]))
+      }
+    } else if (op === 'update' || (op === undefined && (root || childrenDirty) && _hasManagedElements(target))) {
+      dirty = true
       // TODO do we need the where here?
       const keys = target.keys
       const cqn = UPDATE(target).with(diffEntry)
@@ -259,34 +288,16 @@ const _getDeepQueries = (diff, target, root = false) => {
         delete diffEntry[key]
       }
       cqn.with(diffEntry)
-      queries.push(cqn)
+      updates.push(cqn)
     }
-
-    for (const q of subQueries) queries.push(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
-  })
-    .filter(a => a)
+  return root ? { updates, inserts, deletes } : dirty
 }
 
 module.exports = {
   onDeep,
-  getDeepQueries,
-  getExpandForDeep,
   hasDeep,
+  getDeepQueries, // only for testing
+  getExpandForDeep, // only for testing
 }

package/lib/infer/index.js

@@ -170,7 +170,8 @@ function infer(originalQuery, model) {
     if (list) list.forEach(arg => attachRefLinksToArg(arg, $baseLink, expandOrExists))
     if (!ref) return
     init$refLinks(arg)
-    ref.forEach((step, i) => {
+    let i = 0
+    for (const step of ref) {
       const id = step.id || step
       if (i === 0) {
         // infix filter never have table alias
@@ -231,7 +232,8 @@ function infer(originalQuery, model) {
           step.where.forEach(walkTokenStream)
         } else throw new Error('A filter can only be provided when navigating along associations')
       }
-    })
+      i += 1
+    }
     const { definition, target } = arg.$refLinks[arg.$refLinks.length - 1]
     if (definition.value) {
       // nested calculated element
@@ -1046,15 +1048,17 @@ function infer(originalQuery, model) {
       if (Object.keys(queryElements).length === 0 && aliases.length === 1) {
         const { elements } = getDefinitionFromSources(sources, aliases[0])
         // only one query source and no overwritten columns
-        Object.keys(elements)
-          .filter(k => !exclude(k))
-          .forEach(k => {
+        for (const k of Object.keys(elements)) {
+          if (!exclude(k)) {
             const element = elements[k]
-            if (element.type !== 'cds.LargeBinary') queryElements[k] = element
+            if (element.type !== 'cds.LargeBinary') {
+              queryElements[k] = element
+            }
             if (element.value) {
               linkCalculatedElement(element)
             }
-          })
+          }
+        }
         return
       }
 

package/lib/infer/join-tree.js

@@ -1,5 +1,7 @@
 'use strict'
 
+const { prettyPrintRef } = require('../utils')
+
 // REVISIT: define following unknown types
 
 /**
@@ -177,13 +179,19 @@ class JoinTree {
     }
 
     // if no root node was found, the column is selected from a subquery
-    if(!node) return
+    if (!node) return
     while (i < col.ref.length) {
       const step = col.ref[i]
       const { where, args } = step
       const id = joinId(step, args, where)
       const next = node.children.get(id)
       const $refLink = col.$refLinks[i]
+      // sanity check: error out if we can't produce a join
+      if ($refLink.definition.keys && $refLink.definition.keys.length === 0) {
+        const path = prettyPrintRef(col.ref)
+        throw new Error(`Path step “${$refLink.alias}” of “${path}” has no foreign keys`)
+      }
+
       if (next) {
         // step already seen before
         node = next
@@ -208,7 +216,6 @@ class JoinTree {
           }
           child.$refLink.alias = this.addNextAvailableTableAlias($refLink.alias, outerQueries)
         }
-        //> REVISIT: remove fallback once UCSN is standard
         const elements =
           node.$refLink?.definition.isAssociation &&
           (node.$refLink.definition.elements || node.$refLink.definition.foreignKeys)

package/lib/utils.js

@@ -0,0 +1,27 @@
+'use strict'
+
+/**
+ * Formats a ref array into a string representation.
+ * If the first step is an entity, the separator is a colon, otherwise a dot.
+ *
+ * @param {Array} ref - The reference array to be formatted.
+ * @param {Object} model - The model object containing definitions.
+ * @returns {string} The formatted string representation of the reference.
+ */
+function prettyPrintRef(ref, model = null) {
+  return ref.reduce((acc, curr, j) => {
+    if (j > 0) {
+      if (j === 1 && model?.definitions[ref[0]]?.kind === 'entity') {
+        acc += ':'
+      } else {
+        acc += '.'
+      }
+    }
+    return acc + `${curr.id ? curr.id + '[…]' : curr}`
+  }, '')
+}
+
+// export the function to be used in other modules
+module.exports = {
+  prettyPrintRef,
+}

package/package.json

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