@cap-js/db-service 1.12.1 → 1.14.0

package/CHANGELOG.md

@@ -4,6 +4,33 @@
 - The format is based on [Keep a Changelog](http://keepachangelog.com/).
 - This project adheres to [Semantic Versioning](http://semver.org/).
 
+## [1.14.0](https://github.com/cap-js/cds-dbs/compare/db-service-v1.13.0...db-service-v1.14.0) (2024-10-15)
+
+
+### Added
+
+* assoc-like calc elements after exists predicate ([#831](https://github.com/cap-js/cds-dbs/issues/831)) ([05f7d75](https://github.com/cap-js/cds-dbs/commit/05f7d75837495d58cc4f72ad628077bdebb0acf6))
+
+
+### Fixed
+
+* Improved behavioral consistency between the database services ([#837](https://github.com/cap-js/cds-dbs/issues/837)) ([b6f7187](https://github.com/cap-js/cds-dbs/commit/b6f718701e48dfb1c4c3d98ee016ec45930f8e7b))
+* Treat assoc-like calculated elements as unmanaged assocs ([#830](https://github.com/cap-js/cds-dbs/issues/830)) ([cbe0df7](https://github.com/cap-js/cds-dbs/commit/cbe0df7a66fec0d421947767adc8621ed8bf236c))
+
+## [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)
 
 

package/lib/SQLService.js

@@ -466,6 +466,10 @@ const sqls = new (class extends SQLService {
   get factory() {
     return null
   }
+
+  get model() {
+    return cds.model
+  }
 })()
 cds.extend(cds.ql.Query).with(
   class {

package/lib/cql-functions.js

@@ -1,3 +1,5 @@
+const cds = require("@sap/cds")
+
 const StandardFunctions = {
   // OData: https://docs.oasis-open.org/odata/odata/v4.01/odata-v4.01-part2-url-conventions.html#sec_CanonicalFunctions
 
@@ -59,7 +61,7 @@ const StandardFunctions = {
    * @param {string} x
    * @returns {string}
    */
-  countdistinct: x => `count(distinct ${x || '*'})`,
+  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

package/lib/cqn2sql.js

@@ -18,8 +18,8 @@ const DEBUG = (() => {
   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
+  // (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
   //}
 })()
 
@@ -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) {
@@ -82,6 +88,7 @@ class CQN2SQLRenderer {
     this.values = [] // prepare values, filled in by subroutines
     this[kind]((this.cqn = q)) // actual sql rendering happens here
     if (vars?.length && !this.values?.length) this.values = vars
+    if (vars && Object.keys(vars).length && !this.values?.length) this.values = vars
     const sanitize_values = process.env.NODE_ENV === 'production' && cds.env.log.sanitize_values !== false
     DEBUG?.(
       this.sql,
@@ -110,8 +117,13 @@ class CQN2SQLRenderer {
    * @param {import('./infer/cqn').CREATE} q
    */
   CREATE(q) {
-    const { target } = q,
-      { query } = target
+    let { target } = q
+    let query = target?.query || q.CREATE.as
+    if (!target || target._unresolved) {
+      const entity = q.CREATE.entity
+      target = typeof entity === 'string' ? { name: entity } : q.CREATE.entity
+    }
+
     const name = this.name(target.name)
     // Don't allow place holders inside views
     delete this.values
@@ -197,8 +209,9 @@ class CQN2SQLRenderer {
    */
   DROP(q) {
     const { target } = q
-    const isView = target.query || target.projection
-    return (this.sql = `DROP ${isView ? 'VIEW' : 'TABLE'} IF EXISTS ${this.quote(this.name(target.name))}`)
+    const isView = target?.query || target?.projection || q.DROP.view
+    const name = target?.name || q.DROP.table?.ref?.[0] || q.DROP.view?.ref?.[0]
+    return (this.sql = `DROP ${isView ? 'VIEW' : 'TABLE'} IF EXISTS ${this.quote(this.name(name))}`)
   }
 
   // SELECT Statements ------------------------------------------------
@@ -217,11 +230,11 @@ class CQN2SQLRenderer {
 
     // REVISIT: When selecting from an entity that is not in the model the from.where are not normalized (as cqn4sql is skipped)
     if (!where && from?.ref?.length === 1 && from.ref[0]?.where) where = from.ref[0]?.where
-    let columns = this.SELECT_columns(q)
+    const columns = this.SELECT_columns(q)
     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 +324,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 +345,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, isCalculatedOnRead, isCalculatedElement } = 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)
 
@@ -317,10 +317,6 @@ function cqn4sql(originalQuery, model) {
     }
   }
 
-  function isCalculatedOnRead(def) {
-    return def?.value && !def.value.stored
-  }
-
   /**
    * Walks over a list of columns (ref's, xpr, subqueries, val), applies flattening on structured types and expands wildcards.
    *
@@ -763,6 +759,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 +781,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 +802,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,
@@ -1067,13 +1061,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] })
@@ -1089,7 +1082,8 @@ function cqn4sql(originalQuery, model) {
           )
           wildcardColumns.push(...flatColumns)
         }
-      })
+      }
+    }
     return wildcardColumns
 
     /**
@@ -1367,22 +1361,21 @@ function cqn4sql(originalQuery, 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) {
+            let type = next.definition.type
+            if (isCalculatedElement(next.definition)) {
+              // try to infer the type at the leaf for better error message
+              const { $refLinks } = next.definition.value
+              type = $refLinks?.at(-1).definition.type || 'expression'
+            }
             throw new Error(
               `Expecting path “${tokenStream[i + 1].ref
                 .map(idOnly)
-                .join('.')}” following “EXISTS” predicate to end with association/composition, found “${
-                next.definition.type
-              }”`,
+                .join('.')}” following “EXISTS” predicate to end with association/composition, found “${type}”`,
             )
           }
+          const { definition: fkSource } = next
+          ensureValidForeignKeys(fkSource, ref)
           whereExistsSubSelects.push(getWhereExistsSubquery(current, next, step.where, true, step.args))
         }
 
@@ -1419,12 +1412,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]]))
@@ -1584,10 +1577,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, {
@@ -1671,23 +1661,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
@@ -1697,8 +1687,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))
         }
       }
 
@@ -1743,6 +1735,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) => {
@@ -1819,7 +1819,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 = []
@@ -1853,7 +1852,7 @@ function cqn4sql(originalQuery, model) {
           result[i] = asXpr(xpr)
           continue
         }
-        if(lhs.args) {
+        if (lhs.args) {
           const args = calculateOnCondition(lhs.args)
           result[i] = { ...lhs, args }
           continue
@@ -1952,6 +1951,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) => {
@@ -2270,13 +2275,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
@@ -2364,3 +2362,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

@@ -61,7 +61,7 @@ async function onDeep(req, next) {
     ...Array.from(queries.inserts.values()).map(query => this.onINSERT({ query })),
   ])
 
-  return beforeData.length ?? rootResult
+  return rootResult ?? beforeData.length
 }
 
 const hasDeep = (q, target) => {

package/lib/infer/index.js

@@ -4,6 +4,7 @@ const cds = require('@sap/cds')
 
 const JoinTree = require('./join-tree')
 const { pseudos } = require('./pseudos')
+const { isCalculatedOnRead } = require('../utils')
 const cdsTypes = cds.linked({
   definitions: {
     Timestamp: { type: 'cds.Timestamp' },
@@ -170,7 +171,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 +233,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
@@ -744,7 +747,7 @@ function infer(originalQuery, model) {
           joinTree.mergeColumn(colWithBase, originalQuery.outerQueries)
         }
       }
-      if (leafArt.value && !leafArt.value.stored) {
+      if (isCalculatedOnRead(leafArt)) {
         linkCalculatedElement(column, $baseLink, baseColumn)
       }
 
@@ -1046,15 +1049,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.value) {
+            if (element.type !== 'cds.LargeBinary') {
+              queryElements[k] = element
+            }
+            if (isCalculatedOnRead(element)) {
               linkCalculatedElement(element)
             }
-          })
+          }
+        }
         return
       }
 
@@ -1067,7 +1072,7 @@ function infer(originalQuery, 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) {
+        if (isCalculatedOnRead(element)) {
           linkCalculatedElement(element)
         }
       })

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,46 @@
+'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}`
+  }, '')
+}
+
+/**
+ * Determines if a definition is calculated on read.
+ * - Stored calculated elements are not unfolded
+ * - Association like calculated elements have been re-written by the compiler
+ *   they essentially behave like unmanaged associations as their calculations
+ *   have been incorporated into an on-condition which is handled elsewhere
+ *
+ * @param {Object} def - The definition to check.
+ * @returns {boolean} - Returns true if the definition is calculated on read, otherwise false.
+ */
+function isCalculatedOnRead(def) {
+  return isCalculatedElement(def) && !def.value.stored && !def.on
+}
+function isCalculatedElement(def) {
+  return def?.value
+}
+
+// export the function to be used in other modules
+module.exports = {
+  prettyPrintRef,
+  isCalculatedOnRead,
+  isCalculatedElement
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cap-js/db-service",
-  "version": "1.12.1",
+  "version": "1.14.0",
   "description": "CDS base database service",
   "homepage": "https://github.com/cap-js/cds-dbs/tree/main/db-service#cds-base-database-service",
   "repository": {
@@ -22,7 +22,7 @@
     "CHANGELOG.md"
   ],
   "scripts": {
-    "test": "jest --silent"
+    "test": "cds-test"
   },
   "dependencies": {
     "generic-pool": "^3.9.0"