@cap-js/db-service 2.1.2 → 2.3.0

package/CHANGELOG.md

@@ -4,6 +4,29 @@
 - The format is based on [Keep a Changelog](http://keepachangelog.com/).
 - This project adheres to [Semantic Versioning](http://semver.org/).
 
+## [2.3.0](https://github.com/cap-js/cds-dbs/compare/db-service-v2.2.0...db-service-v2.3.0) (2025-07-28)
+
+
+### Added
+
+* **`exists`:** support additional query modifiers ([#1261](https://github.com/cap-js/cds-dbs/issues/1261)) ([1394b46](https://github.com/cap-js/cds-dbs/commit/1394b46b10f628748dd1f945095ab4ce7f3963f6))
+* **hierarchy:** LimitedRank ([#1268](https://github.com/cap-js/cds-dbs/issues/1268)) ([52e16db](https://github.com/cap-js/cds-dbs/commit/52e16db2c83d06e318ea05947a3c3c3153bd3ab2))
+
+
+### Fixed
+
+* `count` subquery for queries with only `expand` columns ([#1264](https://github.com/cap-js/cds-dbs/issues/1264)) ([097a332](https://github.com/cap-js/cds-dbs/commit/097a332f78156526823b2088bdc35278aea09854))
+* **cqn4sql:** multiple path expressions in where clause ([#1272](https://github.com/cap-js/cds-dbs/issues/1272)) ([9b35366](https://github.com/cap-js/cds-dbs/commit/9b353660f4c2568176f57baa642ab2b052cfcff9))
+* **hierarchy:** only modify where if existent ([#1265](https://github.com/cap-js/cds-dbs/issues/1265)) ([eaca855](https://github.com/cap-js/cds-dbs/commit/eaca855ec06087e22bf780fac5e4010ef1b5ff4f))
+* TypeError for empty `list` ([#1269](https://github.com/cap-js/cds-dbs/issues/1269)) ([f262718](https://github.com/cap-js/cds-dbs/commit/f26271813e161c9f7c05fbc82b10c4d5f14916a7))
+
+## [2.2.0](https://github.com/cap-js/cds-dbs/compare/db-service-v2.1.2...db-service-v2.2.0) (2025-06-30)
+
+
+### Added
+
+* **recurse:** object-page hierarchies ([#1247](https://github.com/cap-js/cds-dbs/issues/1247)) ([6fe81f2](https://github.com/cap-js/cds-dbs/commit/6fe81f27bc1aee0b8edebe3d9251928ebea8474a))
+
 ## [2.1.2](https://github.com/cap-js/cds-dbs/compare/db-service-v2.1.1...db-service-v2.1.2) (2025-06-12)
 
 

package/lib/SQLService.js

@@ -337,9 +337,11 @@ class SQLService extends DatabaseService {
 
     // Keep original query columns when potentially used insde conditions
     const { having, groupBy } = query.SELECT
-    const columns = (having?.length || groupBy?.length)
-      ? query.SELECT.columns.filter(c => !c.expand)
-      : [{ val: 1 }]
+    let columns = []
+    if((having?.length || groupBy?.length)) {
+      columns = query.SELECT.columns.filter(c => !c.expand)
+    }
+    if (columns.length === 0) columns.push({ val: 1 })
     const cq = SELECT.one([{ func: 'count' }]).from(
       cds.ql.clone(query, {
         columns,

package/lib/cqn2sql.js

@@ -282,6 +282,25 @@ class CQN2SQLRenderer {
   SELECT_recurse(q) {
     let { from, columns, where, orderBy, recurse, _internal } = q.SELECT
 
+    const _target = q._target
+
+    if (_target && where) {
+      const keys = []
+      for (const _key in _target.keys) {
+        const k = _target.keys[_key]
+        if (!k.virtual && !k.isAssociation && !k.value) {
+          keys.push({ ref: [_key] })
+        }
+      }
+
+      // `where` needs to be wrapped to also support `where == ['exists', { SELECT }]` which is not allowed in `START WHERE`
+      const clone = q.clone()
+      clone.columns(keys)
+      clone.SELECT.recurse = undefined
+      clone.SELECT.expand = undefined // omits JSON
+      where = [{ list: keys }, 'in', clone]
+    }
+
     const requiredComputedColumns = { PARENT_ID: true, NODE_ID: true }
     if (!_internal) requiredComputedColumns.RANK = true
     const addComputedColumn = (name) => {
@@ -305,6 +324,7 @@ class CQN2SQLRenderer {
       DistanceFromRoot: { xpr: [{ ref: ['HIERARCHY_LEVEL'] }, '-', { val: 1, param: false }], as: 'DistanceFromRoot' },
       DrillState: false,
       LimitedDescendantCount: { xpr: [{ ref: ['HIERARCHY_TREE_SIZE'] }, '-', { val: 1, param: false }], as: 'LimitedDescendantCount' },
+      LimitedRank: { xpr: [{ func: 'row_number', args: [] }, 'OVER', { xpr: [] }, '-', { val: 1, param: false }], as: 'LimitedRank' }
     }
 
     const columnsFiltered = columns
@@ -1157,7 +1177,7 @@ class CQN2SQLRenderer {
       .map((x, i) => {
         if (x in { LIKE: 1, like: 1 } && is_regexp(xpr[i + 1]?.val)) return this.operator('regexp')
         if (typeof x === 'string') return this.operator(x, i, xpr)
-        if (x.xpr) return `(${this.xpr(x)})`
+        if (x.xpr && !x.func) return `(${this.xpr(x)})`
         else return this.expr(x)
       })
       .join(' ')

package/lib/cqn4sql.js

@@ -5,7 +5,14 @@ cds.infer.target ??= q => q._target || q.target // instanceof cds.entity ? q._ta
 
 const infer = require('./infer')
 const { computeColumnsToBeSearched } = require('./search')
-const { prettyPrintRef, isCalculatedOnRead, isCalculatedElement, getImplicitAlias, defineProperty, getModelUtils } = require('./utils')
+const {
+  prettyPrintRef,
+  isCalculatedOnRead,
+  isCalculatedElement,
+  getImplicitAlias,
+  defineProperty,
+  getModelUtils,
+} = require('./utils')
 
 /**
  * For operators of <eqOps>, this is replaced by comparing all leaf elements with null, combined with and.
@@ -63,19 +70,8 @@ function cqn4sql(originalQuery, model) {
   }
   // query modifiers can also be defined in from ref leaf infix filter
   // > SELECT from bookshop.Books[order by price] {ID}
-  if (inferred.SELECT?.from.ref) {
-    for (const [key, val] of Object.entries(inferred.SELECT.from.ref.at(-1))) {
-      if (key in { orderBy: 1, groupBy: 1 }) {
-        if (inferred.SELECT[key]) inferred.SELECT[key].push(...val)
-        else inferred.SELECT[key] = val
-      } else if (key === 'limit') {
-        // limit defined on the query has precedence
-        if (!inferred.SELECT.limit) inferred.SELECT.limit = val
-      } else if (key === 'having') {
-        if (!inferred.SELECT.having) inferred.SELECT.having = val
-        else inferred.SELECT.having.push('and', ...val)
-      }
-    }
+  if (inferred.SELECT?.from.ref?.at(-1).id) {
+    assignQueryModifiers(inferred.SELECT, inferred.SELECT.from.ref.at(-1))
   }
   inferred = infer(inferred, model)
   const { getLocalizedName, isLocalized, getDefinition } = getModelUtils(model, originalQuery) // TODO: pass model to getModelUtils
@@ -95,6 +91,7 @@ function cqn4sql(originalQuery, model) {
     const from = queryProp.from
 
     const transformedProp = { __proto__: queryProp } // IMPORTANT: don't lose anything you might not know of
+    const queryNeedsJoins = inferred.joinTree && !inferred.joinTree.isInitial
 
     // Transform the existing where, prepend table aliases, and so on...
     if (where) {
@@ -104,7 +101,47 @@ function cqn4sql(originalQuery, model) {
     // Transform the from clause: association path steps turn into `WHERE EXISTS` subqueries.
     // The already transformed `where` clause is then glued together with the resulting subqueries.
     const { transformedWhere, transformedFrom } = getTransformedFrom(from || entity, transformedProp.where)
-    const queryNeedsJoins = inferred.joinTree && !inferred.joinTree.isInitial
+
+    // build a subquery for DELETE / UPDATE queries with path expressions and match the primary keys
+    if (queryNeedsJoins && (inferred.UPDATE || inferred.DELETE)) {
+      const prop = inferred.UPDATE ? 'UPDATE' : 'DELETE'
+      const subquery = {
+        SELECT: {
+          from: { ...(from || entity) },
+          columns: [], // primary keys of the query target will be added later
+          where: [...where],
+        },
+      }
+      // The alias of the original query is now the alias for the subquery
+      // so that potential references in the where clause to the alias match.
+      // Hence, replace the alias of the original query with the next
+      // available alias, so that each alias is unique.
+      const uniqueSubqueryAlias = getNextAvailableTableAlias(transformedFrom.as)
+      transformedFrom.as = uniqueSubqueryAlias
+
+      // 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 primaryKey = { list: [] }
+      for (const k of Object.keys(queryTarget.elements)) {
+        const e = queryTarget.elements[k]
+        if (e.key === true && !e.virtual && e.isAssociation !== true) {
+          subquery.SELECT.columns.push({ ref: [e.name] })
+          primaryKey.list.push({ ref: [transformedFrom.as, e.name] })
+        }
+      }
+
+      const transformedSubquery = cqn4sql(subquery, model)
+
+      // replace where condition of original query with the transformed subquery
+      // correlate UPDATE / DELETE query with subquery by primary key matches
+      transformedQuery[prop].where = [primaryKey, 'in', transformedSubquery]
+
+      if (prop === 'UPDATE') transformedQuery.UPDATE.entity = transformedFrom
+      else transformedQuery.DELETE.from = transformedFrom
+
+      return transformedQuery
+    }
 
     if (inferred.SELECT) {
       transformedQuery = transformSelectQuery(queryProp, transformedFrom, transformedWhere, transformedQuery)
@@ -130,45 +167,7 @@ function cqn4sql(originalQuery, model) {
     }
 
     if (queryNeedsJoins) {
-      if (inferred.UPDATE || inferred.DELETE) {
-        const prop = inferred.UPDATE ? 'UPDATE' : 'DELETE'
-        const subquery = {
-          SELECT: {
-            from: { ...transformedFrom },
-            columns: [], // primary keys of the query target will be added later
-            where: [...transformedProp.where],
-          },
-        }
-        // The alias of the original query is now the alias for the subquery
-        // so that potential references in the where clause to the alias match.
-        // Hence, replace the alias of the original query with the next
-        // available alias, so that each alias is unique.
-        const uniqueSubqueryAlias = getNextAvailableTableAlias(transformedFrom.as)
-        transformedFrom.as = uniqueSubqueryAlias
-
-        // 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 primaryKey = { list: [] }
-        for (const k of Object.keys(queryTarget.elements)) {
-          const e = queryTarget.elements[k]
-          if (e.key === true && !e.virtual && e.isAssociation !== true) {
-            subquery.SELECT.columns.push({ ref: [e.name] })
-            primaryKey.list.push({ ref: [transformedFrom.as, e.name] })
-          }
-        }
-
-        const transformedSubquery = cqn4sql(subquery, model)
-
-        // replace where condition of original query with the transformed subquery
-        // correlate UPDATE / DELETE query with subquery by primary key matches
-        transformedQuery[prop].where = [primaryKey, 'in', transformedSubquery]
-
-        if (prop === 'UPDATE') transformedQuery.UPDATE.entity = transformedFrom
-        else transformedQuery.DELETE.from = transformedFrom
-      } else {
-        transformedQuery[kind].from = translateAssocsToJoins(transformedQuery[kind].from)
-      }
+      transformedQuery[kind].from = translateAssocsToJoins(transformedQuery[kind].from)
     }
   }
 
@@ -1420,7 +1419,8 @@ function cqn4sql(originalQuery, model) {
           }
           const { definition: fkSource } = next
           ensureValidForeignKeys(fkSource, ref)
-          whereExistsSubSelects.push(getWhereExistsSubquery(current, next, step.where, true, step.args))
+          const { where, ...args } = step
+          whereExistsSubSelects.push(getWhereExistsSubquery(current, next, where, true, args))
         }
 
         const whereExists = { SELECT: whereExistsSubqueries(whereExistsSubSelects) }
@@ -1668,8 +1668,7 @@ function cqn4sql(originalQuery, model) {
   function getTransformedFrom(from, existingWhere = []) {
     const transformedWhere = []
     let transformedFrom = copy(from) // REVISIT: too expensive!
-    if (from.$refLinks)
-      defineProperty(transformedFrom, '$refLinks', [...from.$refLinks])
+    if (from.$refLinks) defineProperty(transformedFrom, '$refLinks', [...from.$refLinks])
     if (from.args) {
       transformedFrom.args = []
       from.args.forEach(arg => {
@@ -1716,7 +1715,7 @@ function cqn4sql(originalQuery, model) {
         const nextStep = refReverse[i + 1] // only because we want the filter condition
 
         if (current.definition.target && next) {
-          const { where, args } = nextStep
+          const { where, ...args } = nextStep
           if (isStructured(next.definition)) {
             // find next association / entity in the ref because this is actually our real nextStep
             const nextStepIndex =
@@ -1777,12 +1776,10 @@ function cqn4sql(originalQuery, model) {
       // adjust ref & $refLinks after associations have turned into where exists subqueries
       transformedFrom.$refLinks.splice(0, transformedFrom.$refLinks.length - 1)
 
-      let args = from.ref.at(-1).args
       const subquerySource =
         getDefinition(transformedFrom.$refLinks[0].definition.target) || transformedFrom.$refLinks[0].target
-      if (subquerySource.params && !args) args = {}
       const id = getLocalizedName(subquerySource)
-      transformedFrom.ref = [args ? { id, args } : id]
+      transformedFrom.ref = [subquerySource.params ? { id, args: from.ref.at(-1).args || {} } : id]
 
       return { transformedWhere, transformedFrom }
     }
@@ -1814,10 +1811,6 @@ function cqn4sql(originalQuery, model) {
     return inferred.joinTree.addNextAvailableTableAlias(id, inferred.outerQueries)
   }
 
-  function asXpr(thing) {
-    return { xpr: thing }
-  }
-
   /**
    * @param {CSN.Element} elt
    * @returns {boolean}
@@ -2133,9 +2126,11 @@ function cqn4sql(originalQuery, model) {
    * @param {object[]} customWhere infix filter which must be part of the where exists subquery on condition
    * @param {boolean} inWhere whether or not the path is part of the queries where clause
    *                    -> if it is, target and source side are flipped in the where exists subquery
+   * @param {object} queryModifier optional query modifiers: group by, order by, limit, offset
+   * 
    * @returns {CQN.SELECT}
    */
-  function getWhereExistsSubquery(current, next, customWhere = null, inWhere = false, customArgs = null) {
+  function getWhereExistsSubquery(current, next, customWhere = null, inWhere = false, queryModifier = null) {
     const { definition } = current
     const { definition: nextDefinition } = next
     const on = []
@@ -2156,10 +2151,9 @@ function cqn4sql(originalQuery, model) {
 
     const subquerySource = getDefinition(nextDefinition.target) || nextDefinition
     const id = getLocalizedName(subquerySource)
-    if (subquerySource.params && !customArgs) customArgs = {}
     const SELECT = {
       from: {
-        ref: [customArgs ? { id, args: customArgs } : id],
+        ref: [subquerySource.params ? { id, args: queryModifier.args || {} } : id],
         as: next.alias,
       },
       columns: [
@@ -2170,25 +2164,27 @@ function cqn4sql(originalQuery, model) {
       ],
       where: on,
     }
-    if (next.pathExpressionInsideFilter) {
-      SELECT.where = customWhere
-      const transformedExists = transformSubquery({ SELECT })
-      // infix filter conditions are wrapped in `xpr` when added to the on-condition
-      if (transformedExists.SELECT.where) {
-        on.push(
-          ...[
-            'and',
-            ...(hasLogicalOr(transformedExists.SELECT.where)
-              ? [asXpr(transformedExists.SELECT.where)]
-              : transformedExists.SELECT.where),
-          ],
-        )
+    // this requires sub-sequent transformation of the subquery
+    if (next.pathExpressionInsideFilter || (queryModifier && ['orderBy', 'groupBy', 'having', 'limit', 'offset'].some(key => key in queryModifier))) {
+      SELECT.where = next.pathExpressionInsideFilter ? customWhere : [];
+      if (queryModifier) assignQueryModifiers(SELECT, queryModifier);
+
+      const transformedExists = transformSubquery({ SELECT });
+      if (transformedExists.SELECT.where?.length) {
+      const wrappedWhere = hasLogicalOr(transformedExists.SELECT.where)
+        ? [asXpr(transformedExists.SELECT.where)]
+        : transformedExists.SELECT.where;
+
+      on.push('and', ...wrappedWhere);
       }
-      transformedExists.SELECT.where = on
-      return transformedExists.SELECT
-    } else if (customWhere) {
-      const filter = getTransformedTokenStream(customWhere, next)
-      on.push(...['and', ...(hasLogicalOr(filter) ? [asXpr(filter)] : filter)])
+      transformedExists.SELECT.where = on;
+      return transformedExists.SELECT;
+    }
+
+    if (customWhere) {
+      const filter = getTransformedTokenStream(customWhere, next);
+      const wrappedFilter = hasLogicalOr(filter) ? [asXpr(filter)] : filter;
+      on.push('and', ...wrappedFilter);
     }
     return SELECT
   }
@@ -2353,6 +2349,26 @@ function getParentEntity(element) {
   else return getParentEntity(element.parent)
 }
 
+
+function asXpr(thing) {
+  return { xpr: thing }
+}
+
+function assignQueryModifiers(SELECT, modifiers) {
+  for (const [key, val] of Object.entries(modifiers)) {
+    if (key in { orderBy: 1, groupBy: 1 }) {
+      if (SELECT[key]) SELECT[key].push(...val)
+      else SELECT[key] = val
+    } else if (key === 'limit') {
+      // limit defined on the query has precedence
+      if (!SELECT.limit) SELECT.limit = val
+    } else if (key === 'having') {
+      if (!SELECT.having) SELECT.having = val
+      else SELECT.having.push('and', ...val)
+    }
+  }
+}
+
 /**
  * Assigns the given `element` as non-enumerable property 'element' onto `col`.
  *

package/lib/fill-in-keys.js

@@ -1,5 +1,5 @@
 const cds = require('@sap/cds')
-const { hasDeep } = require('../lib/deep-queries')
+const { hasDeep } = require('./deep-queries')
 
 // REVISIT: very deep & fragile dependencies to internal modules -> copy these into here
 const propagateForeignKeys = require('@sap/cds/libx/_runtime/common/utils/propagateForeignKeys')

package/package.json

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